omdev 0.0.0.dev178__py3-none-any.whl → 0.0.0.dev179__py3-none-any.whl

omdev/scripts/interp.py

@@ -17,6 +17,7 @@ import asyncio.base_subprocess
 import asyncio.subprocess
 import collections
 import contextlib
+import contextvars
 import dataclasses as dc
 import datetime
 import functools
@@ -35,6 +36,7 @@ import threading
 import time
 import types
 import typing as ta
+import weakref
 
 
 ########################################
@@ -75,6 +77,16 @@ UnparsedVersion = ta.Union['Version', str]
 UnparsedVersionVar = ta.TypeVar('UnparsedVersionVar', bound=UnparsedVersion)
 CallableVersionOperator = ta.Callable[['Version', str], bool]
 
+# ../../omlish/argparse/cli.py
+ArgparseCommandFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
+
+# ../../omlish/lite/inject.py
+U = ta.TypeVar('U')
+InjectorKeyCls = ta.Union[type, ta.NewType]
+InjectorProviderFn = ta.Callable[['Injector'], ta.Any]
+InjectorProviderFnMap = ta.Mapping['InjectorKey', 'InjectorProviderFn']
+InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
+
 # ../../omlish/subprocesses.py
 SubprocessChannelOption = ta.Literal['pipe', 'stdout', 'devnull']  # ta.TypeAlias
 
@@ -1045,6 +1057,50 @@ json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON
 log = logging.getLogger(__name__)
 
 
+########################################
+# ../../../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/reflect.py
 
@@ -1864,267 +1920,1637 @@ class SpecifierSet(BaseSpecifier):
 
 
 ########################################
-# ../../../omlish/lite/runtime.py
+# ../../../omlish/argparse/cli.py
+"""
+TODO:
+ - default command
+ - auto match all underscores to hyphens
+ - pre-run, post-run hooks
+ - exitstack?
+"""
 
 
-@cached_nullary
-def is_debugger_attached() -> bool:
-    return any(frame[1].endswith('pydevd.py') for frame in inspect.stack())
+##
 
 
-LITE_REQUIRED_PYTHON_VERSION = (3, 8)
+@dc.dataclass(eq=False)
+class ArgparseArg:
+    args: ta.Sequence[ta.Any]
+    kwargs: ta.Mapping[str, ta.Any]
+    dest: ta.Optional[str] = None
 
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        return getattr(instance.args, self.dest)  # type: ignore
 
