omdev 0.0.0.dev419__py3-none-any.whl → 0.0.0.dev421__py3-none-any.whl

omdev/scripts/interp.py

@@ -72,12 +72,6 @@ CheckOnRaiseFn = ta.Callable[[Exception], None]  # ta.TypeAlias
 CheckExceptionFactory = ta.Callable[..., Exception]  # ta.TypeAlias
 CheckArgsRenderer = ta.Callable[..., ta.Optional[str]]  # ta.TypeAlias
 
-# ../../omlish/lite/maybes.py
-U = ta.TypeVar('U')
-
-# ../../omlish/lite/timeouts.py
-TimeoutLike = ta.Union['Timeout', ta.Type['Timeout.DEFAULT'], ta.Iterable['TimeoutLike'], float, None]  # ta.TypeAlias
-
 # ../packaging/specifiers.py
 UnparsedVersion = ta.Union['Version', str]
 UnparsedVersionVar = ta.TypeVar('UnparsedVersionVar', bound=UnparsedVersion)
@@ -86,6 +80,12 @@ CallableVersionOperator = ta.Callable[['Version', str], bool]
 # ../../omlish/argparse/cli.py
 ArgparseCmdFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
 
+# ../../omlish/lite/maybes.py
+U = ta.TypeVar('U')
+
+# ../../omlish/lite/timeouts.py
+TimeoutLike = ta.Union['Timeout', ta.Type['Timeout.DEFAULT'], ta.Iterable['TimeoutLike'], float, None]  # ta.TypeAlias
+
 # ../../omlish/asyncs/asyncio/timeouts.py
 AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
 
