Python bindings tests: Near PEP8 compliance
authorBen McGinnes <ben@adversary.org>
Sat, 18 Aug 2018 10:29:14 +0000 (20:29 +1000)
committerBen McGinnes <ben@adversary.org>
Sat, 18 Aug 2018 10:29:14 +0000 (20:29 +1000)
* PEP8 compliance for the vast majoeity of the tests.

31 files changed:
lang/python/tests/final.py
lang/python/tests/initial.py
lang/python/tests/run-tests.py
lang/python/tests/support.py
lang/python/tests/t-callbacks.py
lang/python/tests/t-data.py
lang/python/tests/t-decrypt-verify.py
lang/python/tests/t-decrypt.py
lang/python/tests/t-edit.py
lang/python/tests/t-encrypt-large.py
lang/python/tests/t-encrypt-sign.py
lang/python/tests/t-encrypt-sym.py
lang/python/tests/t-encrypt.py
lang/python/tests/t-export.py
lang/python/tests/t-file-name.py
lang/python/tests/t-idiomatic.py
lang/python/tests/t-import.py
lang/python/tests/t-keylist-from-data.py
lang/python/tests/t-keylist.py
lang/python/tests/t-protocol-assuan.py
lang/python/tests/t-quick-key-creation.py
lang/python/tests/t-quick-key-manipulation.py
lang/python/tests/t-quick-key-signing.py
lang/python/tests/t-quick-subkey-creation.py
lang/python/tests/t-sig-notation.py
lang/python/tests/t-sign.py
lang/python/tests/t-signers.py
lang/python/tests/t-trustlist.py
lang/python/tests/t-verify.py
lang/python/tests/t-wait.py
lang/python/tests/t-wrapper.py

index 65375cb..d0d52dc 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import os
 import subprocess
 import support
-_ = support # to appease pyflakes.
+_ = support  # to appease pyflakes.
+
+del absolute_import, print_function, unicode_literals
 
-subprocess.check_call([os.path.join(os.getenv('top_srcdir'),
-                                    "tests", "start-stop-agent"), "--stop"])
+subprocess.check_call([
+    os.path.join(os.getenv('top_srcdir'), "tests", "start-stop-agent"),
+    "--stop"
+])
index 49e4f82..30a8de7 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import os
 import subprocess
 import gpg
 import support
 
+del absolute_import, print_function, unicode_literals
+
 print("Using gpg module from {0!r}.".format(os.path.dirname(gpg.__file__)))
 
-subprocess.check_call([os.path.join(os.getenv('top_srcdir'),
-                                    "tests", "start-stop-agent"), "--start"])
+subprocess.check_call([
+    os.path.join(os.getenv('top_srcdir'), "tests", "start-stop-agent"),
+    "--start"
+])
 
 with gpg.Context() as c:
     alpha = c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False)
index 95df197..cec13b5 100644 (file)
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
+from __future__ import absolute_import, division
+from __future__ import print_function, unicode_literals
 
 import argparse
 import glob
@@ -28,34 +26,50 @@ import os
 import subprocess
 import sys
 
+del absolute_import, division, print_function, unicode_literals
+
+
 class SplitAndAccumulate(argparse.Action):
     def __call__(self, parser, namespace, values, option_string=None):
         current = getattr(namespace, self.dest, list())
         current.extend(values.split())
         setattr(namespace, self.dest, current)
 
+
 parser = argparse.ArgumentParser(description='Run tests.')
-parser.add_argument('tests', metavar='TEST', type=str, nargs='+',
-                    help='A test to run')
-parser.add_argument('-v', '--verbose', action="store_true", default=False,
-                    help='Be verbose.')
-parser.add_argument('-q', '--quiet', action="store_true", default=False,
-                    help='Be quiet.')
-parser.add_argument('--interpreters', metavar='PYTHON', type=str,
-                    default=[], action=SplitAndAccumulate,
-                    help='Use these interpreters to run the tests, ' +
-                    'separated by spaces.')
-parser.add_argument('--srcdir', type=str,
-                    default=os.environ.get("srcdir", ""),
-                    help='Location of the tests.')
-parser.add_argument('--builddir', type=str,
-                    default=os.environ.get("abs_builddir", ""),
-                    help='Location of the tests.')
-parser.add_argument('--python-libdir', type=str,
-                    default=None,
-                    help='Optional location of the in-tree module lib directory.')
-parser.add_argument('--parallel', action="store_true", default=False,
-                    help='Ignored.  For compatibility with run-tests.scm.')
+parser.add_argument(
+    'tests', metavar='TEST', type=str, nargs='+', help='A test to run')
+parser.add_argument(
+    '-v', '--verbose', action="store_true", default=False, help='Be verbose.')
+parser.add_argument(
+    '-q', '--quiet', action="store_true", default=False, help='Be quiet.')
+parser.add_argument(
+    '--interpreters',
+    metavar='PYTHON',
+    type=str,
+    default=[],
+    action=SplitAndAccumulate,
+    help='Use these interpreters to run the tests, ' + 'separated by spaces.')
+parser.add_argument(
+    '--srcdir',
+    type=str,
+    default=os.environ.get("srcdir", ""),
+    help='Location of the tests.')
+parser.add_argument(
+    '--builddir',
+    type=str,
+    default=os.environ.get("abs_builddir", ""),
+    help='Location of the tests.')
+parser.add_argument(
+    '--python-libdir',
+    type=str,
+    default=None,
+    help='Optional location of the in-tree module lib directory.')
+parser.add_argument(
+    '--parallel',
+    action="store_true",
+    default=False,
+    help='Ignored.  For compatibility with run-tests.scm.')
 
 args = parser.parse_args()
 if not args.interpreters:
@@ -64,26 +78,31 @@ if not args.interpreters:
 out = sys.stdout if args.verbose else None
 err = sys.stderr if args.verbose else None
 
+
 def status_to_str(code):
     return {0: "PASS", 77: "SKIP", 99: "ERROR"}.get(code, "FAIL")
 
+
 results = list()
 for interpreter in args.interpreters:
-    version = subprocess.check_output(
-        [interpreter, "-c", "import sys; print('{0}.{1}'.format(sys.version_info[0], sys.version_info[1]))"]).strip().decode()
+    version = subprocess.check_output([
+        interpreter, "-c",
+        "import sys; print('{0}.{1}'.format(sys.version_info[0], sys.version_info[1]))"
+    ]).strip().decode()
 
     if args.python_libdir:
         python_libdir = args.python_libdir
     else:
-        pattern = os.path.join(args.builddir, "..",
-                               "{0}-gpg".format(os.path.basename(interpreter)),
-                               "lib*")
+        pattern = os.path.join(args.builddir, "..", "{0}-gpg".format(
+            os.path.basename(interpreter)), "lib*")
         libdirs = glob.glob(pattern)
         if len(libdirs) == 0:
-            sys.exit("Build directory matching {0!r} not found.".format(pattern))
+            sys.exit(
+                "Build directory matching {0!r} not found.".format(pattern))
         elif len(libdirs) > 1:
-            sys.exit("Multiple build directories matching {0!r} found: {1}".format(
-                pattern, libdirs))
+            sys.exit(
+                "Multiple build directories matching {0!r} found: {1}".format(
+                    pattern, libdirs))
         python_libdir = libdirs[0]
 
     env = dict(os.environ)
@@ -95,16 +114,22 @@ for interpreter in args.interpreters:
     for test in args.tests:
         status = subprocess.call(
             [interpreter, os.path.join(args.srcdir, test)],
-            env=env, stdout=out, stderr=err)
+            env=env,
+            stdout=out,
+            stderr=err)
         if not args.quiet:
             print("{0}: {1}".format(status_to_str(status), test))
         results.append(status)
 
+
 def count(status):
     return len(list(filter(lambda x: x == status, results)))
+
+
 def failed():
     return len(list(filter(lambda x: x not in (0, 77, 99), results)))
 
+
 if not args.quiet:
     print("{0} tests run, {1} succeeded, {2} failed, {3} skipped.".format(
         len(results), count(0), failed(), count(77)))
index efccf31..e6b3d8b 100644 (file)
@@ -16,7 +16,6 @@
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import contextlib
 import shutil
@@ -27,20 +26,28 @@ import tempfile
 import time
 import gpg
 
+del absolute_import, print_function, unicode_literals
+
+
 def assert_gpg_version(version=(2, 1, 0)):
     with gpg.Context() as c:
-        clean_version = re.match(r'\d+\.\d+\.\d+', c.engine_info.version).group(0)
+        clean_version = re.match(r'\d+\.\d+\.\d+',
+                                 c.engine_info.version).group(0)
         if tuple(map(int, clean_version.split('.'))) < version:
             print("GnuPG too old: have {0}, need {1}.".format(
                 c.engine_info.version, '.'.join(map(str, version))))
             sys.exit(77)
 
+
 def have_tofu_support(ctx, some_uid):
-    keys = list(ctx.keylist(some_uid,
-                            mode=(gpg.constants.keylist.mode.LOCAL
-                                  |gpg.constants.keylist.mode.WITH_TOFU)))
+    keys = list(
+        ctx.keylist(
+            some_uid,
+            mode=(gpg.constants.keylist.mode.LOCAL |
+                  gpg.constants.keylist.mode.WITH_TOFU)))
     return len(keys) > 0
 
+
 # Skip the Python tests for GnuPG < 2.1.12.  Prior versions do not
 # understand the command line flags that we assume exist.  C.f. issue
 # 3008.
@@ -53,13 +60,18 @@ encrypt_only = "F52770D5C4DB41408D918C9F920572769B9FE19C"
 sign_only = "7CCA20CCDE5394CEE71C9F0BFED153F12F18F45D"
 no_such_key = "A" * 40
 
+
 def make_filename(name):
     return os.path.join(os.environ['top_srcdir'], 'tests', 'gpg', name)
 
+
 def in_srcdir(name):
     return os.path.join(os.environ['srcdir'], name)
 
+
 verbose = int(os.environ.get('verbose', 0)) > 1
+
+
 def print_data(data):
     if verbose:
         try:
@@ -75,10 +87,12 @@ def print_data(data):
         else:
             sys.stdout.write(data)
 
+
 def mark_key_trusted(ctx, key):
     class Editor(object):
         def __init__(self):
             self.steps = ["trust", "save"]
+
         def edit(self, status, args, out):
             if args == "keyedit.prompt":
                 result = self.steps.pop(0)
@@ -91,6 +105,7 @@ def mark_key_trusted(ctx, key):
             else:
                 result = None
             return result
+
     with gpg.Data() as sink:
         ctx.op_edit(key, Editor().edit, sink, sink)
 
@@ -103,9 +118,11 @@ class TemporaryDirectory(object):
     def __enter__(self):
         self.path = tempfile.mkdtemp()
         return self.path
+
     def __exit__(self, *args):
         shutil.rmtree(self.path, ignore_errors=True)
 
+
 @contextlib.contextmanager
 def EphemeralContext():
     with TemporaryDirectory() as tmp:
@@ -124,7 +141,7 @@ def EphemeralContext():
                 ctx.assuan_transact(["KILLAGENT"])
             except gpg.errors.GPGMEError as e:
                 if e.getcode() == gpg.errors.ASS_CONNECT_FAILED:
-                    pass # the agent was not running
+                    pass  # the agent was not running
                 else:
                     raise
 
index b311e3d..25a1c23 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import os
 import gpg
 import support
-_ = support # to appease pyflakes.
+_ = support  # to appease pyflakes.
+
+del absolute_import, print_function, unicode_literals
 
 c = gpg.Context()
 c.set_pinentry_mode(gpg.constants.PINENTRY_MODE_LOOPBACK)
@@ -33,6 +34,7 @@ sink = gpg.Data()
 
 # Valid passphrases, both as string and bytes.
 for passphrase in ('foo', b'foo'):
+
     def passphrase_cb(hint, desc, prev_bad, hook=None):
         assert hook == passphrase
         return hook
@@ -40,10 +42,12 @@ for passphrase in ('foo', b'foo'):
     c.set_passphrase_cb(passphrase_cb, passphrase)
     c.op_encrypt([], 0, source, sink)
 
+
 # Returning an invalid type.
 def passphrase_cb(hint, desc, prev_bad, hook=None):
     return 0
 
+
 c.set_passphrase_cb(passphrase_cb, None)
 try:
     c.op_encrypt([], 0, source, sink)
