ominfra 0.0.0.dev172__py3-none-any.whl → 0.0.0.dev174__py3-none-any.whl

ominfra/scripts/manage.py

@@ -77,6 +77,9 @@ TomlParseFloat = ta.Callable[[str], ta.Any]
 TomlKey = ta.Tuple[str, ...]
 TomlPos = int  # ta.TypeAlias
 
+# deploy/paths/types.py
+DeployPathKind = ta.Literal['dir', 'file']  # ta.TypeAlias
+
 # ../../omlish/asyncs/asyncio/timeouts.py
 AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
 
@@ -92,6 +95,11 @@ CheckOnRaiseFn = ta.Callable[[Exception], None]  # ta.TypeAlias
 CheckExceptionFactory = ta.Callable[..., Exception]  # ta.TypeAlias
 CheckArgsRenderer = ta.Callable[..., ta.Optional[str]]  # ta.TypeAlias
 
+# ../../omlish/lite/typing.py
+A0 = ta.TypeVar('A0')
+A1 = ta.TypeVar('A1')
+A2 = ta.TypeVar('A2')
+
 # ../../omdev/packaging/specifiers.py
 UnparsedVersion = ta.Union['Version', str]
 UnparsedVersionVar = ta.TypeVar('UnparsedVersionVar', bound=UnparsedVersion)
@@ -101,10 +109,6 @@ CallableVersionOperator = ta.Callable[['Version', str], bool]
 CommandT = ta.TypeVar('CommandT', bound='Command')
 CommandOutputT = ta.TypeVar('CommandOutputT', bound='Command.Output')
 
-# deploy/types.py
-DeployPathKind = ta.Literal['dir', 'file']  # ta.TypeAlias
-DeployPathPlaceholder = ta.Literal['app', 'tag', 'conf']  # ta.TypeAlias
-
 # ../../omlish/argparse/cli.py
 ArgparseCommandFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
 
@@ -125,6 +129,9 @@ AtomicPathSwapState = ta.Literal['open', 'committed', 'aborted']  # ta.TypeAlias
 # ../configs.py
 ConfigMapping = ta.Mapping[str, ta.Any]
 
+# deploy/specs.py
+KeyDeployTagT = ta.TypeVar('KeyDeployTagT', bound='KeyDeployTag')
+
 # ../../omlish/subprocesses.py
 SubprocessChannelOption = ta.Literal['pipe', 'stdout', 'devnull']  # ta.TypeAlias
 
@@ -1380,6 +1387,25 @@ class DeployConfig:
     deploy_home: ta.Optional[str] = None
 
 
