python-iterutils 0.0.9__tar.gz → 0.1.1__tar.gz

{python_iterutils-0.0.9 → python_iterutils-0.1.1}/PKG-INFO

@@ -1,28 +1,26 @@
 Metadata-Version: 2.1
 Name: python-iterutils
-Version: 0.0.9
+Version: 0.1.1
 Summary: Python another itertools.
 Home-page: https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-iterutils
 License: MIT
 Keywords: iterable,iterutils
 Author: ChenyangGao
 Author-email: wosiwujm@gmail.com
-Requires-Python: >=3.10,<4.0
+Requires-Python: >=3.12,<4.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 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.8.2)
+Requires-Dist: python-asynctools (>=0.0.9)
 Project-URL: Repository, https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-iterutils
 Description-Content-Type: text/markdown
 

{python_iterutils-0.0.9 → python_iterutils-0.1.1}/iterutils/__init__.py

@@ -2,26 +2,27 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 0, 9)
+__version__ = (0, 1, 1)
 __all__ = [
-    "iterable", "async_iterable", "foreach", "async_foreach", "through", "async_through", 
-    "wrap_iter", "wrap_aiter", "acc_step", "cut_iter", "run_gen_step", "run_gen_step_iter", 
-    "Return", "Yield", "YieldFrom", 
+    "Return", "Yield", "YieldFrom", "iterable", "async_iterable", "foreach", "async_foreach", 
+    "through", "async_through", "flatten", "async_flatten", "chunked", "wrap_iter", "wrap_aiter", 
+    "acc_step", "cut_iter", "run_gen_step", "run_gen_step_iter", "bfs_gen", 
 ]
 
+
 from abc import ABC, abstractmethod
 from asyncio import to_thread
+from collections import deque
 from collections.abc import (
-    AsyncIterable, AsyncIterator, Callable, Generator, Iterable, Iterator, 
+    AsyncIterable, AsyncIterator, Buffer, Callable, Generator, 
+    Iterable, Iterator, Sequence, 
 )
 from dataclasses import dataclass
+from itertools import batched, pairwise
 from inspect import isawaitable
-from typing import overload, Any, Literal, TypeVar
-
-from asynctools import async_map, async_zip, ensure_async, ensure_aiter
-
+from typing import overload, Any, Literal
 
-T = TypeVar("T")
+from asynctools import async_map, async_zip, async_batched, ensure_async, ensure_aiter
 
 
 @dataclass(slots=True, frozen=True)
@@ -48,21 +49,28 @@ class YieldFrom(YieldBase):
     yield_type = 2
 
 
-def iterable(it, /) -> bool:
+def iterable(iterable, /) -> bool:
     try:
-        return isinstance(iter(it), Iterable)
+        return isinstance(iter(iterable), Iterable)
     except TypeError:
         return False
 
 
-def async_iterable(it, /) -> bool:
+def async_iterable(iterable, /) -> bool:
     try:
-        return isinstance(iter(it), AsyncIterable)
+        return isinstance(iter(iterable), AsyncIterable)
     except TypeError:
         return False
 
 
-def foreach(value: Callable, iterable, /, *iterables):
+def foreach(
+    value: Callable, 
+    iterable: Iterable | AsyncIterable, 
+    /, 
+    *iterables: Iterable | AsyncIterable, 
+):
+    if not (isinstance(iterable, Iterable) and all(isinstance(it, Iterable) for it in iterables)):
+        return async_foreach(value, iterable, *iterables)
     if iterables:
         for args in zip(iterable, *iterables):
             value(*args)
@@ -71,7 +79,13 @@ def foreach(value: Callable, iterable, /, *iterables):
             value(arg)
 
 
-async def async_foreach(value: Callable, iterable, /, *iterables, threaded: bool = True):
+async def async_foreach(
+    value: Callable, 
+    iterable: Iterable | AsyncIterable, 
+    /, 
+    *iterables: Iterable | AsyncIterable, 
+    threaded: bool = True, 
+):
     value = ensure_async(value, threaded=threaded)
     if iterables:
         async for args in async_zip(iterable, *iterables, threaded=threaded):
