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

pyochain/_dict/_filters.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections.abc import Callable, Mapping
 from functools import partial
-from typing import TYPE_CHECKING, Any, TypeGuard
+from typing import TYPE_CHECKING, Any, TypeIs, overload
 
 import cytoolz as cz
 
@@ -13,7 +13,13 @@ if TYPE_CHECKING:
 
 
 class FilterDict[K, V](MappingWrapper[K, V]):
-    def filter_keys(self, predicate: Callable[[K], bool]) -> Dict[K, V]:
+    @overload
+    def filter_keys[U](self, predicate: Callable[[K], TypeIs[U]]) -> Dict[U, V]: ...
+    @overload
+    def filter_keys(self, predicate: Callable[[K], bool]) -> Dict[K, V]: ...
+    def filter_keys[U](
+        self, predicate: Callable[[K], bool | TypeIs[U]]
+    ) -> Dict[K, V] | Dict[U, V]:
         """
         Return keys that satisfy predicate.
 
@@ -30,7 +36,13 @@ class FilterDict[K, V](MappingWrapper[K, V]):
         """
         return self._new(partial(cz.dicttoolz.keyfilter, predicate))
 
-    def filter_values(self, predicate: Callable[[V], bool]) -> Dict[K, V]:
+    @overload
+    def filter_values[U](self, predicate: Callable[[V], TypeIs[U]]) -> Dict[K, U]: ...
+    @overload
+    def filter_values(self, predicate: Callable[[V], bool]) -> Dict[K, V]: ...
+    def filter_values[U](
+        self, predicate: Callable[[V], bool] | Callable[[V], TypeIs[U]]
+    ) -> Dict[K, V] | Dict[K, U]:
         """
         Return items whose values satisfy predicate.
 
@@ -122,19 +134,19 @@ class FilterDict[K, V](MappingWrapper[K, V]):
         """
 
         def _filter_attr(data: dict[K, V]) -> dict[K, U]:
-            def has_attr(x: V) -> TypeGuard[U]:
+            def has_attr(x: object) -> TypeIs[U]:
                 return hasattr(x, attr)
 
             return cz.dicttoolz.valfilter(has_attr, data)
 
         return self._new(_filter_attr)
 
-    def filter_type[R](self, typ: type[R]) -> Dict[K, R]:
+    def filter_type[R](self, dtype: type[R]) -> Dict[K, R]:
         """
         Filter values by type.
 
         Args:
-            typ: Type to filter values by.
+            dtype: Type to filter values by.
         Example:
         ```python
         >>> import pyochain as pc
@@ -146,35 +158,13 @@ class FilterDict[K, V](MappingWrapper[K, V]):
         """
 
         def _filter_type(data: dict[K, V]) -> dict[K, R]:
-            def _(x: V) -> TypeGuard[R]:
-                return isinstance(x, typ)
+            def _(x: object) -> TypeIs[R]:
+                return isinstance(x, dtype)
 
             return cz.dicttoolz.valfilter(_, data)
 
         return self._new(_filter_type)
 
-    def filter_callable(self) -> Dict[K, Callable[..., Any]]:
-        """
-        Filter values that are callable.
-        ```python
-        >>> import pyochain as pc
-        >>> def foo():
-        ...     pass
-        >>> data = {1: "one", 2: "two", 3: foo, 4: print}
-        >>> pc.Dict(data).filter_callable().map_values(lambda x: x.__name__).unwrap()
-        {3: 'foo', 4: 'print'}
-
-        ```
-        """
-
-        def _filter_callable(data: dict[K, V]) -> dict[K, Callable[..., Any]]:
-            def _(x: V) -> TypeGuard[Callable[..., Any]]:
-                return callable(x)
-
-            return cz.dicttoolz.valfilter(_, data)
-
-        return self._new(_filter_callable)
-
     def filter_subclass[U: type[Any], R](
         self: FilterDict[K, U], parent: type[R], keep_parent: bool = True
     ) -> Dict[K, type[R]]:
@@ -205,7 +195,7 @@ class FilterDict[K, V](MappingWrapper[K, V]):
         """
 
         def _filter_subclass(data: dict[K, U]) -> dict[K, type[R]]:
-            def _(x: type[Any]) -> TypeGuard[type[R]]:
+            def _(x: type[Any]) -> TypeIs[type[R]]:
                 if keep_parent:
                     return issubclass(x, parent)
                 else:

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.
 
@@ -131,7 +135,7 @@ 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))
@@ -450,12 +454,12 @@ class BaseFilter[T](IterWrapper[T]):
 
         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
@@ -466,30 +470,10 @@ 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 (x for x in data if isinstance(x, dtype))
 
         return self._lazy(_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 self._lazy(_filter_callable)
-
     def filter_map[R](self, func: Callable[[T], R]) -> Iter[R]:
         """
         Apply func to every element of iterable, yielding only those which are not None.

pyochain/_iter/_main.py

@@ -33,6 +33,10 @@ class CommonMethods[T](BaseAgg[T], BaseEager[T], BaseDict[T]):
     pass
 
 
+def _convert_data[T](data: Iterable[T] | T, *more_data: T) -> Iterable[T]:
+    return data if cz.itertoolz.isiterable(data) else (data, *more_data)
+
+
 class Iter[T](
     BaseBool[T],
     BaseFilter[T],
@@ -150,13 +154,7 @@ class Iter[T](
         ```
         """
 
-        def _convert_data() -> Sequence[Any]:
-            if cz.itertoolz.isiterable(data):
-                return data
-            else:
-                return (data, *more_data)
-
-        return Iter(iter(_convert_data()))
+        return Iter(iter(_convert_data(data, *more_data)))
 
     @staticmethod
     def unfold[S, V](seed: S, generator: Callable[[S], tuple[V, S] | None]) -> Iter[V]:
@@ -411,10 +409,7 @@ class Seq[T](CommonMethods[T]):
         ```
 
         """
-        if cz.itertoolz.isiterable(data):
-            return Seq(data)
-        else:
-            return Seq((data, *more_data))
+        return Seq(_convert_data(data, *more_data))  # type: ignore[return-value]
 
     def iter(self) -> Iter[T]:
         """

{pyochain-0.5.31.dist-info → pyochain-0.5.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyochain
-Version: 0.5.31
+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

{pyochain-0.5.31.dist-info → pyochain-0.5.32.dist-info}/RECORD

@@ -4,7 +4,7 @@ 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/_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
@@ -17,16 +17,16 @@ pyochain/_iter/_aggregations.py,sha256=VkAYF9w4GwVBDYx1H5pL2dkMIWfodj3QsZsOc4Ach
 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/_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=n9ljv7tL0U58QUpOkwFbesd-9Vd5dwJv-pV0JLmJle8,15047
+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.31.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-pyochain-0.5.31.dist-info/METADATA,sha256=nLD9GiLrdJM5PEjBFHx0qVI2B4Sgt5m-c3gDqtI-I-I,9985
-pyochain-0.5.31.dist-info/RECORD,,
+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,,