omlish 0.0.0.dev417__py3-none-any.whl → 0.0.0.dev419__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev417'
-__revision__ = 'dad70cf0d439b40c7d3457efb0b5ca0d19ce1d99'
+__version__ = '0.0.0.dev419'
+__revision__ = 'ec06deda53ea93f16a7dc690230fe51edce49e7b'
 
 
 #

omlish/daemons/launching.py

@@ -94,7 +94,7 @@ class Launcher:
             if (pid_file := self._pid_file) is not None:
                 if not isinstance(spawner, InProcessSpawner):
                     pidfile = es.enter_context(open_inheritable_pidfile(pid_file))
-                    pidfile_manager = lang.NopContextManager(pidfile)
+                    pidfile_manager = lang.ValueContextManager(pidfile)
 
                 else:
                     check.state(not self._reparent_process)

omlish/dataclasses/impl/configs.py

@@ -20,7 +20,7 @@ DEFAULT_PACKAGE_CONFIG = PackageConfig()
 
 
 def init_package(
-        name: str,
+        init_globals: ta.MutableMapping[str, ta.Any],
         *,
         codegen: bool = False,
 ) -> None:

omlish/formats/json/backends/orjson.py

@@ -48,6 +48,7 @@ class Options:
 
     ##
 
+    @lang.cached_function
     def __int__(self) -> int:
         return (
             (oj.OPT_APPEND_NEWLINE if self.append_newline else 0) |

omlish/formats/toml/parser.py

@@ -49,8 +49,8 @@ import types
 import typing as ta
 
 
-TomlParseFloat = ta.Callable[[str], ta.Any]
-TomlKey = ta.Tuple[str, ...]
+TomlParseFloat = ta.Callable[[str], ta.Any]  # ta.TypeAlias
+TomlKey = ta.Tuple[str, ...]  # ta.TypeAlias
 TomlPos = int  # ta.TypeAlias
 
 

omlish/inject/__init__.py

@@ -1,6 +1,18 @@
 """
 ~> https://github.com/google/guice/commit/70248eafa90cd70a68b293763e53f6aec656e73c
 """
+from .. import dataclasses as _dc
+
+
+_dc.init_package(
+    globals(),
+    codegen=True,
+)
+
+
+##
+
+
 from .binder import (  # noqa
     bind,
     bind_as_fn,

omlish/lang/__init__.py

@@ -145,22 +145,42 @@ with _auto_proxy_init(
     )
 
     from .contextmanagers import (  # noqa
-        AsyncContextManager,
         ContextManaged,
-        ContextManager,
-        ContextWrapped,
-        DefaultLockable,
-        Lockable,
+        SelfContextManaged,
+        ValueContextManager,
         NOP_CONTEXT_MANAGER,
-        NopContextManager,
-        Timer,
+
+        AsyncContextManaged,
+        SelfAsyncContextManaged,
+        ValueAsyncContextManager,
+        NOP_ASYNC_CONTEXT_MANAGER,
+
+        AsyncContextManager,
+
+        ContextManager,
+
+        maybe_managing,
+        disposing,
         breakpoint_on_exception,
         context_var_setting,
+
+        as_async_context_manager,
+
+        ContextWrappable,
+        ContextWrapped,
         context_wrapped,
+
+        Lockable,
+        DefaultLockable,
         default_lock,
-        disposing,
+
+        AsyncLockable,
+        DefaultAsyncLockable,
+        default_async_lock,
+
+        Timer,
+
         double_check_setdefault,
-        maybe_managing,
     )
 
     from .datetimes import (  # noqa
@@ -297,7 +317,7 @@ with _auto_proxy_init(
         just,
     )
 
-    from .maysyncs import (  # noqa
+    from .maysync import (  # noqa
         make_maysync_fn,
         make_maysync_generator_fn,
         make_maysync,
@@ -439,7 +459,7 @@ with _auto_proxy_init(
         Maybe,
     )
 
-    from ..lite.maysyncs import (  # noqa
+    from ..lite.maysync import (  # noqa
         mark_maysync,
         is_maysync,
 

omlish/lang/contextmanagers.py

@@ -2,6 +2,7 @@
 TODO:
  - AsyncExitStacked
  - lol does double_check_setdefault need a CowDict in FT?
+ - AsyncLockable, DefaultAsyncLockable
 """
 import abc
 import contextlib
@@ -21,16 +22,45 @@ V = ta.TypeVar('V')
 ##
 
 
-class _NOT_SET:  # noqa
-    def __new__(cls, *args, **kwargs):  # noqa
-        raise TypeError
+class ContextManaged(abc.ABC):  # noqa
+    def __enter__(self):
+        return None
+
+    def __exit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc_val: BaseException | None,
+            exc_tb: types.TracebackType | None,
+    ) -> bool | None:
+        return None
 
 
-class ContextManaged:
+class SelfContextManaged(ContextManaged):
     def __enter__(self) -> ta.Self:
         return self
 
-    def __exit__(
+
+class ValueContextManager(ContextManaged, ta.Generic[T]):
+    def __init__(self, value: T) -> None:
+        super().__init__()
+
+        self._value = value
+
+    def __enter__(self) -> T:
+        return self._value
+
+
+NOP_CONTEXT_MANAGER = ValueContextManager(None)
+
+
+#
+
+
+class AsyncContextManaged(abc.ABC):  # noqa
+    async def __aenter__(self):
+        return None
+
+    async def __aexit__(
             self,
             exc_type: type[BaseException] | None,
             exc_val: BaseException | None,
@@ -39,23 +69,22 @@ class ContextManaged:
         return None
 
 
-class NopContextManager(ContextManaged):
-    def __init__(self, /, value: ta.Any = _NOT_SET) -> None:
+class SelfAsyncContextManaged(AsyncContextManaged):
+    async def __aenter__(self) -> ta.Self:
+        return self
+
+
+class ValueAsyncContextManager(AsyncContextManaged, ta.Generic[T]):
+    def __init__(self, value: T) -> None:
         super().__init__()
 
         self._value = value
 
-    def __enter__(self):
-        if (value := self._value) is _NOT_SET:
-            return self
-        else:
-            return value
-
-    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
-        raise TypeError
+    async def __aenter__(self) -> T:
+        return self._value
 
 
-NOP_CONTEXT_MANAGER = NopContextManager()
+NOP_ASYNC_CONTEXT_MANAGER = ValueAsyncContextManager(None)
 
 
 ##
@@ -90,6 +119,9 @@ class ContextManager(abc.ABC, ta.Generic[T]):
         return self._contextmanager.__exit__(exc_type, exc_val, exc_tb)
 
 
+#
+
+
 class AsyncContextManager(abc.ABC, ta.Generic[T]):
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
@@ -160,6 +192,15 @@ def context_var_setting(var: contextvars.ContextVar[T], val: T) -> ta.Iterator[T
 ##
 
 
+@contextlib.asynccontextmanager
+async def as_async_context_manager(cm: ta.ContextManager[T]) -> ta.AsyncIterator[T]:
+    with cm as v:
+        yield v
+
+
+##
+
+
 ContextWrappable: ta.TypeAlias = ta.ContextManager | str | ta.Callable[..., ta.ContextManager]
 
 
@@ -257,6 +298,30 @@ def default_lock(value: DefaultLockable, default: DefaultLockable = None) -> Loc
         raise TypeError(value)
 
 
+#
+
+
+AsyncLockable = ta.Callable[[], ta.AsyncContextManager]
+DefaultAsyncLockable = AsyncLockable | ta.AsyncContextManager | None
+
+
+def default_async_lock(value: DefaultAsyncLockable, default: DefaultAsyncLockable = None) -> AsyncLockable:
+    if value is None:
+        value = default
+
+    if value is None:
+        return lambda: NOP_ASYNC_CONTEXT_MANAGER
+
+    elif callable(value):
+        return value
+
+    elif isinstance(value, ta.AsyncContextManager):
+        return lambda: value
+
+    else:
+        raise TypeError(value)
+
+
 ##
 
 

omlish/lang/imports/proxyinit.py

@@ -512,8 +512,8 @@ class AutoProxyInit:
             self,
             init_globals: ta.MutableMapping[str, ta.Any],
             *,
-            disable: bool,
-            eager: bool,
+            disable: bool = False,
+            eager: bool = False,
     ) -> None:
         super().__init__()
 

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

@@ -1,8 +1,8 @@
 import typing as ta
 
-from ..lite.maysyncs import MaysyncFn
-from ..lite.maysyncs import MaysyncGeneratorFn
-from ..lite.maysyncs import make_maysync as _make_maysync
+from ..lite.maysync import MaysyncFn
+from ..lite.maysync import MaysyncGeneratorFn
+from ..lite.maysync import make_maysync as _make_maysync
 from .functions import as_async
 
 

omlish/lifecycles/__init__.py

@@ -1,11 +1,21 @@
 from .abstract import (  # noqa
     AbstractLifecycle,
+
+    AbstractAsyncLifecycle,
 )
 
 from .base import (  # noqa
+    AnyLifecycleCallback,
+    AnyLifecycle,
+    AnyCallbackLifecycle,
+
+    LifecycleCallback,
     CallbackLifecycle,
     Lifecycle,
-    LifecycleCallback,
+
+    AsyncLifecycleCallback,
+    CallbackAsyncLifecycle,
+    AsyncLifecycle,
 )
 
 from .contextmanagers import (  # noqa
@@ -14,6 +24,9 @@ from .contextmanagers import (  # noqa
 )
 
 from .controller import (  # noqa
+    AnyLifecycleListener,
+    AnyLifecycleController,
+
     LifecycleController,
     LifecycleListener,
 )

omlish/lifecycles/abstract.py

@@ -3,11 +3,14 @@ import typing as ta
 from .. import cached
 from .. import dataclasses as dc
 from .. import lang
+from .base import AsyncLifecycle
 from .base import Lifecycle
 
 
 AbstractLifecycleT = ta.TypeVar('AbstractLifecycleT', bound='AbstractLifecycle')
 
+AbstractAsyncLifecycleT = ta.TypeVar('AbstractAsyncLifecycleT', bound='AbstractAsyncLifecycle')
+
 
 ##
 
@@ -44,3 +47,40 @@ class AbstractLifecycle(lang.Abstract):
 
     def _lifecycle_destroy(self) -> None:
         pass
+
+
+##
+
+
+class AbstractAsyncLifecycle(lang.Abstract):
+    @dc.dataclass(frozen=True)
+    class _Lifecycle(AsyncLifecycle, lang.Final, ta.Generic[AbstractAsyncLifecycleT]):
+        obj: AbstractAsyncLifecycleT
+
+        async def lifecycle_construct(self) -> None:
+            await self.obj._lifecycle_construct()  # noqa
+
+        async def lifecycle_start(self) -> None:
+            await self.obj._lifecycle_start()  # noqa
+
+        async def lifecycle_stop(self) -> None:
+            await self.obj._lifecycle_stop()  # noqa
+
+        async def lifecycle_destroy(self) -> None:
+            await self.obj._lifecycle_destroy()  # noqa
+
+    @cached.property
+    def _lifecycle(self) -> _Lifecycle[ta.Self]:
+        return AbstractAsyncLifecycle._Lifecycle(self)
+
+    async def _lifecycle_construct(self) -> None:
+        pass
+
+    async def _lifecycle_start(self) -> None:
+        pass
+
+    async def _lifecycle_stop(self) -> None:
+        pass
+
+    async def _lifecycle_destroy(self) -> None:
+        pass

omlish/lifecycles/base.py

@@ -4,50 +4,100 @@ from .. import dataclasses as dc
 from .. import lang
 
 
+R = ta.TypeVar('R')
+
+AnyLifecycleT = ta.TypeVar('AnyLifecycleT', bound='AnyLifecycle')
+AnyLifecycleCallback: ta.TypeAlias = ta.Callable[[AnyLifecycleT], R]
+
 LifecycleT = ta.TypeVar('LifecycleT', bound='Lifecycle')
-LifecycleCallback: ta.TypeAlias = ta.Callable[[LifecycleT], None]
+LifecycleCallback: ta.TypeAlias = ta.Callable[[LifecycleT], R]
+
+AsyncLifecycleT = ta.TypeVar('AsyncLifecycleT', bound='AsyncLifecycle')
+AsyncLifecycleCallback: ta.TypeAlias = ta.Callable[[AsyncLifecycleT], R]
 
 
 ##
 
 
-class Lifecycle:
-    def lifecycle_construct(self) -> None:
-        pass
+class AnyLifecycle(lang.Abstract, ta.Generic[R]):
+    def lifecycle_construct(self) -> R | None:
+        return None
 
-    def lifecycle_start(self) -> None:
-        pass
+    def lifecycle_start(self) -> R | None:
+        return None
 
-    def lifecycle_stop(self) -> None:
-        pass
+    def lifecycle_stop(self) -> R | None:
+        return None
 
-    def lifecycle_destroy(self) -> None:
-        pass
+    def lifecycle_destroy(self) -> R | None:
+        return None
 
 
 @dc.dataclass(frozen=True, kw_only=True)
-class CallbackLifecycle(Lifecycle, lang.Final, ta.Generic[LifecycleT]):
-    on_construct: LifecycleCallback['CallbackLifecycle[LifecycleT]'] | None = None
-    on_start: LifecycleCallback['CallbackLifecycle[LifecycleT]'] | None = None
-    on_stop: LifecycleCallback['CallbackLifecycle[LifecycleT]'] | None = None
-    on_destroy: LifecycleCallback['CallbackLifecycle[LifecycleT]'] | None = None
+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
 
     @ta.override
-    def lifecycle_construct(self) -> None:
+    def lifecycle_construct(self) -> R | None:
         if self.on_construct is not None:
-            self.on_construct(self)
+            return self.on_construct(self)
+        else:
+            return None
 
     @ta.override
-    def lifecycle_start(self) -> None:
+    def lifecycle_start(self) -> R | None:
         if self.on_start is not None:
-            self.on_start(self)
+            return self.on_start(self)
+        else:
+            return None
 
     @ta.override
-    def lifecycle_stop(self) -> None:
+    def lifecycle_stop(self) -> R | None:
         if self.on_stop is not None:
-            self.on_stop(self)
+            return self.on_stop(self)
+        else:
+            return None
 
     @ta.override
-    def lifecycle_destroy(self) -> None:
+    def lifecycle_destroy(self) -> R | None:
         if self.on_destroy is not None:
-            self.on_destroy(self)
+            return self.on_destroy(self)
+        else:
+            return None
+
+
+##
+
+
+class Lifecycle(AnyLifecycle[None]):
+    pass
+
+
+class CallbackLifecycle(
+    AnyCallbackLifecycle[LifecycleT, None],
+    lang.Final,
+    ta.Generic[LifecycleT],
+):
+    pass
+
+
+##
+
+
+class AsyncLifecycle(AnyLifecycle[ta.Awaitable[None]]):
+    pass
+
+
+class CallbackAsyncLifecycle(
+    AnyCallbackLifecycle[LifecycleT, ta.Awaitable[None]],
+    lang.Final,
+    ta.Generic[LifecycleT],
+):
+    pass