omlish 0.0.0.dev237__py3-none-any.whl → 0.0.0.dev238__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev237'
-__revision__ = 'e8c58292f1ec88727fd832f6496545435d992e9d'
+__version__ = '0.0.0.dev238'
+__revision__ = '0ab60b1d75e5b0b298707ba55797958e528c69b5'
 
 
 #

omlish/collections/__init__.py

@@ -57,11 +57,6 @@ from .identity import (  # noqa
     IdentityWeakSet,
 )
 
-from .indexed import (  # noqa
-    IndexedSeq,
-    IndexedSetSeq,
-)
-
 from .mappings import (  # noqa
     MissingDict,
     TypeMap,
@@ -91,6 +86,11 @@ else:
         'new_treap_map',
     ])
 
+from .ranked import (  # noqa
+    RankedSeq,
+    RankedSetSeq,
+)
+
 if _ta.TYPE_CHECKING:
     from .sorted.skiplist import (  # noqa
         SkipList,

omlish/collections/ranked.py

@@ -0,0 +1,79 @@
+import typing as ta
+
+from .identity import IdentityKeyDict
+from .identity import IdentitySet
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class RankedSeq(ta.Sequence[T]):
+    def __init__(self, it: ta.Iterable[T], *, identity: bool = False) -> None:
+        super().__init__()
+
+        self._lst = list(it)
+        self._ranks: ta.Mapping[T, int] = (IdentityKeyDict if identity else dict)((e, i) for i, e in enumerate(self._lst))  # noqa
+        if len(self._ranks) != len(self._lst):
+            raise ValueError(f'{len(self._ranks)} != {len(self._lst)}')
+
+    @property
+    def debug(self) -> ta.Sequence[T]:
+        return self._lst
+
+    def __iter__(self) -> ta.Iterator[T]:
+        return iter(self._lst)
+
+    def __getitem__(self, rank: int) -> T:  # type: ignore
+        return self._lst[rank]
+
+    def __len__(self) -> int:
+        return len(self._lst)
+
+    def __contains__(self, obj: T) -> bool:  # type: ignore
+        return obj in self._ranks
+
+    @property
+    def ranks(self) -> ta.Mapping[T, int]:
+        return self._ranks
+
+    def rank(self, obj: T) -> int:
+        return self._ranks[obj]
+
+
+##
+
+
+class RankedSetSeq(ta.Sequence[ta.AbstractSet[T]]):
+    def __init__(self, it: ta.Iterable[ta.Iterable[T]], *, identity: bool = False) -> None:
+        super().__init__()
+
+        self._lst = [(IdentitySet if identity else set)(e) for e in it]
+        self._ranks: ta.Mapping[T, int] = (IdentityKeyDict if identity else dict)((e, i) for i, es in enumerate(self._lst) for e in es)  # noqa
+        if len(self._ranks) != sum(map(len, self._lst)):
+            raise ValueError(f'{len(self._ranks)} != {sum(map(len, self._lst))}')
+
+    @property
+    def debug(self) -> ta.Sequence[ta.AbstractSet[T]]:
+        return self._lst
+
+    def __iter__(self) -> ta.Iterator[ta.AbstractSet[T]]:
+        return iter(self._lst)
+
+    def __getitem__(self, rank: int) -> ta.AbstractSet[T]:  # type: ignore
+        return self._lst[rank]
+
+    def __len__(self) -> int:
+        return len(self._lst)
+
+    def __contains__(self, obj: T) -> bool:  # type: ignore
+        return obj in self._ranks
+
+    @property
+    def ranks(self) -> ta.Mapping[T, int]:
+        return self._ranks
+
+    def rank(self, obj: T) -> int:
+        return self._ranks[obj]

omlish/configs/classes.py

@@ -29,3 +29,7 @@ class Configurable(ta.Generic[ConfigurableConfigT], lang.Abstract):
         super().__init__()
 
         self._config: ConfigurableConfigT = check.isinstance(config, self.Config)  # type: ignore[assignment]
+
+    @property
+    def config(self) -> ConfigurableConfigT:
+        return self._config

omlish/daemons/services.py

@@ -1,9 +1,15 @@
 import abc
 import typing as ta
 
+from .. import cached
 from .. import check
+from .. import dataclasses as dc
 from .. import lang
 from ..configs.classes import Configurable
+from .daemon import Daemon
+from .targets import Target
+from .targets import TargetRunner
+from .targets import target_runner_for
 
 
 ServiceConfigT = ta.TypeVar('ServiceConfigT', bound='Service.Config')
@@ -32,3 +38,71 @@ class Service(Configurable[ServiceConfigT], lang.Abstract):
     @classmethod
     def run_config(cls, config: Config) -> None:
         return cls.from_config(config).run()
+
+
+##
+
+
+class ServiceTarget(Target):
+    svc: Service
+
+
+class ServiceTargetRunner(TargetRunner, dc.Frozen):
+    target: ServiceTarget
+
+    def run(self) -> None:
+        self.target.svc.run()
+
+
+@target_runner_for.register
+def _(target: ServiceTarget) -> ServiceTargetRunner:
+    return ServiceTargetRunner(target)
+
+
+#
+
+
+class ServiceConfigTarget(Target):
+    cfg: Service.Config
+
+
+class ServiceConfigTargetRunner(TargetRunner, dc.Frozen):
+    target: ServiceConfigTarget
+
+    def run(self) -> None:
+        Service.run_config(self.target.cfg)
+
+
+@target_runner_for.register
+def _(target: ServiceConfigTarget) -> ServiceConfigTargetRunner:
+    return ServiceConfigTargetRunner(target)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ServiceDaemon(lang.Final):
+    service: Service | Service.Config
+
+    @cached.function
+    def service_(self) -> Service:
+        if isinstance(self.service, Service):
+            return self.service
+        elif isinstance(self.service, Service.Config):
+            return Service.from_config(self.service)
+        else:
+            raise TypeError(self.service)
+
+    #
+
+    daemon: Daemon | Daemon.Config = Daemon.Config()
+
+    @cached.function
+    def daemon_(self) -> Daemon:
+        if isinstance(self.daemon, Daemon):
+            return self.daemon
+        elif isinstance(self.daemon, Daemon.Config):
+            return Daemon(Target.of(self.service_()), self.daemon)
+        else:
+            raise TypeError(self.daemon)

omlish/daemons/targets.py

@@ -6,14 +6,18 @@ import typing as ta
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
-from .services import Service
 
 
 if ta.TYPE_CHECKING:
     import runpy
+
+    from . import services
+
 else:
     runpy = lang.proxy_import('runpy')
 
+    services = lang.proxy_import('.services', __package__)
+
 
 ##
 
@@ -30,8 +34,11 @@ class Target(dc.Case):
         elif callable(obj):
             return FnTarget(obj)
 
-        elif isinstance(obj, Service.Config):
-            return ServiceConfigTarget(obj)
+        elif isinstance(obj, services.Service):
+            return services.ServiceTarget(obj)
+
+        elif isinstance(obj, services.Service.Config):
+            return services.ServiceConfigTarget(obj)
 
         else:
             raise TypeError(obj)
@@ -136,22 +143,3 @@ class ExecTargetRunner(TargetRunner, dc.Frozen):
 @target_runner_for.register
 def _(target: ExecTarget) -> ExecTargetRunner:
     return ExecTargetRunner(target)
-
-
-##
-
-
-class ServiceConfigTarget(Target):
-    cfg: Service.Config
-
-
-class ServiceConfigTargetRunner(TargetRunner, dc.Frozen):
-    target: ServiceConfigTarget
-
-    def run(self) -> None:
-        Service.run_config(self.target.cfg)
-
-
-@target_runner_for.register
-def _(target: ServiceConfigTarget) -> ServiceConfigTargetRunner:
-    return ServiceConfigTargetRunner(target)

omlish/dataclasses/__init__.py

@@ -91,9 +91,11 @@ from .impl.reflect import (  # noqa
     reflect,
 )
 
-from .utils import (  # noqa
-    is_immediate_dataclass,
+from .static import (  # noqa
+    Static,
+)
 
+from .utils import (  # noqa
     opt_repr,
     truthy_repr,
 
@@ -116,5 +118,7 @@ from .utils import (  # noqa
 ##
 
 from ..lite.dataclasses import (  # noqa
+    is_immediate_dataclass,
+
     dataclass_maybe_post_init as maybe_post_init,
 )

omlish/dataclasses/static.py

@@ -0,0 +1,176 @@
+import abc
+import copy
+import dataclasses as dc
+import typing as ta
+
+from .. import lang
+from ..lite.dataclasses import is_immediate_dataclass
+from .impl.api import dataclass
+
+
+##
+
+
+class Static(lang.Abstract):
+    __static_dataclass_class__: ta.ClassVar[type]
+    __static_dataclass_instance__: ta.ClassVar[ta.Any]
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        for a in ('__new__', '__init__'):
+            if a in cls.__dict__ and not (cls.__dict__[a] == getattr(Static, a)):
+                raise TypeError(f'Static base class {cls} must not implement {a}')
+
+        if cls.__init__ is not Static.__init__:
+            # This is necessary to make type-checking work (by allowing it to accept zero). This isn't strictly
+            # necessary, but since it's useful to do sometimes it might as well be done everywhere to prevent clashing.
+            raise TypeError(f'Static.__init__ should be first in mro of {cls}')
+
+        #
+
+        b_dc_lst = []
+
+        def b_dc_rec(b_cls: type) -> None:  # noqa
+            if issubclass(b_cls, Static):
+                return
+            elif is_immediate_dataclass(b_cls):
+                b_dc_lst.append(b_cls)
+            elif dc.is_dataclass(b_cls):
+                for sb_cls in b_cls.__bases__:
+                    b_dc_rec(sb_cls)
+
+        for b_cls in cls.__bases__:
+            b_dc_rec(b_cls)
+
+        b_sdc_dc_lst = [
+            b_cls.__static_dataclass_class__
+            for b_cls in cls.__bases__
+            if issubclass(b_cls, Static)
+            and b_cls is not Static
+        ]
+
+        sdc_dc_set = {*b_dc_lst, *b_sdc_dc_lst}
+        if not sdc_dc_set:
+            raise TypeError(f'Static dataclass {cls} inherits from no dataclass')
+
+        # Base static dataclasses of various types are allowed as long as there is exactly one final subclass involved.
+        # For example, a ModAttrManifest dataclass with an abstract StaticModAttrManifest subclass which sets a default
+        # mod_name may be mixed in with a further down use-case specific Manifest subclass.
+        sdc_dc_set -= {
+            m_cls
+            for s_cls in sdc_dc_set
+            for m_cls in s_cls.__mro__
+            if m_cls is not s_cls
+        }
+
+        if len(sdc_dc_set) > 1:
+            raise TypeError(f'Static dataclass {cls} inherits from multiple dataclasses: {sdc_dc_set!r}')
+        [sdc_cls] = sdc_dc_set
+
+        if '__static_dataclass_class__' in cls.__dict__:
+            raise AttributeError
+        setattr(cls, '__static_dataclass_class__', sdc_cls)
+
+        #
+
+        expected_fld_order: ta.Sequence[str] | None = None
+        is_abstract = lang.is_abstract_class(cls) or abc.ABC in cls.__bases__
+        if not is_abstract:
+            if is_immediate_dataclass(cls):
+                raise TypeError(cls)
+
+            flds_dct = {}
+            for b_cls in cls.__mro__:
+                if not dc.is_dataclass(b_cls):
+                    continue
+                b_flds = dc.fields(b_cls)  # noqa
+                for fld in b_flds:
+                    if fld.name in flds_dct:
+                        continue
+                    flds_dct[fld.name] = fld
+
+            # Annotations are the authoritative source of field order.
+            new_anns = {}
+
+            for fld in flds_dct.values():
+                new_fld = copy.copy(fld)
+
+                try:
+                    v = cls.__dict__[fld.name]
+                except KeyError:
+                    if fld.default is dc.MISSING and fld.default_factory is dc.MISSING:
+                        raise TypeError(f'Field {fld.name!r} of class {cls} is not set and has no default') from None
+                else:
+                    if isinstance(v, dc.Field):
+                        raise TypeError(f'Static dataclass {cls} may not introduce new fields: {fld.name}: {v}')
+
+                    new_fld.default = dc.MISSING
+                    # Use a default_factory to allow unsafe (mutable) values.
+                    new_fld.default_factory = (lambda v2: lambda: v2)(v)  # noqa
+
+                setattr(cls, fld.name, new_fld)
+                new_anns[fld.name] = fld.type
+
+            # Non-abstract static dataclasses may not introduce new fields.
+            expected_fld_order = list(flds_dct)
+
+            new_anns.update({
+                k: v
+                for k, v in getattr(cls, '__annotations__', {}).items()
+                if k not in new_anns
+            })
+
+            cls.__annotations__ = new_anns
+
+        else:
+            for b_cls in cls.__bases__:
+                if hasattr(b_cls, '__static_dataclass_instance__'):
+                    raise TypeError(
+                        f'Abstract static dataclass {cls} may not inherit from non-abstract static dataclass {b_cls}',
+                    )
+
+        # Explicitly forbid dc transforms that rebuild the class, such as slots.
+        if (dc_cls := dataclass(cls, frozen=True)) is not cls:
+            raise TypeError(dc_cls)
+
+        dc_flds = dc.fields(cls)  # type: ignore[arg-type]  # noqa
+
+        if expected_fld_order is not None:
+            dc_fld_order = [f.name for f in dc_flds]
+            if dc_fld_order != expected_fld_order:
+                raise TypeError(
+                    f'Static dataclass field order {dc_fld_order!r} != expected field order {expected_fld_order!r}',
+                )
+
+        if not is_abstract:
+            # This is the only time the Statices are ever actually instantiated, and it's only to produce the
+            # kwargs passed to the underlying dataclass.
+            tmp_inst = cls()
+            inst_kw = dc.asdict(tmp_inst)  # type: ignore[call-overload]  # noqa
+            inst = sdc_cls(**inst_kw)
+
+            cls.__static_dataclass_instance__ = inst
+
+            # Make all field values available via static `Class.field` access, even those created via a factory. Note
+            # that further inheritance of this non-abstract Static will continue to inherit dc.Field instances
+            # (including things like their metadata) via dc.fields() access, which does not reference `cls.__dict__`.
+            for fld in dc_flds:
+                v = getattr(inst, fld.name)
+                setattr(cls, fld.name, v)
+
+            def __new__(new_cls, *new_args, **new_kwargs):  # noqa
+                try:
+                    return new_cls.__dict__['__static_dataclass_instance__']
+                except KeyError:
+                    return super().__new__(new_cls)
+
+            cls.__new__ = __new__  # type: ignore
+
+        cls.__init__ = Static.__init__  # type: ignore
+
+    @ta.final
+    def __init__(self) -> None:
+        # This stub serves to allow `StaticSubclass()` to typecheck by allowing it to accept only zero arguments. Note
+        # that this is only the case when `Static` is first in mro.
+        raise TypeError('May not instantiate static dataclasses')

omlish/dataclasses/utils.py

@@ -4,7 +4,6 @@ import types
 import typing as ta
 
 from .. import check
-from .impl.internals import FIELDS_ATTR
 from .impl.metadata import METADATA_ATTR
 from .impl.metadata import UserMetadata
 from .impl.params import DEFAULT_FIELD_EXTRAS
@@ -18,14 +17,6 @@ T = ta.TypeVar('T')
 ##
 
 
-def is_immediate_dataclass(cls: type) -> bool:
-    check.isinstance(cls, type)
-    return FIELDS_ATTR in cls.__dict__
-
-
-##
-
-
 def opt_repr(o: ta.Any) -> str | None:
     return repr(o) if o is not None else None
 

omlish/graphs/trees.py

@@ -56,7 +56,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
 
         self._set_fac: ta.Callable[..., ta.MutableSet[NodeT]] = col.IdentitySet if identity else set
         self._dict_fac: ta.Callable[..., ta.MutableMapping[NodeT, ta.Any]] = col.IdentityKeyDict if identity else dict
-        self._idx_seq_fac: ta.Callable[..., col.IndexedSeq[NodeT]] = functools.partial(col.IndexedSeq, identity=identity)  # type: ignore  # noqa
+        self._rank_seq_fac: ta.Callable[..., col.RankedSeq[NodeT]] = functools.partial(col.RankedSeq, identity=identity)  # type: ignore  # noqa
 
         def walk(cur: NodeT, parent: NodeT | None) -> None:
             check.not_none(cur)
@@ -88,10 +88,10 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
 
         walk(root, None)
 
-        self._nodes = self._idx_seq_fac(nodes)
+        self._nodes = self._rank_seq_fac(nodes)
         self._node_set: ta.AbstractSet[NodeT] = node_set
-        self._children_by_node: ta.Mapping[NodeT | None, col.IndexedSeq[NodeT]] = self._dict_fac(
-            [(n, self._idx_seq_fac(cs)) for n, cs in children_by_node.items()])
+        self._children_by_node: ta.Mapping[NodeT | None, col.RankedSeq[NodeT]] = self._dict_fac(
+            [(n, self._rank_seq_fac(cs)) for n, cs in children_by_node.items()])
         self._child_sets_by_node: ta.Mapping[NodeT | None, ta.AbstractSet[NodeT]] = child_sets_by_node
         self._parents_by_node: ta.Mapping[NodeT, NodeT | None] = parents_by_node
 
@@ -100,7 +100,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
         return self._root
 
     @property
-    def nodes(self) -> col.IndexedSeq[NodeT]:
+    def nodes(self) -> col.RankedSeq[NodeT]:
         return self._nodes
 
     @property
@@ -116,7 +116,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
         return self._node_set
 
     @property
-    def children_by_node(self) -> ta.Mapping[NodeT | None, col.IndexedSeq[NodeT]]:
+    def children_by_node(self) -> ta.Mapping[NodeT | None, col.RankedSeq[NodeT]]:
         return self._children_by_node
 
     @property
@@ -224,8 +224,8 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
                 break
             yield cur
 
-    def get_lineage(self, node: NodeT) -> col.IndexedSeq[NodeT]:
-        return self._idx_seq_fac(reversed([node, *self.iter_ancestors(node)]))
+    def get_lineage(self, node: NodeT) -> col.RankedSeq[NodeT]:
+        return self._rank_seq_fac(reversed([node, *self.iter_ancestors(node)]))
 
     def get_first_parent_of_type(self, node: NodeT, ty: type[T]) -> T | None:
         for cur in self.iter_ancestors(node):

omlish/lang/descriptors.py

@@ -48,25 +48,26 @@ def _has_method_descriptor(obj: ta.Any) -> bool:
                 return False
 
 
-def unwrap_method_descriptors(fn: ta.Callable) -> ta.Callable:
+def unwrap_method_descriptors(fn: ta.Any) -> ta.Any:
     while is_method_descriptor(fn):
-        fn = fn.__func__  # type: ignore  # noqa
+        fn = fn.__func__
     return fn
 
 
 ##
 
 
-def unwrap_func_with_partials(fn: ta.Callable) -> tuple[ta.Callable, list[functools.partial]]:
+def unwrap_func_with_partials(fn: ta.Any) -> tuple[ta.Any, list[functools.partial]]:
     ps = []
     while True:
         if is_method_descriptor(fn) or isinstance(fn, types.MethodType):
-            fn = fn.__func__  # type: ignore
+            fn = fn.__func__
 
         elif hasattr(fn, '__wrapped__'):
             nxt = fn.__wrapped__
-            if not callable(nxt):
-                raise TypeError(nxt)
+            # FIXME: ?
+            # if not callable(nxt):
+            #     raise TypeError(nxt)
             if nxt is fn:
                 raise TypeError(fn)
             fn = nxt
@@ -83,7 +84,7 @@ def unwrap_func_with_partials(fn: ta.Callable) -> tuple[ta.Callable, list[functo
     return fn, ps
 
 
-def unwrap_func(fn: ta.Callable) -> ta.Callable:
+def unwrap_func(fn: ta.Any) -> ta.Any:
     uw, _ = unwrap_func_with_partials(fn)
     return uw
 

omlish/lite/dataclasses.py

@@ -3,6 +3,18 @@ import dataclasses as dc
 import typing as ta
 
 
+##
+
+
+def is_immediate_dataclass(cls: type) -> bool:
+    if not isinstance(cls, type):
+        raise TypeError(cls)
+    return dc._FIELDS in cls.__dict__  # type: ignore[attr-defined]  # noqa
+
+
+##
+
+
 def dataclass_cache_hash(
         *,
         cached_hash_attr: str = '__dataclass_hash__',
@@ -33,6 +45,9 @@ def dataclass_cache_hash(
     return inner
 
 
+##
+
+
 def dataclass_maybe_post_init(sup: ta.Any) -> bool:
     if not isinstance(sup, super):
         raise TypeError(sup)
@@ -44,6 +59,9 @@ def dataclass_maybe_post_init(sup: ta.Any) -> bool:
     return True
 
 
+##
+
+
 def dataclass_repr_filtered(
         obj: ta.Any,
         fn: ta.Callable[[ta.Any, dc.Field, ta.Any], bool],

omlish/manifests/__init__.py

@@ -1,2 +0,0 @@
-# @omlish-lite
-from .types import Manifest  # noqa

omlish/manifests/base.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 import dataclasses as dc
 import typing as ta
 

omlish/manifests/load.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 """
 Should be kept somewhat lightweight - used in cli entrypoints.
 

omlish/manifests/static.py

@@ -0,0 +1,20 @@
+import abc
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+from .base import ModAttrManifest
+
+
+##
+
+
+class StaticModAttrManifest(dc.Static, ModAttrManifest, abc.ABC):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        if (
+                not (lang.is_abstract_class(cls) or abc.ABC in cls.__bases__) and
+                'mod_name' not in cls.__dict__
+        ):
+            setattr(cls, 'mod_name', cls.__module__)
+
+        super().__init_subclass__(**kwargs)

omlish/manifests/types.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 import dataclasses as dc
 import typing as ta
 

omlish/metadata.py

@@ -0,0 +1,153 @@
+"""
+These attempt to punch through *all* wrappers. The the usecases involve having things like bound methods, classmethods,
+functools.partial instances, and needing to get the metadata of the underlying thing the end-user wrote.
+
+TODO:
+ - re type targets:
+  - unwrap instances of objects to their types?
+  - merge mro?
+  - are these better left up to callers? too usecase-specific to favor either way?
+"""
+import types
+import typing as ta
+
+from . import check
+from . import lang
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class ObjectMetadata(lang.Abstract):
+    pass
+
+
+class ObjectMetadataTarget(lang.Abstract):
+    pass
+
+
+##
+
+
+_VALID_OBJECT_METADATA_TARGET_TYPES: tuple[type, ...] = (
+    type,
+
+    types.FunctionType,
+    # *not* types.MethodType - must unwrap to unbound class func
+    # *not* functools.partial - must unwrap to underlying func
+
+    ObjectMetadataTarget,
+)
+
+
+class ObjectMetadataTargetTypeError(TypeError):
+    pass
+
+
+def _unwrap_object_metadata_target(obj: ta.Any) -> ta.Any:
+    tgt: ta.Any = obj
+    tgt = lang.unwrap_func(tgt)
+
+    if not isinstance(tgt, _VALID_OBJECT_METADATA_TARGET_TYPES):
+        raise ObjectMetadataTargetTypeError(tgt)
+
+    return tgt
+
+
+##
+
+
+_OBJECT_METADATA_ATTR = '__' + __name__.replace('.', '_') + '__metadata__'
+
+
+def append_object_metadata(obj: T, *mds: ObjectMetadata) -> T:
+    for md in mds:
+        check.isinstance(md, ObjectMetadata)
+
+    tgt = _unwrap_object_metadata_target(obj)
+    dct = tgt.__dict__
+
+    if isinstance(dct, types.MappingProxyType):
+        for _ in range(2):
+            try:
+                lst = dct[_OBJECT_METADATA_ATTR]
+            except KeyError:
+                setattr(tgt, _OBJECT_METADATA_ATTR, [])
+            else:
+                break
+        else:
+            raise RuntimeError
+
+    else:
+        lst = dct.setdefault(_OBJECT_METADATA_ATTR, [])
+
+    lst.extend(mds)
+    return obj
+
+
+def get_object_metadata(obj: ta.Any, *, strict: bool = False) -> ta.Sequence[ObjectMetadata]:
+    try:
+        tgt = _unwrap_object_metadata_target(obj)
+    except ObjectMetadataTargetTypeError:
+        if not strict:
+            return ()
+        raise
+
+    try:
+        dct = tgt.__dict__
+    except AttributeError:
+        return ()
+
+    return dct.get(_OBJECT_METADATA_ATTR, ())
+
+
+##
+
+
+class DecoratorObjectMetadata(ObjectMetadata, lang.Abstract):
+    _OBJECT_METADATA_TARGET_TYPES: ta.ClassVar[tuple[type, ...] | None] = None
+
+    def __init_subclass__(
+            cls,
+            *,
+            object_metadata_target_types: ta.Iterable[type] | None = None,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init_subclass__(**kwargs)
+
+        if object_metadata_target_types is not None:
+            tts = tuple(object_metadata_target_types)
+            for tt in tts:
+                check.issubclass(tt, _VALID_OBJECT_METADATA_TARGET_TYPES)
+            setattr(cls, '_OBJECT_METADATA_TARGET_TYPES', tts)
+
+    def __call__(self, obj: T) -> T:
+        tgt: ta.Any = obj
+        if (tts := type(self)._OBJECT_METADATA_TARGET_TYPES) is not None:  # noqa
+            tgt = _unwrap_object_metadata_target(tgt)
+            check.isinstance(tgt, tts)
+
+        append_object_metadata(tgt, self)
+        return obj
+
+
+#
+
+
+class ClassDecoratorObjectMetadata(
+    DecoratorObjectMetadata,
+    lang.Abstract,
+    object_metadata_target_types=[type],
+):
+    pass
+
+
+class FunctionDecoratorObjectMetadata(
+    DecoratorObjectMetadata,
+    lang.Abstract,
+    object_metadata_target_types=[types.FunctionType],
+):
+    pass

{omlish-0.0.0.dev237.dist-info → omlish-0.0.0.dev238.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev237
+Version: 0.0.0.dev238
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev237.dist-info → omlish-0.0.0.dev238.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=vQTAIvR8OblSq-uP2GUfnbei0RnmAnM5j0T1-OToh9E,8253
-omlish/__about__.py,sha256=0tS5CFbCYIp6LwAIjSNK3lhW-DW7VWodegiD0bAa7U8,3380
+omlish/__about__.py,sha256=-JHhiSxa1m9XW-39IA3EWqH7y7ZB6GG03v7p93wDeA0,3380
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
 omlish/cached.py,sha256=UI-XTFBwA6YXWJJJeBn-WkwBkfzDjLBBaZf4nIJA9y0,510
@@ -8,6 +8,7 @@ omlish/datetimes.py,sha256=HajeM1kBvwlTa-uR1TTZHmZ3zTPnnUr1uGGQhiO1XQ0,2152
 omlish/defs.py,sha256=9uUjJuVIbCBL3g14fyzAp-9gH935MFofvlfOGwcBIaM,4913
 omlish/dynamic.py,sha256=kIZokHHid8a0pIAPXMNiXrVJvJJyBnY49WP1a2m-HUQ,6525
 omlish/libc.py,sha256=8K4c66YV1ziJerl5poAAYCmsV-VSsHkT3EHhPW04ufg,15639
+omlish/metadata.py,sha256=IJFczp-bkFk_lCYTUt5UmM_MvCbKICjJunEi2MqnC1w,3495
 omlish/outcome.py,sha256=ABIE0zjjTyTNtn-ZqQ_9_mUzLiBQ3sDAyqc9JVD8N2k,7852
 omlish/runmodule.py,sha256=PWvuAaJ9wQQn6bx9ftEL3_d04DyotNn8dR_twm2pgw0,700
 omlish/shlex.py,sha256=bsW2XUD8GiMTUTDefJejZ5AyqT1pTgWMPD0BMoF02jE,248
@@ -134,16 +135,16 @@ omlish/codecs/funcs.py,sha256=p4imNt7TobyZVXWC-WhntHVu9KfJrO4QwdtPRh-cVOk,850
 omlish/codecs/registry.py,sha256=2FnO5YP7ui1LzkguwESY0MP3WIdwgPTIJTM_4RyTOEg,3896
 omlish/codecs/standard.py,sha256=eiZ4u9ep0XrA4Z_D1zJI0vmWyuN8HLrX4Se_r_Cq_ZM,60
 omlish/codecs/text.py,sha256=JzrdwMpQPo2NBBg3K1EZszzQy5vEWmd82SIerJd4yeQ,5723
-omlish/collections/__init__.py,sha256=ddzZS3C2rvDo65hspO9KlFsrinElxPWvYEgVyBUZdb0,2164
+omlish/collections/__init__.py,sha256=umpclbTE3wsSflMrKmYEiGmWFhiukfJxvBWgtYMZ8mk,2161
 omlish/collections/abc.py,sha256=sP7BpTVhx6s6C59mTFeosBi4rHOWC6tbFBYbxdZmvh0,2365
 omlish/collections/coerce.py,sha256=g68ROb_-5HgH-vI8612mU2S0FZ8-wp2ZHK5_Zy_kVC0,7037
 omlish/collections/exceptions.py,sha256=shcS-NCnEUudF8qC_SmO2TQyjivKlS4TDjaz_faqQ0c,44
 omlish/collections/frozen.py,sha256=mxhd8pw5zIXUiRHiBVZWYCYT7wYDVG3tAY5PNU-WH-I,4150
 omlish/collections/hasheq.py,sha256=XcOCE6f2lXizDCOXxSX6vJv-rLcpDo2OWCYIKGSWuic,3697
 omlish/collections/identity.py,sha256=SwnUE5D3v9RBjATDE1LUr_vO3Rb2NHcmTK64GZIcsO8,2720
-omlish/collections/indexed.py,sha256=tLa88qgWGzTZGssMFgvhgraIEkNEUvcIk5p4yjNEquQ,2201
 omlish/collections/mappings.py,sha256=YunNPyADrpitZGTJcXV0k4bmJddj1avDvEavz0coJWU,3203
 omlish/collections/ordered.py,sha256=tUAl99XHbSbzn7Hdh99jUBl27NcC2J7ZTI67slTMe5M,2333
+omlish/collections/ranked.py,sha256=rg6DL36oOUiG5JQEAkGnT8b6f9mSndQlIovtt8GQj_w,2229
 omlish/collections/unmodifiable.py,sha256=-zys__n6L7liWzhmHAIvfxprq7cUE5HoR3foGvXc_7I,4748
 omlish/collections/utils.py,sha256=Q0lHhNDokVxdOvApmu1QX5fABYwbn1ATiIwp194Ur_E,2889
 omlish/collections/cache/__init__.py,sha256=D1gO71VcwxFTZP9gAc9isHfg_TEdalwhsJcgGLvS9hg,233
@@ -163,7 +164,7 @@ omlish/concurrent/futures.py,sha256=J2s9wYURUskqRJiBbAR0PNEAp1pXbIMYldOVBTQduQY,
 omlish/concurrent/threadlets.py,sha256=JfirbTDJgy9Ouokz_VmHeAAPS7cih8qMUJrN-owwXD4,2423
 omlish/configs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/configs/all.py,sha256=kziwjzUBkf8AT0w7Pq7JX2jtkQVOQ5R1wJyn6hfTN5k,1055
-omlish/configs/classes.py,sha256=oCCkGzokn807mAlpRVe9F_JKZo8x6JcIVmo2sBsm7T8,1080
+omlish/configs/classes.py,sha256=9uelgi9gS5Sf8ZbtydNXhMxjBs7xBxGZgfuK0Vbc2cg,1168
 omlish/configs/formats.py,sha256=RJw4Rzp7vlTd5YyAvpAoruQnk45v8dGPtPWwqH7aYyE,5301
 omlish/configs/nginx.py,sha256=XuX9yyb0_MwkJ8esKiMS9gFkqHUPza_uCprhnWykNy8,2051
 omlish/configs/shadow.py,sha256=-R5nbevC4pFgqDPYOCCIqNcusgXsMWlRIUOEG0HBoJg,2228
@@ -181,12 +182,13 @@ omlish/daemons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/daemons/daemon.py,sha256=ykdbCPbpxKrdZVZc892SnedTdftTAYt_YdDpYchKcUE,3410
 omlish/daemons/launching.py,sha256=mhtkuAO16STcznUl3rrX9pacfrKbPQRCP2AllKL4B70,3664
 omlish/daemons/reparent.py,sha256=UaG2X6VJHJPOlUwHPNRH3aWGgF0Fg771jjO9IRPLlyY,280
-omlish/daemons/services.py,sha256=XRmYBYNLUumnxaXCr2B7ScNEUlM8oM5FSS0bdWheDNs,719
+omlish/daemons/services.py,sha256=UAzzdP4jG0-piVzz6CsSTPIjTGt4VFXtbzP7KczMCho,2354
 omlish/daemons/spawning.py,sha256=cx00xeqSrfhlFbjCtKqaBHvMuHwB9hdjuKNHzAAo_dw,4030
-omlish/daemons/targets.py,sha256=L2BRWsv473X7dE4H7afA8TgTiaevCuZPab9Olh-AKUc,3248
+omlish/daemons/targets.py,sha256=00KmtlknMhQ5PyyVAhWl3rpeTMPym0GxvHHq6mYPZ7c,3051
 omlish/daemons/waiting.py,sha256=RfgD1L33QQVbD2431dkKZGE4w6DUcGvYeRXXi8puAP4,1676
-omlish/dataclasses/__init__.py,sha256=D7I6ZJjEFeLN2re8oOZ_7JKWiG2plrPnaUFq3iEXYmQ,1553
-omlish/dataclasses/utils.py,sha256=N2seT8cJtfOv-41D7F3E-q4us-FCTQmnxxPv3dt1OcI,3796
+omlish/dataclasses/__init__.py,sha256=b7EZCIfHnEHCHWwgD3YXxkdsU-uYd9iD4hM36RgpI1g,1598
+omlish/dataclasses/static.py,sha256=35tPuneXUXZztFTzjNkW6DnQbZgKJUf68GmjzXV-WkQ,6903
+omlish/dataclasses/utils.py,sha256=QWsHxVisS-MUCqh89JQsRdCLgdBVeC6EYK6jRwO9akU,3631
 omlish/dataclasses/impl/LICENSE,sha256=Oy-B_iHRgcSZxZolbI4ZaEVdZonSaaqFNzv7avQdo78,13936
 omlish/dataclasses/impl/__init__.py,sha256=zqGBC5gSbjJxaqG_zS1LL1PX-zAfhIua8UqOE4IwO2k,789
 omlish/dataclasses/impl/api.py,sha256=RhU4f50GVdn-dxilia8NA3F7VIm2R5z78pFfpIVXPRQ,6635
@@ -302,7 +304,7 @@ omlish/funcs/pipes.py,sha256=E7Sz8Aj8ke_vCs5AMNwg1I36kRdHVGTnzxVQaDyn43U,2490
 omlish/graphs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/graphs/dags.py,sha256=zp55lYgUdRCxmADwiGDHeehMJczZFA_tzdWqy77icOk,3047
 omlish/graphs/domination.py,sha256=oCGoWzWTxLwow0LDyGjjEf2AjFiOiDz4WaBtczwSbsQ,7576
-omlish/graphs/trees.py,sha256=zvfjDN8R7J6wStNJEUO6OCioGXJrLGhU8KtcqlWVRPI,8191
+omlish/graphs/trees.py,sha256=OgGDnCJKfpOeWgDJPSkuVEoeYp72o06jpm0jwUB96Xc,8189
 omlish/graphs/dot/__init__.py,sha256=Y1MZRQBZkcYyG1Tn7K2FhL8aYbm4v4tk6f5g9AqEkUw,359
 omlish/graphs/dot/items.py,sha256=OWPf0-hjBgS1uyy2QgAEn4IgFHJcEg7sHVWeTx1ghZc,4083
 omlish/graphs/dot/make.py,sha256=RN30gHfJPiXx5Q51kbDdhVJYf59Fr84Lz9J-mXRt9sI,360
@@ -401,7 +403,7 @@ omlish/lang/clsdct.py,sha256=sJYadm-fwzti-gsi98knR5qQUxriBmOqQE_qz3RopNk,1743
 omlish/lang/cmp.py,sha256=5vbzWWbqdzDmNKAGL19z6ZfUKe5Ci49e-Oegf9f4BsE,1346
 omlish/lang/contextmanagers.py,sha256=Mrn8NJ3pP0Zxi-IoGqSjZDdWUctsyee2vrZ2FtZvNmo,10529
 omlish/lang/datetimes.py,sha256=ehI_DhQRM-bDxAavnp470XcekbbXc4Gdw9y1KpHDJT0,223
-omlish/lang/descriptors.py,sha256=njkYDS1gn5p4-3v1jr-s_srauC7tvvt571RjE7Q4LXE,6616
+omlish/lang/descriptors.py,sha256=mZ2h9zJ__MMpw8hByjRbAiONcwfVb6GD0btNnVi8C5w,6573
 omlish/lang/exceptions.py,sha256=qJBo3NU1mOWWm-NhQUHCY5feYXR3arZVyEHinLsmRH4,47
 omlish/lang/functions.py,sha256=0ql9EXA_gEEhvUVzMJCjVhEnVtHecsLKmfmAXuQqeGY,4388
 omlish/lang/generators.py,sha256=5LX17j-Ej3QXhwBgZvRTm_dq3n9veC4IOUcVmvSu2vU,5243
@@ -432,7 +434,7 @@ omlish/lite/cached.py,sha256=O7ozcoDNFm1Hg2wtpHEqYSp_i_nCLNOP6Ueq_Uk-7mU,1300
 omlish/lite/check.py,sha256=OLwtE2x6nlbGx4vS3Rda7zMHpgqzDSLJminTAX2lqLA,13529
 omlish/lite/configs.py,sha256=Ev_19sbII67pTWzInYjYqa9VyTiZBvyjhZqyG8TtufE,908
 omlish/lite/contextmanagers.py,sha256=ciaMl0D3QDHToM7M28-kwZ-Q48LtwgCxiud3nekgutA,2863
-omlish/lite/dataclasses.py,sha256=sjJnZ4tZXMzKRkr-gymMbhuMxJAY8parJ_sopEqBc6M,1704
+omlish/lite/dataclasses.py,sha256=t1G5-xOuvE6o6w9RyqHzLT9wHD0HkqBh5P8HUZWxGzs,1912
 omlish/lite/inject.py,sha256=qBUftFeXMiRgANYbNS2e7TePMYyFAcuLgsJiLyMTW5o,28769
 omlish/lite/json.py,sha256=7-02Ny4fq-6YAu5ynvqoijhuYXWpLmfCI19GUeZnb1c,740
 omlish/lite/logs.py,sha256=CWFG0NKGhqNeEgryF5atN2gkPYbUdTINEw_s1phbINM,51
@@ -463,10 +465,11 @@ omlish/logs/proxy.py,sha256=A-ROPUUAlF397qTbEqhel6YhQMstNuXL3Xmts7w9dAo,2347
 omlish/logs/standard.py,sha256=FbKdF2Z4Na5i2TNwKn0avLJXyICe2JKsPufjvKCHGn0,3162
 omlish/logs/timing.py,sha256=XrFUHIPT4EHDujLKbGs9fGFMmoM3NEP8xPRaESJr7bQ,1513
 omlish/logs/utils.py,sha256=mzHrZ9ji75p5A8qR29eUr05CBAHMb8J753MSkID_VaQ,393
-omlish/manifests/__init__.py,sha256=P2B0dpT8D7l5lJwRGPA92IcQj6oeXfd90X5-q9BJrKg,51
-omlish/manifests/base.py,sha256=1LGglMh7UUU7JWIqPH_JfIm6czGETibpScEqKI5mSMg,920
-omlish/manifests/load.py,sha256=0ZjtsYL2EIKYd_MF3brKTPYdRZmtWdwomx2cFjjFV2M,6640
-omlish/manifests/types.py,sha256=d8bv5tknCJqclRfxCpao_8XxHo2yofhLpVHQTB-MfNw,260
+omlish/manifests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omlish/manifests/base.py,sha256=D1WvJYcBR_njkc0gpALpFCWh1h3agb9qgqphnbbPlm4,935
+omlish/manifests/load.py,sha256=9mdsS3egmSX9pymO-m-y2Fhs4p6ruOdbsYaKT1-1Hwg,6655
+omlish/manifests/static.py,sha256=7YwOVh_Ek9_aTrWsWNO8kWS10_j4K7yv3TpXZSHsvDY,501
+omlish/manifests/types.py,sha256=mxL6N44mu06995YF8qzmg6V94EmfRiryzIUQcXVSCbI,275
 omlish/marshal/__init__.py,sha256=00D3S6qwUld1TUWd67hVHuNcrj3c_FAFSkCVXgGWT-s,2607
 omlish/marshal/base.py,sha256=tJ4iNuD7cW2GpGMznOhkAf2hugqp2pF2em0FaQcekrk,6740
 omlish/marshal/exceptions.py,sha256=jwQWn4LcPnadT2KRI_1JJCOSkwWh0yHnYK9BmSkNN4U,302
@@ -711,9 +714,9 @@ omlish/text/indent.py,sha256=YjtJEBYWuk8--b9JU_T6q4yxV85_TR7VEVr5ViRCFwk,1336
 omlish/text/minja.py,sha256=jZC-fp3Xuhx48ppqsf2Sf1pHbC0t8XBB7UpUUoOk2Qw,5751
 omlish/text/parts.py,sha256=JkNZpyR2tv2CNcTaWJJhpQ9E4F0yPR8P_YfDbZfMtwQ,6182
 omlish/text/random.py,sha256=jNWpqiaKjKyTdMXC-pWAsSC10AAP-cmRRPVhm59ZWLk,194
-omlish-0.0.0.dev237.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev237.dist-info/METADATA,sha256=xNNscWsZ6ZOLDE0vOj3YCOrR50thYq82_KawDOui9OA,4176
-omlish-0.0.0.dev237.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-omlish-0.0.0.dev237.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev237.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev237.dist-info/RECORD,,
+omlish-0.0.0.dev238.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev238.dist-info/METADATA,sha256=Fzwpe0Ssmu0yFpCL5MUoWK0b3rF72OFhaG7rCK_duxU,4176
+omlish-0.0.0.dev238.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+omlish-0.0.0.dev238.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev238.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev238.dist-info/RECORD,,

omlish/collections/indexed.py

@@ -1,73 +0,0 @@
-import typing as ta
-
-from .identity import IdentityKeyDict
-from .identity import IdentitySet
-
-
-T = ta.TypeVar('T')
-
-
-class IndexedSeq(ta.Sequence[T]):
-    def __init__(self, it: ta.Iterable[T], *, identity: bool = False) -> None:
-        super().__init__()
-
-        self._lst = list(it)
-        self._idxs: ta.Mapping[T, int] = (IdentityKeyDict if identity else dict)((e, i) for i, e in enumerate(self._lst))  # noqa
-        if len(self._idxs) != len(self._lst):
-            raise ValueError(f'{len(self._idxs)} != {len(self._lst)}')
-
-    @property
-    def debug(self) -> ta.Sequence[T]:
-        return self._lst
-
-    def __iter__(self) -> ta.Iterator[T]:
-        return iter(self._lst)
-
-    def __getitem__(self, idx: int) -> T:  # type: ignore
-        return self._lst[idx]
-
-    def __len__(self) -> int:
-        return len(self._lst)
-
-    def __contains__(self, obj: T) -> bool:  # type: ignore
-        return obj in self._idxs
-
-    @property
-    def idxs(self) -> ta.Mapping[T, int]:
-        return self._idxs
-
-    def idx(self, obj: T) -> int:
-        return self._idxs[obj]
-
-
-class IndexedSetSeq(ta.Sequence[ta.AbstractSet[T]]):
-    def __init__(self, it: ta.Iterable[ta.Iterable[T]], *, identity: bool = False) -> None:
-        super().__init__()
-
-        self._lst = [(IdentitySet if identity else set)(e) for e in it]
-        self._idxs: ta.Mapping[T, int] = (IdentityKeyDict if identity else dict)((e, i) for i, es in enumerate(self._lst) for e in es)  # noqa
-        if len(self._idxs) != sum(map(len, self._lst)):
-            raise ValueError(f'{len(self._idxs)} != {sum(map(len, self._lst))}')
-
-    @property
-    def debug(self) -> ta.Sequence[ta.AbstractSet[T]]:
-        return self._lst
-
-    def __iter__(self) -> ta.Iterator[ta.AbstractSet[T]]:
-        return iter(self._lst)
-
-    def __getitem__(self, idx: int) -> ta.AbstractSet[T]:  # type: ignore
-        return self._lst[idx]
-
-    def __len__(self) -> int:
-        return len(self._lst)
-
-    def __contains__(self, obj: T) -> bool:  # type: ignore
-        return obj in self._idxs
-
-    @property
-    def idxs(self) -> ta.Mapping[T, int]:
-        return self._idxs
-
-    def idx(self, obj: T) -> int:
-        return self._idxs[obj]