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

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

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

@@ -2,14 +2,16 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 1, 11)
+__version__ = (0, 2, 1)
 __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", 
-    "iter_gen_step", "iter_gen_step_async", "run_gen_step", "run_gen_step_iter", 
-    "as_gen_step", "bfs_gen", "with_iter_next", "backgroud_loop", 
+    "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", "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
@@ -17,11 +19,14 @@ from asyncio import create_task, sleep as async_sleep, to_thread
 from builtins import map as _map, filter as _filter, zip as _zip
 from collections import defaultdict, deque
 from collections.abc import (
-    AsyncIterable, AsyncIterator, Awaitable, Buffer, Callable, Collection, Container, 
-    Coroutine, Generator, Iterable, Iterator, Mapping, MutableMapping, MutableSet, 
-    MutableSequence, Sequence, ValuesView, 
+    AsyncIterable, AsyncIterator, Awaitable, Buffer, Callable, 
+    Collection, Container, Coroutine, Generator, Iterable, Iterator, 
+    Mapping, MutableMapping, MutableSet, MutableSequence, Sequence, 
+    ValuesView, 
+)
+from contextlib import (
+    asynccontextmanager, contextmanager, ExitStack, AsyncExitStack, 
 )
-from contextlib import asynccontextmanager, contextmanager, ExitStack, AsyncExitStack
 from copy import copy
 from dataclasses import dataclass
 from itertools import batched, pairwise
@@ -30,26 +35,42 @@ 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, Protocol
+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, 
-    collect as async_collect, 
+    async_filter, async_map, async_reduce, async_zip, async_batched, 
+    ensure_async, ensure_aiter, collect as async_collect, 
 )
 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: ...
 
 
-@dataclass(slots=True, frozen=True)
+class Reraised(BaseException):
+    """
+    """
+    def __init__(self, exc: BaseException, /):
+        if isinstance(exc, Reraised):
+            exc = exc.exception
+        self.exception: BaseException = exc
+
+
+@dataclass(slots=True, frozen=True, unsafe_hash=True)
 class YieldBase(ABC):
+    """
+    """
     value: Any
-    identity: bool = False
-    try_call_me: bool = True
+    may_await: None | bool | Literal[1] = False
+    may_call: None | bool | Literal[1] = None
 
     @property
     @abstractmethod
@@ -57,25 +78,30 @@ class YieldBase(ABC):
         ...
 
 
-class Reraised(BaseException):
-
-    def __init__(self, exc: BaseException, /):
-        self.exception = exc
-
-
 class Return(YieldBase):
+    """
+    """
+    __slots__ = ()
     yield_type = 0
 
 
 class Yield(YieldBase):
+    """
+    """
+    __slots__ = ()
     yield_type = 1
 
 
 class YieldFrom(YieldBase):
+    """
+    """
+    __slots__ = ()
     yield_type = 2
 
 
 def iterable(iterable, /) -> bool:
+    """
+    """
     try:
         return isinstance(iter(iterable), Iterable)
     except TypeError:
@@ -83,6 +109,8 @@ def iterable(iterable, /) -> bool:
 
 
 def async_iterable(iterable, /) -> bool:
+    """
+    """
     try:
         return isinstance(iter(iterable), AsyncIterable)
     except TypeError:
@@ -95,6 +123,8 @@ def foreach(
     /, 
     *iterables: Iterable | AsyncIterable, 
 ):
+    """
+    """
     if not (isinstance(iterable, Iterable) and all(isinstance(it, Iterable) for it in iterables)):
         return async_foreach(value, iterable, *iterables)
     if iterables:
@@ -112,6 +142,8 @@ async def async_foreach(
     *iterables: Iterable | AsyncIterable, 
     threaded: bool = False, 
 ):
+    """
+    """
     value = ensure_async(value, threaded=threaded)
     if iterables:
         async for args in async_zip(iterable, *iterables, threaded=threaded):
@@ -126,6 +158,8 @@ def through(
     /, 
     take_while: None | Callable = None, 
 ):
+    """
+    """
     if not isinstance(iterable, Iterable):
         return async_through(iterable, take_while)
     if take_while is None:
@@ -143,6 +177,8 @@ async def async_through(
     take_while: None | Callable = None, 
     threaded: bool = False, 
 ):
+    """
+    """
     iterable = ensure_aiter(iterable, threaded=threaded)
     if take_while is None:
         async for _ in iterable:
