dycw-utilities 0.116.4__tar.gz → 0.116.6__tar.gz

{dycw_utilities-0.116.4 → dycw_utilities-0.116.6}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.116.4
+Version: 0.116.6
 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.17; extra == 'test'
+Requires-Dist: hypothesis<6.132,>=6.131.19; 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'
@@ -43,7 +43,7 @@ Requires-Dist: whenever<0.8,>=0.7.3; extra == 'zzz-test-click'
 Provides-Extra: zzz-test-contextlib
 Provides-Extra: zzz-test-contextvars
 Provides-Extra: zzz-test-cryptography
-Requires-Dist: cryptography<44.1,>=44.0.2; extra == 'zzz-test-cryptography'
+Requires-Dist: cryptography<46.0,>=45.0.2; extra == 'zzz-test-cryptography'
 Provides-Extra: zzz-test-cvxpy
 Requires-Dist: cvxpy<1.7,>=1.6.5; extra == 'zzz-test-cvxpy'
 Provides-Extra: zzz-test-dataclasses
@@ -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.17; extra == 'zzz-test-hypothesis'
+Requires-Dist: hypothesis<6.132,>=6.131.19; extra == 'zzz-test-hypothesis'
 Requires-Dist: luigi<3.7,>=3.6.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: numpy<2.3,>=2.2.5; extra == 'zzz-test-hypothesis'
 Requires-Dist: pathvalidate<3.3,>=3.2.3; extra == 'zzz-test-hypothesis'

{dycw_utilities-0.116.4 → dycw_utilities-0.116.6}/pyproject.toml

