omlish 0.0.0.dev447__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/abstract.py

@@ -3,6 +3,9 @@ import abc
 import typing as ta
 
 
+T = ta.TypeVar('T')
+
+
 ##
 
 
@@ -14,25 +17,49 @@ def is_abstract_method(obj: ta.Any) -> bool:
     return bool(getattr(obj, _IS_ABSTRACT_METHOD_ATTR, False))
 
 
-def update_abstracts(cls, *, force=False):
+def compute_abstract_methods(cls: type) -> ta.FrozenSet[str]:
+    # ~> https://github.com/python/cpython/blob/f3476c6507381ca860eec0989f53647b13517423/Modules/_abc.c#L358
+
+    # Stage 1: direct abstract methods
+
+    abstracts = {
+        a
+        # Get items as a list to avoid mutation issues during iteration
+        for a, v in list(cls.__dict__.items())
+        if is_abstract_method(v)
+    }
+
+    # Stage 2: inherited abstract methods
+
+    for base in cls.__bases__:
+        # Get __abstractmethods__ from base if it exists
+        if (base_abstracts := getattr(base, _ABSTRACT_METHODS_ATTR, None)) is None:
+            continue
+
+        # Iterate over abstract methods in base
+        for key in base_abstracts:
+            # Check if this class has an attribute with this name
+            try:
+                value = getattr(cls, key)
+            except AttributeError:
+                # Attribute not found in this class, skip
+                continue
+
+            # Check if it's still abstract
+            if is_abstract_method(value):
+                abstracts.add(key)
+
+    return frozenset(abstracts)
+
+
+def update_abstracts(cls: ta.Type[T], *, force: bool = False) -> ta.Type[T]:
     if not force and not hasattr(cls, _ABSTRACT_METHODS_ATTR):
         # Per stdlib: We check for __abstractmethods__ here because cls might by a C implementation or a python
         # implementation (especially during testing), and we want to handle both cases.
         return cls
 
-    abstracts: ta.Set[str] = set()
-
-    for scls in cls.__bases__:
-        for name in getattr(scls, _ABSTRACT_METHODS_ATTR, ()):
-            value = getattr(cls, name, None)
-            if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
-                abstracts.add(name)
-
-    for name, value in cls.__dict__.items():
-        if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
-            abstracts.add(name)
-
-    setattr(cls, _ABSTRACT_METHODS_ATTR, frozenset(abstracts))
+    abstracts = compute_abstract_methods(cls)
+    setattr(cls, _ABSTRACT_METHODS_ATTR, abstracts)
     return cls
 
 
@@ -86,23 +113,26 @@ class Abstract:
         super().__init_subclass__(**kwargs)
 
         if not (Abstract in cls.__bases__ or abc.ABC in cls.__bases__):
-            ams = {a: cls for a, o in cls.__dict__.items() if is_abstract_method(o)}
-
-            seen = set(cls.__dict__)
-            for b in cls.__bases__:
-                ams.update({a: b for a in set(getattr(b, _ABSTRACT_METHODS_ATTR, [])) - seen})  # noqa
-                seen.update(dir(b))
+            if ams := compute_abstract_methods(cls):
+                amd = {
+                    a: mcls
+                    for mcls in cls.__mro__[::-1]
+                    for a in ams
+                    if a in mcls.__dict__
+                }
 
-            if ams:
                 raise AbstractTypeError(
                     f'Cannot subclass abstract class {cls.__name__} with abstract methods: ' +
                     ', '.join(sorted([
                         '.'.join([
-                            *([m] if (m := getattr(c, '__module__')) else []),
-                            getattr(c, '__qualname__', getattr(c, '__name__')),
+                            *([
+                                *([m] if (m := getattr(c, '__module__')) else []),
+                                getattr(c, '__qualname__', getattr(c, '__name__')),
+                            ] if c is not None else '?'),
                             a,
                         ])
-                        for a, c in ams.items()
+                        for a in ams
+                        for c in [amd.get(a)]
                     ])),
                 )
 

omlish/lite/asyncs.py

@@ -50,12 +50,12 @@ def sync_await(aw: ta.Awaitable[T]) -> T:
 
     ret = missing = object()
 
-    async def gate():
+    async def thunk():
         nonlocal ret
 
         ret = await aw
 
-    cr = gate()
+    cr = thunk()
     try:
         try:
             cr.send(None)

omlish/lite/attrops.py

@@ -6,6 +6,8 @@ TODO:
  - per-attr repr transform / filter
  - __ne__ ? cases where it still matters
  - ordering ?
+ - repr_filter: ta.Union[ta.Callable[[ta.Any], ta.Optional[str]], ta.Literal['not_none', 'truthy']]] ?
+  - unify repr/repr_fn/repr_filter
 """
 import types  # noqa
 import typing as ta

omlish/lite/contextmanagers.py

@@ -54,7 +54,7 @@ class ExitStacked:
             es.__enter__()
             try:
                 self._enter_contexts()
-            except Exception:  # noqa
+            except BaseException:  # noqa
                 es.__exit__(*sys.exc_info())
                 raise
             return self
@@ -65,7 +65,7 @@ class ExitStacked:
             return None
         try:
             self._exit_contexts()
-        except Exception:  # noqa
+        except BaseException:  # noqa
             es.__exit__(*sys.exc_info())
             raise
         return es.__exit__(exc_type, exc_val, exc_tb)
@@ -113,7 +113,7 @@ class AsyncExitStacked:
             await es.__aenter__()
             try:
                 await self._async_enter_contexts()
-            except Exception:  # noqa
+            except BaseException:  # noqa
                 await es.__aexit__(*sys.exc_info())
                 raise
             return self
@@ -124,7 +124,7 @@ class AsyncExitStacked:
             return None
         try:
             await self._async_exit_contexts()
-        except Exception:  # noqa
+        except BaseException:  # noqa
             await es.__aexit__(*sys.exc_info())
             raise
         return await es.__aexit__(exc_type, exc_val, exc_tb)