+########################################
+# ../deploy/paths/types.py
+
+
+##
+
+
+########################################
+# ../deploy/types.py
+
+
+##
+
+
+DeployHome = ta.NewType('DeployHome', str)
+
+DeployRev = ta.NewType('DeployRev', str)
+
+
 ########################################
 # ../../pyremote.py
 """
@@ -2641,6 +2667,9 @@ def pycharm_debug_preamble(prd: PycharmRemoteDebug) -> str:
 # ../../../omlish/lite/reflect.py
 
 
+##
+
+
 _GENERIC_ALIAS_TYPES = (
     ta._GenericAlias,  # type: ignore  # noqa
     *([ta._SpecialGenericAlias] if hasattr(ta, '_SpecialGenericAlias') else []),  # noqa
@@ -2658,6 +2687,9 @@ 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
@@ -2672,6 +2704,9 @@ def get_optional_alias_arg(spec: ta.Any) -> ta.Any:
     return it
 
 
+##
+
+
 def is_new_type(spec: ta.Any) -> bool:
     if isinstance(ta.NewType, type):
         return isinstance(spec, ta.NewType)
@@ -2684,6 +2719,26 @@ 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__()))
@@ -2823,6 +2878,54 @@ def format_num_bytes(num_bytes: int) -> str:
     return f'{num_bytes / 1024 ** (len(FORMAT_NUM_BYTES_SUFFIXES) - 1):.2f}{FORMAT_NUM_BYTES_SUFFIXES[-1]}'
 
 
+########################################
+# ../../../omlish/lite/typing.py
+
+
+##
+# A workaround for typing deficiencies (like `Argument 2 to NewType(...) must be subclassable`).
+
+
+@dc.dataclass(frozen=True)
+class AnyFunc(ta.Generic[T]):
+    fn: ta.Callable[..., T]
+
+    def __call__(self, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self.fn(*args, **kwargs)
+
+
+@dc.dataclass(frozen=True)
+class Func0(ta.Generic[T]):
+    fn: ta.Callable[[], T]
+
+    def __call__(self) -> T:
+        return self.fn()
+
+
+@dc.dataclass(frozen=True)
+class Func1(ta.Generic[A0, T]):
+    fn: ta.Callable[[A0], T]
+
+    def __call__(self, a0: A0) -> T:
+        return self.fn(a0)
+
+
+@dc.dataclass(frozen=True)
+class Func2(ta.Generic[A0, A1, T]):
+    fn: ta.Callable[[A0, A1], T]
+
+    def __call__(self, a0: A0, a1: A1) -> T:
+        return self.fn(a0, a1)
+
+
+@dc.dataclass(frozen=True)
+class Func3(ta.Generic[A0, A1, A2, T]):
+    fn: ta.Callable[[A0, A1, A2], T]
+
+    def __call__(self, a0: A0, a1: A1, a2: A2) -> T:
+        return self.fn(a0, a1, a2)
+
+
 ########################################
 # ../../../omlish/logs/filters.py
 
@@ -4149,39 +4252,227 @@ def build_command_name_map(crs: CommandRegistrations) -> CommandNameMap:
 
 
 ########################################
-# ../deploy/types.py
+# ../deploy/tags.py
 
 
 ##
 
 
-DeployHome = ta.NewType('DeployHome', str)
+DEPLOY_TAG_SIGIL = '@'
 
-DeployApp = ta.NewType('DeployApp', str)
-DeployTag = ta.NewType('DeployTag', str)
-DeployRev = ta.NewType('DeployRev', str)
-DeployKey = ta.NewType('DeployKey', str)
+DEPLOY_TAG_SEPARATOR = '--'
+
+DEPLOY_TAG_DELIMITERS: ta.AbstractSet[str] = frozenset([
+    DEPLOY_TAG_SEPARATOR,
+    '.',
+])
+
+DEPLOY_TAG_ILLEGAL_STRS: ta.AbstractSet[str] = frozenset([
+    DEPLOY_TAG_SIGIL,
+    *DEPLOY_TAG_DELIMITERS,
+    '/',
+])
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class DeployAppTag:
-    app: DeployApp
-    tag: DeployTag
+class DeployTag(abc.ABC):  # noqa
+    s: str
 
     def __post_init__(self) -> None:
-        for s in [self.app, self.tag]:
-            check.non_empty_str(s)
-            check.equal(s, s.strip())
+        check.not_in(abc.ABC, type(self).__bases__)
+        check.non_empty_str(self.s)
+        for ch in DEPLOY_TAG_ILLEGAL_STRS:
+            check.state(ch not in self.s)
 
-    def placeholders(self) -> ta.Mapping[DeployPathPlaceholder, str]:
-        return {
-            'app': self.app,
-            'tag': self.tag,
+    #
+
+    tag_name: ta.ClassVar[str]
+    tag_kwarg: ta.ClassVar[str]
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        if abc.ABC in cls.__bases__:
+            return
+
+        for b in cls.__bases__:
+            if issubclass(b, DeployTag):
+                check.in_(abc.ABC, b.__bases__)
+
+        check.non_empty_str(tn := cls.tag_name)
+        check.equal(tn, tn.lower().strip())
+        check.not_in('_', tn)
+
+        check.state(not hasattr(cls, 'tag_kwarg'))
+        cls.tag_kwarg = tn.replace('-', '_')
+
+
+##
+
+
+_DEPLOY_TAGS: ta.Set[ta.Type[DeployTag]] = set()
+DEPLOY_TAGS: ta.AbstractSet[ta.Type[DeployTag]] = _DEPLOY_TAGS
+
+_DEPLOY_TAGS_BY_NAME: ta.Dict[str, ta.Type[DeployTag]] = {}
+DEPLOY_TAGS_BY_NAME: ta.Mapping[str, ta.Type[DeployTag]] = _DEPLOY_TAGS_BY_NAME
+
+_DEPLOY_TAGS_BY_KWARG: ta.Dict[str, ta.Type[DeployTag]] = {}
+DEPLOY_TAGS_BY_KWARG: ta.Mapping[str, ta.Type[DeployTag]] = _DEPLOY_TAGS_BY_KWARG
+
+
+def _register_deploy_tag(cls):
+    check.not_in(cls.tag_name, _DEPLOY_TAGS_BY_NAME)
+    check.not_in(cls.tag_kwarg, _DEPLOY_TAGS_BY_KWARG)
+
+    _DEPLOY_TAGS.add(cls)
+    _DEPLOY_TAGS_BY_NAME[cls.tag_name] = cls
+    _DEPLOY_TAGS_BY_KWARG[cls.tag_kwarg] = cls
+
+    return cls
+
+
+##
+
+
+@_register_deploy_tag
+class DeployTime(DeployTag):
+    tag_name: ta.ClassVar[str] = 'time'
+
+
+##
+
+
+class NameDeployTag(DeployTag, abc.ABC):  # noqa
+    pass
+
+
+@_register_deploy_tag
+class DeployApp(NameDeployTag):
+    tag_name: ta.ClassVar[str] = 'app'
+
+
+@_register_deploy_tag
+class DeployConf(NameDeployTag):
+    tag_name: ta.ClassVar[str] = 'conf'
+
+
+##
+
+
+class KeyDeployTag(DeployTag, abc.ABC):  # noqa
+    pass
+
+
+@_register_deploy_tag
+class DeployKey(KeyDeployTag):
+    tag_name: ta.ClassVar[str] = 'deploy-key'
+
+
+@_register_deploy_tag
+class DeployAppKey(KeyDeployTag):
+    tag_name: ta.ClassVar[str] = 'app-key'
+
+
+##
+
+
+class RevDeployTag(DeployTag, abc.ABC):  # noqa
+    pass
+
+
+@_register_deploy_tag
+class DeployAppRev(RevDeployTag):
+    tag_name: ta.ClassVar[str] = 'app-rev'
+
+
+##
+
+
+class DeployTagMap:
+    def __init__(
+            self,
+            *args: DeployTag,
+            **kwargs: str,
+    ) -> None:
+        super().__init__()
+
+        dct: ta.Dict[ta.Type[DeployTag], DeployTag] = {}
+
+        for a in args:
+            c = type(check.isinstance(a, DeployTag))
+            check.not_in(c, dct)
+            dct[c] = a
+
+        for k, v in kwargs.items():
+            c = DEPLOY_TAGS_BY_KWARG[k]
+            check.not_in(c, dct)
+            dct[c] = c(v)
+
+        self._dct = dct
+        self._tup = tuple(sorted((type(t).tag_kwarg, t.s) for t in dct.values()))
+
+    #
+
+    def add(self, *args: ta.Any, **kwargs: ta.Any) -> 'DeployTagMap':
+        return DeployTagMap(
+            *self,
+            *args,
+            **kwargs,
+        )
+
+    def remove(self, *tags_or_names: ta.Union[ta.Type[DeployTag], str]) -> 'DeployTagMap':
+        dcs = {
+            check.issubclass(a, DeployTag) if isinstance(a, type) else DEPLOY_TAGS_BY_NAME[a]
+            for a in tags_or_names
         }
 
+        return DeployTagMap(*[
+            t
+            for t in self._dct.values()
+            if t not in dcs
+        ])
+
+    #
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({", ".join(f"{k}={v!r}" for k, v in self._tup)})'
+
+    def __hash__(self) -> int:
+        return hash(self._tup)
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, DeployTagMap):
+            return self._tup == other._tup
+        else:
+            return NotImplemented
+
+    #
+
+    def __len__(self) -> int:
+        return len(self._dct)
+
+    def __iter__(self) -> ta.Iterator[DeployTag]:
+        return iter(self._dct.values())
+
+    def __getitem__(self, key: ta.Union[ta.Type[DeployTag], str]) -> DeployTag:
+        if isinstance(key, str):
+            return self._dct[DEPLOY_TAGS_BY_NAME[key]]
+        elif isinstance(key, type):
+            return self._dct[key]
+        else:
+            raise TypeError(key)
+
+    def __contains__(self, key: ta.Union[ta.Type[DeployTag], str]) -> bool:
+        if isinstance(key, str):
+            return DEPLOY_TAGS_BY_NAME[key] in self._dct
+        elif isinstance(key, type):
+            return key in self._dct
+        else:
+            raise TypeError(key)
+
 
 ########################################
 # ../remote/config.py
@@ -5787,6 +6078,18 @@ class OptionalObjMarshaler(ObjMarshaler):
         return self.item.unmarshal(o, ctx)
 
 
+@dc.dataclass(frozen=True)
+class LiteralObjMarshaler(ObjMarshaler):
+    item: ObjMarshaler
+    vs: frozenset
+
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.item.marshal(check.in_(o, self.vs), ctx)
+
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return check.in_(self.item.unmarshal(o, ctx), self.vs)
+
+
 @dc.dataclass(frozen=True)
 class MappingObjMarshaler(ObjMarshaler):
     ty: type
@@ -5998,6 +6301,11 @@ class ObjMarshalerManager:
         if is_new_type(ty):
             return rec(get_new_type_supertype(ty))
 
+        if is_literal_type(ty):
+            lvs = frozenset(get_literal_type_args(ty))
+            lty = check.single(set(map(type, lvs)))
+            return LiteralObjMarshaler(rec(lty), lvs)
+
         if is_generic_alias(ty):
             try:
                 mt = self._generic_mapping_types[ta.get_origin(ty)]
@@ -6634,28 +6942,13 @@ TODO:
 ##
 
 
-DEPLOY_PATH_PLACEHOLDER_SIGIL = '@'
-DEPLOY_PATH_PLACEHOLDER_SEPARATOR = '--'
-
-DEPLOY_PATH_PLACEHOLDER_DELIMITERS: ta.AbstractSet[str] = frozenset([
-    DEPLOY_PATH_PLACEHOLDER_SEPARATOR,
-    '.',
-])
-
-DEPLOY_PATH_PLACEHOLDERS: ta.FrozenSet[str] = frozenset([
-    'app',
-    'tag',
-    'conf',
-])
-
-
 class DeployPathError(Exception):
     pass
 
 
 class DeployPathRenderable(abc.ABC):
     @abc.abstractmethod
-    def render(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
+    def render(self, tags: ta.Optional[DeployTagMap] = None) -> str:
         raise NotImplementedError
 
 
@@ -6666,26 +6959,30 @@ class DeployPathNamePart(DeployPathRenderable, abc.ABC):
     @classmethod
     def parse(cls, s: str) -> 'DeployPathNamePart':
         check.non_empty_str(s)
-        if s.startswith(DEPLOY_PATH_PLACEHOLDER_SIGIL):
-            return PlaceholderDeployPathNamePart(s[1:])
-        elif s in DEPLOY_PATH_PLACEHOLDER_DELIMITERS:
+        if s.startswith(DEPLOY_TAG_SIGIL):
+            return TagDeployPathNamePart(s[1:])
+        elif s in DEPLOY_TAG_DELIMITERS:
             return DelimiterDeployPathNamePart(s)
         else:
             return ConstDeployPathNamePart(s)
 
 
 @dc.dataclass(frozen=True)
-class PlaceholderDeployPathNamePart(DeployPathNamePart):
-    placeholder: str  # DeployPathPlaceholder
+class TagDeployPathNamePart(DeployPathNamePart):
+    name: str
 
     def __post_init__(self) -> None:
-        check.in_(self.placeholder, DEPLOY_PATH_PLACEHOLDERS)
+        check.in_(self.name, DEPLOY_TAGS_BY_NAME)
 
-    def render(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
-        if placeholders is not None:
-            return placeholders[self.placeholder]  # type: ignore
+    @property
+    def tag(self) -> ta.Type[DeployTag]:
+        return DEPLOY_TAGS_BY_NAME[self.name]
+
+    def render(self, tags: ta.Optional[DeployTagMap] = None) -> str:
+        if tags is not None:
+            return tags[self.tag].s
         else:
-            return DEPLOY_PATH_PLACEHOLDER_SIGIL + self.placeholder
+            return DEPLOY_TAG_SIGIL + self.name
 
 
 @dc.dataclass(frozen=True)
@@ -6693,9 +6990,9 @@ class DelimiterDeployPathNamePart(DeployPathNamePart):
     delimiter: str
 
     def __post_init__(self) -> None:
-        check.in_(self.delimiter, DEPLOY_PATH_PLACEHOLDER_DELIMITERS)
+        check.in_(self.delimiter, DEPLOY_TAG_DELIMITERS)
 
-    def render(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
+    def render(self, tags: ta.Optional[DeployTagMap] = None) -> str:
         return self.delimiter
 
 
@@ -6705,10 +7002,10 @@ class ConstDeployPathNamePart(DeployPathNamePart):
 
     def __post_init__(self) -> None:
         check.non_empty_str(self.const)
-        for c in [*DEPLOY_PATH_PLACEHOLDER_DELIMITERS, DEPLOY_PATH_PLACEHOLDER_SIGIL, '/']:
+        for c in [*DEPLOY_TAG_DELIMITERS, DEPLOY_TAG_SIGIL, '/']:
             check.not_in(c, self.const)
 
-    def render(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
+    def render(self, tags: ta.Optional[DeployTagMap] = None) -> str:
         return self.const
 
 
@@ -6723,8 +7020,8 @@ class DeployPathName(DeployPathRenderable):
             if len(gl := list(g)) > 1:
                 raise DeployPathError(f'May not have consecutive path name part types: {k} {gl}')
 
-    def render(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
-        return ''.join(p.render(placeholders) for p in self.parts)
+    def render(self, tags: ta.Optional[DeployTagMap] = None) -> str:
+        return ''.join(p.render(tags) for p in self.parts)
 
     @classmethod
     def parse(cls, s: str) -> 'DeployPathName':
@@ -6734,7 +7031,7 @@ class DeployPathName(DeployPathRenderable):
         i = 0
         ps = []
         while i < len(s):
-            ns = [(n, d) for d in DEPLOY_PATH_PLACEHOLDER_DELIMITERS if (n := s.find(d, i)) >= 0]
+            ns = [(n, d) for d in DEPLOY_TAG_DELIMITERS if (n := s.find(d, i)) >= 0]
             if not ns:
                 ps.append(s[i:])
                 break
@@ -6758,8 +7055,8 @@ class DeployPathPart(DeployPathRenderable, abc.ABC):  # noqa
     def kind(self) -> DeployPathKind:
         raise NotImplementedError
 
-    def render(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
-        return self.name.render(placeholders) + ('/' if self.kind == 'dir' else '')
+    def render(self, tags: ta.Optional[DeployTagMap] = None) -> str:
+        return self.name.render(tags) + ('/' if self.kind == 'dir' else '')
 
     @classmethod
     def parse(cls, s: str) -> 'DeployPathPart':
@@ -6805,20 +7102,20 @@ class DeployPath:
         for p in self.parts[:-1]:
             check.equal(p.kind, 'dir')
 
-        pd: ta.Dict[DeployPathPlaceholder, ta.List[int]] = {}
+    @cached_nullary
+    def tag_indices(self) -> ta.Mapping[ta.Type[DeployTag], ta.Sequence[int]]:
+        pd: ta.Dict[ta.Type[DeployTag], ta.List[int]] = {}
         for i, np in enumerate(self.name_parts):
-            if isinstance(np, PlaceholderDeployPathNamePart):
-                pd.setdefault(ta.cast(DeployPathPlaceholder, np.placeholder), []).append(i)
-
-        # if 'tag' in pd and 'app' not in pd:
-        #     raise DeployPathError('Tag placeholder in path without app', self)
+            if isinstance(np, TagDeployPathNamePart):
+                pd.setdefault(np.tag, []).append(i)
+        return pd
 
     @property
     def kind(self) -> ta.Literal['file', 'dir']:
         return self.parts[-1].kind
 
-    def render(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
-        return ''.join([p.render(placeholders) for p in self.parts])
+    def render(self, tags: ta.Optional[DeployTagMap] = None) -> str:
+        return ''.join([p.render(tags) for p in self.parts])
 
     @classmethod
     def parse(cls, s: str) -> 'DeployPath':
@@ -6842,6 +7139,16 @@ def check_valid_deploy_spec_path(s: str) -> str:
     return s
 
 
+class DeploySpecKeyed(ta.Generic[KeyDeployTagT]):
+    @cached_nullary
+    def _key_str(self) -> str:
+        return hashlib.sha256(repr(self).encode('utf-8')).hexdigest()[:8]
+
+    @abc.abstractmethod
+    def key(self) -> KeyDeployTagT:
+        raise NotImplementedError
+
+
 ##
 
 
@@ -6887,7 +7194,7 @@ class DeployVenvSpec:
 
 
 @dc.dataclass(frozen=True)
-class DeployConfFile:
+class DeployAppConfFile:
     path: str
     body: str
 
@@ -6899,7 +7206,7 @@ class DeployConfFile:
 
 
 @dc.dataclass(frozen=True)
-class DeployConfLink(abc.ABC):  # noqa
+class DeployAppConfLink(abc.ABC):  # noqa
     """
     May be either:
      - @conf(.ext)* - links a single file in root of app conf dir to conf/@conf/@dst(.ext)*
