dycw-utilities 0.123.0__tar.gz → 0.124.1__tar.gz

{dycw_utilities-0.123.0 → dycw_utilities-0.124.1}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.123.0
+Version: 0.124.1
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
 Requires-Dist: typing-extensions<4.14,>=4.13.1
 Provides-Extra: test
-Requires-Dist: hypothesis<6.132,>=6.131.21; extra == 'test'
+Requires-Dist: hypothesis<6.132,>=6.131.24; extra == 'test'
 Requires-Dist: pytest-asyncio<0.27,>=0.26.0; extra == 'test'
 Requires-Dist: pytest-cov<6.2,>=6.1.1; extra == 'test'
 Requires-Dist: pytest-instafail<0.6,>=0.5.0; extra == 'test'
@@ -80,7 +80,7 @@ Provides-Extra: zzz-test-hypothesis
 Requires-Dist: aiosqlite<0.22,>=0.21.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: asyncpg<0.31,>=0.30.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: greenlet<3.3,>=3.2.0; extra == 'zzz-test-hypothesis'
-Requires-Dist: hypothesis<6.132,>=6.131.21; extra == 'zzz-test-hypothesis'
+Requires-Dist: hypothesis<6.132,>=6.131.24; extra == 'zzz-test-hypothesis'
 Requires-Dist: luigi<3.7,>=3.6.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: numpy<2.3,>=2.2.6; extra == 'zzz-test-hypothesis'
 Requires-Dist: pathvalidate<3.3,>=3.2.3; extra == 'zzz-test-hypothesis'

{dycw_utilities-0.123.0 → dycw_utilities-0.124.1}/pyproject.toml

