Use ruff for formatting

Author: Kuba314

.github/workflows/python.yml

@@ -23,6 +23,8 @@ jobs:
       uses: abatilo/actions-poetry@v2
     - name: Install poetry project
       run: poetry install
+    - name: Format
+      run: poetry run ruff format --check
     - name: Lint
       run: poetry run ruff check --extend-select I
     - name: Run pyright

arcparse/_argument_helpers.py

@@ -17,7 +17,7 @@
 
 def _check_short_format(short: str) -> None:
     if not re.match(r"^-[^-]+$", short):
-        raise InvalidArgument(f"Invalid argument short-hand \"{short}\", expected a dash followed by non-dash characters")
+        raise InvalidArgument(f'Invalid argument short-hand "{short}", expected a dash followed by non-dash characters')
 
 
 def positional[T](
@@ -203,6 +203,7 @@ class Args:
     """
     ...
 
+
 @overload
 def subparsers[T](**kwargs: type[T]) -> T:
     """
@@ -218,6 +219,7 @@ class Args:
     """
     ...
 
+
 def subparsers(*args, **kwargs) -> Any:
     if args:
         assert all(isinstance(arg, str) for arg in args)
@@ -252,7 +254,6 @@ def dict_positional[T](
     )
 
 
-
 def dict_option[T](
     dict_: dict[str, T],
     *,

arcparse/_partial_arguments.py

@@ -37,8 +37,7 @@ class BasePartialArgument[R: ContainerApplicable](ABC):
     mx_group: PartialMxGroup | None = None
 
     @abstractmethod
-    def resolve_with_typehint(self, name: str, typehint: type) -> R:
-        ...
+    def resolve_with_typehint(self, name: str, typehint: type) -> R: ...
 
     def resolve_to_kwargs(self, name: str, typehint: type) -> dict[str, Any]:
         return {}
@@ -75,7 +74,9 @@ def resolve_to_kwargs(self, name: str, typehint: type) -> dict[str, Any]:
             if get_origin(typehint) in {Union, UnionType}:
                 union_args = get_args(typehint)
                 if len(union_args) > 2 or NoneType not in union_args:
-                    raise InvalidTypehint("Union can be used only for optional arguments (length of 2, 1 of them being None)")
+                    raise InvalidTypehint(
+                        "Union can be used only for optional arguments (length of 2, 1 of them being None)"
+                    )
 
             if type_ is not str and get_origin(type_) != Literal:
                 if extract_collection_type(typehint):
@@ -87,7 +88,7 @@ def resolve_to_kwargs(self, name: str, typehint: type) -> dict[str, Any]:
                 elif callable(type_):
                     self.converter = cast(Callable[[str], T], type_)
                 else:
-                    raise InvalidTypehint(f"Type of argument \"{name}\" is not callable")
+                    raise InvalidTypehint(f'Type of argument "{name}" is not callable')
 
         choices = self.choices
         if literal_choices := extract_literal_strings(type_):
@@ -145,7 +146,9 @@ class PartialOption[T](BasePartialValueArgument[T, Option]):
 
     def resolve_with_typehint(self, name: str, typehint: type) -> Option:
         if self.short_only and self.short is None and len(name) > 1:
-            raise InvalidArgument(f"Argument \"{name}\" requested short_only but name is longer than 1 character and no short-hand was specified")
+            raise InvalidArgument(
+                f'Argument "{name}" requested short_only but name is longer than 1 character and no short-hand was specified'
+            )
 
         kwargs = self.resolve_to_kwargs(name, typehint)
         return Option(**kwargs)
@@ -190,7 +193,9 @@ class PartialFlag(BaseSinglePartialArgument[Flag]):
 
     def resolve_with_typehint(self, name: str, typehint: type) -> Flag:
         if self.short_only and self.short is None and len(name) > 1:
-            raise InvalidArgument(f"Argument \"{name}\" requested short_only but name is longer than 1 character and no short-hand was specified")
+            raise InvalidArgument(
+                f'Argument "{name}" requested short_only but name is longer than 1 character and no short-hand was specified'
+            )
 
         kwargs = self.resolve_to_kwargs(name, typehint)
         kwargs["short"] = self.short

arcparse/_typehints.py

@@ -29,7 +29,9 @@ def extract_subparsers_from_typehint(typehint: type) -> list[type]:
     origin = get_origin(typehint)
     if origin in {Union, UnionType}:
         return list(get_args(typehint))
-    raise InvalidTypehint(f"Unable to extract subparser types from {typehint}, expected a non-empty union of ArcParser types")
+    raise InvalidTypehint(
+        f"Unable to extract subparser types from {typehint}, expected a non-empty union of ArcParser types"
+    )
 
 
 def extract_type_from_typehint(typehint: type) -> type:

arcparse/arguments.py

@@ -26,12 +26,12 @@
 class Void:
     pass
 
+
 void = Void()
 
 
 class ContainerApplicable(Protocol):
-    def apply(self, actions_container: _ActionsContainer, name: str) -> None:
-        ...
+    def apply(self, actions_container: _ActionsContainer, name: str) -> None: ...
 
 
 @dataclass(kw_only=True)
@@ -44,8 +44,7 @@ def apply(self, actions_container: _ActionsContainer, name: str) -> None:
         actions_container.add_argument(*args, **kwargs)
 
     @abstractmethod
-    def get_argparse_args(self, name: str) -> list[str]:
-        ...
+    def get_argparse_args(self, name: str) -> list[str]: ...
 
     def get_argparse_kwargs(self, name: str) -> dict[str, Any]:
         kwargs = {}

arcparse/converters.py

@@ -10,6 +10,7 @@ class itemwise[T]:
     arguments accepting multiple values (nargs="*"), the return type should
     always be wrapped in a list.
     """
+
     def __init__(self, converter: Callable[[str], T]) -> None:
         self._converter = converter
 
@@ -31,7 +32,13 @@ def csv[T](type_: type[T] = str, /) -> Callable[[str], list[T]]:
     return sv(",", type_)
 
 
-def sv_dict[K, V](item_separator: str, key_value_separator: str, *, key_type: Callable[[str], K] = str, value_type: Callable[[str], V] = str) -> Callable[[str], dict[K, V]]:
+def sv_dict[K, V](
+    item_separator: str,
+    key_value_separator: str,
+    *,
+    key_type: Callable[[str], K] = str,
+    value_type: Callable[[str], V] = str,
+) -> Callable[[str], dict[K, V]]:
     def conv(arg: str) -> dict[K, V]:
         items = arg.split(item_separator)
         d = {}

arcparse/errors.py

@@ -1,5 +1,3 @@
-
-
 class InvalidParser(Exception):
     pass
 

arcparse/parser.py

@@ -91,7 +91,9 @@ def _construct_object_with_parsed(self, parsed: dict[str, Any]) -> T:
             # optional subparsers will result in `dict[name]` being `None`
             if chosen_subparser := parsed.get(name):
                 if chosen_subparser not in subparsers.sub_parsers:
-                    raise InvalidParser(f"`{self.shape.__name__}.{name}` was overriden by argument/subparser with same name, got \"{chosen_subparser}\" but should be one of {set(subparsers.sub_parsers.keys())}")
+                    raise InvalidParser(
+                        f'`{self.shape.__name__}.{name}` was overriden by argument/subparser with same name, got "{chosen_subparser}" but should be one of {set(subparsers.sub_parsers.keys())}'
+                    )
                 sub_parser = subparsers.sub_parsers[chosen_subparser]
                 parsed[name] = sub_parser._construct_object_with_parsed(parsed)
 
@@ -103,10 +105,7 @@ def _construct_object_with_parsed(self, parsed: dict[str, Any]) -> T:
             value = parsed.get(name, argument.default)
             if isinstance(argument.converter, itemwise):
                 assert isinstance(value, list)
-                parsed[name] = [
-                    argument.converter(item) if isinstance(item, str) else item
-                    for item in value
-                ]
+                parsed[name] = [argument.converter(item) if isinstance(item, str) else item for item in value]
             else:
                 parsed[name] = argument.converter(value) if isinstance(value, str) else value
 
@@ -219,8 +218,7 @@ def _make_parser[T](shape: type[T]) -> Parser[T]:
         case (name, typehint, partial_subparsers):
             subshapes = partial_subparsers.shapes or extract_subparsers_from_typehint(typehint)
             subparsers_by_name = {
-                name: _make_parser(subshape)
-                for name, subshape in zip(partial_subparsers.names, subshapes)
+                name: _make_parser(subshape) for name, subshape in zip(partial_subparsers.names, subshapes)
             }
             subparsers = (name, Subparsers(subparsers_by_name, required=not union_contains_none(typehint)))
         case _:

examples/subparsers.py

@@ -4,8 +4,7 @@
 
 
 class Action(Protocol):
-    def run_action(self) -> None:
-        ...
+    def run_action(self) -> None: ...
 
 
 class HiAction(Action):

pyproject.toml

@@ -26,6 +26,9 @@ pyright = "^1.1.335"
 pytest = "^7.4.3"
 ruff = "^0.3.7"
 
+[tool.ruff]
+line-length = 120
+
 [tool.ruff.lint.isort]
 from-first = true
 lines-after-imports = 2

tests/test_auto_converter.py

@@ -30,6 +30,7 @@ class Args:
     "literal": None,
 }
 
