format: Run formatter on everything

Signed-off-by: John Andersen <[email protected]>

Author: John Andersen

.ci/run.sh

@@ -52,10 +52,16 @@ function run_whitespace() {
   fi
 }
 
+function run_style() {
+  black --check dffml tests examples
+}
+
 if [ "x$PLUGIN" != "x" ]; then
   run_plugin
 elif [ "x$CHANGELOG" != "x" ]; then
   run_changelog
 elif [ "x$WHITESPACE" != "x" ]; then
   run_whitespace
+elif [ "x$STYLE" != "x" ]; then
+  run_style
 fi

.travis.yml

@@ -20,14 +20,15 @@ env:
   - PLUGIN=feature/auth
   - CHANGELOG=1
   - WHITESPACE=1
+  - STYLE=1
 cache:
   directories:
     - /home/travis/.cache/
     - /home/travis/.local/
 before_install:
 - mkdir -p /home/travis/.cache/
 - mkdir -p /home/travis/.local/bin/
-- pip install coverage codecov sphinx sphinxcontrib-asyncio
+- pip install coverage codecov sphinx sphinxcontrib-asyncio black
 - curl -sSL https://github.com/XAMPPRocky/tokei/releases/download/v9.1.1/tokei-v9.1.1-x86_64-unknown-linux-gnu.tar.gz | tar xvz -C "$HOME/.local/bin/"
 script:
 - ./.ci/run.sh

CONTRIBUTING.md

@@ -20,10 +20,31 @@ Here are some examples:
 
 ## File Formatting
 
