ominfra 0.0.0.dev149__py3-none-any.whl → 0.0.0.dev150__py3-none-any.whl

ominfra/scripts/manage.py

@@ -9,6 +9,7 @@ manage.py -s 'docker run -i python:3.12'
 manage.py -s 'ssh -i /foo/bar.pem foo@bar.baz' -q --python=python3.8
 """
 import abc
+import argparse
 import asyncio
 import asyncio.base_subprocess
 import asyncio.subprocess
@@ -76,6 +77,11 @@ CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 
 # ../../omlish/lite/check.py
 SizedT = ta.TypeVar('SizedT', bound=ta.Sized)
+CheckMessage = ta.Union[str, ta.Callable[..., ta.Optional[str]], None]  # ta.TypeAlias
+CheckLateConfigureFn = ta.Callable[['Checks'], None]
+CheckOnRaiseFn = ta.Callable[[Exception], None]  # ta.TypeAlias
+CheckExceptionFactory = ta.Callable[..., Exception]  # ta.TypeAlias
+CheckArgsRenderer = ta.Callable[..., ta.Optional[str]]  # ta.TypeAlias
 
 # ../../omdev/packaging/specifiers.py
 UnparsedVersion = ta.Union['Version', str]
@@ -86,6 +92,9 @@ CallableVersionOperator = ta.Callable[['Version', str], bool]
 CommandT = ta.TypeVar('CommandT', bound='Command')
 CommandOutputT = ta.TypeVar('CommandOutputT', bound='Command.Output')
 
+# ../../omlish/argparse/cli.py
+ArgparseCommandFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
+
 # ../../omlish/lite/inject.py
 U = ta.TypeVar('U')
 InjectorKeyCls = ta.Union[type, ta.NewType]
@@ -1152,104 +1161,454 @@ def async_cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
 
 ########################################
 # ../../../omlish/lite/check.py
+"""
+TODO:
+ - def maybe(v: lang.Maybe[T])
+ - patch / override lite.check ?
+  - checker interface?
+"""
+
+
+##
+
+
+class Checks:
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._config_lock = threading.RLock()
+        self._on_raise_fns: ta.Sequence[CheckOnRaiseFn] = []
+        self._exception_factory: CheckExceptionFactory = Checks.default_exception_factory
+        self._args_renderer: ta.Optional[CheckArgsRenderer] = None
+        self._late_configure_fns: ta.Sequence[CheckLateConfigureFn] = []
+
+    @staticmethod
+    def default_exception_factory(exc_cls: ta.Type[Exception], *args, **kwargs) -> Exception:
+        return exc_cls(*args, **kwargs)  # noqa
+
+    #
+
+    def register_on_raise(self, fn: CheckOnRaiseFn) -> None:
+        with self._config_lock:
+            self._on_raise_fns = [*self._on_raise_fns, fn]
+
+    def unregister_on_raise(self, fn: CheckOnRaiseFn) -> None:
+        with self._config_lock:
+            self._on_raise_fns = [e for e in self._on_raise_fns if e != fn]
+
+    #
+
+    def set_exception_factory(self, factory: CheckExceptionFactory) -> None:
+        self._exception_factory = factory
+
+    def set_args_renderer(self, renderer: ta.Optional[CheckArgsRenderer]) -> None:
+        self._args_renderer = renderer
+
+    #
+
+    def register_late_configure(self, fn: CheckLateConfigureFn) -> None:
+        with self._config_lock:
+            self._late_configure_fns = [*self._late_configure_fns, fn]
+
+    def _late_configure(self) -> None:
+        if not self._late_configure_fns:
+            return
+
+        with self._config_lock:
+            if not (lc := self._late_configure_fns):
+                return
+
+            for fn in lc:
+                fn(self)
+
+            self._late_configure_fns = []
+
+    #
+
+    class _ArgsKwargs:
+        def __init__(self, *args, **kwargs):
+            self.args = args
+            self.kwargs = kwargs
+
+    def _raise(
+            self,
+            exception_type: ta.Type[Exception],
+            default_message: str,
+            message: CheckMessage,
+            ak: _ArgsKwargs = _ArgsKwargs(),
+            *,
+            render_fmt: ta.Optional[str] = None,
+    ) -> ta.NoReturn:
+        exc_args = ()
+        if callable(message):
+            message = ta.cast(ta.Callable, message)(*ak.args, **ak.kwargs)
+            if isinstance(message, tuple):
+                message, *exc_args = message  # type: ignore
+
+        if message is None:
+            message = default_message
+
+        self._late_configure()
+
+        if render_fmt is not None and (af := self._args_renderer) is not None:
+            rendered_args = af(render_fmt, *ak.args)
+            if rendered_args is not None:
+                message = f'{message} : {rendered_args}'
+
+        exc = self._exception_factory(
+            exception_type,
+            message,
+            *exc_args,
+            *ak.args,
+            **ak.kwargs,
+        )
+
+        for fn in self._on_raise_fns:
+            fn(exc)
+
+        raise exc
+
+    #
+
+    def _unpack_isinstance_spec(self, spec: ta.Any) -> tuple:
+        if isinstance(spec, type):
+            return (spec,)
+        if not isinstance(spec, tuple):
+            spec = (spec,)
+        if None in spec:
+            spec = tuple(filter(None, spec)) + (None.__class__,)  # noqa
+        if ta.Any in spec:
+            spec = (object,)
+        return spec
+
+    def isinstance(self, v: ta.Any, spec: ta.Union[ta.Type[T], tuple], msg: CheckMessage = None) -> T:  # noqa
+        if not isinstance(v, self._unpack_isinstance_spec(spec)):
+            self._raise(
+                TypeError,
+                'Must be instance',
+                msg,
+                Checks._ArgsKwargs(v, spec),
+                render_fmt='not isinstance(%s, %s)',
+            )
+
+        return v
+
+    def of_isinstance(self, spec: ta.Union[ta.Type[T], tuple], msg: CheckMessage = None) -> ta.Callable[[ta.Any], T]:
+        def inner(v):
+            return self.isinstance(v, self._unpack_isinstance_spec(spec), msg)
+
+        return inner
+
+    def cast(self, v: ta.Any, cls: ta.Type[T], msg: CheckMessage = None) -> T:  # noqa
+        if not isinstance(v, cls):
+            self._raise(
+                TypeError,
+                'Must be instance',
+                msg,
+                Checks._ArgsKwargs(v, cls),
+            )
+
+        return v
 
+    def of_cast(self, cls: ta.Type[T], msg: CheckMessage = None) -> ta.Callable[[T], T]:
+        def inner(v):
+            return self.cast(v, cls, msg)
 
-def check_isinstance(v: ta.Any, spec: ta.Union[ta.Type[T], tuple]) -> T:
-    if not isinstance(v, spec):
-        raise TypeError(v)
-    return v
+        return inner
 
+    def not_isinstance(self, v: T, spec: ta.Any, msg: CheckMessage = None) -> T:  # noqa
+        if isinstance(v, self._unpack_isinstance_spec(spec)):
+            self._raise(
+                TypeError,
+                'Must not be instance',
+                msg,
+                Checks._ArgsKwargs(v, spec),
+                render_fmt='isinstance(%s, %s)',
+            )
 
-def check_not_isinstance(v: T, spec: ta.Union[type, tuple]) -> T:
-    if isinstance(v, spec):
-        raise TypeError(v)
-    return v
+        return v
 
+    def of_not_isinstance(self, spec: ta.Any, msg: CheckMessage = None) -> ta.Callable[[T], T]:
+        def inner(v):
+            return self.not_isinstance(v, self._unpack_isinstance_spec(spec), msg)
 
-def check_none(v: T) -> None:
-    if v is not None:
-        raise ValueError(v)
+        return inner
 
+    ##
 
-def check_not_none(v: ta.Optional[T]) -> T:
-    if v is None:
-        raise ValueError
-    return v
+    def issubclass(self, v: ta.Type[T], spec: ta.Any, msg: CheckMessage = None) -> ta.Type[T]:  # noqa
+        if not issubclass(v, spec):
+            self._raise(
+                TypeError,
+                'Must be subclass',
+                msg,
+                Checks._ArgsKwargs(v, spec),
+                render_fmt='not issubclass(%s, %s)',
+            )
 
+        return v
 
-def check_not(v: ta.Any) -> None:
-    if v:
-        raise ValueError(v)
-    return v
+    def not_issubclass(self, v: ta.Type[T], spec: ta.Any, msg: CheckMessage = None) -> ta.Type[T]:  # noqa
+        if issubclass(v, spec):
+            self._raise(
+                TypeError,
+                'Must not be subclass',
+                msg,
+                Checks._ArgsKwargs(v, spec),
+                render_fmt='issubclass(%s, %s)',
+            )
 
+        return v
 
-def check_non_empty_str(v: ta.Optional[str]) -> str:
-    if not v:
-        raise ValueError
-    return v
+    #
 
+    def in_(self, v: T, c: ta.Container[T], msg: CheckMessage = None) -> T:
+        if v not in c:
+            self._raise(
+                ValueError,
+                'Must be in',
+                msg,
+                Checks._ArgsKwargs(v, c),
+                render_fmt='%s not in %s',
+            )
 
-def check_arg(v: bool, msg: str = 'Illegal argument') -> None:
-    if not v:
-        raise ValueError(msg)
+        return v
 
+    def not_in(self, v: T, c: ta.Container[T], msg: CheckMessage = None) -> T:
+        if v in c:
+            self._raise(
+                ValueError,
+                'Must not be in',
+                msg,
+                Checks._ArgsKwargs(v, c),
+                render_fmt='%s in %s',
+            )
 
-def check_state(v: bool, msg: str = 'Illegal state') -> None:
-    if not v:
-        raise ValueError(msg)
+        return v
 
+    def empty(self, v: SizedT, msg: CheckMessage = None) -> SizedT:
+        if len(v) != 0:
+            self._raise(
+                ValueError,
+                'Must be empty',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
 
-def check_equal(l: T, r: T) -> T:
-    if l != r:
-        raise ValueError(l, r)
-    return l
+        return v
 
+    def iterempty(self, v: ta.Iterable[T], msg: CheckMessage = None) -> ta.Iterable[T]:
+        it = iter(v)
+        try:
+            next(it)
+        except StopIteration:
+            pass
+        else:
+            self._raise(
+                ValueError,
+                'Must be empty',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
 
-def check_not_equal(l: T, r: T) -> T:
-    if l == r:
-        raise ValueError(l, r)
-    return l
+        return v
 
+    def not_empty(self, v: SizedT, msg: CheckMessage = None) -> SizedT:
+        if len(v) == 0:
+            self._raise(
+                ValueError,
+                'Must not be empty',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
 
-def check_is(l: T, r: T) -> T:
-    if l is not r:
-        raise ValueError(l, r)
-    return l
+        return v
 
+    def unique(self, it: ta.Iterable[T], msg: CheckMessage = None) -> ta.Iterable[T]:
+        dupes = [e for e, c in collections.Counter(it).items() if c > 1]
+        if dupes:
+            self._raise(
+                ValueError,
+                'Must be unique',
+                msg,
+                Checks._ArgsKwargs(it, dupes),
+            )
 
-def check_is_not(l: T, r: ta.Any) -> T:
-    if l is r:
-        raise ValueError(l, r)
-    return l
+        return it
 
+    def single(self, obj: ta.Iterable[T], message: CheckMessage = None) -> T:
+        try:
+            [value] = obj
+        except ValueError:
+            self._raise(
+                ValueError,
+                'Must be single',
+                message,
+                Checks._ArgsKwargs(obj),
+                render_fmt='%s',
+            )
+
+        return value
+
+    def opt_single(self, obj: ta.Iterable[T], message: CheckMessage = None) -> ta.Optional[T]:
+        it = iter(obj)
+        try:
+            value = next(it)
+        except StopIteration:
+            return None
+
+        try:
+            next(it)
+        except StopIteration:
+            return value  # noqa
+
+        self._raise(
+            ValueError,
+            'Must be empty or single',
+            message,
+            Checks._ArgsKwargs(obj),
+            render_fmt='%s',
+        )
+
+        raise RuntimeError  # noqa
 
-def check_in(v: T, c: ta.Container[T]) -> T:
-    if v not in c:
-        raise ValueError(v, c)
-    return v
+    #
 
+    def none(self, v: ta.Any, msg: CheckMessage = None) -> None:
+        if v is not None:
+            self._raise(
+                ValueError,
+                'Must be None',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
 
-def check_not_in(v: T, c: ta.Container[T]) -> T:
-    if v in c:
-        raise ValueError(v, c)
-    return v
+    def not_none(self, v: ta.Optional[T], msg: CheckMessage = None) -> T:
+        if v is None:
+            self._raise(
+                ValueError,
+                'Must not be None',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
 
+        return v
 
-def check_single(vs: ta.Iterable[T]) -> T:
-    [v] = vs
-    return v
+    #
+
+    def equal(self, v: T, o: ta.Any, msg: CheckMessage = None) -> T:
+        if o != v:
+            self._raise(
+                ValueError,
+                'Must be equal',
+                msg,
+                Checks._ArgsKwargs(v, o),
+                render_fmt='%s != %s',
+            )
+
+        return v
+
+    def is_(self, v: T, o: ta.Any, msg: CheckMessage = None) -> T:
+        if o is not v:
+            self._raise(
+                ValueError,
+                'Must be the same',
+                msg,
+                Checks._ArgsKwargs(v, o),
+                render_fmt='%s is not %s',
+            )
+
+        return v
+
+    def is_not(self, v: T, o: ta.Any, msg: CheckMessage = None) -> T:
+        if o is v:
+            self._raise(
+                ValueError,
+                'Must not be the same',
+                msg,
+                Checks._ArgsKwargs(v, o),
+                render_fmt='%s is %s',
+            )
+
+        return v
+
+    def callable(self, v: T, msg: CheckMessage = None) -> T:  # noqa
+        if not callable(v):
+            self._raise(
+                TypeError,
+                'Must be callable',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v  # type: ignore
+
+    def non_empty_str(self, v: ta.Optional[str], msg: CheckMessage = None) -> str:
+        if not isinstance(v, str) or not v:
+            self._raise(
+                ValueError,
+                'Must be non-empty str',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v
+
+    def replacing(self, expected: ta.Any, old: ta.Any, new: T, msg: CheckMessage = None) -> T:
+        if old != expected:
+            self._raise(
+                ValueError,
+                'Must be replacing',
+                msg,
+                Checks._ArgsKwargs(expected, old, new),
+                render_fmt='%s -> %s -> %s',
+            )
+
+        return new
+
+    def replacing_none(self, old: ta.Any, new: T, msg: CheckMessage = None) -> T:
+        if old is not None:
+            self._raise(
+                ValueError,
+                'Must be replacing None',
+                msg,
+                Checks._ArgsKwargs(old, new),
+                render_fmt='%s -> %s',
+            )
+
+        return new
+
+    #
 
+    def arg(self, v: bool, msg: CheckMessage = None) -> None:
+        if not v:
+            self._raise(
+                RuntimeError,
+                'Argument condition not met',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
 
-def check_empty(v: SizedT) -> SizedT:
-    if len(v):
-        raise ValueError(v)
-    return v
+    def state(self, v: bool, msg: CheckMessage = None) -> None:
+        if not v:
+            self._raise(
+                RuntimeError,
+                'State condition not met',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
 
 
-def check_not_empty(v: SizedT) -> SizedT:
-    if not len(v):
-        raise ValueError(v)
-    return v
+check = Checks()
 
 
 ########################################
@@ -2058,7 +2417,7 @@ class Command(abc.ABC, ta.Generic[CommandOutputT]):
 
     @ta.final
     async def execute(self, executor: 'CommandExecutor') -> CommandOutputT:
-        return check_isinstance(await executor.execute(self), self.Output)  # type: ignore[return-value]
+        return check.isinstance(await executor.execute(self), self.Output)  # type: ignore[return-value]
 
 
 ##
@@ -2253,6 +2612,237 @@ def get_remote_payload_src(
     return importlib.resources.files(__package__.split('.')[0] + '.scripts').joinpath('manage.py').read_text()
 
 
+########################################
+# ../../../omlish/argparse/cli.py
+"""
+TODO:
+ - default command
+ - auto match all underscores to hyphens
+"""
+
+
+##
+
+
+@dc.dataclass(eq=False)
+class ArgparseArg:
+    args: ta.Sequence[ta.Any]
+    kwargs: ta.Mapping[str, ta.Any]
+    dest: ta.Optional[str] = None
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        return getattr(instance.args, self.dest)  # type: ignore
+
+
+def argparse_arg(*args, **kwargs) -> ArgparseArg:
+    return ArgparseArg(args, kwargs)
+
+
+#
+
+
+@dc.dataclass(eq=False)
+class ArgparseCommand:
+    name: str
+    fn: ArgparseCommandFn
+    args: ta.Sequence[ArgparseArg] = ()  # noqa
+
+    # _: dc.KW_ONLY
+
+    aliases: ta.Optional[ta.Sequence[str]] = None
+    parent: ta.Optional['ArgparseCommand'] = None
+    accepts_unknown: bool = False
+
+    def __post_init__(self) -> None:
+        def check_name(s: str) -> None:
+            check.isinstance(s, str)
+            check.not_in('_', s)
+            check.not_empty(s)
+        check_name(self.name)
+        check.not_isinstance(self.aliases, str)
+        for a in self.aliases or []:
+            check_name(a)
+
+        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)
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        return dc.replace(self, fn=self.fn.__get__(instance, owner))  # noqa
+
+    def __call__(self, *args, **kwargs) -> ta.Optional[int]:
+        return self.fn(*args, **kwargs)
+
+
+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[[ArgparseCommandFn], ArgparseCommand]:  # FIXME
+    for arg in args:
+        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 ArgparseCommand(
+            (name if name is not None else fn.__name__).replace('_', '-'),
+            fn,
+            args,
+            aliases=tuple(aliases) if aliases is not None else None,
+            parent=parent,
+            accepts_unknown=accepts_unknown,
+        )
+
+    return inner
+
+
+##
+
+
+def _get_argparse_arg_ann_kwargs(ann: ta.Any) -> ta.Mapping[str, ta.Any]:
+    if ann is str:
+        return {}
+    elif ann is int:
+        return {'type': int}
+    elif ann is bool:
+        return {'action': 'store_true'}
+    elif ann is list:
+        return {'action': 'append'}
+    else:
+        raise TypeError(ann)
+
+
+class _ArgparseCliAnnotationBox:
+    def __init__(self, annotations: ta.Mapping[str, ta.Any]) -> None:
+        super().__init__()
+        self.__annotations__ = annotations  # type: ignore
+
+
+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:]
+
+        self._args, self._unknown_args = self.get_parser().parse_known_args(self._argv)
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        ns = cls.__dict__
+
+        objs = {}
+        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, (ArgparseCommand, ArgparseArg)):
+                    check.not_in(v, bseen)
+                    bseen.add(v)
+                    objs[k] = v
+                elif k in objs:
+                    del [k]
+
+        anns = ta.get_type_hints(_ArgparseCliAnnotationBox({
+            **{k: v for bcls in reversed(mro) for k, v in getattr(bcls, '__annotations__', {}).items()},
+            **ns.get('__annotations__', {}),
+        }), globalns=ns.get('__globals__', {}))
+
+        if '_parser' in ns:
+            parser = check.isinstance(ns['_parser'], argparse.ArgumentParser)
+        else:
+            parser = argparse.ArgumentParser()
+            setattr(cls, '_parser', parser)
+
+        subparsers = parser.add_subparsers()
+        for att, obj in objs.items():
+            if isinstance(obj, ArgparseCommand):
+                if obj.parent is not None:
+                    raise NotImplementedError
+                for cn in [obj.name, *(obj.aliases or [])]:
+                    cparser = subparsers.add_parser(cn)
+                    for arg in (obj.args or []):
+                        if (
+                                len(arg.args) == 1 and
+                                isinstance(arg.args[0], str) and
+                                not (n := check.isinstance(arg.args[0], str)).startswith('-') and
+                                'metavar' not in arg.kwargs
+                        ):
+                            cparser.add_argument(
+                                n.replace('-', '_'),
+                                **arg.kwargs,
+                                metavar=n,
+                            )
+                        else:
+                            cparser.add_argument(*arg.args, **arg.kwargs)
+                    cparser.set_defaults(_cmd=obj)
+
+            elif isinstance(obj, ArgparseArg):
+                if att in anns:
+                    akwargs = _get_argparse_arg_ann_kwargs(anns[att])
+                    obj.kwargs = {**akwargs, **obj.kwargs}
+                if not obj.dest:
+                    if 'dest' in obj.kwargs:
+                        obj.dest = obj.kwargs['dest']
+                    else:
+                        obj.dest = obj.kwargs['dest'] = att  # type: ignore
+                parser.add_argument(*obj.args, **obj.kwargs)
+
+            else:
+                raise TypeError(obj)
+
+    _parser: ta.ClassVar[argparse.ArgumentParser]
+
+    @classmethod
+    def get_parser(cls) -> argparse.ArgumentParser:
+        return cls._parser
+
+    @property
+    def argv(self) -> ta.Sequence[str]:
+        return self._argv
+
+    @property
+    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: ArgparseCommand) -> ta.Optional[int]:
+        return cmd.__get__(self, type(self))()
+
+    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):
+            msg = f'unrecognized arguments: {" ".join(self._unknown_args)}'
+            if (parser := self.get_parser()).exit_on_error:  # type: ignore
+                parser.error(msg)
+            else:
+                raise argparse.ArgumentError(None, msg)
+
+        if cmd is None:
+            self.get_parser().print_help()
+            return 0
+
+        return self._run_cmd(cmd)
+
+    def call_and_exit(self) -> ta.NoReturn:
+        sys.exit(rc if isinstance(rc := self(), int) else 0)
+
+
 ########################################
 # ../../../omlish/lite/inject.py
 
@@ -2397,7 +2987,7 @@ class FnInjectorProvider(InjectorProvider):
     fn: ta.Any
 
     def __post_init__(self) -> None:
-        check_not_isinstance(self.fn, type)
+        check.not_isinstance(self.fn, type)
 
     def provider_fn(self) -> InjectorProviderFn:
         def pfn(i: Injector) -> ta.Any:
@@ -2411,7 +3001,7 @@ class CtorInjectorProvider(InjectorProvider):
     cls_: type
 
     def __post_init__(self) -> None:
-        check_isinstance(self.cls_, type)
+        check.isinstance(self.cls_, type)
 
     def provider_fn(self) -> InjectorProviderFn:
         def pfn(i: Injector) -> ta.Any:
@@ -2433,7 +3023,7 @@ class SingletonInjectorProvider(InjectorProvider):
     p: InjectorProvider
 
     def __post_init__(self) -> None:
-        check_isinstance(self.p, InjectorProvider)
+        check.isinstance(self.p, InjectorProvider)
 
     def provider_fn(self) -> InjectorProviderFn:
         v = not_set = object()
@@ -2453,7 +3043,7 @@ class LinkInjectorProvider(InjectorProvider):
     k: InjectorKey
 
     def __post_init__(self) -> None:
-        check_isinstance(self.k, InjectorKey)
+        check.isinstance(self.k, InjectorKey)
 
     def provider_fn(self) -> InjectorProviderFn:
         def pfn(i: Injector) -> ta.Any:
@@ -2650,7 +3240,7 @@ def build_injection_kwargs_target(
 
     skip_names: ta.Set[str] = set()
     if skip_kwargs is not None:
-        skip_names.update(check_not_isinstance(skip_kwargs, str))
+        skip_names.update(check.not_isinstance(skip_kwargs, str))
 
     seen: ta.Set[InjectorKey] = set()
     kws: ta.List[InjectionKwarg] = []
@@ -2711,8 +3301,8 @@ class _Injector(Injector):
     def __init__(self, bs: InjectorBindings, p: ta.Optional[Injector] = None) -> None:
         super().__init__()
 
-        self._bs = check_isinstance(bs, InjectorBindings)
-        self._p: ta.Optional[Injector] = check_isinstance(p, (Injector, type(None)))
+        self._bs = check.isinstance(bs, InjectorBindings)
+        self._p: ta.Optional[Injector] = check.isinstance(p, (Injector, type(None)))
 
         self._pfm = {k: v.provider_fn() for k, v in build_injector_provider_map(bs).items()}
 
@@ -2743,8 +3333,8 @@ class _Injector(Injector):
             return Maybe.empty()
 
         def handle_provision(self, key: InjectorKey, mv: Maybe) -> Maybe:
-            check_in(key, self._seen_keys)
-            check_not_in(key, self._provisions)
+            check.in_(key, self._seen_keys)
+            check.not_in(key, self._provisions)
             self._provisions[key] = mv
             return mv
 
@@ -2858,7 +3448,7 @@ class InjectorBinder:
 
     @classmethod
     def bind_as_fn(cls, icls: ta.Type[T]) -> ta.Type[T]:
-        check_isinstance(icls, type)
+        check.isinstance(icls, type)
         if icls not in cls._FN_TYPES:
             cls._FN_TYPES = (*cls._FN_TYPES, icls)
         return icls
@@ -2915,7 +3505,7 @@ class InjectorBinder:
             to_fn = obj
             if key is None:
                 insp = _injection_inspect(obj)
-                key_cls: ta.Any = check_valid_injector_key_cls(check_not_none(insp.type_hints.get('return')))
+                key_cls: ta.Any = check_valid_injector_key_cls(check.not_none(insp.type_hints.get('return')))
                 key = InjectorKey(key_cls)
         else:
             if to_const is not None:
@@ -3457,10 +4047,10 @@ class ProxyObjMarshaler(ObjMarshaler):
     m: ta.Optional[ObjMarshaler] = None
 
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return check_not_none(self.m).marshal(o, ctx)
+        return check.not_none(self.m).marshal(o, ctx)
 
     def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return check_not_none(self.m).unmarshal(o, ctx)
+        return check.not_none(self.m).unmarshal(o, ctx)
 
 
 @dc.dataclass(frozen=True)
@@ -3619,19 +4209,19 @@ class DatetimeObjMarshaler(ObjMarshaler):
 
 class DecimalObjMarshaler(ObjMarshaler):
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return str(check_isinstance(o, decimal.Decimal))
+        return str(check.isinstance(o, decimal.Decimal))
 
     def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return decimal.Decimal(check_isinstance(v, str))
+        return decimal.Decimal(check.isinstance(v, str))
 
 
 class FractionObjMarshaler(ObjMarshaler):
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        fr = check_isinstance(o, fractions.Fraction)
+        fr = check.isinstance(o, fractions.Fraction)
         return [fr.numerator, fr.denominator]
 
     def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        num, denom = check_isinstance(v, list)
+        num, denom = check.isinstance(v, list)
         return fractions.Fraction(num, denom)
 
 
@@ -4436,7 +5026,7 @@ class _RemoteCommandHandler:
             ], return_when=asyncio.FIRST_COMPLETED)
 
             if recv_task in done:
-                msg: ta.Optional[_RemoteProtocol.Message] = check_isinstance(
+                msg: ta.Optional[_RemoteProtocol.Message] = check.isinstance(
                     recv_task.result(),
                     (_RemoteProtocol.Message, type(None)),
                 )
@@ -4505,8 +5095,8 @@ class RemoteCommandExecutor(CommandExecutor):
     #
 
     async def start(self) -> None:
-        check_none(self._loop_task)
-        check_state(not self._stop.is_set())
+        check.none(self._loop_task)
+        check.state(not self._stop.is_set())
         self._loop_task = asyncio.create_task(self._loop())
 
     async def aclose(self) -> None:
@@ -4542,12 +5132,12 @@ class RemoteCommandExecutor(CommandExecutor):
             ], return_when=asyncio.FIRST_COMPLETED)
 
             if queue_task in done:
-                req = check_isinstance(queue_task.result(), RemoteCommandExecutor._Request)
+                req = check.isinstance(queue_task.result(), RemoteCommandExecutor._Request)
                 queue_task = None
                 await self._handle_request(req)
 
             if recv_task in done:
-                msg: ta.Optional[_RemoteProtocol.Message] = check_isinstance(
+                msg: ta.Optional[_RemoteProtocol.Message] = check.isinstance(
                     recv_task.result(),
                     (_RemoteProtocol.Message, type(None)),
                 )
@@ -4615,7 +5205,7 @@ class RemoteCommandExecutor(CommandExecutor):
         if (e := r.exception) is not None:
             raise RemoteCommandError(e)
         else:
-            return check_not_none(r.output)
+            return check.not_none(r.output)
 
     # @ta.override
     async def try_execute(
@@ -4660,7 +5250,7 @@ async def asyncio_subprocess_popen(
     if shell:
         fac = functools.partial(
             asyncio.create_subprocess_shell,
-            check_single(cmd),
+            check.single(cmd),
         )
     else:
         fac = functools.partial(
@@ -4700,7 +5290,7 @@ class AsyncioProcessCommunicator:
         self._proc = proc
         self._loop = loop
 
-        self._transport: asyncio.base_subprocess.BaseSubprocessTransport = check_isinstance(
+        self._transport: asyncio.base_subprocess.BaseSubprocessTransport = check.isinstance(
             proc._transport,  # type: ignore  # noqa
             asyncio.base_subprocess.BaseSubprocessTransport,
         )
@@ -4710,7 +5300,7 @@ class AsyncioProcessCommunicator:
         return self._loop.get_debug()
 
     async def _feed_stdin(self, input: bytes) -> None:  # noqa
-        stdin = check_not_none(self._proc.stdin)
+        stdin = check.not_none(self._proc.stdin)
         try:
             if input is not None:
                 stdin.write(input)
@@ -4734,13 +5324,13 @@ class AsyncioProcessCommunicator:
         return None
 
     async def _read_stream(self, fd: int) -> bytes:
-        transport: ta.Any = check_not_none(self._transport.get_pipe_transport(fd))
+        transport: ta.Any = check.not_none(self._transport.get_pipe_transport(fd))
 
         if fd == 2:
-            stream = check_not_none(self._proc.stderr)
+            stream = check.not_none(self._proc.stderr)
         else:
-            check_equal(fd, 1)
-            stream = check_not_none(self._proc.stdout)
+            check.equal(fd, 1)
+            stream = check.not_none(self._proc.stdout)
 
         if self._debug:
             name = 'stdout' if fd == 1 else 'stderr'
@@ -4860,7 +5450,7 @@ async def asyncio_subprocess_check_output(
         **kwargs,
     )
 
-    return check_not_none(stdout)
+    return check.not_none(stdout)
 
 
 async def asyncio_subprocess_check_output_str(*args: str, **kwargs: ta.Any) -> str:
@@ -5038,7 +5628,7 @@ class SubprocessCommand(Command['SubprocessCommand.Output']):
     timeout: ta.Optional[float] = None
 
     def __post_init__(self) -> None:
-        check_not_isinstance(self.cmd, str)
+        check.not_isinstance(self.cmd, str)
 
     @dc.dataclass(frozen=True)
     class Output(Command.Output):
@@ -5079,7 +5669,7 @@ class SubprocessCommandExecutor(CommandExecutor[SubprocessCommand, SubprocessCom
             end_time = time.time()
 
         return SubprocessCommand.Output(
-            rc=check_not_none(proc.returncode),
+            rc=check.not_none(proc.returncode),
             pid=proc.pid,
 
             elapsed_s=end_time - start_time,
@@ -5123,11 +5713,11 @@ class _RemoteExecutionMain:
 
     @property
     def _bootstrap(self) -> MainBootstrap:
-        return check_not_none(self.__bootstrap)
+        return check.not_none(self.__bootstrap)
 
     @property
     def _injector(self) -> Injector:
-        return check_not_none(self.__injector)
+        return check.not_none(self.__injector)
 
     #
 
@@ -5171,12 +5761,12 @@ class _RemoteExecutionMain:
     #
 
     async def _setup(self) -> None:
-        check_none(self.__bootstrap)
-        check_none(self.__injector)
+        check.none(self.__bootstrap)
+        check.none(self.__injector)
 
         # Bootstrap
 
-        self.__bootstrap = check_not_none(await self._chan.recv_obj(MainBootstrap))
+        self.__bootstrap = check.not_none(await self._chan.recv_obj(MainBootstrap))
 
         if (prd := self._bootstrap.remote_config.pycharm_remote_debug) is not None:
             pycharm_debug_connect(prd)
@@ -5318,8 +5908,8 @@ class SubprocessRemoteSpawning(RemoteSpawning):
                 ),
                 timeout=timeout,
         ) as proc:
-            stdin = check_not_none(proc.stdin)
-            stdout = check_not_none(proc.stdout)
+            stdin = check.not_none(proc.stdin)
+            stdout = check.not_none(proc.stdout)
 
             try:
                 yield RemoteSpawning.Spawned(
@@ -5535,7 +6125,7 @@ class Pyenv:
 
     @async_cached_nullary
     async def exe(self) -> str:
-        return os.path.join(check_not_none(await self.root()), 'bin', 'pyenv')
+        return os.path.join(check.not_none(await self.root()), 'bin', 'pyenv')
 
     async def version_exes(self) -> ta.List[ta.Tuple[str, str]]:
         if (root := await self.root()) is None:
@@ -5761,7 +6351,7 @@ class PyenvVersionInstaller:
 
     @async_cached_nullary
     async def install_dir(self) -> str:
-        return str(os.path.join(check_not_none(await self._pyenv.root()), 'versions', self.install_name()))
+        return str(os.path.join(check.not_none(await self._pyenv.root()), 'versions', self.install_name()))
 
     @async_cached_nullary
     async def install(self) -> str:
@@ -5784,7 +6374,7 @@ class PyenvVersionInstaller:
 
         if self._given_install_name is not None:
             full_args = [
-                os.path.join(check_not_none(await self._pyenv.root()), 'plugins', 'python-build', 'bin', 'python-build'),  # noqa
+                os.path.join(check.not_none(await self._pyenv.root()), 'plugins', 'python-build', 'bin', 'python-build'),  # noqa
                 *conf_args,
                 self.install_dir(),
             ]
@@ -5856,7 +6446,7 @@ class PyenvInterpProvider(InterpProvider):
         iv: ta.Optional[InterpVersion]
         if self._inspect:
             try:
-                iv = check_not_none(await self._inspector.inspect(ep)).iv
+                iv = check.not_none(await self._inspector.inspect(ep)).iv
             except Exception as e:  # noqa
                 return None
         else:
@@ -6191,8 +6781,8 @@ class InterpCommand(Command['InterpCommand.Output']):
 
 class InterpCommandExecutor(CommandExecutor[InterpCommand, InterpCommand.Output]):
     async def execute(self, cmd: InterpCommand) -> InterpCommand.Output:
-        i = InterpSpecifier.parse(check_not_none(cmd.spec))
-        o = check_not_none(await DEFAULT_INTERP_RESOLVER.resolve(i, install=cmd.install))
+        i = InterpSpecifier.parse(check.not_none(cmd.spec))
+        o = check.not_none(await DEFAULT_INTERP_RESOLVER.resolve(i, install=cmd.install))
         return InterpCommand.Output(
             exe=o.exe,
             version=str(o.version.version),
@@ -6383,108 +6973,102 @@ def main_bootstrap(bs: MainBootstrap) -> Injector:
 # main.py
 
 
-##
+class MainCli(ArgparseCli):
+    @argparse_command(
+        argparse_arg('--payload-file'),
 
+        argparse_arg('-s', '--shell'),
+        argparse_arg('-q', '--shell-quote', action='store_true'),
+        argparse_arg('--python', default='python3'),
 
-async def _async_main(args: ta.Any) -> None:
-    bs = MainBootstrap(
-        main_config=MainConfig(
-            log_level='DEBUG' if args.debug else 'INFO',
+        argparse_arg('--pycharm-debug-port', type=int),
+        argparse_arg('--pycharm-debug-host'),
+        argparse_arg('--pycharm-debug-version'),
 
-            debug=bool(args.debug),
-        ),
+        argparse_arg('--remote-timebomb-delay-s', type=float),
 
-        remote_config=RemoteConfig(
-            payload_file=args._payload_file,  # noqa
+        argparse_arg('--debug', action='store_true'),
 
-            pycharm_remote_debug=PycharmRemoteDebug(
-                port=args.pycharm_debug_port,
-                **(dict(host=args.pycharm_debug_host) if args.pycharm_debug_host is not None else {}),
-                install_version=args.pycharm_debug_version,
-            ) if args.pycharm_debug_port is not None else None,
+        argparse_arg('--local', action='store_true'),
 
-            timebomb_delay_s=args.remote_timebomb_delay_s,
-        ),
+        argparse_arg('command', nargs='+'),
     )
+    def run(self) -> None:
+        asyncio.run(self._async_run())
 
-    #
-
-    injector = main_bootstrap(
-        bs,
-    )
+    async def _async_run(self) -> None:
+        bs = MainBootstrap(
+            main_config=MainConfig(
+                log_level='DEBUG' if self.args.debug else 'INFO',
 
-    #
-
-    msh = injector[ObjMarshalerManager]
-
-    cmds: ta.List[Command] = []
-    cmd: Command
-    for c in args.command:
-        if not c.startswith('{'):
-            c = json.dumps({c: {}})
-        cmd = msh.unmarshal_obj(json.loads(c), Command)
-        cmds.append(cmd)
-
-    #
-
-    async with contextlib.AsyncExitStack() as es:
-        ce: CommandExecutor
-
-        if args.local:
-            ce = injector[LocalCommandExecutor]
+                debug=bool(self.args.debug),
+            ),
 
-        else:
-            tgt = RemoteSpawning.Target(
-                shell=args.shell,
-                shell_quote=args.shell_quote,
-                python=args.python,
-            )
+            remote_config=RemoteConfig(
+                payload_file=self.args.payload_file,  # noqa
 
-            ce = await es.enter_async_context(injector[RemoteExecutionConnector].connect(tgt, bs))  # noqa
+                pycharm_remote_debug=PycharmRemoteDebug(
+                    port=self.args.pycharm_debug_port,
+                    **(dict(host=self.args.pycharm_debug_host) if self.args.pycharm_debug_host is not None else {}),
+                    install_version=self.args.pycharm_debug_version,
+                ) if self.args.pycharm_debug_port is not None else None,
 
-        async def run_command(cmd: Command) -> None:
-            res = await ce.try_execute(
-                cmd,
-                log=log,
-                omit_exc_object=True,
-            )
+                timebomb_delay_s=self.args.remote_timebomb_delay_s,
+            ),
+        )
 
-            print(msh.marshal_obj(res, opts=ObjMarshalOptions(raw_bytes=True)))
+        #
 
-        await asyncio.gather(*[
-            run_command(cmd)
-            for cmd in cmds
-        ])
+        injector = main_bootstrap(
+            bs,
+        )
 
+        #
 
-def _main() -> None:
-    import argparse
+        msh = injector[ObjMarshalerManager]
 
-    parser = argparse.ArgumentParser()
+        cmds: ta.List[Command] = []
+        cmd: Command
+        for c in self.args.command:
+            if not c.startswith('{'):
+                c = json.dumps({c: {}})
+            cmd = msh.unmarshal_obj(json.loads(c), Command)
+            cmds.append(cmd)
 
-    parser.add_argument('--_payload-file')
+        #
 
-    parser.add_argument('-s', '--shell')
-    parser.add_argument('-q', '--shell-quote', action='store_true')
-    parser.add_argument('--python', default='python3')
+        async with contextlib.AsyncExitStack() as es:
+            ce: CommandExecutor
 
-    parser.add_argument('--pycharm-debug-port', type=int)
-    parser.add_argument('--pycharm-debug-host')
-    parser.add_argument('--pycharm-debug-version')
+            if self.args.local:
+                ce = injector[LocalCommandExecutor]
 
-    parser.add_argument('--remote-timebomb-delay-s', type=float)
+            else:
+                tgt = RemoteSpawning.Target(
+                    shell=self.args.shell,
+                    shell_quote=self.args.shell_quote,
+                    python=self.args.python,
+                )
 
-    parser.add_argument('--debug', action='store_true')
+                ce = await es.enter_async_context(injector[RemoteExecutionConnector].connect(tgt, bs))  # noqa
 
-    parser.add_argument('--local', action='store_true')
+            async def run_command(cmd: Command) -> None:
+                res = await ce.try_execute(
+                    cmd,
+                    log=log,
+                    omit_exc_object=True,
+                )
 
-    parser.add_argument('command', nargs='+')
+                print(msh.marshal_obj(res, opts=ObjMarshalOptions(raw_bytes=True)))
 
-    args = parser.parse_args()
+            await asyncio.gather(*[
+                run_command(cmd)
+                for cmd in cmds
+            ])
 
-    #
 
-    asyncio.run(_async_main(args))
+def _main() -> None:
+    MainCli().call_and_exit()
 
 
 if __name__ == '__main__':