Format sourcode with black

Author: mvantellingen

Makefile

@@ -22,6 +22,10 @@ retest:
 coverage:
 	py.test --cov=zeep --cov-report=term-missing --cov-report=html
 
+format:
+	black src/ tests/
+	isort --recursive src tests
+
 docs:
 	$(MAKE) -C docs html
 

src/zeep/__init__.py

@@ -4,4 +4,4 @@
 from zeep.settings import Settings  # noqa
 from zeep.xsd.valueobjects import AnyObject  # noqa
 
-__version__ = '3.3.1'
+__version__ = "3.3.1"

src/zeep/__main__.py

@@ -13,55 +13,54 @@
 from zeep.settings import Settings
 from zeep.transports import Transport
 
-logger = logging.getLogger('zeep')
+logger = logging.getLogger("zeep")
 
 
 def parse_arguments(args=None):
-    parser = argparse.ArgumentParser(description='Zeep: The SOAP client')
+    parser = argparse.ArgumentParser(description="Zeep: The SOAP client")
     parser.add_argument(
-        'wsdl_file', type=str, help='Path or URL to the WSDL file',
-        default=None)
+        "wsdl_file", type=str, help="Path or URL to the WSDL file", default=None
+    )
+    parser.add_argument("--cache", action="store_true", help="Enable cache")
     parser.add_argument(
-        '--cache', action='store_true', help='Enable cache')
+        "--no-verify", action="store_true", help="Disable SSL verification"
+    )
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
     parser.add_argument(
-        '--no-verify', action='store_true', help='Disable SSL verification')
+        "--profile", help="Enable profiling and save output to given file"
+    )
     parser.add_argument(
-        '--verbose', action='store_true', help='Enable verbose output')
-    parser.add_argument(
-        '--profile', help="Enable profiling and save output to given file")
-    parser.add_argument(
-        '--no-strict', action='store_true', default=False,
-        help="Disable strict mode")
+        "--no-strict", action="store_true", default=False, help="Disable strict mode"
+    )
     return parser.parse_args(args)
 
 
 def main(args):
     if args.verbose:
-        logging.config.dictConfig({
-            'version': 1,
-            'formatters': {
-                'verbose': {
-                    'format': '%(name)20s: %(message)s'
-                }
-            },
-            'handlers': {
-                'console': {
-                    'level': 'DEBUG',
-                    'class': 'logging.StreamHandler',
-                    'formatter': 'verbose',
+        logging.config.dictConfig(
+            {
+                "version": 1,
+                "formatters": {"verbose": {"format": "%(name)20s: %(message)s"}},
+                "handlers": {
+                    "console": {
+                        "level": "DEBUG",
+                        "class": "logging.StreamHandler",
+                        "formatter": "verbose",
+                    }
                 },
-            },
-            'loggers': {
-                'zeep': {
-                    'level': 'DEBUG',
-                    'propagate': True,
-                    'handlers': ['console'],
+                "loggers": {
+                    "zeep": {
+                        "level": "DEBUG",
+                        "propagate": True,
+                        "handlers": ["console"],
+                    }
                 },
             }
-        })
+        )
 
     if args.profile:
         import cProfile
+
         profile = cProfile.Profile()
         profile.enable()
 
@@ -88,6 +87,6 @@ def main(args):
     client.wsdl.dump()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     args = parse_arguments()
     main(args)

src/zeep/asyncio/bindings.py

@@ -1,22 +1,21 @@
 from zeep.wsdl import bindings
 
-__all__ = ['AsyncSoap11Binding', 'AsyncSoap12Binding']
+__all__ = ["AsyncSoap11Binding", "AsyncSoap12Binding"]
 
 
 class AsyncSoapBinding(object):
-
     async def send(self, client, options, operation, args, kwargs):
         envelope, http_headers = self._create(
-            operation, args, kwargs,
-            client=client,
-            options=options)
+            operation, args, kwargs, client=client, options=options
+        )
 
         response = await client.transport.post_xml(
-            options['address'], envelope, http_headers)
+            options["address"], envelope, http_headers
+        )
 
         if client.settings.raw_response:
-            return response 
-     
+            return response
+
         operation_obj = self.get(operation)
         return self.process_reply(client, operation_obj, response)
 

src/zeep/asyncio/transport.py

@@ -20,18 +20,24 @@
     from aiohttp import Timeout as aio_timeout  # Python 3.5, aiohttp < 3
 
 
-__all__ = ['AsyncTransport']
+__all__ = ["AsyncTransport"]
 
 
 class AsyncTransport(Transport):
     """Asynchronous Transport class using aiohttp."""
-    binding_classes = [
-                bindings.AsyncSoap11Binding,
-                bindings.AsyncSoap12Binding,
-            ]
 
-    def __init__(self, loop, cache=None, timeout=300, operation_timeout=None,
-                 session=None, verify_ssl=True, proxy=None):
+    binding_classes = [bindings.AsyncSoap11Binding, bindings.AsyncSoap12Binding]
+
+    def __init__(
+        self,
+        loop,
+        cache=None,
+        timeout=300,
+        operation_timeout=None,
+        session=None,
+        verify_ssl=True,
+        proxy=None,
+    ):
 
         self.loop = loop if loop else asyncio.get_event_loop()
         self.cache = cache
@@ -43,8 +49,9 @@ def __init__(self, loop, cache=None, timeout=300, operation_timeout=None,
         self.proxy = proxy
         self.session = session or aiohttp.ClientSession(loop=self.loop)
         self._close_session = session is None
-        self.session._default_headers['User-Agent'] = (
-            'Zeep/%s (www.python-zeep.org)' % (get_version()))
+        self.session._default_headers[
+            "User-Agent"
+        ] = "Zeep/%s (www.python-zeep.org)" % (get_version())
 
     def __del__(self):
         if self._close_session:
@@ -70,9 +77,7 @@ async def _load_remote_data_async():
                     response.raise_for_status()
                 except aiohttp.ClientError as exc:
                     raise TransportError(
-                        message=str(exc),
-                        status_code=response.status,
-                        content=result
+                        message=str(exc), status_code=response.status, content=result
                     ).with_traceback(exc.__traceback__) from exc
 
         # Block until we have the data
@@ -83,11 +88,18 @@ async def post(self, address, message, headers):
         self.logger.debug("HTTP Post to %s:\n%s", address, message)
         with aio_timeout(self.operation_timeout):
             response = await self.session.post(
-                address, data=message, headers=headers,
-                verify_ssl=self.verify_ssl, proxy=self.proxy)
+                address,
+                data=message,
+                headers=headers,
+                verify_ssl=self.verify_ssl,
+                proxy=self.proxy,
+            )
             self.logger.debug(
                 "HTTP Response from %s (status: %d):\n%s",
-                address, response.status, await response.read())
+                address,
+                response.status,
+                await response.read(),
+            )
             return response
 
     async def post_xml(self, address, envelope, headers):
@@ -98,8 +110,12 @@ async def post_xml(self, address, envelope, headers):
     async def get(self, address, params, headers):
         with aio_timeout(self.operation_timeout):
             response = await self.session.get(
-                address, params=params, headers=headers,
-                verify_ssl=self.verify_ssl, proxy=self.proxy)
+                address,
+                params=params,
+                headers=headers,
+                verify_ssl=self.verify_ssl,
+                proxy=self.proxy,
+            )
 
             return await self.new_response(response)
 

src/zeep/cache.py

@@ -22,7 +22,6 @@
 
 
 class Base(object):
-
     def add(self, url, content):
         raise NotImplemented()
 
@@ -32,6 +31,7 @@ def get(self, url):
 
 class InMemoryCache(Base):
     """Simple in-memory caching using dict lookup with support for timeouts"""
+
     _cache = {}  # global cache, thread-safe by default
 
     def __init__(self, timeout=3600):
@@ -41,7 +41,8 @@ def add(self, url, content):
         logger.debug("Caching contents of %s", url)
         if not isinstance(content, (str, bytes)):
             raise TypeError(
-                "a bytes-like object is required, not {}".format(type(content).__name__))
+                "a bytes-like object is required, not {}".format(type(content).__name__)
+            )
         self._cache[url] = (datetime.datetime.utcnow(), content)
 
     def get(self, url):
@@ -59,18 +60,20 @@ def get(self, url):
 
 class SqliteCache(Base):
     """Cache contents via an sqlite database on the filesystem"""
-    _version = '1'
+
+    _version = "1"
 
     def __init__(self, path=None, timeout=3600):
 
         if sqlite3 is None:
             raise RuntimeError("sqlite3 module is required for the SqliteCache")
 
         # No way we can support this when we want to achieve thread safety
-        if path == ':memory:':
+        if path == ":memory:":
             raise ValueError(
-                "The SqliteCache doesn't support :memory: since it is not " +
-                "thread-safe. Please use zeep.cache.InMemoryCache()")
+                "The SqliteCache doesn't support :memory: since it is not "
+                + "thread-safe. Please use zeep.cache.InMemoryCache()"
+            )
 
         self._lock = threading.RLock()
         self._timeout = timeout
@@ -83,14 +86,16 @@ def __init__(self, path=None, timeout=3600):
                 """
                     CREATE TABLE IF NOT EXISTS request
                     (created timestamp, url text, content text)
-                """)
+                """
+            )
             conn.commit()
 
     @contextmanager
     def db_connection(self):
         with self._lock:
             connection = sqlite3.connect(
-                self._db_path, detect_types=sqlite3.PARSE_DECLTYPES)
+                self._db_path, detect_types=sqlite3.PARSE_DECLTYPES
+            )
             yield connection
             connection.close()
 
@@ -103,14 +108,14 @@ def add(self, url, content):
             cursor.execute("DELETE FROM request WHERE url = ?", (url,))
             cursor.execute(
                 "INSERT INTO request (created, url, content) VALUES (?, ?, ?)",
-                (datetime.datetime.utcnow(), url, data))
+                (datetime.datetime.utcnow(), url, data),
+            )
             conn.commit()
 
     def get(self, url):
         with self.db_connection() as conn:
             cursor = conn.cursor()
-            cursor.execute(
-                "SELECT created, content FROM request WHERE url=?", (url, ))
+            cursor.execute("SELECT created, content FROM request WHERE url=?", (url,))
             rows = cursor.fetchall()
 
         if rows:
@@ -130,12 +135,12 @@ def _decode_data(self, data):
         if six.PY2:
             data = str(data)
         if data.startswith(self._version_string):
-            return base64.b64decode(data[len(self._version_string):])
+            return base64.b64decode(data[len(self._version_string) :])
 
     @property
     def _version_string(self):
-        prefix = u'$ZEEP:%s$' % self._version
-        return bytes(prefix.encode('ascii'))
+        prefix = u"$ZEEP:%s$" % self._version
+        return bytes(prefix.encode("ascii"))
 
 
 def _is_expired(value, timeout):
@@ -150,12 +155,12 @@ def _is_expired(value, timeout):
 
 
 def _get_default_cache_path():
-    path = appdirs.user_cache_dir('zeep', False)
+    path = appdirs.user_cache_dir("zeep", False)
     try:
         os.makedirs(path)
     except OSError as exc:
         if exc.errno == errno.EEXIST and os.path.isdir(path):
             pass
         else:
             raise
-    return os.path.join(path, 'cache.db')
+    return os.path.join(path, "cache.db")