Merge pull request #165 from bearomorphism/typed

refactor: update linter tools, python dependency and add types to app…

Author: woile

.github/workflows/test.yaml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11"]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
     steps:
       - uses: actions/checkout@v3
         with:
@@ -30,13 +30,14 @@ jobs:
           virtualenvs-create: true
       - name: Install Dependencies
         run: |
-          poetry install --no-interaction
+          poetry install --all-groups --no-interaction
       - name: Test and Lint
         run: |
           ./scripts/test
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v3
         with:
+          token: ${{ secrets.CODECOV_TOKEN }}
           file: ./coverage.xml
           flags: unittests
           name: decli

README.rst

@@ -688,7 +688,13 @@ Contributing
 
     poetry install
 
-3. Run tests
+3. Format
+
+::
+
+    ./scripts/format
+
+4. Run tests
 
 ::
 

decli/application.py

@@ -1,25 +1,32 @@
-import argparse
+from __future__ import annotations
+
 import logging
-from typing import Optional, Callable, Union
+from argparse import (
+    ArgumentParser,
+    _ArgumentGroup,
+    _MutuallyExclusiveGroup,
+    _SubParsersAction,
+)
+from collections.abc import Generator, Iterable
 from copy import deepcopy
-
+from typing import Any, Callable
 
 config: dict = {}
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 
 
-def init_config():
+def init_config() -> dict[str, Any]:
     return {"prefix_chars": "-"}
 
 
-def ensure_list(name: Union[str, list]) -> list:
+def ensure_list(name: str | list[str]) -> list[str]:
     if isinstance(name, str):
-        name = [name]
+        return [name]
     return name
 
 
-def has_many_and_is_optional(names: list) -> list:
+def has_many_and_is_optional(names: list[str]) -> list[str]:
     """The arguments can have aliases only when they are optional.
 
     If this is not the case, then it raises an error.
@@ -28,21 +35,18 @@ def has_many_and_is_optional(names: list) -> list:
     is_optional = all(name.startswith(tuple(prefix_chars)) for name in names)
 
     if not is_optional and len(names) > 1:
-        msg = (
-            f"Only optional arguments (starting with {prefix_chars}) "
-            "can have aliases"
+        raise ValueError(
+            f"Only optional arguments (starting with {prefix_chars}) can have aliases"
         )
-        raise ValueError(msg)
     return names
 
 
-def is_exclusive_group_or_not(arg: dict):
+def is_exclusive_group_or_not(arg: dict) -> None:
     if "exclusive_group" in arg and "group" in arg:
-        msg = "choose group or exclusive_group not both."
-        raise ValueError(msg)
+        raise ValueError("choose group or exclusive_group not both.")
 
 
-def validate_args(args: list):
+def validate_args(args: Iterable[dict]) -> Generator[dict, Any, None]:
     for arg in args:
         arg["name"] = ensure_list(arg["name"])
         has_many_and_is_optional(arg["name"])
@@ -51,11 +55,11 @@ def validate_args(args: list):
 
 
 def get_or_create_group(
-    parser,
+    parser: ArgumentParser,
     groups: dict,
-    title: Optional[str] = None,
-    description: Optional[str] = None,
-):
+    title: str | None = None,
+    description: str | None = None,
+) -> _ArgumentGroup | Any:
     group_parser = groups.get(title)
     if group_parser is None:
         group_parser = parser.add_argument_group(title, description)
@@ -64,8 +68,11 @@ def get_or_create_group(
 
 
 def get_or_create_exclusive_group(
-    parser, groups: dict, title: Optional[str] = None, required=False
-):
+    parser: ArgumentParser,
+    groups: dict,
+    title: str | None = None,
+    required: bool = False,
+) -> _MutuallyExclusiveGroup | Any:
     group_parser = groups.get(title)
     if group_parser is None:
         group_parser = parser.add_mutually_exclusive_group(required=required)
@@ -74,18 +81,18 @@ def get_or_create_exclusive_group(
     return group_parser
 
 
-def add_arguments(parser, args: list):
+def add_arguments(parser: ArgumentParser, args: list) -> None:
     groups: dict = {}
     exclusive_groups: dict = {}
 
     for arg in validate_args(args):
         logger.debug("arg: %s", arg)
 
         name: list = arg.pop("name")
-        group_title: Optional[str] = arg.pop("group", None)
-        exclusive_group_title: Optional[str] = arg.pop("exclusive_group", None)
+        group_title: str | None = arg.pop("group", None)
+        exclusive_group_title: str | None = arg.pop("exclusive_group", None)
 
-        _parser = parser
+        _parser: Any = parser
         if exclusive_group_title:
             logger.debug("Exclusive group: %s", exclusive_group_title)
             _parser = get_or_create_exclusive_group(
@@ -98,9 +105,9 @@ def add_arguments(parser, args: list):
         _parser.add_argument(*name, **arg)
 
 
-def add_subcommand(parser, command: dict):
+def add_subcommand(parser: _SubParsersAction[ArgumentParser], command: dict) -> None:
     args: list = command.pop("arguments", None)
-    func: Optional[Callable] = command.pop("func", None)
+    func: Callable | None = command.pop("func", None)
 
     names: list = ensure_list(command.pop("name"))
     name: str = names.pop(0)
@@ -116,7 +123,7 @@ def add_subcommand(parser, command: dict):
         add_arguments(command_parser, args)
 
 
-def add_subparser(parser, subcommand: dict):
+def add_subparser(parser: ArgumentParser, subcommand: dict) -> None:
     commands: list = subcommand.pop("commands")
 
     # This design is for python 3.6 compatibility
@@ -131,12 +138,14 @@ def add_subparser(parser, subcommand: dict):
         add_subcommand(subparser, command)
 
 
-def add_parser(data: dict, parser_class: Callable, parents: Optional[list]):
+def add_parser(
+    data: dict, parser_class: Callable[..., ArgumentParser], parents: list | None
+) -> ArgumentParser:
     if parents is None:
         parents = []
 
-    args: Optional[list] = data.pop("arguments", None)
-    subcommands: Optional[dict] = data.pop("subcommands", None)
+    args: list | None = data.pop("arguments", None)
+    subcommands: dict | None = data.pop("subcommands", None)
 
     parser = parser_class(**data, parents=parents)
 
@@ -153,9 +162,9 @@ def add_parser(data: dict, parser_class: Callable, parents: Optional[list]):
 
 def cli(
     data: dict,
-    parser_class: Callable = argparse.ArgumentParser,
-    parents: Optional[list] = None,
-):
+    parser_class: Callable[..., ArgumentParser] = ArgumentParser,
+    parents: list | None = None,
+) -> ArgumentParser:
     """Create a cli application.
 
     This is the entrypoint.

examples/demo.py

@@ -1,4 +1,5 @@
 """Simple app example"""
+
 from decli import cli
 
 data = {