+
 @pytest.mark.parametrize(
     "arg_string,provided",
     [
@@ -40,7 +41,7 @@ class Args:
         ("--regex ^\\d+$", {"regex": re.compile(r"^\d+$")}),
         ("--literal yes", {"literal": "yes"}),
         ("--literal no", {"literal": "no"}),
-    ]
+    ],
 )
 def test_auto_converter_valid(arg_string: str, provided: dict[str, Any]) -> None:
     parsed = Args.parse(arg_string.split())
@@ -49,17 +50,10 @@ def test_auto_converter_valid(arg_string: str, provided: dict[str, Any]) -> None
         assert getattr(parsed, k) == v
 
 
-@pytest.mark.parametrize(
-    "arg_string",
-    [
-        "--num foo",
-        "--result bar",
-        "--regex '('"
-    ]
-)
+@pytest.mark.parametrize("arg_string", ["--num foo", "--result bar", "--regex '('"])
 def test_option_invalid(arg_string: str) -> None:
     with pytest.raises(BaseException):
-        Args.parse(args = arg_string.split())
+        Args.parse(args=arg_string.split())
 
 
 def test_enum_positional() -> None:

tests/test_converter.py

@@ -18,10 +18,10 @@ def from_int(cls, arg: str) -> "Result":
 
 
 def test_itemwise() -> None:
-
     # @arcparser
     class Xd:
         results: list[Result] = option(converter=itemwise(Result.from_int))
+
     Args = arcparser(Xd)
     args = Args.parse("--results 0 1 0".split())
     assert isinstance(args.results, list)

tests/test_dict_helpers.py

@@ -20,7 +20,7 @@ def test_dict_positional_default_in_dict() -> None:
     [
         ("foo", 1),
         ("bar", 0),
-    ]
+    ],
 )
 def test_dict_positional(arg_string: str, value: int) -> None:
     @arcparser
@@ -41,7 +41,7 @@ def test_dict_option_default_in_dict() -> None:
     [
         ("--foo-bar foo", 1),
         ("--foo-bar bar", 0),
-    ]
+    ],
 )
 def test_dict_option(arg_string: str, value: int) -> None:
     @arcparser

tests/test_flag.py

@@ -39,7 +39,7 @@ class Args:
         ("-z", {"baz": True}),
         ("-o", {"boo": True}),
         ("-c", {"c": True}),
-    ]
+    ],
 )
 def test_flag_valid(arg_string: str, provided: dict[str, Any]) -> None:
     parsed = Args.parse(arg_string.split())
@@ -56,12 +56,11 @@ def test_flag_valid(arg_string: str, provided: dict[str, Any]) -> None:
         "--no-barrr",
         "--no-foo",
         "--boo",
-    ]
+    ],
 )
 def test_flag_invalid(arg_string: str) -> None:
     with pytest.raises(SystemExit):
-        Args.parse(args = arg_string.split())
-
+        Args.parse(args=arg_string.split())
 
 
 @pytest.mark.parametrize(

tests/test_inheritance.py

@@ -15,7 +15,7 @@
         ("--bar", defaults | {"bar": True}),
         ("--baz", defaults | {"baz": True}),
         ("--foo --bar --baz", {"foo": True, "bar": True, "baz": True}),
-    ]
+    ],
 )
 def test_inheritance(arg_string: str, result: dict[str, str]) -> None:
     class Parent1:
@@ -36,9 +36,11 @@ class Argsi(Parent1, Parent2):
 class Common:
     debug: bool
 
+
 class FooArgs(Common):
     foo: bool
 
+
 class BarArgs(Common):
     bar: bool
 

tests/test_option.py

@@ -31,7 +31,7 @@ class Args:
         ("--foo A --bar B -z C", {"foo": "A", "bar": "B", "baz": "C"}),
         ("--foo A -z C --boo D", {"foo": "A", "baz": "C", "boo": "D"}),
         ("--foo A -c B", {"foo": "A", "c": "B"}),
-    ]
+    ],
 )
 def test_option_valid(arg_string: str, provided: dict[str, Any]) -> None:
     parsed = Args.parse(arg_string.split())
@@ -45,8 +45,8 @@ def test_option_valid(arg_string: str, provided: dict[str, Any]) -> None:
     [
         "--foo foo --bar bar --baz baz",
         "--bar bar",
-    ]
+    ],
 )
 def test_option_invalid(arg_string: str) -> None:
     with pytest.raises(SystemExit):
-        Args.parse(args = arg_string.split())
+        Args.parse(args=arg_string.split())

tests/test_positional.py

@@ -24,7 +24,7 @@ class Args:
         ("A", {"foo": "A"}),
         ("A B", {"foo": "A", "bar": "B"}),
         ("A B C", {"foo": "A", "bar": "B", "baz": "C"}),
-    ]
+    ],
 )
 def test_positional_valid(arg_string: str, provided: dict[str, Any]) -> None:
     parsed = Args.parse(arg_string.split())
@@ -38,8 +38,8 @@ def test_positional_valid(arg_string: str, provided: dict[str, Any]) -> None:
     [
         "",
         "A B C D",
-    ]
+    ],
 )
 def test_positional_invalid(arg_string: str) -> None:
     with pytest.raises(SystemExit):
-        Args.parse(args = arg_string.split())
+        Args.parse(args=arg_string.split())

tests/test_short.py

@@ -9,6 +9,7 @@ def test_short_option_invalid() -> None:
         option("-fo-o")
 
     with pytest.raises(InvalidArgument):
+
         @arcparser
         class Args:
             foo: str = option(short_only=True)
@@ -19,6 +20,7 @@ def test_short_flag_invalid() -> None:
         flag("-fo-o")
 
     with pytest.raises(InvalidArgument):
+
         @arcparser
         class Args:
             foo: bool = flag(short_only=True)