@@ -55,9 +59,12 @@ else:
 
 # Raising an exception inside callback.
 myException = Exception()
+
+
 def passphrase_cb(hint, desc, prev_bad, hook=None):
     raise myException
 
+
 c.set_passphrase_cb(passphrase_cb, None)
 try:
     c.op_encrypt([], 0, source, sink)
@@ -66,10 +73,12 @@ except Exception as e:
 else:
     assert False, "Expected an error, got none"
 
+
 # Wrong kind of callback function.
 def bad_passphrase_cb():
     pass
 
+
 c.set_passphrase_cb(bad_passphrase_cb, None)
 try:
     c.op_encrypt([], 0, source, sink)
@@ -78,8 +87,6 @@ except Exception as e:
 else:
     assert False, "Expected an error, got none"
 
-
-
 # Test the progress callback.
 parms = """<GnupgKeyParms format="internal">
 Key-Type: RSA
@@ -93,21 +100,26 @@ Expire-Date: 2099-12-31
 """
 
 messages = []
+
+
 def progress_cb(what, typ, current, total, hook=None):
     assert hook == messages
     messages.append(
         "PROGRESS UPDATE: what = {}, type = {}, current = {}, total = {}"
         .format(what, typ, current, total))
 
+
 c = gpg.Context()
 c.set_progress_cb(progress_cb, messages)
 c.op_genkey(parms, None, None)
 assert len(messages) > 0
 
+
 # Test exception handling.
 def progress_cb(what, typ, current, total, hook=None):
     raise myException
 
+
 c = gpg.Context()
 c.set_progress_cb(progress_cb, None)
 try:
@@ -117,7 +129,6 @@ except Exception as e:
 else:
     assert False, "Expected an error, got none"
 
-
 # Test the edit callback.
 c = gpg.Context()
 c.set_pinentry_mode(gpg.constants.PINENTRY_MODE_LOOPBACK)
@@ -127,11 +138,15 @@ alpha = c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False)
 
 cookie = object()
 edit_cb_called = False
+
+
 def edit_cb(status, args, hook):
     global edit_cb_called
     edit_cb_called = True
     assert hook == cookie
     return "quit" if args == "keyedit.prompt" else None
+
+
 c.op_edit(alpha, edit_cb, cookie, sink)
 assert edit_cb_called
 
@@ -141,8 +156,11 @@ c.set_pinentry_mode(gpg.constants.PINENTRY_MODE_LOOPBACK)
 c.set_passphrase_cb(lambda *args: "abc")
 sink = gpg.Data()
 
+
 def edit_cb(status, args):
     raise myException
+
+
 try:
     c.op_edit(alpha, edit_cb, None, sink)
 except Exception as e:
@@ -150,18 +168,19 @@ except Exception as e:
 else:
     assert False, "Expected an error, got none"
 
-
-
 # Test the status callback.
 source = gpg.Data("Hallo Leute\n")
 sink = gpg.Data()
 
 status_cb_called = False
+
+
 def status_cb(keyword, args, hook=None):
     global status_cb_called
     status_cb_called = True
     assert hook == cookie
 
+
 c = gpg.Context()
 c.set_status_cb(status_cb, cookie)
 c.set_ctx_flag("full-status", "1")
@@ -172,9 +191,11 @@ assert status_cb_called
 source = gpg.Data("Hallo Leute\n")
 sink = gpg.Data()
 
+
 def status_cb(keyword, args):
     raise myException
 
+
 c = gpg.Context()
 c.set_status_cb(status_cb, None)
 c.set_ctx_flag("full-status", "1")
@@ -186,13 +207,16 @@ else:
     assert False, "Expected an error, got none"
 
 
-
 # Test the data callbacks.
 def read_cb(amount, hook=None):
     assert hook == cookie
     return 0
+
+
 def release_cb(hook=None):
     assert hook == cookie
+
+
 data = gpg.Data(cbs=(read_cb, None, None, release_cb, cookie))
 try:
     data.read()
@@ -201,8 +225,11 @@ except Exception as e:
 else:
     assert False, "Expected an error, got none"
 
+
 def read_cb(amount):
     raise myException
+
+
 data = gpg.Data(cbs=(read_cb, None, None, lambda: None))
 try:
     data.read()
@@ -215,6 +242,8 @@ else:
 def write_cb(what, hook=None):
     assert hook == cookie
     return "wrong type"
+
+
 data = gpg.Data(cbs=(None, write_cb, None, release_cb, cookie))
 try:
     data.write(b'stuff')
@@ -223,8 +252,11 @@ except Exception as e:
 else:
     assert False, "Expected an error, got none"
 
+
 def write_cb(what):
     raise myException
+
+
 data = gpg.Data(cbs=(None, write_cb, None, lambda: None))
 try:
     data.write(b'stuff')
@@ -237,6 +269,8 @@ else:
 def seek_cb(offset, whence, hook=None):
     assert hook == cookie
     return "wrong type"
+
+
 data = gpg.Data(cbs=(None, None, seek_cb, release_cb, cookie))
 try:
     data.seek(0, os.SEEK_SET)
@@ -245,8 +279,11 @@ except Exception as e:
 else:
     assert False, "Expected an error, got none"
 
+
 def seek_cb(offset, whence):
     raise myException
+
+
 data = gpg.Data(cbs=(None, None, seek_cb, lambda: None))
 try:
     data.seek(0, os.SEEK_SET)
index 5cf074c..006c11f 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import io
 import os
 import tempfile
 import gpg
 import support
-_ = support # to appease pyflakes.
+_ = support  # to appease pyflakes.
+
+del absolute_import, print_function, unicode_literals
 
 data = gpg.Data('Hello world!')
 assert data.read() == b'Hello world!'
@@ -94,7 +95,8 @@ with tempfile.NamedTemporaryFile() as tmp:
 
     # Open using name, offset, and length.
     data = gpg.Data(file=tmp.name, offset=23, length=42)
-    assert data.read() == binjunk[23:23+42]
+    assert data.read() == binjunk[23:23 + 42]
+
 
 # Test callbacks.
 class DataObject(object):
@@ -118,6 +120,7 @@ class DataObject(object):
         assert not self.released
         self.released = True
 
+
 do = DataObject()
 cookie = object()
 data = gpg.Data(cbs=(do.read, do.write, do.seek, do.release, cookie))
index 03bbc4b..fcaa134 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
 
+del absolute_import, print_function, unicode_literals
+
+
 def check_verify_result(result, summary, fpr, status):
     assert len(result.signatures) == 1, "Unexpected number of signatures"
     sig = result.signatures[0]
@@ -32,7 +34,9 @@ def check_verify_result(result, summary, fpr, status):
     assert len(sig.notations) == 0
     assert not sig.wrong_key_usage
     assert sig.validity == gpg.constants.validity.FULL
-    assert gpg.errors.GPGMEError(sig.validity_reason).getcode() == gpg.errors.NO_ERROR
+    assert gpg.errors.GPGMEError(
+        sig.validity_reason).getcode() == gpg.errors.NO_ERROR
+
 
 c = gpg.Context()
 
@@ -47,10 +51,9 @@ assert not result.unsupported_algorithm, \
 support.print_data(sink)
 
 verify_result = c.op_verify_result()
-check_verify_result(verify_result,
-                    gpg.constants.sigsum.VALID | gpg.constants.sigsum.GREEN,
-                    "A0FF4590BB6122EDEF6E3C542D727CC768697734",
-                    gpg.errors.NO_ERROR)
+check_verify_result(
+    verify_result, gpg.constants.sigsum.VALID | gpg.constants.sigsum.GREEN,
+    "A0FF4590BB6122EDEF6E3C542D727CC768697734", gpg.errors.NO_ERROR)
 
 # Idiomatic interface.
 with gpg.Context() as c:
@@ -60,14 +63,13 @@ with gpg.Context() as c:
         c.decrypt(open(support.make_filename("cipher-2.asc")), verify=[alpha])
     assert plaintext.find(b'Wenn Sie dies lesen k') >= 0, \
         'Plaintext not found'
-    check_verify_result(verify_result,
-                        gpg.constants.sigsum.VALID | gpg.constants.sigsum.GREEN,
-                        "A0FF4590BB6122EDEF6E3C542D727CC768697734",
-                        gpg.errors.NO_ERROR)
+    check_verify_result(
+        verify_result, gpg.constants.sigsum.VALID | gpg.constants.sigsum.GREEN,
+        "A0FF4590BB6122EDEF6E3C542D727CC768697734", gpg.errors.NO_ERROR)
 
     try:
-        c.decrypt(open(support.make_filename("cipher-2.asc")),
-                  verify=[alpha, bob])
+        c.decrypt(
+            open(support.make_filename("cipher-2.asc")), verify=[alpha, bob])
     except gpg.errors.MissingSignatures as e:
         assert len(e.missing) == 1
         assert e.missing[0] == bob
index 05b6d8b..f2417c9 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
 
+del absolute_import, print_function, unicode_literals
+
 c = gpg.Context()
 
 source = gpg.Data(file=support.make_filename("cipher-1.asc"))
index b1075a9..cbc17d9 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import sys
 import os
 import gpg
 import support
-_ = support # to appease pyflakes.
+_ = support  # to appease pyflakes.
+
+del absolute_import, print_function, unicode_literals
+
 
 class KeyEditor(object):
     def __init__(self):
@@ -47,11 +49,12 @@ class KeyEditor(object):
             result = None
 
         if self.verbose:
-            sys.stderr.write("Code: {}, args: {!r}, Returning: {!r}\n"
-                             .format(status, args, result))
+            sys.stderr.write("Code: {}, args: {!r}, Returning: {!r}\n".format(
+                status, args, result))
 
         return result
 
+
 c = gpg.Context()
 c.set_pinentry_mode(gpg.constants.PINENTRY_MODE_LOOPBACK)
 c.set_passphrase_cb(lambda *args: "abc")
@@ -59,13 +62,15 @@ c.set_armor(True)
 
 # The deprecated interface.
 editor = KeyEditor()
-c.interact(c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False),
-           editor.edit_fnc)
+c.interact(
+    c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False),
+    editor.edit_fnc)
 assert editor.done
 
 # The deprecated interface.
 sink = gpg.Data()
 editor = KeyEditor()
-c.op_edit(c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False),
-          editor.edit_fnc, sink, sink)
+c.op_edit(
+    c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False),
+    editor.edit_fnc, sink, sink)
 assert editor.done
index 5646085..18576ac 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import sys
 import random
 import gpg
 import support
 
+del absolute_import, print_function, unicode_literals
+
 if len(sys.argv) == 2:
     nbytes = int(sys.argv[1])
 else:
@@ -33,6 +34,8 @@ else:
 c = gpg.Context()
 
 ntoread = nbytes
+
+
 def read_cb(amount):
     global ntoread
     chunk = ntoread if ntoread < amount else amount
@@ -41,12 +44,16 @@ def read_cb(amount):
     assert chunk >= 0
     return bytes(bytearray(random.randrange(256) for i in range(chunk)))
 
+
 nwritten = 0
+
+
 def write_cb(data):
     global nwritten
     nwritten += len(data)
     return len(data)
 
+
 source = gpg.Data(cbs=(read_cb, None, None, lambda: None))
 sink = gpg.Data(cbs=(None, write_cb, None, lambda: None))
 
@@ -61,5 +68,5 @@ assert not result.invalid_recipients, \
 assert ntoread == 0
 
 if support.verbose:
-    sys.stderr.write(
-        "plaintext={} bytes, ciphertext={} bytes\n".format(nbytes, nwritten))
+    sys.stderr.write("plaintext={} bytes, ciphertext={} bytes\n".format(
+        nbytes, nwritten))
index f04783f..84d1abb 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import sys
 import gpg
 import support
 
+del absolute_import, print_function, unicode_literals
+
 c = gpg.Context()
 c.set_armor(True)
 
+
 def check_result(r, typ):
     if r.invalid_signers:
         sys.exit("Invalid signer found: {}".format(r.invalid_signers.fpr))
@@ -42,7 +44,8 @@ def check_result(r, typ):
         sys.exit("Wrong pubkey algorithm reported: {}".format(
             signature.pubkey_algo))
 
-    if signature.hash_algo not in (gpg.constants.md.SHA1, gpg.constants.md.RMD160):
+    if signature.hash_algo not in (gpg.constants.md.SHA1,
+                                   gpg.constants.md.RMD160):
         sys.exit("Wrong hash algorithm reported: {}".format(
             signature.hash_algo))
 
