Start adding CI/CD

.drone.yml

@@ -3,30 +3,12 @@ type: docker
 name: test
 
 steps:
-  - name: black
-    image: pyfound/black:21.7b0
-    commands:
-      - black --check --diff --quiet .
-    depends_on: []
-
-  - name: pyflakes
-    image: alpine/flake8:3.9.2
-    commands:
-      - pyflakes .
-    depends_on: []
-
   - name: test-python-3.8
     image: python:3.8-slim
     commands:
       - python test.py
-    depends_on:
-      - black
-      - pyflakes
 
   - name: test-python-3.9
     image: python:3.9-slim
     commands:
       - python test.py
-    depends_on:
-      - black
-      - pyflakes

argclass.py

@@ -10,18 +10,18 @@ def make_gnu_option(name):
 def decide_default(field_):
     arg_cfg = {}
     if field_.default != MISSING:
-        arg_cfg["default"] = field_.default
+        arg_cfg['default'] = field_.default
     elif field_.default_factory != MISSING:
-        arg_cfg["default"] = field_.default_factory()
+        arg_cfg['default'] = field_.default_factory()
     else:
-        arg_cfg["required"] = True
+        arg_cfg['required'] = True
     return arg_cfg
 
 
 def get_choices(field_):
     arg_cfg = {}
     try:
-        arg_cfg["choices"] = field_.metadata["choices"]
+        arg_cfg['choices'] = field_.metadata['choices']
     except KeyError:
         pass
     return arg_cfg
@@ -38,16 +38,16 @@ def compute_arg_names(name, field_):
 
 def _prepare_bool(ap: ArgumentParser, name, field_):
     arg_cfg = decide_default(field_)
-    required = "required" in arg_cfg
+    required = 'required' in arg_cfg
     bool_parser = ap.add_mutually_exclusive_group(required=required)
-    bool_parser.add_argument(
+    bool_parser.add_argument(make_gnu_option(name),
-        make_gnu_option(name), action="store_true", dest=name
+                             action='store_true',
-    )
+                             dest=name)
-    bool_parser.add_argument(
+    bool_parser.add_argument(make_gnu_option(f'no_{name}'),
-        make_gnu_option(f"no_{name}"), action="store_false", dest=name
+                             action='store_false',
-    )
+                             dest=name)
     if not required:
-        ap.set_defaults(**{name: arg_cfg["default"]})
+        ap.set_defaults(**{name: arg_cfg['default']})
 
 
 def _prepare_list_cfg(name, field_):
@@ -57,14 +57,14 @@ def _prepare_list_cfg(name, field_):
     }
     subtype = typing.get_args(field_.type)
     if not subtype:
-        arg_cfg["type"] = str
+        arg_cfg['type'] = str
     else:
-        arg_cfg["type"] = subtype[0]
+        arg_cfg['type'] = subtype[0]
 
-    if field_.metadata.get("allow_empty", False):
+    if field_.metadata.get('allow_empty', False):
-        arg_cfg["nargs"] = "*"
+        arg_cfg['nargs'] = '*'
     else:
-        arg_cfg["nargs"] = "+"
+        arg_cfg['nargs'] = '+'
     return arg_cfg
 
 
@@ -73,7 +73,7 @@ def _prepare_trivial_cfg(name, field_):
         **decide_default(field_),
         **get_choices(field_),
     }
-    arg_cfg["type"] = field_.type
+    arg_cfg['type'] = field_.type
     return arg_cfg
 
 
@@ -99,6 +99,7 @@ def prepare_field(ap, name, field_):
 
 
 def argclass(cls):
+
     @classmethod
     def parse_args(cls, argv):
         ap = ArgumentParser()

pyproject.toml

@@ -4,7 +4,3 @@ requires = [
     "wheel"
 ]
 build-backend = "setuptools.build_meta"
-
-[tool.black]
-line-length = 79
-target-version = ["py38"]

test.py

