dycw-utilities 0.117.0__tar.gz → 0.118.0__tar.gz

{dycw_utilities-0.117.0 → dycw_utilities-0.118.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.117.0
+Version: 0.118.0
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12

{dycw_utilities-0.117.0 → dycw_utilities-0.118.0}/pyproject.toml

@@ -92,7 +92,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.117.0"
+version = "0.118.0"
 
 [project.optional-dependencies]
 test = [
@@ -334,7 +334,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.117.0"
+current_version = "0.118.0"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.117.0 → dycw_utilities-0.118.0}/src/tests/test_asyncio.py

@@ -1,23 +1,13 @@
 from __future__ import annotations
 
-from asyncio import (
-    CancelledError,
-    Event,
-    PriorityQueue,
-    Queue,
-    TaskGroup,
-    run,
-    sleep,
-    timeout,
-)
-from collections import Counter
+from asyncio import CancelledError, Event, Queue, TaskGroup, run, sleep, timeout
 from dataclasses import dataclass, field
 from functools import partial
 from itertools import chain, count
 from re import search
 from typing import TYPE_CHECKING, Self, override
 
-from hypothesis import Phase, given, settings
+from hypothesis import HealthCheck, Phase, given, settings
 from hypothesis.strategies import (
     DataObject,
     data,
@@ -28,20 +18,17 @@ from hypothesis.strategies import (
     permutations,
     sampled_from,
 )
-from pytest import approx, mark, param, raises
+from pytest import LogCaptureFixture, mark, raises
 
 from utilities.asyncio import (
-    AsyncLoopingService,
-    AsyncService,
     EnhancedTaskGroup,
-    ExceptionProcessor,
     InfiniteLooper,
     InfiniteLooperError,
     InfiniteQueueLooper,
     InfiniteQueueLooperError,
-    QueueProcessor,
     UniquePriorityQueue,
     UniqueQueue,
+    _DurationOrEvery,
     get_event,
     get_items,
     get_items_nowait,
@@ -54,7 +41,12 @@ from utilities.asyncio import (
     timeout_dur,
 )
 from utilities.dataclasses import replace_non_sentinel
-from utilities.datetime import MILLISECOND, datetime_duration_to_timedelta, get_now
+from utilities.datetime import (
+    MILLISECOND,
+    MINUTE,
+    datetime_duration_to_timedelta,
+    get_now,
+)
 from utilities.hypothesis import sentinels, text_ascii
 from utilities.iterables import one, unique_everseen
 from utilities.pytest import skipif_windows
@@ -67,200 +59,6 @@ if TYPE_CHECKING:
     from utilities.types import Coroutine1, Duration, MaybeCallableEvent, MaybeType
 
 
-class TestAsyncLoopingService:
-    async def test_main(self) -> None:
-        @dataclass(kw_only=True)
-        class Example(AsyncLoopingService):
-            counter: int = 0
-
-            @override
-            async def _run(self) -> None:
-                self.counter += 1
-
-        async with Example(duration=1.0, sleep=0.1) as service:
-            pass
-        assert 5 <= service.counter <= 15
-
-    async def test_cancel(self) -> None:
-        @dataclass(kw_only=True)
-        class Example(AsyncLoopingService):
-            counter: int = 0
-
-            @override
-            async def _run(self) -> None:
-                self.counter += 1
-                if self.counter >= 10:
-                    raise CancelledError
-
-        async with Example(sleep=0.1) as service:
-            pass
-        assert 5 <= service.counter <= 15
-
-    async def test_sleep_after_failure(self) -> None:
-        @dataclass(kw_only=True)
-        class Example(AsyncLoopingService):
-            counter: int = 0
-            errors: Counter[type[Exception]] = field(default_factory=Counter)
-
-            @override
-            async def _run(self) -> None:
-                self.counter += 1
-                if self.counter % 2 == 0:
-                    raise ValueError
-
-            @override
-            async def _run_failure(self, error: Exception, /) -> None:
-                self.errors.update([type(error)])
-
-        async with Example(duration=1.0, sleep=0.1) as service:
-            pass
-        assert 5 <= service.counter <= 15
-        assert 3 <= service.errors[ValueError] <= 7
-
-    async def test_failure(self) -> None:
-        class CustomError(Exception): ...
-
-        @dataclass(kw_only=True)
-        class Example(AsyncLoopingService):
-            counter: int = 0
-            failed: bool = False
-
-            @override
-            async def _run(self) -> None:
-                self.counter += 1
-                if self.counter >= 5:
-                    raise CustomError
-
-        with raises(CustomError):
-            async with Example(sleep=0.1):
-                pass
-
-
-class TestAsyncService:
-    async def test_main(self) -> None:
-        @dataclass(kw_only=True)
-        class Example(AsyncService):
-            running: bool = False
-
-            @override
-            async def _start(self) -> None:
-                self.running = True
-
-            @override
-            async def stop(self) -> None:
-                self.running = False
-                await super().stop()
-
-        service = Example(duration=0.1)
-        for _ in range(2):
-            assert not service.running
-            async with service:
-                assert service.running
-                async with service:
-                    assert service.running
-                assert service.running
-            assert not service.running
-
-    async def test_timeout(self) -> None:
-        @dataclass(kw_only=True)
-        class Example(AsyncService):
-            running: bool = False
-
-            @override
-            async def _start(self) -> None:
-                self.running = True
-
-            @override
-            async def stop(self) -> None:
-                self.running = False
-                await super().stop()
-
-        service = Example()
-        try:
-            async with timeout_dur(duration=0.05), service:
-                await sleep(0.1)
-        except TimeoutError:
-            assert not service.running
-
-    @mark.parametrize(
-        ("duration", "expected"),
-        [
-            param(0.5, approx(5, abs=1)),
-            param(1.0, approx(10, abs=1)),
-            param(1.5, 10),
-            param(None, 10),
-        ],
-    )
-    async def test_cancellation(
-        self, *, duration: Duration | None, expected: int
-    ) -> None:
-        class Example(AsyncService):
-            counter: int = 0
-
-            @override
-            async def _start(self) -> None:
-                for _ in range(10):
-                    self.counter += 1
-                    await sleep(0.1)
-                raise CancelledError
-
-        async with Example(duration=duration) as service:
-            ...
-        assert service.counter == expected
-
-    async def test_extra_context_managers(self) -> None:
-        @dataclass(kw_only=True)
-        class Inner(AsyncService):
-            duration: Duration | None = 0.1
-            running: bool = False
-
-            @override
-            async def _start(self) -> None:
-                self.running = True
-
-            @override
-            async def stop(self) -> None:
-                self.running = False
-                await super().stop()
-
-        @dataclass(kw_only=True)
-        class Outer(AsyncService):
-            duration: Duration | None = 0.1
-            running: bool = False
-            inner: Inner = field(default_factory=Inner, init=False, repr=False)
-
-            @override
-            async def _start(self) -> None:
-                self.running = True
-                _ = await self._stack.enter_async_context(self.inner)
-
-            @override
-            async def stop(self) -> None:
-                self.running = False
-                await super().stop()
-
-        outer = Outer()
-        for _ in range(2):
-            assert not outer.running
-            assert not outer.inner.running
-            async with outer:
-                assert outer.running
-                assert outer.inner.running
-            assert not outer.running
-            assert not outer.inner.running
-
-    def test_repr(self) -> None:
-        class Example(AsyncService):
-            @override
-            async def _start(self) -> None:
-                await sleep(0.01)
-
-        service = Example()
-        result = repr(service)
-        expected = "TestAsyncService.test_repr.<locals>.Example(duration=None)"
-        assert result == expected
-
-
 class TestEnhancedTaskGroup:
     async def test_max_tasks_disabled(self) -> None:
         with Timer() as timer:
@@ -299,18 +97,6 @@ class TestEnhancedTaskGroup:
         assert isinstance(error, CustomError)
 
 
-class TestExceptionProcessor:
-    async def test_main(self) -> None:
-        processor = ExceptionProcessor()
-
-        class CustomError(Exception): ...
-
-        with raises(CustomError):  # noqa: PT012
-            async with processor:
-                processor.enqueue(CustomError)
-                await sleep(0.1)
-
-
 class TestGetEvent:
     def test_event(self) -> None:
         event = Event()
@@ -343,8 +129,8 @@ class TestGetEvent:
 
 
 class TestInfiniteLooper:
-    @given(n=integers(10, 11))
-    async def test_main(self, *, n: int) -> None:
+    @given(n=integers(10, 11), sleep_core=sampled_from([0.1, ("every", 0.1)]))
+    async def test_main(self, *, n: int, sleep_core: _DurationOrEvery) -> None:
         class TrueError(BaseException): ...
 
         class FalseError(BaseException): ...
@@ -370,7 +156,7 @@ class TestInfiniteLooper:
                 yield (True, TrueError)
                 yield (False, FalseError)
 
-        looper = Example(sleep_core=0.1)
+        looper = Example(sleep_core=sleep_core)
         match n % 2 == 0:
             case True:
                 with raises(TrueError):
@@ -522,7 +308,24 @@ class TestInfiniteLooper:
         assert 1 <= looper.counter <= 6
 
     @given(logger=just("logger") | none())
-    async def test_error_upon_initialize(self, *, logger: str | None) -> None:
+    @mark.parametrize(
+        ("sleep_restart", "desc"),
+        [
+            (60.0, "for 0:01:00"),
+            (MINUTE, "for 0:01:00"),
+            (("every", 60), "until next 0:01:00"),
+            (("every", MINUTE), "until next 0:01:00"),
+        ],
+    )
+    @settings(suppress_health_check={HealthCheck.function_scoped_fixture})
+    async def test_error_upon_initialize(
+        self,
+        *,
+        sleep_restart: _DurationOrEvery,
+        desc: str,
+        logger: str | None,
+        caplog: LogCaptureFixture,
+    ) -> None:
         class CustomError(Exception): ...
 
         @dataclass(kw_only=True)
@@ -535,13 +338,34 @@ class TestInfiniteLooper:
             async def _core(self) -> None:
                 raise NotImplementedError
 
-        looper = Example(sleep_core=0.1, logger=logger)
+        looper = Example(sleep_core=0.1, sleep_restart=sleep_restart, logger=logger)
         with raises(TimeoutError):
             async with timeout_dur(duration=0.5):
                 _ = await looper()
+        if logger is not None:
+            message = caplog.messages[0]
+            expected = f"'Example' encountered 'CustomError()' whilst initializing; sleeping {desc}..."
+            assert message == expected
 
     @given(logger=just("logger") | none())
-    async def test_error_group_upon_coroutines(self, *, logger: str | None) -> None:
+    @mark.parametrize(
+        ("sleep_restart", "desc"),
+        [
+            (60.0, "for 0:01:00"),
+            (MINUTE, "for 0:01:00"),
+            (("every", 60), "until next 0:01:00"),
+            (("every", MINUTE), "until next 0:01:00"),
+        ],
+    )
+    @settings(suppress_health_check={HealthCheck.function_scoped_fixture})
+    async def test_error_group_upon_coroutines(
+        self,
+        *,
+        sleep_restart: _DurationOrEvery,
+        desc: str,
+        logger: str | None,
+        caplog: LogCaptureFixture,
+    ) -> None:
         class CustomError(Exception): ...
 
         @dataclass(kw_only=True)
@@ -556,10 +380,14 @@ class TestInfiniteLooper:
             ) -> Iterator[tuple[None, MaybeType[BaseException]]]:
                 yield (None, CustomError)
 
-        looper = Example(sleep_core=0.1, logger=logger)
+        looper = Example(sleep_core=0.1, sleep_restart=sleep_restart, logger=logger)
         with raises(TimeoutError):
             async with timeout_dur(duration=0.5):
                 _ = await looper()
+        if logger is not None:
+            message = caplog.messages[0]
+            expected = f"'Example' encountered 'CustomError()'; sleeping {desc}..."
+            assert message == expected
 
     async def test_error_no_event_found(self) -> None:
         @dataclass(kw_only=True)
@@ -746,169 +574,6 @@ class TestPutAndGetItemsNoWait:
             assert result == xs[:max_size]
 
 
-class TestQueueProcessor:
-    async def test_one_processor_slow_tasks(self) -> None:
-        @dataclass(kw_only=True)
-        class Example(QueueProcessor[int]):
-            output: set[int] = field(default_factory=set)
-
-            @override
-            async def _process_item(self, item: int, /) -> None:
-                self.output.add(item)
-
-        async with Example() as processor:
-
-            async def add_tasks() -> None:
-                for i in range(10):
-                    processor.enqueue(i)
-                    await sleep(0.1)
-
-            async def run_until_empty() -> None:
-                await sleep(0.5)
-                await processor.run_until_empty()
-
-            async with TaskGroup() as tg:
-                _ = tg.create_task(add_tasks())
-                _ = tg.create_task(run_until_empty())
-
-            assert len(processor.output) == 10
-
-    async def test_one_processor_slow_run(self) -> None:
-        @dataclass(kw_only=True)
-        class Example(QueueProcessor[int]):
-            output: set[int] = field(default_factory=set)
-
-            @override
-            async def _process_item(self, item: int, /) -> None:
-                self.output.add(item)
-                await sleep(0.01)
-
-        async with Example() as processor:
-            processor.enqueue(*range(10))
-            await processor.run_until_empty()
-            assert len(processor.output) == 10
-
-    @given(n=integers(1, 10))
-    async def test_one_processor_continually_adding(self, *, n: int) -> None:
-        @dataclass(kw_only=True)
-        class Example(QueueProcessor[int]):
-            output: set[int] = field(default_factory=set)
-
-            @override
-            async def _process_item(self, item: int, /) -> None:
-                self.output.add(item)
-
-        async with Example() as processor:
-            for i in range(n):
-                processor.enqueue(i)
-                await sleep(0.01)
-            assert len(processor.output) == n
-
-    async def test_two_processors(self) -> None:
-        @dataclass(kw_only=True)
-        class First(QueueProcessor[int]):
-            second: Second
-            output: set[int] = field(default_factory=set)
-
-            @override
-            async def _process_item(self, item: int, /) -> None:
-                self.second.enqueue(item)
-                self.output.add(item)
-                await sleep(0.1)
-
-        @dataclass(kw_only=True)
-        class Second(QueueProcessor[int]):
-            output: set[int] = field(default_factory=set)
-
-            @override
-            async def _process_item(self, item: int, /) -> None:
-                self.output.add(item)
-                await sleep(0.01)
-
-        async with Second() as second, First(second=second) as first:
-
-            async def yield_tasks() -> None:
-                first.enqueue(*range(10))
-                await first.run_until_empty()
-
-            await yield_tasks()
-            assert len(first.output) == 10
-            assert len(second.output) == 10
-
-    @mark.parametrize("duration", [param(0.1), param(0.5), param(1.0), param(1.5)])
-    async def test_cancellation(self, *, duration: float) -> None:
-        @dataclass(kw_only=True)
-        class Example(QueueProcessor[int]):
-            output: set[int] = field(default_factory=set)
-
-            @override
-            async def _process_item(self, item: int, /) -> None:
-                self.output.add(item)
-                await sleep(0.1)
-
-        async with Example(duration=duration) as processor:
-            processor.enqueue(*range(10))
-        assert processor.output == set(range(10))
-
-    async def test_empty(self) -> None:
-        class Example(QueueProcessor[int]):
-            @override
-            async def _process_item(self, item: int, /) -> None:
-                _ = item
-
-        processor = Example()
-        assert processor.empty()
-        processor.enqueue(0)
-        assert not processor.empty()
-
-    @given(n=integers(0, 10))
-    async def test_get_items_nowait(self, *, n: int) -> None:
-        @dataclass(kw_only=True)
-        class Example(QueueProcessor[int]):
-            output: set[int] = field(default_factory=set)
-
-            @override
-            async def _process_item(self, _: int, /) -> None:
-                items = self._get_items_nowait()
-                self.output.add(len(items))
-
-        processor = Example()
-        processor.enqueue(*range(n + 1))
-        await processor._run()
-        result = one(processor.output)
-        assert result == n
-
-    @given(n=integers(0, 10))
-    async def test_len(self, *, n: int) -> None:
-        class Example(QueueProcessor[int]):
-            @override
-            async def _process_item(self, item: int) -> None:
-                _ = item
-
-        processor = Example()
-        assert len(processor) == 0
-        processor.enqueue(*range(n))
-        assert len(processor) == n
-
-    @given(data=data(), texts=lists(text_ascii(min_size=1), min_size=1))
-    async def test_priority_queue(self, *, data: DataObject, texts: list[str]) -> None:
-        @dataclass(kw_only=True)
-        class Example(QueueProcessor[tuple[int, str]]):
-            output: set[str] = field(default_factory=set)
-
-            @override
-            async def _process_item(self, item: tuple[int, str]) -> None:
-                _, text = item
-                self.output.add(text)
-
-        processor = Example(queue_type=PriorityQueue)
-        items = data.draw(permutations(list(enumerate(texts))))
-        processor.enqueue(*items)
-        await processor._run()
-        result = one(processor.output)
-        assert result == texts[0]
-
-
 class TestUniquePriorityQueue:
     @given(data=data(), texts=lists(text_ascii(min_size=1), min_size=1, unique=True))
     async def test_main(self, *, data: DataObject, texts: list[str]) -> None:
@@ -955,10 +620,7 @@ class TestSleepDur:
 
 class TestSleepUntil:
     async def test_main(self) -> None:
-        now = get_now()
-        with Timer() as timer:
-            await sleep_until(now + 10 * MILLISECOND)
-        assert timer >= datetime_duration_to_timedelta(5 * MILLISECOND)
+        await sleep_until(get_now() + 10 * MILLISECOND)
 
 
 class TestSleepUntilRounded:

{dycw_utilities-0.117.0 → dycw_utilities-0.118.0}/src/tests/test_fastapi.py

@@ -3,7 +3,10 @@ from __future__ import annotations
 from asyncio import sleep
 from re import search
 
+from pytest import raises
+
 from tests.conftest import SKIPIF_CI
+from utilities.asyncio import EnhancedTaskGroup
 from utilities.fastapi import PingReceiver
 
 
@@ -11,14 +14,19 @@ class TestPingReceiver:
     @SKIPIF_CI
     async def test_main(self) -> None:
         port = 5465
+        receiver = PingReceiver(port=port)
         assert await PingReceiver.ping(port) is False
         await sleep(0.1)
-        async with PingReceiver(port=port):
+
+        async def run_test() -> None:
             await sleep(0.1)
             result = await PingReceiver.ping(port)
             assert isinstance(result, str)
             assert search(
                 r"pong @ \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{1,6}", result
             )
-        await sleep(0.1)
-        assert await PingReceiver.ping(port) is False
+
+        with raises(ExceptionGroup):  # noqa: PT012
+            async with EnhancedTaskGroup(timeout=1.0) as tg:
+                _ = tg.create_task(receiver())
+                _ = tg.create_task(run_test())

{dycw_utilities-0.117.0 → dycw_utilities-0.118.0}/src/tests/test_redis.py

@@ -29,7 +29,6 @@ from utilities.hypothesis import (
 )
 from utilities.orjson import deserialize, serialize
 from utilities.redis import (
-    Publisher,
     PublisherIQL,
     PublisherIQLError,
     publish,
@@ -119,80 +118,6 @@ class TestPublishAndSubscribe:
                 _ = task.cancel()
 
 
-class TestPublisher:
-    @given(
-        data=data(),
-        channel=text_ascii(min_size=1).map(
-            lambda c: f"{get_class_name(TestPublisher)}_obj_ser_{c}"
-        ),
-        obj=make_objects(),
-    )
-    @mark.flaky
-    @settings(
-        max_examples=1,
-        phases={Phase.generate},
-        suppress_health_check={HealthCheck.function_scoped_fixture},
-    )
-    @SKIPIF_CI_AND_NOT_LINUX
-    async def test_main(
-        self, *, capsys: CaptureFixture, data: DataObject, channel: str, obj: Any
-    ) -> None:
-        async with yield_test_redis(data) as test:
-
-            async def listener() -> None:
-                async for msg in subscribe(
-                    test.redis.pubsub(), channel, deserializer=deserialize
-                ):
-                    print(msg)  # noqa: T201
-
-            task = create_task(listener())
-            await sleep(0.1)
-
-            async with Publisher(redis=test.redis, serializer=serialize) as publisher:
-                publisher.enqueue((channel, obj))
-                await sleep(0.1)
-
-            try:
-                out = capsys.readouterr().out
-                expected = f"{obj}\n"
-                assert out == expected
-            finally:
-                _ = task.cancel()
-
-    @given(
-        data=data(),
-        channel=text_ascii(min_size=1).map(
-            lambda c: f"{get_class_name(TestPublisher)}_text_no_ser_{c}"
-        ),
-        text=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_text_without_serialize(
-        self, *, capsys: CaptureFixture, data: DataObject, channel: str, text: str
-    ) -> None:
-        async with yield_test_redis(data) as test:
-
-            async def listener() -> None:
-                async for msg in subscribe(test.redis.pubsub(), channel):
-                    print(msg)  # noqa: T201
-
-            task = create_task(listener())
-            await sleep(0.1)
-            _ = await publish(test.redis, channel, text)
-            await sleep(0.1)
-            try:
-                out = capsys.readouterr().out
-                expected = f"{text.encode()}\n"
-                assert out == expected
-            finally:
-                _ = task.cancel()
-
-
 class TestPublisherIQL:
     @given(
         data=data(),