diff --git a/lang/python/tests/final.py b/lang/python/tests/final.py
index 8e7ab339..65375cb8 100755
--- a/lang/python/tests/final.py
+++ b/lang/python/tests/final.py
@@ -1,27 +1,29 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # 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, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import os
 import subprocess
+import support
+_ = support # to appease pyflakes.
 
 subprocess.check_call([os.path.join(os.getenv('top_srcdir'),
                                     "tests", "start-stop-agent"), "--stop"])
diff --git a/lang/python/tests/t-callbacks.py b/lang/python/tests/t-callbacks.py
index 94cf11ef..9a70cdae 100755
--- a/lang/python/tests/t-callbacks.py
+++ b/lang/python/tests/t-callbacks.py
@@ -1,257 +1,256 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # 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, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import os
 import gpg
 import support
-
-support.assert_gpg_version()
+_ = support # to appease pyflakes.
 
 c = gpg.Context()
 c.set_pinentry_mode(gpg.constants.PINENTRY_MODE_LOOPBACK)
 
 source = gpg.Data("Hallo Leute\n")
 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
 
     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)
 except Exception as e:
     assert type(e) == TypeError
     assert str(e) == "expected str or bytes from passphrase callback, got int"
 else:
     assert False, "Expected an error, got none"
 
 # 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)
 except Exception as e:
     assert e == myException
 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)
 except Exception as e:
     assert type(e) == TypeError
 else:
     assert False, "Expected an error, got none"
 
 
 
 # Test the progress callback.
 parms = """<GnupgKeyParms format="internal">
 Key-Type: RSA
 Key-Length: 1024
 Name-Real: Joe Tester
 Name-Comment: with stupid passphrase
 Name-Email: joe+gpg@example.org
 Passphrase: Crypt0R0cks
 Expire-Date: 2020-12-31
 </GnupgKeyParms>
 """
 
 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:
     c.op_genkey(parms, None, None)
 except Exception as e:
     assert e == myException
 else:
     assert False, "Expected an error, got none"
 
 
 # Test the edit callback.
 c = gpg.Context()
 c.set_pinentry_mode(gpg.constants.PINENTRY_MODE_LOOPBACK)
 c.set_passphrase_cb(lambda *args: "abc")
 sink = gpg.Data()
 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
 
 # Test exceptions.
 c = gpg.Context()
 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:
     assert e == myException
 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")
 c.op_encrypt([alpha], gpg.constants.ENCRYPT_ALWAYS_TRUST, source, sink)
 assert status_cb_called
 
 # Test exceptions.
 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")
 try:
     c.op_encrypt([alpha], gpg.constants.ENCRYPT_ALWAYS_TRUST, source, sink)
 except Exception as e:
     assert e == myException
 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()
 except Exception as e:
     assert type(e) == TypeError
 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()
 except Exception as e:
     assert e == myException
 else:
     assert False, "Expected an error, got none"
 
 
 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')
 except Exception as e:
     assert type(e) == TypeError
 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')
 except Exception as e:
     assert e == myException
 else:
     assert False, "Expected an error, got none"
 
 
 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)
 except Exception as e:
     assert type(e) == TypeError
 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)
 except Exception as e:
     assert e == myException
 else:
     assert False, "Expected an error, got none"
