python-iterutils 0.2.4__tar.gz → 0.2.5__tar.gz

{python_iterutils-0.2.4 → python_iterutils-0.2.5}/PKG-INFO

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

@@ -2,12 +2,12 @@
 # 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", 
+    "map", "filter", "reduce", "zip", "chain", "chunked", 
     "foreach", "async_foreach", "through", "async_through", 
     "flatten", "async_flatten", "collect", "async_collect", 
     "group_collect", "async_group_collect", "iter_unique", 
@@ -30,7 +30,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 +42,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
@@ -85,7 +85,8 @@ def _get_async(back: int = 2, /) -> bool:
         return f_locals.get("async_") or False
     while f_locals is not None and f_locals is not f_globals:
         if "async_" in f_locals:
-            return f_locals["async_"] or False
+            if f_locals["async_"] is not None:
+                return f_locals["async_"]
         f = f.f_back
         if f is None:
             break
@@ -270,8 +271,12 @@ def as_gen_step[**Args](
     /, 
 ) -> Callable[Args, Any]:
     def wrapper(*args: Args.args, **kwds: Args.kwargs):
-        async_ = cast(None | Literal[False, True], kwds.pop("async_", None))
-        return run_gen_step(gen_step, async_, *args, **kwds)
+        return run_gen_step(
+            gen_step, 
+            cast(None | Literal[False, True], kwds.pop("async_", None)), 
+            *args, 
+            **kwds, 
+        )
     return wrapper
 
 
@@ -280,8 +285,12 @@ def as_gen_step_iter[**Args](
     /, 
 ) -> Callable[Args, Iterable | AsyncIterable]:
     def wrapper(*args: Args.args, **kwds: Args.kwargs):
-        async_ = cast(None | Literal[False, True], kwds.pop("async_", None))
-        return run_gen_step_iter(gen_step, async_, *args, **kwds)
+        return run_gen_step_iter(
+            gen_step, 
+            cast(None | Literal[False, True], kwds.pop("async_", None)), 
+            *args, 
+            **kwds, 
+        )
     return wrapper
 
 
@@ -329,7 +338,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__
@@ -380,7 +389,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:
@@ -399,17 +408,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)
@@ -425,11 +438,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)
 
 
@@ -438,11 +452,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)
@@ -453,19 +468,78 @@ 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
+
+
 @overload
 def chunked[T](
     iterable: Iterable[T], 
     n: int = 1, 
     /, 
+    threaded: bool = False, 
 ) -> Iterator[Sequence[T]]:
     ...
 @overload
@@ -473,12 +547,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]]:
     """
     """
@@ -488,10 +564,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(
@@ -499,11 +575,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)
@@ -534,11 +611,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
@@ -575,6 +653,7 @@ def flatten(
     iterable: Iterable, 
     /, 
     exclude_types: type | tuple[type, ...] = (Buffer, str), 
+    threaded: bool = False, 
 ) -> Iterator:
     ...
 @overload
@@ -582,17 +661,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):
@@ -623,6 +704,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
@@ -630,6 +712,7 @@ def collect[T](
     iterable: Iterable[T], 
     /, 
     rettype: Callable[[Iterable[T]], Collection[T]] = list, 
+    threaded: bool = False, 
 ) -> Collection[T]:
     ...
 @overload
@@ -637,6 +720,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
@@ -644,17 +728,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)
 
 
@@ -663,6 +749,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
@@ -670,6 +757,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
@@ -677,6 +765,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
@@ -684,17 +773,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
@@ -791,6 +882,7 @@ def iter_unique[T](
     iterable: Iterable[T], 
     /, 
     seen: None | MutableSet = None, 
+    threaded: bool = False, 
 ) -> Iterator[T]:
     ...
 @overload
@@ -798,17 +890,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 → python_iterutils-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-iterutils"
-version = "0.2.4"
+version = "0.2.5"
 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"