@@ -176,6 +212,8 @@ def flatten(
     /, 
     exclude_types: type | tuple[type, ...] = (Buffer, str), 
 ) -> Iterator | AsyncIterator:
+    """
+    """
     if not isinstance(iterable, Iterable):
         return async_flatten(iterable, exclude_types)
     def gen(iterable):
@@ -193,6 +231,8 @@ async def async_flatten(
     exclude_types: type | tuple[type, ...] = (Buffer, str), 
     threaded: bool = False, 
 ) -> AsyncIterator:
+    """
+    """
     async for e in ensure_aiter(iterable, threaded=threaded):
         if isinstance(e, (Iterable, AsyncIterable)) and not isinstance(e, exclude_types):
             async for e in async_flatten(e, exclude_types, threaded=threaded):
@@ -234,6 +274,8 @@ def collect(
     /, 
     rettype: Callable[[Iterable], Collection] = list, 
 ) -> Collection | Coroutine[Any, Any, Collection]:
+    """
+    """
     if not isinstance(iterable, Iterable):
         return async_collect(iterable, rettype)
     return rettype(iterable)
@@ -272,6 +314,8 @@ def group_collect[K, V, C: Container, M: MutableMapping](
     mapping: None | M = None, 
     factory: None | C | Callable[[], C] = None, 
 ) -> dict[K, C] | M | Coroutine[Any, Any, dict[K, C]] | Coroutine[Any, Any, M]:
+    """
+    """
     if not isinstance(iterable, Iterable):
         return async_group_collect(iterable, mapping, factory)
     if factory is None:
@@ -329,6 +373,8 @@ async def async_group_collect[K, V, C: Container, M: MutableMapping](
     factory: None | C | Callable[[], C] = None, 
     threaded: bool = False, 
 ) -> dict[K, C] | M:
+    """
+    """
     iterable = ensure_aiter(iterable, threaded=threaded)
     if factory is None:
         if isinstance(mapping, defaultdict):
@@ -368,7 +414,9 @@ def map(
     iterable: Iterable | AsyncIterable, 
     /, 
     *iterables: Iterable | AsyncIterable, 
-):      
+):
+    """
+    """
     if (
         iscoroutinefunction(function) or 
         isinstance(iterable, AsyncIterable) or 
@@ -393,6 +441,8 @@ def filter(
     iterable: Iterable | AsyncIterable, 
     /, 
 ):
+    """
+    """
     if iscoroutinefunction(function) or isinstance(iterable, AsyncIterable):
         return async_filter(function, iterable)
     return _filter(function, iterable)
@@ -401,9 +451,11 @@ def filter(
 def reduce(
     function: Callable, 
     iterable: Iterable | AsyncIterable, 
-    initial = undefined, 
+    initial: Any = undefined, 
     /, 
 ):
+    """
+    """
     if iscoroutinefunction(function) or isinstance(iterable, AsyncIterable):
         return async_reduce(function, iterable, initial)
     from functools import reduce
@@ -417,6 +469,8 @@ def zip(
     /, 
     *iterables: Iterable | AsyncIterable, 
 ):
+    """
+    """
     if isinstance(iterable, AsyncIterable) or any(isinstance(i, AsyncIterable) for i in iterables):
         return async_zip(iterable, *iterables)
     return _zip(iterable, *iterables)
@@ -441,6 +495,8 @@ def chunked[T](
     n: int = 1, 
     /, 
 ) -> Iterator[Sequence[T]] | AsyncIterator[Sequence[T]]:
+    """
+    """
     if n < 0:
         n = 1
     if isinstance(iterable, Sequence):
@@ -472,6 +528,8 @@ def iter_unique[T](
     /, 
     seen: None | MutableSet = None, 
 ) -> Iterator[T] | AsyncIterator[T]:
+    """
+    """
     if not isinstance(iterable, Iterable):
         return async_iter_unique(iterable, seen)
     if seen is None:
@@ -491,6 +549,8 @@ async def async_iter_unique[T](
     seen: None | MutableSet = None, 
     threaded: bool = False, 
 ) -> AsyncIterator[T]:
+    """
+    """
     if seen is None:
         seen = set()
     add = seen.add
@@ -506,8 +566,6 @@ def wrap_iter[T](
     /, 
     callprev: None | Callable[[T], Any] = None, 
     callnext: None | Callable[[T], Any] = None, 
-    callenter: None | Callable[[Iterable[T]], Any] = None, 
-    callexit: None | Callable[[Iterable[T], None | BaseException], Any] = None, 
 ) -> Iterator[T]:
     ...
 @overload
@@ -516,8 +574,6 @@ def wrap_iter[T](
     /, 
     callprev: None | Callable[[T], Any] = None, 
     callnext: None | Callable[[T], Any] = None, 
-    callenter: None | Callable[[Iterable[T] | AsyncIterable[T]], Any] = None, 
-    callexit: None | Callable[[Iterable[T] | AsyncIterable[T], None | BaseException], Any] = None, 
 ) -> AsyncIterator[T]:
     ...
 def wrap_iter[T](
@@ -525,47 +581,24 @@ def wrap_iter[T](
     /, 
     callprev: None | Callable[[T], Any] = None, 
     callnext: None | Callable[[T], Any] = None, 
-    callenter: None | Callable[[Iterable[T]], Any] | Callable[[Iterable[T] | AsyncIterable[T]], Any] = None, 
-    callexit: ( None | Callable[[Iterable[T], None | BaseException], Any] | 
-                Callable[[Iterable[T] | AsyncIterable[T], None | BaseException], Any] ) = None, 
 ) -> Iterator[T] | AsyncIterator[T]:
+    """
+    """
     if not isinstance(iterable, Iterable):
         return wrap_aiter(
             iterable, 
             callprev=callprev, 
             callnext=callnext, 
-            callenter=callenter, # type: ignore
-            callexit=callexit, # type: ignore
         )
     if not callable(callprev):
         callprev = None
     if not callable(callnext):
         callnext = None
     def gen():
-        try:
-            if callable(callenter):
-                callenter(iterable)
-            for e in iterable:
-                if callprev:
-                    try:
-                        callprev(e)
-                    except (StopIteration, GeneratorExit):
-                        break
-                yield e
-                if callnext:
-                    try:
-                        callnext(e)
-                    except (StopIteration, GeneratorExit):
-                        break
-        except BaseException as e:
-            if callable(callexit):
-                if not callexit(iterable, e):
-                    raise
-            else:
-                raise
-        finally:
-            if callable(callexit):
-                callexit(iterable, None)
+        for e in iterable:
+            callprev and callprev(e)
+            yield e
+            callnext and callnext(e)
     return gen()
 
 
@@ -574,34 +607,16 @@ async def wrap_aiter[T](
     /, 
     callprev: None | Callable[[T], Any] = None, 
     callnext: None | Callable[[T], Any] = None, 
-    callenter: None | Callable[[Iterable[T] | AsyncIterable[T]], Any] = None, 
-    callexit: None | Callable[[Iterable[T] | AsyncIterable[T], None | BaseException], Any] = None, 
     threaded: bool = False, 
 ) -> AsyncIterator[T]:
+    """
+    """
     callprev = ensure_async(callprev, threaded=threaded) if callable(callprev) else None
     callnext = ensure_async(callnext, threaded=threaded) if callable(callnext) else None
-    try:
-        async for e in ensure_aiter(iterable, threaded=threaded):
-            if callprev:
-                try:
-                    await callprev(e)
-                except (StopAsyncIteration, GeneratorExit):
-                    break
-            yield e
-            if callnext:
-                try:
-                    await callnext(e)
-                except (StopAsyncIteration, GeneratorExit):
-                    break
-    except BaseException as e:
-        if callable(callexit):
-            if not await ensure_async(callexit, threaded=threaded)(iterable, e):
-                raise
-        else:
-            raise
-    finally:
-        if callable(callexit):
-            await ensure_async(callexit, threaded=threaded)(iterable, None)
+    async for e in ensure_aiter(iterable, threaded=threaded):
+        callprev and await callprev(e)
+        yield e
+        callnext and await callnext(e)
 
 
 def acc_step(
@@ -609,6 +624,8 @@ def acc_step(
     stop: None | int = None, 
     step: int = 1, 
 ) -> Iterator[tuple[int, int, int]]:
+    """
+    """
     if stop is None:
         start, stop = 0, start
     for i in range(start + step, stop, step):
@@ -622,6 +639,8 @@ def cut_iter(
     stop: None | int = None, 
     step: int = 1, 
 ) -> Iterator[tuple[int, int]]:
+    """
+    """
     if stop is None:
         start, stop = 0, start
     for start in range(start + step, stop, step):
@@ -650,20 +669,25 @@ def _get_async(back: int = 2) -> bool:
 @overload
 def call_as_async[**Args, T: Coroutine](
     func: Callable[Args, T], /, 
+    may_await: bool | Literal[1] = False, 
     threaded: bool = False, 
 ) -> Callable[Args, T]:
     ...
 @overload
 def call_as_async[**Args, T](
     func: Callable[Args, T], /, 
+    may_await: bool | Literal[1] = False, 
     threaded: bool = False, 
 ) -> Callable[Args, Coroutine[Any, Any, T]]:
     ...
 def call_as_async[**Args, T](
     func: Callable[Args, T], 
     /, 
+    may_await: bool | Literal[1] = False, 
     threaded: bool = False, 
 ) -> Callable[Args, T] | Callable[Args, Coroutine[Any, Any, T]]:
+    """
+    """
     if iscoroutinefunction(func):
         return func
     def wraps(*args, **kwds):
@@ -671,32 +695,35 @@ 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 1 or may_await and isawaitable(value):
+            value = await value
+        return value
     return wrapper
 
 
 def iter_gen_step(
     gen_step: Generator | Callable[[], Generator], 
+    may_call: bool | Literal[1] = True, 
 ):
+    """
+    """
     if callable(gen_step):
-        gen = gen_step()
-    else:
-        gen = gen_step
-    send  = gen.send
-    throw = gen.throw
-    close = gen.close
+        gen_step = gen_step()
+    send  = gen_step.send
+    throw = gen_step.throw
+    close = gen_step.close
+    value: Any = None
     try:
-        value = send(None)
         while True:
             if isinstance(value, YieldBase):
                 raise StopIteration(value)
             try:
-                if callable(value):
+                if may_call is 1 or may_call and callable(value):
                     value = value()
             except BaseException as e:
                 value = throw(e)
@@ -705,11 +732,12 @@ def iter_gen_step(
             yield value
     except StopIteration as e:
         value = e.value
-        try_call_me = True
         if isinstance(value, YieldBase):
-            try_call_me = value.try_call_me
+            maybe_callable = value.may_call
+            if maybe_callable is not None:
+                may_call = maybe_callable
             value = value.value
-        if callable(value) and try_call_me:
+        if may_call is 1 or may_call and callable(value):
             try:
                 value = value()
             except BaseException as e:
@@ -718,32 +746,33 @@ 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()
 
 
 async def iter_gen_step_async(
     gen_step: Generator | Callable[[], Generator], 
+    may_await: bool | Literal[1] = True, 
+    may_call: bool | Literal[1] = True, 
     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)
+        gen_step = gen_step()
+    send: Callable  = call_as_async(gen_step.send, threaded=threaded)
+    throw: Callable = call_as_async(gen_step.throw, threaded=threaded)
+    close: Callable = call_as_async(gen_step.close, threaded=threaded)
+    value: Any = None
     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):
+                if may_call is 1 or may_call and callable(value):
+                    value = await call_as_async(
+                        value, may_await=may_await, threaded=threaded)()
+                elif may_await is 1 or may_await and isawaitable(value):
                     value = await value
             except BaseException as e:
                 if isinstance(e, Reraised):
@@ -757,16 +786,19 @@ async def iter_gen_step_async(
             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
+                maybe_awaitable = value.may_await
+                if maybe_awaitable is not None:
+                    may_await = maybe_awaitable
+                maybe_callable  = value.may_call
+                if maybe_callable is not None:
+                    may_call = maybe_callable
                 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):
+                if may_call is 1 or may_call and callable(value):
+                    value = await call_as_async(
+                        value, may_await=may_await, threaded=threaded)()
+                elif may_await is 1 or may_await and isawaitable(value):
                     value = await value
             except BaseException as e:
                 try:
@@ -780,36 +812,44 @@ async def iter_gen_step_async(
         await close()
 
 
-def run_gen_step[T](
+def run_gen_step(
     gen_step: Generator | Callable[[], Generator], 
+    may_await: bool | Literal[1] = True, 
+    may_call: bool | Literal[1] = True, 
     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, 
 ):
+    """
+    """
     if async_ is None:
         async_ = _get_async()
     if async_:
         async def process():
-            gen = iter_gen_step_async(gen_step, threaded=threaded)
+            gen = iter_gen_step_async(
+                gen_step, 
+                may_await=may_await, 
+                may_call=may_call, 
+                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 +859,7 @@ def run_gen_step[T](
                 raise
         return process()
     else:
-        gen = iter_gen_step(gen_step)
+        gen = iter_gen_step(gen_step, may_call=may_call)
         try:
             if running_flag is None:
                 for value in gen:
@@ -844,6 +884,8 @@ def run_gen_step[T](
 @overload
 def run_gen_step_iter(
     gen_step: Generator | Callable[[], Generator], 
+    may_await: bool | Literal[1] = True, 
+    may_call: bool | Literal[1] = True, 
     threaded: bool = False, 
     *, 
     async_: None = None, 
@@ -852,6 +894,8 @@ def run_gen_step_iter(
 @overload
 def run_gen_step_iter(
     gen_step: Generator | Callable[[], Generator], 
+    may_await: bool | Literal[1] = True, 
+    may_call: bool | Literal[1] = True, 
     threaded: bool = False, 
     *, 
     async_: Literal[False], 
@@ -860,6 +904,8 @@ def run_gen_step_iter(
 @overload
 def run_gen_step_iter(
     gen_step: Generator | Callable[[], Generator], 
+    may_await: bool | Literal[1] = True, 
+    may_call: bool | Literal[1] = True, 
     threaded: bool = False, 
     *, 
     async_: Literal[True], 
@@ -867,44 +913,54 @@ def run_gen_step_iter(
     ...
 def run_gen_step_iter(
     gen_step: Generator | Callable[[], Generator], 
+    may_await: bool | Literal[1] = True, 
+    may_call: bool | Literal[1] = True, 
     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
+    default_may_await = may_await
+    default_may_call  = may_call
     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
-                    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, /):
+            yield_type = -1
+            may_await  = default_may_await
+            may_call   = default_may_call
+            if isinstance(value, YieldBase):
+                yield_type = value.yield_type
+                maybe_awaitable = value.may_await
+                if maybe_awaitable is not None:
+                    may_await = maybe_awaitable
+                maybe_callable = value.may_call
+                if maybe_callable is not None:
+                    may_call = maybe_callable
+                value = value.value
+            if may_call is 1 or may_call and callable(value):
+                value = await call_as_async(
+                    value, may_await=may_await, threaded=threaded)()
+            elif may_await is 1 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 +977,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 +992,21 @@ def run_gen_step_iter(
                     raise
             finally:
                 await close()
+        return aprocess()
     else:
+        def extract(value, /):
+            yield_type = -1
+            may_call   = default_may_call
+            if isinstance(value, YieldBase):
+                yield_type = value.yield_type
+                maybe_callable = value.may_call
+                if maybe_callable is not None:
+                    may_call = maybe_callable
+                value      = value.value
+            if may_call is 1 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 +1037,7 @@ def run_gen_step_iter(
                     throw(e)
             finally:
                 close()
-    return process()
+        return process()
 
 
 @optional
@@ -986,23 +1045,29 @@ def as_gen_step(
     func: Callable, 
     /, 
     iter: bool = False, 
+    may_await: bool | Literal[1] = True, 
+    may_call: bool | Literal[1] = True, 
     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), 
+                may_await=may_await, 
+                may_call=may_call, 
                 threaded=threaded, 
                 async_=async_, # type: ignore
             )
         else:
             return run_gen_step(
                 func(*args, **kwds), 
+                may_await=may_await, 
+                may_call=may_call, 
                 threaded=threaded, 
                 running_flag=running_flag, 
                 async_=async_, 
@@ -1079,6 +1144,8 @@ def with_iter_next[T](
     /, 
     async_: Literal[False, True] = False, 
 ):
+    """
+    """
     if async_:
         get_next: Callable[[], T] | Callable[[], Awaitable[T]] = ensure_aiter(iterable).__anext__
     elif isinstance(iterable, Iterable):
@@ -1117,6 +1184,8 @@ def context[T](
     *ctxs: ContextManager | AsyncContextManager, 
     async_: Literal[False, True] = False, 
 ) -> T | Coroutine[Any, Any, T]:
+    """
+    """
     if async_:
         async def call():
             args: list = []
@@ -1165,6 +1234,8 @@ def backgroud_loop(
     *, 
     async_: Literal[False, True] = False, 
 ) -> ContextManager | AsyncContextManager:
+    """
+    """
     use_default_call = not callable(call)
     if use_default_call:
         start = time()

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

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