omlish 0.0.0.dev493__py3-none-any.whl → 0.0.0.dev506__py3-none-any.whl

omlish/inject/impl/injector.py

@@ -1,21 +1,3 @@
-"""
-TODO:
- - ** can currently bind in a child/private scope shadowing an external parent binding **
- - better source tracking
- - scope bindings, auto in root
- - injector-internal / blacklisted bindings (Injector itself, default scopes) without rebuilding ElementCollection
- - config - proxies, impl select, etc
-  - config is probably shared with ElementCollection... but not 'bound', must be shared everywhere
-  - InjectorRoot object?
- - ** eagers in any scope, on scope init/open
- - unions - raise on ambiguous - usecase: sql.AsyncEngineLike
- - multiple live request scopes on single injector - use private injectors?
- - more listeners - UnboundKeyListener
-  - lazy parent listener chain cache thing
- - https://github.com/7mind/izumi-chibi-ts
-  - Axis tagging for conditional bindings (e.g., dev vs prod implementations)
-  - Fail-fast validation with circular and missing dependency detection
-"""
 import contextlib
 import functools
 import itertools
@@ -96,6 +78,9 @@ class AsyncInjectorImpl(AsyncInjector, lang.Final):
             )
         }
 
+        if self._p is not None:
+            self._p._add_child(self)  # noqa
+
     _cs: weakref.WeakSet['AsyncInjectorImpl'] | None = None  # noqa
 
     __cur_req: ta.Optional['AsyncInjectorImpl._Request'] = None
@@ -126,8 +111,8 @@ class AsyncInjectorImpl(AsyncInjector, lang.Final):
     def get_scope_impl(self, sc: Scope) -> ScopeImpl:
         return self._scopes[sc]
 
-    def create_child(self, ec: ElementCollection) -> AsyncInjector:
-        c = AsyncInjectorImpl(ec, self)
+    def _add_child(self, c: 'AsyncInjectorImpl') -> AsyncInjector:
+        check.isinstance(c, AsyncInjectorImpl)
         if self._cs is None:
             self._cs = weakref.WeakSet()
         self._cs.add(c)
@@ -260,7 +245,7 @@ class AsyncInjectorImpl(AsyncInjector, lang.Final):
         return obj(**kws)
 
 
-async def create_async_injector(ce: CollectedElements) -> AsyncInjector:
-    i = AsyncInjectorImpl(ce)
+async def create_async_injector(ce: CollectedElements, p: AsyncInjector | None = None) -> AsyncInjector:
+    i = AsyncInjectorImpl(ce, check.isinstance(p, (AsyncInjectorImpl, None)))
     await i._init()  # noqa
     return i

omlish/inject/impl/inspect.py

@@ -1,11 +1,3 @@
-"""
-TODO:
- - cache kwarg_keys
- - tag annotations? x: ta.Annotated[int, inj.Tag('foo')]
- - tag decorator - @inj.tag(x='foo')
- - *unpack optional here*
- - use ...metadata
-"""
 import dataclasses as dc
 import inspect
 import typing as ta

omlish/inject/impl/origins.py

@@ -21,6 +21,7 @@ ORIGIN_BASE_OFS = 2
 ORIGIN_IGNORED_PACKAGES = frozenset([
     __package__,
     __package__.rpartition('.')[0],
+    __package__.rpartition('.')[0] + '.helpers',
 
     lang.__name__,
     lang.functions.__name__,

omlish/inject/impl/privates.py

@@ -1,12 +1,7 @@
-"""
-TODO:
- - add origin to Id
-"""
 import itertools
 import typing as ta
 
 from ... import cached
-from ... import check
 from ... import dataclasses as dc
 from ... import lang
 from ..bindings import Binding
@@ -20,6 +15,7 @@ from ..providers import Provider
 from ..scopes import Singleton
 from .elements import ElementCollection
 from .injector import AsyncInjectorImpl
+from .injector import create_async_injector
 from .providers import InternalProvider
 from .providers import ProviderImpl
 
@@ -48,7 +44,7 @@ class PrivateInjectorProviderImpl(ProviderImpl, lang.Final):
         return ()
 
     async def provide(self, injector: AsyncInjector) -> ta.Any:
-        return check.isinstance(injector, AsyncInjectorImpl).create_child(self.ec)
+        return await create_async_injector(self.ec, injector)
 
 
 ##

omlish/inject/impl/providers.py

@@ -1,7 +1,3 @@
-"""
-TODO:
- - required_keys
-"""
 import abc
 import typing as ta
 

omlish/inject/impl/scopes.py

@@ -1,9 +1,3 @@
-"""
-TODO:
- - ContextVar ('context')
- - greenlet?
- - dynamic? https://github.com/wrmsr/iceworm/blob/2f6b4d5e9d237ef9665f7d57cfa6ce328efa0757/iceworm/utils/inject.py#L44
-"""
 import abc
 import contextlib
 import threading
@@ -154,18 +148,20 @@ class SeededScopeImpl(ScopeImpl):
             self._ii = check.isinstance(i, _injector.AsyncInjectorImpl)
             self._ssi = check.isinstance(self._ii.get_scope_impl(self._ss), SeededScopeImpl)
 
-        @contextlib.asynccontextmanager
-        async def __call__(self, seeds: ta.Mapping[Key, ta.Any]) -> ta.AsyncGenerator[None]:
-            try:
-                if self._ssi._st is not None:  # noqa
-                    raise ScopeAlreadyOpenError(self._ss)
-                self._ssi._st = SeededScopeImpl.State(dict(seeds))  # noqa
-                await self._ii._instantiate_eagers(self._ss)  # noqa
-                yield
-            finally:
-                if self._ssi._st is None:  # noqa
-                    raise ScopeNotOpenError(self._ss)
-                self._ssi._st = None  # noqa
+        def __call__(self, seeds: ta.Mapping[Key, ta.Any]) -> ta.AsyncContextManager[None]:
+            @contextlib.asynccontextmanager
+            async def inner():
+                try:
+                    if self._ssi._st is not None:  # noqa
+                        raise ScopeAlreadyOpenError(self._ss)
+                    self._ssi._st = SeededScopeImpl.State(dict(seeds))  # noqa
+                    await self._ii._instantiate_eagers(self._ss)  # noqa
+                    yield
+                finally:
+                    if self._ssi._st is None:  # noqa
+                        raise ScopeNotOpenError(self._ss)
+                    self._ssi._st = None  # noqa
+            return inner()
 
     def auto_elements(self) -> Elements:
         return as_elements(

omlish/inject/inspect.py

@@ -68,3 +68,12 @@ def tag(obj: T, **kwargs: ta.Any) -> T:
 
 def build_kwargs_target(obj: ta.Any, **kwargs: ta.Any) -> KwargsTarget:
     return _inspect.build_kwargs_target(obj, **kwargs)
+
+
+##
+
+
+def target(**kwargs: ta.Any) -> ta.Callable[[ta.Any], KwargsTarget]:
+    def inner(obj: ta.Any) -> KwargsTarget:
+        return KwargsTarget.of(obj, **kwargs)
+    return inner

omlish/inject/multis.py

@@ -1,8 +1,5 @@
 """
 TODO:
- - DynamicSetBinding / DynamicMapBinding ? provider of set[T] / map[K, V] ?
-  - doable not guicey - too much dynamism
- - scopes
 """
 import collections.abc
 import typing as ta

omlish/inject/scopes.py

@@ -89,14 +89,16 @@ def bind_scope_seed(k: ta.Any, ss: SeededScope) -> Element:
 ##
 
 
-@contextlib.asynccontextmanager
-async def async_enter_seeded_scope(
+def async_enter_seeded_scope(
         i: '_injector.AsyncInjector',
         ss: SeededScope,
         keys: ta.Mapping[Key, ta.Any],
-) -> ta.AsyncGenerator[None]:
-    async with (await i.provide(Key(SeededScope.Manager, tag=ss)))(keys):
-        yield
+) -> ta.AsyncContextManager[None]:
+    @contextlib.asynccontextmanager
+    async def inner():
+        async with (await i.provide(Key(SeededScope.Manager, tag=ss)))(keys):
+            yield
+    return inner()
 
 
 def enter_seeded_scope(

omlish/io/buffers.py

@@ -190,16 +190,18 @@ class ReadableListBuffer:
         super().__init__()
 
         self._lst: list[bytes] = []
+        self._len = 0
 
     def __bool__(self) -> ta.NoReturn:
         raise TypeError("Use 'buf is not None' or 'len(buf)'.")
 
     def __len__(self) -> int:
-        return sum(map(len, self._lst))
+        return self._len
 
     def feed(self, d: bytes) -> None:
         if d:
             self._lst.append(d)
+            self._len += len(d)
 
     def _chop(self, i: int, e: int) -> bytes:
         lst = self._lst
@@ -215,6 +217,8 @@ class ReadableListBuffer:
             *lst[i + 1:],
         ]
 
+        self._len -= len(o)
+
         return o
 
     def read(self, n: ta.Optional[int] = None) -> ta.Optional[bytes]:
@@ -224,6 +228,7 @@ class ReadableListBuffer:
 
             o = b''.join(self._lst)
             self._lst = []
+            self._len = 0
             return o
 
         if not (lst := self._lst):
@@ -293,7 +298,12 @@ class ReadableListBuffer:
                 if not (b := self._raw.read1(n)):
                     break
                 self._buf.feed(b)
-            return self._buf.read(n) or b''
+
+            if len(self._buf) >= n:
+                return self._buf.read(n) or b''
+
+            # EOF with a partial buffer: return what we have.
+            return self._buf.read() or b''
 
         def readall(self) -> bytes:
             buf = io.BytesIO()
@@ -343,7 +353,12 @@ class ReadableListBuffer:
                 if not (b := await self._raw.read1(n)):
                     break
                 self._buf.feed(b)
-            return self._buf.read(n) or b''
+
+            if len(self._buf) >= n:
+                return self._buf.read(n) or b''
+
+            # EOF with a partial buffer: return what we have.
+            return self._buf.read() or b''
 
         async def readall(self) -> bytes:
             buf = io.BytesIO()
@@ -396,16 +411,28 @@ class IncrementalWriteBuffer:
 
         t = 0
         for i, d in enumerate(lst):  # noqa
-            n = fn(check.not_empty(d))
+            d = check.not_empty(d)
+            n = fn(d)
             if not n:
                 break
+
+            if n > len(d):
+                raise ValueError(n)
+
             t += n
 
+            if n < len(d):
+                # Short write - keep the remainder of this chunk and stop.
+                self._lst = [
+                    d[n:],
+                    *lst[i + 1:],
+                ]
+                self._pos += t
+                return t
+
         if t:
-            self._lst = [
-                *([d[n:]] if n < len(d) else []),
-                *lst[i + 1:],
-            ]
+            # Only fully-written chunks were consumed.
+            self._lst = lst[i + 1:]
             self._pos += t
 
         return t

omlish/lang/__init__.py

@@ -341,6 +341,7 @@ with _auto_proxy_init(globals(), update_exports=True):
         ilen,
         take,
         consume,
+        opt_list,
         peek,
         chunk,
         interleave,
@@ -381,6 +382,8 @@ with _auto_proxy_init(globals(), update_exports=True):
     from .objects import (  # noqa
         arg_repr,
         opt_repr,
+        just_repr,
+        opt_or_just_repr,
 
         can_weakref,
 
@@ -466,6 +469,10 @@ with _auto_proxy_init(globals(), update_exports=True):
         iterslice,
         iterrange,
 
+        seqs_all,
+        seqs_equal,
+        seqs_identical,
+
         SeqView,
     )
 
@@ -622,6 +629,7 @@ with _auto_proxy_init(globals(), update_exports=True):
         Func3,
 
         CachedFunc0,
+        AsyncCachedFunc0,
 
         typing_annotations_attr,
     )

omlish/lang/classes/simple.py

@@ -3,6 +3,7 @@ import functools
 import threading
 import typing as ta
 
+from ...lite.abstract import Abstract
 from .restrict import Final
 from .restrict import NotInstantiable
 
@@ -40,7 +41,7 @@ class _MarkerMeta(abc.ABCMeta):
         else:
             if set(namespace) - _MARKER_NAMESPACE_KEYS:
                 raise TypeError('Markers must not include contents. Did you mean to use Namespace?')
-            if Final not in bases:
+            if Final not in bases and Abstract not in bases:
                 bases += (Final,)
 
         return super().__new__(mcls, name, bases, namespace)

omlish/lang/iterables.py

@@ -26,6 +26,12 @@ def consume(it: ta.Iterable[ta.Any]) -> None:
     collections.deque(it, maxlen=0)
 
 
+def opt_list(it: ta.Iterable[T] | None) -> list[T] | None:
+    if it is None:
+        return None
+    return list(it)
+
+
 def peek(vs: ta.Iterable[T]) -> tuple[T, ta.Iterator[T]]:
     it = iter(vs)
     v = next(it)

omlish/lang/objects.py

@@ -2,6 +2,7 @@ import types
 import typing as ta
 import weakref
 
+from ..lite.maybes import Maybe
 from .classes.abstract import is_abstract_class
 
 
@@ -24,6 +25,18 @@ def opt_repr(obj: ta.Any) -> str | None:
     return repr(obj)
 
 
+def just_repr(obj: Maybe) -> str | None:
+    return obj.map(repr).or_none()
+
+
+def opt_or_just_repr(obj: ta.Any) -> str | None:
+    if isinstance(obj, Maybe):
+        if obj.present:
+            return repr(obj)
+        return None
+    return opt_repr(obj)
+
+
 ##
 
 

omlish/lang/outcomes.py

@@ -214,7 +214,7 @@ class Value(Outcome[ValueT_co], ta.Generic[ValueT_co]):
 
     @property
     def is_error(self) -> bool:
-        return True
+        return False
 
     def value(self) -> ValueT_co:
         return self._value

omlish/lang/recursion.py

@@ -65,7 +65,7 @@ def recursion_limiting_context(key: ta.Any, limit: int | None) -> ta.Iterator[in
     except KeyError:
         pd = None
     else:
-        if not isinstance(pd, int) and pd > 0:  # type: ignore[operator]
+        if not (isinstance(pd, int) and pd > 0):
             raise RuntimeError
 
     if pd is not None and pd >= limit:

omlish/lang/sequences.py

@@ -8,6 +8,7 @@ TODO:
  - shorter repr if __len__ > some threshold
   - use materialize()?
 """
+import operator
 import typing as ta
 
 
@@ -36,6 +37,38 @@ def iterrange(
 ##
 
 
+def seqs_all(
+        fn: ta.Callable[[T, T], bool],
+        l_seq: ta.Sequence[T],
+        *r_seqs: ta.Sequence[T],
+) -> bool:
+    if not all(len(r_seq) == len(l_seq) for r_seq in r_seqs):
+        return False
+
+    return all(
+        fn(l, r)
+        for r_seq in r_seqs
+        for l, r in zip(l_seq, r_seq, strict=True)
+    )
+
+
+def seqs_equal(
+        l_seq: ta.Sequence[T],
+        *r_seqs: ta.Sequence[T],
+) -> bool:
+    return seqs_all(operator.eq, l_seq, *r_seqs)
+
+
+def seqs_identical(
+        l_seq: ta.Sequence[T],
+        *r_seqs: ta.Sequence[T],
+) -> bool:
+    return seqs_all(operator.is_, l_seq, *r_seqs)
+
+
+##
+
+
 @ta.final
 class SeqView(ta.Sequence[T]):
     def __init__(self, data: ta.Sequence[T], slice_: slice = slice(None)) -> None:

omlish/lifecycles/_dataclasses.py

@@ -94,7 +94,7 @@ def _process_dataclass__80a0a85b19250d1d39ff826c429bd05f9be201e1():
         def __setattr__(self, name, value):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___setattr_frozen_fields
+                or name in __dataclass___setattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
             super(__dataclass__cls, self).__setattr__(name, value)
@@ -111,7 +111,7 @@ def _process_dataclass__80a0a85b19250d1d39ff826c429bd05f9be201e1():
         def __delattr__(self, name):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___delattr_frozen_fields
+                or name in __dataclass___delattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
             super(__dataclass__cls, self).__delattr__(name)
@@ -229,7 +229,7 @@ def _process_dataclass__32f5b8178dfdf24f4db24e8d8cd63ebd10bf83f3():
         def __setattr__(self, name, value):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___setattr_frozen_fields
+                or name in __dataclass___setattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
             super(__dataclass__cls, self).__setattr__(name, value)
@@ -246,7 +246,7 @@ def _process_dataclass__32f5b8178dfdf24f4db24e8d8cd63ebd10bf83f3():
         def __delattr__(self, name):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___delattr_frozen_fields
+                or name in __dataclass___delattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
             super(__dataclass__cls, self).__delattr__(name)
@@ -408,7 +408,7 @@ def _process_dataclass__d177836dcedc950662bdf1c8a8d52e05fc91c5c7():
         def __setattr__(self, name, value):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___setattr_frozen_fields
+                or name in __dataclass___setattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
             super(__dataclass__cls, self).__setattr__(name, value)
@@ -429,7 +429,7 @@ def _process_dataclass__d177836dcedc950662bdf1c8a8d52e05fc91c5c7():
         def __delattr__(self, name):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___delattr_frozen_fields
+                or name in __dataclass___delattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
             super(__dataclass__cls, self).__delattr__(name)
@@ -567,7 +567,7 @@ def _process_dataclass__440e63ab60e5c95ef453ad0e63ffc0977bb48371():
         def __setattr__(self, name, value):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___setattr_frozen_fields
+                or name in __dataclass___setattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
             super(__dataclass__cls, self).__setattr__(name, value)
@@ -586,7 +586,7 @@ def _process_dataclass__440e63ab60e5c95ef453ad0e63ffc0977bb48371():
         def __delattr__(self, name):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___delattr_frozen_fields
+                or name in __dataclass___delattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
             super(__dataclass__cls, self).__delattr__(name)
@@ -704,7 +704,7 @@ def _process_dataclass__6c47afef6781ac6bd88758815660ccbfefe8540e():
         def __setattr__(self, name, value):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___setattr_frozen_fields
+                or name in __dataclass___setattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
             super(__dataclass__cls, self).__setattr__(name, value)
@@ -723,7 +723,7 @@ def _process_dataclass__6c47afef6781ac6bd88758815660ccbfefe8540e():
         def __delattr__(self, name):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___delattr_frozen_fields
+                or name in __dataclass___delattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
             super(__dataclass__cls, self).__delattr__(name)
@@ -863,7 +863,7 @@ def _process_dataclass__ebef99260c9b05bfd28fc9433dcc32af80493f10():
         def __setattr__(self, name, value):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___setattr_frozen_fields
+                or name in __dataclass___setattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
             super(__dataclass__cls, self).__setattr__(name, value)
@@ -883,7 +883,7 @@ def _process_dataclass__ebef99260c9b05bfd28fc9433dcc32af80493f10():
         def __delattr__(self, name):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___delattr_frozen_fields
+                or name in __dataclass___delattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
             super(__dataclass__cls, self).__delattr__(name)
@@ -1014,7 +1014,7 @@ def _process_dataclass__375fd7fd537e2cfb878109217fe4c57607b10510():
         def __setattr__(self, name, value):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___setattr_frozen_fields
+                or name in __dataclass___setattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
             super(__dataclass__cls, self).__setattr__(name, value)
@@ -1031,7 +1031,7 @@ def _process_dataclass__375fd7fd537e2cfb878109217fe4c57607b10510():
         def __delattr__(self, name):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___delattr_frozen_fields
+                or name in __dataclass___delattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
             super(__dataclass__cls, self).__delattr__(name)
@@ -1163,7 +1163,7 @@ def _process_dataclass__b3f39a9348415b6ae3908bd546728de8b2b6d308():
         def __setattr__(self, name, value):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___setattr_frozen_fields
+                or name in __dataclass___setattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
             super(__dataclass__cls, self).__setattr__(name, value)
@@ -1182,7 +1182,7 @@ def _process_dataclass__b3f39a9348415b6ae3908bd546728de8b2b6d308():
         def __delattr__(self, name):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___delattr_frozen_fields
+                or name in __dataclass___delattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
             super(__dataclass__cls, self).__delattr__(name)
@@ -1317,7 +1317,7 @@ def _process_dataclass__56c73a66344b180e8ef52aca8500185dd538bf10():
         def __setattr__(self, name, value):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___setattr_frozen_fields
+                or name in __dataclass___setattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
             super(__dataclass__cls, self).__setattr__(name, value)
@@ -1335,7 +1335,7 @@ def _process_dataclass__56c73a66344b180e8ef52aca8500185dd538bf10():
         def __delattr__(self, name):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___delattr_frozen_fields
+                or name in __dataclass___delattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
             super(__dataclass__cls, self).__delattr__(name)

omlish/lifecycles/injection.py

@@ -123,21 +123,21 @@ def bind_async_lifecycle_registrar() -> inj.Elements:
 ##
 
 
-def bind_managed_lifecycle_manager() -> inj.Elements:
+def bind_managed_lifecycle_manager(*, eager: bool | int = False) -> inj.Elements:
     # FIXME: lock?
     def inner(es: contextlib.ExitStack) -> LifecycleManager:
         return es.enter_context(lifecycle_context_manage(LifecycleManager()))
 
     return inj.as_elements(
-        inj.bind(inner, singleton=True, eager=True),
+        inj.bind(inner, singleton=True, eager=eager),
     )
 
 
-def bind_async_managed_lifecycle_manager() -> inj.Elements:
+def bind_async_managed_lifecycle_manager(*, eager: bool | int = False) -> inj.Elements:
     # FIXME: lock?
     async def inner(aes: contextlib.AsyncExitStack) -> AsyncLifecycleManager:
         return await aes.enter_async_context(async_lifecycle_context_manage(AsyncLifecycleManager()))
 
     return inj.as_elements(
-        inj.bind(inner, singleton=True, eager=True),
+        inj.bind(inner, singleton=True, eager=eager),
     )

omlish/lite/maybes.py

@@ -100,6 +100,13 @@ class Maybe(ta.Generic[T]):
         else:
             return other
 
+    @ta.final
+    def or_none(self) -> ta.Optional[T]:
+        if self.present:
+            return self.must()
+        else:
+            return None
+
     @ta.final
     def or_else_get(self, supplier: ta.Callable[[], ta.Union[T, U]]) -> ta.Union[T, U]:
         if self.present: