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

omlish/lifecycles/manager.py

@@ -4,160 +4,285 @@ from .. import check
 from .. import collections as col
 from .. import dataclasses as dc
 from .. import lang
-from .abstract import AbstractLifecycle
+from .base import AnyLifecycle
+from .base import AsyncLifecycle
 from .base import Lifecycle
+from .base import as_async_lifecycle
+from .controller import AnyLifecycleController
+from .controller import AsyncLifecycleController
 from .controller import LifecycleController
+from .managed import AsyncLifecycleManaged
+from .managed import LifecycleManaged
 from .states import LifecycleState
 from .states import LifecycleStateError
 from .states import LifecycleStates
 
 
+LifecycleControllerT = ta.TypeVar('LifecycleControllerT', bound=AnyLifecycleController)
+
+
 ##
 
 
-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)
+@dc.dataclass(frozen=True, eq=False)
+class LifecycleManagerEntry(lang.Final, ta.Generic[LifecycleControllerT]):
+    controller: LifecycleControllerT
+
+    dependencies: ta.MutableSet['LifecycleManagerEntry'] = dc.field(default_factory=set)
+    dependents: ta.MutableSet['LifecycleManagerEntry'] = dc.field(default_factory=set)
+
 
+#
+
+
+@ta.final
+class _InnerLifecycleManager(AsyncLifecycleManaged, lang.Final):
     def __init__(
             self,
-            *,
-            lock: lang.DefaultLockable = None,
+            get_state: ta.Callable[[], LifecycleState],
     ) -> 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)
+        self._get_state = get_state
 
-    @property
-    def controller(self) -> LifecycleController:
-        return self._controller
+        self._entries_by_lifecycle: ta.MutableMapping[AnyLifecycle, LifecycleManagerEntry] = col.IdentityKeyDict()
 
-    @property
-    def state(self) -> LifecycleState:
-        return self._controller.state
+    #
 
-    @staticmethod
-    def _get_controller(lifecycle: Lifecycle) -> LifecycleController:
-        if isinstance(lifecycle, LifecycleController):
+    def _get_or_make_controller(self, lifecycle: AnyLifecycle) -> AnyLifecycleController:
+        if isinstance(lifecycle, (LifecycleController, AsyncLifecycleController)):
             return lifecycle
-        # elif isinstance(lifecycle, AbstractLifecycle):
-        #     return lifecycle.lifecycle_controller
+
         elif isinstance(lifecycle, Lifecycle):
             return LifecycleController(lifecycle)
+
+        elif isinstance(lifecycle, AsyncLifecycle):
+            return AsyncLifecycleController(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)
+    def _add_internal(self, lifecycle: AnyLifecycle, dependencies: ta.Iterable[AnyLifecycle]) -> LifecycleManagerEntry:
+        check.state(self._get_state() < LifecycleStates.STOPPING and not self._get_state().is_failed)
 
-        check.isinstance(lifecycle, Lifecycle)
+        check.isinstance(lifecycle, (Lifecycle, AsyncLifecycle))
         try:
             entry = self._entries_by_lifecycle[lifecycle]
         except KeyError:
-            controller = self._get_controller(lifecycle)
-            entry = self._entries_by_lifecycle[lifecycle] = LifecycleManager.Entry(controller)
+            controller = self._get_or_make_controller(lifecycle)
+            entry = self._entries_by_lifecycle[lifecycle] = LifecycleManagerEntry(controller)
 
         for dep in dependencies:
-            check.isinstance(dep, Lifecycle)
+            check.isinstance(dep, (Lifecycle, AsyncLifecycle))
             dep_entry = self._add_internal(dep, [])
             entry.dependencies.add(dep_entry)
             dep_entry.dependents.add(entry)
 
         return entry
 
-    def add(
+    async 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
+            lifecycle: AnyLifecycle,
+            dependencies: ta.Iterable[AnyLifecycle] = (),
+    ) -> LifecycleManagerEntry:
+        check.state(self._get_state() < LifecycleStates.STOPPING and not self._get_state().is_failed)
+
+        entry = self._add_internal(lifecycle, dependencies)
+
+        if self._get_state() >= LifecycleStates.CONSTRUCTING:
+            async def rec(e):
+                if e.controller.state < LifecycleStates.CONSTRUCTED:
+                    for dep in e.dependencies:
+                        await rec(dep)
+
+                    await as_async_lifecycle(e.controller).lifecycle_construct()
+
+            await rec(entry)
+
+        if self._get_state() >= LifecycleStates.STARTING:
+            async def rec(e):
+                if e.controller.state < LifecycleStates.STARTED:
+                    for dep in e.dependencies:
+                        await rec(dep)
+
+                    await as_async_lifecycle(e.controller).lifecycle_start()
+
+            await rec(entry)
+
+        return entry
 
     ##
 
     @ta.override
