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

omlish/inject/sync.py

@@ -0,0 +1,49 @@
+import abc
+import typing as ta
+
+from .. import lang
+from .injector import _InjectorCreator
+from .inspect import KwargsTarget
+from .keys import Key
+
+
+if ta.TYPE_CHECKING:
+    from .impl import sync as _sync
+else:
+    _sync = lang.proxy_import('.impl.sync', __package__)
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class Injector(lang.Abstract):
+    @abc.abstractmethod
+    def try_provide(self, key: ta.Any) -> lang.Maybe[ta.Any]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def provide(self, key: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def provide_kwargs(self, kt: KwargsTarget) -> ta.Mapping[str, ta.Any]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def inject(self, obj: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+    def __getitem__(
+            self,
+            target: Key[T] | type[T],
+    ) -> T:
+        return self.provide(target)
+
+
+##
+
+
+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 ..lite.strings import attr_repr
+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/__init__.py

@@ -1,23 +1,31 @@
-from .iterators import (  # noqa
-    PeekIterator,
-    PrefetchIterator,
-    ProxyIterator,
-    RetainIterator,
-)
+from .. import lang as _lang  # noqa
 
-from .recipes import (  # noqa
-    sliding_window,
-)
 
-from .tools import (  # noqa
-    expand_indexed_pairs,
-    merge_on,
-    take,
-    unzip,
-)
+with _lang.auto_proxy_init(globals()):
+    ##
 
-from .unique import (  # noqa
-    UniqueItem,
-    UniqueIterator,
-    UniqueStats,
-)
+    from .iterators import (  # noqa
+        PeekIterator,
+        PrefetchIterator,
+        ProxyIterator,
+        RetainIterator,
+    )
+
+    from .recipes import (  # noqa
+        sliding_window,
+    )
+
+    from .tools import (  # noqa
+        expand_indexed_pairs,
+        merge_on,
+        take,
+        unzip,
+    )
+
+    from . import transforms as tf  # noqa
+
+    from .unique import (  # noqa
+        UniqueItem,
+        UniqueIterator,
+        UniqueStats,
+    )

omlish/iterators/transforms.py

@@ -0,0 +1,204 @@
+import abc
+import dataclasses as dc
+import itertools
+import typing as ta
+
+from .. import lang
+
+
+T = ta.TypeVar('T')
+U = ta.TypeVar('U')
+
+Transform: ta.TypeAlias = ta.Callable[[ta.Iterable[T]], ta.Iterable[U]]
+
+X0 = ta.TypeVar('X0')
+X1 = ta.TypeVar('X1')
+X2 = ta.TypeVar('X2')
+X3 = ta.TypeVar('X3')
+X4 = ta.TypeVar('X4')
+X5 = ta.TypeVar('X5')
+
+
+##
+
+
+_filter = filter
+_map = map
+_zip = zip
+
+
+##
+
+
+class Transform_(lang.Abstract, ta.Generic[T, U]):  # noqa
+    @abc.abstractmethod
+    def __call__(self, it: ta.Iterable[T]) -> ta.Iterable[U]:
+        raise NotImplementedError
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Filter(Transform_[T, T]):
+    fn: ta.Callable[[T], bool] | None
+
+    def __call__(self, it: ta.Iterable[T]) -> ta.Iterable[T]:
+        return _filter(self.fn, it)
+
+
+filter = Filter  # noqa
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Map(Transform_[T, U]):
+    fn: ta.Callable[[T], U]
+
+    def __call__(self, it: ta.Iterable[T]) -> ta.Iterable[U]:
+        return _map(self.fn, it)
+
+
+map = Map  # noqa
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Apply(Transform_[T, T]):
+    fn: ta.Callable[[T], ta.Any]
+
+    def __call__(self, it: ta.Iterable[T]) -> ta.Iterable[T]:
+        return _map(lambda e: (self.fn(e), e)[1], it)
+
+
+apply = Apply
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Flatten(Transform_[ta.Iterable[T], T]):
+    def __call__(self, it: ta.Iterable[ta.Iterable[T]]) -> ta.Iterable[T]:
+        return itertools.chain.from_iterable(it)
+
+
+flatten = Flatten
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class FlatMap(Transform_[T, U]):
+    fn: ta.Callable[[T], ta.Iterable[U]]
+
+    def __call__(self, it: ta.Iterable[T]) -> ta.Iterable[U]:
+        return itertools.chain.from_iterable(_map(self.fn, it))
+
+
+flat_map = FlatMap
+
+# Alternatively:
+# def flat_map(fn: ta.Callable[[T], ta.Iterable[U]]) -> Transform[T, U]:
+#     return compose(map(fn), flatten())
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Compose(Transform_[T, U]):
+    tfs: ta.Sequence[Transform]
+
+    def __call__(self, it: ta.Iterable[T]) -> ta.Iterable[U]:
+        for tf in self.tfs:
+            it = tf(it)
+        return it  # type: ignore[return-value]
+
+
+@ta.overload
+def compose(
+        tf0: Transform[T, U],
+) -> Transform[T, U]:
+    ...
+
+
+@ta.overload
+def compose(
+        tf0: Transform[T, X0],
+        tf1: Transform[X0, U],
+) -> Transform[T, U]:
+    ...
+
+
+@ta.overload
+def compose(
+        tf0: Transform[T, X0],
+        tf1: Transform[X0, X1],
+        tf2: Transform[X1, U],
+) -> Transform[T, U]:
+    ...
+
+
+@ta.overload
+def compose(
+        tf0: Transform[T, X0],
+        tf1: Transform[X0, X1],
+        tf2: Transform[X1, X2],
+        tf3: Transform[X2, U],
+) -> Transform[T, U]:
+    ...
+
+
+@ta.overload
+def compose(
+        tf0: Transform[T, X0],
+        tf1: Transform[X0, X1],
+        tf2: Transform[X1, X2],
+        tf3: Transform[X2, X3],
+        tf4: Transform[X3, U],
+) -> Transform[T, U]:
+    ...
+
+
+@ta.overload
+def compose(
+        tf0: Transform[T, X0],
+        tf1: Transform[X0, X1],
+        tf2: Transform[X1, X2],
+        tf3: Transform[X2, X3],
+        tf4: Transform[X3, X4],
+        tf5: Transform[X4, U],
+) -> Transform[T, U]:
+    ...
+
+
+@ta.overload
+def compose(
+        tf0: Transform[T, X0],
+        tf1: Transform[X0, X1],
+        tf2: Transform[X1, X2],
+        tf3: Transform[X2, X3],
+        tf4: Transform[X3, X4],
+        tf5: Transform[X4, X5],
+        tf6: Transform[X5, U],
+) -> Transform[T, U]:
+    ...
+
+
+@ta.overload
+def compose(
+        *tf: Transform,
+) -> Transform:
+    ...
+
+
+def compose(tf0, *tfn):
+    if not tfn:
+        return tf0
+    return Compose([tf0, *tfn])