omlish 0.0.0.dev137__py3-none-any.whl → 0.0.0.dev139__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev137'
-__revision__ = '895417d0442f51853415386ace94b1c41da0c990'
+__version__ = '0.0.0.dev139'
+__revision__ = '943c8c72d1baaa0ef3088fcadb2933d4abc11f36'
 
 
 #

omlish/configs/flattening.py

@@ -130,7 +130,7 @@ class Flattening:
                             .split(self._index_close + self._index_open):
                         yield int(p)
                 else:
-                    check.state(')' not in part)
+                    check.state(self._index_close not in part)
                     yield part
 
         for fk, v in flattened.items():

omlish/formats/json/stream/errors.py

@@ -0,0 +1,2 @@
+class JsonStreamError(Exception):
+    pass

omlish/formats/json/stream/lex.py

@@ -3,6 +3,7 @@ TODO:
  - max buf size
  - max recursion depth
  - mark start pos of tokens, currently returning end
+ - _do_string inner loop optimization somehow
 """
 import dataclasses as dc
 import io
@@ -12,6 +13,7 @@ import typing as ta
 
 from .... import check
 from ....funcs.genmachine import GenMachine
+from .errors import JsonStreamError
 
 
 ##
@@ -95,7 +97,7 @@ CONST_TOKENS: ta.Mapping[str, tuple[TokenKind, str | float | None]] = {
 
 
 @dc.dataclass()
-class JsonLexError(Exception):
+class JsonStreamLexError(JsonStreamError):
     message: str
 
     pos: Position
@@ -160,8 +162,8 @@ class JsonStreamLexer(GenMachine[str, Token]):
         self._buf.truncate()
         return raw
 
-    def _raise(self, msg: str) -> ta.NoReturn:
-        raise JsonLexError(msg, self.pos)
+    def _raise(self, msg: str, src: Exception | None = None) -> ta.NoReturn:
+        raise JsonStreamLexError(msg, self.pos) from src
 
     def _do_main(self):
         while True:
@@ -202,7 +204,7 @@ class JsonStreamLexer(GenMachine[str, Token]):
                 self._raise('Unexpected end of input')
 
             if not c:
-                raise NotImplementedError
+                self._raise(f'Unterminated string literal: {self._buf.getvalue()}')
 
             self._buf.write(c)
             if c == '"' and last != '\\':
@@ -210,7 +212,11 @@ class JsonStreamLexer(GenMachine[str, Token]):
             last = c
 
         raw = self._flip_buf()
-        sv = json.loads(raw)
+        try:
+            sv = json.loads(raw)
+        except json.JSONDecodeError as e:
+            self._raise(f'Invalid string literal: {raw!r}', e)
+
         yield self._make_tok('STRING', sv, raw, pos)
 
         return self._do_main()

omlish/formats/json/stream/parse.py

@@ -1,9 +1,12 @@
+import dataclasses as dc
 import typing as ta
 
 from .... import lang
 from ....funcs.genmachine import GenMachine
+from .errors import JsonStreamError
 from .lex import SCALAR_VALUE_TYPES
 from .lex import VALUE_TOKEN_KINDS
+from .lex import Position
 from .lex import ScalarValue
 from .lex import Token
 
@@ -79,6 +82,13 @@ def yield_parser_events(obj: ta.Any) -> ta.Generator[JsonStreamParserEvent, None
 ##
 
 
+@dc.dataclass()
+class JsonStreamParseError(JsonStreamError):
+    message: str
+
+    pos: Position | None = None
+
+
 class JsonStreamObject(list):
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}({super().__repr__()})'
@@ -100,29 +110,29 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
         if tt == 'KEY':
             self._stack.pop()
             if not self._stack:
-                raise self.StateError
+                raise JsonStreamParseError('Unexpected key')
 
             tt2 = self._stack[-1]
             if tt2 == 'OBJECT':
                 return ((v,), self._do_after_pair())
 
             else:
-                raise self.StateError
+                raise JsonStreamParseError('Unexpected key')
 
         elif tt == 'ARRAY':
             return ((v,), self._do_after_element())
 
         else:
-            raise self.StateError
+            raise JsonStreamParseError(f'Unexpected value: {v!r}')
 
     #
 
-    def _do_value(self):
+    def _do_value(self, *, must_be_present: bool = False):
         try:
             tok = yield None
         except GeneratorExit:
             if self._stack:
-                raise self.StateError from None
+                raise JsonStreamParseError('Expected value') from None
             else:
                 raise
 
@@ -141,13 +151,16 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
             yield y
             return r
 
+        elif must_be_present:
+            raise JsonStreamParseError('Expected value', tok.pos)
+
         elif tok.kind == 'RBRACKET':
             y, r = self._emit_end_array()
             yield y
             return r
 
         else:
-            raise self.StateError
+            raise JsonStreamParseError('Expected value', tok.pos)
 
     #
 
@@ -157,19 +170,19 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
 
     def _emit_end_object(self):
         if not self._stack:
-            raise self.StateError
+            raise JsonStreamParseError('Unexpected end object')
 
         tt = self._stack.pop()
         if tt != 'OBJECT':
-            raise self.StateError
+            raise JsonStreamParseError('Unexpected end object')
 
         return self._emit_event(EndObject)
 
-    def _do_object_body(self):
+    def _do_object_body(self, *, must_be_present: bool = False):
         try:
             tok = yield None
         except GeneratorExit:
-            raise self.StateError from None
+            raise JsonStreamParseError('Expected object body') from None
 
         if tok.kind == 'STRING':
             k = tok.value
@@ -177,30 +190,33 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
             try:
                 tok = yield None
             except GeneratorExit:
-                raise self.StateError from None
+                raise JsonStreamParseError('Expected key') from None
             if tok.kind != 'COLON':
-                raise self.StateError
+                raise JsonStreamParseError('Expected colon', tok.pos)
 
             yield (Key(k),)
             self._stack.append('KEY')
             return self._do_value()
 
+        elif must_be_present:
+            raise JsonStreamParseError('Expected value', tok.pos)
+
         elif tok.kind == 'RBRACE':
             y, r = self._emit_end_object()
             yield y
             return r
 
         else:
-            raise self.StateError
+            raise JsonStreamParseError('Expected value', tok.pos)
 
     def _do_after_pair(self):
         try:
             tok = yield None
         except GeneratorExit:
-            raise self.StateError from None
+            raise JsonStreamParseError('Expected continuation') from None
 
         if tok.kind == 'COMMA':
-            return self._do_object_body()
+            return self._do_object_body(must_be_present=True)
 
         elif tok.kind == 'RBRACE':
             y, r = self._emit_end_object()
@@ -208,7 +224,7 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
             return r
 
         else:
-            raise self.StateError
+            raise JsonStreamParseError('Expected continuation', tok.pos)
 
     #
 
@@ -218,11 +234,11 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
 
     def _emit_end_array(self):
         if not self._stack:
-            raise self.StateError
+            raise JsonStreamParseError('Expected end array')
 
         tt = self._stack.pop()
         if tt != 'ARRAY':
-            raise self.StateError
+            raise JsonStreamParseError('Unexpected end array')
 
         return self._emit_event(EndArray)
 
@@ -230,10 +246,10 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
         try:
             tok = yield None
         except GeneratorExit:
-            raise self.StateError from None
+            raise JsonStreamParseError('Expected continuation') from None
 
         if tok.kind == 'COMMA':
-            return self._do_value()
+            return self._do_value(must_be_present=True)
 
         elif tok.kind == 'RBRACKET':
             y, r = self._emit_end_array()
@@ -241,4 +257,4 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
             return r
 
         else:
-            raise self.StateError
+            raise JsonStreamParseError('Expected continuation', tok.pos)

omlish/funcs/genmachine.py

@@ -67,8 +67,7 @@ class GenMachine(ta.Generic[I, O]):
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        if exc_type is None:
-            self.close()
+        self.close()
 
     #
 

omlish/io/compress/bz2.py

@@ -24,6 +24,7 @@ class IncrementalBz2Compressor:
 
         self._compresslevel = compresslevel
 
+    @lang.autostart
     def __call__(self) -> IncrementalCompressor:
         return CompressorIncrementalAdapter(
             functools.partial(

omlish/io/compress/gzip.py

@@ -42,7 +42,7 @@ import typing as ta
 from ... import cached
 from ... import check
 from ... import lang
-from ..generators import PrependableBytesGeneratorReader
+from ..generators.readers import PrependableBytesGeneratorReader
 from .types import IncrementalCompressor
 from .types import IncrementalDecompressor
 
@@ -123,10 +123,12 @@ class IncrementalGzipCompressor:
         if fname:
             check.none((yield fname + b'\000'))
 
+    @lang.autostart
     def __call__(self) -> IncrementalCompressor:
         crc = _zero_crc()
         size = 0
         offset = 0  # Current file offset for seek(), tell(), etc
+        wrote_header = False
 
         compress = zlib.compressobj(
             self._compresslevel,
@@ -136,10 +138,13 @@ class IncrementalGzipCompressor:
             0,
         )
 
-        yield from self._write_gzip_header()
-
         while True:
             data: ta.Any = check.isinstance((yield None), bytes)
+
+            if not wrote_header:
+                yield from self._write_gzip_header()
+                wrote_header = True
+
             if not data:
                 break
 

omlish/io/compress/lzma.py

@@ -17,6 +17,7 @@ class IncrementalLzmaCompressor:
     def __init__(self) -> None:
         super().__init__()
 
+    @lang.autostart
     def __call__(self) -> IncrementalCompressor:
         return CompressorIncrementalAdapter(
             lzma.LZMACompressor,  # type: ignore

omlish/io/generators/readers.py

@@ -0,0 +1,183 @@
+"""
+TODO:
+ - BufferedBytesGeneratorReader
+ - docstrings
+ - memoryviews
+"""
+import abc
+import typing as ta
+
+from ... import check
+
+
+T = ta.TypeVar('T')
+I = ta.TypeVar('I')
+R = ta.TypeVar('R')
+AnyT = ta.TypeVar('AnyT', bound=ta.Any)
+
+
+ReaderGenerator: ta.TypeAlias = ta.Generator[int | None, I, R]
+ExactReaderGenerator: ta.TypeAlias = ta.Generator[int, I, R]
+
+BytesReaderGenerator: ta.TypeAlias = ReaderGenerator[bytes, R]
+BytesExactReaderGenerator: ta.TypeAlias = ExactReaderGenerator[bytes, R]
+
+StrReaderGenerator: ta.TypeAlias = ReaderGenerator[str, R]
+StrExactReaderGenerator: ta.TypeAlias = ExactReaderGenerator[str, R]
+
+
+##
+
+
+class _BytesJoiner:
+    def _join(self, lst: list[bytes]) -> bytes:
+        return b''.join(lst)
+
+
+class _StrJoiner:
+    def _join(self, lst: list[str]) -> str:
+        return ''.join(lst)
+
+
+##
+
+
+class GeneratorReader(abc.ABC, ta.Generic[T]):
+    @abc.abstractmethod
+    def read(self, sz: int | None) -> ta.Generator[int | None, T, T]:
+        raise NotImplementedError
+
+    def read_exact(self, sz: int) -> ta.Generator[int | None, T, T]:
+        d: ta.Any = yield from self.read(sz)
+        if len(d) != sz:
+            raise EOFError(f'GeneratorReader got {len(d)}, expected {sz}')
+        return d
+
+
+##
+
+
+class PrependableGeneratorReader(GeneratorReader[AnyT]):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._queue: list[tuple[AnyT, int]] = []
+
+    @abc.abstractmethod
+    def _join(self, lst: list[AnyT]) -> AnyT:
+        raise NotImplementedError
+
+    def read(self, sz: int | None) -> ta.Generator[int | None, AnyT, AnyT]:
+        if not self._queue:
+            d: AnyT = check.not_none((yield sz))
+            return d
+
+        if sz is None:
+            return self._queue.pop(0)[0]
+
+        lst: list[AnyT] = []
+        rem = sz
+        while rem > 0 and self._queue:
+            c, p = self._queue[0]
+
+            if len(c) - p > rem:
+                lst.append(c[p:p + rem])
+                self._queue[0] = (c, p + rem)
+                return self._join(lst)
+
+            lst.append(c[p:])
+            rem -= len(c) - p
+            self._queue.pop(0)
+
+        if rem:
+            d = check.not_none((yield rem))
+            if d:
+                lst.append(d)  # type: ignore[unreachable]
+
+        if len(lst) == 1:
+            return lst[0]
+        else:
+            return self._join(lst)
+
+    def prepend(self, d: AnyT, p: int | None = None) -> None:
+        if d:
+            self._queue.insert(0, (d, p or 0))
+
+
+class PrependableBytesGeneratorReader(
+    _BytesJoiner,
+    PrependableGeneratorReader[bytes],
+):
+    pass
+
+
+class PrependableStrGeneratorReader(
+    _StrJoiner,
+    PrependableGeneratorReader[str],
+):
+    pass
+
+
+prependable_bytes_generator_reader = PrependableBytesGeneratorReader
+prependable_str_generator_reader = PrependableStrGeneratorReader
+
+
+##
+
+
+class BufferedGeneratorReader(PrependableGeneratorReader[AnyT], abc.ABC):
+    DEFAULT_BUFFER_SIZE = 4 * 0x1000
+
+    def __init__(
+            self,
+            buffer_size: int = DEFAULT_BUFFER_SIZE,
+    ) -> None:
+        check.arg(buffer_size > 0)
+
+        super().__init__()
+
+        self._buffer_size = buffer_size
+
+    def read(self, sz: int | None) -> ta.Generator[int | None, AnyT, AnyT]:
+        g = super().read(sz)
+        i: ta.Any = None
+        while True:
+            try:
+                q = g.send(i)
+            except StopIteration as e:
+                return e.value
+
+            check.state(not self._queue)
+
+            if q is None:
+                i = check.not_none((yield None))
+                continue
+
+            r = max(q, self._buffer_size)
+            d: AnyT = check.not_none((yield r))
+            if len(d) < q:
+                i = d
+                continue
+
+            i = d[:q]
+            self.prepend(d, q)
+
+
+class BufferedBytesGeneratorReader(
+    _BytesJoiner,
+    BufferedGeneratorReader[bytes],
+    PrependableGeneratorReader[bytes],
+):
+    pass
+
+
+class BufferedStrGeneratorReader(
+    _StrJoiner,
+    BufferedGeneratorReader[str],
+    PrependableGeneratorReader[str],
+):
+    pass
+
+
+buffered_bytes_generator_reader = BufferedBytesGeneratorReader
+buffered_str_generator_reader = BufferedStrGeneratorReader

omlish/io/generators/stepped.py

@@ -0,0 +1,104 @@
+import typing as ta
+
+from ... import lang
+
+
+T = ta.TypeVar('T')
+I = ta.TypeVar('I')
+O = ta.TypeVar('O')
+OF = ta.TypeVar('OF')
+OT = ta.TypeVar('OT')
+R = ta.TypeVar('R')
+
+
+SteppedGenerator: ta.TypeAlias = ta.Generator[O | None, I | None, R]
+
+
+##
+
+
+@lang.autostart
+def flatmap_stepped_generator(
+        fn: ta.Callable[[list[OF]], OT],
+        g: SteppedGenerator[OF, I, R],
+        *,
+        terminate: ta.Callable[[OF], bool] | None = None,
+) -> ta.Generator[OT, I, lang.Maybe[R]]:
+    """
+    Given a 'stepped generator' - a generator which accepts input items and yields zero or more non-None values in
+    response until it signals it's ready for the next input by yielding None - and a function taking a list, returns a
+    1:1 generator which accepts input, builds a list of yielded generator 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.
+    """
+
+    l: list[OF]
+    i: I | None = yield  # type: ignore
+    while True:
+        l = []
+
+        while True:
+            try:
+                o = g.send(i)
+            except StopIteration as e:
+                if l:
+                    yield fn(l)
+                return lang.just(e.value)
+
+            i = None
+
+            if o is None:
+                break
+
+            l.append(o)
+
+            if terminate is not None and terminate(o):
+                yield fn(l)
+                return lang.empty()
+
+        i = yield fn(l)
+
+
+##
+
+
+def _join_bytes(l: ta.Sequence[bytes]) -> bytes:
+    if not l:
+        return b''
+    elif len(l) == 1:
+        return l[0]
+    else:
+        return b''.join(l)
+
+
+def _join_str(l: ta.Sequence[str]) -> str:
+    if not l:
+        return ''
+    elif len(l) == 1:
+        return l[0]
+    else:
+        return ''.join(l)
+
+
+def _is_empty(o: T) -> bool:
+    return len(o) < 1  # type: ignore
+
+
+##
+
+
+def joined_bytes_stepped_generator(
+        g: ta.Generator[bytes | None, bytes | None, R],
+) -> ta.Generator[bytes, bytes, R]:
+    return flatmap_stepped_generator(_join_bytes, g, terminate=_is_empty)
+
+
+def joined_str_stepped_generator(
+        g: ta.Generator[str | None, str | None, R],
+) -> ta.Generator[str, str, R]:
+    return flatmap_stepped_generator(_join_str, g, terminate=_is_empty)

omlish/lang/__init__.py

@@ -124,7 +124,10 @@ from .generators import (  # noqa
     CoroutineGenerator,
     Generator,
     GeneratorLike,
+    GeneratorMappedIterator,
+    autostart,
     corogen,
+    genmap,
     nextgen,
 )
 

omlish/lang/functions.py

@@ -82,7 +82,6 @@ def identity(obj: T) -> T:
 
 
 class constant(ta.Generic[T]):  # noqa
-
     def __init__(self, obj: T) -> None:
         super().__init__()
 
@@ -116,7 +115,6 @@ class VoidError(Exception):
 
 
 class Void:
-
     def __new__(cls, *args: ta.Any, **kwargs: ta.Any) -> None:  # type: ignore  # noqa
         raise VoidError
 

omlish/lang/generators.py

@@ -1,7 +1,10 @@
 import abc
+import functools
 import typing as ta
 
 from .maybes import Maybe
+from .maybes import empty
+from .maybes import just
 
 
 T = ta.TypeVar('T')
@@ -21,6 +24,16 @@ def nextgen(g: T) -> T:
     return g
 
 
+def autostart(fn):
+    @functools.wraps(fn)
+    def inner(*args, **kwargs):
+        g = fn(*args, **kwargs)
+        if (o := next(g)) is not None:
+            raise TypeError(o)
+        return g
+    return inner
+
+
 ##
 
 
@@ -180,3 +193,51 @@ class CoroutineGenerator(ta.Generic[O, I, R]):
 
 
 corogen = CoroutineGenerator
+
+
+##
+
+
+class GeneratorMappedIterator(ta.Generic[O, I, R]):
+    """
+    Like a `map` iterator but takes a generator instead of a function. Provided generator *must* yield outputs 1:1 with
+    inputs.
+
+    Generator return value will be captured on `value` property - if present generator stopped, it absent iterator
+    stopped.
+    """
+
+    def __init__(self, g: ta.Generator[O, I, R], it: ta.Iterator[I]) -> None:
+        super().__init__()
+
+        self._g = g
+        self._it = it
+        self._value: Maybe[R] = empty()
+
+    @property
+    def g(self) -> ta.Generator[O, I, R]:
+        return self._g
+
+    @property
+    def it(self) -> ta.Iterator[I]:
+        return self._it
+
+    @property
+    def value(self) -> Maybe[R]:
+        return self._value
+
+    def __iter__(self) -> ta.Iterator[O]:
+        return self
+
+    def __next__(self) -> O:
+        i = next(self._it)
+        try:
+            o = self._g.send(i)
+        except StopIteration as e:
+            self._value = just(e.value)
+            raise StopIteration from e
+        return o
+
+
+def genmap(g: ta.Generator[O, I, R], it: ta.Iterable[I]) -> GeneratorMappedIterator[O, I, R]:
+    return GeneratorMappedIterator(g, iter(it))

{omlish-0.0.0.dev137.dist-info → omlish-0.0.0.dev139.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev137
+Version: 0.0.0.dev139
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev137.dist-info → omlish-0.0.0.dev139.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=RX24SRc6DCEg77PUVnaXOKCWa5TF_c9RQJdGIf7gl9c,1135
-omlish/__about__.py,sha256=keq7273S1vADjELx7wkIYWHvdZy7TM3pyrMqOHXwNYg,3379
+omlish/__about__.py,sha256=Hl1Jnwstv8jPOdEO_LJglXfJ8ChFupW5ZTF3kYkK_LQ,3379
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/argparse.py,sha256=cqKGAqcxuxv_s62z0gq29L9KAvg_3-_rFvXKjVpRJjo,8126
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
@@ -118,7 +118,7 @@ omlish/concurrent/futures.py,sha256=J2s9wYURUskqRJiBbAR0PNEAp1pXbIMYldOVBTQduQY,
 omlish/concurrent/threadlets.py,sha256=JfirbTDJgy9Ouokz_VmHeAAPS7cih8qMUJrN-owwXD4,2423
 omlish/configs/__init__.py,sha256=3uh09ezodTwkMI0nRmAMP0eEuJ_0VdF-LYyNmPjHiCE,77
 omlish/configs/classes.py,sha256=GLbB8xKjHjjoUQRCUQm3nEjM8z1qNTx9gPV7ODSt5dg,1317
-omlish/configs/flattening.py,sha256=AOlRpBHm449MxwMp3CiIRGunStOC1DUNs1f3CLou0wc,4731
+omlish/configs/flattening.py,sha256=rVxoTqgM9te86hUwQsHJ5u94jo2PARNfhk_HkrrDT9Y,4745
 omlish/configs/strings.py,sha256=0brx1duL85r1GpfbNvbHcSvH4jWzutwuvMFXda9NeI0,2651
 omlish/dataclasses/__init__.py,sha256=AHo-tN5V_b_VYFUF7VFRmuHrjZBXS1WytRAj061MUTA,1423
 omlish/dataclasses/utils.py,sha256=lcikCPiiX5Giu0Kb1hP18loZjmm_Z9D-XtJ-ZlHq9iM,3793
@@ -194,11 +194,12 @@ omlish/formats/json/backends/std.py,sha256=PM00Kh9ZR2XzollHMEvdo35Eml1N-zFfRW-LO
 omlish/formats/json/backends/ujson.py,sha256=BNJCU4kluGHdqTUKLJEuHhE2m2TmqR7HEN289S0Eokg,2278
 omlish/formats/json/stream/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/formats/json/stream/build.py,sha256=MSxgreWSfI5CzNAdgQrArZ0yWqDsaHl-shI_jmjLDms,2505
-omlish/formats/json/stream/lex.py,sha256=_JYBFnAyHsw_3hu8I0rvZqSSkRCU1BvQzgO81KfqRBg,6489
-omlish/formats/json/stream/parse.py,sha256=s21PgiuNTcqc_i9QS1ggmEp8Qwp_hOqtosr5d0zpg_o,5204
+omlish/formats/json/stream/errors.py,sha256=c8M8UAYmIZ-vWZLeKD2jMj4EDCJbr9QR8Jq_DyHjujQ,43
+omlish/formats/json/stream/lex.py,sha256=bfy0fb3_Z6G18UGueX2DR6oPSVUsMoFhlbsvXC3ztzI,6793
+omlish/formats/json/stream/parse.py,sha256=JuYmXwtTHmQJTFKoJNoEHUpCPxXdl_gvKPykVXgED34,6208
 omlish/formats/json/stream/render.py,sha256=NtmDsN92xZi5dkgSSuMeMXMAiJblmjz1arB4Ft7vBhc,3715
 omlish/funcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/funcs/genmachine.py,sha256=XEHy8SFgHCDYSAqlRm-7wlYQX2h6UWehR2_uMw9EOXU,2509
+omlish/funcs/genmachine.py,sha256=EY2k-IFNKMEmHo9CmGRptFvhEMZVOWzZhn0wdQGeaFM,2476
 omlish/funcs/match.py,sha256=gMLZn1enNiFvQaWrQubY300M1BrmdKWzeePihBS7Ywc,6153
 omlish/funcs/pairs.py,sha256=OzAwnALkRJXVpD47UvBZHKzQfHtFNry_EgjTcC7vgLU,10606
 omlish/funcs/pipes.py,sha256=E7Sz8Aj8ke_vCs5AMNwg1I36kRdHVGTnzxVQaDyn43U,2490
@@ -257,17 +258,19 @@ omlish/inject/impl/proxy.py,sha256=1ko0VaKqzu9UG8bIldp9xtUrAVUOFTKWKTjOCqIGr4s,1
 omlish/inject/impl/scopes.py,sha256=hKnzNieB-fJSFEXDP_QG1mCfIKoVFIfFlf9LiIt5tk4,5920
 omlish/io/__init__.py,sha256=aaIEsXTSfytW-oEkUWczdUJ_ifFY7ihIpyidIbfjkwY,56
 omlish/io/abc.py,sha256=Cxs8KB1B_69rxpUYxI-MTsilAmNooJJn3w07DKqYKkE,1255
-omlish/io/generators.py,sha256=ZlAp_t0ZD_aKztlio1i_hezmpIFFjaiXtrnY6-2QsPs,1123
 omlish/io/pyio.py,sha256=YB3g6yg64MzcFwbzKBo4adnbsbZ3FZMlOZfjNtWmYoc,95316
 omlish/io/trampoline.py,sha256=oUKTQg1F5xQS1431Kt7MbK-NZpX509ubcXU-s86xJr8,7171
 omlish/io/compress/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/io/compress/abc.py,sha256=R9ebpSjJK4VAimV3OevPJB-jSDTGB_xi2FKNZKbTdYE,3054
 omlish/io/compress/adapters.py,sha256=wS7cA_quham3C23j3_H6sf2EQ4gI0vURTQdPhapiiFE,6088
-omlish/io/compress/bz2.py,sha256=XxpAKdQ5pdWfa23a0F6ZspU_GxHhyJVVPjv2SCyw4hM,1006
-omlish/io/compress/gzip.py,sha256=TUjbE5cjiHXd2ZMsRgXBlSW3mCF7xMt_NvIRTYddBCQ,11054
-omlish/io/compress/lzma.py,sha256=rM6FXWeD6s-K-Sfxn04AaFILS-v4rliWKlPnAl_RrJw,803
+omlish/io/compress/bz2.py,sha256=BX-xWrpYe5K9vJ28iB2wCNPtd6PW2RgCh3h6XfE4FtA,1026
+omlish/io/compress/gzip.py,sha256=Vs8O3l1Sf50iAvBSQueMLEDLDbmh6FqPdvdzwwaDy3o,11189
+omlish/io/compress/lzma.py,sha256=_fFNWY1R6z71zRnrejhpKs7DVCHn_Ei9ny_fxHvUwJo,823
 omlish/io/compress/types.py,sha256=IuCyxFX8v12fGqCq2ofCCRM5ZM-4zngHeeBW_PWqYbM,557
-omlish/lang/__init__.py,sha256=U6-WtzQL48e9wqWHmxuA1X2PoGlx6Di2HSAi13gTwjw,3866
+omlish/io/generators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omlish/io/generators/readers.py,sha256=nv6inmyJmYCJ2YFE2cv6jkVmoxGsbXzyuIki-MCjZDg,4195
+omlish/io/generators/stepped.py,sha256=AYZmtZF1p95JW17XKe3ZIXWwWRuYmmbDLVuhB5x8Dog,2571
+omlish/lang/__init__.py,sha256=lQ-w1MgrMtuyVNWtqODI0qNZ71SZPfvf-Lkn2LUMTec,3922
 omlish/lang/cached.py,sha256=92TvRZQ6sWlm7dNn4hgl7aWKbX0J1XUEo3DRjBpgVQk,7834
 omlish/lang/clsdct.py,sha256=AjtIWLlx2E6D5rC97zQ3Lwq2SOMkbg08pdO_AxpzEHI,1744
 omlish/lang/cmp.py,sha256=5vbzWWbqdzDmNKAGL19z6ZfUKe5Ci49e-Oegf9f4BsE,1346
@@ -275,8 +278,8 @@ omlish/lang/contextmanagers.py,sha256=NEwaTLQMfhKawD5x_0HgI2RpeLXbMa5r9NqWqfDnUX
 omlish/lang/datetimes.py,sha256=ehI_DhQRM-bDxAavnp470XcekbbXc4Gdw9y1KpHDJT0,223
 omlish/lang/descriptors.py,sha256=RRBbkMgTzg82fFFE4D0muqobpM-ZZaOta6yB1lpX3s8,6617
 omlish/lang/exceptions.py,sha256=qJBo3NU1mOWWm-NhQUHCY5feYXR3arZVyEHinLsmRH4,47
-omlish/lang/functions.py,sha256=kkPfcdocg-OmyN7skIqrFxNvqAv89Zc_kXKYAN8vw8g,3895
-omlish/lang/generators.py,sha256=AShh0x-9Z9qolAYEOZJgYJcxQuyA3HKq0c9tLwNcFs4,3766
+omlish/lang/functions.py,sha256=tUqeqBNHtJtrwimbG6Kc1SjZQDDhqqC1o-8ANpXWn9E,3893
+omlish/lang/generators.py,sha256=5LX17j-Ej3QXhwBgZvRTm_dq3n9veC4IOUcVmvSu2vU,5243
 omlish/lang/imports.py,sha256=TXLbj2F53LsmozlM05bQhvow9kEgWJOi9qYKsnm2D18,9258
 omlish/lang/iterables.py,sha256=1bc-Vn-b34T6Gy3li2tMNYpUvuwCC7fjg7dpjXkTfWY,1746
 omlish/lang/maybes.py,sha256=1RN7chX_x2XvgUwryZRz0W7hAX-be3eEFcFub5vvf6M,3417
@@ -489,9 +492,9 @@ omlish/text/glyphsplit.py,sha256=Ug-dPRO7x-OrNNr8g1y6DotSZ2KH0S-VcOmUobwa4B0,329
 omlish/text/indent.py,sha256=6Jj6TFY9unaPa4xPzrnZemJ-fHsV53IamP93XGjSUHs,1274
 omlish/text/parts.py,sha256=7vPF1aTZdvLVYJ4EwBZVzRSy8XB3YqPd7JwEnNGGAOo,6495
 omlish/text/random.py,sha256=jNWpqiaKjKyTdMXC-pWAsSC10AAP-cmRRPVhm59ZWLk,194
-omlish-0.0.0.dev137.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev137.dist-info/METADATA,sha256=iU_JPwXqYl0APiFu32-g6dTXny6kbXZWslNaWevwHEs,4173
-omlish-0.0.0.dev137.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-omlish-0.0.0.dev137.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev137.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev137.dist-info/RECORD,,
+omlish-0.0.0.dev139.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev139.dist-info/METADATA,sha256=Eje9SZhVJVmqyDQqodtffHM__nJNBuEZZPhVNuhqel0,4173
+omlish-0.0.0.dev139.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+omlish-0.0.0.dev139.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev139.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev139.dist-info/RECORD,,

omlish/io/generators.py

@@ -1,50 +0,0 @@
-"""
-TODO:
- - BufferedBytesGeneratorReader
-"""
-import typing as ta
-
-from .. import check
-
-
-class PrependableBytesGeneratorReader:
-    def __init__(self) -> None:
-        super().__init__()
-
-        self._p: list[bytes] = []
-
-    def read(self, sz: int | None) -> ta.Generator[int | None, bytes, bytes]:
-        if not self._p:
-            d = check.isinstance((yield sz), bytes)
-            return d
-
-        if sz is None:
-            return self._p.pop(0)
-
-        l: list[bytes] = []
-        r = sz
-        while r > 0 and self._p:
-            c = self._p[0]
-
-            if len(c) > r:
-                l.append(c[:r])
-                self._p[0] = c[r:]
-                return b''.join(l)
-
-            l.append(c)
-            r -= len(c)
-            self._p.pop(0)
-
-        if r:
-            c = check.isinstance((yield r), bytes)
-            if not c:
-                return b''
-            if len(c) != r:
-                raise EOFError(f'Reader got {len(c)} bytes, expected {r}')
-            l.append(c)
-
-        return b''.join(l)
-
-    def prepend(self, d: bytes) -> None:
-        if d:
-            self._p.append(d)