+- Run the [black](https://github.com/python/black) formatter on all files.
 - There shall be no trailing whitespace
 - Files should stick to 80 column width unless there is some programmatic
   constraint
 
+```console
+black dffml tests examples
+```
+
+## Test Coverage
+
+- Each pull request is expected to maintain or increase coverage.
+
+```console
+coverage run setup.py test
+coverage report -m
+coverage html
+```
+
+To view the coverage report at http://127.0.0.1:8080/.
+
+```console
+python3.7 -m http.server --directory htmlcov/ 8080
+```
+
 ## Changelog
 
 - Most PRs should include a description of what is changing to the
@@ -32,6 +53,7 @@ Here are some examples:
   change log. Maintainers will let you know if you need to include it or its not
   needed.
 
-## Community 
+## Community
 
-- Join the community. Ask questions, share ideas, request features and what not. Join our [gitter](https://gitter.im/dffml/community?utm_source=share-link&utm_medium=link&utm_campaign=share-link) room and say Hi!
+- Join the community. Ask questions, share ideas, request features and what not.
+  Join our [gitter](https://gitter.im/dffml/community) room and say Hi!

dffml/__init__.py

@@ -1,14 +1,14 @@
 # SPDX-License-Identifier: MIT
 # Copyright (c) 2019 Intel Corporation
-'''
+"""
 Education (dffml) is a package and tool for doing machine learning.
 
 It uses the setuptools dynamic discovery of services and plugins [1] to
 evaluate a package based on the installed features.
 
 [1]: http://setuptools.readthedocs.io/en/latest/setuptools.html
-'''
+"""
 from .feature import Feature
 
 # Used to declare our namespace for resource discovery
-__import__('pkg_resources').declare_namespace(__name__)
+__import__("pkg_resources").declare_namespace(__name__)

dffml/accuracy.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 # Copyright (c) 2019 Intel Corporation
 class Accuracy(float):
-
     def __str__(self):
-        return '%.02f' % (float(self) * 100.0)
+        return "%.02f" % (float(self) * 100.0)

dffml/base.py

@@ -1,7 +1,7 @@
-'''
+"""
 Base classes for DFFML. All classes in DFFML should inherit from these so that
 they follow a similar API for instantiation and usage.
-'''
+"""
 import abc
 from argparse import ArgumentParser
 from typing import Dict, Any, Tuple, NamedTuple
@@ -12,67 +12,73 @@
 
 from .log import LOGGER
 
+
 class MissingArg(Exception):
-    '''
+    """
     Raised when a BaseConfigurable is missing an argument from the args dict it
     created with args(). If this exception is raised then the config() method is
     attempting to retrive an argument which was not set in the args() method.
-    '''
+    """
+
 
 class MissingConfig(Exception):
-    '''
+    """
     Raised when a BaseConfigurable is missing an argument from the config dict.
     Also raised if there was no default value set and the argument is missing.
-    '''
+    """
+
 
 class MissingRequiredProperty(Exception):
-    '''
+    """
     Raised when a BaseDataFlowFacilitatorObject is missing some property which
     should have been defined in the class.
-    '''
+    """
+
 
 class LoggingLogger(object):
-    '''
+    """
     Provide the logger property using Python's builtin logging module.
-    '''
+    """
 
     @property
     def logger(self):
-        prop_name = '__%s_logger' % (self.__class__.__qualname__,)
+        prop_name = "__%s_logger" % (self.__class__.__qualname__,)
         logger = getattr(self, prop_name, False)
         if logger is False:
             logger = LOGGER.getChild(self.__class__.__qualname__)
             setattr(self, prop_name, logger)
         return logger
 
+
 class BaseConfig(object):
-    '''
+    """
     All DFFML Base Objects should take an object (likely a typing.NamedTuple) as
     as their config.
-    '''
+    """
 
-class ConfigurableParsingNamespace(object):
 
+class ConfigurableParsingNamespace(object):
     def __init__(self):
         self.dest = None
 
+
 class BaseConfigurable(abc.ABC):
-    '''
+    """
     Class which produces a config for itself by providing Args to a CMD (from
     dffml.util.cli.base) and then using a CMD after it contains parsed args to
     instantiate a config (deriving from BaseConfig) which will be used as the
     only parameter to the __init__ of a BaseDataFlowFacilitatorObject.
-    '''
+    """
 
     __argp = ArgumentParser()
 
     def __init__(self, config: BaseConfig) -> None:
-        '''
+        """
         BaseConfigurable takes only one argument to __init__,
         its config, which should inherit from BaseConfig. It shall be a object
         containing any information needed to configure the class and it's child
         context's.
-        '''
+        """
         self.config = config
 
     @classmethod
@@ -83,14 +89,13 @@ def add_orig_label(cls, *above):
 
     @classmethod
     def add_label(cls, *above):
-        return (
-            list(above) + cls.ENTRY_POINT_NAME + [cls.ENTRY_POINT_LABEL]
-        )
+        return list(above) + cls.ENTRY_POINT_NAME + [cls.ENTRY_POINT_LABEL]
 
     @classmethod
     def config_set(cls, args, above, *path) -> BaseConfig:
-        return traverse_config_set(args,
-                                   *(cls.add_orig_label(*above) + list(path)))
+        return traverse_config_set(
+            args, *(cls.add_orig_label(*above) + list(path))
+        )
 
     @classmethod
     def config_get(cls, config, above, *path) -> BaseConfig:
@@ -102,69 +107,77 @@ def config_get(cls, config, above, *path) -> BaseConfig:
         try:
             arg = traverse_config_get(args, *args_above)
         except KeyError as error:
-            raise MissingArg('Arg %r missing from %s%s%s' % \
-                                (args_above[-1],
-                                 cls.__qualname__,
-                                 '.' if args_above[:-1] else '',
-                                 '.'.join(args_above[:-1]),)) from error
+            raise MissingArg(
+                "Arg %r missing from %s%s%s"
+                % (
+                    args_above[-1],
+                    cls.__qualname__,
+                    "." if args_above[:-1] else "",
+                    ".".join(args_above[:-1]),
+                )
+            ) from error
         try:
             value = traverse_config_get(config, *label_above)
         except KeyError as error:
             try:
                 value = traverse_config_get(config, *no_label_above)
             except KeyError as error:
-                if 'default' in arg:
-                    return arg['default']
-                raise MissingConfig('%s missing %r from %s' % \
-                                    (cls.__qualname__,
-                                     label_above[-1],
-                                     '.'.join(label_above[:-1]),)) from error
-
-        if value is None \
-                and 'default' in arg:
-            return arg['default']
+                if "default" in arg:
+                    return arg["default"]
+                raise MissingConfig(
+                    "%s missing %r from %s"
+                    % (
+                        cls.__qualname__,
+                        label_above[-1],
+                        ".".join(label_above[:-1]),
+                    )
+                ) from error
+
+        if value is None and "default" in arg:
+            return arg["default"]
         # TODO This is a oversimplification of argparse's nargs
-        if not 'nargs' in arg:
+        if not "nargs" in arg:
             value = value[0]
-        if 'type' in arg:
+        if "type" in arg:
             # TODO This is a oversimplification of argparse's nargs
-            if 'nargs' in arg:
-                value = list(map(arg['type'], value))
+            if "nargs" in arg:
+                value = list(map(arg["type"], value))
             else:
-                value = arg['type'](value)
-        if 'action' in arg:
-            if isinstance(arg['action'], str):
+                value = arg["type"](value)
+        if "action" in arg:
+            if isinstance(arg["action"], str):
                 # HACK This accesses _pop_action_class from ArgumentParser
                 # which is prefaced with an underscore indicating it not an API
                 # we can rely on
-                arg['action'] = cls.__argp._pop_action_class(arg)
+                arg["action"] = cls.__argp._pop_action_class(arg)
             namespace = ConfigurableParsingNamespace()
-            action = arg['action'](dest='dest', option_strings='')
+            action = arg["action"](dest="dest", option_strings="")
             action(None, namespace, value)
             value = namespace.dest
         return value
 
     @classmethod
     @abc.abstractmethod
     def args(cls, *above) -> Dict[str, Any]:
-        '''
+        """
         Return a dict containing arguments required for this class
-        '''
+        """
 
     @classmethod
     @abc.abstractmethod
     def config(cls, config, *above):
-        '''
+        """
         Create the BaseConfig required to instantiate this class by parsing the
         config dict.
-        '''
+        """
 
     @classmethod
     def withconfig(cls, config, *above):
         return cls(cls.config(config, *above))
 
+
 class BaseDataFlowFacilitatorObjectContext(LoggingLogger):
-    '''
+    """
     Base class for all Data Flow Facilitator object's contexts. These are
     classes which support async context management. Classes ending with
     ...Context are the most inner context's which are used in DFFML.
@@ -173,19 +186,19 @@ class BaseDataFlowFacilitatorObjectContext(LoggingLogger):
     >>> # BaseDataFlowFacilitatorObjectContext.
     >>> async with obj() as ctx:
     >>>     await ctx.method()
-    '''
+    """
 
-    async def __aenter__(self) -> 'BaseDataFlowFacilitatorObjectContext':
+    async def __aenter__(self) -> "BaseDataFlowFacilitatorObjectContext":
         return self
 
     async def __aexit__(self, exc_type, exc_value, traceback):
         pass
 
-class BaseDataFlowFacilitatorObject(BaseDataFlowFacilitatorObjectContext, \
-                                    BaseConfigurable, \
-                                    Entrypoint,
-                                    abc.ABC):
-    '''
+
+class BaseDataFlowFacilitatorObject(
+    BaseDataFlowFacilitatorObjectContext, BaseConfigurable, Entrypoint, abc.ABC
+):
+    """
     Base class for all Data Flow Facilitator objects conforming to the
     instantiate -> enter context -> return context via __call__ -> enter
     returned context's context pattern. Therefore they must contain a CONTEXT
@@ -204,25 +217,26 @@ class BaseDataFlowFacilitatorObject(BaseDataFlowFacilitatorObjectContext, \
     >>> async with BaseDataFlowObject() as obj:
     >>>     async with obj() as ctx:
     >>>         await ctx.method()
-    '''
+    """
 
     def __init__(self, config: BaseConfig) -> None:
         BaseConfigurable.__init__(self, config)
         # TODO figure out how to call these in __new__
-        self.__ensure_property('CONTEXT')
-        self.__ensure_property('ENTRY_POINT')
+        self.__ensure_property("CONTEXT")
+        self.__ensure_property("ENTRY_POINT")
 
     def __repr__(self):
-        return '%s(%r)' % (self.__class__.__qualname__, self.config)
+        return "%s(%r)" % (self.__class__.__qualname__, self.config)
 
     @abc.abstractmethod
-    def __call__(self) -> 'BaseDataFlowFacilitatorObjectContext':
+    def __call__(self) -> "BaseDataFlowFacilitatorObjectContext":
         pass
 
     @classmethod
     def __ensure_property(cls, property_name):
         if getattr(cls, property_name, None) is None:
             raise MissingRequiredProperty(
-                    'BaseDataFlowFacilitatorObjects may not be '
-                    'created without a `%s`. Missing %s.%s' \
-                    % (property_name, cls.__qualname__, property_name,))
+                "BaseDataFlowFacilitatorObjects may not be "
+                "created without a `%s`. Missing %s.%s"
+                % (property_name, cls.__qualname__, property_name)
+            )