@@ -26,7 +26,7 @@ dev = [
   "fpdf2 >= 2.8.3, < 2.9",
   "greenlet >= 3.2.0, < 3.3",  # for sqlalchemy async
   "httpx >= 0.28.1, < 0.29",  # for fastapi
-  "hypothesis >= 6.131.21, < 6.132",
+  "hypothesis >= 6.131.24, < 6.132",
   "img2pdf >= 0.6.0, < 0.7",
   "lightweight-charts >= 2.1, < 2.2",
   "loguru >= 0.7.3, < 0.8",
@@ -92,11 +92,11 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.123.0"
+version = "0.124.1"
 
 [project.optional-dependencies]
 test = [
-  "hypothesis >= 6.131.21, < 6.132",
+  "hypothesis >= 6.131.24, < 6.132",
   "pytest >= 8.3.5, < 8.4",
   "pytest-asyncio >= 0.26.0, < 0.27",
   "pytest-cov >= 6.1.1, < 6.2",
@@ -174,7 +174,7 @@ zzz-test-hypothesis = [
   "aiosqlite >= 0.21.0, < 0.22",
   "asyncpg >= 0.30.0, < 0.31",  # for sqlalchemy async
   "greenlet >= 3.2.0, < 3.3",  # for sqlalchemy async
-  "hypothesis >= 6.131.21, < 6.132",
+  "hypothesis >= 6.131.24, < 6.132",
   "luigi >= 3.6.0, < 3.7",
   "numpy >= 2.2.6, < 2.3",
   "pathvalidate >= 3.2.3, < 3.3",
@@ -334,7 +334,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.123.0"
+current_version = "0.124.1"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.123.0 → dycw_utilities-0.124.1}/src/tests/test_asyncio.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from asyncio import CancelledError, Event, Queue, TaskGroup, run, sleep, timeout
+from asyncio import CancelledError, Event, Queue, run, sleep
+from collections import deque
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from functools import partial
@@ -8,9 +9,10 @@ from itertools import chain, count
 from re import search
 from typing import TYPE_CHECKING, Any, ClassVar, Self, cast, override
 
-from hypothesis import HealthCheck, Phase, given, settings
+from hypothesis import HealthCheck, Phase, assume, given, settings
 from hypothesis.strategies import (
     DataObject,
+    booleans,
     data,
     integers,
     just,
@@ -22,6 +24,7 @@ from hypothesis.strategies import (
 from pytest import LogCaptureFixture, mark, param, raises
 
 from utilities.asyncio import (
+    EnhancedQueue,
     EnhancedTaskGroup,
     InfiniteLooper,
     InfiniteQueueLooper,
@@ -65,6 +68,77 @@ if TYPE_CHECKING:
     )
 
 
+class TestEnhancedQueue:
+    @given(
+        xs=lists(integers()),
+        wait=booleans(),
+        put_all=booleans(),
+        get_reverse=booleans(),
+    )
+    async def test_left(
+        self, *, xs: list[int], wait: int, put_all: bool, get_reverse: bool
+    ) -> None:
+        _ = assume(not ((len(xs) == 0) and wait))
+        deq: deque[int] = deque()
+        for x in xs:
+            deq.appendleft(x)
+        queue: EnhancedQueue[int] = EnhancedQueue()
+        if put_all:
+            if wait:
+                await queue.put_left(*xs)
+            else:
+                queue.put_left_nowait(*xs)
+        else:
+            for i, x in enumerate(xs, start=1):
+                if wait:
+                    await queue.put_left(x)
+                else:
+                    queue.put_left_nowait(x)
+                assert queue.qsize() == i
+        assert list(deq) == xs[::-1]
+        if wait:
+            res = await queue.get_all(reverse=get_reverse)
+        else:
+            res = queue.get_all_nowait(reverse=get_reverse)
+        expected = xs if get_reverse else xs[::-1]
+        assert res == expected
+
+    @given(
+        xs=lists(integers()),
+        wait=booleans(),
+        put_all=booleans(),
+        get_reverse=booleans(),
+    )
+    async def test_right(
+        self, *, xs: list[int], wait: int, put_all: bool, get_reverse: bool
+    ) -> None:
+        _ = assume(not ((len(xs) == 0) and wait))
+        deq: deque[int] = deque()
+        for x in xs:
+            deq.append(x)
+        queue: EnhancedQueue[int] = EnhancedQueue()
+        if put_all:
+            if wait:
+                await queue.put_right(*xs)
+            else:
+                queue.put_right_nowait(*xs)
+            assert queue.qsize() == len(xs)
+        else:
+            for i, x in enumerate(xs, start=1):
+                if wait:
+                    await queue.put_right(x)
+                else:
+                    queue.put_right_nowait(x)
+                assert queue.qsize() == i
+        assert list(deq) == xs
+        if wait:
+            res = await queue.get_all(reverse=get_reverse)
+        else:
+            res = queue.get_all_nowait(reverse=get_reverse)
+        expected = xs[::-1] if get_reverse else xs
+        assert res == expected
+
+
 class TestEnhancedTaskGroup:
     async def test_create_task_context_coroutine(self) -> None:
         flag: bool = False
@@ -175,6 +249,24 @@ class TestGetEvent:
         assert get_event(event=lambda: event) is event
 
 
+class TestGetItems:
+    @given(
+        xs=lists(integers(), min_size=1),
+        max_size=integers(1, 10) | none(),
+        wait=booleans(),
+    )
+    async def test_main(
+        self, *, xs: list[int], max_size: int | None, wait: bool
+    ) -> None:
+        queue: Queue[int] = Queue()
+        put_items_nowait(xs, queue)
+        if wait:
+            result = await get_items(queue, max_size=max_size)
+        else:
+            result = get_items_nowait(queue, max_size=max_size)
+        assert result == xs[:max_size]
+
+
 class TestInfiniteLooper:
     sleep_restart_cases: ClassVar[list[Any]] = [
         param(60.0, "for 0:01:00"),
@@ -386,9 +478,9 @@ class TestInfiniteLooper:
             Example(sleep_core=0.05, sleep_restart=0.05) as looper,
         ):
             ...
-        assert 4 <= looper.initializations <= 6
-        assert 0 <= looper.counter <= 7
-        assert 14 <= external <= 21
+        assert 3 <= looper.initializations <= 7
+        assert 0 <= looper.counter <= 8
+        assert 13 <= external <= 22
 
     async def test_with_coroutine_self_error(self) -> None:
         class CustomError(Exception): ...
@@ -661,13 +753,13 @@ class TestInfiniteQueueLooper:
             counter: int = 0
 
             @override
-            async def _process_items(self, *items: int) -> None:
-                self.counter += len(items)
+            async def _process_queue(self) -> None:
+                self.counter += len(self._queue.get_all_nowait())
 
         async with timeout_dur(duration=1.0), Example(sleep_core=0.05) as looper:
             await sleep(0.1)
             for i in range(10):
-                looper.put_items_nowait(i)
+                looper.put_right_nowait(i)
                 await sleep(0.05)
 
             assert looper.counter == 10
@@ -678,13 +770,13 @@ class TestInfiniteQueueLooper:
             output: set[int] = field(default_factory=set)
 
             @override
-            async def _process_items(self, *items: int) -> None:
-                self.output.update(items)
+            async def _process_queue(self) -> None:
+                self.output.update(self._queue.get_all_nowait())
 
         looper = Example(sleep_core=0.05)
         assert len(looper) == 0
         assert looper.empty()
-        looper.put_items_nowait(*range(n))
+        looper.put_right_nowait(*range(n))
         assert len(looper) == n
         assert not looper.empty()
 
@@ -694,11 +786,11 @@ class TestInfiniteQueueLooper:
             output: set[int] = field(default_factory=set)
 
             @override
-            async def _process_items(self, *items: int) -> None:
-                self.output.update(items)
+            async def _process_queue(self) -> None:
+                self.output.update(self._queue.get_all_nowait())
 
         looper = Example(sleep_core=0.05)
-        looper.put_items_nowait(*range(10))
+        looper.put_right_nowait(*range(10))
         async with looper:
             await looper.run_until_empty()
         assert looper.empty()
@@ -715,66 +807,32 @@ class TestInfiniteQueueLooper:
             output: set[int] = field(default_factory=set)
 
             @override
-            async def _process_items(self, *items: int) -> None:
-                raise CustomError(*items)
+            async def _process_queue(self) -> None:
+                raise CustomError
 
         async with (
             timeout_dur(duration=1.0),
             Example(sleep_core=0.05, logger=logger) as looper,
         ):
-            looper.put_items_nowait(1)
+            looper.put_left_nowait(1)
         if logger is not None:
             message = caplog.messages[0]
-            expected = "'Example' encountered CustomError(1) whilst processing 1 item(s) [1]; sleeping for 0:01:00..."
+            expected = "'Example' encountered 'CustomError()'; sleeping for 0:01:00..."
             assert message == expected
 
 
-class TestPutAndGetItems:
-    @given(xs=lists(integers(), min_size=1), max_size=integers(1, 10) | none())
-    async def test_put_then_get(self, *, xs: list[int], max_size: int | None) -> None:
+class TestPutItems:
+    @given(xs=lists(integers(), min_size=1), wait=booleans())
+    async def test_main(self, *, xs: list[int], wait: bool) -> None:
         queue: Queue[int] = Queue()
-        await put_items(xs, queue)
-        result = await get_items(queue, max_size=max_size)
-        if max_size is None:
-            assert result == xs
+        if wait:
+            put_items_nowait(xs, queue)
         else:
-            assert result == xs[:max_size]
-
-    @given(xs=lists(integers(), min_size=1), max_size=integers(1, 10) | none())
-    async def test_get_then_put(self, *, xs: list[int], max_size: int | None) -> None:
-        queue: Queue[int] = Queue()
-
-        async def put() -> None:
-            await sleep(0.01)
             await put_items(xs, queue)
-
-        async with TaskGroup() as tg:
-            task = tg.create_task(get_items(queue, max_size=max_size))
-            _ = tg.create_task(put())
-        result = task.result()
-        if max_size is None:
-            assert result == xs
-        else:
-            assert result == xs[:max_size]
-
-    async def test_empty(self) -> None:
-        queue: Queue[int] = Queue()
-        with raises(TimeoutError):  # noqa: PT012
-            async with timeout(0.01), TaskGroup() as tg:
-                _ = tg.create_task(get_items(queue))
-                _ = tg.create_task(sleep(0.02))
-
-
-class TestPutAndGetItemsNoWait:
-    @given(xs=lists(integers(), min_size=1), max_size=integers(1, 10) | none())
-    def test_main(self, *, xs: list[int], max_size: int | None) -> None:
-        queue: Queue[int] = Queue()
-        put_items_nowait(xs, queue)
-        result = get_items_nowait(queue, max_size=max_size)
-        if max_size is None:
-            assert result == xs
-        else:
-            assert result == xs[:max_size]
+        result: list[int] = []
+        while not queue.empty():
+            result.append(await queue.get())
+        assert result == xs
 
 
 class TestUniquePriorityQueue:

{dycw_utilities-0.123.0 → dycw_utilities-0.124.1}/src/tests/test_more_itertools.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Iterator
 from typing import TYPE_CHECKING, Any, ClassVar, TypeGuard
 
 from pytest import mark, param, raises
@@ -24,17 +25,45 @@ class TestBucketMapping:
     def test_main(self) -> None:
         mapping = bucket_mapping(self.iterable, lambda x: x[0])
         assert set(mapping) == {"a", "b", "c"}
+        for value in mapping.values():
+            assert isinstance(value, Iterator)
+            assert not isinstance(value, list)
         assert list(mapping["a"]) == ["a1", "a2"]
         assert list(mapping["b"]) == ["b1", "b2", "b3"]
         assert list(mapping["c"]) == ["c1", "c2"]
 
+    def test_transform(self) -> None:
+        mapping = bucket_mapping(
+            self.iterable, lambda x: x[0], transform=lambda x: int(x[-1])
+        )
+        assert set(mapping) == {"a", "b", "c"}
+        for value in mapping.values():
+            assert isinstance(value, Iterator)
+            assert not isinstance(value, list)
+        assert list(mapping["a"]) == [1, 2]
+        assert list(mapping["b"]) == [1, 2, 3]
+        assert list(mapping["c"]) == [1, 2]
+
     def test_list(self) -> None:
         mapping = bucket_mapping(self.iterable, lambda x: x[0], list=True)
         assert set(mapping) == {"a", "b", "c"}
+        for value in mapping.values():
+            assert isinstance(value, list)
         assert mapping["a"] == ["a1", "a2"]
         assert mapping["b"] == ["b1", "b2", "b3"]
         assert mapping["c"] == ["c1", "c2"]
 
+    def test_transform_and_list(self) -> None:
+        mapping = bucket_mapping(
+            self.iterable, lambda x: x[0], transform=lambda x: int(x[-1]), list=True
+        )
+        assert set(mapping) == {"a", "b", "c"}
+        for value in mapping.values():
+            assert isinstance(value, list)
+        assert mapping["a"] == [1, 2]
+        assert mapping["b"] == [1, 2, 3]
+        assert mapping["c"] == [1, 2]
+
 
 class TestPartitionList:
     def test_main(self) -> None:

{dycw_utilities-0.123.0 → dycw_utilities-0.124.1}/src/tests/test_redis.py

@@ -150,7 +150,7 @@ class TestPublisher:
 
             async def sleep_then_put() -> None:
                 await sleep(0.1)
-                publisher.put_items_nowait((channel, obj))
+                publisher.put_right_nowait((channel, obj))
 
             with raises(ExceptionGroup):  # noqa: PT012
                 async with EnhancedTaskGroup(timeout=1.0) as tg:
@@ -187,7 +187,7 @@ class TestPublisher:
 
             async def sleep_then_put() -> None:
                 await sleep(0.1)
-                publisher.put_items_nowait((channel, text))
+                publisher.put_right_nowait((channel, text))
 
             with raises(ExceptionGroup):  # noqa: PT012
                 async with EnhancedTaskGroup(timeout=1.0) as tg:

{dycw_utilities-0.123.0 → dycw_utilities-0.124.1}/src/tests/test_sqlalchemy.py

@@ -1169,7 +1169,7 @@ class TestUpserter:
         engine = await sqlalchemy_engines(data, table)
         pairs = [(id_, init) for id_, init, _ in triples]
         async with Upserter(duration=1.0, sleep_core=0.1, engine=engine) as upserter:
-            upserter.put_items_nowait((pairs, table))
+            upserter.put_right_nowait((pairs, table))
 
         sel = select(table)
         async with engine.begin() as conn:

{dycw_utilities-0.123.0 → dycw_utilities-0.124.1}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.123.0"
+__version__ = "0.124.1"