@@ -53,6 +56,7 @@ def check_result(r, typ):
     if signature.fpr != "A0FF4590BB6122EDEF6E3C542D727CC768697734":
         sys.exit("Wrong fingerprint reported: {}".format(signature.fpr))
 
+
 keys = []
 keys.append(c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False))
 keys.append(c.get_key("D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2", False))
@@ -61,7 +65,8 @@ for recipients in (keys, []):
     source = gpg.Data("Hallo Leute\n")
     sink = gpg.Data()
 
-    c.op_encrypt_sign(recipients, gpg.constants.ENCRYPT_ALWAYS_TRUST, source, sink)
+    c.op_encrypt_sign(recipients, gpg.constants.ENCRYPT_ALWAYS_TRUST, source,
+                      sink)
     result = c.op_encrypt_result()
     assert not result.invalid_recipients, \
         "Invalid recipient encountered: {}".format(
@@ -72,13 +77,11 @@ for recipients in (keys, []):
 
     support.print_data(sink)
 
-
 # Idiomatic interface.
 with gpg.Context(armor=True) as c:
     message = "Hallo Leute\n".encode()
-    ciphertext, _, sig_result = c.encrypt(message,
-                                          recipients=keys,
-                                          always_trust=True)
+    ciphertext, _, sig_result = c.encrypt(
+        message, recipients=keys, always_trust=True)
     assert len(ciphertext) > 0
     assert ciphertext.find(b'BEGIN PGP MESSAGE') > 0, 'Marker not found'
     check_result(sig_result, gpg.constants.sig.mode.NORMAL)
index 8299293..9b099fe 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import os
 import gpg
 import support
-_ = support # to appease pyflakes.
+_ = support  # to appease pyflakes.
+
+del absolute_import, print_function, unicode_literals
 
 for passphrase in ("abc", b"abc"):
     c = gpg.Context()
@@ -34,6 +35,7 @@ for passphrase in ("abc", b"abc"):
     cipher = gpg.Data()
 
     passphrase_cb_called = 0
+
     def passphrase_cb(hint, desc, prev_bad, hook=None):
         global passphrase_cb_called
         passphrase_cb_called += 1
@@ -55,7 +57,7 @@ for passphrase in ("abc", b"abc"):
 
     c.op_decrypt(cipher, plain)
     # Seems like the passphrase is cached.
-    #assert passphrase_cb_called == 2, \
+    # assert passphrase_cb_called == 2, \
     #    "Callback called {} times".format(passphrase_cb_called)
     support.print_data(plain)
 
@@ -70,12 +72,12 @@ for passphrase in ("abc", b"abc"):
         # Check that the passphrase callback is not altered.
         def f(*args):
             assert False
+
         c.set_passphrase_cb(f)
 
         message = "Hallo Leute\n".encode()
-        ciphertext, _, _ = c.encrypt(message,
-                                     passphrase=passphrase,
-                                     sign=False)
+        ciphertext, _, _ = c.encrypt(
+            message, passphrase=passphrase, sign=False)
         assert ciphertext.find(b'BEGIN PGP MESSAGE') > 0, 'Marker not found'
 
         plaintext, _, _ = c.decrypt(ciphertext, passphrase=passphrase)
index 921502a..e702daa 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
 
+del absolute_import, print_function, unicode_literals
+
 c = gpg.Context()
 c.set_armor(True)
 
@@ -41,36 +42,37 @@ support.print_data(sink)
 
 # Idiomatic interface.
 with gpg.Context(armor=True) as c:
-    ciphertext, _, _ = c.encrypt("Hallo Leute\n".encode(),
-                                 recipients=keys,
-                                 sign=False,
-                                 always_trust=True)
+    ciphertext, _, _ = c.encrypt(
+        "Hallo Leute\n".encode(),
+        recipients=keys,
+        sign=False,
+        always_trust=True)
     assert len(ciphertext) > 0
     assert ciphertext.find(b'BEGIN PGP MESSAGE') > 0, 'Marker not found'
 
-    c.encrypt("Hallo Leute\n".encode(),
-              recipients=[c.get_key(support.encrypt_only, False)],
-              sign=False, always_trust=True)
+    c.encrypt(
+        "Hallo Leute\n".encode(),
+        recipients=[c.get_key(support.encrypt_only, False)],
+        sign=False,
+        always_trust=True)
 
     try:
-        c.encrypt("Hallo Leute\n".encode(),
-                  recipients=[c.get_key(support.sign_only, False)],
-                  sign=False, always_trust=True)
+        c.encrypt(
+            "Hallo Leute\n".encode(),
+            recipients=[c.get_key(support.sign_only, False)],
+            sign=False,
+            always_trust=True)
     except gpg.errors.InvalidRecipients as e:
         assert len(e.recipients) == 1
         assert support.sign_only.endswith(e.recipients[0].fpr)
     else:
         assert False, "Expected an InvalidRecipients error, got none"
 
-
-
     try:
         # People might be tempted to provide strings.
         # We should raise something useful.
-        ciphertext, _, _ = c.encrypt("Hallo Leute\n",
-                                     recipients=keys,
-                                     sign=False,
-                                     always_trust=True)
+        ciphertext, _, _ = c.encrypt(
+            "Hallo Leute\n", recipients=keys, sign=False, always_trust=True)
     except TypeError as e:
         # This test is a bit fragile, because the message
         # may very well change. So if the behaviour will change
index b9d5204..6d771dd 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
 
+del absolute_import, print_function, unicode_literals
+
 c = gpg.Context()
 c.set_armor(True)
 
@@ -32,8 +33,8 @@ support.print_data(sink)
 
 # Again. Now using a key array.
 keys = []
-keys.append(c.get_key("0x68697734", False)) # Alpha
-keys.append(c.get_key("0xA9E3B0B2", False)) # Bob
+keys.append(c.get_key("0x68697734", False))  # Alpha
+keys.append(c.get_key("0xA9E3B0B2", False))  # Bob
 sink = gpg.Data()
 c.op_export_keys(keys, 0, sink)
 support.print_data(sink)
index 32fe84a..d9c226f 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import os
 import gpg
 import support
-_ = support # to appease pyflakes.
+_ = support  # to appease pyflakes.
+
+del absolute_import, print_function, unicode_literals
 
 testname = "abcde12345"
 
index b7ae4eb..238bbf3 100755 (executable)
@@ -18,7 +18,6 @@
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import sys
 import io
@@ -26,7 +25,9 @@ import os
 import tempfile
 import gpg
 import support
-_ = support # to appease pyflakes.
+_ = support  # to appease pyflakes.
+
+del absolute_import, print_function, unicode_literals
 
 # Both Context and Data can be used as context manager:
 with gpg.Context() as c, gpg.Data() as d:
@@ -34,8 +35,9 @@ with gpg.Context() as c, gpg.Data() as d:
     d.write(b"Halloechen")
     leak_c = c
     leak_d = d
-assert leak_c.wrapped == None
-assert leak_d.wrapped == None
+assert leak_c.wrapped is None
+assert leak_d.wrapped is None
+
 
 def sign_and_verify(source, signed, sink):
     with gpg.Context() as c:
@@ -53,6 +55,7 @@ def sign_and_verify(source, signed, sink):
     sink.seek(0, os.SEEK_SET)
     assert sink.read() == b"Hallo Leute\n"
 
+
 # Demonstrate automatic wrapping of file-like objects with 'fileno'
 # method.
 with tempfile.TemporaryFile() as source, \
@@ -73,7 +76,7 @@ if sys.version_info[0] == 3:
     bio.truncate(1)
     if len(bio.getvalue()) != 1:
         # This version of Python is affected, preallocate buffer.
-        preallocate = 128*b'\x00'
+        preallocate = 128 * b'\x00'
     else:
         preallocate = b''
 
index 44dc360..8d8a699 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
 
+del absolute_import, print_function, unicode_literals
+
+
 def check_result(result, fpr, secret):
     assert result.considered == 1 or (secret and result.considered == 3)
     assert result.no_user_id == 0
-    assert not ((secret and result.imported != 0)
-                or (not secret and (result.imported != 0
-                                    and result.imported != 1)))
+    assert not ((secret and result.imported != 0) or
+                (not secret and
+                 (result.imported != 0 and result.imported != 1)))
     assert result.imported_rsa == 0
-    assert not ((secret and (result.unchanged != 0 and result.unchanged != 1))
-                or (not secret and ((result.imported == 0
-                                     and result.unchanged != 1)
-                                 or (result.imported == 1
-                                     and result.unchanged != 0))))
+    assert not ((secret and
+                 (result.unchanged != 0 and result.unchanged != 1)) or
+                (not secret and
+                 ((result.imported == 0 and result.unchanged != 1) or
+                  (result.imported == 1 and result.unchanged != 0))))
     assert result.new_user_ids == 0
     assert result.new_sub_keys == 0
-    assert not ((secret
-                 and ((result.secret_imported == 0
-                       and result.new_signatures != 0)
-                      or (result.secret_imported == 1
-                          and result.new_signatures > 1)))
-                or (not secret and result.new_signatures != 0))
+    assert not ((secret and (
+        (result.secret_imported == 0 and result.new_signatures != 0) or
+        (result.secret_imported == 1 and result.new_signatures > 1))) or
+                (not secret and result.new_signatures != 0))
     assert result.new_revocations == 0
-    assert not ((secret and result.secret_read != 1 and result.secret_read != 3)
-                or (not secret and result.secret_read != 0))
-    assert not ((secret and result.secret_imported != 0
-                 and result.secret_imported != 1
-                 and result.secret_imported != 2)
-                or (not secret and result.secret_imported != 0))
-    assert not ((secret
-                 and ((result.secret_imported == 0
-                       and result.secret_unchanged != 1
-                       and result.secret_unchanged != 2)
-                      or (result.secret_imported == 1
-                          and result.secret_unchanged != 0)))
-                or (not secret and result.secret_unchanged != 0))
+    assert not (
+        (secret and result.secret_read != 1 and result.secret_read != 3) or
+        (not secret and result.secret_read != 0))
+    assert not (
+        (secret and result.secret_imported != 0 and result.
+            secret_imported != 1 and result.
+            secret_imported != 2) or (not secret and result.
+                                      secret_imported != 0))
+    assert not ((secret and
+                 ((result.secret_imported == 0 and result.
+                   secret_unchanged != 1 and result.
+                   secret_unchanged != 2) or (result.
+                                              secret_imported == 1 and result.
+                                              secret_unchanged != 0))) or
+                (not secret and result.secret_unchanged != 0))
     assert result.not_imported == 0
     if secret:
         assert not (len(result.imports) in (0, 3))
@@ -67,6 +69,7 @@ def check_result(result, fpr, secret):
     assert len(result.imports) == 1 or fpr == result.imports[1].fpr
     assert result.imports[0].result == 0
 
+
 c = gpg.Context()
 
 result = c.key_import(open(support.make_filename("pubkey-1.asc"), 'rb').read())
index 6503eb7..f82ca84 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
 
+del absolute_import, print_function, unicode_literals
+
 support.assert_gpg_version((2, 1, 14))
 
+
 # Check expration of keys.  This test assumes three subkeys of which
 # 2 are expired; it is used with the "Whisky" test key.  It has
 # already been checked that these 3 subkeys are available.
 def check_whisky(name, key):
-  sub1 = key.subkeys[2]
-  sub2 = key.subkeys[3]
+    sub1 = key.subkeys[2]
+    sub2 = key.subkeys[3]
+
+    assert sub1.expired and sub2.expired, \
+        "Subkey of `{}' not flagged as expired".format(name)
+    assert sub1.expires == 1129636886 and sub2.expires == 1129636939, \
+        "Subkey of `{}' has wrong expiration date".format(name)
 
-  assert sub1.expired and sub2.expired, \
-      "Subkey of `{}' not flagged as expired".format(name)
-  assert sub1.expires == 1129636886 and sub2.expires == 1129636939, \
-      "Subkey of `{}' has wrong expiration date".format(name)
 
 keys = [
-    [ "A0FF4590BB6122EDEF6E3C542D727CC768697734", "6AE6D7EE46A871F8",
-      [ [ "Alfa Test", "demo key", "alfa@example.net" ],
-        [ "Alpha Test", "demo key", "alpha@example.net" ],
-       [ "Alice", "demo key", "" ] ], 1 ],
-    [ "D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2", "5381EA4EE29BA37F",
-      [ [ "Bob", "demo key", "" ],
-       [ "Bravo Test", "demo key", "bravo@example.net" ] ], 1 ],
-    [ "61EE841A2A27EB983B3B3C26413F4AF31AFDAB6C", "E71E72ACBC43DA60",
-      [ [ "Charlie Test", "demo key", "charlie@example.net" ] ], 1 ],
-    [ "6560C59C43D031C54D7C588EEBA9F240EB9DC9E6", "06F22880B0C45424",
-      [ [ "Delta Test", "demo key", "delta@example.net" ] ], 1 ],
-    [ "3531152DE293E26A07F504BC318C1FAEFAEF6D1B", "B5C79E1A7272144D",
-      [ [ "Echelon", "demo key", "" ],
-       [ "Echo Test", "demo key", "echo@example.net" ],
-       [ "Eve", "demo key", "" ] ], 1 ],
-    [ "56D33268F7FE693FBB594762D4BF57F37372E243", "0A32EE79EE45198E",
-      [ [ "Foxtrot Test", "demo key", "foxtrot@example.net" ] ], 1 ],
-    [ "C9C07DCC6621B9FB8D071B1D168410A48FC282E6", "247491CC9DCAD354",
-      [ [ "Golf Test", "demo key", "golf@example.net" ] ], 1 ],
-    [ "9E91CBB11E4D4135583EF90513DB965534C6E3F1", "76E26537D622AD0A",
-      [ [ "Hotel Test", "demo key", "hotel@example.net" ] ], 1 ],
-    [ "CD538D6CC9FB3D745ECDA5201FE8FC6F04259677", "C1C8EFDE61F76C73",
-      [ [ "India Test", "demo key", "india@example.net" ] ], 1 ],
-    [ "F8F1EDC73995AB739AD54B380C820C71D2699313", "BD0B108735F8F136",
-      [ [ "Juliet Test", "demo key", "juliet@example.net" ] ], 1 ],
-    [ "3FD11083779196C2ECDD9594AD1B0FAD43C2D0C7", "86CBB34A9AF64D02",
-      [ [ "Kilo Test", "demo key", "kilo@example.net" ] ], 1 ],
-    [ "1DDD28CEF714F5B03B8C246937CAB51FB79103F8", "0363B449FE56350C",
-      [ [ "Lima Test", "demo key", "lima@example.net" ] ], 1 ],
-    [ "2686AA191A278013992C72EBBE794852BE5CF886", "5F600A834F31EAE8",
-      [ [ "Mallory", "demo key", "" ],
-       [ "Mike Test", "demo key", "mike@example.net" ] ], 1 ],
-    [ "5AB9D6D7BAA1C95B3BAA3D9425B00FD430CEC684", "4C1D63308B70E472",
-      [ [ "November Test", "demo key", "november@example.net" ] ], 1 ],
-    [ "43929E89F8F79381678CAE515F6356BA6D9732AC", "FF0785712681619F",
-      [ [ "Oscar Test", "demo key", "oscar@example.net" ] ], 1 ],
-    [ "6FAA9C201E5E26DCBAEC39FD5D15E01D3FF13206", "2764E18263330D9C",
-      [ [ "Papa test", "demo key", "papa@example.net" ] ], 1 ],
-    [ "A7969DA1C3297AA96D49843F1C67EC133C661C84", "6CDCFC44A029ACF4",
-      [ [ "Quebec Test", "demo key", "quebec@example.net" ] ], 1 ],
-    [ "38FBE1E4BF6A5E1242C8F6A13BDBEDB1777FBED3", "9FAB805A11D102EA",
-      [ [ "Romeo Test", "demo key", "romeo@example.net" ] ], 1 ],
-    [ "045B2334ADD69FC221076841A5E67F7FA3AE3EA1", "93B88B0F0F1B50B4",
-      [ [ "Sierra Test", "demo key", "sierra@example.net" ] ], 1 ],
-    [ "ECAC774F4EEEB0620767044A58CB9A4C85A81F38", "97B60E01101C0402",
-      [ [ "Tango Test", "demo key", "tango@example.net" ] ], 1 ],
-    [ "0DBCAD3F08843B9557C6C4D4A94C0F75653244D6", "93079B915522BDB9",
-      [ [ "Uniform Test", "demo key", "uniform@example.net" ] ], 1 ],
-    [ "E8143C489C8D41124DC40D0B47AF4B6961F04784", "04071FB807287134",
-      [ [ "Victor Test", "demo key", "victor@example.org" ] ], 1 ],
-    [ "E8D6C90B683B0982BD557A99DEF0F7B8EC67DBDE", "D7FBB421FD6E27F6",
-      [ [ "Whisky Test", "demo key", "whisky@example.net" ] ], 3,
-      check_whisky ],
-    [ "04C1DF62EFA0EBB00519B06A8979A6C5567FB34A", "5CC6F87F41E408BE",
-      [ [ "XRay Test", "demo key", "xray@example.net" ] ], 1 ],
-    [ "ED9B316F78644A58D042655A9EEF34CD4B11B25F", "5ADFD255F7B080AD",
-      [ [ "Yankee Test", "demo key", "yankee@example.net" ] ], 1 ],
-    [ "23FD347A419429BACCD5E72D6BC4778054ACD246", "EF9DC276A172C881",
-      [ [ "Zulu Test", "demo key", "zulu@example.net" ] ], 1 ],
+    [
+        "A0FF4590BB6122EDEF6E3C542D727CC768697734", "6AE6D7EE46A871F8",
+        [["Alfa Test", "demo key", "alfa@example.net"],
+         ["Alpha Test", "demo key", "alpha@example.net"],
+         ["Alice", "demo key", ""]], 1
+    ],
+    [
+        "D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2", "5381EA4EE29BA37F",
+        [["Bob", "demo key", ""],
+         ["Bravo Test", "demo key", "bravo@example.net"]], 1
+    ],
+    [
+        "61EE841A2A27EB983B3B3C26413F4AF31AFDAB6C", "E71E72ACBC43DA60",
+        [["Charlie Test", "demo key", "charlie@example.net"]], 1
+    ],
+    [
+        "6560C59C43D031C54D7C588EEBA9F240EB9DC9E6", "06F22880B0C45424",
+        [["Delta Test", "demo key", "delta@example.net"]], 1
+    ],
+    [
+        "3531152DE293E26A07F504BC318C1FAEFAEF6D1B", "B5C79E1A7272144D",
+        [["Echelon", "demo key",
+          ""], ["Echo Test", "demo key", "echo@example.net"],
+         ["Eve", "demo key", ""]], 1
+    ],
+    [
+        "56D33268F7FE693FBB594762D4BF57F37372E243", "0A32EE79EE45198E",
+        [["Foxtrot Test", "demo key", "foxtrot@example.net"]], 1
+    ],
+    [
+        "C9C07DCC6621B9FB8D071B1D168410A48FC282E6", "247491CC9DCAD354",
+        [["Golf Test", "demo key", "golf@example.net"]], 1
+    ],
+    [
+        "9E91CBB11E4D4135583EF90513DB965534C6E3F1", "76E26537D622AD0A",
+        [["Hotel Test", "demo key", "hotel@example.net"]], 1
+    ],
+    [
+        "CD538D6CC9FB3D745ECDA5201FE8FC6F04259677", "C1C8EFDE61F76C73",
+        [["India Test", "demo key", "india@example.net"]], 1
+    ],
+    [
+        "F8F1EDC73995AB739AD54B380C820C71D2699313", "BD0B108735F8F136",
+        [["Juliet Test", "demo key", "juliet@example.net"]], 1
+    ],
+    [
+        "3FD11083779196C2ECDD9594AD1B0FAD43C2D0C7", "86CBB34A9AF64D02",
+        [["Kilo Test", "demo key", "kilo@example.net"]], 1
+    ],
+    [
+        "1DDD28CEF714F5B03B8C246937CAB51FB79103F8", "0363B449FE56350C",
+        [["Lima Test", "demo key", "lima@example.net"]], 1
+    ],
+    [
+        "2686AA191A278013992C72EBBE794852BE5CF886", "5F600A834F31EAE8",
+        [["Mallory", "demo key", ""],
+         ["Mike Test", "demo key", "mike@example.net"]], 1
+    ],
+    [
+        "5AB9D6D7BAA1C95B3BAA3D9425B00FD430CEC684", "4C1D63308B70E472",
+        [["November Test", "demo key", "november@example.net"]], 1
+    ],
+    [
+        "43929E89F8F79381678CAE515F6356BA6D9732AC", "FF0785712681619F",
+        [["Oscar Test", "demo key", "oscar@example.net"]], 1
+    ],
+    [
+        "6FAA9C201E5E26DCBAEC39FD5D15E01D3FF13206", "2764E18263330D9C",
+        [["Papa test", "demo key", "papa@example.net"]], 1
+    ],
+    [
+        "A7969DA1C3297AA96D49843F1C67EC133C661C84", "6CDCFC44A029ACF4",
+        [["Quebec Test", "demo key", "quebec@example.net"]], 1
+    ],
+    [
+        "38FBE1E4BF6A5E1242C8F6A13BDBEDB1777FBED3", "9FAB805A11D102EA",
+        [["Romeo Test", "demo key", "romeo@example.net"]], 1
+    ],
+    [
+        "045B2334ADD69FC221076841A5E67F7FA3AE3EA1", "93B88B0F0F1B50B4",
+        [["Sierra Test", "demo key", "sierra@example.net"]], 1
+    ],
+    [
+        "ECAC774F4EEEB0620767044A58CB9A4C85A81F38", "97B60E01101C0402",
+        [["Tango Test", "demo key", "tango@example.net"]], 1
+    ],
+    [
+        "0DBCAD3F08843B9557C6C4D4A94C0F75653244D6", "93079B915522BDB9",
+        [["Uniform Test", "demo key", "uniform@example.net"]], 1
+    ],
+    [
+        "E8143C489C8D41124DC40D0B47AF4B6961F04784", "04071FB807287134",
+        [["Victor Test", "demo key", "victor@example.org"]], 1
+    ],
+    [
+        "E8D6C90B683B0982BD557A99DEF0F7B8EC67DBDE", "D7FBB421FD6E27F6",
+        [["Whisky Test", "demo key", "whisky@example.net"]], 3, check_whisky
+    ],
+    [
+        "04C1DF62EFA0EBB00519B06A8979A6C5567FB34A", "5CC6F87F41E408BE",
+        [["XRay Test", "demo key", "xray@example.net"]], 1
+    ],
+    [
+        "ED9B316F78644A58D042655A9EEF34CD4B11B25F", "5ADFD255F7B080AD",
+        [["Yankee Test", "demo key", "yankee@example.net"]], 1
+    ],
+    [
+        "23FD347A419429BACCD5E72D6BC4778054ACD246", "EF9DC276A172C881",
+        [["Zulu Test", "demo key", "zulu@example.net"]], 1
+    ],
 ]
 
+
 def check_global(key, uids, n_subkeys):
     assert not key.revoked, "Key unexpectedly revoked"
     assert not key.expired, "Key unexpectedly expired"
@@ -107,18 +162,18 @@ def check_global(key, uids, n_subkeys):
     assert key.can_sign, "Key unexpectedly unusable for signing"
     assert key.can_certify, "Key unexpectedly unusable for certifications"
     assert not key.secret, "Key unexpectedly secret"
-    assert not key.protocol != gpg.constants.protocol.OpenPGP, \
-        "Key has unexpected protocol: {}".format(key.protocol)
-    assert not key.issuer_serial, \
-        "Key unexpectedly carries issuer serial: {}".format(key.issuer_serial)
-    assert not key.issuer_name, \
-        "Key unexpectedly carries issuer name: {}".format(key.issuer_name)
-    assert not key.chain_id, \
-        "Key unexpectedly carries chain ID: {}".format(key.chain_id)
-    assert key.owner_trust == gpg.constants.validity.UNKNOWN, \
-        "Key has unexpected owner trust: {}".format(key.owner_trust)
-    assert len(key.subkeys) - 1 == n_subkeys, \
-        "Key `{}' has unexpected number of subkeys".format(uids[0][0])
+    assert not key.protocol != gpg.constants.protocol.
+    OpenPGP, "Key has unexpected protocol: {}".format(key.protocol)
+    assert not key.issuer_serial,
+    "Key unexpectedly carries issuer serial: {}".format(key.issuer_serial)
+    assert not key.issuer_name,
+    "Key unexpectedly carries issuer name: {}".format(key.issuer_name)
+    assert not key.chain_id,
+    "Key unexpectedly carries chain ID: {}".format(key.chain_id)
+    assert key.owner_trust == gpg.constants.validity.UNKNOWN,
+    "Key has unexpected owner trust: {}".format(key.owner_trust)
+    assert len(key.subkeys) - 1 == n_subkeys,
+    "Key `{}' has unexpected number of subkeys".format(uids[0][0])
 
 
 def check_subkey(fpr, which, subkey):
@@ -128,54 +183,55 @@ def check_subkey(fpr, which, subkey):
     assert not subkey.invalid, which + " key unexpectedly invalid"
 
     if which == "Primary":
-        assert not subkey.can_encrypt, \
-            which + " key unexpectedly usable for encryption"
-        assert subkey.can_sign, \
-            which + " key unexpectedly unusable for signing"
-        assert subkey.can_certify, \
-            which + " key unexpectedly unusable for certifications"
+        assert not subkey.can_encrypt,
+        which + " key unexpectedly usable for encryption"
+        assert subkey.can_sign,
+        which + " key unexpectedly unusable for signing"
+        assert subkey.can_certify,
+        which + " key unexpectedly unusable for certifications"
     else:
-        assert subkey.can_encrypt, \
-            which + " key unexpectedly unusable for encryption"
-        assert not subkey.can_sign, \
-            which + " key unexpectedly usable for signing"
-        assert not subkey.can_certify, \
-            which + " key unexpectedly usable for certifications"
+        assert subkey.can_encrypt,
+        which + " key unexpectedly unusable for encryption"
+        assert not subkey.can_sign,
+        which + " key unexpectedly usable for signing"
+        assert not subkey.can_certify,
+        which + " key unexpectedly usable for certifications"
 
     assert not subkey.secret, which + " key unexpectedly secret"
     assert not subkey.is_cardkey, "Public key marked as card key"
     assert not subkey.card_number, "Public key with card number set"
-    assert not subkey.pubkey_algo != (gpg.constants.pk.DSA if which == "Primary"
-                                      else gpg.constants.pk.ELG_E), \
-        which + " key has unexpected public key algo: {}".\
-            format(subkey.pubkey_algo)
-    assert subkey.length == 1024, \
-        which + " key has unexpected length: {}".format(subkey.length)
-    assert fpr.endswith(subkey.keyid), \
-        which + " key has unexpected key ID: {}".format(subkey.keyid)
-    assert which == "Secondary" or subkey.fpr == fpr, \
-        which + " key has unexpected fingerprint: {}".format(subkey.fpr)
-    assert not subkey.expires, \
-        which + " key unexpectedly expires: {}".format(subkey.expires)
+    assert not subkey.pubkey_algo !=
+    (gpg.constants.pk.DSA if which == "Primary" else gpg.constants.pk.ELG_E),
+    which + " key has unexpected public key algo: {}".format(subkey.
+                                                             pubkey_algo)
+    assert subkey.length == 1024,
+    which + " key has unexpected length: {}".format(subkey.length)
+    assert fpr.endswith(subkey.keyid),
+    which + " key has unexpected key ID: {}".format(subkey.keyid)
+    assert which == "Secondary" or subkey.fpr == fpr,
+    which + " key has unexpected fingerprint: {}".format(subkey.fpr)
+    assert not subkey.expires,
+    which + " key unexpectedly expires: {}".format(subkey.expires)
+
 
 def check_uid(which, ref, uid):
     assert not uid.revoked, which + " user ID unexpectedly revoked"
     assert not uid.invalid, which + " user ID unexpectedly invalid"
-    assert uid.validity == gpg.constants.validity.UNKNOWN, \
-      which + " user ID has unexpected validity: {}".format(uid.validity)
+    assert uid.validity == gpg.constants.validity.UNKNOWN,
+    which + " user ID has unexpected validity: {}".format(uid.validity)
     assert not uid.signatures, which + " user ID unexpectedly signed"
-    assert uid.name == ref[0], \
-      "Unexpected name in {} user ID: {!r}".format(which.lower(), uid.name)
-    assert uid.comment == ref[1], \
-      "Unexpected comment in {} user ID: {!r}".format(which.lower(),
-                                                      uid.comment)
-    assert uid.email == ref[2], \
-      "Unexpected email in {} user ID: {!r}".format(which.lower(), uid.email)
+    assert uid.name == ref[0],
+    "Unexpected name in {} user ID: {!r}".format(which.lower(), uid.name)
+    assert uid.comment == ref[1],
+    "Unexpected comment in {} user ID: {!r}".format(which.lower(), uid.comment)
+    assert uid.email == ref[2],
+    "Unexpected email in {} user ID: {!r}".format(which.lower(), uid.email)
+
 
 # Export all the data from our keyring...
 key_data = gpg.Data()
 with gpg.Context() as c:
-  c.op_export_keys([c.get_key(k[0]) for k in keys], 0, key_data)
+    c.op_export_keys([c.get_key(k[0]) for k in keys], 0, key_data)
 
 # ... rewind the tape...
 key_data.rewind()
@@ -201,11 +257,11 @@ with support.EphemeralContext() as c:
         assert len(key.uids) == len(uids)
         check_uid("First", uids[0], key.uids[0])
         if len(key.uids) > 1:
-          check_uid("Second", uids[1], key.uids[1])
+            check_uid("Second", uids[1], key.uids[1])
         if len(key.uids) > 2:
-          check_uid("Third", uids[2], key.uids[2])
+            check_uid("Third", uids[2], key.uids[2])
 
         if misc_check:
-            misc_check (uids[0][0], key)
+            misc_check(uids[0][0], key)
 
     assert len(list(c.keylist())) == 0, "Keys were imported"
index 4505d3c..b725fc3 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
 
+del absolute_import, print_function, unicode_literals
+
 c = gpg.Context()
 
+
 # Check expration of keys.  This test assumes three subkeys of which
 # 2 are expired; it is used with the "Whisky" test key.  It has
 # already been checked that these 3 subkeys are available.
 def check_whisky(name, key):
-  sub1 = key.subkeys[2]
-  sub2 = key.subkeys[3]
+    sub1 = key.subkeys[2]
+    sub2 = key.subkeys[3]
+
+    assert sub1.expired and sub2.expired, \
+        "Subkey of `{}' not flagged as expired".format(name)
+    assert sub1.expires == 1129636886 and sub2.expires == 1129636939, \
+        "Subkey of `{}' has wrong expiration date".format(name)
 
-  assert sub1.expired and sub2.expired, \
-      "Subkey of `{}' not flagged as expired".format(name)
-  assert sub1.expires == 1129636886 and sub2.expires == 1129636939, \
-      "Subkey of `{}' has wrong expiration date".format(name)
 
 keys = [
-    [ "A0FF4590BB6122EDEF6E3C542D727CC768697734", "6AE6D7EE46A871F8",
-      [ [ "Alfa Test", "demo key", "alfa@example.net" ],
-        [ "Alpha Test", "demo key", "alpha@example.net" ],
-       [ "Alice", "demo key", "" ] ], 1 ],
-    [ "D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2", "5381EA4EE29BA37F",
-      [ [ "Bob", "demo key", "" ],
-       [ "Bravo Test", "demo key", "bravo@example.net" ] ], 1 ],
-    [ "61EE841A2A27EB983B3B3C26413F4AF31AFDAB6C", "E71E72ACBC43DA60",
-      [ [ "Charlie Test", "demo key", "charlie@example.net" ] ], 1 ],
-    [ "6560C59C43D031C54D7C588EEBA9F240EB9DC9E6", "06F22880B0C45424",
-      [ [ "Delta Test", "demo key", "delta@example.net" ] ], 1 ],
-    [ "3531152DE293E26A07F504BC318C1FAEFAEF6D1B", "B5C79E1A7272144D",
-      [ [ "Echelon", "demo key", "" ],
-       [ "Echo Test", "demo key", "echo@example.net" ],
-       [ "Eve", "demo key", "" ] ], 1 ],
-    [ "56D33268F7FE693FBB594762D4BF57F37372E243", "0A32EE79EE45198E",
-      [ [ "Foxtrot Test", "demo key", "foxtrot@example.net" ] ], 1 ],
-    [ "C9C07DCC6621B9FB8D071B1D168410A48FC282E6", "247491CC9DCAD354",
-      [ [ "Golf Test", "demo key", "golf@example.net" ] ], 1 ],
-    [ "9E91CBB11E4D4135583EF90513DB965534C6E3F1", "76E26537D622AD0A",
-      [ [ "Hotel Test", "demo key", "hotel@example.net" ] ], 1 ],
-    [ "CD538D6CC9FB3D745ECDA5201FE8FC6F04259677", "C1C8EFDE61F76C73",
-      [ [ "India Test", "demo key", "india@example.net" ] ], 1 ],
-    [ "F8F1EDC73995AB739AD54B380C820C71D2699313", "BD0B108735F8F136",
-      [ [ "Juliet Test", "demo key", "juliet@example.net" ] ], 1 ],
-    [ "3FD11083779196C2ECDD9594AD1B0FAD43C2D0C7", "86CBB34A9AF64D02",
-      [ [ "Kilo Test", "demo key", "kilo@example.net" ] ], 1 ],
-    [ "1DDD28CEF714F5B03B8C246937CAB51FB79103F8", "0363B449FE56350C",
-      [ [ "Lima Test", "demo key", "lima@example.net" ] ], 1 ],
-    [ "2686AA191A278013992C72EBBE794852BE5CF886", "5F600A834F31EAE8",
-      [ [ "Mallory", "demo key", "" ],
-       [ "Mike Test", "demo key", "mike@example.net" ] ], 1 ],
-    [ "5AB9D6D7BAA1C95B3BAA3D9425B00FD430CEC684", "4C1D63308B70E472",
-      [ [ "November Test", "demo key", "november@example.net" ] ], 1 ],
-    [ "43929E89F8F79381678CAE515F6356BA6D9732AC", "FF0785712681619F",
-      [ [ "Oscar Test", "demo key", "oscar@example.net" ] ], 1 ],
-    [ "6FAA9C201E5E26DCBAEC39FD5D15E01D3FF13206", "2764E18263330D9C",
-      [ [ "Papa test", "demo key", "papa@example.net" ] ], 1 ],
-    [ "A7969DA1C3297AA96D49843F1C67EC133C661C84", "6CDCFC44A029ACF4",
-      [ [ "Quebec Test", "demo key", "quebec@example.net" ] ], 1 ],
-    [ "38FBE1E4BF6A5E1242C8F6A13BDBEDB1777FBED3", "9FAB805A11D102EA",
-      [ [ "Romeo Test", "demo key", "romeo@example.net" ] ], 1 ],
-    [ "045B2334ADD69FC221076841A5E67F7FA3AE3EA1", "93B88B0F0F1B50B4",
-      [ [ "Sierra Test", "demo key", "sierra@example.net" ] ], 1 ],
-    [ "ECAC774F4EEEB0620767044A58CB9A4C85A81F38", "97B60E01101C0402",
-      [ [ "Tango Test", "demo key", "tango@example.net" ] ], 1 ],
-    [ "0DBCAD3F08843B9557C6C4D4A94C0F75653244D6", "93079B915522BDB9",
-      [ [ "Uniform Test", "demo key", "uniform@example.net" ] ], 1 ],
-    [ "E8143C489C8D41124DC40D0B47AF4B6961F04784", "04071FB807287134",
-      [ [ "Victor Test", "demo key", "victor@example.org" ] ], 1 ],
-    [ "E8D6C90B683B0982BD557A99DEF0F7B8EC67DBDE", "D7FBB421FD6E27F6",
-      [ [ "Whisky Test", "demo key", "whisky@example.net" ] ], 3,
-      check_whisky ],
-    [ "04C1DF62EFA0EBB00519B06A8979A6C5567FB34A", "5CC6F87F41E408BE",
-      [ [ "XRay Test", "demo key", "xray@example.net" ] ], 1 ],
-    [ "ED9B316F78644A58D042655A9EEF34CD4B11B25F", "5ADFD255F7B080AD",
-      [ [ "Yankee Test", "demo key", "yankee@example.net" ] ], 1 ],
-    [ "23FD347A419429BACCD5E72D6BC4778054ACD246", "EF9DC276A172C881",
-      [ [ "Zulu Test", "demo key", "zulu@example.net" ] ], 1 ],
+    [
+        "A0FF4590BB6122EDEF6E3C542D727CC768697734", "6AE6D7EE46A871F8",
+        [["Alfa Test", "demo key",
+          "alfa@example.net"], ["Alpha Test", "demo key", "alpha@example.net"],
+         ["Alice", "demo key", ""]], 1
+    ],
+    [
+        "D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2", "5381EA4EE29BA37F",
+        [["Bob", "demo key", ""],
+         ["Bravo Test", "demo key", "bravo@example.net"]], 1
+    ],
+    [
+        "61EE841A2A27EB983B3B3C26413F4AF31AFDAB6C", "E71E72ACBC43DA60",
+        [["Charlie Test", "demo key", "charlie@example.net"]], 1
+    ],
+    [
+        "6560C59C43D031C54D7C588EEBA9F240EB9DC9E6", "06F22880B0C45424",
+        [["Delta Test", "demo key", "delta@example.net"]], 1
+    ],
+    [
+        "3531152DE293E26A07F504BC318C1FAEFAEF6D1B", "B5C79E1A7272144D",
+        [["Echelon", "demo key",
+          ""], ["Echo Test", "demo key", "echo@example.net"],
+         ["Eve", "demo key", ""]], 1
+    ],
+    [
+        "56D33268F7FE693FBB594762D4BF57F37372E243", "0A32EE79EE45198E",
+        [["Foxtrot Test", "demo key", "foxtrot@example.net"]], 1
+    ],
+    [
+        "C9C07DCC6621B9FB8D071B1D168410A48FC282E6", "247491CC9DCAD354",
+        [["Golf Test", "demo key", "golf@example.net"]], 1
+    ],
+    [
+        "9E91CBB11E4D4135583EF90513DB965534C6E3F1", "76E26537D622AD0A",
+        [["Hotel Test", "demo key", "hotel@example.net"]], 1
+    ],
+    [
+        "CD538D6CC9FB3D745ECDA5201FE8FC6F04259677", "C1C8EFDE61F76C73",
+        [["India Test", "demo key", "india@example.net"]], 1
+    ],
+    [
+        "F8F1EDC73995AB739AD54B380C820C71D2699313", "BD0B108735F8F136",
+        [["Juliet Test", "demo key", "juliet@example.net"]], 1
+    ],
+    [
+        "3FD11083779196C2ECDD9594AD1B0FAD43C2D0C7", "86CBB34A9AF64D02",
+        [["Kilo Test", "demo key", "kilo@example.net"]], 1
+    ],
+    [
+        "1DDD28CEF714F5B03B8C246937CAB51FB79103F8", "0363B449FE56350C",
+        [["Lima Test", "demo key", "lima@example.net"]], 1
+    ],
+    [
+        "2686AA191A278013992C72EBBE794852BE5CF886", "5F600A834F31EAE8",
+        [["Mallory", "demo key", ""],
+         ["Mike Test", "demo key", "mike@example.net"]], 1
+    ],
+    [
+        "5AB9D6D7BAA1C95B3BAA3D9425B00FD430CEC684", "4C1D63308B70E472",
+        [["November Test", "demo key", "november@example.net"]], 1
+    ],
+    [
+        "43929E89F8F79381678CAE515F6356BA6D9732AC", "FF0785712681619F",
+        [["Oscar Test", "demo key", "oscar@example.net"]], 1
+    ],
+    [
+        "6FAA9C201E5E26DCBAEC39FD5D15E01D3FF13206", "2764E18263330D9C",
+        [["Papa test", "demo key", "papa@example.net"]], 1
+    ],
+    [
+        "A7969DA1C3297AA96D49843F1C67EC133C661C84", "6CDCFC44A029ACF4",
+        [["Quebec Test", "demo key", "quebec@example.net"]], 1
+    ],
+    [
+        "38FBE1E4BF6A5E1242C8F6A13BDBEDB1777FBED3", "9FAB805A11D102EA",
+        [["Romeo Test", "demo key", "romeo@example.net"]], 1
+    ],
+    [
+        "045B2334ADD69FC221076841A5E67F7FA3AE3EA1", "93B88B0F0F1B50B4",
+        [["Sierra Test", "demo key", "sierra@example.net"]], 1
+    ],
+    [
+        "ECAC774F4EEEB0620767044A58CB9A4C85A81F38", "97B60E01101C0402",
+        [["Tango Test", "demo key", "tango@example.net"]], 1
+    ],
+    [
+        "0DBCAD3F08843B9557C6C4D4A94C0F75653244D6", "93079B915522BDB9",
+        [["Uniform Test", "demo key", "uniform@example.net"]], 1
+    ],
+    [
+        "E8143C489C8D41124DC40D0B47AF4B6961F04784", "04071FB807287134",
+        [["Victor Test", "demo key", "victor@example.org"]], 1
+    ],
+    [
+        "E8D6C90B683B0982BD557A99DEF0F7B8EC67DBDE", "D7FBB421FD6E27F6",
+        [["Whisky Test", "demo key", "whisky@example.net"]], 3, check_whisky
+    ],
+    [
+        "04C1DF62EFA0EBB00519B06A8979A6C5567FB34A", "5CC6F87F41E408BE",
+        [["XRay Test", "demo key", "xray@example.net"]], 1
+    ],
+    [
+        "ED9B316F78644A58D042655A9EEF34CD4B11B25F", "5ADFD255F7B080AD",
+        [["Yankee Test", "demo key", "yankee@example.net"]], 1
+    ],
+    [
+        "23FD347A419429BACCD5E72D6BC4778054ACD246", "EF9DC276A172C881",
+        [["Zulu Test", "demo key", "zulu@example.net"]], 1
+    ],
 ]
 
+
 def check_global(key, uids, n_subkeys):
     assert not key.revoked, "Key unexpectedly revoked"
     assert not key.expired, "Key unexpectedly expired"
@@ -107,25 +162,25 @@ def check_global(key, uids, n_subkeys):
     assert key.can_sign, "Key unexpectedly unusable for signing"
     assert key.can_certify, "Key unexpectedly unusable for certifications"
     assert not key.secret, "Key unexpectedly secret"
-    assert not key.protocol != gpg.constants.protocol.OpenPGP, \
-        "Key has unexpected protocol: {}".format(key.protocol)
-    assert not key.issuer_serial, \
-        "Key unexpectedly carries issuer serial: {}".format(key.issuer_serial)
-    assert not key.issuer_name, \
-        "Key unexpectedly carries issuer name: {}".format(key.issuer_name)
-    assert not key.chain_id, \
-        "Key unexpectedly carries chain ID: {}".format(key.chain_id)
+    assert not key.protocol != gpg.constants.protocol.OpenPGP,
+    "Key has unexpected protocol: {}".format(key.protocol)
+    assert not key.issuer_serial,
+    "Key unexpectedly carries issuer serial: {}".format(key.issuer_serial)
+    assert not key.issuer_name,
+    "Key unexpectedly carries issuer name: {}".format(key.issuer_name)
+    assert not key.chain_id,
+    "Key unexpectedly carries chain ID: {}".format(key.chain_id)
 
     # Only key Alfa is trusted
-    assert key.uids[0].name == 'Alfa Test' \
-      or key.owner_trust == gpg.constants.validity.UNKNOWN, \
-        "Key has unexpected owner trust: {}".format(key.owner_trust)
-    assert key.uids[0].name != 'Alfa Test' \
-      or key.owner_trust == gpg.constants.validity.ULTIMATE, \
-        "Key has unexpected owner trust: {}".format(key.owner_trust)
+    assert key.uids[0].name == 'Alfa Test' or
+    key.owner_trust == gpg.constants.validity.UNKNOWN,
+    "Key has unexpected owner trust: {}".format(key.owner_trust)
+    assert key.uids[0].name != 'Alfa Test' or key.owner_trust == gpg.constants.
+    validity.ULTIMATE, "Key has unexpected owner trust: {}".
+    format(key.owner_trust)
 
-    assert len(key.subkeys) - 1 == n_subkeys, \
-        "Key `{}' has unexpected number of subkeys".format(uids[0][0])
+    assert len(key.subkeys) - 1 == n_subkeys,
+    "Key `{}' has unexpected number of subkeys".format(uids[0][0])
 
 
 def check_subkey(fpr, which, subkey):
@@ -152,18 +207,19 @@ def check_subkey(fpr, which, subkey):
     assert not subkey.secret, which + " key unexpectedly secret"
     assert not subkey.is_cardkey, "Public key marked as card key"
     assert not subkey.card_number, "Public key with card number set"
-    assert not subkey.pubkey_algo != (gpg.constants.pk.DSA if which == "Primary"
-                                      else gpg.constants.pk.ELG_E), \
-        which + " key has unexpected public key algo: {}".\
-            format(subkey.pubkey_algo)
-    assert subkey.length == 1024, \
-        which + " key has unexpected length: {}".format(subkey.length)
-    assert fpr.endswith(subkey.keyid), \
-        which + " key has unexpected key ID: {}".format(subkey.keyid)
-    assert which == "Secondary" or subkey.fpr == fpr, \
-        which + " key has unexpected fingerprint: {}".format(subkey.fpr)
-    assert not subkey.expires, \
-        which + " key unexpectedly expires: {}".format(subkey.expires)
+    assert not subkey.pubkey_algo !=
+    (gpg.constants.pk.DSA if which == "Primary" else gpg.constants.pk.ELG_E),
+    which + " key has unexpected public key algo: {}".format(subkey.
+                                                             pubkey_algo)
+    assert subkey.length == 1024,
+    which + " key has unexpected length: {}".format(subkey.length)
+    assert fpr.endswith(subkey.keyid),
+    which + " key has unexpected key ID: {}".format(subkey.keyid)
+    assert which == "Secondary" or subkey.fpr == fpr,
+    which + " key has unexpected fingerprint: {}".format(subkey.fpr)
+    assert not subkey.expires,
+    which + " key unexpectedly expires: {}".format(subkey.expires)
+
 
 def check_uid(which, ref, uid):
     assert not uid.revoked, which + " user ID unexpectedly revoked"
@@ -171,20 +227,21 @@ def check_uid(which, ref, uid):
     assert uid.validity == (gpg.constants.validity.UNKNOWN
                             if uid.name.split()[0]
                             not in {'Alfa', 'Alpha', 'Alice'} else
-                            gpg.constants.validity.ULTIMATE), \
-      which + " user ID has unexpectedly validity: {}".format(uid.validity)
+                            gpg.constants.validity.ULTIMATE),
+    which + " user ID has unexpectedly validity: {}".format(uid.validity)
     assert not uid.signatures, which + " user ID unexpectedly signed"
