omlish 0.0.0.dev484__py3-none-any.whl → 0.0.0.dev493__py3-none-any.whl

omlish/lifecycles/controller.py

@@ -1,163 +1,226 @@
-import abc
 import typing as ta
 
 from .. import check
 from .. import lang
-from .base import AnyLifecycle  # noqa
-from .base import Lifecycle  # noqa
+from .base import AsyncLifecycle
+from .base import Lifecycle
+from .listeners import AsyncLifecycleListener
+from .listeners import LifecycleListener
 from .states import LifecycleState
 from .states import LifecycleStates
 from .transitions import LifecycleTransition
 from .transitions import LifecycleTransitions
 
 
-R = ta.TypeVar('R')
-
-AnyLifecycleT = ta.TypeVar('AnyLifecycleT', bound='AnyLifecycle')
-
-LifecycleT = ta.TypeVar('LifecycleT', bound='Lifecycle')
-
-
 ##
 
 
-class AnyLifecycleListener(ta.Generic[AnyLifecycleT, R]):
-    def on_starting(self, obj: AnyLifecycleT) -> R | None:
-        return None
-
-    def on_started(self, obj: AnyLifecycleT) -> R | None:
-        return None
-
-    def on_stopping(self, obj: AnyLifecycleT) -> R | None:
-        return None
-
-    def on_stopped(self, obj: AnyLifecycleT) -> R | None:
-        return None
-
-
-class AnyLifecycleController(AnyLifecycle[R], lang.Abstract, ta.Generic[AnyLifecycleT, R]):
+@ta.final
+class LifecycleController(Lifecycle, lang.Final):
     def __init__(
             self,
-            lifecycle: AnyLifecycleT,
+            controlled: Lifecycle,
+            *,
+            lock: lang.DefaultLockable = None,
     ) -> None:
         super().__init__()
 
-        self._lifecycle: AnyLifecycleT = check.isinstance(lifecycle, AnyLifecycle)  # type: ignore
+        self._controlled: Lifecycle = check.isinstance(controlled, Lifecycle)
+        self._lock = lang.default_lock(lock, None)
 
         self._state = LifecycleStates.NEW
-        self._listeners: list[AnyLifecycleListener[AnyLifecycleT, R]] = []
+        self._listeners: list[LifecycleListener] = []
+
+    __repr__ = lang.attr_ops(lambda o: (o.controlled, o.state)).repr
 
-    __repr__ = lang.attr_ops(lambda o: (o.lifecycle, o.state)).repr
+    #
 
     @property
-    def lifecycle(self) -> AnyLifecycleT:
-        return self._lifecycle
+    def controlled(self) -> Lifecycle:
+        return self._controlled
 
     @property
     def state(self) -> LifecycleState:
         return self._state
 
-    def add_listener(self, listener: AnyLifecycleListener[AnyLifecycleT, R]) -> ta.Self:
-        self._listeners.append(check.isinstance(listener, AnyLifecycleListener))
+    def add_listener(self, listener: LifecycleListener) -> ta.Self:
+        self._listeners.append(check.isinstance(listener, LifecycleListener))
         return self
 
-    @abc.abstractmethod
+    #
+
+    def _set_state(self, state: LifecycleState) -> None:
+        self._state = state
+        self._controlled.lifecycle_state(state)
+
     def _advance(
             self,
             transition: LifecycleTransition,
-            lifecycle_fn: ta.Callable[[], R | None],
-            pre_listener_fn: ta.Callable[
-                [AnyLifecycleListener[AnyLifecycleT, R]],
-                ta.Callable[[AnyLifecycleT], R | None],
-            ] | None = None,
-            post_listener_fn: ta.Callable[
-                [AnyLifecycleListener[AnyLifecycleT, R]],
-                ta.Callable[[AnyLifecycleT], R | None],
-            ] | None = None,
-    ) -> R | None:
-        raise NotImplementedError
+            controlled_fn: ta.Callable[[], None],
+            pre_listener_fn: ta.Callable[[LifecycleListener], ta.Callable[[Lifecycle], None]] | None = None,
+            post_listener_fn: ta.Callable[[LifecycleListener], ta.Callable[[Lifecycle], None]] | None = None,
+    ) -> None:
+        with self._lock():
+            if pre_listener_fn is not None:
+                for listener in self._listeners:
+                    pre_listener_fn(listener)(self._controlled)
+
+            check.state(self._state in transition.old)
+            self._set_state(transition.new_intermediate)
+
+            try:
+                controlled_fn()
+            except Exception:
+                self._set_state(transition.new_failed)
+                raise
+
+            self._set_state(transition.new_succeeded)
+
+            if post_listener_fn is not None:
+                for listener in self._listeners:
+                    post_listener_fn(listener)(self._controlled)
 
     ##
 
     @ta.override
-    def lifecycle_construct(self) -> R | None:
-        return self._advance(
+    def lifecycle_construct(self) -> None:
+        self._advance(
             LifecycleTransitions.CONSTRUCT,
-            self._lifecycle.lifecycle_construct,
+            self._controlled.lifecycle_construct,
         )
 
     @ta.override
-    def lifecycle_start(self) -> R | None:
-        return self._advance(
+    def lifecycle_start(self) -> None:
+        self._advance(
             LifecycleTransitions.START,
-            self._lifecycle.lifecycle_start,
+            self._controlled.lifecycle_start,
             lambda l: l.on_starting,
             lambda l: l.on_started,
         )
 
     @ta.override
-    def lifecycle_stop(self) -> R | None:
-        return self._advance(
+    def lifecycle_stop(self) -> None:
+        self._advance(
             LifecycleTransitions.STOP,
-            self._lifecycle.lifecycle_stop,
+            self._controlled.lifecycle_stop,
             lambda l: l.on_stopping,
             lambda l: l.on_stopped,
         )
 
     @ta.override
-    def lifecycle_destroy(self) -> R | None:
-        return self._advance(
+    def lifecycle_destroy(self) -> None:
+        self._advance(
             LifecycleTransitions.DESTROY,
-            self._lifecycle.lifecycle_destroy,
+            self._controlled.lifecycle_destroy,
         )
 
 
-##
-
-
-LifecycleListener: ta.TypeAlias = AnyLifecycleListener[LifecycleT, None]
+#
 
 
-class LifecycleController(
-    AnyLifecycleController[LifecycleT, None],
-    Lifecycle,
-    ta.Generic[LifecycleT],
-):
+@ta.final
+class AsyncLifecycleController(AsyncLifecycle, lang.Final):
     def __init__(
             self,
-            lifecycle: LifecycleT,
+            controlled: AsyncLifecycle,
             *,
-            lock: lang.DefaultLockable = None,
+            lock: lang.DefaultAsyncLockable = None,
     ) -> None:
-        super().__init__(lifecycle)
+        super().__init__()
 
-        self._lock = lang.default_lock(lock, False)
+        self._controlled: AsyncLifecycle = check.isinstance(controlled, AsyncLifecycle)
+        self._lock = lang.default_async_lock(lock, None)
 
-    def _advance(
+        self._state = LifecycleStates.NEW
+        self._listeners: list[AsyncLifecycleListener] = []
+
+    __repr__ = lang.attr_ops(lambda o: (o.controlled, o.state)).repr
+
+    #
+
+    @property
+    def controlled(self) -> AsyncLifecycle:
+        return self._controlled
+
+    @property
+    def state(self) -> LifecycleState:
+        return self._state
+
+    def add_listener(self, listener: AsyncLifecycleListener) -> ta.Self:
+        self._listeners.append(check.isinstance(listener, AsyncLifecycleListener))
+        return self
+
+    #
+
+    async def _set_state(self, state: LifecycleState) -> None:
+        self._state = state
+        await self._controlled.lifecycle_state(state)
+
+    async def _advance(
             self,
             transition: LifecycleTransition,
-            lifecycle_fn: ta.Callable[[], None],
-            pre_listener_fn: ta.Callable[
-                [LifecycleListener[LifecycleT]],
-                ta.Callable[[LifecycleT], None],
-            ] | None = None,
-            post_listener_fn: ta.Callable[
-                [LifecycleListener[LifecycleT]],
-                ta.Callable[[LifecycleT], None],
-            ] | None = None,
+            controlled_fn: ta.Callable[[], ta.Awaitable[None]],
+            pre_listener_fn: ta.Callable[[AsyncLifecycleListener], ta.Callable[[AsyncLifecycle], ta.Awaitable[None]]] | None = None,  # noqa
+            post_listener_fn: ta.Callable[[AsyncLifecycleListener], ta.Callable[[AsyncLifecycle], ta.Awaitable[None]]] | None = None,  # noqa
     ) -> None:
-        with self._lock():
+        async with self._lock():
             if pre_listener_fn is not None:
                 for listener in self._listeners:
-                    pre_listener_fn(listener)(self._lifecycle)
+                    await pre_listener_fn(listener)(self._controlled)
+
             check.state(self._state in transition.old)
-            self._state = transition.new_intermediate
+            await self._set_state(transition.new_intermediate)
+
             try:
-                lifecycle_fn()
+                await controlled_fn()
             except Exception:
-                self._state = transition.new_failed
+                await self._set_state(transition.new_failed)
                 raise
-            self._state = transition.new_succeeded
+
+            await self._set_state(transition.new_succeeded)
+
             if post_listener_fn is not None:
                 for listener in self._listeners:
-                    post_listener_fn(listener)(self._lifecycle)
+                    await post_listener_fn(listener)(self._controlled)
+
+    ##
+
+    @ta.override
+    async def lifecycle_construct(self) -> None:
+        await self._advance(
+            LifecycleTransitions.CONSTRUCT,
+            self._controlled.lifecycle_construct,
+        )
+
+    @ta.override
+    async def lifecycle_start(self) -> None:
+        await self._advance(
+            LifecycleTransitions.START,
+            self._controlled.lifecycle_start,
+            lambda l: l.on_starting,
+            lambda l: l.on_started,
+        )
+
+    @ta.override
+    async def lifecycle_stop(self) -> None:
+        await self._advance(
+            LifecycleTransitions.STOP,
+            self._controlled.lifecycle_stop,
+            lambda l: l.on_stopping,
+            lambda l: l.on_stopped,
+        )
+
+    @ta.override
+    async def lifecycle_destroy(self) -> None:
+        await self._advance(
+            LifecycleTransitions.DESTROY,
+            self._controlled.lifecycle_destroy,
+        )
+
+
+#
+
+
+AnyLifecycleController: ta.TypeAlias = LifecycleController | AsyncLifecycleController
+
+ANY_LIFECYCLE_CONTROLLER_TYPES: tuple[type[LifecycleController | AsyncLifecycleController], ...] = (LifecycleController, AsyncLifecycleController)  # noqa

omlish/lifecycles/injection.py

@@ -0,0 +1,143 @@
+import contextlib
+import typing as ta
+
+from .. import check
+from .. import collections as col
+from .. import dataclasses as dc
+from .. import inject as inj
+from .. import lang
+from .base import AsyncLifecycle
+from .base import Lifecycle
+from .contextmanagers import async_lifecycle_context_manage
+from .contextmanagers import lifecycle_context_manage
+from .manager import AsyncLifecycleManager
+from .manager import LifecycleManager
+from .unwrap import unwrap_any_lifecycle
+
+
+##
+
+
+@ta.final
+class _LifecycleRegistrar(lang.Final):
+    def __init__(
+            self,
+            lifecycle_manager_cls: type[LifecycleManager | AsyncLifecycleManager],
+            lifecycle_cls_tup: tuple[type[Lifecycle | AsyncLifecycle], ...],
+            *,
+            unwrap: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._lifecycle_manager_cls = lifecycle_manager_cls
+        self._lifecycle_cls_tup = lifecycle_cls_tup
+        self._unwrap = unwrap
+
+        self._seen: ta.MutableSet[ta.Any] = col.IdentityWeakSet()
+        self._stack: list[_LifecycleRegistrar.State] = []
+
+    @ta.final
+    @dc.dataclass(frozen=True)
+    class Dep(lang.Final):
+        binding: inj.Binding | None
+        obj: ta.Any
+        lco: ta.Any
+
+    @ta.final
+    @dc.dataclass(frozen=True)
+    class State(lang.Final):
+        key: inj.Key
+        deps: list['_LifecycleRegistrar.Dep'] = dc.field(default_factory=list)
+
+    async def _on_provision(
+            self,
+            injector: inj.AsyncInjector,
+            key: inj.Key,
+            binding: inj.Binding | None,
+            fn: ta.Callable[[], ta.Awaitable[ta.Any]],
+    ) -> ta.Awaitable[ta.Any]:
+        st = _LifecycleRegistrar.State(key)
+        self._stack.append(st)
+        try:
+            obj = await fn()
+        finally:
+            popped = self._stack.pop()
+            check.state(popped is st)
+
+        lco: ta.Any
+        if self._unwrap:
+            lco = unwrap_any_lifecycle(obj)
+        else:
+            lco = obj
+
+        if (
+                lco is not None and
+                isinstance(lco, self._lifecycle_cls_tup) and
+                not isinstance(obj, self._lifecycle_manager_cls)
+        ):
+            if self._stack:
+                self._stack[-1].deps.append(_LifecycleRegistrar.Dep(binding, obj, lco))
+
+            if obj not in self._seen:
+                mgr = await injector[self._lifecycle_manager_cls]
+
+                dep_lcos = [d.lco for d in st.deps]
+
+                if isinstance(mgr, AsyncLifecycleManager):
+                    await mgr.add(lco, dep_lcos)
+                elif isinstance(mgr, LifecycleManager):
+                    mgr.add(lco, dep_lcos)
+                else:
+                    raise TypeError(mgr)
+
+                self._seen.add(obj)
+
+        elif self._stack:
+            self._stack[-1].deps.extend(st.deps)
+
+        return obj
+
+
+def bind_lifecycle_registrar() -> inj.Elements:
+    return inj.as_elements(
+        inj.bind(_LifecycleRegistrar, to_const=(lr := _LifecycleRegistrar(
+            LifecycleManager,
+            (Lifecycle,),
+            unwrap=True,
+        ))),
+        inj.bind_provision_listener(lr._on_provision),  # noqa
+    )
+
+
+def bind_async_lifecycle_registrar() -> inj.Elements:
+    return inj.as_elements(
+        inj.bind(_LifecycleRegistrar, to_const=(lr := _LifecycleRegistrar(
+            AsyncLifecycleManager,
+            (Lifecycle, AsyncLifecycle),
+            unwrap=True,
+        ))),
+        inj.bind_provision_listener(lr._on_provision),  # noqa
+    )
+
+
+##
+
+
+def bind_managed_lifecycle_manager() -> inj.Elements:
+    # FIXME: lock?
+    def inner(es: contextlib.ExitStack) -> LifecycleManager:
+        return es.enter_context(lifecycle_context_manage(LifecycleManager()))
+
+    return inj.as_elements(
+        inj.bind(inner, singleton=True, eager=True),
+    )
+
+
+def bind_async_managed_lifecycle_manager() -> inj.Elements:
+    # FIXME: lock?
+    async def inner(aes: contextlib.AsyncExitStack) -> AsyncLifecycleManager:
+        return await aes.enter_async_context(async_lifecycle_context_manage(AsyncLifecycleManager()))
+
+    return inj.as_elements(
+        inj.bind(inner, singleton=True, eager=True),
+    )

omlish/lifecycles/listeners.py

@@ -0,0 +1,56 @@
+import typing as ta
+
+from .. import check
+from .base import AsyncLifecycle
+from .base import Lifecycle
+
+
+##
+
+
+class LifecycleListener:
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        try:
+            async_lifecycle_listener_cls = AsyncLifecycleListener
+        except NameError:
+            pass
+        else:
+            check.not_issubclass(cls, async_lifecycle_listener_cls)
+
+    def on_starting(self, obj: Lifecycle) -> None:
+        pass
+
+    def on_started(self, obj: Lifecycle) -> None:
+        pass
+
+    def on_stopping(self, obj: Lifecycle) -> None:
+        pass
+
+    def on_stopped(self, obj: Lifecycle) -> None:
+        pass
+
+
+class AsyncLifecycleListener:
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        check.not_issubclass(cls, LifecycleListener)
+
+    async def on_starting(self, obj: AsyncLifecycle) -> None:
+        pass
+
+    async def on_started(self, obj: AsyncLifecycle) -> None:
+        pass
+
+    async def on_stopping(self, obj: AsyncLifecycle) -> None:
+        pass
+
+    async def on_stopped(self, obj: AsyncLifecycle) -> None:
+        pass
+
+
+AnyLifecycleListener: ta.TypeAlias = LifecycleListener | AsyncLifecycleListener
+
+ANY_LIFECYCLE_LISTENER_TYPES: tuple[type[LifecycleListener | AsyncLifecycleListener], ...] = (LifecycleListener, AsyncLifecycleListener)  # noqa

omlish/lifecycles/managed.py

@@ -0,0 +1,142 @@
+import typing as ta
+
+from .. import cached
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+from .base import AsyncLifecycle
+from .base import Lifecycle
+from .states import LifecycleState
+from .states import LifecycleStates
+
+
+LifecycleManagedT = ta.TypeVar('LifecycleManagedT', bound='LifecycleManaged')
+
+AsyncLifecycleManagedT = ta.TypeVar('AsyncLifecycleManagedT', bound='AsyncLifecycleManaged')
+
+
+##
+
+
+class LifecycleManaged(lang.Abstract):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        try:
+            async_lifecycle_managed_cls = AsyncLifecycleManaged
+        except NameError:
+            pass
+        else:
+            check.not_issubclass(cls, async_lifecycle_managed_cls)
+
+    @ta.final
+    @dc.dataclass(frozen=True)
+    class _Lifecycle(
+        Lifecycle,
+        lang.Final,
+        ta.Generic[LifecycleManagedT],
+    ):
+        obj: LifecycleManagedT
+
+        def lifecycle_state(self, state: LifecycleState) -> None:
+            self.obj._lifecycle_state_ = state
+
+        def lifecycle_construct(self) -> None:
+            self.obj._lifecycle_construct()  # noqa
+
+        def lifecycle_start(self) -> None:
+            self.obj._lifecycle_start()  # noqa
+
+        def lifecycle_stop(self) -> None:
+            self.obj._lifecycle_stop()  # noqa
+
+        def lifecycle_destroy(self) -> None:
+            self.obj._lifecycle_destroy()  # noqa
+
+    @ta.final
+    @cached.property
+    def _lifecycle(self) -> _Lifecycle[ta.Self]:
+        return LifecycleManaged._Lifecycle(self)
+
+    _lifecycle_state_: LifecycleState = LifecycleStates.NEW
+
+    @property
+    def _lifecycle_state(self) -> LifecycleState:
+        return self._lifecycle_state_
+
+    def _lifecycle_construct(self) -> None:
+        pass
+
+    def _lifecycle_start(self) -> None:
+        pass
+
+    def _lifecycle_stop(self) -> None:
+        pass
+
+    def _lifecycle_destroy(self) -> None:
+        pass
+
+
+#
+
+
+class AsyncLifecycleManaged(lang.Abstract):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        check.not_issubclass(cls, LifecycleManaged)
+
+    @ta.final
+    @dc.dataclass(frozen=True)
+    class _Lifecycle(
+        AsyncLifecycle,
+        lang.Final,
+        ta.Generic[AsyncLifecycleManagedT],
+    ):
+        obj: AsyncLifecycleManagedT
+
+        async def lifecycle_state(self, state: LifecycleState) -> None:
+            self.obj._lifecycle_state_ = state
+
+        async def lifecycle_construct(self) -> None:
+            await self.obj._lifecycle_construct()  # noqa
+
+        async def lifecycle_start(self) -> None:
+            await self.obj._lifecycle_start()  # noqa
+
+        async def lifecycle_stop(self) -> None:
+            await self.obj._lifecycle_stop()  # noqa
+
+        async def lifecycle_destroy(self) -> None:
+            await self.obj._lifecycle_destroy()  # noqa
+
+    @ta.final
+    @cached.property
+    def _lifecycle(self) -> _Lifecycle[ta.Self]:
+        return AsyncLifecycleManaged._Lifecycle(self)
+
+    _lifecycle_state_: LifecycleState = LifecycleStates.NEW
+
+    @property
+    def _lifecycle_state(self) -> LifecycleState:
+        return self._lifecycle_state_
+
+    async def _lifecycle_construct(self) -> None:
+        pass
+
+    async def _lifecycle_start(self) -> None:
+        pass
+
+    async def _lifecycle_stop(self) -> None:
+        pass
+
+    async def _lifecycle_destroy(self) -> None:
+        pass
+
+
+#
+
+
+AnyLifecycleManaged: ta.TypeAlias = LifecycleManaged | AsyncLifecycleManaged
+
+ANY_LIFECYCLE_MANAGED_TYPES: tuple[type[LifecycleManaged | AsyncLifecycleManaged], ...] = (LifecycleManaged, AsyncLifecycleManaged)  # noqa