use cliskel 0.0.6

Author: jet-logic

.github/workflows/across.yml

@@ -0,0 +1,30 @@
+name: Test Across
+
+on:
+  workflow_dispatch:
+
+jobs:
+  test:
+    name: Test with Py ${{ matrix.python-version }} on ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: ["3.9", "3.11", "3.12"]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install pytest
+          pip install -e .
+
+      - name: Run tests
+        run: |
+          python -m pytest

.github/workflows/build.yml .github/workflows/tests.yml.github/workflows/build.yml renamed to .github/workflows/tests.yml

@@ -1,4 +1,4 @@
-name: Python CI
+name: Tests
 
 on:
   push:

runce/main.py

@@ -1,9 +1,9 @@
 from typing import TYPE_CHECKING
 
-__version__ = "0.0.4"
+__version__ = "0.0.6"
 if TYPE_CHECKING:
-    import argparse
-    from typing import Sequence, Generator, Any
+    from argparse import ArgumentParser
+    from typing import Sequence, Generator
 
 INVALID = object()
 
@@ -15,7 +15,9 @@ def __init__(self, *args: str, **kwargs):
         self.args = args
         self.kwargs = kwargs
 
-    def _add(self, name: str, type_: type, argp: "argparse.ArgumentParser", that: object) -> None:
+    def _add(
+        self, name: str, type_: type, argp: "ArgumentParser", that: object
+    ) -> None:
         """Add argument to parser."""
         args = []
         kwargs = {**self.kwargs}