-    assert uid.name == ref[0], \
-      "Unexpected name in {} user ID: {!r}".format(which.lower(), uid.name)
-    assert uid.comment == ref[1], \
-      "Unexpected comment in {} user ID: {!r}".format(which.lower(),
-                                                      uid.comment)
-    assert uid.email == ref[2], \
-      "Unexpected email in {} user ID: {!r}".format(which.lower(), uid.email)
+    assert uid.name == ref[0],
+    "Unexpected name in {} user ID: {!r}".format(which.lower(), uid.name)
+    assert uid.comment == ref[1],
+    "Unexpected comment in {} user ID: {!r}".format(which.lower(),
+                                                    uid.comment)
+    assert uid.email == ref[2],
+    "Unexpected email in {} user ID: {!r}".format(which.lower(), uid.email)
+
 
 i = 0
 c.op_keylist_start(None, False)
-key = c.op_keylist_next ()
+key = c.op_keylist_next()
 while key:
     try:
         if len(keys[i]) == 4:
@@ -204,20 +261,19 @@ while key:
     assert len(key.uids) == len(uids)
     check_uid("First", uids[0], key.uids[0])
     if len(key.uids) > 1:
-      check_uid("Second", uids[1], key.uids[1])
+        check_uid("Second", uids[1], key.uids[1])
     if len(key.uids) > 2:
