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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev237'
-__revision__ = 'e8c58292f1ec88727fd832f6496545435d992e9d'
+__version__ = '0.0.0.dev239'
+__revision__ = 'f241f36977bf74d1ea680d415782228917ec3669'
 
 
 #

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,189 @@
+"""
+TODO:
+ - metaclass, to forbid __subclasscheck__ / __instancecheck__? Clash with dc.Meta, don't want that lock-in, not
+   necessary for functionality, just a helpful misuse prevention.
+"""
+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):
+    """
+    Dataclass mixin for dataclasses in which all fields have class-level defaults and are not intended for any
+    instance-level overrides - effectively making their subclasses equivalent to instances. For dataclasses which make
+    sense as singletons (such as project specs or manifests), for which dynamic instantiation is not the usecase, this
+    can enable more natural syntax. Inheritance is permitted - equivalent to a `functools.partial` or composing
+    `**kwargs`, as long as there is only ever one unambiguous underlying non-static dataclass to be instantiated.
+    """
+
+    __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 args). 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 Statics 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/__init__.py

@@ -137,9 +137,6 @@ from .imports import (  # noqa
     can_import,
     get_real_module_name,
     import_all,
-    import_attr,
-    import_module,
-    import_module_attr,
     lazy_import,
     proxy_import,
     proxy_init,
@@ -235,6 +232,12 @@ from .typing import (  # noqa
 
 ##
 
+from ..lite.imports import (  # noqa
+    import_attr,
+    import_module,
+    import_module_attr,
+)
+
 from ..lite.timeouts import (  # noqa
     DeadlineTimeout,
     InfiniteTimeout,

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/lang/imports.py

@@ -87,49 +87,6 @@ def proxy_import(
 ##
 
 
-def import_module(dotted_path: str) -> types.ModuleType:
-    if not dotted_path:
-        raise ImportError(dotted_path)
-    mod = __import__(dotted_path, globals(), locals(), [])
-    for name in dotted_path.split('.')[1:]:
-        try:
-            mod = getattr(mod, name)
-        except AttributeError:
-            raise AttributeError(f'Module {mod!r} has no attribute {name!r}') from None
-    return mod
-
-
-def import_module_attr(dotted_path: str) -> ta.Any:
-    module_name, _, class_name = dotted_path.rpartition('.')
-    mod = import_module(module_name)
-    try:
-        return getattr(mod, class_name)
-    except AttributeError:
-        raise AttributeError(f'Module {module_name!r} has no attr {class_name!r}') from None
-
-
-def import_attr(dotted_path: str) -> ta.Any:
-    parts = dotted_path.split('.')
-    mod: ta.Any = None
-    mod_pos = 0
-    while mod_pos < len(parts):
-        mod_name = '.'.join(parts[:mod_pos + 1])
-        try:
-            mod = importlib.import_module(mod_name)
-        except ImportError:
-            break
-        mod_pos += 1
-    if mod is None:
-        raise ImportError(dotted_path)
-    obj = mod
-    for att_pos in range(mod_pos, len(parts)):
-        obj = getattr(obj, parts[att_pos])
-    return obj
-
-
-##
-
-
 SPECIAL_IMPORTABLE: ta.AbstractSet[str] = frozenset([
     '__init__.py',
     '__main__.py',