ominfra 0.0.0.dev177__py3-none-any.whl → 0.0.0.dev179__py3-none-any.whl

ominfra/scripts/manage.py

@@ -17,6 +17,7 @@ import base64
 import collections
 import collections.abc
 import contextlib
+import contextvars
 import ctypes as ct
 import dataclasses as dc
 import datetime
@@ -4905,6 +4906,10 @@ 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
@@ -5121,6 +5126,33 @@ def as_injector_bindings(*args: InjectorBindingOrBindings) -> InjectorBindings:
 ##
 
 
+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
@@ -5142,30 +5174,160 @@ def injector_override(p: InjectorBindings, *args: InjectorBindingOrBindings) ->
     return OverridesInjectorBindings(p, m)
 
 
-##
+###
+# scopes
 
 
-def build_injector_provider_map(bs: InjectorBindings) -> ta.Mapping[InjectorKey, InjectorProvider]:
-    pm: ta.Dict[InjectorKey, InjectorProvider] = {}
-    am: ta.Dict[InjectorKey, ta.List[InjectorProvider]] = {}
+class InjectorScope(abc.ABC):  # noqa
+    def __init__(
+            self,
+            *,
+            _i: Injector,
+    ) -> None:
+        check.not_in(abc.ABC, type(self).__bases__)
 
-    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)
+        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:
-            if b.key in pm:
-                raise KeyError(b.key)
-            pm[b.key] = b.provider
+            raise RuntimeError(f'Scope already entered: {self}')
+        st = self.new_state(vs)
+        tok = self._cv.set(st)
+        try:
+            yield
+        finally:
+            self._cv.reset(tok)
 
-    if am:
-        for k, aps in am.items():
-            pm[k] = ArrayInjectorProvider(aps)
 
-    return pm
+#
+
+
+@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),
+    )
 
 
 ###
@@ -5312,13 +5474,21 @@ _INJECTOR_EAGER_ARRAY_KEY: InjectorKey[_InjectorEager] = InjectorKey(_InjectorEa
 
 
 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(bs).items()}
+        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)
@@ -5485,6 +5655,7 @@ class InjectorBinder:
             to_const: ta.Any = None,
             to_key: ta.Any = None,
 
+            in_: ta.Optional[ta.Type[InjectorScope]] = None,
             singleton: bool = False,
 
             eager: bool = False,
@@ -5494,12 +5665,12 @@ class InjectorBinder:
         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
@@ -5529,7 +5700,7 @@ class InjectorBinder:
                 key = InjectorKey(type(obj))
         del has_to
 
-        ##
+        #
 
         if tag is not None:
             if key.tag is not None:
@@ -5539,7 +5710,7 @@ class InjectorBinder:
         if array is not None:
             key = dc.replace(key, array=array)
 
-        ##
+        #
 
         providers: ta.List[InjectorProvider] = []
         if to_fn is not None:
@@ -5554,23 +5725,34 @@ class InjectorBinder:
             raise TypeError('Must specify provider')
         if len(providers) > 1:
             raise TypeError('May not specify multiple providers')
-        provider, = 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:
-            provider = SingletonInjectorProvider(provider)
+            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)
@@ -5643,7 +5825,8 @@ def bind_injector_eager_key(key: ta.Any) -> InjectorBinding:
     return InjectorBinding(_INJECTOR_EAGER_ARRAY_KEY, ConstInjectorProvider(_InjectorEager(as_injector_key(key))))
 
 
-##
+###
+# api
 
 
 class InjectionApi:
@@ -5663,9 +5846,19 @@ class InjectionApi:
     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:
@@ -5686,6 +5879,7 @@ class InjectionApi:
             to_const: ta.Any = None,
             to_key: ta.Any = None,
 
+            in_: ta.Optional[ta.Type[InjectorScope]] = None,
             singleton: bool = False,
 
             eager: bool = False,