diff --git a/lang/python/tests/t-data.py b/lang/python/tests/t-data.py
index d1facd40..33013193 100755
--- a/lang/python/tests/t-data.py
+++ b/lang/python/tests/t-data.py
@@ -1,129 +1,131 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # 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, 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.
 
 data = gpg.Data('Hello world!')
 assert data.read() == b'Hello world!'
 assert data.read() == b''
 
 data.seek(0, os.SEEK_SET)
 assert data.read() == b'Hello world!'
 assert data.read() == b''
 
 data = gpg.Data(b'Hello world!')
 assert data.read() == b'Hello world!'
 
 data = gpg.Data(b'Hello world!', copy=False)
 assert data.read() == b'Hello world!'
 
 data = gpg.Data()
 data.write('Hello world!')
 data.seek(0, os.SEEK_SET)
 assert data.read() == b'Hello world!'
 
 data = gpg.Data()
 data.write(b'Hello world!')
 data.seek(0, os.SEEK_SET)
 assert data.read() == b'Hello world!'
 
 binjunk = bytes(range(256))
 data = gpg.Data()
 data.write(binjunk)
 data.seek(0, os.SEEK_SET)
 assert data.read() == binjunk
 
 data = gpg.Data()
 data.set_file_name("foobar")
 assert data.get_file_name() == "foobar"
 
 # Test reading from an existing file.
 with tempfile.NamedTemporaryFile() as tmp:
     tmp.write(binjunk)
     tmp.flush()
     tmp.seek(0)
 
     # Open using name.
     data = gpg.Data(file=tmp.name)
     assert data.read() == binjunk
 
     # Open using name, without copying.
     if False:
         # delayed reads are not yet supported
         data = gpg.Data(file=tmp.name, copy=False)
         assert data.read() == binjunk
 
     # Open using stream.
     tmp.seek(0)
     data = gpg.Data(file=tmp)
     assert data.read() == binjunk
 
     # Open using stream, offset, and length.
     data = gpg.Data(file=tmp, offset=0, length=42)
     assert data.read() == binjunk[:42]
 
     # Open using name, offset, and length.
     data = gpg.Data(file=tmp.name, offset=23, length=42)
     assert data.read() == binjunk[23:23+42]
 
 # Test callbacks.
 class DataObject(object):
     def __init__(self):
         self.buffer = io.BytesIO()
         self.released = False
 
     def read(self, amount, hook=None):
         assert not self.released
         return self.buffer.read(amount)
 
     def write(self, data, hook=None):
         assert not self.released
         return self.buffer.write(data)
 
     def seek(self, offset, whence, hook=None):
         assert not self.released
         return self.buffer.seek(offset, whence)
 
     def release(self, hook=None):
         assert not self.released
         self.released = True
 
 do = DataObject()
 cookie = object()
 data = gpg.Data(cbs=(do.read, do.write, do.seek, do.release, cookie))
 data.write('Hello world!')
 data.seek(0, os.SEEK_SET)
 assert data.read() == b'Hello world!'
 del data
 assert do.released
 
 # Again, without the cookie.
 do = DataObject()
 data = gpg.Data(cbs=(do.read, do.write, do.seek, do.release))
 data.write('Hello world!')
 data.seek(0, os.SEEK_SET)
 assert data.read() == b'Hello world!'
 del data
 assert do.released
diff --git a/lang/python/tests/t-edit.py b/lang/python/tests/t-edit.py
index ffc32965..b1075a96 100755
--- a/lang/python/tests/t-edit.py
+++ b/lang/python/tests/t-edit.py
@@ -1,72 +1,71 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2005 Igor Belyi <belyi@users.sourceforge.net>
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # 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, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import sys
 import os
 import gpg
 import support
-
-support.assert_gpg_version()
+_ = support # to appease pyflakes.
 
 class KeyEditor(object):
     def __init__(self):
         self.steps = ["fpr", "expire", "1", "primary", "quit"]
         self.step = 0
         self.done = False
         self.verbose = int(os.environ.get('verbose', 0)) > 1
 
     def edit_fnc(self, status, args, out=None):
         if args == "keyedit.prompt":
             result = self.steps[self.step]
             self.step += 1
         elif args == "keyedit.save.okay":
             result = "Y"
             self.done = self.step == len(self.steps)
         elif args == "keygen.valid":
             result = "0"
         else:
             result = None
 
         if self.verbose:
             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")
 c.set_armor(True)
 
 # The deprecated interface.
 editor = KeyEditor()
 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)
 assert editor.done
diff --git a/lang/python/tests/t-encrypt-sym.py b/lang/python/tests/t-encrypt-sym.py
index 8ee9cd6b..82992934 100755
--- a/lang/python/tests/t-encrypt-sym.py
+++ b/lang/python/tests/t-encrypt-sym.py
@@ -1,85 +1,84 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # 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, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import os
 import gpg
 import support
