omlish 0.0.0.dev149__py3-none-any.whl → 0.0.0.dev151__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev149'
-__revision__ = '78e7c7e35dc2bc806db7fd199c1ce42b0f41cbe8'
+__version__ = '0.0.0.dev151'
+__revision__ = '7d978888ef2b04964976a01388376b919ec8bafe'
 
 
 #

omlish/argparse/cli.py

@@ -11,16 +11,15 @@ import functools
 import sys
 import typing as ta
 
-from ..lite.check import check_arg
-from ..lite.check import check_isinstance
-from ..lite.check import check_not_empty
-from ..lite.check import check_not_in
-from ..lite.check import check_not_isinstance
+from ..lite.check import check
 
 
 T = ta.TypeVar('T')
 
 
+ArgparseCommandFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
+
+
 ##
 
 
@@ -43,9 +42,6 @@ def argparse_arg(*args, **kwargs) -> ArgparseArg:
 #
 
 
-ArgparseCommandFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
-
-
 @dc.dataclass(eq=False)
 class ArgparseCommand:
     name: str
@@ -60,18 +56,18 @@ class ArgparseCommand:
 
     def __post_init__(self) -> None:
         def check_name(s: str) -> None:
-            check_isinstance(s, str)
-            check_not_in('_', s)
-            check_not_empty(s)
+            check.isinstance(s, str)
+            check.not_in('_', s)
+            check.not_empty(s)
         check_name(self.name)
-        check_not_isinstance(self.aliases, str)
+        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)
+        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)
 
@@ -92,10 +88,10 @@ def argparse_command(
         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)
+        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(
@@ -151,7 +147,7 @@ class ArgparseCli:
             bseen = set()  # type: ignore
             for k, v in bns.items():
                 if isinstance(v, (ArgparseCommand, ArgparseArg)):
-                    check_not_in(v, bseen)
+                    check.not_in(v, bseen)
                     bseen.add(v)
                     objs[k] = v
                 elif k in objs:
@@ -163,7 +159,7 @@ class ArgparseCli:
         }), globalns=ns.get('__globals__', {}))
 
         if '_parser' in ns:
-            parser = check_isinstance(ns['_parser'], argparse.ArgumentParser)
+            parser = check.isinstance(ns['_parser'], argparse.ArgumentParser)
         else:
             parser = argparse.ArgumentParser()
             setattr(cls, '_parser', parser)
