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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-iterutils
-Version: 0.2.1
+Version: 0.2.2
 Summary: Python another itertools.
 Home-page: https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-iterutils
 License: MIT

{python_iterutils-0.2.1 → python_iterutils-0.2.2}/iterutils/__init__.py

@@ -2,7 +2,7 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 2, 1)
+__version__ = (0, 2, 2)
 __all__ = [
     "Return", "Yield", "YieldFrom", "iterable", "async_iterable", 
     "foreach", "async_foreach", "through", "async_through", "flatten", 
@@ -10,8 +10,9 @@ __all__ = [
     "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", 
+    "run_gen_step", "run_gen_step_sync_iter", "run_gen_step_async_iter", 
+    "run_gen_step_iter", "as_gen_step", "bfs_gen", "with_iter_next", 
+    "backgroud_loop", 
 ]
 
 from abc import ABC, abstractmethod
@@ -656,7 +657,7 @@ def _get_async(back: int = 2) -> bool:
     f_locals  = f.f_locals
     if f_locals is f_globals:
         return f_locals.get("async_") or False
-    while f_locals is not f_globals:
+    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
@@ -881,6 +882,131 @@ def run_gen_step(
             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], 
@@ -923,121 +1049,15 @@ def run_gen_step_iter(
     """
     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, /):
-            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 aextract(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 aextract(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()
-        return aprocess()
+        return run_gen_step_async_iter(
+            gen_step, 
+            may_await=may_await, 
+            may_call=may_call, 
+            threaded=threaded, 
+        )
     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():
-            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()
-        return process()
+        return run_gen_step_sync_iter(gen_step, may_call=may_call)
 
 
 @optional
@@ -1054,6 +1074,8 @@ def as_gen_step(
 ) -> Callable:
     """装饰器，构建一个 gen_step 函数
     """
+    if async_ is None:
+        async_ = _get_async()
     def wrapper(*args, **kwds):
         if iter:
             return run_gen_step_iter(
@@ -1121,31 +1143,36 @@ def bfs_gen[T](
 def with_iter_next[T](
     iterable: Iterable[T], 
     /, 
-    async_: Literal[False] = False, 
+    async_: Literal[False], 
 ) -> ContextManager[Callable[[], T]]:
     ...
 @overload
 def with_iter_next[T](
-    iterable: AsyncIterable[T], 
+    iterable: Iterable[T] | AsyncIterable[T], 
     /, 
-    async_: Literal[False] = False, 
+    async_: Literal[True], 
 ) -> ContextManager[Callable[[], Awaitable[T]]]:
     ...
 @overload
 def with_iter_next[T](
     iterable: Iterable[T] | AsyncIterable[T], 
     /, 
-    async_: Literal[True], 
-) -> ContextManager[Callable[[], Awaitable[T]]]:
+    async_: None = None, 
+) -> ContextManager[Callable[[], T]] | ContextManager[Callable[[], Awaitable[T]]]:
     ...
 @contextmanager
 def with_iter_next[T](
     iterable: Iterable[T] | AsyncIterable[T], 
     /, 
-    async_: Literal[False, True] = False, 
+    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):
@@ -1169,7 +1196,7 @@ def with_iter_next[T](
 def context[T](
     func: Callable[..., T], 
     *ctxs: ContextManager, 
-    async_: Literal[False] = False, 
+    async_: Literal[False], 
 ) -> T:
     ...
 @overload
@@ -1179,13 +1206,25 @@ def context[T](
     async_: Literal[True], 
 ) -> Coroutine[Any, Any, T]:
     ...
+@overload
+def context[T](
+    func: Callable[..., T] | Callable[..., Awaitable[T]], 
+    *ctxs: ContextManager | AsyncContextManager, 
+    async_: None = None, 
+) -> T | Coroutine[Any, Any, T]:
+    ...
 def context[T](
     func: Callable[..., T] | Callable[..., Awaitable[T]], 
     *ctxs: ContextManager | AsyncContextManager, 
-    async_: Literal[False, True] = False, 
+    async_: None | Literal[False, True] = None, 
 ) -> T | Coroutine[Any, Any, T]:
     """
     """
+    if async_ is None:
+        if iscoroutinefunction(func):
+            async_ = True
+        else:
+            async_ = _get_async()
     if async_:
         async def call():
             args: list = []
@@ -1215,7 +1254,7 @@ def backgroud_loop(
     /, 
     interval: int | float = 0.05, 
     *, 
-    async_: Literal[False] = False, 
+    async_: Literal[False], 
 ) -> ContextManager:
     ...
 @overload
@@ -1227,15 +1266,29 @@ def backgroud_loop(
     async_: Literal[True], 
 ) -> AsyncContextManager:
     ...
+@overload
 def backgroud_loop(
     call: None | Callable = None, 
     /, 
     interval: int | float = 0.05, 
     *, 
-    async_: Literal[False, True] = False, 
+    async_: None = None, 
+) -> ContextManager | AsyncContextManager:
+    ...
+def backgroud_loop(
+    call: None | Callable = None, 
+    /, 
+    interval: int | float = 0.05, 
+    *, 
+    async_: None | Literal[False, True] = None, 
 ) -> ContextManager | AsyncContextManager:
     """
     """
+    if async_ is None:
+        if iscoroutinefunction(call):
+            async_ = True
+        else:
+            async_ = _get_async()
     use_default_call = not callable(call)
     if use_default_call:
         start = time()
@@ -1254,6 +1307,7 @@ def backgroud_loop(
                     sleep(interval)
     running = True
     if async_:
+        @asynccontextmanager
         async def actx():
             nonlocal running
             try:
@@ -1264,8 +1318,9 @@ def backgroud_loop(
                 task.cancel()
                 if use_default_call:
                     print("\r\x1b[K", end="")
-        return asynccontextmanager(actx)()
+        return actx()
     else:
+        @contextmanager
         def ctx():
             nonlocal running
             try:
@@ -1274,5 +1329,5 @@ def backgroud_loop(
                 running = False
                 if use_default_call:
                     print("\r\x1b[K", end="")
-        return contextmanager(ctx)()
+        return ctx()
 

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

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