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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-iterutils
-Version: 0.1.8
+Version: 0.1.10
 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.10}/iterutils/__init__.py

@@ -2,13 +2,14 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 1, 8)
+__version__ = (0, 1, 10)
 __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,163 @@ 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, 
+@overload
+def call_as_async[**Args, T: Coroutine](
+    func: Callable[Args, T], /, 
     threaded: bool = False, 
-    as_iter: bool = False, 
-) -> T:
-    if async_ is None:
-        async_ = _get_async()
+) -> Callable[Args, T]:
+    ...
+@overload
+def call_as_async[**Args, T](
+    func: Callable[Args, T], /, 
+    threaded: bool = False, 
+) -> Callable[Args, Coroutine[Any, Any, T]]:
+    ...
+def call_as_async[**Args, T](
+    func: Callable[Args, T], 
+    /, 
+    threaded: bool = False, 
+) -> Callable[Args, T] | Callable[Args, Coroutine[Any, Any, T]]:
+    if iscoroutinefunction(func):
+        return func
+    def wraps(*args, **kwds):
+        try:
+            return func(*args, **kwds)
+        except (StopIteration, StopAsyncIteration) as e:
+            raise Reraised(e) from e
+    if threaded:
+        async def wrapper(*args, **kwds):
+            return await to_thread(wraps, *args, **kwds)
+    else:
+        async def wrapper(*args, **kwds):
+            return wraps(*args, **kwds)
+    return wrapper
+
+
+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
+    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 threaded:
-                    value = await to_thread(send, None)
-                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:
+                if callable(value):
                     value = value()
-                if not identity and isawaitable(value):
-                    value = await value
-                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
-    else:
-        try:
-            value = send(None)
-            while True:
-                if isinstance(value, YieldBase):
-                    raise StopIteration(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:
-                    if callable(value):
-                        value = value()
-                except BaseException as e:
                     value = throw(e)
-                else:
-                    value = send(value)
-        except StopIteration as e:
+                except BaseException as e:
+                    raise Reraised(e) from e
+        yield value
+    except BaseException as e:
+        raise Reraised(e) from e
+    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:  Callable = call_as_async(gen.send, threaded=threaded)
+    throw: Callable = call_as_async(gen.throw, threaded=threaded)
+    close: Callable = call_as_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 call_as_async(value, threaded=threaded)()
+                if isawaitable(value):
+                    value = await value
+            except BaseException as e:
+                if isinstance(e, Reraised):
+                    e = e.exception
+                value = await throw(e)
+            else:
+                value = await send(value)
+            yield value
+    except BaseException as e:
+        if isinstance(e, Reraised):
+            e = e.exception
+        if isinstance(e, StopIteration):
             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 as_iter:
-                value = iter(value)
+            try:
+                if callable(value) and try_call_me:
+                    value = await call_as_async(value, threaded=threaded)()
+                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
+        else:
+            raise
+    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
+            except Reraised as e:
+                raise e.exception
+        return process()
+    else:
+        try:
+            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,33 +836,32 @@ 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
+    send:  Callable = gen.send
+    throw: Callable = gen.throw
+    close: Callable = gen.close
     if async_:
+        send  = call_as_async(send, threaded=threaded)
+        throw = call_as_async(throw, threaded=threaded)
+        close = call_as_async(close, threaded=threaded)
         async def process():
             async def extract(value):
                 identity = False
                 try_call_me = True
                 yield_type = -1
                 if isinstance(value, YieldBase):
-                    identity = value.identity
+                    identity    = value.identity
                     try_call_me = value.try_call_me
-                    yield_type = value.yield_type
-                    value = value.value
+                    yield_type  = value.yield_type
+                    value       = value.value
                 if try_call_me and callable(value):
-                    value = value()
+                    value = await call_as_async(value, threaded=threaded)()
                 if not identity and isawaitable(value):
                     value = await value
                 return yield_type, value
             try:
-                if threaded:
-                    value = await to_thread(send, None)
-                else:
-                    value = send(None)
+                value = await send(None)
                 while True:
                     try:
                         yield_type, value = await extract(value)
@@ -813,29 +872,31 @@ def run_gen_step_iter(
                                 async for val in ensure_aiter(value, threaded=threaded):
                                     yield val
                     except BaseException as e:
-                        if threaded:
-                            value = await to_thread(throw, e)
-                        else:
-                            value = throw(e)
+                        if isinstance(e, Reraised):
+                            e = e.exception
+                        value = await throw(e)
                     else:
-                        if threaded:
-                            value = await to_thread(send, value)
-                        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
+                        value = await send(value)
+            except BaseException as e:
+                if isinstance(e, Reraised):
+                    e = e.exception
+                if isinstance(e, StopIteration):
+                    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 isinstance(e, Reraised):
+                            e = e.exception
+                        await throw(e)
+                else:
+                    raise
             finally:
-                if close is not None:
-                    if threaded:
-                        await to_thread(close)
-                    else:
-                        close()
+                await close()
     else:
         def process():
             def extract(value, /):
@@ -865,17 +926,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.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-iterutils"
-version = "0.1.8"
+version = "0.1.10"
 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"