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

omlish/lifecycles/base.py

@@ -1,103 +1,217 @@
 import typing as ta
 
+from .. import check
 from .. import dataclasses as dc
 from .. import lang
+from .states import LifecycleState
 
 
-R = ta.TypeVar('R')
+##
+
+
+class Lifecycle(lang.Abstract):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        try:
+            async_lifecycle_cls = AsyncLifecycle
+        except NameError:
+            pass
+        else:
+            check.not_issubclass(cls, async_lifecycle_cls)
+
+    def lifecycle_state(self, state: LifecycleState) -> None:
+        """
+        This method is not intended for actual work - this is intended solely for safe bookkeeping. Only do real work in
+        the explicit per-state methods.
+        """
+
+    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 AsyncLifecycle(lang.Abstract):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        check.not_issubclass(cls, Lifecycle)
+
+    async def lifecycle_state(self, state: LifecycleState) -> None:
+        """
+        This method is not intended for actual work - this is intended solely for safe bookkeeping. Only do real work in
+        the explicit per-state methods.
+        """
+
+    async def lifecycle_construct(self) -> None:
+        pass
+
+    async def lifecycle_start(self) -> None:
+        pass
+
+    async def lifecycle_stop(self) -> None:
+        pass
 
-AnyLifecycleT = ta.TypeVar('AnyLifecycleT', bound='AnyLifecycle')
-AnyLifecycleCallback: ta.TypeAlias = ta.Callable[[AnyLifecycleT], R]
+    async def lifecycle_destroy(self) -> None:
+        pass
 
-LifecycleT = ta.TypeVar('LifecycleT', bound='Lifecycle')
-LifecycleCallback: ta.TypeAlias = ta.Callable[[LifecycleT], R]
 
-AsyncLifecycleT = ta.TypeVar('AsyncLifecycleT', bound='AsyncLifecycle')
-AsyncLifecycleCallback: ta.TypeAlias = ta.Callable[[AsyncLifecycleT], R]
+AnyLifecycle: ta.TypeAlias = Lifecycle | AsyncLifecycle
+
+ANY_LIFECYCLE_TYPES: tuple[type[Lifecycle | AsyncLifecycle], ...] = (Lifecycle, AsyncLifecycle)
 
 
 ##
 
 
-class AnyLifecycle(lang.Abstract, ta.Generic[R]):
-    def lifecycle_construct(self) -> R | None:
-        return None
+@ta.final
+@dc.dataclass(frozen=True)
+class _SyncToAsyncLifecycle(AsyncLifecycle, lang.Final):
+    lifecycle: Lifecycle
+
+    async def lifecycle_state(self, state: LifecycleState) -> None:
+        self.lifecycle.lifecycle_state(state)
+
+    async def lifecycle_construct(self) -> None:
+        self.lifecycle.lifecycle_construct()
+
+    async def lifecycle_start(self) -> None:
+        self.lifecycle.lifecycle_start()
+
+    async def lifecycle_stop(self) -> None:
+        self.lifecycle.lifecycle_stop()
+
+    async def lifecycle_destroy(self) -> None:
+        self.lifecycle.lifecycle_destroy()
+
+
+def sync_to_async_lifecycle(lifecycle: Lifecycle) -> AsyncLifecycle:
+    return _SyncToAsyncLifecycle(lifecycle)
+
+
+def as_async_lifecycle(lifecycle: Lifecycle | AsyncLifecycle) -> AsyncLifecycle:
+    if isinstance(lifecycle, Lifecycle):
+        return sync_to_async_lifecycle(lifecycle)
+
+    elif isinstance(lifecycle, AsyncLifecycle):
+        return lifecycle
+
+    else:
+        raise TypeError(lifecycle)
+
+
+@ta.final
+@dc.dataclass(frozen=True)
+class _AsyncToSyncLifecycle(Lifecycle, lang.Final):
+    lifecycle: AsyncLifecycle
+
+    def lifecycle_state(self, state: LifecycleState) -> None:
+        lang.sync_await(self.lifecycle.lifecycle_state(state))
+
+    def lifecycle_construct(self) -> None:
+        lang.sync_await(self.lifecycle.lifecycle_construct())
 
-    def lifecycle_start(self) -> R | None:
-        return None
+    def lifecycle_start(self) -> None:
+        lang.sync_await(self.lifecycle.lifecycle_start())
 
-    def lifecycle_stop(self) -> R | None:
-        return None
+    def lifecycle_stop(self) -> None:
+        lang.sync_await(self.lifecycle.lifecycle_stop())
 
