python-iterutils 0.1.8__tar.gz → 0.1.9__tar.gz

{python_iterutils-0.1.8 → python_iterutils-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-iterutils
-Version: 0.1.8
+Version: 0.1.9
 Summary: Python another itertools.
 Home-page: https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-iterutils
 License: MIT
@@ -20,7 +20,7 @@ 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.10.1)
+Requires-Dist: python-asynctools (>=0.1.2)
 Requires-Dist: python-decotools (>=0.0.2)
 Requires-Dist: python-texttools (>=0.0.3)
 Requires-Dist: python-undefined (>=0.0.3)

{python_iterutils-0.1.8 → python_iterutils-0.1.9}/iterutils/__init__.py

@@ -2,13 +2,14 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 1, 8)
+__version__ = (0, 1, 9)
 __all__ = [
     "Return", "Yield", "YieldFrom", "iterable", "async_iterable", "foreach", "async_foreach", 
     "through", "async_through", "flatten", "async_flatten", "collect", "async_collect", 
     "group_collect", "async_group_collect", "map", "filter", "reduce", "zip", "chunked", 
     "iter_unique", "async_iter_unique", "wrap_iter", "wrap_aiter", "acc_step", "cut_iter", 
-    "run_gen_step", "run_gen_step_iter", "as_gen_step", "bfs_gen", "with_iter_next", "backgroud_loop", 
+    "iter_gen_step", "iter_gen_step_async", "run_gen_step", "run_gen_step_iter", 
+    "as_gen_step", "bfs_gen", "with_iter_next", "backgroud_loop", 
 ]
 
 from abc import ABC, abstractmethod
@@ -52,6 +53,12 @@ class YieldBase(ABC):
         ...
 
 
+class Reraised(BaseException):
+
+    def __init__(self, exc: BaseException, /):
+        self.exception = exc
+
+
 class Return(YieldBase):
     yield_type = 0
 
@@ -636,110 +643,124 @@ def _get_async(back: int = 2) -> bool:
     return False
 
 
-def run_gen_step[T](
-    gen_step: Generator[Any, Any, T] | Callable[[], Generator[Any, Any, T]], 
-    *, 
-    async_: None | bool = None, 
-    threaded: bool = False, 
-    as_iter: bool = False, 
-) -> T:
-    if async_ is None:
-        async_ = _get_async()
+def iter_gen_step(
+    gen_step: Generator | Callable[[], Generator], 
+):
     if callable(gen_step):
         gen = gen_step()
-        close = gen.close
     else:
         gen = gen_step
-        close = None
     send = gen.send
     throw = gen.throw
-    if async_:
-        async def process():
+    close = gen.close
+    try:
+        value = send(None)
+        while True:
+            if isinstance(value, YieldBase):
+                raise StopIteration(value)
             try:
+                if callable(value):
+                    value = value()
+            except BaseException as e:
+                value = throw(e)
+            else:
+                value = send(value)
+            yield value
+    except StopIteration as e:
+        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:
+            try:
+                value = value()
+            except BaseException as e:
+                try:
+                    value = throw(e)
+                except BaseException as e:
+                    raise Reraised(e) from e
+        yield value
+    finally:
+        close()
+
+
+async def iter_gen_step_async(
+    gen_step: Generator | Callable[[], Generator], 
+    threaded: bool = False, 
+):
+    if callable(gen_step):
+        gen = gen_step()
+    else:
+        gen = gen_step
+    send = ensure_async(gen.send, threaded=threaded)
+    throw = ensure_async(gen.throw, threaded=threaded)
+    close = ensure_async(gen.close, threaded=threaded)
+    try:
+        value = await send(None)
+        while True:
+            if isinstance(value, YieldBase):
+                raise StopIteration(value)
+            try:
+                if callable(value):
+                    value = await ensure_async(value, threaded=threaded)()
+            except BaseException as e:
+                value = await throw(e)
+            else:
+                value = await send(value)
+            yield value
+    except StopIteration as e:
+        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
+        try:
+            if callable(value) and try_call_me:
                 if threaded:
-                    value = await to_thread(send, None)
+                    value = await to_thread(value)
                 else:
-                    value = send(None)
-                while True:
-                    if isinstance(value, YieldBase):
-                        raise StopIteration(value)
-                    try:
-                        if callable(value):
-                            value = value()
-                        if isawaitable(value):
-                            value = await value
-                    except BaseException as e:
-                        if threaded:
-                            value = await to_thread(throw, e)
-                        else:
-                            value = throw(e)
-                    else:
-                        if threaded:
-                            value = await to_thread(send, value)
-                        else:
-                            value = send(value)
-            except StopIteration as e:
-                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
+            if not identity and isawaitable(value):
+                value = await value
+        except BaseException as e:
+            try:
+                value = await throw(e)
+            except BaseException as e:
+                raise Reraised(e) from e
+        yield value
+    except StopAsyncIteration as e:
+        raise Reraised(e) from e
+    finally:
+        await close()
+
+
+def run_gen_step[T](
+    gen_step: Generator | Callable[[], Generator], 
+    *, 
+    async_: None | bool = None, 
+    threaded: bool = False, 
+):
+    if async_ is None:
+        async_ = _get_async()
+    if async_:
+        async def process():
+            try:
+                async for value in iter_gen_step_async(gen_step, threaded=threaded):
+                    pass
                 return value
-            finally:
-                if close is not None:
-                    if threaded:
-                        await to_thread(close)
-                    else:
-                        close()
-        result = process()
-        if as_iter:
-            async def wrap(result):
-                iterable = await result
-                try:
-                    iterable = aiter(iterable)
-                except TypeError:
-                    for val in iter(iterable):
-                        if isawaitable(val):
-                            val = await val
-                        yield val
-                else:
-                    async for val in iterable:
-                        yield val
-            result = wrap(result)
-        return result
+            except Reraised as e:
+                raise e.exception
+        return process()
     else:
         try:
-            value = send(None)
-            while True:
-                if isinstance(value, YieldBase):
-                    raise StopIteration(value)
-                try:
-                    if callable(value):
-                        value = value()
-                except BaseException as e:
-                    value = throw(e)
-                else:
-                    value = send(value)
-        except StopIteration as e:
-            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:
-                value = iter(value)
+            for value in iter_gen_step(gen_step):
+                pass
             return value
-        finally:
-            if close is not None:
-                close()
+        except Reraised as e:
+            raise e.exception
 
 
 @overload
@@ -776,12 +797,11 @@ def run_gen_step_iter(
         async_ = _get_async()
     if callable(gen_step):
         gen = gen_step()
-        close = gen.close
     else:
         gen = gen_step
-        close = None
     send = gen.send
     throw = gen.throw
+    close = gen.close
     if async_:
         async def process():
             async def extract(value):
@@ -823,19 +843,24 @@ def run_gen_step_iter(
                         else:
                             value = send(value)
             except StopIteration as e:
-                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:
+                try:
+                    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
+                except BaseException as e:
                     if threaded:
-                        await to_thread(close)
+                        await to_thread(throw, e)
                     else:
-                        close()
+                        throw(e)
+            finally:
+                if threaded:
+                    await to_thread(close)
+                else:
+                    close()
     else:
         def process():
             def extract(value, /):
@@ -865,17 +890,19 @@ def run_gen_step_iter(
                     else:
                         value = send(value)
             except StopIteration as e:
-                yield_type, value = extract(e.value)
-                match yield_type:
-                    case 1:
-                        yield value
-                    case 2:
-                        yield from value
-                    case _:
-                        return value
+                try:
+                    yield_type, value = extract(e.value)
+                    match yield_type:
+                        case 1:
+                            yield value
+                        case 2:
+                            yield from value
+                        case _:
+                            return value
+                except BaseException as e:
+                    throw(e)
             finally:
-                if close is not None:
-                    close()
+                close()
     return process()
 
 

{python_iterutils-0.1.8 → python_iterutils-0.1.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-iterutils"
-version = "0.1.8"
+version = "0.1.9"
 description = "Python another itertools."
 authors = ["ChenyangGao <wosiwujm@gmail.com>"]
 license = "MIT"
@@ -27,7 +27,7 @@ include = [
 
 [tool.poetry.dependencies]
 python = "^3.12"
-python-asynctools = ">=0.0.10.1"
+python-asynctools = ">=0.1.2"
 python-decotools = ">=0.0.2"
 python-texttools = ">=0.0.3"
 python-undefined = ">=0.0.3"