@@ -5702,6 +5896,7 @@ class InjectionApi:
             to_const=to_const,
             to_key=to_key,
 
+            in_=in_,
             singleton=singleton,
 
             eager=eager,
@@ -6511,6 +6706,9 @@ class TempDirAtomicPathSwapping(AtomicPathSwapping):
 # ../../../omdev/interp/types.py
 
 
+##
+
+
 # See https://peps.python.org/pep-3149/
 INTERP_OPT_GLYPHS_BY_ATTR: ta.Mapping[str, str] = collections.OrderedDict([
     ('debug', 'd'),
@@ -6542,6 +6740,9 @@ class InterpOpts:
         return s, cls(**kw)
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class InterpVersion:
     version: Version
@@ -6567,6 +6768,9 @@ class InterpVersion:
             return None
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class InterpSpecifier:
     specifier: Specifier
@@ -6594,12 +6798,25 @@ class InterpSpecifier:
         return self.contains(iv)
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class Interp:
     exe: str
     version: InterpVersion
 
 
+########################################
+# ../../../omdev/interp/uv/inject.py
+
+
+def bind_interp_uv() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = []
+
+    return inj.as_bindings(*lst)
+
+
 ########################################
 # ../../configs.py
 
@@ -7513,6 +7730,50 @@ class AbstractAsyncSubprocesses(BaseSubprocesses):
             return ret.decode().strip()
 
 
+########################################
+# ../../../omdev/interp/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])
+
+
 ########################################
 # ../bootstrap.py
 
@@ -7547,6 +7808,37 @@ class LocalCommandExecutor(CommandExecutor):
         return await ce.execute(cmd)
 
 
+########################################
+# ../deploy/deploy.py
+
+
+DEPLOY_TAG_DATETIME_FMT = '%Y%m%dT%H%M%SZ'
+
+
+DeployManagerUtcClock = ta.NewType('DeployManagerUtcClock', Func0[datetime.datetime])
+
+
+class DeployManager:
+    def __init__(
+            self,
+            *,
+
+            utc_clock: ta.Optional[DeployManagerUtcClock] = None,
+    ):
+        super().__init__()
+
+        self._utc_clock = utc_clock
+
+    def _utc_now(self) -> datetime.datetime:
+        if self._utc_clock is not None:
+            return self._utc_clock()  # noqa
+        else:
+            return datetime.datetime.now(tz=datetime.timezone.utc)  # noqa
+
+    def make_deploy_time(self) -> DeployTime:
+        return DeployTime(self._utc_now().strftime(DEPLOY_TAG_DATETIME_FMT))
+
+
 ########################################
 # ../deploy/paths/paths.py
 """
@@ -8616,25 +8908,110 @@ class InterpInspector:
             return ret
 
 
-INTERP_INSPECTOR = InterpInspector()
-
-
 ########################################
-# ../commands/subprocess.py
-
-
-##
+# ../../../omdev/interp/resolvers.py
 
 
 @dc.dataclass(frozen=True)
-class SubprocessCommand(Command['SubprocessCommand.Output']):
-    cmd: ta.Sequence[str]
+class InterpResolverProviders:
+    providers: ta.Sequence[ta.Tuple[str, InterpProvider]]
 
-    shell: bool = False
-    cwd: ta.Optional[str] = None
-    env: ta.Optional[ta.Mapping[str, str]] = None
 
-    stdout: str = 'pipe'  # SubprocessChannelOption
+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}')
+
+
+########################################
+# ../commands/subprocess.py
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class SubprocessCommand(Command['SubprocessCommand.Output']):
+    cmd: ta.Sequence[str]
+
+    shell: bool = False
+    cwd: ta.Optional[str] = None
+    env: ta.Optional[ta.Mapping[str, str]] = None
+
+    stdout: str = 'pipe'  # SubprocessChannelOption
     stderr: str = 'pipe'  # SubprocessChannelOption
 
     input: ta.Optional[bytes] = None
@@ -9270,47 +9647,7 @@ class YumSystemPackageManager(SystemPackageManager):
 
 
 ########################################
-# ../../../omdev/interp/providers.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
-
-
-##
+# ../../../omdev/interp/providers/running.py
 
 
 class RunningInterpProvider(InterpProvider):
@@ -9331,314 +9668,132 @@ class RunningInterpProvider(InterpProvider):
 
 
 ########################################
-# ../commands/inject.py
+# ../../../omdev/interp/providers/system.py
+"""
+TODO:
+ - python, python3, python3.12, ...
+ - check if path py's are venvs: sys.prefix != sys.base_prefix
+"""
 
 
 ##
 
 
-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),
-        ])
+class SystemInterpProvider(InterpProvider):
+    @dc.dataclass(frozen=True)
+    class Options:
+        cmd: str = 'python3'  # FIXME: unused lol
+        path: ta.Optional[str] = None
 
-    return inj.as_bindings(*lst)
+        inspect: bool = False
 
+    def __init__(
+            self,
+            options: Options = Options(),
+            *,
+            inspector: ta.Optional[InterpInspector] = None,
+    ) -> None:
+        super().__init__()
 
-##
+        self._options = options
 
+        self._inspector = inspector
 
-@dc.dataclass(frozen=True)
-class _FactoryCommandExecutor(CommandExecutor):
-    factory: ta.Callable[[], CommandExecutor]
+    #
 
-    def execute(self, i: Command) -> ta.Awaitable[Command.Output]:
-        return self.factory().execute(i)
+    @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)
 
-def bind_commands(
-        *,
-        main_config: MainConfig,
-) -> InjectorBindings:
-    lst: ta.List[InjectorBindingOrBindings] = [
-        inj.bind_array(CommandRegistration),
-        inj.bind_array_type(CommandRegistration, CommandRegistrations),
+        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)
 
-        inj.bind_array(CommandExecutorRegistration),
-        inj.bind_array_type(CommandExecutorRegistration, CommandExecutorRegistrations),
+        return out
 
-        inj.bind(build_command_name_map, singleton=True),
-    ]
+    @cached_nullary
+    def exes(self) -> ta.List[str]:
+        return self._re_which(
+            re.compile(r'python3(\.\d+)?'),
+            path=self._options.path,
+        )
 
     #
 
-    def provide_obj_marshaler_installer(cmds: CommandNameMap) -> ObjMarshalerInstaller:
-        return ObjMarshalerInstaller(functools.partial(install_command_marshaling, cmds))
+    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
 
-    lst.append(inj.bind(provide_obj_marshaler_installer, array=True))
+    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 provide_command_executor_map(
-            injector: Injector,
-            crs: CommandExecutorRegistrations,
-    ) -> CommandExecutorMap:
-        dct: ta.Dict[ta.Type[Command], CommandExecutor] = {}
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [ev for e, ev in await self.exe_versions()]
 
-        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(LocalCommandExecutor, singleton=True, eager=main_config.debug),
-    ])
-
-    #
-
-    lst.extend([
-        bind_command(PingCommand, PingCommandExecutor),
-        bind_command(SubprocessCommand, SubprocessCommandExecutor),
-    ])
-
-    #
-
-    return inj.as_bindings(*lst)
-
-
-########################################
-# ../deploy/paths/manager.py
-
-
-class DeployPathsManager:
-    def __init__(
-            self,
-            *,
-            deploy_path_owners: DeployPathOwners,
-    ) -> None:
-        super().__init__()
-
-        self._deploy_path_owners = deploy_path_owners
-
-    @cached_nullary
-    def owners_by_path(self) -> ta.Mapping[DeployPath, DeployPathOwner]:
-        dct: ta.Dict[DeployPath, DeployPathOwner] = {}
-        for o in self._deploy_path_owners:
-            for p in o.get_owned_deploy_paths():
-                if p in dct:
-                    raise DeployPathError(f'Duplicate deploy path owner: {p}')
-                dct[p] = o
-        return dct
-
-    def validate_deploy_paths(self) -> None:
-        self.owners_by_path()
-
-
-########################################
-# ../deploy/tmp.py
-
-
-class DeployHomeAtomics(Func1[DeployHome, AtomicPathSwapping]):
-    pass
-
-
-class DeployTmpManager(
-    SingleDirDeployPathOwner,
-):
-    def __init__(self) -> None:
-        super().__init__(
-            owned_dir='tmp',
-        )
-
-    def get_swapping(self, home: DeployHome) -> AtomicPathSwapping:
-        return TempDirAtomicPathSwapping(
-            temp_dir=self._make_dir(home),
-            root_dir=check.non_empty_str(home),
-        )
-
-
-########################################
-# ../remote/connection.py
-
-
-##
-
-
-class PyremoteRemoteExecutionConnector:
-    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.asynccontextmanager
-    async def connect(
-            self,
-            tgt: RemoteSpawning.Target,
-            bs: MainBootstrap,
-    ) -> ta.AsyncGenerator[RemoteCommandExecutor, None]:
-        spawn_src = self._spawn_src()
-        remote_src = self._remote_src()
-
-        async with self._spawning.spawn(
-                tgt,
-                spawn_src,
-                debug=bs.main_config.debug,
-        ) as proc:
-            res = await PyremoteBootstrapDriver(  # noqa
-                remote_src,
-                PyremoteBootstrapOptions(
-                    debug=bs.main_config.debug,
-                ),
-            ).async_run(
-                proc.stdout,
-                proc.stdin,
-            )
-
-            chan = RemoteChannelImpl(
-                proc.stdout,
-                proc.stdin,
-                msh=self._msh,
+    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,
             )
-
-            await chan.send_obj(bs)
-
-            rce: RemoteCommandExecutor
-            async with aclosing(RemoteCommandExecutor(chan)) as rce:
-                await rce.start()
-
-                yield rce
-
-
-##
-
-
-class InProcessRemoteExecutionConnector:
-    def __init__(
-            self,
-            *,
-            msh: ObjMarshalerManager,
-            local_executor: LocalCommandExecutor,
-    ) -> None:
-        super().__init__()
-
-        self._msh = msh
-        self._local_executor = local_executor
-
-    @contextlib.asynccontextmanager
-    async def connect(self) -> ta.AsyncGenerator[RemoteCommandExecutor, None]:
-        r0, w0 = asyncio_create_bytes_channel()
-        r1, w1 = asyncio_create_bytes_channel()
-
-        remote_chan = RemoteChannelImpl(r0, w1, msh=self._msh)
-        local_chan = RemoteChannelImpl(r1, w0, msh=self._msh)
-
-        rch = _RemoteCommandHandler(
-            remote_chan,
-            self._local_executor,
-        )
-        rch_task = asyncio.create_task(rch.run())  # noqa
-        try:
-            rce: RemoteCommandExecutor
-            async with aclosing(RemoteCommandExecutor(local_chan)) as rce:
-                await rce.start()
-
-                yield rce
-
-        finally:
-            rch.stop()
-            await rch_task
-
-
-########################################
-# ../system/commands.py
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class CheckSystemPackageCommand(Command['CheckSystemPackageCommand.Output']):
-    pkgs: ta.Sequence[str] = ()
-
-    def __post_init__(self) -> None:
-        check.not_isinstance(self.pkgs, str)
-
-    @dc.dataclass(frozen=True)
-    class Output(Command.Output):
-        pkgs: ta.Sequence[SystemPackage]
-
-
-class CheckSystemPackageCommandExecutor(CommandExecutor[CheckSystemPackageCommand, CheckSystemPackageCommand.Output]):
-    def __init__(
-            self,
-            *,
-            mgr: SystemPackageManager,
-    ) -> None:
-        super().__init__()
-
-        self._mgr = mgr
-
-    async def execute(self, cmd: CheckSystemPackageCommand) -> CheckSystemPackageCommand.Output:
-        log.info('Checking system package!')
-
-        ret = await self._mgr.query(*cmd.pkgs)
-
-        return CheckSystemPackageCommand.Output(list(ret.values()))
+        raise KeyError(version)
 
 
 ########################################
-# ../../../omdev/interp/pyenv.py
+# ../../../omdev/interp/pyenv/pyenv.py
 """
 TODO:
  - custom tags
@@ -9868,9 +10023,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__()
 
@@ -9960,26 +10116,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
@@ -10004,7 +10160,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
@@ -10060,7 +10216,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)
 
@@ -10076,6 +10232,7 @@ class PyenvInterpProvider(InterpProvider):
         installer = PyenvVersionInstaller(
             inst_version,
             interp_opts=inst_opts,
+            pyenv=self._pyenv,
         )
 
         exe = await installer.install()
@@ -10083,116 +10240,344 @@ class PyenvInterpProvider(InterpProvider):
 
 
 ########################################
-# ../../../omdev/interp/system.py
-"""
-TODO:
- - python, python3, python3.12, ...
- - check if path py's are venvs: sys.prefix != sys.base_prefix
-"""
+# ../commands/inject.py
+
+
+##
+
+
+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)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class _FactoryCommandExecutor(CommandExecutor):
+    factory: ta.Callable[[], CommandExecutor]
+
+    def execute(self, i: Command) -> ta.Awaitable[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(LocalCommandExecutor, singleton=True, eager=main_config.debug),
+    ])
+
+    #
+
+    lst.extend([
+        bind_command(PingCommand, PingCommandExecutor),
+        bind_command(SubprocessCommand, SubprocessCommandExecutor),
+    ])
+
+    #
+
+    return inj.as_bindings(*lst)
+
+
+########################################
+# ../deploy/paths/manager.py
+
+
+class DeployPathsManager:
+    def __init__(
+            self,
+            *,
+            deploy_path_owners: DeployPathOwners,
+    ) -> None:
+        super().__init__()
+
+        self._deploy_path_owners = deploy_path_owners
+
+    @cached_nullary
+    def owners_by_path(self) -> ta.Mapping[DeployPath, DeployPathOwner]:
+        dct: ta.Dict[DeployPath, DeployPathOwner] = {}
+        for o in self._deploy_path_owners:
+            for p in o.get_owned_deploy_paths():
+                if p in dct:
+                    raise DeployPathError(f'Duplicate deploy path owner: {p}')
+                dct[p] = o
+        return dct
+
+    def validate_deploy_paths(self) -> None:
+        self.owners_by_path()
+
+
+########################################
+# ../deploy/tmp.py
+
+
+class DeployHomeAtomics(Func1[DeployHome, AtomicPathSwapping]):
+    pass
+
+
+class DeployTmpManager(
+    SingleDirDeployPathOwner,
+):
+    def __init__(self) -> None:
+        super().__init__(
+            owned_dir='tmp',
+        )
+
+    def get_swapping(self, home: DeployHome) -> AtomicPathSwapping:
+        return TempDirAtomicPathSwapping(
+            temp_dir=self._make_dir(home),
+            root_dir=check.non_empty_str(home),
+        )
+
+
+########################################
+# ../remote/connection.py
+
+
+##
+
+
+class PyremoteRemoteExecutionConnector:
+    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.asynccontextmanager
+    async def connect(
+            self,
+            tgt: RemoteSpawning.Target,
+            bs: MainBootstrap,
+    ) -> ta.AsyncGenerator[RemoteCommandExecutor, None]:
+        spawn_src = self._spawn_src()
+        remote_src = self._remote_src()
+
+        async with self._spawning.spawn(
+                tgt,
+                spawn_src,
+                debug=bs.main_config.debug,
+        ) as proc:
+            res = await PyremoteBootstrapDriver(  # noqa
+                remote_src,
+                PyremoteBootstrapOptions(
+                    debug=bs.main_config.debug,
+                ),
+            ).async_run(
+                proc.stdout,
+                proc.stdin,
+            )
+
+            chan = RemoteChannelImpl(
+                proc.stdout,
+                proc.stdin,
+                msh=self._msh,
+            )
+
+            await chan.send_obj(bs)
+
+            rce: RemoteCommandExecutor
+            async with aclosing(RemoteCommandExecutor(chan)) as rce:
+                await rce.start()
+
+                yield rce
+
+
+##
+
+
+class InProcessRemoteExecutionConnector:
+    def __init__(
+            self,
+            *,
+            msh: ObjMarshalerManager,
+            local_executor: LocalCommandExecutor,
+    ) -> None:
+        super().__init__()
+
+        self._msh = msh
+        self._local_executor = local_executor
+
+    @contextlib.asynccontextmanager
+    async def connect(self) -> ta.AsyncGenerator[RemoteCommandExecutor, None]:
+        r0, w0 = asyncio_create_bytes_channel()
+        r1, w1 = asyncio_create_bytes_channel()
+
+        remote_chan = RemoteChannelImpl(r0, w1, msh=self._msh)
+        local_chan = RemoteChannelImpl(r1, w0, msh=self._msh)
+
+        rch = _RemoteCommandHandler(
+            remote_chan,
+            self._local_executor,
+        )
+        rch_task = asyncio.create_task(rch.run())  # noqa
+        try:
+            rce: RemoteCommandExecutor
+            async with aclosing(RemoteCommandExecutor(local_chan)) as rce:
+                await rce.start()
+
+                yield rce
+
+        finally:
+            rch.stop()
+            await rch_task
+
+
+########################################
+# ../system/commands.py
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class CheckSystemPackageCommand(Command['CheckSystemPackageCommand.Output']):
+    pkgs: ta.Sequence[str] = ()
+
+    def __post_init__(self) -> None:
+        check.not_isinstance(self.pkgs, str)
+
+    @dc.dataclass(frozen=True)
+    class Output(Command.Output):
+        pkgs: ta.Sequence[SystemPackage]
 
 
-##
+class CheckSystemPackageCommandExecutor(CommandExecutor[CheckSystemPackageCommand, CheckSystemPackageCommand.Output]):
+    def __init__(
+            self,
+            *,
+            mgr: SystemPackageManager,
+    ) -> None:
+        super().__init__()
 
+        self._mgr = mgr
 
-@dc.dataclass(frozen=True)
-class SystemInterpProvider(InterpProvider):
-    cmd: str = 'python3'
-    path: ta.Optional[str] = None
+    async def execute(self, cmd: CheckSystemPackageCommand) -> CheckSystemPackageCommand.Output:
+        log.info('Checking system package!')
 
-    inspect: bool = False
-    inspector: InterpInspector = INTERP_INSPECTOR
+        ret = await self._mgr.query(*cmd.pkgs)
 
-    #
+        return CheckSystemPackageCommand.Output(list(ret.values()))
 
-    @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 []
+########################################
+# ../../../omdev/interp/providers/inject.py
 
-        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)
+def bind_interp_providers() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind_array(InterpProvider),
+        inj.bind_array_type(InterpProvider, InterpProviders),
 
-        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)
+        inj.bind(RunningInterpProvider, singleton=True),
+        inj.bind(InterpProvider, to_key=RunningInterpProvider, array=True),
 
-        return out
+        inj.bind(SystemInterpProvider, singleton=True),
+        inj.bind(InterpProvider, to_key=SystemInterpProvider, array=True),
+    ]
 
-    @cached_nullary
-    def exes(self) -> ta.List[str]:
-        return self._re_which(
-            re.compile(r'python3(\.\d+)?'),
-            path=self.path,
-        )
+    return inj.as_bindings(*lst)
 
