omdev 0.0.0.dev221__py3-none-any.whl → 0.0.0.dev223__py3-none-any.whl

omdev/scripts/ci.py

@@ -21,6 +21,7 @@ import asyncio.base_subprocess
 import asyncio.subprocess
 import collections
 import contextlib
+import contextvars
 import dataclasses as dc
 import datetime
 import functools
@@ -44,6 +45,7 @@ import types
 import typing as ta
 import urllib.parse
 import urllib.request
+import weakref
 
 
 ########################################
@@ -80,6 +82,13 @@ ArgparseCmdFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
 ExitStackedT = ta.TypeVar('ExitStackedT', bound='ExitStacked')
 AsyncExitStackedT = ta.TypeVar('AsyncExitStackedT', bound='AsyncExitStacked')
 
+# ../../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
 
@@ -797,6 +806,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
 
@@ -1133,24 +1186,30 @@ def unlinking_if_exists(path: str) -> ta.Iterator[None]:
 # ../cache.py
 
 
+CacheVersion = ta.NewType('CacheVersion', int)
+
+
 ##
 
 
-@abc.abstractmethod
 class FileCache(abc.ABC):
+    DEFAULT_CACHE_VERSION: ta.ClassVar[CacheVersion] = CacheVersion(CI_CACHE_VERSION)
+
     def __init__(
             self,
             *,
-            version: int = CI_CACHE_VERSION,
+            version: ta.Optional[CacheVersion] = None,
     ) -> None:
         super().__init__()
 
+        if version is None:
+            version = self.DEFAULT_CACHE_VERSION
         check.isinstance(version, int)
         check.arg(version >= 0)
-        self._version = version
+        self._version: CacheVersion = version
 
     @property
-    def version(self) -> int:
+    def version(self) -> CacheVersion:
         return self._version
 
     #
@@ -1174,19 +1233,28 @@ class FileCache(abc.ABC):
 
 
 class DirectoryFileCache(FileCache):
+    @dc.dataclass(frozen=True)
+    class Config:
+        dir: str
+
+        no_create: bool = False
+        no_purge: bool = False
+
     def __init__(
             self,
-            dir: str,  # noqa
+            config: Config,
             *,
-            no_create: bool = False,
-            no_purge: bool = False,
-            **kwargs: ta.Any,
+            version: ta.Optional[CacheVersion] = None,
     ) -> None:  # noqa
-        super().__init__(**kwargs)
+        super().__init__(
+            version=version,
+        )
+
+        self._config = config
 
-        self._dir = dir
-        self._no_create = no_create
-        self._no_purge = no_purge
+    @property
+    def dir(self) -> str:
+        return self._config.dir
 
     #
 
@@ -1194,37 +1262,38 @@ class DirectoryFileCache(FileCache):
 
     @cached_nullary
     def setup_dir(self) -> None:
-        version_file = os.path.join(self._dir, self.VERSION_FILE_NAME)
+        version_file = os.path.join(self.dir, self.VERSION_FILE_NAME)
 
-        if self._no_create:
-            check.state(os.path.isdir(self._dir))
+        if self._config.no_create:
+            check.state(os.path.isdir(self.dir))
 
-        elif not os.path.isdir(self._dir):
-            os.makedirs(self._dir)
+        elif not os.path.isdir(self.dir):
+            os.makedirs(self.dir)
             with open(version_file, 'w') as f:
                 f.write(str(self._version))
             return
 
+        # NOTE: intentionally raises FileNotFoundError to refuse to use an existing non-cache dir as a cache dir.
         with open(version_file) as f:
             dir_version = int(f.read().strip())
 
         if dir_version == self._version:
             return
 
-        if self._no_purge:
+        if self._config.no_purge:
             raise RuntimeError(f'{dir_version=} != {self._version=}')
 
-        dirs = [n for n in sorted(os.listdir(self._dir)) if os.path.isdir(os.path.join(self._dir, n))]
+        dirs = [n for n in sorted(os.listdir(self.dir)) if os.path.isdir(os.path.join(self.dir, n))]
         if dirs:
             raise RuntimeError(
-                f'Refusing to remove stale cache dir {self._dir!r} '
+                f'Refusing to remove stale cache dir {self.dir!r} '
                 f'due to present directories: {", ".join(dirs)}',
             )
 
-        for n in sorted(os.listdir(self._dir)):
+        for n in sorted(os.listdir(self.dir)):
             if n.startswith('.'):
                 continue
-            fp = os.path.join(self._dir, n)
+            fp = os.path.join(self.dir, n)
             check.state(os.path.isfile(fp))
             log.debug('Purging stale cache file: %s', fp)
             os.unlink(fp)
@@ -1241,7 +1310,7 @@ class DirectoryFileCache(FileCache):
             key: str,
     ) -> str:
         self.setup_dir()
-        return os.path.join(self._dir, key)
+        return os.path.join(self.dir, key)
 
     def format_incomplete_file(self, f: str) -> str:
         return os.path.join(os.path.dirname(f), f'_{os.path.basename(f)}.incomplete')
@@ -1956,270 +2025,1388 @@ class aclosing(contextlib.AbstractAsyncContextManager):  # noqa
 
 
 ########################################
