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

omlish/inject/binder.py

@@ -88,7 +88,7 @@ def bind(
         in_: Scope | None = None,
         singleton: bool = False,
 
-        eager: bool = False,
+        eager: bool | int = False,
         expose: bool = False,
 ) -> Element | Elements:
     if obj is None or obj is inspect.Parameter.empty:
@@ -117,7 +117,10 @@ def bind(
     elif _is_fn(obj) and not has_to:
         sig = _inspect.signature(obj)
         ty = rfl.type_(sig.return_annotation)
-        to_fn = obj
+        if inspect.iscoroutinefunction(obj):
+            to_async_fn = obj
+        else:
+            to_fn = obj
         key = Key(ty)
     else:
         if to_const is not None:
@@ -180,8 +183,8 @@ def bind(
 
     elements: list[Element] = [binding]
 
-    if eager:
-        elements.append(Eager(key))
+    if eager is not False:
+        elements.append(Eager(key, priority=eager if isinstance(eager, int) else 0))
     if expose:
         elements.append(Expose(key))
 

omlish/inject/eagers.py

@@ -1,7 +1,3 @@
-"""
-TODO:
- - SCOPED - eagers for EACH SCOPE
-"""
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
@@ -16,3 +12,5 @@ from .keys import Key
 @dc.extra_class_params(cache_hash=True)
 class Eager(Element, lang.Final):
     key: Key = dc.xfield(coerce=check.of_isinstance(Key))
+
+    priority: int = dc.xfield(0, kw_only=True)

omlish/inject/elements.py

@@ -37,6 +37,10 @@ class Elements(lang.Final):
             for c in self.cs:
                 yield from c
 
+    @property
+    def debug(self) -> ta.Sequence[Element]:
+        return list(self)
+
 
 Elemental: ta.TypeAlias = ta.Union[  # noqa
     Element,

omlish/inject/helpers/late.py

@@ -0,0 +1,76 @@
+"""
+A minor tidiness for hiding refs to [Async]Injector in circ-dep workarounds. Unfortunately unsuitable outside of
+injection modules due to it itself being in here (as user code shouldn't reference injector guts), but at least it's
+something.
+"""
+import abc
+import functools
+import typing as ta
+
+from ... import lang
+from ... import reflect as rfl
+from ..binder import bind
+from ..elements import Elements
+from ..elements import as_elements
+from ..injector import AsyncInjector
+from ..inspect import KwargsTarget
+from ..keys import Key
+from ..keys import as_key
+from ..sync import Injector
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class Late(lang.Abstract, ta.Generic[T]):
+    @abc.abstractmethod
+    def __call__(self) -> T:
+        raise NotImplementedError
+
+
+class AsyncLate(lang.Abstract, ta.Generic[T]):
+    @abc.abstractmethod
+    def __call__(self) -> ta.Awaitable[T]:
+        raise NotImplementedError
+
+
+#
+
+
+def _bind_late(
+        injector_cls: type,
+        late_cls: ta.Any,
+        inner: ta.Any,
+        outer: ta.Any | None = None,
+) -> Elements:
+    inner_key = as_key(inner)
+
+    outer_key: Key
+    outer_fac: ta.Callable[[ta.Any], ta.Any]
+    if outer is None:
+        inner_ann = rfl.to_annotation(inner_key.ty)
+        outer_ann = late_cls[inner_ann]
+        outer_key = Key(rfl.type_(outer_ann), tag=inner_key.tag)
+        outer_fac = lang.identity
+    else:
+        outer_key = as_key(outer)
+        outer_cls = rfl.get_concrete_type(outer_key.ty)
+        outer_fac = outer_cls  # type: ignore[assignment]
+
+    return as_elements(
+        bind(outer_key, to_fn=KwargsTarget.of(  # noqa
+            lambda i: outer_fac(functools.partial(i.provide, inner_key)),
+            i=injector_cls,
+        )),
+    )
+
+
+def bind_late(inner: ta.Any, outer: ta.Any | None = None) -> Elements:
+    return _bind_late(Injector, Late, inner, outer)
+
+
+def bind_async_late(inner: ta.Any, outer: ta.Any | None = None) -> Elements:
+    return _bind_late(AsyncInjector, AsyncLate, inner, outer)

omlish/inject/{managed.py → helpers/managed.py}

@@ -5,20 +5,20 @@ TODO:
 import contextlib
 import typing as ta
 
-from .. import lang
-from .binder import bind
-from .elements import Elemental
-from .impl.inspect import build_kwargs_target
+from ... import lang
+from ..binder import bind
+from ..elements import Elemental
+from ..impl.inspect import build_kwargs_target
 
 
 if ta.TYPE_CHECKING:
-    from . import injector as _injector
-    from . import maysync as _maysync
-    from . import sync as _sync
+    from .. import injector as _injector
+    from .. import maysync as _maysync
+    from .. import sync as _sync
 else:
-    _injector = lang.proxy_import('.injector', __package__)
-    _maysync = lang.proxy_import('.maysync', __package__)
-    _sync = lang.proxy_import('.sync', __package__)
+    _injector = lang.proxy_import('..injector', __package__)
+    _maysync = lang.proxy_import('..maysync', __package__)
+    _sync = lang.proxy_import('..sync', __package__)
 
 
 T = ta.TypeVar('T')
@@ -27,14 +27,15 @@ T = ta.TypeVar('T')
 ##
 
 
-@contextlib.asynccontextmanager
-async def create_async_managed_injector(*args: Elemental) -> ta.AsyncGenerator['_injector.AsyncInjector']:
-    ai = await _injector.create_async_injector(
-        bind(contextlib.AsyncExitStack, singleton=True, eager=True),
-        *args,
-    )
-    async with (await ai[contextlib.AsyncExitStack]):
-        yield ai
+def create_async_managed_injector(*args: Elemental) -> ta.AsyncContextManager['_injector.AsyncInjector']:
+    @contextlib.asynccontextmanager
+    async def inner():
+        async with contextlib.AsyncExitStack() as aes:
+            yield await _injector.create_async_injector(
+                bind(contextlib.AsyncExitStack, to_const=aes),
+                *args,
+            )
+    return inner()
 
 
 def make_async_managed_provider(
@@ -61,14 +62,15 @@ def make_async_managed_provider(
 ##
 
 
-@contextlib.contextmanager
-def create_managed_injector(*args: Elemental) -> ta.Generator['_sync.Injector']:
-    i = _sync.create_injector(
-        bind(contextlib.ExitStack, singleton=True, eager=True),
-        *args,
-    )
-    with i[contextlib.ExitStack]:
-        yield i
+def create_managed_injector(*args: Elemental) -> ta.ContextManager['_sync.Injector']:
+    @contextlib.contextmanager
+    def inner():
+        with contextlib.ExitStack() as es:
+            yield _sync.create_injector(
+                bind(contextlib.ExitStack, to_const=es),
+                *args,
+            )
+    return inner()
 
 
 def make_managed_provider(
@@ -95,14 +97,15 @@ def make_managed_provider(
 ##
 
 
-@contextlib.contextmanager
-def create_maysync_managed_injector(*args: Elemental) -> ta.Generator['_maysync.MaysyncInjector']:
-    i = _maysync.create_maysync_injector(
-        bind(contextlib.ExitStack, singleton=True, eager=True),
-        *args,
-    )
-    with i[contextlib.ExitStack]:
-        yield i
+def create_maysync_managed_injector(*args: Elemental) -> ta.ContextManager['_maysync.MaysyncInjector']:
+    @contextlib.contextmanager
+    def inner():
+        with contextlib.ExitStack() as es:
+            yield _maysync.create_maysync_injector(
+                bind(contextlib.ExitStack, to_const=es),
+                *args,
+            )
+    return inner()
 
 
 def make_maysync_managed_provider(

omlish/inject/impl/elements.py

@@ -214,13 +214,16 @@ class ElementCollection(CollectedElements, lang.Final):
         return [sb.scope for sb in self.elements_of_type(ScopeBinding)]
 
     @lang.cached_function
-    def eager_keys_by_scope(self) -> ta.Mapping[Scope, ta.Sequence[Key]]:
+    def sorted_eager_keys_by_scope(self) -> ta.Mapping[Scope, ta.Sequence[Key]]:
         bim = self.binding_impl_map()
-        ret: dict[Scope, list[Key]] = {}
+        dct: dict[Scope, list[Eager]] = {}
         for e in self.elements_of_type(Eager):
             bi = bim[e.key]
-            ret.setdefault(bi.scope, []).append(e.key)
-        return ret
+            dct.setdefault(bi.scope, []).append(e)
+        return {
+            sc: tuple(eg.key for eg in sorted(egs, key=lambda eg: eg.priority))
+            for sc, egs in dct.items()
+        }
 
 
 ##

omlish/inject/impl/injector.py

@@ -1,18 +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
-"""
 import contextlib
 import functools
 import itertools
@@ -73,14 +58,14 @@ class AsyncInjectorImpl(AsyncInjector, lang.Final):
 
         self._bim = ec.binding_impl_map()
 
-        self._ekbs = ec.eager_keys_by_scope()
+        self._ekbs = ec.sorted_eager_keys_by_scope()
 
-        self._pls: tuple[ProvisionListener, ...] = tuple(
-            b.listener  # type: ignore[attr-defined]
-            for b in itertools.chain(
-                ec.elements_of_type(ProvisionListenerBinding),
-                p._pls if p is not None else (),  # noqa
-            )
+        self._pls: tuple[ProvisionListener, ...] = (
+            *(
+                b.listener
+                for b in ec.elements_of_type(ProvisionListenerBinding)
+            ),
+            *(p._pls if p is not None else []),  # noqa
         )
 
         self._root: AsyncInjectorImpl = p._root if p is not None else self  # noqa
@@ -93,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
@@ -123,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)
@@ -257,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

@@ -58,7 +58,7 @@ class KwargsTarget(ta.NamedTuple):
 
         return cls(
             obj,
-            [*kws, *kw_kwargs],
+            (*kws, *kw_kwargs),
         )
 
 
@@ -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,
     )
 
@@ -621,6 +628,9 @@ with _auto_proxy_init(globals(), update_exports=True):
         Func2,
         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)