chore: Adopt Black as an autoformatter

.appveyor.yml

@@ -12,13 +12,13 @@ environment:
   matrix:
 
   - PYTHON: "C:\\Python27-x64"
-    PYTHON_VERSION: '2.7.16'
+    PYTHON_VERSION: '2.7.17'
     PYTHON_ARCH: '64'
     LINE_COVERAGE: '91'
     NEW_FLAKE8: 0
     JAVA_HOME: "C:\\Program Files\\Java\\jdk11"
   - PYTHON: "C:\\Python36-x64"
-    PYTHON_VERSION: '3.6.8'
+    PYTHON_VERSION: '3.6.9'
     PYTHON_ARCH: '64'
     LINE_COVERAGE: '91'
     NEW_FLAKE8: 0
@@ -100,6 +100,11 @@ for:
       - sh: "sudo unzip -d /opt/gradle /tmp/gradle-*.zip"
       - sh: "PATH=/opt/gradle/gradle-5.5/bin:$PATH"
 
+      # Install black
+      - sh: "wget -O /tmp/black https://github.com/python/black/releases/download/19.3b0/black"
+      - sh: "chmod +x /tmp/black"
+      - sh: "/tmp/black --version"
+
     build_script:
       - "python -c \"import sys; print(sys.executable)\""
       - "LAMBDA_BUILDERS_DEV=1 pip install -e \".[dev]\""
@@ -111,20 +116,5 @@ for:
       # Runs only in Linux
       - "LAMBDA_BUILDERS_DEV=1 pytest -vv tests/integration"
 
-  -
-    matrix:
-      only:
-        - OLD_FLAKE8: 1
-
-    test_script:
-      - "flake8 lambda_builders"
-      - "flake8 tests/unit tests/integration"
-
-  -
-    matrix:
-      only:
-        - NEW_FLAKE8: 0
-
-    test_script:
-      - "flake8 lambda_builders"
-      - "flake8 tests/unit tests/integration --extend-ignore=W504"
+      # Validate Code was formatted with Black
+      - "/tmp/black --check setup.py tests aws_lambda_builders"

Makefile

@@ -13,17 +13,18 @@ integ-test:
 	# Integration tests don't need code coverage
 	LAMBDA_BUILDERS_DEV=1 pytest tests/integration
 
-flake:
-	# Make sure code conforms to PEP8 standards
-	flake8 lambda_builders
-	flake8 tests/unit tests/integration --extend-ignore=W504
-
 lint:
 	# Liner performs static analysis to catch latent bugs
 	pylint --rcfile .pylintrc aws_lambda_builders
 
 # Command to run everytime you make changes to verify everything works
