Merge pull request #17 from SunDoge/fix-pylance

Fix pylance

Author: SunDoge

.github/workflows/python-package.yml

@@ -5,34 +5,28 @@ name: Python package
 
 on:
   push:
-    branches: [ "master" ]
+    branches: ["main"]
   pull_request:
-    branches: [ "master" ]
+    branches: ["main"]
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.8", "3.9", "3.10"]
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
 
     steps:
-    - uses: actions/checkout@v3
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v3
-      with:
-        python-version: ${{ matrix.python-version }}
-    - uses: Gr1N/setup-poetry@v8
-    - uses: actions/cache@v2
-      with:
-        path: ~/.cache/pypoetry/virtualenvs
-        key: ${{ runner.os }}-poetry-${{ hashFiles('poetry.lock') }}
-    - run: poetry --version
-    - name: Install dependencies
-      run: poetry install
-    - name: Test with pytest
-      run: |
-        poetry run pytest
-        
+      - uses: actions/checkout@v4
+
+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Test with pytest
+        run: uv run --frozen pytest

_test_v0_6.py

@@ -6,46 +6,46 @@
 
 @ta.dataclass
 class Group1:
-    x2: str = ta.add_argument('--x2')
-    x3: str = ta.add_argument('--x3')
+    x2: str = ta.add_argument("--x2")
+    x3: str = ta.add_argument("--x3")
 
 
 @ta.dataclass
 class Group2:
-    x4: str = ta.add_argument('--x4')
+    x4: str = ta.add_argument("--x4")
     """
     x4 in group2
     """
 
-    x5: str = ta.add_argument('--x5')
+    x5: str = ta.add_argument("--x5")
     """x5 in group2"""
 
 
 @ta.dataclass
 class Cmd1:
-    x6: str = ta.add_argument('--x6')
-    x7: str = ta.add_argument('--x7')
+    x6: str = ta.add_argument("--x6")
+    x7: str = ta.add_argument("--x7")
 
 
 @ta.dataclass
 class Cmd2:
-    x6: str = ta.add_argument('--x6')
-    x7: str = ta.add_argument('--x7')
-    x8: str = ta.add_argument('--x8')
+    x6: str = ta.add_argument("--x6")
+    x7: str = ta.add_argument("--x7")
+    x8: str = ta.add_argument("--x8")
 
 
 class SubCommands(ta.SubcommandEnum):
-    CMD1: Cmd1 = ta.add_parser('cmd1')
-    CMD2: Cmd2 = ta.add_parser('cmd2')
+    CMD1: Cmd1 = ta.add_parser("cmd1")
+    CMD2: Cmd2 = ta.add_parser("cmd2")
 
 
-@ta.argument_parser(prog='dddd')
+@ta.argument_parser(prog="dddd")
 class Args(ta.TypedArgs):
     x1: str = ta.add_argument()
     group1: Group1 = ta.add_argument_group()
     group2: Group2 = ta.add_argument_group()
     sub_cmd: SubCommands = ta.add_subparsers()
-    x9: int = ta.add_argument('--x9', type=int)
+    x9: int = ta.add_argument("--x9", type=int)
 
 
 def test():
@@ -59,5 +59,5 @@ def test():
     pickle.dumps(args)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     test()

examples/prog.py

