omlish 0.0.0.dev165__py3-none-any.whl → 0.0.0.dev166__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev165'
-__revision__ = '5e68eb26c319c7641fcdbec0513840b576224ff3'
+__version__ = '0.0.0.dev166'
+__revision__ = 'e832ee32347c3f4c51e8ead2186def228e3aac1c'
 
 
 #

omlish/codecs/text.py

@@ -46,8 +46,8 @@ TextEncodingErrors: ta.TypeAlias = ta.Literal[
     'namereplace',
 
     ##
-    # In addition, the following error handler is specific to the given codecs:
-    # utf-8, utf-16, utf-32, utf-16-be, utf-16-le, utf-32-be, utf-32-le
+    # In addition, the following error handler is specific to the given codecs: utf-8, utf-16, utf-32, utf-16-be,
+    # utf-16-le, utf-32-be, utf-32-le
 
     # Allow encoding and decoding surrogate code point (U+D800 - U+DFFF) as normal code point. Otherwise these codecs
     # treat the presence of surrogate code point in str as an error.

omlish/io/compress/codecs.py

@@ -2,7 +2,9 @@ import dataclasses as dc
 import typing as ta
 
 from ... import codecs
+from ..generators import buffer_bytes_stepped_reader_generator
 from .base import Compression
+from .base import IncrementalCompression
 
 
 ##
@@ -22,6 +24,20 @@ class CompressionEagerCodec(codecs.EagerCodec[bytes, bytes]):
 ##
 
 
+@dc.dataclass(frozen=True)
+class CompressionIncrementalCodec(codecs.IncrementalCodec[bytes, bytes]):
+    compression: IncrementalCompression
+
+    def encode_incremental(self) -> ta.Generator[bytes | None, bytes, None]:
+        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())
+
+
+##
+
+
 class CompressionCodec(codecs.Codec):
     pass
 
@@ -40,6 +56,10 @@ def make_compression_codec(
         output=bytes,
 
         new=lambda *args, **kwargs: CompressionEagerCodec(cls(*args, **kwargs)),
+
+        new_incremental=(
+            lambda *args, **kwargs: CompressionIncrementalCodec(cls(*args, **kwargs))  # noqa
+        ) if issubclass(cls, IncrementalCompression) else None,
     )
 
 

omlish/io/generators/__init__.py

@@ -50,4 +50,7 @@ from .stepped import (  # noqa
     joined_str_stepped_generator,
 
     read_into_bytes_stepped_generator,
+    read_into_str_stepped_generator,
+
+    buffer_bytes_stepped_reader_generator,
 )

omlish/io/generators/stepped.py

@@ -151,18 +151,32 @@ def read_into_str_stepped_generator(
 def buffer_bytes_stepped_reader_generator(g: BytesSteppedReaderGenerator) -> BytesSteppedGenerator:
     o = g.send(None)
     buf: ta.Any = None
+    eof = False
 
     while True:
+        if eof:
+            raise EOFError
+
         if not buf:
             buf = check.isinstance((yield None), bytes)
+            if not buf:
+                eof = True
 
-        if o is None or not buf:
+        if o is None:
             i = buf
+            buf = None
+
         elif isinstance(o, int):
-            if len(buf) < o:
-                raise NotImplementedError
+            while len(buf) < o:
+                more = check.isinstance((yield None), bytes)
+                if not more:
+                    raise EOFError
+                # FIXME: lol - share guts with readers
+                buf += more
+
             i = buf[:o]
             buf = buf[o:]
+
         else:
             raise TypeError(o)
 
@@ -171,5 +185,7 @@ def buffer_bytes_stepped_reader_generator(g: BytesSteppedReaderGenerator) -> Byt
             i = None
             if isinstance(o, bytes):
                 check.none((yield o))
+                if not o:
+                    return
             else:
                 break

omlish/iterators/__init__.py

@@ -0,0 +1,24 @@
+from .iterators import (  # noqa
+    PeekIterator,
+    PrefetchIterator,
+    ProxyIterator,
+    RetainIterator,
+)
+
+from .recipes import (  # noqa
+    sliding_window,
+)
+
+from .tools import (  # noqa
+    chunk,
+    expand_indexed_pairs,
+    merge_on,
+    take,
+    unzip,
+)
+
+from .unique import (  # noqa
+    UniqueItem,
+    UniqueIterator,
+    UniqueStats,
+)

omlish/iterators/iterators.py

@@ -0,0 +1,132 @@
+import collections
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+_MISSING = object()
+
+
+class PeekIterator(ta.Iterator[T]):
+
+    def __init__(self, it: ta.Iterable[T]) -> None:
+        super().__init__()
+
+        self._it = iter(it)
+        self._pos = -1
+        self._next_item: ta.Any = _MISSING
+
+    _item: T
+
+    def __iter__(self) -> ta.Self:
+        return self
+
+    @property
+    def done(self) -> bool:
+        try:
+            self.peek()
+        except StopIteration:
+            return True
+        else:
+            return False
+
+    def __next__(self) -> T:
+        if self._next_item is not _MISSING:
+            self._item = ta.cast(T, self._next_item)
+            self._next_item = _MISSING
+        else:
+            self._item = next(self._it)
+        self._pos += 1
+        return self._item
+
+    def peek(self) -> T:
+        if self._next_item is not _MISSING:
+            return ta.cast(T, self._next_item)
+        self._next_item = next(self._it)
+        return self._next_item
+
+    def next_peek(self) -> T:
+        next(self)
+        return self.peek()
+
+    def takewhile(self, fn: ta.Callable[[T], bool]) -> ta.Iterator[T]:
+        while fn(self.peek()):
+            yield next(self)
+
+    def skipwhile(self, fn: ta.Callable[[T], bool]) -> None:
+        while fn(self.peek()):
+            next(self)
+
+    def takeuntil(self, fn: ta.Callable[[T], bool]) -> ta.Iterator[T]:
+        return self.takewhile(lambda e: not fn(e))
+
+    def skipuntil(self, fn: ta.Callable[[T], bool]) -> None:
+        self.skipwhile(lambda e: not fn(e))
+
+    def takethrough(self, pos: int) -> ta.Iterator[T]:
+        return self.takewhile(lambda _: self._pos < pos)
+
+    def skipthrough(self, pos: int) -> None:
+        self.skipwhile(lambda _: self._pos < pos)
+
+    def taketo(self, pos: int) -> ta.Iterator[T]:
+        return self.takethrough(pos - 1)
+
+    def skipto(self, pos: int) -> None:
+        self.skipthrough(pos - 1)
+
+
+class ProxyIterator(ta.Iterator[T]):
+
+    def __init__(self, fn: ta.Callable[[], T]) -> None:
+        self._fn = fn
+
+    def __iter__(self) -> ta.Self:
+        return self
+
+    def __next__(self) -> T:
+        return self._fn()
+
+
+class PrefetchIterator(ta.Iterator[T]):
+
+    def __init__(self, fn: ta.Callable[[], T] | None = None) -> None:
+        super().__init__()
+
+        self._fn = fn
+        self._deque: collections.deque[T] = collections.deque()
+
+    def __iter__(self) -> ta.Self:
+        return self
+
+    def push(self, item) -> None:
+        self._deque.append(item)
+
+    def __next__(self) -> T:
+        try:
+            return self._deque.popleft()
+        except IndexError:
+            if self._fn is None:
+                raise StopIteration from None
+        return self._fn()
+
+
+class RetainIterator(ta.Iterator[T]):
+
+    def __init__(self, fn: ta.Callable[[], T]) -> None:
+        super().__init__()
+
+        self._fn = fn
+        self._deque: collections.deque[T] = collections.deque()
+
+    def __iter__(self) -> ta.Self:
+        return self
+
+    def pop(self) -> None:
+        self._deque.popleft()
+
+    def __next__(self) -> T:
+        item = self._fn()
+        self._deque.append(item)
+        return item

omlish/iterators/recipes.py

@@ -0,0 +1,18 @@
+"""
+https://docs.python.org/3/library/itertools.html#itertools-recipes
+"""
+import collections
+import itertools
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+def sliding_window(it: ta.Iterable[T], n: int) -> ta.Iterator[tuple[T, ...]]:
+    # sliding_window('ABCDEFG', 4) -> ABCD BCDE CDEF DEFG
+    iterator = iter(it)
+    window = collections.deque(itertools.islice(iterator, n - 1), maxlen=n)
+    for x in iterator:
+        window.append(x)
+        yield tuple(window)

omlish/iterators/tools.py

@@ -0,0 +1,96 @@
+import functools
+import heapq
+import itertools
+import typing as ta
+
+from .iterators import PeekIterator
+from .iterators import PrefetchIterator
+
+
+T = ta.TypeVar('T')
+U = ta.TypeVar('U')
+
+
+def unzip(it: ta.Iterable[T], width: int | None = None) -> list:
+    if width is None:
+        if not isinstance(it, PeekIterator):
+            it = PeekIterator(iter(it))
+        try:
+            width = len(it.peek())
+        except StopIteration:
+            return []
+
+    its: list[PrefetchIterator[T]] = []
+    running = True
+
+    def next_fn(idx):
+        nonlocal running
+        if not running:
+            raise StopIteration
+        try:
+            items = next(it)  # type: ignore
+        except StopIteration:
+            running = False
+            raise
+        for item_idx, item in enumerate(items):
+            its[item_idx].push(item)
+        return next(its[idx])
+
+    its.extend(PrefetchIterator(functools.partial(next_fn, idx)) for idx in range(width))
+    return its
+
+
+def take(n: int, iterable: ta.Iterable[T]) -> list[T]:
+    return list(itertools.islice(iterable, n))
+
+
+def chunk(n: int, iterable: ta.Iterable[T], strict: bool = False) -> ta.Iterator[list[T]]:
+    iterator = iter(functools.partial(take, n, iter(iterable)), [])
+    if strict:
+        def ret():
+            for chunk in iterator:
+                if len(chunk) != n:
+                    raise ValueError('iterable is not divisible by n.')
+                yield chunk
+        return iter(ret())
+    else:
+        return iterator
+
+
+def merge_on(
+        function: ta.Callable[[T], U],
+        *its: ta.Iterable[T],
+) -> ta.Iterator[tuple[U, list[tuple[int, T]]]]:
+    indexed_its = [
+        (
+            (function(item), it_idx, item)
+            for it_idx, item in zip(itertools.repeat(it_idx), it)
+        )
+        for it_idx, it in enumerate(its)
+    ]
+
+    grouped_indexed_its = itertools.groupby(
+        heapq.merge(*indexed_its),
+        key=lambda item_tuple: item_tuple[0],
+    )
+
+    return (
+        (fn_item, [(it_idx, item) for _, it_idx, item in grp])
+        for fn_item, grp in grouped_indexed_its
+    )
+
+
+def expand_indexed_pairs(
+        seq: ta.Iterable[tuple[int, T]],
+        default: T,
+        *,
+        width: int | None = None,
+) -> list[T]:
+    width_ = width
+    if width_ is None:
+        width_ = (max(idx for idx, _ in seq) + 1) if seq else 0
+    result = [default] * width_
+    for idx, value in seq:
+        if idx < width_:
+            result[idx] = value
+    return result

omlish/iterators/unique.py

@@ -0,0 +1,67 @@
+import dataclasses as dc
+import typing as ta
+
+from .. import lang
+
+
+T = ta.TypeVar('T')
+
+
+@dc.dataclass()
+class UniqueStats:
+    key: ta.Any
+    num_seen: int
+    first_idx: int
+    last_idx: int
+
+
+@dc.dataclass(frozen=True)
+class UniqueItem(ta.Generic[T]):
+    idx: int
+    item: T
+    stats: UniqueStats
+    out: lang.Maybe[T]
+
+
+class UniqueIterator(ta.Iterator[UniqueItem[T]]):
+    def __init__(
+            self,
+            it: ta.Iterable[T],
+            keyer: ta.Callable[[T], ta.Any] = lang.identity,
+    ) -> None:
+        super().__init__()
+        self._it = enumerate(it)
+        self._keyer = keyer
+
+        self.stats: dict[ta.Any, UniqueStats] = {}
+
+    def __next__(self) -> UniqueItem[T]:
+        idx, item = next(self._it)
+        key = self._keyer(item)
+
+        try:
+            stats = self.stats[key]
+
+        except KeyError:
+            stats = self.stats[key] = UniqueStats(
+                key,
+                num_seen=1,
+                first_idx=idx,
+                last_idx=idx,
+            )
+            return UniqueItem(
+                idx,
+                item,
+                stats,
+                lang.just(item),
+            )
+
+        else:
+            stats.num_seen += 1
+            stats.last_idx = idx
+            return UniqueItem(
+                idx,
+                item,
+                stats,
+                lang.empty(),
+            )

{omlish-0.0.0.dev165.dist-info → omlish-0.0.0.dev166.dist-info}/METADATA

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

{omlish-0.0.0.dev165.dist-info → omlish-0.0.0.dev166.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=0BnQGD2dcXEma0Jop2ZesvDNzSj3CAJBNq8aTGuBz9A,7276
-omlish/__about__.py,sha256=Zdlb1wmkdCXyJBRRyIwfdhrNEFzKL3DnTkBFMYzau-4,3409
+omlish/__about__.py,sha256=fXaHA2dVpft8O6khsmrd4euInIFrrMexrl8b4pMj_ME,3409
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
 omlish/cached.py,sha256=UI-XTFBwA6YXWJJJeBn-WkwBkfzDjLBBaZf4nIJA9y0,510
@@ -7,7 +7,6 @@ omlish/check.py,sha256=RzMJhp8_dDnpHXnPiHDyZTW13KGDTopeuMgpwKCowPs,1988
 omlish/datetimes.py,sha256=HajeM1kBvwlTa-uR1TTZHmZ3zTPnnUr1uGGQhiO1XQ0,2152
 omlish/defs.py,sha256=9uUjJuVIbCBL3g14fyzAp-9gH935MFofvlfOGwcBIaM,4913
 omlish/dynamic.py,sha256=35C_cCX_Vq2HrHzGk5T-zbrMvmUdiIiwDzDNixczoDo,6541
-omlish/iterators.py,sha256=GGLC7RIT86uXMjhIIIqnff_Iu5SI_b9rXYywYGFyzmo,7292
 omlish/libc.py,sha256=8r7Ejyhttk9ruCfBkxNTrlzir5WPbDE2vmY7VPlceMA,15362
 omlish/multiprocessing.py,sha256=QZT4C7I-uThCAjaEY3xgUYb-5GagUlnE4etN01LDyU4,5186
 omlish/runmodule.py,sha256=PWvuAaJ9wQQn6bx9ftEL3_d04DyotNn8dR_twm2pgw0,700
@@ -116,7 +115,7 @@ omlish/codecs/chain.py,sha256=DrBi5vbaFfObfoppo6alwOmyW2XbrH2051cjExwr2Gs,527
 omlish/codecs/funcs.py,sha256=p4imNt7TobyZVXWC-WhntHVu9KfJrO4QwdtPRh-cVOk,850
 omlish/codecs/registry.py,sha256=8ySUG-kwGJoUN1HCRnz8VjcykB0wlIzoWF5WTAE1ny0,3860
 omlish/codecs/standard.py,sha256=eiZ4u9ep0XrA4Z_D1zJI0vmWyuN8HLrX4Se_r_Cq_ZM,60
-omlish/codecs/text.py,sha256=D8uy-3_XFwUSlygPQsHP8c2t5ZCgebQS0hv5CWoDXCI,5728
+omlish/codecs/text.py,sha256=8inuZbi_ODJB4G6eZfj2wBvCLgtpvhcTebKdGSori5c,5728
 omlish/collections/__init__.py,sha256=zeUvcAz073ekko37QKya6sElTMfKTuF1bKrdbMtaRpI,2142
 omlish/collections/abc.py,sha256=sP7BpTVhx6s6C59mTFeosBi4rHOWC6tbFBYbxdZmvh0,2365
 omlish/collections/coerce.py,sha256=g68ROb_-5HgH-vI8612mU2S0FZ8-wp2ZHK5_Zy_kVC0,7037
@@ -311,7 +310,7 @@ omlish/io/compress/adapters.py,sha256=DQvbiqTiaVE-GsawpOpUTX07Gjg125Iuwd6IhjuSax
 omlish/io/compress/base.py,sha256=yx8ifzs_j8y66gMCQcssjZ936NNBFhYn_kBRwNh3SWQ,647
 omlish/io/compress/brotli.py,sha256=Q2t9uRqBEgRyJCSPsTaJv5w7d-rhsjDMluA4VRBHa_A,1182
 omlish/io/compress/bz2.py,sha256=2ULaZwcpAkHKV-JargrLoXgL9G-gxrVnPqE_pGqNUrg,1566
-omlish/io/compress/codecs.py,sha256=e6jCYVfUbanUzvkWW9IHDK6SbG6dwRLAztTADCWnWEQ,1076
+omlish/io/compress/codecs.py,sha256=ySLHZdNKLx_CiBW9aGIu0gHbALGzF-uyH0usloU7s-8,1820
 omlish/io/compress/gzip.py,sha256=ZKZdg0wg_nIgFdkfemOv8xZpHneBXZAiCH0n6gIibWY,12281
 omlish/io/compress/lz4.py,sha256=4kppXZCXpSAQw6wJvCs9LLHFzukekENja7RiwmN8uMc,2790
 omlish/io/compress/lzma.py,sha256=4bWNKk7uTFiRT_HogW2ZldgaNy1IukmqfVDVkf5M2Ok,2501
@@ -323,11 +322,16 @@ omlish/io/fdio/handlers.py,sha256=OOQhiazbhNMwxLwyzf8KUQrBQSuHIm-UqAMpXmmHGFQ,13
 omlish/io/fdio/kqueue.py,sha256=YgGBQibkAUYODYDiGl7Enjtx1oQsJXuDsBLBXgqlLQw,3832
 omlish/io/fdio/manager.py,sha256=q4wWf7nKrNtjx6yPEvrVnFt4UtK_BTvVlquEGw7poEo,1250
 omlish/io/fdio/pollers.py,sha256=yNadAt3W5wd90PFmd3vD77bq5QwoVb2A6SM2JjZpKRs,5507
-omlish/io/generators/__init__.py,sha256=40DTZUqyss40dlgm68yKAtiAlqeIlYylTi8zaFrUW40,1135
+omlish/io/generators/__init__.py,sha256=YsSLJY9uw72eX3iXd_A0pM69g7EvEqMFdCdR_BBD4RA,1216
 omlish/io/generators/consts.py,sha256=4r6IMLBMic6MJHVn9UiORIkkPAuxsqtzFT3KV0fatC0,33
 omlish/io/generators/direct.py,sha256=A9VJB1rNKU3l-NatpYIwyCLI3R_ybGglmdx6sAtoTo4,324
 omlish/io/generators/readers.py,sha256=MolTFCzcnD5XoP0su0YUNHJ0xlHC3KTihvWAi75y8Bo,4336
-omlish/io/generators/stepped.py,sha256=wk4vDqOKi_Tr4qMY_FxIGO5dF3Ob-3Uh8UcV_9UYrAg,4677
+omlish/io/generators/stepped.py,sha256=sl-3-hNVYi7qGYZjwBPHs0hKxmz7XkfDMosCXbhIYlE,5025
+omlish/iterators/__init__.py,sha256=yMavf5FofiS1EU4UFuWPXiFZ03W0H-y7MuMxW8FUaEE,358
+omlish/iterators/iterators.py,sha256=ghI4dO6WPyyFOLTIIMaHQ_IOy2xXaFpGPqveZ5YGIBU,3158
+omlish/iterators/recipes.py,sha256=53mkexitMhkwXQZbL6DrhpT0WePQ_56uXd5Jaw3DfzI,467
+omlish/iterators/tools.py,sha256=SvXyyQJh7aceLYhRl6pQB-rfSaXw5IMIWukeEeOZt-0,2492
+omlish/iterators/unique.py,sha256=0jAX3kwzVfRNhe0Tmh7kVP_Q2WBIn8POo_O-rgFV0rQ,1390
 omlish/lang/__init__.py,sha256=wMfsQjBFNsZ_Y4352iEr0DlEnNebf26JmR4ETtDsQow,3948
 omlish/lang/cached.py,sha256=92TvRZQ6sWlm7dNn4hgl7aWKbX0J1XUEo3DRjBpgVQk,7834
 omlish/lang/clsdct.py,sha256=AjtIWLlx2E6D5rC97zQ3Lwq2SOMkbg08pdO_AxpzEHI,1744
@@ -552,9 +556,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.dev165.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev165.dist-info/METADATA,sha256=1yDvcRGCepEy655WVgRWrcVtvZKHIgCZVoOr5zdq_rs,4264
-omlish-0.0.0.dev165.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-omlish-0.0.0.dev165.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev165.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev165.dist-info/RECORD,,
+omlish-0.0.0.dev166.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev166.dist-info/METADATA,sha256=k2XolFifVQc4PpG7_98r62S2OP6NpxBerLqcXtxl-tg,4264
+omlish-0.0.0.dev166.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+omlish-0.0.0.dev166.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev166.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev166.dist-info/RECORD,,

omlish/iterators.py

@@ -1,300 +0,0 @@
-import collections
-import dataclasses as dc
-import functools
-import heapq
-import itertools
-import typing as ta
-
-# from . import check
-from . import lang
-
-
-T = ta.TypeVar('T')
-U = ta.TypeVar('U')
-
-_MISSING = object()
-
-
-class PeekIterator(ta.Iterator[T]):
-
-    def __init__(self, it: ta.Iterable[T]) -> None:
-        super().__init__()
-
-        self._it = iter(it)
-        self._pos = -1
-        self._next_item: ta.Any = _MISSING
-
-    _item: T
-
-    def __iter__(self) -> ta.Self:
-        return self
-
-    @property
-    def done(self) -> bool:
-        try:
-            self.peek()
-        except StopIteration:
-            return True
-        else:
-            return False
-
-    def __next__(self) -> T:
-        if self._next_item is not _MISSING:
-            self._item = ta.cast(T, self._next_item)
-            self._next_item = _MISSING
-        else:
-            self._item = next(self._it)
-        self._pos += 1
-        return self._item
-
-    def peek(self) -> T:
-        if self._next_item is not _MISSING:
-            return ta.cast(T, self._next_item)
-        self._next_item = next(self._it)
-        return self._next_item
-
-    def next_peek(self) -> T:
-        next(self)
-        return self.peek()
-
-    def takewhile(self, fn: ta.Callable[[T], bool]) -> ta.Iterator[T]:
-        while fn(self.peek()):
-            yield next(self)
-
-    def skipwhile(self, fn: ta.Callable[[T], bool]) -> None:
-        while fn(self.peek()):
-            next(self)
-
-    def takeuntil(self, fn: ta.Callable[[T], bool]) -> ta.Iterator[T]:
-        return self.takewhile(lambda e: not fn(e))
-
-    def skipuntil(self, fn: ta.Callable[[T], bool]) -> None:
-        self.skipwhile(lambda e: not fn(e))
-
-    def takethrough(self, pos: int) -> ta.Iterator[T]:
-        return self.takewhile(lambda _: self._pos < pos)
-
-    def skipthrough(self, pos: int) -> None:
-        self.skipwhile(lambda _: self._pos < pos)
-
-    def taketo(self, pos: int) -> ta.Iterator[T]:
-        return self.takethrough(pos - 1)
-
-    def skipto(self, pos: int) -> None:
-        self.skipthrough(pos - 1)
-
-
-class ProxyIterator(ta.Iterator[T]):
-
-    def __init__(self, fn: ta.Callable[[], T]) -> None:
-        self._fn = fn
-
-    def __iter__(self) -> ta.Self:
-        return self
-
-    def __next__(self) -> T:
-        return self._fn()
-
-
-class PrefetchIterator(ta.Iterator[T]):
-
-    def __init__(self, fn: ta.Callable[[], T] | None = None) -> None:
-        super().__init__()
-
-        self._fn = fn
-        self._deque: collections.deque[T] = collections.deque()
-
-    def __iter__(self) -> ta.Self:
-        return self
-
-    def push(self, item) -> None:
-        self._deque.append(item)
-
-    def __next__(self) -> T:
-        try:
-            return self._deque.popleft()
-        except IndexError:
-            if self._fn is None:
-                raise StopIteration from None
-        return self._fn()
-
-
-class RetainIterator(ta.Iterator[T]):
-
-    def __init__(self, fn: ta.Callable[[], T]) -> None:
-        super().__init__()
-
-        self._fn = fn
-        self._deque: collections.deque[T] = collections.deque()
-
-    def __iter__(self) -> ta.Self:
-        return self
-
-    def pop(self) -> None:
-        self._deque.popleft()
-
-    def __next__(self) -> T:
-        item = self._fn()
-        self._deque.append(item)
-        return item
-
-
-def unzip(it: ta.Iterable[T], width: int | None = None) -> list:
-    if width is None:
-        if not isinstance(it, PeekIterator):
-            it = PeekIterator(iter(it))
-        try:
-            width = len(it.peek())
-        except StopIteration:
-            return []
-
-    its: list[PrefetchIterator[T]] = []
-    running = True
-
-    def next_fn(idx):
-        nonlocal running
-        if not running:
-            raise StopIteration
-        try:
-            items = next(it)  # type: ignore
-        except StopIteration:
-            running = False
-            raise
-        for item_idx, item in enumerate(items):
-            its[item_idx].push(item)
-        return next(its[idx])
-
-    its.extend(PrefetchIterator(functools.partial(next_fn, idx)) for idx in range(width))
-    return its
-
-
-def take(n: int, iterable: ta.Iterable[T]) -> list[T]:
-    return list(itertools.islice(iterable, n))
-
-
-def chunk(n: int, iterable: ta.Iterable[T], strict: bool = False) -> ta.Iterator[list[T]]:
-    iterator = iter(functools.partial(take, n, iter(iterable)), [])
-    if strict:
-        def ret():
-            for chunk in iterator:
-                if len(chunk) != n:
-                    raise ValueError('iterable is not divisible by n.')
-                yield chunk
-        return iter(ret())
-    else:
-        return iterator
-
-
-def merge_on(
-        function: ta.Callable[[T], U],
-        *its: ta.Iterable[T],
-) -> ta.Iterator[tuple[U, list[tuple[int, T]]]]:
-    indexed_its = [
-        (
-            (function(item), it_idx, item)
-            for it_idx, item in zip(itertools.repeat(it_idx), it)
-        )
-        for it_idx, it in enumerate(its)
-    ]
-
-    grouped_indexed_its = itertools.groupby(
-        heapq.merge(*indexed_its),
-        key=lambda item_tuple: item_tuple[0],
-    )
-
-    return (
-        (fn_item, [(it_idx, item) for _, it_idx, item in grp])
-        for fn_item, grp in grouped_indexed_its
-    )
-
-
-def expand_indexed_pairs(
-        seq: ta.Iterable[tuple[int, T]],
-        default: T,
-        *,
-        width: int | None = None,
-) -> list[T]:
-    width_ = width
-    if width_ is None:
-        width_ = (max(idx for idx, _ in seq) + 1) if seq else 0
-    result = [default] * width_
-    for idx, value in seq:
-        if idx < width_:
-            result[idx] = value
-    return result
-
-
-##
-# https://docs.python.org/3/library/itertools.html#itertools-recipes
-
-
-def sliding_window(it: ta.Iterable[T], n: int) -> ta.Iterator[tuple[T, ...]]:
-    # sliding_window('ABCDEFG', 4) -> ABCD BCDE CDEF DEFG
-    iterator = iter(it)
-    window = collections.deque(itertools.islice(iterator, n - 1), maxlen=n)
-    for x in iterator:
-        window.append(x)
-        yield tuple(window)
-
-
-##
-
-
-@dc.dataclass()
-class UniqueStats:
-    key: ta.Any
-    num_seen: int
-    first_idx: int
-    last_idx: int
-
-
-@dc.dataclass(frozen=True)
-class UniqueItem(ta.Generic[T]):
-    idx: int
-    item: T
-    stats: UniqueStats
-    out: lang.Maybe[T]
-
-
-class UniqueIterator(ta.Iterator[UniqueItem[T]]):
-    def __init__(
-            self,
-            it: ta.Iterable[T],
-            keyer: ta.Callable[[T], ta.Any] = lang.identity,
-    ) -> None:
-        super().__init__()
-        self._it = enumerate(it)
-        self._keyer = keyer
-
-        self.stats: dict[ta.Any, UniqueStats] = {}
-
-    def __next__(self) -> UniqueItem[T]:
-        idx, item = next(self._it)
-        key = self._keyer(item)
-
-        try:
-            stats = self.stats[key]
-
-        except KeyError:
-            stats = self.stats[key] = UniqueStats(
-                key,
-                num_seen=1,
-                first_idx=idx,
-                last_idx=idx,
-            )
-            return UniqueItem(
-                idx,
-                item,
-                stats,
-                lang.just(item),
-            )
-
-        else:
-            stats.num_seen += 1
-            stats.last_idx = idx
-            return UniqueItem(
-                idx,
-                item,
-                stats,
-                lang.empty(),
-            )