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

pyochain/_iter/_filters.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import itertools
 from collections.abc import Callable, Generator, Iterable, Iterator
 from functools import partial
-from typing import TYPE_CHECKING, Any, TypeGuard
+from typing import TYPE_CHECKING, Any, TypeIs, overload
 
 import cytoolz as cz
 import more_itertools as mit
@@ -15,7 +15,11 @@ if TYPE_CHECKING:
 
 
 class BaseFilter[T](IterWrapper[T]):
-    def filter(self, func: Callable[[T], bool]) -> Iter[T]:
+    @overload
+    def filter[U](self, func: Callable[[T], TypeIs[U]]) -> Iter[U]: ...
+    @overload
+    def filter(self, func: Callable[[T], bool]) -> Iter[T]: ...
+    def filter[U](self, func: Callable[[T], bool | TypeIs[U]]) -> Iter[T] | Iter[U]:
         """
         Return an iterator yielding those items of iterable for which function is true.
 
@@ -33,7 +37,7 @@ class BaseFilter[T](IterWrapper[T]):
         def _filter(data: Iterable[T]) -> Iterator[T]:
             return (x for x in data if func(x))
 
-        return self.apply(_filter)
+        return self._lazy(_filter)
 
     def filter_isin(self, values: Iterable[T]) -> Iter[T]:
         """
@@ -54,7 +58,7 @@ class BaseFilter[T](IterWrapper[T]):
             value_set: set[T] = set(values)
             return (x for x in data if x in value_set)
 
-        return self.apply(_filter_isin)
+        return self._lazy(_filter_isin)
 
     def filter_notin(self, values: Iterable[T]) -> Iter[T]:
         """
@@ -75,7 +79,7 @@ class BaseFilter[T](IterWrapper[T]):
             value_set: set[T] = set(values)
             return (x for x in data if x not in value_set)
 
-        return self.apply(_filter_notin)
+        return self._lazy(_filter_notin)
 
     def filter_contain(
         self: IterWrapper[str], text: str, format: Callable[[str], str] | None = None
@@ -84,6 +88,7 @@ class BaseFilter[T](IterWrapper[T]):
         Return elements that contain the given text.
 
         Optionally, a format function can be provided to preprocess each element before checking for the substring.
+
         Args:
             text: Substring to check for.
             format: Optional function to preprocess each element before checking. Defaults to None.
@@ -107,7 +112,7 @@ class BaseFilter[T](IterWrapper[T]):
 
             return (x for x in data if _(x))
 
-        return self.apply(_filter_contain)
+        return self._lazy(_filter_contain)
 
     def filter_attr[U](self, attr: str, dtype: type[U] = object) -> Iter[U]:
         """
@@ -130,12 +135,12 @@ class BaseFilter[T](IterWrapper[T]):
         """
 
         def check(data: Iterable[Any]) -> Generator[U, None, None]:
-            def _(x: Any) -> TypeGuard[U]:
+            def _(x: Any) -> TypeIs[U]:
                 return hasattr(x, attr)
 
             return (x for x in data if _(x))
 
-        return self.apply(check)
+        return self._lazy(check)
 
     def filter_false(self, func: Callable[[T], bool]) -> Iter[T]:
         """
@@ -151,7 +156,7 @@ class BaseFilter[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(partial(itertools.filterfalse, func))
+        return self._lazy(partial(itertools.filterfalse, func))
 
     def filter_except(
         self, func: Callable[[T], object], *exceptions: type[BaseException]
@@ -181,7 +186,7 @@ class BaseFilter[T](IterWrapper[T]):
         def _filter_except(data: Iterable[T]) -> Iterator[T]:
             return mit.filter_except(func, data, *exceptions)
 
-        return self.apply(_filter_except)
+        return self._lazy(_filter_except)
 
     def take_while(self, predicate: Callable[[T], bool]) -> Iter[T]:
         """
@@ -197,7 +202,7 @@ class BaseFilter[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(partial(itertools.takewhile, predicate))
+        return self._lazy(partial(itertools.takewhile, predicate))
 
     def skip_while(self, predicate: Callable[[T], bool]) -> Iter[T]:
         """
@@ -213,7 +218,7 @@ class BaseFilter[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(partial(itertools.dropwhile, predicate))
+        return self._lazy(partial(itertools.dropwhile, predicate))
 
     def compress(self, *selectors: bool) -> Iter[T]:
         """
@@ -229,7 +234,7 @@ class BaseFilter[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(itertools.compress, selectors)
+        return self._lazy(itertools.compress, selectors)
 
     def unique(self, key: Callable[[T], Any] | None = None) -> Iter[T]:
         """
@@ -253,7 +258,7 @@ class BaseFilter[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(cz.itertoolz.unique, key=key)
+        return self._lazy(cz.itertoolz.unique, key=key)
 
     def take(self, n: int) -> Iter[T]:
         """
@@ -280,7 +285,7 @@ class BaseFilter[T](IterWrapper[T]):
         ```
         """
 
-        return self.apply(partial(cz.itertoolz.take, n))
+        return self._lazy(partial(cz.itertoolz.take, n))
 
     def skip(self, n: int) -> Iter[T]:
         """
@@ -296,7 +301,7 @@ class BaseFilter[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(partial(cz.itertoolz.drop, n))
+        return self._lazy(partial(cz.itertoolz.drop, n))
 
     def unique_justseen(self, key: Callable[[T], Any] | None = None) -> Iter[T]:
         """
@@ -314,7 +319,7 @@ class BaseFilter[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(mit.unique_justseen, key=key)
+        return self._lazy(mit.unique_justseen, key=key)
 
     def unique_in_window(
         self, n: int, key: Callable[[T], Any] | None = None
@@ -323,6 +328,7 @@ class BaseFilter[T](IterWrapper[T]):
         Yield the items from iterable that haven't been seen recently.
 
         The items in iterable must be hashable.
+
         Args:
             n: Size of the lookback window.
             key: Function to transform items before comparison. Defaults to None.
@@ -342,7 +348,7 @@ class BaseFilter[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(mit.unique_in_window, n, key=key)
+        return self._lazy(mit.unique_in_window, n, key=key)
 
     def extract(self, indices: Iterable[int]) -> Iter[T]:
         """
@@ -364,7 +370,7 @@ class BaseFilter[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(mit.extract, indices)
+        return self._lazy(mit.extract, indices)
 
     def every(self, index: int) -> Iter[T]:
         """
@@ -380,28 +386,33 @@ class BaseFilter[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(partial(cz.itertoolz.take_nth, index))
+        return self._lazy(partial(cz.itertoolz.take_nth, index))
 
-    def slice(self, start: int | None = None, stop: int | None = None) -> Iter[T]:
+    def slice(
+        self, start: int | None = None, stop: int | None = None, step: int | None = None
+    ) -> Iter[T]:
         """
         Return a slice of the iterable.
 
         Args:
             start: Starting index of the slice. Defaults to None.
             stop: Ending index of the slice. Defaults to None.
+            step: Step size for the slice. Defaults to None.
         Example:
         ```python
         >>> import pyochain as pc
         >>> pc.Iter.from_([1, 2, 3, 4, 5]).slice(1, 4).into(list)
         [2, 3, 4]
+        >>> pc.Iter.from_([1, 2, 3, 4, 5]).slice(step=2).into(list)
+        [1, 3, 5]
 
         ```
         """
 
         def _slice(data: Iterable[T]) -> Iterator[T]:
-            return itertools.islice(data, start, stop)
+            return itertools.islice(data, start, stop, step)
 
-        return self.apply(_slice)
+        return self._lazy(_slice)
 
     def filter_subclass[U: type[Any], R](
         self: IterWrapper[U], parent: type[R], keep_parent: bool = True
@@ -441,14 +452,14 @@ class BaseFilter[T](IterWrapper[T]):
             else:
                 return (x for x in data if issubclass(x, parent) and x is not parent)
 
-        return self.apply(_filter_subclass)
+        return self._lazy(_filter_subclass)
 
-    def filter_type[R](self, typ: type[R]) -> Iter[R]:
+    def filter_type[R](self, dtype: type[R]) -> Iter[R]:
         """
         Return elements that are instances of the given type.
 
         Args:
-            typ: Type to check against.
+            dtype: Type to check against.
         Example:
         ```python
         >>> import pyochain as pc
@@ -459,29 +470,9 @@ class BaseFilter[T](IterWrapper[T]):
         """
 
         def _filter_type(data: Iterable[T]) -> Generator[R, None, None]:
-            return (x for x in data if isinstance(x, typ))
-
-        return self.apply(_filter_type)
-
-    def filter_callable(self) -> Iter[Callable[..., Any]]:
-        """
-        Return only elements that are callable.
-
-        Example:
-        ```python
-        >>> import pyochain as pc
-        >>> pc.Iter.from_([len, 42, str, None, list]).filter_callable().into(list)
-        [<built-in function len>, <class 'str'>, <class 'list'>]
-
-        ```
-        """
-
-        def _filter_callable(
-            data: Iterable[T],
-        ) -> Generator[Callable[..., Any], None, None]:
-            return (x for x in data if callable(x))
+            return (x for x in data if isinstance(x, dtype))
 
-        return self.apply(_filter_callable)
+        return self._lazy(_filter_type)
 
     def filter_map[R](self, func: Callable[[T], R]) -> Iter[R]:
         """
@@ -500,4 +491,4 @@ class BaseFilter[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(partial(mit.filter_map, func))
+        return self._lazy(partial(mit.filter_map, func))

pyochain/_iter/_joins.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import itertools
 from collections.abc import Callable, Generator, Iterable, Iterator
-from typing import TYPE_CHECKING, Any, overload
+from typing import TYPE_CHECKING, Any, TypeIs, overload
 
 import cytoolz as cz
 import more_itertools as mit
@@ -67,7 +67,7 @@ class BaseJoins[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(zip, *others, strict=strict)
+        return self._lazy(zip, *others, strict=strict)
 
     def zip_offset[U](
         self,
@@ -113,7 +113,7 @@ class BaseJoins[T](IterWrapper[T]):
                 fillvalue=fillvalue,
             )
 
-        return self.apply(_zip_offset)
+        return self._lazy(_zip_offset)
 
     @overload
     def zip_broadcast[T1](
@@ -162,6 +162,7 @@ class BaseJoins[T](IterWrapper[T]):
         `str` and `bytes` are not treated as iterables.
 
         If the strict keyword argument is True, then UnequalIterablesError will be raised if any of the iterables have different lengths.
+
         Args:
             *others: Other iterables or scalars to zip with.
             strict: Whether to enforce equal lengths of iterables. Defaults to False.
@@ -182,15 +183,10 @@ class BaseJoins[T](IterWrapper[T]):
         ) -> Generator[tuple[Iterable[Any], ...] | tuple[object, ...], Any, None]:
             """from more_itertools.zip_broadcast"""
 
-            def is_scalar(obj: Any) -> bool:
+            def is_scalar(obj: Any) -> TypeIs[object]:
                 if isinstance(obj, (str, bytes)):
                     return True
-                try:
-                    iter(obj)
-                except TypeError:
-                    return True
-                else:
-                    return False
+                return cz.itertoolz.isiterable(obj) is False
 
             size = len(objects)
             if not size:
@@ -216,7 +212,7 @@ class BaseJoins[T](IterWrapper[T]):
                     pass
                 yield tuple(new_item)
 
-        return self.apply(_zip_broadcast, *others)
+        return self._lazy(_zip_broadcast, *others)
 
     @overload
     def zip_equal(self) -> Iter[tuple[T]]: ...
@@ -265,7 +261,7 @@ class BaseJoins[T](IterWrapper[T]):
         def _zip_equal(data: Iterable[T]) -> Iterator[tuple[Any, ...]]:
             return mit.zip_equal(data, *others)
 
-        return self.apply(_zip_equal)
+        return self._lazy(_zip_equal)
 
     def zip_longest[U](
         self, *others: Iterable[T], fill_value: U = None
@@ -284,7 +280,7 @@ class BaseJoins[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(itertools.zip_longest, *others, fillvalue=fill_value)
+        return self._lazy(itertools.zip_longest, *others, fillvalue=fill_value)
 
     @overload
     def product(self) -> Iter[tuple[T]]: ...
@@ -328,7 +324,7 @@ class BaseJoins[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(itertools.product, *others)
+        return self._lazy(itertools.product, *others)
 
     def diff_at(
         self,
@@ -341,6 +337,7 @@ class BaseJoins[T](IterWrapper[T]):
         Each output item is a tuple where the i-th element is from the i-th input iterable.
 
         If an input iterable is exhausted before others, then the corresponding output items will be filled with *default*.
+
         Args:
             *others: Other iterables to compare with.
             default: Value to use for missing elements. Defaults to None.
@@ -364,7 +361,7 @@ class BaseJoins[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(cz.itertoolz.diff, *others, default=default, key=key)
+        return self._lazy(cz.itertoolz.diff, *others, default=default, key=key)
 
     def join[R, K](
         self,
@@ -404,4 +401,4 @@ class BaseJoins[T](IterWrapper[T]):
                 right_default=right_default,
             )
 
-        return self.apply(_join)
+        return self._lazy(_join)

pyochain/_iter/_lists.py

@@ -29,7 +29,7 @@ class BaseList[T](IterWrapper[T]):
         def _implode(data: Iterable[T]) -> Generator[list[T], None, None]:
             return ([x] for x in data)
 
-        return self.apply(_implode)
+        return self._lazy(_implode)
 
     def split_at(
         self,
@@ -73,7 +73,7 @@ class BaseList[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(mit.split_at, pred, maxsplit, keep_separator)
+        return self._lazy(mit.split_at, pred, maxsplit, keep_separator)
 
     def split_after(
         self, predicate: Callable[[T], bool], max_split: int = -1
@@ -100,7 +100,7 @@ class BaseList[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(mit.split_after, predicate, max_split)
+        return self._lazy(mit.split_after, predicate, max_split)
 
     def split_before(
         self, predicate: Callable[[T], bool], max_split: int = -1
@@ -133,7 +133,7 @@ class BaseList[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(mit.split_before, predicate, max_split)
+        return self._lazy(mit.split_before, predicate, max_split)
 
     def split_into(self, sizes: Iterable[int | None]) -> Iter[list[T]]:
         """
@@ -179,7 +179,7 @@ class BaseList[T](IterWrapper[T]):
         - multiple columns represent elements of the same feature (e.g. a point represented by x,y,z)
         - the format is not the same for all columns.
         """
-        return self.apply(mit.split_into, sizes)
+        return self._lazy(mit.split_into, sizes)
 
     def split_when(
         self, predicate: Callable[[T, T], bool], max_split: int = -1
@@ -209,7 +209,7 @@ class BaseList[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(mit.split_when, predicate, max_split)
+        return self._lazy(mit.split_when, predicate, max_split)
 
     def chunks(self, n: int, strict: bool = False) -> Iter[list[T]]:
         """
@@ -225,6 +225,7 @@ class BaseList[T](IterWrapper[T]):
         - *strict* is `True`
 
         then `ValueError` will be raised before the last list is yielded.
+
         Args:
             n: Number of elements in each chunk.
             strict: Whether to raise an error if the last chunk is smaller than n. Defaults to False.
@@ -238,13 +239,14 @@ class BaseList[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(mit.chunked, n, strict)
+        return self._lazy(mit.chunked, n, strict)
 
     def chunks_even(self, n: int) -> Iter[list[T]]:
         """
         Break iterable into lists of approximately length n.
 
         Items are distributed such the lengths of the lists differ by at most 1 item.
+
         Args:
             n: Approximate number of elements in each chunk.
         Example:
@@ -258,7 +260,7 @@ class BaseList[T](IterWrapper[T]):
 
         ```
         """
-        return self.apply(mit.chunked_even, n)
+        return self._lazy(mit.chunked_even, n)
 
     def unique_to_each[U: Iterable[Any]](self: IterWrapper[U]) -> Iter[list[U]]:
         """
@@ -303,4 +305,4 @@ class BaseList[T](IterWrapper[T]):
             uniques: set[U] = {element for element in counts if counts[element] == 1}
             return ((list(filter(uniques.__contains__, it))) for it in pool)
 
-        return self.apply(_unique_to_each)
+        return self._lazy(_unique_to_each)