ominfra 0.0.0.dev132__py3-none-any.whl → 0.0.0.dev134__py3-none-any.whl

ominfra/pyremote/_runcommands.py

@@ -1,1201 +0,0 @@
-#!/usr/bin/env python3
-# noinspection DuplicatedCode
-# @omlish-lite
-# @omlish-script
-# @omlish-amalg-output runcommands.py
-# ruff: noqa: N802 UP006 UP007 UP036
-import abc
-import base64
-import collections.abc
-import contextlib
-import dataclasses as dc
-import datetime
-import decimal
-import enum
-import fractions
-import functools
-import inspect
-import io
-import json
-import logging
-import os
-import shlex
-import subprocess
-import sys
-import textwrap
-import threading
-import types
-import typing as ta
-import uuid
-import weakref  # noqa
-import zlib
-
-
-########################################
-
-
-if sys.version_info < (3, 8):
-    raise OSError(f'Requires python (3, 8), got {sys.version_info} from {sys.executable}')  # noqa
-
-
-########################################
-
-
-# ../../omlish/lite/cached.py
-T = ta.TypeVar('T')
-
-# ../../omlish/lite/check.py
-SizedT = ta.TypeVar('SizedT', bound=ta.Sized)
-
-
-########################################
-# ../bootstrap.py
-"""
-Basically this: https://mitogen.networkgenomics.com/howitworks.html
-"""
-
-
-##
-
-
-_BOOTSTRAP_COMM_FD = 100
-_BOOTSTRAP_SRC_FD = 101
-
-_BOOTSTRAP_CHILD_PID_VAR = '_OPYR_CPID'
-_BOOTSTRAP_ARGV0_VAR = '_OPYR_ARGV0'
-
-BOOTSTRAP_ACK0 = b'OPYR000\n'
-BOOTSTRAP_ACK1 = b'OPYR001\n'
-
-_BOOTSTRAP_PROC_TITLE_FMT = '(pyremote:%s)'
-
-_BOOTSTRAP_IMPORTS = [
-    'base64',
-    'os',
-    'sys',
-    'zlib',
-]
-
-
-def _bootstrap_main(context_name: str, main_z_len: int) -> None:
-    # Two copies of main src to be sent to parent
-    r0, w0 = os.pipe()
-    r1, w1 = os.pipe()
-
-    if (cp := os.fork()):
-        # Parent process
-
-        # Dup original stdin to comm_fd for use as comm channel
-        os.dup2(0, _BOOTSTRAP_COMM_FD)
-
-        # Overwrite stdin (fed to python repl) with first copy of src
-        os.dup2(r0, 0)
-
-        # Dup second copy of src to src_fd to recover after launch
-        os.dup2(r1, _BOOTSTRAP_SRC_FD)
-
-        # Close remaining fd's
-        for f in [r0, w0, r1, w1]:
-            os.close(f)
-
-        # Save child pid to close after relaunch
-        os.environ[_BOOTSTRAP_CHILD_PID_VAR] = str(cp)
-
-        # Save original argv0
-        os.environ[_BOOTSTRAP_ARGV0_VAR] = sys.executable
-
-        # Start repl reading stdin from r0
-        os.execl(sys.executable, sys.executable + (_BOOTSTRAP_PROC_TITLE_FMT % (context_name,)))
-
-    else:
-        # Child process
-
-        # Write first ack
-        os.write(1, BOOTSTRAP_ACK0)
-
-        # Read main src from stdin
-        main_src = zlib.decompress(os.fdopen(0, 'rb').read(main_z_len))
-
-        # Write both copies of main src
-        for w in [w0, w1]:
-            fp = os.fdopen(w, 'wb', 0)
-            fp.write(main_src)
-            fp.close()
-
-        # Write second ack
-        os.write(1, BOOTSTRAP_ACK1)
-
-        sys.exit(0)
-
-
-#
-
-
-def bootstrap_payload(context_name: str, main_z_len: int) -> str:
-    bs_src = textwrap.dedent(inspect.getsource(_bootstrap_main))
-
-    for gl in [
-        '_BOOTSTRAP_COMM_FD',
-        '_BOOTSTRAP_SRC_FD',
-
-        '_BOOTSTRAP_CHILD_PID_VAR',
-        '_BOOTSTRAP_ARGV0_VAR',
-
-        'BOOTSTRAP_ACK0',
-        'BOOTSTRAP_ACK1',
-
-        '_BOOTSTRAP_PROC_TITLE_FMT',
-    ]:
-        bs_src = bs_src.replace(gl, repr(globals()[gl]))
-
-    bs_src = '\n'.join(
-        cl
-        for l in bs_src.splitlines()
-        if (cl := (l.split('#')[0]).rstrip())
-        if cl.strip()
-    )
-
-    bs_z = zlib.compress(bs_src.encode('utf-8'))
-    bs_z64 = base64.encodebytes(bs_z).replace(b'\n', b'')
-
-    stmts = [
-        f'import {", ".join(_BOOTSTRAP_IMPORTS)}',
-        f'exec(zlib.decompress(base64.decodebytes({bs_z64!r})))',
-        f'_bootstrap_main({context_name!r}, {main_z_len})',
-    ]
-
-    cmd = '; '.join(stmts)
-    return cmd
-
-
-#
-
-
-class PostBoostrap(ta.NamedTuple):
-    input: ta.BinaryIO
-    main_src: str
-
-
-def post_boostrap() -> PostBoostrap:
-    # Restore original argv0
-    sys.executable = os.environ.pop(_BOOTSTRAP_ARGV0_VAR)
-
-    # Reap boostrap child
-    os.waitpid(int(os.environ.pop(_BOOTSTRAP_CHILD_PID_VAR)), 0)
-
-    # Read second copy of main src
-    r1 = os.fdopen(_BOOTSTRAP_SRC_FD, 'rb', 0)
-    main_src = r1.read().decode('utf-8')
-    r1.close()
-
-    return PostBoostrap(
-        input=os.fdopen(_BOOTSTRAP_COMM_FD, 'rb', 0),
-        main_src=main_src,
-    )
-
-
-########################################
-# ../../../omlish/lite/cached.py
-
-
-class _cached_nullary:  # noqa
-    def __init__(self, fn):
-        super().__init__()
-        self._fn = fn
-        self._value = self._missing = object()
-        functools.update_wrapper(self, fn)
-
-    def __call__(self, *args, **kwargs):  # noqa
-        if self._value is self._missing:
-            self._value = self._fn()
-        return self._value
-
-    def __get__(self, instance, owner):  # noqa
-        bound = instance.__dict__[self._fn.__name__] = self.__class__(self._fn.__get__(instance, owner))
-        return bound
-
-
-def cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
-    return _cached_nullary(fn)
-
-
-########################################
-# ../../../omlish/lite/check.py
-
-
-def check_isinstance(v: ta.Any, spec: ta.Union[ta.Type[T], tuple]) -> T:
-    if not isinstance(v, spec):
-        raise TypeError(v)
-    return v
-
-
-def check_not_isinstance(v: T, spec: ta.Union[type, tuple]) -> T:
-    if isinstance(v, spec):
-        raise TypeError(v)
-    return v
-
-
-def check_none(v: T) -> None:
-    if v is not None:
-        raise ValueError(v)
-
-
-def check_not_none(v: ta.Optional[T]) -> T:
-    if v is None:
-        raise ValueError
-    return v
-
-
-def check_not(v: ta.Any) -> None:
-    if v:
-        raise ValueError(v)
-    return v
-
-
-def check_non_empty_str(v: ta.Optional[str]) -> str:
-    if not v:
-        raise ValueError
-    return v
-
-
-def check_state(v: bool, msg: str = 'Illegal state') -> None:
-    if not v:
-        raise ValueError(msg)
-
-
-def check_equal(l: T, r: T) -> T:
-    if l != r:
-        raise ValueError(l, r)
-    return l
-
-
-def check_not_equal(l: T, r: T) -> T:
-    if l == r:
-        raise ValueError(l, r)
-    return l
-
-
-def check_is(l: T, r: T) -> T:
-    if l is not r:
-        raise ValueError(l, r)
-    return l
-
-
-def check_is_not(l: T, r: ta.Any) -> T:
-    if l is r:
-        raise ValueError(l, r)
-    return l
-
-
-def check_in(v: T, c: ta.Container[T]) -> T:
-    if v not in c:
-        raise ValueError(v, c)
-    return v
-
-
-def check_not_in(v: T, c: ta.Container[T]) -> T:
-    if v in c:
-        raise ValueError(v, c)
-    return v
-
-
-def check_single(vs: ta.Iterable[T]) -> T:
-    [v] = vs
-    return v
-
-
-def check_empty(v: SizedT) -> SizedT:
-    if len(v):
-        raise ValueError(v)
-    return v
-
-
-def check_non_empty(v: SizedT) -> SizedT:
-    if not len(v):
-        raise ValueError(v)
-    return v
-
-
-########################################
-# ../../../omlish/lite/json.py
-
-
-##
-
-
-JSON_PRETTY_INDENT = 2
-
-JSON_PRETTY_KWARGS: ta.Mapping[str, ta.Any] = dict(
-    indent=JSON_PRETTY_INDENT,
-)
-
-json_dump_pretty: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON_PRETTY_KWARGS)  # type: ignore
-json_dumps_pretty: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_PRETTY_KWARGS)
-
-
-##
-
-
-JSON_COMPACT_SEPARATORS = (',', ':')
-
-JSON_COMPACT_KWARGS: ta.Mapping[str, ta.Any] = dict(
-    indent=None,
-    separators=JSON_COMPACT_SEPARATORS,
-)
-
-json_dump_compact: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON_COMPACT_KWARGS)  # type: ignore
-json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_COMPACT_KWARGS)
-
-
-########################################
-# ../../../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, *, origin: ta.Any = None) -> bool:
-    return (
-        isinstance(obj, _GENERIC_ALIAS_TYPES) and
-        (origin is None or ta.get_origin(obj) is origin)
-    )
-
-
-is_union_alias = functools.partial(is_generic_alias, origin=ta.Union)
-is_callable_alias = functools.partial(is_generic_alias, origin=ta.Callable)
-
-
-def is_optional_alias(spec: ta.Any) -> bool:
-    return (
-        isinstance(spec, _GENERIC_ALIAS_TYPES) and  # noqa
-        ta.get_origin(spec) is ta.Union 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 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/logs.py
-"""
-TODO:
- - translate json keys
- - debug
-"""
-
-
-log = logging.getLogger(__name__)
-
-
-##
-
-
-class TidLogFilter(logging.Filter):
-
-    def filter(self, record):
-        record.tid = threading.get_native_id()
-        return True
-
-
-##
-
-
-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 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 json_dumps_compact(dct)
-
-
-##
-
-
-STANDARD_LOG_FORMAT_PARTS = [
-    ('asctime', '%(asctime)-15s'),
-    ('process', 'pid=%(process)-6s'),
-    ('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)  # type: ignore
-        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 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):
-        return self._underlying.name
-
-    @property
-    def level(self):
-        return self._underlying.level
-
-    @level.setter
-    def level(self, level):
-        self._underlying.level = level
-
-    @property
-    def formatter(self):
-        return self._underlying.formatter
-
-    @formatter.setter
-    def formatter(self, formatter):
-        self._underlying.formatter = formatter
-
-    def createLock(self):
-        self._underlying.createLock()
-
-    def acquire(self):
-        self._underlying.acquire()
-
-    def release(self):
-        self._underlying.release()
-
-    def setLevel(self, level):
-        self._underlying.setLevel(level)
-
-    def format(self, record):
-        return self._underlying.format(record)
-
-    def emit(self, record):
-        self._underlying.emit(record)
-
-    def handle(self, record):
-        return self._underlying.handle(record)
-
-    def setFormatter(self, fmt):
-        self._underlying.setFormatter(fmt)
-
-    def flush(self):
-        self._underlying.flush()
-
-    def close(self):
-        self._underlying.close()
-
-    def handleError(self, record):
-        self._underlying.handleError(record)
-
-
-##
-
-
-class StandardLogHandler(ProxyLogHandler):
-    pass
-
-
-##
-
-
-@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[StandardLogHandler]:
-    with _locking_logging_module_lock():
-        if target is None:
-            target = logging.root
-
-        #
-
-        if not force:
-            if any(isinstance(h, StandardLogHandler) 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 StandardLogHandler(handler)
-
-
-########################################
-# ../../../omlish/lite/marshal.py
-"""
-TODO:
- - pickle stdlib objs? have to pin to 3.8 pickle protocol, will be cross-version
- - nonstrict toggle
-"""
-
-
-##
-
-
-class ObjMarshaler(abc.ABC):
-    @abc.abstractmethod
-    def marshal(self, o: ta.Any) -> ta.Any:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        raise NotImplementedError
-
-
-class NopObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return o
-
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        return o
-
-
-@dc.dataclass()
-class ProxyObjMarshaler(ObjMarshaler):
-    m: ta.Optional[ObjMarshaler] = None
-
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return check_not_none(self.m).marshal(o)
-
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        return check_not_none(self.m).unmarshal(o)
-
-
-@dc.dataclass(frozen=True)
-class CastObjMarshaler(ObjMarshaler):
-    ty: type
-
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return o
-
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        return self.ty(o)
-
-
-class DynamicObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return marshal_obj(o)
-
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        return o
-
-
-@dc.dataclass(frozen=True)
-class Base64ObjMarshaler(ObjMarshaler):
-    ty: type
-
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return base64.b64encode(o).decode('ascii')
-
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        return self.ty(base64.b64decode(o))
-
-
-@dc.dataclass(frozen=True)
-class EnumObjMarshaler(ObjMarshaler):
-    ty: type
-
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return o.name
-
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        return self.ty.__members__[o]  # type: ignore
-
-
-@dc.dataclass(frozen=True)
-class OptionalObjMarshaler(ObjMarshaler):
-    item: ObjMarshaler
-
-    def marshal(self, o: ta.Any) -> ta.Any:
-        if o is None:
-            return None
-        return self.item.marshal(o)
-
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        if o is None:
-            return None
-        return self.item.unmarshal(o)
-
-
-@dc.dataclass(frozen=True)
-class MappingObjMarshaler(ObjMarshaler):
-    ty: type
-    km: ObjMarshaler
-    vm: ObjMarshaler
-
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return {self.km.marshal(k): self.vm.marshal(v) for k, v in o.items()}
-
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        return self.ty((self.km.unmarshal(k), self.vm.unmarshal(v)) for k, v in o.items())
-
-
-@dc.dataclass(frozen=True)
-class IterableObjMarshaler(ObjMarshaler):
-    ty: type
-    item: ObjMarshaler
-
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return [self.item.marshal(e) for e in o]
-
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        return self.ty(self.item.unmarshal(e) for e in o)
-
-
-@dc.dataclass(frozen=True)
-class DataclassObjMarshaler(ObjMarshaler):
-    ty: type
-    fs: ta.Mapping[str, ObjMarshaler]
-    nonstrict: bool = False
-
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return {k: m.marshal(getattr(o, k)) for k, m in self.fs.items()}
-
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        return self.ty(**{k: self.fs[k].unmarshal(v) for k, v in o.items() if not self.nonstrict or k in self.fs})
-
-
-@dc.dataclass(frozen=True)
-class PolymorphicObjMarshaler(ObjMarshaler):
-    class Impl(ta.NamedTuple):
-        ty: type
-        tag: str
-        m: ObjMarshaler
-
-    impls_by_ty: ta.Mapping[type, Impl]
-    impls_by_tag: ta.Mapping[str, Impl]
-
-    def marshal(self, o: ta.Any) -> ta.Any:
-        impl = self.impls_by_ty[type(o)]
-        return {impl.tag: impl.m.marshal(o)}
-
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        [(t, v)] = o.items()
-        impl = self.impls_by_tag[t]
-        return impl.m.unmarshal(v)
-
-
-@dc.dataclass(frozen=True)
-class DatetimeObjMarshaler(ObjMarshaler):
-    ty: type
-
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return o.isoformat()
-
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        return self.ty.fromisoformat(o)  # type: ignore
-
-
-class DecimalObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return str(check_isinstance(o, decimal.Decimal))
-
-    def unmarshal(self, v: ta.Any) -> ta.Any:
-        return decimal.Decimal(check_isinstance(v, str))
-
-
-class FractionObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any) -> ta.Any:
-        fr = check_isinstance(o, fractions.Fraction)
-        return [fr.numerator, fr.denominator]
-
-    def unmarshal(self, v: ta.Any) -> ta.Any:
-        num, denom = check_isinstance(v, list)
-        return fractions.Fraction(num, denom)
-
-
-class UuidObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return str(o)
-
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        return uuid.UUID(o)
-
-
-##
-
-
-_DEFAULT_OBJ_MARSHALERS: ta.Dict[ta.Any, ObjMarshaler] = {
-    **{t: NopObjMarshaler() for t in (type(None),)},
-    **{t: CastObjMarshaler(t) for t in (int, float, str, bool)},
-    **{t: Base64ObjMarshaler(t) for t in (bytes, bytearray)},
-    **{t: IterableObjMarshaler(t, DynamicObjMarshaler()) for t in (list, tuple, set, frozenset)},
-    **{t: MappingObjMarshaler(t, DynamicObjMarshaler(), DynamicObjMarshaler()) for t in (dict,)},
-
-    ta.Any: DynamicObjMarshaler(),
-
-    **{t: DatetimeObjMarshaler(t) for t in (datetime.date, datetime.time, datetime.datetime)},
-    decimal.Decimal: DecimalObjMarshaler(),
-    fractions.Fraction: FractionObjMarshaler(),
-    uuid.UUID: UuidObjMarshaler(),
-}
-
-_OBJ_MARSHALER_GENERIC_MAPPING_TYPES: ta.Dict[ta.Any, type] = {
-    **{t: t for t in (dict,)},
-    **{t: dict for t in (collections.abc.Mapping, collections.abc.MutableMapping)},
-}
-
-_OBJ_MARSHALER_GENERIC_ITERABLE_TYPES: ta.Dict[ta.Any, type] = {
-    **{t: t for t in (list, tuple, set, frozenset)},
-    collections.abc.Set: frozenset,
-    collections.abc.MutableSet: set,
-    collections.abc.Sequence: tuple,
-    collections.abc.MutableSequence: list,
-}
-
-
-def _make_obj_marshaler(
-        ty: ta.Any,
-        rec: ta.Callable[[ta.Any], ObjMarshaler],
-        *,
-        nonstrict_dataclasses: bool = False,
-) -> ObjMarshaler:
-    if isinstance(ty, type):
-        if abc.ABC in ty.__bases__:
-            impls = [  # type: ignore
-                PolymorphicObjMarshaler.Impl(
-                    ity,
-                    ity.__qualname__,
-                    rec(ity),
-                )
-                for ity in deep_subclasses(ty)
-                if abc.ABC not in ity.__bases__
-            ]
-            return PolymorphicObjMarshaler(
-                {i.ty: i for i in impls},
-                {i.tag: i for i in impls},
-            )
-
-        if issubclass(ty, enum.Enum):
-            return EnumObjMarshaler(ty)
-
-        if dc.is_dataclass(ty):
-            return DataclassObjMarshaler(
-                ty,
-                {f.name: rec(f.type) for f in dc.fields(ty)},
-                nonstrict=nonstrict_dataclasses,
-            )
-
-    if is_generic_alias(ty):
-        try:
-            mt = _OBJ_MARSHALER_GENERIC_MAPPING_TYPES[ta.get_origin(ty)]
-        except KeyError:
-            pass
-        else:
-            k, v = ta.get_args(ty)
-            return MappingObjMarshaler(mt, rec(k), rec(v))
-
-        try:
-            st = _OBJ_MARSHALER_GENERIC_ITERABLE_TYPES[ta.get_origin(ty)]
-        except KeyError:
-            pass
-        else:
-            [e] = ta.get_args(ty)
-            return IterableObjMarshaler(st, rec(e))
-
-        if is_union_alias(ty):
-            return OptionalObjMarshaler(rec(get_optional_alias_arg(ty)))
-
-    raise TypeError(ty)
-
-
-##
-
-
-_OBJ_MARSHALERS_LOCK = threading.RLock()
-
-_OBJ_MARSHALERS: ta.Dict[ta.Any, ObjMarshaler] = dict(_DEFAULT_OBJ_MARSHALERS)
-
-_OBJ_MARSHALER_PROXIES: ta.Dict[ta.Any, ProxyObjMarshaler] = {}
-
-
-def register_opj_marshaler(ty: ta.Any, m: ObjMarshaler) -> None:
-    with _OBJ_MARSHALERS_LOCK:
-        if ty in _OBJ_MARSHALERS:
-            raise KeyError(ty)
-        _OBJ_MARSHALERS[ty] = m
-
-
-def get_obj_marshaler(
-        ty: ta.Any,
-        *,
-        no_cache: bool = False,
-        **kwargs: ta.Any,
-) -> ObjMarshaler:
-    with _OBJ_MARSHALERS_LOCK:
-        if not no_cache:
-            try:
-                return _OBJ_MARSHALERS[ty]
-            except KeyError:
-                pass
-
-        try:
-            return _OBJ_MARSHALER_PROXIES[ty]
-        except KeyError:
-            pass
-
-        rec = functools.partial(
-            get_obj_marshaler,
-            no_cache=no_cache,
-            **kwargs,
-        )
-
-        p = ProxyObjMarshaler()
-        _OBJ_MARSHALER_PROXIES[ty] = p
-        try:
-            m = _make_obj_marshaler(ty, rec, **kwargs)
-        finally:
-            del _OBJ_MARSHALER_PROXIES[ty]
-        p.m = m
-
-        if not no_cache:
-            _OBJ_MARSHALERS[ty] = m
-        return m
-
-
-##
-
-
-def marshal_obj(o: ta.Any, ty: ta.Any = None) -> ta.Any:
-    return get_obj_marshaler(ty if ty is not None else type(o)).marshal(o)
-
-
-def unmarshal_obj(o: ta.Any, ty: ta.Union[ta.Type[T], ta.Any]) -> T:
-    return get_obj_marshaler(ty).unmarshal(o)
-
-
-########################################
-# ../../../omlish/lite/runtime.py
-
-
-@cached_nullary
-def is_debugger_attached() -> bool:
-    return any(frame[1].endswith('pydevd.py') for frame in inspect.stack())
-
-
-REQUIRED_PYTHON_VERSION = (3, 8)
-
-
-def check_runtime_version() -> None:
-    if sys.version_info < REQUIRED_PYTHON_VERSION:
-        raise OSError(f'Requires python {REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
-
-
-########################################
-# ../../../omlish/lite/subprocesses.py
-
-
-##
-
-
-_SUBPROCESS_SHELL_WRAP_EXECS = False
-
-
-def subprocess_shell_wrap_exec(*args: str) -> ta.Tuple[str, ...]:
-    return ('sh', '-c', ' '.join(map(shlex.quote, args)))
-
-
-def subprocess_maybe_shell_wrap_exec(*args: str) -> ta.Tuple[str, ...]:
-    if _SUBPROCESS_SHELL_WRAP_EXECS or is_debugger_attached():
-        return subprocess_shell_wrap_exec(*args)
-    else:
-        return args
-
-
-def _prepare_subprocess_invocation(
-        *args: str,
-        env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
-        extra_env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
-        quiet: bool = False,
-        shell: bool = False,
-        **kwargs: ta.Any,
-) -> ta.Tuple[ta.Tuple[ta.Any, ...], ta.Dict[str, ta.Any]]:
-    log.debug(args)
-    if extra_env:
-        log.debug(extra_env)
-
-    if extra_env:
-        env = {**(env if env is not None else os.environ), **extra_env}
-
-    if quiet and 'stderr' not in kwargs:
-        if not log.isEnabledFor(logging.DEBUG):
-            kwargs['stderr'] = subprocess.DEVNULL
-
-    if not shell:
-        args = subprocess_maybe_shell_wrap_exec(*args)
-
-    return args, dict(
-        env=env,
-        shell=shell,
-        **kwargs,
-    )
-
-
-def subprocess_check_call(*args: str, stdout=sys.stderr, **kwargs: ta.Any) -> None:
-    args, kwargs = _prepare_subprocess_invocation(*args, stdout=stdout, **kwargs)
-    return subprocess.check_call(args, **kwargs)  # type: ignore
-
-
-def subprocess_check_output(*args: str, **kwargs: ta.Any) -> bytes:
-    args, kwargs = _prepare_subprocess_invocation(*args, **kwargs)
-    return subprocess.check_output(args, **kwargs)
-
-
-def subprocess_check_output_str(*args: str, **kwargs: ta.Any) -> str:
-    return subprocess_check_output(*args, **kwargs).decode().strip()
-
-
-##
-
-
-DEFAULT_SUBPROCESS_TRY_EXCEPTIONS: ta.Tuple[ta.Type[Exception], ...] = (
-    FileNotFoundError,
-    subprocess.CalledProcessError,
-)
-
-
-def subprocess_try_call(
-        *args: str,
-        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
-        **kwargs: ta.Any,
-) -> bool:
-    try:
-        subprocess_check_call(*args, **kwargs)
-    except try_exceptions as e:  # noqa
-        if log.isEnabledFor(logging.DEBUG):
-            log.exception('command failed')
-        return False
-    else:
-        return True
-
-
-def subprocess_try_output(
-        *args: str,
-        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
-        **kwargs: ta.Any,
-) -> ta.Optional[bytes]:
-    try:
-        return subprocess_check_output(*args, **kwargs)
-    except try_exceptions as e:  # noqa
-        if log.isEnabledFor(logging.DEBUG):
-            log.exception('command failed')
-        return None
-
-
-def subprocess_try_output_str(*args: str, **kwargs: ta.Any) -> ta.Optional[str]:
-    out = subprocess_try_output(*args, **kwargs)
-    return out.decode().strip() if out is not None else None
-
-
-##
-
-
-def subprocess_close(
-        proc: subprocess.Popen,
-        timeout: ta.Optional[float] = None,
-) -> None:
-    # TODO: terminate, sleep, kill
-    if proc.stdout:
-        proc.stdout.close()
-    if proc.stderr:
-        proc.stderr.close()
-    if proc.stdin:
-        proc.stdin.close()
-
-    proc.wait(timeout)
-
-
-########################################
-# runcommands.py
-
-
-@dc.dataclass(frozen=True)
-class CommandRequest:
-    cmd: ta.Sequence[str]
-    in_: ta.Optional[bytes] = None
-
-
-@dc.dataclass(frozen=True)
-class CommandResponse:
-    req: CommandRequest
-    rc: int
-    out: bytes
-    err: bytes
-
-
-def _run_commands_loop(input: ta.BinaryIO, output: ta.BinaryIO = sys.stdout.buffer) -> None:  # noqa
-    while (l := input.readline().decode('utf-8').strip()):
-        req: CommandRequest = unmarshal_obj(json.loads(l), CommandRequest)
-        proc = subprocess.Popen(  # type: ignore
-            subprocess_maybe_shell_wrap_exec(*req.cmd),
-            **(dict(stdin=io.BytesIO(req.in_)) if req.in_ is not None else {}),
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        )
-        out, err = proc.communicate()
-        resp = CommandResponse(
-            req=req,
-            rc=proc.returncode,
-            out=out,  # noqa
-            err=err,  # noqa
-        )
-        output.write(json_dumps_compact(marshal_obj(resp)).encode('utf-8'))
-        output.write(b'\n')
-        output.flush()
-
-
-def run_commands_main() -> None:
-    bs = post_boostrap()
-    _run_commands_loop(bs.input)