@@ -179,7 +175,7 @@ class ArgparseCli:
                         if (
                                 len(arg.args) == 1 and
                                 isinstance(arg.args[0], str) and
-                                not (n := check_isinstance(arg.args[0], str)).startswith('-') and
+                                not (n := check.isinstance(arg.args[0], str)).startswith('-') and
                                 'metavar' not in arg.kwargs
                         ):
                             cparser.add_argument(

omlish/check.py

@@ -1,20 +1,13 @@
-"""
-TODO:
- - def maybe(v: lang.Maybe[T])
- - patch / override lite.check ?
-  - checker interface?
-"""
-import collections
-import threading
 import typing as ta
 
+from .lite.check import CheckArgsRenderer as ArgsRenderer  # noqa
+from .lite.check import CheckExceptionFactory as ExceptionFactory  # noqa
+from .lite.check import CheckLateConfigureFn as LateConfigureFn  # noqa
+from .lite.check import CheckMessage as Message  # noqa
+from .lite.check import CheckOnRaiseFn as OnRaiseFn  # noqa
+from .lite.check import Checks
+from .lite.check import check
 
-T = ta.TypeVar('T')
-SizedT = ta.TypeVar('SizedT', bound=ta.Sized)
-
-Message: ta.TypeAlias = str | ta.Callable[..., str | None] | None
-
-_NONE_TYPE = type(None)
 
 _isinstance = isinstance
 _issubclass = issubclass
@@ -24,43 +17,21 @@ _callable = callable
 ##
 
 
-_CONFIG_LOCK = threading.RLock()
-
-
-OnRaiseFn: ta.TypeAlias = ta.Callable[[Exception], None]
-_ON_RAISE: ta.Sequence[OnRaiseFn] = []
-
-
-def register_on_raise(fn: OnRaiseFn) -> None:
-    global _ON_RAISE
-    with _CONFIG_LOCK:
-        _ON_RAISE = [*_ON_RAISE, fn]
-
-
-def unregister_on_raise(fn: OnRaiseFn) -> None:
-    global _ON_RAISE
-    with _CONFIG_LOCK:
-        _ON_RAISE = [e for e in _ON_RAISE if e != fn]
+register_on_raise = check.register_on_raise
+unregister_on_raise = check.unregister_on_raise
 
 
-#
-
-
-_ARGS_RENDERER: ta.Callable[..., str | None] | None = None
-
+##
 
-def _try_enable_args_rendering() -> bool:
-    global _ARGS_RENDERER
-    if _ARGS_RENDERER is not None:
-        return True
 
+def _try_get_args_rendering() -> ArgsRenderer | None:
     try:
         from .diag.asts import ArgsRenderer
 
         ArgsRenderer.smoketest()
 
     except Exception:  # noqa
-        return False
+        return None
 
     def _real_render_args(fmt: str, *args: ta.Any) -> str | None:
         ra = ArgsRenderer(back=3).render_args(*args)
@@ -69,445 +40,59 @@ def _try_enable_args_rendering() -> bool:
 
         return fmt % tuple(str(a) for a in ra)
 
-    _ARGS_RENDERER = _real_render_args
-    return True
-
-
-_TRIED_ENABLED_ARGS_RENDERING: bool | None = None
-
-
-def try_enable_args_rendering() -> bool:
-    global _TRIED_ENABLED_ARGS_RENDERING
-    if _TRIED_ENABLED_ARGS_RENDERING is not None:
-        return _TRIED_ENABLED_ARGS_RENDERING
-
-    with _CONFIG_LOCK:
-        if _TRIED_ENABLED_ARGS_RENDERING is None:
-            _TRIED_ENABLED_ARGS_RENDERING = _try_enable_args_rendering()
-
-        return _TRIED_ENABLED_ARGS_RENDERING
-
-
-##
-
-
-def _default_exception_factory(exc_cls: type[Exception], *args, **kwargs) -> Exception:
-    return exc_cls(*args, **kwargs)  # noqa
-
-
-_EXCEPTION_FACTORY = _default_exception_factory
-
-
-class _ArgsKwargs:
-    def __init__(self, *args, **kwargs):
-        self.args = args
-        self.kwargs = kwargs
-
-
-def _raise(
-        exception_type: type[Exception],
-        default_message: str,
-        message: Message,
-        ak: _ArgsKwargs = _ArgsKwargs(),
-        *,
-        render_fmt: str | None = 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
-
-    try_enable_args_rendering()
-
-    if render_fmt is not None and _ARGS_RENDERER is not None:
-        rendered_args = _ARGS_RENDERER(render_fmt, *ak.args)
-        if rendered_args is not None:
-            message = f'{message} : {rendered_args}'
-
-    exc = _EXCEPTION_FACTORY(
-        exception_type,
-        message,
-        *exc_args,
-        *ak.args,
-        **ak.kwargs,
-    )
-
-    for fn in _ON_RAISE:
-        fn(exc)
-
-    raise exc
-
-
-##
-
-
-def _unpack_isinstance_spec(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_TYPE,)  # noqa
-    if ta.Any in spec:
-        spec = (object,)
-    return spec
-
-
-def isinstance(v: ta.Any, spec: type[T] | tuple, msg: Message = None) -> T:  # noqa
-    if not _isinstance(v, _unpack_isinstance_spec(spec)):
-        _raise(
-            TypeError,
-            'Must be instance',
-            msg,
-            _ArgsKwargs(v, spec),
-            render_fmt='not isinstance(%s, %s)',
-        )
-
-    return v
-
-
-def of_isinstance(spec: type[T] | tuple, msg: Message = None) -> ta.Callable[[ta.Any], T]:
-    def inner(v):
-        return isinstance(v, _unpack_isinstance_spec(spec), msg)
-
-    return inner
-
-
-def cast(v: ta.Any, cls: type[T], msg: Message = None) -> T:  # noqa
-    if not _isinstance(v, cls):
-        _raise(
-            TypeError,
-            'Must be instance',
-            msg,
-            _ArgsKwargs(v, cls),
-        )
-
-    return v
-
-
-def of_cast(cls: type[T], msg: Message = None) -> ta.Callable[[T], T]:
-    def inner(v):
-        return isinstance(v, cls, msg)
-
-    return inner
-
-
-def not_isinstance(v: T, spec: ta.Any, msg: Message = None) -> T:  # noqa
-    if _isinstance(v, _unpack_isinstance_spec(spec)):
-        _raise(
-            TypeError,
-            'Must not be instance',
-            msg,
-            _ArgsKwargs(v, spec),
-            render_fmt='isinstance(%s, %s)',
-        )
-
-    return v
-
+    return _real_render_args
 
-def of_not_isinstance(spec: ta.Any, msg: Message = None) -> ta.Callable[[T], T]:
-    def inner(v):
-        return not_isinstance(v, _unpack_isinstance_spec(spec), msg)
 
-    return inner
+def _try_enable_args_rendering(c: Checks) -> None:
+    if (rf := _try_get_args_rendering()) is not None:
+        c.set_args_renderer(rf)
 
 
-##
-
-
-def issubclass(v: type[T], spec: ta.Any, msg: Message = None) -> type[T]:  # noqa
-    if not _issubclass(v, spec):
-        _raise(
-            TypeError,
-            'Must be subclass',
-            msg,
-            _ArgsKwargs(v, spec),
-            render_fmt='not issubclass(%s, %s)',
-        )
-
-    return v
-
-
-def not_issubclass(v: type[T], spec: ta.Any, msg: Message = None) -> type[T]:  # noqa
-    if _issubclass(v, spec):
-        _raise(
-            TypeError,
-            'Must not be subclass',
-            msg,
-            _ArgsKwargs(v, spec),
-            render_fmt='issubclass(%s, %s)',
-        )
-
-    return v
-
-
-##
-
-
-def in_(v: T, c: ta.Container[T], msg: Message = None) -> T:
-    if v not in c:
-        _raise(
-            ValueError,
-            'Must be in',
-            msg,
-            _ArgsKwargs(v, c),
-            render_fmt='%s not in %s',
-        )
-
-    return v
-
-
-def not_in(v: T, c: ta.Container[T], msg: Message = None) -> T:
-    if v in c:
-        _raise(
-            ValueError,
-            'Must not be in',
-            msg,
-            _ArgsKwargs(v, c),
-            render_fmt='%s in %s',
-        )
-
-    return v
-
-
-def empty(v: SizedT, msg: Message = None) -> SizedT:
-    if len(v) != 0:
-        _raise(
-            ValueError,
-            'Must be empty',
-            msg,
-            _ArgsKwargs(v),
-            render_fmt='%s',
-        )
-
-    return v
-
-
-def iterempty(v: ta.Iterable[T], msg: Message = None) -> ta.Iterable[T]:
-    it = iter(v)
-    try:
-        next(it)
-    except StopIteration:
-        pass
-    else:
-        _raise(
-            ValueError,
-            'Must be empty',
-            msg,
-            _ArgsKwargs(v),
-            render_fmt='%s',
-        )
-
-    return v
-
-
-def not_empty(v: SizedT, msg: Message = None) -> SizedT:
-    if len(v) == 0:
-        _raise(
-            ValueError,
-            'Must not be empty',
-            msg,
-            _ArgsKwargs(v),
-            render_fmt='%s',
-        )
-
-    return v
-
-
-def unique(it: ta.Iterable[T], msg: Message = None) -> ta.Iterable[T]:
-    dupes = [e for e, c in collections.Counter(it).items() if c > 1]
-    if dupes:
-        _raise(
-            ValueError,
-            'Must be unique',
-            msg,
-            _ArgsKwargs(it, dupes),
-        )
-
-    return it
-
-
-def single(obj: ta.Iterable[T], message: Message = None) -> T:
-    try:
-        [value] = obj
-    except ValueError:
-        _raise(
-            ValueError,
-            'Must be single',
-            message,
-            _ArgsKwargs(obj),
-            render_fmt='%s',
-        )
-
-    return value
-
-
-def opt_single(obj: ta.Iterable[T], message: Message = None) -> T | None:
-    it = iter(obj)
-    try:
-        value = next(it)
-    except StopIteration:
-        return None
-
-    try:
-        next(it)
-    except StopIteration:
-        return value  # noqa
-
-    _raise(
-        ValueError,
-        'Must be empty or single',
-        message,
-        _ArgsKwargs(obj),
-        render_fmt='%s',
-    )
+check.register_late_configure(_try_enable_args_rendering)
 
 
 ##
 
 
-def none(v: ta.Any, msg: Message = None) -> None:
-    if v is not None:
-        _raise(
-            ValueError,
-            'Must be None',
-            msg,
-            _ArgsKwargs(v),
-            render_fmt='%s',
-        )
-
-
-def not_none(v: T | None, msg: Message = None) -> T:
-    if v is None:
-        _raise(
-            ValueError,
-            'Must not be None',
-            msg,
-            _ArgsKwargs(v),
-            render_fmt='%s',
-        )
-
-    return v
-
-
-##
-
-
-def equal(v: T, o: ta.Any, msg: Message = None) -> T:
-    if o != v:
-        _raise(
-            ValueError,
-            'Must be equal',
-            msg,
-            _ArgsKwargs(v, o),
-            render_fmt='%s != %s',
-        )
-
-    return v
-
-
-def is_(v: T, o: ta.Any, msg: Message = None) -> T:
-    if o is not v:
-        _raise(
-            ValueError,
-            'Must be the same',
-            msg,
-            _ArgsKwargs(v, o),
-            render_fmt='%s is not %s',
-        )
-
-    return v
-
-
-def is_not(v: T, o: ta.Any, msg: Message = None) -> T:
-    if o is v:
-        _raise(
-            ValueError,
-            'Must not be the same',
-            msg,
-            _ArgsKwargs(v, o),
-            render_fmt='%s is %s',
-        )
-
-    return v
-
-
-def callable(v: T, msg: Message = None) -> T:  # noqa
-    if not _callable(v):
-        _raise(
-            TypeError,
-            'Must be callable',
-            msg,
-            _ArgsKwargs(v),
-            render_fmt='%s',
-        )
-
-    return v  # type: ignore
-
-
-def non_empty_str(v: str | None, msg: Message = None) -> str:
-    if not _isinstance(v, str) or not v:
-        _raise(
-            ValueError,
-            'Must be non-empty str',
-            msg,
-            _ArgsKwargs(v),
-            render_fmt='%s',
-        )
-
-    return v
+isinstance = check.isinstance  # noqa
+of_isinstance = check.of_isinstance
+cast = check.cast
+of_cast = check.of_cast
+not_isinstance = check.not_isinstance
+of_not_isinstance = check.of_not_isinstance
 
+#
 
-def replacing(expected: ta.Any, old: ta.Any, new: T, msg: Message = None) -> T:
-    if old != expected:
-        _raise(
-            ValueError,
-            'Must be replacing',
-            msg,
-            _ArgsKwargs(expected, old, new),
-            render_fmt='%s -> %s -> %s',
-        )
+issubclass = check.issubclass  # noqa
+not_issubclass = check.not_issubclass
 
-    return new
+#
 
+in_ = check.in_
+not_in = check.not_in
+empty = check.empty
+iterempty = check.iterempty
+not_empty = check.not_empty
+unique = check.unique
+single = check.single
+opt_single = check.opt_single
 
-def replacing_none(old: ta.Any, new: T, msg: Message = None) -> T:
-    if old is not None:
-        _raise(
-            ValueError,
-            'Must be replacing None',
-            msg,
-            _ArgsKwargs(old, new),
-            render_fmt='%s -> %s',
-        )
+#
 
-    return new
+none = check.none
+not_none = check.not_none
 
+#
 
-##
+equal = check.equal
+is_ = check.is_
+is_not = check.is_not
+callable = check.callable  # noqa
+non_empty_str = check.non_empty_str
+replacing = check.replacing
+replacing_none = check.replacing_none
 
+#
 
-def arg(v: bool, msg: Message = None) -> None:
-    if not v:
-        _raise(
-            RuntimeError,
-            'Argument condition not met',
-            msg,
-            _ArgsKwargs(v),
-            render_fmt='%s',
-        )
-
-
-def state(v: bool, msg: Message = None) -> None:
-    if not v:
-        _raise(
-            RuntimeError,
-            'State condition not met',
-            msg,
-            _ArgsKwargs(v),
-            render_fmt='%s',
-        )
+arg = check.arg
+state = check.state

omlish/docker/__init__.py

@@ -1,37 +0,0 @@
-from .cli import (  # noqa
-    Inspect,
-    Port,
-    PsItem,
-    cli_inspect,
-    cli_ps,
-    has_cli,
-    parse_port,
-)
-
-from .compose import (  # noqa
-    ComposeConfig,
-    get_compose_port,
-)
-
-from .helpers import (  # noqa
-    DOCKER_HOST_PLATFORM_KEY,
-    get_docker_host_platform,
-    timebomb_payload,
-)
-
-from .hub import (  # noqa
-    HubRepoInfo,
-    get_hub_repo_info,
-    select_latest_tag,
-    split_tag_suffix,
-)
-
-
-##
-
-
-from ..lite.docker import (  # noqa
-    DOCKER_FOR_MAC_HOSTNAME,
-
-    is_likely_in_docker,
-)