Lint fixes with black and isort

Author: aaltat

.flake8

@@ -0,0 +1,5 @@
+[flake8]
+exclude =
+    __pycache__,
+ignore = E203
+max-line-length = 120

.github/workflows/CI.yml

@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.6, 3.9, pypy3, 3.10.0-rc.1]
+        python-version: [3.6, 3.9, 3.10.0-rc.1]
         rf-version: [4.0.2, 4.1.1]
 
     steps:
@@ -26,7 +26,10 @@ jobs:
         pip install -U --pre robotframework==${{ matrix.rf-version }}
     - name: Run flake8
       run: |
-        flake8 --max-line-length=110 src/
+        flake8 --config .flake8 src/
+    - name: Run balck
+      run: |
+        black --target-version py36 --line-length 120 --check src/
     - name: Run unit tests
       run: |
         python utest/run.py

requirements-dev.txt

@@ -3,3 +3,5 @@ pytest-cov
 pytest-mockito
 robotstatuschecker
 flake8
+black
+isort

src/robotlibcore.py

@@ -24,11 +24,10 @@
 
 from robot.api.deco import keyword  # noqa F401
 
-__version__ = '3.0.1.dev1'
+__version__ = "3.0.1.dev1"
 
 
 class HybridCore:
-
     def __init__(self, library_components):
         self.keywords = {}
         self.keywords_spec = {}
@@ -37,10 +36,10 @@ def __init__(self, library_components):
         self.add_library_components([self])
 
     def add_library_components(self, library_components):
-        self.keywords_spec['__init__'] = KeywordBuilder.build(self.__init__)
+        self.keywords_spec["__init__"] = KeywordBuilder.build(self.__init__)
         for component in library_components:
             for name, func in self.__get_members(component):
-                if callable(func) and hasattr(func, 'robot_name'):
+                if callable(func) and hasattr(func, "robot_name"):
                     kw = getattr(component, name)
                     kw_name = func.robot_name or name
                     self.keywords[kw_name] = kw
@@ -53,12 +52,14 @@ def __get_members(self, component):
         if inspect.ismodule(component):
             return inspect.getmembers(component)
         if inspect.isclass(component):
-            raise TypeError('Libraries must be modules or instances, got '
-                            'class {!r} instead.'.format(component.__name__))
+            raise TypeError(
+                "Libraries must be modules or instances, got " "class {!r} instead.".format(component.__name__)
+            )
         if type(component) != component.__class__:
-            raise TypeError('Libraries must be modules or new-style class '
-                            'instances, got old-style class {!r} instead.'
-                            .format(component.__class__.__name__))
+            raise TypeError(
+                "Libraries must be modules or new-style class "
+                "instances, got old-style class {!r} instead.".format(component.__class__.__name__)
+            )
         return self.__get_members_from_instance(component)
 
     def __get_members_from_instance(self, instance):
@@ -71,8 +72,7 @@ def __get_members_from_instance(self, instance):
     def __getattr__(self, name):
         if name in self.attributes:
             return self.attributes[name]
-        raise AttributeError('{!r} object has no attribute {!r}'
-                             .format(type(self).__name__, name))
+        raise AttributeError("{!r} object has no attribute {!r}".format(type(self).__name__, name))
 
     def __dir__(self):
         my_attrs = super().__dir__()
@@ -83,7 +83,6 @@ def get_keyword_names(self):
 
 
 class DynamicCore(HybridCore):
-
     def run_keyword(self, name, args, kwargs=None):
         return self.keywords[name](*args, **(kwargs or {}))
 
@@ -95,8 +94,8 @@ def get_keyword_tags(self, name):
         return self.keywords[name].robot_tags
 
     def get_keyword_documentation(self, name):
-        if name == '__intro__':
-            return inspect.getdoc(self) or ''
+        if name == "__intro__":
+            return inspect.getdoc(self) or ""
         spec = self.keywords_spec.get(name)
         return spec.documentation
 
@@ -107,9 +106,9 @@ def get_keyword_types(self, name):
         return spec.argument_types
 
     def __get_keyword(self, keyword_name):
-        if keyword_name == '__init__':
+        if keyword_name == "__init__":
             return self.__init__
-        if keyword_name.startswith('__') and keyword_name.endswith('__'):
+        if keyword_name.startswith("__") and keyword_name.endswith("__"):
             return None
         method = self.keywords.get(keyword_name)
         if not method:
@@ -121,11 +120,11 @@ def get_keyword_source(self, keyword_name):
         path = self.__get_keyword_path(method)
         line_number = self.__get_keyword_line(method)
         if path and line_number:
-            return '{}:{}'.format(path, line_number)
+            return "{}:{}".format(path, line_number)
         if path:
             return path
         if line_number:
-            return ':%s' % line_number
+            return ":%s" % line_number
         return None
 
     def __get_keyword_line(self, method):
@@ -134,7 +133,7 @@ def __get_keyword_line(self, method):
         except (OSError, TypeError):
             return None
         for increment, line in enumerate(lines):
-            if line.strip().startswith('def '):
+            if line.strip().startswith("def "):
                 return line_number + increment
         return line_number
 
@@ -146,13 +145,12 @@ def __get_keyword_path(self, method):
 
 
 class KeywordBuilder:
-
     @classmethod
     def build(cls, function):
         return KeywordSpecification(
             argument_specification=cls._get_arguments(function),
-            documentation=inspect.getdoc(function) or '',
-            argument_types=cls._get_types(function)
+            documentation=inspect.getdoc(function) or "",
+            argument_types=cls._get_types(function),
         )
 
     @classmethod
@@ -163,9 +161,7 @@ def unwrap(cls, function):
     def _get_arguments(cls, function):
         unwrap_function = cls.unwrap(function)
         arg_spec = cls._get_arg_spec(unwrap_function)
-        argument_specification = cls._get_default_and_named_args(
-            arg_spec, function
-        )
+        argument_specification = cls._get_default_and_named_args(arg_spec, function)
         argument_specification.extend(cls._get_var_args(arg_spec))
         kw_only_args = cls._get_kw_only(arg_spec)
         if kw_only_args:
@@ -198,12 +194,12 @@ def _drop_self_from_args(cls, function, arg_spec):
     @classmethod
     def _get_var_args(cls, arg_spec):
         if arg_spec.varargs:
-            return ['*%s' % arg_spec.varargs]
+            return ["*%s" % arg_spec.varargs]
         return []
 
     @classmethod
     def _get_kwargs(cls, arg_spec):
-        return ['**%s' % arg_spec.varkw] if arg_spec.varkw else []
+        return ["**%s" % arg_spec.varkw] if arg_spec.varkw else []
 
     @classmethod
     def _get_kw_only(cls, arg_spec):
@@ -212,15 +208,15 @@ def _get_kw_only(cls, arg_spec):
             if not arg_spec.kwonlydefaults or arg not in arg_spec.kwonlydefaults:
                 kw_only_args.append(arg)
             else:
-                value = arg_spec.kwonlydefaults.get(arg, '')
+                value = arg_spec.kwonlydefaults.get(arg, "")
                 kw_only_args.append((arg, value))
         return kw_only_args
 
     @classmethod
     def _get_types(cls, function):
         if function is None:
             return function
-        types = getattr(function, 'robot_types', ())
+        types = getattr(function, "robot_types", ())
         if types is None or types:
             return types
         return cls._get_typing_hints(function)
@@ -255,12 +251,11 @@ def _args_as_list(cls, function, arg_spec):
     def _get_defaults(cls, arg_spec):
         if not arg_spec.defaults:
             return {}
-        names = arg_spec.args[-len(arg_spec.defaults):]
+        names = arg_spec.args[-len(arg_spec.defaults) :]
         return zip(names, arg_spec.defaults)
 
 
 class KeywordSpecification:
-
     def __init__(self, argument_specification=None, documentation=None, argument_types=None):
         self.argument_specification = argument_specification
         self.documentation = documentation

tasks.py

@@ -118,3 +118,12 @@ def init_labels(ctx, username=None, password=None):
     when labels it uses have changed.
     """
     initialize_labels(REPOSITORY, username, password)
+
+@task
+def lint(ctx):
+    print("Run flake8")
+    ctx.run("flake8 --config .flake8 src/")
+    print("Run black")
+    ctx.run("black --target-version py36 --line-length 120 src/")
+    print("Run isort")
+    ctx.run("isort src/")