omlish 0.0.0.dev195__py3-none-any.whl → 0.0.0.dev197__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev195'
-__revision__ = '8bbac0c946d60a9f0b3d684c3f701165d7247971'
+__version__ = '0.0.0.dev197'
+__revision__ = 'e4b51b7c95116d97eddbd8f1a37a1c1a42cc8e39'
 
 
 #
@@ -32,7 +32,7 @@ class Project(ProjectBase):
 
     optional_dependencies = {
         'async': [
-            'anyio ~= 4.7',
+            'anyio ~= 4.8',
             'sniffio ~= 1.3',
 
             'greenlet ~= 3.1',

omlish/asyncs/asyncio/all.py

@@ -1,7 +1,6 @@
 # ruff: noqa: I001
 from .asyncio import (  # noqa
     asyncio_once,
-    get_real_current_loop,
     drain_tasks,
     draining_asyncio_tasks,
 )

omlish/asyncs/asyncio/asyncio.py

@@ -20,13 +20,9 @@ def asyncio_once(fn: CallableT) -> CallableT:
     return ta.cast(CallableT, inner)
 
 
-def get_real_current_loop() -> asyncio.AbstractEventLoop | None:
-    return asyncio.get_event_loop_policy()._local._loop  # type: ignore  # noqa
-
-
 def drain_tasks(loop=None):
     if loop is None:
-        loop = get_real_current_loop()
+        loop = asyncio.get_running_loop()
 
     while loop._ready or loop._scheduled:  # noqa
         loop._run_once()  # noqa
@@ -34,7 +30,7 @@ def drain_tasks(loop=None):
 
 @contextlib.contextmanager
 def draining_asyncio_tasks() -> ta.Iterator[None]:
-    loop = get_real_current_loop()
+    loop = asyncio.get_running_loop()
     try:
         yield
     finally:

omlish/asyncs/bluelet/runner.py

@@ -233,7 +233,7 @@ class _BlueletRunner:
 
         try:
             if is_exc:
-                next_event = coro.throw(*value)
+                next_event = coro.throw(value[0])
             else:
                 next_event = coro.send(value)
 

omlish/asyncs/bridge.py

@@ -86,7 +86,7 @@ class BridgeAwaitRequiredError(Exception):
     pass
 
 
-class MissingBridgeGreenletError(Exception):
+class MissingBridgeThreadletError(Exception):
     pass
 
 
@@ -224,7 +224,7 @@ def s_to_a_await(awaitable: ta.Awaitable[T]) -> T:
 
     if not getattr(g.underlying, _BRIDGE_THREADLET_ATTR, False):
         _safe_cancel_awaitable(awaitable)
-        raise MissingBridgeGreenletError
+        raise MissingBridgeThreadletError
 
     return check.not_none(g.parent).switch(awaitable)
 

omlish/codecs/base.py

@@ -7,11 +7,11 @@ TODO:
 import abc
 import typing as ta
 
-from omlish import check
-from omlish import dataclasses as dc
-from omlish import lang
-from omlish import reflect as rfl
-from omlish.funcs import pairs as fps
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+from .. import reflect as rfl
+from ..funcs import pairs as fps
 
 
 I = ta.TypeVar('I')

omlish/codecs/text.py

@@ -3,8 +3,7 @@ import dataclasses as dc
 import functools
 import typing as ta
 
-from omlish import check
-
+from .. import check
 from .base import Codec
 from .base import ComboCodec
 from .standard import STANDARD_CODECS

omlish/io/compress/adapters.py

@@ -37,8 +37,8 @@
 import typing as ta
 
 from ... import check
-from ..generators import BytesSteppedGenerator
-from ..generators import BytesSteppedReaderGenerator
+from ..coro import BytesSteppedCoro
+from ..coro import BytesSteppedReaderCoro
 from .abc import CompressorObject
 from .abc import NeedsInputDecompressorObject
 from .abc import UnconsumedTailDecompressorObject
@@ -56,7 +56,7 @@ class CompressorObjectIncrementalAdapter:
 
         self._factory = factory
 
-    def __call__(self) -> BytesSteppedGenerator:
+    def __call__(self) -> BytesSteppedCoro:
         compressor = self._factory()
 
         while True:
@@ -89,7 +89,7 @@ class DecompressorObjectIncrementalAdapter:
         self._factory = factory
         self._trailing_error = trailing_error
 
-    def __call__(self) -> BytesSteppedReaderGenerator:
+    def __call__(self) -> BytesSteppedReaderCoro:
         pos = 0
 
         data = None  # Default if EOF is encountered

omlish/io/compress/base.py

@@ -1,7 +1,7 @@
 import abc
 
-from ..generators import BytesSteppedGenerator
-from ..generators import BytesSteppedReaderGenerator
+from ..coro import BytesSteppedCoro
+from ..coro import BytesSteppedReaderCoro
 
 
 class Compression(abc.ABC):
@@ -16,9 +16,9 @@ class Compression(abc.ABC):
 
 class IncrementalCompression(abc.ABC):
     @abc.abstractmethod
-    def compress_incremental(self) -> BytesSteppedGenerator[None]:
+    def compress_incremental(self) -> BytesSteppedCoro[None]:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def decompress_incremental(self) -> BytesSteppedReaderGenerator[None]:
+    def decompress_incremental(self) -> BytesSteppedReaderCoro[None]:
         raise NotImplementedError

omlish/io/compress/bz2.py

@@ -3,8 +3,8 @@ import functools
 import typing as ta
 
 from ... import lang
-from ..generators import BytesSteppedGenerator
-from ..generators import BytesSteppedReaderGenerator
+from ..coro import BytesSteppedCoro
+from ..coro import BytesSteppedReaderCoro
 from .adapters import CompressorObjectIncrementalAdapter
 from .adapters import DecompressorObjectIncrementalAdapter
 from .base import Compression
@@ -37,7 +37,7 @@ class Bz2Compression(Compression, IncrementalCompression):
             d,
         )
 
-    def compress_incremental(self) -> BytesSteppedGenerator[None]:
+    def compress_incremental(self) -> BytesSteppedCoro[None]:
         return lang.nextgen(CompressorObjectIncrementalAdapter(
             functools.partial(
                 bz2.BZ2Compressor,  # type: ignore
@@ -45,7 +45,7 @@ class Bz2Compression(Compression, IncrementalCompression):
             ),
         )())
 
-    def decompress_incremental(self) -> BytesSteppedReaderGenerator[None]:
+    def decompress_incremental(self) -> BytesSteppedReaderCoro[None]:
         return DecompressorObjectIncrementalAdapter(
             bz2.BZ2Decompressor,  # type: ignore
             trailing_error=OSError,

omlish/io/compress/codecs.py

@@ -2,7 +2,7 @@ import dataclasses as dc
 import typing as ta
 
 from ... import codecs
-from ..generators import buffer_bytes_stepped_reader_generator
+from ..coro import buffer_bytes_stepped_reader_coro
 from .base import Compression
 from .base import IncrementalCompression
 
@@ -32,7 +32,7 @@ class CompressionIncrementalCodec(codecs.IncrementalCodec[bytes, bytes]):
         return self.compression.compress_incremental()
 
     def decode_incremental(self) -> ta.Generator[bytes | None, bytes, None]:
-        return buffer_bytes_stepped_reader_generator(self.compression.decompress_incremental())
+        return buffer_bytes_stepped_reader_coro(self.compression.decompress_incremental())
 
 
 ##

omlish/io/compress/gzip.py

@@ -43,9 +43,9 @@ import typing as ta
 from ... import cached
 from ... import check
 from ... import lang
-from ..generators import BytesSteppedGenerator
-from ..generators import BytesSteppedReaderGenerator
-from ..generators.readers import PrependableBytesGeneratorReader
+from ..coro import BytesSteppedCoro
+from ..coro import BytesSteppedReaderCoro
+from ..coro.readers import PrependableBytesCoroReader
 from .base import Compression
 from .base import IncrementalCompression
 from .codecs import make_compression_codec
@@ -86,13 +86,13 @@ class GzipCompression(Compression, IncrementalCompression):
             d,
         )
 
-    def compress_incremental(self) -> BytesSteppedGenerator[None]:
+    def compress_incremental(self) -> BytesSteppedCoro[None]:
         return lang.nextgen(IncrementalGzipCompressor(
             level=self.level,
             mtime=self.mtime,
         )())
 
-    def decompress_incremental(self) -> BytesSteppedReaderGenerator[None]:
+    def decompress_incremental(self) -> BytesSteppedReaderCoro[None]:
         return IncrementalGzipDecompressor()()
 
 
@@ -159,7 +159,7 @@ class IncrementalGzipCompressor:
         if fname:
             check.none((yield fname + b'\000'))
 
-    def __call__(self) -> BytesSteppedGenerator:
+    def __call__(self) -> BytesSteppedCoro:
         crc = _zero_crc()
         size = 0
         offset = 0  # Current file offset for seek(), tell(), etc
@@ -222,7 +222,7 @@ class IncrementalGzipDecompressor:
 
     def _read_gzip_header(
             self,
-            rdr: PrependableBytesGeneratorReader,
+            rdr: PrependableBytesCoroReader,
     ) -> ta.Generator[int | None, bytes, int | None]:
         magic = yield from rdr.read(2)
         if magic == b'':
@@ -264,7 +264,7 @@ class IncrementalGzipDecompressor:
 
     def _read_eof(
             self,
-            rdr: PrependableBytesGeneratorReader,
+            rdr: PrependableBytesCoroReader,
             crc: int,
             stream_size: int,
     ) -> ta.Generator[int | None, bytes, None]:
@@ -286,8 +286,8 @@ class IncrementalGzipDecompressor:
         if c:
             rdr.prepend(c)
 
-    def __call__(self) -> BytesSteppedReaderGenerator:
-        rdr = PrependableBytesGeneratorReader()
+    def __call__(self) -> BytesSteppedReaderCoro:
+        rdr = PrependableBytesCoroReader()
 
         pos = 0  # Current offset in decompressed stream
 

omlish/io/compress/lz4.py

@@ -3,7 +3,7 @@ import typing as ta
 
 from ... import check
 from ... import lang
-from ..generators import BytesSteppedGenerator
+from ..coro import BytesSteppedCoro
 from .base import Compression
 from .base import IncrementalCompression
 from .codecs import make_compression_codec
@@ -46,7 +46,7 @@ class Lz4Compression(Compression, IncrementalCompression):
         )
 
     @lang.autostart
