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

pyochain/_iter/_partitions.py

@@ -31,7 +31,6 @@ class BasePartitions[T](IterWrapper[T]):
 
         Args:
             length: The length of each window.
-
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_([1, 2, 3, 4]).windows(2).into(list)
@@ -47,7 +46,7 @@ class BasePartitions[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(partial(cz.itertoolz.sliding_window, length))
+        return self._lazy(partial(cz.itertoolz.sliding_window, length))
 
     @overload
     def partition(self, n: Literal[1], pad: None = None) -> Iter[tuple[T]]: ...
@@ -70,7 +69,6 @@ class BasePartitions[T](IterWrapper[T]):
         Args:
             n: Length of each partition.
             pad: Value to pad the last partition if needed.
-
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_([1, 2, 3, 4]).partition(2).into(list)
@@ -85,7 +83,7 @@ class BasePartitions[T](IterWrapper[T]):
         ```
         """
 
-        return self.apply(partial(cz.itertoolz.partition, n, pad=pad))
+        return self._lazy(partial(cz.itertoolz.partition, n, pad=pad))
 
     def partition_all(self, n: int) -> Iter[tuple[T, ...]]:
         """
@@ -93,7 +91,6 @@ class BasePartitions[T](IterWrapper[T]):
 
         Args:
             n: Maximum length of each partition.
-
         The final tuple may be shorter to accommodate extra elements.
         ```python
         >>> import pyochain as pc
@@ -104,17 +101,17 @@ class BasePartitions[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(partial(cz.itertoolz.partition_all, n))
+        return self._lazy(partial(cz.itertoolz.partition_all, n))
 
     def partition_by(self, predicate: Callable[[T], bool]) -> Iter[tuple[T, ...]]:
         """
         Partition the `iterable` into a sequence of `tuples` according to a predicate function.
 
-        Args:
-            predicate: Function to determine partition boundaries.
-
         Every time the output of `predicate` changes, a new `tuple` is started,
         and subsequent items are collected into that `tuple`.
+
+        Args:
+            predicate: Function to determine partition boundaries.
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_("I have space").partition_by(lambda c: c == " ").into(list)
@@ -126,18 +123,18 @@ class BasePartitions[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(partial(cz.recipes.partitionby, predicate))
+        return self._lazy(partial(cz.recipes.partitionby, predicate))
 
     def batch(self, n: int) -> Iter[tuple[T, ...]]:
         """
         Batch elements into tuples of length n and return a new Iter.
 
-        Args:
-            n: Number of elements in each batch.
-
         - The last batch may be shorter than n.
         - The data is consumed lazily, just enough to fill a batch.
         - The result is yielded as soon as a batch is full or when the input iterable is exhausted.
+
+        Args:
+            n: Number of elements in each batch.
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_("ABCDEFG").batch(3).into(list)
@@ -145,4 +142,4 @@ class BasePartitions[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(itertools.batched, n)
+        return self._lazy(itertools.batched, n)

pyochain/_iter/_process.py

@@ -46,7 +46,7 @@ class BaseProcess[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(itertools.cycle)
+        return self._lazy(itertools.cycle)
 
     def interpose(self, element: T) -> Iter[T]:
         """
@@ -54,7 +54,6 @@ class BaseProcess[T](IterWrapper[T]):
 
         Args:
             element: The element to interpose between items.
-
         Example:
         ```python
         >>> import pyochain as pc
@@ -63,7 +62,7 @@ class BaseProcess[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(partial(cz.itertoolz.interpose, element))
+        return self._lazy(partial(cz.itertoolz.interpose, element))
 
     def random_sample(
         self, probability: float, state: Random | int | None = None
@@ -71,15 +70,15 @@ class BaseProcess[T](IterWrapper[T]):
         """
         Return elements from a sequence with probability of prob.
 
-        Args:
-            probability: The probability of including each element.
-            state: Random state or seed for deterministic sampling.
-
         Returns a lazy iterator of random items from seq.
 
         random_sample considers each item independently and without replacement.
 
         See below how the first time it returned 13 items and the next time it returned 6 items.
+
+        Args:
+            probability: The probability of including each element.
+            state: Random state or seed for deterministic sampling.
         ```python
         >>> import pyochain as pc
         >>> data = pc.Seq(list(range(100)))
@@ -108,7 +107,7 @@ class BaseProcess[T](IterWrapper[T]):
         ```
         """
 
-        return self.apply(
+        return self._lazy(
             partial(cz.itertoolz.random_sample, probability, random_state=state)
         )
 
@@ -118,7 +117,6 @@ class BaseProcess[T](IterWrapper[T]):
 
         Args:
             func: A binary function to apply cumulatively.
-
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_([1, 2, 3]).accumulate(lambda a, b: a + b).into(list)
@@ -126,7 +124,7 @@ class BaseProcess[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(partial(cz.itertoolz.accumulate, func))
+        return self._lazy(partial(cz.itertoolz.accumulate, func))
 
     def insert_left(self, value: T) -> Iter[T]:
         """
@@ -134,7 +132,6 @@ class BaseProcess[T](IterWrapper[T]):
 
         Args:
             value: The value to prepend.
-
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_([2, 3]).insert_left(1).into(list)
@@ -142,7 +139,7 @@ class BaseProcess[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(partial(cz.itertoolz.cons, value))
+        return self._lazy(partial(cz.itertoolz.cons, value))
 
     def peekn(self, n: int) -> Iter[T]:
         """
@@ -150,7 +147,6 @@ class BaseProcess[T](IterWrapper[T]):
 
         Args:
             n: Number of items to peek.
-
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_([1, 2, 3]).peekn(2).into(list)
@@ -165,7 +161,7 @@ class BaseProcess[T](IterWrapper[T]):
             print(f"Peeked {n} values: {peeked.value}")
             return peeked.sequence
 
-        return self.apply(_peekn)
+        return self._lazy(_peekn)
 
     def peek(self) -> Iter[T]:
         """
@@ -184,7 +180,7 @@ class BaseProcess[T](IterWrapper[T]):
             print(f"Peeked value: {peeked.value}")
             return peeked.sequence
 
-        return self.apply(_peek)
+        return self._lazy(_peek)
 
     def merge_sorted(
         self, *others: Iterable[T], sort_on: Callable[[T], Any] | None = None
@@ -195,7 +191,6 @@ class BaseProcess[T](IterWrapper[T]):
         Args:
             others: Other sorted iterables to merge.
             sort_on: Optional key function for sorting.
-
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_([1, 3]).merge_sorted([2, 4]).into(list)
@@ -203,7 +198,7 @@ class BaseProcess[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(cz.itertoolz.merge_sorted, *others, key=sort_on)
+        return self._lazy(cz.itertoolz.merge_sorted, *others, key=sort_on)
 
     def interleave(self, *others: Iterable[T]) -> Iter[T]:
         """
@@ -211,7 +206,6 @@ class BaseProcess[T](IterWrapper[T]):
 
         Args:
             others: Other iterables to interleave.
-
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_([1, 2]).interleave([3, 4]).into(list)
@@ -223,18 +217,18 @@ class BaseProcess[T](IterWrapper[T]):
         def _interleave(data: Iterable[T]) -> Iterator[T]:
             return cz.itertoolz.interleave((data, *others))
 
-        return self.apply(_interleave)
+        return self._lazy(_interleave)
 
     def chain(self, *others: Iterable[T]) -> Iter[T]:
         """
         Concatenate zero or more iterables, any of which may be infinite.
 
-        Args:
-            others: Other iterables to concatenate.
-
         An infinite sequence will prevent the rest of the arguments from being included.
 
         We use chain.from_iterable rather than chain(*seqs) so that seqs can be a generator.
+
+        Args:
+            others: Other iterables to concatenate.
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_([1, 2]).chain([3, 4], [5]).into(list)
@@ -244,9 +238,9 @@ class BaseProcess[T](IterWrapper[T]):
         """
 
         def _chain(data: Iterable[T]) -> Iterator[T]:
-            return itertools.chain.from_iterable((data, *others))
+            return cz.itertoolz.concat((data, *others))
 
-        return self.apply(_chain)
+        return self._lazy(_chain)
 
     def elements(self) -> Iter[T]:
         """
@@ -275,7 +269,7 @@ class BaseProcess[T](IterWrapper[T]):
         def _elements(data: Iterable[T]) -> Iterator[T]:
             return Counter(data).elements()
 
-        return self.apply(_elements)
+        return self._lazy(_elements)
 
     def reverse(self) -> Iter[T]:
         """
@@ -296,7 +290,7 @@ class BaseProcess[T](IterWrapper[T]):
         def _reverse(data: Iterable[T]) -> Iterator[T]:
             return reversed(list(data))
 
-        return self.apply(_reverse)
+        return self._lazy(_reverse)
 
     def is_strictly_n(
         self,
@@ -307,14 +301,14 @@ class BaseProcess[T](IterWrapper[T]):
         """
         Validate that *iterable* has exactly *n* items and return them if it does.
 
+        If it has fewer than *n* items, call function *too_short* with the actual number of items.
+
+        If it has more than *n* items, call function *too_long* with the number `n + 1`.
+
         Args:
             n: The exact number of items expected.
             too_short: Function to call if there are too few items.
             too_long: Function to call if there are too many items.
-
-        If it has fewer than *n* items, call function *too_short* with the actual number of items.
-
-        If it has more than *n* items, call function *too_long* with the number `n + 1`.
         ```python
         >>> import pyochain as pc
         >>> iterable = ["a", "b", "c", "d"]
@@ -381,4 +375,4 @@ class BaseProcess[T](IterWrapper[T]):
                 too_long(n + 1)
                 return
 
-        return self.apply(strictly_n_)
+        return self._lazy(strictly_n_)

pyochain/_iter/_rolling.py

@@ -18,7 +18,6 @@ class BaseRolling[T](IterWrapper[T]):
 
         Args:
             window_size: Size of the rolling window.
-
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_([1, 2, 3, 4, 5]).rolling_mean(3).into(list)
@@ -26,7 +25,7 @@ class BaseRolling[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(rolling.Mean, window_size)
+        return self._lazy(rolling.Mean, window_size)
 
     def rolling_median(self, window_size: int) -> Iter[T]:
         """
@@ -34,7 +33,6 @@ class BaseRolling[T](IterWrapper[T]):
 
         Args:
             window_size: Size of the rolling window.
-
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_([1, 3, 2, 5, 4]).rolling_median(3).into(list)
@@ -42,16 +40,16 @@ class BaseRolling[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(rolling.Median, window_size)
+        return self._lazy(rolling.Median, window_size)
 
     def rolling_sum(self, window_size: int) -> Iter[T]:
         """
         Compute the rolling sum.
 
+        Will return integers if the input is integers, floats if the input is floats or mixed.
+
         Args:
             window_size: Size of the rolling window.
-
-        Will return integers if the input is integers, floats if the input is floats or mixed.
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_([1.0, 2, 3, 4, 5]).rolling_sum(3).into(list)
@@ -59,7 +57,7 @@ class BaseRolling[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(rolling.Sum, window_size)
+        return self._lazy(rolling.Sum, window_size)
 
     def rolling_min(self, window_size: int) -> Iter[T]:
         """
@@ -74,7 +72,7 @@ class BaseRolling[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(rolling.Min, window_size)
+        return self._lazy(rolling.Min, window_size)
 
     def rolling_max(self, window_size: int) -> Iter[T]:
         """
@@ -89,7 +87,7 @@ class BaseRolling[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(rolling.Max, window_size)
+        return self._lazy(rolling.Max, window_size)
 
     def rolling_var(self, window_size: int) -> Iter[float]:
         """
@@ -104,7 +102,7 @@ class BaseRolling[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(rolling.Var, window_size)
+        return self._lazy(rolling.Var, window_size)
 
     def rolling_std(self, window_size: int) -> Iter[float]:
         """
@@ -119,16 +117,14 @@ class BaseRolling[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(rolling.Std, window_size)
+        return self._lazy(rolling.Std, window_size)
 
     def rolling_kurtosis(self, window_size: int) -> Iter[float]:
         """
         Compute the rolling kurtosis.
 
         Args:
-            window_size: Size of the rolling window.
-
-        The windows must have at least 4 observations.
+            window_size: Size of the rolling window. Must be at least 4.
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_([1, 2, 4, 1, 4]).rolling_kurtosis(4).into(list)
@@ -136,16 +132,14 @@ class BaseRolling[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(rolling.Kurtosis, window_size)
+        return self._lazy(rolling.Kurtosis, window_size)
 
     def rolling_skew(self, window_size: int) -> Iter[float]:
         """
         Compute the rolling skewness.
 
         Args:
-            window_size: Size of the rolling window.
-
-        The windows must have at least 3 observations.
+            window_size: Size of the rolling window. Must be at least 3.
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_([1, 2, 4, 1, 4]).rolling_skew(3).round(2).into(list)
@@ -153,7 +147,7 @@ class BaseRolling[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(rolling.Skew, window_size)
+        return self._lazy(rolling.Skew, window_size)
 
     def rolling_all(self, window_size: int) -> Iter[bool]:
         """
@@ -168,7 +162,7 @@ class BaseRolling[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(rolling.All, window_size)
+        return self._lazy(rolling.All, window_size)
 
     def rolling_any(self, window_size: int) -> Iter[bool]:
         """
@@ -183,7 +177,7 @@ class BaseRolling[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(rolling.Any, window_size)
+        return self._lazy(rolling.Any, window_size)
 
     def rolling_product(self, window_size: int) -> Iter[float]:
         """
@@ -198,7 +192,7 @@ class BaseRolling[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(rolling.Product, window_size)
+        return self._lazy(rolling.Product, window_size)
 
     def rolling_apply[R](
         self, func: Callable[[Iterable[T]], R], window_size: int
@@ -206,11 +200,11 @@ class BaseRolling[T](IterWrapper[T]):
         """
         Apply a custom function to each rolling window.
 
+        The function should accept an iterable and return a single value.
+
         Args:
             func: Function to apply to each rolling window.
             window_size: Size of the rolling window.
-
-        The function should accept an iterable and return a single value.
         ```python
         >>> import pyochain as pc
         >>> def range_func(window):
@@ -220,7 +214,7 @@ class BaseRolling[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(rolling.Apply, window_size, "fixed", func)
+        return self._lazy(rolling.Apply, window_size, "fixed", func)
 
     def rolling_apply_pairwise[R](
         self, other: Iterable[T], func: Callable[[T, T], R], window_size: int
@@ -228,12 +222,12 @@ class BaseRolling[T](IterWrapper[T]):
         """
         Apply a custom pairwise function to each rolling window of size 2.
 
+        The function should accept two arguments and return a single value.
+
         Args:
             other: Second iterable to apply the pairwise function.
             func: Function to apply to each pair of elements.
             window_size: Size of the rolling window.
-
-        The function should accept two arguments and return a single value.
         ```python
         >>> import pyochain as pc
         >>> from statistics import correlation as corr
@@ -244,4 +238,4 @@ class BaseRolling[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(rolling.ApplyPairwise, other, window_size, func)
+        return self._lazy(rolling.ApplyPairwise, other, window_size, func)