Apply and enable black + isort through tox (#324)

Co-authored-by: Mark Bunday <[email protected]>

Author: mabunday

pyproject.toml

@@ -0,0 +1,2 @@
+[tool.isort]
+profile = "black"

setup.py

@@ -1,49 +1,42 @@
 from __future__ import absolute_import
+
 import os
 from glob import glob
 from os.path import basename, splitext
-from setuptools import setup, find_packages
+
+from setuptools import find_packages, setup
 
 
 def read(fname):
     return open(os.path.join(os.path.dirname(__file__), fname)).read()
 
 
 setup(
-    name='sagemaker_xgboost_container',
-    version='2.0',
-    description='Open source library for creating XGBoost containers to run on Amazon SageMaker.',
-
-    packages=find_packages(where='src', exclude=('test',)),
-    package_dir={'': 'src'},
-    py_modules=[splitext(basename(path))[0] for path in glob('src/*.py')],
-
-    long_description=read('README.rst'),
-    author='Amazon Web Services',
-    license='Apache License 2.0',
-
+    name="sagemaker_xgboost_container",
+    version="2.0",
+    description="Open source library for creating XGBoost containers to run on Amazon SageMaker.",
+    packages=find_packages(where="src", exclude=("test",)),
+    package_dir={"": "src"},
+    py_modules=[splitext(basename(path))[0] for path in glob("src/*.py")],
+    long_description=read("README.rst"),
+    author="Amazon Web Services",
+    license="Apache License 2.0",
     classifiers=[
         "Development Status :: 5 - Production/Stable",
         "Intended Audience :: Developers",
         "Natural Language :: English",
         "License :: OSI Approved :: Apache Software License",
         "Programming Language :: Python",
-        'Programming Language :: Python :: 3.6',
-        'Programming Language :: Python :: 3.7',
-        'Programming Language :: Python :: 3.8',
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
     ],
-
     install_requires=read("requirements.txt"),
-
-    extras_require={
-        'test': read("test-requirements.txt")
-    },
-
+    extras_require={"test": read("test-requirements.txt")},
     entry_points={
         "console_scripts": [
             "serve=sagemaker_xgboost_container.serving:serving_entrypoint",
         ]
     },
-
-    python_requires='>=3.6',
+    python_requires=">=3.6",
 )

src/sagemaker_algorithm_toolkit/channel_validation.py

@@ -12,14 +12,14 @@
 # language governing permissions and limitations under the License.
 from sagemaker_algorithm_toolkit import exceptions as exc
 
-
 CONTENT_TYPE = "ContentType"
 TRAINING_INPUT_MODE = "TrainingInputMode"
 S3_DIST_TYPE = "S3DistributionType"
 
 
 class Channel(object):
     """Represents a single SageMaker training job channel."""
+
     FILE_MODE = "File"
     PIPE_MODE = "Pipe"
     AUGMENTED_MODE = "Augmented"
@@ -36,12 +36,13 @@ def format(self):
         """Format channel for SageMaker's CreateAlgorithm API."""
         supported_content_types = list(set(c[0] for c in self.supported))
         supported_input_modes = list(set(c[1] for c in self.supported))
-        return {"Name": self.name,
-                "Description": self.name,
-                "IsRequired": self.required,
-                "SupportedContentTypes": supported_content_types,
-                "SupportedInputModes": supported_input_modes,
-                }
+        return {
+            "Name": self.name,
+            "Description": self.name,
+            "IsRequired": self.required,
+            "SupportedContentTypes": supported_content_types,
+            "SupportedInputModes": supported_input_modes,
+        }
 
     def add(self, content_type, supported_input_mode, supported_s3_data_distribution_type):
         """Add relevant configuration as a supported configuration for the channel."""

src/sagemaker_algorithm_toolkit/exceptions.py

@@ -39,9 +39,7 @@ class BaseToolkitError(Exception):
                                  non-BaseToolkitError.
     """
 
-    def __init__(self,
-                 message=None,
-                 caused_by=None):
+    def __init__(self, message=None, caused_by=None):
         formatted_message = BaseToolkitError._format_exception_message(message, caused_by)
         super(BaseToolkitError, self).__init__(formatted_message)
         self.message = formatted_message
@@ -63,7 +61,7 @@ def _format_exception_message(message, caused_by):
         elif caused_by:
             with warnings.catch_warnings():
                 warnings.simplefilter("ignore")  # Suppress deprecation warning
-                formatted_message = getattr(caused_by, 'message', str(caused_by))
+                formatted_message = getattr(caused_by, "message", str(caused_by))
         else:
             formatted_message = "unknown error occurred"
 

src/sagemaker_algorithm_toolkit/hyperparameter_validation.py

@@ -10,20 +10,25 @@
 # distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
-import sys
 import ast
+import sys
 
 from sagemaker_algorithm_toolkit import exceptions as exc
 
 
 class Hyperparameter(object):
     """Represents a single SageMaker training job hyperparameter."""
-    def __init__(self,
-                 name,
-                 range=None,
-                 dependencies=None,
-                 required=None, default=None,
-                 tunable=False, tunable_recommended_range=None):
+
+    def __init__(
+        self,
+        name,
+        range=None,
+        dependencies=None,
+        required=None,
+        default=None,
+        tunable=False,
+        tunable_recommended_range=None,
+    ):
         if required is None and default is None:
             raise exc.AlgorithmError("At least one of 'required' or 'default' must be specified.")
 
@@ -98,12 +103,9 @@ def format_tunable_range(self):
 
         min_, max_ = self.tunable_recommended_range.format_as_integer()
         scale = self.tunable_recommended_range.scale
-        return {"IntegerParameterRanges": [{
-            "MinValue": min_,
-            "MaxValue": max_,
-            "Name": self.name,
-            "ScalingType": scale
-        }]}
+        return {
+            "IntegerParameterRanges": [{"MinValue": min_, "MaxValue": max_, "Name": self.name, "ScalingType": scale}]
+        }
 
 
 class CategoricalHyperparameter(Hyperparameter):
@@ -122,15 +124,16 @@ def _format_range_helper(self, range_):
         return range_.format()
 
     def format_range(self):
-        return {"CategoricalParameterRangeSpecification": {
-            "Values": self._format_range_helper(self.range)}}
+        return {"CategoricalParameterRangeSpecification": {"Values": self._format_range_helper(self.range)}}
 
     def format_tunable_range(self):
         if not self.tunable or self.tunable_recommended_range is None:
             return None
-        return {"CategoricalParameterRanges": [
-            {"Name": self.name,
-             "Values": self._format_range_helper(self.tunable_recommended_range)}]}
+        return {
+            "CategoricalParameterRanges": [
+                {"Name": self.name, "Values": self._format_range_helper(self.tunable_recommended_range)}
+            ]
+        }
 
 
 class ContinuousHyperparameter(Hyperparameter):
@@ -156,11 +159,9 @@ def format_tunable_range(self):
 
         min_, max_ = self.tunable_recommended_range.format_as_continuous()
         scale = self.tunable_recommended_range.scale
-        return {"ContinuousParameterRanges": [
-            {"Name": self.name,
-             "MinValue": min_,
-             "MaxValue": max_,
-             "ScalingType": scale}]}
+        return {
+            "ContinuousParameterRanges": [{"Name": self.name, "MinValue": min_, "MaxValue": max_, "ScalingType": scale}]
+        }
 
 
 class CommaSeparatedListHyperparameter(Hyperparameter):
@@ -191,9 +192,7 @@ def parse(self, value):
 
     def format_range(self):
         min_, max_ = self.range.format_as_integer()
-        return {"NestedParameterRangeSpecification": {
-            "MinValue": min_,
-            "MaxValue": max_}}
+        return {"NestedParameterRangeSpecification": {"MinValue": min_, "MaxValue": max_}}
 
     def validate_range(self, value):
         if any([element not in self.range for outer in value for element in outer]):
@@ -213,8 +212,7 @@ def parse(self, value):
             return value
 
     def format_range(self):
-        return {"TupleParameterRangeSpecification": {
-            "Values": self.range}}
+        return {"TupleParameterRangeSpecification": {"Values": self.range}}
 
     def validate_range(self, value):
         if any([element not in self.range for element in value]):
@@ -290,8 +288,9 @@ def validate(self, user_hyperparameters):
             except exc.UserError:
                 raise
             except Exception as e:
-                raise exc.AlgorithmError("Hyperparameter {}: unexpected failure when validating {}".format(hp, value),
-                                         caused_by=e)
+                raise exc.AlgorithmError(
+                    "Hyperparameter {}: unexpected failure when validating {}".format(hp, value), caused_by=e
+                )
 
         # NOTE: 4. Validate dependencies.
         sorted_deps = self._sort_dependencies(converted_hyperparameters.keys())
@@ -300,9 +299,11 @@ def validate(self, user_hyperparameters):
             hp = sorted_deps.pop()
             value = converted_hyperparameters[hp]
             if self.hyperparameters[hp].dependencies:
-                dependencies = {hp_d: new_validated_hyperparameters[hp_d]
-                                for hp_d in self.hyperparameters[hp].dependencies
-                                if hp_d in new_validated_hyperparameters}
+                dependencies = {
+                    hp_d: new_validated_hyperparameters[hp_d]
+                    for hp_d in self.hyperparameters[hp].dependencies
+                    if hp_d in new_validated_hyperparameters
+                }
                 self.hyperparameters[hp].validate_dependencies(value, dependencies)
             new_validated_hyperparameters[hp] = value
 
@@ -312,12 +313,12 @@ def __getitem__(self, name):
         return self.hyperparameters[name]
 
     def format(self):
-        return [hyperparameter.format()
-                for name, hyperparameter in self.hyperparameters.items()]
+        return [hyperparameter.format() for name, hyperparameter in self.hyperparameters.items()]
 
 
 class Range:
     """Abstract interface for Hyperparameter.range objects."""
+
     def __contains__(self, value):
         raise NotImplementedError
 
@@ -363,30 +364,34 @@ def __str__(self):
 
     def __contains__(self, value):
         return not (
-            (self.min_open is not None and value <= self.min_open) or
-            (self.min_closed is not None and value < self.min_closed) or
-            (self.max_open is not None and value >= self.max_open) or
-            (self.max_closed is not None and value > self.max_closed))
+            (self.min_open is not None and value <= self.min_open)
+            or (self.min_closed is not None and value < self.min_closed)
+            or (self.max_open is not None and value >= self.max_open)
+            or (self.max_closed is not None and value > self.max_closed)
+        )
 
     def _format_range_value(self, open_, closed, default):
-        return str(open_ if open_ is not None
-                   else closed if closed is not None
-                   else default)
+        return str(open_ if open_ is not None else closed if closed is not None else default)
 
     def format_as_integer(self):
-        max_neg_signed_int = -2 ** 31
+        max_neg_signed_int = -(2 ** 31)
         max_signed_int = 2 ** 31 - 1
-        return (self._format_range_value(self.min_open, self.min_closed, max_neg_signed_int),
-                self._format_range_value(self.max_open, self.max_closed, max_signed_int))
+        return (
+            self._format_range_value(self.min_open, self.min_closed, max_neg_signed_int),
+            self._format_range_value(self.max_open, self.max_closed, max_signed_int),
+        )
 
     def format_as_continuous(self):
         max_float = sys.float_info.max
-        return (self._format_range_value(self.min_open, self.min_closed, -max_float),
-                self._format_range_value(self.max_open, self.max_closed, max_float))
+        return (
+            self._format_range_value(self.min_open, self.min_closed, -max_float),
+            self._format_range_value(self.max_open, self.max_closed, max_float),
+        )
 
 
 class range_validator:
     """Function decorator helper to override hyperparameter's range validation."""
+
     def __init__(self, range):
         self.range = range
 
@@ -400,11 +405,13 @@ def __str__(self_):
 
             def __contains__(self_, value):
                 return f(self.range, value)
+
         return inner()
 
 
 class dependencies_validator:
     """Function decorator helper to override hyperparameter's dependency validation."""
+
     def __init__(self, dependencies):
         self.dependencies = dependencies
 
@@ -421,4 +428,5 @@ def __next__(self):
 
             def __call__(self, value, dependencies):
                 return f(value, dependencies)
+
         return inner()