@@ -506,6 +506,126 @@ def canonicalize_version(
     return ''.join(parts)
 
 
+########################################
+# ../../../omlish/lite/abstract.py
+
+
+##
+
+
+_ABSTRACT_METHODS_ATTR = '__abstractmethods__'
+_IS_ABSTRACT_METHOD_ATTR = '__isabstractmethod__'
+
+
+def is_abstract_method(obj: ta.Any) -> bool:
+    return bool(getattr(obj, _IS_ABSTRACT_METHOD_ATTR, False))
+
+
+def update_abstracts(cls, *, force=False):
+    if not force and not hasattr(cls, _ABSTRACT_METHODS_ATTR):
+        # Per stdlib: We check for __abstractmethods__ here because cls might by a C implementation or a python
+        # implementation (especially during testing), and we want to handle both cases.
+        return cls
+
+    abstracts: ta.Set[str] = set()
+
+    for scls in cls.__bases__:
+        for name in getattr(scls, _ABSTRACT_METHODS_ATTR, ()):
+            value = getattr(cls, name, None)
+            if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
+                abstracts.add(name)
+
+    for name, value in cls.__dict__.items():
+        if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
+            abstracts.add(name)
+
+    setattr(cls, _ABSTRACT_METHODS_ATTR, frozenset(abstracts))
+    return cls
+
+
+#
+
+
+class AbstractTypeError(TypeError):
+    pass
+
+
+_FORCE_ABSTRACT_ATTR = '__forceabstract__'
+
+
+class Abstract:
+    """
+    Different from, but interoperable with, abc.ABC / abc.ABCMeta:
+
+     - This raises AbstractTypeError during class creation, not instance instantiation - unless Abstract or abc.ABC are
+       explicitly present in the class's direct bases.
+     - This will forbid instantiation of classes with Abstract in their direct bases even if there are no
+       abstractmethods left on the class.
+     - This is a mixin, not a metaclass.
+     - As it is not an ABCMeta, this does not support virtual base classes. As a result, operations like `isinstance`
+       and `issubclass` are ~7x faster.
+     - It additionally enforces a base class order of (Abstract, abc.ABC) to preemptively prevent common mro conflicts.
+
+    If not mixed-in with an ABCMeta, it will update __abstractmethods__ itself.
+    """
+
+    __slots__ = ()
+
+    __abstractmethods__: ta.ClassVar[ta.FrozenSet[str]] = frozenset()
+
+    #
+
+    def __forceabstract__(self):
+        raise TypeError
+
+    # This is done manually, rather than through @abc.abstractmethod, to mask it from static analysis.
+    setattr(__forceabstract__, _IS_ABSTRACT_METHOD_ATTR, True)
+
+    #
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        setattr(
+            cls,
+            _FORCE_ABSTRACT_ATTR,
+            getattr(Abstract, _FORCE_ABSTRACT_ATTR) if Abstract in cls.__bases__ else False,
+        )
+
+        super().__init_subclass__(**kwargs)
+
+        if not (Abstract in cls.__bases__ or abc.ABC in cls.__bases__):
+            ams = {a: cls for a, o in cls.__dict__.items() if is_abstract_method(o)}
+
+            seen = set(cls.__dict__)
+            for b in cls.__bases__:
+                ams.update({a: b for a in set(getattr(b, _ABSTRACT_METHODS_ATTR, [])) - seen})  # noqa
+                seen.update(dir(b))
+
+            if ams:
+                raise AbstractTypeError(
+                    f'Cannot subclass abstract class {cls.__name__} with abstract methods: ' +
+                    ', '.join(sorted([
+                        '.'.join([
+                            *([m] if (m := getattr(c, '__module__')) else []),
+                            getattr(c, '__qualname__', getattr(c, '__name__')),
+                            a,
+                        ])
+                        for a, c in ams.items()
+                    ])),
+                )
+
+        xbi = (Abstract, abc.ABC)  # , ta.Generic ?
+        bis = [(cls.__bases__.index(b), b) for b in xbi if b in cls.__bases__]
+        if bis != sorted(bis):
+            raise TypeError(
+                f'Abstract subclass {cls.__name__} must have proper base class order of '
+                f'({", ".join(getattr(b, "__name__") for b in xbi)}), got: '
+                f'({", ".join(getattr(b, "__name__") for _, b in sorted(bis))})',
+            )
+
+        if not isinstance(cls, abc.ABCMeta):
+            update_abstracts(cls, force=True)
+
+
 ########################################
 # ../../../omlish/lite/cached.py
 
@@ -1086,335 +1206,116 @@ json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON
 
 
 ########################################
-# ../../../omlish/lite/maybes.py
+# ../../../omlish/lite/reflect.py
 
 
 ##
 
 
-@functools.total_ordering
-class Maybe(ta.Generic[T]):
-    class ValueNotPresentError(BaseException):
-        pass
+_GENERIC_ALIAS_TYPES = (
+    ta._GenericAlias,  # type: ignore  # noqa
+    *([ta._SpecialGenericAlias] if hasattr(ta, '_SpecialGenericAlias') else []),  # noqa
+)
 
-    #
 
-    @property
-    @abc.abstractmethod
-    def present(self) -> bool:
-        raise NotImplementedError
+def is_generic_alias(obj: ta.Any, *, origin: ta.Any = None) -> bool:
+    return (
+        isinstance(obj, _GENERIC_ALIAS_TYPES) and
+        (origin is None or ta.get_origin(obj) is origin)
+    )
 
-    @abc.abstractmethod
-    def must(self) -> T:
-        raise NotImplementedError
 
-    #
+is_callable_alias = functools.partial(is_generic_alias, origin=ta.Callable)
 
-    @abc.abstractmethod
-    def __repr__(self) -> str:
-        raise NotImplementedError
 
-    @abc.abstractmethod
-    def __hash__(self) -> int:
-        raise NotImplementedError
+##
 
-    @abc.abstractmethod
-    def __eq__(self, other) -> bool:
-        raise NotImplementedError
 
-    @abc.abstractmethod
-    def __lt__(self, other) -> bool:
-        raise NotImplementedError
+_UNION_ALIAS_ORIGINS = frozenset([
+    ta.get_origin(ta.Optional[int]),
+    *(
+        [
+            ta.get_origin(int | None),
+            ta.get_origin(getattr(ta, 'TypeVar')('_T') | None),
+        ] if sys.version_info >= (3, 10) else ()
+    ),
+])
 
-    #
 
-    @ta.final
-    def __ne__(self, other):
-        return not (self == other)
+def is_union_alias(obj: ta.Any) -> bool:
+    return ta.get_origin(obj) in _UNION_ALIAS_ORIGINS
 
-    @ta.final
-    def __iter__(self) -> ta.Iterator[T]:
-        if self.present:
-            yield self.must()
 
-    @ta.final
-    def __bool__(self) -> ta.NoReturn:
-        raise TypeError
+#
 
-    #
 
-    @ta.final
-    def if_present(self, consumer: ta.Callable[[T], None]) -> None:
-        if self.present:
-            consumer(self.must())
+def is_optional_alias(spec: ta.Any) -> bool:
+    return (
+        is_union_alias(spec) and
+        len(ta.get_args(spec)) == 2 and
+        any(a in (None, type(None)) for a in ta.get_args(spec))
+    )
 
-    @ta.final
-    def filter(self, predicate: ta.Callable[[T], bool]) -> 'Maybe[T]':
-        if self.present and predicate(self.must()):
-            return self
-        else:
-            return Maybe.empty()
 
-    @ta.final
-    def map(self, mapper: ta.Callable[[T], U]) -> 'Maybe[U]':
-        if self.present:
-            return Maybe.just(mapper(self.must()))
-        else:
-            return Maybe.empty()
+def get_optional_alias_arg(spec: ta.Any) -> ta.Any:
+    [it] = [it for it in ta.get_args(spec) if it not in (None, type(None))]
+    return it
 
-    @ta.final
-    def flat_map(self, mapper: ta.Callable[[T], 'Maybe[U]']) -> 'Maybe[U]':
-        if self.present:
-            if not isinstance(v := mapper(self.must()), Maybe):
-                raise TypeError(v)
-            return v
-        else:
-            return Maybe.empty()
 
-    @ta.final
-    def or_else(self, other: ta.Union[T, U]) -> ta.Union[T, U]:
-        if self.present:
-            return self.must()
-        else:
-            return other
+##
 
-    @ta.final
-    def or_else_get(self, supplier: ta.Callable[[], ta.Union[T, U]]) -> ta.Union[T, U]:
-        if self.present:
-            return self.must()
-        else:
-            return supplier()
 
-    @ta.final
-    def or_else_raise(self, exception_supplier: ta.Callable[[], Exception]) -> T:
-        if self.present:
-            return self.must()
-        else:
-            raise exception_supplier()
+def is_new_type(spec: ta.Any) -> bool:
+    if isinstance(ta.NewType, type):
+        return isinstance(spec, ta.NewType)
+    else:
+        # Before https://github.com/python/cpython/commit/c2f33dfc83ab270412bf243fb21f724037effa1a
+        return isinstance(spec, types.FunctionType) and spec.__code__ is ta.NewType.__code__.co_consts[1]  # type: ignore  # noqa
 
-    #
 
-    @classmethod
-    def of_optional(cls, v: ta.Optional[T]) -> 'Maybe[T]':
-        if v is not None:
-            return cls.just(v)
-        else:
-            return cls.empty()
+def get_new_type_supertype(spec: ta.Any) -> ta.Any:
+    return spec.__supertype__
 
-    @classmethod
-    def just(cls, v: T) -> 'Maybe[T]':
-        return _JustMaybe(v)
 
-    _empty: ta.ClassVar['Maybe']
+##
 
-    @classmethod
-    def empty(cls) -> 'Maybe[T]':
-        return Maybe._empty
 
+def is_literal_type(spec: ta.Any) -> bool:
+    if hasattr(ta, '_LiteralGenericAlias'):
+        return isinstance(spec, ta._LiteralGenericAlias)  # noqa
+    else:
+        return (
+            isinstance(spec, ta._GenericAlias) and  # type: ignore  # noqa
+            spec.__origin__ is ta.Literal
+        )
 
-##
 
+def get_literal_type_args(spec: ta.Any) -> ta.Iterable[ta.Any]:
+    return spec.__args__
 
-class _Maybe(Maybe[T], abc.ABC):
-    def __lt__(self, other):
-        if not isinstance(other, _Maybe):
-            return NotImplemented
-        sp = self.present
-        op = other.present
-        if self.present and other.present:
-            return self.must() < other.must()
-        else:
-            return op and not sp
 
+########################################
+# ../../../omlish/lite/strings.py
 
-class _JustMaybe(_Maybe[T]):
-    __slots__ = ('_v', '_hash')
 
-    def __init__(self, v: T) -> None:
-        super().__init__()
+##
 
-        self._v = v
 
-    @property
-    def present(self) -> bool:
-        return True
+def camel_case(name: str, *, lower: bool = False) -> str:
+    if not name:
+        return ''
+    s = ''.join(map(str.capitalize, name.split('_')))  # noqa
+    if lower:
+        s = s[0].lower() + s[1:]
+    return s
 
-    def must(self) -> T:
-        return self._v
 
-    #
+def snake_case(name: str) -> str:
+    uppers: list[int | None] = [i for i, c in enumerate(name) if c.isupper()]
+    return '_'.join([name[l:r].lower() for l, r in zip([None, *uppers], [*uppers, None])]).strip('_')
 
-    def __repr__(self) -> str:
-        return f'just({self._v!r})'
 
-    _hash: int
-
-    def __hash__(self) -> int:
-        try:
-            return self._hash
-        except AttributeError:
-            pass
-        h = self._hash = hash((_JustMaybe, self._v))
-        return h
-
-    def __eq__(self, other):
-        return (
-            self.__class__ is other.__class__ and
-            self._v == other._v  # noqa
-        )
-
-
-class _EmptyMaybe(_Maybe[T]):
-    __slots__ = ()
-
-    @property
-    def present(self) -> bool:
-        return False
-
-    def must(self) -> T:
-        raise Maybe.ValueNotPresentError
-
-    #
-
-    def __repr__(self) -> str:
-        return 'empty()'
-
-    def __hash__(self) -> int:
-        return hash(_EmptyMaybe)
-
-    def __eq__(self, other):
-        return self.__class__ is other.__class__
-
-
-Maybe._empty = _EmptyMaybe()  # noqa
-
-
-########################################
-# ../../../omlish/lite/reflect.py
-
-
-##
-
-
-_GENERIC_ALIAS_TYPES = (
-    ta._GenericAlias,  # type: ignore  # noqa
-    *([ta._SpecialGenericAlias] if hasattr(ta, '_SpecialGenericAlias') else []),  # noqa
-)
-
-
-def is_generic_alias(obj: ta.Any, *, origin: ta.Any = None) -> bool:
-    return (
-        isinstance(obj, _GENERIC_ALIAS_TYPES) and
-        (origin is None or ta.get_origin(obj) is origin)
-    )
-
-
-is_callable_alias = functools.partial(is_generic_alias, origin=ta.Callable)
-
-
-##
-
-
-_UNION_ALIAS_ORIGINS = frozenset([
-    ta.get_origin(ta.Optional[int]),
-    *(
-        [
-            ta.get_origin(int | None),
-            ta.get_origin(getattr(ta, 'TypeVar')('_T') | None),
-        ] if sys.version_info >= (3, 10) else ()
-    ),
-])
-
-
-def is_union_alias(obj: ta.Any) -> bool:
-    return ta.get_origin(obj) in _UNION_ALIAS_ORIGINS
-
-
-#
-
-
-def is_optional_alias(spec: ta.Any) -> bool:
-    return (
-        is_union_alias(spec) and
-        len(ta.get_args(spec)) == 2 and
-        any(a in (None, type(None)) for a in ta.get_args(spec))
-    )
-
-
-def get_optional_alias_arg(spec: ta.Any) -> ta.Any:
-    [it] = [it for it in ta.get_args(spec) if it not in (None, type(None))]
-    return it
-
-
-##
-
-
-def is_new_type(spec: ta.Any) -> bool:
-    if isinstance(ta.NewType, type):
-        return isinstance(spec, ta.NewType)
-    else:
-        # Before https://github.com/python/cpython/commit/c2f33dfc83ab270412bf243fb21f724037effa1a
-        return isinstance(spec, types.FunctionType) and spec.__code__ is ta.NewType.__code__.co_consts[1]  # type: ignore  # noqa
-
-
-def get_new_type_supertype(spec: ta.Any) -> ta.Any:
-    return spec.__supertype__
-
-
-##
-
-
-def is_literal_type(spec: ta.Any) -> bool:
-    if hasattr(ta, '_LiteralGenericAlias'):
-        return isinstance(spec, ta._LiteralGenericAlias)  # noqa
-    else:
-        return (
-            isinstance(spec, ta._GenericAlias) and  # type: ignore  # noqa
-            spec.__origin__ is ta.Literal
-        )
-
-
-def get_literal_type_args(spec: ta.Any) -> ta.Iterable[ta.Any]:
-    return spec.__args__
-
-
-##
-
-
-def deep_subclasses(cls: ta.Type[T]) -> ta.Iterator[ta.Type[T]]:
-    seen = set()
-    todo = list(reversed(cls.__subclasses__()))
-    while todo:
-        cur = todo.pop()
-        if cur in seen:
-            continue
-        seen.add(cur)
-        yield cur
-        todo.extend(reversed(cur.__subclasses__()))
-
-
-########################################
-# ../../../omlish/lite/strings.py
-
-
-##
-
-
-def camel_case(name: str, *, lower: bool = False) -> str:
-    if not name:
-        return ''
-    s = ''.join(map(str.capitalize, name.split('_')))  # noqa
-    if lower:
-        s = s[0].lower() + s[1:]
-    return s
-
-
-def snake_case(name: str) -> str:
-    uppers: list[int | None] = [i for i, c in enumerate(name) if c.isupper()]
-    return '_'.join([name[l:r].lower() for l, r in zip([None, *uppers], [*uppers, None])]).strip('_')
-
-
-##
+##
 
 
 def is_dunder(name: str) -> bool:
@@ -1492,277 +1393,78 @@ def format_num_bytes(num_bytes: int) -> str:
 
 
 ########################################
-# ../../../omlish/lite/timeouts.py
-"""
-TODO:
- - Event (/ Predicate)
-"""
+# ../../../omlish/logs/filters.py
 
 
 ##
 
 
-class Timeout(abc.ABC):
-    @property
-    @abc.abstractmethod
-    def can_expire(self) -> bool:
-        """Indicates whether or not this timeout will ever expire."""
-
-        raise NotImplementedError
+class TidLogFilter(logging.Filter):
+    def filter(self, record):
+        # FIXME: handle better - missing from wasm and cosmos
+        if hasattr(threading, 'get_native_id'):
+            record.tid = threading.get_native_id()
+        else:
+            record.tid = '?'
+        return True
 
-    @abc.abstractmethod
-    def expired(self) -> bool:
-        """Return whether or not this timeout has expired."""
 
-        raise NotImplementedError
+########################################
+# ../../../omlish/logs/proxy.py
 
-    @abc.abstractmethod
-    def remaining(self) -> float:
-        """Returns the time (in seconds) remaining until the timeout expires. May be negative and/or infinite."""
 
-        raise NotImplementedError
+##
 
-    @abc.abstractmethod
-    def __call__(self) -> float:
-        """Returns the time (in seconds) remaining until the timeout expires, or raises if the timeout has expired."""
 
-        raise NotImplementedError
+class ProxyLogFilterer(logging.Filterer):
+    def __init__(self, underlying: logging.Filterer) -> None:  # noqa
+        self._underlying = underlying
 
-    @abc.abstractmethod
-    def or_(self, o: ta.Any) -> ta.Any:
-        """Evaluates time remaining via remaining() if this timeout can expire, otherwise returns `o`."""
+    @property
+    def underlying(self) -> logging.Filterer:
+        return self._underlying
 
-        raise NotImplementedError
+    @property
+    def filters(self):
+        return self._underlying.filters
 
-    #
+    @filters.setter
+    def filters(self, filters):
+        self._underlying.filters = filters
 
-    @classmethod
-    def _now(cls) -> float:
-        return time.monotonic()
+    def addFilter(self, filter):  # noqa
+        self._underlying.addFilter(filter)
 
-    #
+    def removeFilter(self, filter):  # noqa
+        self._underlying.removeFilter(filter)
 
-    class DEFAULT:  # Noqa
-        def __new__(cls, *args, **kwargs):  # noqa
-            raise TypeError
+    def filter(self, record):
+        return self._underlying.filter(record)
 
-    class _NOT_SPECIFIED:  # noqa
-        def __new__(cls, *args, **kwargs):  # noqa
-            raise TypeError
 
-    @classmethod
-    def of(
-            cls,
-            obj: TimeoutLike,
-            default: ta.Union[TimeoutLike, ta.Type[_NOT_SPECIFIED]] = _NOT_SPECIFIED,
-    ) -> 'Timeout':
-        if obj is None:
-            return InfiniteTimeout()
+class ProxyLogHandler(ProxyLogFilterer, logging.Handler):
+    def __init__(self, underlying: logging.Handler) -> None:  # noqa
+        ProxyLogFilterer.__init__(self, underlying)
 
-        elif isinstance(obj, Timeout):
-            return obj
+    _underlying: logging.Handler
 
-        elif isinstance(obj, (float, int)):
-            return DeadlineTimeout(cls._now() + obj)
+    @property
+    def underlying(self) -> logging.Handler:
+        return self._underlying
 
-        elif isinstance(obj, ta.Iterable):
-            return CompositeTimeout(*[Timeout.of(c) for c in obj])
+    def get_name(self):
+        return self._underlying.get_name()
 
-        elif obj is Timeout.DEFAULT:
-            if default is Timeout._NOT_SPECIFIED or default is Timeout.DEFAULT:
-                raise RuntimeError('Must specify a default timeout')
+    def set_name(self, name):
+        self._underlying.set_name(name)
 
-            else:
-                return Timeout.of(default)  # type: ignore[arg-type]
+    @property
+    def name(self):  # type: ignore[override]
+        return self._underlying.name
 
-        else:
-            raise TypeError(obj)
-
-    @classmethod
-    def of_deadline(cls, deadline: float) -> 'DeadlineTimeout':
-        return DeadlineTimeout(deadline)
-
-    @classmethod
-    def of_predicate(cls, expired_fn: ta.Callable[[], bool]) -> 'PredicateTimeout':
-        return PredicateTimeout(expired_fn)
-
-
-class DeadlineTimeout(Timeout):
-    def __init__(
-            self,
-            deadline: float,
-            exc: ta.Union[ta.Type[BaseException], BaseException] = TimeoutError,
-    ) -> None:
-        super().__init__()
-
-        self.deadline = deadline
-        self.exc = exc
-
-    @property
-    def can_expire(self) -> bool:
-        return True
-
-    def expired(self) -> bool:
-        return not (self.remaining() > 0)
-
-    def remaining(self) -> float:
-        return self.deadline - self._now()
-
-    def __call__(self) -> float:
-        if (rem := self.remaining()) > 0:
-            return rem
-        raise self.exc
-
-    def or_(self, o: ta.Any) -> ta.Any:
-        return self()
-
-
-class InfiniteTimeout(Timeout):
-    @property
-    def can_expire(self) -> bool:
-        return False
-
-    def expired(self) -> bool:
-        return False
-
-    def remaining(self) -> float:
-        return float('inf')
-
-    def __call__(self) -> float:
-        return float('inf')
-
-    def or_(self, o: ta.Any) -> ta.Any:
-        return o
-
-
-class CompositeTimeout(Timeout):
-    def __init__(self, *children: Timeout) -> None:
-        super().__init__()
-
-        self.children = children
-
-    @property
-    def can_expire(self) -> bool:
-        return any(c.can_expire for c in self.children)
-
-    def expired(self) -> bool:
-        return any(c.expired() for c in self.children)
-
-    def remaining(self) -> float:
-        return min(c.remaining() for c in self.children)
-
-    def __call__(self) -> float:
-        return min(c() for c in self.children)
-
-    def or_(self, o: ta.Any) -> ta.Any:
-        if self.can_expire:
-            return self()
-        return o
-
-
-class PredicateTimeout(Timeout):
-    def __init__(
-            self,
-            expired_fn: ta.Callable[[], bool],
-            exc: ta.Union[ta.Type[BaseException], BaseException] = TimeoutError,
-    ) -> None:
-        super().__init__()
-
-        self.expired_fn = expired_fn
-        self.exc = exc
-
-    @property
-    def can_expire(self) -> bool:
-        return True
-
-    def expired(self) -> bool:
-        return self.expired_fn()
-
-    def remaining(self) -> float:
-        return float('inf')
-
-    def __call__(self) -> float:
-        if not self.expired_fn():
-            return float('inf')
-        raise self.exc
-
-    def or_(self, o: ta.Any) -> ta.Any:
-        return self()
-
-
-########################################
-# ../../../omlish/logs/filters.py
-
-
-##
-
-
-class TidLogFilter(logging.Filter):
-    def filter(self, record):
-        # FIXME: handle better - missing from wasm and cosmos
-        if hasattr(threading, 'get_native_id'):
-            record.tid = threading.get_native_id()
-        else:
-            record.tid = '?'
-        return True
-
-
-########################################
-# ../../../omlish/logs/proxy.py
-
-
-##
-
-
-class ProxyLogFilterer(logging.Filterer):
-    def __init__(self, underlying: logging.Filterer) -> None:  # noqa
-        self._underlying = underlying
-
-    @property
-    def underlying(self) -> logging.Filterer:
-        return self._underlying
-
-    @property
-    def filters(self):
-        return self._underlying.filters
-
-    @filters.setter
-    def filters(self, filters):
-        self._underlying.filters = filters
-
-    def addFilter(self, filter):  # noqa
-        self._underlying.addFilter(filter)
-
-    def removeFilter(self, filter):  # noqa
-        self._underlying.removeFilter(filter)
-
-    def filter(self, record):
-        return self._underlying.filter(record)
-
-
-class ProxyLogHandler(ProxyLogFilterer, logging.Handler):
-    def __init__(self, underlying: logging.Handler) -> None:  # noqa
-        ProxyLogFilterer.__init__(self, underlying)
-
-    _underlying: logging.Handler
-
-    @property
-    def underlying(self) -> logging.Handler:
-        return self._underlying
-
-    def get_name(self):
-        return self._underlying.get_name()
-
-    def set_name(self, name):
-        self._underlying.set_name(name)
-
-    @property
-    def name(self):  # type: ignore[override]
-        return self._underlying.name
-
-    @property
-    def level(self):
-        return self._underlying.level
+    @property
+    def level(self):
+        return self._underlying.level
 
     @level.setter
     def level(self, level):
@@ -1833,7 +1535,7 @@ class ProxyLogHandler(ProxyLogFilterer, logging.Handler):
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. This file is dual licensed under the terms of the
 # Apache License, Version 2.0, and the BSD License. See the LICENSE file in the root of this repository for complete
 # details.
-# https://github.com/pypa/packaging/blob/2c885fe91a54559e2382902dce28428ad2887be5/src/packaging/specifiers.py
+# https://github.com/pypa/packaging/blob/48125006684bb2d7d28c50af48a03176da45942d/src/packaging/specifiers.py
 
 
 ##
@@ -1981,7 +1683,7 @@ class Specifier(BaseSpecifier):
     ) -> None:
         match = self._regex.search(spec)
         if not match:
-            raise InvalidSpecifier(f"Invalid specifier: '{spec}'")
+            raise InvalidSpecifier(f'Invalid specifier: {spec!r}')
 
         self._spec: ta.Tuple[str, str] = (
             match.group('operator').strip(),
@@ -1996,7 +1698,7 @@ class Specifier(BaseSpecifier):
             return self._prereleases
 
         operator, version = self._spec
-        if operator in ['==', '>=', '<=', '~=', '===']:
+        if operator in ['==', '>=', '<=', '~=', '===', '>', '<']:
             if operator == '==' and version.endswith('.*'):
                 version = version[:-2]
 
@@ -2122,40 +1824,38 @@ class Specifier(BaseSpecifier):
         return self.contains(item)
 
     def contains(self, item: UnparsedVersion, prereleases: ta.Optional[bool] = None) -> bool:
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        normalized_item = _coerce_version(item)
-
-        if normalized_item.is_prerelease and not prereleases:
-            return False
-
-        operator_callable: CallableVersionOperator = self._get_operator(self.operator)
-        return operator_callable(normalized_item, self.version)
+        return bool(list(self.filter([item], prereleases=prereleases)))
 
     def filter(
             self,
             iterable: ta.Iterable[UnparsedVersionVar],
             prereleases: ta.Optional[bool] = None,
     ) -> ta.Iterator[UnparsedVersionVar]:
-        yielded = False
-        found_prereleases = []
+        prereleases_versions = []
+        found_non_prereleases = False
+
+        include_prereleases = (
+            prereleases if prereleases is not None else self.prereleases
+        )
 
-        kw = {'prereleases': prereleases if prereleases is not None else True}
+        operator_callable = self._get_operator(self.operator)
 
         for version in iterable:
             parsed_version = _coerce_version(version)
 
-            if self.contains(parsed_version, **kw):
-                if parsed_version.is_prerelease and not (prereleases or self.prereleases):
-                    found_prereleases.append(version)
-                else:
-                    yielded = True
+            if operator_callable(parsed_version, self.version):
+                if not parsed_version.is_prerelease or include_prereleases:
+                    found_non_prereleases = True
                     yield version
+                elif prereleases is None and self._prereleases is not False:
+                    prereleases_versions.append(version)
 
-        if not yielded and found_prereleases:
-            for version in found_prereleases:
-                yield version
+        if (
+                not found_non_prereleases and
+                prereleases is None and
+                self._prereleases is not False
+        ):
+            yield from prereleases_versions
 
 
 _version_prefix_regex = re.compile(r'^([0-9]+)((?:a|b|c|rc)[0-9]+)$')
@@ -2206,12 +1906,15 @@ def _pad_version(left: ta.List[str], right: ta.List[str]) -> ta.Tuple[ta.List[st
 class SpecifierSet(BaseSpecifier):
     def __init__(
             self,
-            specifiers: str = '',
+            specifiers: ta.Union[str, ta.Iterable['Specifier']] = '',
             prereleases: ta.Optional[bool] = None,
     ) -> None:
-        split_specifiers = [s.strip() for s in specifiers.split(',') if s.strip()]
+        if isinstance(specifiers, str):
+            split_specifiers = [s.strip() for s in specifiers.split(',') if s.strip()]
+            self._specs = frozenset(map(Specifier, split_specifiers))
+        else:
+            self._specs = frozenset(specifiers)
 
-        self._specs = frozenset(map(Specifier, split_specifiers))
         self._prereleases = prereleases
 
     @property
@@ -2222,7 +1925,10 @@ class SpecifierSet(BaseSpecifier):
         if not self._specs:
             return None
 
-        return any(s.prereleases for s in self._specs)
+        if any(s.prereleases for s in self._specs):
+            return True
+
+        return None
 
     @prereleases.setter
     def prereleases(self, value: bool) -> None:
@@ -2289,28 +1995,22 @@ class SpecifierSet(BaseSpecifier):
         if not isinstance(item, Version):
             item = Version(item)
 
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        if not prereleases and item.is_prerelease:
-            return False
-
         if installed and item.is_prerelease:
-            item = Version(item.base_version)
+            prereleases = True
 
-        return all(s.contains(item, prereleases=prereleases) for s in self._specs)
+        return bool(list(self.filter([item], prereleases=prereleases)))
 
     def filter(
             self,
             iterable: ta.Iterable[UnparsedVersionVar],
             prereleases: ta.Optional[bool] = None,
     ) -> ta.Iterator[UnparsedVersionVar]:
-        if prereleases is None:
+        if prereleases is None and self.prereleases is not None:
             prereleases = self.prereleases
 
         if self._specs:
             for spec in self._specs:
-                iterable = spec.filter(iterable, prereleases=bool(prereleases))
+                iterable = spec.filter(iterable, prereleases=prereleases)
             return iter(iterable)
 
         else:
@@ -2543,91 +2243,676 @@ class ArgparseCli:
                     else:
                         obj.dest = obj.kwargs['dest'] = att  # type: ignore
 
-                parser.add_argument(*obj.args, **obj.kwargs)
+                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 _bind_cli_cmd(self, cmd: ArgparseCmd) -> ta.Callable:
+        return cmd.__get__(self, type(self))
+
+    def prepare_cli_run(self) -> ta.Optional[ta.Callable]:
+        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:
+                parser.error(msg)
+            else:
+                raise argparse.ArgumentError(None, msg)
+
+        if cmd is None:
+            self.get_parser().print_help()
+            return None
+
+        return self._bind_cli_cmd(cmd)
+
+    #
+
+    def cli_run(self) -> ta.Optional[int]:
+        if (fn := self.prepare_cli_run()) is None:
+            return 0
+
+        return fn()
+
+    def cli_run_and_exit(self) -> ta.NoReturn:
+        sys.exit(rc if isinstance(rc := self.cli_run(), int) else 0)
+
+    def __call__(self, *, exit: bool = False) -> ta.Optional[int]:  # noqa
+        if exit:
+            return self.cli_run_and_exit()
+        else:
+            return self.cli_run()
+
+    #
+
+    async def async_cli_run(
+            self,
+            *,
+            force_async: bool = False,
+    ) -> ta.Optional[int]:
+        if (fn := self.prepare_cli_run()) is None:
+            return 0
+
+        if force_async:
+            is_async = True
+        else:
+            tfn = fn
+            if isinstance(tfn, ArgparseCmd):
+                tfn = tfn.fn
+            is_async = inspect.iscoroutinefunction(tfn)
+
+        if is_async:
+            return await fn()
+        else:
+            return fn()
+
+
+########################################
+# ../../../omlish/lite/maybes.py
+
+
+##
+
+
+@functools.total_ordering
+class Maybe(ta.Generic[T]):
+    class ValueNotPresentError(BaseException):
+        pass
+
+    #
+
+    @property
+    @abc.abstractmethod
+    def present(self) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def must(self) -> T:
+        raise NotImplementedError
+
+    #
+
+    @abc.abstractmethod
+    def __repr__(self) -> str:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __hash__(self) -> int:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __eq__(self, other) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __lt__(self, other) -> bool:
+        raise NotImplementedError
+
+    #
+
+    @ta.final
+    def __ne__(self, other):
+        return not (self == other)
+
+    @ta.final
+    def __iter__(self) -> ta.Iterator[T]:
+        if self.present:
+            yield self.must()
+
+    @ta.final
+    def __bool__(self) -> ta.NoReturn:
+        raise TypeError
+
+    #
+
+    @ta.final
+    def if_present(self, consumer: ta.Callable[[T], None]) -> None:
+        if self.present:
+            consumer(self.must())
+
+    @ta.final
+    def filter(self, predicate: ta.Callable[[T], bool]) -> 'Maybe[T]':
+        if self.present and predicate(self.must()):
+            return self
+        else:
+            return Maybe.empty()
+
+    @ta.final
+    def map(self, mapper: ta.Callable[[T], U]) -> 'Maybe[U]':
+        if self.present:
+            return Maybe.just(mapper(self.must()))
+        else:
+            return Maybe.empty()
+
+    @ta.final
+    def flat_map(self, mapper: ta.Callable[[T], 'Maybe[U]']) -> 'Maybe[U]':
+        if self.present:
+            if not isinstance(v := mapper(self.must()), Maybe):
+                raise TypeError(v)
+            return v
+        else:
+            return Maybe.empty()
+
+    @ta.final
+    def or_else(self, other: ta.Union[T, U]) -> ta.Union[T, U]:
+        if self.present:
+            return self.must()
+        else:
+            return other
+
+    @ta.final
+    def or_else_get(self, supplier: ta.Callable[[], ta.Union[T, U]]) -> ta.Union[T, U]:
+        if self.present:
+            return self.must()
+        else:
+            return supplier()
+
+    @ta.final
+    def or_else_raise(self, exception_supplier: ta.Callable[[], Exception]) -> T:
+        if self.present:
+            return self.must()
+        else:
+            raise exception_supplier()
+
+    #
+
+    @classmethod
+    def of_optional(cls, v: ta.Optional[T]) -> 'Maybe[T]':
+        if v is not None:
+            return cls.just(v)
+        else:
+            return cls.empty()
+
+    @classmethod
+    def just(cls, v: T) -> 'Maybe[T]':
+        return _JustMaybe(v)
+
+    _empty: ta.ClassVar['Maybe']
+
+    @classmethod
+    def empty(cls) -> 'Maybe[T]':
+        return Maybe._empty
+
+
+##
+
+
+class _Maybe(Maybe[T], Abstract):
+    def __lt__(self, other):
+        if not isinstance(other, _Maybe):
+            return NotImplemented
+        sp = self.present
+        op = other.present
+        if self.present and other.present:
+            return self.must() < other.must()
+        else:
+            return op and not sp
+
+
+class _JustMaybe(_Maybe[T]):
+    __slots__ = ('_v', '_hash')
+
+    def __init__(self, v: T) -> None:
+        super().__init__()
+
+        self._v = v
+
+    @property
+    def present(self) -> bool:
+        return True
+
+    def must(self) -> T:
+        return self._v
+
+    #
+
+    def __repr__(self) -> str:
+        return f'just({self._v!r})'
+
+    _hash: int
+
+    def __hash__(self) -> int:
+        try:
+            return self._hash
+        except AttributeError:
+            pass
+        h = self._hash = hash((_JustMaybe, self._v))
+        return h
+
+    def __eq__(self, other):
+        return (
+            self.__class__ is other.__class__ and
+            self._v == other._v  # noqa
+        )
+
+
+class _EmptyMaybe(_Maybe[T]):
+    __slots__ = ()
+
+    @property
+    def present(self) -> bool:
+        return False
+
+    def must(self) -> T:
+        raise Maybe.ValueNotPresentError
+
+    #
+
+    def __repr__(self) -> str:
+        return 'empty()'
+
+    def __hash__(self) -> int:
+        return hash(_EmptyMaybe)
+
+    def __eq__(self, other):
+        return self.__class__ is other.__class__
+
+
+Maybe._empty = _EmptyMaybe()  # noqa
+
+
+########################################
+# ../../../omlish/lite/runtime.py
+
+
+##
+
+
+@cached_nullary
+def is_debugger_attached() -> bool:
+    return any(frame[1].endswith('pydevd.py') for frame in inspect.stack())
+
+
+LITE_REQUIRED_PYTHON_VERSION = (3, 8)
+
+
+def check_lite_runtime_version() -> None:
+    if sys.version_info < LITE_REQUIRED_PYTHON_VERSION:
+        raise OSError(f'Requires python {LITE_REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
+
+
+########################################
+# ../../../omlish/lite/timeouts.py
+"""
+TODO:
+ - Event (/ Predicate)
+"""
+
+
+##
+
+
+class Timeout(Abstract):
+    @property
+    @abc.abstractmethod
+    def can_expire(self) -> bool:
+        """Indicates whether or not this timeout will ever expire."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def expired(self) -> bool:
+        """Return whether or not this timeout has expired."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def remaining(self) -> float:
+        """Returns the time (in seconds) remaining until the timeout expires. May be negative and/or infinite."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __call__(self) -> float:
+        """Returns the time (in seconds) remaining until the timeout expires, or raises if the timeout has expired."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def or_(self, o: ta.Any) -> ta.Any:
+        """Evaluates time remaining via remaining() if this timeout can expire, otherwise returns `o`."""
+
+        raise NotImplementedError
+
+    #
+
+    @classmethod
+    def _now(cls) -> float:
+        return time.monotonic()
+
+    #
+
+    class DEFAULT:  # Noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    class _NOT_SPECIFIED:  # noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    @classmethod
+    def of(
+            cls,
+            obj: TimeoutLike,
+            default: ta.Union[TimeoutLike, ta.Type[_NOT_SPECIFIED]] = _NOT_SPECIFIED,
+    ) -> 'Timeout':
+        if obj is None:
+            return InfiniteTimeout()
+
+        elif isinstance(obj, Timeout):
+            return obj
+
+        elif isinstance(obj, (float, int)):
+            return DeadlineTimeout(cls._now() + obj)
+
+        elif isinstance(obj, ta.Iterable):
+            return CompositeTimeout(*[Timeout.of(c) for c in obj])
+
+        elif obj is Timeout.DEFAULT:
+            if default is Timeout._NOT_SPECIFIED or default is Timeout.DEFAULT:
+                raise RuntimeError('Must specify a default timeout')
+
+            else:
+                return Timeout.of(default)  # type: ignore[arg-type]
+
+        else:
+            raise TypeError(obj)
+
+    @classmethod
+    def of_deadline(cls, deadline: float) -> 'DeadlineTimeout':
+        return DeadlineTimeout(deadline)
+
+    @classmethod
+    def of_predicate(cls, expired_fn: ta.Callable[[], bool]) -> 'PredicateTimeout':
+        return PredicateTimeout(expired_fn)
+
+
+class DeadlineTimeout(Timeout):
+    def __init__(
+            self,
+            deadline: float,
+            exc: ta.Union[ta.Type[BaseException], BaseException] = TimeoutError,
+    ) -> None:
+        super().__init__()
+
+        self.deadline = deadline
+        self.exc = exc
+
+    @property
+    def can_expire(self) -> bool:
+        return True
+
+    def expired(self) -> bool:
+        return not (self.remaining() > 0)
+
+    def remaining(self) -> float:
+        return self.deadline - self._now()
+
+    def __call__(self) -> float:
+        if (rem := self.remaining()) > 0:
+            return rem
+        raise self.exc
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        return self()
+
+
+class InfiniteTimeout(Timeout):
+    @property
+    def can_expire(self) -> bool:
+        return False
+
+    def expired(self) -> bool:
+        return False
+
+    def remaining(self) -> float:
+        return float('inf')
+
+    def __call__(self) -> float:
+        return float('inf')
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        return o
+
+
+class CompositeTimeout(Timeout):
+    def __init__(self, *children: Timeout) -> None:
+        super().__init__()
+
+        self.children = children
+
+    @property
+    def can_expire(self) -> bool:
+        return any(c.can_expire for c in self.children)
+
+    def expired(self) -> bool:
+        return any(c.expired() for c in self.children)
+
+    def remaining(self) -> float:
+        return min(c.remaining() for c in self.children)
+
+    def __call__(self) -> float:
+        return min(c() for c in self.children)
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        if self.can_expire:
+            return self()
+        return o
+
+
+class PredicateTimeout(Timeout):
+    def __init__(
+            self,
+            expired_fn: ta.Callable[[], bool],
+            exc: ta.Union[ta.Type[BaseException], BaseException] = TimeoutError,
+    ) -> None:
+        super().__init__()
+
+        self.expired_fn = expired_fn
+        self.exc = exc
+
+    @property
+    def can_expire(self) -> bool:
+        return True
+
+    def expired(self) -> bool:
+        return self.expired_fn()
+
+    def remaining(self) -> float:
+        return float('inf')
+
+    def __call__(self) -> float:
+        if not self.expired_fn():
+            return float('inf')
+        raise self.exc
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        return self()
+
+
+########################################
+# ../../../omlish/logs/json.py
+"""
+TODO:
+ - translate json keys
+"""
+
+
+##
+
+
+class JsonLogFormatter(logging.Formatter):
+    KEYS: ta.Mapping[str, bool] = {
+        'name': False,
+        'msg': False,
+        'args': False,
+        'levelname': False,
+        'levelno': False,
+        'pathname': False,
+        'filename': False,
+        'module': False,
+        'exc_info': True,
+        'exc_text': True,
+        'stack_info': True,
+        'lineno': False,
+        'funcName': False,
+        'created': False,
+        'msecs': False,
+        'relativeCreated': False,
+        'thread': False,
+        'threadName': False,
+        'processName': False,
+        'process': False,
+    }
+
+    def __init__(
+            self,
+            *args: ta.Any,
+            json_dumps: ta.Optional[ta.Callable[[ta.Any], str]] = None,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        if json_dumps is None:
+            json_dumps = json_dumps_compact
+        self._json_dumps = json_dumps
+
+    def format(self, record: logging.LogRecord) -> str:
+        dct = {
+            k: v
+            for k, o in self.KEYS.items()
+            for v in [getattr(record, k)]
+            if not (o and v is None)
+        }
+        return self._json_dumps(dct)
+
+
+########################################
+# ../types.py
+
+
+##
+
+
+# See https://peps.python.org/pep-3149/
+INTERP_OPT_GLYPHS_BY_ATTR: ta.Mapping[str, str] = collections.OrderedDict([
+    ('debug', 'd'),
+    ('threaded', 't'),
+])
+
+INTERP_OPT_ATTRS_BY_GLYPH: ta.Mapping[str, str] = collections.OrderedDict(
+    (g, a) for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items()
+)
 
-            else:
-                raise TypeError(obj)
 
-    #
+@dc.dataclass(frozen=True)
+class InterpOpts:
+    threaded: bool = False
+    debug: bool = False
 
-    _parser: ta.ClassVar[argparse.ArgumentParser]
+    def __str__(self) -> str:
+        return ''.join(g for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items() if getattr(self, a))
 
     @classmethod
-    def get_parser(cls) -> argparse.ArgumentParser:
-        return cls._parser
+    def parse(cls, s: str) -> 'InterpOpts':
+        return cls(**{INTERP_OPT_ATTRS_BY_GLYPH[g]: True for g in s})
 
-    @property
-    def argv(self) -> ta.Sequence[str]:
-        return self._argv
+    @classmethod
+    def parse_suffix(cls, s: str) -> ta.Tuple[str, 'InterpOpts']:
+        kw = {}
+        while s and (a := INTERP_OPT_ATTRS_BY_GLYPH.get(s[-1])):
+            s, kw[a] = s[:-1], True
+        return s, cls(**kw)
 
-    @property
-    def args(self) -> argparse.Namespace:
-        return self._args
 
-    @property
-    def unknown_args(self) -> ta.Sequence[str]:
-        return self._unknown_args
+##
 
-    #
 
-    def _bind_cli_cmd(self, cmd: ArgparseCmd) -> ta.Callable:
-        return cmd.__get__(self, type(self))
+@dc.dataclass(frozen=True)
+class InterpVersion:
+    version: Version
+    opts: InterpOpts
 
-    def prepare_cli_run(self) -> ta.Optional[ta.Callable]:
-        cmd = getattr(self.args, '_cmd', None)
+    def __str__(self) -> str:
+        return str(self.version) + str(self.opts)
 
-        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:
-                parser.error(msg)
-            else:
-                raise argparse.ArgumentError(None, msg)
+    @classmethod
+    def parse(cls, s: str) -> 'InterpVersion':
+        s, o = InterpOpts.parse_suffix(s)
+        v = Version(s)
+        return cls(
+            version=v,
+            opts=o,
+        )
 
-        if cmd is None:
-            self.get_parser().print_help()
+    @classmethod
+    def try_parse(cls, s: str) -> ta.Optional['InterpVersion']:
+        try:
+            return cls.parse(s)
+        except (KeyError, InvalidVersion):
             return None
 
-        return self._bind_cli_cmd(cmd)
 
-    #
+##
 
-    def cli_run(self) -> ta.Optional[int]:
-        if (fn := self.prepare_cli_run()) is None:
-            return 0
 
-        return fn()
+@dc.dataclass(frozen=True)
+class InterpSpecifier:
+    specifier: Specifier
+    opts: InterpOpts
 
-    def cli_run_and_exit(self) -> ta.NoReturn:
-        sys.exit(rc if isinstance(rc := self.cli_run(), int) else 0)
+    def __str__(self) -> str:
+        return str(self.specifier) + str(self.opts)
 
-    def __call__(self, *, exit: bool = False) -> ta.Optional[int]:  # noqa
-        if exit:
-            return self.cli_run_and_exit()
-        else:
-            return self.cli_run()
+    @classmethod
+    def parse(cls, s: str) -> 'InterpSpecifier':
+        s, o = InterpOpts.parse_suffix(s)
+        if not any(s.startswith(o) for o in Specifier.OPERATORS):
+            s = '~=' + s
+            if s.count('.') < 2:
+                s += '.0'
+        return cls(
+            specifier=Specifier(s),
+            opts=o,
+        )
 
-    #
+    def contains(self, iv: InterpVersion) -> bool:
+        return self.specifier.contains(iv.version) and self.opts == iv.opts
 
-    async def async_cli_run(
-            self,
-            *,
-            force_async: bool = False,
-    ) -> ta.Optional[int]:
-        if (fn := self.prepare_cli_run()) is None:
-            return 0
+    def __contains__(self, iv: InterpVersion) -> bool:
+        return self.contains(iv)
 
-        if force_async:
-            is_async = True
-        else:
-            tfn = fn
-            if isinstance(tfn, ArgparseCmd):
-                tfn = tfn.fn
-            is_async = inspect.iscoroutinefunction(tfn)
 
-        if is_async:
-            return await fn()
-        else:
-            return fn()
+##
+
+
+@dc.dataclass(frozen=True)
+class Interp:
+    exe: str
+    version: InterpVersion
 
 
 ########################################
@@ -2680,7 +2965,7 @@ def check_valid_injector_key_cls(cls: T) -> T:
 ##
 
 
-class InjectorProvider(abc.ABC):
+class InjectorProvider(Abstract):
     @abc.abstractmethod
     def provider_fn(self) -> InjectorProviderFn:
         raise NotImplementedError
@@ -2699,7 +2984,7 @@ class InjectorBinding:
         check.isinstance(self.provider, InjectorProvider)
 
 
-class InjectorBindings(abc.ABC):
+class InjectorBindings(Abstract):
     @abc.abstractmethod
     def bindings(self) -> ta.Iterator[InjectorBinding]:
         raise NotImplementedError
@@ -2707,7 +2992,7 @@ class InjectorBindings(abc.ABC):
 ##
 
 
-class Injector(abc.ABC):
+class Injector(Abstract):
     @abc.abstractmethod
     def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
         raise NotImplementedError
@@ -2966,14 +3251,12 @@ def injector_override(p: InjectorBindings, *args: InjectorBindingOrBindings) ->
 # scopes
 
 
-class InjectorScope(abc.ABC):  # noqa
+class InjectorScope(Abstract):
     def __init__(
             self,
             *,
             _i: Injector,
     ) -> None:
-        check.not_in(abc.ABC, type(self).__bases__)
-
         super().__init__()
 
         self._i = _i
@@ -3004,7 +3287,7 @@ class InjectorScope(abc.ABC):  # noqa
         raise NotImplementedError
 
 
-class ExclusiveInjectorScope(InjectorScope, abc.ABC):
+class ExclusiveInjectorScope(InjectorScope, Abstract):
     _st: ta.Optional[InjectorScope.State] = None
 
     def state(self) -> InjectorScope.State:
@@ -3020,12 +3303,13 @@ class ExclusiveInjectorScope(InjectorScope, abc.ABC):
             self._st = None
 
 
-class ContextvarInjectorScope(InjectorScope, abc.ABC):
+class ContextvarInjectorScope(InjectorScope, Abstract):
     _cv: contextvars.ContextVar
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
 
+        check.not_in(Abstract, cls.__bases__)
         check.not_in(abc.ABC, cls.__bases__)
         check.state(not hasattr(cls, '_cv'))
         cls._cv = contextvars.ContextVar(f'{cls.__name__}_cv')
@@ -3531,7 +3815,7 @@ class InjectorBinder:
         pws: ta.List[ta.Any] = []
         if in_ is not None:
             check.issubclass(in_, InjectorScope)
-            check.not_in(abc.ABC, in_.__bases__)
+            check.not_in(Abstract, in_.__bases__)
             pws.append(functools.partial(ScopedInjectorProvider, k=key, sc=in_))
         if singleton:
             pws.append(SingletonInjectorProvider)
@@ -3732,80 +4016,125 @@ inj = InjectionApi()
 
 
 ########################################
-# ../../../omlish/lite/runtime.py
+# ../../../omlish/logs/standard.py
+"""
+TODO:
+ - structured
+ - prefixed
+ - debug
+ - optional noisy? noisy will never be lite - some kinda configure_standard callback mechanism?
+"""
 
 
 ##
 
 
-@cached_nullary
-def is_debugger_attached() -> bool:
-    return any(frame[1].endswith('pydevd.py') for frame in inspect.stack())
+STANDARD_LOG_FORMAT_PARTS = [
+    ('asctime', '%(asctime)-15s'),
+    ('process', 'pid=%(process)s'),
+    ('thread', 'tid=%(thread)x'),
+    ('levelname', '%(levelname)s'),
+    ('name', '%(name)s'),
+    ('separator', '::'),
+    ('message', '%(message)s'),
+]
 
 
-LITE_REQUIRED_PYTHON_VERSION = (3, 8)
+class StandardLogFormatter(logging.Formatter):
+    @staticmethod
+    def build_log_format(parts: ta.Iterable[ta.Tuple[str, str]]) -> str:
+        return ' '.join(v for k, v in parts)
 
+    converter = datetime.datetime.fromtimestamp  # type: ignore
 
-def check_lite_runtime_version() -> None:
-    if sys.version_info < LITE_REQUIRED_PYTHON_VERSION:
-        raise OSError(f'Requires python {LITE_REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
+    def formatTime(self, record, datefmt=None):
+        ct = self.converter(record.created)
+        if datefmt:
+            return ct.strftime(datefmt)  # noqa
+        else:
+            t = ct.strftime('%Y-%m-%d %H:%M:%S')
+            return '%s.%03d' % (t, record.msecs)  # noqa
 
 
-########################################
-# ../../../omlish/logs/json.py
-"""
-TODO:
- - translate json keys
-"""
+##
+
+
+class StandardConfiguredLogHandler(ProxyLogHandler):
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError('This class serves only as a marker and should not be subclassed.')
 
 
 ##
 
 
-class JsonLogFormatter(logging.Formatter):
-    KEYS: ta.Mapping[str, bool] = {
-        'name': False,
-        'msg': False,
-        'args': False,
-        'levelname': False,
-        'levelno': False,
-        'pathname': False,
-        'filename': False,
-        'module': False,
-        'exc_info': True,
-        'exc_text': True,
-        'stack_info': True,
-        'lineno': False,
-        'funcName': False,
-        'created': False,
-        'msecs': False,
-        'relativeCreated': False,
-        'thread': False,
-        'threadName': False,
-        'processName': False,
-        'process': False,
-    }
+@contextlib.contextmanager
+def _locking_logging_module_lock() -> ta.Iterator[None]:
+    if hasattr(logging, '_acquireLock'):
+        logging._acquireLock()  # noqa
+        try:
+            yield
+        finally:
+            logging._releaseLock()  # type: ignore  # noqa
+
+    elif hasattr(logging, '_lock'):
+        # https://github.com/python/cpython/commit/74723e11109a320e628898817ab449b3dad9ee96
+        with logging._lock:  # noqa
+            yield
+
+    else:
+        raise Exception("Can't find lock in logging module")
+
+
+def configure_standard_logging(
+        level: ta.Union[int, str] = logging.INFO,
+        *,
+        json: bool = False,
+        target: ta.Optional[logging.Logger] = None,
+        force: bool = False,
+        handler_factory: ta.Optional[ta.Callable[[], logging.Handler]] = None,
+) -> ta.Optional[StandardConfiguredLogHandler]:
+    with _locking_logging_module_lock():
+        if target is None:
+            target = logging.root
+
+        #
+
+        if not force:
+            if any(isinstance(h, StandardConfiguredLogHandler) for h in list(target.handlers)):
+                return None
+
+        #
+
+        if handler_factory is not None:
+            handler = handler_factory()
+        else:
+            handler = logging.StreamHandler()
+
+        #
+
+        formatter: logging.Formatter
+        if json:
+            formatter = JsonLogFormatter()
+        else:
+            formatter = StandardLogFormatter(StandardLogFormatter.build_log_format(STANDARD_LOG_FORMAT_PARTS))
+        handler.setFormatter(formatter)
+
+        #
+
+        handler.addFilter(TidLogFilter())
 
-    def __init__(
-            self,
-            *args: ta.Any,
-            json_dumps: ta.Optional[ta.Callable[[ta.Any], str]] = None,
-            **kwargs: ta.Any,
-    ) -> None:
-        super().__init__(*args, **kwargs)
+        #
 
-        if json_dumps is None:
-            json_dumps = json_dumps_compact
-        self._json_dumps = json_dumps
+        target.addHandler(handler)
 
-    def format(self, record: logging.LogRecord) -> str:
-        dct = {
-            k: v
-            for k, o in self.KEYS.items()
-            for v in [getattr(record, k)]
-            if not (o and v is None)
-        }
-        return self._json_dumps(dct)
+        #
+
+        if level is not None:
+            target.setLevel(level)
+
+        #
+
+        return StandardConfiguredLogHandler(handler)
 
 
 ########################################
@@ -3924,7 +4253,7 @@ SubprocessRun._FIELD_NAMES = frozenset(fld.name for fld in dc.fields(SubprocessR
 ##
 
 
-class SubprocessRunnable(abc.ABC, ta.Generic[T]):
+class SubprocessRunnable(Abstract, ta.Generic[T]):
     @abc.abstractmethod
     def make_run(self) -> SubprocessRun:
         raise NotImplementedError
@@ -3957,233 +4286,6 @@ class SubprocessRunnable(abc.ABC, ta.Generic[T]):
         return self.handle_run_output(await self.make_run().maysync_run(maysync_subprocesses, **kwargs))
 
 
-########################################
-# ../types.py
-
-
-##
-
-
-# See https://peps.python.org/pep-3149/
-INTERP_OPT_GLYPHS_BY_ATTR: ta.Mapping[str, str] = collections.OrderedDict([
-    ('debug', 'd'),
-    ('threaded', 't'),
-])
-
-INTERP_OPT_ATTRS_BY_GLYPH: ta.Mapping[str, str] = collections.OrderedDict(
-    (g, a) for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items()
-)
-
-
-@dc.dataclass(frozen=True)
-class InterpOpts:
-    threaded: bool = False
-    debug: bool = False
-
-    def __str__(self) -> str:
-        return ''.join(g for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items() if getattr(self, a))
-
-    @classmethod
-    def parse(cls, s: str) -> 'InterpOpts':
-        return cls(**{INTERP_OPT_ATTRS_BY_GLYPH[g]: True for g in s})
-
-    @classmethod
-    def parse_suffix(cls, s: str) -> ta.Tuple[str, 'InterpOpts']:
-        kw = {}
-        while s and (a := INTERP_OPT_ATTRS_BY_GLYPH.get(s[-1])):
-            s, kw[a] = s[:-1], True
-        return s, cls(**kw)
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class InterpVersion:
-    version: Version
-    opts: InterpOpts
-
-    def __str__(self) -> str:
-        return str(self.version) + str(self.opts)
-
-    @classmethod
-    def parse(cls, s: str) -> 'InterpVersion':
-        s, o = InterpOpts.parse_suffix(s)
-        v = Version(s)
-        return cls(
-            version=v,
-            opts=o,
-        )
-
-    @classmethod
-    def try_parse(cls, s: str) -> ta.Optional['InterpVersion']:
-        try:
-            return cls.parse(s)
-        except (KeyError, InvalidVersion):
-            return None
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class InterpSpecifier:
-    specifier: Specifier
-    opts: InterpOpts
-
-    def __str__(self) -> str:
-        return str(self.specifier) + str(self.opts)
-
-    @classmethod
-    def parse(cls, s: str) -> 'InterpSpecifier':
-        s, o = InterpOpts.parse_suffix(s)
-        if not any(s.startswith(o) for o in Specifier.OPERATORS):
-            s = '~=' + s
-            if s.count('.') < 2:
-                s += '.0'
-        return cls(
-            specifier=Specifier(s),
-            opts=o,
-        )
-
-    def contains(self, iv: InterpVersion) -> bool:
-        return self.specifier.contains(iv.version) and self.opts == iv.opts
-
-    def __contains__(self, iv: InterpVersion) -> bool:
-        return self.contains(iv)
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class Interp:
-    exe: str
-    version: InterpVersion
-
-
-########################################
-# ../../../omlish/logs/standard.py
-"""
-TODO:
- - structured
- - prefixed
- - debug
- - optional noisy? noisy will never be lite - some kinda configure_standard callback mechanism?
-"""
-
-
-##
-
-
-STANDARD_LOG_FORMAT_PARTS = [
-    ('asctime', '%(asctime)-15s'),
-    ('process', 'pid=%(process)s'),
-    ('thread', 'tid=%(thread)x'),
-    ('levelname', '%(levelname)s'),
-    ('name', '%(name)s'),
-    ('separator', '::'),
-    ('message', '%(message)s'),
-]
-
-
-class StandardLogFormatter(logging.Formatter):
-    @staticmethod
-    def build_log_format(parts: ta.Iterable[ta.Tuple[str, str]]) -> str:
-        return ' '.join(v for k, v in parts)
-
-    converter = datetime.datetime.fromtimestamp  # type: ignore
-
-    def formatTime(self, record, datefmt=None):
-        ct = self.converter(record.created)
-        if datefmt:
-            return ct.strftime(datefmt)  # noqa
-        else:
-            t = ct.strftime('%Y-%m-%d %H:%M:%S')
-            return '%s.%03d' % (t, record.msecs)  # noqa
-
-
-##
-
-
-class StandardConfiguredLogHandler(ProxyLogHandler):
-    def __init_subclass__(cls, **kwargs):
-        raise TypeError('This class serves only as a marker and should not be subclassed.')
-
-
-##
-
-
-@contextlib.contextmanager
-def _locking_logging_module_lock() -> ta.Iterator[None]:
-    if hasattr(logging, '_acquireLock'):
-        logging._acquireLock()  # noqa
-        try:
-            yield
-        finally:
-            logging._releaseLock()  # type: ignore  # noqa
-
-    elif hasattr(logging, '_lock'):
-        # https://github.com/python/cpython/commit/74723e11109a320e628898817ab449b3dad9ee96
-        with logging._lock:  # noqa
-            yield
-
-    else:
-        raise Exception("Can't find lock in logging module")
-
-
-def configure_standard_logging(
-        level: ta.Union[int, str] = logging.INFO,
-        *,
-        json: bool = False,
-        target: ta.Optional[logging.Logger] = None,
-        force: bool = False,
-        handler_factory: ta.Optional[ta.Callable[[], logging.Handler]] = None,
-) -> ta.Optional[StandardConfiguredLogHandler]:
-    with _locking_logging_module_lock():
-        if target is None:
-            target = logging.root
-
-        #
-
-        if not force:
-            if any(isinstance(h, StandardConfiguredLogHandler) for h in list(target.handlers)):
-                return None
-
-        #
-
-        if handler_factory is not None:
-            handler = handler_factory()
-        else:
-            handler = logging.StreamHandler()
-
-        #
-
-        formatter: logging.Formatter
-        if json:
-            formatter = JsonLogFormatter()
-        else:
-            formatter = StandardLogFormatter(StandardLogFormatter.build_log_format(STANDARD_LOG_FORMAT_PARTS))
-        handler.setFormatter(formatter)
-
-        #
-
-        handler.addFilter(TidLogFilter())
-
-        #
-
-        target.addHandler(handler)
-
-        #
-
-        if level is not None:
-            target.setLevel(level)
-
-        #
-
-        return StandardConfiguredLogHandler(handler)
-
-
 ########################################
 # ../../../omlish/subprocesses/wrap.py
 """
@@ -4225,13 +4327,13 @@ TODO:
 ##
 
 
-class InterpProvider(abc.ABC):
+class InterpProvider(Abstract):
     name: ta.ClassVar[str]
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
 
-        if abc.ABC not in cls.__bases__ and 'name' not in cls.__dict__:
+        if Abstract not in cls.__bases__ and 'name' not in cls.__dict__:
             sfx = 'InterpProvider'
             if not cls.__name__.endswith(sfx):
                 raise NameError(cls)
@@ -4297,7 +4399,7 @@ class VerboseCalledProcessError(subprocess.CalledProcessError):
         return msg
 
 
-class BaseSubprocesses(abc.ABC):  # noqa
+class BaseSubprocesses(Abstract):
     DEFAULT_LOGGER: ta.ClassVar[ta.Optional[logging.Logger]] = None
 
     def __init__(
@@ -4562,7 +4664,7 @@ class InterpResolver:
 ##
 
 
-class AbstractAsyncSubprocesses(BaseSubprocesses):
+class AbstractAsyncSubprocesses(BaseSubprocesses, Abstract):
     @abc.abstractmethod
     def run_(self, run: SubprocessRun) -> ta.Awaitable[SubprocessRunOutput]:
         raise NotImplementedError
@@ -5328,7 +5430,7 @@ THREADED_PYENV_INSTALL_OPTS = PyenvInstallOpts(conf_opts=['--disable-gil'])
 #
 
 
-class PyenvInstallOptsProvider(abc.ABC):
+class PyenvInstallOptsProvider(Abstract):
     @abc.abstractmethod
     def opts(self) -> ta.Awaitable[PyenvInstallOpts]:
         raise NotImplementedError