omlish 0.0.0.dev4__py3-none-any.whl → 0.0.0.dev6__py3-none-any.whl

omlish/lifecycles/contextmanagers.py

@@ -0,0 +1,74 @@
+import types
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import defs
+from .. import lang
+from .base import Lifecycle
+from .controller import LifecycleController
+from .states import LifecycleState
+from .states import LifecycleStates
+
+
+LifecycleT = ta.TypeVar('LifecycleT', bound='Lifecycle')
+ContextManagerT = ta.TypeVar('ContextManagerT', bound=ta.ContextManager)
+
+
+@dc.dataclass(frozen=True)
+class ContextManagerLifecycle(Lifecycle, lang.Final, ta.Generic[ContextManagerT]):
+    cm: ContextManagerT
+
+    @ta.override
+    def lifecycle_start(self) -> None:
+        self.cm.__enter__()
+
+    @ta.override
+    def lifecycle_stop(self) -> None:
+        self.cm.__exit__(None, None, None)
+
+
+class LifecycleContextManager(ta.Generic[LifecycleT]):
+
+    def __init__(self, lifecycle: LifecycleT) -> None:
+        super().__init__()
+        self._lifecycle = lifecycle
+        self._controller = lifecycle if isinstance(lifecycle, LifecycleController) else LifecycleController(lifecycle)
+
+    defs.repr('lifecycle', 'state')
+
+    @property
+    def lifecycle(self) -> LifecycleT:
+        return self._lifecycle
+
+    @property
+    def controller(self) -> LifecycleController:
+        return self._controller
+
+    @property
+    def state(self) -> LifecycleState:
+        return self._controller.state
+
+    def __enter__(self) -> ta.Self:
+        try:
+            self._controller.lifecycle_construct()
+            self._controller.lifecycle_start()
+        except Exception:
+            self._controller.lifecycle_destroy()
+            raise
+        return self
+
+    def __exit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc_val: BaseException | None,
+            exc_tb: types.TracebackType | None,
+    ) -> bool | None:
+        try:
+            if self._controller.state is LifecycleStates.STARTED:
+                self._controller.lifecycle_stop()
+        except Exception:
+            self._controller.lifecycle_destroy()
+            raise
+        else:
+            self._controller.lifecycle_destroy()
+        return None

omlish/lifecycles/controller.py

@@ -0,0 +1,116 @@
+import typing as ta
+
+from .. import check
+from .. import defs
+from .. import lang
+from .base import Lifecycle
+from .states import LifecycleState
+from .states import LifecycleStates
+from .transitions import LifecycleTransition
+from .transitions import LifecycleTransitions
+
+
+LifecycleT = ta.TypeVar('LifecycleT', bound='Lifecycle')
+
+
+class LifecycleListener(ta.Generic[LifecycleT]):
+
+    def on_starting(self, obj: LifecycleT) -> None:
+        pass
+
+    def on_started(self, obj: LifecycleT) -> None:
+        pass
+
+    def on_stopping(self, obj: LifecycleT) -> None:
+        pass
+
+    def on_stopped(self, obj: LifecycleT) -> None:
+        pass
+
+
+class LifecycleController(Lifecycle, ta.Generic[LifecycleT]):
+
+    def __init__(
+            self,
+            lifecycle: LifecycleT,
+            *,
+            lock: lang.DefaultLockable = None,
+    ) -> None:
+        super().__init__()
+
+        self._lifecycle: LifecycleT = check.isinstance(lifecycle, Lifecycle)  # type: ignore
+        self._lock = lang.default_lock(lock, False)
+
+        self._state = LifecycleStates.NEW
+        self._listeners: list[LifecycleListener[LifecycleT]] = []
+
+    defs.repr('lifecycle', 'state')
+
+    @property
+    def lifecycle(self) -> LifecycleT:
+        return self._lifecycle
+
+    @property
+    def state(self) -> LifecycleState:
+        return self._state
+
+    def add_listener(self, listener: LifecycleListener[LifecycleT]) -> 'LifecycleController':
+        self._listeners.append(check.isinstance(listener, LifecycleListener))  # type: ignore
+        return self
+
+    def _advance(
+            self,
+            transition: LifecycleTransition,
+            lifecycle_fn: ta.Callable[[], None],
+            pre_listener_fn: ta.Callable[[LifecycleListener[LifecycleT]], ta.Callable[[LifecycleT], None]] | None = None,  # noqa
+            post_listener_fn: ta.Callable[[LifecycleListener[LifecycleT]], ta.Callable[[LifecycleT], None]] | None = None,  # noqa
+    ) -> None:
+        with self._lock():
+            if pre_listener_fn is not None:
+                for listener in self._listeners:
+                    pre_listener_fn(listener)(self._lifecycle)
+            check.state(self._state in transition.old)
+            self._state = transition.new_intermediate
+            try:
+                lifecycle_fn()
+            except Exception:
+                self._state = transition.new_failed
+                raise
+            self._state = transition.new_succeeded
+            if post_listener_fn is not None:
+                for listener in self._listeners:
+                    post_listener_fn(listener)(self._lifecycle)
+
+    ##
+
+    @ta.override
+    def lifecycle_construct(self) -> None:
+        self._advance(
+            LifecycleTransitions.CONSTRUCT,
+            self._lifecycle.lifecycle_construct,
+        )
+
+    @ta.override
+    def lifecycle_start(self) -> None:
+        self._advance(
+            LifecycleTransitions.START,
+            self._lifecycle.lifecycle_start,
+            lambda l: l.on_starting,
+            lambda l: l.on_started,
+        )
+
+    @ta.override
+    def lifecycle_stop(self) -> None:
+        self._advance(
+            LifecycleTransitions.STOP,
+            self._lifecycle.lifecycle_stop,
+            lambda l: l.on_stopping,
+            lambda l: l.on_stopped,
+        )
+
+    @ta.override
+    def lifecycle_destroy(self) -> None:
+        self._advance(
+            LifecycleTransitions.DESTROY,
+            self._lifecycle.lifecycle_destroy,
+        )

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/logs/formatters.py

@@ -5,8 +5,8 @@ import datetime
 import logging
 import typing as ta
 
-from .. import json
 from .. import term
+from ..serde import json
 
 
 class StandardLogFormatter(logging.Formatter):

omlish/logs/utils.py

@@ -12,7 +12,7 @@ def error_logging(log=log):  # noqa
             try:
                 return fn(*args, **kwargs)
             except Exception:
-                log.exception(f'Error in {fn!r}')
+                log.exception('Error in %r', fn)
                 raise
 
         return inner

omlish/marshal/__init__.py

@@ -50,3 +50,7 @@ from .standard import (  # noqa
     STANDARD_UNMARSHALER_FACTORIES,
     new_standard_unmarshaler_factory,
 )
+
+from .values import (  # noqa
+    Value,
+)

omlish/marshal/datetimes.py

@@ -67,7 +67,7 @@ class DatetimeUnmarshaler(Unmarshaler):
 
         for fmt in self.fmts:
             try:
-                return datetime.datetime.strptime(v, fmt)
+                return datetime.datetime.strptime(v, fmt)  # FIXME: timezone  # noqa
             except ValueError:
                 pass
 

omlish/marshal/naming.py

@@ -7,6 +7,7 @@ from .base import Option
 class Naming(Option, enum.Enum):
     SNAKE = 'snake'
     CAMEL = 'camel'
+    LOW_CAMEL = 'low_camel'
 
 
 def translate_name(n: str, e: Naming) -> str:
@@ -14,4 +15,7 @@ def translate_name(n: str, e: Naming) -> str:
         return lang.snake_case(n)
     if e is Naming.CAMEL:
         return lang.camel_case(n)
+    if e is Naming.LOW_CAMEL:
+        r = lang.camel_case(n)
+        return (r[0].lower() + r[1:]) if r else r
     raise ValueError(e)

omlish/marshal/objects.py

@@ -2,6 +2,7 @@
 TODO:
  - cfg naming
  - adapters for dataclasses / namedtuples / user objects (as confitured)
+ - mro-merge ObjectMetadata
 """
 import collections.abc
 import typing as ta

omlish/marshal/polymorphism.py

@@ -97,7 +97,7 @@ def polymorphism_from_subclasses(ty: type, *, naming: Naming | None = None) -> P
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismMarshaler(Marshaler):
+class DictKeyPolymorphismMarshaler(Marshaler):
     m: ta.Mapping[type, tuple[str, Marshaler]]
 
     def marshal(self, ctx: MarshalContext, o: ta.Any | None) -> Value:
@@ -111,7 +111,7 @@ class PolymorphismMarshalerFactory(MarshalerFactory):
 
     def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
         if rty is self.p.ty:
-            return PolymorphismMarshaler({
+            return DictKeyPolymorphismMarshaler({
                 i.ty: (i.tag, ctx.make(i.ty))
                 for i in self.p.impls
             })
@@ -122,7 +122,7 @@ class PolymorphismMarshalerFactory(MarshalerFactory):
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismUnmarshaler(Unmarshaler):
+class DictKeyPolymorphismUnmarshaler(Unmarshaler):
     m: ta.Mapping[str, Unmarshaler]
 
     def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
@@ -138,7 +138,7 @@ class PolymorphismUnmarshalerFactory(UnmarshalerFactory):
 
     def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
         if rty is self.p.ty:
-            return PolymorphismUnmarshaler({
+            return DictKeyPolymorphismUnmarshaler({
                 t: u
                 for i in self.p.impls
                 for u in [ctx.make(i.ty)]