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

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

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

@@ -2,7 +2,7 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 1, 9)
+__version__ = (0, 1, 11)
 __all__ = [
     "Return", "Yield", "YieldFrom", "iterable", "async_iterable", "foreach", "async_foreach", 
     "through", "async_through", "flatten", "async_flatten", "collect", "async_collect", 
@@ -30,7 +30,7 @@ from sys import _getframe
 from _thread import start_new_thread
 from time import sleep, time
 from types import FrameType
-from typing import cast, overload, Any, AsyncContextManager, ContextManager, Literal
+from typing import cast, overload, Any, AsyncContextManager, ContextManager, Literal, Protocol
 
 from asynctools import (
     async_filter, async_map, async_reduce, async_zip, async_batched, ensure_async, ensure_aiter, 
@@ -41,6 +41,10 @@ from texttools import format_time
 from undefined import undefined, Undefined
 
 
+class SupportsBool(Protocol):
+    def __bool__(self, /) -> bool: ...
+
+
 @dataclass(slots=True, frozen=True)
 class YieldBase(ABC):
     value: Any
@@ -643,6 +647,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 +687,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 +718,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 +732,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,64 +742,103 @@ 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()
 
 
 def run_gen_step[T](
     gen_step: Generator | Callable[[], Generator], 
+    threaded: bool = False, 
+    running_flag: None | Callable[[], SupportsBool] | Callable[[], Awaitable[SupportsBool]] | SupportsBool = None, 
     *, 
     async_: None | bool = None, 
-    threaded: bool = False, 
 ):
     if async_ is None:
         async_ = _get_async()
     if async_:
         async def process():
+            gen = iter_gen_step_async(gen_step, threaded=threaded)
             try:
-                async for value in iter_gen_step_async(gen_step, threaded=threaded):
-                    pass
+                if running_flag is None:
+                    async for value in gen:
+                        pass
+                elif callable(running_flag):
+                    pred = running_flag()
+                    if not ((await pred) if isawaitable(pred) else pred):
+                        raise RuntimeError("stop before starting", gen) from StopIteration()
+                    async for value in gen:
+                        pred = running_flag()
+                        if not ((await pred) if isawaitable(pred) else pred):
+                            raise RuntimeError("stop midway", gen) from StopIteration(value)
+                    else:
+                        if not running_flag:
+                            raise RuntimeError("stop before starting", gen) from StopIteration()
+                        async for value in gen:
+                            if not running_flag:
+                                raise RuntimeError("stop midway", gen) from StopIteration(value)
                 return value
             except Reraised as e:
                 raise e.exception
+            except KeyboardInterrupt as e:
+                e.args = gen,
+                e.add_note(f"stop iterating gen_step: {gen!r}")
+                raise
         return process()
     else:
+        gen = iter_gen_step(gen_step)
         try:
-            for value in iter_gen_step(gen_step):
-                pass
+            if running_flag is None:
+                for value in gen:
+                    pass
+            else:
+                if not callable(running_flag):
+                    running_flag = running_flag.__bool__
+                if not running_flag():
+                    raise RuntimeError("stop before starting", gen) from StopIteration()
+                for value in gen:
+                    if not running_flag():
+                        raise RuntimeError("stop midway", gen) from StopIteration(value)
             return value
         except Reraised as e:
             raise e.exception
+        except KeyboardInterrupt as e:
+            e.args = gen,
+            e.add_note(f"stop iterating gen_step: {gen!r}")
+            raise
 
 
 @overload
@@ -799,30 +877,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 +911,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, /):
@@ -910,16 +985,28 @@ def run_gen_step_iter(
 def as_gen_step(
     func: Callable, 
     /, 
-    async_: None | bool = None, 
     iter: bool = False, 
+    threaded: bool = False, 
+    running_flag: None | Callable[[], SupportsBool] | Callable[[], Awaitable[SupportsBool]] | SupportsBool = None, 
+    *, 
+    async_: None | bool = None, 
 ) -> Callable:
     if async_ is None:
         async_ = _get_async()
     def wrapper(*args, **kwds):
         if iter:
-            return run_gen_step_iter(func(*args, **kwds), async_=async_) # type: ignore
+            return run_gen_step_iter(
+                func(*args, **kwds), 
+                threaded=threaded, 
+                async_=async_, # type: ignore
+            )
         else:
-            return run_gen_step(func(*args, **kwds), async_=async_)
+            return run_gen_step(
+                func(*args, **kwds), 
+                threaded=threaded, 
+                running_flag=running_flag, 
+                async_=async_, 
+            )
     return wrapper
 
 

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

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