python-iterutils 0.1.7__py3-none-any.whl → 0.1.8__py3-none-any.whl

iterutils/__init__.py

@@ -2,24 +2,26 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 1, 7)
+__version__ = (0, 1, 8)
 __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", 
+    "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 +29,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
@@ -96,7 +99,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 +130,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 +180,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 +190,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 +565,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

{python_iterutils-0.1.7.dist-info → python_iterutils-0.1.8.dist-info}/METADATA

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

@@ -0,0 +1,7 @@
+LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
+iterutils/__init__.py,sha256=zcNPBE2QtJZyGlTr4n913Zwtd2OJAiAFdvEaYIur0kw,32751
+iterutils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_iterutils-0.1.8.dist-info/LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
+python_iterutils-0.1.8.dist-info/METADATA,sha256=JuLFHrGXyrqYv-ajoNOpWuxXKAhAu9CMch5Mbscvf3E,1470
+python_iterutils-0.1.8.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+python_iterutils-0.1.8.dist-info/RECORD,,

python_iterutils-0.1.7.dist-info/RECORD

@@ -1,7 +0,0 @@
-LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
-iterutils/__init__.py,sha256=BR4ZaZouhl3o9e6ZrBLLEBRfNJzKik8Et-B38Lw_yf0,27444
-iterutils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_iterutils-0.1.7.dist-info/LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
-python_iterutils-0.1.7.dist-info/METADATA,sha256=DkEirEtm5-ycdVDBZwb_o-0poNqQDA8Gv5QfJ5o4SwA,1468
-python_iterutils-0.1.7.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-python_iterutils-0.1.7.dist-info/RECORD,,