python-iterutils 0.0.8__py3-none-any.whl → 0.1.0__py3-none-any.whl

iterutils/__init__.py

@@ -2,26 +2,26 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 0, 8)
+__version__ = (0, 1, 0)
 __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", 
-    "Yield", "YieldFrom", 
+    "flatten", "async_flatten", "chunked", "wrap_iter", "wrap_aiter", "acc_step", 
+    "cut_iter", "run_gen_step", "run_gen_step_iter", "Return", "Yield", "YieldFrom", 
 ]
 
+
 from abc import ABC, abstractmethod
 from asyncio import to_thread
 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)
@@ -36,6 +36,10 @@ class YieldBase(ABC):
         ...
 
 
+class Return(YieldBase):
+    yield_type = 0
+
+
 class Yield(YieldBase):
     yield_type = 1
 
@@ -44,105 +48,234 @@ 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(ret: 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):
-            ret(*args)
+            value(*args)
     else:
         for arg in iterable:
-            ret(arg)
+            value(arg)
 
 
-async def async_foreach(ret: Callable, iterable, /, *iterables, threaded: bool = True):
-    ret = ensure_async(ret, threaded=threaded)
+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):
-            await ret(*args)
+            await value(*args)
     else:
         async for arg in ensure_aiter(iterable, threaded=threaded):
-            await ret(arg)
+            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 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, 
@@ -153,7 +286,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)
@@ -167,13 +300,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(
@@ -202,7 +335,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, 
@@ -221,27 +354,40 @@ def run_gen_step(
         async def process():
             try:
                 if threaded:
-                    ret = await to_thread(send, None)
+                    value = await to_thread(send, None)
                 else:
-                    ret = send(None)
+                    value = send(None)
                 while True:
+                    if isinstance(value, YieldBase):
+                        raise StopIteration(value)
                     try:
-                        if callable(ret):
-                            ret = ret()
-                        if isawaitable(ret):
-                            ret = await ret
+                        if callable(value):
+                            value = value()
+                        if isawaitable(value):
+                            value = await value
                     except BaseException as e:
                         if threaded:
-                            ret = await to_thread(throw, e)
+                            value = await to_thread(throw, e)
                         else:
-                            ret = throw(e)
+                            value = throw(e)
                     else:
                         if threaded:
-                            ret = await to_thread(send, ret)
+                            value = await to_thread(send, value)
                         else:
-                            ret = send(ret)
+                            value = send(value)
             except StopIteration as e:
-                return e.value
+                value = e.value
+                identity = False
+                try_call_me = True
+                if isinstance(value, YieldBase):
+                    identity = value.identity
+                    try_call_me = value.try_call_me
+                    value = value.value
+                if callable(value) and try_call_me:
+                    value = value()
+                if not identity and isawaitable(value):
+                    value = await value
+                return value
             finally:
                 if close is not None:
                     if threaded:
@@ -251,35 +397,43 @@ 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
     else:
         try:
-            ret = send(None)
+            value = send(None)
             while True:
+                if isinstance(value, YieldBase):
+                    raise StopIteration(value)
                 try:
-                    if callable(ret):
-                        ret = ret()
+                    if callable(value):
+                        value = value()
                 except BaseException as e:
-                    ret = throw(e)
+                    value = throw(e)
                 else:
-                    ret = send(ret)
+                    value = send(value)
         except StopIteration as e:
-            result = e.value
+            value = e.value
+            try_call_me = True
+            if isinstance(value, YieldBase):
+                try_call_me = value.try_call_me
+                value = value.value
+            if callable(value) and try_call_me:
+                value = value()
             if as_iter:
-                result = iter(result)
-            return result
+                value = iter(value)
+            return value
         finally:
             if close is not None:
                 close()
@@ -317,55 +471,52 @@ def run_gen_step_iter(
     throw = gen.throw
     if async_:
         async def process():
-            async def extract(ret):
-                yield_type = 0
+            async def extract(value):
                 identity = False
                 try_call_me = True
-                if isinstance(ret, YieldBase):
-                    identity = ret.identity
-                    try_call_me = ret.try_call_me
-                    yield_type = ret.yield_type
-                    ret = ret.value
-                if not identity:
-                    if try_call_me and callable(ret):
-                        ret = ret()
-                    if isawaitable(ret):
-                        ret = await ret
-                return yield_type, ret
+                yield_type = -1
+                if isinstance(value, YieldBase):
+                    identity = value.identity
+                    try_call_me = value.try_call_me
+                    yield_type = value.yield_type
+                    value = value.value
+                if try_call_me and callable(value):
+                    value = value()
+                if not identity and isawaitable(value):
+                    value = await value
+                return yield_type, value
             try:
                 if threaded:
-                    ret = await to_thread(send, None)
+                    value = await to_thread(send, None)
                 else:
-                    ret = send(None)
+                    value = send(None)
                 while True:
                     try:
-                        yield_type, ret = await extract(ret)
+                        yield_type, value = await extract(value)
                         match yield_type:
                             case 1:
-                                yield ret
+                                yield value
                             case 2:
-                                async for val in ensure_aiter(ret, threaded=threaded):
+                                async for val in ensure_aiter(value, threaded=threaded):
                                     yield val
                     except BaseException as e:
                         if threaded:
-                            ret = await to_thread(throw, e)
+                            value = await to_thread(throw, e)
                         else:
-                            ret = throw(e)
+                            value = throw(e)
                     else:
                         if threaded:
-                            ret = await to_thread(send, ret)
+                            value = await to_thread(send, value)
                         else:
-                            ret = send(ret)
+                            value = send(value)
             except StopIteration as e:
-                ret = e.value
-                if isinstance(ret, YieldBase):
-                    yield_type, ret = await extract(ret)
-                    match yield_type:
-                        case 1:
-                            yield ret
-                        case 2:
-                            async for val in ensure_aiter(ret, threaded=threaded):
-                                yield val
+                yield_type, value = await extract(e.value)
+                match yield_type:
+                    case 1:
+                        yield value
+                    case 2:
+                        async for val in ensure_aiter(value, threaded=threaded):
+                            yield val
             finally:
                 if close is not None:
                     if threaded:
@@ -374,41 +525,41 @@ def run_gen_step_iter(
                         close()
     else:
         def process():
-            def extract(ret):
-                yield_type = 0
-                identity = False
+            def extract(value, /):
                 try_call_me = True
-                if isinstance(ret, YieldBase):
-                    identity = ret.identity
-                    try_call_me = ret.try_call_me
-                    yield_type = ret.yield_type
-                    ret = ret.value
-                if not identity and try_call_me and callable(ret):
-                    ret = ret()
-                return yield_type, ret
+                yield_type = -1
+                if isinstance(value, YieldBase):
+                    try_call_me = value.try_call_me
+                    yield_type  = value.yield_type
+                    value       = value.value
+                if try_call_me and callable(value):
+                    value = value()
+                return yield_type, value
             try:
-                ret = send(None)
+                value = send(None)
                 while True:
                     try:
-                        yield_type, ret = extract(ret)
+                        yield_type, value = extract(value)
                         match yield_type:
+                            case 0:
+                                return value
                             case 1:
-                                yield ret
+                                yield value
                             case 2:
-                                yield from ret
+                                yield from value
                     except BaseException as e:
-                        ret = throw(e)
+                        value = throw(e)
                     else:
-                        ret = send(ret)
+                        value = send(value)
             except StopIteration as e:
-                ret = e.value
-                if isinstance(ret, YieldBase):
-                    yield_type, ret = extract(ret)
-                    match yield_type:
-                        case 1:
-                            yield ret
-                        case 2:
-                            yield from ret
+                yield_type, value = extract(e.value)
+                match yield_type:
+                    case 1:
+                        yield value
+                    case 2:
+                        yield from value
+                    case _:
+                        return value
             finally:
                 if close is not None:
                     close()

{python_iterutils-0.0.8.dist-info → python_iterutils-0.1.0.dist-info}/METADATA

@@ -1,27 +1,26 @@
 Metadata-Version: 2.1
 Name: python-iterutils
-Version: 0.0.8
+Version: 0.1.0
 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
+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.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
+iterutils/__init__.py,sha256=m6CldG12romSrteHnbHufKlmbRjzd6LfnsxqrqCETwM,17487
+iterutils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_iterutils-0.1.0.dist-info/LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
+python_iterutils-0.1.0.dist-info/METADATA,sha256=a1p4ibqdGfFKWEhsNSv80GJwd3PiNr7JNCmVOBEAb2U,1341
+python_iterutils-0.1.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+python_iterutils-0.1.0.dist-info/RECORD,,

{python_iterutils-0.0.8.dist-info → python_iterutils-0.1.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.8.1
+Generator: poetry-core 1.9.1
 Root-Is-Purelib: true
 Tag: py3-none-any

python_iterutils-0.0.8.dist-info/RECORD

@@ -1,7 +0,0 @@
-LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
-iterutils/__init__.py,sha256=rwD7tD31XxBl85Yo2pONeJoOng3aqYySh-I6CzEPILA,12467
-iterutils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_iterutils-0.0.8.dist-info/LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
-python_iterutils-0.0.8.dist-info/METADATA,sha256=3BSfEd9eF0b_zmgOE_pCEO6BNQeIRRv9X1UgGBUADSY,1382
-python_iterutils-0.0.8.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-python_iterutils-0.0.8.dist-info/RECORD,,