ominfra 0.0.0.dev142__py3-none-any.whl → 0.0.0.dev144__py3-none-any.whl

ominfra/scripts/manage.py

@@ -31,6 +31,7 @@ import subprocess
 import sys
 import threading
 import time
+import traceback
 import types
 import typing as ta
 import uuid
@@ -48,10 +49,6 @@ if sys.version_info < (3, 8):
 ########################################
 
 
-# commands/base.py
-CommandT = ta.TypeVar('CommandT', bound='Command')
-CommandOutputT = ta.TypeVar('CommandOutputT', bound='Command.Output')
-
 # ../../omlish/lite/cached.py
 T = ta.TypeVar('T')
 CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
@@ -59,37 +56,39 @@ CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 # ../../omlish/lite/check.py
 SizedT = ta.TypeVar('SizedT', bound=ta.Sized)
 
+# commands/base.py
+CommandT = ta.TypeVar('CommandT', bound='Command')
+CommandOutputT = ta.TypeVar('CommandOutputT', bound='Command.Output')
+
+# ../../omlish/lite/inject.py
+U = ta.TypeVar('U')
+InjectorKeyCls = ta.Union[type, ta.NewType]
+InjectorProviderFn = ta.Callable[['Injector'], ta.Any]
+InjectorProviderFnMap = ta.Mapping['InjectorKey', 'InjectorProviderFn']
+InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
+
 # ../../omlish/lite/subprocesses.py
 SubprocessChannelOption = ta.Literal['pipe', 'stdout', 'devnull']
 
 
 ########################################
-# ../commands/base.py
-
-
-##
+# ../config.py
 
 
 @dc.dataclass(frozen=True)
-class Command(abc.ABC, ta.Generic[CommandOutputT]):
-    @dc.dataclass(frozen=True)
-    class Output(abc.ABC):  # noqa
-        pass
-
-
-##
+class MainConfig:
+    log_level: ta.Optional[str] = 'INFO'
 
-
-class CommandExecutor(abc.ABC, ta.Generic[CommandT, CommandOutputT]):
-    @abc.abstractmethod
-    def execute(self, i: CommandT) -> CommandOutputT:
-        raise NotImplementedError
+    debug: bool = False
 
 
 ########################################
 # ../../pyremote.py
 """
 Basically this: https://mitogen.networkgenomics.com/howitworks.html
+
+TODO:
+ - log: ta.Optional[logging.Logger] = None + log.debug's
 """
 
 
@@ -100,6 +99,9 @@ Basically this: https://mitogen.networkgenomics.com/howitworks.html
 class PyremoteBootstrapOptions:
     debug: bool = False
 
+    DEFAULT_MAIN_NAME_OVERRIDE: ta.ClassVar[str] = '__pyremote__'
+    main_name_override: ta.Optional[str] = DEFAULT_MAIN_NAME_OVERRIDE
+
 
 ##
 
@@ -416,6 +418,10 @@ def pyremote_bootstrap_finalize() -> PyremotePayloadRuntime:
     os.dup2(nfd := os.open('/dev/null', os.O_WRONLY), 1)
     os.close(nfd)
 
+    if (mn := options.main_name_override) is not None:
+        # Inspections like typing.get_type_hints need an entry in sys.modules.
+        sys.modules[mn] = sys.modules['__main__']
+
     # Write fourth ack
     output.write(_PYREMOTE_BOOTSTRAP_ACK3)
 
@@ -434,14 +440,41 @@ def pyremote_bootstrap_finalize() -> PyremotePayloadRuntime:
 
 
 class PyremoteBootstrapDriver:
-    def __init__(self, main_src: str, options: PyremoteBootstrapOptions = PyremoteBootstrapOptions()) -> None:
+    def __init__(
+            self,
+            main_src: ta.Union[str, ta.Sequence[str]],
+            options: PyremoteBootstrapOptions = PyremoteBootstrapOptions(),
+    ) -> None:
         super().__init__()
 
         self._main_src = main_src
-        self._main_z = zlib.compress(main_src.encode('utf-8'))
-
         self._options = options
+
+        self._prepared_main_src = self._prepare_main_src(main_src, options)
+        self._main_z = zlib.compress(self._prepared_main_src.encode('utf-8'))
+
         self._options_json = json.dumps(dc.asdict(options), indent=None, separators=(',', ':')).encode('utf-8')  # noqa
+    #
+
+    @classmethod
+    def _prepare_main_src(
+            cls,
+            main_src: ta.Union[str, ta.Sequence[str]],
+            options: PyremoteBootstrapOptions,
+    ) -> str:
+        parts: ta.List[str]
+        if isinstance(main_src, str):
+            parts = [main_src]
+        else:
+            parts = list(main_src)
+
+        if (mn := options.main_name_override) is not None:
+            parts.insert(0, f'__name__ = {mn!r}')
+
+        if len(parts) == 1:
+            return parts[0]
+        else:
+            return '\n\n'.join(parts)
 
     #
 
@@ -702,6 +735,99 @@ json_dump_compact: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON
 json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_COMPACT_KWARGS)
 
 
+########################################
+# ../../../omlish/lite/maybes.py
+
+
+class Maybe(ta.Generic[T]):
+    @property
+    @abc.abstractmethod
+    def present(self) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def must(self) -> T:
+        raise NotImplementedError
+
+    @classmethod
+    def just(cls, v: T) -> 'Maybe[T]':
+        return tuple.__new__(_Maybe, (v,))  # noqa
+
+    _empty: ta.ClassVar['Maybe']
+
+    @classmethod
+    def empty(cls) -> 'Maybe[T]':
+        return Maybe._empty
+
+
+class _Maybe(Maybe[T], tuple):
+    __slots__ = ()
+
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError
+
+    @property
+    def present(self) -> bool:
+        return bool(self)
+
+    def must(self) -> T:
+        if not self:
+            raise ValueError
+        return self[0]
+
+
+Maybe._empty = tuple.__new__(_Maybe, ())  # noqa
+
+
+########################################
+# ../../../omlish/lite/pycharm.py
+
+
+DEFAULT_PYCHARM_VERSION = '242.23726.102'
+
+
+@dc.dataclass(frozen=True)
+class PycharmRemoteDebug:
+    port: int
+    host: ta.Optional[str] = 'localhost'
+    install_version: ta.Optional[str] = DEFAULT_PYCHARM_VERSION
+
+
+def pycharm_debug_connect(prd: PycharmRemoteDebug) -> None:
+    if prd.install_version is not None:
+        import subprocess
+        import sys
+        subprocess.check_call([
+            sys.executable,
+            '-mpip',
+            'install',
+            f'pydevd-pycharm~={prd.install_version}',
+        ])
+
+    pydevd_pycharm = __import__('pydevd_pycharm')  # noqa
+    pydevd_pycharm.settrace(
+        prd.host,
+        port=prd.port,
+        stdoutToServer=True,
+        stderrToServer=True,
+    )
+
+
+def pycharm_debug_preamble(prd: PycharmRemoteDebug) -> str:
+    import inspect
+    import textwrap
+
+    return textwrap.dedent(f"""
+        {inspect.getsource(pycharm_debug_connect)}
+
+        pycharm_debug_connect(PycharmRemoteDebug(
+            {prd.port!r},
+            host={prd.host!r},
+            install_version={prd.install_version!r},
+        ))
+    """)
+
+
 ########################################
 # ../../../omlish/lite/reflect.py
 
@@ -758,207 +884,1334 @@ def deep_subclasses(cls: ta.Type[T]) -> ta.Iterator[ta.Type[T]]:
 
 
 ########################################
-# ../payload.py
+# ../../../omlish/lite/strings.py
 
 
-@cached_nullary
-def _get_self_src() -> str:
-    return inspect.getsource(sys.modules[__name__])
+##
 
 
-def _is_src_amalg(src: str) -> bool:
-    for l in src.splitlines():  # noqa
-        if l.startswith('# @omlish-amalg-output '):
-            return True
-    return False
+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
 
 
-@cached_nullary
-def _is_self_amalg() -> bool:
-    return _is_src_amalg(_get_self_src())
+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 get_payload_src(*, file: ta.Optional[str]) -> str:
-    if file is not None:
-        with open(file) as f:
-            return f.read()
+##
 
-    if _is_self_amalg():
-        return _get_self_src()
 
