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

ominfra/manage/deploy/specs.py

@@ -7,11 +7,16 @@ import typing as ta
 from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check
 
-from .types import DeployApp
-from .types import DeployKey
+from .tags import DeployApp
+from .tags import DeployAppKey
+from .tags import DeployKey
+from .tags import KeyDeployTag  # noqa
 from .types import DeployRev
 
 
+KeyDeployTagT = ta.TypeVar('KeyDeployTagT', bound='KeyDeployTag')
+
+
 ##
 
 
@@ -23,6 +28,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
+
+
 ##
 
 
@@ -68,7 +83,7 @@ class DeployVenvSpec:
 
 
 @dc.dataclass(frozen=True)
-class DeployConfFile:
+class DeployAppConfFile:
     path: str
     body: str
 
@@ -80,7 +95,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)*
@@ -96,11 +111,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
 
 
@@ -108,10 +123,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:
@@ -125,15 +140,34 @@ 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())

ominfra/manage/deploy/tags.py

@@ -0,0 +1,225 @@
+# ruff: noqa: UP006 UP007
+import abc
+import dataclasses as dc
+import typing as ta
+
+from omlish.lite.check import check
+
+
+##
+
+
+DEPLOY_TAG_SIGIL = '@'
+
+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 DeployTag(abc.ABC):  # noqa
+    s: str
+
+    def __post_init__(self) -> None:
+        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)
+
+    #
+
+    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)

ominfra/manage/deploy/types.py

@@ -1,39 +1,9 @@
-import dataclasses as dc
 import typing as ta
 
-from omlish.lite.check import check
-
-
-DeployPathKind = ta.Literal['dir', 'file']  # ta.TypeAlias
-DeployPathPlaceholder = ta.Literal['app', 'tag', 'conf']  # ta.TypeAlias
-
 
 ##
 
 
 DeployHome = ta.NewType('DeployHome', str)
 
-DeployApp = ta.NewType('DeployApp', str)
-DeployTag = ta.NewType('DeployTag', str)
 DeployRev = ta.NewType('DeployRev', str)
-DeployKey = ta.NewType('DeployKey', str)
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class DeployAppTag:
-    app: DeployApp
-    tag: DeployTag
-
-    def __post_init__(self) -> None:
-        for s in [self.app, self.tag]:
-            check.non_empty_str(s)
-            check.equal(s, s.strip())
-
-    def placeholders(self) -> ta.Mapping[DeployPathPlaceholder, str]:
-        return {
-            'app': self.app,
-            'tag': self.tag,
-        }

ominfra/scripts/journald2aws.py

@@ -1450,6 +1450,9 @@ log = logging.getLogger(__name__)
 # ../../../../../omlish/lite/reflect.py
 
 
+##
+
+
 _GENERIC_ALIAS_TYPES = (
     ta._GenericAlias,  # type: ignore  # noqa
     *([ta._SpecialGenericAlias] if hasattr(ta, '_SpecialGenericAlias') else []),  # noqa
@@ -1467,6 +1470,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
@@ -1481,6 +1487,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)
@@ -1493,6 +1502,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__()))
@@ -2600,6 +2629,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
@@ -2811,6 +2852,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)]