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

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

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

@@ -2,7 +2,7 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 1, 10)
+__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
@@ -778,28 +782,63 @@ async def iter_gen_step_async(
 
 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
@@ -946,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.10 → python_iterutils-0.1.11}/pyproject.toml

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