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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev418'
-__revision__ = '768aa72e47d914554932c2598e2f832465969997'
+__version__ = '0.0.0.dev420'
+__revision__ = '513bbdf392274f50320eb9577bd88bc0a683e1a5'
 
 
 #

omlish/configs/all.py

@@ -1,47 +1,54 @@
-# ruff: noqa: I001
-from .classes import (  # noqa
-    Configurable,
-)
+# rufF: noqa: I001
+from .. import lang as _lang
 
-from .formats import (  # noqa
-    ConfigData as Data,
 
-    ConfigLoader as Loader,
+with _lang.auto_proxy_init(globals()):
+    ##
 
-    ConfigRenderer as Renderer,
+    from .classes import (  # noqa
+        Configurable,
+    )
 
-    ObjConfigData as ObjData,
+    from .formats import (  # noqa
+        ConfigData as Data,
 
-    JsonConfigData as JsonData,
-    JsonConfigLoader as JsonLoader,
-    JsonConfigRenderer as JsonRenderer,
+        ConfigLoader as Loader,
 
-    TomlConfigData as TomlData,
-    TomlConfigLoader as TomlLoader,
-    TomlConfigRenderer as TomlRenderer,
+        ConfigRenderer as Renderer,
 
-    YamlConfigData as YamlData,
-    YamlConfigLoader as YamlLoader,
-    YamlConfigRenderer as YamlRenderer,
+        ObjConfigData as ObjData,
 
-    IniConfigData as IniData,
-    IniConfigLoader as IniLoader,
-    IniConfigRenderer as IniRenderer,
+        JsonConfigData as JsonData,
+        JsonConfigLoader as JsonLoader,
+        JsonConfigRenderer as JsonRenderer,
 
-    SwitchedConfigFileLoader as SwitchedFileLoader,
+        TomlConfigData as TomlData,
+        TomlConfigLoader as TomlLoader,
+        TomlConfigRenderer as TomlRenderer,
 
-    DEFAULT_CONFIG_LOADERS as DEFAULT_LOADERS,
-    DEFAULT_CONFIG_LOADER as DEFAULT_LOADER,
-    DEFAULT_CONFIG_FILE_LOADER as DEFAULT_FILE_LOADER,
+        YamlConfigData as YamlData,
+        YamlConfigLoader as YamlLoader,
+        YamlConfigRenderer as YamlRenderer,
 
-    SwitchedConfigRenderer as SwitchedRenderer,
+        IniConfigData as IniData,
+        IniConfigLoader as IniLoader,
+        IniConfigRenderer as IniRenderer,
 
-    DEFAULT_CONFIG_RENDERERS as DEFAULT_RENDERERS,
-    DEFAULT_CONFIG_RENDERER as DEFAULT_RENDERER,
-)
+        SwitchedConfigFileLoader as SwitchedFileLoader,
+
+        DEFAULT_CONFIG_LOADERS as DEFAULT_LOADERS,
+        DEFAULT_CONFIG_LOADER as DEFAULT_LOADER,
+        DEFAULT_CONFIG_FILE_LOADER as DEFAULT_FILE_LOADER,
+
+        SwitchedConfigRenderer as SwitchedRenderer,
+
+        DEFAULT_CONFIG_RENDERERS as DEFAULT_RENDERERS,
+        DEFAULT_CONFIG_RENDERER as DEFAULT_RENDERER,
+    )
+
+    from .types import (  # noqa
+        ConfigMap as Map,
+    )
 
-from .types import (  # noqa
-    ConfigMap as Map,
-)
 
 from .processing import all as processing  # noqa

omlish/configs/processing/all.py

@@ -1,37 +1,43 @@
 # ruff: noqa: I001
-from .flattening import (  # noqa
-    ConfigFlattening as Flattening,
-)
+from ... import lang as _lang
 
-from .inheritance import (  # noqa
-    build_config_inherited_values as build_inherited_values,
-)
 
-from .matching import (  # noqa
-    MatchingConfigRewriter as MatchingRewriter,
+with _lang.auto_proxy_init(globals()):
+    ##
 
-    matched_config_rewrite as matched_rewrite,
-)
+    from .flattening import (  # noqa
+        ConfigFlattening as Flattening,
+    )
 
-from .merging import (  # noqa
-    merge_configs as merge,
-)
+    from .inheritance import (  # noqa
+        build_config_inherited_values as build_inherited_values,
+    )
 
-from .names import (  # noqa
-    build_config_named_children as build_named_children,
-)
+    from .matching import (  # noqa
+        MatchingConfigRewriter as MatchingRewriter,
 
-from .rewriting import (  # noqa
-    ConfigRewriterItem as RewriterItem,
-    ConfigRewriterPath as RewriterPath,
+        matched_config_rewrite as matched_rewrite,
+    )
 
-    RawConfigMetadata as RawMetadata,
+    from .merging import (  # noqa
+        merge_configs as merge,
+    )
 
-    ConfigRewriter as Rewriter,
-)
+    from .names import (  # noqa
+        build_config_named_children as build_named_children,
+    )
 
-from .strings import (  # noqa
-    StringConfigRewriter as StringRewriter,
+    from .rewriting import (  # noqa
+        ConfigRewriterItem as RewriterItem,
+        ConfigRewriterPath as RewriterPath,
 
-    format_config_strings as format_strings,
-)
+        RawConfigMetadata as RawMetadata,
+
+        ConfigRewriter as Rewriter,
+    )
+
+    from .strings import (  # noqa
+        StringConfigRewriter as StringRewriter,
+
+        format_config_strings as format_strings,
+    )

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/formats/json/backends/default.py

@@ -2,9 +2,15 @@ import typing as ta
 
 from .... import lang
 from .base import Backend
-from .orjson import orjson_backend
 from .std import std_backend
-from .ujson import ujson_backend
+
+
+if ta.TYPE_CHECKING:
+    from . import orjson as oj
+    from . import ujson as uj
+else:
+    oj = lang.proxy_import('.orjson', __package__)
+    uj = lang.proxy_import('.ujson', __package__)
 
 
 ##
@@ -12,12 +18,13 @@ from .ujson import ujson_backend
 
 @lang.cached_function
 def default_backend() -> Backend:
-    for fn in [
-        orjson_backend,
-        ujson_backend,
+    for (im, bm, fn) in [
+        ('orjson', oj, 'orjson_backend'),
+        ('ujson', uj, 'ujson_backend'),
     ]:
-        if (be := fn()) is not None:
-            return be
+        if lang.can_import(im):
+            if (be := getattr(bm, fn)()) is not None:
+                return be
 
     return std_backend()
 

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/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