python-iterutils 0.0.5__tar.gz → 0.0.6__tar.gz

{python_iterutils-0.0.5 → python_iterutils-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-iterutils
-Version: 0.0.5
+Version: 0.0.6
 Summary: Python another itertools.
 Home-page: https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-iterutils
 License: MIT

{python_iterutils-0.0.5 → python_iterutils-0.0.6}/iterutils/__init__.py

@@ -2,19 +2,20 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 0, 5)
+__version__ = (0, 0, 6)
 __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", 
 ]
 
+from abc import ABC, abstractmethod
 from asyncio import to_thread
 from collections.abc import (
     AsyncIterable, AsyncIterator, Awaitable, Callable, Generator, Iterable, Iterator, 
 )
 from inspect import isawaitable
-from typing import overload, Any, Literal, TypeVar
+from typing import overload, Any, Literal, NamedTuple, TypeVar
 
 from asynctools import async_zip, ensure_async, ensure_aiter
 
@@ -22,16 +23,23 @@ from asynctools import async_zip, ensure_async, ensure_aiter
 T = TypeVar("T")
 
 
-class Yield:
+class YieldBase(ABC, Iterable):
+    __slots__ = "value", "identity"
+    @property
+    @abstractmethod
+    def yield_type(self, /) -> int:
+        ...
 
-    def __init__(self, value, /):
-        self.value = value
 
+@YieldBase.register
+class Yield(NamedTuple):
+    value: Any
+    identity: bool = False
+    yield_type = 1 # type: ignore
 
-class YieldFrom:
 
-    def __init__(self, value, /):
-        self.value = value
+class YieldFrom(Yield):
+    yield_type = 2
 
 
 def iterable(it, /) -> bool:
@@ -48,23 +56,23 @@ def async_iterable(it, /) -> bool:
         return False
 
 
-def foreach(func: Callable, iterable, /, *iterables):
+def foreach(ret: Callable, iterable, /, *iterables):
     if iterables:
         for args in zip(iterable, *iterables):
-            func(*args)
+            ret(*args)
     else:
         for arg in iterable:
-            func(arg)
+            ret(arg)
 
 
-async def async_foreach(func: Callable, iterable, /, *iterables, threaded: bool = True):
-    func = ensure_async(func, threaded=threaded)
+async def async_foreach(ret: Callable, iterable, /, *iterables, threaded: bool = True):
+    ret = ensure_async(ret, threaded=threaded)
     if iterables:
         async for args in async_zip(iterable, *iterables, threaded=threaded):
-            await func(*args)
+            await ret(*args)
     else:
         async for arg in ensure_aiter(iterable, threaded=threaded):
-            await func(arg)
+            await ret(arg)
 
 
 def through(it: Iterable, /):
@@ -199,29 +207,27 @@ def run_gen_step(
         async def process():
             try:
                 if threaded:
-                    func = await to_thread(send, None)
+                    ret = await to_thread(send, None)
                 else:
-                    func = send(None)
+                    ret = send(None)
                 while True:
                     try:
-                        if isawaitable(func):
-                            ret = await func
-                        elif callable(func):
-                            ret = func()
+                        if isawaitable(ret):
+                            ret = await ret
+                        elif callable(ret):
+                            ret = ret()
                             if isawaitable(ret):
                                 ret = await ret
-                        else:
-                            ret = func
                     except BaseException as e:
                         if threaded:
-                            func = await to_thread(throw, e)
+                            ret = await to_thread(throw, e)
                         else:
-                            func = throw(e)
+                            ret = throw(e)
                     else:
                         if threaded:
-                            func = await to_thread(send, ret)
+                            ret = await to_thread(send, ret)
                         else:
-                            func = send(ret)
+                            ret = send(ret)
             except StopIteration as e:
                 return e.value
             finally:
@@ -248,14 +254,15 @@ def run_gen_step(
         return result
     else:
         try:
-            func = send(None)
+            ret = send(None)
             while True:
                 try:
-                    ret = func() if callable(func) else func
+                    if callable(ret):
+                        ret = ret()
                 except BaseException as e:
-                    func = throw(e)
+                    ret = throw(e)
                 else:
-                    func = send(ret)
+                    ret = send(ret)
         except StopIteration as e:
             result = e.value
             if as_iter:
@@ -300,41 +307,41 @@ def run_gen_step_iter(
         async def process():
             try:
                 if threaded:
-                    func = await to_thread(send, None)
+                    ret = await to_thread(send, None)
                 else:
-                    func = send(None)
+                    ret = send(None)
                 while True:
                     yield_type = 0
-                    if isinstance(func, Yield):
-                        yield_type = 1
-                    elif isinstance(func, YieldFrom):
-                        yield_type = 2
-                    if yield_type:
-                        func = func.value
+                    identity = False
+                    if isinstance(ret, YieldBase):
+                        yield_type = ret.yield_type
+                        ret, identity = ret
                     try:
-                        if isawaitable(func):
-                            ret = await func
-                        elif callable(func):
-                            ret = func()
+                        if not identity:
                             if isawaitable(ret):
                                 ret = await ret
-                        else:
-                            ret = func
+                            elif callable(ret):
+                                ret = ret()
+                                if isawaitable(ret):
+                                    ret = await ret
+                            else:
+                                ret = ret
                     except BaseException as e:
                         if threaded:
-                            func = await to_thread(throw, e)
+                            ret = await to_thread(throw, e)
                         else:
-                            func = throw(e)
+                            ret = throw(e)
                     else:
-                        if yield_type == 1:
-                            yield ret
-                        elif yield_type == 2:
-                            async for val in ensure_aiter(ret, threaded=threaded):
-                                yield val
+                        match yield_type:
+                            case 1:
+                                yield ret
+                            case 2:
+                                async for val in ensure_aiter(ret, threaded=threaded):
+                                    yield val
                         if threaded:
-                            func = await to_thread(send, ret)
+                            ret = await to_thread(send, ret)
                         else:
-                            func = send(ret)
+                            ret = send(ret)
             except (StopIteration, GeneratorExit):
                 pass
             finally:
@@ -346,25 +353,25 @@ def run_gen_step_iter(
     else:
         def process():
             try:
-                func = send(None)
+                ret = send(None)
                 while True:
                     yield_type = 0
-                    if isinstance(func, Yield):
-                        yield_type = 1
-                    elif isinstance(func, YieldFrom):
-                        yield_type = 2
-                    if yield_type:
-                        func = func.value
+                    identity = False
+                    if isinstance(ret, YieldBase):
+                        yield_type = ret.yield_type
+                        ret, identity = ret
                     try:
-                        ret = func() if callable(func) else func
+                        if not identity:
+                            ret = ret() if callable(ret) else ret
                     except BaseException as e:
-                        func = throw(e)
+                        ret = throw(e)
                     else:
-                        if yield_type == 1:
-                            yield ret
-                        elif yield_type == 2:
-                            yield from ret
-                        func = send(ret)
+                        match yield_type:
+                            case 1:
+                                yield ret
+                            case 2:
+                                yield from ret
+                        ret = send(ret)
             except StopIteration as e:
                 return e.value
             except GeneratorExit:

{python_iterutils-0.0.5 → python_iterutils-0.0.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-iterutils"
-version = "0.0.5"
+version = "0.0.6"
 description = "Python another itertools."
 authors = ["ChenyangGao <wosiwujm@gmail.com>"]
 license = "MIT"