omlish 0.0.0.dev417__py3-none-any.whl → 0.0.0.dev419__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/marshal/__init__.py

@@ -16,7 +16,19 @@ See:
  - https://github.com/Fatal1ty/mashumaro
  - https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/serializers.md#custom-serializers
 """
-from .. import lang as _lang
+from .. import dataclasses as _dc  # noqa
+
+
+_dc.init_package(
+    globals(),
+    codegen=True,
+)
+
+
+##
+
+
+from .. import lang as _lang  # noqa
 
 
 with _lang.auto_proxy_init(globals()) as _api_cap:
@@ -39,6 +51,14 @@ with _lang.auto_proxy_init(globals()) as _api_cap:
         UnhandledTypeError,
     )
 
+    from .base.funcs import (  # noqa
+        FuncMarshaler,
+        FuncUnmarshaler,
+
+        FuncMarshalerFactory,
+        FuncUnmarshalerFactory,
+    )
+
     from .base.options import (  # noqa
         Option,
     )
@@ -63,8 +83,7 @@ with _lang.auto_proxy_init(globals()) as _api_cap:
         MarshalerFactory,
         UnmarshalerFactory,
 
-        MarshalerFactory_,
-        UnmarshalerFactory_,
+        Marshaling,
     )
 
     from .base.values import (  # noqa
@@ -115,11 +134,6 @@ with _lang.auto_proxy_init(globals()) as _api_cap:
         TypeCacheUnmarshalerFactory,
     )
 
-    from .factories.func import (  # noqa
-        FuncMarshaler,
-        FuncUnmarshaler,
-    )
-
     from .factories.recursive import (  # noqa
         RecursiveMarshalerFactory,
         RecursiveUnmarshalerFactory,
@@ -241,11 +255,3 @@ with _lang.auto_proxy_init(globals()) as _api_cap:
 
         install_standard_factories,
     )
-
-
-##
-
-
-from .. import lang as _lang
-
-_lang.trigger_conditional_imports(__package__)

omlish/marshal/base/funcs.py

@@ -0,0 +1,57 @@
+import dataclasses as dc
+import typing as ta
+
+from ... import lang
+from ... import reflect as rfl
+from ...funcs import match as mfs
+from .contexts import MarshalContext
+from .contexts import UnmarshalContext
+from .types import Marshaler
+from .types import MarshalerFactory
+from .types import MarshalerMaker
+from .types import Unmarshaler
+from .types import UnmarshalerFactory
+from .types import UnmarshalerMaker
+from .values import Value
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class FuncMarshaler(Marshaler, lang.Final):
+    fn: ta.Callable[[MarshalContext, ta.Any], Value]
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        return self.fn(ctx, o)
+
+
+@dc.dataclass(frozen=True)
+class FuncUnmarshaler(Unmarshaler, lang.Final):
+    fn: ta.Callable[[UnmarshalContext, Value], ta.Any]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        return self.fn(ctx, v)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class FuncMarshalerFactory(MarshalerFactory):  # noqa
+    guard: ta.Callable[[MarshalContext, rfl.Type], bool]
+    fn: ta.Callable[[MarshalContext, rfl.Type], Marshaler]
+
+    @lang.cached_property
+    def make_marshaler(self) -> MarshalerMaker:
+        return mfs.simple(self.guard, self.fn)
+
+
+@dc.dataclass(frozen=True)
+class FuncUnmarshalerFactory(UnmarshalerFactory):  # noqa
+    guard: ta.Callable[[UnmarshalContext, rfl.Type], bool]
+    fn: ta.Callable[[UnmarshalContext, rfl.Type], Unmarshaler]
+
+    @lang.cached_property
+    def make_unmarshaler(self) -> UnmarshalerMaker:
+        return mfs.simple(self.guard, self.fn)

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/marshal/base/types.py

@@ -1,5 +1,4 @@
 import abc
-import dataclasses as dc
 import typing as ta
 
 from ... import lang
@@ -53,27 +52,6 @@ class UnmarshalerFactory(lang.Abstract):
 ##
 
 
-@dc.dataclass(frozen=True)
-class MarshalerFactory_(MarshalerFactory):  # noqa
-    fn: MarshalerMaker
-
-    @property
-    def make_marshaler(self) -> MarshalerMaker:
-        return self.fn
-
-
-@dc.dataclass(frozen=True)
-class UnmarshalerFactory_(UnmarshalerFactory):  # noqa
-    fn: UnmarshalerMaker
-
-    @property
-    def make_unmarshaler(self) -> UnmarshalerMaker:
-        return self.fn
-
-
-##
-
-
 class Marshaling(lang.Abstract):
     @abc.abstractmethod
     def config_registry(self) -> ConfigRegistry:

omlish/marshal/objects/dataclasses.py

@@ -1,5 +1,6 @@
 """
 TODO:
