Rename map_tuple to batched_map, more consistent with python stdlib

Author: simw

README.md

@@ -23,7 +23,7 @@ result = (
     StreamStart(range(10))
     .filter(lambda x: x % 2 == 0)
     .map(lambda x: x ^ 2)
-    .map_tuple(lambda x: x, 2)
+    .batched_map(lambda x: x, 2)
     .to_list()
 )
 print(result)
@@ -40,7 +40,7 @@ chain = (
     ChainStart()
     .filter(lambda x: x % 2 == 0)
     .map(lambda x: x ^ 2)
-    .map_tuple(lambda x: sum(x), 2)
+    .batched_map(lambda x: sum(x), 2)
 )
 print(Stream(range(10), chain).to_list())
 #> [2, 10, 10]

src/pipedata/core/chain.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from itertools import islice
+import functools
+import itertools
 from typing import (
     Any,
     Callable,
@@ -21,6 +22,12 @@
 TOther = TypeVar("TOther")
 
 
+def _batched(iterable: Iterator[TEnd], n: Optional[int]) -> Iterator[Tuple[TEnd, ...]]:
+    """Can be replaced by itertools.batched once using Python 3.12+."""
+    while (elements := tuple(itertools.islice(iterable, n))) != ():
+        yield elements
+
+
 def _identity(input_iterator: Iterator[TEnd]) -> Iterator[TEnd]:
     yield from input_iterator
 
@@ -122,10 +129,10 @@ def filter(self, func: Callable[[TEnd], bool]) -> Chain[TStart, TEnd]:  # noqa:
         Remove elements from the stream that do not pass the filter function.
         """
 
+        @functools.wraps(func)
         def new_action(previous_step: Iterator[TEnd]) -> Iterator[TEnd]:
             return filter(func, previous_step)
 
-        new_action.__name__ = func.__name__
         return self.flat_map(new_action)
 
     def map(  # noqa: A003
@@ -135,13 +142,13 @@ def map(  # noqa: A003
         Return a single transformed element from each input element.
         """
 
+        @functools.wraps(func)
         def new_action(previous_step: Iterator[TEnd]) -> Iterator[TOther]:
             return map(func, previous_step)
 
-        new_action.__name__ = func.__name__
         return self.flat_map(new_action)
 
-    def map_tuple(
+    def batched_map(
         self, func: Callable[[Tuple[TEnd, ...]], TOther], n: Optional[int] = None
     ) -> Chain[TStart, TOther]:
         """
@@ -151,11 +158,11 @@ def map_tuple(
         an iterator of 1 element.
         """
 
+        @functools.wraps(func)
         def new_action(previous_step: Iterator[TEnd]) -> Iterator[TOther]:
-            while elements := tuple(islice(previous_step, n)):
+            for elements in _batched(previous_step, n):
                 yield func(elements)
 
-        new_action.__name__ = func.__name__
         return self.flat_map(new_action)
 
     def get_counts(self) -> List[Dict[str, Any]]:

src/pipedata/core/stream.py

@@ -45,10 +45,10 @@ def filter(self, func: Callable[[TEnd], bool]) -> Stream[TEnd]:  # noqa: A003
     def map(self, func: Callable[[TEnd], TNewEnd]) -> Stream[TNewEnd]:  # noqa: A003
         return Stream(self._items, self._chain.map(func))
 
-    def map_tuple(
+    def batched_map(
         self, func: Callable[[Tuple[TEnd, ...]], TNewEnd], n: Optional[int] = None
     ) -> Stream[TNewEnd]:
-        return Stream(self._items, self._chain.map_tuple(func, n))
+        return Stream(self._items, self._chain.batched_map(func, n))
 
     @overload
     def reduce(self, func: Callable[[TEnd, TEnd], TEnd]) -> TEnd:

tests/core/test_chain.py

@@ -151,11 +151,11 @@ def test_chain_map_changing_types() -> None:
     assert result == ["0", "1", "2", "3"]
 
 
-def test_chain_map_tuple() -> None:
+def test_chain_batched_map() -> None:
     def add_values(values: Tuple[int, ...]) -> int:
         return sum(values)
 
-    chain = ChainStart[int]().map_tuple(add_values, 2)
+    chain = ChainStart[int]().batched_map(add_values, 2)
     result = list(chain(iter([0, 1, 2, 3, 4])))
     assert result == [1, 5, 4]
     assert chain.get_counts() == [

tests/core/test_stream.py

@@ -148,9 +148,9 @@ def append_values(a: List[int], b: int) -> List[int]:
     assert result == [0, 1, 2, 3]
 
 
-def test_stream_map_tuple() -> None:
+def test_stream_batched_map() -> None:
     def add_values(values: Iterable[int]) -> int:
         return sum(values)
 
-    result = StreamStart([0, 1, 2, 3, 4]).map_tuple(add_values, 2).to_list()
+    result = StreamStart([0, 1, 2, 3, 4]).batched_map(add_values, 2).to_list()
     assert result == [1, 5, 4]