Applying black formatting

- Fixing flake8 configuration to agree with black
- Adding black validation check to github actions

examples/calculator_server.py

@@ -8,29 +8,29 @@ import calculator_capnp
 
 
 def read_value(value):
-    '''Helper function to asynchronously call read() on a Calculator::Value and
+    """Helper function to asynchronously call read() on a Calculator::Value and
     return a promise for the result.  (In the future, the generated code might
-    include something like this automatically.)'''
+    include something like this automatically.)"""
 
     return value.read().then(lambda result: result.value)
 
 
 def evaluate_impl(expression, params=None):
-    '''Implementation of CalculatorImpl::evaluate(), also shared by
+    """Implementation of CalculatorImpl::evaluate(), also shared by
     FunctionImpl::call().  In the latter case, `params` are the parameter
     values passed to the function; in the former case, `params` is just an
-    empty list.'''
+    empty list."""
 
     which = expression.which()
 
-    if which == 'literal':
+    if which == "literal":
         return capnp.Promise(expression.literal)
-    elif which == 'previousResult':
+    elif which == "previousResult":
         return read_value(expression.previousResult)
-    elif which == 'parameter':
+    elif which == "parameter":
         assert expression.parameter < len(params)
         return capnp.Promise(params[expression.parameter])
-    elif which == 'call':
+    elif which == "call":
         call = expression.call
         func = call.function
 
@@ -39,9 +39,9 @@ def evaluate_impl(expression, params=None):
 
         joinedParams = capnp.join_promises(paramPromises)
         # When the parameters are complete, call the function.
-        ret = (joinedParams
-               .then(lambda vals: func.call(vals))
-               .then(lambda result: result.value))
+        ret = joinedParams.then(lambda vals: func.call(vals)).then(
+            lambda result: result.value
+        )
 
         return ret
     else:
@@ -61,28 +61,30 @@ class ValueImpl(calculator_capnp.Calculator.Value.Server):
 
 class FunctionImpl(calculator_capnp.Calculator.Function.Server):
 
-    '''Implementation of the Calculator.Function Cap'n Proto interface, where the
-    function is defined by a Calculator.Expression.'''
+    """Implementation of the Calculator.Function Cap'n Proto interface, where the
+    function is defined by a Calculator.Expression."""
 
     def __init__(self, paramCount, body):
         self.paramCount = paramCount
         self.body = body.as_builder()
 
     def call(self, params, _context, **kwargs):
-        '''Note that we're returning a Promise object here, and bypassing the
+        """Note that we're returning a Promise object here, and bypassing the
         helper functionality that normally sets the results struct from the
         returned object. Instead, we set _context.results directly inside of
-        another promise'''
+        another promise"""
 
         assert len(params) == self.paramCount
         # using setattr because '=' is not allowed inside of lambdas
-        return evaluate_impl(self.body, params).then(lambda value: setattr(_context.results, 'value', value))
+        return evaluate_impl(self.body, params).then(
+            lambda value: setattr(_context.results, "value", value)
+        )
 
 
 class OperatorImpl(calculator_capnp.Calculator.Function.Server):
 
-    '''Implementation of the Calculator.Function Cap'n Proto interface, wrapping
-    basic binary arithmetic operators.'''
+    """Implementation of the Calculator.Function Cap'n Proto interface, wrapping
+    basic binary arithmetic operators."""
 
     def __init__(self, op):
         self.op = op
@@ -92,16 +94,16 @@ class OperatorImpl(calculator_capnp.Calculator.Function.Server):
 
         op = self.op
 
-        if op == 'add':
+        if op == "add":
             return params[0] + params[1]
-        elif op == 'subtract':
+        elif op == "subtract":
             return params[0] - params[1]
-        elif op == 'multiply':
+        elif op == "multiply":
             return params[0] * params[1]
-        elif op == 'divide':
+        elif op == "divide":
             return params[0] / params[1]
         else:
-            raise ValueError('Unknown operator')
+            raise ValueError("Unknown operator")
 
 
 class CalculatorImpl(calculator_capnp.Calculator.Server):
@@ -109,7 +111,9 @@ class CalculatorImpl(calculator_capnp.Calculator.Server):
     "Implementation of the Calculator Cap'n Proto interface."
 
     def evaluate(self, expression, _context, **kwargs):
-        return evaluate_impl(expression).then(lambda value: setattr(_context.results, 'value', ValueImpl(value)))
+        return evaluate_impl(expression).then(
+            lambda value: setattr(_context.results, "value", ValueImpl(value))
+        )
 
     def defFunction(self, paramCount, body, _context, **kwargs):
         return FunctionImpl(paramCount, body)
@@ -119,9 +123,11 @@ class CalculatorImpl(calculator_capnp.Calculator.Server):
 
 
 def parse_args():
-    parser = argparse.ArgumentParser(usage='''Runs the server bound to the\
+    parser = argparse.ArgumentParser(
+        usage="""Runs the server bound to the\
 given address/port ADDRESS may be '*' to bind to all local addresses.\
-:PORT may be omitted to choose a port automatically. ''')
+:PORT may be omitted to choose a port automatically. """
+    )
 
     parser.add_argument("address", help="ADDRESS[:PORT]")
 
@@ -137,5 +143,5 @@ def main():
         time.sleep(0.001)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()