-    import importlib.resources
-    return importlib.resources.files(__package__.split('.')[0] + '.scripts').joinpath('manage.py').read_text()
+def is_dunder(name: str) -> bool:
+    return (
+        name[:2] == name[-2:] == '__' and
+        name[2:3] != '_' and
+        name[-3:-2] != '_' and
+        len(name) > 4
+    )
 
 
-########################################
-# ../../../omlish/lite/logs.py
-"""
-TODO:
- - translate json keys
- - debug
-"""
+def is_sunder(name: str) -> bool:
+    return (
+        name[0] == name[-1] == '_' and
+        name[1:2] != '_' and
+        name[-2:-1] != '_' and
+        len(name) > 2
+    )
 
 
-log = logging.getLogger(__name__)
+##
+
+
+def attr_repr(obj: ta.Any, *attrs: str) -> str:
+    return f'{type(obj).__name__}({", ".join(f"{attr}={getattr(obj, attr)!r}" for attr in attrs)})'
 
 
 ##
 
 
-class TidLogFilter(logging.Filter):
+FORMAT_NUM_BYTES_SUFFIXES: ta.Sequence[str] = ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB']
 
-    def filter(self, record):
-        record.tid = threading.get_native_id()
-        return True
 
+def format_num_bytes(num_bytes: int) -> str:
+    for i, suffix in enumerate(FORMAT_NUM_BYTES_SUFFIXES):
+        value = num_bytes / 1024 ** i
+        if num_bytes < 1024 ** (i + 1):
+            if value.is_integer():
+                return f'{int(value)}{suffix}'
+            else:
+                return f'{value:.2f}{suffix}'
 
-##
+    return f'{num_bytes / 1024 ** (len(FORMAT_NUM_BYTES_SUFFIXES) - 1):.2f}{FORMAT_NUM_BYTES_SUFFIXES[-1]}'
 
 
-class JsonLogFormatter(logging.Formatter):
+########################################
+# ../commands/base.py
 
-    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)
+##
+
+
+@dc.dataclass(frozen=True)
+class Command(abc.ABC, ta.Generic[CommandOutputT]):
+    @dc.dataclass(frozen=True)
+    class Output(abc.ABC):  # noqa
+        pass
+
+    @ta.final
+    def execute(self, executor: 'CommandExecutor') -> CommandOutputT:
+        return check_isinstance(executor.execute(self), self.Output)  # type: ignore[return-value]
 
 
 ##
 
 
-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'),
-]
+@dc.dataclass(frozen=True)
+class CommandException:
+    name: str
+    repr: str
 
+    traceback: ta.Optional[str] = None
 
-class StandardLogFormatter(logging.Formatter):
+    exc: ta.Optional[ta.Any] = None  # Exception
 
-    @staticmethod
-    def build_log_format(parts: ta.Iterable[ta.Tuple[str, str]]) -> str:
-        return ' '.join(v for k, v in parts)
+    cmd: ta.Optional[Command] = None
 
-    converter = datetime.datetime.fromtimestamp  # type: ignore
+    @classmethod
+    def of(
+            cls,
+            exc: Exception,
+            *,
+            omit_exc_object: bool = False,
 
-    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
+            cmd: ta.Optional[Command] = None,
+    ) -> 'CommandException':
+        return CommandException(
+            name=type(exc).__qualname__,
+            repr=repr(exc),
 
+            traceback=(
+                ''.join(traceback.format_tb(exc.__traceback__))
+                if getattr(exc, '__traceback__', None) is not None else None
+            ),
 
-##
+            exc=None if omit_exc_object else exc,
 
+            cmd=cmd,
+        )
 
-class ProxyLogFilterer(logging.Filterer):
-    def __init__(self, underlying: logging.Filterer) -> None:  # noqa
-        self._underlying = underlying
 
+class CommandOutputOrException(abc.ABC, ta.Generic[CommandOutputT]):
     @property
-    def underlying(self) -> logging.Filterer:
-        return self._underlying
+    @abc.abstractmethod
+    def output(self) -> ta.Optional[CommandOutputT]:
+        raise NotImplementedError
 
     @property
-    def filters(self):
-        return self._underlying.filters
+    @abc.abstractmethod
+    def exception(self) -> ta.Optional[CommandException]:
+        raise NotImplementedError
 
-    @filters.setter
-    def filters(self, filters):
-        self._underlying.filters = filters
 
-    def addFilter(self, filter):  # noqa
-        self._underlying.addFilter(filter)
+@dc.dataclass(frozen=True)
+class CommandOutputOrExceptionData(CommandOutputOrException):
+    output: ta.Optional[Command.Output] = None
+    exception: ta.Optional[CommandException] = None
 
-    def removeFilter(self, filter):  # noqa
-        self._underlying.removeFilter(filter)
 
-    def filter(self, record):
-        return self._underlying.filter(record)
+class CommandExecutor(abc.ABC, ta.Generic[CommandT, CommandOutputT]):
+    @abc.abstractmethod
+    def execute(self, cmd: CommandT) -> CommandOutputT:
+        raise NotImplementedError
 
+    def try_execute(
+            self,
+            cmd: CommandT,
+            *,
+            log: ta.Optional[logging.Logger] = None,
+            omit_exc_object: bool = False,
+    ) -> CommandOutputOrException[CommandOutputT]:
+        try:
+            o = self.execute(cmd)
 
-class ProxyLogHandler(ProxyLogFilterer, logging.Handler):
-    def __init__(self, underlying: logging.Handler) -> None:  # noqa
-        ProxyLogFilterer.__init__(self, underlying)
+        except Exception as e:  # noqa
+            if log is not None:
+                log.exception('Exception executing command: %r', type(cmd))
 
-    _underlying: logging.Handler
+            return CommandOutputOrExceptionData(exception=CommandException.of(
+                e,
+                omit_exc_object=omit_exc_object,
+                cmd=cmd,
+            ))
 
-    @property
-    def underlying(self) -> logging.Handler:
-        return self._underlying
+        else:
+            return CommandOutputOrExceptionData(output=o)
 
-    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
+@dc.dataclass(frozen=True)
+class CommandRegistration:
+    command_cls: ta.Type[Command]
 
-    @level.setter
-    def level(self, level):
-        self._underlying.level = level
+    name: ta.Optional[str] = None
 
     @property
-    def formatter(self):
-        return self._underlying.formatter
+    def name_or_default(self) -> str:
+        if not (cls_name := self.command_cls.__name__).endswith('Command'):
+            raise NameError(cls_name)
+        return snake_case(cls_name[:-len('Command')])
 
-    @formatter.setter
-    def formatter(self, formatter):
-        self._underlying.formatter = formatter
 
-    def createLock(self):
-        self._underlying.createLock()
+CommandRegistrations = ta.NewType('CommandRegistrations', ta.Sequence[CommandRegistration])
 
-    def acquire(self):
-        self._underlying.acquire()
 
-    def release(self):
-        self._underlying.release()
+##
 
-    def setLevel(self, level):
-        self._underlying.setLevel(level)
 
