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

omlish/inject/impl/injector.py

@@ -2,16 +2,19 @@
 TODO:
  - ** can currently bind in a child/private scope shadowing an external parent binding **
  - better source tracking
- - cache/export ElementCollections lol
  - 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
- - injection listeners
  - 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
@@ -22,7 +25,7 @@ import weakref
 from ... import check
 from ... import lang
 from ...logs import all as logs
-from ..elements import Elements
+from ..elements import CollectedElements
 from ..errors import CyclicDependencyError
 from ..errors import UnboundKeyError
 from ..injector import AsyncInjector
@@ -31,7 +34,6 @@ from ..keys import Key
 from ..keys import as_key
 from ..listeners import ProvisionListener
 from ..listeners import ProvisionListenerBinding
-from ..scopes import ScopeBinding
 from ..scopes import Singleton
 from ..scopes import ThreadScope
 from ..types import Scope
@@ -55,17 +57,16 @@ DEFAULT_SCOPES: list[Scope] = [
 ]
 
 
+@ta.final
 class AsyncInjectorImpl(AsyncInjector, lang.Final):
     def __init__(
             self,
-            ec: ElementCollection,
+            ec: CollectedElements,
             p: ta.Optional['AsyncInjectorImpl'] = None,
             *,
             internal_consts: dict[Key, ta.Any] | None = None,
     ) -> None:
-        super().__init__()
-
-        self._ec = check.isinstance(ec, ElementCollection)
+        self._ec = (ec := check.isinstance(ec, ElementCollection))
         self._p: AsyncInjectorImpl | None = check.isinstance(p, (AsyncInjectorImpl, None))
 
         self._internal_consts: dict[Key, ta.Any] = {
@@ -74,28 +75,31 @@ class AsyncInjectorImpl(AsyncInjector, lang.Final):
         }
 
         self._bim = ec.binding_impl_map()
-        self._ekbs = ec.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._ekbs = ec.sorted_eager_keys_by_scope()
+
+        self._pls: tuple[ProvisionListener, ...] = (
+            *(
+                b.listener
+                for b in ec.elements_of_type(ProvisionListenerBinding)
+            ),
+            *(p._pls if p is not None else []),  # noqa
         )
 
-        self._cs: weakref.WeakSet[AsyncInjectorImpl] | None = None
         self._root: AsyncInjectorImpl = p._root if p is not None else self  # noqa
 
-        self.__cur_req: AsyncInjectorImpl._Request | None = None
-
-        ss = [
-            *DEFAULT_SCOPES,
-            *[sb.scope for sb in ec.elements_of_type(ScopeBinding)],
-        ]
         self._scopes: dict[Scope, ScopeImpl] = {
-            s: make_scope_impl(s) for s in ss
+            s: make_scope_impl(s)
+            for s in itertools.chain(
+                DEFAULT_SCOPES,
+                ec.scope_binding_scopes(),
+            )
         }
 
+    _cs: weakref.WeakSet['AsyncInjectorImpl'] | None = None  # noqa
+
+    __cur_req: ta.Optional['AsyncInjectorImpl._Request'] = None
+
     #
 
     _has_run_init: bool = False
@@ -256,7 +260,7 @@ class AsyncInjectorImpl(AsyncInjector, lang.Final):
         return obj(**kws)
 
 
-async def create_async_injector(es: Elements) -> AsyncInjector:
-    i = AsyncInjectorImpl(ElementCollection(es))
+async def create_async_injector(ce: CollectedElements) -> AsyncInjector:
+    i = AsyncInjectorImpl(ce)
     await i._init()  # noqa
     return i

omlish/inject/impl/inspect.py

@@ -75,7 +75,11 @@ def build_kwargs_target(
         skip_args: int = 0,
         skip_kwargs: ta.Iterable[str] | None = None,
         raw_optional: bool = False,
+        non_strict: bool = False,
 ) -> KwargsTarget:
+    if isinstance(obj, KwargsTarget):
+        return obj
+
     sig = signature(obj)
     tags = _TAGS.get(obj)
 
@@ -90,11 +94,15 @@ def build_kwargs_target(
             continue
 
         if p.annotation is inspect.Signature.empty:
+            if non_strict:
+                continue
             if p.default is not inspect.Parameter.empty:
                 raise KeyError(f'{obj}, {p.name}')
             continue
 
         if p.kind not in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY):
+            if non_strict:
+                continue
             raise TypeError(sig)
 
         ann = p.annotation
@@ -119,7 +127,8 @@ def build_kwargs_target(
             k = dc.replace(k, tag=pt)
 
         if k in seen:
-            raise ConflictingKeyError(k)
+            if not non_strict:
+                raise ConflictingKeyError(k)
         seen.add(k)
 
         kws.append(Kwarg(

omlish/inject/impl/maysync.py

@@ -1,13 +1,12 @@
 import typing as ta
 
 from ... import lang
-from ..elements import Elements
+from ..elements import CollectedElements
 from ..injector import AsyncInjector
 from ..inspect import KwargsTarget
 from ..keys import Key
 from ..maysync import MaysyncInjector
 from ..sync import Injector
-from .elements import ElementCollection
 from .injector import AsyncInjectorImpl
 
 
@@ -30,10 +29,10 @@ class MaysyncInjectorImpl(MaysyncInjector, lang.Final):
         return lang.run_maysync(self._ai.inject(obj))
 
 
-def create_maysync_injector(es: Elements) -> MaysyncInjector:
+def create_maysync_injector(ce: CollectedElements) -> MaysyncInjector:
     si = MaysyncInjectorImpl()
     ai = AsyncInjectorImpl(
-        ElementCollection(es),
+        ce,
         internal_consts={
             Key(MaysyncInjector): si,
             Key(Injector): si,

omlish/inject/impl/multis.py

@@ -1,5 +1,6 @@
 import typing as ta
 
+from ... import check
 from ... import dataclasses as dc
 from ... import lang
 from ..elements import Element
@@ -58,6 +59,7 @@ class MapProviderImpl(ProviderImpl, lang.Final):
 def make_multi_provider_impl(p: Provider, es_by_ty: ta.MutableMapping[type, list[Element]]) -> ProviderImpl:
     if isinstance(p, SetProvider):
         sbs: ta.Iterable[SetBinding] = es_by_ty.pop(SetBinding, ())  # type: ignore
+        check.empty(es_by_ty)
         return SetProviderImpl([
             LinkProviderImpl(LinkProvider(sb.dst))
             for sb in sbs
@@ -65,6 +67,7 @@ def make_multi_provider_impl(p: Provider, es_by_ty: ta.MutableMapping[type, list
 
     elif isinstance(p, MapProvider):
         mbs: ta.Iterable[MapBinding] = es_by_ty.pop(MapBinding, ())  # type: ignore
+        check.empty(es_by_ty)
         return MapProviderImpl([
             MapProviderImpl.Entry(
                 mb.map_key,

omlish/inject/impl/sync.py

@@ -1,12 +1,11 @@
 import typing as ta
 
 from ... import lang
-from ..elements import Elements
+from ..elements import CollectedElements
 from ..injector import AsyncInjector
 from ..inspect import KwargsTarget
 from ..keys import Key
 from ..sync import Injector
-from .elements import ElementCollection
 from .injector import AsyncInjectorImpl
 
 
@@ -29,10 +28,10 @@ class InjectorImpl(Injector, lang.Final):
         return lang.sync_await(self._ai.inject(obj))
 
 
-def create_injector(es: Elements) -> Injector:
+def create_injector(ce: CollectedElements) -> Injector:
     si = InjectorImpl()
     ai = AsyncInjectorImpl(
-        ElementCollection(es),
+        ce,
         internal_consts={
             Key(Injector): si,
         },

omlish/inject/injector.py

@@ -1,9 +1,12 @@
 import abc
 import typing as ta
 
+from .. import check
 from .. import lang
+from .elements import CollectedElements
 from .elements import Elemental
 from .elements import as_elements
+from .elements import collect_elements
 from .inspect import KwargsTarget
 from .keys import Key
 
@@ -44,5 +47,31 @@ class AsyncInjector(lang.Abstract):
         return self.provide(target)
 
 
-def create_async_injector(*args: Elemental) -> ta.Awaitable[AsyncInjector]:
-    return _injector.create_async_injector(as_elements(*args))
+##
+
+
+@ta.final
+class _InjectorCreator(ta.Generic[T]):
+    def __init__(self, fac: ta.Callable[[CollectedElements], T]) -> None:
+        self._fac = fac
+
+    @ta.overload
+    def __call__(self, es: CollectedElements, /) -> T: ...
+
+    @ta.overload
+    def __call__(self, *es: Elemental) -> T: ...
+
+    def __call__(self, arg0, *argv):
+        ce: CollectedElements
+        if isinstance(arg0, CollectedElements):
+            check.arg(not argv)
+            ce = arg0
+        else:
+            ce = collect_elements(as_elements(arg0, *argv))
+        return self._fac(ce)
+
+
+##
+
+
+create_async_injector = _InjectorCreator[ta.Awaitable[AsyncInjector]](lambda ce: _injector.create_async_injector(ce))

omlish/inject/inspect.py

@@ -2,6 +2,7 @@ import typing as ta
 
 from .. import lang
 from .keys import Key
+from .keys import as_key
 
 
 if ta.TYPE_CHECKING:
@@ -21,11 +22,45 @@ class Kwarg(ta.NamedTuple):
     key: Key
     has_default: bool
 
+    @classmethod
+    def of(
+            cls,
+            name: str,
+            key: Key,
+            *,
+            has_default: bool = False,
+    ) -> 'Kwarg':
+        return cls(
+            name,
+            key,
+            has_default,
+        )
+
 
 class KwargsTarget(ta.NamedTuple):
     obj: ta.Any
     kwargs: ta.Sequence[Kwarg]
 
+    @classmethod
+    def of(
+            cls,
+            obj: ta.Any,
+            *kws: Kwarg,
+            **kwargs: tuple[Key, bool] | Key | ta.Any,
+    ) -> 'KwargsTarget':
+        kw_kwargs: list[Kwarg] = []
+        for n, v in kwargs.items():
+            if isinstance(v, tuple):
+                kw_k, kw_hd = v
+                kw_kwargs.append(Kwarg.of(n, kw_k, has_default=kw_hd))
+            else:
+                kw_kwargs.append(Kwarg.of(n, as_key(v)))
+
+        return cls(
+            obj,
+            (*kws, *kw_kwargs),
+        )
+
 
 def tag(obj: T, **kwargs: ta.Any) -> T:
     return _inspect.tag(obj, **kwargs)

omlish/inject/maysync.py

@@ -1,8 +1,7 @@
 import typing as ta
 
 from .. import lang
-from .elements import Elemental
-from .elements import as_elements
+from .injector import _InjectorCreator
 from .sync import Injector
 
 
@@ -25,5 +24,4 @@ class MaysyncInjector(Injector, lang.Abstract):
 ##
 
 
-def create_maysync_injector(*args: Elemental) -> MaysyncInjector:
-    return _maysync.create_maysync_injector(as_elements(*args))
+create_maysync_injector = _InjectorCreator[MaysyncInjector](lambda ce: _maysync.create_maysync_injector(ce))

omlish/inject/multis.py

@@ -1,5 +1,7 @@
 """
 TODO:
+ - DynamicSetBinding / DynamicMapBinding ? provider of set[T] / map[K, V] ?
+  - doable not guicey - too much dynamism
  - scopes
 """
 import collections.abc
@@ -94,6 +96,9 @@ class SetBinder(ElementGenerator, ta.Generic[T]):
         yield from self._sbs
 
 
+set_binder = SetBinder
+
+
 #
 
 
@@ -123,3 +128,6 @@ class MapBinder(ElementGenerator, ta.Generic[K, V]):
     def __iter__(self) -> ta.Iterator[Element]:
         yield self._map_provider_binding
         yield from self._mbs
+
+
+map_binder = MapBinder

omlish/inject/overrides.py

@@ -14,9 +14,9 @@ from .elements import as_elements
 @dc.dataclass(frozen=True)
 @dc.extra_class_params(cache_hash=True)
 class Overrides(Element, lang.Final):
-    ovr: Elements = dc.xfield(coerce=check.of_isinstance(Elements))
     src: Elements = dc.xfield(coerce=check.of_isinstance(Elements))
+    ovr: Elements = dc.xfield(coerce=check.of_isinstance(Elements))
 
 
-def override(ovr: ta.Any, *a: ta.Any) -> Element:
-    return Overrides(as_elements(ovr), as_elements(*a))
+def override(src: ta.Any, *ovr: ta.Any) -> Element:
+    return Overrides(as_elements(src), as_elements(*ovr))

omlish/inject/privates.py

@@ -18,6 +18,12 @@ class Expose(Element, lang.Final):
     key: Key = dc.xfield(coerce=as_key)
 
 
+expose = Expose
+
+
+#
+
+
 @dc.dataclass(frozen=True)
 @dc.extra_class_params(cache_hash=True)
 class Private(Element, lang.Final):

omlish/inject/providers.py

@@ -3,6 +3,7 @@ import typing as ta
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
+from .inspect import KwargsTarget
 from .keys import Key
 
 
@@ -20,13 +21,13 @@ class Provider(lang.Abstract):
 @dc.dataclass(frozen=True)
 @dc.extra_class_params(cache_hash=True)
 class AsyncFnProvider(Provider):
-    fn: ta.Any = dc.xfield(validate=callable)
+    fn: ta.Any = dc.xfield(validate=lambda v: callable(v) or isinstance(v, KwargsTarget))
 
 
 @dc.dataclass(frozen=True)
 @dc.extra_class_params(cache_hash=True)
 class FnProvider(Provider):
-    fn: ta.Any = dc.xfield(validate=callable)
+    fn: ta.Any = dc.xfield(validate=lambda v: callable(v) or isinstance(v, KwargsTarget))
 
 
 @dc.dataclass(frozen=True)

omlish/inject/sync.py

@@ -2,8 +2,7 @@ import abc
 import typing as ta
 
 from .. import lang
-from .elements import Elemental
-from .elements import as_elements
+from .injector import _InjectorCreator
 from .inspect import KwargsTarget
 from .keys import Key
 
@@ -44,5 +43,7 @@ class Injector(lang.Abstract):
         return self.provide(target)
 
 
-def create_injector(*args: Elemental) -> Injector:
-    return _sync.create_injector(as_elements(*args))
+##
+
+
+create_injector = _InjectorCreator[Injector](lambda ce: _sync.create_injector(ce))

omlish/io/buffers.py

@@ -1,10 +1,18 @@
 # ruff: noqa: UP006 UP007 UP043 UP045
 # @omlish-lite
+"""
+TODO:
+ - overhaul and just coro-ify pyio?
+"""
 import io
 import typing as ta
 
 from ..lite.attrops import attr_repr
 from ..lite.check import check
+from .readers import AsyncBufferedBytesReader
+from .readers import AsyncRawBytesReader
+from .readers import BufferedBytesReader
+from .readers import RawBytesReader
 
 
 ##
@@ -183,6 +191,9 @@ class ReadableListBuffer:
 
         self._lst: list[bytes] = []
 
+    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))
 
@@ -208,6 +219,9 @@ class ReadableListBuffer:
 
     def read(self, n: ta.Optional[int] = None) -> ta.Optional[bytes]:
         if n is None:
+            if not self._lst:
+                return b''
+
             o = b''.join(self._lst)
             self._lst = []
             return o
@@ -246,6 +260,110 @@ class ReadableListBuffer:
         r = self.read_until_(delim)
         return r if isinstance(r, bytes) else None
 
+    #
+
+    DEFAULT_BUFFERED_READER_CHUNK_SIZE: ta.ClassVar[int] = -1
+
+    @ta.final
+    class _BufferedBytesReader(BufferedBytesReader):
+        def __init__(
+                self,
+                raw: RawBytesReader,
+                buf: 'ReadableListBuffer',
+                *,
+                chunk_size: ta.Optional[int] = None,
+        ) -> None:
+            self._raw = raw
+            self._buf = buf
+            self._chunk_size = chunk_size or ReadableListBuffer.DEFAULT_BUFFERED_READER_CHUNK_SIZE
+
+        def read1(self, n: int = -1, /) -> bytes:
+            if n < 0:
+                n = self._chunk_size
+            if not n:
+                return b''
+            if 0 < n <= len(self._buf):
+                return self._buf.read(n) or b''
+            return self._raw.read1(n)
+
+        def read(self, /, n: int = -1) -> bytes:
+            if n < 0:
+                return self.readall()
+            while len(self._buf) < n:
+                if not (b := self._raw.read1(n)):
+                    break
+                self._buf.feed(b)
+            return self._buf.read(n) or b''
+
+        def readall(self) -> bytes:
+            buf = io.BytesIO()
+            buf.write(self._buf.read() or b'')
+            while (b := self._raw.read1(self._chunk_size)):
+                buf.write(b)
+            return buf.getvalue()
+
+    def new_buffered_reader(
+            self,
+            raw: RawBytesReader,
+            *,
+            chunk_size: ta.Optional[int] = None,
+    ) -> BufferedBytesReader:
+        return self._BufferedBytesReader(
+            raw,
+            self,
+            chunk_size=chunk_size,
+        )
+
+    @ta.final
+    class _AsyncBufferedBytesReader(AsyncBufferedBytesReader):
+        def __init__(
+                self,
+                raw: AsyncRawBytesReader,
+                buf: 'ReadableListBuffer',
+                *,
+                chunk_size: ta.Optional[int] = None,
+        ) -> None:
+            self._raw = raw
+            self._buf = buf
+            self._chunk_size = chunk_size or ReadableListBuffer.DEFAULT_BUFFERED_READER_CHUNK_SIZE
+
+        async def read1(self, n: int = -1, /) -> bytes:
+            if n < 0:
+                n = self._chunk_size
+            if not n:
+                return b''
+            if 0 < n <= len(self._buf):
+                return self._buf.read(n) or b''
+            return await self._raw.read1(n)
+
+        async def read(self, /, n: int = -1) -> bytes:
+            if n < 0:
+                return await self.readall()
+            while len(self._buf) < n:
+                if not (b := await self._raw.read1(n)):
+                    break
+                self._buf.feed(b)
+            return self._buf.read(n) or b''
+
+        async def readall(self) -> bytes:
+            buf = io.BytesIO()
+            buf.write(self._buf.read() or b'')
+            while b := await self._raw.read1(self._chunk_size):
+                buf.write(b)
+            return buf.getvalue()
+
+    def new_async_buffered_reader(
+            self,
+            raw: AsyncRawBytesReader,
+            *,
+            chunk_size: ta.Optional[int] = None,
+    ) -> AsyncBufferedBytesReader:
+        return self._AsyncBufferedBytesReader(
+            raw,
+            self,
+            chunk_size=chunk_size,
+        )
+
 
 ##
 

omlish/io/readers.py

@@ -0,0 +1,29 @@
+# ruff: noqa: UP045
+# @omlish-lite
+import typing as ta
+
+
+##
+
+
+class RawBytesReader(ta.Protocol):
+    def read1(self, n: int = -1, /) -> bytes: ...
+
+
+class BufferedBytesReader(RawBytesReader, ta.Protocol):
+    def read(self, n: int = -1, /) -> bytes: ...
+
+    def readall(self) -> bytes: ...
+
+
+#
+
+
+class AsyncRawBytesReader(ta.Protocol):
+    def read1(self, n: int = -1, /) -> ta.Awaitable[bytes]: ...
+
+
+class AsyncBufferedBytesReader(AsyncRawBytesReader, ta.Protocol):
+    def read(self, n: int = -1, /) -> ta.Awaitable[bytes]: ...
+
+    def readall(self) -> ta.Awaitable[bytes]: ...

omlish/iterators/transforms.py

@@ -83,8 +83,8 @@ apply = Apply
 
 @dc.dataclass(frozen=True)
 class Flatten(Transform_[ta.Iterable[T], T]):
-    def __call__(self, it: ta.Iterable[ta.Iterable[T]]) -> ta.Iterable[U]:
-        return itertools.chain.from_iterable(it)  # type: ignore[arg-type]
+    def __call__(self, it: ta.Iterable[ta.Iterable[T]]) -> ta.Iterable[T]:
+        return itertools.chain.from_iterable(it)
 
 
 flatten = Flatten