Blacken the project (#141)

1 files changed, 159 insertions, 128 deletions

diff --git a/examples/statemachine/statemachine.py b/examples/statemachine/statemachine.py
index 4c8ee1d..a5f144e 100644
--- a/examples/statemachine/statemachine.py
+++ b/examples/statemachine/statemachine.py
@@ -18,7 +18,8 @@ import pyparsing as pp
 
 # define basic exception for invalid state transitions - state machine classes will subclass to
 # define their own specific exception type
-class InvalidTransitionException(Exception): pass
+class InvalidTransitionException(Exception):
+    pass
 
 
 ident = pp.Word(pp.alphas + "_", pp.alphanums + "_$")
@@ -28,17 +29,30 @@ ident = pp.Word(pp.alphas + "_", pp.alphanums + "_$")
 def no_keywords_allowed(s, l, t):
     wd = t[0]
     return not keyword.iskeyword(wd)
-ident.addCondition(no_keywords_allowed, message="cannot use a Python keyword for state or transition identifier")
 
-stateTransition = ident("from_state") + "->" + ident("to_state")
-stateMachine = (pp.Keyword("statemachine") + ident("name") + ":"
-                + pp.OneOrMore(pp.Group(stateTransition))("transitions"))
 
-namedStateTransition = (ident("from_state")
-                        + "-(" + ident("transition") + ")->"
-                        + ident("to_state"))
-namedStateMachine = (pp.Keyword("statemachine") + ident("name") + ":"
-                     + pp.OneOrMore(pp.Group(namedStateTransition))("transitions"))
+ident.addCondition(
+    no_keywords_allowed,
+    message="cannot use a Python keyword for state or transition identifier",
+)
+
+stateTransition = ident("from_state") + "->" + ident("to_state")
+stateMachine = (
+    pp.Keyword("statemachine")
+    + ident("name")
+    + ":"
+    + pp.OneOrMore(pp.Group(stateTransition))("transitions")
+)
+
+namedStateTransition = (
+    ident("from_state") + "-(" + ident("transition") + ")->" + ident("to_state")
+)
+namedStateMachine = (
+    pp.Keyword("statemachine")
+    + ident("name")
+    + ":"
+    + pp.OneOrMore(pp.Group(namedStateTransition))("transitions")
+)
 
 
 def expand_state_definition(source, loc, tokens):
@@ -58,50 +72,53 @@ def expand_state_definition(source, loc, tokens):
 
     # define base class for state classes
     baseStateClass = tokens.name
-    statedef.extend([
-        "class %s(object):" % baseStateClass,
-        "    def __str__(self):",
-        "        return self.__class__.__name__",
-
-        "    @classmethod",
-        "    def states(cls):",
-        "        return list(cls.__subclasses__())",
-
-        "    def next_state(self):",
-        "        return self._next_state_class()",
-    ])
+    statedef.extend(
+        [
+            "class %s(object):" % baseStateClass,
+            "    def __str__(self):",
+            "        return self.__class__.__name__",
+            "    @classmethod",
+            "    def states(cls):",
+            "        return list(cls.__subclasses__())",
+            "    def next_state(self):",
+            "        return self._next_state_class()",
+        ]
+    )
 
     # define all state classes
     statedef.extend("class {}({}): pass".format(s, baseStateClass) for s in states)
 
     # define state->state transitions
-    statedef.extend("{}._next_state_class = {}".format(s, fromTo[s]) for s in states if s in fromTo)
-
-    statedef.extend([
-        "class {baseStateClass}Mixin:".format(baseStateClass=baseStateClass),
-        "    def __init__(self):",
-        "        self._state = None",
-
-        "    def initialize_state(self, init_state):",
-        "        if issubclass(init_state, {baseStateClass}):".format(baseStateClass=baseStateClass),
-        "            init_state = init_state()",
-        "        self._state = init_state",
-
-        "    @property",
-        "    def state(self):",
-        "        return self._state",
-
-        "    # get behavior/properties from current state",
-        "    def __getattr__(self, attrname):",
-        "        attr = getattr(self._state, attrname)",
-        "        return attr",
+    statedef.extend(
+        "{}._next_state_class = {}".format(s, fromTo[s]) for s in states if s in fromTo
+    )
 
-        "    def __str__(self):",
-        "       return '{0}: {1}'.format(self.__class__.__name__, self._state)",
-        ])
+    statedef.extend(
+        [
+            "class {baseStateClass}Mixin:".format(baseStateClass=baseStateClass),
+            "    def __init__(self):",
+            "        self._state = None",
+            "    def initialize_state(self, init_state):",
+            "        if issubclass(init_state, {baseStateClass}):".format(
+                baseStateClass=baseStateClass
+            ),
+            "            init_state = init_state()",
+            "        self._state = init_state",
+            "    @property",
+            "    def state(self):",
+            "        return self._state",
+            "    # get behavior/properties from current state",
+            "    def __getattr__(self, attrname):",
+            "        attr = getattr(self._state, attrname)",
+            "        return attr",
+            "    def __str__(self):",
+            "       return '{0}: {1}'.format(self.__class__.__name__, self._state)",
+        ]
+    )
 
     return ("\n" + indent).join(statedef) + "\n"
 
+
 stateMachine.setParseAction(expand_state_definition)
 
 
@@ -134,102 +151,115 @@ def expand_named_state_definition(source, loc, tokens):
             fromTo[s] = {}
 
     # define state transition class
-    statedef.extend([
-        "class {baseStateClass}Transition:".format(baseStateClass=baseStateClass),
-        "    def __str__(self):",
-        "        return self.transitionName",
-    ])
     statedef.extend(
-        "{tn_name} = {baseStateClass}Transition()".format(tn_name=tn,
-                                                          baseStateClass=baseStateClass)
-        for tn in transitions)
-    statedef.extend("{tn_name}.transitionName = '{tn_name}'".format(tn_name=tn)
-                    for tn in transitions)
+        [
+            "class {baseStateClass}Transition:".format(baseStateClass=baseStateClass),
+            "    def __str__(self):",
+            "        return self.transitionName",
+        ]
+    )
+    statedef.extend(
+        "{tn_name} = {baseStateClass}Transition()".format(
+            tn_name=tn, baseStateClass=baseStateClass
+        )
+        for tn in transitions
+    )
+    statedef.extend(
+        "{tn_name}.transitionName = '{tn_name}'".format(tn_name=tn)
+        for tn in transitions
+    )
 
     # define base class for state classes