@@ -27,10 +29,14 @@ def _add(self, name: str, type_: type, argp: "argparse.ArgumentParser", that: ob
         if action is None:
 
             if const is not None:
-                kwargs["action"] = "append_const" if issubclass(type_, list) or isinstance(default, list) else "store_const"
+                kwargs["action"] = (
+                    "append_const"
+                    if issubclass(type_, list) or isinstance(default, list)
+                    else "store_const"
+                )
             elif type_ is None:
                 kwargs["action"] = "store"
-            elif issubclass(type_, bool):
+            elif isinstance(type_, type) and issubclass(type_, bool):
                 if default is None:
                     try:
                         from argparse import BooleanOptionalAction
@@ -43,7 +49,9 @@ def _add(self, name: str, type_: type, argp: "argparse.ArgumentParser", that: ob
                 else:
                     assert default is INVALID or default is False
                     kwargs["action"] = "store_true"
-            elif issubclass(type_, list) or isinstance(default, list):
+            elif (isinstance(type_, type) and issubclass(type_, list)) or isinstance(
+                default, list
+            ):
                 if "nargs" not in kwargs:
                     kwargs["action"] = "append"
                 if "default" not in kwargs:
@@ -56,7 +64,11 @@ def _add(self, name: str, type_: type, argp: "argparse.ArgumentParser", that: ob
             pass
         elif parser:
             kwargs["type"] = parser
-        elif type_ is not bool and type(type_) is type and issubclass(type_, (int, float, str)):
+        elif (
+            type_ is not bool
+            and type(type_) is type
+            and issubclass(type_, (int, float, str))
+        ):
             kwargs["type"] = type_
         # print(name, type_, that, "_add", action, flag_arg)
         if flag_arg is None:
@@ -71,7 +83,9 @@ def _add(self, name: str, type_: type, argp: "argparse.ArgumentParser", that: ob
         else:
 
             def add_args(x: str) -> None:
-                args.append(x if x.startswith("-") else (f"--{x}" if len(x) > 1 else f"-{x}"))
+                args.append(
+                    x if x.startswith("-") else (f"--{x}" if len(x) > 1 else f"-{x}")
+                )
 
             for x in self.args:
                 if " " in x or "\t" in x:
@@ -121,14 +135,16 @@ def __getattr__(self, name: str) -> object:
         try:
             m = super().__getattr__
         except AttributeError:
-            raise AttributeError(f"{self.__class__.__name__} has no attribute {name}") from None
+            raise AttributeError(
+                f"{self.__class__.__name__} has no attribute {name}"
+            ) from None
         else:
             return m(name)
 
     def main(
         self,
         args: "Sequence[str]|None" = None,
-        argp: "argparse.ArgumentParser|None" = None,
+        argp: "ArgumentParser|None" = None,
     ):
         """Entry point for CLI execution.
         Args:
@@ -142,17 +158,17 @@ def main(
         self.parse_arguments(argp, args)
         return self
 
-    def new_argparse(self) -> "argparse.ArgumentParser":
+    def new_argparse(self) -> "ArgumentParser":
         """Create a new argument parser."""
         from argparse import ArgumentParser
 
         return ArgumentParser()
 
-    def init_argparse(self, argp: "argparse.ArgumentParser") -> None:
+    def init_argparse(self, argp: "ArgumentParser") -> None:
         """Initialize the argument parser."""
         pass
 
-    def add_arguments(self, argp: "argparse.ArgumentParser") -> None:
+    def add_arguments(self, argp: "ArgumentParser") -> None:
         """Add arguments to the parser."""
         for k, v, t in _arg_fields(self):
             v._add(k, t, argp, self)
@@ -170,44 +186,32 @@ def start(self) -> None:
         pass
 
     def sub_args(self):
-        # type: () -> Generator[tuple[Main|None, dict[str,Any]], None, None]
+        # type: () -> Generator[tuple[Main|None, dict[str,object]], None, None]
         """Yield subcommands."""
         yield None, {}
 
-    def parse_arguments(self, argp: "argparse.ArgumentParser", args: "Sequence[str]|None") -> None:
+    def parse_arguments(
+        self, argp: "ArgumentParser", args: "Sequence[str]|None"
+    ) -> None:
         """Parse command line arguments."""
         p = self._walk_subparsers(argp)
 
         if p:
             self._arg_parent = None
             n = argp.parse_args(args)
-            try:
-                s = self._arg_final = n._arg_final
-            except AttributeError:
-                raise
-            else:
-                m, h, a = n.__dict__, None, s
-                while a:
-                    h = (a, h)
-                    for k, v, t in _arg_fields(a):
-                        if k in m:
-                            setattr(a, k, m[k])
-                    a = getattr(a, "_arg_parent", None)
-                assert h and h[0] is self
-                s._arg_parent_head = h
-                for m in s._arg_parents_and_self():
-                    m.ready()
-                for m in s._arg_parents_and_self():
-                    m.start()
-                for m in s._arg_parents_and_self():
-                    m.done()
+            s = self._arg_final = n._arg_final
+            for k, v in n.__dict__.items():
+                setattr(s, k, v)
+            s.ready()
+            s.start()
+            s.done()
         else:
             argp.parse_args(args, self)
             self.ready()
             self.start()
             self.done()
 
-    def _walk_subparsers(self, argp: "argparse.ArgumentParser", root=None):
+    def _walk_subparsers(self, argp: "ArgumentParser", root=None):
         s = None
         for c, d in self.sub_args():
             if c:
@@ -222,19 +226,16 @@ def _walk_subparsers(self, argp: "argparse.ArgumentParser", root=None):
         return s
 
     def _arg_parents_and_self(self):
-        # type: () -> Generator[Main, Any, Any]
-        c = self._arg_parent_head
+        c: "Main | None" = self
         while c is not None:
-            d, n = c
-            yield d
-            c = n
+            yield c
+            c = c._arg_parent
 
     def _arg_parents(self):
-        for d in self._arg_parents_and_self():
-            if d is self:
-                break
-            yield d
+        c = self._arg_parent
+        while c is not None:
+            yield c
+            c = c._arg_parent
 
     _arg_final: "Main | None"
     _arg_parent: "Main | None"
-    _arg_parent_head: "tuple[Main, tuple] | None"