@@ -19,14 +19,14 @@ dev = [
   "click >= 8.2.0, < 8.3",
   "coloredlogs >= 15.0.1, < 15.1",
   "concurrent-log-handler >= 0.9.26, < 0.10",
-  "cryptography >= 44.0.2, < 44.1",
+  "cryptography >= 45.0.2, < 46.0",
   "cvxpy >= 1.6.5, < 1.7",
   "eventkit >= 1.0.3, < 1.1",
   "fastapi >= 0.115.11, < 0.116",
   "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.17, < 6.132",
+  "hypothesis >= 6.131.19, < 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.116.4"
+version = "0.116.6"
 
 [project.optional-dependencies]
 test = [
-  "hypothesis >= 6.131.17, < 6.132",
+  "hypothesis >= 6.131.19, < 6.132",
   "pytest >= 8.3.5, < 8.4",
   "pytest-asyncio >= 0.26.0, < 0.27",
   "pytest-cov >= 6.1.1, < 6.2",
@@ -133,7 +133,7 @@ zzz-test-click = [
 ]
 zzz-test-contextlib = []
 zzz-test-contextvars = []
-zzz-test-cryptography = ["cryptography >= 44.0.2, < 44.1"]
+zzz-test-cryptography = ["cryptography >= 45.0.2, < 46.0"]
 zzz-test-cvxpy = ["cvxpy >= 1.6.5, < 1.7"]
 zzz-test-dataclasses = [
   "orjson >= 3.10.15, < 3.11",
@@ -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.17, < 6.132",
+  "hypothesis >= 6.131.19, < 6.132",
   "luigi >= 3.6.0, < 3.7",
   "numpy >= 2.2.5, < 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.116.4"
+current_version = "0.116.6"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.116.4 → dycw_utilities-0.116.6}/src/tests/test_asyncio.py

@@ -602,6 +602,22 @@ class TestInfiniteQueueLooper:
                 _ = tg.create_task(add_items())
         assert 15 <= len(looper.output) <= 20
 
+    @given(n=integers(1, 10))
+    def test_len_and_empty(self, *, n: int) -> None:
+        class Example(InfiniteQueueLooper[None, int]):
+            output: set[int] = field(default_factory=set)
+
+            @override
+            async def _process_items(self, *items: int) -> None:
+                self.output.update(items)
+
+        looper = Example(sleep_core=0.05)
+        assert len(looper) == 0
+        assert looper.empty()
+        looper.put_items_nowait(*range(n))
+        assert len(looper) == n
+        assert not looper.empty()
+
     async def test_no_items(self) -> None:
         @dataclass(kw_only=True)
         class Example(InfiniteQueueLooper[None, int]):
@@ -616,6 +632,34 @@ class TestInfiniteQueueLooper:
             async with timeout_dur(duration=0.5):
                 _ = await looper()
 
+    async def test_run_until_empty(self) -> None:
+        @dataclass(kw_only=True)
+        class Example(InfiniteQueueLooper[None, int]):
+            output: set[int] = field(default_factory=set)
+
+            @override
+            async def _process_items(self, *items: int) -> None:
+                self.output.update(items)
+
+        looper = Example(sleep_core=0.5)
+
+        async def add_items() -> None:
+            for i in count():
+                looper.put_items_nowait(i)
+                await sleep(0.01)
+
+        with raises(ExceptionGroup):  # noqa: PT012
+            async with EnhancedTaskGroup(timeout=1.0) as tg:
+                _ = tg.create_task(looper())
+                _ = tg.create_task(add_items())
+
+        tasks = len(looper)
+        assert tasks >= 1
+        await sleep(0.1)
+        assert len(looper) == tasks
+        await looper.run_until_empty()
+        assert looper.empty()
+
     @given(logger=just("logger") | none())
     async def test_error_process_items(self, *, logger: str | None) -> None:
         class CustomError(Exception): ...

{dycw_utilities-0.116.4 → dycw_utilities-0.116.6}/src/tests/test_redis.py

@@ -45,13 +45,14 @@ if TYPE_CHECKING:
     from collections.abc import Mapping
 
     from pytest import CaptureFixture
+    from redis.asyncio.client import PubSub
 
 
 class TestPublishAndSubscribe:
     @given(
         data=data(),
         channel=text_ascii(min_size=1).map(
-            lambda c: f"{get_class_name(TestPublishAndSubscribe)}_obj_ser_{c}"
+            lambda c: f"{get_class_name(TestPublishAndSubscribe)}_all_objects_with_serialize_{c}"
         ),
         obj=make_objects(),
     )
@@ -87,7 +88,7 @@ class TestPublishAndSubscribe:
     @given(
         data=data(),
         channel=text_ascii(min_size=1).map(
-            lambda c: f"{get_class_name(TestPublishAndSubscribe)}_text_no_ser_{c}"
+            lambda c: f"{get_class_name(TestPublishAndSubscribe)}_text_without_serialize_{c}"
         ),
         text=text_ascii(min_size=1),
     )
@@ -282,7 +283,7 @@ class TestPublisherIQL:
 class TestSubscribeMessages:
     @given(
         channel=text_ascii(min_size=1).map(
-            lambda c: f"{get_class_name(TestSubscribeMessages)}_{c}"
+            lambda c: f"{get_class_name(TestSubscribeMessages)}_redis_{c}"
         ),
         message=text_ascii(min_size=1),
     )
@@ -292,18 +293,46 @@ class TestSubscribeMessages:
         suppress_health_check={HealthCheck.function_scoped_fixture},
     )
     @SKIPIF_CI_AND_NOT_LINUX
-    async def test_main(
+    async def test_redis(
         self, *, capsys: CaptureFixture, channel: str, message: str
     ) -> None:
-        client = Redis()
+        redis = Redis()
+        await self._run_test(redis, redis, capsys, channel, message)
 
+    @given(
+        channel=text_ascii(min_size=1).map(
+            lambda c: f"{get_class_name(TestSubscribeMessages)}_pubsub_{c}"
+        ),
+        message=text_ascii(min_size=1),
+    )
+    @settings(
+        max_examples=1,
+        phases={Phase.generate},
+        suppress_health_check={HealthCheck.function_scoped_fixture},
+    )
+    @SKIPIF_CI_AND_NOT_LINUX
+    async def test_pubsub(
+        self, *, capsys: CaptureFixture, channel: str, message: str
+    ) -> None:
+        redis = Redis()
+        await self._run_test(redis, redis.pubsub(), capsys, channel, message)
+
+    async def _run_test(
+        self,
+        redis: Redis,
+        redis_or_pubsub: Redis | PubSub,
+        capsys: CaptureFixture,
+        channel: str,
+        message: str,
+        /,
+    ) -> None:
         async def listener() -> None:
-            async for msg in subscribe_messages(client.pubsub(), channel):
+            async for msg in subscribe_messages(redis_or_pubsub, channel):
                 print(msg)  # noqa: T201
 
         task = get_running_loop().create_task(listener())
         await sleep(0.05)
-        _ = await client.publish(channel, message)
+        _ = await redis.publish(channel, message)
         await sleep(0.05)
         try:
             out = capsys.readouterr().out

{dycw_utilities-0.116.4 → dycw_utilities-0.116.6}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.116.4"
+__version__ = "0.116.6"

{dycw_utilities-0.116.4 → dycw_utilities-0.116.6}/src/utilities/asyncio.py

@@ -490,6 +490,9 @@ class InfiniteQueueLooper(InfiniteLooper[THashable], Generic[THashable, _T]):
         super().__post_init__()
         self._queue = self.queue_type()
 
+    def __len__(self) -> int:
+        return self._queue.qsize()
+
     @override
     async def _core(self) -> None:
         """Run the core part of the loop."""
@@ -505,10 +508,19 @@ class InfiniteQueueLooper(InfiniteLooper[THashable], Generic[THashable, _T]):
     async def _process_items(self, *items: _T) -> None:
         """Process the items."""
 
+    def empty(self) -> bool:
+        """Check if the queue is empty."""
+        return self._queue.empty()
+
     def put_items_nowait(self, *items: _T) -> None:
         """Put items into the queue."""
         put_items_nowait(items, self._queue)
 
+    async def run_until_empty(self) -> None:
+        """Run until the queue is empty."""
+        while not self.empty():
+            await self._process_items(*get_items_nowait(self._queue))
+
     @override
     def _error_upon_core(self, error: Exception, /) -> None:
         """Handle any errors upon running the core function."""

{dycw_utilities-0.116.4 → dycw_utilities-0.116.6}/src/utilities/redis.py

@@ -19,6 +19,7 @@ from typing import (
 from uuid import UUID, uuid4
 
 from redis.asyncio import Redis
+from redis.asyncio.client import PubSub
 from redis.typing import EncodableT
 
 from utilities.asyncio import InfiniteQueueLooper, QueueProcessor, timeout_dur
@@ -46,7 +47,6 @@ if TYPE_CHECKING:
     )
 
     from redis.asyncio import ConnectionPool
-    from redis.asyncio.client import PubSub
     from redis.typing import ResponseT
 
     from utilities.iterables import MaybeIterable
@@ -649,7 +649,7 @@ _SUBSCRIBE_SLEEP: Duration = MILLISECOND
 
 @overload
 def subscribe(
-    pubsub: PubSub,
+    redis_or_pubsub: Redis | PubSub,
     channels: MaybeIterable[str],
     /,
     *,
@@ -659,7 +659,7 @@ def subscribe(
 ) -> AsyncIterator[_T]: ...
 @overload
 def subscribe(
-    pubsub: PubSub,
+    redis_or_pubsub: Redis | PubSub,
     channels: MaybeIterable[str],
     /,
     *,
@@ -668,7 +668,7 @@ def subscribe(
     sleep: Duration = _SUBSCRIBE_SLEEP,
 ) -> AsyncIterator[bytes]: ...
 async def subscribe(  # pyright: ignore[reportInconsistentOverload]
-    pubsub: PubSub,
+    redis_or_pubsub: Redis | PubSub,
     channels: MaybeIterable[str],
     /,
     *,
@@ -679,7 +679,7 @@ async def subscribe(  # pyright: ignore[reportInconsistentOverload]
     """Subscribe to the data of a given channel(s)."""
     channels = list(always_iterable(channels))  # skipif-ci-and-not-linux
     messages = subscribe_messages(  # skipif-ci-and-not-linux
-        pubsub, channels, timeout=timeout, sleep=sleep
+        redis_or_pubsub, channels, timeout=timeout, sleep=sleep
     )
     if deserializer is None:  # skipif-ci-and-not-linux
         async for message in messages:
@@ -690,7 +690,7 @@ async def subscribe(  # pyright: ignore[reportInconsistentOverload]
 
 
 async def subscribe_messages(
-    pubsub: PubSub,
+    redis_or_pubsub: Redis | PubSub,
     channels: MaybeIterable[str],
     /,
     *,
@@ -698,28 +698,40 @@ async def subscribe_messages(
     sleep: Duration = _SUBSCRIBE_SLEEP,
 ) -> AsyncIterator[_RedisMessageSubscribe]:
     """Subscribe to the messages of a given channel(s)."""
-    channels = list(always_iterable(channels))  # skipif-ci-and-not-linux
-    for channel in channels:  # skipif-ci-and-not-linux
-        await pubsub.subscribe(channel)
-    channels_bytes = [c.encode() for c in channels]  # skipif-ci-and-not-linux
-    timeout_use = (  # skipif-ci-and-not-linux
-        None if timeout is None else datetime_duration_to_float(timeout)
-    )
-    sleep_use = datetime_duration_to_float(sleep)  # skipif-ci-and-not-linux
-    while True:  # skipif-ci-and-not-linux
-        message = cast(
-            "_RedisMessageSubscribe | _RedisMessageUnsubscribe | None",
-            await pubsub.get_message(timeout=timeout_use),
-        )
-        if (
-            (message is not None)
-            and (message["type"] in {"subscribe", "psubscribe", "message", "pmessage"})
-            and (message["channel"] in channels_bytes)
-            and isinstance(message["data"], bytes)
-        ):
-            yield cast("_RedisMessageSubscribe", message)
-        else:
-            await asyncio.sleep(sleep_use)
+    match redis_or_pubsub:  # skipif-ci-and-not-linux
+        case Redis() as redis:
+            async for msg in subscribe_messages(
+                redis.pubsub(), channels, timeout=timeout, sleep=sleep
+            ):
+                yield msg
+        case PubSub() as pubsub:
+            channels = list(always_iterable(channels))
+            for channel in channels:
+                await pubsub.subscribe(channel)
+            channels_bytes = [c.encode() for c in channels]
+            timeout_use = (
+                None if timeout is None else datetime_duration_to_float(timeout)
+            )
+            sleep_use = datetime_duration_to_float(sleep)
+            while True:
+                message = cast(
+                    "_RedisMessageSubscribe | _RedisMessageUnsubscribe | None",
+                    await pubsub.get_message(timeout=timeout_use),
+                )
+                if (
+                    (message is not None)
+                    and (
+                        message["type"]
+                        in {"subscribe", "psubscribe", "message", "pmessage"}
+                    )
+                    and (message["channel"] in channels_bytes)
+                    and isinstance(message["data"], bytes)
+                ):
+                    yield cast("_RedisMessageSubscribe", message)
+                else:
+                    await asyncio.sleep(sleep_use)
+        case _ as never:
+            assert_never(never)
 
 
 class _RedisMessageSubscribe(TypedDict):