omlish 0.0.0.dev148__py3-none-any.whl → 0.0.0.dev150__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev148'
-__revision__ = '01263e3c2d1b82ca19c3d1d6916041ca4276737b'
+__version__ = '0.0.0.dev150'
+__revision__ = 'ab779edf0b58378203e055980af0fedacedb20aa'
 
 
 #

omlish/argparse/all.py

@@ -0,0 +1,45 @@
+# ruff: noqa: I001
+import argparse
+
+from .cli import (  # noqa
+    ArgparseArg as Arg,
+    argparse_arg as arg,
+
+    ArgparseCommandFn as CommandFn,
+    ArgparseCommand as Command,
+    argparse_command as command,
+
+    ArgparseCli as Cli,
+)
+
+
+##
+
+
+SUPPRESS = argparse.SUPPRESS
+
+OPTIONAL = argparse.OPTIONAL
+ZERO_OR_MORE = argparse.ZERO_OR_MORE
+ONE_OR_MORE = argparse.ONE_OR_MORE
+PARSER = argparse.PARSER
+REMAINDER = argparse.REMAINDER
+
+HelpFormatter = argparse.HelpFormatter
+RawDescriptionHelpFormatter = argparse.RawDescriptionHelpFormatter
+RawTextHelpFormatter = argparse.RawTextHelpFormatter
+ArgumentDefaultsHelpFormatter = argparse.ArgumentDefaultsHelpFormatter
+
+MetavarTypeHelpFormatter = argparse.MetavarTypeHelpFormatter
+
+ArgumentError = argparse.ArgumentError
+ArgumentTypeError = argparse.ArgumentTypeError
+
+Action = argparse.Action
+BooleanOptionalAction = argparse.BooleanOptionalAction
+SubParsersAction = argparse._SubParsersAction  # noqa
+
+FileType = argparse.FileType
+
+Namespace = argparse.Namespace
+
+ArgumentParser = argparse.ArgumentParser

omlish/{argparse.py → argparse/cli.py}