-
-support.assert_gpg_version()
+_ = support # to appease pyflakes.
 
 for passphrase in ("abc", b"abc"):
     c = gpg.Context()
     c.set_armor(True)
     c.set_pinentry_mode(gpg.constants.PINENTRY_MODE_LOOPBACK)
 
     source = gpg.Data("Hallo Leute\n")
     cipher = gpg.Data()
 
     passphrase_cb_called = 0
     def passphrase_cb(hint, desc, prev_bad, hook=None):
         global passphrase_cb_called
         passphrase_cb_called += 1
         return passphrase
 
     c.set_passphrase_cb(passphrase_cb, None)
 
     c.op_encrypt([], 0, source, cipher)
     assert passphrase_cb_called == 1, \
         "Callback called {} times".format(passphrase_cb_called)
     support.print_data(cipher)
 
     c = gpg.Context()
     c.set_armor(True)
     c.set_pinentry_mode(gpg.constants.PINENTRY_MODE_LOOPBACK)
     c.set_passphrase_cb(passphrase_cb, None)
     plain = gpg.Data()
     cipher.seek(0, os.SEEK_SET)
 
     c.op_decrypt(cipher, plain)
     # Seems like the passphrase is cached.
     #assert passphrase_cb_called == 2, \
     #    "Callback called {} times".format(passphrase_cb_called)
     support.print_data(plain)
 
     plain.seek(0, os.SEEK_SET)
     plaintext = plain.read()
     assert plaintext == b"Hallo Leute\n", \
         "Wrong plaintext {!r}".format(plaintext)
 
 # Idiomatic interface.
 for passphrase in ("abc", b"abc"):
     with gpg.Context(armor=True) as c:
         # 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)
         assert ciphertext.find(b'BEGIN PGP MESSAGE') > 0, 'Marker not found'
 
         plaintext, _, _ = c.decrypt(ciphertext, passphrase=passphrase)
         assert plaintext == message, 'Message body not recovered'
 
         assert c._passphrase_cb[1] == f, "Passphrase callback not restored"
diff --git a/lang/python/tests/t-file-name.py b/lang/python/tests/t-file-name.py
index aab56802..32fe84a0 100755
--- a/lang/python/tests/t-file-name.py
+++ b/lang/python/tests/t-file-name.py
@@ -1,44 +1,45 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # 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, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import os
 import gpg
 import support
+_ = support # to appease pyflakes.
 
 testname = "abcde12345"
 
 c = gpg.Context()
 c.set_armor(True)
 
 source = gpg.Data("Hallo Leute\n")
 source.set_file_name(testname)
 cipher = gpg.Data()
 plain = gpg.Data()
 
 keys = []
 keys.append(c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False))
 
 c.op_encrypt(keys, gpg.constants.ENCRYPT_ALWAYS_TRUST, source, cipher)
 cipher.seek(0, os.SEEK_SET)
 c.op_decrypt(cipher, plain)
 result = c.op_decrypt_result()
 assert result.file_name == testname
diff --git a/lang/python/tests/t-idiomatic.py b/lang/python/tests/t-idiomatic.py
index 826bc23c..b7ae4eb9 100755
--- a/lang/python/tests/t-idiomatic.py
+++ b/lang/python/tests/t-idiomatic.py
@@ -1,82 +1,83 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # 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, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import sys
 import io
 import os
 import tempfile
 import gpg
 import support
+_ = support # to appease pyflakes.
 
 # Both Context and Data can be used as context manager:
 with gpg.Context() as c, gpg.Data() as d:
     c.get_engine_info()
     d.write(b"Halloechen")
     leak_c = c
     leak_d = d
 assert leak_c.wrapped == None
 assert leak_d.wrapped == None
 
 def sign_and_verify(source, signed, sink):
     with gpg.Context() as c:
         c.op_sign(source, signed, gpg.constants.sig.mode.NORMAL)
         signed.seek(0, os.SEEK_SET)
         c.op_verify(signed, None, sink)
         result = c.op_verify_result()
 
     assert len(result.signatures) == 1, "Unexpected number of signatures"
     sig = result.signatures[0]
     assert sig.summary == (gpg.constants.sigsum.VALID |
                            gpg.constants.sigsum.GREEN)
     assert gpg.errors.GPGMEError(sig.status).getcode() == gpg.errors.NO_ERROR
 
     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, \
      tempfile.TemporaryFile() as signed, \
      tempfile.TemporaryFile() as sink:
     source.write(b"Hallo Leute\n")
     source.seek(0, os.SEEK_SET)
 
     sign_and_verify(source, signed, sink)
 
 if sys.version_info[0] == 3:
     # Python2's io.BytesIO does not implement the buffer interface,
     # hence we cannot use it as sink.
 
     # XXX: Python's io.BytesIo.truncate does not work as advertised.
     # http://bugs.python.org/issue27261
     bio = io.BytesIO()
     bio.truncate(1)
     if len(bio.getvalue()) != 1:
         # This version of Python is affected, preallocate buffer.
         preallocate = 128*b'\x00'
     else:
         preallocate = b''
 
     # Demonstrate automatic wrapping of objects implementing the buffer
     # interface, and the use of data objects with the 'with' statement.
     with io.BytesIO(preallocate) as signed, gpg.Data() as sink:
         sign_and_verify(b"Hallo Leute\n", signed, sink)
diff --git a/lang/python/tests/t-keylist-from-data.py b/lang/python/tests/t-keylist-from-data.py
index 6a26267d..6503eb7a 100755
--- a/lang/python/tests/t-keylist-from-data.py
+++ b/lang/python/tests/t-keylist-from-data.py
@@ -1,213 +1,211 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # 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, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
-import os
-import sys
 import gpg
 import support
 
 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]
 
   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 ],
 ]
 
 def check_global(key, uids, n_subkeys):
     assert not key.revoked, "Key unexpectedly revoked"
     assert not key.expired, "Key unexpectedly expired"
     assert not key.disabled, "Key unexpectedly disabled"
     assert not key.invalid, "Key unexpectedly invalid"
     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])
 
 
 def check_subkey(fpr, which, subkey):
     assert not subkey.revoked, which + " key unexpectedly revoked"
     assert not subkey.expired, which + " key unexpectedly expired"
     assert not subkey.disabled, which + " key unexpectedly disabled"
     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"
     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 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)
 
 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 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)
 
 # 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)
 
 # ... rewind the tape...
 key_data.rewind()
 
 # ... and feed it into a keylist in an empty context.
 with support.EphemeralContext() as c:
     for i, key in enumerate(c.keylist(source=key_data)):
         try:
             if len(keys[i]) == 4:
                 fpr, sec_keyid, uids, n_subkeys = keys[i]
                 misc_check = None
             else:
                 fpr, sec_keyid, uids, n_subkeys, misc_check = keys[i]
         except IndexError:
             # There are more keys.  We don't check for that.
             break
 
         # Global key flags.
         check_global(key, uids, n_subkeys)
         check_subkey(fpr, "Primary", key.subkeys[0])
         check_subkey(sec_keyid, "Secondary", key.subkeys[1])
 
         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])
         if len(key.uids) > 2:
           check_uid("Third", uids[2], key.uids[2])
 
         if misc_check:
             misc_check (uids[0][0], key)
 
     assert len(list(c.keylist())) == 0, "Keys were imported"
diff --git a/lang/python/tests/t-protocol-assuan.py b/lang/python/tests/t-protocol-assuan.py
index 27b28c72..8da50351 100755
--- a/lang/python/tests/t-protocol-assuan.py
+++ b/lang/python/tests/t-protocol-assuan.py
@@ -1,72 +1,74 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # 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, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import gpg
+import support
+_ = support # to appease pyflakes.
 
 with gpg.Context(protocol=gpg.constants.protocol.ASSUAN) as c:
     # Do nothing.
     err = c.assuan_transact('nop')
     assert err == None
     err = c.assuan_transact(b'NOP')
     assert err == None
     err = c.assuan_transact(['NOP'])
     assert err == None
 
     err = c.assuan_transact('idontexist')
     assert err.getsource() == gpg.errors.SOURCE_GPGAGENT
     assert err.getcode() == gpg.errors.ASS_UNKNOWN_CMD
 
     # Invoke the pinentry to get a confirmation.
     c.assuan_transact(['GET_CONFIRMATION', 'Hello there'])
 
     data = []
     def data_cb(line):
         data.append(line)
 
     err = c.assuan_transact(['GETINFO', 'version'], data_cb=data_cb)
     assert not err
     assert len(data) == 1
 
     data = []
     err = c.assuan_transact(['GETINFO', 's2k_count'], data_cb=data_cb)
     if not err:
         assert len(data) == 1
         assert int(data[0]) > 0
 
     # XXX HELP sends status lines if we could use ASSUAN_CONVEY_COMMENTS.
 
     status = []
     def status_cb(line, args):
         status.append((line, args))
 
     alphas_grip = '76F7E2B35832976B50A27A282D9B87E44577EB66'
     err = c.assuan_transact(['KEYINFO', alphas_grip], status_cb=status_cb)
     if not err:
         assert len(status) == 1
         line, args = status[0]
         assert line.startswith('KEYINFO')
         assert args.startswith(alphas_grip)
 
     # XXX: test these callbacks, e.g. using PRESET_PASSPHRASE
     # XXX: once issue2428 is resolved
     def inq_cb(name, args):
         print("inq_cb", name, args)
diff --git a/lang/python/tests/t-sig-notation.py b/lang/python/tests/t-sig-notation.py
index 22774974..bc8da2e6 100755
--- a/lang/python/tests/t-sig-notation.py
+++ b/lang/python/tests/t-sig-notation.py
@@ -1,78 +1,79 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # 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, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import os
 import gpg
 import support
+_ = support # to appease pyflakes.
 
 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),
     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'))
 
 def check_result(result):
     assert len(result.signatures) == 1, "Unexpected number of signatures"
     sig = result.signatures[0]
     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 r.name in expected_notations
         value, flags = expected_notations.pop(r.name)
 
         assert r.value == value, \
             "Expected {!r}, got {!r}".format(value, r.value)
         assert r.human_readable \
             == bool(flags & gpg.constants.sig.notation.HUMAN_READABLE)
         assert r.critical \
             == (bool(flags & gpg.constants.sig.notation.CRITICAL)
                 if have_correct_sig_data else False)
 
     assert len(expected_notations) == 0
 
 source = gpg.Data("Hallo Leute\n")
 signed = gpg.Data()
 
 c = gpg.Context()
 for name, (value, flags) in expected_notations.items():
     c.sig_notation_add(name, value, flags)
 
 c.op_sign(source, signed, gpg.constants.sig.mode.NORMAL)
 
 signed.seek(0, os.SEEK_SET)
 sink = gpg.Data()
 c.op_verify(signed, None, sink)
 result = c.op_verify_result()
 check_result(result)
diff --git a/lang/python/tests/t-trustlist.py b/lang/python/tests/t-trustlist.py
index 85865965..89524bb5 100755
--- a/lang/python/tests/t-trustlist.py
+++ b/lang/python/tests/t-trustlist.py
@@ -1,42 +1,43 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # 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, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
+_ = support # to appease pyflakes.
 
 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))
 
 c.op_trustlist_start("alice", 0)
 while True:
     item = c.op_trustlist_next()
     if not item:
         break
     dump_item(item)
 c.op_trustlist_end()
 
 for item in c.op_trustlist_all("alice", 0):
     dump_item(item)
diff --git a/lang/python/tests/t-verify.py b/lang/python/tests/t-verify.py
index 03476382..320dae66 100755
--- a/lang/python/tests/t-verify.py
+++ b/lang/python/tests/t-verify.py
@@ -1,192 +1,193 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # 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, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import sys
 import os
 import gpg
 import support