-    def format(self, record):
+@dc.dataclass(frozen=True)
+class CommandExecutorRegistration:
+    command_cls: ta.Type[Command]
+    executor_cls: ta.Type[CommandExecutor]
+
+
+CommandExecutorRegistrations = ta.NewType('CommandExecutorRegistrations', ta.Sequence[CommandExecutorRegistration])
+
+
+##
+
+
+CommandNameMap = ta.NewType('CommandNameMap', ta.Mapping[str, ta.Type[Command]])
+
+
+def build_command_name_map(crs: CommandRegistrations) -> CommandNameMap:
+    dct: ta.Dict[str, ta.Type[Command]] = {}
+    cr: CommandRegistration
+    for cr in crs:
+        if (name := cr.name_or_default) in dct:
+            raise NameError(name)
+        dct[name] = cr.command_cls
+    return CommandNameMap(dct)
+
+
+########################################
+# ../remote/config.py
+
+
+@dc.dataclass(frozen=True)
+class RemoteConfig:
+    payload_file: ta.Optional[str] = None
+
+    pycharm_remote_debug: ta.Optional[PycharmRemoteDebug] = None
+
+
+########################################
+# ../remote/payload.py
+
+
+RemoteExecutionPayloadFile = ta.NewType('RemoteExecutionPayloadFile', str)
+
+
+@cached_nullary
+def _get_self_src() -> str:
+    return inspect.getsource(sys.modules[__name__])
+
+
+def _is_src_amalg(src: str) -> bool:
+    for l in src.splitlines():  # noqa
+        if l.startswith('# @omlish-amalg-output '):
+            return True
+    return False
+
+
+@cached_nullary
+def _is_self_amalg() -> bool:
+    return _is_src_amalg(_get_self_src())
+
+
+def get_remote_payload_src(
+        *,
+        file: ta.Optional[RemoteExecutionPayloadFile],
+) -> str:
+    if file is not None:
+        with open(file) as f:
+            return f.read()
+
+    if _is_self_amalg():
+        return _get_self_src()
+
+    import importlib.resources
+    return importlib.resources.files(__package__.split('.')[0] + '.scripts').joinpath('manage.py').read_text()
+
+
+########################################
+# ../../../omlish/lite/inject.py
+
+
+###
+# types
+
+
+@dc.dataclass(frozen=True)
+class InjectorKey(ta.Generic[T]):
+    # Before PEP-560 typing.Generic was a metaclass with a __new__ that takes a 'cls' arg, so instantiating a dataclass
+    # with kwargs (such as through dc.replace) causes `TypeError: __new__() got multiple values for argument 'cls'`.
+    # See:
+    #  - https://github.com/python/cpython/commit/d911e40e788fb679723d78b6ea11cabf46caed5a
+    #  - https://gist.github.com/wrmsr/4468b86efe9f373b6b114bfe85b98fd3
+    cls_: InjectorKeyCls
+
+    tag: ta.Any = None
+    array: bool = False
+
+
+def is_valid_injector_key_cls(cls: ta.Any) -> bool:
+    return isinstance(cls, type) or is_new_type(cls)
+
+
+def check_valid_injector_key_cls(cls: T) -> T:
+    if not is_valid_injector_key_cls(cls):
+        raise TypeError(cls)
+    return cls
+
+
+##
+
+
+class InjectorProvider(abc.ABC):
+    @abc.abstractmethod
+    def provider_fn(self) -> InjectorProviderFn:
+        raise NotImplementedError
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class InjectorBinding:
+    key: InjectorKey
+    provider: InjectorProvider
+
+
+class InjectorBindings(abc.ABC):
+    @abc.abstractmethod
+    def bindings(self) -> ta.Iterator[InjectorBinding]:
+        raise NotImplementedError
+
+##
+
+
+class Injector(abc.ABC):
+    @abc.abstractmethod
+    def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def provide(self, key: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def provide_kwargs(
+            self,
+            obj: ta.Any,
+            *,
+            skip_args: int = 0,
+            skip_kwargs: ta.Optional[ta.Iterable[ta.Any]] = None,
+    ) -> ta.Mapping[str, ta.Any]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def inject(
+            self,
+            obj: ta.Any,
+            *,
+            args: ta.Optional[ta.Sequence[ta.Any]] = None,
+            kwargs: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+    ) -> ta.Any:
+        raise NotImplementedError
+
+    def __getitem__(
+            self,
+            target: ta.Union[InjectorKey[T], ta.Type[T]],
+    ) -> T:
+        return self.provide(target)
+
+
+###
+# exceptions
+
+
+class InjectorError(Exception):
+    pass
+
+
+@dc.dataclass()
+class InjectorKeyError(InjectorError):
+    key: InjectorKey
+
+    source: ta.Any = None
+    name: ta.Optional[str] = None
+
+
+class UnboundInjectorKeyError(InjectorKeyError):
+    pass
+
+
+class DuplicateInjectorKeyError(InjectorKeyError):
+    pass
+
+
+class CyclicDependencyInjectorKeyError(InjectorKeyError):
+    pass
+
+
+###
+# keys
+
+
+def as_injector_key(o: ta.Any) -> InjectorKey:
+    if o is inspect.Parameter.empty:
+        raise TypeError(o)
+    if isinstance(o, InjectorKey):
+        return o
+    if is_valid_injector_key_cls(o):
+        return InjectorKey(o)
+    raise TypeError(o)
+
+
+###
+# providers
+
+
+@dc.dataclass(frozen=True)
+class FnInjectorProvider(InjectorProvider):
+    fn: ta.Any
+
+    def __post_init__(self) -> None:
+        check_not_isinstance(self.fn, type)
+
+    def provider_fn(self) -> InjectorProviderFn:
+        def pfn(i: Injector) -> ta.Any:
+            return i.inject(self.fn)
+
+        return pfn
+
+
+@dc.dataclass(frozen=True)
+class CtorInjectorProvider(InjectorProvider):
+    cls_: type
+
+    def __post_init__(self) -> None:
+        check_isinstance(self.cls_, type)
+
+    def provider_fn(self) -> InjectorProviderFn:
+        def pfn(i: Injector) -> ta.Any:
+            return i.inject(self.cls_)
+
+        return pfn
+
+
+@dc.dataclass(frozen=True)
+class ConstInjectorProvider(InjectorProvider):
+    v: ta.Any
+
+    def provider_fn(self) -> InjectorProviderFn:
+        return lambda _: self.v
+
+
+@dc.dataclass(frozen=True)
+class SingletonInjectorProvider(InjectorProvider):
+    p: InjectorProvider
+
+    def __post_init__(self) -> None:
+        check_isinstance(self.p, InjectorProvider)
+
+    def provider_fn(self) -> InjectorProviderFn:
+        v = not_set = object()
+
+        def pfn(i: Injector) -> ta.Any:
+            nonlocal v
+            if v is not_set:
+                v = ufn(i)
+            return v
+
+        ufn = self.p.provider_fn()
+        return pfn
+
+
+@dc.dataclass(frozen=True)
+class LinkInjectorProvider(InjectorProvider):
+    k: InjectorKey
+
+    def __post_init__(self) -> None:
+        check_isinstance(self.k, InjectorKey)
+
+    def provider_fn(self) -> InjectorProviderFn:
+        def pfn(i: Injector) -> ta.Any:
+            return i.provide(self.k)
+
+        return pfn
+
+
+@dc.dataclass(frozen=True)
+class ArrayInjectorProvider(InjectorProvider):
+    ps: ta.Sequence[InjectorProvider]
+
+    def provider_fn(self) -> InjectorProviderFn:
+        ps = [p.provider_fn() for p in self.ps]
+
+        def pfn(i: Injector) -> ta.Any:
+            rv = []
+            for ep in ps:
+                o = ep(i)
+                rv.append(o)
+            return rv
+
+        return pfn
+
+
+###
+# bindings
+
+
+@dc.dataclass(frozen=True)
+class _InjectorBindings(InjectorBindings):
+    bs: ta.Optional[ta.Sequence[InjectorBinding]] = None
+    ps: ta.Optional[ta.Sequence[InjectorBindings]] = None
+
+    def bindings(self) -> ta.Iterator[InjectorBinding]:
+        if self.bs is not None:
+            yield from self.bs
+        if self.ps is not None:
+            for p in self.ps:
+                yield from p.bindings()
+
+
+def as_injector_bindings(*args: InjectorBindingOrBindings) -> InjectorBindings:
+    bs: ta.List[InjectorBinding] = []
+    ps: ta.List[InjectorBindings] = []
+
+    for a in args:
+        if isinstance(a, InjectorBindings):
+            ps.append(a)
+        elif isinstance(a, InjectorBinding):
+            bs.append(a)
+        else:
+            raise TypeError(a)
+
+    return _InjectorBindings(
+        bs or None,
+        ps or None,
+    )
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class OverridesInjectorBindings(InjectorBindings):
+    p: InjectorBindings
+    m: ta.Mapping[InjectorKey, InjectorBinding]
+
+    def bindings(self) -> ta.Iterator[InjectorBinding]:
+        for b in self.p.bindings():
+            yield self.m.get(b.key, b)
+
+
+def injector_override(p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
+    m: ta.Dict[InjectorKey, InjectorBinding] = {}
+
+    for b in as_injector_bindings(*args).bindings():
+        if b.key in m:
+            raise DuplicateInjectorKeyError(b.key)
+        m[b.key] = b
+
+    return OverridesInjectorBindings(p, m)
+
+
+##
+
+
+def build_injector_provider_map(bs: InjectorBindings) -> ta.Mapping[InjectorKey, InjectorProvider]:
+    pm: ta.Dict[InjectorKey, InjectorProvider] = {}
+    am: ta.Dict[InjectorKey, ta.List[InjectorProvider]] = {}
+
+    for b in bs.bindings():
+        if b.key.array:
+            al = am.setdefault(b.key, [])
+            if isinstance(b.provider, ArrayInjectorProvider):
+                al.extend(b.provider.ps)
+            else:
+                al.append(b.provider)
+        else:
+            if b.key in pm:
+                raise KeyError(b.key)
+            pm[b.key] = b.provider
+
+    if am:
+        for k, aps in am.items():
+            pm[k] = ArrayInjectorProvider(aps)
+
+    return pm
+
+
+###
+# inspection
+
+
+class _InjectionInspection(ta.NamedTuple):
+    signature: inspect.Signature
+    type_hints: ta.Mapping[str, ta.Any]
+    args_offset: int
+
+
+_INJECTION_INSPECTION_CACHE: ta.MutableMapping[ta.Any, _InjectionInspection] = weakref.WeakKeyDictionary()
+
+
+def _do_injection_inspect(obj: ta.Any) -> _InjectionInspection:
+    tgt = obj
+    if isinstance(tgt, type) and tgt.__init__ is not object.__init__:  # type: ignore[misc]
+        # Python 3.8's inspect.signature can't handle subclasses overriding __new__, always generating *args/**kwargs.
+        #  - https://bugs.python.org/issue40897
+        #  - https://github.com/python/cpython/commit/df7c62980d15acd3125dfbd81546dad359f7add7
+        tgt = tgt.__init__  # type: ignore[misc]
+        has_generic_base = True
+    else:
+        has_generic_base = False
+
+    # inspect.signature(eval_str=True) was added in 3.10 and we have to support 3.8, so we have to get_type_hints to
+    # eval str annotations *in addition to* getting the signature for parameter information.
+    uw = tgt
+    has_partial = False
+    while True:
+        if isinstance(uw, functools.partial):
+            has_partial = True
+            uw = uw.func
+        else:
+            if (uw2 := inspect.unwrap(uw)) is uw:
+                break
+            uw = uw2
+
+    if has_generic_base and has_partial:
+        raise InjectorError(
+            'Injector inspection does not currently support both a typing.Generic base and a functools.partial: '
+            f'{obj}',
+        )
+
+    return _InjectionInspection(
+        inspect.signature(tgt),
+        ta.get_type_hints(uw),
+        1 if has_generic_base else 0,
+    )
+
+
+def _injection_inspect(obj: ta.Any) -> _InjectionInspection:
+    try:
+        return _INJECTION_INSPECTION_CACHE[obj]
+    except TypeError:
+        return _do_injection_inspect(obj)
+    except KeyError:
+        pass
+    insp = _do_injection_inspect(obj)
+    _INJECTION_INSPECTION_CACHE[obj] = insp
+    return insp
+
+
+class InjectionKwarg(ta.NamedTuple):
+    name: str
+    key: InjectorKey
+    has_default: bool
+
+
+class InjectionKwargsTarget(ta.NamedTuple):
+    obj: ta.Any
+    kwargs: ta.Sequence[InjectionKwarg]
+
+
+def build_injection_kwargs_target(
+        obj: ta.Any,
+        *,
+        skip_args: int = 0,
+        skip_kwargs: ta.Optional[ta.Iterable[str]] = None,
+        raw_optional: bool = False,
+) -> InjectionKwargsTarget:
+    insp = _injection_inspect(obj)
+
+    params = list(insp.signature.parameters.values())
+
+    skip_names: ta.Set[str] = set()
+    if skip_kwargs is not None:
+        skip_names.update(check_not_isinstance(skip_kwargs, str))
+
+    seen: ta.Set[InjectorKey] = set()
+    kws: ta.List[InjectionKwarg] = []
+    for p in params[insp.args_offset + skip_args:]:
+        if p.name in skip_names:
+            continue
+
+        if p.annotation is inspect.Signature.empty:
+            if p.default is not inspect.Parameter.empty:
+                raise KeyError(f'{obj}, {p.name}')
+            continue
+
+        if p.kind not in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY):
+            raise TypeError(insp)
+
+        # 3.8 inspect.signature doesn't eval_str but typing.get_type_hints does, so prefer that.
+        ann = insp.type_hints.get(p.name, p.annotation)
+        if (
+                not raw_optional and
+                is_optional_alias(ann)
+        ):
+            ann = get_optional_alias_arg(ann)
+
+        k = as_injector_key(ann)
+
+        if k in seen:
+            raise DuplicateInjectorKeyError(k)
+        seen.add(k)
+
+        kws.append(InjectionKwarg(
+            p.name,
+            k,
+            p.default is not inspect.Parameter.empty,
+        ))
+
+    return InjectionKwargsTarget(
+        obj,
+        kws,
+    )
+
+
+###
+# injector
+
+
+_INJECTOR_INJECTOR_KEY: InjectorKey[Injector] = InjectorKey(Injector)
+
+
+@dc.dataclass(frozen=True)
+class _InjectorEager:
+    key: InjectorKey
+
+
+_INJECTOR_EAGER_ARRAY_KEY: InjectorKey[_InjectorEager] = InjectorKey(_InjectorEager, array=True)
+
+
+class _Injector(Injector):
+    def __init__(self, bs: InjectorBindings, p: ta.Optional[Injector] = None) -> None:
+        super().__init__()
+
+        self._bs = check_isinstance(bs, InjectorBindings)
+        self._p: ta.Optional[Injector] = check_isinstance(p, (Injector, type(None)))
+
+        self._pfm = {k: v.provider_fn() for k, v in build_injector_provider_map(bs).items()}
+
+        if _INJECTOR_INJECTOR_KEY in self._pfm:
+            raise DuplicateInjectorKeyError(_INJECTOR_INJECTOR_KEY)
+
+        self.__cur_req: ta.Optional[_Injector._Request] = None
+
+        if _INJECTOR_EAGER_ARRAY_KEY in self._pfm:
+            for e in self.provide(_INJECTOR_EAGER_ARRAY_KEY):
+                self.provide(e.key)
+
+    class _Request:
+        def __init__(self, injector: '_Injector') -> None:
+            super().__init__()
+            self._injector = injector
+            self._provisions: ta.Dict[InjectorKey, Maybe] = {}
+            self._seen_keys: ta.Set[InjectorKey] = set()
+
+        def handle_key(self, key: InjectorKey) -> Maybe[Maybe]:
+            try:
+                return Maybe.just(self._provisions[key])
+            except KeyError:
+                pass
+            if key in self._seen_keys:
+                raise CyclicDependencyInjectorKeyError(key)
+            self._seen_keys.add(key)
+            return Maybe.empty()
+
+        def handle_provision(self, key: InjectorKey, mv: Maybe) -> Maybe:
+            check_in(key, self._seen_keys)
+            check_not_in(key, self._provisions)
+            self._provisions[key] = mv
+            return mv
+
+    @contextlib.contextmanager
+    def _current_request(self) -> ta.Generator[_Request, None, None]:
+        if (cr := self.__cur_req) is not None:
+            yield cr
+            return
+
+        cr = self._Request(self)
+        try:
+            self.__cur_req = cr
+            yield cr
+        finally:
+            self.__cur_req = None
+
+    def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
+        key = as_injector_key(key)
+
+        cr: _Injector._Request
+        with self._current_request() as cr:
+            if (rv := cr.handle_key(key)).present:
+                return rv.must()
+
+            if key == _INJECTOR_INJECTOR_KEY:
+                return cr.handle_provision(key, Maybe.just(self))
+
+            fn = self._pfm.get(key)
+            if fn is not None:
+                return cr.handle_provision(key, Maybe.just(fn(self)))
+
+            if self._p is not None:
+                pv = self._p.try_provide(key)
+                if pv is not None:
+                    return cr.handle_provision(key, Maybe.empty())
+
+            return cr.handle_provision(key, Maybe.empty())
+
+    def provide(self, key: ta.Any) -> ta.Any:
+        v = self.try_provide(key)
+        if v.present:
+            return v.must()
+        raise UnboundInjectorKeyError(key)
+
+    def provide_kwargs(
+            self,
+            obj: ta.Any,
+            *,
+            skip_args: int = 0,
+            skip_kwargs: ta.Optional[ta.Iterable[ta.Any]] = None,
+    ) -> ta.Mapping[str, ta.Any]:
+        kt = build_injection_kwargs_target(
+            obj,
+            skip_args=skip_args,
+            skip_kwargs=skip_kwargs,
+        )
+
+        ret: ta.Dict[str, ta.Any] = {}
+        for kw in kt.kwargs:
+            if kw.has_default:
+                if not (mv := self.try_provide(kw.key)).present:
+                    continue
+                v = mv.must()
+            else:
+                v = self.provide(kw.key)
+            ret[kw.name] = v
+        return ret
+
+    def inject(
+            self,
+            obj: ta.Any,
+            *,
+            args: ta.Optional[ta.Sequence[ta.Any]] = None,
+            kwargs: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+    ) -> ta.Any:
+        provided = self.provide_kwargs(
+            obj,
+            skip_args=len(args) if args is not None else 0,
+            skip_kwargs=kwargs if kwargs is not None else None,
+        )
+
+        return obj(
+            *(args if args is not None else ()),
+            **(kwargs if kwargs is not None else {}),
+            **provided,
+        )
+
+
+###
+# binder
+
+
+class InjectorBinder:
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
+
+    _FN_TYPES: ta.Tuple[type, ...] = (
+        types.FunctionType,
+        types.MethodType,
+
+        classmethod,
+        staticmethod,
+
+        functools.partial,
+        functools.partialmethod,
+    )
+
+    @classmethod
+    def _is_fn(cls, obj: ta.Any) -> bool:
+        return isinstance(obj, cls._FN_TYPES)
+
+    @classmethod
+    def bind_as_fn(cls, icls: ta.Type[T]) -> ta.Type[T]:
+        check_isinstance(icls, type)
+        if icls not in cls._FN_TYPES:
+            cls._FN_TYPES = (*cls._FN_TYPES, icls)
+        return icls
+
+    _BANNED_BIND_TYPES: ta.Tuple[type, ...] = (
+        InjectorProvider,
+    )
+
+    @classmethod
+    def bind(
+            cls,
+            obj: ta.Any,
+            *,
+            key: ta.Any = None,
+            tag: ta.Any = None,
+            array: ta.Optional[bool] = None,  # noqa
+
+            to_fn: ta.Any = None,
+            to_ctor: ta.Any = None,
+            to_const: ta.Any = None,
+            to_key: ta.Any = None,
+
+            singleton: bool = False,
+
+            eager: bool = False,
+    ) -> InjectorBindingOrBindings:
+        if obj is None or obj is inspect.Parameter.empty:
+            raise TypeError(obj)
+        if isinstance(obj, cls._BANNED_BIND_TYPES):
+            raise TypeError(obj)
+
+        ##
+
+        if key is not None:
+            key = as_injector_key(key)
+
+        ##
+
+        has_to = (
+            to_fn is not None or
+            to_ctor is not None or
+            to_const is not None or
+            to_key is not None
+        )
+        if isinstance(obj, InjectorKey):
+            if key is None:
+                key = obj
+        elif isinstance(obj, type):
+            if not has_to:
+                to_ctor = obj
+            if key is None:
+                key = InjectorKey(obj)
+        elif cls._is_fn(obj) and not has_to:
+            to_fn = obj
+            if key is None:
+                insp = _injection_inspect(obj)
+                key_cls: ta.Any = check_valid_injector_key_cls(check_not_none(insp.type_hints.get('return')))
+                key = InjectorKey(key_cls)
+        else:
+            if to_const is not None:
+                raise TypeError('Cannot bind instance with to_const')
+            to_const = obj
+            if key is None:
+                key = InjectorKey(type(obj))
+        del has_to
+
+        ##
+
+        if tag is not None:
+            if key.tag is not None:
+                raise TypeError('Tag already set')
+            key = dc.replace(key, tag=tag)
+
+        if array is not None:
+            key = dc.replace(key, array=array)
+
+        ##
+
+        providers: ta.List[InjectorProvider] = []
+        if to_fn is not None:
+            providers.append(FnInjectorProvider(to_fn))
+        if to_ctor is not None:
+            providers.append(CtorInjectorProvider(to_ctor))
+        if to_const is not None:
+            providers.append(ConstInjectorProvider(to_const))
+        if to_key is not None:
+            providers.append(LinkInjectorProvider(as_injector_key(to_key)))
+        if not providers:
+            raise TypeError('Must specify provider')
+        if len(providers) > 1:
+            raise TypeError('May not specify multiple providers')
+        provider, = providers
+
+        ##
+
+        if singleton:
+            provider = SingletonInjectorProvider(provider)
+
+        binding = InjectorBinding(key, provider)
+
+        ##
+
+        extras: ta.List[InjectorBinding] = []
+
+        if eager:
+            extras.append(bind_injector_eager_key(key))
+
+        ##
+
+        if extras:
+            return as_injector_bindings(binding, *extras)
+        else:
+            return binding
+
+
+###
+# injection helpers
+
+
+def make_injector_factory(
+        fn: ta.Callable[..., T],
+        cls: U,
+        ann: ta.Any = None,
+) -> ta.Callable[..., U]:
+    if ann is None:
+        ann = cls
+
+    def outer(injector: Injector) -> ann:
+        def inner(*args, **kwargs):
+            return injector.inject(fn, args=args, kwargs=kwargs)
+        return cls(inner)  # type: ignore
+
+    return outer
+
+
+def bind_injector_array(
+        obj: ta.Any = None,
+        *,
+        tag: ta.Any = None,
+) -> InjectorBindingOrBindings:
+    key = as_injector_key(obj)
+    if tag is not None:
+        if key.tag is not None:
+            raise ValueError('Must not specify multiple tags')
+        key = dc.replace(key, tag=tag)
+
+    if key.array:
+        raise ValueError('Key must not be array')
+
+    return InjectorBinding(
+        dc.replace(key, array=True),
+        ArrayInjectorProvider([]),
+    )
+
+
+def make_injector_array_type(
+        ele: ta.Union[InjectorKey, InjectorKeyCls],
+        cls: U,
+        ann: ta.Any = None,
+) -> ta.Callable[..., U]:
+    if isinstance(ele, InjectorKey):
+        if not ele.array:
+            raise InjectorError('Provided key must be array', ele)
+        key = ele
+    else:
+        key = dc.replace(as_injector_key(ele), array=True)
+
+    if ann is None:
+        ann = cls
+
+    def inner(injector: Injector) -> ann:
+        return cls(injector.provide(key))  # type: ignore[operator]
+
+    return inner
+
+
+def bind_injector_eager_key(key: ta.Any) -> InjectorBinding:
+    return InjectorBinding(_INJECTOR_EAGER_ARRAY_KEY, ConstInjectorProvider(_InjectorEager(as_injector_key(key))))
+
+
+##
+
+
+class Injection:
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
+
+    # keys
+
+    @classmethod
+    def as_key(cls, o: ta.Any) -> InjectorKey:
+        return as_injector_key(o)
+
+    @classmethod
+    def array(cls, o: ta.Any) -> InjectorKey:
+        return dc.replace(as_injector_key(o), array=True)
+
+    @classmethod
+    def tag(cls, o: ta.Any, t: ta.Any) -> InjectorKey:
+        return dc.replace(as_injector_key(o), tag=t)
+
+    # bindings
+
+    @classmethod
+    def as_bindings(cls, *args: InjectorBindingOrBindings) -> InjectorBindings:
+        return as_injector_bindings(*args)
+
+    @classmethod
+    def override(cls, p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
+        return injector_override(p, *args)
+
+    # injector
+
+    @classmethod
+    def create_injector(cls, *args: InjectorBindingOrBindings, parent: ta.Optional[Injector] = None) -> Injector:
+        return _Injector(as_injector_bindings(*args), parent)
+
+    # binder
+
+    @classmethod
+    def bind(
+            cls,
+            obj: ta.Any,
+            *,
+            key: ta.Any = None,
+            tag: ta.Any = None,
+            array: ta.Optional[bool] = None,  # noqa
+
+            to_fn: ta.Any = None,
+            to_ctor: ta.Any = None,
+            to_const: ta.Any = None,
+            to_key: ta.Any = None,
+
+            singleton: bool = False,
+
+            eager: bool = False,
+    ) -> InjectorBindingOrBindings:
+        return InjectorBinder.bind(
+            obj,
+
+            key=key,
+            tag=tag,
+            array=array,
+
+            to_fn=to_fn,
+            to_ctor=to_ctor,
+            to_const=to_const,
+            to_key=to_key,
+
+            singleton=singleton,
+
+            eager=eager,
+        )
+
+    # helpers
+
+    @classmethod
+    def bind_factory(
+            cls,
+            fn: ta.Callable[..., T],
+            cls_: U,
+            ann: ta.Any = None,
+    ) -> InjectorBindingOrBindings:
+        return cls.bind(make_injector_factory(fn, cls_, ann))
+
+    @classmethod
+    def bind_array(
+            cls,
+            obj: ta.Any = None,
+            *,
+            tag: ta.Any = None,
+    ) -> InjectorBindingOrBindings:
+        return bind_injector_array(obj, tag=tag)
+
+    @classmethod
+    def bind_array_type(
+            cls,
+            ele: ta.Union[InjectorKey, InjectorKeyCls],
+            cls_: U,
+            ann: ta.Any = None,
+    ) -> InjectorBindingOrBindings:
+        return cls.bind(make_injector_array_type(ele, cls_, ann))
+
+
+inj = Injection
+
+
+########################################
+# ../../../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):
@@ -1072,21 +2325,26 @@ TODO:
 ##
 
 
+@dc.dataclass(frozen=True)
+class ObjMarshalOptions:
+    raw_bytes: bool = False
+
+
 class ObjMarshaler(abc.ABC):
     @abc.abstractmethod
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         raise NotImplementedError
 
 
 class NopObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         return o
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         return o
 
 
@@ -1094,29 +2352,29 @@ class NopObjMarshaler(ObjMarshaler):
 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 marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+        return check_not_none(self.m).marshal(o, opts)
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        return check_not_none(self.m).unmarshal(o)
+    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+        return check_not_none(self.m).unmarshal(o, opts)
 
 
 @dc.dataclass(frozen=True)
 class CastObjMarshaler(ObjMarshaler):
     ty: type
 
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         return o
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         return self.ty(o)
 
 
 class DynamicObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         return marshal_obj(o)
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         return o
 
 
@@ -1124,21 +2382,36 @@ class DynamicObjMarshaler(ObjMarshaler):
 class Base64ObjMarshaler(ObjMarshaler):
     ty: type
 
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         return base64.b64encode(o).decode('ascii')
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         return self.ty(base64.b64decode(o))
 
 
+@dc.dataclass(frozen=True)
+class BytesSwitchedObjMarshaler(ObjMarshaler):
+    m: ObjMarshaler
+
+    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+        if opts.raw_bytes:
+            return o
+        return self.m.marshal(o, opts)
+
+    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+        if opts.raw_bytes:
+            return o
+        return self.m.unmarshal(o, opts)
+
+
 @dc.dataclass(frozen=True)
 class EnumObjMarshaler(ObjMarshaler):
     ty: type
 
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         return o.name
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         return self.ty.__members__[o]  # type: ignore
 
 
@@ -1146,15 +2419,15 @@ class EnumObjMarshaler(ObjMarshaler):
 class OptionalObjMarshaler(ObjMarshaler):
     item: ObjMarshaler
 
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         if o is None:
             return None
-        return self.item.marshal(o)
+        return self.item.marshal(o, opts)
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         if o is None:
             return None
-        return self.item.unmarshal(o)
+        return self.item.unmarshal(o, opts)
 
 
 @dc.dataclass(frozen=True)
@@ -1163,11 +2436,11 @@ class MappingObjMarshaler(ObjMarshaler):
     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 marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+        return {self.km.marshal(k, opts): self.vm.marshal(v, opts) 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())
+    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+        return self.ty((self.km.unmarshal(k, opts), self.vm.unmarshal(v, opts)) for k, v in o.items())
 
 
 @dc.dataclass(frozen=True)
@@ -1175,11 +2448,11 @@ 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 marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+        return [self.item.marshal(e, opts) for e in o]
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        return self.ty(self.item.unmarshal(e) for e in o)
+    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+        return self.ty(self.item.unmarshal(e, opts) for e in o)
 
 
 @dc.dataclass(frozen=True)
@@ -1188,11 +2461,11 @@ class DataclassObjMarshaler(ObjMarshaler):
     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 marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+        return {k: m.marshal(getattr(o, k), opts) 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})
+    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+        return self.ty(**{k: self.fs[k].unmarshal(v, opts) for k, v in o.items() if not self.nonstrict or k in self.fs})
 
 
 @dc.dataclass(frozen=True)
@@ -1212,50 +2485,50 @@ class PolymorphicObjMarshaler(ObjMarshaler):
             {i.tag: i for i in impls},
         )
 
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         impl = self.impls_by_ty[type(o)]
-        return {impl.tag: impl.m.marshal(o)}
+        return {impl.tag: impl.m.marshal(o, opts)}
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         [(t, v)] = o.items()
         impl = self.impls_by_tag[t]
