python-iterutils 0.1.2__tar.gz → 0.1.3__tar.gz

{python_iterutils-0.1.2 → python_iterutils-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-iterutils
-Version: 0.1.2
+Version: 0.1.3
 Summary: Python another itertools.
 Home-page: https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-iterutils
 License: MIT
@@ -20,7 +20,8 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: python-asynctools (>=0.0.9)
+Requires-Dist: python-asynctools (>=0.0.10)
+Requires-Dist: python-undefined (>=0.0.3)
 Project-URL: Repository, https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-iterutils
 Description-Content-Type: text/markdown
 

{python_iterutils-0.1.2 → python_iterutils-0.1.3}/iterutils/__init__.py

@@ -2,28 +2,31 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 1, 2)
+__version__ = (0, 1, 3)
 __all__ = [
     "Return", "Yield", "YieldFrom", "iterable", "async_iterable", "foreach", "async_foreach", 
-    "through", "async_through", "flatten", "async_flatten", "iter_unique", "async_iter_unique", 
-    "chunked", "wrap_iter", "wrap_aiter", "acc_step", "cut_iter", "run_gen_step", 
-    "run_gen_step_iter", "bfs_gen", 
+    "through", "async_through", "flatten", "async_flatten", "map", "filter", "reduce", "chunked", 
+    "iter_unique", "async_iter_unique", "wrap_iter", "wrap_aiter", "acc_step", "cut_iter", 
+    "run_gen_step", "run_gen_step_iter", "bfs_gen", "with_iter_next", 
 ]
 
-
 from abc import ABC, abstractmethod
 from asyncio import to_thread
 from collections import deque
 from collections.abc import (
-    AsyncIterable, AsyncIterator, Buffer, Callable, Generator, 
+    AsyncIterable, AsyncIterator, Awaitable, Buffer, Callable, Generator, 
     Iterable, Iterator, MutableSet, Sequence, 
 )
+from contextlib import contextmanager
 from dataclasses import dataclass
 from itertools import batched, pairwise
-from inspect import isawaitable
-from typing import overload, Any, Literal
+from inspect import isawaitable, iscoroutinefunction
+from typing import overload, Any, ContextManager, Literal
 
-from asynctools import async_map, async_zip, async_batched, ensure_async, ensure_aiter
+from asynctools import (
+    async_filter, async_map, async_reduce, async_zip, async_batched, ensure_async, ensure_aiter, 
+)
+from undefined import undefined, Undefined
 
 
 @dataclass(slots=True, frozen=True)
@@ -107,6 +110,7 @@ def through(
         for _ in iterable:
             pass
     else:
+        from builtins import map
         for v in map(take_while, iterable):
             if not v:
                 break
@@ -137,20 +141,20 @@ def flatten(
     iterable: Iterable, 
     /, 
     exclude_types: type | tuple[type, ...] = (Buffer, str), 
-) -> Iterable:
+) -> Iterator:
     ...
 @overload
 def flatten(
     iterable: AsyncIterable, 
     /, 
     exclude_types: type | tuple[type, ...] = (Buffer, str), 
-) -> AsyncIterable:
+) -> AsyncIterator:
     ...
 def flatten(
     iterable: Iterable | AsyncIterable, 
     /, 
     exclude_types: type | tuple[type, ...] = (Buffer, str), 
-) -> Iterable | AsyncIterable:
+) -> Iterator | AsyncIterator:
     if not isinstance(iterable, Iterable):
         return async_flatten(iterable, exclude_types)
     def gen(iterable):