-    #
 
-    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
+########################################
+# ../../../omdev/interp/pyenv/inject.py
 
-    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_pyenv() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind(Pyenv, singleton=True),
 
-    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [ev for e, ev in await self.exe_versions()]
+        inj.bind(PyenvInterpProvider, singleton=True),
+        inj.bind(InterpProvider, to_key=PyenvInterpProvider, 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)
 
 
 ########################################
@@ -10559,101 +10944,44 @@ class SshManageTargetConnector(ManageTargetConnector):
 
 
 ########################################
-# ../../../omdev/interp/resolvers.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
-}
-
-
-class InterpResolver:
-    def __init__(
-            self,
-            providers: ta.Sequence[ta.Tuple[str, InterpProvider]],
-    ) -> None:
-        super().__init__()
-
-        self._providers: ta.Mapping[str, InterpProvider] = collections.OrderedDict(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
+# ../../../omdev/interp/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)
 
 
 ########################################
@@ -10685,6 +11013,15 @@ def bind_targets() -> InjectorBindings:
     return inj.as_bindings(*lst)
 
 
+########################################
+# ../../../omdev/interp/default.py
+
+
+@cached_nullary
+def get_default_interp_resolver() -> InterpResolver:
+    return inj.create_injector(bind_interp())[InterpResolver]
+
+
 ########################################
 # ../deploy/interp.py
 
@@ -10707,7 +11044,7 @@ class InterpCommand(Command['InterpCommand.Output']):
 class InterpCommandExecutor(CommandExecutor[InterpCommand, InterpCommand.Output]):
     async def execute(self, cmd: InterpCommand) -> InterpCommand.Output:
         i = InterpSpecifier.parse(check.not_none(cmd.spec))
-        o = check.not_none(await DEFAULT_INTERP_RESOLVER.resolve(i, install=cmd.install))
+        o = check.not_none(await get_default_interp_resolver().resolve(i, install=cmd.install))
         return InterpCommand.Output(
             exe=o.exe,
             version=str(o.version.version),
@@ -10734,7 +11071,7 @@ class DeployVenvManager:
     ) -> None:
         if spec.interp is not None:
             i = InterpSpecifier.parse(check.not_none(spec.interp))
-            o = check.not_none(await DEFAULT_INTERP_RESOLVER.resolve(i))
+            o = check.not_none(await get_default_interp_resolver().resolve(i))
             sys_exe = o.exe
         else:
             sys_exe = 'python3'
@@ -10929,65 +11266,46 @@ class DeployAppManager(DeployPathOwner):
 
 
 ########################################
-# ../deploy/deploy.py
-
-
-DEPLOY_TAG_DATETIME_FMT = '%Y%m%dT%H%M%SZ'
+# ../deploy/driver.py
 
 
-DeployManagerUtcClock = ta.NewType('DeployManagerUtcClock', Func0[datetime.datetime])
+class DeployDriverFactory(Func1[DeploySpec, ta.ContextManager['DeployDriver']]):
+    pass
 
 
-class DeployManager:
+class DeployDriver:
     def __init__(
             self,
             *,
-            apps: DeployAppManager,
-            paths: DeployPathsManager,
+            spec: DeploySpec,
+            home: DeployHome,
+            time: DeployTime,
 
-            utc_clock: ta.Optional[DeployManagerUtcClock] = None,
-    ):
+            paths: DeployPathsManager,
+            apps: DeployAppManager,
+    ) -> None:
         super().__init__()
 
-        self._apps = apps
-        self._paths = paths
-
-        self._utc_clock = utc_clock
-
-    def _utc_now(self) -> datetime.datetime:
-        if self._utc_clock is not None:
-            return self._utc_clock()  # noqa
-        else:
-            return datetime.datetime.now(tz=datetime.timezone.utc)  # noqa
+        self._spec = spec
+        self._home = home
+        self._time = time
 
-    def _make_deploy_time(self) -> DeployTime:
-        return DeployTime(self._utc_now().strftime(DEPLOY_TAG_DATETIME_FMT))
+        self._paths = paths
+        self._apps = apps
 
-    async def run_deploy(
-            self,
-            spec: DeploySpec,
-    ) -> None:
+    async def drive_deploy(self) -> None:
         self._paths.validate_deploy_paths()
 
         #
 
-        hs = check.non_empty_str(spec.home)
-        hs = os.path.expanduser(hs)
-        hs = os.path.realpath(hs)
-        hs = os.path.abspath(hs)
-
-        home = DeployHome(hs)
-
-        #
-
         deploy_tags = DeployTagMap(
-            self._make_deploy_time(),
-            spec.key(),
+            self._time,
+            self._spec.key(),
         )
 
         #
 
-        for app in spec.apps:
+        for app in self._spec.apps:
             app_tags = deploy_tags.add(
                 app.app,
                 app.key(),
@@ -10996,7 +11314,7 @@ class DeployManager:
 
             await self._apps.prepare_app(
                 app,
-                home,
+                self._home,
                 app_tags,
             )
 
@@ -11019,12 +11337,13 @@ class DeployCommand(Command['DeployCommand.Output']):
 
 @dc.dataclass(frozen=True)
 class DeployCommandExecutor(CommandExecutor[DeployCommand, DeployCommand.Output]):
-    _deploy: DeployManager
+    _driver_factory: DeployDriverFactory
 
     async def execute(self, cmd: DeployCommand) -> DeployCommand.Output:
         log.info('Deploying! %r', cmd.spec)
 
-        await self._deploy.run_deploy(cmd.spec)
+        with self._driver_factory(cmd.spec) as driver:
+            await driver.drive_deploy()
 
         return DeployCommand.Output()
 
@@ -11033,6 +11352,57 @@ class DeployCommandExecutor(CommandExecutor[DeployCommand, DeployCommand.Output]
 # ../deploy/inject.py
 
 
+##
+
+
+class DeployInjectorScope(ContextvarInjectorScope):
+    pass
+
+
+def bind_deploy_scope() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind_scope(DeployInjectorScope),
+        inj.bind_scope_seed(DeploySpec, DeployInjectorScope),
+
+        inj.bind(DeployDriver, in_=DeployInjectorScope),
+    ]
+
+    #
+
+    def provide_deploy_driver_factory(injector: Injector, sc: DeployInjectorScope) -> DeployDriverFactory:
+        @contextlib.contextmanager
+        def factory(spec: DeploySpec) -> ta.Iterator[DeployDriver]:
+            with sc.enter({
+                inj.as_key(DeploySpec): spec,
+            }):
+                yield injector[DeployDriver]
+        return DeployDriverFactory(factory)
+    lst.append(inj.bind(provide_deploy_driver_factory, singleton=True))
+
+    #
+
+    def provide_deploy_home(deploy: DeploySpec) -> DeployHome:
+        hs = check.non_empty_str(deploy.home)
+        hs = os.path.expanduser(hs)
+        hs = os.path.realpath(hs)
+        hs = os.path.abspath(hs)
+        return DeployHome(hs)
+    lst.append(inj.bind(provide_deploy_home, in_=DeployInjectorScope))
+
+    #
+
+    def provide_deploy_time(deploys: DeployManager) -> DeployTime:
+        return deploys.make_deploy_time()
+    lst.append(inj.bind(provide_deploy_time, in_=DeployInjectorScope))
+
+    #
+
+    return inj.as_bindings(*lst)
+
+
+##
+
+
 def bind_deploy(
         *,
         deploy_config: DeployConfig,
@@ -11041,6 +11411,8 @@ def bind_deploy(
         inj.bind(deploy_config),
 
         bind_deploy_paths(),
+
+        bind_deploy_scope(),
     ]
 
     #