black formatting

Author: amancevice

lambda_function.py

@@ -5,7 +5,7 @@
 import os
 import time
 
-SLEEP = os.getenv('SLEEP') or '0'
+SLEEP = os.getenv("SLEEP") or "0"
 
 
 def lambda_handler(event, context=None):
@@ -14,13 +14,13 @@ def lambda_handler(event, context=None):
     # Do some work...
     time.sleep(float(SLEEP))
     # Get name from qs
-    params = event.get('queryStringParameters') or {}
-    name = params.get('name') or 'Pythonista'
+    params = event.get("queryStringParameters") or {}
+    name = params.get("name") or "Pythonista"
     # Return response
     return {
-        'body': json.dumps({'text': f'Hello, {name}! ~ Lambda Gateway'}),
-        'statusCode': 200,
-        'headers': {
-            'Content-Type': 'application/json',
+        "body": json.dumps({"text": f"Hello, {name}! ~ Lambda Gateway"}),
+        "statusCode": 200,
+        "headers": {
+            "Content-Type": "application/json",
         },
     }

lambda_gateway/__init__.py

@@ -1,36 +1,24 @@
 import logging
-from pkg_resources import (get_distribution, DistributionNotFound)
+
+__version__ = "1.0.0"
 
 
 def set_stream_logger(name, level=logging.DEBUG, format_string=None):
     """
     Adapted from boto3.set_stream_logger()
     """
     if format_string is None:
-        format_string = \
-            '%(addr)s - - [%(asctime)s] %(levelname)s - %(message)s'
+        format_string = "%(addr)s - - [%(asctime)s] %(levelname)s - %(message)s"
 
     logger = logging.getLogger(name)
     handler = logging.StreamHandler()
-    formatter = logging.Formatter(format_string, '%-d/%b/%Y %H:%M:%S')
-    adapter = logging.LoggerAdapter(logger, dict(addr='::1'))
+    formatter = logging.Formatter(format_string, "%-d/%b/%Y %H:%M:%S")
+    adapter = logging.LoggerAdapter(logger, dict(addr="::1"))
     logger.setLevel(level)
     handler.setLevel(level)
     handler.setFormatter(formatter)
     logger.addHandler(handler)
     return adapter
 
 
-def _version():
-    """
-    Helper to get package version.
-    """
-    try:
-        return get_distribution(__name__).version
-    except DistributionNotFound:  # pragma: no cover
-        return None
-
-
-__version__ = _version()
-
 logger = set_stream_logger(__name__)

lambda_gateway/__main__.py

@@ -39,71 +39,77 @@ def get_opts():
     Get CLI options.
     """
     parser = argparse.ArgumentParser(
-        prog='lambda-gateway',
-        description='Start a simple Lambda Gateway server',
+        prog="lambda-gateway",
+        description="Start a simple Lambda Gateway server",
     )
     parser.add_argument(
-        '-B', '--base-path',
-        dest='base_path',
-        help='Set base path for REST API',
-        metavar='PATH',
+        "-B",
+        "--base-path",
+        dest="base_path",
+        help="Set base path for REST API",
+        metavar="PATH",
     )
     parser.add_argument(
-        '-b', '--bind',
-        dest='bind',
-        metavar='ADDR',
-        help='Specify alternate bind address [default: all interfaces]',
+        "-b",
+        "--bind",
+        dest="bind",
+        metavar="ADDR",
+        help="Specify alternate bind address [default: all interfaces]",
     )
     parser.add_argument(
-        '-p', '--port',
-        dest='port',
+        "-p",
+        "--port",
+        dest="port",
         default=8000,
-        help='Specify alternate port [default: 8000]',
+        help="Specify alternate port [default: 8000]",
         type=int,
     )
     parser.add_argument(
-        '-t', '--timeout',
-        dest='timeout',
-        help='Lambda timeout.',
-        metavar='SECONDS',
+        "-t",
+        "--timeout",
+        dest="timeout",
+        help="Lambda timeout.",
+        metavar="SECONDS",
         type=int,
     )
     parser.add_argument(
-        '-v', '--version',
-        action='version',
-        help='Print version and exit',
-        version=f'%(prog)s {__version__}',
+        "-v",
+        "--version",
+        action="version",
+        help="Print version and exit",
+        version=f"%(prog)s {__version__}",
     )
     parser.add_argument(
-        '-V', '--payload-version',
-        choices=['1.0', '2.0'],
-        default='2.0',
-        help='API Gateway payload version [default: 2.0]',
+        "-V",
+        "--payload-version",
+        choices=["1.0", "2.0"],
+        default="2.0",
+        help="API Gateway payload version [default: 2.0]",
     )
     parser.add_argument(
-        'HANDLER',
-        help='Lambda handler signature',
+        "HANDLER",
+        help="Lambda handler signature",
     )
     return parser.parse_args()
 
 
-def run(httpd, base_path='/'):
+def run(httpd, base_path="/"):
     """
     Run Lambda Gateway server.
 
     :param object httpd: ThreadingHTTPServer instance
     :param str base_path: REST API base path
     """
     host, port = httpd.socket.getsockname()[:2]
-    url_host = f'[{host}]' if ':' in host else host
+    url_host = f"[{host}]" if ":" in host else host
     sys.stderr.write(
-        f'Serving HTTP on {host} port {port} '
-        f'(http://{url_host}:{port}{base_path}) ...\n'
+        f"Serving HTTP on {host} port {port} "
+        f"(http://{url_host}:{port}{base_path}) ...\n"
     )
     try:
         httpd.serve_forever()
     except KeyboardInterrupt:
-        sys.stderr.write('\nKeyboard interrupt received, exiting.\n')
+        sys.stderr.write("\nKeyboard interrupt received, exiting.\n")
     finally:
         httpd.shutdown()
 
@@ -116,7 +122,7 @@ def main():
     opts = get_opts()
 
     # Ensure base_path is wrapped in slashes
-    base_path = os.path.join('/', str(opts.base_path or ''), '')
+    base_path = os.path.join("/", str(opts.base_path or ""), "")
 
     # Setup handler
     address_family, addr = get_best_family(opts.bind, opts.port)
@@ -129,5 +135,5 @@ def main():
         run(httpd, base_path)
 
 
-if __name__ == '__main__':  # pragma: no cover
+if __name__ == "__main__":  # pragma: no cover
     main()

lambda_gateway/event_proxy.py

@@ -4,7 +4,7 @@
 import os
 import sys
 
-from lambda_gateway import (lambda_context, logger)
+from lambda_gateway import lambda_context, logger
 
 
 class EventProxy:
@@ -19,8 +19,8 @@ def get_handler(self):
 
         :returns function: Lambda handler function
         """
-        *path, func = self.handler.split('.')
-        name = '.'.join(path)
+        *path, func = self.handler.split(".")
+        name = ".".join(path)
         if not name:
             raise ValueError(f"Bad handler signature '{self.handler}'")
         try:
@@ -37,23 +37,25 @@ def get_httpMethod(self, event):
         """
         Helper to get httpMethod from v1 or v2 events.
         """
-        if event.get('version') == '2.0':
-            return event['requestContext']['http']['method']
-        elif event.get('version') == '1.0':
-            return event['httpMethod']
+        if event.get("version") == "2.0":
+            return event["requestContext"]["http"]["method"]
+        elif event.get("version") == "1.0":
+            return event["httpMethod"]
         raise ValueError(  # pragma: no cover
-            f"Unknown API Gateway payload version: {event.get('version')}")
+            f"Unknown API Gateway payload version: {event.get('version')}"
+        )
 
     def get_path(self, event):
         """
         Helper to get path from v1 or v2 events.
         """
