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

omdev/scripts/ci.py

@@ -3,7 +3,7 @@
 # @omlish-lite
 # @omlish-script
 # @omlish-amalg-output ../ci/cli.py
-# ruff: noqa: UP006 UP007 UP036
+# ruff: noqa: N802 UP006 UP007 UP036
 """
 Inputs:
  - requirements.txt
@@ -20,6 +20,7 @@ import asyncio
 import collections
 import contextlib
 import dataclasses as dc
+import datetime
 import functools
 import hashlib
 import inspect
@@ -50,8 +51,10 @@ if sys.version_info < (3, 8):
 ########################################
 
 
-# ../../omlish/lite/cached.py
+# shell.py
 T = ta.TypeVar('T')
+
+# ../../omlish/lite/cached.py
 CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 
 # ../../omlish/lite/check.py
@@ -73,72 +76,41 @@ SubprocessChannelOption = ta.Literal['pipe', 'stdout', 'devnull']  # ta.TypeAlia
 
 
 ########################################
-# ../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
+# ../shell.py
 
 
 ##
 
 
-def read_yaml_file(yaml_file: str) -> ta.Any:
-    yaml = __import__('yaml')
-
-    with open(yaml_file) as f:
-        return yaml.safe_load(f)
-
+@dc.dataclass(frozen=True)
+class ShellCmd:
+    s: str
 
-##
+    env: ta.Optional[ta.Mapping[str, str]] = None
 
+    def build_run_kwargs(
+            self,
+            *,
+            env: ta.Optional[ta.Mapping[str, str]] = None,
+            **kwargs: ta.Any,
+    ) -> ta.Dict[str, ta.Any]:
+        if env is None:
+            env = os.environ
+        if self.env:
+            if (ek := set(env) & set(self.env)):
+                raise KeyError(*ek)
+            env = {**env, **self.env}
+
+        return dict(
+            env=env,
+            **kwargs,
+        )
 
-def sha256_str(s: str) -> str:
-    return hashlib.sha256(s.encode('utf-8')).hexdigest()
+    def run(self, fn: ta.Callable[..., T], **kwargs) -> T:
+        return fn(
+            'sh', '-c', self.s,
+            **self.build_run_kwargs(**kwargs),
+        )
 
 
 ########################################
@@ -680,6 +652,13 @@ json_dump_compact: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON
 json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_COMPACT_KWARGS)
 
 
+########################################
+# ../../../omlish/lite/logs.py
+
+
+log = logging.getLogger(__name__)
+
+
 ########################################
 # ../../../omlish/lite/reflect.py
 
@@ -769,248 +748,895 @@ def deep_subclasses(cls: ta.Type[T]) -> ta.Iterator[ta.Type[T]]:
 
 
 ########################################
-# ../../../omlish/argparse/cli.py
-"""
-TODO:
- - default command
- - auto match all underscores to hyphens
- - pre-run, post-run hooks
- - exitstack?
-"""
+# ../../../omlish/lite/strings.py
 
 
 ##
 
 
-@dc.dataclass(eq=False)
-class ArgparseArg:
-    args: ta.Sequence[ta.Any]
-    kwargs: ta.Mapping[str, ta.Any]
-    dest: ta.Optional[str] = None
+def camel_case(name: str, *, lower: bool = False) -> str:
+    if not name:
+        return ''
+    s = ''.join(map(str.capitalize, name.split('_')))  # noqa
+    if lower:
+        s = s[0].lower() + s[1:]
+    return s
 
-    def __get__(self, instance, owner=None):
-        if instance is None:
-            return self
-        return getattr(instance.args, self.dest)  # type: ignore
 
+def snake_case(name: str) -> str:
+    uppers: list[int | None] = [i for i, c in enumerate(name) if c.isupper()]
+    return '_'.join([name[l:r].lower() for l, r in zip([None, *uppers], [*uppers, None])]).strip('_')
 
-def argparse_arg(*args, **kwargs) -> ArgparseArg:
-    return ArgparseArg(args, kwargs)
 
+##
 
-#
 
+def is_dunder(name: str) -> bool:
+    return (
+        name[:2] == name[-2:] == '__' and
+        name[2:3] != '_' and
+        name[-3:-2] != '_' and
+        len(name) > 4
+    )
 
-@dc.dataclass(eq=False)
-class ArgparseCmd:
-    name: str
-    fn: ArgparseCmdFn
-    args: ta.Sequence[ArgparseArg] = ()  # noqa
 
-    # _: dc.KW_ONLY
+def is_sunder(name: str) -> bool:
+    return (
+        name[0] == name[-1] == '_' and
+        name[1:2] != '_' and
+        name[-2:-1] != '_' and
+        len(name) > 2
+    )
 
-    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 strip_with_newline(s: str) -> str:
+    if not s:
+        return ''
+    return s.strip() + '\n'
 
-    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)
+@ta.overload
+def split_keep_delimiter(s: str, d: str) -> str:
+    ...
 
 
-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)
+@ta.overload
+def split_keep_delimiter(s: bytes, d: bytes) -> bytes:
+    ...
 
-    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 split_keep_delimiter(s, d):
+    ps = []
+    i = 0
+    while i < len(s):
+        if (n := s.find(d, i)) < i:
+            ps.append(s[i:])
+            break
+        ps.append(s[i:n + 1])
+        i = n + 1
+    return ps
 
 
 ##
 
 
-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)
+def attr_repr(obj: ta.Any, *attrs: str) -> str:
+    return f'{type(obj).__name__}({", ".join(f"{attr}={getattr(obj, attr)!r}" for attr in attrs)})'
 
 
-class _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__()
+FORMAT_NUM_BYTES_SUFFIXES: ta.Sequence[str] = ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB']
 
-        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 format_num_bytes(num_bytes: int) -> str:
+    for i, suffix in enumerate(FORMAT_NUM_BYTES_SUFFIXES):
+        value = num_bytes / 1024 ** i
+        if num_bytes < 1024 ** (i + 1):
+            if value.is_integer():
+                return f'{int(value)}{suffix}'
+            else:
+                return f'{value:.2f}{suffix}'
 
-    #
+    return f'{num_bytes / 1024 ** (len(FORMAT_NUM_BYTES_SUFFIXES) - 1):.2f}{FORMAT_NUM_BYTES_SUFFIXES[-1]}'
 
-    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]
+########################################
+# ../../../omlish/logs/filters.py
 
-        #
 
-        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__', {}))
+class TidLogFilter(logging.Filter):
+    def filter(self, record):
+        record.tid = threading.get_native_id()
+        return True
 
-        #
 
-        if '_parser' in ns:
-            parser = check.isinstance(ns['_parser'], argparse.ArgumentParser)
-        else:
-            parser = argparse.ArgumentParser()
-            setattr(cls, '_parser', parser)
+########################################
+# ../../../omlish/logs/proxy.py
 
-        #
 
-        subparsers = parser.add_subparsers()
+class ProxyLogFilterer(logging.Filterer):
+    def __init__(self, underlying: logging.Filterer) -> None:  # noqa
+        self._underlying = underlying
 
-        for att, obj in objs.items():
-            if isinstance(obj, ArgparseCmd):
-                if obj.parent is not None:
-                    raise NotImplementedError
+    @property
+    def underlying(self) -> logging.Filterer:
+        return self._underlying
 
-                for cn in [obj.name, *(obj.aliases or [])]:
-                    subparser = subparsers.add_parser(cn)
+    @property
+    def filters(self):
+        return self._underlying.filters
 
-                    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)
+    @filters.setter
+    def filters(self, filters):
+        self._underlying.filters = filters
 
-                    subparser.set_defaults(_cmd=obj)
+    def addFilter(self, filter):  # noqa
+        self._underlying.addFilter(filter)
 
-            elif isinstance(obj, ArgparseArg):
-                if att in anns:
-                    ann_kwargs = _get_argparse_arg_ann_kwargs(anns[att])
-                    obj.kwargs = {**ann_kwargs, **obj.kwargs}
+    def removeFilter(self, filter):  # noqa
+        self._underlying.removeFilter(filter)
 
-                if not obj.dest:
-                    if 'dest' in obj.kwargs:
-                        obj.dest = obj.kwargs['dest']
-                    else:
-                        obj.dest = obj.kwargs['dest'] = att  # type: ignore
+    def filter(self, record):
+        return self._underlying.filter(record)
 
-                parser.add_argument(*obj.args, **obj.kwargs)
 
-            else:
-                raise TypeError(obj)
+class ProxyLogHandler(ProxyLogFilterer, logging.Handler):
+    def __init__(self, underlying: logging.Handler) -> None:  # noqa
+        ProxyLogFilterer.__init__(self, underlying)
 
-    #
+    _underlying: logging.Handler
 
-    _parser: ta.ClassVar[argparse.ArgumentParser]
+    @property
+    def underlying(self) -> logging.Handler:
+        return self._underlying
 
-    @classmethod
-    def get_parser(cls) -> argparse.ArgumentParser:
-        return cls._parser
+    def get_name(self):
+        return self._underlying.get_name()
+
+    def set_name(self, name):
+        self._underlying.set_name(name)
 
     @property
-    def argv(self) -> ta.Sequence[str]:
-        return self._argv
+    def name(self):
+        return self._underlying.name
 
     @property
-    def args(self) -> argparse.Namespace:
-        return self._args
+    def level(self):
+        return self._underlying.level
+
+    @level.setter
+    def level(self, level):
+        self._underlying.level = level
 
     @property
-    def unknown_args(self) -> ta.Sequence[str]:
-        return self._unknown_args
+    def formatter(self):
+        return self._underlying.formatter
 
-    #
+    @formatter.setter
+    def formatter(self, formatter):
+        self._underlying.formatter = formatter
 
-    def _bind_cli_cmd(self, cmd: ArgparseCmd) -> ta.Callable:
-        return cmd.__get__(self, type(self))
+    def createLock(self):
+        self._underlying.createLock()
 
-    def prepare_cli_run(self) -> ta.Optional[ta.Callable]:
-        cmd = getattr(self.args, '_cmd', None)
+    def acquire(self):
+        self._underlying.acquire()
 
-        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)
+    def release(self):
+        self._underlying.release()
 
-        if cmd is None:
+    def setLevel(self, level):
+        self._underlying.setLevel(level)
+
+    def format(self, record):
+        return self._underlying.format(record)
+
+    def emit(self, record):
+        self._underlying.emit(record)
+
+    def handle(self, record):
+        return self._underlying.handle(record)
+
+    def setFormatter(self, fmt):
+        self._underlying.setFormatter(fmt)
+
+    def flush(self):
+        self._underlying.flush()
+
+    def close(self):
+        self._underlying.close()
+
+    def handleError(self, record):
+        self._underlying.handleError(record)
+
+
+########################################
+# ../cache.py
+
+
+##
+
+
+@abc.abstractmethod
+class FileCache(abc.ABC):
+    @abc.abstractmethod
+    def get_file(self, key: str) -> ta.Optional[str]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def put_file(self, key: str, file_path: str) -> ta.Optional[str]:
+        raise NotImplementedError
+
+
+#
+
+
+class DirectoryFileCache(FileCache):
+    def __init__(self, dir: str) -> None:  # noqa
+        super().__init__()
+
+        self._dir = dir
+
+    #
+
+    def get_cache_file_path(
+            self,
+            key: str,
+            *,
+            make_dirs: bool = False,
+    ) -> str:
+        if make_dirs:
+            os.makedirs(self._dir, exist_ok=True)
+        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')
+
+    #
+
+    def get_file(self, key: str) -> ta.Optional[str]:
+        cache_file_path = self.get_cache_file_path(key)
+        if not os.path.exists(cache_file_path):
+            return None
+        return cache_file_path
+
+    def put_file(self, key: str, file_path: str) -> None:
+        cache_file_path = self.get_cache_file_path(key, make_dirs=True)
+        shutil.copyfile(file_path, cache_file_path)
+
+
+##
+
+
+class ShellCache(abc.ABC):
+    @abc.abstractmethod
+    def get_file_cmd(self, key: str) -> ta.Optional[ShellCmd]:
+        raise NotImplementedError
+
+    class PutFileCmdContext(abc.ABC):
+        def __init__(self) -> None:
+            super().__init__()
+
+            self._state: ta.Literal['open', 'committed', 'aborted'] = 'open'
+
+        @property
+        def state(self) -> ta.Literal['open', 'committed', 'aborted']:
+            return self._state
+
+        #
+
+        @property
+        @abc.abstractmethod
+        def cmd(self) -> ShellCmd:
+            raise NotImplementedError
+
+        #
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc_val, exc_tb):
+            if exc_val is None:
+                self.commit()
+            else:
+                self.abort()
+
+        #
+
+        @abc.abstractmethod
+        def _commit(self) -> None:
+            raise NotImplementedError
+
+        def commit(self) -> None:
+            if self._state == 'committed':
+                return
+            elif self._state == 'open':
+                self._commit()
+                self._state = 'committed'
+            else:
+                raise RuntimeError(self._state)
+
+        #
+
+        @abc.abstractmethod
+        def _abort(self) -> None:
+            raise NotImplementedError
+
+        def abort(self) -> None:
+            if self._state == 'aborted':
+                return
+            elif self._state == 'open':
+                self._abort()
+                self._state = 'committed'
+            else:
+                raise RuntimeError(self._state)
+
+    @abc.abstractmethod
+    def put_file_cmd(self, key: str) -> PutFileCmdContext:
+        raise NotImplementedError
+
+
+#
+
+
+class DirectoryShellCache(ShellCache):
+    def __init__(self, dfc: DirectoryFileCache) -> None:
+        super().__init__()
+
+        self._dfc = dfc
+
+    def get_file_cmd(self, key: str) -> ta.Optional[ShellCmd]:
+        f = self._dfc.get_file(key)
+        if f is None:
+            return None
+        return ShellCmd(f'cat {shlex.quote(f)}')
+
+    class _PutFileCmdContext(ShellCache.PutFileCmdContext):  # noqa
+        def __init__(self, tf: str, f: str) -> None:
+            super().__init__()
+
+            self._tf = tf
+            self._f = f
+
+        @property
+        def cmd(self) -> ShellCmd:
+            return ShellCmd(f'cat > {shlex.quote(self._tf)}')
+
+        def _commit(self) -> None:
+            os.replace(self._tf, self._f)
+
+        def _abort(self) -> None:
+            os.unlink(self._tf)
+
+    def put_file_cmd(self, key: str) -> ShellCache.PutFileCmdContext:
+        f = self._dfc.get_cache_file_path(key, make_dirs=True)
+        return self._PutFileCmdContext(self._dfc.format_incomplete_file(f), f)
+
+
+########################################
+# ../github/cacheapi.py
+"""
+export FILE_SIZE=$(stat --format="%s" $FILE)
+
+export CACHE_ID=$(curl -s \
+  -X POST \
+  "${ACTIONS_CACHE_URL}_apis/artifactcache/caches" \
+  -H 'Content-Type: application/json' \
+  -H 'Accept: application/json;api-version=6.0-preview.1' \
+  -H "Authorization: Bearer $ACTIONS_RUNTIME_TOKEN" \
+  -d '{"key": "'"$CACHE_KEY"'", "cacheSize": '"$FILE_SIZE"'}' \
+  | jq .cacheId)
+
+curl -s \
+  -X PATCH \
+  "${ACTIONS_CACHE_URL}_apis/artifactcache/caches/$CACHE_ID" \
+  -H 'Content-Type: application/octet-stream' \
+  -H 'Accept: application/json;api-version=6.0-preview.1' \
+  -H "Authorization: Bearer $ACTIONS_RUNTIME_TOKEN" \
+  -H "Content-Range: bytes 0-$((FILE_SIZE - 1))/*" \
+  --data-binary @"$FILE"
+
+curl -s \
+  -X POST \
+  "${ACTIONS_CACHE_URL}_apis/artifactcache/caches/$CACHE_ID" \
+  -H 'Content-Type: application/json' \
+  -H 'Accept: application/json;api-version=6.0-preview.1' \
+  -H "Authorization: Bearer $ACTIONS_RUNTIME_TOKEN" \
+  -d '{"size": '"$(stat --format="%s" $FILE)"'}'
+
+curl -s \
+  -X GET \
+  "${ACTIONS_CACHE_URL}_apis/artifactcache/cache?keys=$CACHE_KEY" \
+  -H 'Content-Type: application/json' \
+  -H "Authorization: Bearer $ACTIONS_RUNTIME_TOKEN" \
+  | jq .
+"""
+
+
+##
+
+
+class GithubCacheServiceV1:
+    API_VERSION = '6.0-preview.1'
+
+    @classmethod
+    def get_service_url(cls, base_url: str) -> str:
+        return f'{base_url.rstrip("/")}/_apis/artifactcache'
+
+    #
+
+    @classmethod
+    def dataclass_to_json(cls, obj: ta.Any) -> ta.Any:
+        return {
+            camel_case(k, lower=True): v
+            for k, v in dc.asdict(obj).items()
+            if v is not None
+        }
+
+    @classmethod
+    def dataclass_from_json(cls, dcls: ta.Type[T], obj: ta.Any) -> T:
+        return dcls(**{
+            snake_case(k): v
+            for k, v in obj.items()
+        })
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class ArtifactCacheEntry:
+        cache_key: ta.Optional[str]
+        scope: ta.Optional[str]
+        cache_version: ta.Optional[str]
+        creation_time: ta.Optional[str]
+        archive_location: ta.Optional[str]
+
+    @dc.dataclass(frozen=True)
+    class ArtifactCacheList:
+        total_count: int
+        artifact_caches: ta.Optional[ta.Sequence['GithubCacheServiceV1.ArtifactCacheEntry']]
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class ReserveCacheRequest:
+        key: str
+        cache_size: ta.Optional[int]
+        version: ta.Optional[str] = None
+
+    @dc.dataclass(frozen=True)
+    class ReserveCacheResponse:
+        cache_id: int
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class CommitCacheRequest:
+        size: int
+
+    #
+
+    class CompressionMethod:
+        GZIP = 'gzip'
+        ZSTD_WITHOUT_LONG = 'zstd-without-long'
+        ZSTD = 'zstd'
+
+    @dc.dataclass(frozen=True)
+    class InternalCacheOptions:
+        compression_method: ta.Optional[str]  # CompressionMethod
+        enable_cross_os_archive: ta.Optional[bool]
+        cache_size: ta.Optional[int]
+
+
+class GithubCacheServiceV2:
+    SERVICE_NAME = 'github.actions.results.api.v1.CacheService'
+
+    @dc.dataclass(frozen=True)
+    class Method:
+        name: str
+        request: type
+        response: type
+
+    #
+
+    class CacheScopePermission:
+        READ = 1
+        WRITE = 2
+        ALL = READ | WRITE
+
+    @dc.dataclass(frozen=True)
+    class CacheScope:
+        scope: str
+        permission: int  # CacheScopePermission
+
+    @dc.dataclass(frozen=True)
+    class CacheMetadata:
+        repository_id: int
+        scope: ta.Sequence['GithubCacheServiceV2.CacheScope']
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class CreateCacheEntryRequest:
+        key: str
+        version: str
+        metadata: ta.Optional['GithubCacheServiceV2.CacheMetadata'] = None
+
+    @dc.dataclass(frozen=True)
+    class CreateCacheEntryResponse:
+        ok: bool
+        signed_upload_url: str
+
+    CREATE_CACHE_ENTRY_METHOD = Method(
+        'CreateCacheEntry',
+        CreateCacheEntryRequest,
+        CreateCacheEntryResponse,
+    )
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class FinalizeCacheEntryUploadRequest:
+        key: str
+        size_bytes: int
+        version: str
+        metadata: ta.Optional['GithubCacheServiceV2.CacheMetadata'] = None
+
+    @dc.dataclass(frozen=True)
+    class FinalizeCacheEntryUploadResponse:
+        ok: bool
+        entry_id: str
+
+    FINALIZE_CACHE_ENTRY_METHOD = Method(
+        'FinalizeCacheEntryUpload',
+        FinalizeCacheEntryUploadRequest,
+        FinalizeCacheEntryUploadResponse,
+    )
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class GetCacheEntryDownloadUrlRequest:
+        key: str
+        restore_keys: ta.Sequence[str]
+        version: str
+        metadata: ta.Optional['GithubCacheServiceV2.CacheMetadata'] = None
+
+    @dc.dataclass(frozen=True)
+    class GetCacheEntryDownloadUrlResponse:
+        ok: bool
+        signed_download_url: str
+        matched_key: str
+
+    GET_CACHE_ENTRY_DOWNLOAD_URL_METHOD = Method(
+        'GetCacheEntryDownloadURL',
+        GetCacheEntryDownloadUrlRequest,
+        GetCacheEntryDownloadUrlResponse,
+    )
+
+
+########################################
+# ../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()
+
+
+##
+
+
+class LogTimingContext:
+    DEFAULT_LOG: ta.ClassVar[logging.Logger] = log
+
+    def __init__(
+            self,
+            description: str,
+            *,
+            log: ta.Optional[logging.Logger] = None,  # noqa
+            level: int = logging.DEBUG,
+    ) -> None:
+        super().__init__()
+
+        self._description = description
+        self._log = log if log is not None else self.DEFAULT_LOG
+        self._level = level
+
+    def set_description(self, description: str) -> 'LogTimingContext':
+        self._description = description
+        return self
+
+    _begin_time: float
+    _end_time: float
+
+    def __enter__(self) -> 'LogTimingContext':
+        self._begin_time = time.time()
+
+        self._log.log(self._level, f'Begin {self._description}')  # noqa
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._end_time = time.time()
+
+        self._log.log(
+            self._level,
+            f'End {self._description} - {self._end_time - self._begin_time:0.2f} s elapsed',
+        )
+
+
+log_timing_context = LogTimingContext
+
+
+########################################
+# ../../../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
 
@@ -1118,32 +1744,208 @@ def attr_setting(obj, attr, val, *, default=None):  # noqa
 ##
 
 
-class aclosing(contextlib.AbstractAsyncContextManager):  # noqa
-    def __init__(self, thing):
-        self.thing = thing
+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/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/logs/standard.py
+"""
+TODO:
+ - structured
+ - prefixed
+ - debug
+ - optional noisy? noisy will never be lite - some kinda configure_standard callback mechanism?
+"""
+
+
+##
+
+
+STANDARD_LOG_FORMAT_PARTS = [
+    ('asctime', '%(asctime)-15s'),
+    ('process', 'pid=%(process)-6s'),
+    ('thread', 'tid=%(thread)x'),
+    ('levelname', '%(levelname)s'),
+    ('name', '%(name)s'),
+    ('separator', '::'),
+    ('message', '%(message)s'),
+]
+
+
+class StandardLogFormatter(logging.Formatter):
+    @staticmethod
+    def build_log_format(parts: ta.Iterable[ta.Tuple[str, str]]) -> str:
+        return ' '.join(v for k, v in parts)
+
+    converter = datetime.datetime.fromtimestamp  # type: ignore
+
+    def formatTime(self, record, datefmt=None):
+        ct = self.converter(record.created)  # type: ignore
+        if datefmt:
+            return ct.strftime(datefmt)  # noqa
+        else:
+            t = ct.strftime('%Y-%m-%d %H:%M:%S')
+            return '%s.%03d' % (t, record.msecs)  # noqa
+
+
+##
+
+
+class StandardConfiguredLogHandler(ProxyLogHandler):
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError('This class serves only as a marker and should not be subclassed.')
+
+
+##
+
+
+@contextlib.contextmanager
+def _locking_logging_module_lock() -> ta.Iterator[None]:
+    if hasattr(logging, '_acquireLock'):
+        logging._acquireLock()  # noqa
+        try:
+            yield
+        finally:
+            logging._releaseLock()  # type: ignore  # noqa
 
-    async def __aenter__(self):
-        return self.thing
+    elif hasattr(logging, '_lock'):
+        # https://github.com/python/cpython/commit/74723e11109a320e628898817ab449b3dad9ee96
+        with logging._lock:  # noqa
+            yield
 
-    async def __aexit__(self, *exc_info):
-        await self.thing.aclose()
+    else:
+        raise Exception("Can't find lock in logging module")
 
 
-########################################
-# ../../../omlish/lite/runtime.py
+def configure_standard_logging(
+        level: ta.Union[int, str] = logging.INFO,
+        *,
+        json: bool = False,
+        target: ta.Optional[logging.Logger] = None,
+        force: bool = False,
+        handler_factory: ta.Optional[ta.Callable[[], logging.Handler]] = None,
+) -> ta.Optional[StandardConfiguredLogHandler]:
+    with _locking_logging_module_lock():
+        if target is None:
+            target = logging.root
 
+        #
 
-@cached_nullary
-def is_debugger_attached() -> bool:
-    return any(frame[1].endswith('pydevd.py') for frame in inspect.stack())
+        if not force:
+            if any(isinstance(h, StandardConfiguredLogHandler) for h in list(target.handlers)):
+                return None
 
+        #
 
-LITE_REQUIRED_PYTHON_VERSION = (3, 8)
+        if handler_factory is not None:
+            handler = handler_factory()
+        else:
+            handler = logging.StreamHandler()
+
+        #
 
+        formatter: logging.Formatter
+        if json:
+            formatter = JsonLogFormatter()
+        else:
+            formatter = StandardLogFormatter(StandardLogFormatter.build_log_format(STANDARD_LOG_FORMAT_PARTS))
+        handler.setFormatter(formatter)
 
-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
+        #
+
+        handler.addFilter(TidLogFilter())
+
+        #
+
+        target.addHandler(handler)
+
+        #
+
+        if level is not None:
+            target.setLevel(level)
+
+        #
+
+        return StandardConfiguredLogHandler(handler)
 
 
 ########################################
@@ -1513,7 +2315,7 @@ class DockerComposeRun(ExitStacked):
 
         image: str
 
-        run_cmd: ta.Sequence[str]
+        cmd: ShellCmd
 
         #
 
@@ -1523,9 +2325,11 @@ class DockerComposeRun(ExitStacked):
 
         #
 
-        def __post_init__(self) -> None:
-            check.not_isinstance(self.run_cmd, str)
+        no_dependency_cleanup: bool = False
+
+        #
 
+        def __post_init__(self) -> None:
             check.not_isinstance(self.run_options, str)
 
     def __init__(self, cfg: Config) -> None:
@@ -1597,196 +2401,560 @@ class DockerComposeRun(ExitStacked):
             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 _cleanup_dependencies(self) -> None:
+        subprocesses.check_call(
+            'docker',
+            'compose',
+            '-f', self.rewrite_compose_file(),
+            'down',
+        )
+
+    def run(self) -> None:
+        self.tag_image()
+
+        compose_file = self.rewrite_compose_file()
+
+        with contextlib.ExitStack() as es:
+            if not self._cfg.no_dependency_cleanup:
+                es.enter_context(defer(self._cleanup_dependencies))  # noqa
+
+            sh_cmd = ' '.join([
+                'docker',
+                'compose',
+                '-f', compose_file,
+                'run',
+                '--rm',
+                *itertools.chain.from_iterable(
+                    ['-e', k]
+                    for k in (self._cfg.cmd.env or [])
+                ),
+                *(self._cfg.run_options or []),
+                self._cfg.service,
+                'sh', '-c', shlex.quote(self._cfg.cmd.s),
+            ])
+
+            run_cmd = dc.replace(self._cfg.cmd, s=sh_cmd)
+
+            run_cmd.run(
+                subprocesses.check_call,
+                **self._subprocess_kwargs,
+            )
+
+
+########################################
+# ../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
+
+
+##
+
+
+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_image(
+        image: str,
+) -> None:
+    subprocesses.check_call(
+        'docker',
+        'pull',
+        image,
+    )
+
+
+def build_docker_image(
+        docker_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()
+
+    return image_id
+
+
+##
+
+
+def save_docker_tar_cmd(
+        image: str,
+        output_cmd: ShellCmd,
+) -> None:
+    cmd = dc.replace(output_cmd, s=f'docker save {image} | {output_cmd.s}')
+    cmd.run(subprocesses.check_call)
+
+
+def save_docker_tar(
+        image: str,
+        tar_file: str,
+) -> None:
+    return save_docker_tar_cmd(
+        image,
+        ShellCmd(f'cat > {shlex.quote(tar_file)}'),
+    )
+
+
+#
+
+
+def load_docker_tar_cmd(
+        input_cmd: ShellCmd,
+) -> str:
+    cmd = dc.replace(input_cmd, s=f'{input_cmd.s} | docker load')
+
+    out = cmd.run(subprocesses.check_output).decode()
+
+    line = check.single(out.strip().splitlines())
+    loaded = line.partition(':')[2].strip()
+    return loaded
+
+
+def load_docker_tar(
+        tar_file: str,
+) -> str:
+    return load_docker_tar_cmd(ShellCmd(f'cat {shlex.quote(tar_file)}'))
+
+
+########################################
+# ../github/cache.py
+
+
+##
+
+
+class GithubV1CacheShellClient:
+    BASE_URL_ENV_KEY = 'ACTIONS_CACHE_URL'
+    AUTH_TOKEN_ENV_KEY = 'ACTIONS_RUNTIME_TOKEN'  # noqa
+
+    def __init__(
+            self,
+            *,
+            base_url: ta.Optional[str] = None,
+            auth_token: ta.Optional[str] = None,
+    ) -> None:
+        super().__init__()
+
+        if base_url is None:
+            base_url = os.environ[self.BASE_URL_ENV_KEY]
+        self._base_url = check.non_empty_str(base_url)
+
+        if auth_token is None:
+            auth_token = os.environ.get(self.AUTH_TOKEN_ENV_KEY)
+        self._auth_token = auth_token
+
+        self._service_url = GithubCacheServiceV1.get_service_url(self._base_url)
+
+    #
+
+    _MISSING = object()
+
+    def build_headers(
+            self,
+            *,
+            auth_token: ta.Any = _MISSING,
+            content_type: ta.Optional[str] = None,
+    ) -> ta.Dict[str, str]:
+        dct = {
+            'Accept': f'application/json;api-version={GithubCacheServiceV1.API_VERSION}',
+        }
+
+        if auth_token is self._MISSING:
+            auth_token = self._auth_token
+        if auth_token:
+            dct['Authorization'] = f'Bearer {auth_token}'
+
+        if content_type is not None:
+            dct['Content-Type'] = content_type
+
+        return dct
+
+    #
+
+    HEADER_AUTH_TOKEN_ENV_KEY = '_GITHUB_CACHE_AUTH_TOKEN'  # noqa
+
+    def build_curl_cmd(
+            self,
+            method: str,
+            url: str,
+            *,
+            json_content: bool = False,
+            content_type: ta.Optional[str] = None,
+    ) -> ShellCmd:
+        if content_type is None and json_content:
+            content_type = 'application/json'
+
+        env = {}
+
+        header_auth_token: ta.Optional[str]
+        if self._auth_token:
+            env[self.HEADER_AUTH_TOKEN_ENV_KEY] = self._auth_token
+            header_auth_token = f'${self.HEADER_AUTH_TOKEN_ENV_KEY}'
+        else:
+            header_auth_token = None
+
+        hdrs = self.build_headers(
+            auth_token=header_auth_token,
+            content_type=content_type,
+        )
+
+        url = f'{self._service_url}/{url}'
 
-        depends_on = in_service.get('depends_on', [])
+        cmd = ' '.join([
+            'curl',
+            '-s',
+            '-X', method,
+            url,
+            *[f'-H "{k}: {v}"' for k, v in hdrs.items()],
+        ])
 
-        for dep_service, in_dep_service_dct in list(in_services.items()):
-            if dep_service not in depends_on:
-                continue
+        return ShellCmd(
+            cmd,
+            env=env,
+        )
 
-            out_dep_service: dict = dict(in_dep_service_dct)
-            out_services[dep_service] = out_dep_service
+    def build_post_json_curl_cmd(
+            self,
+            url: str,
+            obj: ta.Any,
+            **kwargs: ta.Any,
+    ) -> ShellCmd:
+        curl_cmd = self.build_curl_cmd(
+            'POST',
+            url,
+            json_content=True,
+            **kwargs,
+        )
 
-            out_dep_service['ports'] = []
+        obj_json = json_dumps_compact(obj)
 
-        #
+        return dc.replace(curl_cmd, s=f'{curl_cmd.s} -d {shlex.quote(obj_json)}')
 
-        return out
+    #
 
-    @cached_nullary
-    def rewrite_compose_file(self) -> str:
-        in_dct = read_yaml_file(self._cfg.compose_file)
+    @dc.dataclass()
+    class CurlError(RuntimeError):
+        status_code: int
+        body: ta.Optional[bytes]
 
-        out_dct = self._rewrite_compose_dct(in_dct)
+        def __str__(self) -> str:
+            return repr(self)
 
-        #
+    @dc.dataclass(frozen=True)
+    class CurlResult:
+        status_code: int
+        body: ta.Optional[bytes]
+
+        def as_error(self) -> 'GithubV1CacheShellClient.CurlError':
+            return GithubV1CacheShellClient.CurlError(
+                status_code=self.status_code,
+                body=self.body,
+            )
 
-        out_compose_file = make_temp_file()
-        self._enter_context(defer(lambda: os.unlink(out_compose_file)))  # noqa
+    def run_curl_cmd(
+            self,
+            cmd: ShellCmd,
+            *,
+            raise_: bool = False,
+    ) -> CurlResult:
+        out_file = make_temp_file()
+        with defer(lambda: os.unlink(out_file)):
+            run_cmd = dc.replace(cmd, s=f"{cmd.s} -o {out_file} -w '%{{json}}'")
 
-        compose_json = json_dumps_pretty(out_dct)
+            out_json_bytes = run_cmd.run(subprocesses.check_output)
 
-        with open(out_compose_file, 'w') as f:
-            f.write(compose_json)
+            out_json = json.loads(out_json_bytes.decode())
+            status_code = check.isinstance(out_json['response_code'], int)
 
-        return out_compose_file
+            with open(out_file, 'rb') as f:
+                body = f.read()
 
-    #
+            result = self.CurlResult(
+                status_code=status_code,
+                body=body,
+            )
 
-    def run(self) -> None:
-        self.tag_image()
+        if raise_ and (500 <= status_code <= 600):
+            raise result.as_error()
 
-        compose_file = self.rewrite_compose_file()
+        return result
 
-        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,
-            )
+    def run_json_curl_cmd(
+            self,
+            cmd: ShellCmd,
+            *,
+            success_status_codes: ta.Optional[ta.Container[int]] = None,
+    ) -> ta.Optional[ta.Any]:
+        result = self.run_curl_cmd(cmd, raise_=True)
 
-        finally:
-            subprocesses.check_call(
-                'docker',
-                'compose',
-                '-f', compose_file,
-                'down',
-            )
+        if success_status_codes is not None:
+            is_success = result.status_code in success_status_codes
+        else:
+            is_success = 200 <= result.status_code < 300
 
+        if is_success:
+            if not (body := result.body):
+                return None
+            return json.loads(body.decode('utf-8-sig'))
 
-########################################
-# ../dockertars.py
-"""
-TODO:
- - some less stupid Dockerfile hash
-  - doesn't change too much though
-"""
+        elif result.status_code == 404:
+            return None
 
+        else:
+            raise result.as_error()
 
-##
+    #
 
+    def build_get_entry_curl_cmd(self, key: str) -> ShellCmd:
+        return self.build_curl_cmd(
+            'GET',
+            f'cache?keys={key}',
+        )
 
-def build_docker_file_hash(docker_file: str) -> str:
-    with open(docker_file) as f:
-        contents = f.read()
+    def run_get_entry(self, key: str) -> ta.Optional[GithubCacheServiceV1.ArtifactCacheEntry]:
+        curl_cmd = self.build_get_entry_curl_cmd(key)
 
-    return sha256_str(contents)
+        obj = self.run_json_curl_cmd(
+            curl_cmd,
+            success_status_codes=[200, 204],
+        )
+        if obj is None:
+            return None
 
+        return GithubCacheServiceV1.dataclass_from_json(
+            GithubCacheServiceV1.ArtifactCacheEntry,
+            obj,
+        )
 
-##
+    #
 
+    def build_download_get_entry_cmd(
+            self,
+            entry: GithubCacheServiceV1.ArtifactCacheEntry,
+            out_file: str,
+    ) -> ShellCmd:
+        return ShellCmd(' '.join([
+            'aria2c',
+            '-x', '4',
+            '-o', out_file,
+            check.non_empty_str(entry.archive_location),
+        ]))
+
+    def download_get_entry(
+            self,
+            entry: GithubCacheServiceV1.ArtifactCacheEntry,
+            out_file: str,
+    ) -> None:
+        dl_cmd = self.build_download_get_entry_cmd(entry, out_file)
+        dl_cmd.run(subprocesses.check_call)
 
-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 upload_cache_entry(
+            self,
+            key: str,
+            in_file: str,
+    ) -> None:
+        check.state(os.path.isfile(in_file))
 
+        file_size = os.stat(in_file).st_size
 
-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()
+        reserve_req = GithubCacheServiceV1.ReserveCacheRequest(
+            key=key,
+            cache_size=file_size,
+        )
+        reserve_cmd = self.build_post_json_curl_cmd(
+            'caches',
+            GithubCacheServiceV1.dataclass_to_json(reserve_req),
+        )
+        reserve_resp_obj: ta.Any = check.not_none(self.run_json_curl_cmd(
+            reserve_cmd,
+            success_status_codes=[201],
+        ))
+        reserve_resp = GithubCacheServiceV1.dataclass_from_json(  # noqa
+            GithubCacheServiceV1.ReserveCacheResponse,
+            reserve_resp_obj,
+        )
 
-    index = json.loads(i.decode('utf-8'))
-    manifest = check.single(index['manifests'])
-    image_id = check.non_empty_str(manifest['digest'])
-    return image_id
+        raise NotImplementedError
 
 
 ##
 
 
-def is_docker_image_present(image: str) -> bool:
-    out = subprocesses.check_output(
-        'docker',
-        'images',
-        '--format', 'json',
-        image,
-    )
+class GithubShellCache(ShellCache):
+    def __init__(
+            self,
+            dir: str,  # noqa
+            *,
+            client: ta.Optional[GithubV1CacheShellClient] = None,
+    ) -> None:
+        super().__init__()
 
-    out_s = out.decode('utf-8').strip()
-    if not out_s:
-        return False
+        self._dir = check.not_none(dir)
 
-    json.loads(out_s)  # noqa
-    return True
+        if client is None:
+            client = GithubV1CacheShellClient()
+        self._client = client
 
+        self._local = DirectoryFileCache(self._dir)
 
-##
+    def get_file_cmd(self, key: str) -> ta.Optional[ShellCmd]:
+        local_file = self._local.get_cache_file_path(key)
+        if os.path.exists(local_file):
+            return ShellCmd(f'cat {shlex.quote(local_file)}')
 
+        if (entry := self._client.run_get_entry(key)) is None:
+            return None
 
-def pull_docker_tar(
-        image: str,
-        tar_file: str,
-) -> None:
-    subprocesses.check_call(
-        'docker',
-        'pull',
-        image,
-    )
+        tmp_file = self._local.format_incomplete_file(local_file)
+        try:
+            self._client.download_get_entry(entry, tmp_file)
 
-    subprocesses.check_call(
-        'docker',
-        'save',
-        image,
-        '-o', tar_file,
-    )
+            os.replace(tmp_file, local_file)
 
+        except BaseException:  # noqa
+            os.unlink(tmp_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 {}),
-        )
+            raise
 
-        with open(id_file) as f:
-            image_id = check.single(f.read().strip().splitlines()).strip()
+        return ShellCmd(f'cat {shlex.quote(local_file)}')
 
-        subprocesses.check_call(
-            'docker',
-            'save',
-            image_id,
-            '-o', tar_file,
-        )
+    class _PutFileCmdContext(ShellCache.PutFileCmdContext):  # noqa
+        def __init__(
+                self,
+                owner: 'GithubShellCache',
+                key: str,
+                tmp_file: str,
+                local_file: str,
+        ) -> None:
+            super().__init__()
 
-        return image_id
+            self._owner = owner
+            self._key = key
+            self._tmp_file = tmp_file
+            self._local_file = local_file
 
+        @property
+        def cmd(self) -> ShellCmd:
+            return ShellCmd(f'cat > {shlex.quote(self._tmp_file)}')
 
-##
+        def _commit(self) -> None:
+            os.replace(self._tmp_file, self._local_file)
 
+            self._owner._client.upload_cache_entry(self._key, self._local_file)  # noqa
 
-def load_docker_tar(
-        tar_file: str,
-) -> None:
-    subprocesses.check_call(
-        'docker',
-        'load',
-        '-i', tar_file,
-    )
+        def _abort(self) -> None:
+            os.unlink(self._tmp_file)
+
+    def put_file_cmd(self, key: str) -> ShellCache.PutFileCmdContext:
+        local_file = self._local.get_cache_file_path(key, make_dirs=True)
+        return self._PutFileCmdContext(
+            self,
+            key,
+            self._local.format_incomplete_file(local_file),
+            local_file,
+        )
 
 
 ########################################
@@ -1845,6 +3013,7 @@ def download_requirements(
         subprocesses.check_call(
             'docker',
             'run',
+            '--rm',
             '-i',
             '-v', f'{os.path.abspath(requirements_dir)}:/requirements',
             '-v', f'{requirements_txt_dir}:/requirements_txt',
@@ -1852,10 +3021,10 @@ def download_requirements(
             'pip',
             'download',
             '-d', '/requirements',
-            *itertools.chain.from_iterable([
+            *itertools.chain.from_iterable(
                 ['-r', f'/requirements_txt/{os.path.basename(rt)}']
                 for rt in requirements_txts
-            ]),
+            ),
         )
 
 
@@ -1863,9 +3032,6 @@ def download_requirements(
 # ../ci.py
 
 
-##
-
-
 class Ci(ExitStacked):
     FILE_NAME_HASH_LEN = 16
 
@@ -1878,8 +3044,12 @@ class Ci(ExitStacked):
         compose_file: str
         service: str
 
+        cmd: ShellCmd
+
         requirements_txts: ta.Optional[ta.Sequence[str]] = None
 
+        always_pull: bool = False
+
         def __post_init__(self) -> None:
             check.not_isinstance(self.requirements_txts, str)
 
@@ -1887,40 +3057,61 @@ class Ci(ExitStacked):
             self,
             cfg: Config,
             *,
+            shell_cache: ta.Optional[ShellCache] = None,
             file_cache: ta.Optional[FileCache] = None,
     ) -> None:
         super().__init__()
 
         self._cfg = cfg
+        self._shell_cache = shell_cache
         self._file_cache = file_cache
 
     #
 
-    def load_docker_image(self, image: str) -> None:
-        if is_docker_image_present(image):
+    def _load_cache_docker_image(self, key: str) -> ta.Optional[str]:
+        if self._shell_cache is None:
+            return None
+
+        get_cache_cmd = self._shell_cache.get_file_cmd(key)
+        if get_cache_cmd is None:
+            return None
+
+        get_cache_cmd = dc.replace(get_cache_cmd, s=f'{get_cache_cmd.s} | zstd -cd --long')  # noqa
+
+        return load_docker_tar_cmd(get_cache_cmd)
+
+    def _save_cache_docker_image(self, key: str, image: str) -> None:
+        if self._shell_cache is None:
+            return
+
+        with self._shell_cache.put_file_cmd(key) as put_cache:
+            put_cache_cmd = put_cache.cmd
+
+            put_cache_cmd = dc.replace(put_cache_cmd, s=f'zstd | {put_cache_cmd.s}')
+
+            save_docker_tar_cmd(image, put_cache_cmd)
+
+    #
+
+    def _load_docker_image(self, image: str) -> None:
+        if not self._cfg.always_pull and 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)
+        cache_key = f'docker-{dep_suffix}'
+        if self._load_cache_docker_image(cache_key) is not None:
             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_image(image)
 
-            pull_docker_tar(
-                image,
-                temp_tar_file,
-            )
+        self._save_cache_docker_image(cache_key, image)
 
-            if self._file_cache is not None:
-                self._file_cache.put_file(temp_tar_file)
+    def load_docker_image(self, image: str) -> None:
+        with log_timing_context(f'Load docker image: {image}'):
+            self._load_docker_image(image)
 
     @cached_nullary
     def load_compose_service_dependencies(self) -> None:
@@ -1934,46 +3125,46 @@ class Ci(ExitStacked):
 
     #
 
-    @cached_nullary
-    def build_ci_image(self) -> str:
+    def _resolve_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
+        cache_key = f'ci-{docker_file_hash}'
+        if (cache_image_id := self._load_cache_docker_image(cache_key)) is not None:
+            return cache_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_image(
+            self._cfg.docker_file,
+            cwd=self._cfg.project_dir,
+        )
 
-            image_id = build_docker_tar(
-                self._cfg.docker_file,
-                temp_tar_file,
-                cwd=self._cfg.project_dir,
-            )
+        self._save_cache_docker_image(cache_key, image_id)
 
-            if self._file_cache is not None:
-                self._file_cache.put_file(temp_tar_file)
+        return image_id
 
+    @cached_nullary
+    def resolve_ci_image(self) -> str:
+        with log_timing_context('Resolve ci image') as ltc:
+            image_id = self._resolve_ci_image()
+            ltc.set_description(f'Resolve ci image: {image_id}')
             return image_id
 
     #
 
-    @cached_nullary
-    def build_requirements_dir(self) -> str:
-        requirements_txts = check.not_none(self._cfg.requirements_txts)
+    def _resolve_requirements_dir(self) -> str:
+        requirements_txts = [
+            os.path.join(self._cfg.project_dir, rf)
+            for rf in 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'
+        tar_file_key = f'requirements-{requirements_hash}'
+        tar_file_name = f'{tar_file_key}.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)):
+        if self._file_cache is not None and (cache_tar_file := self._file_cache.get_file(tar_file_key)):
             with tarfile.open(cache_tar_file) as tar:
                 tar.extractall(path=temp_dir)  # noqa
 
@@ -1983,7 +3174,7 @@ class Ci(ExitStacked):
         os.makedirs(temp_requirements_dir)
 
         download_requirements(
-            self.build_ci_image(),
+            self.resolve_ci_image(),
             temp_requirements_dir,
             requirements_txts,
         )
@@ -1998,21 +3189,20 @@ class Ci(ExitStacked):
                         arcname=requirement_file,
                     )
 
-            self._file_cache.put_file(temp_tar_file)
+            self._file_cache.put_file(os.path.basename(tar_file_key), 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()
+    @cached_nullary
+    def resolve_requirements_dir(self) -> str:
+        with log_timing_context('Resolve requirements dir') as ltc:
+            requirements_dir = self._resolve_requirements_dir()
+            ltc.set_description(f'Resolve requirements dir: {requirements_dir}')
+            return requirements_dir
 
-        #
+    #
 
+    def _run_compose_(self) -> None:
         setup_cmds = [
             'pip install --root-user-action ignore --find-links /requirements --no-index uv',
             (
@@ -2023,40 +3213,74 @@ class Ci(ExitStacked):
 
         #
 
-        test_cmds = [
-            '(cd /project && python3 -m pytest -svv test.py)',
-        ]
+        ci_cmd = dc.replace(self._cfg.cmd, s=' && '.join([
+            *setup_cmds,
+            f'({self._cfg.cmd.s})',
+        ]))
 
         #
 
-        bash_src = ' && '.join([
-            *setup_cmds,
-            *test_cmds,
-        ])
-
         with DockerComposeRun(DockerComposeRun.Config(
-                compose_file=self._cfg.compose_file,
-                service=self._cfg.service,
+            compose_file=self._cfg.compose_file,
+            service=self._cfg.service,
 
-                image=ci_image,
+            image=self.resolve_ci_image(),
 
-                run_cmd=['bash', '-c', bash_src],
+            cmd=ci_cmd,
 
-                run_options=[
-                    '-v', f'{os.path.abspath(self._cfg.project_dir)}:/project',
-                    '-v', f'{os.path.abspath(requirements_dir)}:/requirements',
-                ],
+            run_options=[
+                '-v', f'{os.path.abspath(self._cfg.project_dir)}:/project',
+                '-v', f'{os.path.abspath(self.resolve_requirements_dir())}:/requirements',
+            ],
 
-                cwd=self._cfg.project_dir,
+            cwd=self._cfg.project_dir,
         )) as ci_compose_run:
             ci_compose_run.run()
 
+    def _run_compose(self) -> None:
+        with log_timing_context('Run compose'):
+            self._run_compose_()
+
+    #
+
+    def run(self) -> None:
+        self.load_compose_service_dependencies()
+
+        self.resolve_ci_image()
+
+        self.resolve_requirements_dir()
+
+        self._run_compose()
+
 
 ########################################
-# cli.py
+# ../github/cli.py
+"""
+See:
+ - https://docs.github.com/en/rest/actions/cache?apiVersion=2022-11-28
+"""
 
 
-##
+class GithubCli(ArgparseCli):
+    @argparse_cmd(
+        argparse_arg('key'),
+    )
+    def get_cache_entry(self) -> None:
+        shell_client = GithubV1CacheShellClient()
+        entry = shell_client.run_get_entry(self.args.key)
+        if entry is None:
+            return
+        print(json_dumps_pretty(dc.asdict(entry)))  # noqa
+
+    @argparse_cmd(
+        argparse_arg('repository-id'),
+    )
+    def list_cache_entries(self) -> None:
+        raise NotImplementedError
+
+
+########################################
+# cli.py
 
 
 class CiCli(ArgparseCli):
@@ -2087,23 +3311,32 @@ class CiCli(ArgparseCli):
 
     #
 
+    @argparse_cmd(
+        accepts_unknown=True,
+    )
+    def github(self) -> ta.Optional[int]:
+        return GithubCli(self.unknown_args).cli_run()
+
+    #
+
     @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('--github-cache', action='store_true'),
         argparse_arg('--cache-dir'),
+        argparse_arg('--always-pull', action='store_true'),
     )
     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
+        always_pull = self.args.always_pull
 
         #
 
@@ -2113,7 +3346,7 @@ class CiCli(ArgparseCli):
 
         def find_alt_file(*alts: str) -> ta.Optional[str]:
             for alt in alts:
-                alt_file = os.path.join(project_dir, alt)
+                alt_file = os.path.abspath(os.path.join(project_dir, alt))
                 if os.path.isfile(alt_file):
                     return alt_file
             return None
@@ -2128,10 +3361,16 @@ class CiCli(ArgparseCli):
         check.state(os.path.isfile(docker_file))
 
         if compose_file is None:
-            compose_file = find_alt_file(
-                'docker/compose.yml',
-                'compose.yml',
-            )
+            compose_file = find_alt_file(*[
+                f'{f}.{x}'
+                for f in [
+                    'docker/docker-compose',
+                    'docker/compose',
+                    'docker-compose',
+                    'compose',
+                ]
+                for x in ['yaml', 'yml']
+            ])
         check.state(os.path.isfile(compose_file))
 
         if not requirements_txts:
@@ -2149,24 +3388,44 @@ class CiCli(ArgparseCli):
 
         #
 
+        shell_cache: ta.Optional[ShellCache] = None
         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)
+
+            directory_file_cache = DirectoryFileCache(cache_dir)
+
+            file_cache = directory_file_cache
+
+            if self.args.github_cache:
+                shell_cache = GithubShellCache(cache_dir)
+            else:
+                shell_cache = DirectoryShellCache(directory_file_cache)
 
         #
 
         with Ci(
                 Ci.Config(
                     project_dir=project_dir,
+
                     docker_file=docker_file,
+
                     compose_file=compose_file,
                     service=service,
+
                     requirements_txts=requirements_txts,
+
+                    cmd=ShellCmd(' && '.join([
+                        'cd /project',
+                        'python3 -m pytest -svv test.py',
+                    ])),
+
+                    always_pull=always_pull,
                 ),
                 file_cache=file_cache,
+                shell_cache=shell_cache,
         ) as ci:
             ci.run()
 
@@ -2176,6 +3435,8 @@ async def _async_main() -> ta.Optional[int]:
 
 
 def _main() -> None:
+    configure_standard_logging('DEBUG')
+
     sys.exit(rc if isinstance(rc := asyncio.run(_async_main()), int) else 0)