pyochain 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

pyochain/_iter/_tuples.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import itertools
-from collections.abc import Callable
+from collections.abc import Callable, Iterable, Iterator
 from functools import partial
-from typing import TYPE_CHECKING, Literal, overload
+from typing import TYPE_CHECKING, Any, Literal, overload
 
 import cytoolz as cz
 import more_itertools as mit
@@ -25,7 +25,7 @@ class BaseTuples[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(enumerate)
+        return self._lazy(enumerate)
 
     @overload
     def combinations(self, r: Literal[2]) -> Iter[tuple[T, T]]: ...
@@ -41,7 +41,6 @@ class BaseTuples[T](IterWrapper[T]):
 
         Args:
             r: Length of each combination.
-
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_([1, 2, 3]).combinations(2).into(list)
@@ -49,7 +48,7 @@ class BaseTuples[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(itertools.combinations, r)
+        return self._lazy(itertools.combinations, r)
 
     @overload
     def permutations(self, r: Literal[2]) -> Iter[tuple[T, T]]: ...
@@ -65,7 +64,6 @@ class BaseTuples[T](IterWrapper[T]):
 
         Args:
             r: Length of each permutation. Defaults to the length of the iterable.
-
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_([1, 2, 3]).permutations(2).into(list)
@@ -73,7 +71,7 @@ class BaseTuples[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(itertools.permutations, r)
+        return self._lazy(itertools.permutations, r)
 
     @overload
     def combinations_with_replacement(self, r: Literal[2]) -> Iter[tuple[T, T]]: ...
@@ -93,7 +91,6 @@ class BaseTuples[T](IterWrapper[T]):
 
         Args:
             r: Length of each combination.
-
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_([1, 2, 3]).combinations_with_replacement(2).into(list)
@@ -101,7 +98,7 @@ class BaseTuples[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(itertools.combinations_with_replacement, r)
+        return self._lazy(itertools.combinations_with_replacement, r)
 
     def pairwise(self) -> Iter[tuple[T, T]]:
         """
@@ -113,7 +110,7 @@ class BaseTuples[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(itertools.pairwise)
+        return self._lazy(itertools.pairwise)
 
     @overload
     def map_juxt[R1, R2](
@@ -156,7 +153,7 @@ class BaseTuples[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(partial(map, cz.functoolz.juxt(*funcs)))
+        return self._lazy(partial(map, cz.functoolz.juxt(*funcs)))
 
     def adjacent(
         self, predicate: Callable[[T], bool], distance: int = 1
@@ -195,7 +192,7 @@ class BaseTuples[T](IterWrapper[T]):
 
         See also groupby_transform, which can be used with this function to group ranges of items with the same bool value.
         """
-        return self.apply(partial(mit.adjacent, predicate, distance=distance))
+        return self._lazy(partial(mit.adjacent, predicate, distance=distance))
 
     def classify_unique(self) -> Iter[tuple[T, bool, bool]]:
         """
@@ -205,6 +202,9 @@ class BaseTuples[T](IterWrapper[T]):
         - The element itself
         - False if the element is equal to the one preceding it in the input, True otherwise (i.e. the equivalent of unique_justseen)
         - False if this element has been seen anywhere in the input before, True otherwise (i.e. the equivalent of unique_everseen)
+
+        This function is analogous to unique_everseen and is subject to the same performance considerations.
+
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_("otto").classify_unique().into(list)
@@ -215,7 +215,112 @@ class BaseTuples[T](IterWrapper[T]):
         ('o', True,  False)]
 
         ```
+        """
+        return self._lazy(mit.classify_unique)
 
-        This function is analogous to unique_everseen and is subject to the same performance considerations.
+    @overload
+    def group_by_transform(
+        self,
+        keyfunc: None = None,
+        valuefunc: None = None,
+        reducefunc: None = None,
+    ) -> Iter[tuple[T, Iterator[T]]]: ...
+    @overload
+    def group_by_transform[U](
+        self,
+        keyfunc: Callable[[T], U],
+        valuefunc: None,
+        reducefunc: None,
+    ) -> Iter[tuple[U, Iterator[T]]]: ...
+    @overload
+    def group_by_transform[V](
+        self,
+        keyfunc: None,
+        valuefunc: Callable[[T], V],
+        reducefunc: None,
+    ) -> Iter[tuple[T, Iterator[V]]]: ...
+    @overload
+    def group_by_transform[U, V](
+        self,
+        keyfunc: Callable[[T], U],
+        valuefunc: Callable[[T], V],
+        reducefunc: None,
+    ) -> Iter[tuple[U, Iterator[V]]]: ...
+    @overload
+    def group_by_transform[W](
+        self,
+        keyfunc: None,
+        valuefunc: None,
+        reducefunc: Callable[[Iterator[T]], W],
+    ) -> Iter[tuple[T, W]]: ...
+    @overload
+    def group_by_transform[U, W](
+        self,
+        keyfunc: Callable[[T], U],
+        valuefunc: None,
+        reducefunc: Callable[[Iterator[T]], W],
+    ) -> Iter[tuple[U, W]]: ...
+    @overload
+    def group_by_transform[V, W](
+        self,
+        keyfunc: None,
+        valuefunc: Callable[[T], V],
+        reducefunc: Callable[[Iterator[V]], W],
+    ) -> Iter[tuple[T, W]]: ...
+    @overload
+    def group_by_transform[U, V, W](
+        self,
+        keyfunc: Callable[[T], U],
+        valuefunc: Callable[[T], V],
+        reducefunc: Callable[[Iterator[V]], W],
+    ) -> Iter[tuple[U, W]]: ...
+    def group_by_transform[U, V](
+        self,
+        keyfunc: Callable[[T], U] | None = None,
+        valuefunc: Callable[[T], V] | None = None,
+        reducefunc: Any = None,
+    ) -> Iter[tuple[Any, ...]]:
         """
-        return self.apply(mit.classify_unique)
+        An extension of ``Iter.groupby`` that can apply transformations to the grouped data.
+
+        Args:
+            keyfunc: Function to compute the key for grouping. Defaults to None.
+            valuefunc: Function to transform individual items after grouping. Defaults to None.
+            reducefunc: Function to transform each group of items. Defaults to None.
+
+        Example:
+        ```python
+        >>> import pyochain as pc
+        >>> data = pc.Iter.from_("aAAbBBcCC")
+        >>> data.group_by_transform(
+        ...     lambda k: k.upper(), lambda v: v.lower(), lambda g: "".join(g)
+        ... ).into(list)
+        [('A', 'aaa'), ('B', 'bbb'), ('C', 'ccc')]
+
+        ```
+        Each optional argument defaults to an identity function if not specified.
+
+        group_by_transform is useful when grouping elements of an iterable using a separate iterable as the key.
+
+        To do this, zip the iterables and pass a keyfunc that extracts the first element and a valuefunc that extracts the second element:
+
+        Note that the order of items in the iterable is significant.
+
+        Only adjacent items are grouped together, so if you don't want any duplicate groups, you should sort the iterable by the key function.
+
+        Example:
+        ```python
+        >>> from operator import itemgetter
+        >>> data = pc.Iter.from_([0, 0, 1, 1, 1, 2, 2, 2, 3])
+        >>> data.zip("abcdefghi").group_by_transform(itemgetter(0), itemgetter(1)).map(
+        ...     lambda kv: (kv[0], "".join(kv[1]))
+        ... ).into(list)
+        [(0, 'ab'), (1, 'cde'), (2, 'fgh'), (3, 'i')]
+
+        ```
+        """
+
+        def _group_by_transform(data: Iterable[T]) -> Iterator[tuple[Any, ...]]:
+            return mit.groupby_transform(data, keyfunc, valuefunc, reducefunc)
+
+        return self._lazy(_group_by_transform)

{pyochain-0.5.0.dist-info → pyochain-0.5.2.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.3
 Name: pyochain
-Version: 0.5.0
-Summary: Add your description here
+Version: 0.5.2
+Summary: Method chaining for iterables and dictionaries in Python.
 Requires-Dist: cytoolz>=1.0.1
 Requires-Dist: more-itertools>=10.8.0
 Requires-Dist: rolling>=0.5.0
@@ -19,7 +19,7 @@ Manipulate data through composable chains of operations, enhancing readability a
 ## Installation
 
 ```bash
-uv add git+https://github.com/OutSquareCapital/pyochain.git
+uv add pyochain
 ```
 
 ## API Reference 📖
@@ -33,7 +33,7 @@ The full API reference can be found at:
 
 * **Declarative over Imperative:** Replace explicit `for` and `while` loops with sequences of high-level operations (map, filter, group, join...).
 * **Fluent Chaining:** Each method transforms the data and returns a new wrapper instance, allowing for seamless chaining.
-* **Lazy and Eager:** `Iter` operates lazily for efficiency on large or infinite sequences, while `Seq` represents materialized collections for eager operations.
+* **Lazy and Eager:** `Iter` operates lazily for efficiency on large or infinite sequences, while `Seq` represents materialized sequences for eager operations.
 * **100% Type-safe:** Extensive use of generics and overloads ensures type safety and improves developer experience.
 * **Documentation-first:** Each method is thoroughly documented with clear explanations, and usage examples. Before any commit is made, each docstring is automatically tested to ensure accuracy. This also allows for a convenient experience in IDEs, where developers can easily access documentation with a simple hover of the mouse.
 * **Functional paradigm:** Design encourages building complex data transformations by composing simple, reusable functions on known buildings blocks, rather than implementing customs classes each time.
@@ -57,7 +57,7 @@ Provides a vast array of methods for transformation, filtering, aggregation, joi
 
 #### `Seq[T]`
 
-Wraps a Python `Collection` (`list`, `tuple`, `set`...), and represents **eagerly** evaluated data.
+Wraps a Python `Sequence` (`list`, `tuple`...), and represents **eagerly** evaluated data.
 
 Exposes a subset of the `Iter` methods who operate on the full dataset (e.g., `sort`, `union`) or who aggregate it.
 
@@ -122,8 +122,6 @@ Each method and class make extensive use of generics, type hints, and overloads
 
 Since there's much less need for intermediate variables, the developper don't have to annotate them as much, whilst still keeping a type-safe codebase.
 
-Target: modern Python 3.13 syntax (PEP 695 generics, updated collections.abc types).
-
 ### Expressions for Dict ``pyochain.key``
 
 Compute new fields from existing nested data with key() and Expr.apply(), either selecting a new dict or merging into the root.

pyochain-0.5.2.dist-info/RECORD

@@ -0,0 +1,32 @@
+pyochain/__init__.py,sha256=f5iynOtt1j-5GNsyBlThe4KHLqnDXXxxSfrBr72KRjM,152
+pyochain/_core/__init__.py,sha256=J91CV32HesQdEK8D5iwLoWW9LRGbtN4wqHY6c12eZo8,451
+pyochain/_core/_main.py,sha256=vQ_f2GaMGAL8HcT12gNwxudsNdHr5ZrhgkHzi_YAy6I,4769
+pyochain/_core/_protocols.py,sha256=D0t1-amduqjN27qoKESApBr7YPx6Dt5kB6oH9VTDq8o,941
+pyochain/_dict/__init__.py,sha256=PdRjmX-7GTlZy3qbeS1IFO6QZNgjhVnhrUje-EvNZfw,89
+pyochain/_dict/_exprs.py,sha256=sgUlTK09OC0o-Isd3eJena8ug39Qj8W_bBeTVbo40bc,3138
+pyochain/_dict/_filters.py,sha256=NbdUMPC7b9Htb4bTNYNukIjMrwVZs1iSj7IOix5NDqQ,8235
+pyochain/_dict/_funcs.py,sha256=zse4gAU7Zk6TnKvxvyyJtWwvydJ59gDqMOWOukh5T94,2209
+pyochain/_dict/_groups.py,sha256=LwzV4bHdsgNHqQ0-0euyWaN7SthgI11HkbpZNDtFMvE,6080
+pyochain/_dict/_iter.py,sha256=1nB6kv4nG7YB0_LzUj52dNuylTXc5Lts140VZMrjVrc,2707
+pyochain/_dict/_joins.py,sha256=wvexoINtPpO5zZvuorJJ2RYLFOE3JbSZ-19S3QHk1F0,4409
+pyochain/_dict/_main.py,sha256=TuVX-isXxubtTakV9ydDe_ikRLS0BCDgA-54JQ6Wldc,9097
+pyochain/_dict/_nested.py,sha256=vjuh-J7KIPOiTKCwZdHLobXnrgxWxJyFJ8VXDjXHkM4,7929
+pyochain/_dict/_process.py,sha256=usJF3FLZodzVvZzgmhDzwHSNyC791Ul2NtjsF5wMHso,6118
+pyochain/_iter/__init__.py,sha256=a8YS8Yx_UbLXdzM70YQrt6gyv1v7QW_16i2ydsyGGV8,56
+pyochain/_iter/_aggregations.py,sha256=VkAYF9w4GwVBDYx1H5pL2dkMIWfodj3QsZsOc4AchlA,8584
+pyochain/_iter/_booleans.py,sha256=KE4x-lxayHH_recHoX5ZbNz7JVdC9WuvA2ewNBpqUL0,7210
+pyochain/_iter/_dicts.py,sha256=65GdlZHYydTtzI3qZgoyejjmeLU28jVJ8VNmX5DIwzQ,6600
+pyochain/_iter/_eager.py,sha256=fzWRTMgND6a84-FTP5Qrr9vYPWPcASfEAyntxsFuFlU,5547
+pyochain/_iter/_filters.py,sha256=_ppvUG-DgEIhqmuyaOB0_g4tbtH_4bNk7vdVpjP8luY,15515
+pyochain/_iter/_joins.py,sha256=oZOaziwme27Db28puy9MBPsixDzJxznIKFuPCkNGug0,13136
+pyochain/_iter/_lists.py,sha256=TU-HjyyM_KqJTwA_0V0fCyJHl9L6wsRi1n4Sl8g2Gro,11103
+pyochain/_iter/_main.py,sha256=6xN5QLPbT5yPn4cTEdRYKxC6p47T_uJT10uLskzzdUY,15083
+pyochain/_iter/_maps.py,sha256=OE9t14gtCyyTBaDXyxE1ZqgHcJRjWCmoUDH6EKnHJm8,11491
+pyochain/_iter/_partitions.py,sha256=MYxlzQRrCBtfjnhtIVdMUhkNq5FCTpFV1R9sJ9LznsM,5095
+pyochain/_iter/_process.py,sha256=Igmn7sqMYWciCnvIL-tAXpfmBjktv1hjpGBOUf-sbDk,11433
+pyochain/_iter/_rolling.py,sha256=YJ5X23eZTizXEJYneaZvn98zORbvJzLWXP8gX1BCvGY,6979
+pyochain/_iter/_tuples.py,sha256=rcEeqrz3eio1CEYyZ0lt2CC5P_OW7ARLkTL0g7yf3ws,11137
+pyochain/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyochain-0.5.2.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+pyochain-0.5.2.dist-info/METADATA,sha256=9Dt0bz_zlfqmgH6i5LFSX1IQGhkhc25v6aMINM3NYbE,11043
+pyochain-0.5.2.dist-info/RECORD,,

pyochain/_iter/_constructors.py

@@ -1,155 +0,0 @@
-from __future__ import annotations
-
-import itertools
-from collections.abc import Callable, Iterable, Iterator
-from typing import TYPE_CHECKING
-
-import cytoolz as cz
-
-if TYPE_CHECKING:
-    from ._main import Iter
-
-
-class IterConstructors:
-    @staticmethod
-    def from_count(start: int = 0, step: int = 1) -> Iter[int]:
-        """
-        Create an infinite iterator of evenly spaced values.
-
-        **Warning** ⚠️
-            This creates an infinite iterator.
-            Be sure to use `Iter.take()` or `Iter.slice()` to limit the number of items taken.
-
-        Args:
-            start: Starting value of the sequence. Defaults to 0.
-            step: Difference between consecutive values. Defaults to 1.
-        Example:
-        ```python
-        >>> import pyochain as pc
-        >>> pc.Iter.from_count(10, 2).take(3).into(list)
-        [10, 12, 14]
-
-        ```
-        """
-        from ._main import Iter
-
-        return Iter(itertools.count(start, step))
-
-    @staticmethod
-    def from_func[U](func: Callable[[U], U], input: U) -> Iter[U]:
-        """
-        Create an infinite iterator by repeatedly applying a function on an original input.
-
-        **Warning** ⚠️
-            This creates an infinite iterator.
-            Be sure to use `Iter.take()` or `Iter.slice()` to limit the number of items taken.
-
-        Args:
-            func: Function to apply repeatedly.
-            input: Initial value to start the iteration.
-
-        Example:
-        ```python
-        >>> import pyochain as pc
-        >>> pc.Iter.from_func(lambda x: x + 1, 0).take(3).into(list)
-        [0, 1, 2]
-
-        ```
-        """
-        from ._main import Iter
-
-        return Iter(cz.itertoolz.iterate(func, input))
-
-    @staticmethod
-    def from_[U](data: Iterable[U]) -> Iter[U]:
-        """
-        Create an iterator from any Iterable.
-
-        - An Iterable is any object capable of returning its members one at a time, permitting it to be iterated over in a for-loop.
-        - An Iterator is an object representing a stream of data; returned by calling `iter()` on an Iterable.
-        - Once an Iterator is exhausted, it cannot be reused or reset.
-
-        If you need to reuse the data, consider collecting it into a list first with `.collect()`.
-
-        In general, avoid intermediate references when dealing with lazy iterators, and prioritize method chaining instead.
-        Args:
-            data: Iterable to convert into an iterator.
-        Example:
-        ```python
-        >>> import pyochain as pc
-        >>> data: tuple[int, ...] = (1, 2, 3)
-        >>> iterator = pc.Iter.from_(data)
-        >>> iterator.unwrap().__class__.__name__
-        'tuple_iterator'
-        >>> mapped = iterator.map(lambda x: x * 2)
-        >>> mapped.unwrap().__class__.__name__
-        'map'
-        >>> mapped.collect(tuple).unwrap()
-        (2, 4, 6)
-        >>> # iterator is now exhausted
-        >>> iterator.collect().unwrap()
-        []
-
-        ```
-        """
-        from ._main import Iter
-
-        return Iter(iter(data))
-
-    @staticmethod
-    def unfold[S, V](seed: S, generator: Callable[[S], tuple[V, S] | None]) -> Iter[V]:
-        """
-        Create an iterator by repeatedly applying a generator function to an initial state.
-
-        The `generator` function takes the current state and must return:
-            - A tuple `(value, new_state)` to emit the `value` and continue with the `new_state`.
-            - `None` to stop the generation.
-
-        This is functionally equivalent to a state-based `while` loop.
-
-        **Warning** ⚠️
-            If the `generator` function never returns `None`, it creates an infinite iterator.
-            Be sure to use `Iter.take()` or `Iter.slice()` to limit the number of items taken if necessary.
-
-        Args:
-            seed: Initial state for the generator.
-            generator: Function that generates the next value and state.
-
-        Example:
-        ```python
-        >>> import pyochain as pc
-        >>> # Example 1: Simple counter up to 5
-        >>> def counter_generator(state: int) -> tuple[int, int] | None:
-        ...     if state < 5:
-        ...         return (state * 10, state + 1)
-        ...     return None
-        >>> pc.Iter.unfold(seed=0, generator=counter_generator).into(list)
-        [0, 10, 20, 30, 40]
-        >>> # Example 2: Fibonacci sequence up to 100
-        >>> type FibState = tuple[int, int]
-        >>> def fib_generator(state: FibState) -> tuple[int, FibState] | None:
-        ...     a, b = state
-        ...     if a > 100:
-        ...         return None
-        ...     return (a, (b, a + b))
-        >>> pc.Iter.unfold(seed=(0, 1), generator=fib_generator).into(list)
-        [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
-        >>> # Example 3: Infinite iterator (requires take())
-        >>> pc.Iter.unfold(seed=1, generator=lambda s: (s, s * 2)).take(5).into(list)
-        [1, 2, 4, 8, 16]
-
-        ```
-        """
-        from ._main import Iter
-
-        def _unfold() -> Iterator[V]:
-            current_seed: S = seed
-            while True:
-                result: tuple[V, S] | None = generator(current_seed)
-                if result is None:
-                    break
-                value, next_seed = result
-                yield value
-                current_seed = next_seed
-
-        return Iter(_unfold())

pyochain-0.5.0.dist-info/RECORD

@@ -1,33 +0,0 @@
-pyochain/__init__.py,sha256=f5iynOtt1j-5GNsyBlThe4KHLqnDXXxxSfrBr72KRjM,152
-pyochain/_core/__init__.py,sha256=J91CV32HesQdEK8D5iwLoWW9LRGbtN4wqHY6c12eZo8,451
-pyochain/_core/_main.py,sha256=LdcJRYGvHfGYTmY0avTm7M2ykPDspfO_R7wKDxQ3oQY,5468
-pyochain/_core/_protocols.py,sha256=D0t1-amduqjN27qoKESApBr7YPx6Dt5kB6oH9VTDq8o,941
-pyochain/_dict/__init__.py,sha256=PdRjmX-7GTlZy3qbeS1IFO6QZNgjhVnhrUje-EvNZfw,89
-pyochain/_dict/_exprs.py,sha256=KJwVXZS64GjpbjtHVl0PPTY1KvZVG-qo6HPSvigg0NU,3137
-pyochain/_dict/_filters.py,sha256=E7aykSNn2N74n2HS2DhG_intEU7KoNQHFxUYDEVydV8,8234
-pyochain/_dict/_funcs.py,sha256=zse4gAU7Zk6TnKvxvyyJtWwvydJ59gDqMOWOukh5T94,2209
-pyochain/_dict/_groups.py,sha256=vw4lmBORvJ5w3u3rnG0G1xa4LONF5rthl5qVy7luhhw,6122
-pyochain/_dict/_iter.py,sha256=LwylGaaQeB2Xx94U4UgVH9f66jzBeCx2THuv60iV3DY,2463
-pyochain/_dict/_joins.py,sha256=wvexoINtPpO5zZvuorJJ2RYLFOE3JbSZ-19S3QHk1F0,4409
-pyochain/_dict/_main.py,sha256=Jkb84P-5WqZqsZPfxnk_nWcrZPIXFE3iTn40-lYjALc,9130
-pyochain/_dict/_nested.py,sha256=vjuh-J7KIPOiTKCwZdHLobXnrgxWxJyFJ8VXDjXHkM4,7929
-pyochain/_dict/_process.py,sha256=B5ivADOuwShODeg7Kh4fMwvGQb1vRXISHTtUi-DkvWs,5443
-pyochain/_iter/__init__.py,sha256=a8YS8Yx_UbLXdzM70YQrt6gyv1v7QW_16i2ydsyGGV8,56
-pyochain/_iter/_aggregations.py,sha256=LLdeK8GwdMV8-ljlOCQPF3i90OUoAg8ImGU06pVu6O8,8583
-pyochain/_iter/_booleans.py,sha256=3wOlvCqIV20sKwyPlwUq57cWpUbiKNYm3CMU6gtuYVY,7207
-pyochain/_iter/_constructors.py,sha256=sEB8W6r22kjBuu0lUvyPKwHLXbPc9L9diK5UYMSTGU0,5348
-pyochain/_iter/_eager.py,sha256=1GklA98m7rRYKh6NVqHnwcwxt4eDSkVnyakcATmH-Rc,5562
-pyochain/_iter/_filters.py,sha256=e9F8j5VgPqD4jPwCwPMdjbi5I8bb-mjzBXKyYIiwiTU,15321
-pyochain/_iter/_groups.py,sha256=oUkxgNXqC9je2XRCpV8MVQYiVwp4t8pKejiPBtfY340,8327
-pyochain/_iter/_joins.py,sha256=dF28_muvSxMnShauTEQ0KkcA1b9JZia1ieAhWBQ_nk8,13134
-pyochain/_iter/_lists.py,sha256=N71EV_ha3vjnMOcRVLZy4-Sk2mf7rDxmL_GLgRtBU8k,11101
-pyochain/_iter/_main.py,sha256=1_XL9boT5GKi6SwYBIXoIcO5P9tqFGV1nWWs6qX0BV8,7191
-pyochain/_iter/_maps.py,sha256=5W92MYGCKWK2d-byoomXktVPJZa5sCFVHTb6a5Duqko,11395
-pyochain/_iter/_partitions.py,sha256=y97P9Y7wMX8qcSfdly6PVleB9D8gfAWeBAcNlDKZuOo,5098
-pyochain/_iter/_process.py,sha256=obpPnz4uYmdikPLJGlcyWVGmU2k0bEkU6nMi5zZdatY,11449
-pyochain/_iter/_rolling.py,sha256=lcqtkTJtHtEwpZaj_d3ILoCKHh_GVJhOg7L9BE0rWq4,7053
-pyochain/_iter/_tuples.py,sha256=FeKFQ5KAZZaPlnykE3AD4MEaZLaPVFw3w9LEqR_BVWE,7477
-pyochain/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyochain-0.5.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-pyochain-0.5.0.dist-info/METADATA,sha256=m4-VmCaegu3uOmtFMfomAkPaPW6rg4DWdKAeJDCcnJ4,11152
-pyochain-0.5.0.dist-info/RECORD,,