-    def compress_incremental(self) -> BytesSteppedGenerator[None]:
+    def compress_incremental(self) -> BytesSteppedCoro[None]:
         with lz4_frame.LZ4FrameCompressor(
                 compression_level=self.level,
                 block_size=self.block_size,
@@ -69,9 +69,9 @@ class Lz4Compression(Compression, IncrementalCompression):
                     yield o
 
     @lang.autostart
-    def decompress_incremental(self) -> BytesSteppedGenerator[None]:
-        # lz4 lib does internal buffering so this is simply a BytesSteppedGenerator not a BytesSteppedReaderGenerator as
-        # it only yields None, accepting any number of bytes at a time.
+    def decompress_incremental(self) -> BytesSteppedCoro[None]:
+        # lz4 lib does internal buffering so this is simply a BytesSteppedCoro not a BytesSteppedReaderCoro as it
+        # only yields None, accepting any number of bytes at a time.
         with lz4_frame.LZ4FrameDecompressor() as decompressor:
             while True:
                 i = check.isinstance((yield None), bytes)

omlish/io/compress/lzma.py

@@ -3,8 +3,8 @@ import functools
 import typing as ta
 
 from ... import lang
-from ..generators import BytesSteppedGenerator
-from ..generators import BytesSteppedReaderGenerator
+from ..coro import BytesSteppedCoro
+from ..coro import BytesSteppedReaderCoro
 from .adapters import CompressorObjectIncrementalAdapter
 from .adapters import DecompressorObjectIncrementalAdapter
 from .base import Compression
@@ -49,7 +49,7 @@ class LzmaCompression(Compression, IncrementalCompression):
             filters=self.filters,  # type: ignore[arg-type]
         )
 