@@ -1,3 +1,5 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
 """
 TODO:
  - default command
@@ -9,53 +11,23 @@ import functools
 import sys
 import typing as ta
 
-from . import c3
-from . import check
+from ..lite.check import check
 
 
 T = ta.TypeVar('T')
 
 
-##
-
-
-SUPPRESS = argparse.SUPPRESS
-
-OPTIONAL = argparse.OPTIONAL
-ZERO_OR_MORE = argparse.ZERO_OR_MORE
-ONE_OR_MORE = argparse.ONE_OR_MORE
-PARSER = argparse.PARSER
-REMAINDER = argparse.REMAINDER
-
-HelpFormatter = argparse.HelpFormatter
-RawDescriptionHelpFormatter = argparse.RawDescriptionHelpFormatter
-RawTextHelpFormatter = argparse.RawTextHelpFormatter
-ArgumentDefaultsHelpFormatter = argparse.ArgumentDefaultsHelpFormatter
-
-MetavarTypeHelpFormatter = argparse.MetavarTypeHelpFormatter
-
-ArgumentError = argparse.ArgumentError
-ArgumentTypeError = argparse.ArgumentTypeError
-
-Action = argparse.Action
-BooleanOptionalAction = argparse.BooleanOptionalAction
-SubParsersAction = argparse._SubParsersAction  # noqa
-
-FileType = argparse.FileType
-
-Namespace = argparse.Namespace
-
-ArgumentParser = argparse.ArgumentParser
+ArgparseCommandFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
 
 
 ##
 
 
 @dc.dataclass(eq=False)
-class Arg:
+class ArgparseArg:
     args: ta.Sequence[ta.Any]
     kwargs: ta.Mapping[str, ta.Any]
-    dest: str | None = None
+    dest: ta.Optional[str] = None
 
     def __get__(self, instance, owner=None):
         if instance is None:
@@ -63,26 +35,23 @@ class Arg:
         return getattr(instance.args, self.dest)  # type: ignore
 
 
-def arg(*args, **kwargs) -> Arg:
-    return Arg(args, kwargs)
+def argparse_arg(*args, **kwargs) -> ArgparseArg:
+    return ArgparseArg(args, kwargs)
 
 
 #
 
 
-CommandFn = ta.Callable[[], int | None]
-
-
 @dc.dataclass(eq=False)
-class Command:
+class ArgparseCommand:
     name: str
-    fn: CommandFn
-    args: ta.Sequence[Arg] = ()  # noqa
+    fn: ArgparseCommandFn
+    args: ta.Sequence[ArgparseArg] = ()  # noqa
 
-    _: dc.KW_ONLY
+    # _: dc.KW_ONLY
 
-    aliases: ta.Sequence[str] | None = None
-    parent: ta.Optional['Command'] = None
+    aliases: ta.Optional[ta.Sequence[str]] = None
+    parent: ta.Optional['ArgparseCommand'] = None
     accepts_unknown: bool = False
 
     def __post_init__(self) -> None:
@@ -95,9 +64,9 @@ class Command:
         for a in self.aliases or []:
             check_name(a)
 
-        check.callable(self.fn)
-        check.arg(all(isinstance(a, Arg) for a in self.args))
-        check.isinstance(self.parent, (Command, None))
+        check.arg(callable(self.fn))
+        check.arg(all(isinstance(a, ArgparseArg) for a in self.args))
+        check.isinstance(self.parent, (ArgparseCommand, type(None)))
         check.isinstance(self.accepts_unknown, bool)
 
         functools.update_wrapper(self, self.fn)
@@ -107,25 +76,25 @@ class Command:
             return self
         return dc.replace(self, fn=self.fn.__get__(instance, owner))  # noqa
 
-    def __call__(self, *args, **kwargs) -> int | None:
+    def __call__(self, *args, **kwargs) -> ta.Optional[int]:
         return self.fn(*args, **kwargs)
 
 
-def command(
-        *args: Arg,
-        name: str | None = None,
-        aliases: ta.Iterable[str] | None = None,
-        parent: Command | None = None,
+def argparse_command(
+        *args: ArgparseArg,
+        name: ta.Optional[str] = None,
+        aliases: ta.Optional[ta.Iterable[str]] = None,
+        parent: ta.Optional[ArgparseCommand] = None,
         accepts_unknown: bool = False,
-) -> ta.Any:  # ta.Callable[[CommandFn], Command]:  # FIXME
+) -> ta.Any:  # ta.Callable[[ArgparseCommandFn], ArgparseCommand]:  # FIXME
     for arg in args:
-        check.isinstance(arg, Arg)
-    check.isinstance(name, (str, None))
-    check.isinstance(parent, (Command, None))
+        check.isinstance(arg, ArgparseArg)
+    check.isinstance(name, (str, type(None)))
+    check.isinstance(parent, (ArgparseCommand, type(None)))
     check.not_isinstance(aliases, str)
 
     def inner(fn):
-        return Command(
+        return ArgparseCommand(
             (name if name is not None else fn.__name__).replace('_', '-'),
             fn,
             args,
@@ -140,7 +109,7 @@ def command(
 ##
 
 
-def get_arg_ann_kwargs(ann: ta.Any) -> ta.Mapping[str, ta.Any]:
+def _get_argparse_arg_ann_kwargs(ann: ta.Any) -> ta.Mapping[str, ta.Any]:
     if ann is str:
         return {}
     elif ann is int:
@@ -153,48 +122,51 @@ def get_arg_ann_kwargs(ann: ta.Any) -> ta.Mapping[str, ta.Any]:
         raise TypeError(ann)
 
 
-class _AnnotationBox:
-
+class _ArgparseCliAnnotationBox:
     def __init__(self, annotations: ta.Mapping[str, ta.Any]) -> None:
         super().__init__()
         self.__annotations__ = annotations  # type: ignore
 
 
-class _CliMeta(type):
+class ArgparseCli:
+    def __init__(self, argv: ta.Optional[ta.Sequence[str]] = None) -> None:
+        super().__init__()
+
+        self._argv = argv if argv is not None else sys.argv[1:]
 
-    def __new__(mcls, name: str, bases: ta.Sequence[type], namespace: ta.Mapping[str, ta.Any]) -> type:
-        if not bases:
-            return super().__new__(mcls, name, tuple(bases), dict(namespace))
+        self._args, self._unknown_args = self.get_parser().parse_known_args(self._argv)
 
-        bases = list(bases)
-        namespace = dict(namespace)
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        ns = cls.__dict__
 
         objs = {}
-        mro = c3.merge([list(b.__mro__) for b in bases])
-        for bns in [bcls.__dict__ for bcls in reversed(mro)] + [namespace]:
+        mro = cls.__mro__[::-1]
+        for bns in [bcls.__dict__ for bcls in reversed(mro)] + [ns]:
             bseen = set()  # type: ignore
             for k, v in bns.items():
-                if isinstance(v, (Command, Arg)):
+                if isinstance(v, (ArgparseCommand, ArgparseArg)):
                     check.not_in(v, bseen)
                     bseen.add(v)
                     objs[k] = v
                 elif k in objs:
                     del [k]
 
-        anns = ta.get_type_hints(_AnnotationBox({
+        anns = ta.get_type_hints(_ArgparseCliAnnotationBox({
             **{k: v for bcls in reversed(mro) for k, v in getattr(bcls, '__annotations__', {}).items()},
-            **namespace.get('__annotations__', {}),
-        }), globalns=namespace.get('__globals__', {}))
+            **ns.get('__annotations__', {}),
+        }), globalns=ns.get('__globals__', {}))
 
-        if 'parser' in namespace:
-            parser = check.isinstance(namespace.pop('parser'), ArgumentParser)
+        if '_parser' in ns:
+            parser = check.isinstance(ns['_parser'], argparse.ArgumentParser)
         else:
-            parser = ArgumentParser()
-        namespace['_parser'] = parser
+            parser = argparse.ArgumentParser()
+            setattr(cls, '_parser', parser)
 
         subparsers = parser.add_subparsers()
         for att, obj in objs.items():
-            if isinstance(obj, Command):
+            if isinstance(obj, ArgparseCommand):
                 if obj.parent is not None:
                     raise NotImplementedError
                 for cn in [obj.name, *(obj.aliases or [])]:
@@ -215,9 +187,9 @@ class _CliMeta(type):
                             cparser.add_argument(*arg.args, **arg.kwargs)
                     cparser.set_defaults(_cmd=obj)
 
-            elif isinstance(obj, Arg):
+            elif isinstance(obj, ArgparseArg):
                 if att in anns:
-                    akwargs = get_arg_ann_kwargs(anns[att])
+                    akwargs = _get_argparse_arg_ann_kwargs(anns[att])
                     obj.kwargs = {**akwargs, **obj.kwargs}
                 if not obj.dest:
                     if 'dest' in obj.kwargs:
@@ -229,22 +201,10 @@ class _CliMeta(type):
             else:
                 raise TypeError(obj)
 
-        return super().__new__(mcls, name, tuple(bases), namespace)
-
-
-class Cli(metaclass=_CliMeta):
-
-    def __init__(self, argv: ta.Sequence[str] | None = None) -> None:
-        super().__init__()
-
-        self._argv = argv if argv is not None else sys.argv[1:]
-
-        self._args, self._unknown_args = self.get_parser().parse_known_args(self._argv)
-
-    _parser: ta.ClassVar[ArgumentParser]
+    _parser: ta.ClassVar[argparse.ArgumentParser]
 
     @classmethod
-    def get_parser(cls) -> ArgumentParser:
+    def get_parser(cls) -> argparse.ArgumentParser:
         return cls._parser
 
     @property
@@ -252,17 +212,17 @@ class Cli(metaclass=_CliMeta):
         return self._argv
 
     @property
-    def args(self) -> Namespace:
+    def args(self) -> argparse.Namespace:
         return self._args
 
     @property
     def unknown_args(self) -> ta.Sequence[str]:
         return self._unknown_args
 
-    def _run_cmd(self, cmd: Command) -> int | None:
+    def _run_cmd(self, cmd: ArgparseCommand) -> ta.Optional[int]:
         return cmd.__get__(self, type(self))()
 
-    def __call__(self) -> int | None:
+    def __call__(self) -> ta.Optional[int]:
         cmd = getattr(self.args, '_cmd', None)
 
         if self._unknown_args and not (cmd is not None and cmd.accepts_unknown):
@@ -270,7 +230,7 @@ class Cli(metaclass=_CliMeta):
             if (parser := self.get_parser()).exit_on_error:  # type: ignore
                 parser.error(msg)
             else:
-                raise ArgumentError(None, msg)
+                raise argparse.ArgumentError(None, msg)
 
         if cmd is None:
             self.get_parser().print_help()