omlish 0.0.0.dev5__py3-none-any.whl → 0.0.0.dev7__py3-none-any.whl

omlish/lifecycles/manager.py

@@ -0,0 +1,161 @@
+import typing as ta
+
+from .. import check
+from .. import collections as col
+from .. import dataclasses as dc
+from .. import lang
+from .abstract import AbstractLifecycle
+from .base import Lifecycle
+from .controller import LifecycleController
+from .states import LifecycleState
+from .states import LifecycleStateError
+from .states import LifecycleStates
+
+
+class LifecycleManager(AbstractLifecycle):
+
+    @dc.dataclass(frozen=True)
+    class Entry(lang.Final):
+        controller: LifecycleController
+        dependencies: ta.MutableSet['LifecycleManager.Entry'] = dc.field(default_factory=col.IdentitySet)
+        dependents: ta.MutableSet['LifecycleManager.Entry'] = dc.field(default_factory=col.IdentitySet)
+
+    def __init__(
+            self,
+            *,
+            lock: lang.DefaultLockable = None,
+    ) -> None:
+        super().__init__()
+
+        self._lock = lang.default_lock(lock, False)
+
+        self._entries_by_lifecycle: ta.MutableMapping[Lifecycle, LifecycleManager.Entry] = col.IdentityKeyDict()
+
+        self._controller = LifecycleController(self._lifecycle, lock=self._lock)
+
+    @property
+    def controller(self) -> LifecycleController:
+        return self._controller
+
+    @property
+    def state(self) -> LifecycleState:
+        return self._controller.state
+
+    @staticmethod
+    def _get_controller(lifecycle: Lifecycle) -> LifecycleController:
+        if isinstance(lifecycle, LifecycleController):
+            return lifecycle
+        # elif isinstance(lifecycle, AbstractLifecycle):
+        #     return lifecycle.lifecycle_controller
+        elif isinstance(lifecycle, Lifecycle):
+            return LifecycleController(lifecycle)
+        else:
+            raise TypeError(lifecycle)
+
+    def _add_internal(self, lifecycle: Lifecycle, dependencies: ta.Iterable[Lifecycle]) -> Entry:
+        check.state(self.state < LifecycleStates.STOPPING and not self.state.is_failed)
+
+        check.isinstance(lifecycle, Lifecycle)
+        try:
+            entry = self._entries_by_lifecycle[lifecycle]
+        except KeyError:
+            controller = self._get_controller(lifecycle)
+            entry = self._entries_by_lifecycle[lifecycle] = LifecycleManager.Entry(controller)
+
+        for dep in dependencies:
+            check.isinstance(dep, Lifecycle)
+            dep_entry = self._add_internal(dep, [])
+            entry.dependencies.add(dep_entry)
+            dep_entry.dependents.add(entry)
+
+        return entry
+
+    def add(
+            self,
+            lifecycle: Lifecycle,
+            dependencies: ta.Iterable[Lifecycle] = (),
+    ) -> Entry:
+        check.state(self.state < LifecycleStates.STOPPING and not self.state.is_failed)
+
+        with self._lock():
+            entry = self._add_internal(lifecycle, dependencies)
+
+            if self.state >= LifecycleStates.CONSTRUCTING:
+                def rec(e):
+                    if e.controller.state < LifecycleStates.CONSTRUCTED:
+                        for dep in e.dependencies:
+                            rec(dep)
+                        e.controller.lifecycle_construct()
+                rec(entry)
+
+            if self.state >= LifecycleStates.STARTING:
+                def rec(e):
+                    if e.controller.state < LifecycleStates.STARTED:
+                        for dep in e.dependencies:
+                            rec(dep)
+                        e.controller.lifecycle_start()
+                rec(entry)
+
+            return entry
+
+    ##
+
+    @ta.override
+    def _lifecycle_construct(self) -> None:
+        def rec(entry: LifecycleManager.Entry) -> None:
+            for dep in entry.dependencies:
+                rec(dep)
+
+            if entry.controller.state.is_failed:
+                raise LifecycleStateError(entry.controller)
+
+            if entry.controller.state < LifecycleStates.CONSTRUCTED:
+                entry.controller.lifecycle_construct()
+
+        for entry in self._entries_by_lifecycle.values():
+            rec(entry)
+
+    @ta.override
+    def _lifecycle_start(self) -> None:
+        def rec(entry: LifecycleManager.Entry) -> None:
+            for dep in entry.dependencies:
+                rec(dep)
+
+            if entry.controller.state.is_failed:
+                raise LifecycleStateError(entry.controller)
+
+            if entry.controller.state < LifecycleStates.CONSTRUCTED:
+                entry.controller.lifecycle_construct()
+
+            if entry.controller.state < LifecycleStates.STARTED:
+                entry.controller.lifecycle_start()
+
+        for entry in self._entries_by_lifecycle.values():
+            rec(entry)
+
+    @ta.override
+    def _lifecycle_stop(self) -> None:
+        def rec(entry: LifecycleManager.Entry) -> None:
+            for dep in entry.dependents:
+                rec(dep)
+
+            if entry.controller.state.is_failed:
+                raise LifecycleStateError(entry.controller)
+
+            if entry.controller.state is LifecycleStates.STARTED:
+                entry.controller.lifecycle_stop()
+
+        for entry in self._entries_by_lifecycle.values():
+            rec(entry)
+
+    @ta.override
+    def _lifecycle_destroy(self) -> None:
+        def rec(entry: LifecycleManager.Entry) -> None:
+            for dep in entry.dependents:
+                rec(dep)
+
+            if entry.controller.state < LifecycleStates.DESTROYED:
+                entry.controller.lifecycle_destroy()
+
+        for entry in self._entries_by_lifecycle.values():
+            rec(entry)

omlish/lifecycles/states.py

@@ -0,0 +1,43 @@
+import functools
+
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+
+
+class LifecycleStateError(Exception):
+    pass
+
+
+@dc.dataclass(frozen=True, eq=False)
+@functools.total_ordering
+class LifecycleState(lang.Final):
+    name: str
+    phase: int
+    is_failed: bool
+
+    def __lt__(self, other):
+        return self.phase < check.isinstance(other, LifecycleState).phase
+
+    def __le__(self, other):
+        return self.phase <= check.isinstance(other, LifecycleState).phase
+
+
+class LifecycleStates(lang.Namespace):
+    NEW = LifecycleState('NEW', 0, False)
+
+    CONSTRUCTING = LifecycleState('CONSTRUCTING', 1, False)
+    FAILED_CONSTRUCTING = LifecycleState('FAILED_CONSTRUCTING', 2, True)
+    CONSTRUCTED = LifecycleState('CONSTRUCTED', 3, False)
+
+    STARTING = LifecycleState('STARTING', 4, False)
+    FAILED_STARTING = LifecycleState('FAILED_STARTING', 5, True)
+    STARTED = LifecycleState('STARTED', 6, False)
+
+    STOPPING = LifecycleState('STOPPING', 7, False)
+    FAILED_STOPPING = LifecycleState('FAILED_STOPPING', 8, True)
+    STOPPED = LifecycleState('STOPPED', 9, False)
+
+    DESTROYING = LifecycleState('DESTROYING', 10, False)
+    FAILED_DESTROYING = LifecycleState('FAILED_DESTROYING', 11, True)
+    DESTROYED = LifecycleState('DESTROYED', 12, False)

omlish/lifecycles/transitions.py

@@ -0,0 +1,64 @@
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+from .states import LifecycleState
+from .states import LifecycleStates
+
+
+@dc.dataclass(frozen=True)
+class LifecycleTransition(lang.Final):
+    old: frozenset[LifecycleState]
+    new_intermediate: LifecycleState
+    new_failed: LifecycleState
+    new_succeeded: LifecycleState
+
+    def __post_init__(self) -> None:
+        dc.maybe_post_init(super())
+        check.unique([*self.old, self.new_intermediate, self.new_succeeded, self.new_failed])
+        check.arg(all(self.new_intermediate > o for o in self.old))
+        check.arg(self.new_failed > self.new_intermediate)
+        check.arg(self.new_succeeded > self.new_failed)
+
+
+class LifecycleTransitions(lang.Namespace):
+    CONSTRUCT = LifecycleTransition(
+        frozenset([LifecycleStates.NEW]),
+        LifecycleStates.CONSTRUCTING,
+        LifecycleStates.FAILED_CONSTRUCTING,
+        LifecycleStates.CONSTRUCTED,
+    )
+
+    START = LifecycleTransition(
+        frozenset([LifecycleStates.CONSTRUCTED]),
+        LifecycleStates.STARTING,
+        LifecycleStates.FAILED_STARTING,
+        LifecycleStates.STARTED,
+    )
+
+    STOP = LifecycleTransition(
+        frozenset([LifecycleStates.STARTED]),
+        LifecycleStates.STOPPING,
+        LifecycleStates.FAILED_STOPPING,
+        LifecycleStates.STOPPED,
+    )
+
+    DESTROY = LifecycleTransition(
+        frozenset([
+            LifecycleStates.NEW,
+
+            LifecycleStates.CONSTRUCTING,
+            LifecycleStates.FAILED_CONSTRUCTING,
+            LifecycleStates.CONSTRUCTED,
+
+            LifecycleStates.STARTING,
+            LifecycleStates.FAILED_STARTING,
+            LifecycleStates.STARTED,
+
+            LifecycleStates.STOPPING,
+            LifecycleStates.FAILED_STOPPING,
+            LifecycleStates.STOPPED,
+        ]),
+        LifecycleStates.DESTROYING,
+        LifecycleStates.FAILED_DESTROYING,
+        LifecycleStates.DESTROYED,
+    )

