| Language: | Australian English, British English |
| Language codes: | en-AU, en-GB, en |
This document provides basic instruction in how to use the GPGME
Python bindings to programmatically leverage the GPGME library.
** Python 2 versus Python 3
:PROPERTIES:
:CUSTOM_ID: py2-vs-py3
:END:
Though the GPGME Python bindings themselves provide support for both
Python 2 and 3, the focus is unequivocally on Python 3 and
specifically from Python 3.4 and above. As a consequence all the
examples and instructions in this guide use Python 3 code.
Much of it will work with Python 2, but much of it also deals with
Python 3 byte literals, particularly when reading and writing data.
Developers concentrating on Python 2.7, and possibly even 2.6, will
need to make the appropriate modifications to support the older string
and unicode types as opposed to bytes.
There are multiple reasons for concentrating on Python 3; some of
which relate to the immediate integration of these bindings, some of
which relate to longer term plans for both GPGME and the python
bindings and some of which relate to the impending EOL period for
Python 2.7. Essentially, though, there is little value in tying the
bindings to a version of the language which is a dead end and the
advantages offered by Python 3 over Python 2 make handling the data
types with which GPGME deals considerably easier.
** Examples
:PROPERTIES:
:CUSTOM_ID: howto-python3-examples
:END:
All of the examples found in this document can be found as Python 3
scripts in the =lang/python/examples/howto= directory.
** Unofficial Drafts
:PROPERTIES:
:CUSTOM_ID: unofficial-drafts
:END:
In addition to shipping with each release of GPGME, there is a section
on locations to read or download [[#draft-editions][draft editions]] of this document from
at the end of it. These are unofficial versions produced in between
major releases.
** What's New
:PROPERTIES:
:CUSTOM_ID: new-stuff
:END:
Full details of what is new are now available in the [[file:what-is-new.org][What's New]] file
and archives of the preceding /What's New/ sections are available in
the [[file:what-was-new][What Was New]] file.
*** New in GPGME 1·13·0
:PROPERTIES:
:CUSTOM_ID: new-stuff-1-13-0
:END:
See the [[file:what-is-new#new-stuff-1-13-0][What's New]] document for what is new in version 1.13.0.
*** New in GPGME 1·12·0
:PROPERTIES:
:CUSTOM_ID: new-stuff-1-12-0
:END:
See the [[file:what-was-new#new-stuff-1-12-0][What Was New]] document for what was new in version 1.12.0.
* GPGME Concepts
:PROPERTIES:
:CUSTOM_ID: gpgme-concepts
:END:
** A C API
:PROPERTIES:
:CUSTOM_ID: gpgme-c-api
:END:
Unlike many modern APIs with which programmers will be more familiar
with these days, the GPGME API is a C API. The API is intended for
use by C coders who would be able to access its features by including
the =gpgme.h= header file with their own C source code and then access
its functions just as they would any other C headers.
This is a very effective method of gaining complete access to the API
and in the most efficient manner possible. It does, however, have the
drawback that it cannot be directly used by other languages without
some means of providing an interface to those languages. This is
where the need for bindings in various languages stems.
** Python bindings
:PROPERTIES:
:CUSTOM_ID: gpgme-python-bindings
:END:
The Python bindings for GPGME provide a higher level means of
accessing the complete feature set of GPGME itself. It also provides
a more pythonic means of calling these API functions.
The bindings are generated dynamically with SWIG and the copy of
=gpgme.h= generated when GPGME is compiled.
This means that a version of the Python bindings is fundamentally tied
to the exact same version of GPGME used to generate that copy of
=gpgme.h=.
** Difference between the Python bindings and other GnuPG Python packages
:PROPERTIES:
:CUSTOM_ID: gpgme-python-bindings-diffs
:END:
There have been numerous attempts to add GnuPG support to Python over
the years. Some of the most well known are listed here, along with
what differentiates them.
*** The python-gnupg package maintained by Vinay Sajip
:PROPERTIES:
:CUSTOM_ID: diffs-python-gnupg
:END:
This is arguably the most popular means of integrating GPG with
Python. The package utilises the =subprocess= module to implement
wrappers for the =gpg= and =gpg2= executables normally invoked on the
command line (=gpg.exe= and =gpg2.exe= on Windows).
The popularity of this package stemmed from its ease of use and
capability in providing the most commonly required features.
Unfortunately it has been beset by a number of security issues in the
past; most of which stemmed from using unsafe methods of accessing the
command line via the =subprocess= calls. While some effort has been
made over the last two to three years (as of 2018) to mitigate this,
particularly by no longer providing shell access through those
subprocess calls, the wrapper is still somewhat limited in the scope
of its GnuPG features coverage.
The python-gnupg package is available under the MIT license.
*** The gnupg package created and maintained by Isis Lovecruft
:PROPERTIES:
:CUSTOM_ID: diffs-isis-gnupg
:END:
In 2015 Isis Lovecruft from the Tor Project forked and then
re-implemented the python-gnupg package as just gnupg. This new
package also relied on subprocess to call the =gpg= or =gpg2=
binaries, but did so somewhat more securely.
The naming and version numbering selected for this package, however,
resulted in conflicts with the original python-gnupg and since its
functions were called in a different manner to python-gnupg, the
release of this package also resulted in a great deal of consternation
when people installed what they thought was an upgrade that
subsequently broke the code relying on it.
The gnupg package is available under the GNU General Public License
version 3.0 (or any later version).
*** The PyME package maintained by Martin Albrecht
:PROPERTIES:
:CUSTOM_ID: diffs-pyme
:END:
This package is the origin of these bindings, though they are somewhat
different now. For details of when and how the PyME package was
folded back into GPGME itself see the [[file:short-history.org][Short History]] document.[fn:1]
The PyME package was first released in 2002 and was also the first
attempt to implement a low level binding to GPGME. In doing so it
provided access to considerably more functionality than either the
=python-gnupg= or =gnupg= packages.
The PyME package is only available for Python 2.6 and 2.7.
Porting the PyME package to Python 3.4 in 2015 is what resulted in it
being folded into the GPGME project and the current bindings are the
end result of that effort.
The PyME package is available under the same dual licensing as GPGME
itself: the GNU General Public License version 2.0 (or any later
version) and the GNU Lesser General Public License version 2.1 (or any
later version).
* GPGME Python bindings installation
:PROPERTIES:
:CUSTOM_ID: gpgme-python-install
:END:
** No PyPI
:PROPERTIES:
:CUSTOM_ID: do-not-use-pypi
:END:
Most third-party Python packages and modules are available and
distributed through the Python Package Installer, known as PyPI.
Due to the nature of what these bindings are and how they work, it is
infeasible to install the GPGME Python bindings in the same way.
This is because the bindings use SWIG to dynamically generate C
bindings against =gpgme.h= and =gpgme.h= is generated from
=gpgme.h.in= at compile time when GPGME is built from source. Thus to
include a package in PyPI which actually built correctly would require
either statically built libraries for every architecture bundled with
it or a full implementation of C for each architecture.
See the additional notes regarding [[#snafu-cffi][CFFI and SWIG]] at the end of this
section for further details.
** Requirements
:PROPERTIES:
:CUSTOM_ID: gpgme-python-requirements
:END:
The GPGME Python bindings only have three requirements:
1. A suitable version of Python 2 or Python 3. With Python 2 that
means CPython 2.7 and with Python 3 that means CPython 3.4 or
higher.
2. [[https://www.swig.org][SWIG]].
3. GPGME itself. Which also means that all of GPGME's dependencies
must be installed too.
*** Recommended Additions
:PROPERTIES:
:CUSTOM_ID: gpgme-python-recommendations
:END:
Though none of the following are absolute requirements, they are all
recommended for use with the Python bindings. In some cases these
recommendations refer to which version(s) of CPython to use the
bindings with, while others refer to third party modules which provide
a significant advantage in some way.
1. If possible, use Python 3 instead of 2.
2. Favour a more recent version of Python since even 3.4 is due to
reach EOL soon. In production systems and services, Python 3.6
should be robust enough to be relied on.
3. If possible add the following Python modules which are not part of
the standard library: [[http://docs.python-requests.org/en/latest/index.html][Requests]], [[https://cython.org/][Cython]], [[https://pendulum.eustace.io/][Pendulum]] and [[https://github.com/Selfnet/hkp4py][hkp4py]].
Chances are quite high that at least the first one and maybe two of
those will already be installed.
Note that, as with Cython, some of advanced use case scenarios will
bring with them additional requirements. Most of these will be fairly
well known and commonly installed ones, however, which are in many
cases likely to have already been installed on many systems or be
familiar to Python programmers.
** Installation
:PROPERTIES:
:CUSTOM_ID: installation
:END:
Installing the Python bindings is effectively achieved by compiling
and installing GPGME itself.
Once SWIG is installed with Python and all the dependencies for GPGME
are installed you only need to confirm that the version(s) of Python
you want the bindings installed for are in your =$PATH=.
By default GPGME will attempt to install the bindings for the most
recent or highest version number of Python 2 and Python 3 it detects
in =$PATH=. It specifically checks for the =python= and =python3=
executables first and then checks for specific version numbers.
For Python 2 it checks for these executables in this order: =python=,
=python2= and =python2.7=.
For Python 3 it checks for these executables in this order: =python3=,
=python3.7=, =python3.6=, =python3.5= and =python3.4=.[fn:2]
On systems where =python= is actually =python3= and not =python2= it
may be possible that =python2= may be overlooked, but there have been
no reports of that actually occurring as yet.
In the three months or so since the release of Python 3.7.0 there has
been extensive testing and work with these bindings with no issues
specifically relating to the new version of Python or any of the new
features of either the language or the bindings. This has also been
the case with Python 3.7.1rc1. With that in mind and given the
release of Python 3.7.1 is scheduled for around the same time as GPGME
1.12.0, the order of preferred Python versions has been changed to
move Python 3.7 ahead of Python 3.6.
*** Installing GPGME
:PROPERTIES:
:CUSTOM_ID: install-gpgme
:END:
See the GPGME =README= file for details of how to install GPGME from
source.
** Known Issues
:PROPERTIES:
:CUSTOM_ID: snafu
:END:
There are a few known issues with the current build process and the
Python bindings. For the most part these are easily addressed should
they be encountered.
*** Breaking Builds
:PROPERTIES:
:CUSTOM_ID: snafu-a-swig-of-this-builds-character
:END:
Occasionally when installing GPGME with the Python bindings included
it may be observed that the =make= portion of that process induces a
large very number of warnings and, eventually errors which end that
part of the build process. Yet following that with =make check= and
=make install= appears to work seamlessly.
The cause of this is related to the way SWIG needs to be called to
dynamically generate the C bindings for GPGME in the first place. So
the entire process will always produce =lang/python/python2-gpg/= and
=lang/python/python3-gpg/= directories. These should contain the
build output generated during compilation, including the complete
bindings and module installed into =site-packages=.
Occasionally the errors in the early part or some other conflict
(e.g. not installing as */root/* or */su/*) may result in nothing
being installed to the relevant =site-packages= directory and the
build directory missing a lot of expected files. Even when this
occurs, the solution is actually quite simple and will always work.
That solution is simply to run the following commands as either the
*root* user or prepended with =sudo -H=[fn:3] in the =lang/python/=
directory:
#+BEGIN_SRC shell
/path/to/pythonX.Y setup.py build
/path/to/pythonX.Y setup.py build
/path/to/pythonX.Y setup.py install
#+END_SRC
Yes, the build command does need to be run twice. Yes, you still need
to run the potentially failing or incomplete steps during the
=configure=, =make= and =make install= steps with installing GPGME.
This is because those steps generate a lot of essential files needed,
both by and in order to create, the bindings (including both the
=setup.py= and =gpgme.h= files).
**** IMPORTANT Note
:PROPERTIES:
:CUSTOM_ID: snafu-swig-build-note
:END:
If specifying a selected number of languages to create bindings for,
try to leave Python last. Currently the majority of the other
language bindings are also preceding Python of either version when
listed alphabetically (not counting the Qt bindings).
If Python is set to precede one of the other languages then it is
possible that the errors described here may interrupt the build
process before generating bindings for those other languages. In
these cases it may be preferable to configure all preferred language
bindings separately with alternative =configure= steps for GPGME using
the =--enable-languages=$LANGUAGE= option.
Alternatively =make= (or =gmake=, depending on your platform) may be
run with the the =-k= option, which tells make to keep going even if
errors are encountered. In that case the failure of one language's
set of bindings to build should not hamper another language's bindings
to build.
*** Reinstalling Responsibly
:PROPERTIES:
:CUSTOM_ID: snafu-lessons-for-the-lazy
:END:
Regardless of whether you're installing for one version of Python or
several, there will come a point where reinstallation is required.
With most Python module installations, the installed files go into the
relevant site-packages directory and are then forgotten about. Then
the module is upgraded, the new files are copied over the old and
that's the end of the matter.
While the same is true of these bindings, there have been intermittent
issues observed on some platforms which have benefited significantly
from removing all the previous installations of the bindings before
installing the updated versions.
Removing the previous version(s) is simply a matter of changing to the
relevant =site-packages= directory for the version of Python in
question and removing the =gpg/= directory and any accompanying
egg-info files for that module.
In most cases this will require root or administration privileges on
the system, but the same is true of installing the module in the first
place.
*** Multiple installations
:PROPERTIES:
:CUSTOM_ID: snafu-the-full-monty
:END:
For a variety of reasons it may be either necessary or just preferable
to install the bindings to alternative installed Python versions which
meet the requirements of these bindings.
On POSIX systems this will generally be most simply achieved by
running the manual installation commands (build, build, install) as
described in the previous section for each Python installation the
bindings need to be installed to.
As per the SWIG documentation: the compilers, libraries and runtime
used to build GPGME and the Python Bindings *must* match those used to
compile Python itself, including the version number(s) (at least going
by major version numbers and probably minor numbers too).
On most POSIX systems, including OS X, this will very likely be the
case in most, if not all, cases.
Note that from GPGME [[https://dev.gnupg.org/rMff6ff616aea6f59b7f2ce1176492850ecdf3851e][1.12.1]] the default installation installs to each
version of Python it can find first. That is that it will currently
install for the first copies of Python versions 2.7, 3.4, 3.5, and so on
up until the current dev branch that it finds. Usually this will be in the
same prefix as GPGME itself, but is dictated by the =$PATH= when the
installation is performed. The above instructions can still be
performed on other python installations which the installer does not
find, including alternative prefixes.
*** Won't Work With Windows
:PROPERTIES:
:CUSTOM_ID: snafu-runtime-not-funtime
:END:
There are semi-regular reports of Windows users having considerable
difficulty in installing and using the Python bindings at all. Very
often, possibly even always, these reports come from Cygwin users
and/or MinGW users and/or Msys2 users. Though not all of them have
been confirmed, it appears that these reports have also come from
people who installed Python using the Windows installer files from the
[[https://python.org][Python website]] (i.e. mostly MSI installers, sometimes self-extracting
=.exe= files).
The Windows versions of Python are not built using Cygwin, MinGW or
Msys2; they're built using Microsoft Visual Studio. Furthermore the
version used is /considerably/ more advanced than the version which
MinGW obtained a small number of files from many years ago in order to
be able to compile anything at all. Not only that, but there are
changes to the version of Visual Studio between some micro releases,
though that is is particularly the case with Python 2.7, since it has
been kept around far longer than it should have been.
There are two theoretical solutions to this issue:
1. Compile and install the GnuPG stack, including GPGME and the
Python bindings using the same version of Microsoft Visual Studio
used by the Python Foundation to compile the version of Python
installed.
If there are multiple versions of Python then this will need to be
done with each different version of Visual Studio used for those
versions of Python.
2. Compile and install Python using the same tools used by choice,
such as MinGW or Msys2.
Do *not* use the official Windows installer for Python unless
following the first method.
In this type of situation it may even be for the best to accept that
there are less limitations on permissive software than free software
and simply opt to use a recent version of the Community Edition of
Microsoft Visual Studio to compile and build all of it, no matter
what.
Investigations into the extent or the limitations of this issue are
ongoing.
The following table lists the version of Microsoft Visual Studio which
needs to be used when compiling GPGME and the Python bindings with
each version of the CPython binary released [[https://www.python.org/downloads/windows/][for Windows]]:
| CPython | Microsoft product name | runtime filename |
| 2.7.6 | Visual Studio 2008 | MSVCR90.DLL |
| 3.4.0 | Visual Studio 2010 | MSVCR100.DLL |
| 3.5.0 | Visual Studio 2015 | *see below* |
| 3.6.0 | Visual Studio 2015 | *see below* |
| 3.7.0 | Visual Studio 2017* | *see below* |
It is important to note that MingW and Msys2 ship with the Visual C
runtime from Microsoft Visual Studio 2005 and are thus *incompatible*
with all the versions of CPython which can be used with the GPGME
Python bindings.
It is also important to note that from CPython 3.5 onwards, the Python
Foundation has adopted the reworking of the Visual C runtime which was
performed for Visual Studio 2015 and aimed at resolving many of these
kinds of issues. Much greater detail on these issues and the correct
file(s) to link to are available from Matthew Brett's invaluable page,
[[https://matthew-brett.github.io/pydagogue/python_msvc.html][Using Microsoft Visual C with Python]]. It is also worth reading the
Microsoft Developer Network blog post on [[http://blogs.msdn.com/b/vcblog/archive/2015/03/03/introducing-the-universal-crt.aspx][the universal CRT]] and Steve
Dower's blog posts on Python extensions ([[http://stevedower.id.au/blog/building-for-python-3-5][part 1]] and [[http://stevedower.id.au/blog/building-for-python-3-5-part-two][part 2]]).
The second of those two posts by Steve Dower contains the details of
specific configuration options required for compiling anything to be
used with official CPython releases. In addition to those
configuration and compiler settings to use, the versions of Visual
Studio prior to Visual Studio 2015 did not support 64-bit systems by
default. So compiling a 64-bit version of these bindings for a 64-bit
version of CPython 2.7 or 3.4 requires additional work.
In addition to the blog posts, the [[https://wiki.python.org/moin/WindowsCompilers][Windows compilers]] wiki page on the
CPython wiki is another essential reference on the relevant versions
of Visual Studio to use and the degree of compatibility with CPython
releases.
Eventually someone will ask why there isn't an installable binary for
Windows, which the GPGME of the licenses do not preclude as long as
the source code is available in conjunction with such a release.
The sheer number of versions of Visual Studio in conjunction with
differing configuration options depending on the target Windows
version and whether the architecture is 64-bit or 32-bit makes it
difficult to provide a correct binary installer for Windows users. At
the bare minimum doing so would require the GnuPG project compile ten
different versions of the bindings with each release; both 32-bit and
64-bit versions for CPython 2.7 and 3.4, with 64-bit versions for both
x86-64 (i.e. Intel and AMD) and ARM architectures for CPython 3.5,
3.6, 3.7 and later releases. That's the bare *minimum*, it'd probably
be higher.
Additionally, with only a binary installation used in conjunction with
the CPython installer from =python.org= the advanced options available
which utilise [[#cython][Cython]] will not be able to be used at all. Cython
depends on being able to compile the C code it generates and that too
would need to utilise a matching runtime to both the installed version
of CPython and these bindings in order to work with the bindings.
Considering all of that, what do we recommend?
1. Use a recent version of CPython; at least 3.5, but ideally 3.6 or
later.
2. Use Visual Studio 2015 or the standalone build tools for Visual
Studio 2017 (or later).
3. Compile both CPython and GPGME with these bindings using the tools
selected in step 2.
4. Ignore MingW, Msys2 and the official CPython binary installers.
5. Be thankful the answer to this question wasn't simply to say
something like, “install Linux” or “install FreeBSD” (or even
Apple's OS X).
*** CFFI is the Best™ and GPGME should use it instead of SWIG
:PROPERTIES:
:CUSTOM_ID: snafu-cffi
:END:
There are many reasons for favouring [[https://cffi.readthedocs.io/en/latest/overview.html][CFFI]] and proponents of it are
quite happy to repeat these things as if all it would take to switch
from SWIG to CFFI is repeating that list as if it were a new concept.
The fact is that there are things which Python's CFFI implementation
cannot handle in the GPGME C code. Beyond that there are features of
SWIG which are simply not available with CFFI at all. SWIG generates
the bindings to Python using the =gpgme.h= file, but that file is not
a single version shipped with each release, it too is generated when
GPGME is compiled.
CFFI is currently unable to adapt to such a potentially mutable
codebase. If there were some means of applying SWIG's dynamic code
generation to produce the Python/CFFI API modes of accessing the GPGME
libraries (or the source source code directly), but such a thing does
not exist yet either and it currently appears that work is needed in
at least one of CFFI's dependencies before any of this can be
addressed.
So if you're a massive fan of CFFI; that's great, but if you want this
project to switch to CFFI then rather than just insisting that it
should, I'd suggest you volunteer to bring CFFI up to the level this
project needs.
If you're actually seriously considering doing so, then I'd suggest
taking the =gpgme-tool.c= file in the GPGME =src/= directory and
getting that to work with any of the CFFI API methods (not the ABI
methods, they'll work with pretty much anything). When you start
running into trouble with "ifdefs" then you'll know what sort of
things are lacking. That doesn't even take into account the amount of
work saved via SWIG's code generation techniques either.
*** Virtualised Environments
:PROPERTIES:
:CUSTOM_ID: snafu-venv
:END:
It is fairly common practice amongst Python developers to, as much as
possible, use packages like virtualenv to keep various things that are
to be installed from interfering with each other. Given how much of
the GPGME bindings is often at odds with the usual pythonic way of
doing things, it stands to reason that this would be called into
question too.
As it happens the answer as to whether or not the bindings can be used
with virtualenv, the answer is both yes and no.
In general we recommend installing to the relevant path and matching
prefix of GPGME itself. Which means that when GPGME, and ideally the
rest of the GnuPG stack, is installed to a prefix like =/usr/local= or
=/opt/local= then the bindings would need to be installed to the main
Python installation and not a virtualised abstraction. Attempts to
separate the two in the past have been known to cause weird and
intermittent errors ranging from minor annoyances to complete failures
in the build process.
As a consequence we only recommend building with and installing to the
main Python installations within the same prefix as GPGME is installed
to or which are found by GPGME's configuration stage immediately prior
to running the make commands. Which is exactly what the compiling and
installing process of GPGME does by default.
Once that is done, however, it appears that a copy of the compiled
module may be installed into a virtualenv of the same major and minor
version matching the build. Alternatively it is possible to utilise a
=sites.pth= file in the =site-packages/= directory of a virtualenv
installation, which links back to the system installations
corresponding directory in order to import anything installed system
wide. This may or may not be appropriate on a case by case basis.
Though extensive testing of either of these options is not yet
complete, preliminary testing of them indicates that both are viable
as long as the main installation is complete. Which means that
certain other options normally restricted to virtual environments are
also available, including integration with pythonic test suites
(e.g. [[https://docs.pytest.org/en/latest/index.html][pytest]]) and other large projects.
That said, it is worth reiterating the warning regarding non-standard
installations. If one were to attempt to install the bindings only to
a virtual environment without somehow also including the full GnuPG
stack (or enough of it as to include GPGME) then it is highly likely
that errors would be encountered at some point and more than a little
likely that the build process itself would break.
If a degree of separation from the main operating system is still
required in spite of these warnings, then consider other forms of
virtualisation. Either a virtual machine (e.g. [[https://www.virtualbox.org/][VirtualBox]]), a
hardware emulation layer (e.g. [[https://www.qemu.org/][QEMU]]) or an application container
These draft versions have been generated from this document via GNU
Emacs [[https://orgmode.org/][Org mode]] to =.texi= and [[https://www.gnu.org/software/texinfo/][GNU Texinfo]] to HTML. Though it is
likely that the specific [[https://files.au.adversary.org/crypto/gpgme-python-howto][file]] [[http://files.au.adversary.org/crypto/gpgme-python-howto.org][version]] used will be on the same server
with the generated output formats. Occasionally I may include the Org
cat $x.texi | sed -e 's/@documentencoding UTF-8/@documentencoding utf-8/g' > ../texinfo/$x.texi
pandoc -f org -t rst+smart -o ../rst/$x.rst $x
done ;
rm -fv *.texi
cd ../texinfo
mkdir info
mkdir html
for x in *.texi ; do
makeinfo -v $x
makeinfo --html --no-split $x
done ;
mv *.info info/
mv *.html html/
#+END_SRC
This code snippet includes the generation of the reStructuredText
files and would be expected to be run from the =doc/src/= directory
containing the Org mode source files. It also assumes that the
commands are being run on POSIX compliant systems with basic tools
like sed, the Bourne shell and GNU Emacs[fn:6] available. The code
snippet also includes the steps for generating the Emacs Info files
and HTML files from the Texinfo files. Using reStructuredText files
with Sphinx is best left for the documentation of that project.
In addition to these there is a significantly less frequently updated
version as a HTML [[https://files.au.adversary.org/crypto/gpgme-python/dita/webhelp/index.html][WebHelp site]] (AWS S3 SSL); generated from DITA XML
source files, which can be found in [[https://dev.gnupg.org/source/gpgme/browse/ben%252Fhowto-dita/][an alternative branch]] of the GPGME
git repository.
Various generated output formats may occasionally be found in
subdirectories of the [[https://s3.amazonaws.com/files.au.adversary.org/crypto/gpgme-python][gpgme-python]] directory. In particular within
the [[https://s3.amazonaws.com/files.au.adversary.org/crypto/gpgme-python/dita][DITA]], [[https://s3.amazonaws.com/files.au.adversary.org/crypto/gpgme-python/rst][reStructuredText]] and [[https://s3.amazonaws.com/files.au.adversary.org/crypto/gpgme-python/texinfo][Texinfo]] subdirectories. The =rst=
directory contains output files generated with Sphinx and may include a
considerable number of its possible output formats, but there are no
guarantees as to how recent these are or even if they are present.
These draft editions are not official documents and the version of
documentation in the master branch or which ships with released
versions is the only official documentation. Nevertheless, these
draft editions may occasionally be of use by providing more accessible
web versions which are updated between releases. They are provided on
the understanding that they may contain errors or may contain content
subject to change prior to an official release.
** License GPL compatible
:PROPERTIES:
:CUSTOM_ID: license
:END:
This file is free software; as a special exception the author gives
unlimited permission to copy and/or distribute it, with or without
modifications, as long as this notice is preserved.
This file is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR