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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-iterutils
-Version: 0.0.6
+Version: 0.0.7.1
 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.6 → python_iterutils-0.0.7.1}/iterutils/__init__.py

@@ -2,20 +2,21 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 0, 6)
+__version__ = (0, 0, 7)
 __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 dataclasses import dataclass
 from abc import ABC, abstractmethod
 from asyncio import to_thread
 from collections.abc import (
-    AsyncIterable, AsyncIterator, Awaitable, Callable, Generator, Iterable, Iterator, 
+    AsyncIterable, AsyncIterator, Callable, Generator, Iterable, Iterator, 
 )
 from inspect import isawaitable
-from typing import overload, Any, Literal, NamedTuple, TypeVar
+from typing import overload, Any, Literal, TypeVar
 
 from asynctools import async_zip, ensure_async, ensure_aiter
 
@@ -23,22 +24,23 @@ from asynctools import async_zip, ensure_async, ensure_aiter
 T = TypeVar("T")
 
 
-class YieldBase(ABC, Iterable):
-    __slots__ = "value", "identity"
+@dataclass(slots=True, frozen=True)
+class YieldBase(ABC):
+    value: Any
+    identity: bool = False
+    try_call_me: bool = True
+
     @property
     @abstractmethod
     def yield_type(self, /) -> int:
         ...
 
 
-@YieldBase.register
-class Yield(NamedTuple):
-    value: Any
-    identity: bool = False
-    yield_type = 1 # type: ignore
+class Yield(YieldBase):
+    yield_type = 1
 
 
-class YieldFrom(Yield):
+class YieldFrom(YieldBase):
     yield_type = 2
 
 
@@ -212,12 +214,10 @@ def run_gen_step(
                     ret = send(None)
                 while True:
                     try:
+                        if callable(ret):
+                            ret = ret()
                         if isawaitable(ret):
                             ret = await ret
-                        elif callable(ret):
-                            ret = ret()
-                            if isawaitable(ret):
-                                ret = await ret
                     except BaseException as e:
                         if threaded:
                             ret = await to_thread(throw, e)
@@ -305,45 +305,55 @@ def run_gen_step_iter(
     throw = gen.throw
     if async_:
         async def process():
+            async def extract(ret):
+                yield_type = 0
+                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
             try:
                 if threaded:
                     ret = await to_thread(send, None)
                 else:
                     ret = send(None)
                 while True:
-                    yield_type = 0
-                    identity = False
-                    if isinstance(ret, YieldBase):
-                        yield_type = ret.yield_type
-                        ret, identity = ret
                     try:
-                        if not identity:
-                            if isawaitable(ret):
-                                ret = await ret
-                            elif callable(ret):
-                                ret = ret()
-                                if isawaitable(ret):
-                                    ret = await ret
-                            else:
-                                ret = ret
-                    except BaseException as e:
-                        if threaded:
-                            ret = await to_thread(throw, e)
-                        else:
-                            ret = throw(e)
-                    else:
+                        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
+                    except BaseException as e:
+                        if threaded:
+                            ret = await to_thread(throw, e)
+                        else:
+                            ret = throw(e)
+                    else:
                         if threaded:
                             ret = await to_thread(send, ret)
                         else:
                             ret = send(ret)
-            except (StopIteration, GeneratorExit):
-                pass
+            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
             finally:
                 if close is not None:
                     if threaded:
@@ -352,30 +362,41 @@ def run_gen_step_iter(
                         close()
     else:
         def process():
+            def extract(ret):
+                yield_type = 0
+                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 and try_call_me and callable(ret):
+                    ret = ret()
+                return yield_type, ret
             try:
                 ret = send(None)
                 while True:
-                    yield_type = 0
-                    identity = False
-                    if isinstance(ret, YieldBase):
-                        yield_type = ret.yield_type
-                        ret, identity = ret
                     try:
-                        if not identity:
-                            ret = ret() if callable(ret) else ret
-                    except BaseException as e:
-                        ret = throw(e)
-                    else:
+                        yield_type, ret = extract(ret)
                         match yield_type:
                             case 1:
                                 yield ret
                             case 2:
                                 yield from ret
+                    except BaseException as e:
+                        ret = throw(e)
+                    else:
                         ret = send(ret)
             except StopIteration as e:
-                return e.value
-            except GeneratorExit:
-                pass
+                ret = e.value
+                if isinstance(ret, YieldBase):
+                    yield_type, ret = extract(ret)
+                    match yield_type:
+                        case 1:
+                            yield ret
+                        case 2:
+                            yield from ret
             finally:
                 if close is not None:
                     close()

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

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