-# ../../../omlish/lite/runtime.py
-
-
-@cached_nullary
-def is_debugger_attached() -> bool:
-    return any(frame[1].endswith('pydevd.py') for frame in inspect.stack())
-
-
-LITE_REQUIRED_PYTHON_VERSION = (3, 8)
+# ../../../omlish/lite/inject.py
 
 
-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
-"""
+###
+# types
 
 
-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,
-    }
+@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
 
-    def __init__(
-            self,
-            *args: ta.Any,
-            json_dumps: ta.Optional[ta.Callable[[ta.Any], str]] = None,
-            **kwargs: ta.Any,
-    ) -> None:
-        super().__init__(*args, **kwargs)
+    tag: ta.Any = None
+    array: bool = False
 
-        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)
+def is_valid_injector_key_cls(cls: ta.Any) -> bool:
+    return isinstance(cls, type) or is_new_type(cls)
 
 
-########################################
-# ../../../omlish/os/temp.py
+def check_valid_injector_key_cls(cls: T) -> T:
+    if not is_valid_injector_key_cls(cls):
+        raise TypeError(cls)
+    return cls
 
 
-def make_temp_file(**kwargs: ta.Any) -> str:
-    file_fd, file = tempfile.mkstemp(**kwargs)
-    os.close(file_fd)
-    return file
+##
 
 
-@contextlib.contextmanager
-def temp_file_context(**kwargs: ta.Any) -> ta.Iterator[str]:
-    path = make_temp_file(**kwargs)
-    try:
-        yield path
-    finally:
-        unlink_if_exists(path)
+class InjectorProvider(abc.ABC):
+    @abc.abstractmethod
+    def provider_fn(self) -> InjectorProviderFn:
+        raise NotImplementedError
 
 
-@contextlib.contextmanager
-def temp_dir_context(
-        root_dir: ta.Optional[str] = None,
-        **kwargs: ta.Any,
-) -> ta.Iterator[str]:
-    path = tempfile.mkdtemp(dir=root_dir, **kwargs)
-    try:
-        yield path
-    finally:
-        shutil.rmtree(path, ignore_errors=True)
+##
 
 
-@contextlib.contextmanager
-def temp_named_file_context(
-        root_dir: ta.Optional[str] = None,
-        cleanup: bool = True,
-        **kwargs: ta.Any,
-) -> ta.Iterator[tempfile._TemporaryFileWrapper]:  # noqa
-    with tempfile.NamedTemporaryFile(dir=root_dir, delete=False, **kwargs) as f:
-        try:
-            yield f
-        finally:
-            if cleanup:
-                shutil.rmtree(f.name, ignore_errors=True)
+@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)
 
-########################################
-# ../github/client.py
 
+class InjectorBindings(abc.ABC):
+    @abc.abstractmethod
+    def bindings(self) -> ta.Iterator[InjectorBinding]:
+        raise NotImplementedError
 
 ##
 
 
-class GithubCacheClient(abc.ABC):
-    class Entry(abc.ABC):  # noqa
-        pass
+class Injector(abc.ABC):
+    @abc.abstractmethod
+    def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
+        raise NotImplementedError
 
     @abc.abstractmethod
-    def get_entry(self, key: str) -> ta.Awaitable[ta.Optional[Entry]]:
+    def provide(self, key: ta.Any) -> ta.Any:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def download_file(self, entry: Entry, out_file: str) -> ta.Awaitable[None]:
+    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 upload_file(self, key: str, in_file: str) -> ta.Awaitable[None]:
+    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 GithubCacheServiceV1BaseClient(GithubCacheClient, abc.ABC):
-    BASE_URL_ENV_VAR = register_github_env_var('ACTIONS_CACHE_URL')
-    AUTH_TOKEN_ENV_VAR = register_github_env_var('ACTIONS_RUNTIME_TOKEN')  # noqa
 
-    KEY_SUFFIX_ENV_VAR = register_github_env_var('GITHUB_RUN_ID')
+class InjectorError(Exception):
+    pass
 
-    #
 
-    def __init__(
-            self,
-            *,
-            base_url: ta.Optional[str] = None,
-            auth_token: ta.Optional[str] = None,
+@dc.dataclass()
+class InjectorKeyError(InjectorError):
+    key: InjectorKey
 
-            key_prefix: ta.Optional[str] = None,
-            key_suffix: ta.Optional[str] = None,
+    source: ta.Any = None
+    name: ta.Optional[str] = None
 
-            cache_version: int = CI_CACHE_VERSION,
 
-            loop: ta.Optional[asyncio.AbstractEventLoop] = None,
-    ) -> None:
-        super().__init__()
+class UnboundInjectorKeyError(InjectorKeyError):
+    pass
 
-        #
 
-        if base_url is None:
-            base_url = check.non_empty_str(self.BASE_URL_ENV_VAR())
-        self._service_url = GithubCacheServiceV1.get_service_url(base_url)
+class DuplicateInjectorKeyError(InjectorKeyError):
+    pass
 
-        if auth_token is None:
-            auth_token = self.AUTH_TOKEN_ENV_VAR()
-        self._auth_token = auth_token
 
-        #
+class CyclicDependencyInjectorKeyError(InjectorKeyError):
+    pass
 
-        self._key_prefix = key_prefix
 
-        if key_suffix is None:
-            key_suffix = self.KEY_SUFFIX_ENV_VAR()
-        self._key_suffix = check.non_empty_str(key_suffix)
+###
+# keys
 
-        #
 
-        self._cache_version = check.isinstance(cache_version, int)
+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)
 
-        #
 
-        self._given_loop = loop
+###
+# providers
 
-    #
 
-    def _get_loop(self) -> asyncio.AbstractEventLoop:
-        if (loop := self._given_loop) is not None:
-            return loop
-        return asyncio.get_event_loop()
+@dc.dataclass(frozen=True)
+class FnInjectorProvider(InjectorProvider):
+    fn: ta.Any
 
-    #
+    def __post_init__(self) -> None:
+        check.not_isinstance(self.fn, type)
 
-    def build_request_headers(
-            self,
-            headers: ta.Optional[ta.Mapping[str, str]] = None,
-            *,
-            content_type: ta.Optional[str] = None,
-            json_content: bool = False,
-    ) -> ta.Dict[str, str]:
-        dct = {
-            'Accept': ';'.join([
-                'application/json',
-                f'api-version={GithubCacheServiceV1.API_VERSION}',
-            ]),
-        }
+    def provider_fn(self) -> InjectorProviderFn:
+        def pfn(i: Injector) -> ta.Any:
+            return i.inject(self.fn)
 
-        if (auth_token := self._auth_token):
-            dct['Authorization'] = f'Bearer {auth_token}'
+        return pfn
 
-        if content_type is None and json_content:
-            content_type = 'application/json'
-        if content_type is not None:
-            dct['Content-Type'] = content_type
 
-        if headers:
-            dct.update(headers)
+@dc.dataclass(frozen=True)
+class CtorInjectorProvider(InjectorProvider):
+    cls_: type
 
-        return dct
+    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_)
 
-    def load_json_bytes(self, b: ta.Optional[bytes]) -> ta.Optional[ta.Any]:
-        if not b:
-            return None
-        return json.loads(b.decode('utf-8-sig'))
+        return pfn
 
-    #
 
-    async def send_url_request(
-            self,
-            req: urllib.request.Request,
-    ) -> ta.Tuple[http.client.HTTPResponse, ta.Optional[bytes]]:
-        def run_sync():
-            with urllib.request.urlopen(req) as resp:  # noqa
-                body = resp.read()
-            return (resp, body)
+@dc.dataclass(frozen=True)
+class ConstInjectorProvider(InjectorProvider):
+    v: ta.Any
 
-        return await self._get_loop().run_in_executor(None, run_sync)  # noqa
+    def provider_fn(self) -> InjectorProviderFn:
+        return lambda _: self.v
 
-    #
 
-    @dc.dataclass()
-    class ServiceRequestError(RuntimeError):
-        status_code: int
-        body: ta.Optional[bytes]
+@dc.dataclass(frozen=True)
+class SingletonInjectorProvider(InjectorProvider):
+    p: InjectorProvider
 
-        def __str__(self) -> str:
-            return repr(self)
+    def __post_init__(self) -> None:
+        check.isinstance(self.p, InjectorProvider)
 
-    async def send_service_request(
-            self,
-            path: str,
-            *,
-            method: ta.Optional[str] = None,
-            headers: ta.Optional[ta.Mapping[str, str]] = None,
-            content_type: ta.Optional[str] = None,
+    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)
+
+
+########################################
+# ../../../omlish/os/temp.py
+
+
+def make_temp_file(**kwargs: ta.Any) -> str:
+    file_fd, file = tempfile.mkstemp(**kwargs)
+    os.close(file_fd)
+    return file
+
+
+@contextlib.contextmanager
+def temp_file_context(**kwargs: ta.Any) -> ta.Iterator[str]:
+    path = make_temp_file(**kwargs)
+    try:
+        yield path
+    finally:
+        unlink_if_exists(path)
+
+
+@contextlib.contextmanager
+def temp_dir_context(
+        root_dir: ta.Optional[str] = None,
+        **kwargs: ta.Any,
+) -> ta.Iterator[str]:
+    path = tempfile.mkdtemp(dir=root_dir, **kwargs)
+    try:
+        yield path
+    finally:
+        shutil.rmtree(path, ignore_errors=True)
+
+
+@contextlib.contextmanager
+def temp_named_file_context(
+        root_dir: ta.Optional[str] = None,
+        cleanup: bool = True,
+        **kwargs: ta.Any,
+) -> ta.Iterator[tempfile._TemporaryFileWrapper]:  # noqa
+    with tempfile.NamedTemporaryFile(dir=root_dir, delete=False, **kwargs) as f:
+        try:
+            yield f
+        finally:
+            if cleanup:
+                shutil.rmtree(f.name, ignore_errors=True)
+
+
+########################################
+# ../docker/utils.py
+"""
+TODO:
+ - some less stupid Dockerfile hash
+  - doesn't change too much though
+"""
+
+
+##
+
+
+def build_docker_file_hash(docker_file: str) -> str:
+    with open(docker_file) as f:
+        contents = f.read()
+
+    return sha256_str(contents)
+
+
+##
+
+
+def read_docker_tar_image_tag(tar_file: str) -> str:
+    with tarfile.open(tar_file) as tf:
+        with contextlib.closing(check.not_none(tf.extractfile('manifest.json'))) as mf:
+            m = mf.read()
+
+    manifests = json.loads(m.decode('utf-8'))
+    manifest = check.single(manifests)
+    tag = check.non_empty_str(check.single(manifest['RepoTags']))
+    return tag
+
+
+def read_docker_tar_image_id(tar_file: str) -> str:
+    with tarfile.open(tar_file) as tf:
+        with contextlib.closing(check.not_none(tf.extractfile('index.json'))) as mf:
+            i = mf.read()
+
+    index = json.loads(i.decode('utf-8'))
+    manifest = check.single(index['manifests'])
+    image_id = check.non_empty_str(manifest['digest'])
+    return image_id
+
+
+########################################
+# ../github/client.py
+
+
+##
+
+
+class GithubCacheClient(abc.ABC):
+    class Entry(abc.ABC):  # noqa
+        pass
+
+    @abc.abstractmethod
+    def get_entry(self, key: str) -> ta.Awaitable[ta.Optional[Entry]]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def download_file(self, entry: Entry, out_file: str) -> ta.Awaitable[None]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def upload_file(self, key: str, in_file: str) -> ta.Awaitable[None]:
+        raise NotImplementedError
+
+
+##
+
+
+class GithubCacheServiceV1BaseClient(GithubCacheClient, abc.ABC):
+    BASE_URL_ENV_VAR = register_github_env_var('ACTIONS_CACHE_URL')
+    AUTH_TOKEN_ENV_VAR = register_github_env_var('ACTIONS_RUNTIME_TOKEN')  # noqa
+
+    KEY_SUFFIX_ENV_VAR = register_github_env_var('GITHUB_RUN_ID')
+
+    #
+
+    def __init__(
+            self,
+            *,
+            base_url: ta.Optional[str] = None,
+            auth_token: ta.Optional[str] = None,
+
+            key_prefix: ta.Optional[str] = None,
+            key_suffix: ta.Optional[str] = None,
+
+            cache_version: int = CI_CACHE_VERSION,
+
+            loop: ta.Optional[asyncio.AbstractEventLoop] = None,
+    ) -> None:
+        super().__init__()
+
+        #
+
+        if base_url is None:
+            base_url = check.non_empty_str(self.BASE_URL_ENV_VAR())
+        self._service_url = GithubCacheServiceV1.get_service_url(base_url)
+
+        if auth_token is None:
+            auth_token = self.AUTH_TOKEN_ENV_VAR()
+        self._auth_token = auth_token
+
+        #
+
+        self._key_prefix = key_prefix
+
+        if key_suffix is None:
+            key_suffix = self.KEY_SUFFIX_ENV_VAR()
+        self._key_suffix = check.non_empty_str(key_suffix)
+
+        #
+
+        self._cache_version = check.isinstance(cache_version, int)
+
+        #
+
+        self._given_loop = loop
+
+    #
+
+    def _get_loop(self) -> asyncio.AbstractEventLoop:
+        if (loop := self._given_loop) is not None:
+            return loop
+        return asyncio.get_event_loop()
+
+    #
+
+    def build_request_headers(
+            self,
+            headers: ta.Optional[ta.Mapping[str, str]] = None,
+            *,
+            content_type: ta.Optional[str] = None,
+            json_content: bool = False,
+    ) -> ta.Dict[str, str]:
+        dct = {
+            'Accept': ';'.join([
+                'application/json',
+                f'api-version={GithubCacheServiceV1.API_VERSION}',
+            ]),
+        }
+
+        if (auth_token := self._auth_token):
+            dct['Authorization'] = f'Bearer {auth_token}'
+
+        if content_type is None and json_content:
+            content_type = 'application/json'
+        if content_type is not None:
+            dct['Content-Type'] = content_type
+
+        if headers:
+            dct.update(headers)
+
+        return dct
+
+    #
+
+    def load_json_bytes(self, b: ta.Optional[bytes]) -> ta.Optional[ta.Any]:
+        if not b:
+            return None
+        return json.loads(b.decode('utf-8-sig'))
+
+    #
+
+    async def send_url_request(
+            self,
+            req: urllib.request.Request,
+    ) -> ta.Tuple[http.client.HTTPResponse, ta.Optional[bytes]]:
+        def run_sync():
+            with urllib.request.urlopen(req) as resp:  # noqa
+                body = resp.read()
+            return (resp, body)
+
+        return await self._get_loop().run_in_executor(None, run_sync)  # noqa
+
+    #
+
+    @dc.dataclass()
+    class ServiceRequestError(RuntimeError):
+        status_code: int
+        body: ta.Optional[bytes]
+
+        def __str__(self) -> str:
+            return repr(self)
+
+    async def send_service_request(
+            self,
+            path: str,
+            *,
+            method: ta.Optional[str] = None,
+            headers: ta.Optional[ta.Mapping[str, str]] = None,
+            content_type: ta.Optional[str] = None,
             content: ta.Optional[bytes] = None,
             json_content: ta.Optional[ta.Any] = None,
             success_status_codes: ta.Optional[ta.Container[int]] = None,
@@ -2911,7 +4098,51 @@ class BaseSubprocesses(abc.ABC):  # noqa
 ##
 
 
+@dc.dataclass(frozen=True)
+class SubprocessRun:
+    cmd: ta.Sequence[str]
+    input: ta.Any = None
+    timeout: ta.Optional[float] = None
+    check: bool = False
+    capture_output: ta.Optional[bool] = None
+    kwargs: ta.Optional[ta.Mapping[str, ta.Any]] = None
+
+
+@dc.dataclass(frozen=True)
+class SubprocessRunOutput(ta.Generic[T]):
+    proc: T
+
+    returncode: int  # noqa
+
+    stdout: ta.Optional[bytes] = None
+    stderr: ta.Optional[bytes] = None
+
+
 class AbstractSubprocesses(BaseSubprocesses, abc.ABC):
+    @abc.abstractmethod
+    def run_(self, run: SubprocessRun) -> SubprocessRunOutput:
+        raise NotImplementedError
+
+    def run(
+            self,
+            *cmd: str,
+            input: ta.Any = None,  # noqa
+            timeout: ta.Optional[float] = None,
+            check: bool = False,
+            capture_output: ta.Optional[bool] = None,
+            **kwargs: ta.Any,
+    ) -> SubprocessRunOutput:
+        return self.run_(SubprocessRun(
+            cmd=cmd,
+            input=input,
+            timeout=timeout,
+            check=check,
+            capture_output=capture_output,
+            kwargs=kwargs,
+        ))
+
+    #
+
     @abc.abstractmethod
     def check_call(
             self,
@@ -2975,6 +4206,25 @@ class AbstractSubprocesses(BaseSubprocesses, abc.ABC):
 
 
 class Subprocesses(AbstractSubprocesses):
+    def run_(self, run: SubprocessRun) -> SubprocessRunOutput[subprocess.CompletedProcess]:
+        proc = subprocess.run(
+            run.cmd,
+            input=run.input,
+            timeout=run.timeout,
+            check=run.check,
+            capture_output=run.capture_output or False,
+            **(run.kwargs or {}),
+        )
+
+        return SubprocessRunOutput(
+            proc=proc,
+
+            returncode=proc.returncode,
+
+            stdout=proc.stdout,  # noqa
+            stderr=proc.stderr,  # noqa
+        )
+
     def check_call(
             self,
             *cmd: str,
@@ -3000,6 +4250,30 @@ subprocesses = Subprocesses()
 
 
 class AbstractAsyncSubprocesses(BaseSubprocesses):
+    @abc.abstractmethod
+    async def run_(self, run: SubprocessRun) -> SubprocessRunOutput:
+        raise NotImplementedError
+
+    def run(
+            self,
+            *cmd: str,
+            input: ta.Any = None,  # noqa
+            timeout: ta.Optional[float] = None,
+            check: bool = False,
+            capture_output: ta.Optional[bool] = None,
+            **kwargs: ta.Any,
+    ) -> ta.Awaitable[SubprocessRunOutput]:
+        return self.run_(SubprocessRun(
+            cmd=cmd,
+            input=input,
+            timeout=timeout,
+            check=check,
+            capture_output=capture_output,
+            kwargs=kwargs,
+        ))
+
+    #
+
     @abc.abstractmethod
     async def check_call(
             self,
@@ -3067,16 +4341,22 @@ class AbstractAsyncSubprocesses(BaseSubprocesses):
 
 
 class GithubFileCache(FileCache):
+    @dc.dataclass(frozen=True)
+    class Config:
+        dir: str
+
     def __init__(
             self,
-            dir: str,  # noqa
+            config: Config,
             *,
             client: ta.Optional[GithubCacheClient] = None,
-            **kwargs: ta.Any,
+            version: ta.Optional[CacheVersion] = None,
     ) -> None:
-        super().__init__(**kwargs)
+        super().__init__(
+            version=version,
+        )
 
-        self._dir = check.not_none(dir)
+        self._config = config
 
         if client is None:
             client = GithubCacheServiceV1Client(
@@ -3085,7 +4365,9 @@ class GithubFileCache(FileCache):
         self._client: GithubCacheClient = client
 
         self._local = DirectoryFileCache(
-            self._dir,
+            DirectoryFileCache.Config(
+                dir=check.non_empty_str(config.dir),
+            ),
             version=self._version,
         )
 
@@ -3388,41 +4670,32 @@ class AsyncioSubprocesses(AbstractAsyncSubprocesses):
 
     #
 
-    @dc.dataclass(frozen=True)
-    class RunOutput:
-        proc: asyncio.subprocess.Process
-        stdout: ta.Optional[bytes]
-        stderr: ta.Optional[bytes]
+    async def run_(self, run: SubprocessRun) -> SubprocessRunOutput[asyncio.subprocess.Process]:
+        kwargs = dict(run.kwargs or {})
 
-    async def run(
-            self,
-            *cmd: str,
-            input: ta.Any = None,  # noqa
-            timeout: ta.Optional[float] = None,
-            check: bool = False,  # noqa
-            capture_output: ta.Optional[bool] = None,
-            **kwargs: ta.Any,
-    ) -> RunOutput:
-        if capture_output:
+        if run.capture_output:
             kwargs.setdefault('stdout', subprocess.PIPE)
             kwargs.setdefault('stderr', subprocess.PIPE)
 
         proc: asyncio.subprocess.Process
-        async with self.popen(*cmd, **kwargs) as proc:
-            stdout, stderr = await self.communicate(proc, input, timeout)
+        async with self.popen(*run.cmd, **kwargs) as proc:
+            stdout, stderr = await self.communicate(proc, run.input, run.timeout)
 
         if check and proc.returncode:
             raise subprocess.CalledProcessError(
                 proc.returncode,
-                cmd,
+                run.cmd,
                 output=stdout,
                 stderr=stderr,
             )
 
-        return self.RunOutput(
-            proc,
-            stdout,
-            stderr,
+        return SubprocessRunOutput(
+            proc=proc,
+
+            returncode=check.isinstance(proc.returncode, int),
+
+            stdout=stdout,
+            stderr=stderr,
         )
 
     #
@@ -3615,47 +4888,7 @@ class DockerComposeRun(AsyncExitStacked):
 
 
 ########################################
-# ../docker.py
-"""
-TODO:
- - some less stupid Dockerfile hash
-  - doesn't change too much though
-"""
-
-
-##
-
-
-def build_docker_file_hash(docker_file: str) -> str:
-    with open(docker_file) as f:
-        contents = f.read()
-
-    return sha256_str(contents)
-
-
-##
-
-
-def read_docker_tar_image_tag(tar_file: str) -> str:
-    with tarfile.open(tar_file) as tf:
-        with contextlib.closing(check.not_none(tf.extractfile('manifest.json'))) as mf:
-            m = mf.read()
-
-    manifests = json.loads(m.decode('utf-8'))
-    manifest = check.single(manifests)
-    tag = check.non_empty_str(check.single(manifest['RepoTags']))
-    return tag
-
-
-def read_docker_tar_image_id(tar_file: str) -> str:
-    with tarfile.open(tar_file) as tf:
-        with contextlib.closing(check.not_none(tf.extractfile('index.json'))) as mf:
-            i = mf.read()
-
-    index = json.loads(i.decode('utf-8'))
-    manifest = check.single(index['manifests'])
-    image_id = check.non_empty_str(manifest['digest'])
-    return image_id
+# ../docker/cmds.py
 
 
 ##
@@ -3772,75 +5005,58 @@ async def load_docker_tar(
 
 
 ########################################
-# ../ci.py
+# ../github/inject.py
 
 
-class Ci(AsyncExitStacked):
-    KEY_HASH_LEN = 16
+##
 
-    @dc.dataclass(frozen=True)
-    class Config:
-        project_dir: str
 
-        docker_file: str
+def bind_github(
+        *,
+        cache_dir: ta.Optional[str] = None,
+) -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = []
+
+    if cache_dir is not None:
+        lst.extend([
+            inj.bind(GithubFileCache.Config(
+                dir=cache_dir,
+            )),
+            inj.bind(GithubFileCache, singleton=True),
+            inj.bind(FileCache, to_key=GithubFileCache),
+        ])
 
-        compose_file: str
-        service: str
+    return inj.as_bindings(*lst)
 
-        cmd: ShellCmd
 
-        #
+########################################
+# ../docker/cache.py
 
-        requirements_txts: ta.Optional[ta.Sequence[str]] = None
 
-        always_pull: bool = False
-        always_build: bool = False
+##
 
-        no_dependencies: bool = False
 
-        run_options: ta.Optional[ta.Sequence[str]] = None
+class DockerCache(abc.ABC):
+    @abc.abstractmethod
+    def load_cache_docker_image(self, key: str) -> ta.Awaitable[ta.Optional[str]]:
+        raise NotImplementedError
 
-        #
+    @abc.abstractmethod
+    def save_cache_docker_image(self, key: str, image: str) -> ta.Awaitable[None]:
+        raise NotImplementedError
 
-        def __post_init__(self) -> None:
-            check.not_isinstance(self.requirements_txts, str)
 
+class DockerCacheImpl(DockerCache):
     def __init__(
             self,
-            cfg: Config,
             *,
             file_cache: ta.Optional[FileCache] = None,
     ) -> None:
         super().__init__()
 
-        self._cfg = cfg
         self._file_cache = file_cache
 
-    #
-
-    async def _load_docker_image(self, image: str) -> None:
-        if not self._cfg.always_pull and (await is_docker_image_present(image)):
-            return
-
-        dep_suffix = image
-        for c in '/:.-_':
-            dep_suffix = dep_suffix.replace(c, '-')
-
-        cache_key = f'docker-{dep_suffix}'
-        if (await self._load_cache_docker_image(cache_key)) is not None:
-            return
-
-        await pull_docker_image(image)
-
-        await self._save_cache_docker_image(cache_key, image)
-
-    async def load_docker_image(self, image: str) -> None:
-        with log_timing_context(f'Load docker image: {image}'):
-            await self._load_docker_image(image)
-
-    #
-
-    async def _load_cache_docker_image(self, key: str) -> ta.Optional[str]:
+    async def load_cache_docker_image(self, key: str) -> ta.Optional[str]:
         if self._file_cache is None:
             return None
 
@@ -3852,7 +5068,7 @@ class Ci(AsyncExitStacked):
 
         return await load_docker_tar_cmd(get_cache_cmd)
 
-    async def _save_cache_docker_image(self, key: str, image: str) -> None:
+    async def save_cache_docker_image(self, key: str, image: str) -> None:
         if self._file_cache is None:
             return
 
@@ -3863,19 +5079,58 @@ class Ci(AsyncExitStacked):
 
             await self._file_cache.put_file(key, tmp_file, steal=True)
 
-    #
 
-    async def _resolve_docker_image(
+########################################
+# ../docker/buildcaching.py
+
+
+##
+
+
+class DockerBuildCaching(abc.ABC):
+    @abc.abstractmethod
+    def cached_build_docker_image(
+            self,
+            cache_key: str,
+            build_and_tag: ta.Callable[[str], ta.Awaitable[str]],  # image_tag -> image_id
+    ) -> ta.Awaitable[str]:
+        raise NotImplementedError
+
+
+class DockerBuildCachingImpl(DockerBuildCaching):
+    @dc.dataclass(frozen=True)
+    class Config:
+        service: str
+
+        always_build: bool = False
+
+    def __init__(
+            self,
+            *,
+            config: Config,
+
+            docker_cache: ta.Optional[DockerCache] = None,
+    ) -> None:
+        super().__init__()
+
+        self._config = config
+
+        self._docker_cache = docker_cache
+
+    async def cached_build_docker_image(
             self,
             cache_key: str,
             build_and_tag: ta.Callable[[str], ta.Awaitable[str]],
     ) -> str:
-        image_tag = f'{self._cfg.service}:{cache_key}'
+        image_tag = f'{self._config.service}:{cache_key}'
 
-        if not self._cfg.always_build and (await is_docker_image_present(image_tag)):
+        if not self._config.always_build and (await is_docker_image_present(image_tag)):
             return image_tag
 
-        if (cache_image_id := await self._load_cache_docker_image(cache_key)) is not None:
+        if (
+                self._docker_cache is not None and
+                (cache_image_id := await self._docker_cache.load_cache_docker_image(cache_key)) is not None
+        ):
             await tag_docker_image(
                 cache_image_id,
                 image_tag,
@@ -3884,27 +5139,143 @@ class Ci(AsyncExitStacked):
 
         image_id = await build_and_tag(image_tag)
 
-        await self._save_cache_docker_image(cache_key, image_id)
+        if self._docker_cache is not None:
+            await self._docker_cache.save_cache_docker_image(cache_key, image_id)
 
         return image_tag
 
+
+########################################
+# ../docker/imagepulling.py
+
+
+##
+
+
+class DockerImagePulling(abc.ABC):
+    @abc.abstractmethod
+    def pull_docker_image(self, image: str) -> ta.Awaitable[None]:
+        raise NotImplementedError
+
+
+class DockerImagePullingImpl(DockerImagePulling):
+    @dc.dataclass(frozen=True)
+    class Config:
+        always_pull: bool = False
+
+    def __init__(
+            self,
+            *,
+            config: Config = Config(),
+
+            file_cache: ta.Optional[FileCache] = None,
+            docker_cache: ta.Optional[DockerCache] = None,
+    ) -> None:
+        super().__init__()
+
+        self._config = config
+
+        self._file_cache = file_cache
+        self._docker_cache = docker_cache
+
+    async def _pull_docker_image(self, image: str) -> None:
+        if not self._config.always_pull and (await is_docker_image_present(image)):
+            return
+
+        dep_suffix = image
+        for c in '/:.-_':
+            dep_suffix = dep_suffix.replace(c, '-')
+
+        cache_key = f'docker-{dep_suffix}'
+        if (
+                self._docker_cache is not None and
+                (await self._docker_cache.load_cache_docker_image(cache_key)) is not None
+        ):
+            return
+
+        await pull_docker_image(image)
+
+        if self._docker_cache is not None:
+            await self._docker_cache.save_cache_docker_image(cache_key, image)
+
+    async def pull_docker_image(self, image: str) -> None:
+        with log_timing_context(f'Load docker image: {image}'):
+            await self._pull_docker_image(image)
+
+
+########################################
+# ../ci.py
+
+
+##
+
+
+class Ci(AsyncExitStacked):
+    KEY_HASH_LEN = 16
+
+    @dc.dataclass(frozen=True)
+    class Config:
+        project_dir: str
+
+        docker_file: str
+
+        compose_file: str
+        service: str
+
+        cmd: ShellCmd
+
+        #
+
+        requirements_txts: ta.Optional[ta.Sequence[str]] = None
+
+        always_pull: bool = False
+        always_build: bool = False
+
+        no_dependencies: bool = False
+
+        run_options: ta.Optional[ta.Sequence[str]] = None
+
+        #
+
+        def __post_init__(self) -> None:
+            check.not_isinstance(self.requirements_txts, str)
+
+    def __init__(
+            self,
+            config: Config,
+            *,
+            docker_build_caching: DockerBuildCaching,
+            docker_image_pulling: DockerImagePulling,
+    ) -> None:
+        super().__init__()
+
+        self._config = config
+
+        self._docker_build_caching = docker_build_caching
+        self._docker_image_pulling = docker_image_pulling
+
     #
 
     @cached_nullary
     def docker_file_hash(self) -> str:
-        return build_docker_file_hash(self._cfg.docker_file)[:self.KEY_HASH_LEN]
+        return build_docker_file_hash(self._config.docker_file)[:self.KEY_HASH_LEN]
+
+    @cached_nullary
+    def ci_base_image_cache_key(self) -> str:
+        return f'ci-base-{self.docker_file_hash()}'
 
     async def _resolve_ci_base_image(self) -> str:
         async def build_and_tag(image_tag: str) -> str:
             return await build_docker_image(
-                self._cfg.docker_file,
+                self._config.docker_file,
                 tag=image_tag,
-                cwd=self._cfg.project_dir,
+                cwd=self._config.project_dir,
             )
 
-        cache_key = f'ci-base-{self.docker_file_hash()}'
-
-        return await self._resolve_docker_image(cache_key, build_and_tag)
+        return await self._docker_build_caching.cached_build_docker_image(
+            self.ci_base_image_cache_key(),
+            build_and_tag,
+        )
 
     @async_cached_nullary
     async def resolve_ci_base_image(self) -> str:
@@ -3918,14 +5289,18 @@ class Ci(AsyncExitStacked):
     @cached_nullary
     def requirements_txts(self) -> ta.Sequence[str]:
         return [
-            os.path.join(self._cfg.project_dir, rf)
-            for rf in check.not_none(self._cfg.requirements_txts)
+            os.path.join(self._config.project_dir, rf)
+            for rf in check.not_none(self._config.requirements_txts)
         ]
 
     @cached_nullary
     def requirements_hash(self) -> str:
         return build_requirements_hash(self.requirements_txts())[:self.KEY_HASH_LEN]
 
+    @cached_nullary
+    def ci_image_cache_key(self) -> str:
+        return f'ci-{self.docker_file_hash()}-{self.requirements_hash()}'
+
     async def _resolve_ci_image(self) -> str:
         async def build_and_tag(image_tag: str) -> str:
             base_image = await self.resolve_ci_base_image()
@@ -3942,7 +5317,7 @@ class Ci(AsyncExitStacked):
                     '--no-cache',
                     '--index-strategy unsafe-best-match',
                     '--system',
-                    *[f'-r /project/{rf}' for rf in self._cfg.requirements_txts or []],
+                    *[f'-r /project/{rf}' for rf in self._config.requirements_txts or []],
                 ]),
             ]
             setup_cmd = ' && '.join(setup_cmds)
@@ -3950,7 +5325,7 @@ class Ci(AsyncExitStacked):
             docker_file_lines = [
                 f'FROM {base_image}',
                 'RUN mkdir /project',
-                *[f'COPY {rf} /project/{rf}' for rf in self._cfg.requirements_txts or []],
+                *[f'COPY {rf} /project/{rf}' for rf in self._config.requirements_txts or []],
                 f'RUN {setup_cmd}',
                 'RUN rm /project/*',
                 'WORKDIR /project',
@@ -3963,12 +5338,13 @@ class Ci(AsyncExitStacked):
                 return await build_docker_image(
                     docker_file,
                     tag=image_tag,
-                    cwd=self._cfg.project_dir,
+                    cwd=self._config.project_dir,
                 )
 
-        cache_key = f'ci-{self.docker_file_hash()}-{self.requirements_hash()}'
-
-        return await self._resolve_docker_image(cache_key, build_and_tag)
+        return await self._docker_build_caching.cached_build_docker_image(
+            self.ci_image_cache_key(),
+            build_and_tag,
+        )
 
     @async_cached_nullary
     async def resolve_ci_image(self) -> str:
@@ -3980,34 +5356,34 @@ class Ci(AsyncExitStacked):
     #
 
     @async_cached_nullary
-    async def load_dependencies(self) -> None:
+    async def pull_dependencies(self) -> None:
         deps = get_compose_service_dependencies(
-            self._cfg.compose_file,
-            self._cfg.service,
+            self._config.compose_file,
+            self._config.service,
         )
 
         for dep_image in deps.values():
-            await self.load_docker_image(dep_image)
+            await self._docker_image_pulling.pull_docker_image(dep_image)
 
     #
 
     async def _run_compose_(self) -> None:
         async with DockerComposeRun(DockerComposeRun.Config(
-            compose_file=self._cfg.compose_file,
-            service=self._cfg.service,
+            compose_file=self._config.compose_file,
+            service=self._config.service,
 
             image=await self.resolve_ci_image(),
 
-            cmd=self._cfg.cmd,
+            cmd=self._config.cmd,
 
             run_options=[
-                '-v', f'{os.path.abspath(self._cfg.project_dir)}:/project',
-                *(self._cfg.run_options or []),
+                '-v', f'{os.path.abspath(self._config.project_dir)}:/project',
+                *(self._config.run_options or []),
             ],
 
-            cwd=self._cfg.project_dir,
+            cwd=self._config.project_dir,
 
-            no_dependencies=self._cfg.no_dependencies,
+            no_dependencies=self._config.no_dependencies,
         )) as ci_compose_run:
             await ci_compose_run.run()
 
@@ -4020,11 +5396,90 @@ class Ci(AsyncExitStacked):
     async def run(self) -> None:
         await self.resolve_ci_image()
 
-        await self.load_dependencies()
+        await self.pull_dependencies()
 
         await self._run_compose()
 
 
+########################################
+# ../docker/inject.py
+
+
+##
+
+
+def bind_docker(
+    *,
+    build_caching_config: DockerBuildCachingImpl.Config,
+    image_pulling_config: DockerImagePullingImpl.Config = DockerImagePullingImpl.Config(),
+) -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind(build_caching_config),
+        inj.bind(DockerBuildCachingImpl, singleton=True),
+        inj.bind(DockerBuildCaching, to_key=DockerBuildCachingImpl),
+
+        inj.bind(DockerCacheImpl, singleton=True),
+        inj.bind(DockerCache, to_key=DockerCacheImpl),
+
+        inj.bind(image_pulling_config),
+        inj.bind(DockerImagePullingImpl, singleton=True),
+        inj.bind(DockerImagePulling, to_key=DockerImagePullingImpl),
+    ]
+
+    return inj.as_bindings(*lst)
+
+
+########################################
+# ../inject.py
+
+
+##
+
+
+def bind_ci(
+        *,
+        config: Ci.Config,
+
+        github: bool = False,
+
+        cache_dir: ta.Optional[str] = None,
+) -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [  # noqa
+        inj.bind(config),
+        inj.bind(Ci, singleton=True),
+    ]
+
+    lst.append(bind_docker(
+        build_caching_config=DockerBuildCachingImpl.Config(
+            service=config.service,
+
+            always_build=config.always_build,
+        ),
+
+        image_pulling_config=DockerImagePullingImpl.Config(
+            always_pull=config.always_pull,
+        ),
+    ))
+
+    if cache_dir is not None:
+        if github:
+            lst.append(bind_github(
+                cache_dir=cache_dir,
+            ))
+
+        else:
+            lst.extend([
+                inj.bind(DirectoryFileCache.Config(
+                    dir=cache_dir,
+                )),
+                inj.bind(DirectoryFileCache, singleton=True),
+                inj.bind(FileCache, to_key=DirectoryFileCache),
+
+            ])
+
+    return inj.as_bindings(*lst)
+
+
 ########################################
 # cli.py
 
@@ -4159,14 +5614,9 @@ class CiCli(ArgparseCli):
 
         #
 
-        file_cache: ta.Optional[FileCache] = None
         if cache_dir is not None:
             cache_dir = os.path.abspath(cache_dir)
             log.debug('Using cache dir %s', cache_dir)
-            if github:
-                file_cache = GithubFileCache(cache_dir)
-            else:
-                file_cache = DirectoryFileCache(cache_dir)
 
         #
 
@@ -4182,28 +5632,35 @@ class CiCli(ArgparseCli):
 
         #
 
-        async with Ci(
-                Ci.Config(
-                    project_dir=project_dir,
+        config = Ci.Config(
+            project_dir=project_dir,
 
-                    docker_file=docker_file,
+            docker_file=docker_file,
 
-                    compose_file=compose_file,
-                    service=self.args.service,
+            compose_file=compose_file,
+            service=self.args.service,
 
-                    requirements_txts=requirements_txts,
+            requirements_txts=requirements_txts,
 
-                    cmd=ShellCmd(cmd),
+            cmd=ShellCmd(cmd),
 
-                    always_pull=self.args.always_pull,
-                    always_build=self.args.always_build,
+            always_pull=self.args.always_pull,
+            always_build=self.args.always_build,
 
-                    no_dependencies=self.args.no_dependencies,
+            no_dependencies=self.args.no_dependencies,
 
-                    run_options=run_options,
-                ),
-                file_cache=file_cache,
-        ) as ci:
+            run_options=run_options,
+        )
+
+        injector = inj.create_injector(bind_ci(
+            config=config,
+
+            github=github,
+
+            cache_dir=cache_dir,
+        ))
+
+        async with injector[Ci] as ci:
             await ci.run()