pyochain 0.5.3__py3-none-any.whl

pyochain/_iter/_tuples.py

@@ -0,0 +1,326 @@
+from __future__ import annotations
+
+import itertools
+from collections.abc import Callable, Iterable, Iterator
+from functools import partial
+from typing import TYPE_CHECKING, Any, Literal, overload
+
+import cytoolz as cz
+import more_itertools as mit
+
+from .._core import IterWrapper
+
+if TYPE_CHECKING:
+    from ._main import Iter
+
+
+class BaseTuples[T](IterWrapper[T]):
+    def enumerate(self) -> Iter[tuple[int, T]]:
+        """
+        Return a Iter of (index, value) pairs.
+        ```python
+        >>> import pyochain as pc
+        >>> pc.Iter.from_(["a", "b"]).enumerate().into(list)
+        [(0, 'a'), (1, 'b')]
+
+        ```
+        """
+        return self._lazy(enumerate)
+
+    @overload
+    def combinations(self, r: Literal[2]) -> Iter[tuple[T, T]]: ...
+    @overload
+    def combinations(self, r: Literal[3]) -> Iter[tuple[T, T, T]]: ...
+    @overload
+    def combinations(self, r: Literal[4]) -> Iter[tuple[T, T, T, T]]: ...
+    @overload
+    def combinations(self, r: Literal[5]) -> Iter[tuple[T, T, T, T, T]]: ...
+    def combinations(self, r: int) -> Iter[tuple[T, ...]]:
+        """
+        Return all combinations of length r.
+
+        Args:
+            r: Length of each combination.
+        ```python
+        >>> import pyochain as pc
+        >>> pc.Iter.from_([1, 2, 3]).combinations(2).into(list)
+        [(1, 2), (1, 3), (2, 3)]
+
+        ```
+        """
+        return self._lazy(itertools.combinations, r)
+
+    @overload
+    def permutations(self, r: Literal[2]) -> Iter[tuple[T, T]]: ...
+    @overload
+    def permutations(self, r: Literal[3]) -> Iter[tuple[T, T, T]]: ...
+    @overload
+    def permutations(self, r: Literal[4]) -> Iter[tuple[T, T, T, T]]: ...
+    @overload
+    def permutations(self, r: Literal[5]) -> Iter[tuple[T, T, T, T, T]]: ...
+    def permutations(self, r: int | None = None) -> Iter[tuple[T, ...]]:
+        """
+        Return all permutations of length r.
+
+        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)
+        [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]
+
+        ```
+        """
+        return self._lazy(itertools.permutations, r)
+
+    @overload
+    def combinations_with_replacement(self, r: Literal[2]) -> Iter[tuple[T, T]]: ...
+    @overload
+    def combinations_with_replacement(self, r: Literal[3]) -> Iter[tuple[T, T, T]]: ...
+    @overload
+    def combinations_with_replacement(
+        self, r: Literal[4]
+    ) -> Iter[tuple[T, T, T, T]]: ...
+    @overload
+    def combinations_with_replacement(
+        self, r: Literal[5]
+    ) -> Iter[tuple[T, T, T, T, T]]: ...
+    def combinations_with_replacement(self, r: int) -> Iter[tuple[T, ...]]:
+        """
+        Return all combinations with replacement of length r.
+
+        Args:
+            r: Length of each combination.
+        ```python
+        >>> import pyochain as pc
+        >>> pc.Iter.from_([1, 2, 3]).combinations_with_replacement(2).into(list)
+        [(1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3)]
+
+        ```
+        """
+        return self._lazy(itertools.combinations_with_replacement, r)
+
+    def pairwise(self) -> Iter[tuple[T, T]]:
+        """
+        Return an iterator over pairs of consecutive elements.
+        ```python
+        >>> import pyochain as pc
+        >>> pc.Iter.from_([1, 2, 3]).pairwise().into(list)
+        [(1, 2), (2, 3)]
+
+        ```
+        """
+        return self._lazy(itertools.pairwise)
+
+    @overload
+    def map_juxt[R1, R2](
+        self,
+        func1: Callable[[T], R1],
+        func2: Callable[[T], R2],
+        /,
+    ) -> Iter[tuple[R1, R2]]: ...
+    @overload
+    def map_juxt[R1, R2, R3](
+        self,
+        func1: Callable[[T], R1],
+        func2: Callable[[T], R2],
+        func3: Callable[[T], R3],
+        /,
+    ) -> Iter[tuple[R1, R2, R3]]: ...
+    @overload
+    def map_juxt[R1, R2, R3, R4](
+        self,
+        func1: Callable[[T], R1],
+        func2: Callable[[T], R2],
+        func3: Callable[[T], R3],
+        func4: Callable[[T], R4],
+        /,
+    ) -> Iter[tuple[R1, R2, R3, R4]]: ...
+    def map_juxt(self, *funcs: Callable[[T], object]) -> Iter[tuple[object, ...]]:
+        """
+        Apply several functions to each item.
+
+        Returns a new Iter where each item is a tuple of the results of applying each function to the original item.
+        ```python
+        >>> import pyochain as pc
+        >>> def is_even(n: int) -> bool:
+        ...     return n % 2 == 0
+        >>> def is_positive(n: int) -> bool:
+        ...     return n > 0
+        >>>
+        >>> pc.Iter.from_([1, -2, 3]).map_juxt(is_even, is_positive).into(list)
+        [(False, True), (True, False), (False, True)]
+
+        ```
+        """
+        return self._lazy(partial(map, cz.functoolz.juxt(*funcs)))
+
+    def adjacent(
+        self, predicate: Callable[[T], bool], distance: int = 1
+    ) -> Iter[tuple[bool, T]]:
+        """
+        Return an iterable over (bool, item) tuples.
+
+        Args:
+            predicate: Function to determine if an item satisfies the condition.
+            distance: Number of places to consider as adjacent. Defaults to 1.
+
+        The output is a sequence of tuples where the item is drawn from iterable.
+
+        The bool indicates whether that item satisfies the predicate or is adjacent to an item that does.
+
+        For example, to find whether items are adjacent to a 3:
+        ```python
+        >>> import pyochain as pc
+        >>> pc.Iter.from_(range(6)).adjacent(lambda x: x == 3).into(list)
+        [(False, 0), (False, 1), (True, 2), (True, 3), (True, 4), (False, 5)]
+
+        ```
+        Set distance to change what counts as adjacent.
+        For example, to find whether items are two places away from a 3:
+        ```python
+        >>> pc.Iter.from_(range(6)).adjacent(lambda x: x == 3, distance=2).into(list)
+        [(False, 0), (True, 1), (True, 2), (True, 3), (True, 4), (True, 5)]
+
+        ```
+
+        This is useful for contextualizing the results of a search function.
+
+        For example, a code comparison tool might want to identify lines that have changed, but also surrounding lines to give the viewer of the diff context.
+
+        The predicate function will only be called once for each item in the iterable.
+
+        See also groupby_transform, which can be used with this function to group ranges of items with the same bool value.
+        """
+        return self._lazy(partial(mit.adjacent, predicate, distance=distance))
+
+    def classify_unique(self) -> Iter[tuple[T, bool, bool]]:
+        """
+        Classify each element in terms of its uniqueness.\n
+        For each element in the input iterable, return a 3-tuple consisting of:
+
+        - 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)
+        ... # doctest: +NORMALIZE_WHITESPACE
+        [('o', True,  True),
+        ('t', True,  True),
+        ('t', False, False),
+        ('o', True,  False)]
+
+        ```
+        """
+        return self._lazy(mit.classify_unique)
+
+    @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, ...]]:
+        """
+        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.3.dist-info/METADATA

@@ -0,0 +1,261 @@
+Metadata-Version: 2.3
+Name: pyochain
+Version: 0.5.3
+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
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# pyochain ⛓️
+
+**_Functional-style method chaining for Python data structures._**
+
+`pyochain` brings a fluent, declarative API inspired by Rust's `Iterator` and DataFrame libraries like Polars to your everyday Python iterables and dictionaries.
+
+Manipulate data through composable chains of operations, enhancing readability and reducing boilerplate.
+
+## Notice on Stability ⚠️
+
+`pyochain` is currently in early development (< 1.0), and the API may undergo significant changes multiple times before reaching a stable 1.0 release.
+
+## Installation
+
+```bash
+uv add pyochain
+```
+
+## API Reference 📖
+
+The full API reference can be found at:
+<https://outsquarecapital.github.io/pyochain/>
+
+## Overview
+
+### Philosophy
+
+* **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 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.
+
+### Inspirations
+
+* **Rust's language and  Rust `Iterator` Trait:** Emulate naming conventions (`from_()`, `into()`) and leverage concepts from Rust's powerful iterator traits (method chaining, lazy evaluation) to bring similar expressiveness to Python.
+* **Python iterators libraries:** Libraries like `rolling`, `cytoolz`, and `more-itertools` provided ideas, inspiration, and implementations for many of the iterator methods.
+* **PyFunctional:** Although not directly used (because I started writing pyochain before discovering it), also shares similar goals and ideas.
+
+### Core Components
+
+#### `Iter[T]`
+
+To instantiate it, wrap a Python `Iterator` or `Generator`, or take any Iterable (`list`, `tuple`, etc...) and call Iter.from_ (which will call the builtin `iter()` on it).
+
+All operations that return a new `Iter` are **lazy**, consuming the underlying iterator on demand.
+
+Provides a vast array of methods for transformation, filtering, aggregation, joining, etc..
+
+#### `Seq[T]`
+
+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.
+
+It is most useful when you need to reuse the data multiple times without re-iterating it.
+
+Use `.iter()` to switch back to lazy processing.
+
+#### `Dict[K, V]`
+
+Wraps a Python `dict` (or any Mapping via ``Dict.from_``) and provides chainable methods specific to dictionaries (manipulating keys, values, items, nesting, joins, grouping).
+
+Promote immutability by returning new `Dict` instances on each operation, and avoiding in-place modifications.
+
+Can work easily on known data structure (e.g `dict[str, int]`), with methods like `map_values`, `filter_keys`, etc., who works on the whole `dict` in a performant way, mostly thanks to `cytoolz` functions.
+
+But `Dict` can work also as well as on "irregular" structures (e.g., `dict[Any, Any]`, TypedDict, etc..), by providing a set of utilities for working with nested data, including:
+
+* `pluck` to extract multiple fields at once.
+* `flatten` to collapse nested structures into a single level.
+
+#### `Wrapper[T]`
+
+A generic wrapper for any Python object, allowing integration into `pyochain`'s fluent style using `pipe`, `apply`, and `into`.
+
+Can be for example used to wrap numpy arrays, json outputs from requests, or any custom class instance, as a way to integrate them into a chain of operations, rather than breaking the chain to reference intermediate variables.
+
+### Core Piping Methods
+
+All wrappers inherit from `CommonBase`:
+
+* `into[**P, R](func: Callable[Concatenate[T, P]], *args: P.args, **kwargs: P.kwargs) -> R`
+    Passes the **unwrapped** data to `func` and returns the raw result (terminal).
+* `apply[**P, R](func: Callable[Concatenate[T, P]], *args: P.args, **kwargs: P.kwargs) -> "CurrentWrapper"[R]`
+    Passes the **unwrapped** data to`func` and **re-wraps** the result for continued chaining.
+* `pipe[**P, R](func: Callable[Concatenate[Self, P]], *args: P.args, **kwargs: P.kwargs) -> R`
+    Passes the **wrapped instance** (`self`) to `func` and returns the raw result (can be terminal).
+* `println()`
+    Prints the unwrapped data and returns `self`.
+
+### Rich Lazy Iteration (`Iter`)
+
+Leverage dozens of methods inspired by Rust's `Iterator`, `itertools`, `cytoolz`, and `more-itertools`.
+
+```python
+import pyochain as pc
+
+result = (
+    pc.Iter.from_count(1) # Infinite iterator: 1, 2, 3, ...
+    .filter(lambda x: x % 2 != 0) # Keep odd numbers: 1, 3, 5, ...
+    .map(lambda x: x * x) # Square them: 1, 9, 25, ...
+    .take(5) # Take the first 5: 1, 9, 25, 49, 81
+    .into(list) # Consume into a list
+)
+# result: [1, 9, 25, 49, 81]
+```
+
+### Typing enforcement
+
+Each method and class make extensive use of generics, type hints, and overloads (when necessary) to ensure type safety and improve developer experience.
+
+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.
+
+### Convenience mappers: itr and struct
+
+Operate on iterables of iterables or iterables of dicts without leaving the chain.
+
+```python
+import pyochain as pc
+
+nested = pc.Iter.from_([[1, 2, 3], [4, 5]])
+totals = nested.itr(lambda it: it.sum()).into(list)
+# [6, 9]
+
+records = pc.Iter.from_(
+    [
+        {"name": "Alice", "age": 30},
+        {"name": "Bob", "age": 25},
+    ]
+)
+names = records.struct(lambda d: d.pluck("name").unwrap()).into(list)
+# ['Alice', 'Bob']
+```
+
+## Key Dependencies and credits
+
+Most of the computations are done with implementations from the `cytoolz`, `more-itertools`, and `rolling` libraries.
+
+An extensive use of the `itertools` stdlib module is also to be noted.
+
+pyochain acts as a unifying API layer over these powerful tools.
+
+<https://github.com/pytoolz/cytoolz>
+
+<https://github.com/more-itertools/more-itertools>
+
+<https://github.com/ajcr/rolling>
+
+The stubs used for the developpement, made by the maintainer of pyochain, can be found here:
+
+<https://github.com/py-stubs/cytoolz-stubs>
+
+---
+
+## Real-life simple example
+
+In one of my project, I have to introspect some modules from plotly to get some lists of colors.
+
+I want to check wether the colors are in hex format or not, and I want to get a dictionary of palettes.
+We can see here that pyochain allow to keep the same style than polars, with method chaining, but for plain python objects.
+
+Due to the freedom of python, multiple paradigms are implemented across libraries.
+
+If you like the fluent, functional, chainable style, pyochain can help you to keep it across your codebase, rather than mixing object().method().method() and then another where it's [[... for ... in ...] ... ].
+
+```python
+
+from types import ModuleType
+
+import polars as pl
+import pyochain as pc
+from plotly.express.colors import cyclical, qualitative, sequential
+
+
+
+MODULES: set[ModuleType] = {
+    sequential,
+    cyclical,
+    qualitative,
+}
+
+def get_palettes() -> pc.Dict[str, list[str]]:
+    clr = "color"
+    scl = "scale"
+    df: pl.DataFrame = (
+        pc.Iter.from_(MODULES)
+        .map(
+            lambda mod: pc.Dict.from_object(mod)
+            .filter_values(lambda v: isinstance(v, list))
+            .unwrap()
+        )
+        .into(pl.LazyFrame)
+        .unpivot(value_name=clr, variable_name=scl)
+        .drop_nulls()
+        .filter(
+            pl.col(clr)
+            .list.eval(pl.element().first().str.starts_with("#").alias("is_hex"))
+            .list.first()
+        )
+        .sort(scl)
+        .collect()
+    )
+    keys: list[str] = df.get_column(scl).to_list()
+    values: list[list[str]] = df.get_column(clr).to_list()
+    return pc.Iter.from_(keys).with_values(values)
+
+
+# Ouput excerpt:
+{'mygbm_r': ['#ef55f1',
+            '#c543fa',
+            '#9139fa',
+            '#6324f5',
+            '#2e21ea',
+            '#284ec8',
+            '#3d719a',
+            '#439064',
+            '#31ac28',
+            '#61c10b',
+            '#96d310',
+            '#c6e516',
+            '#f0ed35',
+            '#fcd471',
+            '#fbafa1',
+            '#fb84ce',
+            '#ef55f1']}
+```
+
+However you can still easily go back with for loops when the readability is better this way.
+
+In another place, I use this function to generate a Literal from the keys of the palettes.
+
+```python
+
+from enum import StrEnum
+
+class Text(StrEnum):
+    CONTENT = "Palettes = Literal[\n"
+    END_CONTENT = "]\n"
+    ...# rest of the class
+
+def generate_palettes_literal() -> None:
+    literal_content: str = Text.CONTENT
+    for name in get_palettes().iter_keys().sort().unwrap():
+        literal_content += f'    "{name}",\n'
+    literal_content += Text.END_CONTENT
+    ...# rest of the function
+```
+
+Since I have to reference the literal_content variable in the for loop, This is more reasonnable to use a for loop here rather than a map + reduce approach.

pyochain-0.5.3.dist-info/RECORD

@@ -0,0 +1,32 @@
+pyochain/__init__.py,sha256=IbaRq48Skr5RhltOmUkmwNbffziiFy9JltsLMDYlSEg,126
+pyochain/_core/__init__.py,sha256=tBC30VIS-bRGGRbtT3NmFZ4kJ1Du84AGF9WJ17upJCY,505
+pyochain/_core/_format.py,sha256=7H9sAlLRoUpaOw8gzKso7YAGrtcUs9dTcRvlb2oO6xo,900
+pyochain/_core/_main.py,sha256=8LPnMRJnv8SDz2Q3rmngG1rx9c7fhkgAlqm5BzlUd34,5745
+pyochain/_core/_protocols.py,sha256=UgjOCINuz6cJpkkj7--6S0ULbUudv860HVNYEquBZvM,833
+pyochain/_dict/__init__.py,sha256=z3_hkXG_BrmS63WGjQocu7QXNuWZxeFF5wAnERmobsQ,44
+pyochain/_dict/_filters.py,sha256=a5ohEdwZlmCQwzrCO3KM00-EsSY1wPze-jfdGM1tQLs,8111
+pyochain/_dict/_groups.py,sha256=2QPQsfCV7GvUTEJfpW72EDKXGw5Yvw17Pcp9-X2iBo4,6076
+pyochain/_dict/_iter.py,sha256=y8S6zAFu6A9NK-13f-u0Q3-lt16jE3kuMOl8awn_nnI,3702
+pyochain/_dict/_joins.py,sha256=a6wzbr_xAmne0ohtL5tDpdccJ_89uUKgc3MnbZr39vk,4420
+pyochain/_dict/_main.py,sha256=HNpClIk7mlkTLIU79mfLoRTM8YxaE01IMrXd9q132LI,3066
+pyochain/_dict/_maps.py,sha256=pxwgPvgnRiQ1Kj8vTwQwG1OjVDTu0qKMeQPRFfFwHoM,3941
+pyochain/_dict/_nested.py,sha256=VE2MisvxaOReevNvtyfTMCA_HYXBGnFDl7Tad9i-R68,9286
+pyochain/_dict/_process.py,sha256=g5O_6Xwp_NPt1528KDPJTphyykmu6wYqztBx5dvMHn0,6381
+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=eA6WafYcOrQS-ZrUES2B-yX2HTqewSgvWMl6neqEDk8,7652
+pyochain/_iter/_eager.py,sha256=ARC995qZaEE1v9kiyZNEieM1qJKEXiOUdkIRJTpOkJs,6880
+pyochain/_iter/_filters.py,sha256=_ppvUG-DgEIhqmuyaOB0_g4tbtH_4bNk7vdVpjP8luY,15515
+pyochain/_iter/_joins.py,sha256=ivvnTvfiw67U9kVWMIoy78PJNBwN0oZ4Ko9AyfxyGYM,13043
+pyochain/_iter/_lists.py,sha256=TU-HjyyM_KqJTwA_0V0fCyJHl9L6wsRi1n4Sl8g2Gro,11103
+pyochain/_iter/_main.py,sha256=n9ljv7tL0U58QUpOkwFbesd-9Vd5dwJv-pV0JLmJle8,15047
+pyochain/_iter/_maps.py,sha256=OE9t14gtCyyTBaDXyxE1ZqgHcJRjWCmoUDH6EKnHJm8,11491
+pyochain/_iter/_partitions.py,sha256=MYxlzQRrCBtfjnhtIVdMUhkNq5FCTpFV1R9sJ9LznsM,5095
+pyochain/_iter/_process.py,sha256=P3Zw3uInZkOL-VlDUG4xfTnwek6lIa4j2a3IwxVaLD0,11039
+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.3.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+pyochain-0.5.3.dist-info/METADATA,sha256=-ahwMj7JiG8XTEAQUhzvayLpBus-nHu7baoHTGjjQ_M,9984
+pyochain-0.5.3.dist-info/RECORD,,

pyochain-0.5.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.24
+Root-Is-Purelib: true
+Tag: py3-none-any