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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-iterutils
-Version: 0.1.9
+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

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

@@ -2,7 +2,7 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 1, 9)
+__version__ = (0, 1, 10)
 __all__ = [
     "Return", "Yield", "YieldFrom", "iterable", "async_iterable", "foreach", "async_foreach", 
     "through", "async_through", "flatten", "async_flatten", "collect", "async_collect", 
@@ -643,6 +643,39 @@ def _get_async(back: int = 2) -> bool:
     return False
 
 
+@overload
+def call_as_async[**Args, T: Coroutine](
+    func: Callable[Args, T], /, 
+    threaded: bool = False, 
+) -> 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], 
 ):
@@ -650,7 +683,7 @@ def iter_gen_step(
         gen = gen_step()
     else:
         gen = gen_step
-    send = gen.send
+    send  = gen.send
     throw = gen.throw
     close = gen.close
     try:
@@ -681,6 +714,8 @@ def iter_gen_step(
                 except BaseException as e:
                     raise Reraised(e) from e
         yield value
+    except BaseException as e:
+        raise Reraised(e) from e
     finally:
         close()
 
@@ -693,9 +728,9 @@ async def iter_gen_step_async(
         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)
+    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:
@@ -703,36 +738,40 @@ async def iter_gen_step_async(
                 raise StopIteration(value)
             try:
                 if callable(value):
-                    value = await ensure_async(value, threaded=threaded)()
+                    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 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(value)
-                else:
-                    value = value()
-            if not identity and isawaitable(value):
-                value = await value
-        except BaseException as e:
+    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
             try:
-                value = await throw(e)
+                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:
-                raise Reraised(e) from e
-        yield value
-    except StopAsyncIteration as e:
-        raise Reraised(e) from e
+                try:
+                    value = await throw(e)
+                except BaseException as e:
+                    raise Reraised(e) from e
+            yield value
+        else:
+            raise
     finally:
         await close()
 
@@ -799,30 +838,30 @@ def run_gen_step_iter(
         gen = gen_step()
     else:
         gen = gen_step
-    send = gen.send
-    throw = gen.throw
-    close = gen.close
+    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)
@@ -833,34 +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:
-                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(throw, e)
-                    else:
-                        throw(e)
-            finally:
-                if threaded:
-                    await to_thread(close)
+                        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:
-                    close()
+                    raise
+            finally:
+                await close()
     else:
         def process():
             def extract(value, /):

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

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