python-iterutils 0.1.7__tar.gz → 0.1.9__tar.gz

{python_iterutils-0.1.7 → python_iterutils-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-iterutils
-Version: 0.1.7
+Version: 0.1.9
 Summary: Python another itertools.
 Home-page: https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-iterutils
 License: MIT
@@ -20,7 +20,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: python-asynctools (>=0.0.10)
+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)

{python_iterutils-0.1.7 → python_iterutils-0.1.9}/iterutils/__init__.py

@@ -2,24 +2,27 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 1, 7)
+__version__ = (0, 1, 9)
 __all__ = [
     "Return", "Yield", "YieldFrom", "iterable", "async_iterable", "foreach", "async_foreach", 
-    "through", "async_through", "flatten", "async_flatten", "map", "filter", "reduce", "zip", 
-    "chunked", "iter_unique", "async_iter_unique", "wrap_iter", "wrap_aiter", "acc_step", 
-    "cut_iter", "run_gen_step", "run_gen_step_iter", "as_gen_step", "bfs_gen", "with_iter_next", 
-    "backgroud_loop", 
+    "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
 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 deque
+from collections import defaultdict, deque
 from collections.abc import (
-    AsyncIterable, AsyncIterator, Awaitable, Buffer, Callable, Coroutine, Generator, 
-    Iterable, Iterator, MutableSet, Sequence, 
+    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 copy import copy
 from dataclasses import dataclass
 from itertools import batched, pairwise
 from inspect import isawaitable, iscoroutinefunction
@@ -27,10 +30,11 @@ from sys import _getframe
 from _thread import start_new_thread
 from time import sleep, time
 from types import FrameType
-from typing import overload, Any, AsyncContextManager, ContextManager, Literal
+from typing import cast, overload, Any, AsyncContextManager, ContextManager, Literal
 
 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
@@ -49,6 +53,12 @@ class YieldBase(ABC):
         ...
 
 
+class Reraised(BaseException):
+
+    def __init__(self, exc: BaseException, /):
+        self.exception = exc
+
+
 class Return(YieldBase):
     yield_type = 0
 
@@ -96,7 +106,7 @@ async def async_foreach(
     iterable: Iterable | AsyncIterable, 
     /, 
     *iterables: Iterable | AsyncIterable, 
-    threaded: bool = True, 
+    threaded: bool = False, 
 ):
     value = ensure_async(value, threaded=threaded)
     if iterables:
@@ -127,7 +137,7 @@ async def async_through(
     iterable: Iterable | AsyncIterable, 
     /, 
     take_while: None | Callable = None, 
-    threaded: bool = True, 
+    threaded: bool = False, 
 ):
     iterable = ensure_aiter(iterable, threaded=threaded)
     if take_while is None:
@@ -177,7 +187,7 @@ async def async_flatten(
     iterable: Iterable | AsyncIterable, 
     /, 
     exclude_types: type | tuple[type, ...] = (Buffer, str), 
-    threaded: bool = True, 
+    threaded: bool = False, 
 ) -> AsyncIterator:
     async for e in ensure_aiter(iterable, threaded=threaded):
         if isinstance(e, (Iterable, AsyncIterable)) and not isinstance(e, exclude_types):
@@ -187,6 +197,168 @@ async def async_flatten(
             yield e
 
 
+@overload
+def collect[K, V](
+    iterable: Iterable[tuple[K, V]] | Mapping[K, V], 
+    /, 
+    rettype: Callable[[Iterable[tuple[K, V]]], MutableMapping[K, V]], 
+) -> MutableMapping[K, V]:
+    ...
+@overload
+def collect[T](
+    iterable: Iterable[T], 
+    /, 
+    rettype: Callable[[Iterable[T]], Collection[T]] = list, 
+) -> Collection[T]:
+    ...
+@overload
+def collect[K, V](
+    iterable: AsyncIterable[tuple[K, V]], 
+    /, 
+    rettype: Callable[[Iterable[tuple[K, V]]], MutableMapping[K, V]], 
+) -> Coroutine[Any, Any, MutableMapping[K, V]]:
+    ...
+@overload
+def collect[T](
+    iterable: AsyncIterable[T], 
+    /, 
+    rettype: Callable[[Iterable[T]], Collection[T]] = list, 
+) -> Coroutine[Any, Any, Collection[T]]:
+    ...
+def collect(
+    iterable: Iterable | AsyncIterable | Mapping, 
+    /, 
+    rettype: Callable[[Iterable], Collection] = list, 
+) -> Collection | Coroutine[Any, Any, Collection]:
+    if not isinstance(iterable, Iterable):
+        return async_collect(iterable, rettype)
+    return rettype(iterable)
+
+
+@overload
+def group_collect[K, V, C: Container](
+    iterable: Iterable[tuple[K, V]], 
+    mapping: None = None, 
+    factory: None | C | Callable[[], C] = None, 
+) -> dict[K, C]:
+    ...
+@overload
+def group_collect[K, V, C: Container, M: MutableMapping](
+    iterable: Iterable[tuple[K, V]], 
+    mapping: M, 
+    factory: None | C | Callable[[], C] = None, 
+) -> M:
+    ...
+@overload
+def group_collect[K, V, C: Container](
+    iterable: AsyncIterable[tuple[K, V]], 
+    mapping: None = None, 
+    factory: None | C | Callable[[], C] = None, 
+) -> Coroutine[Any, Any, dict[K, C]]:
+    ...
+@overload
+def group_collect[K, V, C: Container, M: MutableMapping](
+    iterable: AsyncIterable[tuple[K, V]], 
+    mapping: M, 
+    factory: None | C | Callable[[], C] = None, 
+) -> Coroutine[Any, Any, M]:
+    ...
+def group_collect[K, V, C: Container, M: MutableMapping](
+    iterable: Iterable[tuple[K, V]] | AsyncIterable[tuple[K, V]], 
+    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:
+        if isinstance(mapping, defaultdict):
+            factory = mapping.default_factory
+        elif mapping:
+            factory = type(next(iter(ValuesView(mapping))))
+        else:
+            factory = cast(type[C], list)
+    elif callable(factory):
+        pass
+    elif isinstance(factory, Container):
+        factory = cast(Callable[[], C], lambda _obj=factory: copy(_obj))
+    else:
+        raise ValueError("can't determine factory")
+    factory = cast(Callable[[], C], factory)
+    if isinstance(factory, type):
+        factory_type = factory
+    else:
+        factory_type = type(factory())
+    if issubclass(factory_type, MutableSequence):
+        add = getattr(factory_type, "append")
+    else:
+        add = getattr(factory_type, "add")
+    if mapping is None:
+        mapping = cast(M, {})
+    for k, v in iterable:
+        try:
+            c = mapping[k]
+        except LookupError:
+            c = mapping[k] = factory()
+        add(c, v)
+    return mapping
+
+
+@overload
+async def async_group_collect[K, V, C: Container](
+    iterable: Iterable[tuple[K, V]] | AsyncIterable[tuple[K, V]], 
+    mapping: None = None, 
+    factory: None | C | Callable[[], C] = None, 
+    threaded: bool = False, 
+) -> dict[K, C]:
+    ...
+@overload
+async def async_group_collect[K, V, C: Container, M: MutableMapping](
+    iterable: Iterable[tuple[K, V]] | AsyncIterable[tuple[K, V]], 
+    mapping: M, 
+    factory: None | C | Callable[[], C] = None, 
+    threaded: bool = False, 
+) -> M:
+    ...
+async def async_group_collect[K, V, C: Container, M: MutableMapping](
+    iterable: Iterable[tuple[K, V]] | AsyncIterable[tuple[K, V]], 
+    mapping: None | M = None, 
+    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):
+            factory = mapping.default_factory
+        elif mapping:
+            factory = type(next(iter(ValuesView(mapping))))
+        else:
+            factory = cast(type[C], list)
+    elif callable(factory):
+        pass
+    elif isinstance(factory, Container):
+        factory = cast(Callable[[], C], lambda _obj=factory: copy(_obj))
+    else:
+        raise ValueError("can't determine factory")
+    factory = cast(Callable[[], C], factory)
+    if isinstance(factory, type):
+        factory_type = factory
+    else:
+        factory_type = type(factory())
+    if issubclass(factory_type, MutableSequence):
+        add = getattr(factory_type, "append")
+    else:
+        add = getattr(factory_type, "add")
+    if mapping is None:
+        mapping = cast(M, {})
+    async for k, v in iterable:
+        try:
+            c = mapping[k]
+        except LookupError:
+            c = mapping[k] = factory()
+        add(c, v)
+    return mapping
+
+
 def map(
     function: None | Callable, 
     iterable: Iterable | AsyncIterable, 
@@ -400,7 +572,7 @@ async def wrap_aiter[T](
     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 = True, 
+    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
@@ -471,110 +643,124 @@ def _get_async(back: int = 2) -> bool:
     return False
 
 
-def run_gen_step[T](
-    gen_step: Generator[Any, Any, T] | Callable[[], Generator[Any, Any, T]], 
-    *, 
-    async_: None | bool = None, 
-    threaded: bool = False, 
-    as_iter: bool = False, 
-) -> T:
-    if async_ is None:
-        async_ = _get_async()
+def iter_gen_step(
+    gen_step: Generator | Callable[[], Generator], 
+):
     if callable(gen_step):
         gen = gen_step()
-        close = gen.close
     else:
         gen = gen_step
-        close = None
     send = gen.send
     throw = gen.throw
-    if async_:
-        async def process():
+    close = gen.close
+    try:
+        value = send(None)
+        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:
+        value = e.value
+        try_call_me = True
+        if isinstance(value, YieldBase):
+            try_call_me = value.try_call_me
+            value = value.value
+        if callable(value) and try_call_me:
+            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], 
+    threaded: bool = False, 
+):
+    if callable(gen_step):
+        gen = gen_step()
+    else:
+        gen = gen_step
+    send = ensure_async(gen.send, threaded=threaded)
+    throw = ensure_async(gen.throw, threaded=threaded)
+    close = ensure_async(gen.close, threaded=threaded)
+    try:
+        value = await send(None)
+        while True:
+            if isinstance(value, YieldBase):
+                raise StopIteration(value)
             try:
+                if callable(value):
+                    value = await ensure_async(value, threaded=threaded)()
+            except BaseException as e:
+                value = await throw(e)
+            else:
+                value = await send(value)
+            yield value
+    except StopIteration as e:
+        value = e.value
+        identity = False
+        try_call_me = True
+        if isinstance(value, YieldBase):
+            identity = value.identity
+            try_call_me = value.try_call_me
+            value = value.value
+        try:
+            if callable(value) and try_call_me:
                 if threaded:
-                    value = await to_thread(send, None)
+                    value = await to_thread(value)
                 else:
-                    value = send(None)
-                while True:
-                    if isinstance(value, YieldBase):
-                        raise StopIteration(value)
-                    try:
-                        if callable(value):
-                            value = value()
-                        if isawaitable(value):
-                            value = await value
-                    except BaseException as e:
-                        if threaded:
-                            value = await to_thread(throw, e)
-                        else:
-                            value = throw(e)
-                    else:
-                        if threaded:
-                            value = await to_thread(send, value)
-                        else:
-                            value = send(value)
-            except StopIteration as e:
-                value = e.value
-                identity = False
-                try_call_me = True
-                if isinstance(value, YieldBase):
-                    identity = value.identity
-                    try_call_me = value.try_call_me
-                    value = value.value
-                if callable(value) and try_call_me:
                     value = value()
-                if not identity and isawaitable(value):
-                    value = await value
+            if not identity 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
+    except StopAsyncIteration as e:
+        raise Reraised(e) from e
+    finally:
+        await close()
+
+
+def run_gen_step[T](
+    gen_step: Generator | Callable[[], Generator], 
+    *, 
+    async_: None | bool = None, 
+    threaded: bool = False, 
+):
+    if async_ is None:
+        async_ = _get_async()
+    if async_:
+        async def process():
+            try:
+                async for value in iter_gen_step_async(gen_step, threaded=threaded):
+                    pass
                 return value
-            finally:
-                if close is not None:
-                    if threaded:
-                        await to_thread(close)
-                    else:
-                        close()
-        result = process()
-        if as_iter:
-            async def wrap(result):
-                iterable = await result
-                try:
-                    iterable = aiter(iterable)
-                except TypeError:
-                    for val in iter(iterable):
-                        if isawaitable(val):
-                            val = await val
-                        yield val
-                else:
-                    async for val in iterable:
-                        yield val
-            result = wrap(result)
-        return result
+            except Reraised as e:
+                raise e.exception
+        return process()
     else:
         try:
-            value = send(None)
-            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)
-        except StopIteration as e:
-            value = e.value
-            try_call_me = True
-            if isinstance(value, YieldBase):
-                try_call_me = value.try_call_me
-                value = value.value
-            if callable(value) and try_call_me:
-                value = value()
-            if as_iter:
-                value = iter(value)
+            for value in iter_gen_step(gen_step):
+                pass
             return value
-        finally:
-            if close is not None:
-                close()
+        except Reraised as e:
+            raise e.exception
 
 
 @overload
@@ -611,12 +797,11 @@ def run_gen_step_iter(
         async_ = _get_async()
     if callable(gen_step):
         gen = gen_step()
-        close = gen.close
     else:
         gen = gen_step
-        close = None
     send = gen.send
     throw = gen.throw
+    close = gen.close
     if async_:
         async def process():
             async def extract(value):
@@ -658,19 +843,24 @@ def run_gen_step_iter(
                         else:
                             value = send(value)
             except StopIteration as e:
-                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
-            finally:
-                if close is not None:
+                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 threaded:
-                        await to_thread(close)
+                        await to_thread(throw, e)
                     else:
-                        close()
+                        throw(e)
+            finally:
+                if threaded:
+                    await to_thread(close)
+                else:
+                    close()
     else:
         def process():
             def extract(value, /):
@@ -700,17 +890,19 @@ def run_gen_step_iter(
                     else:
                         value = send(value)
             except StopIteration as e:
-                yield_type, value = extract(e.value)
-                match yield_type:
-                    case 1:
-                        yield value
-                    case 2:
-                        yield from value
-                    case _:
-                        return value
+                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:
-                if close is not None:
-                    close()
+                close()
     return process()
 
 

{python_iterutils-0.1.7 → python_iterutils-0.1.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-iterutils"
-version = "0.1.7"
+version = "0.1.9"
 description = "Python another itertools."
 authors = ["ChenyangGao <wosiwujm@gmail.com>"]
 license = "MIT"
@@ -27,7 +27,7 @@ include = [
 
 [tool.poetry.dependencies]
 python = "^3.12"
-python-asynctools = ">=0.0.10"
+python-asynctools = ">=0.1.2"
 python-decotools = ">=0.0.2"
 python-texttools = ">=0.0.3"
 python-undefined = ">=0.0.3"