@@ -6915,11 +7222,11 @@ class DeployConfLink(abc.ABC):  # noqa
             check.equal(self.src.count('/'), 1)
 
 
-class AppDeployConfLink(DeployConfLink):
+class CurrentOnlyDeployAppConfLink(DeployAppConfLink):
     pass
 
 
-class TagDeployConfLink(DeployConfLink):
+class AllActiveDeployAppConfLink(DeployAppConfLink):
     pass
 
 
@@ -6927,10 +7234,10 @@ class TagDeployConfLink(DeployConfLink):
 
 
 @dc.dataclass(frozen=True)
-class DeployConfSpec:
-    files: ta.Optional[ta.Sequence[DeployConfFile]] = None
+class DeployAppConfSpec:
+    files: ta.Optional[ta.Sequence[DeployAppConfFile]] = None
 
-    links: ta.Optional[ta.Sequence[DeployConfLink]] = None
+    links: ta.Optional[ta.Sequence[DeployAppConfLink]] = None
 
     def __post_init__(self) -> None:
         if self.files:
@@ -6944,18 +7251,37 @@ class DeployConfSpec:
 
 
 @dc.dataclass(frozen=True)
-class DeploySpec:
+class DeployAppSpec(DeploySpecKeyed[DeployAppKey]):
     app: DeployApp
 
     git: DeployGitSpec
 
     venv: ta.Optional[DeployVenvSpec] = None
 
-    conf: ta.Optional[DeployConfSpec] = None
+    conf: ta.Optional[DeployAppConfSpec] = None
 
-    @cached_nullary
+    # @ta.override
+    def key(self) -> DeployAppKey:
+        return DeployAppKey(self._key_str())
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DeploySpec(DeploySpecKeyed[DeployKey]):
+    apps: ta.Sequence[DeployAppSpec]
+
+    def __post_init__(self) -> None:
+        seen: ta.Set[DeployApp] = set()
+        for a in self.apps:
+            if a.app in seen:
+                raise KeyError(a.app)
+            seen.add(a.app)
+
+    # @ta.override
     def key(self) -> DeployKey:
-        return DeployKey(hashlib.sha256(repr(self).encode('utf-8')).hexdigest()[:8])
+        return DeployKey(self._key_str())
 
 
 ########################################
@@ -7575,18 +7901,18 @@ class DeployConfManager:
 
     #
 
-    async def _write_conf_file(
+    async def _write_app_conf_file(
             self,
-            cf: DeployConfFile,
-            conf_dir: str,
+            acf: DeployAppConfFile,
+            app_conf_dir: str,
     ) -> None:
-        conf_file = os.path.join(conf_dir, cf.path)
-        check.arg(is_path_in_dir(conf_dir, conf_file))
+        conf_file = os.path.join(app_conf_dir, acf.path)
+        check.arg(is_path_in_dir(app_conf_dir, conf_file))
 
         os.makedirs(os.path.dirname(conf_file), exist_ok=True)
 
         with open(conf_file, 'w') as f:  # noqa
-            f.write(cf.body)
+            f.write(acf.body)
 
     #
 
@@ -7595,15 +7921,18 @@ class DeployConfManager:
         link_src: str
         link_dst: str
 
-    def _compute_conf_link_dst(
+    _UNIQUE_LINK_NAME_STR = '@app--@time--@app-key'
+    _UNIQUE_LINK_NAME = DeployPath.parse(_UNIQUE_LINK_NAME_STR)
+
+    def _compute_app_conf_link_dst(
             self,
-            link: DeployConfLink,
-            app_tag: DeployAppTag,
-            conf_dir: str,
-            link_dir: str,
+            link: DeployAppConfLink,
+            tags: DeployTagMap,
+            app_conf_dir: str,
+            conf_link_dir: str,
     ) -> _ComputedConfLink:
-        link_src = os.path.join(conf_dir, link.src)
-        check.arg(is_path_in_dir(conf_dir, link_src))
+        link_src = os.path.join(app_conf_dir, link.src)
+        check.arg(is_path_in_dir(app_conf_dir, link_src))
 
         #
 
@@ -7618,7 +7947,7 @@ class DeployConfManager:
             d, f = os.path.split(link.src)
             # TODO: check filename :|
             link_dst_pfx = d + '/'
-            link_dst_sfx = DEPLOY_PATH_PLACEHOLDER_SEPARATOR + f
+            link_dst_sfx = DEPLOY_TAG_SEPARATOR + f
 
         else:  # noqa
             # @conf(.ext)* - links a single file in root of app conf dir to conf/@conf/@dst(.ext)*
@@ -7632,10 +7961,10 @@ class DeployConfManager:
 
         #
 
-        if isinstance(link, AppDeployConfLink):
-            link_dst_mid = str(app_tag.app)
-        elif isinstance(link, TagDeployConfLink):
-            link_dst_mid = DEPLOY_PATH_PLACEHOLDER_SEPARATOR.join([app_tag.app, app_tag.tag])
+        if isinstance(link, CurrentOnlyDeployAppConfLink):
+            link_dst_mid = str(tags[DeployApp].s)
+        elif isinstance(link, AllActiveDeployAppConfLink):
+            link_dst_mid = self._UNIQUE_LINK_NAME.render(tags)
         else:
             raise TypeError(link)
 
@@ -7646,7 +7975,7 @@ class DeployConfManager:
             link_dst_mid,
             link_dst_sfx,
         ])
-        link_dst = os.path.join(link_dir, link_dst_name)
+        link_dst = os.path.join(conf_link_dir, link_dst_name)
 
         return DeployConfManager._ComputedConfLink(
             is_dir=is_dir,
@@ -7654,24 +7983,24 @@ class DeployConfManager:
             link_dst=link_dst,
         )
 
-    async def _make_conf_link(
+    async def _make_app_conf_link(
             self,
-            link: DeployConfLink,
-            app_tag: DeployAppTag,
-            conf_dir: str,
-            link_dir: str,
+            link: DeployAppConfLink,
+            tags: DeployTagMap,
+            app_conf_dir: str,
+            conf_link_dir: str,
     ) -> None:
-        comp = self._compute_conf_link_dst(
+        comp = self._compute_app_conf_link_dst(
             link,
-            app_tag,
-            conf_dir,
-            link_dir,
+            tags,
+            app_conf_dir,
+            conf_link_dir,
         )
 
         #
 
-        check.arg(is_path_in_dir(conf_dir, comp.link_src))
-        check.arg(is_path_in_dir(link_dir, comp.link_dst))
+        check.arg(is_path_in_dir(app_conf_dir, comp.link_src))
+        check.arg(is_path_in_dir(conf_link_dir, comp.link_dst))
 
         if comp.is_dir:
             check.arg(os.path.isdir(comp.link_src))
@@ -7689,27 +8018,27 @@ class DeployConfManager:
 
     #
 
-    async def write_conf(
+    async def write_app_conf(
             self,
-            spec: DeployConfSpec,
-            app_tag: DeployAppTag,
-            conf_dir: str,
-            link_dir: str,
+            spec: DeployAppConfSpec,
+            tags: DeployTagMap,
+            app_conf_dir: str,
+            conf_link_dir: str,
     ) -> None:
-        for cf in spec.files or []:
-            await self._write_conf_file(
-                cf,
-                conf_dir,
+        for acf in spec.files or []:
+            await self._write_app_conf_file(
+                acf,
+                app_conf_dir,
             )
 
         #
 
         for link in spec.links or []:
-            await self._make_conf_link(
+            await self._make_app_conf_link(
                 link,
-                app_tag,
-                conf_dir,
-                link_dir,
+                tags,
+                app_conf_dir,
+                conf_link_dir,
             )
 
 
@@ -9312,19 +9641,6 @@ def bind_commands(
 # ../deploy/apps.py
 
 
-def make_deploy_tag(
-        rev: DeployRev,
-        key: DeployKey,
-        *,
-        utcnow: ta.Optional[datetime.datetime] = None,
-) -> DeployTag:
-    if utcnow is None:
-        utcnow = datetime.datetime.now(tz=datetime.timezone.utc)  # noqa
-    now_fmt = '%Y%m%dT%H%M%SZ'
-    now_str = utcnow.strftime(now_fmt)
-    return DeployTag('-'.join([now_str, rev, key]))
-
-
 class DeployAppManager(DeployPathOwner):
     def __init__(
             self,
@@ -9345,32 +9661,27 @@ class DeployAppManager(DeployPathOwner):
 
     #
 
-    _APP_TAG_DIR_STR = 'tags/apps/@app/@tag/'
-    _APP_TAG_DIR = DeployPath.parse(_APP_TAG_DIR_STR)
+    _APP_DIR_STR = 'apps/@app/@time--@app-rev--@app-key/'
+    _APP_DIR = DeployPath.parse(_APP_DIR_STR)
 
-    _CONF_TAG_DIR_STR = 'tags/conf/@tag--@app/'
-    _CONF_TAG_DIR = DeployPath.parse(_CONF_TAG_DIR_STR)
-
-    _DEPLOY_DIR_STR = 'deploys/@tag--@app/'
+    _DEPLOY_DIR_STR = 'deploys/@time--@deploy-key/'
     _DEPLOY_DIR = DeployPath.parse(_DEPLOY_DIR_STR)
 
     _APP_DEPLOY_LINK = DeployPath.parse(f'{_DEPLOY_DIR_STR}apps/@app')
-    _CONF_DEPLOY_LINK = DeployPath.parse(f'{_DEPLOY_DIR_STR}conf')
+    _CONF_DEPLOY_DIR = DeployPath.parse(f'{_DEPLOY_DIR_STR}conf/@conf/')
 
     @cached_nullary
     def get_owned_deploy_paths(self) -> ta.AbstractSet[DeployPath]:
         return {
-            self._APP_TAG_DIR,
-
-            self._CONF_TAG_DIR,
+            self._APP_DIR,
 
             self._DEPLOY_DIR,
 
             self._APP_DEPLOY_LINK,
-            self._CONF_DEPLOY_LINK,
+            self._CONF_DEPLOY_DIR,
 
             *[
-                DeployPath.parse(f'{self._APP_TAG_DIR_STR}{sfx}/')
+                DeployPath.parse(f'{self._APP_DIR_STR}{sfx}/')
                 for sfx in [
                     'conf',
                     'git',
@@ -9383,26 +9694,21 @@ class DeployAppManager(DeployPathOwner):
 
     async def prepare_app(
             self,
-            spec: DeploySpec,
+            spec: DeployAppSpec,
+            tags: DeployTagMap,
     ) -> None:
-        app_tag = DeployAppTag(spec.app, make_deploy_tag(spec.git.rev, spec.key()))
-
-        #
-
         deploy_home = check.non_empty_str(self._deploy_home)
 
         def build_path(pth: DeployPath) -> str:
-            return os.path.join(deploy_home, pth.render(app_tag.placeholders()))
+            return os.path.join(deploy_home, pth.render(tags))
 
-        app_tag_dir = build_path(self._APP_TAG_DIR)
-        conf_tag_dir = build_path(self._CONF_TAG_DIR)
+        app_dir = build_path(self._APP_DIR)
         deploy_dir = build_path(self._DEPLOY_DIR)
         app_deploy_link = build_path(self._APP_DEPLOY_LINK)
-        conf_deploy_link_file = build_path(self._CONF_DEPLOY_LINK)
 
         #
 
-        os.makedirs(deploy_dir)
+        os.makedirs(deploy_dir, exist_ok=True)
 
         deploying_link = os.path.join(deploy_home, 'deploys/deploying')
         relative_symlink(
@@ -9414,9 +9720,9 @@ class DeployAppManager(DeployPathOwner):
 
         #
 
-        os.makedirs(app_tag_dir)
+        os.makedirs(app_dir)
         relative_symlink(
-            app_tag_dir,
+            app_dir,
             app_deploy_link,
             target_is_directory=True,
             make_dirs=True,
@@ -9424,37 +9730,33 @@ class DeployAppManager(DeployPathOwner):
 
         #
 
-        os.makedirs(conf_tag_dir)
-        relative_symlink(
-            conf_tag_dir,
-            conf_deploy_link_file,
-            target_is_directory=True,
-            make_dirs=True,
-        )
+        deploy_conf_dir = os.path.join(deploy_dir, 'conf')
+        os.makedirs(deploy_conf_dir, exist_ok=True)
 
         #
 
-        def mirror_symlinks(src: str, dst: str) -> None:
-            def mirror_link(lp: str) -> None:
-                check.state(os.path.islink(lp))
-                shutil.copy2(
-                    lp,
-                    os.path.join(dst, os.path.relpath(lp, src)),
-                    follow_symlinks=False,
-                )
-
-            for dp, dns, fns in os.walk(src, followlinks=False):
-                for fn in fns:
-                    mirror_link(os.path.join(dp, fn))
-
-                for dn in dns:
-                    dp2 = os.path.join(dp, dn)
-                    if os.path.islink(dp2):
-                        mirror_link(dp2)
-                    else:
-                        os.makedirs(os.path.join(dst, os.path.relpath(dp2, src)))
+        # def mirror_symlinks(src: str, dst: str) -> None:
+        #     def mirror_link(lp: str) -> None:
+        #         check.state(os.path.islink(lp))
+        #         shutil.copy2(
+        #             lp,
+        #             os.path.join(dst, os.path.relpath(lp, src)),
+        #             follow_symlinks=False,
+        #         )
+        #
+        #     for dp, dns, fns in os.walk(src, followlinks=False):
+        #         for fn in fns:
+        #             mirror_link(os.path.join(dp, fn))
+        #
+        #         for dn in dns:
+        #             dp2 = os.path.join(dp, dn)
+        #             if os.path.islink(dp2):
+        #                 mirror_link(dp2)
+        #             else:
+        #                 os.makedirs(os.path.join(dst, os.path.relpath(dp2, src)))
 
         current_link = os.path.join(deploy_home, 'deploys/current')
+
         # if os.path.exists(current_link):
         #     mirror_symlinks(
         #         os.path.join(current_link, 'conf'),
@@ -9467,31 +9769,31 @@ class DeployAppManager(DeployPathOwner):
 
         #
 
-        git_dir = os.path.join(app_tag_dir, 'git')
+        app_git_dir = os.path.join(app_dir, 'git')
         await self._git.checkout(
             spec.git,
-            git_dir,
+            app_git_dir,
         )
 
         #
 
         if spec.venv is not None:
-            venv_dir = os.path.join(app_tag_dir, 'venv')
+            app_venv_dir = os.path.join(app_dir, 'venv')
             await self._venvs.setup_venv(
                 spec.venv,
-                git_dir,
-                venv_dir,
+                app_git_dir,
+                app_venv_dir,
             )
 
         #
 
         if spec.conf is not None:
-            conf_dir = os.path.join(app_tag_dir, 'conf')
-            await self._conf.write_conf(
+            app_conf_dir = os.path.join(app_dir, 'conf')
+            await self._conf.write_app_conf(
                 spec.conf,
-                app_tag,
-                conf_dir,
-                conf_tag_dir,
+                tags,
+                app_conf_dir,
+                deploy_conf_dir,
             )
 
         #
@@ -10232,18 +10534,37 @@ class SystemInterpProvider(InterpProvider):
 # ../deploy/deploy.py
 
 
+DEPLOY_TAG_DATETIME_FMT = '%Y%m%dT%H%M%SZ'
+
+
+DeployManagerUtcClock = ta.NewType('DeployManagerUtcClock', Func0[datetime.datetime])
+
+
 class DeployManager:
     def __init__(
             self,
             *,
             apps: DeployAppManager,
             paths: DeployPathsManager,
+
+            utc_clock: ta.Optional[DeployManagerUtcClock] = None,
     ):
         super().__init__()
 
         self._apps = apps
         self._paths = paths
 
+        self._utc_clock = utc_clock
+
+    def _utc_now(self) -> datetime.datetime:
+        if self._utc_clock is not None:
+            return self._utc_clock()  # noqa
+        else:
+            return datetime.datetime.now(tz=datetime.timezone.utc)  # noqa
+
+    def _make_deploy_time(self) -> DeployTime:
+        return DeployTime(self._utc_now().strftime(DEPLOY_TAG_DATETIME_FMT))
+
     async def run_deploy(
             self,
             spec: DeploySpec,
@@ -10252,7 +10573,24 @@ class DeployManager:
 
         #
 
-        await self._apps.prepare_app(spec)
+        deploy_tags = DeployTagMap(
+            self._make_deploy_time(),
+            spec.key(),
+        )
+
+        #
+
+        for app in spec.apps:
+            app_tags = deploy_tags.add(
+                app.app,
+                app.key(),
+                DeployAppRev(app.git.rev),
+            )
+
+            await self._apps.prepare_app(
+                app,
+                app_tags,
+            )
 
 
 ########################################