-def check_lite_runtime_version() -> None:
-    if sys.version_info < LITE_REQUIRED_PYTHON_VERSION:
-        raise OSError(f'Requires python {LITE_REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
 
+def argparse_arg(*args, **kwargs) -> ArgparseArg:
+    return ArgparseArg(args, kwargs)
 
-########################################
-# ../../../omlish/logs/json.py
-"""
-TODO:
- - translate json keys
-"""
 
+#
 
-class JsonLogFormatter(logging.Formatter):
-    KEYS: ta.Mapping[str, bool] = {
-        'name': False,
-        'msg': False,
-        'args': False,
-        'levelname': False,
-        'levelno': False,
-        'pathname': False,
-        'filename': False,
-        'module': False,
-        'exc_info': True,
-        'exc_text': True,
-        'stack_info': True,
-        'lineno': False,
-        'funcName': False,
-        'created': False,
-        'msecs': False,
-        'relativeCreated': False,
-        'thread': False,
-        'threadName': False,
-        'processName': False,
-        'process': False,
-    }
 
-    def __init__(
-            self,
-            *args: ta.Any,
-            json_dumps: ta.Optional[ta.Callable[[ta.Any], str]] = None,
-            **kwargs: ta.Any,
-    ) -> None:
-        super().__init__(*args, **kwargs)
+@dc.dataclass(eq=False)
+class ArgparseCommand:
+    name: str
+    fn: ArgparseCommandFn
+    args: ta.Sequence[ArgparseArg] = ()  # noqa
+
+    # _: dc.KW_ONLY
+
+    aliases: ta.Optional[ta.Sequence[str]] = None
+    parent: ta.Optional['ArgparseCommand'] = None
+    accepts_unknown: bool = False
+
+    def __post_init__(self) -> None:
+        def check_name(s: str) -> None:
+            check.isinstance(s, str)
+            check.not_in('_', s)
+            check.not_empty(s)
+        check_name(self.name)
+        check.not_isinstance(self.aliases, str)
+        for a in self.aliases or []:
+            check_name(a)
+
+        check.arg(callable(self.fn))
+        check.arg(all(isinstance(a, ArgparseArg) for a in self.args))
+        check.isinstance(self.parent, (ArgparseCommand, type(None)))
+        check.isinstance(self.accepts_unknown, bool)
+
+        functools.update_wrapper(self, self.fn)
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        return dc.replace(self, fn=self.fn.__get__(instance, owner))  # noqa
+
+    def __call__(self, *args, **kwargs) -> ta.Optional[int]:
+        return self.fn(*args, **kwargs)
+
+
+def argparse_command(
+        *args: ArgparseArg,
+        name: ta.Optional[str] = None,
+        aliases: ta.Optional[ta.Iterable[str]] = None,
+        parent: ta.Optional[ArgparseCommand] = None,
+        accepts_unknown: bool = False,
+) -> ta.Any:  # ta.Callable[[ArgparseCommandFn], ArgparseCommand]:  # FIXME
+    for arg in args:
+        check.isinstance(arg, ArgparseArg)
+    check.isinstance(name, (str, type(None)))
+    check.isinstance(parent, (ArgparseCommand, type(None)))
+    check.not_isinstance(aliases, str)
+
+    def inner(fn):
+        return ArgparseCommand(
+            (name if name is not None else fn.__name__).replace('_', '-'),
+            fn,
+            args,
+            aliases=tuple(aliases) if aliases is not None else None,
+            parent=parent,
+            accepts_unknown=accepts_unknown,
+        )
 
-        if json_dumps is None:
-            json_dumps = json_dumps_compact
-        self._json_dumps = json_dumps
+    return inner
 
-    def format(self, record: logging.LogRecord) -> str:
-        dct = {
-            k: v
-            for k, o in self.KEYS.items()
-            for v in [getattr(record, k)]
-            if not (o and v is None)
-        }
-        return self._json_dumps(dct)
 
+##
 
-########################################
-# ../types.py
 
+def _get_argparse_arg_ann_kwargs(ann: ta.Any) -> ta.Mapping[str, ta.Any]:
+    if ann is str:
+        return {}
+    elif ann is int:
+        return {'type': int}
+    elif ann is bool:
+        return {'action': 'store_true'}
+    elif ann is list:
+        return {'action': 'append'}
+    elif is_optional_alias(ann):
+        return _get_argparse_arg_ann_kwargs(get_optional_alias_arg(ann))
+    else:
+        raise TypeError(ann)
 
-# See https://peps.python.org/pep-3149/
-INTERP_OPT_GLYPHS_BY_ATTR: ta.Mapping[str, str] = collections.OrderedDict([
-    ('debug', 'd'),
-    ('threaded', 't'),
-])
 
-INTERP_OPT_ATTRS_BY_GLYPH: ta.Mapping[str, str] = collections.OrderedDict(
-    (g, a) for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items()
-)
+class _ArgparseCliAnnotationBox:
+    def __init__(self, annotations: ta.Mapping[str, ta.Any]) -> None:
+        super().__init__()
+        self.__annotations__ = annotations  # type: ignore
 
 
-@dc.dataclass(frozen=True)
-class InterpOpts:
-    threaded: bool = False
-    debug: bool = False
+class ArgparseCli:
+    def __init__(self, argv: ta.Optional[ta.Sequence[str]] = None) -> None:
+        super().__init__()
 
-    def __str__(self) -> str:
-        return ''.join(g for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items() if getattr(self, a))
+        self._argv = argv if argv is not None else sys.argv[1:]
 
-    @classmethod
-    def parse(cls, s: str) -> 'InterpOpts':
-        return cls(**{INTERP_OPT_ATTRS_BY_GLYPH[g]: True for g in s})
+        self._args, self._unknown_args = self.get_parser().parse_known_args(self._argv)
 
-    @classmethod
-    def parse_suffix(cls, s: str) -> ta.Tuple[str, 'InterpOpts']:
-        kw = {}
-        while s and (a := INTERP_OPT_ATTRS_BY_GLYPH.get(s[-1])):
-            s, kw[a] = s[:-1], True
-        return s, cls(**kw)
+    #
 
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
 
-@dc.dataclass(frozen=True)
-class InterpVersion:
-    version: Version
-    opts: InterpOpts
+        ns = cls.__dict__
+        objs = {}
+        mro = cls.__mro__[::-1]
+        for bns in [bcls.__dict__ for bcls in reversed(mro)] + [ns]:
+            bseen = set()  # type: ignore
+            for k, v in bns.items():
+                if isinstance(v, (ArgparseCommand, ArgparseArg)):
+                    check.not_in(v, bseen)
+                    bseen.add(v)
+                    objs[k] = v
+                elif k in objs:
+                    del [k]
 
-    def __str__(self) -> str:
-        return str(self.version) + str(self.opts)
+        #
 
-    @classmethod
-    def parse(cls, s: str) -> 'InterpVersion':
-        s, o = InterpOpts.parse_suffix(s)
-        v = Version(s)
-        return cls(
-            version=v,
-            opts=o,
-        )
+        anns = ta.get_type_hints(_ArgparseCliAnnotationBox({
+            **{k: v for bcls in reversed(mro) for k, v in getattr(bcls, '__annotations__', {}).items()},
+            **ns.get('__annotations__', {}),
+        }), globalns=ns.get('__globals__', {}))
 
-    @classmethod
-    def try_parse(cls, s: str) -> ta.Optional['InterpVersion']:
-        try:
-            return cls.parse(s)
-        except (KeyError, InvalidVersion):
-            return None
+        #
+
+        if '_parser' in ns:
+            parser = check.isinstance(ns['_parser'], argparse.ArgumentParser)
+        else:
+            parser = argparse.ArgumentParser()
+            setattr(cls, '_parser', parser)
 
+        #
 
-@dc.dataclass(frozen=True)
-class InterpSpecifier:
-    specifier: Specifier
-    opts: InterpOpts
+        subparsers = parser.add_subparsers()
+
+        for att, obj in objs.items():
+            if isinstance(obj, ArgparseCommand):
+                if obj.parent is not None:
+                    raise NotImplementedError
+
+                for cn in [obj.name, *(obj.aliases or [])]:
+                    subparser = subparsers.add_parser(cn)
+
+                    for arg in (obj.args or []):
+                        if (
+                                len(arg.args) == 1 and
+                                isinstance(arg.args[0], str) and
+                                not (n := check.isinstance(arg.args[0], str)).startswith('-') and
+                                'metavar' not in arg.kwargs
+                        ):
+                            subparser.add_argument(
+                                n.replace('-', '_'),
+                                **arg.kwargs,
+                                metavar=n,
+                            )
+                        else:
+                            subparser.add_argument(*arg.args, **arg.kwargs)
+
+                    subparser.set_defaults(_cmd=obj)
+
+            elif isinstance(obj, ArgparseArg):
+                if att in anns:
+                    ann_kwargs = _get_argparse_arg_ann_kwargs(anns[att])
+                    obj.kwargs = {**ann_kwargs, **obj.kwargs}
+
+                if not obj.dest:
+                    if 'dest' in obj.kwargs:
+                        obj.dest = obj.kwargs['dest']
+                    else:
+                        obj.dest = obj.kwargs['dest'] = att  # type: ignore
+
+                parser.add_argument(*obj.args, **obj.kwargs)
 
-    def __str__(self) -> str:
-        return str(self.specifier) + str(self.opts)
+            else:
+                raise TypeError(obj)
+
+    #
+
+    _parser: ta.ClassVar[argparse.ArgumentParser]
 
     @classmethod
-    def parse(cls, s: str) -> 'InterpSpecifier':
-        s, o = InterpOpts.parse_suffix(s)
-        if not any(s.startswith(o) for o in Specifier.OPERATORS):
-            s = '~=' + s
-            if s.count('.') < 2:
-                s += '.0'
-        return cls(
-            specifier=Specifier(s),
-            opts=o,
-        )
+    def get_parser(cls) -> argparse.ArgumentParser:
+        return cls._parser
 
-    def contains(self, iv: InterpVersion) -> bool:
-        return self.specifier.contains(iv.version) and self.opts == iv.opts
+    @property
+    def argv(self) -> ta.Sequence[str]:
+        return self._argv
 
-    def __contains__(self, iv: InterpVersion) -> bool:
-        return self.contains(iv)
+    @property
+    def args(self) -> argparse.Namespace:
+        return self._args
 
+    @property
+    def unknown_args(self) -> ta.Sequence[str]:
+        return self._unknown_args
 
-@dc.dataclass(frozen=True)
-class Interp:
-    exe: str
-    version: InterpVersion
+    #
 
+    def _bind_cli_cmd(self, cmd: ArgparseCommand) -> ta.Callable:
+        return cmd.__get__(self, type(self))
 
-########################################
-# ../../../omlish/logs/standard.py
-"""
-TODO:
- - structured
- - prefixed
- - debug
- - optional noisy? noisy will never be lite - some kinda configure_standard callback mechanism?
-"""
+    def prepare_cli_run(self) -> ta.Optional[ta.Callable]:
+        cmd = getattr(self.args, '_cmd', None)
 
+        if self._unknown_args and not (cmd is not None and cmd.accepts_unknown):
+            msg = f'unrecognized arguments: {" ".join(self._unknown_args)}'
+            if (parser := self.get_parser()).exit_on_error:  # type: ignore
+                parser.error(msg)
+            else:
+                raise argparse.ArgumentError(None, msg)
 
-##
+        if cmd is None:
+            self.get_parser().print_help()
+            return None
 
+        return self._bind_cli_cmd(cmd)
 
-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'),
-]
+    #
 
+    def cli_run(self) -> ta.Optional[int]:
+        if (fn := self.prepare_cli_run()) is None:
+            return 0
 
-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)
+        return fn()
 
-    converter = datetime.datetime.fromtimestamp  # type: ignore
+    def cli_run_and_exit(self) -> ta.NoReturn:
+        sys.exit(rc if isinstance(rc := self.cli_run(), int) else 0)
 
-    def formatTime(self, record, datefmt=None):
-        ct = self.converter(record.created)  # type: ignore
-        if datefmt:
-            return ct.strftime(datefmt)  # noqa
+    def __call__(self, *, exit: bool = False) -> ta.Optional[int]:  # noqa
+        if exit:
+            return self.cli_run_and_exit()
         else:
-            t = ct.strftime('%Y-%m-%d %H:%M:%S')
-            return '%s.%03d' % (t, record.msecs)  # noqa
+            return self.cli_run()
 
+    #
 
-##
+    async def async_cli_run(self) -> ta.Optional[int]:
+        if (fn := self.prepare_cli_run()) is None:
+            return 0
 
+        return await fn()
 
-class StandardConfiguredLogHandler(ProxyLogHandler):
-    def __init_subclass__(cls, **kwargs):
-        raise TypeError('This class serves only as a marker and should not be subclassed.')
 
+########################################
+# ../../../omlish/lite/inject.py
 
-##
 
+###
+# types
 
-@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
+@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
 
-    else:
-        raise Exception("Can't find lock in logging module")
+    tag: ta.Any = None
+    array: bool = False
 
 
-def configure_standard_logging(
-        level: ta.Union[int, str] = logging.INFO,
-        *,
-        json: bool = False,
-        target: ta.Optional[logging.Logger] = None,
-        force: bool = False,
-        handler_factory: ta.Optional[ta.Callable[[], logging.Handler]] = None,
-) -> ta.Optional[StandardConfiguredLogHandler]:
-    with _locking_logging_module_lock():
-        if target is None:
-            target = logging.root
+def is_valid_injector_key_cls(cls: ta.Any) -> bool:
+    return isinstance(cls, type) or is_new_type(cls)
 
-        #
 
-        if not force:
-            if any(isinstance(h, StandardConfiguredLogHandler) for h in list(target.handlers)):
-                return None
+def check_valid_injector_key_cls(cls: T) -> T:
+    if not is_valid_injector_key_cls(cls):
+        raise TypeError(cls)
+    return cls
 
-        #
 
-        if handler_factory is not None:
-            handler = handler_factory()
-        else:
-            handler = logging.StreamHandler()
+##
 
-        #
 
