python-iterutils 0.2.4.1__tar.gz → 0.2.5.1__tar.gz

{python_iterutils-0.2.4.1 → python_iterutils-0.2.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-iterutils
-Version: 0.2.4.1
+Version: 0.2.5.1
 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.1.2)
+Requires-Dist: python-asynctools (>=0.1.3.4)
 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.1 → python_iterutils-0.2.5.1}/iterutils/__init__.py

@@ -2,13 +2,14 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 2, 4)
+__version__ = (0, 2, 5)
 __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", "chunked", 
-    "foreach", "async_foreach", "through", "async_through", 
+    "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", 
@@ -30,7 +31,7 @@ from contextlib import (
 )
 from copy import copy
 from dataclasses import dataclass
-from itertools import batched, pairwise
+from itertools import batched, chain as _chain, pairwise
 from inspect import isawaitable, iscoroutinefunction, signature
 from sys import _getframe, exc_info
 from _thread import start_new_thread
@@ -42,7 +43,7 @@ from typing import (
 
 from asynctools import (
     async_filter, async_map, async_reduce, async_zip, async_batched, 
-    ensure_async, ensure_aiter, collect as async_collect, 
+    ensure_async, ensure_aiter, async_chain, collect as async_collect, 
 )
 from texttools import format_time
 from undefined import undefined
@@ -338,7 +339,7 @@ def split_cm[T](
             finally:
                 yield exit()
 
-        run_gen_step(gen_step, async_=async_)
+        run_gen_step(gen_step, async_)
     """
     if isinstance(cm, AbstractAsyncContextManager):
         enter: Callable = cm.__aenter__
@@ -389,7 +390,7 @@ def with_iter_next[T](
                     e = yield do_next()
                     do_what_you_want()
 
-        run_gen_step(gen_step, async_=async_)
+        run_gen_step(gen_step, async_)
     """
     if isinstance(iterable, AsyncIterable):
         try:
@@ -408,17 +409,21 @@ def map(
     iterable: Iterable | AsyncIterable, 
     /, 
     *iterables: Iterable | AsyncIterable, 
+    threaded: bool = False, 
 ):
     """
     """
     if (
+        threaded or
         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)
+                return async_zip(iterable, *iterables, threaded=threaded)
+            elif threaded:
+                return ensure_aiter(iterable, threaded=threaded)
             else:
                 return iterable
         return async_map(function, iterable, *iterables)
@@ -434,11 +439,12 @@ def filter(
     function: None | Callable, 
     iterable: Iterable | AsyncIterable, 
     /, 
+    threaded: bool = False, 
 ):
     """
     """
-    if iscoroutinefunction(function) or isinstance(iterable, AsyncIterable):
-        return async_filter(function, iterable)
+    if threaded or iscoroutinefunction(function) or isinstance(iterable, AsyncIterable):
+        return async_filter(function, iterable, threaded=threaded)
     return _filter(function, iterable)
 
 
@@ -447,11 +453,12 @@ def reduce(
     iterable: Iterable | AsyncIterable, 
     initial: Any = undefined, 
     /, 
+    threaded: bool = False, 
 ):
     """
     """
-    if iscoroutinefunction(function) or isinstance(iterable, AsyncIterable):
-        return async_reduce(function, iterable, initial)
+    if threaded or iscoroutinefunction(function) or isinstance(iterable, AsyncIterable):
+        return async_reduce(function, iterable, initial, threaded=threaded)
     from functools import reduce
     if initial is undefined:
         return reduce(function, iterable)
@@ -462,19 +469,80 @@ def zip(
     iterable: Iterable | AsyncIterable, 
     /, 
     *iterables: Iterable | AsyncIterable, 
+    threaded: bool = False, 
 ):
     """
     """
-    if isinstance(iterable, AsyncIterable) or any(isinstance(i, AsyncIterable) for i in iterables):
-        return async_zip(iterable, *iterables)
+    if threaded or isinstance(iterable, AsyncIterable) or any(isinstance(i, AsyncIterable) for i in iterables):
+        return async_zip(iterable, *iterables, threaded=threaded)
     return _zip(iterable, *iterables)
 
 
+@overload
+def chain[T](
+    iterable: Iterable[T], 
+    /, 
+    *iterables: Iterable[T], 
+    threaded: bool = False, 
+) -> Iterator[T]:
+    ...
+@overload
+def chain[T](
+    iterable: AsyncIterable[T], 
+    /, 
+    *iterables: Iterable[T] | AsyncIterable[T], 
+    threaded: bool = False, 
+) -> AsyncIterator[T]:
+    ...
+def chain[T](
+    iterable: Iterable[T] | AsyncIterable[T], 
+    /, 
+    *iterables: Iterable[T] | AsyncIterable[T], 
+    threaded: bool = False, 
+) -> Iterator[T] | AsyncIterator[T]:
+    if threaded or not isinstance(iterable, Iterable):
+        return async_chain(iterable, *iterables, threaded=threaded)
+    return _chain(iterable, *iterables) # type: ignore
+
+
+@overload
+def chain_from_iterable[T](
+    iterables: Iterable[Iterable[T]], 
+    threaded: Literal[False] = False, 
+    *, 
+    async_: Literal[False] = False, 
+) -> Iterator[T]:
+    ...
+@overload
+def chain_from_iterable[T](
+    iterables: Iterable[Iterable[T] | AsyncIterable[T]] | AsyncIterable[Iterable[T] | AsyncIterable[T]], 
+    threaded: bool = False, 
+    *, 
+    async_: Literal[True], 
+) -> AsyncIterator[T]:
+    ...
+def chain_from_iterable[T](
+    iterables: Iterable[Iterable[T]] | Iterable[Iterable[T] | AsyncIterable[T]] | AsyncIterable[Iterable[T] | AsyncIterable[T]], 
+    threaded: bool = False, 
+    *, 
+    async_: Literal[False, True] = False, 
+) -> Iterator[T] | AsyncIterator[T]:
+    if async_ or threaded or not isinstance(iterables, Iterable):
+        if isinstance(iterables, Iterable):
+            return async_chain.from_iterable(iterables, threaded=threaded)
+        else:
+            return async_chain.from_iterable(iterables, threaded=threaded)
+    return _chain.from_iterable(iterables) # type: ignore
+
+setattr(chain, "from_iterable", chain_from_iterable)
+
+
 @overload
 def chunked[T](
     iterable: Iterable[T], 
     n: int = 1, 
     /, 
+    threaded: bool = False, 
 ) -> Iterator[Sequence[T]]:
     ...
 @overload
@@ -482,12 +550,14 @@ def chunked[T](
     iterable: AsyncIterable[T], 
     n: int = 1, 
     /, 
+    threaded: bool = False, 
 ) -> AsyncIterator[Sequence[T]]:
     ...
 def chunked[T](
     iterable: Iterable[T] | AsyncIterable[T], 
     n: int = 1, 
     /, 
+    threaded: bool = False, 
 ) -> Iterator[Sequence[T]] | AsyncIterator[Sequence[T]]:
     """
     """
@@ -497,10 +567,10 @@ def chunked[T](
         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):
+    elif not threaded and isinstance(iterable, Iterable):
         return batched(iterable, n)
     else:
-        return async_batched(iterable, n)
+        return async_batched(iterable, n, threaded=threaded)
 
 
 def foreach(
@@ -508,11 +578,12 @@ def foreach(
     iterable: Iterable | AsyncIterable, 
     /, 
     *iterables: Iterable | AsyncIterable, 
+    threaded: bool = False, 
 ):
     """
     """
-    if not (isinstance(iterable, Iterable) and all(isinstance(it, Iterable) for it in iterables)):
-        return async_foreach(value, iterable, *iterables)
+    if threaded or not (isinstance(iterable, Iterable) and all(isinstance(it, Iterable) for it in iterables)):
+        return async_foreach(value, iterable, *iterables, threaded=threaded)
     if iterables:
         for args in _zip(iterable, *iterables):
             value(*args)
@@ -543,11 +614,12 @@ def through(
     iterable: Iterable | AsyncIterable, 
     /, 
     take_while: None | Callable = None, 
+    threaded: bool = False, 
 ):
     """
     """
-    if not isinstance(iterable, Iterable):
-        return async_through(iterable, take_while)
+    if threaded or not isinstance(iterable, Iterable):
+        return async_through(iterable, take_while, threaded=threaded)
     if take_while is None:
         for _ in iterable:
             pass
@@ -584,6 +656,7 @@ def flatten(
     iterable: Iterable, 
     /, 
     exclude_types: type | tuple[type, ...] = (Buffer, str), 
+    threaded: bool = False, 
 ) -> Iterator:
     ...
 @overload
@@ -591,17 +664,19 @@ def flatten(
     iterable: AsyncIterable, 
     /, 
     exclude_types: type | tuple[type, ...] = (Buffer, str), 
+    threaded: bool = False, 
 ) -> AsyncIterator:
     ...
 def flatten(
     iterable: Iterable | AsyncIterable, 
     /, 
     exclude_types: type | tuple[type, ...] = (Buffer, str), 
+    threaded: bool = False, 
 ) -> Iterator | AsyncIterator:
     """
     """
-    if not isinstance(iterable, Iterable):
-        return async_flatten(iterable, exclude_types)
+    if threaded or not isinstance(iterable, Iterable):
+        return async_flatten(iterable, exclude_types, threaded=threaded)
     def gen(iterable):
         for e in iterable:
             if isinstance(e, (Iterable, AsyncIterable)) and not isinstance(e, exclude_types):
@@ -632,6 +707,7 @@ def collect[K, V](
     iterable: Iterable[tuple[K, V]] | Mapping[K, V], 
     /, 
     rettype: Callable[[Iterable[tuple[K, V]]], MutableMapping[K, V]], 
+    threaded: bool = False, 
 ) -> MutableMapping[K, V]:
     ...
 @overload
@@ -639,6 +715,7 @@ def collect[T](
     iterable: Iterable[T], 
     /, 
     rettype: Callable[[Iterable[T]], Collection[T]] = list, 
+    threaded: bool = False, 
 ) -> Collection[T]:
     ...
 @overload
@@ -646,6 +723,7 @@ def collect[K, V](
     iterable: AsyncIterable[tuple[K, V]], 
     /, 
     rettype: Callable[[Iterable[tuple[K, V]]], MutableMapping[K, V]], 
+    threaded: bool = False, 
 ) -> Coroutine[Any, Any, MutableMapping[K, V]]:
     ...
 @overload
@@ -653,17 +731,19 @@ def collect[T](
     iterable: AsyncIterable[T], 
     /, 
     rettype: Callable[[Iterable[T]], Collection[T]] = list, 
+    threaded: bool = False, 
 ) -> Coroutine[Any, Any, Collection[T]]:
     ...
 def collect(
     iterable: Iterable | AsyncIterable | Mapping, 
     /, 
     rettype: Callable[[Iterable], Collection] = list, 
+    threaded: bool = False, 
 ) -> Collection | Coroutine[Any, Any, Collection]:
     """
     """
-    if not isinstance(iterable, Iterable):
-        return async_collect(iterable, rettype)
+    if threaded or not isinstance(iterable, Iterable):
+        return async_collect(iterable, rettype, threaded=threaded)
     return rettype(iterable)
 
 
@@ -672,6 +752,7 @@ def group_collect[K, V, C: Container](
     iterable: Iterable[tuple[K, V]], 
     mapping: None = None, 
     factory: None | C | Callable[[], C] = None, 
+    threaded: bool = False, 
 ) -> dict[K, C]:
     ...
 @overload
@@ -679,6 +760,7 @@ def group_collect[K, V, C: Container, M: MutableMapping](
     iterable: Iterable[tuple[K, V]], 
     mapping: M, 
     factory: None | C | Callable[[], C] = None, 
+    threaded: bool = False, 
 ) -> M:
     ...
 @overload
@@ -686,6 +768,7 @@ def group_collect[K, V, C: Container](
     iterable: AsyncIterable[tuple[K, V]], 
     mapping: None = None, 
     factory: None | C | Callable[[], C] = None, 
+    threaded: bool = False, 
 ) -> Coroutine[Any, Any, dict[K, C]]:
     ...
 @overload
@@ -693,17 +776,19 @@ def group_collect[K, V, C: Container, M: MutableMapping](
     iterable: AsyncIterable[tuple[K, V]], 
     mapping: M, 
     factory: None | C | Callable[[], C] = None, 
+    threaded: bool = False, 
 ) -> 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, 
+    threaded: bool = False, 
 ) -> 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 threaded or not isinstance(iterable, Iterable):
+        return async_group_collect(iterable, mapping, factory, threaded=threaded)
     if factory is None:
         if isinstance(mapping, defaultdict):
             factory = mapping.default_factory
@@ -800,6 +885,7 @@ def iter_unique[T](
     iterable: Iterable[T], 
     /, 
     seen: None | MutableSet = None, 
+    threaded: bool = False, 
 ) -> Iterator[T]:
     ...
 @overload
@@ -807,17 +893,19 @@ def iter_unique[T](
     iterable: AsyncIterable[T], 
     /, 
     seen: None | MutableSet = None, 
+    threaded: bool = False, 
 ) -> AsyncIterator[T]:
     ...
 def iter_unique[T](
     iterable: Iterable[T] | AsyncIterable[T], 
     /, 
     seen: None | MutableSet = None, 
+    threaded: bool = False, 
 ) -> Iterator[T] | AsyncIterator[T]:
     """
     """
-    if not isinstance(iterable, Iterable):
-        return async_iter_unique(iterable, seen)
+    if threaded or not isinstance(iterable, Iterable):
+        return async_iter_unique(iterable, seen, threaded=threaded)
     if seen is None:
         seen = set()
     def gen(iterable):

{python_iterutils-0.2.4.1 → python_iterutils-0.2.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-iterutils"
-version = "0.2.4.1"
+version = "0.2.5.1"
 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.1.2"
+python-asynctools = ">=0.1.3.4"
 python-texttools = ">=0.0.3"
 python-undefined = ">=0.0.3"