Fixup lint errors for ssl_compat.py.

Author: Lukasa

hyper/ssl_compat.py

@@ -3,7 +3,8 @@
 hyper/ssl_compat
 ~~~~~~~~~
 
-Shoves pyOpenSSL into an API that looks like the standard Python 3.x ssl module.
+Shoves pyOpenSSL into an API that looks like the standard Python 3.x ssl
+module.
 
 Currently exposes exactly those attributes, classes, and methods that we
 actually use in hyper (all method signatures are complete, however). May be
@@ -16,7 +17,6 @@
 import errno
 import socket
 import time
-import re
 
 from OpenSSL import SSL as ossl
 from service_identity.pyopenssl import verify_hostname as _verify
@@ -36,18 +36,24 @@
         locals()[external] = value
 
 OP_ALL = 0
-for bit in [31] + list(range(10)): # TODO figure out the names of these other flags
+# TODO: Find out the names of these other flags.
+for bit in [31] + list(range(10)):
     OP_ALL |= 1 << bit
 
 HAS_NPN = True
 
+
 def _proxy(method):
-    return lambda self, *args, **kwargs: getattr(self._conn, method)(*args, **kwargs)
+    def inner(self, *args, **kwargs):
+        getattr(self._conn, method)(*args, **kwargs)
+    return inner
+
 
 # TODO missing some attributes
 class SSLError(OSError):
     pass
 
+
 class CertificateError(SSLError):
     pass
 
@@ -76,9 +82,12 @@ def __init__(self, conn, server_side, do_handshake_on_connect,
             self._conn.set_accept_state()
         else:
             if server_hostname:
-                self._conn.set_tlsext_host_name(server_hostname.encode('utf-8'))
+                self._conn.set_tlsext_host_name(
+                    server_hostname.encode('utf-8')
+                )
                 self._server_hostname = server_hostname
-            self._conn.set_connect_state() # FIXME does this override do_handshake_on_connect=False?
+            # FIXME does this override do_handshake_on_connect=False?
+            self._conn.set_connect_state()
 
         if self.connected and self._do_handshake_on_connect:
             self.do_handshake()
@@ -95,7 +104,8 @@ def connected(self):
             return False
         return True
 
-    # Lovingly stolen from CherryPy (http://svn.cherrypy.org/tags/cherrypy-3.2.1/cherrypy/wsgiserver/ssl_pyopenssl.py).
+    # Lovingly stolen from CherryPy
+    # (http://svn.cherrypy.org/tags/cherrypy-3.2.1/cherrypy/wsgiserver/ssl_pyopenssl.py).
     def _safe_ssl_call(self, suppress_ragged_eofs, call, *args, **kwargs):
         """Wrap the given call with SSL error-trapping."""
         start = time.time()
@@ -127,8 +137,12 @@ def do_handshake(self):
             verify_hostname(self, self._server_hostname)
 
     def recv(self, bufsize, flags=None):
-        return self._safe_ssl_call(self._suppress_ragged_eofs, self._conn.recv,
-                               bufsize, flags)
+        return self._safe_ssl_call(
+            self._suppress_ragged_eofs,
+            self._conn.recv,
+            bufsize,
+            flags
+        )
 
     def recv_into(self, buffer, bufsize=None, flags=None):
         # A temporary recv_into implementation. Should be replaced when
@@ -173,9 +187,15 @@ def resolve_alias(alias):
             ).get(alias, alias)
 
         def to_components(name):
-            # TODO Verify that these are actually *supposed* to all be single-element
-            # tuples, and that's not just a quirk of the examples I've seen.
-            return tuple([((resolve_alias(name.decode('utf-8')), value.decode('utf-8')),) for name, value in name.get_components()])
+            # TODO Verify that these are actually *supposed* to all be
+            # single-element tuples, and that's not just a quirk of the
+            # examples I've seen.
+            return tuple(
+                [
+                    (resolve_alias(k.decode('utf-8'), v.decode('utf-8')),)
+                    for k, v in name.get_components()
+                ]
+            )
 
         # The standard getpeercert() takes the nice X509 object tree returned
         # by OpenSSL and turns it into a dict according to some format it seems
@@ -189,11 +209,13 @@ def to_components(name):
             notBefore=cert.get_notBefore(),
             notAfter=cert.get_notAfter(),
         )
-        # TODO extensions, including subjectAltName (see _decode_certificate in _ssl.c)
+        # TODO extensions, including subjectAltName
+        # (see _decode_certificate in _ssl.c)
         return result
 
     # a dash of magic to reduce boilerplate
-    for method in ['accept', 'bind', 'close', 'getsockname', 'listen', 'fileno']:
+    methods = ['accept', 'bind', 'close', 'getsockname', 'listen', 'fileno']
+    for method in methods:
         locals()[method] = _proxy(method)
 
 
@@ -221,7 +243,9 @@ def verify_mode(self):
     @verify_mode.setter
     def verify_mode(self, value):
         # TODO verify exception is raised on failure
-        self._ctx.set_verify(value, lambda conn, cert, errnum, errdepth, ok: ok)
+        self._ctx.set_verify(
+            value, lambda conn, cert, errnum, errdepth, ok: ok
+        )
 
     def set_default_verify_paths(self):
         self._ctx.set_default_verify_paths()
@@ -239,11 +263,13 @@ def load_verify_locations(self, cafile=None, capath=None, cadata=None):
     def load_cert_chain(self, certfile, keyfile=None, password=None):
         self._ctx.use_certificate_file(certfile)
         if password is not None:
-            self._ctx.set_passwd_cb(lambda max_length, prompt_twice, userdata: password)
+            self._ctx.set_passwd_cb(
+                lambda max_length, prompt_twice, userdata: password
+            )
         self._ctx.use_privatekey_file(keyfile or certfile)
 
     def set_npn_protocols(self, protocols):
-        self.protocols = list(map(lambda x:x.encode('ascii'), protocols))
+        self.protocols = list(map(lambda x: x.encode('ascii'), protocols))
 
         def cb(conn, protos):
             # Detect the overlapping set of protocols.
@@ -262,8 +288,12 @@ def set_alpn_protocols(self, protocols):
         protocols = list(map(lambda x: x.encode('ascii'), protocols))
         self._ctx.set_alpn_protos(protocols)
 
-    def wrap_socket(self, sock, server_side=False, do_handshake_on_connect=True,
-                    suppress_ragged_eofs=True, server_hostname=None):
+    def wrap_socket(self,
+                    sock,
+                    server_side=False,
+                    do_handshake_on_connect=True,
+                    suppress_ragged_eofs=True,
+                    server_hostname=None):
         conn = ossl.Connection(self._ctx, sock)
         return SSLSocket(conn, server_side, do_handshake_on_connect,
                          suppress_ragged_eofs, server_hostname,