python-iterutils 0.2.5.5__tar.gz → 0.2.7__tar.gz

{python_iterutils-0.2.5.5 → python_iterutils-0.2.7}/PKG-INFO

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

@@ -2,14 +2,13 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 2, 5)
+__version__ = (0, 2, 7)
 __all__ = [
-    "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", "chain", 
-    "chain_from_iterable", "chunked", "foreach", 
-    "async_foreach", "through", "async_through", 
+    "Yield", "YieldFrom", "GenStep", "GenStepIter", "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", "chain", "chain_from_iterable", 
+    "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", 
@@ -63,6 +62,22 @@ class YieldFrom:
     value: Any
 
 
+@dataclass(slots=True, frozen=True, unsafe_hash=True)
+class GenStep:
+    """专供 `run_gen_step` 和 `run_gen_step_iter`，说明值需要进一步提取
+    """
+    value: Generator
+    max_depth: int = 0
+
+
+@dataclass(slots=True, frozen=True, unsafe_hash=True)
+class GenStepIter:
+    """专供 `run_gen_step_iter`，说明值需要进一步提取
+    """
+    value: Generator
+    max_depth: int = 0
+
+
 iterable = Iterable.__instancecheck__
 async_iterable = AsyncIterable.__instancecheck__
 isawaitable = Awaitable.__instancecheck__
@@ -91,37 +106,68 @@ def _get_async[T](back: int = 2, /, *, default: Literal[False] | T = False) -> b
     return _coalesce(iter_frams(), default)
 
 
-def _run_gen_step(gen: Generator, /):
-    send = gen.send
+def _run_gen_step(
+    gen: Generator, 
+    /, 
+    drive_generator: int = 0, 
+):
+    send  = gen.send
+    throw = gen.throw
+    dgen  = drive_generator if drive_generator < 0 else drive_generator - 1
     try:
         value: Any = send(None)
         while True:
-            value = send(value)
+            try:
+                if isinstance(value, GenStep):
+                    value = _run_gen_step(value.value, value.max_depth)
+                elif drive_generator and isinstance(value, Generator):
+                    value = _run_gen_step(value, dgen)
+            except BaseException as e:
+                value = throw(e)
+            else:
+                value = send(value)
     except StopIteration as e:
-        return e.value
+        value = e.value
+        if isinstance(value, GenStep):
+            value = _run_gen_step(value.value, value.max_depth)
+        elif drive_generator and isinstance(value, Generator):
+            value = _run_gen_step(value, dgen)
+        return value
     finally:
         gen.close()
 
 
-async def _run_gen_step_async(gen: Generator, /):
+async def _run_gen_step_async(
+    gen: Generator, 
+    /, 
+    drive_generator: int = 0, 
+):
     send  = gen.send
     throw = gen.throw
+    dgen = drive_generator if drive_generator < 0 else drive_generator - 1
     try:
-        ret: Any = send(None)
+        value: Any = send(None)
         while True:
-            if isawaitable(ret):
-                try:
-                    value: Any = (await ret)
-                except BaseException as e:
-                    ret = throw(e)
-                else:
-                    ret = send(value)
+            try:
+                if isawaitable(value):
+                    value = await value
+                elif isinstance(value, GenStep):
+                    value = await _run_gen_step_async(value.value, value.max_depth)
+                elif drive_generator and isinstance(value, Generator):
+                    value = await _run_gen_step_async(value, dgen)
+            except BaseException as e:
+                value = throw(e)
             else:
-                ret = send(ret)
+                value = send(value)
     except StopIteration as e:
-        if isawaitable(e.value):
-            return await e.value
-        return e.value
+        value = e.value
+        if isawaitable(value):
+            value = await value
+        elif isinstance(value, GenStep):
+            value = await _run_gen_step_async(value.value, value.max_depth)
+        elif drive_generator and isinstance(value, Generator):
+            value = await _run_gen_step_async(value, dgen)
+        return value
     finally:
         gen.close()
 
@@ -150,69 +196,114 @@ def run_gen_step[**Args](
         return _run_gen_step(gen_step)
 
 
-def _run_gen_step_iter(gen: Generator, /) -> Iterator:
-    send = gen.send
+def _run_gen_step_iter(
+    gen: Generator, 
+    /, 
+    drive_generator: int = 0, 
+) -> Iterator:
+    send  = gen.send
+    throw = gen.throw
+    dgen  = drive_generator if drive_generator < 0 else drive_generator - 1
     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)
+            try:
+                val_type = type(value)
+                if issubclass(val_type, (Yield, YieldFrom)):
+                    value = value.value
+                elif isinstance(value, GenStepIter):
+                    yield from _run_gen_step_iter(value.value, value.max_depth)
+                elif isinstance(value, GenStep):
+                    value = _run_gen_step(value.value, value.max_depth)
+                elif drive_generator and isinstance(value, Generator):
+                    value = _run_gen_step(value, dgen)
+                if val_type is Yield:
+                    yield value
+                elif val_type is YieldFrom:
+                    yield from value
+            except BaseException as e:
+                value = throw(e)
+            else:
+                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
+        val_type = type(value)
+        if issubclass(val_type, (Yield, YieldFrom)):
+            value = value.value
+        elif isinstance(value, GenStepIter):
+            yield from _run_gen_step_iter(value.value, value.max_depth)
+        elif isinstance(value, GenStep):
+            value = _run_gen_step(value.value, value.max_depth)
+        elif drive_generator and isinstance(value, Generator):
+            value = _run_gen_step(value, dgen)
+        if val_type is Yield:
+            yield value
+        elif val_type is YieldFrom:
+            yield from value
     finally:
         gen.close()
 
 
-async def _run_gen_step_async_iter(gen: Generator, /) -> AsyncIterator:
+async def _run_gen_step_async_iter(
+    gen: Generator, 
+    /, 
+    drive_generator: int = 0, 
+) -> AsyncIterator:
     send  = gen.send
     throw = gen.throw
+    dgen = drive_generator if drive_generator < 0 else drive_generator - 1
     try:
-        ret: Any = send(None)
+        value: Any = send(None)
         while True:
             try:
-                if isinstance(ret, (Yield, YieldFrom)):
-                    value: Any = 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
+                val_type = type(value)
+                if issubclass(val_type, (Yield, YieldFrom)):
+                    value = value.value
+                if isawaitable(value):
+                    value = await value
+                elif isinstance(value, GenStepIter):
+                    async for el in _run_gen_step_async_iter(value.value, value.max_depth):
+                        yield el
+                elif isinstance(value, GenStep):
+                    value = await _run_gen_step_async(value.value, value.max_depth)
+                elif drive_generator and isinstance(value, Generator):
+                    value = await _run_gen_step_async(value, dgen)
+                if val_type is Yield:
+                    yield value
+                elif val_type is YieldFrom:
+                    if isinstance(value, AsyncIterable):
+                        async for el in value:
+                            yield el
                     else:
-                        for e in value:
-                            yield e
-                elif isawaitable(ret):
-                    value = await ret
-                else:
-                    value = ret
+                        for el in value:
+                            yield el
             except BaseException as e:
-                ret = throw(e)
+                value = throw(e)
             else:
-                ret = send(value)
+                value = 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
+        value = e.value
+        val_type = type(value)
+        if issubclass(val_type, (Yield, YieldFrom)):
+            value = value.value
+        if isawaitable(value):
+            value = await value
+        elif isinstance(value, GenStepIter):
+            async for el in _run_gen_step_async_iter(value.value, value.max_depth):
+                yield el
+        elif isinstance(value, GenStep):
+            value = await _run_gen_step_async(value.value, value.max_depth)
+        elif drive_generator and isinstance(value, Generator):
+            value = await _run_gen_step_async(value, dgen)
+        if val_type is Yield:
+            yield value
+        elif val_type is YieldFrom:
+            if isinstance(value, AsyncIterable):
+                async for el in value:
+                    yield el
             else:
-                for e in value:
-                    yield e
-        elif isawaitable(val):
-            await val
+                for el in value:
+                    yield el
     finally:
         gen.close()
 

{python_iterutils-0.2.5.5 → python_iterutils-0.2.7}/pyproject.toml

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