omdev 0.0.0.dev209__py3-none-any.whl → 0.0.0.dev210__py3-none-any.whl

omdev/scripts/ci.py

@@ -0,0 +1,2183 @@
+#!/usr/bin/env python3
+# noinspection DuplicatedCode
+# @omlish-lite
+# @omlish-script
+# @omlish-amalg-output ../ci/cli.py
+# ruff: noqa: UP006 UP007 UP036
+"""
+Inputs:
+ - requirements.txt
+ - ci.Dockerfile
+ - compose.yml
+
+==
+
+./python -m ci run --cache-dir ci/cache ci/project omlish-ci
+"""
+import abc
+import argparse
+import asyncio
+import collections
+import contextlib
+import dataclasses as dc
+import functools
+import hashlib
+import inspect
+import itertools
+import json
+import logging
+import os
+import os.path
+import shlex
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+import threading
+import time
+import types
+import typing as ta
+
+
+########################################
+
+
+if sys.version_info < (3, 8):
+    raise OSError(f'Requires python (3, 8), got {sys.version_info} from {sys.executable}')  # noqa
+
+
+########################################
+
+
+# ../../omlish/lite/cached.py
+T = ta.TypeVar('T')
+CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
+
+# ../../omlish/lite/check.py
+SizedT = ta.TypeVar('SizedT', bound=ta.Sized)
+CheckMessage = ta.Union[str, ta.Callable[..., ta.Optional[str]], None]  # ta.TypeAlias
+CheckLateConfigureFn = ta.Callable[['Checks'], None]  # ta.TypeAlias
+CheckOnRaiseFn = ta.Callable[[Exception], None]  # ta.TypeAlias
+CheckExceptionFactory = ta.Callable[..., Exception]  # ta.TypeAlias
+CheckArgsRenderer = ta.Callable[..., ta.Optional[str]]  # ta.TypeAlias
+
+# ../../omlish/argparse/cli.py
+ArgparseCmdFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
+
+# ../../omlish/lite/contextmanagers.py
+ExitStackedT = ta.TypeVar('ExitStackedT', bound='ExitStacked')
+
+# ../../omlish/subprocesses.py
+SubprocessChannelOption = ta.Literal['pipe', 'stdout', 'devnull']  # ta.TypeAlias
+
+
+########################################
+# ../cache.py
+
+
+#
+
+
+@abc.abstractmethod
+class FileCache(abc.ABC):
+    @abc.abstractmethod
+    def get_file(self, name: str) -> ta.Optional[str]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def put_file(self, name: str) -> ta.Optional[str]:
+        raise NotImplementedError
+
+
+#
+
+
+class DirectoryFileCache(FileCache):
+    def __init__(self, dir: str) -> None:  # noqa
+        super().__init__()
+
+        self._dir = dir
+
+    def get_file(self, name: str) -> ta.Optional[str]:
+        file_path = os.path.join(self._dir, name)
+        if not os.path.exists(file_path):
+            return None
+        return file_path
+
+    def put_file(self, file_path: str) -> None:
+        os.makedirs(self._dir, exist_ok=True)
+        cache_file_path = os.path.join(self._dir, os.path.basename(file_path))
+        shutil.copyfile(file_path, cache_file_path)
+
+
+########################################
+# ../utils.py
+
+
+##
+
+
+def make_temp_file() -> str:
+    file_fd, file = tempfile.mkstemp()
+    os.close(file_fd)
+    return file
+
+
+##
+
+
+def read_yaml_file(yaml_file: str) -> ta.Any:
+    yaml = __import__('yaml')
+
+    with open(yaml_file) as f:
+        return yaml.safe_load(f)
+
+
+##
+
+
+def sha256_str(s: str) -> str:
+    return hashlib.sha256(s.encode('utf-8')).hexdigest()
+
+
+########################################
+# ../../../omlish/lite/cached.py
+
+
+##
+
+
+class _AbstractCachedNullary:
+    def __init__(self, fn):
+        super().__init__()
+        self._fn = fn
+        self._value = self._missing = object()
+        functools.update_wrapper(self, fn)
+
+    def __call__(self, *args, **kwargs):  # noqa
+        raise TypeError
+
+    def __get__(self, instance, owner):  # noqa
+        bound = instance.__dict__[self._fn.__name__] = self.__class__(self._fn.__get__(instance, owner))
+        return bound
+
+
+##
+
+
+class _CachedNullary(_AbstractCachedNullary):
+    def __call__(self, *args, **kwargs):  # noqa
+        if self._value is self._missing:
+            self._value = self._fn()
+        return self._value
+
+
+def cached_nullary(fn: CallableT) -> CallableT:
+    return _CachedNullary(fn)  # type: ignore
+
+
+def static_init(fn: CallableT) -> CallableT:
+    fn = cached_nullary(fn)
+    fn()
+    return fn
+
+
+##
+
+
+class _AsyncCachedNullary(_AbstractCachedNullary):
+    async def __call__(self, *args, **kwargs):
+        if self._value is self._missing:
+            self._value = await self._fn()
+        return self._value
+
+
+def async_cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
+    return _AsyncCachedNullary(fn)
+
+
+########################################
+# ../../../omlish/lite/check.py
+"""
+TODO:
+ - def maybe(v: lang.Maybe[T])
+ - def not_ ?
+ - ** class @dataclass Raise - user message should be able to be an exception type or instance or factory
+"""
+
+
+##
+
+
+class Checks:
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._config_lock = threading.RLock()
+        self._on_raise_fns: ta.Sequence[CheckOnRaiseFn] = []
+        self._exception_factory: CheckExceptionFactory = Checks.default_exception_factory
+        self._args_renderer: ta.Optional[CheckArgsRenderer] = None
+        self._late_configure_fns: ta.Sequence[CheckLateConfigureFn] = []
+
+    @staticmethod
+    def default_exception_factory(exc_cls: ta.Type[Exception], *args, **kwargs) -> Exception:
+        return exc_cls(*args, **kwargs)  # noqa
+
+    #
+
+    def register_on_raise(self, fn: CheckOnRaiseFn) -> None:
+        with self._config_lock:
+            self._on_raise_fns = [*self._on_raise_fns, fn]
+
+    def unregister_on_raise(self, fn: CheckOnRaiseFn) -> None:
+        with self._config_lock:
+            self._on_raise_fns = [e for e in self._on_raise_fns if e != fn]
+
+    #
+
+    def set_exception_factory(self, factory: CheckExceptionFactory) -> None:
+        self._exception_factory = factory
+
+    def set_args_renderer(self, renderer: ta.Optional[CheckArgsRenderer]) -> None:
+        self._args_renderer = renderer
+
+    #
+
+    def register_late_configure(self, fn: CheckLateConfigureFn) -> None:
+        with self._config_lock:
+            self._late_configure_fns = [*self._late_configure_fns, fn]
+
+    def _late_configure(self) -> None:
+        if not self._late_configure_fns:
+            return
+
+        with self._config_lock:
+            if not (lc := self._late_configure_fns):
+                return
+
+            for fn in lc:
+                fn(self)
+
+            self._late_configure_fns = []
+
+    #
+
+    class _ArgsKwargs:
+        def __init__(self, *args, **kwargs):
+            self.args = args
+            self.kwargs = kwargs
+
+    def _raise(
+            self,
+            exception_type: ta.Type[Exception],
+            default_message: str,
+            message: CheckMessage,
+            ak: _ArgsKwargs = _ArgsKwargs(),
+            *,
+            render_fmt: ta.Optional[str] = None,
+    ) -> ta.NoReturn:
+        exc_args = ()
+        if callable(message):
+            message = ta.cast(ta.Callable, message)(*ak.args, **ak.kwargs)
+            if isinstance(message, tuple):
+                message, *exc_args = message  # type: ignore
+
+        if message is None:
+            message = default_message
+
+        self._late_configure()
+
+        if render_fmt is not None and (af := self._args_renderer) is not None:
+            rendered_args = af(render_fmt, *ak.args)
+            if rendered_args is not None:
+                message = f'{message} : {rendered_args}'
+
+        exc = self._exception_factory(
+            exception_type,
+            message,
+            *exc_args,
+            *ak.args,
+            **ak.kwargs,
+        )
+
+        for fn in self._on_raise_fns:
+            fn(exc)
+
+        raise exc
+
+    #
+
+    def _unpack_isinstance_spec(self, spec: ta.Any) -> tuple:
+        if isinstance(spec, type):
+            return (spec,)
+        if not isinstance(spec, tuple):
+            spec = (spec,)
+        if None in spec:
+            spec = tuple(filter(None, spec)) + (None.__class__,)  # noqa
+        if ta.Any in spec:
+            spec = (object,)
+        return spec
+
+    def isinstance(self, v: ta.Any, spec: ta.Union[ta.Type[T], tuple], msg: CheckMessage = None) -> T:  # noqa
+        if not isinstance(v, self._unpack_isinstance_spec(spec)):
+            self._raise(
+                TypeError,
+                'Must be instance',
+                msg,
+                Checks._ArgsKwargs(v, spec),
+                render_fmt='not isinstance(%s, %s)',
+            )
+
+        return v
+
+    def of_isinstance(self, spec: ta.Union[ta.Type[T], tuple], msg: CheckMessage = None) -> ta.Callable[[ta.Any], T]:
+        def inner(v):
+            return self.isinstance(v, self._unpack_isinstance_spec(spec), msg)
+
+        return inner
+
+    def cast(self, v: ta.Any, cls: ta.Type[T], msg: CheckMessage = None) -> T:  # noqa
+        if not isinstance(v, cls):
+            self._raise(
+                TypeError,
+                'Must be instance',
+                msg,
+                Checks._ArgsKwargs(v, cls),
+            )
+
+        return v
+
+    def of_cast(self, cls: ta.Type[T], msg: CheckMessage = None) -> ta.Callable[[T], T]:
+        def inner(v):
+            return self.cast(v, cls, msg)
+
+        return inner
+
+    def not_isinstance(self, v: T, spec: ta.Any, msg: CheckMessage = None) -> T:  # noqa
+        if isinstance(v, self._unpack_isinstance_spec(spec)):
+            self._raise(
+                TypeError,
+                'Must not be instance',
+                msg,
+                Checks._ArgsKwargs(v, spec),
+                render_fmt='isinstance(%s, %s)',
+            )
+
+        return v
+
+    def of_not_isinstance(self, spec: ta.Any, msg: CheckMessage = None) -> ta.Callable[[T], T]:
+        def inner(v):
+            return self.not_isinstance(v, self._unpack_isinstance_spec(spec), msg)
+
+        return inner
+
+    ##
+
+    def issubclass(self, v: ta.Type[T], spec: ta.Any, msg: CheckMessage = None) -> ta.Type[T]:  # noqa
+        if not issubclass(v, spec):
+            self._raise(
+                TypeError,
+                'Must be subclass',
+                msg,
+                Checks._ArgsKwargs(v, spec),
+                render_fmt='not issubclass(%s, %s)',
+            )
+
+        return v
+
+    def not_issubclass(self, v: ta.Type[T], spec: ta.Any, msg: CheckMessage = None) -> ta.Type[T]:  # noqa
+        if issubclass(v, spec):
+            self._raise(
+                TypeError,
+                'Must not be subclass',
+                msg,
+                Checks._ArgsKwargs(v, spec),
+                render_fmt='issubclass(%s, %s)',
+            )
+
+        return v
+
+    #
+
+    def in_(self, v: T, c: ta.Container[T], msg: CheckMessage = None) -> T:
+        if v not in c:
+            self._raise(
+                ValueError,
+                'Must be in',
+                msg,
+                Checks._ArgsKwargs(v, c),
+                render_fmt='%s not in %s',
+            )
+
+        return v
+
+    def not_in(self, v: T, c: ta.Container[T], msg: CheckMessage = None) -> T:
+        if v in c:
+            self._raise(
+                ValueError,
+                'Must not be in',
+                msg,
+                Checks._ArgsKwargs(v, c),
+                render_fmt='%s in %s',
+            )
+
+        return v
+
+    def empty(self, v: SizedT, msg: CheckMessage = None) -> SizedT:
+        if len(v) != 0:
+            self._raise(
+                ValueError,
+                'Must be empty',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v
+
+    def iterempty(self, v: ta.Iterable[T], msg: CheckMessage = None) -> ta.Iterable[T]:
+        it = iter(v)
+        try:
+            next(it)
+        except StopIteration:
+            pass
+        else:
+            self._raise(
+                ValueError,
+                'Must be empty',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v
+
+    def not_empty(self, v: SizedT, msg: CheckMessage = None) -> SizedT:
+        if len(v) == 0:
+            self._raise(
+                ValueError,
+                'Must not be empty',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v
+
+    def unique(self, it: ta.Iterable[T], msg: CheckMessage = None) -> ta.Iterable[T]:
+        dupes = [e for e, c in collections.Counter(it).items() if c > 1]
+        if dupes:
+            self._raise(
+                ValueError,
+                'Must be unique',
+                msg,
+                Checks._ArgsKwargs(it, dupes),
+            )
+
+        return it
+
+    def single(self, obj: ta.Iterable[T], message: CheckMessage = None) -> T:
+        try:
+            [value] = obj
+        except ValueError:
+            self._raise(
+                ValueError,
+                'Must be single',
+                message,
+                Checks._ArgsKwargs(obj),
+                render_fmt='%s',
+            )
+
+        return value
+
+    def opt_single(self, obj: ta.Iterable[T], message: CheckMessage = None) -> ta.Optional[T]:
+        it = iter(obj)
+        try:
+            value = next(it)
+        except StopIteration:
+            return None
+
+        try:
+            next(it)
+        except StopIteration:
+            return value  # noqa
+
+        self._raise(
+            ValueError,
+            'Must be empty or single',
+            message,
+            Checks._ArgsKwargs(obj),
+            render_fmt='%s',
+        )
+
+        raise RuntimeError  # noqa
+
+    #
+
+    def none(self, v: ta.Any, msg: CheckMessage = None) -> None:
+        if v is not None:
+            self._raise(
+                ValueError,
+                'Must be None',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+    def not_none(self, v: ta.Optional[T], msg: CheckMessage = None) -> T:
+        if v is None:
+            self._raise(
+                ValueError,
+                'Must not be None',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v
+
+    #
+
+    def equal(self, v: T, o: ta.Any, msg: CheckMessage = None) -> T:
+        if o != v:
+            self._raise(
+                ValueError,
+                'Must be equal',
+                msg,
+                Checks._ArgsKwargs(v, o),
+                render_fmt='%s != %s',
+            )
+
+        return v
+
+    def is_(self, v: T, o: ta.Any, msg: CheckMessage = None) -> T:
+        if o is not v:
+            self._raise(
+                ValueError,
+                'Must be the same',
+                msg,
+                Checks._ArgsKwargs(v, o),
+                render_fmt='%s is not %s',
+            )
+
+        return v
+
+    def is_not(self, v: T, o: ta.Any, msg: CheckMessage = None) -> T:
+        if o is v:
+            self._raise(
+                ValueError,
+                'Must not be the same',
+                msg,
+                Checks._ArgsKwargs(v, o),
+                render_fmt='%s is %s',
+            )
+
+        return v
+
+    def callable(self, v: T, msg: CheckMessage = None) -> T:  # noqa
+        if not callable(v):
+            self._raise(
+                TypeError,
+                'Must be callable',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v  # type: ignore
+
+    def non_empty_str(self, v: ta.Optional[str], msg: CheckMessage = None) -> str:
+        if not isinstance(v, str) or not v:
+            self._raise(
+                ValueError,
+                'Must be non-empty str',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v
+
+    def replacing(self, expected: ta.Any, old: ta.Any, new: T, msg: CheckMessage = None) -> T:
+        if old != expected:
+            self._raise(
+                ValueError,
+                'Must be replacing',
+                msg,
+                Checks._ArgsKwargs(expected, old, new),
+                render_fmt='%s -> %s -> %s',
+            )
+
+        return new
+
+    def replacing_none(self, old: ta.Any, new: T, msg: CheckMessage = None) -> T:
+        if old is not None:
+            self._raise(
+                ValueError,
+                'Must be replacing None',
+                msg,
+                Checks._ArgsKwargs(old, new),
+                render_fmt='%s -> %s',
+            )
+
+        return new
+
+    #
+
+    def arg(self, v: bool, msg: CheckMessage = None) -> None:
+        if not v:
+            self._raise(
+                RuntimeError,
+                'Argument condition not met',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+    def state(self, v: bool, msg: CheckMessage = None) -> None:
+        if not v:
+            self._raise(
+                RuntimeError,
+                'State condition not met',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+
+check = Checks()
+
+
+########################################
+# ../../../omlish/lite/json.py
+
+
+##
+
+
+JSON_PRETTY_INDENT = 2
+
+JSON_PRETTY_KWARGS: ta.Mapping[str, ta.Any] = dict(
+    indent=JSON_PRETTY_INDENT,
+)
+
+json_dump_pretty: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON_PRETTY_KWARGS)  # type: ignore
+json_dumps_pretty: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_PRETTY_KWARGS)
+
+
+##
+
+
+JSON_COMPACT_SEPARATORS = (',', ':')
+
+JSON_COMPACT_KWARGS: ta.Mapping[str, ta.Any] = dict(
+    indent=None,
+    separators=JSON_COMPACT_SEPARATORS,
+)
+
+json_dump_compact: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON_COMPACT_KWARGS)  # type: ignore
+json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_COMPACT_KWARGS)
+
+
+########################################
+# ../../../omlish/lite/reflect.py
+
+
+##
+
+
+_GENERIC_ALIAS_TYPES = (
+    ta._GenericAlias,  # type: ignore  # noqa
+    *([ta._SpecialGenericAlias] if hasattr(ta, '_SpecialGenericAlias') else []),  # noqa
+)
+
+
+def is_generic_alias(obj, *, origin: ta.Any = None) -> bool:
+    return (
+        isinstance(obj, _GENERIC_ALIAS_TYPES) and
+        (origin is None or ta.get_origin(obj) is origin)
+    )
+
+
+is_union_alias = functools.partial(is_generic_alias, origin=ta.Union)
+is_callable_alias = functools.partial(is_generic_alias, origin=ta.Callable)
+
+
+##
+
+
+def is_optional_alias(spec: ta.Any) -> bool:
+    return (
+        isinstance(spec, _GENERIC_ALIAS_TYPES) and  # noqa
+        ta.get_origin(spec) is ta.Union and
+        len(ta.get_args(spec)) == 2 and
+        any(a in (None, type(None)) for a in ta.get_args(spec))
+    )
+
+
+def get_optional_alias_arg(spec: ta.Any) -> ta.Any:
+    [it] = [it for it in ta.get_args(spec) if it not in (None, type(None))]
+    return it
+
+
+##
+
+
+def is_new_type(spec: ta.Any) -> bool:
+    if isinstance(ta.NewType, type):
+        return isinstance(spec, ta.NewType)
+    else:
+        # Before https://github.com/python/cpython/commit/c2f33dfc83ab270412bf243fb21f724037effa1a
+        return isinstance(spec, types.FunctionType) and spec.__code__ is ta.NewType.__code__.co_consts[1]  # type: ignore  # noqa
+
+
+def get_new_type_supertype(spec: ta.Any) -> ta.Any:
+    return spec.__supertype__
+
+
+##
+
+
+def is_literal_type(spec: ta.Any) -> bool:
+    if hasattr(ta, '_LiteralGenericAlias'):
+        return isinstance(spec, ta._LiteralGenericAlias)  # noqa
+    else:
+        return (
+            isinstance(spec, ta._GenericAlias) and  # type: ignore  # noqa
+            spec.__origin__ is ta.Literal
+        )
+
+
+def get_literal_type_args(spec: ta.Any) -> ta.Iterable[ta.Any]:
+    return spec.__args__
+
+
+##
+
+
+def deep_subclasses(cls: ta.Type[T]) -> ta.Iterator[ta.Type[T]]:
+    seen = set()
+    todo = list(reversed(cls.__subclasses__()))
+    while todo:
+        cur = todo.pop()
+        if cur in seen:
+            continue
+        seen.add(cur)
+        yield cur
+        todo.extend(reversed(cur.__subclasses__()))
+
+
+########################################
+# ../../../omlish/argparse/cli.py
+"""
+TODO:
+ - default command
+ - auto match all underscores to hyphens
+ - pre-run, post-run hooks
+ - exitstack?
+"""
+
+
+##
+
+
+@dc.dataclass(eq=False)
+class ArgparseArg:
+    args: ta.Sequence[ta.Any]
+    kwargs: ta.Mapping[str, ta.Any]
+    dest: ta.Optional[str] = None
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        return getattr(instance.args, self.dest)  # type: ignore
+
+
+def argparse_arg(*args, **kwargs) -> ArgparseArg:
+    return ArgparseArg(args, kwargs)
+
+
+#
+
+
+@dc.dataclass(eq=False)
+class ArgparseCmd:
+    name: str
+    fn: ArgparseCmdFn
+    args: ta.Sequence[ArgparseArg] = ()  # noqa
+
+    # _: dc.KW_ONLY
+
+    aliases: ta.Optional[ta.Sequence[str]] = None
+    parent: ta.Optional['ArgparseCmd'] = None
+    accepts_unknown: bool = False
+
+    def __post_init__(self) -> None:
+        def check_name(s: str) -> None:
+            check.isinstance(s, str)
+            check.not_in('_', s)
+            check.not_empty(s)
+        check_name(self.name)
+        check.not_isinstance(self.aliases, str)
+        for a in self.aliases or []:
+            check_name(a)
+
+        check.arg(callable(self.fn))
+        check.arg(all(isinstance(a, ArgparseArg) for a in self.args))
+        check.isinstance(self.parent, (ArgparseCmd, type(None)))
+        check.isinstance(self.accepts_unknown, bool)
+
+        functools.update_wrapper(self, self.fn)
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        return dc.replace(self, fn=self.fn.__get__(instance, owner))  # noqa
+
+    def __call__(self, *args, **kwargs) -> ta.Optional[int]:
+        return self.fn(*args, **kwargs)
+
+
+def argparse_cmd(
+        *args: ArgparseArg,
+        name: ta.Optional[str] = None,
+        aliases: ta.Optional[ta.Iterable[str]] = None,
+        parent: ta.Optional[ArgparseCmd] = None,
+        accepts_unknown: bool = False,
+) -> ta.Any:  # ta.Callable[[ArgparseCmdFn], ArgparseCmd]:  # FIXME
+    for arg in args:
+        check.isinstance(arg, ArgparseArg)
+    check.isinstance(name, (str, type(None)))
+    check.isinstance(parent, (ArgparseCmd, type(None)))
+    check.not_isinstance(aliases, str)
+
+    def inner(fn):
+        return ArgparseCmd(
+            (name if name is not None else fn.__name__).replace('_', '-'),
+            fn,
+            args,
+            aliases=tuple(aliases) if aliases is not None else None,
+            parent=parent,
+            accepts_unknown=accepts_unknown,
+        )
+
+    return inner
+
+
+##
+
+
+def _get_argparse_arg_ann_kwargs(ann: ta.Any) -> ta.Mapping[str, ta.Any]:
+    if ann is str:
+        return {}
+    elif ann is int:
+        return {'type': int}
+    elif ann is bool:
+        return {'action': 'store_true'}
+    elif ann is list:
+        return {'action': 'append'}
+    elif is_optional_alias(ann):
+        return _get_argparse_arg_ann_kwargs(get_optional_alias_arg(ann))
+    else:
+        raise TypeError(ann)
+
+
+class _ArgparseCliAnnotationBox:
+    def __init__(self, annotations: ta.Mapping[str, ta.Any]) -> None:
+        super().__init__()
+        self.__annotations__ = annotations  # type: ignore
+
+
+class ArgparseCli:
+    def __init__(self, argv: ta.Optional[ta.Sequence[str]] = None) -> None:
+        super().__init__()
+
+        self._argv = argv if argv is not None else sys.argv[1:]
+
+        self._args, self._unknown_args = self.get_parser().parse_known_args(self._argv)
+
+    #
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        ns = cls.__dict__
+        objs = {}
+        mro = cls.__mro__[::-1]
+        for bns in [bcls.__dict__ for bcls in reversed(mro)] + [ns]:
+            bseen = set()  # type: ignore
+            for k, v in bns.items():
+                if isinstance(v, (ArgparseCmd, ArgparseArg)):
+                    check.not_in(v, bseen)
+                    bseen.add(v)
+                    objs[k] = v
+                elif k in objs:
+                    del [k]
+
+        #
+
+        anns = ta.get_type_hints(_ArgparseCliAnnotationBox({
+            **{k: v for bcls in reversed(mro) for k, v in getattr(bcls, '__annotations__', {}).items()},
+            **ns.get('__annotations__', {}),
+        }), globalns=ns.get('__globals__', {}))
+
+        #
+
+        if '_parser' in ns:
+            parser = check.isinstance(ns['_parser'], argparse.ArgumentParser)
+        else:
+            parser = argparse.ArgumentParser()
+            setattr(cls, '_parser', parser)
+
+        #
+
+        subparsers = parser.add_subparsers()
+
+        for att, obj in objs.items():
+            if isinstance(obj, ArgparseCmd):
+                if obj.parent is not None:
+                    raise NotImplementedError
+
+                for cn in [obj.name, *(obj.aliases or [])]:
+                    subparser = subparsers.add_parser(cn)
+
+                    for arg in (obj.args or []):
+                        if (
+                                len(arg.args) == 1 and
+                                isinstance(arg.args[0], str) and
+                                not (n := check.isinstance(arg.args[0], str)).startswith('-') and
+                                'metavar' not in arg.kwargs
+                        ):
+                            subparser.add_argument(
+                                n.replace('-', '_'),
+                                **arg.kwargs,
+                                metavar=n,
+                            )
+                        else:
+                            subparser.add_argument(*arg.args, **arg.kwargs)
+
+                    subparser.set_defaults(_cmd=obj)
+
+            elif isinstance(obj, ArgparseArg):
+                if att in anns:
+                    ann_kwargs = _get_argparse_arg_ann_kwargs(anns[att])
+                    obj.kwargs = {**ann_kwargs, **obj.kwargs}
+
+                if not obj.dest:
+                    if 'dest' in obj.kwargs:
+                        obj.dest = obj.kwargs['dest']
+                    else:
+                        obj.dest = obj.kwargs['dest'] = att  # type: ignore
+
+                parser.add_argument(*obj.args, **obj.kwargs)
+
+            else:
+                raise TypeError(obj)
+
+    #
+
+    _parser: ta.ClassVar[argparse.ArgumentParser]
+
+    @classmethod
+    def get_parser(cls) -> argparse.ArgumentParser:
+        return cls._parser
+
+    @property
+    def argv(self) -> ta.Sequence[str]:
+        return self._argv
+
+    @property
+    def args(self) -> argparse.Namespace:
+        return self._args
+
+    @property
+    def unknown_args(self) -> ta.Sequence[str]:
+        return self._unknown_args
+
+    #
+
+    def _bind_cli_cmd(self, cmd: ArgparseCmd) -> ta.Callable:
+        return cmd.__get__(self, type(self))
+
+    def prepare_cli_run(self) -> ta.Optional[ta.Callable]:
+        cmd = getattr(self.args, '_cmd', None)
+
+        if self._unknown_args and not (cmd is not None and cmd.accepts_unknown):
+            msg = f'unrecognized arguments: {" ".join(self._unknown_args)}'
+            if (parser := self.get_parser()).exit_on_error:  # type: ignore
+                parser.error(msg)
+            else:
+                raise argparse.ArgumentError(None, msg)
+
+        if cmd is None:
+            self.get_parser().print_help()
+            return None
+
+        return self._bind_cli_cmd(cmd)
+
+    #
+
+    def cli_run(self) -> ta.Optional[int]:
+        if (fn := self.prepare_cli_run()) is None:
+            return 0
+
+        return fn()
+
+    def cli_run_and_exit(self) -> ta.NoReturn:
+        sys.exit(rc if isinstance(rc := self.cli_run(), int) else 0)
+
+    def __call__(self, *, exit: bool = False) -> ta.Optional[int]:  # noqa
+        if exit:
+            return self.cli_run_and_exit()
+        else:
+            return self.cli_run()
+
+    #
+
+    async def async_cli_run(
+            self,
+            *,
+            force_async: bool = False,
+    ) -> ta.Optional[int]:
+        if (fn := self.prepare_cli_run()) is None:
+            return 0
+
+        if force_async:
+            is_async = True
+        else:
+            tfn = fn
+            if isinstance(tfn, ArgparseCmd):
+                tfn = tfn.fn
+            is_async = inspect.iscoroutinefunction(tfn)
+
+        if is_async:
+            return await fn()
+        else:
+            return fn()
+
+
+########################################
+# ../../../omlish/lite/contextmanagers.py
+
+
+##
+
+
+class ExitStacked:
+    _exit_stack: ta.Optional[contextlib.ExitStack] = None
+
+    def __enter__(self: ExitStackedT) -> ExitStackedT:
+        check.state(self._exit_stack is None)
+        es = self._exit_stack = contextlib.ExitStack()
+        es.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if (es := self._exit_stack) is None:
+            return None
+        self._exit_contexts()
+        return es.__exit__(exc_type, exc_val, exc_tb)
+
+    def _exit_contexts(self) -> None:
+        pass
+
+    def _enter_context(self, cm: ta.ContextManager[T]) -> T:
+        es = check.not_none(self._exit_stack)
+        return es.enter_context(cm)
+
+
+##
+
+
+@contextlib.contextmanager
+def defer(fn: ta.Callable) -> ta.Generator[ta.Callable, None, None]:
+    try:
+        yield fn
+    finally:
+        fn()
+
+
+@contextlib.contextmanager
+def attr_setting(obj, attr, val, *, default=None):  # noqa
+    not_set = object()
+    orig = getattr(obj, attr, not_set)
+    try:
+        setattr(obj, attr, val)
+        if orig is not not_set:
+            yield orig
+        else:
+            yield default
+    finally:
+        if orig is not_set:
+            delattr(obj, attr)
+        else:
+            setattr(obj, attr, orig)
+
+
+##
+
+
+class aclosing(contextlib.AbstractAsyncContextManager):  # noqa
+    def __init__(self, thing):
+        self.thing = thing
+
+    async def __aenter__(self):
+        return self.thing
+
+    async def __aexit__(self, *exc_info):
+        await self.thing.aclose()
+
+
+########################################
+# ../../../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/subprocesses.py
+
+
+##
+
+
+SUBPROCESS_CHANNEL_OPTION_VALUES: ta.Mapping[SubprocessChannelOption, int] = {
+    'pipe': subprocess.PIPE,
+    'stdout': subprocess.STDOUT,
+    'devnull': subprocess.DEVNULL,
+}
+
+
+##
+
+
+_SUBPROCESS_SHELL_WRAP_EXECS = False
+
+
+def subprocess_shell_wrap_exec(*cmd: str) -> ta.Tuple[str, ...]:
+    return ('sh', '-c', ' '.join(map(shlex.quote, cmd)))
+
+
+def subprocess_maybe_shell_wrap_exec(*cmd: str) -> ta.Tuple[str, ...]:
+    if _SUBPROCESS_SHELL_WRAP_EXECS or is_debugger_attached():
+        return subprocess_shell_wrap_exec(*cmd)
+    else:
+        return cmd
+
+
+##
+
+
+def subprocess_close(
+        proc: subprocess.Popen,
+        timeout: ta.Optional[float] = None,
+) -> None:
+    # TODO: terminate, sleep, kill
+    if proc.stdout:
+        proc.stdout.close()
+    if proc.stderr:
+        proc.stderr.close()
+    if proc.stdin:
+        proc.stdin.close()
+
+    proc.wait(timeout)
+
+
+##
+
+
+class BaseSubprocesses(abc.ABC):  # noqa
+    DEFAULT_LOGGER: ta.ClassVar[ta.Optional[logging.Logger]] = None
+
+    def __init__(
+            self,
+            *,
+            log: ta.Optional[logging.Logger] = None,
+            try_exceptions: ta.Optional[ta.Tuple[ta.Type[Exception], ...]] = None,
+    ) -> None:
+        super().__init__()
+
+        self._log = log if log is not None else self.DEFAULT_LOGGER
+        self._try_exceptions = try_exceptions if try_exceptions is not None else self.DEFAULT_TRY_EXCEPTIONS
+
+    def set_logger(self, log: ta.Optional[logging.Logger]) -> None:
+        self._log = log
+
+    #
+
+    def prepare_args(
+            self,
+            *cmd: str,
+            env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+            extra_env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+            quiet: bool = False,
+            shell: bool = False,
+            **kwargs: ta.Any,
+    ) -> ta.Tuple[ta.Tuple[ta.Any, ...], ta.Dict[str, ta.Any]]:
+        if self._log:
+            self._log.debug('Subprocesses.prepare_args: cmd=%r', cmd)
+            if extra_env:
+                self._log.debug('Subprocesses.prepare_args: extra_env=%r', extra_env)
+
+        if extra_env:
+            env = {**(env if env is not None else os.environ), **extra_env}
+
+        if quiet and 'stderr' not in kwargs:
+            if self._log and not self._log.isEnabledFor(logging.DEBUG):
+                kwargs['stderr'] = subprocess.DEVNULL
+
+        if not shell:
+            cmd = subprocess_maybe_shell_wrap_exec(*cmd)
+
+        return cmd, dict(
+            env=env,
+            shell=shell,
+            **kwargs,
+        )
+
+    @contextlib.contextmanager
+    def wrap_call(self, *cmd: ta.Any, **kwargs: ta.Any) -> ta.Iterator[None]:
+        start_time = time.time()
+        try:
+            if self._log:
+                self._log.debug('Subprocesses.wrap_call.try: cmd=%r', cmd)
+            yield
+
+        except Exception as exc:  # noqa
+            if self._log:
+                self._log.debug('Subprocesses.wrap_call.except: exc=%r', exc)
+            raise
+
+        finally:
+            end_time = time.time()
+            elapsed_s = end_time - start_time
+            if self._log:
+                self._log.debug('sSubprocesses.wrap_call.finally: elapsed_s=%f cmd=%r', elapsed_s, cmd)
+
+    @contextlib.contextmanager
+    def prepare_and_wrap(
+            self,
+            *cmd: ta.Any,
+            **kwargs: ta.Any,
+    ) -> ta.Iterator[ta.Tuple[
+        ta.Tuple[ta.Any, ...],
+        ta.Dict[str, ta.Any],
+    ]]:
+        cmd, kwargs = self.prepare_args(*cmd, **kwargs)
+        with self.wrap_call(*cmd, **kwargs):
+            yield cmd, kwargs
+
+    #
+
+    DEFAULT_TRY_EXCEPTIONS: ta.Tuple[ta.Type[Exception], ...] = (
+        FileNotFoundError,
+        subprocess.CalledProcessError,
+    )
+
+    def try_fn(
+            self,
+            fn: ta.Callable[..., T],
+            *cmd: str,
+            try_exceptions: ta.Optional[ta.Tuple[ta.Type[Exception], ...]] = None,
+            **kwargs: ta.Any,
+    ) -> ta.Union[T, Exception]:
+        if try_exceptions is None:
+            try_exceptions = self._try_exceptions
+
+        try:
+            return fn(*cmd, **kwargs)
+
+        except try_exceptions as e:  # noqa
+            if self._log and self._log.isEnabledFor(logging.DEBUG):
+                self._log.exception('command failed')
+            return e
+
+    async def async_try_fn(
+            self,
+            fn: ta.Callable[..., ta.Awaitable[T]],
+            *cmd: ta.Any,
+            try_exceptions: ta.Optional[ta.Tuple[ta.Type[Exception], ...]] = None,
+            **kwargs: ta.Any,
+    ) -> ta.Union[T, Exception]:
+        if try_exceptions is None:
+            try_exceptions = self._try_exceptions
+
+        try:
+            return await fn(*cmd, **kwargs)
+
+        except try_exceptions as e:  # noqa
+            if self._log and self._log.isEnabledFor(logging.DEBUG):
+                self._log.exception('command failed')
+            return e
+
+
+##
+
+
+class AbstractSubprocesses(BaseSubprocesses, abc.ABC):
+    @abc.abstractmethod
+    def check_call(
+            self,
+            *cmd: str,
+            stdout: ta.Any = sys.stderr,
+            **kwargs: ta.Any,
+    ) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def check_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bytes:
+        raise NotImplementedError
+
+    #
+
+    def check_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> str:
+        return self.check_output(*cmd, **kwargs).decode().strip()
+
+    #
+
+    def try_call(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bool:
+        if isinstance(self.try_fn(self.check_call, *cmd, **kwargs), Exception):
+            return False
+        else:
+            return True
+
+    def try_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[bytes]:
+        if isinstance(ret := self.try_fn(self.check_output, *cmd, **kwargs), Exception):
+            return None
+        else:
+            return ret
+
+    def try_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[str]:
+        if (ret := self.try_output(*cmd, **kwargs)) is None:
+            return None
+        else:
+            return ret.decode().strip()
+
+
+##
+
+
+class Subprocesses(AbstractSubprocesses):
+    def check_call(
+            self,
+            *cmd: str,
+            stdout: ta.Any = sys.stderr,
+            **kwargs: ta.Any,
+    ) -> None:
+        with self.prepare_and_wrap(*cmd, stdout=stdout, **kwargs) as (cmd, kwargs):  # noqa
+            subprocess.check_call(cmd, **kwargs)
+
+    def check_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bytes:
+        with self.prepare_and_wrap(*cmd, **kwargs) as (cmd, kwargs):  # noqa
+            return subprocess.check_output(cmd, **kwargs)
+
+
+subprocesses = Subprocesses()
+
+
+##
+
+
+class AbstractAsyncSubprocesses(BaseSubprocesses):
+    @abc.abstractmethod
+    async def check_call(
+            self,
+            *cmd: str,
+            stdout: ta.Any = sys.stderr,
+            **kwargs: ta.Any,
+    ) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def check_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bytes:
+        raise NotImplementedError
+
+    #
+
+    async def check_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> str:
+        return (await self.check_output(*cmd, **kwargs)).decode().strip()
+
+    #
+
+    async def try_call(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bool:
+        if isinstance(await self.async_try_fn(self.check_call, *cmd, **kwargs), Exception):
+            return False
+        else:
+            return True
+
+    async def try_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[bytes]:
+        if isinstance(ret := await self.async_try_fn(self.check_output, *cmd, **kwargs), Exception):
+            return None
+        else:
+            return ret
+
+    async def try_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[str]:
+        if (ret := await self.try_output(*cmd, **kwargs)) is None:
+            return None
+        else:
+            return ret.decode().strip()
+
+
+########################################
+# ../compose.py
+"""
+TODO:
+ - fix rmi - only when not referenced anymore
+"""
+
+
+##
+
+
+def get_compose_service_dependencies(
+        compose_file: str,
+        service: str,
+) -> ta.Dict[str, str]:
+    compose_dct = read_yaml_file(compose_file)
+
+    services = compose_dct['services']
+    service_dct = services[service]
+
+    out = {}
+    for dep_service in service_dct.get('depends_on', []):
+        dep_service_dct = services[dep_service]
+        out[dep_service] = dep_service_dct['image']
+
+    return out
+
+
+##
+
+
+class DockerComposeRun(ExitStacked):
+    @dc.dataclass(frozen=True)
+    class Config:
+        compose_file: str
+        service: str
+
+        image: str
+
+        run_cmd: ta.Sequence[str]
+
+        #
+
+        run_options: ta.Optional[ta.Sequence[str]] = None
+
+        cwd: ta.Optional[str] = None
+
+        #
+
+        def __post_init__(self) -> None:
+            check.not_isinstance(self.run_cmd, str)
+
+            check.not_isinstance(self.run_options, str)
+
+    def __init__(self, cfg: Config) -> None:
+        super().__init__()
+
+        self._cfg = cfg
+
+        self._subprocess_kwargs = {
+            **(dict(cwd=self._cfg.cwd) if self._cfg.cwd is not None else {}),
+        }
+
+    #
+
+    @property
+    def image_tag(self) -> str:
+        pfx = 'sha256:'
+        if (image := self._cfg.image).startswith(pfx):
+            image = image[len(pfx):]
+
+        return f'{self._cfg.service}:{image}'
+
+    @cached_nullary
+    def tag_image(self) -> str:
+        image_tag = self.image_tag
+
+        subprocesses.check_call(
+            'docker',
+            'tag',
+            self._cfg.image,
+            image_tag,
+            **self._subprocess_kwargs,
+        )
+
+        def delete_tag() -> None:
+            subprocesses.check_call(
+                'docker',
+                'rmi',
+                image_tag,
+                **self._subprocess_kwargs,
+            )
+
+        self._enter_context(defer(delete_tag))  # noqa
+
+        return image_tag
+
+    #
+
+    def _rewrite_compose_dct(self, in_dct: ta.Dict[str, ta.Any]) -> ta.Dict[str, ta.Any]:
+        out = dict(in_dct)
+
+        #
+
+        in_services = in_dct['services']
+        out['services'] = out_services = {}
+
+        #
+
+        in_service: dict = in_services[self._cfg.service]
+        out_services[self._cfg.service] = out_service = dict(in_service)
+
+        out_service['image'] = self.image_tag
+
+        for k in ['build', 'platform']:
+            if k in out_service:
+                del out_service[k]
+
+        out_service['links'] = [
+            f'{l}:{l}' if ':' not in l else l
+            for l in out_service.get('links', [])
+        ]
+
+        #
+
+        depends_on = in_service.get('depends_on', [])
+
+        for dep_service, in_dep_service_dct in list(in_services.items()):
+            if dep_service not in depends_on:
+                continue
+
+            out_dep_service: dict = dict(in_dep_service_dct)
+            out_services[dep_service] = out_dep_service
+
+            out_dep_service['ports'] = []
+
+        #
+
+        return out
+
+    @cached_nullary
+    def rewrite_compose_file(self) -> str:
+        in_dct = read_yaml_file(self._cfg.compose_file)
+
+        out_dct = self._rewrite_compose_dct(in_dct)
+
+        #
+
+        out_compose_file = make_temp_file()
+        self._enter_context(defer(lambda: os.unlink(out_compose_file)))  # noqa
+
+        compose_json = json_dumps_pretty(out_dct)
+
+        with open(out_compose_file, 'w') as f:
+            f.write(compose_json)
+
+        return out_compose_file
+
+    #
+
+    def run(self) -> None:
+        self.tag_image()
+
+        compose_file = self.rewrite_compose_file()
+
+        try:
+            subprocesses.check_call(
+                'docker',
+                'compose',
+                '-f', compose_file,
+                'run',
+                '--rm',
+                *self._cfg.run_options or [],
+                self._cfg.service,
+                *self._cfg.run_cmd,
+                **self._subprocess_kwargs,
+            )
+
+        finally:
+            subprocesses.check_call(
+                'docker',
+                'compose',
+                '-f', compose_file,
+                'down',
+            )
+
+
+########################################
+# ../dockertars.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
+
+
+##
+
+
+def is_docker_image_present(image: str) -> bool:
+    out = subprocesses.check_output(
+        'docker',
+        'images',
+        '--format', 'json',
+        image,
+    )
+
+    out_s = out.decode('utf-8').strip()
+    if not out_s:
+        return False
+
+    json.loads(out_s)  # noqa
+    return True
+
+
+##
+
+
+def pull_docker_tar(
+        image: str,
+        tar_file: str,
+) -> None:
+    subprocesses.check_call(
+        'docker',
+        'pull',
+        image,
+    )
+
+    subprocesses.check_call(
+        'docker',
+        'save',
+        image,
+        '-o', tar_file,
+    )
+
+
+def build_docker_tar(
+    docker_file: str,
+    tar_file: str,
+    *,
+    cwd: ta.Optional[str] = None,
+) -> str:
+    id_file = make_temp_file()
+    with defer(lambda: os.unlink(id_file)):
+        subprocesses.check_call(
+            'docker',
+            'build',
+            '-f', os.path.abspath(docker_file),
+            '--iidfile', id_file,
+            '--squash',
+            '.',
+            **(dict(cwd=cwd) if cwd is not None else {}),
+        )
+
+        with open(id_file) as f:
+            image_id = check.single(f.read().strip().splitlines()).strip()
+
+        subprocesses.check_call(
+            'docker',
+            'save',
+            image_id,
+            '-o', tar_file,
+        )
+
+        return image_id
+
+
+##
+
+
+def load_docker_tar(
+        tar_file: str,
+) -> None:
+    subprocesses.check_call(
+        'docker',
+        'load',
+        '-i', tar_file,
+    )
+
+
+########################################
+# ../requirements.py
+"""
+TODO:
+ - pip compile lol
+  - but still support git+ stuff
+ - req.txt format aware hash
+  - more than just whitespace
+ - pyproject req rewriting
+ - download_requirements bootstrap off prev? not worth the dl?
+  - big deps (torch) change less, probably worth it
+ - follow embedded -r automatically like pyp
+"""
+
+
+##
+
+
+def build_requirements_hash(
+        requirements_txts: ta.Sequence[str],
+) -> str:
+    txt_file_contents: dict = {}
+
+    for txt_file in requirements_txts:
+        txt_file_name = os.path.basename(txt_file)
+        check.not_in(txt_file_name, txt_file_contents)
+        with open(txt_file) as f:
+            txt_contents = f.read()
+        txt_file_contents[txt_file_name] = txt_contents
+
+    #
+
+    lines = []
+    for txt_file, txt_contents in sorted(txt_file_contents.items()):
+        txt_hash = sha256_str(txt_contents)
+        lines.append(f'{txt_file}={txt_hash}')
+
+    return sha256_str('\n'.join(lines))
+
+
+##
+
+
+def download_requirements(
+        image: str,
+        requirements_dir: str,
+        requirements_txts: ta.Sequence[str],
+) -> None:
+    requirements_txt_dir = tempfile.mkdtemp()
+    with defer(lambda: shutil.rmtree(requirements_txt_dir)):
+        for rt in requirements_txts:
+            shutil.copyfile(rt, os.path.join(requirements_txt_dir, os.path.basename(rt)))
+
+        subprocesses.check_call(
+            'docker',
+            'run',
+            '-i',
+            '-v', f'{os.path.abspath(requirements_dir)}:/requirements',
+            '-v', f'{requirements_txt_dir}:/requirements_txt',
+            image,
+            'pip',
+            'download',
+            '-d', '/requirements',
+            *itertools.chain.from_iterable([
+                ['-r', f'/requirements_txt/{os.path.basename(rt)}']
+                for rt in requirements_txts
+            ]),
+        )
+
+
+########################################
+# ../ci.py
+
+
+##
+
+
+class Ci(ExitStacked):
+    FILE_NAME_HASH_LEN = 16
+
+    @dc.dataclass(frozen=True)
+    class Config:
+        project_dir: str
+
+        docker_file: str
+
+        compose_file: str
+        service: str
+
+        requirements_txts: ta.Optional[ta.Sequence[str]] = None
+
+        def __post_init__(self) -> None:
+            check.not_isinstance(self.requirements_txts, str)
+
+    def __init__(
+            self,
+            cfg: Config,
+            *,
+            file_cache: ta.Optional[FileCache] = None,
+    ) -> None:
+        super().__init__()
+
+        self._cfg = cfg
+        self._file_cache = file_cache
+
+    #
+
+    def load_docker_image(self, image: str) -> None:
+        if is_docker_image_present(image):
+            return
+
+        dep_suffix = image
+        for c in '/:.-_':
+            dep_suffix = dep_suffix.replace(c, '-')
+
+        tar_file_name = f'docker-{dep_suffix}.tar'
+
+        if self._file_cache is not None and (cache_tar_file := self._file_cache.get_file(tar_file_name)):
+            load_docker_tar(cache_tar_file)
+            return
+
+        temp_dir = tempfile.mkdtemp()
+        with defer(lambda: shutil.rmtree(temp_dir)):
+            temp_tar_file = os.path.join(temp_dir, tar_file_name)
+
+            pull_docker_tar(
+                image,
+                temp_tar_file,
+            )
+
+            if self._file_cache is not None:
+                self._file_cache.put_file(temp_tar_file)
+
+    @cached_nullary
+    def load_compose_service_dependencies(self) -> None:
+        deps = get_compose_service_dependencies(
+            self._cfg.compose_file,
+            self._cfg.service,
+        )
+
+        for dep_image in deps.values():
+            self.load_docker_image(dep_image)
+
+    #
+
+    @cached_nullary
+    def build_ci_image(self) -> str:
+        docker_file_hash = build_docker_file_hash(self._cfg.docker_file)[:self.FILE_NAME_HASH_LEN]
+
+        tar_file_name = f'ci-{docker_file_hash}.tar'
+
+        if self._file_cache is not None and (cache_tar_file := self._file_cache.get_file(tar_file_name)):
+            image_id = read_docker_tar_image_id(cache_tar_file)
+            load_docker_tar(cache_tar_file)
+            return image_id
+
+        temp_dir = tempfile.mkdtemp()
+        with defer(lambda: shutil.rmtree(temp_dir)):
+            temp_tar_file = os.path.join(temp_dir, tar_file_name)
+
+            image_id = build_docker_tar(
+                self._cfg.docker_file,
+                temp_tar_file,
+                cwd=self._cfg.project_dir,
+            )
+
+            if self._file_cache is not None:
+                self._file_cache.put_file(temp_tar_file)
+
+            return image_id
+
+    #
+
+    @cached_nullary
+    def build_requirements_dir(self) -> str:
+        requirements_txts = check.not_none(self._cfg.requirements_txts)
+
+        requirements_hash = build_requirements_hash(requirements_txts)[:self.FILE_NAME_HASH_LEN]
+
+        tar_file_name = f'requirements-{requirements_hash}.tar'
+
+        temp_dir = tempfile.mkdtemp()
+        self._enter_context(defer(lambda: shutil.rmtree(temp_dir)))  # noqa
+
+        if self._file_cache is not None and (cache_tar_file := self._file_cache.get_file(tar_file_name)):
+            with tarfile.open(cache_tar_file) as tar:
+                tar.extractall(path=temp_dir)  # noqa
+
+            return temp_dir
+
+        temp_requirements_dir = os.path.join(temp_dir, 'requirements')
+        os.makedirs(temp_requirements_dir)
+
+        download_requirements(
+            self.build_ci_image(),
+            temp_requirements_dir,
+            requirements_txts,
+        )
+
+        if self._file_cache is not None:
+            temp_tar_file = os.path.join(temp_dir, tar_file_name)
+
+            with tarfile.open(temp_tar_file, 'w') as tar:
+                for requirement_file in os.listdir(temp_requirements_dir):
+                    tar.add(
+                        os.path.join(temp_requirements_dir, requirement_file),
+                        arcname=requirement_file,
+                    )
+
+            self._file_cache.put_file(temp_tar_file)
+
+        return temp_requirements_dir
+
+    #
+
+    def run(self) -> None:
+        self.load_compose_service_dependencies()
+
+        ci_image = self.build_ci_image()
+
+        requirements_dir = self.build_requirements_dir()
+
+        #
+
+        setup_cmds = [
+            'pip install --root-user-action ignore --find-links /requirements --no-index uv',
+            (
+                'uv pip install --system --find-links /requirements ' +
+                ' '.join(f'-r /project/{rf}' for rf in self._cfg.requirements_txts or [])
+            ),
+        ]
+
+        #
+
+        test_cmds = [
+            '(cd /project && python3 -m pytest -svv test.py)',
+        ]
+
+        #
+
+        bash_src = ' && '.join([
+            *setup_cmds,
+            *test_cmds,
+        ])
+
+        with DockerComposeRun(DockerComposeRun.Config(
+                compose_file=self._cfg.compose_file,
+                service=self._cfg.service,
+
+                image=ci_image,
+
+                run_cmd=['bash', '-c', bash_src],
+
+                run_options=[
+                    '-v', f'{os.path.abspath(self._cfg.project_dir)}:/project',
+                    '-v', f'{os.path.abspath(requirements_dir)}:/requirements',
+                ],
+
+                cwd=self._cfg.project_dir,
+        )) as ci_compose_run:
+            ci_compose_run.run()
+
+
+########################################
+# cli.py
+
+
+##
+
+
+class CiCli(ArgparseCli):
+    #
+
+    @argparse_cmd(
+        argparse_arg('requirements-txt', nargs='+'),
+    )
+    def print_requirements_hash(self) -> None:
+        requirements_txts = self.args.requirements_txt
+
+        print(build_requirements_hash(requirements_txts))
+
+    #
+
+    @argparse_cmd(
+        argparse_arg('compose-file'),
+        argparse_arg('service'),
+    )
+    def dump_compose_deps(self) -> None:
+        compose_file = self.args.compose_file
+        service = self.args.service
+
+        print(get_compose_service_dependencies(
+            compose_file,
+            service,
+        ))
+
+    #
+
+    @argparse_cmd(
+        argparse_arg('project-dir'),
+        argparse_arg('service'),
+        argparse_arg('--docker-file'),
+        argparse_arg('--compose-file'),
+        argparse_arg('-r', '--requirements-txt', action='append'),
+        argparse_arg('--cache-dir'),
+    )
+    async def run(self) -> None:
+        await asyncio.sleep(1)
+
+        project_dir = self.args.project_dir
+        docker_file = self.args.docker_file
+        compose_file = self.args.compose_file
+        service = self.args.service
+        requirements_txts = self.args.requirements_txt
+        cache_dir = self.args.cache_dir
+
+        #
+
+        check.state(os.path.isdir(project_dir))
+
+        #
+
+        def find_alt_file(*alts: str) -> ta.Optional[str]:
+            for alt in alts:
+                alt_file = os.path.join(project_dir, alt)
+                if os.path.isfile(alt_file):
+                    return alt_file
+            return None
+
+        if docker_file is None:
+            docker_file = find_alt_file(
+                'docker/ci/Dockerfile',
+                'docker/ci.Dockerfile',
+                'ci.Dockerfile',
+                'Dockerfile',
+            )
+        check.state(os.path.isfile(docker_file))
+
+        if compose_file is None:
+            compose_file = find_alt_file(
+                'docker/compose.yml',
+                'compose.yml',
+            )
+        check.state(os.path.isfile(compose_file))
+
+        if not requirements_txts:
+            requirements_txts = []
+            for rf in [
+                'requirements.txt',
+                'requirements-dev.txt',
+                'requirements-ci.txt',
+            ]:
+                if os.path.exists(os.path.join(project_dir, rf)):
+                    requirements_txts.append(rf)
+        else:
+            for rf in requirements_txts:
+                check.state(os.path.isfile(rf))
+
+        #
+
+        file_cache: ta.Optional[FileCache] = None
+        if cache_dir is not None:
+            if not os.path.exists(cache_dir):
+                os.makedirs(cache_dir)
+            check.state(os.path.isdir(cache_dir))
+            file_cache = DirectoryFileCache(cache_dir)
+
+        #
+
+        with Ci(
+                Ci.Config(
+                    project_dir=project_dir,
+                    docker_file=docker_file,
+                    compose_file=compose_file,
+                    service=service,
+                    requirements_txts=requirements_txts,
+                ),
+                file_cache=file_cache,
+        ) as ci:
+            ci.run()
+
+
+async def _async_main() -> ta.Optional[int]:
+    return await CiCli().async_cli_run()
+
+
+def _main() -> None:
+    sys.exit(rc if isinstance(rc := asyncio.run(_async_main()), int) else 0)
+
+
+if __name__ == '__main__':
+    _main()