-    def _lifecycle_construct(self) -> None:
-        def rec(entry: LifecycleManager.Entry) -> None:
-            for dep in entry.dependencies:
-                rec(dep)
+    async def _lifecycle_construct(self) -> None:
+        async def rec(e: LifecycleManagerEntry) -> None:
+            for dep in e.dependencies:
+                await rec(dep)
 
-            if entry.controller.state.is_failed:
-                raise LifecycleStateError(entry.controller)
+            if e.controller.state.is_failed:
+                raise LifecycleStateError(e.controller)
 
-            if entry.controller.state < LifecycleStates.CONSTRUCTED:
-                entry.controller.lifecycle_construct()
+            if e.controller.state < LifecycleStates.CONSTRUCTED:
+                await as_async_lifecycle(e.controller).lifecycle_construct()
 
         for entry in self._entries_by_lifecycle.values():
-            rec(entry)
+            await rec(entry)
 
     @ta.override
-    def _lifecycle_start(self) -> None:
-        def rec(entry: LifecycleManager.Entry) -> None:
-            for dep in entry.dependencies:
-                rec(dep)
+    async def _lifecycle_start(self) -> None:
+        async def rec(e: LifecycleManagerEntry) -> None:
+            for dep in e.dependencies:
+                await rec(dep)
 
-            if entry.controller.state.is_failed:
-                raise LifecycleStateError(entry.controller)
+            if e.controller.state.is_failed:
+                raise LifecycleStateError(e.controller)
 
-            if entry.controller.state < LifecycleStates.CONSTRUCTED:
-                entry.controller.lifecycle_construct()
+            if e.controller.state < LifecycleStates.CONSTRUCTED:
+                await as_async_lifecycle(e.controller).lifecycle_construct()
 
-            if entry.controller.state < LifecycleStates.STARTED:
-                entry.controller.lifecycle_start()
+            if e.controller.state < LifecycleStates.STARTED:
+                await as_async_lifecycle(e.controller).lifecycle_start()
 
         for entry in self._entries_by_lifecycle.values():
-            rec(entry)
+            await rec(entry)
 
     @ta.override
-    def _lifecycle_stop(self) -> None:
-        def rec(entry: LifecycleManager.Entry) -> None:
-            for dep in entry.dependents:
-                rec(dep)
+    async def _lifecycle_stop(self) -> None:
+        async def rec(e: LifecycleManagerEntry) -> None:
+            for dep in e.dependents:
+                await rec(dep)
 
-            if entry.controller.state.is_failed:
-                raise LifecycleStateError(entry.controller)
+            if e.controller.state.is_failed:
+                raise LifecycleStateError(e.controller)
 
-            if entry.controller.state is LifecycleStates.STARTED:
-                entry.controller.lifecycle_stop()
+            if e.controller.state is LifecycleStates.STARTED:
+                await as_async_lifecycle(e.controller).lifecycle_stop()
 
         for entry in self._entries_by_lifecycle.values():
-            rec(entry)
+            await rec(entry)
 
     @ta.override
-    def _lifecycle_destroy(self) -> None:
-        def rec(entry: LifecycleManager.Entry) -> None:
-            for dep in entry.dependents:
-                rec(dep)
+    async def _lifecycle_destroy(self) -> None:
+        async def rec(e: LifecycleManagerEntry) -> None:
+            for dep in e.dependents:
+                await rec(dep)
 
-            if entry.controller.state < LifecycleStates.DESTROYED:
-                entry.controller.lifecycle_destroy()
+            if e.controller.state < LifecycleStates.DESTROYED:
+                await as_async_lifecycle(e.controller).lifecycle_destroy()
 
         for entry in self._entries_by_lifecycle.values():
