dycw-utilities 0.166.25__tar.gz → 0.166.27__tar.gz

{dycw_utilities-0.166.25 → dycw_utilities-0.166.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.166.25
+Version: 0.166.27
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -13,11 +13,11 @@ Requires-Dist: coloredlogs<15.1,>=15.0.1; extra == 'logging'
 Provides-Extra: test
 Requires-Dist: dycw-pytest-only<2.2,>=2.1.1; extra == 'test'
 Requires-Dist: hypothesis<6.139,>=6.138.15; extra == 'test'
-Requires-Dist: pytest-asyncio<1.2,>=1.1.0; extra == 'test'
+Requires-Dist: pytest-asyncio<1.2,>=1.1.1; extra == 'test'
 Requires-Dist: pytest-cov<7.1,>=7.0.0; extra == 'test'
 Requires-Dist: pytest-instafail<0.6,>=0.5.0; extra == 'test'
 Requires-Dist: pytest-lazy-fixtures<1.4,>=1.3.4; extra == 'test'
-Requires-Dist: pytest-randomly<4.1,>=4.0.0; extra == 'test'
+Requires-Dist: pytest-randomly<4.1,>=4.0.1; extra == 'test'
 Requires-Dist: pytest-regressions<2.9,>=2.8.3; extra == 'test'
 Requires-Dist: pytest-repeat<0.10,>=0.9.4; extra == 'test'
 Requires-Dist: pytest-rerunfailures<16.1,>=16.0.1; extra == 'test'

{dycw_utilities-0.166.25 → dycw_utilities-0.166.27}/pyproject.toml

@@ -161,8 +161,8 @@ pyinstrument = [
 ]
 pytest = [
   "pytest >=8.4.2, <8.5",
-  "pytest-asyncio >=1.1.0, <1.2",
-  "pytest-randomly >=4.0.0, <4.1",
+  "pytest-asyncio >=1.1.1, <1.2",
+  "pytest-randomly >=4.0.1, <4.1",
   "pytest-timeout >=2.4.0, <2.5",
   "pytest-xdist >=3.8.0, <3.9",
 ]
@@ -189,7 +189,7 @@ reprlib-test = [
   "rich",
 ]
 scipy = [
-  "scipy >=1.16.0, <1.17",
+  "scipy >=1.16.2, <1.17",
 ]
 sklearn = [
   "scikit-learn >=1.7.2, <1.8",
@@ -246,7 +246,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.166.25"
+version = "0.166.27"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -260,11 +260,11 @@ test = [
   "dycw-pytest-only >=2.1.1, <2.2",
   "hypothesis >=6.138.15, <6.139",
   "pytest >=8.4.2, <8.5",
-  "pytest-asyncio >=1.1.0, <1.2",
+  "pytest-asyncio >=1.1.1, <1.2",
   "pytest-cov >=7.0.0, <7.1",
   "pytest-instafail >=0.5.0, <0.6",
   "pytest-lazy-fixtures >=1.3.4, <1.4",
-  "pytest-randomly >=4.0.0, <4.1",
+  "pytest-randomly >=4.0.1, <4.1",
   "pytest-regressions >=2.8.3, <2.9",
   "pytest-repeat >=0.9.4, <0.10",
   "pytest-rerunfailures >=16.0.1, <16.1",
@@ -279,7 +279,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.166.25"
+current_version = "0.166.27"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.166.25 → dycw_utilities-0.166.27}/src/tests/test_asyncio.py

@@ -1,21 +1,26 @@
 from __future__ import annotations
 
+import re
 from asyncio import Queue, run
-from collections.abc import ItemsView, KeysView, ValuesView
+from collections.abc import AsyncIterable, ItemsView, Iterable, KeysView, ValuesView
 from contextlib import asynccontextmanager
-from re import search
-from typing import TYPE_CHECKING, ClassVar
+from re import DOTALL, search
+from typing import TYPE_CHECKING, Any, ClassVar
 
 from hypothesis import HealthCheck, given, settings
-from hypothesis.strategies import booleans, dictionaries, integers, lists, none
-from pytest import RaisesGroup, raises
+from hypothesis.strategies import booleans, dictionaries, integers, lists, none, sets
+from pytest import RaisesGroup, mark, param, raises
 
 from utilities.asyncio import (
     AsyncDict,
     EnhancedTaskGroup,
+    OneAsyncEmptyError,
+    OneAsyncNonUniqueError,
+    chain_async,
     get_coroutine_name,
     get_items,
     get_items_nowait,
+    one_async,
     put_items,
     put_items_nowait,
     sleep_max,
@@ -188,6 +193,26 @@ class TestAsyncDict:
             assert isinstance(value, int)
 
 
+class TestChainAsync:
+    @given(n=integers(0, 10))
+    async def test_sync(self, *, n: int) -> None:
+        it = chain_async(range(n))
+        result = [x async for x in it]
+        expected = list(range(n))
+        assert result == expected
+
+    @given(n=integers(0, 10))
+    async def test_async(self, *, n: int) -> None:
+        async def range_async(n: int, /) -> AsyncIterator[int]:
+            for i in range(n):
+                yield i
+
+        it = chain_async(range_async(n))
+        result = [x async for x in it]
+        expected = list(range(n))
+        assert result == expected
+
+
 class TestEnhancedTaskGroup:
     delta: ClassVar[TimeDelta] = 0.05 * SECOND
 
@@ -317,6 +342,40 @@ class TestGetItems:
         assert result == xs[:max_size]
 
 
+class TestOneAsync:
+    @mark.parametrize(
+        "args", [param(([None],)), param(([None], [])), param(([None], [], []))]
+    )
+    async def test_main(self, *, args: tuple[Iterable[Any], ...]) -> None:
+        assert await one_async(*map(self._lift, args)) is None
+
+    @mark.parametrize("args", [param([]), param(([], [])), param(([], [], []))])
+    async def test_error_empty(self, *, args: tuple[Iterable[Any], ...]) -> None:
+        with raises(
+            OneAsyncEmptyError,
+            match=re.compile(r"Iterable\(s\) .* must not be empty", flags=DOTALL),
+        ):
+            _ = await one_async(*map(self._lift, args))
+
+    @given(iterable=sets(integers(), min_size=2))
+    async def test_error_non_unique(self, *, iterable: set[int]) -> None:
+        with raises(
+            OneAsyncNonUniqueError,
+            match=re.compile(
+                r"Iterable\(s\) .* must contain exactly one item; got .*, .* and perhaps more",
+                flags=DOTALL,
+            ),
+        ):
+            _ = await one_async(iterable)
+
+    def _lift[T](self, iterable: Iterable[T], /) -> AsyncIterable[T]:
+        async def lifted() -> AsyncIterator[Any]:
+            for i in iterable:
+                yield i
+
+        return lifted()
+
+
 class TestPutItems:
     @given(xs=lists(integers(), min_size=1), wait=booleans())
     async def test_main(self, *, xs: list[int], wait: bool) -> None:

{dycw_utilities-0.166.25 → dycw_utilities-0.166.27}/src/tests/test_iterables.py

@@ -885,11 +885,13 @@ class TestMergeStrMappings:
 
 
 class TestOne:
-    @given(args=sampled_from([([None],), ([None], []), ([None], [], [])]))
+    @mark.parametrize(
+        "args", [param(([None],)), param(([None], [])), param(([None], [], []))]
+    )
     def test_main(self, *, args: tuple[Iterable[Any], ...]) -> None:
         assert one(*args) is None
 
-    @given(args=sampled_from([([],), ([], []), ([], [], [])]))
+    @mark.parametrize("args", [param([]), param(([], [])), param(([], [], []))])
     def test_error_empty(self, *, args: tuple[Iterable[Any], ...]) -> None:
         with raises(OneEmptyError, match=r"Iterable\(s\) .* must not be empty"):
             _ = one(*args)
@@ -907,20 +909,21 @@ class TestOne:
 
 
 class TestOneMaybe:
-    @given(
-        args=sampled_from([
-            (None,),
-            ([None],),
-            (None, []),
-            ([None], []),
-            (None, []),
-            ([None], [], []),
-        ])
+    @mark.parametrize(
+        "args",
+        [
+            param((None,)),
+            param(([None],)),
+            param((None, [])),
+            param(([None], [])),
+            param((None, [], [])),
+            param(([None], [], [])),
+        ],
     )
     def test_main(self, *, args: tuple[MaybeIterable[Any], ...]) -> None:
         assert one_maybe(*args) is None
 
-    @given(args=sampled_from([([],), ([], []), ([], [], [])]))
+    @mark.parametrize("args", [param([]), param(([], [])), param(([], [], []))])
     def test_error_empty(self, *, args: tuple[MaybeIterable[Any], ...]) -> None:
         with raises(OneMaybeEmptyError, match=r"Object\(s\) must not be empty"):
             _ = one_maybe(*args)

{dycw_utilities-0.166.25 → dycw_utilities-0.166.27}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.166.25"
+__version__ = "0.166.27"

{dycw_utilities-0.166.25 → dycw_utilities-0.166.27}/src/utilities/asyncio.py

@@ -31,6 +31,7 @@ from typing import (
     Self,
     TextIO,
     assert_never,
+    cast,
     overload,
     override,
 )
@@ -38,6 +39,7 @@ from typing import (
 from utilities.functions import ensure_int, ensure_not_none
 from utilities.os import is_pytest
 from utilities.random import SYSTEM_RANDOM
+from utilities.reprlib import get_repr
 from utilities.sentinel import Sentinel, sentinel
 from utilities.shelve import yield_shelf
 from utilities.text import to_bool
@@ -48,6 +50,7 @@ if TYPE_CHECKING:
     from asyncio import _CoroutineLike
     from asyncio.subprocess import Process
     from collections.abc import (
+        AsyncIterable,
         AsyncIterator,
         Callable,
         ItemsView,
@@ -346,6 +349,24 @@ class EnhancedTaskGroup(TaskGroup):
 ##
 
 
+def chain_async[T](*iterables: Iterable[T] | AsyncIterable[T]) -> AsyncIterator[T]:
+    """Asynchronous version of `chain`."""
+
+    async def iterator() -> AsyncIterator[T]:
+        for it in iterables:
+            try:
+                async for item in cast("AsyncIterable[T]", it):
+                    yield item
+            except TypeError:
+                for item in cast("Iterable[T]", it):
+                    yield item
+
+    return iterator()
+
+
+##
+
+
 def get_coroutine_name(func: Callable[[], Coro[Any]], /) -> str:
     """Get the name of a coroutine, and then dispose of it gracefully."""
     coro = func()
@@ -394,6 +415,43 @@ def get_items_nowait[T](queue: Queue[T], /, *, max_size: int | None = None) -> l
 ##
 
 
+async def one_async[T](*iterables: Iterable[T] | AsyncIterable[T]) -> T:
+    """Asynchronous version of `one`."""
+    result: T | Sentinel = sentinel
+    async for item in chain_async(*iterables):
+        if not isinstance(result, Sentinel):
+            raise OneAsyncNonUniqueError(iterables=iterables, first=result, second=item)
+        result = item
+    if isinstance(result, Sentinel):
+        raise OneAsyncEmptyError(iterables=iterables)
+    return result
+
+
+@dataclass(kw_only=True, slots=True)
+class OneAsyncError[T](Exception):
+    iterables: tuple[Iterable[T] | AsyncIterable[T], ...]
+
+
+@dataclass(kw_only=True, slots=True)
+class OneAsyncEmptyError[T](OneAsyncError[T]):
+    @override
+    def __str__(self) -> str:
+        return f"Iterable(s) {get_repr(self.iterables)} must not be empty"
+
+
+@dataclass(kw_only=True, slots=True)
+class OneAsyncNonUniqueError[T](OneAsyncError):
+    first: T
+    second: T
+
+    @override
+    def __str__(self) -> str:
+        return f"Iterable(s) {get_repr(self.iterables)} must contain exactly one item; got {self.first}, {self.second} and perhaps more"
+
+
+##
+
+
 async def put_items[T](items: Iterable[T], queue: Queue[T], /) -> None:
     """Put items into a queue; if full then wait."""
     for item in items:
@@ -542,10 +600,15 @@ async def yield_locked_shelf(
 __all__ = [
     "AsyncDict",
     "EnhancedTaskGroup",
+    "OneAsyncEmptyError",
+    "OneAsyncError",
+    "OneAsyncNonUniqueError",
     "StreamCommandOutput",
+    "chain_async",
     "get_coroutine_name",
     "get_items",
     "get_items_nowait",
+    "one_async",
     "put_items",
     "put_items_nowait",
     "sleep_max",

{dycw_utilities-0.166.25 → dycw_utilities-0.166.27}/src/utilities/iterables.py

@@ -933,7 +933,7 @@ class MergeStrMappingsError(Exception):
 
 def one[T](*iterables: Iterable[T]) -> T:
     """Return the unique value in a set of iterables."""
-    it = iter(chain(*iterables))
+    it = chain(*iterables)
     try:
         first = next(it)
     except StopIteration: