pyochain 0.5.0__py3-none-any.whl

pyochain/_iter/_tuples.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+import itertools
+from collections.abc import Callable
+from functools import partial
+from typing import TYPE_CHECKING, 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.apply(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.apply(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.apply(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.apply(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.apply(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.apply(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.apply(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)
+        ```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)]
+
+        ```
+
+        This function is analogous to unique_everseen and is subject to the same performance considerations.
+        """
+        return self.apply(mit.classify_unique)

pyochain-0.5.0.dist-info/METADATA

@@ -0,0 +1,295 @@
+Metadata-Version: 2.3
+Name: pyochain
+Version: 0.5.0
+Summary: Add your description here
+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.
+
+## Installation
+
+```bash
+uv add git+https://github.com/OutSquareCapital/pyochain.git
+```
+
+## 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 collections 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.
+* **Polars API:** The powerful expression API for `pyochain.Dict` (`select`, `with_fields`, `key`) mimics the expressive power of Polars for selecting, transforming, and reshaping nested dictionary data.
+* **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 `Collection` (`list`, `tuple`, `set`...), 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.
+* `schema` to infer the structure of the data by recursively analyzing keys and value types.
+* `pyochain.key` expressions to compute/retrieve/select/create new fields from existing nested data in a declarative way.
+
+#### `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.
+
+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.
+
+```python
+import pyochain as pc
+
+# Build a compact view
+data = pc.Dict(
+    {
+        "user": {"name": "Alice", "age": 30},
+        "scores": {"math": 18, "eng": 15},
+    }
+)
+
+view = data.select(
+    pc.key("user").key("name"),
+    pc.key("scores").key("math"),
+    pc.key("scores").key("eng"),
+    pc.key("user").key("age").apply(lambda x: x >= 18).alias("is_adult"),
+)
+# {"name": "Alice", "math": 18, "eng": 15, "is_adult": True}
+merged = data.with_fields(
+    pc.key("scores").key("math").apply(lambda x: x * 10).alias("math_x10")
+)
+# {
+#   'user': {'name': 'Alice', 'age': 30},
+#   'scores': {'math': 18, 'eng': 15},
+#   'math_x10': 180
+# }
+
+```
+
+### 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.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+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,,

pyochain-0.5.0.dist-info/WHEEL

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