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

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

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

{dycw_utilities-0.117.1 → 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.1"
+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.1"
+current_version = "0.118.0"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

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

@@ -1,16 +1,6 @@
 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
@@ -28,18 +18,14 @@ from hypothesis.strategies import (
     permutations,
     sampled_from,
 )
-from pytest import LogCaptureFixture, 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,
@@ -73,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:
@@ -305,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()
@@ -794,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:
@@ -1003,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.1 → 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.1 → 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(),

dycw_utilities-0.118.0/src/tests/test_slack_sdk.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from asyncio import sleep
+from logging import getLogger
+from typing import TYPE_CHECKING
+
+from aiohttp import InvalidUrlClientError
+from pytest import mark, raises
+from slack_sdk.webhook.async_client import AsyncWebhookClient
+
+from utilities.asyncio import EnhancedTaskGroup, sleep_dur
+from utilities.datetime import MINUTE
+from utilities.os import get_env_var
+from utilities.pytest import throttle
+from utilities.slack_sdk import SlackHandlerIQL, _get_client, send_to_slack
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from pathlib import Path
+
+
+class TestGetClient:
+    def test_main(self) -> None:
+        client = _get_client("url")
+        assert isinstance(client, AsyncWebhookClient)
+
+
+class TestSendToSlack:
+    async def test_main(self) -> None:
+        with raises(InvalidUrlClientError, match="url"):
+            await send_to_slack("url", "message")
+
+    @mark.skipif(get_env_var("SLACK", nullable=True) is None, reason="'SLACK' not set")
+    @throttle(duration=5 * MINUTE)
+    async def test_real(self) -> None:
+        url = get_env_var("SLACK")
+        await send_to_slack(
+            url, f"message from {TestSendToSlack.test_real.__qualname__}"
+        )
+
+
+class TestSlackHandlerIQL:
+    async def test_main(self, *, tmp_path: Path) -> None:
+        messages: Sequence[str] = []
+
+        async def sender(_: str, text: str, /) -> None:
+            await sleep(0.01)
+            messages.append(text)
+
+        logger = getLogger(str(tmp_path))
+        logger.addHandler(
+            handler := SlackHandlerIQL("url", sleep_core=0.05, sender=sender)
+        )
+
+        async def sleep_then_log() -> None:
+            await sleep_dur(duration=0.05)
+            logger.warning("message")
+
+        with raises(ExceptionGroup):  # noqa: PT012
+            async with EnhancedTaskGroup(timeout=0.5) as tg:
+                _ = tg.create_task(handler())
+                _ = tg.create_task(sleep_then_log())
+
+        assert messages == ["message"]
+
+    @mark.skipif(get_env_var("SLACK", nullable=True) is None, reason="'SLACK' not set")
+    @throttle(duration=5 * MINUTE)
+    async def test_real(self, *, tmp_path: Path) -> None:
+        url = get_env_var("SLACK")
+        logger = getLogger(str(tmp_path))
+        logger.addHandler(handler := SlackHandlerIQL(url, sleep_core=0.05))
+
+        async def sleep_then_log() -> None:
+            await sleep_dur(duration=0.05)
+            for i in range(10):
+                logger.warning(
+                    "message %d from %s", i, TestSlackHandlerIQL.test_real.__qualname__
+                )
+
+        with raises(ExceptionGroup):  # noqa: PT012
+            async with EnhancedTaskGroup(timeout=0.5) as tg:
+                _ = tg.create_task(handler())
+                _ = tg.create_task(sleep_then_log())