@@ -9,18 +9,21 @@ class Args(ta.TypedArgs):
     """
 
     integers: List[int] = ta.add_argument(
-        metavar='N', type=int, nargs='+',
+        metavar="N",
+        type=int,
+        nargs="+",
         # help='an integer for the accumulator'
     )
     """
     an integer for the accumulator
     """
 
     accumulate: Callable[[List[int]], int] = ta.add_argument(
-        '--sum',
-        action='store_const',
-        const=sum, default=max,
-        help='sum the integers (default: find the max)'
+        "--sum",
+        action="store_const",
+        const=sum,
+        default=max,
+        help="sum the integers (default: find the max)",
     )
 
 

pyproject.toml

@@ -1,26 +1,25 @@
-[tool.poetry]
+[project]
 name = "typed-args"
-version = "0.6.4"
+version = "0.6.5"
 description = "Parse command line arguments by defining dataclasses"
-license = "BSD-3-Clause"
-authors = ["SunDoge <[email protected]>"]
+license = { file = "LICENSE" }
 readme = "README.md"
-homepage = "https://github.com/SunDoge/typed-args"
-repository = "https://github.com/SunDoge/typed-args"
-keywords = ["argparse", "cli"]
+requires-python = ">=3.6"
+dependencies = []
 classifiers = [
     "Operating System :: OS Independent",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
 ]
+keywords = ["argparse", "cli"]
 
-[tool.poetry.dependencies]
-python = "^3.6"
-
-[tool.poetry.dev-dependencies]
-toml = "^0.10.2"
-pytest = "^6.2.5"
 
 [build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.uv]
+dev-dependencies = [
+    "pytest",
+    "icecream",
+]

pyproject.toml.bak

@@ -0,0 +1,26 @@
+[tool.poetry]
+name = "typed-args"
+version = "0.6.4"
+description = "Parse command line arguments by defining dataclasses"
+license = "BSD-3-Clause"
+authors = ["SunDoge <[email protected]>"]
+readme = "README.md"
+homepage = "https://github.com/SunDoge/typed-args"
+repository = "https://github.com/SunDoge/typed-args"
+keywords = ["argparse", "cli"]
+classifiers = [
+    "Operating System :: OS Independent",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+]
+
+[tool.poetry.dependencies]
+python = "^3.6"
+
+[tool.poetry.dev-dependencies]
+toml = "^0.10.2"
+pytest = "^6.2.5"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

pyrightconfig.json

@@ -0,0 +1,4 @@
+{
+  "venvPath": ".",
+  "venv": ".venv"
+}

src/typed_args/__init__.py

@@ -0,0 +1,33 @@
+try:
+    from dataclasses import dataclass
+except ImportError as e:
+    import warnings
+
+    warnings.warn("Please `pip install dataclasses` if you are using Python 3.5 or 3.6")
+    raise e
+
+
+from ._core import parse_args, parse_known_args, argument_parser, TypedArgs
+from ._parser import add_argument, add_argument_group, add_parser, add_subparsers
+from ._utils import SubcommandEnum, DefaultHelpFormatter
+from argparse import SUPPRESS, OPTIONAL, ZERO_OR_MORE, ONE_OR_MORE, REMAINDER
+
+
+__all__ = [
+    "dataclass",
+    "parse_args",
+    "parse_known_args",
+    "argument_parser",
+    "TypedArgs",
+    "add_argument",
+    "add_argument_group",
+    "add_parser",
+    "add_subparsers",
+    "SubcommandEnum",
+    "DefaultHelpFormatter",
+    "SUPPRESS",
+    "OPTIONAL",
+    "ZERO_OR_MORE",
+    "ONE_OR_MORE",
+    "REMAINDER",
+]

typed_args/_assigner.py renamed to src/typed_args/_assigner.py

@@ -13,14 +13,14 @@ def _set_attr(x, paths: List[str], value):
     elif len(paths) > 1:
         dataclass_fields = get_dataclass_fields(x)
         field = dataclass_fields.get(paths[0])
-        action = field.metadata['action']
-        if action == 'add_argument_group':
+        action = field.metadata["action"]
+        if action == "add_argument_group":
             group = getattr(x, paths[0])
             if group is None:
                 group = field.type()
                 setattr(x, paths[0], group)
             _set_attr(group, paths[1:], value)
-        elif action == 'add_subparsers':
+        elif action == "add_subparsers":
             annotations = get_annotations(field.type)
             key = paths[1]
             sub_command_enum: SubcommandEnum = getattr(x, paths[0])
@@ -36,4 +36,4 @@ def _set_attr(x, paths: List[str], value):
 def assign(x, ns: argparse.Namespace):
     kv = vars(ns)
     for key, value in kv.items():
-        _set_attr(x, key.split('.'), value)
+        _set_attr(x, key.split("."), value)

typed_args/_core.py renamed to src/typed_args/_core.py

@@ -11,12 +11,12 @@
 
 logger = logging.getLogger(__name__)
 
-T = TypeVar('T')
+T = TypeVar("T")
 
 
 def _make_parser(klass) -> argparse.ArgumentParser:
-    if hasattr(klass, '__make_parser'):
-        parser = getattr(klass, '__make_parser')()
+    if hasattr(klass, "__make_parser"):
+        parser = getattr(klass, "__make_parser")()
     else:
         parser = argparse.ArgumentParser()
     return parser
@@ -26,10 +26,9 @@ def parse_args(
     klass: Type[T],
     parser: Optional[argparse.ArgumentParser] = None,
     args: Optional[Sequence[str]] = None,
-    namespace:  Optional[argparse.Namespace] = None,
+    namespace: Optional[argparse.Namespace] = None,
 ) -> T:
-    assert dataclasses.is_dataclass(
-        klass), "{} must be dataclass".format(klass)
+    assert dataclasses.is_dataclass(klass), "{} must be dataclass".format(klass)
     if not parser:
         parser = _make_parser(klass)
     parse(parser, klass)
@@ -43,10 +42,9 @@ def parse_known_args(
     klass: Type[T],
     parser: Optional[argparse.ArgumentParser] = None,
     args: Optional[Sequence[str]] = None,
-    namespace:  Optional[argparse.Namespace] = None,
+    namespace: Optional[argparse.Namespace] = None,
 ) -> Tuple[T, List[str]]:
-    assert dataclasses.is_dataclass(
-        klass), "{} must be dataclass".format(klass)
+    assert dataclasses.is_dataclass(klass), "{} must be dataclass".format(klass)
     if not parser:
         parser = _make_parser(klass)
     parse(parser, klass)
@@ -57,34 +55,33 @@ def parse_known_args(
 
 
 class TypedArgs:
-
     @classmethod
     def parse_args(
         cls: Type[T],
         args: Optional[Sequence[str]] = None,
-        namespace:  Optional[argparse.Namespace] = None
+        namespace: Optional[argparse.Namespace] = None,
     ) -> T:
         return parse_args(cls, args=args, namespace=namespace)
 
     @classmethod
     def parse_known_args(
         cls: Type[T],
         args: Optional[Sequence[str]] = None,
-        namespace:  Optional[argparse.Namespace] = None
+        namespace: Optional[argparse.Namespace] = None,
     ) -> Tuple[T, List[str]]:
         return parse_known_args(cls, args=args, namespace=namespace)
 
 
 @overload
 def argument_parser(
-    prog: str = None,
-    usage: str = None,
-    description: str = None,
-    epilog: str = None,
-    parents: List[argparse.ArgumentParser] = None,
-    formatter_class: argparse.HelpFormatter = None,
-    prefix_chars: str = '-',
-    fromfile_prefix_chars: str = None,
+    prog: str = ...,
+    usage: str = ...,
+    description: str = ...,
+    epilog: str = ...,
+    parents: List[argparse.ArgumentParser] = ...,
+    formatter_class: argparse.HelpFormatter = ...,
+    prefix_chars: str = "-",
+    fromfile_prefix_chars: str = ...,
     argument_default=None,
     conflict_handler=None,
     add_help: bool = True,
@@ -94,13 +91,12 @@ def argument_parser(
 
 
 def argument_parser(**kwargs):
-
     def f(klass):
         description = get_doc(klass)
 
         def make_parser():
-            if 'description' not in kwargs and description is not None:
-                logger.debug('Get description from __doc__: %s', description)
+            if "description" not in kwargs and description is not None:
+                logger.debug("Get description from __doc__: %s", description)
                 return argparse.ArgumentParser(description=description, **kwargs)
             else:
                 return argparse.ArgumentParser(**kwargs)
@@ -109,7 +105,7 @@ def make_parser():
             logger.debug("make %s a dataclass", klass)
             klass = dataclasses.dataclass(klass)
 
-        setattr(klass, '__make_parser', make_parser)
+        setattr(klass, "__make_parser", make_parser)
         return klass
 
     return f