+ - clean up yeesh
  - tangled with objects - Field/ObjectMetadata defined over there but unused
 """
 import typing as ta
@@ -158,11 +159,17 @@ def get_dataclass_field_infos(
     return FieldInfos(ret)
 
 
-def _make_field_obj(ctx, ty, obj, fac):
+def _make_field_obj(
+        ctx,
+        ty,
+        obj,
+        fac,
+        fac_attr,
+):
     if obj is not None:
         return obj
     if fac is not None:
-        return fac(ctx, ty)
+        return getattr(fac, fac_attr)(ctx, ty)
     return ctx.make(ty)
 
 
@@ -210,7 +217,16 @@ class DataclassMarshalerFactory(AbstractDataclassFactory, SimpleMarshalerFactory
         fis = self._get_field_infos(ty, ctx.options)
 
         fields = [
-            (fi, _make_field_obj(ctx, fi.type, fi.metadata.marshaler, fi.metadata.marshaler_factory))
+            (
+                fi,
+                _make_field_obj(
+                    ctx,
+                    fi.type,
+                    fi.metadata.marshaler,
+                    fi.metadata.marshaler_factory,
+                    'make_marshaler',
+                ),
+            )
             for fi in fis
             if fi.name not in dc_md.specials.set
         ]
@@ -262,7 +278,16 @@ class DataclassUnmarshalerFactory(AbstractDataclassFactory, SimpleUnmarshalerFac
                     ret.extend(e_ns)
 
             else:
-                tup = (fi, _make_field_obj(ctx, fi.type, fi.metadata.unmarshaler, fi.metadata.unmarshaler_factory))
+                tup = (
+                    fi,
+                    _make_field_obj(
+                        ctx,
+                        fi.type,
+                        fi.metadata.unmarshaler,
+                        fi.metadata.unmarshaler_factory,
+                        'make_unmarshaler',
+                    ),
+                )
 
                 for pfx in prefixes:
                     for un in fi.unmarshal_names:

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/text/templating.py

@@ -9,16 +9,18 @@ import string
 import typing as ta
 
 from .. import lang
-from .minja import MinjaTemplate
-from .minja import MinjaTemplateParam
-from .minja import compile_minja_template
 
 
 if ta.TYPE_CHECKING:
     import jinja2
+
+    from . import minja
+
 else:
     jinja2 = lang.proxy_import('jinja2')
 
+    minja = lang.proxy_import('.minja', __package__)
+
 
 ##
 
@@ -97,7 +99,7 @@ pep292_templater = Pep292Templater.from_string
 
 @dc.dataclass(frozen=True)
 class MinjaTemplater(Templater):
-    tmpl: MinjaTemplate
+    tmpl: 'minja.MinjaTemplate'
 
     ENV_IDENT: ta.ClassVar[str] = 'env'
 
@@ -110,12 +112,12 @@ class MinjaTemplater(Templater):
             src: str,
             **ns: ta.Any,
     ) -> 'MinjaTemplater':
-        tmpl = compile_minja_template(
+        tmpl = minja.compile_minja_template(
             src,
             [
-                MinjaTemplateParam(cls.ENV_IDENT),
+                minja.MinjaTemplateParam(cls.ENV_IDENT),
                 *[
-                    MinjaTemplateParam.new(k, v)
+                    minja.MinjaTemplateParam.new(k, v)
                     for k, v in ns.items()
                 ],
             ],