-            rec(entry)
+            await rec(entry)
+
+
+##
+
+
+class LifecycleManager(LifecycleManaged, lang.Final):
+    def __init__(
+            self,
+            *,
+            lock: lang.DefaultLockable = None,
+    ) -> None:
+        super().__init__()
+
+        self._lock = lang.default_lock(lock, None)
+
+        self._inner = _InnerLifecycleManager(lambda: self._inner_controller.state)
+
+        self._inner_controller = AsyncLifecycleController(
+            self._inner._lifecycle,  # noqa
+            lock=lambda: lang.SyncToAsyncContextManager(self._lock()),
+        )
+
+    #
+
+    @property
+    def state(self) -> LifecycleState:
+        return self._inner_controller.state
+
+    #
+
+    def add(
+            self,
+            lifecycle: Lifecycle,
+            dependencies: ta.Iterable[Lifecycle] = (),
+    ) -> LifecycleManagerEntry[LifecycleController]:
+        return lang.sync_await(self._inner.add(
+            check.isinstance(lifecycle, Lifecycle),
+            [check.isinstance(d, Lifecycle) for d in dependencies],
+        ))
+
+    #
+
+    @ta.override
+    def _lifecycle_construct(self) -> None:
+        return lang.sync_await(self._inner_controller.lifecycle_construct())
+
+    @ta.override
+    def _lifecycle_start(self) -> None:
+        return lang.sync_await(self._inner_controller.lifecycle_start())
+
+    @ta.override
+    def _lifecycle_stop(self) -> None:
+        return lang.sync_await(self._inner_controller.lifecycle_stop())
+
+    @ta.override
+    def _lifecycle_destroy(self) -> None:
+        return lang.sync_await(self._inner_controller.lifecycle_destroy())
+
+
+#
+
+
+class AsyncLifecycleManager(AsyncLifecycleManaged, lang.Final):
+    def __init__(
+            self,
+            *,
+            lock: lang.DefaultAsyncLockable = None,
+    ) -> None:
+        super().__init__()
+
+        self._lock = lang.default_async_lock(lock, None)
+
+        self._inner = _InnerLifecycleManager(lambda: self._inner_controller.state)
+
+        self._inner_controller = AsyncLifecycleController(
+            self._inner._lifecycle,  # noqa
+            lock=self._lock,
+        )
+
+    #
+
+    @property
+    def state(self) -> LifecycleState:
+        return self._inner_controller.state
+
+    #
+
+    async def add(
+            self,
+            lifecycle: AnyLifecycle,
+            dependencies: ta.Iterable[AnyLifecycle] = (),
+    ) -> LifecycleManagerEntry[AnyLifecycleController]:
+        return await self._inner.add(
+            lifecycle,
+            dependencies,
+        )
+
+    #
+
+    @ta.override
+    async def _lifecycle_construct(self) -> None:
+        return await self._inner_controller.lifecycle_construct()
+
+    @ta.override
+    async def _lifecycle_start(self) -> None:
+        return await self._inner_controller.lifecycle_start()
+
+    @ta.override
+    async def _lifecycle_stop(self) -> None:
+        return await self._inner_controller.lifecycle_stop()
+
+    @ta.override
+    async def _lifecycle_destroy(self) -> None:
+        return await self._inner_controller.lifecycle_destroy()

omlish/lifecycles/states.py

@@ -1,4 +1,5 @@
 import functools
+import typing as ta
 
 from .. import check
 from .. import dataclasses as dc
@@ -12,6 +13,7 @@ class LifecycleStateError(Exception):
     pass
 
 
+@ta.final
 @dc.dataclass(frozen=True, eq=False)
 @functools.total_ordering
 class LifecycleState(lang.Final):

omlish/lifecycles/transitions.py

@@ -1,3 +1,5 @@
+import typing as ta
+
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
@@ -8,6 +10,7 @@ from .states import LifecycleStates
 ##
 
 
+@ta.final
 @dc.dataclass(frozen=True)
 class LifecycleTransition(lang.Final):
     old: frozenset[LifecycleState]

omlish/lifecycles/unwrap.py

@@ -0,0 +1,57 @@
+import functools
+import typing as ta
+
+from .base import AsyncLifecycle
+from .base import Lifecycle
+from .managed import AsyncLifecycleManaged
+from .managed import LifecycleManaged
+
+
+##
+
+
+@functools.singledispatch
+def unwrap_lifecycle(obj: ta.Any) -> Lifecycle | None:
+    return None
+
+
+@unwrap_lifecycle.register
+def _(obj: Lifecycle) -> Lifecycle:
+    return obj
+
+
+@unwrap_lifecycle.register
+def _(obj: LifecycleManaged) -> Lifecycle:
+    return obj._lifecycle  # noqa
+
+
+#
+
+
+@functools.singledispatch
+def unwrap_async_lifecycle(obj: ta.Any) -> AsyncLifecycle | None:
+    return None
+
+
+@unwrap_async_lifecycle.register
+def _(obj: AsyncLifecycle) -> AsyncLifecycle:
+    return obj
+
+
+@unwrap_async_lifecycle.register
+def _(obj: AsyncLifecycleManaged) -> AsyncLifecycle:
+    return obj._lifecycle  # noqa
+
+
+#
+
+
+def unwrap_any_lifecycle(obj: ta.Any) -> Lifecycle | AsyncLifecycle | None:
+    if (lc := unwrap_lifecycle(obj)) is not None:
+        return lc
+
+    elif (alc := unwrap_async_lifecycle(obj)) is not None:
+        return alc
+
+    else:
+        return None