+_ = support # to appease pyflakes.
 
 test_text1 = b"Just GNU it!\n"
 test_text1f= b"Just GNU it?\n"
 test_sig1 = b"""-----BEGIN PGP SIGNATURE-----
 
 iN0EABECAJ0FAjoS+i9FFIAAAAAAAwA5YmFyw7bDpMO8w58gZGFzIHdhcmVuIFVt
 bGF1dGUgdW5kIGpldHp0IGVpbiBwcm96ZW50JS1aZWljaGVuNRSAAAAAAAgAJGZv
 b2Jhci4xdGhpcyBpcyBhIG5vdGF0aW9uIGRhdGEgd2l0aCAyIGxpbmVzGhpodHRw
 Oi8vd3d3Lmd1Lm9yZy9wb2xpY3kvAAoJEC1yfMdoaXc0JBIAoIiLlUsvpMDOyGEc
 dADGKXF/Hcb+AKCJWPphZCphduxSvrzH0hgzHdeQaA==
 =nts1
 -----END PGP SIGNATURE-----
 """
 
 test_sig2 = b"""-----BEGIN PGP MESSAGE-----
 
 owGbwMvMwCSoW1RzPCOz3IRxjXQSR0lqcYleSUWJTZOvjVdpcYmCu1+oQmaJIleH
 GwuDIBMDGysTSIqBi1MApi+nlGGuwDeHao53HBr+FoVGP3xX+kvuu9fCMJvl6IOf
 y1kvP4y+8D5a11ang0udywsA
 =Crq6
 -----END PGP MESSAGE-----
 """
 
 # A message with a prepended but unsigned plaintext packet.
 double_plaintext_sig = b"""-----BEGIN PGP MESSAGE-----
 
 rDRiCmZvb2Jhci50eHRF4pxNVGhpcyBpcyBteSBzbmVha3kgcGxhaW50ZXh0IG1l
 c3NhZ2UKowGbwMvMwCSoW1RzPCOz3IRxTWISa6JebnG666MFD1wzSzJSixQ81XMV
 UlITUxTyixRyKxXKE0uSMxQyEosVikvyCwpSU/S4FNCArq6Ce1F+aXJGvoJvYlGF
 erFCTmJxiUJ5flFKMVeHGwuDIBMDGysTyA4GLk4BmO036xgWzMgzt9V85jCtfDFn
 UqVooWlGXHwNw/xg/fVzt9VNbtjtJ/fhUqYo0/LyCGEA
 =6+AK
 -----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]
     assert sig.summary == summary, \
         "Unexpected signature summary: {}, want: {}".format(sig.summary,
                                                             summary)
     assert sig.fpr == fpr
     assert gpg.errors.GPGMEError(sig.status).getcode() == status
 
     if notation:
         expected_notations = {
             "bar": (b"\xc3\xb6\xc3\xa4\xc3\xbc\xc3\x9f" +
                     b" das waren Umlaute und jetzt ein prozent%-Zeichen"
                     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/",
         }
         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 r.name in expected_notations
             assert r.value == expected_notations[r.name], \
                 "Expected {!r}, got {!r}".format(expected_notations[r.name],
                                                  r.value)
             expected_notations.pop(r.name)
 
         assert len(expected_notations) == 0
 
     assert not sig.wrong_key_usage
     assert sig.validity == validity, \
         "Unexpected signature validity: {}, want: {}".format(
             sig.validity, validity)
     assert gpg.errors.GPGMEError(sig.validity_reason).getcode() == gpg.errors.NO_ERROR
 
 c = gpg.Context()
 c.set_armor(True)
 
 # Checking a valid message.
 text = gpg.Data(test_text1)
 sig = gpg.Data(test_sig1)
 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)
 
 
 # Checking a manipulated message.
 text = gpg.Data(test_text1f)
 sig.seek(0, os.SEEK_SET)
 c.op_verify(sig, text, None)
 result = c.op_verify_result()
 check_result(result, gpg.constants.sigsum.RED, gpg.constants.validity.UNKNOWN,
              "2D727CC768697734", gpg.errors.BAD_SIGNATURE, False)
 
 # Checking a normal signature.
 text = gpg.Data()
 sig = gpg.Data(test_sig2)
 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)
 
 # Checking an invalid message.
 text = gpg.Data()
 sig = gpg.Data(double_plaintext_sig)
 try:
     c.op_verify(sig, None, text)
 except Exception as e:
     assert type(e) == gpg.errors.GPGMEError
     assert e.getcode() == gpg.errors.BAD_DATA
 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)
 
     # 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)
     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)
     assert data == test_text1
 
     # Checking an invalid message.
     try:
         c.verify(double_plaintext_sig)
     except gpg.errors.GPGMEError as e:
         assert e.getcode() == gpg.errors.BAD_DATA
     else:
         assert False, "Expected an error but got none."
 
     alpha = c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False)
     bob = c.get_key("D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2", False)
 
     # Checking a valid message.
     c.verify(test_text1, test_sig1, verify=[alpha])
 
     try:
         c.verify(test_text1, test_sig1, verify=[alpha, bob])
     except gpg.errors.MissingSignatures as e:
         assert len(e.missing) == 1
         assert e.missing[0] == bob
     else:
         assert False, "Expected an error, got none"
diff --git a/lang/python/tests/t-wait.py b/lang/python/tests/t-wait.py
index 0c403fa6..31013011 100755
--- a/lang/python/tests/t-wait.py
+++ b/lang/python/tests/t-wait.py
@@ -1,44 +1,45 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # 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, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import time
 import gpg
 import support
+_ = support # to appease pyflakes.
 
 c = gpg.Context()
 c.set_armor(True)
 
 # Checking a message without a signature.
 sig = gpg.Data("foo\n")
 text = gpg.Data()
 c.op_verify_start(sig, None, text)
 
 try:
     while True:
         err = c.wait(False)
         if err:
             break
         time.sleep(0.1)
 except Exception as e:
     assert e.getcode() == gpg.errors.NO_DATA
 else:
     assert False, "Expected an error, got none"
diff --git a/lang/python/tests/t-wrapper.py b/lang/python/tests/t-wrapper.py
index 79f047fa..08a320d2 100755
--- a/lang/python/tests/t-wrapper.py
+++ b/lang/python/tests/t-wrapper.py
@@ -1,25 +1,27 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # 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/>.
 
 import gpg
+import support
+_ = support # to appease pyflakes.
 
 d0 = gpg.Data()
 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"