pyochain 0.5.1__py3-none-any.whl → 0.5.32__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.1.dist-info → pyochain-0.5.32.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.3
 Name: pyochain
-Version: 0.5.1
-Summary: Add your description here
+Version: 0.5.32
+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
@@ -16,6 +16,10 @@ Description-Content-Type: text/markdown
 
 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
@@ -33,7 +37,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.
@@ -41,7 +45,6 @@ The full API reference can be found at:
 ### 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.
 
@@ -57,7 +60,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.
 
@@ -77,8 +80,6 @@ But `Dict` can work also as well as on "irregular" structures (e.g., `dict[Any,
 
 * `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]`
 
@@ -122,41 +123,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.
-
-```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.

pyochain-0.5.32.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=I6kmcmeUsoxjMg9mOJbRd2aKg7sjfBUUEKaiGQc2-_c,7927
+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=IRBhvopIT8YkBdH5UEMxHz7FyADMfhkLiAB8qdleces,15136
+pyochain/_iter/_joins.py,sha256=ivvnTvfiw67U9kVWMIoy78PJNBwN0oZ4Ko9AyfxyGYM,13043
+pyochain/_iter/_lists.py,sha256=TU-HjyyM_KqJTwA_0V0fCyJHl9L6wsRi1n4Sl8g2Gro,11103
+pyochain/_iter/_main.py,sha256=ILGWDv6E0PWYDkeZEAwHE8chjow9xcosVH6M94Mjb5I,14986
+pyochain/_iter/_maps.py,sha256=5PR7OGX9VewX_CDRyllcg0wIKEu81yaQZU7sRU6OCs4,11914
+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.32.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+pyochain-0.5.32.dist-info/METADATA,sha256=VX2CxM_dLgjRivIc5_LwCJ5QBQmjDjNFjwG2CYjGVXg,9985
+pyochain-0.5.32.dist-info/RECORD,,

pyochain/_dict/_exprs.py

@@ -1,115 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Callable, Iterable
-from dataclasses import dataclass
-from typing import Any, Self, TypeGuard
-
-import cytoolz as cz
-
-from .._core import Pipeable
-
-
-@dataclass(slots=True)
-class Expr(Pipeable):
-    """
-    Represents an expression in the pipeline.
-
-    An Expr encapsulates a sequence of operations to be applied to keys on a python dict.
-
-    Each Expr instance maintains:
-    - A list of tokens representing the keys to access in the dict (the first being the input given to the `key` function),
-    - A tuple of operations to apply to the accessed data
-    - An alias for the expression (default to the last token).
-    """
-
-    __tokens__: list[str]
-    __ops__: tuple[Callable[[object], object], ...]
-    _alias: str
-
-    def __repr__(self) -> str:
-        parts: list[str] = []
-        s_parts: list[str] = []
-        for t in self.__tokens__:
-            parts.append(f"field({t!r})")
-            if s_parts:
-                s_parts.append(".")
-            s_parts.append(str(t))
-        symbolic = ".".join(parts) if parts else "<root>"
-        lowered = "".join(s_parts) or "<root>"
-        base = f"Expr({symbolic} -> {lowered})"
-        return f"{base}.alias({self._alias!r})"
-
-    def _to_expr(self, op: Callable[[Any], Any]) -> Self:
-        return self.__class__(
-            self.__tokens__,
-            self.__ops__ + (op,),
-            self._alias,
-        )
-
-    def key(self, name: str) -> Self:
-        """
-        Add a key to the expression.
-
-        Allow to access nested keys in a dict.
-
-        Args:
-            name: The key to access.
-        Example:
-        ```python
-        >>> import pyochain as pc
-        >>> expr = pc.key("a").key("b").key("c")
-        >>> expr.__tokens__
-        ['a', 'b', 'c']
-        >>> data = {"a": {"b": {"c": 42}}}
-        >>> pc.Dict(data).select(expr).unwrap()
-        {'c': 42}
-
-        ```
-        """
-        return self.__class__(
-            self.__tokens__ + [name],
-            self.__ops__,
-            name,
-        )
-
-    def alias(self, name: str) -> Self:
-        return self.__class__(self.__tokens__, self.__ops__, name)
-
-    @property
-    def name(self) -> str:
-        return self._alias
-
-    def apply(self, fn: Callable[[Any], Any]) -> Self:
-        """
-        Applies the given function fn to the data within the current Expr instance
-        """
-
-        def _apply(data: Any) -> Any:
-            return fn(data)
-
-        return self._to_expr(_apply)
-
-
-def key(name: str) -> Expr:
-    """Create an Expr that accesses the given key."""
-    return Expr([name], (), name)
-
-
-def _expr_identity(obj: Any) -> TypeGuard[Expr]:
-    return hasattr(obj, "__tokens__")
-
-
-type IntoExpr = Expr | str
-
-
-def compute_exprs(
-    exprs: Iterable[IntoExpr], data_in: dict[str, Any], data_out: dict[str, Any]
-) -> dict[str, Any]:
-    for e in exprs:
-        if not _expr_identity(e):
-            e = key(e)  # type: ignore
-        current: object = cz.dicttoolz.get_in(e.__tokens__, data_in)
-        for op in e.__ops__:
-            current = op(current)
-        data_out[e.name] = current
-    return data_out

pyochain/_dict/_funcs.py

@@ -1,62 +0,0 @@
-from typing import Any
-
-
-def dict_repr(
-    v: object,
-    depth: int = 0,
-    max_depth: int = 3,
-    max_items: int = 6,
-    max_str: int = 80,
-    indent: int = 2,
-) -> str:
-    pad = " " * (depth * indent)
-    if depth > max_depth:
-        return "…"
-    match v:
-        case dict():
-            items: list[tuple[str, Any]] = list(v.items())  # type: ignore
-            shown: list[tuple[str, Any]] = items[:max_items]
-            if (
-                all(
-                    not isinstance(val, dict) and not isinstance(val, list)
-                    for _, val in shown
-                )
-                and len(shown) <= 2
-            ):
-                body = ", ".join(
-                    f"{k!r}: {dict_repr(val, depth + 1)}" for k, val in shown
-                )
-                if len(items) > max_items:
-                    body += ", …"
-                return "{" + body + "}"
-            lines: list[str] = []
-            for k, val in shown:
-                lines.append(
-                    f"{pad}{' ' * indent}{k!r}: {dict_repr(val, depth + 1, max_depth, max_items, max_str, indent)}"
-                )
-            if len(items) > max_items:
-                lines.append(f"{pad}{' ' * indent}…")
-            return "{\n" + ",\n".join(lines) + f"\n{pad}" + "}"
-
-        case list():
-            elems: list[Any] = v[:max_items]  # type: ignore
-            if (
-                all(isinstance(x, (int, float, str, bool, type(None))) for x in elems)
-                and len(elems) <= 4
-            ):
-                body = ", ".join(dict_repr(x, depth + 1) for x in elems)
-                if len(v) > max_items:  # type: ignore
-                    body += ", …"
-                return "[" + body + "]"
-            lines = [
-                f"{pad}{' ' * indent}{dict_repr(x, depth + 1, max_depth, max_items, max_str, indent)}"
-                for x in elems
-            ]
-            if len(v) > max_items:  # type: ignore
-                lines.append(f"{pad}{' ' * indent}…")
-            return "[\n" + ",\n".join(lines) + f"\n{pad}" + "]"
-
-        case str():
-            return repr(v if len(v) <= max_str else v[:max_str] + "…")
-        case _:
-            return repr(v)

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())