python-iterutils 0.2__py3-none-any.whl → 0.2.1__py3-none-any.whl

iterutils/__init__.py

@@ -2,14 +2,16 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 2)
+__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,11 +35,14 @@ 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
@@ -42,22 +50,27 @@ 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)
+@dataclass(slots=True, frozen=True, unsafe_hash=True)
 class YieldBase(ABC):
+    """
+    """
     value: Any
-    may_await: None | bool = True
-    may_call: None | bool = True
+    may_await: None | bool | Literal[1] = False
+    may_call: None | bool | Literal[1] = None
 
     @property
     @abstractmethod
@@ -66,18 +79,29 @@ class YieldBase(ABC):
 
 
 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:
@@ -85,6 +109,8 @@ def iterable(iterable, /) -> bool:
 
 
 def async_iterable(iterable, /) -> bool:
+    """
+    """
     try:
         return isinstance(iter(iterable), AsyncIterable)
     except TypeError:
@@ -97,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:
@@ -114,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):
@@ -128,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:
@@ -145,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:
@@ -178,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):
@@ -195,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):
@@ -236,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)
@@ -274,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:
@@ -331,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):
@@ -370,7 +414,9 @@ def map(
     iterable: Iterable | AsyncIterable, 
     /, 
     *iterables: Iterable | AsyncIterable, 
-):      
+):
+    """
+    """
     if (
         iscoroutinefunction(function) or 
         isinstance(iterable, AsyncIterable) or 
@@ -395,6 +441,8 @@ def filter(
     iterable: Iterable | AsyncIterable, 
     /, 
 ):
+    """
+    """
     if iscoroutinefunction(function) or isinstance(iterable, AsyncIterable):
         return async_filter(function, iterable)
     return _filter(function, iterable)
@@ -406,6 +454,8 @@ def reduce(
     initial: Any = undefined, 
     /, 
 ):
+    """
+    """
     if iscoroutinefunction(function) or isinstance(iterable, AsyncIterable):
         return async_reduce(function, iterable, initial)
     from functools import reduce
@@ -419,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)
@@ -443,6 +495,8 @@ def chunked[T](
     n: int = 1, 
     /, 
 ) -> Iterator[Sequence[T]] | AsyncIterator[Sequence[T]]:
+    """
+    """
     if n < 0:
         n = 1
     if isinstance(iterable, Sequence):
@@ -474,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:
@@ -493,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
@@ -508,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
@@ -518,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](
@@ -527,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()
 
 
@@ -576,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(
@@ -611,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):
@@ -624,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):
@@ -652,23 +669,25 @@ def _get_async(back: int = 2) -> bool:
 @overload
 def call_as_async[**Args, T: Coroutine](
     func: Callable[Args, T], /, 
-    may_await: None | bool = False, 
+    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: None | bool = False, 
+    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: None | bool = False, 
+    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):
@@ -681,7 +700,7 @@ def call_as_async[**Args, T](
             value = await to_thread(wraps, *args, **kwds)
         else:
             value = wraps(*args, **kwds)
-        if may_await is None or may_await and isawaitable(value):
+        if may_await is 1 or may_await and isawaitable(value):
             value = await value
         return value
     return wrapper
@@ -689,140 +708,131 @@ def call_as_async[**Args, T](
 
 def iter_gen_step(
     gen_step: Generator | Callable[[], Generator], 
-    simple: bool = False, 
+    may_call: bool | Literal[1] = True, 
 ):
-    gen = gen_step() if callable(gen_step) else gen_step
-    send  = gen.send
-    throw = gen.throw
-    close = gen.close
+    """
+    """
+    if callable(gen_step):
+        gen_step = gen_step()
+    send  = gen_step.send
+    throw = gen_step.throw
+    close = gen_step.close
     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
+    try:
+        while True:
             if isinstance(value, YieldBase):
-                may_call = value.may_call
-                value    = value.value
-            if may_call is None or may_call and callable(value):
-                try:
+                raise StopIteration(value)
+            try:
+                if may_call is 1 or may_call and callable(value):
                     value = value()
-                except BaseException as e:
-                    try:
-                        value = throw(e)
-                    except BaseException as e:
-                        raise Reraised(e) from e
+            except BaseException as e:
+                value = throw(e)
+            else:
+                value = send(value)
             yield value
-        finally:
-            close()
+    except StopIteration as e:
+        value = e.value
+        if isinstance(value, YieldBase):
+            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):
+            try:
+                value = value()
+            except BaseException as e:
+                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], 
+    may_await: bool | Literal[1] = True, 
+    may_call: bool | Literal[1] = True, 
     threaded: bool = False, 
-    simple: bool = False, 
 ):
-    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)
+    """
+    """
+    if callable(gen_step):
+        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
-    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
+    try:
+        while True:
+            if isinstance(value, YieldBase):
+                raise StopIteration(value)
+            try:
+                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):
+                    e = e.exception
+                value = await throw(e)
             else:
-                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)
+                value = await send(value)
+            yield value
+    except BaseException as e:
+        if isinstance(e, Reraised):
+            e = e.exception
+        if isinstance(e, StopIteration):
+            value = e.value
+            if isinstance(value, YieldBase):
+                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 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:
-                    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:
-                    try:
-                        value = await throw(e)
-                    except BaseException as e:
-                        raise Reraised(e) from e
-                yield value
-            else:
-                raise
-        finally:
-            await close()
+                    raise Reraised(e) from e
+            yield value
+        else:
+            raise
+    finally:
+        await close()
 
 
 def run_gen_step(
     gen_step: Generator | Callable[[], Generator], 
-    simple: bool = False, 
+    may_await: bool | Literal[1] = True, 
+    may_call: bool | Literal[1] = True, 
     threaded: bool = False, 
     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, simple=simple, 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:
@@ -849,7 +859,7 @@ def run_gen_step(
                 raise
         return process()
     else:
-        gen = iter_gen_step(gen_step, simple=simple)
+        gen = iter_gen_step(gen_step, may_call=may_call)
         try:
             if running_flag is None:
                 for value in gen:
@@ -874,7 +884,8 @@ def run_gen_step(
 @overload
 def run_gen_step_iter(
     gen_step: Generator | Callable[[], Generator], 
-    simple: bool = False, 
+    may_await: bool | Literal[1] = True, 
+    may_call: bool | Literal[1] = True, 
     threaded: bool = False, 
     *, 
     async_: None = None, 
@@ -883,7 +894,8 @@ def run_gen_step_iter(
 @overload
 def run_gen_step_iter(
     gen_step: Generator | Callable[[], Generator], 
-    simple: bool = False, 
+    may_await: bool | Literal[1] = True, 
+    may_call: bool | Literal[1] = True, 
     threaded: bool = False, 
     *, 
     async_: Literal[False], 
@@ -892,7 +904,8 @@ def run_gen_step_iter(
 @overload
 def run_gen_step_iter(
     gen_step: Generator | Callable[[], Generator], 
-    simple: bool = False, 
+    may_await: bool | Literal[1] = True, 
+    may_call: bool | Literal[1] = True, 
     threaded: bool = False, 
     *, 
     async_: Literal[True], 
@@ -900,34 +913,43 @@ def run_gen_step_iter(
     ...
 def run_gen_step_iter(
     gen_step: Generator | Callable[[], Generator], 
-    simple: bool = False, 
+    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()
     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 aextract(value, /):
-            may_await: None | bool = None if simple else False
-            may_call: None | bool  = not simple
             yield_type = -1
+            may_await  = default_may_await
+            may_call   = default_may_call
             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):
+                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 None or may_await and isawaitable(value):
+            elif may_await is 1 or may_await and isawaitable(value):
                 value = await value
             return yield_type, value
         async def aprocess():
@@ -973,13 +995,15 @@ def run_gen_step_iter(
         return aprocess()
     else:
         def extract(value, /):
-            may_call: None | bool = not simple
             yield_type = -1
+            may_call   = default_may_call
             if isinstance(value, YieldBase):
                 yield_type = value.yield_type
-                may_call   = value.may_call
+                maybe_callable = value.may_call
+                if maybe_callable is not None:
+                    may_call = maybe_callable
                 value      = value.value
-            if may_call is None or may_call and callable(value):
+            if may_call is 1 or may_call and callable(value):
                 value = value()
             return yield_type, value
         def process():
@@ -1021,7 +1045,8 @@ def as_gen_step(
     func: Callable, 
     /, 
     iter: bool = False, 
-    simple: bool = False, 
+    may_await: bool | Literal[1] = True, 
+    may_call: bool | Literal[1] = True, 
     threaded: bool = False, 
     running_flag: None | SupportsBool | Callable[[], SupportsBool] | Callable[[], Awaitable[SupportsBool]] = None, 
     *, 
@@ -1033,14 +1058,16 @@ def as_gen_step(
         if iter:
             return run_gen_step_iter(
                 func(*args, **kwds), 
-                simple=simple, 
+                may_await=may_await, 
+                may_call=may_call, 
                 threaded=threaded, 
                 async_=async_, # type: ignore
             )
         else:
             return run_gen_step(
                 func(*args, **kwds), 
-                simple=simple, 
+                may_await=may_await, 
+                may_call=may_call, 
                 threaded=threaded, 
                 running_flag=running_flag, 
                 async_=async_, 
@@ -1117,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):
@@ -1155,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 = []
@@ -1203,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.2.dist-info → python_iterutils-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-iterutils
-Version: 0.2
+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.2.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
+iterutils/__init__.py,sha256=_veJbrFYJld_cVSYbBnR37dSbGi2aSDAkNmLUEvuiXE,37134
+iterutils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_iterutils-0.2.1.dist-info/LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
+python_iterutils-0.2.1.dist-info/METADATA,sha256=C55LpIsT807qqeehnsAZ7ZS-za5Gb03eltgrdYiN5vM,1467
+python_iterutils-0.2.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+python_iterutils-0.2.1.dist-info/RECORD,,

python_iterutils-0.2.dist-info/RECORD

@@ -1,7 +0,0 @@
-LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
-iterutils/__init__.py,sha256=LEkMyVkA2qLrVtJDuTXgUz0cUSexnjyEcJ0skHehf4M,38403
-iterutils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_iterutils-0.2.dist-info/LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
-python_iterutils-0.2.dist-info/METADATA,sha256=EYmtSSWyFbN7QMzuv79s2UKsPoJ3fNvr_SmLsL8SnlE,1465
-python_iterutils-0.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-python_iterutils-0.2.dist-info/RECORD,,