@@ -176,6 +180,78 @@ async def async_flatten(
             yield e
 
 
+def map(
+    function: Callable, 
+    iterable: Iterable | AsyncIterable, 
+    /, 
+    *iterables: Iterable | AsyncIterable, 
+):
+    if (
+        iscoroutinefunction(function) or 
+        isinstance(iterable, AsyncIterable) or 
+        any(isinstance(i, AsyncIterable) for i in iterables)
+    ):
+        return async_map(function, iterable, *iterables)
+    from builtins import map
+    return map(function, iterable, *iterables)
+
+
+def filter(
+    function: Callable, 
+    iterable: Iterable | AsyncIterable, 
+    /, 
+):
+    if iscoroutinefunction(function) or isinstance(iterable, AsyncIterable):
+        return async_filter(function, iterable)
+    from builtins import filter
+    return filter(function, iterable)
+
+
+def reduce(
+    function: Callable, 
+    iterable: Iterable | AsyncIterable, 
+    initial = undefined, 
+    /, 
+):
+    if iscoroutinefunction(function) or isinstance(iterable, AsyncIterable):
+        return async_reduce(function, iterable, initial)
+    from functools import reduce
+    if initial is undefined:
+        return reduce(function, iterable)
+    return reduce(function, iterable, initial)
+
+
+@overload
+def chunked[T](
+    iterable: Iterable[T], 
+    n: int = 1, 
+    /, 
+) -> Iterator[Sequence[T]]:
+    ...
+@overload
+def chunked[T](
+    iterable: AsyncIterable[T], 
+    n: int = 1, 
+    /, 
+) -> AsyncIterator[Sequence[T]]:
+    ...
+def chunked[T](
+    iterable: Iterable[T] | AsyncIterable[T], 
+    n: int = 1, 
+    /, 
+) -> Iterator[Sequence[T]] | AsyncIterator[Sequence[T]]:
+    if n < 0:
+        n = 1
+    if isinstance(iterable, Sequence):
+        if n == 1:
+            return ((e,) for e in iterable)
+        return (iterable[i:j] for i, j in pairwise(range(0, len(iterable)+n, n)))
+    elif isinstance(iterable, Iterable):
+        return batched(iterable, n)
+    else:
+        return async_batched(iterable, n)
+
+
 @overload
 def iter_unique[T](
     iterable: Iterable[T], 
@@ -223,37 +299,6 @@ async def async_iter_unique[T](
             add(e)
 
 
-@overload
-def chunked[T](
-    iterable: Iterable[T], 
-    n: int = 1, 
-    /, 
-) -> Iterator[Sequence[T]]:
-    ...
-@overload
-def chunked[T](
-    iterable: AsyncIterable[T], 
-    n: int = 1, 
-    /, 
-) -> AsyncIterator[Sequence[T]]:
-    ...
-def chunked[T](
-    iterable: Iterable[T] | AsyncIterable[T], 
-    n: int = 1, 
-    /, 
-) -> Iterator[Sequence[T]] | AsyncIterator[Sequence[T]]:
-    if n < 0:
-        n = 1
-    if isinstance(iterable, Sequence):
-        if n == 1:
-            return ((e,) for e in iterable)
-        return (iterable[i:j] for i, j in pairwise(range(0, len(iterable)+n, n)))
-    elif isinstance(iterable, Iterable):
-        return batched(iterable, n)
-    else:
-        return async_batched(iterable, n)
-
-
 @overload
 def wrap_iter[T](
     iterable: Iterable[T], 
@@ -656,3 +701,49 @@ def bfs_gen[T](
                 push(args)
                 args = yield val
 
+
+@overload
+def with_iter_next[T](
+    iterable: Iterable[T], 
+    /, 
+    async_: Literal[False] = False, 
+) -> ContextManager[Callable[[], T]]:
+    ...
+@overload
+def with_iter_next[T](
+    iterable: AsyncIterable[T], 
+    /, 
+    async_: Literal[False] = False, 
+) -> ContextManager[Callable[[], Awaitable[T]]]:
+    ...
+@overload
+def with_iter_next[T](
+    iterable: Iterable[T] | AsyncIterable[T], 
+    /, 
+    async_: Literal[True], 
+) -> ContextManager[Callable[[], Awaitable[T]]]:
+    ...
+@contextmanager
+def with_iter_next[T](
+    iterable: Iterable[T] | AsyncIterable[T], 
+    /, 
+    async_: Literal[False, True] = False, 
+):
+    if async_:
+        get_next: Callable[[], T] | Callable[[], Awaitable[T]] = ensure_aiter(iterable).__anext__
+    elif isinstance(iterable, Iterable):
+        get_next = iter(iterable).__next__
+    else:
+        get_next = aiter(iterable).__anext__
+        async_ = True
+    if async_:
+        try:
+            yield get_next
+        except StopAsyncIteration:
+            pass
+    else:
+        try:
+            yield get_next
+        except StopIteration:
+            pass
+

{python_iterutils-0.1.2 → python_iterutils-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-iterutils"
-version = "0.1.2"
+version = "0.1.3"
 description = "Python another itertools."
 authors = ["ChenyangGao <wosiwujm@gmail.com>"]
 license = "MIT"
@@ -27,7 +27,8 @@ include = [
 
 [tool.poetry.dependencies]
 python = "^3.12"
-python-asynctools = ">=0.0.9"
+python-asynctools = ">=0.0.10"
+python-undefined = ">=0.0.3"
 
 [build-system]
 requires = ["poetry-core"]