-    def lifecycle_destroy(self) -> R | None:
-        return None
+    def lifecycle_destroy(self) -> None:
+        lang.sync_await(self.lifecycle.lifecycle_destroy())
 
 
+def async_to_sync_lifecycle(lifecycle: AsyncLifecycle) -> Lifecycle:
+    return _AsyncToSyncLifecycle(lifecycle)
+
+
+def as_sync_lifecycle(lifecycle: Lifecycle | AsyncLifecycle) -> Lifecycle:
+    if isinstance(lifecycle, Lifecycle):
+        return lifecycle
+
+    elif isinstance(lifecycle, AsyncLifecycle):
+        return async_to_sync_lifecycle(lifecycle)
+
+    else:
+        raise TypeError(lifecycle)
+
+
+##
+
+
+@ta.final
 @dc.dataclass(frozen=True, kw_only=True)
-class AnyCallbackLifecycle(
-    AnyLifecycle[R],
-    lang.Abstract,
-    ta.Generic[AnyLifecycleT, R],
-):
-    on_construct: AnyLifecycleCallback['AnyCallbackLifecycle[AnyLifecycleT, R]', R] | None = None
-    on_start: AnyLifecycleCallback['AnyCallbackLifecycle[AnyLifecycleT, R]', R] | None = None
-    on_stop: AnyLifecycleCallback['AnyCallbackLifecycle[AnyLifecycleT, R]', R] | None = None
-    on_destroy: AnyLifecycleCallback['AnyCallbackLifecycle[AnyLifecycleT, R]', R] | None = None
+class CallbackLifecycle(Lifecycle, lang.Final):
+    on_state: ta.Callable[[LifecycleState], None] | None = None
+    on_construct: ta.Callable[[], None] | None = None
+    on_start: ta.Callable[[], None] | None = None
+    on_stop: ta.Callable[[], None] | None = None
+    on_destroy: ta.Callable[[], None] | None = None
+
+    @ta.override
+    def lifecycle_state(self, state: LifecycleState) -> None:
+        if self.on_state is not None:
+            self.on_state(state)
 
     @ta.override
-    def lifecycle_construct(self) -> R | None:
+    def lifecycle_construct(self) -> None:
         if self.on_construct is not None:
-            return self.on_construct(self)
-        else:
-            return None
+            self.on_construct()
 
     @ta.override
-    def lifecycle_start(self) -> R | None:
+    def lifecycle_start(self) -> None:
         if self.on_start is not None:
-            return self.on_start(self)
-        else:
-            return None
+            self.on_start()
 
     @ta.override
-    def lifecycle_stop(self) -> R | None:
+    def lifecycle_stop(self) -> None:
         if self.on_stop is not None:
-            return self.on_stop(self)
-        else:
-            return None
+            self.on_stop()
 
     @ta.override
-    def lifecycle_destroy(self) -> R | None:
+    def lifecycle_destroy(self) -> None:
         if self.on_destroy is not None:
-            return self.on_destroy(self)
-        else:
-            return None
-
-
-##
-
-
-class Lifecycle(AnyLifecycle[None]):
-    pass
+            self.on_destroy()
 
 
-class CallbackLifecycle(
-    AnyCallbackLifecycle[LifecycleT, None],
-    lang.Final,
-    ta.Generic[LifecycleT],
-):
-    pass
-
+@ta.final
+@dc.dataclass(frozen=True, kw_only=True)
+class CallbackAsyncLifecycle(AsyncLifecycle, lang.Final):
+    on_state: ta.Callable[[LifecycleState], ta.Awaitable[None]] | None = None
+    on_construct: ta.Callable[[], ta.Awaitable[None]] | None = None
+    on_start: ta.Callable[[], ta.Awaitable[None]] | None = None
+    on_stop: ta.Callable[[], ta.Awaitable[None]] | None = None
+    on_destroy: ta.Callable[[], ta.Awaitable[None]] | None = None
 
-##
+    @ta.override
+    async def lifecycle_state(self, state: LifecycleState) -> None:
+        if self.on_state is not None:
+            await self.on_state(state)
 
+    @ta.override
+    async def lifecycle_construct(self) -> None:
+        if self.on_construct is not None:
+            await self.on_construct()
 
-class AsyncLifecycle(AnyLifecycle[ta.Awaitable[None]]):
-    pass
+    @ta.override
+    async def lifecycle_start(self) -> None:
+        if self.on_start is not None:
+            await self.on_start()
 
+    @ta.override
+    async def lifecycle_stop(self) -> None:
+        if self.on_stop is not None:
+            await self.on_stop()
 
-class CallbackAsyncLifecycle(
-    AnyCallbackLifecycle[LifecycleT, ta.Awaitable[None]],
-    lang.Final,
-    ta.Generic[LifecycleT],
-):
-    pass
+    @ta.override
+    async def lifecycle_destroy(self) -> None:
+        if self.on_destroy is not None:
+            await self.on_destroy()

omlish/lifecycles/contextmanagers.py

@@ -1,21 +1,33 @@
+import contextlib
 import types
 import typing as ta
 
+from .. import check
 from .. import dataclasses as dc
 from .. import lang
+from .base import AsyncLifecycle
 from .base import Lifecycle
+from .controller import AsyncLifecycleController
 from .controller import LifecycleController
 from .states import LifecycleState
 from .states import LifecycleStates
