fixes flake8 warnings

Author: moisesguimaraes

src/wolfssl/__about__.py

@@ -43,6 +43,7 @@
 __copyright__ = "Copyright (C) 2006-2017 wolfSSL Inc"
 
 __all__ = [
-    "__title__", "__summary__", "__uri__", "__version__", "__wolfssl_version__",
-    "__author__", "__email__", "__license__", "__copyright__"
+    "__title__", "__summary__", "__uri__", "__version__",
+    "__wolfssl_version__", "__author__", "__email__",
+    "__license__", "__copyright__"
 ]

src/wolfssl/__init__.py

@@ -26,7 +26,9 @@
     socket, AF_INET, SOCK_STREAM, SOL_SOCKET, SO_TYPE, error as socket_error
 )
 
-from wolfssl.__about__ import * # pylint: disable=wildcard-import
+# pylint: disable=wildcard-import
+from wolfssl.__about__ import *  # noqa: F401, F403
+# pylint: enable=wildcard-import
 
 try:
     from wolfssl._ffi import ffi as _ffi
@@ -36,12 +38,12 @@
 
 from wolfssl.utils import t2b
 
-from wolfssl.exceptions import (
+from wolfssl.exceptions import (  # noqa: F401
     CertificateError, SSLError, SSLEOFError, SSLSyscallError,
     SSLWantReadError, SSLWantWriteError, SSLZeroReturnError
 )
 
-from wolfssl._methods import (
+from wolfssl._methods import (  # noqa: F401
     PROTOCOL_SSLv23, PROTOCOL_SSLv3, PROTOCOL_TLSv1,
     PROTOCOL_TLSv1_1, PROTOCOL_TLSv1_2, PROTOCOL_TLS,
     WolfSSLMethod as _WolfSSLMethod
@@ -58,6 +60,7 @@
 
 _PY3 = sys.version_info[0] == 3
 
+
 class SSLContext(object):
     """
     An SSLContext holds various SSL-related configuration options and
@@ -83,12 +86,10 @@ def __init__(self, protocol, server_side=False):
         # verify_mode initialization needs a valid native_object.
         self.verify_mode = CERT_NONE
 
-
     def __del__(self):
         if getattr(self, 'native_object', _ffi.NULL) != _ffi.NULL:
             _lib.wolfSSL_CTX_free(self.native_object)
 
-
     @property
     def verify_mode(self):
         """
@@ -98,7 +99,6 @@ def verify_mode(self):
         """
         return self._verify_mode
 
-
     @verify_mode.setter
     def verify_mode(self, value):
         if value not in _VERIFY_MODE_LIST:
@@ -111,7 +111,6 @@ def verify_mode(self, value):
                                         self._verify_mode,
                                         _ffi.NULL)
 
-
     def wrap_socket(self, sock, server_side=False,
                     do_handshake_on_connect=True,
                     suppress_ragged_eofs=True):
@@ -129,20 +128,19 @@ def wrap_socket(self, sock, server_side=False,
                          suppress_ragged_eofs=suppress_ragged_eofs,
                          _context=self)
 
-
     def set_ciphers(self, ciphers):
         """
         Set the available ciphers for sockets created with this context. It
         should be a string in the wolfSSL cipher list format. If no cipher can
-        be selected (because compile-time options or other configuration forbids
-        use of all the specified ciphers), an SSLError will be raised.
+        be selected (because compile-time options or other configuration
+        forbids use of all the specified ciphers), an SSLError will be raised.
         """
-        ret = _lib.wolfSSL_CTX_set_cipher_list(self.native_object, t2b(ciphers))
+        ret = _lib.wolfSSL_CTX_set_cipher_list(self.native_object,
+                                               t2b(ciphers))
 
         if ret != _SSL_SUCCESS:
             raise SSLError("Unnable to set cipher list")
 
-
     def load_cert_chain(self, certfile, keyfile=None, password=None):
         """
         Load a private key and the corresponding certificate. The certfile
@@ -164,16 +162,16 @@ def load_cert_chain(self, certfile, keyfile=None, password=None):
             ret = _lib.wolfSSL_CTX_use_certificate_chain_file(
                 self.native_object, t2b(certfile))
             if ret != _SSL_SUCCESS:
-                raise SSLError("Unnable to load certificate chain. Err %d"% ret)
+                raise SSLError(
+                    "Unnable to load certificate chain. E(%d)" % ret)
         else:
             raise TypeError("certfile should be a valid filesystem path")
 
         if keyfile is not None:
             ret = _lib.wolfSSL_CTX_use_PrivateKey_file(
                 self.native_object, t2b(keyfile), _SSL_FILETYPE_PEM)
             if ret != _SSL_SUCCESS:
-                raise SSLError("Unnable to load private key. Err %d" % ret)
-
+                raise SSLError("Unnable to load private key. E(%d)" % ret)
 
     def load_verify_locations(self, cafile=None, capath=None, cadata=None):
         """
@@ -198,14 +196,15 @@ def load_verify_locations(self, cafile=None, capath=None, cadata=None):
                 t2b(capath) if capath else _ffi.NULL)
 
             if ret != _SSL_SUCCESS:
-                raise SSLError("Unnable to load verify locations. Err %d" % ret)
+                raise SSLError("Unnable to load verify locations. E(%d)" % ret)
 
         if cadata is not None:
             ret = _lib.wolfSSL_CTX_load_verify_buffer(
-                self.native_object, t2b(cadata), len(cadata), _SSL_FILETYPE_PEM)
+                self.native_object, t2b(cadata),
+                len(cadata), _SSL_FILETYPE_PEM)
 
             if ret != _SSL_SUCCESS:
-                raise SSLError("Unnable to load verify locations. Err %d" % ret)
+                raise SSLError("Unnable to load verify locations. E(%d)" % ret)
 
 
 class SSLSocket(socket):
@@ -313,35 +312,30 @@ def __init__(self, sock=None, keyfile=None, certfile=None,
             try:
                 if do_handshake_on_connect:
                     self.do_handshake()
-            except:
+            except SSLError:
                 self._release_native_object()
                 self.close()
                 raise
 
-
     def __del__(self):
         self._release_native_object()
 
-
     def _release_native_object(self):
         if getattr(self, 'native_object', _ffi.NULL) != _ffi.NULL:
             _lib.wolfSSL_CTX_free(self.native_object)
             self.native_object = _ffi.NULL
 
-
     @property
     def context(self):
         """
         Returns the context used by this object.
         """
         return self._context
 
-
     def dup(self):
         raise NotImplementedError("Can't dup() %s instances" %
                                   self.__class__.__name__)
 
-
     def _check_closed(self, call=None):
         if self.native_object == _ffi.NULL:
             raise ValueError("%s on closed or unwrapped secure channel" % call)
@@ -354,7 +348,6 @@ def _check_connected(self):
             # EAGAIN.
             self.getpeername()
 
-
     def write(self, data):
         """
         Write DATA to the underlying secure channel.
@@ -367,15 +360,13 @@ def write(self, data):
 
         return _lib.wolfSSL_write(self.native_object, data, len(data))
 
-
     def send(self, data, flags=0):
         if flags != 0:
             raise NotImplementedError("non-zero flags not allowed in calls to "
                                       "send() on %s" % self.__class__)
 
         return self.write(data)
 
-
     def sendall(self, data, flags=0):
         if flags != 0:
             raise NotImplementedError("non-zero flags not allowed in calls to "
@@ -389,25 +380,21 @@ def sendall(self, data, flags=0):
 
         return sent
 
-
     def sendto(self, data, flags_or_addr, addr=None):
-        # Ensure programs don't send unencrypted data trying to use this method
+        # Ensures not to send unencrypted data trying to use this method
         raise NotImplementedError("sendto not allowed on instances "
                                   "of %s" % self.__class__)
 
-
     def sendmsg(self, *args, **kwargs):
-        # Ensure programs don't send unencrypted data trying to use this method
+        # Ensures not to send unencrypted data trying to use this method
         raise NotImplementedError("sendmsg not allowed on instances "
                                   "of %s" % self.__class__)
 
-
     def sendfile(self, file, offset=0, count=None):
-        # Ensure programs don't send unencrypted files trying to use this method
+        # Ensures not to send unencrypted files trying to use this method
         raise NotImplementedError("sendfile not allowed on instances "
                                   "of %s" % self.__class__)
 
-
     def read(self, length=1024, buffer=None):
         """
         Read up to LENGTH bytes and return them.
@@ -432,49 +419,41 @@ def read(self, length=1024, buffer=None):
 
         return _ffi.buffer(data, length)[:] if length > 0 else b''
 
-
     def recv(self, length=1024, flags=0):
         if flags != 0:
             raise NotImplementedError("non-zero flags not allowed in calls to "
                                       "recv() on %s" % self.__class__)
 
         return self.read(self, length)
 
-
     def recv_into(self, buffer, nbytes=None, flags=0):
         raise NotImplementedError("recv_into not allowed on instances "
                                   "of %s" % self.__class__)
 
-
     def recvfrom(self, length=1024, flags=0):
-        # Ensure programs don't receive encrypted data trying to use this method
+        # Ensures not to receive encrypted data trying to use this method
         raise NotImplementedError("recvfrom not allowed on instances "
                                   "of %s" % self.__class__)
 
-
     def recvfrom_into(self, buffer, nbytes=None, flags=0):
-        # Ensure programs don't receive encrypted data trying to use this method
+        # Ensures not to receive encrypted data trying to use this method
         raise NotImplementedError("recvfrom_into not allowed on instances "
                                   "of %s" % self.__class__)
 
-
     def recvmsg(self, *args, **kwargs):
         raise NotImplementedError("recvmsg not allowed on instances of %s" %
                                   self.__class__)
 
-
     def recvmsg_into(self, *args, **kwargs):
         raise NotImplementedError("recvmsg_into not allowed on instances of "
                                   "%s" % self.__class__)
 
-
     def shutdown(self, how):
         if self.native_object != _ffi.NULL:
             _lib.wolfSSL_shutdown(self.native_object)
             self._release_native_object()
         socket.shutdown(self, how)
 
-
     def unwrap(self):
         """
         Unwraps the underlying OS socket from the SSL/TLS connection.
@@ -492,7 +471,6 @@ def unwrap(self):
 
         return sock
 
-
     def do_handshake(self, block=False):
         """
         Perform a TLS/SSL handshake.
@@ -504,7 +482,6 @@ def do_handshake(self, block=False):
         if ret != _SSL_SUCCESS:
             raise SSLError("do_handshake failed with error %d" % ret)
 
-
     def _real_connect(self, addr, connect_ex):
         if self.server_side:
             raise ValueError("can't connect in server-side mode")
@@ -527,23 +504,20 @@ def _real_connect(self, addr, connect_ex):
 
         return err
 
-
     def connect(self, addr):
         """
         Connects to remote ADDR, and then wraps the connection in a secure
         channel.
         """
         self._real_connect(addr, False)
 
-
     def connect_ex(self, addr):
         """
         Connects to remote ADDR, and then wraps the connection in a secure
         channel.
         """
         return self._real_connect(addr, True)
 
-
     def accept(self):
         """
         Accepts a new connection from a remote client, and returns a tuple
@@ -580,16 +554,17 @@ def wrap_socket(sock, keyfile=None, certfile=None, server_side=False,
     The parameter server_side is a boolean which identifies whether server-side
     or client-side behavior is desired from this socket.
 
-    The parameter cert_reqs specifies whether a certificate is required from the
-    other side of the connection, and whether it will be validated if provided.
+    The parameter cert_reqs specifies whether a certificate is required from
+    the other side of the connection, and whether it will be validated if
+    provided.
     It must be one of the three values:
 
         * CERT_NONE (certificates ignored)
         * CERT_OPTIONAL (not required, but validated if provided)
         * CERT_REQUIRED (required and validated)
 
-    If the value of this parameter is not CERT_NONE, then the ca_certs parameter
-    must point to a file of CA certificates.
+    If the value of this parameter is not CERT_NONE, then the ca_certs
+    parameter must point to a file of CA certificates.
 
     The ca_certs file contains a set of concatenated “certification authority”
     certificates, which are used to validate certificates passed from the other
@@ -619,18 +594,18 @@ def wrap_socket(sock, keyfile=None, certfile=None, server_side=False,
     +------------------+-------+-----+-------+---------+---------+
 
     Note:
-        Which connections succeed will vary depending on the versions of the ssl
-        providers on both sides of the communication.
+        Which connections succeed will vary depending on the versions of the
+        ssl providers on both sides of the communication.
 
     The ciphers parameter sets the available ciphers for this SSL object. It
     should be a string in the wolfSSL cipher list format.
 
     The parameter do_handshake_on_connect specifies whether to do the SSL
     handshake automatically after doing a socket.connect(), or whether the
     application program will call it explicitly, by invoking the
-    SSLSocket.do_handshake() method. Calling SSLSocket.do_handshake() explicitly
-    gives the program control over the blocking behavior of the socket I/O
-    involved in the handshake.
+    SSLSocket.do_handshake() method. Calling SSLSocket.do_handshake()
+    explicitly gives the program control over the blocking behavior of the
+    socket I/O involved in the handshake.
 
     The parameter suppress_ragged_eofs is not supported yet.
     """

src/wolfssl/_build_ffi.py

@@ -72,7 +72,7 @@
     int  wolfSSL_CTX_set_cipher_list(void*, const char*);
     int  wolfSSL_CTX_use_PrivateKey_file(void*, const char*, int);
     int  wolfSSL_CTX_load_verify_locations(void*, const char*, const char*);
-    int  wolfSSL_CTX_load_verify_buffer(void*, const unsigned char*, long, int);
+    int  wolfSSL_CTX_load_verify_buffer(void*, const unsigned char*, long,int);
     int  wolfSSL_CTX_use_certificate_chain_file(void*, const char *);
 
     /**

src/wolfssl/_build_wolfssl.py

@@ -87,7 +87,7 @@ def checkout_version(version):
 
             call("git checkout --force {}".format(version))
 
-            return True # rebuild needed
+            return True  # rebuild needed
 
     return False
 

src/wolfssl/_memory.py

@@ -30,5 +30,6 @@
 
 _DYNAMIC_TYPE_METHOD = 11
 
+
 def _native_free(native_object, dynamic_type):
     _lib.wolfSSL_Free(native_object, _ffi.NULL, dynamic_type)

src/wolfssl/_methods.py

@@ -76,7 +76,6 @@ def __init__(self, protocol, server_side):
         if self.native_object == _ffi.NULL:
             raise MemoryError("Unnable to allocate method object")
 
-
     def __del__(self):
         if getattr(self, 'native_object', _ffi.NULL) != _ffi.NULL:
             _native_free(self.native_object, _DYNAMIC_TYPE_METHOD)