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

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