omlish/lite/typing.py

@@ -63,6 +63,24 @@ class Func3(ta.Generic[A0, A1, A2, T]):
 ##
 
 
+@dc.dataclass(frozen=True)
+class CachedFunc0(ta.Generic[T]):
+    fn: ta.Callable[[], T]
+
+    def __call__(self) -> T:
+        try:
+            return object.__getattribute__(self, '_value')
+        except AttributeError:
+            pass
+
+        value = self.fn()
+        object.__setattr__(self, '_value', value)
+        return value
+
+
+##
+
+
 _TYPING_ANNOTATIONS_ATTR = '__annotate__' if sys.version_info >= (3, 14) else '__annotations__'
 
 

omlish/logs/_amalg.py

@@ -1,8 +1,8 @@
 # @omlish-lite
 # @omlish-amalg ../../omdev/scripts/lib/logs.py
 from .base import AnyLogger  # noqa
-from .standard import configure_standard_logging  # noqa
 from .std.loggers import StdLogger  # noqa
+from .std.standard import configure_standard_logging  # noqa
 
 
 ##

omlish/logs/all.py

@@ -38,6 +38,20 @@ with _lang.auto_proxy_init(globals()):
         LoggingContextLogRecord,
     )
 
+    from .std.standard import (  # noqa
+        STANDARD_LOG_FORMAT_PARTS,
+        StandardLoggingFormatter,
+
+        StandardConfiguredLoggingHandler,
+
+        configure_standard_logging,
+    )
+
+    from .asyncs import (  # noqa
+        AsyncLoggerToLogger,
+        LoggerToAsyncLogger,
+    )
+
     from .base import (  # noqa
         AnyLogger,
         Logger,
@@ -67,28 +81,28 @@ with _lang.auto_proxy_init(globals()):
         NamedLogLevel,
     )
 
+    from .lists import (  # noqa
+        AnyListLogger,
+        ListLogger,
+        AsyncLogger,
+    )
+
     from .modules import (  # noqa
         get_module_logger,
+        get_module_async_logger,
+        get_module_loggers,
     )
 
     from .protocols import (  # noqa
         LoggerLike,
     )
 
-    from .standard import (  # noqa
-        STANDARD_LOG_FORMAT_PARTS,
-        StandardLoggingFormatter,
-
-        StandardConfiguredLoggingHandler,
-
-        configure_standard_logging,
-    )
-
     from .utils import (  # noqa
+        exception_logging,
+        async_exception_logging,
+
         LogTimingContext,
         log_timing_context,
-
-        exception_logging,
     )
 
     from .warnings import (  # noqa

omlish/logs/asyncs.py

@@ -0,0 +1,73 @@
+# ruff: noqa: UP006 UP007 UP045 UP046
+# @omlish-lite
+import typing as ta
+
+from ..lite.asyncs import sync_await
+from ..lite.check import check
+from .base import AsyncLogger
+from .base import CaptureLoggingContext
+from .base import Logger
+from .base import LoggingMsgFn
+from .contexts import CaptureLoggingContextImpl
+from .infos import LoggingContextInfos
+from .levels import LogLevel
+
+
+##
+
+
+class AsyncLoggerToLogger(Logger):
+    def __init__(self, u: AsyncLogger) -> None:
+        super().__init__()
+
+        self._u = u
+
+    def get_effective_level(self) -> LogLevel:
+        return self._u.get_effective_level()
+
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
+        # Nope out early to avoid sync_await if possible - don't bother in the LoggerToAsyncLogger.
+        if not self.is_enabled_for(ctx.must_get_info(LoggingContextInfos.Level).level):
+            return
+
+        # Note: we hardcode the stack offset of sync_await (which is 2 - sync_await + sync_await.thunk). In non-lite
+        # code, lang.sync_await uses a cext if present to avoid being on the py stack, which would obviously complicate
+        # this, but this is lite code so we will always have the non-c version.
+        sync_await(
+            self._u._log(  # noqa
+                check.isinstance(ctx, CaptureLoggingContextImpl).inc_stack_offset(3),
+                msg,
+                *args,
+                **kwargs,
+            ),
+        )
+
+
+class LoggerToAsyncLogger(AsyncLogger):
+    def __init__(self, u: Logger) -> None:
+        super().__init__()
+
+        self._u = u
+
+    def get_effective_level(self) -> LogLevel:
+        return self._u.get_effective_level()
+
+    async def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
+        return self._u._log(  # noqa
+            check.isinstance(ctx, CaptureLoggingContextImpl).inc_stack_offset(),
+            msg,
+            *args,
+            **kwargs,
+        )