+from .unwrap import unwrap_async_lifecycle
+from .unwrap import unwrap_lifecycle
 
 
-LifecycleT = ta.TypeVar('LifecycleT', bound='Lifecycle')
+T = ta.TypeVar('T')
+
 ContextManagerT = ta.TypeVar('ContextManagerT', bound=ta.ContextManager)
+AsyncContextManagerT = ta.TypeVar('AsyncContextManagerT', bound=ta.AsyncContextManager)
+
+LifecycleT = ta.TypeVar('LifecycleT', bound=Lifecycle)
+AsyncLifecycleT = ta.TypeVar('AsyncLifecycleT', bound=AsyncLifecycle)
 
 
 ##
 
 
+@ta.final
 @dc.dataclass(frozen=True)
 class ContextManagerLifecycle(Lifecycle, lang.Final, ta.Generic[ContextManagerT]):
     cm: ContextManagerT
@@ -29,7 +41,25 @@ class ContextManagerLifecycle(Lifecycle, lang.Final, ta.Generic[ContextManagerT]
         self.cm.__exit__(None, None, None)
 
 
-class LifecycleContextManager(ta.Generic[LifecycleT]):
+@ta.final
+@dc.dataclass(frozen=True)
+class AsyncContextManagerLifecycle(AsyncLifecycle, lang.Final, ta.Generic[AsyncContextManagerT]):
+    cm: AsyncContextManagerT
+
+    @ta.override
+    async def lifecycle_start(self) -> None:
+        await self.cm.__aenter__()
+
+    @ta.override
+    async def lifecycle_stop(self) -> None:
+        await self.cm.__aexit__(None, None, None)
+
+
+##
+
+
+@ta.final
+class LifecycleContextManager(lang.Final, ta.Generic[LifecycleT]):
     def __init__(self, lifecycle: LifecycleT) -> None:
         super().__init__()
 
@@ -38,6 +68,8 @@ class LifecycleContextManager(ta.Generic[LifecycleT]):
 
     __repr__ = lang.attr_ops(lambda o: (o.lifecycle, o.state)).repr
 
+    #
+
     @property
     def lifecycle(self) -> LifecycleT:
         return self._lifecycle
@@ -50,14 +82,16 @@ class LifecycleContextManager(ta.Generic[LifecycleT]):
     def state(self) -> LifecycleState:
         return self._controller.state
 
-    def __enter__(self) -> ta.Self:
+    #
+
+    def __enter__(self) -> LifecycleT:
         try:
             self._controller.lifecycle_construct()
             self._controller.lifecycle_start()
         except Exception:
             self._controller.lifecycle_destroy()
             raise
-        return self
+        return self._lifecycle
 
     def __exit__(
             self,
@@ -74,3 +108,78 @@ class LifecycleContextManager(ta.Generic[LifecycleT]):
         else:
             self._controller.lifecycle_destroy()
         return None
+
+
+@ta.final
+class AsyncLifecycleContextManager(lang.Final, ta.Generic[AsyncLifecycleT]):
+    def __init__(self, lifecycle: AsyncLifecycleT) -> None:
+        super().__init__()
+
+        self._lifecycle = lifecycle
+        self._controller = lifecycle if isinstance(lifecycle, AsyncLifecycleController) else AsyncLifecycleController(lifecycle)  # noqa
+
+    __repr__ = lang.attr_ops(lambda o: (o.lifecycle, o.state)).repr
+
+    #
+
+    @property
+    def lifecycle(self) -> AsyncLifecycleT:
+        return self._lifecycle
+
+    @property
+    def controller(self) -> AsyncLifecycleController:
+        return self._controller
+
+    @property
+    def state(self) -> LifecycleState:
+        return self._controller.state
+
+    #
+
+    async def __aenter__(self) -> AsyncLifecycleT:
+        try:
+            await self._controller.lifecycle_construct()
+            await self._controller.lifecycle_start()
+        except Exception:
+            await self._controller.lifecycle_destroy()
+            raise
+        return self._lifecycle
+
+    async def __aexit__(
+            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:
+                await self._controller.lifecycle_stop()
+        except Exception:
+            await self._controller.lifecycle_destroy()
+            raise
+        else:
+            await self._controller.lifecycle_destroy()
+        return None
+
+
+##
+
+
+def lifecycle_context_manage(obj: T) -> ta.ContextManager[T]:
+    @contextlib.contextmanager
+    def inner():
+        lc = check.not_none(unwrap_lifecycle(obj))
+        with LifecycleContextManager(lc):
+            yield obj
+
+    return inner()
+
+
+def async_lifecycle_context_manage(obj: T) -> ta.AsyncContextManager[T]:
+    @contextlib.asynccontextmanager
+    async def inner():
+        lc = check.not_none(unwrap_async_lifecycle(obj))
+        async with AsyncLifecycleContextManager(lc):
+            yield obj
+
+    return inner()