@@ -81,76 +95,188 @@ async def async_foreach(value: Callable, iterable, /, *iterables, threaded: bool
             await value(arg)
 
 
-def through(it: Iterable, /, take_while: None | Callable = None):
+def through(
+    iterable: Iterable | AsyncIterable, 
+    /, 
+    take_while: None | Callable = None, 
+):
+    if not isinstance(iterable, Iterable):
+        return async_through(iterable, take_while)
     if take_while is None:
-        for _ in it:
+        for _ in iterable:
             pass
     else:
-        for v in map(take_while, it):
+        for v in map(take_while, iterable):
             if not v:
                 break
 
 
 async def async_through(
-    it: Iterable | AsyncIterable, 
+    iterable: Iterable | AsyncIterable, 
     /, 
     take_while: None | Callable = None, 
     threaded: bool = True, 
 ):
-    it = ensure_aiter(it, threaded=threaded)
+    iterable = ensure_aiter(iterable, threaded=threaded)
     if take_while is None:
-        async for _ in it:
+        async for _ in iterable:
             pass
     elif take_while is bool:
-        async for v in it:
+        async for v in iterable:
             if not v:
                 break
     else:
-        async for v in async_map(take_while, it):
+        async for v in async_map(take_while, iterable):
             if not v:
                 break
 
 
-def wrap_iter(
-    it: Iterable[T], 
+@overload
+def flatten(
+    iterable: Iterable, 
+    /, 
+    exclude_types: type | tuple[type, ...] = (Buffer, str), 
+) -> Iterable:
+    ...
+@overload
+def flatten(
+    iterable: AsyncIterable, 
+    /, 
+    exclude_types: type | tuple[type, ...] = (Buffer, str), 
+) -> AsyncIterable:
+    ...
+def flatten(
+    iterable: Iterable | AsyncIterable, 
+    /, 
+    exclude_types: type | tuple[type, ...] = (Buffer, str), 
+) -> Iterable | AsyncIterable:
+    if not isinstance(iterable, Iterable):
+        return async_flatten(iterable, exclude_types)
+    def gen(iterable):
+        for e in iterable:
+            if isinstance(e, (Iterable, AsyncIterable)) and not isinstance(e, exclude_types):
+                yield from gen(e)
+            else:
+                yield e
+    return gen(iterable)
+
+
+async def async_flatten(
+    iterable: Iterable | AsyncIterable, 
+    /, 
+    exclude_types: type | tuple[type, ...] = (Buffer, str), 
+    threaded: bool = True, 
+) -> AsyncIterator:
+    async for e in ensure_aiter(iterable, threaded=threaded):
+        if isinstance(e, (Iterable, AsyncIterable)) and not isinstance(e, exclude_types):
+            async for e in async_flatten(e, exclude_types, threaded=threaded):
+                yield e
+        else:
+            yield 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], 
     /, 
     callprev: None | Callable[[T], Any] = None, 
     callnext: None | Callable[[T], Any] = None, 
     callenter: None | Callable[[Iterable[T]], Any] = None, 
     callexit: None | Callable[[Iterable[T], None | BaseException], Any] = None, 
 ) -> Iterator[T]:
+    ...
+@overload
+def wrap_iter[T](
+    iterable: AsyncIterable[T], 
+    /, 
+    callprev: None | Callable[[T], Any] = None, 
+    callnext: None | Callable[[T], Any] = None, 
+    callenter: None | Callable[[Iterable[T] | AsyncIterable[T]], Any] = None, 
+    callexit: None | Callable[[Iterable[T] | AsyncIterable[T], None | BaseException], Any] = None, 
+) -> AsyncIterator[T]:
+    ...
+def wrap_iter[T](
+    iterable: Iterable[T] | AsyncIterable[T], 
+    /, 
+    callprev: None | Callable[[T], Any] = None, 
+    callnext: None | Callable[[T], Any] = None, 
+    callenter: None | Callable[[Iterable[T]], Any] | Callable[[Iterable[T] | AsyncIterable[T]], Any] = None, 
+    callexit: ( None | Callable[[Iterable[T], None | BaseException], Any] | 
+                Callable[[Iterable[T] | AsyncIterable[T], None | BaseException], Any] ) = None, 
+) -> Iterator[T] | AsyncIterator[T]:
+    if not isinstance(iterable, Iterable):
+        return wrap_aiter(
+            iterable, 
+            callprev=callprev, 
+            callnext=callnext, 
+            callenter=callenter, # type: ignore
+            callexit=callexit, # type: ignore
+        )
     if not callable(callprev):
         callprev = None
     if not callable(callnext):
         callnext = None
-    try:
-        if callable(callenter):
-            callenter(it)
-        for e in it:
-            if callprev:
-                try:
-                    callprev(e)
-                except (StopIteration, GeneratorExit):
-                    break
-            yield e
-            if callnext:
-                try:
-                    callnext(e)
-                except (StopIteration, GeneratorExit):
-                    break
-    except BaseException as e:
-        if callable(callexit):
-            if not callexit(it, e):
+    def gen():
+        try:
+            if callable(callenter):
+                callenter(iterable)
+            for e in iterable:
+                if callprev:
+                    try:
+                        callprev(e)
+                    except (StopIteration, GeneratorExit):
+                        break
+                yield e
+                if callnext:
+                    try:
+                        callnext(e)
+                    except (StopIteration, GeneratorExit):
+                        break
+        except BaseException as e:
+            if callable(callexit):
+                if not callexit(iterable, e):
+                    raise
+            else:
                 raise
