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

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

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

@@ -2,7 +2,7 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 1, 11)
+__version__ = (0, 2)
 __all__ = [
     "Return", "Yield", "YieldFrom", "iterable", "async_iterable", "foreach", "async_foreach", 
     "through", "async_through", "flatten", "async_flatten", "collect", "async_collect", 
@@ -38,18 +38,26 @@ from asynctools import (
 )
 from decotools import optional
 from texttools import format_time
-from undefined import undefined, Undefined
+from undefined import undefined
 
 
 class SupportsBool(Protocol):
     def __bool__(self, /) -> bool: ...
 
 
+class Reraised(BaseException):
+
+    def __init__(self, exc: BaseException, /):
+        if isinstance(exc, Reraised):
+            exc = exc.exception
+        self.exception: BaseException = exc
+
+
 @dataclass(slots=True, frozen=True)
 class YieldBase(ABC):
     value: Any
-    identity: bool = False
-    try_call_me: bool = True
+    may_await: None | bool = True
+    may_call: None | bool = True
 
     @property
     @abstractmethod
@@ -57,12 +65,6 @@ class YieldBase(ABC):
         ...
 
 
-class Reraised(BaseException):
-
-    def __init__(self, exc: BaseException, /):
-        self.exception = exc
-
-
 class Return(YieldBase):
     yield_type = 0
 
@@ -401,7 +403,7 @@ def filter(
 def reduce(
     function: Callable, 
     iterable: Iterable | AsyncIterable, 
-    initial = undefined, 
+    initial: Any = undefined, 
     /, 
 ):
     if iscoroutinefunction(function) or isinstance(iterable, AsyncIterable):
@@ -650,18 +652,21 @@ def _get_async(back: int = 2) -> bool:
 @overload
 def call_as_async[**Args, T: Coroutine](
     func: Callable[Args, T], /, 
+    may_await: None | bool = False, 
     threaded: bool = False, 
 ) -> Callable[Args, T]:
     ...
 @overload
 def call_as_async[**Args, T](
     func: Callable[Args, T], /, 
+    may_await: None | bool = False, 
     threaded: bool = False, 
 ) -> Callable[Args, Coroutine[Any, Any, T]]:
     ...
 def call_as_async[**Args, T](
     func: Callable[Args, T], 
     /, 
+    may_await: None | bool = False, 
     threaded: bool = False, 
 ) -> Callable[Args, T] | Callable[Args, Coroutine[Any, Any, T]]:
     if iscoroutinefunction(func):
@@ -671,119 +676,145 @@ def call_as_async[**Args, T](
             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)
+    async def wrapper(*args, **kwds):
+        if threaded:
+            value = await to_thread(wraps, *args, **kwds)
+        else:
+            value = wraps(*args, **kwds)
+        if may_await is None or may_await and isawaitable(value):
+            value = await value
+        return value
     return wrapper
 
 
 def iter_gen_step(
     gen_step: Generator | Callable[[], Generator], 
+    simple: bool = False, 
 ):
-    if callable(gen_step):
-        gen = gen_step()
-    else:
-        gen = gen_step
+    gen = gen_step() if callable(gen_step) else gen_step
     send  = gen.send
     throw = gen.throw
     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:
+    value: Any = None
+    if simple:
+        try:
+            while True:
+                yield (value := send(value))
+        except StopIteration as e:
+            yield e.value
+        finally:
+            close()
+    else:
+        try:
+            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:
+            may_call: None | bool = True
+            value    = e.value
+            if isinstance(value, YieldBase):
+                may_call = value.may_call
+                value    = value.value
+            if may_call is None or may_call and callable(value):
+                try:
+                    value = value()
                 except BaseException as e:
-                    raise Reraised(e) from e
-        yield value
-    except BaseException as e:
-        raise Reraised(e) from e
-    finally:
-        close()
+                    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, 
+    simple: 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)
+    gen = gen_step() if callable(gen_step) else gen_step
+    send: Callable  = gen.send
+    throw: Callable = gen.throw
     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)
+    value: Any = None
+    if simple:
+        send  = call_as_async(send,  may_await=None, threaded=threaded)
+        throw = call_as_async(throw, may_await=None, threaded=threaded)
+        try:
+            while True:
+                yield (value := await send(value))
+        except BaseException as e:
+            if isinstance(e, Reraised):
+                e = e.exception
+            if isinstance(e, StopIteration):
+                yield e.value
             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
-            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:
+                raise
+        finally:
+            await close()
+    else:
+        send  = call_as_async(send,  threaded=threaded)
+        throw = call_as_async(throw, threaded=threaded)
+        try:
+            while True:
+                if isinstance(value, YieldBase):
+                    raise StopIteration(value)
                 try:
+                    if callable(value):
+                        value = await call_as_async(
+                            value, may_await=True, threaded=threaded)()
+                    elif 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):
+                may_await: None | bool = True
+                may_call: None | bool  = True
+                value     = e.value
+                if isinstance(value, YieldBase):
+                    may_await = value.may_await
+                    may_call  = value.may_call
+                    value     = value.value
+                try:
+                    if may_call is None or may_call and callable(value):
+                        value = await call_as_async(
+                            value, may_await=may_await, threaded=threaded)()
+                    elif may_await is None or may_await and isawaitable(value):
+                        value = await value
                 except BaseException as e:
-                    raise Reraised(e) from e
-            yield value
-        else:
-            raise
-    finally:
-        await close()
+                    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](
+def run_gen_step(
     gen_step: Generator | Callable[[], Generator], 
+    simple: bool = False, 
     threaded: bool = False, 
-    running_flag: None | Callable[[], SupportsBool] | Callable[[], Awaitable[SupportsBool]] | SupportsBool = None, 
+    running_flag: None | SupportsBool | Callable[[], SupportsBool] | Callable[[], Awaitable[SupportsBool]] = None, 
     *, 
     async_: None | bool = None, 
 ):
@@ -791,25 +822,24 @@ def run_gen_step[T](
         async_ = _get_async()
     if async_:
         async def process():
-            gen = iter_gen_step_async(gen_step, threaded=threaded)
+            gen = iter_gen_step_async(gen_step, simple=simple, threaded=threaded)
             try:
                 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):
+                    pred = call_as_async(running_flag, threaded=threaded)
+                    if not await 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):
+                        if not await pred():
                             raise RuntimeError("stop midway", gen) from StopIteration(value)
-                    else:
+                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 before starting", gen) from StopIteration()
-                        async for value in gen:
-                            if not running_flag:
-                                raise RuntimeError("stop midway", gen) from StopIteration(value)
+                            raise RuntimeError("stop midway", gen) from StopIteration(value)
                 return value
             except Reraised as e:
                 raise e.exception