-dev: flake lint test
+dev: lint test
+
+black:
+	black setup.py aws_lambda_builders/* tests/*
+
+black-check:
+	black --check setup.py aws_lambda_builders/* tests/*
 
 # Verifications to run before sending a pull request
-pr: init dev
+pr: init dev black-check

aws_lambda_builders/__init__.py

@@ -1,5 +1,5 @@
 """
 AWS Lambda Builder Library
 """
-__version__ = '0.6.0'
+__version__ = "0.6.0"
 RPC_PROTOCOL_VERSION = "0.3"

aws_lambda_builders/__main__.py

@@ -19,34 +19,19 @@
 log_level = int(os.environ.get("LAMBDA_BUILDERS_LOG_LEVEL", logging.INFO))
 
 # Write output to stderr because stdout is used for command response
-logging.basicConfig(stream=sys.stderr,
-                    level=log_level,
-                    format='%(message)s')
+logging.basicConfig(stream=sys.stderr, level=log_level, format="%(message)s")
 
 LOG = logging.getLogger(__name__)
 
 VERSION_REGEX = re.compile("^([0-9])+.([0-9]+)$")
 
 
 def _success_response(request_id, artifacts_dir):
-    return json.dumps({
-        "jsonrpc": "2.0",
-        "id": request_id,
-        "result": {
-            "artifacts_dir": artifacts_dir
-        }
-    })
+    return json.dumps({"jsonrpc": "2.0", "id": request_id, "result": {"artifacts_dir": artifacts_dir}})
 
 
 def _error_response(request_id, http_status_code, message):
-    return json.dumps({
-        "jsonrpc": "2.0",
-        "id": request_id,
-        "error": {
-            "code": http_status_code,
-            "message": message
-        }
-    })
+    return json.dumps({"jsonrpc": "2.0", "id": request_id, "error": {"code": http_status_code, "message": message}})
 
 
 def _parse_version(version_string):
@@ -68,8 +53,9 @@ def version_compatibility_check(version):
     # 0.2 < 0.1 comparison will fail, don't throw a value Error saying incompatible version
 
     if _parse_version(lambda_builders_protocol_version) < version:
-        ex = "Incompatible Protocol Version : {}, " \
-             "Current Protocol Version: {}".format(version, lambda_builders_protocol_version)
+        ex = "Incompatible Protocol Version : {}, " "Current Protocol Version: {}".format(
+            version, lambda_builders_protocol_version
+        )
         LOG.error(ex)
         raise ValueError(ex)
 
@@ -120,21 +106,25 @@ def main():  # pylint: disable=too-many-statements
     response = None
 
     try:
-        builder = LambdaBuilder(language=capabilities["language"],
-                                dependency_manager=capabilities["dependency_manager"],
-                                application_framework=capabilities["application_framework"],
-                                supported_workflows=supported_workflows)
+        builder = LambdaBuilder(
+            language=capabilities["language"],
+            dependency_manager=capabilities["dependency_manager"],
+            application_framework=capabilities["application_framework"],
+            supported_workflows=supported_workflows,
+        )
 
         artifacts_dir = params["artifacts_dir"]
-        builder.build(params["source_dir"],
-                      params["artifacts_dir"],
-                      params["scratch_dir"],
-                      params["manifest_path"],
-                      executable_search_paths=params.get('executable_search_paths', None),
-                      runtime=params["runtime"],
-                      optimizations=params["optimizations"],
-                      options=params["options"],
-                      mode=params.get('mode', None))
+        builder.build(
+            params["source_dir"],
+            params["artifacts_dir"],
+            params["scratch_dir"],
+            params["manifest_path"],
+            executable_search_paths=params.get("executable_search_paths", None),
+            runtime=params["runtime"],
+            optimizations=params["optimizations"],
+            options=params["options"],
+            mode=params.get("mode", None),
+        )
 
         # Return a success response
         response = _success_response(request_id, artifacts_dir)
@@ -152,5 +142,5 @@ def main():  # pylint: disable=too-many-statements
     _write_response(response, exit_code)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

aws_lambda_builders/actions.py

@@ -15,6 +15,7 @@ class ActionFailedError(Exception):
     """
     Base class for exception raised when action failed to complete. Use this to express well-known failure scenarios.
     """
+
     pass
 
 
@@ -38,12 +39,11 @@ def has_value(item):
 
 
 class _ActionMetaClass(type):
-
     def __new__(mcs, name, bases, class_dict):
 
         cls = type.__new__(mcs, name, bases, class_dict)
 
-        if cls.__name__ == 'BaseAction':
+        if cls.__name__ == "BaseAction":
             return cls
 
         # Validate class variables
@@ -78,15 +78,15 @@ def execute(self):
         :raises lambda_builders.actions.ActionFailedError: Instance of this class if something went wrong with the
             action
         """
-        raise NotImplementedError('execute')
+        raise NotImplementedError("execute")
 
     def __repr__(self):
         return "Name={}, Purpose={}, Description={}".format(self.NAME, self.PURPOSE, self.DESCRIPTION)
 
 
 class CopySourceAction(BaseAction):
 
-    NAME = 'CopySource'
+    NAME = "CopySource"
 
     DESCRIPTION = "Copying source code while skipping certain commonly excluded files"
 

aws_lambda_builders/binary_path.py

@@ -4,7 +4,6 @@
 
 
 class BinaryPath(object):
-
     def __init__(self, resolver, validator, binary, binary_path=None):
         self.resolver = resolver
         self.validator = validator

aws_lambda_builders/builder.py

@@ -11,9 +11,7 @@
 
 LOG = logging.getLogger(__name__)
 
-_SUPPORTED_WORKFLOWS = [
-    "aws_lambda_builders.workflows"
-]
+_SUPPORTED_WORKFLOWS = ["aws_lambda_builders.workflows"]
 
 
 class LambdaBuilder(object):
@@ -49,14 +47,24 @@ def __init__(self, language, dependency_manager, application_framework, supporte
             # If a module is already loaded, this call is pretty much a no-op. So it is okay to keep loading again.
             importlib.import_module(workflow_module)
 
-        self.capability = Capability(language=language,
-                                     dependency_manager=dependency_manager,
-                                     application_framework=application_framework)
+        self.capability = Capability(
+            language=language, dependency_manager=dependency_manager, application_framework=application_framework
+        )
         self.selected_workflow_cls = get_workflow(self.capability)
         LOG.debug("Found workflow '%s' to support capabilities '%s'", self.selected_workflow_cls.NAME, self.capability)
 
-    def build(self, source_dir, artifacts_dir, scratch_dir, manifest_path,
-              runtime=None, optimizations=None, options=None, executable_search_paths=None, mode=None):
+    def build(
+        self,
+        source_dir,
+        artifacts_dir,
+        scratch_dir,
+        manifest_path,
+        runtime=None,
+        optimizations=None,
+        options=None,
+        executable_search_paths=None,
+        mode=None,
+    ):
         """
         Actually build the code by running workflows
 
@@ -102,15 +110,17 @@ def build(self, source_dir, artifacts_dir, scratch_dir, manifest_path,
         if not os.path.exists(scratch_dir):
             os.makedirs(scratch_dir)
 
-        workflow = self.selected_workflow_cls(source_dir,
-                                              artifacts_dir,
-                                              scratch_dir,
-                                              manifest_path,
-                                              runtime=runtime,
-                                              optimizations=optimizations,
-                                              options=options,
-                                              executable_search_paths=executable_search_paths,
-                                              mode=mode)
+        workflow = self.selected_workflow_cls(
+            source_dir,
+            artifacts_dir,
+            scratch_dir,
+            manifest_path,
+            runtime=runtime,
+            optimizations=optimizations,
+            options=options,
+            executable_search_paths=executable_search_paths,
+            mode=mode,
+        )
 
         return workflow.run()
 

aws_lambda_builders/exceptions.py

@@ -5,7 +5,7 @@
 
 class LambdaBuilderError(Exception):
 
-    MESSAGE = ''
+    MESSAGE = ""
 
     def __init__(self, **kwargs):
         Exception.__init__(self, self.MESSAGE.format(**kwargs))
@@ -16,29 +16,36 @@ class UnsupportedManifestError(LambdaBuilderError):
 
 
 class MisMatchRuntimeError(LambdaBuilderError):
-    MESSAGE = "{language} executable found in your path does not " \
-              "match runtime. " \
-              "\n Expected version: {required_runtime}, Found version: {runtime_path}. " \
-              "\n Possibly related: https://github.com/awslabs/aws-lambda-builders/issues/30"
+    MESSAGE = (
+        "{language} executable found in your path does not "
+        "match runtime. "
+        "\n Expected version: {required_runtime}, Found version: {runtime_path}. "
+        "\n Possibly related: https://github.com/awslabs/aws-lambda-builders/issues/30"
+    )
 
 
 class WorkflowNotFoundError(LambdaBuilderError):
     """
     Raised when a workflow matching the given capabilities was not found
     """
-    MESSAGE = "Unable to find a workflow matching given capability: " \
-              "{language}, {dependency_manager}, {application_framework}"
+
+    MESSAGE = (
+        "Unable to find a workflow matching given capability: "
+        "{language}, {dependency_manager}, {application_framework}"
+    )
 
 
 class WorkflowFailedError(LambdaBuilderError):
     """
     Raised when the build failed, for well-known cases
     """
+
     MESSAGE = "{workflow_name}:{action_name} - {reason}"
 
 
 class WorkflowUnknownError(LambdaBuilderError):
     """
     Raised when the build ran into an unexpected error
     """
+
     MESSAGE = "{workflow_name}:{action_name} - {reason}"

aws_lambda_builders/path_resolver.py

@@ -6,7 +6,6 @@
 
 
 class PathResolver(object):
-
     def __init__(self, binary, runtime, executable_search_paths=None):
         self.binary = binary
         self.runtime = runtime
@@ -20,8 +19,9 @@ def _which(self):
             exec_paths.extend(paths)
 
         if not exec_paths:
-            raise ValueError("Path resolution for runtime: {} of binary: "
-                             "{} was not successful".format(self.runtime, self.binary))
+            raise ValueError(
+                "Path resolution for runtime: {} of binary: " "{} was not successful".format(self.runtime, self.binary)
+            )
         return exec_paths
 
     @property

aws_lambda_builders/registry.py

@@ -61,11 +61,9 @@ def _make_key(capability):
         # Key is created by concatenating the capabilites data with underscore.
         # This delimiter is positional ie. if a value is not provided, the delimiter still needs to exist in the key.
         # This helps us be forwards compatible with new capabilities
-        return "_".join([
-            capability.language or "",
-            capability.dependency_manager or "",
-            capability.application_framework or ""
-        ]).lower()
+        return "_".join(
+            [capability.language or "", capability.dependency_manager or "", capability.application_framework or ""]
+        ).lower()
 
 
 # Built-in registry of workflows.
@@ -92,8 +90,10 @@ def get_workflow(capability, registry=DEFAULT_REGISTRY):
     """
 
     if capability not in registry:
-        raise WorkflowNotFoundError(language=capability.language,
-                                    dependency_manager=capability.dependency_manager,
-                                    application_framework=capability.application_framework)
+        raise WorkflowNotFoundError(
+            language=capability.language,
+            dependency_manager=capability.dependency_manager,
+            application_framework=capability.application_framework,
+        )
 
     return registry[capability]