-        else:
-            raise
-    finally:
-        if callable(callexit):
-            callexit(it, None)
+        finally:
+            if callable(callexit):
+                callexit(iterable, None)
+    return gen()
 
 
-async def wrap_aiter(
-    it: Iterable[T] | AsyncIterable[T], 
+async def wrap_aiter[T](
+    iterable: Iterable[T] | AsyncIterable[T], 
     /, 
     callprev: None | Callable[[T], Any] = None, 
     callnext: None | Callable[[T], Any] = None, 
@@ -161,7 +287,7 @@ async def wrap_aiter(
     callprev = ensure_async(callprev, threaded=threaded) if callable(callprev) else None
     callnext = ensure_async(callnext, threaded=threaded) if callable(callnext) else None
     try:
-        async for e in ensure_aiter(it, threaded=threaded):
+        async for e in ensure_aiter(iterable, threaded=threaded):
             if callprev:
                 try:
                     await callprev(e)
@@ -175,13 +301,13 @@ async def wrap_aiter(
                     break
     except BaseException as e:
         if callable(callexit):
-            if not await ensure_async(callexit, threaded=threaded)(it, e):
+            if not await ensure_async(callexit, threaded=threaded)(iterable, e):
                 raise
         else:
             raise
     finally:
         if callable(callexit):
-            await ensure_async(callexit, threaded=threaded)(it, None)
+            await ensure_async(callexit, threaded=threaded)(iterable, None)
 
 
 def acc_step(
@@ -210,7 +336,7 @@ def cut_iter(
         yield stop, stop - start
 
 
-def run_gen_step(
+def run_gen_step[T](
     gen_step: Generator[Any, Any, T] | Callable[[], Generator[Any, Any, T]], 
     *, 
     async_: bool = False, 
@@ -272,16 +398,16 @@ def run_gen_step(
         result = process()
         if as_iter:
             async def wrap(result):
-                it = await result
+                iterable = await result
                 try:
-                    it = aiter(it)
+                    iterable = aiter(iterable)
                 except TypeError:
-                    for val in iter(it):
+                    for val in iter(iterable):
                         if isawaitable(val):
                             val = await val
                         yield val
                 else:
-                    async for val in it:
+                    async for val in iterable:
                         yield val
             result = wrap(result)
         return result
@@ -440,3 +566,45 @@ def run_gen_step_iter(
                     close()
     return process()
 
+
+@overload
+def bfs_gen[T](
+    initial: T, 
+    /, 
+    unpack_iterator: Literal[False] = False, 
+) -> Generator[T, T | None, None]:
+    ...
+@overload
+def bfs_gen[T](
+    initial: T | Iterator[T], 
+    /, 
+    unpack_iterator: Literal[True], 
+) -> Generator[T, T | None, None]:
+    ...
+def bfs_gen[T](
+    initial: T | Iterator[T], 
+    /, 
+    unpack_iterator: bool = False, 
+) -> Generator[T, T | None, None]:
+    """辅助函数，返回生成器，用来简化广度优先遍历
+    """
+    dq: deque[T] = deque()
+    push, pushmany, pop = dq.append, dq.extend, dq.popleft
+    if isinstance(initial, Iterator) and unpack_iterator:
+        pushmany(initial)
+    else:
+        push(initial) # type: ignore
+    while dq:
+        args: None | T = yield (val := pop())
+        if unpack_iterator:
+            while args is not None:
+                if isinstance(args, Iterator):
+                    pushmany(args)
+                else:
+                    push(args)
+                args = yield val
+        else:
+            while args is not None:
+                push(args)
+                args = yield val
+

{python_iterutils-0.0.9 → python_iterutils-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-iterutils"
-version = "0.0.9"
+version = "0.1.1"
 description = "Python another itertools."
 authors = ["ChenyangGao <wosiwujm@gmail.com>"]
 license = "MIT"
@@ -13,7 +13,7 @@ classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3 :: Only",
     "Operating System :: OS Independent",
     "Intended Audience :: Developers",
@@ -26,8 +26,8 @@ include = [
 ]
 
 [tool.poetry.dependencies]
-python = "^3.10"
-python-asynctools = ">=0.0.8.2"
+python = "^3.12"
+python-asynctools = ">=0.0.9"
 
 [build-system]
 requires = ["poetry-core"]