-    def compress_incremental(self) -> BytesSteppedGenerator[None]:
+    def compress_incremental(self) -> BytesSteppedCoro[None]:
         return lang.nextgen(CompressorObjectIncrementalAdapter(
             functools.partial(  # type: ignore
                 lzma.LZMACompressor,
@@ -60,7 +60,7 @@ class LzmaCompression(Compression, IncrementalCompression):
             ),
         )())
 
-    def decompress_incremental(self) -> BytesSteppedReaderGenerator[None]:
+    def decompress_incremental(self) -> BytesSteppedReaderCoro[None]:
         return DecompressorObjectIncrementalAdapter(
             functools.partial(  # type: ignore
                 lzma.LZMADecompressor,

omlish/io/compress/zlib.py

@@ -3,8 +3,8 @@ import functools
 import typing as ta
 
 from ... import lang
-from ..generators import BytesSteppedGenerator
-from ..generators import BytesSteppedReaderGenerator
+from ..coro import BytesSteppedCoro
+from ..coro import BytesSteppedReaderCoro
 from .adapters import CompressorObjectIncrementalAdapter
 from .adapters import DecompressorObjectIncrementalAdapter
 from .base import Compression
@@ -43,7 +43,7 @@ class ZlibCompression(Compression, IncrementalCompression):
             **(dict(wbits=self.wbits) if self.wbits is not None else {}),
         )
 
-    def compress_incremental(self) -> BytesSteppedGenerator[None]:
+    def compress_incremental(self) -> BytesSteppedCoro[None]:
         return lang.nextgen(CompressorObjectIncrementalAdapter(
             functools.partial(
                 zlib.compressobj,  # type: ignore
@@ -54,7 +54,7 @@ class ZlibCompression(Compression, IncrementalCompression):
             ),
         )())
 
-    def decompress_incremental(self) -> BytesSteppedReaderGenerator[None]:
+    def decompress_incremental(self) -> BytesSteppedReaderCoro[None]:
         return DecompressorObjectIncrementalAdapter(
             functools.partial(  # type: ignore
                 zlib.decompressobj,

omlish/io/coro/__init__.py

@@ -0,0 +1,56 @@
+from .consts import (  # noqa
+    DEFAULT_BUFFER_SIZE,
+)
+
+from .direct import (  # noqa
+    DirectCoro,
+
+    BytesDirectCoro,
+    StrDirectCoro,
+)
+
+from .readers import (  # noqa
+    ReaderCoro,
+    BytesReaderCoro,
+    StrReaderCoro,
+
+    ExactReaderCoro,
+    BytesExactReaderCoro,
+    StrExactReaderCoro,
+
+    CoroReader,
+
+    PrependableCoroReader,
+    PrependableBytesCoroReader,
+    PrependableStrCoroReader,
+    prependable_bytes_coro_reader,
+    prependable_str_coro_reader,
+
+    BufferedCoroReader,
+    BufferedBytesCoroReader,
+    BufferedStrCoroReader,
+    buffered_bytes_coro_reader,
+    buffered_str_coro_reader,
+)
+
+from .stepped import (  # noqa
+    SteppedCoro,
+    BytesSteppedCoro,
+    StrSteppedCoro,
+    BytesToStrSteppedCoro,
+    StrToBytesSteppedCoro,
+
+    SteppedReaderCoro,
+    BytesSteppedReaderCoro,
+    StrSteppedReaderCoro,
+
+    flatmap_stepped_coro,
+
+    joined_bytes_stepped_coro,
+    joined_str_stepped_coro,
+
+    read_into_bytes_stepped_coro,
+    read_into_str_stepped_coro,
+
+    buffer_bytes_stepped_reader_coro,
+)

omlish/io/coro/direct.py

@@ -0,0 +1,13 @@
+import typing as ta
+
+
+O = ta.TypeVar('O')
+I = ta.TypeVar('I')
+R = ta.TypeVar('R')
+
+
+# Direct coros yield outputs 1:1 with inputs.
+DirectCoro: ta.TypeAlias = ta.Generator[O, I, R]
+
+BytesDirectCoro: ta.TypeAlias = DirectCoro[bytes, bytes, R]
+StrDirectCoro: ta.TypeAlias = DirectCoro[str, str, R]

omlish/io/{generators → coro}/readers.py

@@ -1,6 +1,6 @@
 """
 TODO:
- - BufferedBytesGeneratorReader
+ - BufferedBytesCoroReader
  - docstrings
  - memoryviews
 """
@@ -20,18 +20,18 @@ R = ta.TypeVar('R')
 AnyT = ta.TypeVar('AnyT', bound=ta.Any)
 
 
-# Reader generators yield ints of amounts of data needed, or None for needing any amount of data.
-ReaderGenerator: ta.TypeAlias = ta.Generator[int | None, I, R]
+# Reader coros yield ints of amounts of data needed, or None for needing any amount of data.
+ReaderCoro: ta.TypeAlias = ta.Generator[int | None, I, R]
 
-BytesReaderGenerator: ta.TypeAlias = ReaderGenerator[bytes, R]
-StrReaderGenerator: ta.TypeAlias = ReaderGenerator[str, R]
+BytesReaderCoro: ta.TypeAlias = ReaderCoro[bytes, R]
+StrReaderCoro: ta.TypeAlias = ReaderCoro[str, R]
 
 
-# Exact reader generators always specify read sizes.
-ExactReaderGenerator: ta.TypeAlias = ta.Generator[int, I, R]
+# Exact reader coros always specify read sizes.
+ExactReaderCoro: ta.TypeAlias = ta.Generator[int, I, R]
 
-BytesExactReaderGenerator: ta.TypeAlias = ExactReaderGenerator[bytes, R]
-StrExactReaderGenerator: ta.TypeAlias = ExactReaderGenerator[str, R]
+BytesExactReaderCoro: ta.TypeAlias = ExactReaderCoro[bytes, R]
+StrExactReaderCoro: ta.TypeAlias = ExactReaderCoro[str, R]
 
 
 ##
@@ -50,22 +50,22 @@ class _StrJoiner:
 ##
 
 
-class GeneratorReader(abc.ABC, ta.Generic[T]):
+class CoroReader(abc.ABC, ta.Generic[T]):
     @abc.abstractmethod
-    def read(self, sz: int | None) -> ReaderGenerator[T, T]:
+    def read(self, sz: int | None) -> ReaderCoro[T, T]:
         raise NotImplementedError
 
-    def read_exact(self, sz: int) -> ReaderGenerator[T, T]:
+    def read_exact(self, sz: int) -> ReaderCoro[T, T]:
         d: ta.Any = yield from self.read(sz)
         if len(d) != sz:
-            raise EOFError(f'GeneratorReader got {len(d)}, expected {sz}')
+            raise EOFError(f'CoroReader got {len(d)}, expected {sz}')
         return d
 
 
 ##
 
 
-class PrependableGeneratorReader(GeneratorReader[AnyT]):
+class PrependableCoroReader(CoroReader[AnyT]):
     def __init__(self) -> None:
         super().__init__()
 
@@ -75,7 +75,7 @@ class PrependableGeneratorReader(GeneratorReader[AnyT]):
     def _join(self, lst: list[AnyT]) -> AnyT:
         raise NotImplementedError
 
-    def read(self, sz: int | None) -> ReaderGenerator[AnyT, AnyT]:
+    def read(self, sz: int | None) -> ReaderCoro[AnyT, AnyT]:
         if not self._queue:
             d: AnyT = check.not_none((yield sz))
             return d
@@ -112,28 +112,28 @@ class PrependableGeneratorReader(GeneratorReader[AnyT]):
             self._queue.insert(0, (d, p or 0))
 
 
-class PrependableBytesGeneratorReader(
+class PrependableBytesCoroReader(
     _BytesJoiner,
-    PrependableGeneratorReader[bytes],
+    PrependableCoroReader[bytes],
 ):
     pass
 
 
-class PrependableStrGeneratorReader(
+class PrependableStrCoroReader(
     _StrJoiner,
-    PrependableGeneratorReader[str],
+    PrependableCoroReader[str],
 ):
     pass
 
 
-prependable_bytes_generator_reader = PrependableBytesGeneratorReader
-prependable_str_generator_reader = PrependableStrGeneratorReader
+prependable_bytes_coro_reader = PrependableBytesCoroReader
+prependable_str_coro_reader = PrependableStrCoroReader
 
 
 ##
 
 
-class BufferedGeneratorReader(PrependableGeneratorReader[AnyT], abc.ABC):
+class BufferedCoroReader(PrependableCoroReader[AnyT], abc.ABC):
     def __init__(
             self,
             buffer_size: int = DEFAULT_BUFFER_SIZE,
@@ -144,7 +144,7 @@ class BufferedGeneratorReader(PrependableGeneratorReader[AnyT], abc.ABC):
 
         self._buffer_size = buffer_size
 
-    def read(self, sz: int | None) -> ReaderGenerator[AnyT, AnyT]:
+    def read(self, sz: int | None) -> ReaderCoro[AnyT, AnyT]:
         g = super().read(sz)
         i: ta.Any = None
         while True:
@@ -169,21 +169,21 @@ class BufferedGeneratorReader(PrependableGeneratorReader[AnyT], abc.ABC):
             self.prepend(d, q)
 
 
-class BufferedBytesGeneratorReader(
+class BufferedBytesCoroReader(
     _BytesJoiner,
-    BufferedGeneratorReader[bytes],
-    PrependableGeneratorReader[bytes],
+    BufferedCoroReader[bytes],
+    PrependableCoroReader[bytes],
 ):
     pass
 
 
-class BufferedStrGeneratorReader(
+class BufferedStrCoroReader(
     _StrJoiner,
-    BufferedGeneratorReader[str],
-    PrependableGeneratorReader[str],
+    BufferedCoroReader[str],
+    PrependableCoroReader[str],
 ):
     pass
 
 
-buffered_bytes_generator_reader = BufferedBytesGeneratorReader
-buffered_str_generator_reader = BufferedStrGeneratorReader
+buffered_bytes_coro_reader = BufferedBytesCoroReader
+buffered_str_coro_reader = BufferedStrCoroReader