omlish 0.0.0.dev194__py3-none-any.whl → 0.0.0.dev196__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev194'
-__revision__ = '39cfe872573628af34684eb1ec41a0ccb127ad0f'
+__version__ = '0.0.0.dev196'
+__revision__ = 'c5eb72314e32c8694da771f815a207214d553c90'
 
 
 #
@@ -32,7 +32,7 @@ class Project(ProjectBase):
 
     optional_dependencies = {
         'async': [
-            'anyio ~= 4.7',
+            'anyio ~= 4.8',
             'sniffio ~= 1.3',
 
             'greenlet ~= 3.1',

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/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

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

@@ -4,8 +4,8 @@ from ... import check
 from ... import lang
 from ..buffers import ReadableListBuffer
 from .consts import DEFAULT_BUFFER_SIZE
-from .direct import BytesDirectGenerator
-from .direct import StrDirectGenerator
+from .direct import BytesDirectCoro
+from .direct import StrDirectCoro
 
 
 T = ta.TypeVar('T')
@@ -18,44 +18,44 @@ OF = ta.TypeVar('OF')
 OT = ta.TypeVar('OT')
 
 
-# Stepped generators accept a non-None input, then in response yield zero or more non-None outputs, until yielding None
-# to signal they need more input again.
-SteppedGenerator: ta.TypeAlias = ta.Generator[O | None, I | None, R]
+# Stepped coros accept a non-None input, then in response yield zero or more non-None outputs, until yielding None to
+# signal they need more input again.
+SteppedCoro: ta.TypeAlias = ta.Generator[O | None, I | None, R]
 
 # Conventionally, these are sent and themselves yield an empty value to signify termination.
-BytesSteppedGenerator: ta.TypeAlias = SteppedGenerator[bytes, bytes, R]
-StrSteppedGenerator: ta.TypeAlias = SteppedGenerator[str, str, R]
+BytesSteppedCoro: ta.TypeAlias = SteppedCoro[bytes, bytes, R]
+StrSteppedCoro: ta.TypeAlias = SteppedCoro[str, str, R]
 
-BytesToStrSteppedGenerator: ta.TypeAlias = SteppedGenerator[str, bytes, R]
-StrToBytesSteppedGenerator: ta.TypeAlias = SteppedGenerator[bytes, str, R]
+BytesToStrSteppedCoro: ta.TypeAlias = SteppedCoro[str, bytes, R]
+StrToBytesSteppedCoro: ta.TypeAlias = SteppedCoro[bytes, str, R]
 
 
 # Stepped reader generators emit either an int or None to request input, or emit some other kind of output.
-SteppedReaderGenerator: ta.TypeAlias = ta.Generator[int | None | O, I | None, R]
+SteppedReaderCoro: ta.TypeAlias = ta.Generator[int | None | O, I | None, R]
 
-BytesSteppedReaderGenerator: ta.TypeAlias = SteppedReaderGenerator[bytes, bytes, R]
-StrSteppedReaderGenerator: ta.TypeAlias = SteppedReaderGenerator[str, str, R]
+BytesSteppedReaderCoro: ta.TypeAlias = SteppedReaderCoro[bytes, bytes, R]
+StrSteppedReaderCoro: ta.TypeAlias = SteppedReaderCoro[str, str, R]
 
 
 ##
 
 
 @lang.autostart
-def flatmap_stepped_generator(
+def flatmap_stepped_coro(
         fn: ta.Callable[[list[OF]], OT],
-        g: SteppedGenerator[OF, I, R],
+        g: SteppedCoro[OF, I, R],
         *,
         terminate: ta.Callable[[OF], bool] | None = None,
 ) -> ta.Generator[OT, I, lang.Maybe[R]]:
     """
-    Given a stepped generator and a function taking a list, returns a direct (1:1) generator which accepts input, builds
-    a list of yielded generator output, calls the given function with that list, and yields the result.
+    Given a stepped coro and a function taking a list, returns a direct (1:1) coro which accepts input, builds a list of
+    yielded coro output, calls the given function with that list, and yields the result.
 
     An optional terminate function may be provided which will cause this function to return early if it returns true for
     an encountered yielded value. The encountered value causing termination will be included in the list sent to the
     given fn.
 
-    Returns a Maybe of either the given generator's return value or empty if the terminator was encountered.
+    Returns a Maybe of either the given coro's return value or empty if the terminator was encountered.
     """
 
     l: list[OF]
@@ -110,37 +110,37 @@ def _is_empty(o: T) -> bool:
     return len(o) < 1  # type: ignore
 
 
-def joined_bytes_stepped_generator(g: BytesSteppedGenerator[R]) -> BytesDirectGenerator[R]:
-    return flatmap_stepped_generator(_join_bytes, g, terminate=_is_empty)
+def joined_bytes_stepped_coro(g: BytesSteppedCoro[R]) -> BytesDirectCoro[R]:
+    return flatmap_stepped_coro(_join_bytes, g, terminate=_is_empty)
 
 
-def joined_str_stepped_generator(g: StrSteppedGenerator[R]) -> StrDirectGenerator[R]:
-    return flatmap_stepped_generator(_join_str, g, terminate=_is_empty)
+def joined_str_stepped_coro(g: StrSteppedCoro[R]) -> StrDirectCoro[R]:
+    return flatmap_stepped_coro(_join_str, g, terminate=_is_empty)
 
 
 ##
 
 
-def read_into_bytes_stepped_generator(
-        g: BytesSteppedGenerator,
+def read_into_bytes_stepped_coro(
+        g: BytesSteppedCoro,
         f: ta.IO,
         *,
         read_size: int = DEFAULT_BUFFER_SIZE,
 ) -> ta.Iterator[bytes]:
     yield from lang.genmap(  # type: ignore[misc]
-        joined_bytes_stepped_generator(g),
+        joined_bytes_stepped_coro(g),
         lang.readiter(f, read_size),
     )
 
 
-def read_into_str_stepped_generator(
-        g: StrSteppedGenerator,
+def read_into_str_stepped_coro(
+        g: StrSteppedCoro,
         f: ta.TextIO,
         *,
         read_size: int = DEFAULT_BUFFER_SIZE,
 ) -> ta.Iterator[str]:
     yield from lang.genmap(
-        joined_str_stepped_generator(g),
+        joined_str_stepped_coro(g),
         lang.readiter(f, read_size),
     )
 
@@ -149,7 +149,7 @@ def read_into_str_stepped_generator(
 
 
 @lang.autostart
-def buffer_bytes_stepped_reader_generator(g: BytesSteppedReaderGenerator) -> BytesSteppedGenerator:
+def buffer_bytes_stepped_reader_coro(g: BytesSteppedReaderCoro) -> BytesSteppedCoro:
     i: bytes | None
     o = g.send(None)
     rlb = ReadableListBuffer()