omlish/lite/__init__.py

@@ -0,0 +1 @@
+# @omlish-lite

omlish/lite/cached.py

@@ -0,0 +1,18 @@
+import functools
+
+
+class cached_nullary:  # noqa
+    def __init__(self, fn):
+        super().__init__()
+        self._fn = fn
+        self._value = self._missing = object()
+        functools.update_wrapper(self, fn)
+
+    def __call__(self, *args, **kwargs):  # noqa
+        if self._value is self._missing:
+            self._value = self._fn()
+        return self._value
+
+    def __get__(self, instance, owner):  # noqa
+        bound = instance.__dict__[self._fn.__name__] = self.__class__(self._fn.__get__(instance, owner))
+        return bound

omlish/lite/check.py

@@ -0,0 +1,29 @@
+# ruff: noqa: UP006 UP007
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+def check_isinstance(v: T, spec: ta.Union[ta.Type[T], tuple]) -> T:
+    if not isinstance(v, spec):
+        raise TypeError(v)
+    return v
+
+
+def check_not_isinstance(v: T, spec: ta.Union[type, tuple]) -> T:
+    if isinstance(v, spec):
+        raise TypeError(v)
+    return v
+
+
+def check_not_none(v: ta.Optional[T]) -> T:
+    if v is None:
+        raise ValueError
+    return v
+
+
+def check_not(v: ta.Any) -> None:
+    if v:
+        raise ValueError(v)
+    return v

omlish/lite/contextmanagers.py

@@ -0,0 +1,18 @@
+import contextlib
+
+
+@contextlib.contextmanager
+def attr_setting(obj, attr, val, *, default=None):  # noqa
+    not_set = object()
+    orig = getattr(obj, attr, not_set)
+    try:
+        setattr(obj, attr, val)
+        if orig is not not_set:
+            yield orig
+        else:
+            yield default
+    finally:
+        if orig is not_set:
+            delattr(obj, attr)
+        else:
+            setattr(obj, attr, orig)

omlish/lite/json.py

@@ -0,0 +1,30 @@
+import functools
+import json
+import typing as ta
+
+
+##
+
+
+JSON_PRETTY_INDENT = 2
+
+JSON_PRETTY_KWARGS: ta.Mapping[str, ta.Any] = dict(
+    indent=JSON_PRETTY_INDENT,
+)
+
+json_dump_pretty: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON_PRETTY_KWARGS)  # type: ignore
+json_dumps_pretty: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_PRETTY_KWARGS)
+
+
+##
+
+
+JSON_COMPACT_SEPARATORS = (',', ':')
+
+JSON_COMPACT_KWARGS: ta.Mapping[str, ta.Any] = dict(
+    indent=None,
+    separators=JSON_COMPACT_SEPARATORS,
+)
+
+json_dump_compact: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON_COMPACT_KWARGS)  # type: ignore
+json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_COMPACT_KWARGS)

omlish/lite/logs.py

@@ -0,0 +1,52 @@
+"""
+TODO:
+ - debug
+"""
+# ruff: noqa: UP007
+import logging
+import typing as ta
+
+from .json import json_dumps_compact
+
+
+log = logging.getLogger(__name__)
+
+
+class JsonLogFormatter(logging.Formatter):
+
+    KEYS: ta.Mapping[str, bool] = {
+        'name': False,
+        'msg': False,
+        'args': False,
+        'levelname': False,
+        'levelno': False,
+        'pathname': False,
+        'filename': False,
+        'module': False,
+        'exc_info': True,
+        'exc_text': True,
+        'stack_info': True,
+        'lineno': False,
+        'funcName': False,
+        'created': False,
+        'msecs': False,
+        'relativeCreated': False,
+        'thread': False,
+        'threadName': False,
+        'processName': False,
+        'process': False,
+    }
+
+    def format(self, record: logging.LogRecord) -> str:
+        dct = {
+            k: v
+            for k, o in self.KEYS.items()
+            for v in [getattr(record, k)]
+            if not (o and v is None)
+        }
+        return json_dumps_compact(dct)
+
+
+def configure_standard_logging(level: ta.Union[int, str] = logging.INFO) -> None:
+    logging.root.addHandler(logging.StreamHandler())
+    logging.root.setLevel(level)