-        if event.get('version') == '2.0':
-            return event['rawPath']
-        elif event.get('version') == '1.0':
-            return event['path']
+        if event.get("version") == "2.0":
+            return event["rawPath"]
+        elif event.get("version") == "1.0":
+            return event["path"]
         raise ValueError(  # pragma: no cover
-            f"Unknown API Gateway payload version: {event.get('version')}")
+            f"Unknown API Gateway payload version: {event.get('version')}"
+        )
 
     def invoke(self, event):
         with lambda_context.start(self.timeout) as context:
@@ -73,9 +75,9 @@ async def invoke_async(self, event, context=None):
 
         # Reject request if not starting at base path
         if not path.startswith(self.base_path):
-            err = f'Rejected {path} :: Base path is {self.base_path}'
+            err = f"Rejected {path} :: Base path is {self.base_path}"
             logger.error(err)
-            return self.jsonify(httpMethod, 403, message='Forbidden')
+            return self.jsonify(httpMethod, 403, message="Forbidden")
 
         # Get & invoke Lambda handler
         try:
@@ -84,7 +86,7 @@ async def invoke_async(self, event, context=None):
             return await loop.run_in_executor(None, handler, event, context)
         except Exception as err:
             logger.error(err)
-            message = 'Internal server error'
+            message = "Internal server error"
             return self.jsonify(httpMethod, 502, message=message)
 
     async def invoke_async_with_timeout(self, event, context=None):
@@ -100,7 +102,7 @@ async def invoke_async_with_timeout(self, event, context=None):
             return await asyncio.wait_for(coroutine, self.timeout)
         except asyncio.TimeoutError:
             httpMethod = self.get_httpMethod(event)
-            message = 'Endpoint request timed out'
+            message = "Endpoint request timed out"
             return self.jsonify(httpMethod, 504, message=message)
 
     @staticmethod
@@ -112,12 +114,12 @@ def jsonify(httpMethod, statusCode, **kwargs):
         :params int statusCode: Response status code
         :params dict kwargs: Response object
         """
-        body = '' if httpMethod in ['HEAD'] else json.dumps(kwargs)
+        body = "" if httpMethod in ["HEAD"] else json.dumps(kwargs)
         return {
-            'body': body,
-            'statusCode': statusCode,
-            'headers': {
-                'Content-Type': 'application/json',
-                'Content-Length': len(body),
+            "body": body,
+            "statusCode": statusCode,
+            "headers": {
+                "Content-Type": "application/json",
+                "Content-Length": len(body),
             },
         }

lambda_gateway/lambda_context.py

@@ -17,24 +17,25 @@ class Context:
 
     :param int timeout: Lambda timeout in seconds
     """
+
     def __init__(self, timeout=None):
         self._start = datetime.utcnow()
         self._timeout = timeout or 30
 
     @property
     def function_name(self):
-        return 'lambda-gateway'
+        return "lambda-gateway"
 
     @property
     def function_version(self):
-        return '$LATEST'
+        return "$LATEST"
 
     @property
     def invoked_function_arn(self):
-        account_id = '123456789012'
-        region = 'us-east-1'
+        account_id = "123456789012"
+        region = "us-east-1"
         function_name = self.function_name
-        return f'arn:aws:lambda:{region}:{account_id}:function:{function_name}'
+        return f"arn:aws:lambda:{region}:{account_id}:function:{function_name}"
 
     @property
     def memory_limit_in_mb(self):
@@ -46,7 +47,7 @@ def aws_request_id(self):
 
     @property
     def log_group_name(self):
-        return '/aws/lambda/lambda-gateway'
+        return "/aws/lambda/lambda-gateway"
 
     @property
     def log_stream_name(self):