-      check_uid("Third", uids[2], key.uids[2])
+        check_uid("Third", uids[2], key.uids[2])
 
     if misc_check:
-        misc_check (uids[0][0], key)
-    key = c.op_keylist_next ()
+        misc_check(uids[0][0], key)
+    key = c.op_keylist_next()
     i += 1
 
 c.op_keylist_end()
 result = c.op_keylist_result()
 assert not result.truncated, "Key listing unexpectedly truncated"
 
-
 # We test for a parameter-less keylist
 keyring_length = len(list(c.op_keylist_all()))
 assert keyring_length > 1,\
@@ -226,13 +282,12 @@ assert keyring_length > 1,\
 # Then we do want to call with a pattern, only
 # i.e. without giving secret=0
 alpha_keys = list(c.op_keylist_all(b"Alpha"))
-assert len(alpha_keys) == 1, "Expected only one key for 'Alpha', got %r" % len(alpha_keys)
-
+assert len(alpha_keys) == 1, "Expected only one key for 'Alpha', got %r" % len(
+    alpha_keys)
 
 # Check negative result.
 assert len(list(c.keylist("no such key in sight"))) == 0
 
-
 for i, key in enumerate(c.keylist()):
     try:
         if len(keys[i]) == 4:
@@ -252,31 +307,30 @@ for i, key in enumerate(c.keylist()):
     assert len(key.uids) == len(uids)
     check_uid("First", uids[0], key.uids[0])
     if len(key.uids) > 1:
-      check_uid("Second", uids[1], key.uids[1])
+        check_uid("Second", uids[1], key.uids[1])
     if len(key.uids) > 2:
-      check_uid("Third", uids[2], key.uids[2])
+        check_uid("Third", uids[2], key.uids[2])
 
     if misc_check:
-        misc_check (uids[0][0], key)
-
+        misc_check(uids[0][0], key)
 
 # check get_key()
 with gpg.Context() as c:
-  c.get_key(support.alpha)
-  c.get_key(support.alpha, secret=True)
-
-  c.get_key(support.bob)
-  try:
-    c.get_key(support.bob, secret=True)
-  except KeyError:
-    pass
-  else:
-    assert False, "Expected KeyError"
-
-  # Legacy error
-  try:
-    c.get_key(support.no_such_key)
-  except gpg.errors.GPGMEError:
-    pass
-  else:
-    assert False, "Expected GPGMEError"
+    c.get_key(support.alpha)
+    c.get_key(support.alpha, secret=True)
+
+    c.get_key(support.bob)
+    try:
+        c.get_key(support.bob, secret=True)
+    except KeyError:
+        pass
+    else:
+        assert False, "Expected KeyError"
+
+    # Legacy error
+    try:
+        c.get_key(support.no_such_key)
+    except gpg.errors.GPGMEError:
+        pass
+    else:
+        assert False, "Expected GPGMEError"
index 8da5035..c337c3b 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
-_ = support # to appease pyflakes.
+_ = support  # to appease pyflakes.
+
+del absolute_import, print_function, unicode_literals
 
 with gpg.Context(protocol=gpg.constants.protocol.ASSUAN) as c:
     # Do nothing.
     err = c.assuan_transact('nop')
-    assert err == None
+    assert err is None
     err = c.assuan_transact(b'NOP')
-    assert err == None
+    assert err is None
     err = c.assuan_transact(['NOP'])
-    assert err == None
+    assert err is None
 
     err = c.assuan_transact('idontexist')
     assert err.getsource() == gpg.errors.SOURCE_GPGAGENT
@@ -41,6 +42,7 @@ with gpg.Context(protocol=gpg.constants.protocol.ASSUAN) as c:
     c.assuan_transact(['GET_CONFIRMATION', 'Hello there'])
 
     data = []
+
     def data_cb(line):
         data.append(line)
 
@@ -57,6 +59,7 @@ with gpg.Context(protocol=gpg.constants.protocol.ASSUAN) as c:
     # XXX HELP sends status lines if we could use ASSUAN_CONVEY_COMMENTS.
 
     status = []
+
     def status_cb(line, args):
         status.append((line, args))
 
index 8b7372e..4720928 100755 (executable)
@@ -18,7 +18,6 @@
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import gpg
 import itertools
@@ -27,6 +26,8 @@ import time
 import support
 support.assert_gpg_version((2, 1, 2))
 
+del absolute_import, print_function, unicode_literals
+
 alpha = "Alpha <alpha@invalid.example.net>"
 
 with support.EphemeralContext() as ctx:
@@ -51,14 +52,16 @@ with support.EphemeralContext() as ctx:
     res2 = ctx.create_key(alpha, force=True)
     assert res.fpr != res2.fpr
 
-
 # From here on, we use one context, and create unique UIDs
 uid_counter = 0
+
+
 def make_uid():
     global uid_counter
     uid_counter += 1
     return "user{0}@invalid.example.org".format(uid_counter)
 
+
 with support.EphemeralContext() as ctx:
     # Check gpg.constants.create.NOEXPIRE...
     res = ctx.create_key(make_uid(), expires=False)
@@ -77,10 +80,8 @@ with support.EphemeralContext() as ctx:
         "Primary keys expiration time is off"
 
     # Check capabilities
-    for sign, encrypt, certify, authenticate in itertools.product([False, True],
-                                                                  [False, True],
-                                                                  [False, True],
-                                                                  [False, True]):
+    for sign, encrypt, certify, authenticate in itertools.
+    product([False, True], [False, True], [False, True], [False, True]):
         # Filter some out
         if not (sign or encrypt or certify or authenticate):
             # This triggers the default capabilities tested before.
@@ -89,9 +90,13 @@ with support.EphemeralContext() as ctx:
             # The primary key always certifies.
             continue
 
-        res = ctx.create_key(make_uid(), algorithm="rsa",
-                             sign=sign, encrypt=encrypt, certify=certify,
-                             authenticate=authenticate)
+        res = ctx.create_key(
+            make_uid(),
+            algorithm="rsa",
+            sign=sign,
+            encrypt=encrypt,
+            certify=certify,
+            authenticate=authenticate)
         key = ctx.get_key(res.fpr, secret=True)
         assert key.fpr == res.fpr
         assert len(key.subkeys) == 1, \
@@ -125,13 +130,16 @@ with support.EphemeralContext() as ctx:
     recipient = make_uid()
     passphrase = "streng geheim"
     res = ctx.create_key(recipient, passphrase=passphrase)
-    ciphertext, _, _ = ctx.encrypt(b"hello there", recipients=[ctx.get_key(res.fpr)])
+    ciphertext, _, _ = ctx.encrypt(
+        b"hello there", recipients=[ctx.get_key(res.fpr)])
 
     cb_called = False
+
     def cb(*args):
         global cb_called
         cb_called = True
         return passphrase
+
     ctx.pinentry_mode = gpg.constants.PINENTRY_MODE_LOOPBACK
     ctx.set_passphrase_cb(cb)
 
index 37e05b3..ade171e 100755 (executable)
@@ -18,7 +18,6 @@
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import os
 import gpg
@@ -27,6 +26,8 @@ import sys
 import support
 support.assert_gpg_version((2, 1, 14))
 
+del absolute_import, print_function, unicode_literals
+
 alpha = "Alpha <alpha@invalid.example.net>"
 bravo = "Bravo <bravo@invalid.example.net>"
 
@@ -111,9 +112,11 @@ with support.EphemeralContext() as ctx:
 
         ctx.key_tofu_policy(key, policy)
 
-        keys = list(ctx.keylist(key.uids[0].uid,
-                                mode=(gpg.constants.keylist.mode.LOCAL
-                                      |gpg.constants.keylist.mode.WITH_TOFU)))
+        keys = list(
+            ctx.keylist(
+                key.uids[0].uid,
+                mode=(gpg.constants.keylist.mode.LOCAL |
+                      gpg.constants.keylist.mode.WITH_TOFU)))
         assert len(keys) == 1
 
         if policy == gpg.constants.tofu.policy.AUTO:
index 3d648c5..6f9b8a7 100755 (executable)
@@ -18,7 +18,6 @@
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import gpg
 import itertools
@@ -27,8 +26,11 @@ import time
 import support
 support.assert_gpg_version((2, 1, 1))
 
+del absolute_import, print_function, unicode_literals
+
 with support.EphemeralContext() as ctx:
     uid_counter = 0
+
     def make_uid():
         global uid_counter
         uid_counter += 1
@@ -43,10 +45,16 @@ with support.EphemeralContext() as ctx:
         return key, uids
 
     def check_sigs(key, expected_sigs):
-        keys = list(ctx.keylist(key.fpr, mode=(gpg.constants.keylist.mode.LOCAL
-                                               |gpg.constants.keylist.mode.SIGS)))
+        keys = list(
+            ctx.keylist(
+                key.fpr,
+                mode=(gpg.constants.keylist.mode.LOCAL |
+                      gpg.constants.keylist.mode.SIGS)))
         assert len(keys) == 1
-        key_uids = {uid.uid: [s for s in uid.signatures] for uid in keys[0].uids}
+        key_uids = {
+            uid.uid: [s for s in uid.signatures]
+            for uid in keys[0].uids
+        }
         expected = list(expected_sigs)
 
         while key_uids and expected:
@@ -76,9 +84,12 @@ with support.EphemeralContext() as ctx:
         assert s.exportable
         assert s.expires == 0
 
-    check_sigs(key_b, itertools.product(uids_b, [key_b], [exportable_non_expiring]))
+    check_sigs(key_b,
+               itertools.product(uids_b, [key_b], [exportable_non_expiring]))
     ctx.key_sign(key_b)
-    check_sigs(key_b, itertools.product(uids_b, [key_b, key_a], [exportable_non_expiring]))
+    check_sigs(
+        key_b,
+        itertools.product(uids_b, [key_b, key_a], [exportable_non_expiring]))
 
     # Create a non-exportable signature, and explicitly name all uids.
     key_c, uids_c = make_key()
@@ -89,11 +100,12 @@ with support.EphemeralContext() as ctx:
         assert s.expires == 0
 
     ctx.key_sign(key_c, local=True, uids=uids_c)
-    check_sigs(key_c,
-               list(itertools.product(uids_c, [key_c],
-                                      [exportable_non_expiring]))
-               + list(itertools.product(uids_c, [key_b, key_a],
-                                        [non_exportable_non_expiring])))
+    check_sigs(
+        key_c,
+        list(itertools.product(uids_c, [key_c], [exportable_non_expiring])) +
+        list(
+            itertools.product(uids_c, [key_b, key_a],
+                              [non_exportable_non_expiring])))
 
     # Create a non-exportable, expiring signature for a single uid.
     key_d, uids_d = make_key()
@@ -106,16 +118,16 @@ with support.EphemeralContext() as ctx:
         assert abs(time.time() + expires_in - s.expires) < slack
 
     ctx.key_sign(key_d, local=True, expires_in=expires_in, uids=uids_d[0])
-    check_sigs(key_d,
-               list(itertools.product(uids_d, [key_d],
-                                      [exportable_non_expiring]))
-               + list(itertools.product(uids_d[:1], [key_c],
-                                        [non_exportable_expiring])))
+    check_sigs(
+        key_d,
+        list(itertools.product(uids_d, [key_d], [exportable_non_expiring])) +
+        list(
+            itertools.product(uids_d[:1], [key_c], [non_exportable_expiring])))
 
     # Now sign the second in the same fashion, but use a singleton list.
     ctx.key_sign(key_d, local=True, expires_in=expires_in, uids=uids_d[1:2])
-    check_sigs(key_d,
-               list(itertools.product(uids_d, [key_d],
-                                      [exportable_non_expiring]))
-               + list(itertools.product(uids_d[:2], [key_c],
-                                        [non_exportable_expiring])))
+    check_sigs(
+        key_d,
+        list(itertools.product(uids_d, [key_d], [exportable_non_expiring])) +
+        list(
+            itertools.product(uids_d[:2], [key_c], [non_exportable_expiring])))
index ad4f35c..30424c1 100755 (executable)
@@ -18,7 +18,6 @@
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import gpg
 import itertools
@@ -26,6 +25,8 @@ import time
 
 import support
 
+del absolute_import, print_function, unicode_literals
+
 alpha = "Alpha <alpha@invalid.example.net>"
 bravo = "Bravo <bravo@invalid.example.net>"
 
@@ -59,16 +60,15 @@ with support.EphemeralContext() as ctx:
         "subkeys expiration time is off"
 
     # Check capabilities
-    for sign, encrypt, authenticate in itertools.product([False, True],
-                                                         [False, True],
-                                                         [False, True]):
+    for sign, encrypt, authenticate in itertools.
+    product([False, True], [False, True], [False, True]):
         # Filter some out
         if not (sign or encrypt or authenticate):
             # This triggers the default capabilities tested before.
             continue
 
-        res = ctx.create_subkey(key, sign=sign, encrypt=encrypt,
-                                authenticate=authenticate)
+        res = ctx.create_subkey(
+            key, sign=sign, encrypt=encrypt, authenticate=authenticate)
         subkey = get_subkey(res.fpr)
         assert sign == subkey.can_sign
         assert encrypt == subkey.can_encrypt
@@ -92,18 +92,21 @@ with support.EphemeralContext() as ctx:
     # so that we have a key with just one encryption subkey.
     bravo_res = ctx.create_key(bravo, certify=True)
     bravo_key = ctx.get_key(bravo_res.fpr)
-    assert len(bravo_key.subkeys) == 1, "Expected one primary key and no subkeys"
+    assert len(
+        bravo_key.subkeys) == 1, "Expected one primary key and no subkeys"
 
     passphrase = "streng geheim"
     res = ctx.create_subkey(bravo_key, passphrase=passphrase)
-    ciphertext, _, _ = ctx.encrypt(b"hello there",
-                                   recipients=[ctx.get_key(bravo_res.fpr)])
+    ciphertext, _, _ = ctx.encrypt(
+        b"hello there", recipients=[ctx.get_key(bravo_res.fpr)])
 
     cb_called = False
+
     def cb(*args):
         global cb_called
         cb_called = True
         return passphrase
+
     ctx.pinentry_mode = gpg.constants.PINENTRY_MODE_LOOPBACK
     ctx.set_passphrase_cb(cb)
 
index bc8da2e..5960f44 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import os
 import gpg
 import support
-_ = support # to appease pyflakes.
+_ = support  # to appease pyflakes.
+
+del absolute_import, print_function, unicode_literals
 
 expected_notations = {
-    "laughing@me": ("Just Squeeze Me", gpg.constants.sig.notation.HUMAN_READABLE),
-    "preferred-email-encoding@pgp.com": ("pgpmime",
-                                         gpg.constants.sig.notation.HUMAN_READABLE
-                                         | gpg.constants.sig.notation.CRITICAL),
+    "laughing@me": ("Just Squeeze Me",
+                    gpg.constants.sig.notation.HUMAN_READABLE),
+    "preferred-email-encoding@pgp.com":
+    ("pgpmime", gpg.constants.sig.notation.HUMAN_READABLE |
+     gpg.constants.sig.notation.CRITICAL),
     None: ("http://www.gnu.org/policy/", 0),
 }
 
 # GnuPG prior to 2.1.13 did not report the critical flag correctly.
 with gpg.Context() as c:
     version = c.engine_info.version
-    have_correct_sig_data = not (version.startswith("1.")
-                                 or version.startswith("2.0.")
-                                 or version == "2.1.1"
-                                 or (version.startswith("2.1.1")
-                                     and version[5] < '3'))
+    have_correct_sig_data = not (
+        version.startswith("1.") or version.startswith("2.0.") or
+        (version.startswith("2.1.") and int(version[4:]) < 13))
+
 
 def check_result(result):
     assert len(result.signatures) == 1, "Unexpected number of signatures"
@@ -48,8 +49,8 @@ def check_result(result):
     assert len(sig.notations) == len(expected_notations)
 
     for r in sig.notations:
-        assert not 'name_len' in dir(r)
-        assert not 'value_len' in dir(r)
+        assert 'name_len' not in dir(r)
+        assert 'value_len' not in dir(r)
         assert r.name in expected_notations
         value, flags = expected_notations.pop(r.name)
 
@@ -63,6 +64,7 @@ def check_result(result):
 
     assert len(expected_notations) == 0
 
+
 source = gpg.Data("Hallo Leute\n")
 signed = gpg.Data()
 
index d375729..3ad05e8 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import os
 import gpg
 import support
 
+del absolute_import, print_function, unicode_literals
+
+
 def fail(msg):
     raise RuntimeError(msg)
 
+
 def check_result(r, typ):
     if r.invalid_signers:
         fail("Invalid signer found: {}".format(r.invalid_signers.fpr))
@@ -43,16 +46,15 @@ def check_result(r, typ):
             signature.pubkey_algo))
 
     if signature.hash_algo != gpg.constants.md.SHA1:
-        fail("Wrong hash algorithm reported: {}".format(
-            signature.hash_algo))
+        fail("Wrong hash algorithm reported: {}".format(signature.hash_algo))
 
     if signature.sig_class != 1:
-        fail("Wrong signature class reported: {}".format(
-            signature.sig_class))
+        fail("Wrong signature class reported: {}".format(signature.sig_class))
 
     if signature.fpr != "A0FF4590BB6122EDEF6E3C542D727CC768697734":
         fail("Wrong fingerprint reported: {}".format(signature.fpr))
 
+
 c = gpg.Context()
 c.set_textmode(True)
 c.set_armor(True)
index 5864ee5..119ab77 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
 
+del absolute_import, print_function, unicode_literals
+
+
 def fail(msg):
     raise RuntimeError(msg)
 
+
 def check_result(r, typ):
     if r.invalid_signers:
         fail("Invalid signer found: {}".format(r.invalid_signers.fpr))
@@ -53,6 +56,7 @@ def check_result(r, typ):
                                  "23FD347A419429BACCD5E72D6BC4778054ACD246"):
             fail("Wrong fingerprint reported: {}".format(signature.fpr))
 
+
 c = gpg.Context()
 c.set_textmode(True)
 c.set_armor(True)
index 89524bb..ffa0b96 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
-_ = support # to appease pyflakes.
+_ = support  # to appease pyflakes.
+
+del absolute_import, print_function, unicode_literals
 
 c = gpg.Context()
 
+
 def dump_item(item):
-    print("l={} k={} t={} o={} v={} u={}".format(
-        item.level, item.keyid, item.type, item.owner_trust,
-        item.validity, item.name))
+    print("l={} k={} t={} o={} v={} u={}".format(item.level, item.keyid,
+                                                 item.type, item.owner_trust,
+                                                 item.validity, item.name))
+
 
 c.op_trustlist_start("alice", 0)
 while True:
index 320dae6..70a6c1c 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import sys
 import os
 import gpg
 import support
-_ = support # to appease pyflakes.
+_ = support  # to appease pyflakes.
+
+del absolute_import, print_function, unicode_literals
 
 test_text1 = b"Just GNU it!\n"
-test_text1f= b"Just GNU it?\n"
+test_text1f = b"Just GNU it?\n"
 test_sig1 = b"""-----BEGIN PGP SIGNATURE-----
 
 iN0EABECAJ0FAjoS+i9FFIAAAAAAAwA5YmFyw7bDpMO8w58gZGFzIHdhcmVuIFVt
@@ -60,6 +61,7 @@ UqVooWlGXHwNw/xg/fVzt9VNbtjtJ/fhUqYo0/LyCGEA
 -----END PGP MESSAGE-----
 """
 
+
 def check_result(result, summary, validity, fpr, status, notation):
     assert len(result.signatures) == 1, "Unexpected number of signatures"
     sig = result.signatures[0]
@@ -76,14 +78,16 @@ def check_result(result, summary, validity, fpr, status, notation):
                     if sys.version_info[0] < 3 else
                     b"\xc3\xb6\xc3\xa4\xc3\xbc\xc3\x9f".decode() +
                     " das waren Umlaute und jetzt ein prozent%-Zeichen"),
-            "foobar.1":  "this is a notation data with 2 lines",
-            None: "http://www.gu.org/policy/",
+            "foobar.1":
+            "this is a notation data with 2 lines",
+            None:
+            "http://www.gu.org/policy/",
         }
         assert len(sig.notations) == len(expected_notations)
 
         for r in sig.notations:
-            assert not 'name_len' in dir(r)
-            assert not 'value_len' in dir(r)
+            assert 'name_len' not in dir(r)
+            assert 'value_len' not in dir(r)
             assert r.name in expected_notations
             assert r.value == expected_notations[r.name], \
                 "Expected {!r}, got {!r}".format(expected_notations[r.name],
@@ -96,7 +100,9 @@ def check_result(result, summary, validity, fpr, status, notation):
     assert sig.validity == validity, \
         "Unexpected signature validity: {}, want: {}".format(
             sig.validity, validity)
-    assert gpg.errors.GPGMEError(sig.validity_reason).getcode() == gpg.errors.NO_ERROR
+    assert gpg.errors.GPGMEError(
+        sig.validity_reason).getcode() == gpg.errors.NO_ERROR
+
 
 c = gpg.Context()
 c.set_armor(True)
@@ -108,9 +114,8 @@ c.op_verify(sig, text, None)
 result = c.op_verify_result()
 check_result(result, gpg.constants.sigsum.VALID | gpg.constants.sigsum.GREEN,
              gpg.constants.validity.FULL,
-             "A0FF4590BB6122EDEF6E3C542D727CC768697734",
-             gpg.errors.NO_ERROR, True)
-
+             "A0FF4590BB6122EDEF6E3C542D727CC768697734", gpg.errors.NO_ERROR,
+             True)
 
 # Checking a manipulated message.
 text = gpg.Data(test_text1f)
@@ -127,8 +132,8 @@ c.op_verify(sig, None, text)
 result = c.op_verify_result()
 check_result(result, gpg.constants.sigsum.VALID | gpg.constants.sigsum.GREEN,
              gpg.constants.validity.FULL,
-             "A0FF4590BB6122EDEF6E3C542D727CC768697734",
-             gpg.errors.NO_ERROR, False)
+             "A0FF4590BB6122EDEF6E3C542D727CC768697734", gpg.errors.NO_ERROR,
+             False)
 
 # Checking an invalid message.
 text = gpg.Data()
@@ -141,33 +146,32 @@ except Exception as e:
 else:
     assert False, "Expected an error but got none."
 
-
 # Idiomatic interface.
 with gpg.Context(armor=True) as c:
     # Checking a valid message.
     _, result = c.verify(test_text1, test_sig1)
-    check_result(result, gpg.constants.sigsum.VALID | gpg.constants.sigsum.GREEN,
-                 gpg.constants.validity.FULL,
-                 "A0FF4590BB6122EDEF6E3C542D727CC768697734",
-                 gpg.errors.NO_ERROR, True)
+    check_result(
+        result, gpg.constants.sigsum.VALID | gpg.constants.sigsum.GREEN,
+        gpg.constants.validity.FULL,
+        "A0FF4590BB6122EDEF6E3C542D727CC768697734", gpg.errors.NO_ERROR, True)
 
     # Checking a manipulated message.
     try:
         c.verify(test_text1f, test_sig1)
     except gpg.errors.BadSignatures as e:
         check_result(e.result, gpg.constants.sigsum.RED,
-                     gpg.constants.validity.UNKNOWN,
-                     "2D727CC768697734", gpg.errors.BAD_SIGNATURE, False)
+                     gpg.constants.validity.UNKNOWN, "2D727CC768697734",
+                     gpg.errors.BAD_SIGNATURE, False)
     else:
         assert False, "Expected an error but got none."
 
     # Checking a normal signature.
     sig = gpg.Data(test_sig2)
     data, result = c.verify(test_sig2)
-    check_result(result, gpg.constants.sigsum.VALID | gpg.constants.sigsum.GREEN,
-                 gpg.constants.validity.FULL,
-                 "A0FF4590BB6122EDEF6E3C542D727CC768697734",
-                 gpg.errors.NO_ERROR, False)
+    check_result(
+        result, gpg.constants.sigsum.VALID | gpg.constants.sigsum.GREEN,
+        gpg.constants.validity.FULL,
+        "A0FF4590BB6122EDEF6E3C542D727CC768697734", gpg.errors.NO_ERROR, False)
     assert data == test_text1
 
     # Checking an invalid message.
index 3101301..907f450 100755 (executable)
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
-del absolute_import, print_function, unicode_literals
 
 import time
 import gpg
 import support
-_ = support # to appease pyflakes.
+_ = support  # to appease pyflakes.
+
+del absolute_import, print_function, unicode_literals
 
 c = gpg.Context()
 c.set_armor(True)
index 08a320d..020e71e 100755 (executable)
@@ -19,9 +19,9 @@
 
 import gpg
 import support
-_ = support # to appease pyflakes.
+_ = support  # to appease pyflakes.
 
 d0 = gpg.Data()
-d0.seek # trigger on-demand-wrapping
+d0.seek  # trigger on-demand-wrapping
 assert d0.seek == d0.seek, "Generated wrapper functions are not cached"
 assert hasattr(gpg.Data, 'seek'), "Generated wrapper functions are not shared"