-    statedef.extend([
-        "class %s(object):" % baseStateClass,
-        "    from statemachine import InvalidTransitionException as BaseTransitionException",
-        "    class InvalidTransitionException(BaseTransitionException): pass",
-        "    def __str__(self):",
-        "        return self.__class__.__name__",
-
-        "    @classmethod",
-        "    def states(cls):",
-        "        return list(cls.__subclasses__())",
-
-        "    @classmethod",
-        "    def next_state(cls, name):",
-        "        try:",
-        "            return cls.tnmap[name]()",
-        "        except KeyError:",
-        "            raise cls.InvalidTransitionException('%s does not support transition %r'% (cls.__name__, name))",
-
-        "    def __bad_tn(name):",
-        "        def _fn(cls):",
-        "            raise cls.InvalidTransitionException('%s does not support transition %r'% (cls.__name__, name))",
-        "        _fn.__name__ = name",
-        "        return _fn",
-    ])
+    statedef.extend(
+        [
+            "class %s(object):" % baseStateClass,
+            "    from statemachine import InvalidTransitionException as BaseTransitionException",
+            "    class InvalidTransitionException(BaseTransitionException): pass",
+            "    def __str__(self):",
+            "        return self.__class__.__name__",
+            "    @classmethod",
+            "    def states(cls):",
+            "        return list(cls.__subclasses__())",
+            "    @classmethod",
+            "    def next_state(cls, name):",
+            "        try:",
+            "            return cls.tnmap[name]()",
+            "        except KeyError:",
+            "            raise cls.InvalidTransitionException('%s does not support transition %r'% (cls.__name__, name))",
+            "    def __bad_tn(name):",
+            "        def _fn(cls):",
+            "            raise cls.InvalidTransitionException('%s does not support transition %r'% (cls.__name__, name))",
+            "        _fn.__name__ = name",
+            "        return _fn",
+        ]
+    )
 
     # define default 'invalid transition' methods in base class, valid transitions will be implemented in subclasses
     statedef.extend(
         "    {tn_name} = classmethod(__bad_tn({tn_name!r}))".format(tn_name=tn)
-        for tn in transitions)
+        for tn in transitions
+    )
 
     # define all state classes
-    statedef.extend("class {}({}): pass".format(s, baseStateClass)
-                    for s in states)
+    statedef.extend("class {}({}): pass".format(s, baseStateClass) for s in states)
 
     # define state transition methods for valid transitions from each state
     for s in states:
         trns = list(fromTo[s].items())
         # statedef.append("%s.tnmap = {%s}" % (s, ", ".join("%s:%s" % tn for tn in trns)))