-        return impl.m.unmarshal(v)
+        return impl.m.unmarshal(v, opts)
 
 
 @dc.dataclass(frozen=True)
 class DatetimeObjMarshaler(ObjMarshaler):
     ty: type
 
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         return o.isoformat()
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         return self.ty.fromisoformat(o)  # type: ignore
 
 
 class DecimalObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         return str(check_isinstance(o, decimal.Decimal))
 
-    def unmarshal(self, v: ta.Any) -> ta.Any:
+    def unmarshal(self, v: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         return decimal.Decimal(check_isinstance(v, str))
 
 
 class FractionObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         fr = check_isinstance(o, fractions.Fraction)
         return [fr.numerator, fr.denominator]
 
-    def unmarshal(self, v: ta.Any) -> ta.Any:
+    def unmarshal(self, v: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         num, denom = check_isinstance(v, list)
         return fractions.Fraction(num, denom)
 
 
 class UuidObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         return str(o)
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
         return uuid.UUID(o)
 
 
@@ -1265,7 +2538,7 @@ class UuidObjMarshaler(ObjMarshaler):
 _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: BytesSwitchedObjMarshaler(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,)},
 
@@ -1298,12 +2571,16 @@ class ObjMarshalerManager:
     def __init__(
             self,
             *,
+            default_options: ObjMarshalOptions = ObjMarshalOptions(),
+
             default_obj_marshalers: ta.Dict[ta.Any, ObjMarshaler] = _DEFAULT_OBJ_MARSHALERS,  # noqa
             generic_mapping_types: ta.Dict[ta.Any, type] = _OBJ_MARSHALER_GENERIC_MAPPING_TYPES,  # noqa
             generic_iterable_types: ta.Dict[ta.Any, type] = _OBJ_MARSHALER_GENERIC_ITERABLE_TYPES,  # noqa
     ) -> None:
         super().__init__()
 
+        self._default_options = default_options
+
         self._obj_marshalers = dict(default_obj_marshalers)
         self._generic_mapping_types = generic_mapping_types
         self._generic_iterable_types = generic_iterable_types
@@ -1412,11 +2689,35 @@ class ObjMarshalerManager:
 
     #
 
-    def marshal_obj(self, o: ta.Any, ty: ta.Any = None) -> ta.Any:
-        return self.get_obj_marshaler(ty if ty is not None else type(o)).marshal(o)
-
-    def unmarshal_obj(self, o: ta.Any, ty: ta.Union[ta.Type[T], ta.Any]) -> T:
-        return self.get_obj_marshaler(ty).unmarshal(o)
+    def marshal_obj(
+            self,
+            o: ta.Any,
+            ty: ta.Any = None,
+            opts: ta.Optional[ObjMarshalOptions] = None,
+    ) -> ta.Any:
+        m = self.get_obj_marshaler(ty if ty is not None else type(o))
+        return m.marshal(o, opts or self._default_options)
+
+    def unmarshal_obj(
+            self,
+            o: ta.Any,
+            ty: ta.Union[ta.Type[T], ta.Any],
+            opts: ta.Optional[ObjMarshalOptions] = None,
+    ) -> T:
+        m = self.get_obj_marshaler(ty)
+        return m.unmarshal(o, opts or self._default_options)
+
+    def roundtrip_obj(
+            self,
+            o: ta.Any,
+            ty: ta.Any = None,
+            opts: ta.Optional[ObjMarshalOptions] = None,
+    ) -> ta.Any:
+        if ty is None:
+            ty = type(o)
+        m: ta.Any = self.marshal_obj(o, ty, opts)
+        u: ta.Any = self.unmarshal_obj(m, ty, opts)
+        return u
 
 
 ##
@@ -1449,10 +2750,102 @@ def check_runtime_version() -> None:
 
 
 ########################################
-# ../protocol.py
+# ../bootstrap.py
+
+
+@dc.dataclass(frozen=True)
+class MainBootstrap:
+    main_config: MainConfig = MainConfig()
+
+    remote_config: RemoteConfig = RemoteConfig()
+
+
+########################################
+# ../commands/execution.py
+
+
+CommandExecutorMap = ta.NewType('CommandExecutorMap', ta.Mapping[ta.Type[Command], CommandExecutor])
+
+
+class CommandExecutionService(CommandExecutor):
+    def __init__(
+            self,
+            *,
+            command_executors: CommandExecutorMap,
+    ) -> None:
+        super().__init__()
+
+        self._command_executors = command_executors
+
+    def execute(self, cmd: Command) -> Command.Output:
+        ce: CommandExecutor = self._command_executors[type(cmd)]
+        return ce.execute(cmd)
+
+
+########################################
+# ../commands/marshal.py
+
+
+def install_command_marshaling(
+        cmds: CommandNameMap,
+        msh: ObjMarshalerManager,
+) -> None:
+    for fn in [
+        lambda c: c,
+        lambda c: c.Output,
+    ]:
+        msh.register_opj_marshaler(
+            fn(Command),
+            PolymorphicObjMarshaler.of([
+                PolymorphicObjMarshaler.Impl(
+                    fn(cmd),
+                    name,
+                    msh.get_obj_marshaler(fn(cmd)),
+                )
+                for name, cmd in cmds.items()
+            ]),
+        )
+
+
+########################################
+# ../deploy/command.py
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DeployCommand(Command['DeployCommand.Output']):
+    @dc.dataclass(frozen=True)
+    class Output(Command.Output):
+        pass
+
+
+##
+
+
+class DeployCommandExecutor(CommandExecutor[DeployCommand, DeployCommand.Output]):
+    def execute(self, cmd: DeployCommand) -> DeployCommand.Output:
+        return DeployCommand.Output()
+
+
+########################################
+# ../marshal.py
+
+
+@dc.dataclass(frozen=True)
+class ObjMarshalerInstaller:
+    fn: ta.Callable[[ObjMarshalerManager], None]
+
+
+ObjMarshalerInstallers = ta.NewType('ObjMarshalerInstallers', ta.Sequence[ObjMarshalerInstaller])
+
+
+########################################
+# ../remote/channel.py
 
 
-class Channel:
+class RemoteChannel:
     def __init__(
             self,
             input: ta.IO,  # noqa
@@ -1466,6 +2859,9 @@ class Channel:
         self._output = output
         self._msh = msh
 
+    def set_marshaler(self, msh: ObjMarshalerManager) -> None:
+        self._msh = msh
+
     def send_obj(self, o: ta.Any, ty: ta.Any = None) -> None:
         j = json_dumps_compact(self._msh.marshal_obj(o, ty))
         d = j.encode('utf-8')
@@ -1474,7 +2870,7 @@ class Channel:
         self._output.write(d)
         self._output.flush()
 
-    def recv_obj(self, ty: ta.Any) -> ta.Any:
+    def recv_obj(self, ty: ta.Type[T]) -> ta.Optional[T]:
         d = self._input.read(4)
         if not d:
             return None
@@ -1695,28 +3091,19 @@ class SubprocessCommandExecutor(CommandExecutor[SubprocessCommand, SubprocessCom
 
 
 ########################################
-# ../spawning.py
+# ../remote/spawning.py
 
 
-class PySpawner:
-    DEFAULT_PYTHON = 'python3'
+class RemoteSpawning:
+    @dc.dataclass(frozen=True)
+    class Target:
+        shell: ta.Optional[str] = None
+        shell_quote: bool = False
 
-    def __init__(
-            self,
-            src: str,
-            *,
-            shell: ta.Optional[str] = None,
-            shell_quote: bool = False,
-            python: str = DEFAULT_PYTHON,
-            stderr: ta.Optional[SubprocessChannelOption] = None,
-    ) -> None:
-        super().__init__()
+        DEFAULT_PYTHON: ta.ClassVar[str] = 'python3'
+        python: str = DEFAULT_PYTHON
 
-        self._src = src
-        self._shell = shell
-        self._shell_quote = shell_quote
-        self._python = python
-        self._stderr = stderr
+        stderr: ta.Optional[str] = None  # SubprocessChannelOption
 
     #
 
@@ -1724,20 +3111,24 @@ class PySpawner:
         cmd: ta.Sequence[str]
         shell: bool
 
-    def _prepare_cmd(self) -> _PreparedCmd:
-        if self._shell is not None:
-            sh_src = f'{self._python} -c {shlex.quote(self._src)}'
-            if self._shell_quote:
+    def _prepare_cmd(
+            self,
+            tgt: Target,
+            src: str,
+    ) -> _PreparedCmd:
+        if tgt.shell is not None:
+            sh_src = f'{tgt.python} -c {shlex.quote(src)}'
+            if tgt.shell_quote:
                 sh_src = shlex.quote(sh_src)
-            sh_cmd = f'{self._shell} {sh_src}'
-            return PySpawner._PreparedCmd(
+            sh_cmd = f'{tgt.shell} {sh_src}'
+            return RemoteSpawning._PreparedCmd(
                 cmd=[sh_cmd],
                 shell=True,
             )
 
         else:
-            return PySpawner._PreparedCmd(
-                cmd=[self._python, '-c', self._src],
+            return RemoteSpawning._PreparedCmd(
+                cmd=[tgt.python, '-c', src],
                 shell=False,
             )
 
@@ -1752,23 +3143,28 @@ class PySpawner:
     @contextlib.contextmanager
     def spawn(
             self,
+            tgt: Target,
+            src: str,
             *,
             timeout: ta.Optional[float] = None,
     ) -> ta.Generator[Spawned, None, None]:
-        pc = self._prepare_cmd()
+        pc = self._prepare_cmd(tgt, src)
 
         with subprocess.Popen(
             subprocess_maybe_shell_wrap_exec(*pc.cmd),
             shell=pc.shell,
             stdin=subprocess.PIPE,
             stdout=subprocess.PIPE,
-            stderr=SUBPROCESS_CHANNEL_OPTION_VALUES[self._stderr] if self._stderr is not None else None,
+            stderr=(
+                SUBPROCESS_CHANNEL_OPTION_VALUES[ta.cast(SubprocessChannelOption, tgt.stderr)]
+                if tgt.stderr is not None else None
+            ),
         ) as proc:
             stdin = check_not_none(proc.stdin)
             stdout = check_not_none(proc.stdout)
 
             try:
-                yield PySpawner.Spawned(
+                yield RemoteSpawning.Spawned(
                     stdin=stdin,
                     stdout=stdout,
                     stderr=proc.stderr,
@@ -1784,59 +3180,371 @@ class PySpawner:
 
 
 ########################################
-# main.py
+# ../commands/inject.py
 
 
 ##
 
 
-_COMMAND_TYPES = {
-    'subprocess': SubprocessCommand,
-}
+def bind_command(
+        command_cls: ta.Type[Command],
+        executor_cls: ta.Optional[ta.Type[CommandExecutor]],
+) -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind(CommandRegistration(command_cls), array=True),
+    ]
+
+    if executor_cls is not None:
+        lst.extend([
+            inj.bind(executor_cls, singleton=True),
+            inj.bind(CommandExecutorRegistration(command_cls, executor_cls), array=True),
+        ])
+
+    return inj.as_bindings(*lst)
 
 
 ##
 
 
-def register_command_marshaling(msh: ObjMarshalerManager) -> None:
-    for fn in [
-        lambda c: c,
-        lambda c: c.Output,
+@dc.dataclass(frozen=True)
+class _FactoryCommandExecutor(CommandExecutor):
+    factory: ta.Callable[[], CommandExecutor]
+
+    def execute(self, i: Command) -> Command.Output:
+        return self.factory().execute(i)
+
+
+##
+
+
+def bind_commands(
+        *,
+        main_config: MainConfig,
+) -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind_array(CommandRegistration),
+        inj.bind_array_type(CommandRegistration, CommandRegistrations),
+
+        inj.bind_array(CommandExecutorRegistration),
+        inj.bind_array_type(CommandExecutorRegistration, CommandExecutorRegistrations),
+
+        inj.bind(build_command_name_map, singleton=True),
+    ]
+
+    #
+
+    def provide_obj_marshaler_installer(cmds: CommandNameMap) -> ObjMarshalerInstaller:
+        return ObjMarshalerInstaller(functools.partial(install_command_marshaling, cmds))
+
+    lst.append(inj.bind(provide_obj_marshaler_installer, array=True))
+
+    #
+
+    def provide_command_executor_map(
+            injector: Injector,
+            crs: CommandExecutorRegistrations,
+    ) -> CommandExecutorMap:
+        dct: ta.Dict[ta.Type[Command], CommandExecutor] = {}
+
+        cr: CommandExecutorRegistration
+        for cr in crs:
+            if cr.command_cls in dct:
+                raise KeyError(cr.command_cls)
+
+            factory = functools.partial(injector.provide, cr.executor_cls)
+            if main_config.debug:
+                ce = factory()
+            else:
+                ce = _FactoryCommandExecutor(factory)
+
+            dct[cr.command_cls] = ce
+
+        return CommandExecutorMap(dct)
+
+    lst.extend([
+        inj.bind(provide_command_executor_map, singleton=True),
+
+        inj.bind(CommandExecutionService, singleton=True, eager=main_config.debug),
+        inj.bind(CommandExecutor, to_key=CommandExecutionService),
+    ])
+
+    #
+
+    for command_cls, executor_cls in [
+        (SubprocessCommand, SubprocessCommandExecutor),
     ]:
-        msh.register_opj_marshaler(
-            fn(Command),
-            PolymorphicObjMarshaler.of([
-                PolymorphicObjMarshaler.Impl(
-                    fn(cty),
-                    k,
-                    msh.get_obj_marshaler(fn(cty)),
-                )
-                for k, cty in _COMMAND_TYPES.items()
-            ]),
-        )
+        lst.append(bind_command(command_cls, executor_cls))
+
+    #
+
+    return inj.as_bindings(*lst)
 
 
-register_command_marshaling(OBJ_MARSHALER_MANAGER)
+########################################
+# ../remote/execution.py
 
 
 ##
 
 
-def _remote_main() -> None:
+def _remote_execution_main() -> None:
     rt = pyremote_bootstrap_finalize()  # noqa
-    chan = Channel(rt.input, rt.output)
+
+    chan = RemoteChannel(
+        rt.input,
+        rt.output,
+    )
+
+    bs = check_not_none(chan.recv_obj(MainBootstrap))
+
+    if (prd := bs.remote_config.pycharm_remote_debug) is not None:
+        pycharm_debug_connect(prd)
+
+    injector = main_bootstrap(bs)
+
+    chan.set_marshaler(injector[ObjMarshalerManager])
+
+    ce = injector[CommandExecutor]
 
     while True:
         i = chan.recv_obj(Command)
         if i is None:
             break
 
-        if isinstance(i, SubprocessCommand):
-            o = SubprocessCommandExecutor().execute(i)  # noqa
+        r = ce.try_execute(
+            i,
+            log=log,
+            omit_exc_object=True,
+        )
+
+        chan.send_obj(r)
+
+
+##
+
+
+@dc.dataclass()
+class RemoteCommandError(Exception):
+    e: CommandException
+
+
+class RemoteCommandExecutor(CommandExecutor):
+    def __init__(self, chan: RemoteChannel) -> None:
+        super().__init__()
+
+        self._chan = chan
+
+    def _remote_execute(self, cmd: Command) -> CommandOutputOrException:
+        self._chan.send_obj(cmd, Command)
+
+        if (r := self._chan.recv_obj(CommandOutputOrExceptionData)) is None:
+            raise EOFError
+
+        return r
+
+    # @ta.override
+    def execute(self, cmd: Command) -> Command.Output:
+        r = self._remote_execute(cmd)
+        if (e := r.exception) is not None:
+            raise RemoteCommandError(e)
+        else:
+            return check_not_none(r.output)
+
+    # @ta.override
+    def try_execute(
+            self,
+            cmd: Command,
+            *,
+            log: ta.Optional[logging.Logger] = None,
+            omit_exc_object: bool = False,
+    ) -> CommandOutputOrException:
+        try:
+            r = self._remote_execute(cmd)
+
+        except Exception as e:  # noqa
+            if log is not None:
+                log.exception('Exception executing remote command: %r', type(cmd))
+
+            return CommandOutputOrExceptionData(exception=CommandException.of(
+                e,
+                omit_exc_object=omit_exc_object,
+                cmd=cmd,
+            ))
+
         else:
-            raise TypeError(i)
+            return r
+
+
+##
+
+
+class RemoteExecution:
+    def __init__(
+            self,
+            *,
+            spawning: RemoteSpawning,
+            msh: ObjMarshalerManager,
+            payload_file: ta.Optional[RemoteExecutionPayloadFile] = None,
+    ) -> None:
+        super().__init__()
+
+        self._spawning = spawning
+        self._msh = msh
+        self._payload_file = payload_file
+
+    #
+
+    @cached_nullary
+    def _payload_src(self) -> str:
+        return get_remote_payload_src(file=self._payload_file)
+
+    @cached_nullary
+    def _remote_src(self) -> ta.Sequence[str]:
+        return [
+            self._payload_src(),
+            '_remote_execution_main()',
+        ]
+
+    @cached_nullary
+    def _spawn_src(self) -> str:
+        return pyremote_build_bootstrap_cmd(__package__ or 'manage')
+
+    #
+
+    @contextlib.contextmanager
+    def connect(
+            self,
+            tgt: RemoteSpawning.Target,
+            bs: MainBootstrap,
+    ) -> ta.Generator[RemoteCommandExecutor, None, None]:
+        spawn_src = self._spawn_src()
+        remote_src = self._remote_src()
+
+        with self._spawning.spawn(
+                tgt,
+                spawn_src,
+        ) as proc:
+            res = PyremoteBootstrapDriver(  # noqa
+                remote_src,
+                PyremoteBootstrapOptions(
+                    debug=bs.main_config.debug,
+                ),
+            ).run(
+                proc.stdout,
+                proc.stdin,
+            )
+
+            chan = RemoteChannel(
+                proc.stdout,
+                proc.stdin,
+                msh=self._msh,
+            )
+
+            chan.send_obj(bs)
+
+            yield RemoteCommandExecutor(chan)
+
+
+########################################
+# ../deploy/inject.py
 
-        chan.send_obj(o, Command.Output)
+
+def bind_deploy(
+) -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        bind_command(DeployCommand, DeployCommandExecutor),
+    ]
+
+    return inj.as_bindings(*lst)
+
+
+########################################
+# ../remote/inject.py
+
+
+def bind_remote(
+        *,
+        remote_config: RemoteConfig,
+) -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind(remote_config),
+
+        inj.bind(RemoteSpawning, singleton=True),
+
+        inj.bind(RemoteExecution, singleton=True),
+    ]
+
+    if (pf := remote_config.payload_file) is not None:
+        lst.append(inj.bind(pf, to_key=RemoteExecutionPayloadFile))
+
+    return inj.as_bindings(*lst)
+
+
+########################################
+# ../inject.py
+
+
+##
+
+
+def bind_main(
+        *,
+        main_config: MainConfig,
+        remote_config: RemoteConfig,
+) -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind(main_config),
+
+        bind_commands(
+            main_config=main_config,
+        ),
+
+        bind_remote(
+            remote_config=remote_config,
+        ),
+
+        bind_deploy(),
+    ]
+
+    #
+
+    def build_obj_marshaler_manager(insts: ObjMarshalerInstallers) -> ObjMarshalerManager:
+        msh = ObjMarshalerManager()
+        inst: ObjMarshalerInstaller
+        for inst in insts:
+            inst.fn(msh)
+        return msh
+
+    lst.extend([
+        inj.bind(build_obj_marshaler_manager, singleton=True),
+
+        inj.bind_array(ObjMarshalerInstaller),
+        inj.bind_array_type(ObjMarshalerInstaller, ObjMarshalerInstallers),
+    ])
+
+    #
+
+    return inj.as_bindings(*lst)
+
+
+########################################
+# ../bootstrap_.py
+
+
+def main_bootstrap(bs: MainBootstrap) -> Injector:
+    if (log_level := bs.main_config.log_level) is not None:
+        configure_standard_logging(log_level)
+
+    injector = inj.create_injector(bind_main(  # noqa
+        main_config=bs.main_config,
+        remote_config=bs.remote_config,
+    ))
+
+    return injector
+
+
+########################################
+# main.py
 
 
 ##
@@ -1853,50 +3561,72 @@ def _main() -> None:
     parser.add_argument('-q', '--shell-quote', action='store_true')
     parser.add_argument('--python', default='python3')
 
+    parser.add_argument('--pycharm-debug-port', type=int)
+    parser.add_argument('--pycharm-debug-host')
+    parser.add_argument('--pycharm-debug-version')
+
     parser.add_argument('--debug', action='store_true')
 
+    parser.add_argument('--local', action='store_true')
+
+    parser.add_argument('command', nargs='+')
+
     args = parser.parse_args()
 
     #
 
-    payload_src = get_payload_src(file=args._payload_file)  # noqa
+    bs = MainBootstrap(
+        main_config=MainConfig(
+            log_level='DEBUG' if args.debug else 'INFO',
 
-    remote_src = '\n\n'.join([
-        '__name__ = "__remote__"',
-        payload_src,
-        '_remote_main()',
-    ])
+            debug=bool(args.debug),
+        ),
 
-    #
+        remote_config=RemoteConfig(
+            payload_file=args._payload_file,  # noqa
 
-    spawner = PySpawner(
-        pyremote_build_bootstrap_cmd(__package__ or 'manage'),
-        shell=args.shell,
-        shell_quote=args.shell_quote,
-        python=args.python,
+            pycharm_remote_debug=PycharmRemoteDebug(
+                port=args.pycharm_debug_port,
+                host=args.pycharm_debug_host,
+                install_version=args.pycharm_debug_version,
+            ) if args.pycharm_debug_port is not None else None,
+        ),
     )
 
-    with spawner.spawn() as proc:
-        res = PyremoteBootstrapDriver(  # noqa
-            remote_src,
-            PyremoteBootstrapOptions(
-                debug=args.debug,
-            ),
-        ).run(proc.stdout, proc.stdin)
+    injector = main_bootstrap(
+        bs,
+    )
 
-        chan = Channel(proc.stdout, proc.stdin)
+    #
 
-        #
+    cmds: ta.List[Command] = []
+    for c in args.command:
+        if c == 'deploy':
+            cmds.append(DeployCommand())
+        else:
+            cmds.append(SubprocessCommand([c]))
+
+    #
+
+    with contextlib.ExitStack() as es:
+        ce: CommandExecutor
+
+        if args.local:
+            ce = injector[CommandExecutor]
+
+        else:
+            tgt = RemoteSpawning.Target(
+                shell=args.shell,
+                shell_quote=args.shell_quote,
+                python=args.python,
+            )
 
-        for ci in [
-            SubprocessCommand(['python3', '-'], input=b'print(1)\n'),
-            SubprocessCommand(['uname']),
-        ]:
-            chan.send_obj(ci, Command)
+            ce = es.enter_context(injector[RemoteExecution].connect(tgt, bs))  # noqa
 
-            o = chan.recv_obj(Command.Output)
+        for cmd in cmds:
+            r = ce.try_execute(cmd)
 
-            print(o)
+            print(injector[ObjMarshalerManager].marshal_obj(r, opts=ObjMarshalOptions(raw_bytes=True)))
 
 
 if __name__ == '__main__':