omlish 0.0.0.dev418__py3-none-any.whl → 0.0.0.dev420__py3-none-any.whl

omlish/lifecycles/controller.py

@@ -1,99 +1,95 @@
+import abc
 import typing as ta
 
 from .. import check
 from .. import defs
 from .. import lang
-from .base import Lifecycle
+from .base import AnyLifecycle  # noqa
+from .base import Lifecycle  # noqa
 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 LifecycleListener(ta.Generic[LifecycleT]):
-    def on_starting(self, obj: LifecycleT) -> None:
-        pass
+class AnyLifecycleListener(ta.Generic[AnyLifecycleT, R]):
+    def on_starting(self, obj: AnyLifecycleT) -> R | None:
+        return None
 
-    def on_started(self, obj: LifecycleT) -> None:
-        pass
+    def on_started(self, obj: AnyLifecycleT) -> R | None:
+        return None
 
-    def on_stopping(self, obj: LifecycleT) -> None:
-        pass
+    def on_stopping(self, obj: AnyLifecycleT) -> R | None:
+        return None
 
-    def on_stopped(self, obj: LifecycleT) -> None:
-        pass
+    def on_stopped(self, obj: AnyLifecycleT) -> R | None:
+        return None
 
 
-class LifecycleController(Lifecycle, ta.Generic[LifecycleT]):
+class AnyLifecycleController(AnyLifecycle[R], lang.Abstract, ta.Generic[AnyLifecycleT, R]):
     def __init__(
             self,
-            lifecycle: LifecycleT,
-            *,
-            lock: lang.DefaultLockable = None,
+            lifecycle: AnyLifecycleT,
     ) -> None:
         super().__init__()
 
-        self._lifecycle: LifecycleT = check.isinstance(lifecycle, Lifecycle)  # type: ignore
-        self._lock = lang.default_lock(lock, False)
+        self._lifecycle: AnyLifecycleT = check.isinstance(lifecycle, AnyLifecycle)  # type: ignore
 
         self._state = LifecycleStates.NEW
-        self._listeners: list[LifecycleListener[LifecycleT]] = []
+        self._listeners: list[AnyLifecycleListener[AnyLifecycleT, R]] = []
 
     defs.repr('lifecycle', 'state')
 
     @property
-    def lifecycle(self) -> LifecycleT:
+    def lifecycle(self) -> AnyLifecycleT:
         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))
+    def add_listener(self, listener: AnyLifecycleListener[AnyLifecycleT, R]) -> ta.Self:
+        self._listeners.append(check.isinstance(listener, AnyLifecycleListener))
         return self
 
+    @abc.abstractmethod
     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)
+            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
 
     ##
 
     @ta.override
-    def lifecycle_construct(self) -> None:
-        self._advance(
+    def lifecycle_construct(self) -> R | None:
+        return self._advance(
             LifecycleTransitions.CONSTRUCT,
             self._lifecycle.lifecycle_construct,
         )
 
     @ta.override
-    def lifecycle_start(self) -> None:
-        self._advance(
+    def lifecycle_start(self) -> R | None:
+        return self._advance(
             LifecycleTransitions.START,
             self._lifecycle.lifecycle_start,
             lambda l: l.on_starting,
@@ -101,8 +97,8 @@ class LifecycleController(Lifecycle, ta.Generic[LifecycleT]):
         )
 
     @ta.override
-    def lifecycle_stop(self) -> None:
-        self._advance(
+    def lifecycle_stop(self) -> R | None:
+        return self._advance(
             LifecycleTransitions.STOP,
             self._lifecycle.lifecycle_stop,
             lambda l: l.on_stopping,
@@ -110,8 +106,59 @@ class LifecycleController(Lifecycle, ta.Generic[LifecycleT]):
         )
 
     @ta.override
-    def lifecycle_destroy(self) -> None:
-        self._advance(
+    def lifecycle_destroy(self) -> R | None:
+        return self._advance(
             LifecycleTransitions.DESTROY,
             self._lifecycle.lifecycle_destroy,
         )
+
+
+##
+
+
+LifecycleListener: ta.TypeAlias = AnyLifecycleListener[LifecycleT, None]
+
+
+class LifecycleController(
+    AnyLifecycleController[LifecycleT, None],
+    Lifecycle,
+    ta.Generic[LifecycleT],
+):
+    def __init__(
+            self,
+            lifecycle: LifecycleT,
+            *,
+            lock: lang.DefaultLockable = None,
+    ) -> None:
+        super().__init__(lifecycle)
+
+        self._lock = lang.default_lock(lock, False)
+
+    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,
+    ) -> 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)

omlish/logs/all.py

@@ -1,50 +1,57 @@
-from .callers import (  # noqa
-    LoggingCaller,
-)
+# rufF: noqa: I001
+from .. import lang as _lang
 
-from .color import (  # noqa
-    ColorLogFormatter,
-)
 
-from .filters import (  # noqa
-    TidLogFilter,
-)
+with _lang.auto_proxy_init(globals()):
+    ##
 
-from .handlers import (  # noqa
-    ListHandler,
-)
+    from .callers import (  # noqa
+        LoggingCaller,
+    )
 
-from .json import (  # noqa
-    JsonLogFormatter,
-)
+    from .color import (  # noqa
+        ColorLogFormatter,
+    )
 
-from .noisy import (  # noqa
-    silence_noisy_loggers,
-)
+    from .filters import (  # noqa
+        TidLogFilter,
+    )
 
-from .protocol import (  # noqa
-    LogLevel,
+    from .handlers import (  # noqa
+        ListHandler,
+    )
 
-    Logging,
-    NopLogging,
-    AbstractLogging,
-    StdlibLogging,
-)
+    from .json import (  # noqa
+        JsonLogFormatter,
+    )
 
-from .proxy import (  # noqa
-    ProxyLogFilterer,
-    ProxyLogHandler,
-)
+    from .noisy import (  # noqa
+        silence_noisy_loggers,
+    )
 
-from .standard import (  # noqa
-    STANDARD_LOG_FORMAT_PARTS,
-    StandardLogFormatter,
+    from .protocol import (  # noqa
+        LogLevel,
 
-    StandardConfiguredLogHandler,
+        Logging,
+        NopLogging,
+        AbstractLogging,
+        StdlibLogging,
+    )
 
-    configure_standard_logging,
-)
+    from .proxy import (  # noqa
+        ProxyLogFilterer,
+        ProxyLogHandler,
+    )
 
-from .utils import (  # noqa
-    error_logging,
-)
+    from .standard import (  # noqa
+        STANDARD_LOG_FORMAT_PARTS,
+        StandardLogFormatter,
+
+        StandardConfiguredLogHandler,
+
+        configure_standard_logging,
+    )
+
+    from .utils import (  # noqa
+        error_logging,
+    )

omlish/marshal/base/registries.py

@@ -53,6 +53,7 @@ class Registry(ta.Generic[RegistryItemT]):
         self._dct: dict[ta.Any, _KeyRegistryItems[RegistryItemT]] = {}
         self._id_dct: ta.MutableMapping[ta.Any, _KeyRegistryItems[RegistryItemT]] = col.IdentityKeyDict()
 
+        self._version = 0
         self._sealed = False
 
     #
@@ -84,6 +85,9 @@ class Registry(ta.Generic[RegistryItemT]):
             *items: RegistryItemT,
             identity: bool = False,
     ) -> ta.Self:
+        if not items:
+            return self
+
         with self._lock:
             if self._sealed:
                 raise RegistrySealedError(self)
@@ -93,6 +97,8 @@ class Registry(ta.Generic[RegistryItemT]):
                 sr = dct[key] = _KeyRegistryItems(key)
             sr.add(*items)
 
+            self._version += 1
+
         return self
 
     #

omlish/math/__init__.py

@@ -1,83 +1,89 @@
-from .bits import (  # noqa
-    get_bit,
-    get_bits,
-    set_bit,
-    set_bits,
-)
-
-from .c import (  # noqa
-    cdiv,
-    cmod,
-)
-
-from .fixed import (  # noqa
-    CheckedFixedWidthIntError,
-    OverflowFixedWidthIntError,
-    UnderflowFixedWidthIntError,
-
-    FixedWidthInt,
-
-    SignedInt,
-    UnsignedInt,
-
-    CheckedInt,
-    ClampedInt,
-
-    AnyInt8,
-    AnyInt16,
-    AnyInt32,
-    AnyInt64,
-    AnyInt128,
-
-    CheckedInt8,
-    CheckedInt16,
-    CheckedInt32,
-    CheckedInt64,
-    CheckedInt128,
-
-    CheckedUint8,
-    CheckedUint16,
-    CheckedUint32,
-    CheckedUint64,
-    CheckedUint128,
-
-    ClampedInt8,
-    ClampedInt16,
-    ClampedInt32,
-    ClampedInt64,
-    ClampedInt128,
-
-    ClampedUint8,
-    ClampedUint16,
-    ClampedUint32,
-    ClampedUint64,
-    ClampedUint128,
-
-    WrappedInt8,
-    WrappedInt16,
-    WrappedInt32,
-    WrappedInt64,
-    WrappedInt128,
-
-    WrappedUint8,
-    WrappedUint16,
-    WrappedUint32,
-    WrappedUint64,
-    WrappedUint128,
-)
-
-from .floats import (  # noqa
-    isclose,
-    float_to_bytes,
-    bytes_to_float,
-)
-
-from .stats import (  # noqa
-    get_quantile,
-
-    Stats,
-)
-
-from .histogram import (  # noqa
-    SamplingHistogram,
-)
+from .. import lang as _lang
+
+
+with _lang.auto_proxy_init(globals()):
+    ##
+
+    from .bits import (  # noqa
+        get_bit,
+        get_bits,
+        set_bit,
+        set_bits,
+    )
+
+    from .c import (  # noqa
+        cdiv,
+        cmod,
+    )
+
+    from .fixed import (  # noqa
+        CheckedFixedWidthIntError,
+        OverflowFixedWidthIntError,
+        UnderflowFixedWidthIntError,
+
+        FixedWidthInt,
+
+        SignedInt,
+        UnsignedInt,
+
+        CheckedInt,
+        ClampedInt,
+
+        AnyInt8,
+        AnyInt16,
+        AnyInt32,
+        AnyInt64,
+        AnyInt128,
+
+        CheckedInt8,
+        CheckedInt16,
+        CheckedInt32,
+        CheckedInt64,
+        CheckedInt128,
+
+        CheckedUint8,
+        CheckedUint16,
+        CheckedUint32,
+        CheckedUint64,
+        CheckedUint128,
+
+        ClampedInt8,
+        ClampedInt16,
+        ClampedInt32,
+        ClampedInt64,
+        ClampedInt128,
+
+        ClampedUint8,
+        ClampedUint16,
+        ClampedUint32,
+        ClampedUint64,
+        ClampedUint128,
+
+        WrappedInt8,
+        WrappedInt16,
+        WrappedInt32,
+        WrappedInt64,
+        WrappedInt128,
+
+        WrappedUint8,
+        WrappedUint16,
+        WrappedUint32,
+        WrappedUint64,
+        WrappedUint128,
+    )
+
+    from .floats import (  # noqa
+        isclose,
+        float_to_bytes,
+        bytes_to_float,
+    )
+
+    from .stats import (  # noqa
+        get_quantile,
+
+        Stats,
+    )
+
+    from .histogram import (  # noqa
+        SamplingHistogram,
+    )

omlish/subprocesses/{maysyncs.py → maysync.py}

@@ -4,7 +4,7 @@ import abc
 import sys
 import typing as ta
 
-from ..lite.maysyncs import make_maysync
+from ..lite.maysync import make_maysync
 from .asyncs import AbstractAsyncSubprocesses
 from .run import SubprocessRun
 from .run import SubprocessRunOutput

{omlish-0.0.0.dev418.dist-info → omlish-0.0.0.dev420.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev418
+Version: 0.0.0.dev420
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -132,7 +132,7 @@ dependencies of any kind**.
     of the presence or absence of an object, as in [many](https://en.cppreference.com/w/cpp/utility/optional)
     [other](https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html)
     [languages](https://doc.rust-lang.org/std/option/).
-  - **[maysyncs](https://github.com/wrmsr/omlish/blob/master/omlish/lite/maysyncs.py)** - A lightweight means of sharing
+  - **[maysync](https://github.com/wrmsr/omlish/blob/master/omlish/lite/maysync.py)** - A lightweight means of sharing
     code between sync and async contexts, eliminating the need for maintaining sync and async versions of functions.
 
 - **[bootstrap](https://github.com/wrmsr/omlish/blob/master/omlish/bootstrap)** - A centralized, configurable,