@@ -819,7 +849,7 @@ def run_gen_step[T](
                 raise
         return process()
     else:
-        gen = iter_gen_step(gen_step)
+        gen = iter_gen_step(gen_step, simple=simple)
         try:
             if running_flag is None:
                 for value in gen:
@@ -844,6 +874,7 @@ def run_gen_step[T](
 @overload
 def run_gen_step_iter(
     gen_step: Generator | Callable[[], Generator], 
+    simple: bool = False, 
     threaded: bool = False, 
     *, 
     async_: None = None, 
@@ -852,6 +883,7 @@ def run_gen_step_iter(
 @overload
 def run_gen_step_iter(
     gen_step: Generator | Callable[[], Generator], 
+    simple: bool = False, 
     threaded: bool = False, 
     *, 
     async_: Literal[False], 
@@ -860,6 +892,7 @@ def run_gen_step_iter(
 @overload
 def run_gen_step_iter(
     gen_step: Generator | Callable[[], Generator], 
+    simple: bool = False, 
     threaded: bool = False, 
     *, 
     async_: Literal[True], 
@@ -867,16 +900,14 @@ def run_gen_step_iter(
     ...
 def run_gen_step_iter(
     gen_step: Generator | Callable[[], Generator], 
+    simple: bool = False, 
     threaded: bool = False, 
     *, 
     async_: None | bool = None, 
 ) -> Iterator | AsyncIterator:
     if async_ is None:
         async_ = _get_async()
-    if callable(gen_step):
-        gen = gen_step()
-    else:
-        gen = gen_step
+    gen = gen_step() if callable(gen_step) else gen_step
     send:  Callable = gen.send
     throw: Callable = gen.throw
     close: Callable = gen.close
@@ -884,27 +915,30 @@ def run_gen_step_iter(
         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
-                    try_call_me = value.try_call_me
-                    yield_type  = value.yield_type
-                    value       = value.value
-                if try_call_me and callable(value):
-                    value = await call_as_async(value, threaded=threaded)()
-                if not identity and isawaitable(value):
-                    value = await value
-                return yield_type, value
+        async def aextract(value, /):
+            may_await: None | bool = None if simple else False
+            may_call: None | bool  = not simple
+            yield_type = -1
+            if isinstance(value, YieldBase):
+                yield_type  = value.yield_type
+                may_await   = value.may_await
+                may_call    = value.may_call
+                value       = value.value
+            if may_call is None or may_call and callable(value):
+                value = await call_as_async(
+                    value, may_await=may_await, threaded=threaded)()
+            elif may_await is None or may_await and isawaitable(value):
+                value = await value
+            return yield_type, value
+        async def aprocess():
             try:
                 value = await send(None)
                 while True:
                     try:
-                        yield_type, value = await extract(value)
+                        yield_type, value = await aextract(value)
                         match yield_type:
+                            case 0:
+                                return
                             case 1:
                                 yield value
                             case 2:
@@ -921,7 +955,7 @@ def run_gen_step_iter(
                     e = e.exception
                 if isinstance(e, StopIteration):
                     try:
-                        yield_type, value = await extract(e.value)
+                        yield_type, value = await aextract(e.value)
                         match yield_type:
                             case 1:
                                 yield value
@@ -936,18 +970,19 @@ def run_gen_step_iter(
                     raise
             finally:
                 await close()
+        return aprocess()
     else:
+        def extract(value, /):
+            may_call: None | bool = not simple
+            yield_type = -1
+            if isinstance(value, YieldBase):
+                yield_type = value.yield_type
+                may_call   = value.may_call
+                value      = value.value
+            if may_call is None or may_call and callable(value):
+                value = value()
+            return yield_type, value
         def process():
-            def extract(value, /):
-                try_call_me = True
-                yield_type = -1
-                if isinstance(value, YieldBase):
-                    try_call_me = value.try_call_me
-                    yield_type  = value.yield_type
-                    value       = value.value
-                if try_call_me and callable(value):
-                    value = value()
-                return yield_type, value
             try:
                 value = send(None)
                 while True:
@@ -978,7 +1013,7 @@ def run_gen_step_iter(
                     throw(e)
             finally:
                 close()
-    return process()
+        return process()
 
 
 @optional
@@ -986,23 +1021,26 @@ def as_gen_step(
     func: Callable, 
     /, 
     iter: bool = False, 
+    simple: bool = False, 
     threaded: bool = False, 
-    running_flag: None | Callable[[], SupportsBool] | Callable[[], Awaitable[SupportsBool]] | SupportsBool = None, 
+    running_flag: None | SupportsBool | Callable[[], SupportsBool] | Callable[[], Awaitable[SupportsBool]] = None, 
     *, 
     async_: None | bool = None, 
 ) -> Callable:
-    if async_ is None:
-        async_ = _get_async()
+    """装饰器，构建一个 gen_step 函数
+    """
     def wrapper(*args, **kwds):
         if iter:
             return run_gen_step_iter(
                 func(*args, **kwds), 
+                simple=simple, 
                 threaded=threaded, 
                 async_=async_, # type: ignore
             )
         else:
             return run_gen_step(
                 func(*args, **kwds), 
+                simple=simple, 
                 threaded=threaded, 
                 running_flag=running_flag, 
                 async_=async_, 

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

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