-        statedef.extend("{}.{} = classmethod(lambda cls: {}())".format(s, tn_, to_)
-                        for tn_, to_ in trns)
-
-    statedef.extend([
-        "{baseStateClass}.transitions = classmethod(lambda cls: [{transition_class_list}])".format(
-            baseStateClass=baseStateClass,
-            transition_class_list = ', '.join("cls.{}".format(tn) for tn in transitions)
-        ),
-        "{baseStateClass}.transition_names = [tn.__name__ for tn in {baseStateClass}.transitions()]".format(
-            baseStateClass=baseStateClass
+        statedef.extend(
+            "{}.{} = classmethod(lambda cls: {}())".format(s, tn_, to_)
+            for tn_, to_ in trns
         )
-    ])
-
-    # define <state>Mixin class for application classes that delegate to the state
-    statedef.extend([
-        "class {baseStateClass}Mixin:".format(baseStateClass=baseStateClass),
-        "    def __init__(self):",
-        "        self._state = None",
-
-        "    def initialize_state(self, init_state):",
-        "        if issubclass(init_state, {baseStateClass}):".format(baseStateClass=baseStateClass),
-        "            init_state = init_state()",
-        "        self._state = init_state",
 
-        "    @property",
-        "    def state(self):",
-        "        return self._state",
-
-        "    # get behavior/properties from current state",
-        "    def __getattr__(self, attrname):",
-        "        attr = getattr(self._state, attrname)",
-        "        return attr",
-
-        "    def __str__(self):",
-        "       return '{0}: {1}'.format(self.__class__.__name__, self._state)",
+    statedef.extend(
+        [
+            "{baseStateClass}.transitions = classmethod(lambda cls: [{transition_class_list}])".format(
+                baseStateClass=baseStateClass,
+                transition_class_list=", ".join(
+                    "cls.{}".format(tn) for tn in transitions
+                ),
+            ),
+            "{baseStateClass}.transition_names = [tn.__name__ for tn in {baseStateClass}.transitions()]".format(
+                baseStateClass=baseStateClass
+            ),
+        ]
+    )
 
-    ])
+    # define <state>Mixin class for application classes that delegate to the state
+    statedef.extend(
+        [
+            "class {baseStateClass}Mixin:".format(baseStateClass=baseStateClass),
+            "    def __init__(self):",
+            "        self._state = None",
+            "    def initialize_state(self, init_state):",
+            "        if issubclass(init_state, {baseStateClass}):".format(
+                baseStateClass=baseStateClass
+            ),
+            "            init_state = init_state()",
+            "        self._state = init_state",
+            "    @property",
+            "    def state(self):",
+            "        return self._state",
+            "    # get behavior/properties from current state",
+            "    def __getattr__(self, attrname):",
+            "        attr = getattr(self._state, attrname)",
+            "        return attr",
+            "    def __str__(self):",
+            "       return '{0}: {1}'.format(self.__class__.__name__, self._state)",
+        ]
+    )
 
     # define transition methods to be delegated to the _state instance variable
     statedef.extend(
-        "    def {tn_name}(self): self._state = self._state.{tn_name}()".format(tn_name=tn)
+        "    def {tn_name}(self): self._state = self._state.{tn_name}()".format(
+            tn_name=tn
+        )
         for tn in transitions
     )
     return ("\n" + indent).join(statedef) + "\n"
 
+
 namedStateMachine.setParseAction(expand_named_state_definition)
 
 
@@ -248,15 +278,15 @@ class SuffixImporter:
     :meth:`register` on your class to actually install it in the appropriate
     places in :mod:`sys`. """
 
-    scheme = 'suffix'
+    scheme = "suffix"
     suffix = None
     path_entry = None
 
     @classmethod
     def trigger_url(cls):
         if cls.suffix is None:
-            raise ValueError('%s.suffix is not set' % cls.__name__)
-        return 'suffix:%s' % cls.suffix
+            raise ValueError("%s.suffix is not set" % cls.__name__)
+        return "suffix:%s" % cls.suffix
 
     @classmethod
     def register(cls):
@@ -279,7 +309,7 @@ class SuffixImporter:
             # it probably isn't even a filesystem path
             finder = sys.path_importer_cache.get(dirpath)
             if isinstance(finder, (type(None), importlib.machinery.FileFinder)):
-                checkpath = os.path.join(dirpath, '{}.{}'.format(fullname, self.suffix))
+                checkpath = os.path.join(dirpath, "{}.{}".format(fullname, self.suffix))
                 yield checkpath
 
     def find_module(self, fullname, path=None):
@@ -311,25 +341,26 @@ class SuffixImporter:
 
 
 class PystateImporter(SuffixImporter):
-    suffix = 'pystate'
+    suffix = "pystate"
 
     def process_filedata(self, module, data):
         # MATT-NOTE: re-worked :func:`get_state_machine`
 
         # convert any statemachine expressions
-        stateMachineExpr = (stateMachine | namedStateMachine).ignore(pp.pythonStyleComment)
+        stateMachineExpr = (stateMachine | namedStateMachine).ignore(
+            pp.pythonStyleComment
+        )
         generated_code = stateMachineExpr.transformString(data)
 
-        if DEBUG: print(generated_code)
+        if DEBUG:
+            print(generated_code)
 
         # compile code object from generated code
         # (strip trailing spaces and tabs, compile doesn't like
         # dangling whitespace)
-        COMPILE_MODE = 'exec'
+        COMPILE_MODE = "exec"
 
-        codeobj = compile(generated_code.rstrip(" \t"),
-                          module.__file__,
-                          COMPILE_MODE)
+        codeobj = compile(generated_code.rstrip(" \t"), module.__file__, COMPILE_MODE)
 
         exec(codeobj, module.__dict__)