-        formatter: logging.Formatter
+class InjectorProvider(abc.ABC):
+    @abc.abstractmethod
+    def provider_fn(self) -> InjectorProviderFn:
+        raise NotImplementedError
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class InjectorBinding:
+    key: InjectorKey
+    provider: InjectorProvider
+
+    def __post_init__(self) -> None:
+        check.isinstance(self.key, InjectorKey)
+        check.isinstance(self.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,
+    )
+
+
+##
+
+
+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
+
+
+###
+# overrides
+
+
+@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)
+
+
+###
+# scopes
+
+
+class InjectorScope(abc.ABC):  # noqa
+    def __init__(
+            self,
+            *,
+            _i: Injector,
+    ) -> None:
+        check.not_in(abc.ABC, type(self).__bases__)
+
+        super().__init__()
+
+        self._i = _i
+
+        all_seeds: ta.Iterable[_InjectorScopeSeed] = self._i.provide(InjectorKey(_InjectorScopeSeed, array=True))
+        self._sks = {s.k for s in all_seeds if s.sc is type(self)}
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class State:
+        seeds: ta.Dict[InjectorKey, ta.Any]
+        provisions: ta.Dict[InjectorKey, ta.Any] = dc.field(default_factory=dict)
+
+    def new_state(self, vs: ta.Mapping[InjectorKey, ta.Any]) -> State:
+        vs = dict(vs)
+        check.equal(set(vs.keys()), self._sks)
+        return InjectorScope.State(vs)
+
+    #
+
+    @abc.abstractmethod
+    def state(self) -> State:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def enter(self, vs: ta.Mapping[InjectorKey, ta.Any]) -> ta.ContextManager[None]:
+        raise NotImplementedError
+
+
+class ExclusiveInjectorScope(InjectorScope, abc.ABC):
+    _st: ta.Optional[InjectorScope.State] = None
+
+    def state(self) -> InjectorScope.State:
+        return check.not_none(self._st)
+
+    @contextlib.contextmanager
+    def enter(self, vs: ta.Mapping[InjectorKey, ta.Any]) -> ta.Iterator[None]:
+        check.none(self._st)
+        self._st = self.new_state(vs)
+        try:
+            yield
+        finally:
+            self._st = None
+
+
+class ContextvarInjectorScope(InjectorScope, abc.ABC):
+    _cv: contextvars.ContextVar
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+        check.not_in(abc.ABC, cls.__bases__)
+        check.state(not hasattr(cls, '_cv'))
+        cls._cv = contextvars.ContextVar(f'{cls.__name__}_cv')
+
+    def state(self) -> InjectorScope.State:
+        return self._cv.get()
+
+    @contextlib.contextmanager
+    def enter(self, vs: ta.Mapping[InjectorKey, ta.Any]) -> ta.Iterator[None]:
+        try:
+            self._cv.get()
+        except LookupError:
+            pass
+        else:
+            raise RuntimeError(f'Scope already entered: {self}')
+        st = self.new_state(vs)
+        tok = self._cv.set(st)
+        try:
+            yield
+        finally:
+            self._cv.reset(tok)
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class ScopedInjectorProvider(InjectorProvider):
+    p: InjectorProvider
+    k: InjectorKey
+    sc: ta.Type[InjectorScope]
+
+    def __post_init__(self) -> None:
+        check.isinstance(self.p, InjectorProvider)
+        check.isinstance(self.k, InjectorKey)
+        check.issubclass(self.sc, InjectorScope)
+
+    def provider_fn(self) -> InjectorProviderFn:
+        def pfn(i: Injector) -> ta.Any:
+            st = i[self.sc].state()
+            try:
+                return st.provisions[self.k]
+            except KeyError:
+                pass
+            v = ufn(i)
+            st.provisions[self.k] = v
+            return v
+
+        ufn = self.p.provider_fn()
+        return pfn
+
+
+@dc.dataclass(frozen=True)
+class _ScopeSeedInjectorProvider(InjectorProvider):
+    k: InjectorKey
+    sc: ta.Type[InjectorScope]
+
+    def __post_init__(self) -> None:
+        check.isinstance(self.k, InjectorKey)
+        check.issubclass(self.sc, InjectorScope)
+
+    def provider_fn(self) -> InjectorProviderFn:
+        def pfn(i: Injector) -> ta.Any:
+            st = i[self.sc].state()
+            return st.seeds[self.k]
+        return pfn
+
+
+def bind_injector_scope(sc: ta.Type[InjectorScope]) -> InjectorBindingOrBindings:
+    return InjectorBinder.bind(sc, singleton=True)
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class _InjectorScopeSeed:
+    sc: ta.Type['InjectorScope']
+    k: InjectorKey
+
+    def __post_init__(self) -> None:
+        check.issubclass(self.sc, InjectorScope)
+        check.isinstance(self.k, InjectorKey)
+
+
+def bind_injector_scope_seed(k: ta.Any, sc: ta.Type[InjectorScope]) -> InjectorBindingOrBindings:
+    kk = as_injector_key(k)
+    return as_injector_bindings(
+        InjectorBinding(kk, _ScopeSeedInjectorProvider(kk, sc)),
+        InjectorBinder.bind(_InjectorScopeSeed(sc, kk), array=True),
+    )
+
+
+###
+# 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):
+    _DEFAULT_BINDINGS: ta.ClassVar[ta.List[InjectorBinding]] = []
+
+    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(as_injector_bindings(
+                *self._DEFAULT_BINDINGS,
+                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.ClassVar[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.ClassVar[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,
+
+            in_: ta.Optional[ta.Type[InjectorScope]] = 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 = check.single(providers)
+
+        #
+
+        pws: ta.List[ta.Any] = []
+        if in_ is not None:
+            check.issubclass(in_, InjectorScope)
+            check.not_in(abc.ABC, in_.__bases__)
+            pws.append(functools.partial(ScopedInjectorProvider, k=key, sc=in_))
+        if singleton:
+            pws.append(SingletonInjectorProvider)
+        if len(pws) > 1:
+            raise TypeError('May not specify multiple provider wrappers')
+        elif pws:
+            provider = check.single(pws)(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))))
+
+
+###
+# api
+
+
+class InjectionApi:
+    # keys
+
+    def as_key(self, o: ta.Any) -> InjectorKey:
+        return as_injector_key(o)
+
+    def array(self, o: ta.Any) -> InjectorKey:
+        return dc.replace(as_injector_key(o), array=True)
+
+    def tag(self, o: ta.Any, t: ta.Any) -> InjectorKey:
+        return dc.replace(as_injector_key(o), tag=t)
+
+    # bindings
+
+    def as_bindings(self, *args: InjectorBindingOrBindings) -> InjectorBindings:
+        return as_injector_bindings(*args)
+
+    # overrides
+
+    def override(self, p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
+        return injector_override(p, *args)
+
+    # scopes
+
+    def bind_scope(self, sc: ta.Type[InjectorScope]) -> InjectorBindingOrBindings:
+        return bind_injector_scope(sc)
+
+    def bind_scope_seed(self, k: ta.Any, sc: ta.Type[InjectorScope]) -> InjectorBindingOrBindings:
+        return bind_injector_scope_seed(k, sc)
+
+    # injector
+
+    def create_injector(self, *args: InjectorBindingOrBindings, parent: ta.Optional[Injector] = None) -> Injector:
+        return _Injector(as_injector_bindings(*args), parent)
+
+    # binder
+
+    def bind(
+            self,
+            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,
+
+            in_: ta.Optional[ta.Type[InjectorScope]] = 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,
+
+            in_=in_,
+            singleton=singleton,
+
+            eager=eager,
+        )
+
+    # helpers
+
+    def bind_factory(
+            self,
+            fn: ta.Callable[..., T],
+            cls_: U,
+            ann: ta.Any = None,
+    ) -> InjectorBindingOrBindings:
+        return self.bind(make_injector_factory(fn, cls_, ann))
+
+    def bind_array(
+            self,
+            obj: ta.Any = None,
+            *,
+            tag: ta.Any = None,
+    ) -> InjectorBindingOrBindings:
+        return bind_injector_array(obj, tag=tag)
+
+    def bind_array_type(
+            self,
+            ele: ta.Union[InjectorKey, InjectorKeyCls],
+            cls_: U,
+            ann: ta.Any = None,
+    ) -> InjectorBindingOrBindings:
+        return self.bind(make_injector_array_type(ele, cls_, ann))
+
+
+inj = InjectionApi()
+
+
+########################################
+# ../../../omlish/lite/runtime.py
+
+
+@cached_nullary
+def is_debugger_attached() -> bool:
+    return any(frame[1].endswith('pydevd.py') for frame in inspect.stack())
+
+
+LITE_REQUIRED_PYTHON_VERSION = (3, 8)
+
+
+def check_lite_runtime_version() -> None:
+    if sys.version_info < LITE_REQUIRED_PYTHON_VERSION:
+        raise OSError(f'Requires python {LITE_REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
+
+
+########################################
+# ../../../omlish/logs/json.py
+"""
+TODO:
+ - translate json keys
+"""
+
+
+class JsonLogFormatter(logging.Formatter):
+    KEYS: ta.Mapping[str, bool] = {
+        'name': False,
+        'msg': False,
+        'args': False,
+        'levelname': False,
+        'levelno': False,
+        'pathname': False,
+        'filename': False,
+        'module': False,
+        'exc_info': True,
+        'exc_text': True,
+        'stack_info': True,
+        'lineno': False,
+        'funcName': False,
+        'created': False,
+        'msecs': False,
+        'relativeCreated': False,
+        'thread': False,
+        'threadName': False,
+        'processName': False,
+        'process': False,
+    }
+
+    def __init__(
+            self,
+            *args: ta.Any,
+            json_dumps: ta.Optional[ta.Callable[[ta.Any], str]] = None,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        if json_dumps is None:
+            json_dumps = json_dumps_compact
+        self._json_dumps = json_dumps
+
+    def format(self, record: logging.LogRecord) -> str:
+        dct = {
+            k: v
+            for k, o in self.KEYS.items()
+            for v in [getattr(record, k)]
+            if not (o and v is None)
+        }
+        return self._json_dumps(dct)
+
+
+########################################
+# ../types.py
+
+
+##
+
+
+# See https://peps.python.org/pep-3149/
+INTERP_OPT_GLYPHS_BY_ATTR: ta.Mapping[str, str] = collections.OrderedDict([
+    ('debug', 'd'),
+    ('threaded', 't'),
+])
+
+INTERP_OPT_ATTRS_BY_GLYPH: ta.Mapping[str, str] = collections.OrderedDict(
+    (g, a) for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items()
+)
+
+
+@dc.dataclass(frozen=True)
+class InterpOpts:
+    threaded: bool = False
+    debug: bool = False
+
+    def __str__(self) -> str:
+        return ''.join(g for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items() if getattr(self, a))
+
+    @classmethod
+    def parse(cls, s: str) -> 'InterpOpts':
+        return cls(**{INTERP_OPT_ATTRS_BY_GLYPH[g]: True for g in s})
+
+    @classmethod
+    def parse_suffix(cls, s: str) -> ta.Tuple[str, 'InterpOpts']:
+        kw = {}
+        while s and (a := INTERP_OPT_ATTRS_BY_GLYPH.get(s[-1])):
+            s, kw[a] = s[:-1], True
+        return s, cls(**kw)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class InterpVersion:
+    version: Version
+    opts: InterpOpts
+
+    def __str__(self) -> str:
+        return str(self.version) + str(self.opts)
+
+    @classmethod
+    def parse(cls, s: str) -> 'InterpVersion':
+        s, o = InterpOpts.parse_suffix(s)
+        v = Version(s)
+        return cls(
+            version=v,
+            opts=o,
+        )
+
+    @classmethod
+    def try_parse(cls, s: str) -> ta.Optional['InterpVersion']:
+        try:
+            return cls.parse(s)
+        except (KeyError, InvalidVersion):
+            return None
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class InterpSpecifier:
+    specifier: Specifier
+    opts: InterpOpts
+
+    def __str__(self) -> str:
+        return str(self.specifier) + str(self.opts)
+
+    @classmethod
+    def parse(cls, s: str) -> 'InterpSpecifier':
+        s, o = InterpOpts.parse_suffix(s)
+        if not any(s.startswith(o) for o in Specifier.OPERATORS):
+            s = '~=' + s
+            if s.count('.') < 2:
+                s += '.0'
+        return cls(
+            specifier=Specifier(s),
+            opts=o,
+        )
+
+    def contains(self, iv: InterpVersion) -> bool:
+        return self.specifier.contains(iv.version) and self.opts == iv.opts
+
+    def __contains__(self, iv: InterpVersion) -> bool:
+        return self.contains(iv)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Interp:
+    exe: str
+    version: InterpVersion
+
+
+########################################
+# ../uv/inject.py
+
+
+def bind_interp_uv() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = []
+
+    return inj.as_bindings(*lst)
+
+
+########################################
+# ../../../omlish/logs/standard.py
+"""
+TODO:
+ - structured
+ - prefixed
+ - debug
+ - optional noisy? noisy will never be lite - some kinda configure_standard callback mechanism?
+"""
+
+
+##
+
+
+STANDARD_LOG_FORMAT_PARTS = [
+    ('asctime', '%(asctime)-15s'),
+    ('process', 'pid=%(process)-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 StandardConfiguredLogHandler(ProxyLogHandler):
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError('This class serves only as a marker and should not be subclassed.')
+
+
+##
+
+
+@contextlib.contextmanager
+def _locking_logging_module_lock() -> ta.Iterator[None]:
+    if hasattr(logging, '_acquireLock'):
+        logging._acquireLock()  # noqa
+        try:
+            yield
+        finally:
+            logging._releaseLock()  # type: ignore  # noqa
+
+    elif hasattr(logging, '_lock'):
+        # https://github.com/python/cpython/commit/74723e11109a320e628898817ab449b3dad9ee96
+        with logging._lock:  # noqa
+            yield
+
+    else:
+        raise Exception("Can't find lock in logging module")
+
+
+def configure_standard_logging(
+        level: ta.Union[int, str] = logging.INFO,
+        *,
+        json: bool = False,
+        target: ta.Optional[logging.Logger] = None,
+        force: bool = False,
+        handler_factory: ta.Optional[ta.Callable[[], logging.Handler]] = None,
+) -> ta.Optional[StandardConfiguredLogHandler]:
+    with _locking_logging_module_lock():
+        if target is None:
+            target = logging.root
+
+        #
+
+        if not force:
+            if any(isinstance(h, StandardConfiguredLogHandler) for h in list(target.handlers)):
+                return None
+
+        #
+
+        if handler_factory is not None:
+            handler = handler_factory()
+        else:
+            handler = logging.StreamHandler()
+
+        #
+
+        formatter: logging.Formatter
         if json:
             formatter = JsonLogFormatter()
         else:
@@ -2477,6 +3903,50 @@ class AbstractAsyncSubprocesses(BaseSubprocesses):
             return ret.decode().strip()
 
 
+########################################
+# ../providers/base.py
+"""
+TODO:
+ - backends
+  - local builds
+  - deadsnakes?
+  - uv
+ - loose versions
+"""
+
+
+##
+
+
+class InterpProvider(abc.ABC):
+    name: ta.ClassVar[str]
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+        if abc.ABC not in cls.__bases__ and 'name' not in cls.__dict__:
+            sfx = 'InterpProvider'
+            if not cls.__name__.endswith(sfx):
+                raise NameError(cls)
+            setattr(cls, 'name', snake_case(cls.__name__[:-len(sfx)]))
+
+    @abc.abstractmethod
+    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Awaitable[ta.Sequence[InterpVersion]]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_installed_version(self, version: InterpVersion) -> ta.Awaitable[Interp]:
+        raise NotImplementedError
+
+    async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return []
+
+    async def install_version(self, version: InterpVersion) -> Interp:
+        raise TypeError
+
+
+InterpProviders = ta.NewType('InterpProviders', ta.Sequence[InterpProvider])
+
+
 ########################################
 # ../../../omlish/asyncs/asyncio/subprocesses.py
 
@@ -2793,72 +4263,242 @@ class InterpInspector:
             return ret
 
 
-INTERP_INSPECTOR = InterpInspector()
+########################################
+# ../resolvers.py
+
+
+@dc.dataclass(frozen=True)
+class InterpResolverProviders:
+    providers: ta.Sequence[ta.Tuple[str, InterpProvider]]
+
+
+class InterpResolver:
+    def __init__(
+            self,
+            providers: InterpResolverProviders,
+    ) -> None:
+        super().__init__()
+
+        self._providers: ta.Mapping[str, InterpProvider] = collections.OrderedDict(providers.providers)
+
+    async def _resolve_installed(self, spec: InterpSpecifier) -> ta.Optional[ta.Tuple[InterpProvider, InterpVersion]]:
+        lst = [
+            (i, si)
+            for i, p in enumerate(self._providers.values())
+            for si in await p.get_installed_versions(spec)
+            if spec.contains(si)
+        ]
+
+        slst = sorted(lst, key=lambda t: (-t[0], t[1].version))
+        if not slst:
+            return None
+
+        bi, bv = slst[-1]
+        bp = list(self._providers.values())[bi]
+        return (bp, bv)
+
+    async def resolve(
+            self,
+            spec: InterpSpecifier,
+            *,
+            install: bool = False,
+    ) -> ta.Optional[Interp]:
+        tup = await self._resolve_installed(spec)
+        if tup is not None:
+            bp, bv = tup
+            return await bp.get_installed_version(bv)
+
+        if not install:
+            return None
+
+        tp = list(self._providers.values())[0]  # noqa
+
+        sv = sorted(
+            [s for s in await tp.get_installable_versions(spec) if s in spec],
+            key=lambda s: s.version,
+        )
+        if not sv:
+            return None
+
+        bv = sv[-1]
+        return await tp.install_version(bv)
+
+    async def list(self, spec: InterpSpecifier) -> None:
+        print('installed:')
+        for n, p in self._providers.items():
+            lst = [
+                si
+                for si in await p.get_installed_versions(spec)
+                if spec.contains(si)
+            ]
+            if lst:
+                print(f'  {n}')
+                for si in lst:
+                    print(f'    {si}')
+
+        print()
+
+        print('installable:')
+        for n, p in self._providers.items():
+            lst = [
+                si
+                for si in await p.get_installable_versions(spec)
+                if spec.contains(si)
+            ]
+            if lst:
+                print(f'  {n}')
+                for si in lst:
+                    print(f'    {si}')
+
+
+########################################
+# ../providers/running.py
+
+
+class RunningInterpProvider(InterpProvider):
+    @cached_nullary
+    def version(self) -> InterpVersion:
+        return InterpInspector.running().iv
+
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [self.version()]
+
+    async def get_installed_version(self, version: InterpVersion) -> Interp:
+        if version != self.version():
+            raise KeyError(version)
+        return Interp(
+            exe=sys.executable,
+            version=self.version(),
+        )
 
 
 ########################################
-# ../providers.py
+# ../providers/system.py
 """
 TODO:
- - backends
-  - local builds
-  - deadsnakes?
-  - uv
- - loose versions
+ - python, python3, python3.12, ...
+ - check if path py's are venvs: sys.prefix != sys.base_prefix
 """
 
 
 ##
 
 
-class InterpProvider(abc.ABC):
-    name: ta.ClassVar[str]
+class SystemInterpProvider(InterpProvider):
+    @dc.dataclass(frozen=True)
+    class Options:
+        cmd: str = 'python3'  # FIXME: unused lol
+        path: ta.Optional[str] = None
 
-    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
-        super().__init_subclass__(**kwargs)
-        if abc.ABC not in cls.__bases__ and 'name' not in cls.__dict__:
-            sfx = 'InterpProvider'
-            if not cls.__name__.endswith(sfx):
-                raise NameError(cls)
-            setattr(cls, 'name', snake_case(cls.__name__[:-len(sfx)]))
+        inspect: bool = False
 
-    @abc.abstractmethod
-    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Awaitable[ta.Sequence[InterpVersion]]:
-        raise NotImplementedError
+    def __init__(
+            self,
+            options: Options = Options(),
+            *,
+            inspector: ta.Optional[InterpInspector] = None,
+    ) -> None:
+        super().__init__()
 
-    @abc.abstractmethod
-    def get_installed_version(self, version: InterpVersion) -> ta.Awaitable[Interp]:
-        raise NotImplementedError
+        self._options = options
+
+        self._inspector = inspector
+
+    #
+
+    @staticmethod
+    def _re_which(
+            pat: re.Pattern,
+            *,
+            mode: int = os.F_OK | os.X_OK,
+            path: ta.Optional[str] = None,
+    ) -> ta.List[str]:
+        if path is None:
+            path = os.environ.get('PATH', None)
+            if path is None:
+                try:
+                    path = os.confstr('CS_PATH')
+                except (AttributeError, ValueError):
+                    path = os.defpath
+
+        if not path:
+            return []
+
+        path = os.fsdecode(path)
+        pathlst = path.split(os.pathsep)
+
+        def _access_check(fn: str, mode: int) -> bool:
+            return os.path.exists(fn) and os.access(fn, mode)
+
+        out = []
+        seen = set()
+        for d in pathlst:
+            normdir = os.path.normcase(d)
+            if normdir not in seen:
+                seen.add(normdir)
+                if not _access_check(normdir, mode):
+                    continue
+                for thefile in os.listdir(d):
+                    name = os.path.join(d, thefile)
+                    if not (
+                            os.path.isfile(name) and
+                            pat.fullmatch(thefile) and
+                            _access_check(name, mode)
+                    ):
+                        continue
+                    out.append(name)
 
-    async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return []
+        return out
 
-    async def install_version(self, version: InterpVersion) -> Interp:
-        raise TypeError
+    @cached_nullary
+    def exes(self) -> ta.List[str]:
+        return self._re_which(
+            re.compile(r'python3(\.\d+)?'),
+            path=self._options.path,
+        )
 
+    #
 
-##
+    async def get_exe_version(self, exe: str) -> ta.Optional[InterpVersion]:
+        if not self._options.inspect:
+            s = os.path.basename(exe)
+            if s.startswith('python'):
+                s = s[len('python'):]
+            if '.' in s:
+                try:
+                    return InterpVersion.parse(s)
+                except InvalidVersion:
+                    pass
+        ii = await check.not_none(self._inspector).inspect(exe)
+        return ii.iv if ii is not None else None
 
+    async def exe_versions(self) -> ta.Sequence[ta.Tuple[str, InterpVersion]]:
+        lst = []
+        for e in self.exes():
+            if (ev := await self.get_exe_version(e)) is None:
+                log.debug('Invalid system version: %s', e)
+                continue
+            lst.append((e, ev))
+        return lst
 
-class RunningInterpProvider(InterpProvider):
-    @cached_nullary
-    def version(self) -> InterpVersion:
-        return InterpInspector.running().iv
+    #
 
     async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [self.version()]
+        return [ev for e, ev in await self.exe_versions()]
 
     async def get_installed_version(self, version: InterpVersion) -> Interp:
-        if version != self.version():
-            raise KeyError(version)
-        return Interp(
-            exe=sys.executable,
-            version=self.version(),
-        )
+        for e, ev in await self.exe_versions():
+            if ev != version:
+                continue
+            return Interp(
+                exe=e,
+                version=ev,
+            )
+        raise KeyError(version)
 
 
 ########################################
-# ../pyenv.py
+# ../pyenv/pyenv.py
 """
 TODO:
  - custom tags
@@ -3088,9 +4728,10 @@ class PyenvVersionInstaller:
             opts: ta.Optional[PyenvInstallOpts] = None,
             interp_opts: InterpOpts = InterpOpts(),
             *,
+            pyenv: Pyenv,
+
             install_name: ta.Optional[str] = None,
             no_default_opts: bool = False,
-            pyenv: Pyenv = Pyenv(),
     ) -> None:
         super().__init__()
 
@@ -3180,26 +4821,26 @@ class PyenvVersionInstaller:
 
 
 class PyenvInterpProvider(InterpProvider):
-    def __init__(
-            self,
-            pyenv: Pyenv = Pyenv(),
+    @dc.dataclass(frozen=True)
+    class Options:
+        inspect: bool = False
 
-            inspect: bool = False,
-            inspector: InterpInspector = INTERP_INSPECTOR,
+        try_update: bool = False
 
+    def __init__(
+            self,
+            options: Options = Options(),
             *,
-
-            try_update: bool = False,
+            pyenv: Pyenv,
+            inspector: InterpInspector,
     ) -> None:
         super().__init__()
 
-        self._pyenv = pyenv
+        self._options = options
 
-        self._inspect = inspect
+        self._pyenv = pyenv
         self._inspector = inspector
 
-        self._try_update = try_update
-
     #
 
     @staticmethod
@@ -3224,7 +4865,7 @@ class PyenvInterpProvider(InterpProvider):
 
     async def _make_installed(self, vn: str, ep: str) -> ta.Optional[Installed]:
         iv: ta.Optional[InterpVersion]
-        if self._inspect:
+        if self._options.inspect:
             try:
                 iv = check.not_none(await self._inspector.inspect(ep)).iv
             except Exception as e:  # noqa
@@ -3280,7 +4921,7 @@ class PyenvInterpProvider(InterpProvider):
     async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
         lst = await self._get_installable_versions(spec)
 
-        if self._try_update and not any(v in spec for v in lst):
+        if self._options.try_update and not any(v in spec for v in lst):
             if self._pyenv.update():
                 lst = await self._get_installable_versions(spec)
 
@@ -3296,6 +4937,7 @@ class PyenvInterpProvider(InterpProvider):
         installer = PyenvVersionInstaller(
             inst_version,
             interp_opts=inst_opts,
+            pyenv=self._pyenv,
         )
 
         exe = await installer.install()
@@ -3303,266 +4945,126 @@ class PyenvInterpProvider(InterpProvider):
 
 
 ########################################
-# ../system.py
-"""
-TODO:
- - python, python3, python3.12, ...
- - check if path py's are venvs: sys.prefix != sys.base_prefix
-"""
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class SystemInterpProvider(InterpProvider):
-    cmd: str = 'python3'
-    path: ta.Optional[str] = None
-
-    inspect: bool = False
-    inspector: InterpInspector = INTERP_INSPECTOR
-
-    #
-
-    @staticmethod
-    def _re_which(
-            pat: re.Pattern,
-            *,
-            mode: int = os.F_OK | os.X_OK,
-            path: ta.Optional[str] = None,
-    ) -> ta.List[str]:
-        if path is None:
-            path = os.environ.get('PATH', None)
-            if path is None:
-                try:
-                    path = os.confstr('CS_PATH')
-                except (AttributeError, ValueError):
-                    path = os.defpath
-
-        if not path:
-            return []
-
-        path = os.fsdecode(path)
-        pathlst = path.split(os.pathsep)
-
-        def _access_check(fn: str, mode: int) -> bool:
-            return os.path.exists(fn) and os.access(fn, mode)
-
-        out = []
-        seen = set()
-        for d in pathlst:
-            normdir = os.path.normcase(d)
-            if normdir not in seen:
-                seen.add(normdir)
-                if not _access_check(normdir, mode):
-                    continue
-                for thefile in os.listdir(d):
-                    name = os.path.join(d, thefile)
-                    if not (
-                            os.path.isfile(name) and
-                            pat.fullmatch(thefile) and
-                            _access_check(name, mode)
-                    ):
-                        continue
-                    out.append(name)
-
-        return out
-
-    @cached_nullary
-    def exes(self) -> ta.List[str]:
-        return self._re_which(
-            re.compile(r'python3(\.\d+)?'),
-            path=self.path,
-        )
-
-    #
+# ../providers/inject.py
 
-    async def get_exe_version(self, exe: str) -> ta.Optional[InterpVersion]:
-        if not self.inspect:
-            s = os.path.basename(exe)
-            if s.startswith('python'):
-                s = s[len('python'):]
-            if '.' in s:
-                try:
-                    return InterpVersion.parse(s)
-                except InvalidVersion:
-                    pass
-        ii = await self.inspector.inspect(exe)
-        return ii.iv if ii is not None else None
 
-    async def exe_versions(self) -> ta.Sequence[ta.Tuple[str, InterpVersion]]:
-        lst = []
-        for e in self.exes():
-            if (ev := await self.get_exe_version(e)) is None:
-                log.debug('Invalid system version: %s', e)
-                continue
-            lst.append((e, ev))
-        return lst
+def bind_interp_providers() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind_array(InterpProvider),
+        inj.bind_array_type(InterpProvider, InterpProviders),
 
-    #
+        inj.bind(RunningInterpProvider, singleton=True),
+        inj.bind(InterpProvider, to_key=RunningInterpProvider, array=True),
 
-    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [ev for e, ev in await self.exe_versions()]
+        inj.bind(SystemInterpProvider, singleton=True),
+        inj.bind(InterpProvider, to_key=SystemInterpProvider, array=True),
+    ]
 
-    async def get_installed_version(self, version: InterpVersion) -> Interp:
-        for e, ev in await self.exe_versions():
-            if ev != version:
-                continue
-            return Interp(
-                exe=e,
-                version=ev,
-            )
-        raise KeyError(version)
+    return inj.as_bindings(*lst)
 
 
 ########################################
-# ../resolvers.py
+# ../pyenv/inject.py
 
 
-INTERP_PROVIDER_TYPES_BY_NAME: ta.Mapping[str, ta.Type[InterpProvider]] = {
-    cls.name: cls for cls in deep_subclasses(InterpProvider) if abc.ABC not in cls.__bases__  # type: ignore
-}
-
+def bind_interp_pyenv() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind(Pyenv, singleton=True),
 
-class InterpResolver:
-    def __init__(
-            self,
-            providers: ta.Sequence[ta.Tuple[str, InterpProvider]],
-    ) -> None:
-        super().__init__()
+        inj.bind(PyenvInterpProvider, singleton=True),
+        inj.bind(InterpProvider, to_key=PyenvInterpProvider, array=True),
+    ]
 
-        self._providers: ta.Mapping[str, InterpProvider] = collections.OrderedDict(providers)
+    return inj.as_bindings(*lst)
 
-    async def _resolve_installed(self, spec: InterpSpecifier) -> ta.Optional[ta.Tuple[InterpProvider, InterpVersion]]:
-        lst = [
-            (i, si)
-            for i, p in enumerate(self._providers.values())
-            for si in await p.get_installed_versions(spec)
-            if spec.contains(si)
-        ]
 
-        slst = sorted(lst, key=lambda t: (-t[0], t[1].version))
-        if not slst:
-            return None
+########################################
+# ../inject.py
 
-        bi, bv = slst[-1]
-        bp = list(self._providers.values())[bi]
-        return (bp, bv)
 
-    async def resolve(
-            self,
-            spec: InterpSpecifier,
-            *,
-            install: bool = False,
-    ) -> ta.Optional[Interp]:
-        tup = await self._resolve_installed(spec)
-        if tup is not None:
-            bp, bv = tup
-            return await bp.get_installed_version(bv)
+def bind_interp() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        bind_interp_providers(),
 
-        if not install:
-            return None
+        bind_interp_pyenv(),
 
-        tp = list(self._providers.values())[0]  # noqa
+        bind_interp_uv(),
 
-        sv = sorted(
-            [s for s in await tp.get_installable_versions(spec) if s in spec],
-            key=lambda s: s.version,
-        )
-        if not sv:
-            return None
+        inj.bind(InterpInspector, singleton=True),
+    ]
 
-        bv = sv[-1]
-        return await tp.install_version(bv)
+    #
 
-    async def list(self, spec: InterpSpecifier) -> None:
-        print('installed:')
-        for n, p in self._providers.items():
-            lst = [
-                si
-                for si in await p.get_installed_versions(spec)
-                if spec.contains(si)
+    def provide_interp_resolver_providers(injector: Injector) -> InterpResolverProviders:
+        # FIXME: lol
+        rps: ta.List[ta.Any] = [
+            injector.provide(c)
+            for c in [
+                PyenvInterpProvider,
+                RunningInterpProvider,
+                SystemInterpProvider,
             ]
-            if lst:
-                print(f'  {n}')
-                for si in lst:
-                    print(f'    {si}')
-
-        print()
+        ]
 
-        print('installable:')
-        for n, p in self._providers.items():
-            lst = [
-                si
-                for si in await p.get_installable_versions(spec)
-                if spec.contains(si)
-            ]
-            if lst:
-                print(f'  {n}')
-                for si in lst:
-                    print(f'    {si}')
+        return InterpResolverProviders([(rp.name, rp) for rp in rps])
 
+    lst.append(inj.bind(provide_interp_resolver_providers, singleton=True))
 
-DEFAULT_INTERP_RESOLVER = InterpResolver([(p.name, p) for p in [
-    # pyenv is preferred to system interpreters as it tends to have more support for things like tkinter
-    PyenvInterpProvider(try_update=True),
+    lst.extend([
+        inj.bind(InterpResolver, singleton=True),
+    ])
 
-    RunningInterpProvider(),
+    #
 
-    SystemInterpProvider(),
-]])
+    return inj.as_bindings(*lst)
 
 
 ########################################
 # cli.py
 
 
-async def _list_cmd(args) -> None:
-    r = DEFAULT_INTERP_RESOLVER
-    s = InterpSpecifier.parse(args.version)
-    await r.list(s)
-
-
-async def _resolve_cmd(args) -> None:
-    if args.provider:
-        p = INTERP_PROVIDER_TYPES_BY_NAME[args.provider]()
-        r = InterpResolver([(p.name, p)])
-    else:
-        r = DEFAULT_INTERP_RESOLVER
-    s = InterpSpecifier.parse(args.version)
-    print(check.not_none(await r.resolve(s, install=bool(args.install))).exe)
-
-
-def _build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser()
-
-    subparsers = parser.add_subparsers()
+class InterpCli(ArgparseCli):
+    @cached_nullary
+    def injector(self) -> Injector:
+        return inj.create_injector(bind_interp())
 
-    parser_list = subparsers.add_parser('list')
-    parser_list.add_argument('version')
-    parser_list.add_argument('-d', '--debug', action='store_true')
-    parser_list.set_defaults(func=_list_cmd)
+    @cached_nullary
+    def providers(self) -> InterpResolverProviders:
+        return self.injector()[InterpResolverProviders]
 
-    parser_resolve = subparsers.add_parser('resolve')
-    parser_resolve.add_argument('version')
-    parser_resolve.add_argument('-p', '--provider')
-    parser_resolve.add_argument('-d', '--debug', action='store_true')
-    parser_resolve.add_argument('-i', '--install', action='store_true')
-    parser_resolve.set_defaults(func=_resolve_cmd)
+    #
 
-    return parser
+    @argparse_command(
+        argparse_arg('version'),
+        argparse_arg('-d', '--debug', action='store_true'),
+    )
+    async def list(self) -> None:
+        r = InterpResolver(self.providers())
+        s = InterpSpecifier.parse(self.args.version)
+        await r.list(s)
+
+    @argparse_command(
+        argparse_arg('version'),
+        argparse_arg('-p', '--provider'),
+        argparse_arg('-d', '--debug', action='store_true'),
+        argparse_arg('-i', '--install', action='store_true'),
+    )
+    async def resolve(self) -> None:
+        if self.args.provider:
+            p = check.single([p for n, p in self.providers().providers if n == self.args.provider])
+            r = InterpResolver(InterpResolverProviders([(p.name, p)]))
+        else:
+            r = InterpResolver(self.providers())
+        s = InterpSpecifier.parse(self.args.version)
+        print(check.not_none(await r.resolve(s, install=bool(self.args.install))).exe)
 
 
 async def _async_main(argv: ta.Optional[ta.Sequence[str]] = None) -> None:
     check_lite_runtime_version()
     configure_standard_logging()
 
-    parser = _build_parser()
-    args = parser.parse_args(argv)
-    if not getattr(args, 'func', None):
-        parser.print_help()
-    else:
-        await args.func(args)
+    cli = ArgparseCli(argv)
+    await cli.async_cli_run()
 
 
 def _main(argv: ta.Optional[ta.Sequence[str]] = None) -> None: