python-iterutils 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

iterutils/__init__.py

@@ -2,21 +2,20 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 2, 3)
+__version__ = (0, 2, 4)
 __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_sync_iter", "run_gen_step_async_iter", 
-    "run_gen_step_iter", "as_gen_step", "as_gen_step_iter", "bfs_gen", 
-    "with_iter_next", "backgroud_loop", 
+    "Yield", "YieldFrom", "iterable", "async_iterable", 
+    "run_gen_step", "run_gen_step_iter", "as_gen_step", 
+    "as_gen_step_iter", "split_cm, ""with_iter_next", 
+    "map", "filter", "reduce", "zip", "chunked", 
+    "foreach", "async_foreach", "through", "async_through", 
+    "flatten", "async_flatten", "collect", "async_collect", 
+    "group_collect", "async_group_collect", "iter_unique", 
+    "async_iter_unique", "wrap_iter", "wrap_aiter", "acc_step", 
+    "cut_iter", "bfs_gen", "context", "backgroud_loop", 
 ]
 
-from abc import ABC, abstractmethod
-from asyncio import create_task, sleep as async_sleep, to_thread
+from asyncio import create_task, sleep as async_sleep
 from builtins import map as _map, filter as _filter, zip as _zip
 from collections import defaultdict, deque
 from collections.abc import (
@@ -27,95 +26,472 @@ from collections.abc import (
 )
 from contextlib import (
     asynccontextmanager, contextmanager, ExitStack, AsyncExitStack, 
+    AbstractContextManager, AbstractAsyncContextManager, 
 )
 from copy import copy
 from dataclasses import dataclass
 from itertools import batched, pairwise
-from inspect import isawaitable, iscoroutinefunction
-from sys import _getframe
+from inspect import isawaitable, iscoroutinefunction, signature
+from sys import _getframe, exc_info
 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 asynctools import (
     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
 
 
-class SupportsBool(Protocol):
+@dataclass(slots=True, frozen=True, unsafe_hash=True)
+class Yield:
+    """专供 `run_gen_step_iter`，说明值需要 yield 给用户
     """
+    value: Any
+
+
+@dataclass(slots=True, frozen=True, unsafe_hash=True)
+class YieldFrom:
+    """专供 `run_gen_step_iter`，说明值需要解包后逐个 yield 给用户
     """
-    def __bool__(self, /) -> bool: ...
+    value: Any
 
 
-class Reraised(BaseException):
+def iterable(obj, /) -> bool:
+    """判断对象是不是 Iterable
     """
+    return isinstance(obj, Iterable)
+
+
+def async_iterable(obj, /) -> bool:
+    """判断对象是不是 AsyncIterable
     """
-    def __init__(self, exc: BaseException, /):
-        if isinstance(exc, Reraised):
-            exc = exc.exception
-        self.exception: BaseException = exc
+    return isinstance(obj, AsyncIterable)
 
 
-@dataclass(slots=True, frozen=True, unsafe_hash=True)
-class YieldBase(ABC):
+def _get_async(back: int = 2, /) -> bool:
+    """往上查找，从最近的调用栈的命名空间中获取 `async_` 的值
     """
+    f: None | FrameType
+    f = _getframe(back)
+    f_globals = f.f_globals
+    f_locals  = f.f_locals
+    if f_locals is f_globals:
+        return f_locals.get("async_") or False
+    while f_locals is not None and f_locals is not f_globals:
+        if "async_" in f_locals:
+            return f_locals["async_"] or False
+        f = f.f_back
+        if f is None:
+            break
+        f_locals = f.f_locals
+    return False
+
+
+def _run_gen_step(gen: Generator, /):
+    send = gen.send
+    try:
+        value: Any = send(None)
+        while True:
+            value = send(value)
+    except StopIteration as e:
+        return e.value
+    finally:
+        gen.close()
+
+
+async def _run_gen_step_async(gen: Generator, /):
+    send  = gen.send
+    throw = gen.throw
+    try:
+        ret: Awaitable = send(None)
+        while True:
+            try:
+                value: Any = await ret
+            except BaseException as e:
+                ret = throw(e)
+            else:
+                ret = send(value)
+    except StopIteration as e:
+        if isawaitable(e.value):
+            return await e.value
+        return e.value
+    finally:
+        gen.close()
+
+
+def run_gen_step[**Args](
+    gen_step: Generator | Callable[Args, Generator], 
+    async_: None | Literal[False, True] = None, 
+    /, 
+    *args: Args.args, 
+    **kwds: Args.kwargs, 
+):
+    """驱动生成器运行，并返回其结果
     """
-    value: Any
-    may_await: None | bool | Literal[1] = False
-    may_call: None | bool | Literal[1] = None
+    if async_ is None:
+        async_ = _get_async()
+    if not isinstance(gen_step, Generator):
+        params = signature(gen_step).parameters
+        if ((param := params.get("async_")) and 
+            (param.kind in (param.POSITIONAL_OR_KEYWORD, param.KEYWORD_ONLY))
+        ):
+            kwds.setdefault("async_", async_)
+        gen_step = gen_step(*args, **kwds)
+    if async_:
+        return _run_gen_step_async(gen_step)
+    else:
+        return _run_gen_step(gen_step)
+
+
+def _run_gen_step_iter(gen: Generator, /) -> Iterator:
+    send = gen.send
+    try:
+        value: Any = send(None)
+        while True:
+            if isinstance(value, Yield):
+                yield value.value
+            elif isinstance(value, YieldFrom):
+                yield from value.value
+            value = send(value)
+    except StopIteration as e:
+        value = e.value
+        if isinstance(value, Yield):
+            yield value.value
+        elif isinstance(value, YieldFrom):
+            yield from value.value
+    finally:
+        gen.close()
+
+
+async def _run_gen_step_async_iter(gen: Generator, /) -> AsyncIterator:
+    send  = gen.send
+    throw = gen.throw
+    try:
+        ret: Awaitable | Yield | YieldFrom = send(None)
+        while True:
+            try:
+                if isinstance(ret, Awaitable):
+                    value: Any = await ret
+                else:
+                    value = ret.value
+                    if isawaitable(value):
+                        value = await value
+                    if isinstance(ret, Yield):
+                        yield value
+                    elif isinstance(value, AsyncIterable):
+                        async for e in value:
+                            yield e
+                    else:
+                        for e in value:
+                            yield e
+            except BaseException as e:
+                ret = throw(e)
+            else:
+                ret = send(value)
+    except StopIteration as e:
+        val = e.value
+        if isinstance(val, (Yield, YieldFrom)):
+            value = val.value
+            if isawaitable(value):
+                value = await value
+            if isinstance(ret, Yield):
+                yield value
+            elif isinstance(value, AsyncIterable):
+                async for e in value:
+                    yield e
+            else:
+                for e in value:
+                    yield e
+        elif isawaitable(val):
+            await val
+    finally:
+        gen.close()
+
+
+@overload
+def run_gen_step_iter[**Args](
+    gen_step: Generator | Callable[Args, Generator], 
+    async_: None = None, 
+    /, 
+    *args: Args.args, 
+    **kwds: Args.kwargs, 
+) -> Iterator | AsyncIterator:
+    ...
+@overload
+def run_gen_step_iter[**Args](
+    gen_step: Generator | Callable[Args, Generator], 
+    async_: Literal[False] = False, 
+    /, 
+    *args: Args.args, 
+    **kwds: Args.kwargs, 
+) -> Iterator:
+    ...
+@overload
+def run_gen_step_iter[**Args](
+    gen_step: Generator | Callable[Args, Generator], 
+    async_: Literal[True], 
+    /, 
+    *args: Args.args, 
+    **kwds: Args.kwargs, 
+) -> AsyncIterator:
+    ...
+def run_gen_step_iter[**Args](
+    gen_step: Generator | Callable[Args, Generator], 
+    async_: None | Literal[False, True] = None, 
+    /, 
+    *args: Args.args, 
+    **kwds: Args.kwargs, 
+) -> Iterator | AsyncIterator:
+    """驱动生成器运行，并从中返回可迭代而出的值
+    """
+    if async_ is None:
+        async_ = _get_async()
+    if not isinstance(gen_step, Generator):
+        params = signature(gen_step).parameters
+        if ((param := params.get("async_")) and 
+            (param.kind in (param.POSITIONAL_OR_KEYWORD, param.KEYWORD_ONLY))
+        ):
+            kwds.setdefault("async_", async_)
+        gen_step = gen_step(*args, **kwds)
+    if async_:
+        return _run_gen_step_async_iter(gen_step)
+    else:
+        return _run_gen_step_iter(gen_step)
+
+
+def as_gen_step[**Args](
+    gen_step: Callable[Args, Generator], 
+    /, 
+) -> Callable[Args, Any]:
+    def wrapper(*args: Args.args, **kwds: Args.kwargs):
+        async_ = cast(None | Literal[False, True], kwds.pop("async_", None))
+        return run_gen_step(gen_step, async_, *args, **kwds)
+    return wrapper
+
+
+def as_gen_step_iter[**Args](
+    gen_step: Callable[Args, Generator], 
+    /, 
+) -> Callable[Args, Iterable | AsyncIterable]:
+    def wrapper(*args: Args.args, **kwds: Args.kwargs):
+        async_ = cast(None | Literal[False, True], kwds.pop("async_", None))
+        return run_gen_step_iter(gen_step, async_, *args, **kwds)
+    return wrapper
+
+
+@overload
+def split_cm[T](
+    cm: AbstractContextManager[T], 
+    /, 
+) -> tuple[Callable[[], T], Callable[[], Any]]:
+    ...
+@overload
+def split_cm[T](
+    cm: AbstractAsyncContextManager[T], 
+    /, 
+) -> tuple[Callable[[], Coroutine[Any, Any, T]], Callable[[], Coroutine]]:
+    ...
+def split_cm[T](
+    cm: AbstractContextManager[T] | AbstractAsyncContextManager[T], 
+    /, 
+) -> (
+    tuple[Callable[[], T], Callable[[], Any]] | 
+    tuple[Callable[[], Coroutine[Any, Any, T]], Callable[[], Coroutine]]
+):
+    """拆分上下文管理器，以供 `run_gen_step` 和 `run_gen_step_iter` 使用
+
+    .. code:: python
+
+        if async_:
+            async def process():
+                async with cm as obj:
+                    do_what_you_want()
+            return process()
+        else:
+            with cm as obj:
+                do_what_you_want()
+
+    大概相当于
+
+    .. code:: python
+
+        def gen_step():
+            enter, exit = split_cm(cm)
+            obj = yield enter()
+            try:
+                do_what_you_want()
+            finally:
+                yield exit()
+
+        run_gen_step(gen_step, async_=async_)
+    """
+    if isinstance(cm, AbstractAsyncContextManager):
+        enter: Callable = cm.__aenter__
+        exit: Callable  = cm.__aexit__
+    else:
+        enter = cm.__enter__
+        exit  = cm.__exit__
+    return enter, lambda: exit(*exc_info())
+
+
+@overload
+def with_iter_next[T](
+    iterable: Iterable[T], 
+    /, 
+) -> ContextManager[Callable[[], T]]:
+    ...
+@overload
+def with_iter_next[T](
+    iterable: AsyncIterable[T], 
+    /, 
+) -> ContextManager[Callable[[], Awaitable[T]]]:
+    ...
+@contextmanager
+def with_iter_next[T](
+    iterable: Iterable[T] | AsyncIterable[T], 
+    /, 
+):
+    """包装迭代器，以供 `run_gen_step` 和 `run_gen_step_iter` 使用
+
+    .. code:: python
+
+        if async_:
+            async def process():
+                async for e in iterable:
+                    do_what_you_want()
+            return process()
+        else:
+            for e in iterable:
+                do_what_you_want()
+
+    大概相当于
+
+    .. code:: python
 
-    @property
-    @abstractmethod
-    def yield_type(self, /) -> int:
-        ...
+        def gen_step():
+            with with_iter_next(iterable) as do_next:
+                while True:
+                    e = yield do_next()
+                    do_what_you_want()
 
+        run_gen_step(gen_step, async_=async_)
+    """
+    if isinstance(iterable, AsyncIterable):
+        try:
+            yield aiter(iterable).__anext__
+        except StopAsyncIteration:
+            pass
+    else:
+        try:
+            yield iter(iterable).__next__
+        except StopIteration:
+            pass
 
-class Return(YieldBase):
+
+def map(
+    function: None | Callable, 
+    iterable: Iterable | AsyncIterable, 
+    /, 
+    *iterables: Iterable | AsyncIterable, 
+):
     """
     """
-    __slots__ = ()
-    yield_type = 0
+    if (
+        iscoroutinefunction(function) or 
+        isinstance(iterable, AsyncIterable) or 
+        any(isinstance(i, AsyncIterable) for i in iterables)
+    ):
+        if function is None:
+            if iterables:
+                return async_zip(iterable, *iterables)
+            else:
+                return iterable
+        return async_map(function, iterable, *iterables)
+    if function is None:
+        if iterables:
+            return _zip(iterable, *iterables)
+        else:
+            return iterable
+    return _map(function, iterable, *iterables)
 
 
-class Yield(YieldBase):
+def filter(
+    function: None | Callable, 
+    iterable: Iterable | AsyncIterable, 
+    /, 
+):
     """
     """
-    __slots__ = ()
-    yield_type = 1
+    if iscoroutinefunction(function) or isinstance(iterable, AsyncIterable):
+        return async_filter(function, iterable)
+    return _filter(function, iterable)
 
 
-class YieldFrom(YieldBase):
+def reduce(
+    function: Callable, 
+    iterable: Iterable | AsyncIterable, 
+    initial: Any = undefined, 
+    /, 
+):
     """
     """
-    __slots__ = ()
-    yield_type = 2
+    if iscoroutinefunction(function) or isinstance(iterable, AsyncIterable):
+        return async_reduce(function, iterable, initial)
+    from functools import reduce
+    if initial is undefined:
+        return reduce(function, iterable)
+    return reduce(function, iterable, initial)
 
 
-def iterable(iterable, /) -> bool:
+def zip(
+    iterable: Iterable | AsyncIterable, 
+    /, 
+    *iterables: Iterable | AsyncIterable, 
+):
     """
     """
-    try:
-        return isinstance(iter(iterable), Iterable)
-    except TypeError:
-        return False
+    if isinstance(iterable, AsyncIterable) or any(isinstance(i, AsyncIterable) for i in iterables):
+        return async_zip(iterable, *iterables)
+    return _zip(iterable, *iterables)
 
 
-def async_iterable(iterable, /) -> bool:
+@overload
+def chunked[T](
+    iterable: Iterable[T], 
+    n: int = 1, 
+    /, 
+) -> Iterator[Sequence[T]]:
+    ...
+@overload
+def chunked[T](
+    iterable: AsyncIterable[T], 
+    n: int = 1, 
+    /, 
+) -> AsyncIterator[Sequence[T]]:
+    ...
+def chunked[T](
+    iterable: Iterable[T] | AsyncIterable[T], 
+    n: int = 1, 
+    /, 
+) -> Iterator[Sequence[T]] | AsyncIterator[Sequence[T]]:
     """
     """
-    try:
-        return isinstance(iter(iterable), AsyncIterable)
-    except TypeError:
-        return False
+    if n < 0:
+        n = 1
+    if isinstance(iterable, Sequence):
+        if n == 1:
+            return ((e,) for e in iterable)
+        return (iterable[i:j] for i, j in pairwise(range(0, len(iterable)+n, n)))
+    elif isinstance(iterable, Iterable):
+        return batched(iterable, n)
+    else:
+        return async_batched(iterable, n)
 
 
 def foreach(
@@ -410,109 +786,9 @@ async def async_group_collect[K, V, C: Container, M: MutableMapping](
     return mapping
 
 
-def map(
-    function: None | Callable, 
-    iterable: Iterable | AsyncIterable, 
-    /, 
-    *iterables: Iterable | AsyncIterable, 
-):
-    """
-    """
-    if (
-        iscoroutinefunction(function) or 
-        isinstance(iterable, AsyncIterable) or 
-        any(isinstance(i, AsyncIterable) for i in iterables)
-    ):
-        if function is None:
-            if iterables:
-                return async_zip(iterable, *iterables)
-            else:
-                return iterable
-        return async_map(function, iterable, *iterables)
-    if function is None:
-        if iterables:
-            return _zip(iterable, *iterables)
-        else:
-            return iterable
-    return _map(function, iterable, *iterables)
-
-
-def filter(
-    function: None | Callable, 
-    iterable: Iterable | AsyncIterable, 
-    /, 
-):
-    """
-    """
-    if iscoroutinefunction(function) or isinstance(iterable, AsyncIterable):
-        return async_filter(function, iterable)
-    return _filter(function, iterable)
-
-
-def reduce(
-    function: Callable, 
-    iterable: Iterable | AsyncIterable, 
-    initial: Any = undefined, 
-    /, 
-):
-    """
-    """
-    if iscoroutinefunction(function) or isinstance(iterable, AsyncIterable):
-        return async_reduce(function, iterable, initial)
-    from functools import reduce
-    if initial is undefined:
-        return reduce(function, iterable)
-    return reduce(function, iterable, initial)
-
-
-def zip(
-    iterable: Iterable | AsyncIterable, 
-    /, 
-    *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)
-
-
-@overload
-def chunked[T](
-    iterable: Iterable[T], 
-    n: int = 1, 
-    /, 
-) -> Iterator[Sequence[T]]:
-    ...
-@overload
-def chunked[T](
-    iterable: AsyncIterable[T], 
-    n: int = 1, 
-    /, 
-) -> AsyncIterator[Sequence[T]]:
-    ...
-def chunked[T](
-    iterable: Iterable[T] | AsyncIterable[T], 
-    n: int = 1, 
-    /, 
-) -> Iterator[Sequence[T]] | AsyncIterator[Sequence[T]]:
-    """
-    """
-    if n < 0:
-        n = 1
-    if isinstance(iterable, Sequence):
-        if n == 1:
-            return ((e,) for e in iterable)
-        return (iterable[i:j] for i, j in pairwise(range(0, len(iterable)+n, n)))
-    elif isinstance(iterable, Iterable):
-        return batched(iterable, n)
-    else:
-        return async_batched(iterable, n)
-
-
-@overload
-def iter_unique[T](
-    iterable: Iterable[T], 
+@overload
+def iter_unique[T](
+    iterable: Iterable[T], 
     /, 
     seen: None | MutableSet = None, 
 ) -> Iterator[T]:
@@ -650,493 +926,6 @@ def cut_iter(
         yield stop, stop - start
 
 
-def _get_async(back: int = 2) -> bool:
-    f: None | FrameType
-    f = _getframe(back)
-    f_globals = f.f_globals
-    f_locals  = f.f_locals
-    if f_locals is f_globals:
-        return f_locals.get("async_") or False
-    while f_locals is not None and f_locals is not f_globals:
-        if "async_" in f_locals:
-            return f_locals["async_"] or False
-        f = f.f_back
-        if f is None:
-            break
-        f_locals = f.f_locals
-    return False
-
-
-@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):
-        try:
-            return func(*args, **kwds)
-        except (StopIteration, StopAsyncIteration) as e:
-            raise Reraised(e) from e
-    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_step = gen_step()
-    send  = gen_step.send
-    throw = gen_step.throw
-    close = gen_step.close
-    value: Any = None
-    try:
-        while True:
-            if isinstance(value, YieldBase):
-                raise StopIteration(value)
-            try:
-                if may_call is 1 or may_call and callable(value):
-                    value = value()
-            except BaseException as e:
-                value = throw(e)
-            else:
-                value = send(value)
-            yield value
-    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, 
-):
-    """
-    """
-    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
-    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:
-                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:
-                    value = await throw(e)
-                except BaseException as e:
-                    raise Reraised(e) from e
-            yield value
-        else:
-            raise
-    finally:
-        await close()
-
-
-@overload
-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 | SupportsBool | Callable[[], SupportsBool] | Callable[[], Awaitable[SupportsBool]] = None, 
-    *, 
-    async_: None = None, 
-):
-    ...
-@overload
-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 | SupportsBool | Callable[[], SupportsBool] | Callable[[], Awaitable[SupportsBool]] = None, 
-    *, 
-    async_: Literal[False], 
-):
-    ...
-@overload
-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 | SupportsBool | Callable[[], SupportsBool] | Callable[[], Awaitable[SupportsBool]] = None, 
-    *, 
-    async_: Literal[True], 
-) -> Coroutine:
-    ...
-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 | SupportsBool | Callable[[], SupportsBool] | Callable[[], Awaitable[SupportsBool]] = None, 
-    *, 
-    async_: None | Literal[False, True] = None, 
-):
-    """
-    """
-    if async_ is None:
-        async_ = _get_async()
-    if async_:
-        async def process():
-            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 = call_as_async(running_flag, threaded=threaded)
-                    if not await pred():
-                        raise RuntimeError("stop before starting", gen) from StopIteration()
-                    async for value in gen:
-                        if not await 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, may_call=may_call)
-        try:
-            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
-
-
-def run_gen_step_sync_iter(
-    gen_step: Generator | Callable[[], Generator], 
-    may_call: bool | Literal[1] = True, 
-) -> Iterator:
-    """
-    """
-    if callable(gen_step):
-        gen_step = gen_step()
-    send:  Callable = gen_step.send
-    throw: Callable = gen_step.throw
-    close: Callable = gen_step.close
-    def extract(value, may_call=may_call, /):
-        yield_type = -1
-        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
-    try:
-        value = send(None)
-        while True:
-            try:
-                yield_type, value = extract(value)
-                match yield_type:
-                    case 0:
-                        return value
-                    case 1:
-                        yield value
-                    case 2:
-                        yield from value
-            except BaseException as e:
-                value = throw(e)
-            else:
-                value = send(value)
-    except StopIteration as e:
-        try:
-            yield_type, value = extract(e.value)
-            match yield_type:
-                case 1:
-                    yield value
-                case 2:
-                    yield from value
-                case _:
-                    return value
-        except BaseException as e:
-            throw(e)
-    finally:
-        close()
-
-
-async def run_gen_step_async_iter(
-    gen_step: Generator | Callable[[], Generator], 
-    may_await: bool | Literal[1] = True, 
-    may_call: bool | Literal[1] = True, 
-    threaded: bool = False, 
-) -> AsyncIterator:
-    """
-    """
-    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)
-    async def extract(value, may_await=may_await, may_call=may_call, /):
-        yield_type = -1
-        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
-    try:
-        value = await send(None)
-        while True:
-            try:
-                yield_type, value = await extract(value)
-                match yield_type:
-                    case 0:
-                        return
-                    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
-                value = await throw(e)
-            else:
-                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:
-            raise
-    finally:
-        await close()
-
-
-@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, 
-    running_flag: None | SupportsBool | Callable[[], SupportsBool] | Callable[[], Awaitable[SupportsBool]] = None, 
-    *, 
-    async_: None = None, 
-) -> Iterator | AsyncIterator:
-    ...
-@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, 
-    running_flag: None | SupportsBool | Callable[[], SupportsBool] | Callable[[], Awaitable[SupportsBool]] = None, 
-    *, 
-    async_: Literal[False], 
-) -> Iterator:
-    ...
-@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, 
-    running_flag: None | SupportsBool | Callable[[], SupportsBool] | Callable[[], Awaitable[SupportsBool]] = None, 
-    *, 
-    async_: Literal[True], 
-) -> AsyncIterator:
-    ...
-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, 
-    running_flag: None | SupportsBool | Callable[[], SupportsBool] | Callable[[], Awaitable[SupportsBool]] = None, 
-    *, 
-    async_: None | Literal[False, True] = None, 
-) -> Iterator | AsyncIterator:
-    """
-    """
-    if async_ is None:
-        async_ = _get_async()
-    if async_:
-        return run_gen_step_async_iter(
-            gen_step, 
-            may_await=may_await, 
-            may_call=may_call, 
-            threaded=threaded, 
-        )
-    else:
-        return run_gen_step_sync_iter(gen_step, may_call=may_call)
-
-
-@optional
-def as_gen_step(
-    func: Callable[..., Generator], 
-    /, 
-    *deco_args, 
-    iter: bool = False, 
-    **deco_kwds, 
-) -> Callable:
-    """装饰器，把生成器封装成 gen_step 函数
-    """
-    call = run_gen_step_iter if iter else run_gen_step
-    def wrapper(*args, async_: Literal[False, True] = False, **kwds):
-        return call(
-            func(*args, async_=async_, **kwds), 
-            *deco_args, 
-            async_=async_, 
-            **deco_kwds, 
-        )
-    return wrapper
-
-
-@optional
-def as_gen_step_iter(
-    func: Callable[..., Generator], 
-    /, 
-    *deco_args, 
-    **deco_kwds, 
-) -> Callable:
-    """装饰器，把生成器封装成 gen_step 函数
-    """
-    def wrapper(*args, async_: Literal[False, True] = False, **kwds):
-        return run_gen_step_iter(
-            func(*args, async_=async_, **kwds), 
-            *deco_args, 
-            async_=async_, 
-            **deco_kwds, 
-        )
-    return wrapper
-
-
 @overload
 def bfs_gen[T](
     initial: T, 
@@ -1179,59 +968,6 @@ def bfs_gen[T](
                 args = yield val
 
 
-@overload
-def with_iter_next[T](
-    iterable: Iterable[T], 
-    /, 
-    async_: Literal[False], 
-) -> ContextManager[Callable[[], T]]:
-    ...
-@overload
-def with_iter_next[T](
-    iterable: Iterable[T] | AsyncIterable[T], 
-    /, 
-    async_: Literal[True], 
-) -> ContextManager[Callable[[], Awaitable[T]]]:
-    ...
-@overload
-def with_iter_next[T](
-    iterable: Iterable[T] | AsyncIterable[T], 
-    /, 
-    async_: None = None, 
-) -> ContextManager[Callable[[], T]] | ContextManager[Callable[[], Awaitable[T]]]:
-    ...
-@contextmanager
-def with_iter_next[T](
-    iterable: Iterable[T] | AsyncIterable[T], 
-    /, 
-    async_: None | Literal[False, True] = None, 
-):
-    """
-    """
-    if async_ is None:
-        if not isinstance(iterable, Iterable):
-            async_ = True
-        else:
-            async_ = _get_async()
-    if async_:
-        get_next: Callable[[], T] | Callable[[], Awaitable[T]] = ensure_aiter(iterable).__anext__
-    elif isinstance(iterable, Iterable):
-        get_next = iter(iterable).__next__
-    else:
-        get_next = aiter(iterable).__anext__
-        async_ = True
-    if async_:
-        try:
-            yield get_next
-        except StopAsyncIteration:
-            pass
-    else:
-        try:
-            yield get_next
-        except StopIteration:
-            pass
-
-
 @overload
 def context[T](
     func: Callable[..., T], 

{python_iterutils-0.2.3.dist-info → python_iterutils-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-iterutils
-Version: 0.2.3
+Version: 0.2.4
 Summary: Python another itertools.
 Home-page: https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-iterutils
 License: MIT
@@ -21,7 +21,6 @@ Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: python-asynctools (>=0.1.2)
-Requires-Dist: python-decotools (>=0.0.2)
 Requires-Dist: python-texttools (>=0.0.3)
 Requires-Dist: python-undefined (>=0.0.3)
 Project-URL: Repository, https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-iterutils

python_iterutils-0.2.4.dist-info/RECORD

@@ -0,0 +1,7 @@
+LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
+iterutils/__init__.py,sha256=1DAr8LAf7Gge6iCv7YTDLAu_uI4EqWbuzWBfyAT76nE,30237
+iterutils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_iterutils-0.2.4.dist-info/LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
+python_iterutils-0.2.4.dist-info/METADATA,sha256=z2H59Xf9TIn6I8XRGLHxenhfVyMGXOMErl5x0dooOWU,1425
+python_iterutils-0.2.4.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+python_iterutils-0.2.4.dist-info/RECORD,,

python_iterutils-0.2.3.dist-info/RECORD

@@ -1,7 +0,0 @@
-LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
-iterutils/__init__.py,sha256=egZxWU804STaONEuyAjvI2R-nUbTXx1wU4AECgYu0jg,39456
-iterutils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_iterutils-0.2.3.dist-info/LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
-python_iterutils-0.2.3.dist-info/METADATA,sha256=ZdhvscMtLIfrgiGyeXC30ZTSXg2v0J98cLu9YpVt7uo,1467
-python_iterutils-0.2.3.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-python_iterutils-0.2.3.dist-info/RECORD,,