@@ -1,3 +1,4 @@
+from argparse import ArgumentError, ArgumentTypeError
 import unittest
 from typing import List
 
@@ -5,14 +6,17 @@ from argclass import argclass
 
 
 class TestArgClass(unittest.TestCase):
+
     def test__required_argument(self):
+
         @argclass
         class A:
             arg1: str
 
-        assert A.parse_args(["--arg1", "hello"]) == A(arg1="hello")
+        assert A.parse_args(['--arg1', 'hello']) == A(arg1='hello')
 
     def test__required_argument_missing(self):
+
         @argclass
         class A:
             arg1: str
@@ -20,86 +24,101 @@ class TestArgClass(unittest.TestCase):
         self.assertRaises(SystemExit, A.parse_args, [])
 
     def test__required_argument_wrong_given(self):
+
         @argclass
         class A:
             arg1: str
 
-        self.assertRaises(SystemExit, A.parse_args, ["--arg2", "hello"])
+        self.assertRaises(SystemExit, A.parse_args, ['--arg2', 'hello'])
 
     def test__optional_argument_missing(self):
+
         @argclass
         class A:
-            arg2: str = "world"
+            arg2: str = 'world'
 
-        assert A.parse_args([]) == A(arg2="world")
+        assert A.parse_args([]) == A(arg2='world')
 
     def test__optional_argument_given(self):
+
         @argclass
         class A:
-            arg2: str = "world"
+            arg2: str = 'world'
 
-        assert A.parse_args(["--arg2", "welt"]) == A(arg2="welt")
+        assert A.parse_args(['--arg2', 'welt']) == A(arg2='welt')
 
     def test__optional_argument_wrong_given(self):
+
         @argclass
         class A:
-            arg2: str = "world"
+            arg2: str = 'world'
 
-        self.assertRaises(SystemExit, A.parse_args, ["--arg3", "welt"])
+        self.assertRaises(SystemExit, A.parse_args, ['--arg3', 'welt'])
 
     def test__boolean_true(self):
+
         @argclass
         class A:
             arg3: bool
 
-        assert A.parse_args(["--arg3"]) == A(arg3=True)
+        assert A.parse_args(['--arg3']) == A(arg3=True)
 
     def test__boolean_false(self):
+
         @argclass
         class A:
             arg3: bool
 
-        assert A.parse_args(["--no-arg3"]) == A(arg3=False)
+        assert A.parse_args(['--no-arg3']) == A(arg3=False)
 
     def test__int(self):
+
         @argclass
         class A:
             arg4: int
 
-        assert A.parse_args(["--arg4", "42"]) == A(arg4=42)
+        assert A.parse_args(['--arg4', '42']) == A(arg4=42)
 
     def test__int_malformed(self):
+
         @argclass
         class A:
             arg4: int
 
-        self.assertRaises(SystemExit, A.parse_args, ["--arg4", "4e2"])
+        self.assertRaises(SystemExit, A.parse_args, ['--arg4', '4e2'])
 
     def test__list(self):
+
         @argclass
         class A:
             arg5: List
 
-        assert A.parse_args(["--arg5", "hello", "world"]) == A(
+        assert (
-            arg5=["hello", "world"]
+            A.parse_args(['--arg5', 'hello', 'world'])
+            ==
+            A(arg5=['hello', 'world'])
         )
 
     def test__list_str(self):
+
         @argclass
         class A:
             arg5: List[str]
 
-        assert A.parse_args(["--arg5", "hello", "world"]) == A(
+        assert (
-            arg5=["hello", "world"]
+            A.parse_args(['--arg5', 'hello', 'world'])
+            ==
+            A(arg5=['hello', 'world'])
         )
 
     def test__list_int(self):
+
         @argclass
         class A:
             arg5: List[int]
 
-        assert A.parse_args(["--arg5", "23", "42"]) == A(arg5=[23, 42])
+        assert A.parse_args(['--arg5', '23', '42']) == A(arg5=[23, 42])
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     unittest.main()