dycw-utilities 0.126.10__tar.gz → 0.126.12__tar.gz

{dycw_utilities-0.126.10 → dycw_utilities-0.126.12}/PKG-INFO

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

{dycw_utilities-0.126.10 → dycw_utilities-0.126.12}/pyproject.toml

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

{dycw_utilities-0.126.10 → dycw_utilities-0.126.12}/src/tests/test_asyncio.py

@@ -21,16 +21,20 @@ from hypothesis.strategies import (
     permutations,
     sampled_from,
 )
-from pytest import LogCaptureFixture, approx, mark, param, raises
+from pytest import LogCaptureFixture, mark, param, raises
 
 from tests.test_asyncio_classes.loopers import (
+    _REL,
     CountingLooper,
     CountingLooperError,
     LooperWithCounterMixin,
+    LooperWithCounterMixins,
     MultipleSubLoopers,
     Outer2CountingLooper,
     OuterCountingLooper,
     QueueLooper,
+    assert_looper_full,
+    assert_looper_stats,
 )
 from utilities.asyncio import (
     EnhancedQueue,
@@ -195,6 +199,7 @@ class TestEnhancedTaskGroup:
             assert looper.running
         assert not looper.running
 
+    @mark.flaky
     async def test_max_tasks_disabled(self) -> None:
         with Timer() as timer:
             async with EnhancedTaskGroup() as tg:
@@ -607,8 +612,8 @@ class TestInfiniteLooper:
 
         async with timeout(1.0), Parent(sleep_core=0.05) as parent:
             ...
-        assert 15 <= parent.counter <= 25
-        assert 15 <= parent.child.counter <= 25
+        assert 12 <= parent.counter <= 25
+        assert 12 <= parent.child.counter <= 25
 
     async def test_error_default_event(self) -> None:
         @dataclass(kw_only=True)
@@ -864,6 +869,7 @@ class TestInfiniteQueueLooper:
         assert looper.empty()
 
     @given(logger=just("logger") | none())
+    @mark.flaky
     @settings(suppress_health_check={HealthCheck.function_scoped_fixture})
     async def test_error_process_items(
         self, *, logger: str | None, caplog: LogCaptureFixture
@@ -1007,6 +1013,70 @@ class TestLooper:
                 ...
             self._assert_stats_half(looper._counter, stops=1)
 
+    @mark.parametrize("counter_auto_start", [param(True), param(False)])
+    async def test_mixin_in_task_group(self, *, counter_auto_start: bool) -> None:
+        looper = LooperWithCounterMixin(
+            auto_start=True, timeout=1.0, counter_auto_start=counter_auto_start
+        )
+        with raises(ExceptionGroup) as exc_info:
+            async with EnhancedTaskGroup(timeout=looper.timeout) as tg:
+                _ = tg.create_task_context(looper)
+        error = one(exc_info.value.exceptions)
+        assert isinstance(error, TimeoutError)
+        self._assert_stats_half(looper._counter)
+
+    @mark.parametrize("counter1_auto_start", [param(True), param(False)])
+    @mark.parametrize("counter2_auto_start", [param(True), param(False)])
+    async def test_mixins(
+        self, *, counter1_auto_start: bool, counter2_auto_start: bool
+    ) -> None:
+        looper = LooperWithCounterMixins(
+            auto_start=True,
+            timeout=1.0,
+            counter1_auto_start=counter1_auto_start,
+            counter2_auto_start=counter2_auto_start,
+        )
+        match counter1_auto_start, counter2_auto_start:
+            case _, True:
+                with raises(TimeoutError):
+                    async with timeout(1.0), looper:
+                        ...
+                assert_looper_full(looper)
+                self._assert_stats_no_runs(looper._counter1)
+                self._assert_stats_third(looper._counter2)
+            case True, False:
+                with raises(TimeoutError):
+                    async with timeout(1.0), looper:
+                        ...
+                assert_looper_full(looper)
+                self._assert_stats_half(looper._counter1)
+                self._assert_stats_third(looper._counter2)
+            case False, False:
+                async with looper:
+                    ...
+                assert_looper_full(looper, stops=1)
+                self._assert_stats_half(looper._counter1, stops=1)
+                self._assert_stats_third(looper._counter2, stops=1)
+
+    @mark.parametrize("counter_auto_start", [param(True), param(False)])
+    async def test_mixins_in_task_group(self, *, counter_auto_start: bool) -> None:
+        looper1 = LooperWithCounterMixin(
+            auto_start=True, timeout=1.0, counter_auto_start=counter_auto_start
+        )
+        looper2 = LooperWithCounterMixin(
+            auto_start=True, timeout=1.0, counter_auto_start=counter_auto_start
+        )
+        with raises(ExceptionGroup) as exc_info:  # noqa: PT012
+            async with EnhancedTaskGroup(timeout=1.0) as tg:
+                _ = tg.create_task_context(looper1)
+                _ = tg.create_task_context(looper2)
+        errors = exc_info.value.exceptions
+        assert 1 <= len(errors) <= 2
+        for error in errors:
+            assert isinstance(error, TimeoutError)
+        self._assert_stats_half(looper1._counter)
+        self._assert_stats_half(looper2._counter)
+
     def test_replace(self) -> None:
         looper = CountingLooper().replace(freq=10.0)
         assert looper.freq == 10.0
@@ -1024,7 +1094,7 @@ class TestLooper:
         looper = Example(auto_start=True, timeout=1.0)
         async with looper:
             ...
-        self._assert_stats(
+        assert_looper_stats(
             looper,
             entries=1,
             core_successes=79,
@@ -1058,7 +1128,7 @@ class TestLooper:
         looper = Example(auto_start=True, timeout=1.0)
         async with looper:
             ...
-        self._assert_stats(
+        assert_looper_stats(
             looper,
             entries=1,
             core_successes=14,
@@ -1098,7 +1168,7 @@ class TestLooper:
                     looper.put_right_nowait(i)
         async with looper:
             ...
-        self._assert_stats(
+        assert_looper_stats(
             looper,
             entries=1,
             core_successes=25,
@@ -1301,47 +1371,6 @@ class TestLooper:
         assert not looper.auto_start
         assert looper.with_auto_start.auto_start
 
-    def _assert_stats(
-        self,
-        looper: Looper[Any],
-        /,
-        *,
-        entries: int = 0,
-        core_successes: int = 0,
-        core_failures: int = 0,
-        initialization_successes: int = 0,
-        initialization_failures: int = 0,
-        tear_down_successes: int = 0,
-        tear_down_failures: int = 0,
-        restart_successes: int = 0,
-        restart_failures: int = 0,
-        stops: int = 0,
-        rel: float = 0.5,
-    ) -> None:
-        stats = looper.stats
-        assert stats.entries == entries
-        assert stats.core_attempts == (stats.core_successes + stats.core_failures)
-        assert stats.core_successes == approx(core_successes, rel=rel)
-        assert stats.core_failures == approx(core_failures, rel=rel)
-        assert stats.initialization_attempts == (
-            stats.initialization_successes + stats.initialization_failures
-        )
-        assert stats.initialization_successes == approx(
-            initialization_successes, rel=rel
-        )
-        assert stats.initialization_failures == approx(initialization_failures, rel=rel)
-        assert stats.tear_down_attempts == (
-            stats.tear_down_successes + stats.tear_down_failures
-        )
-        assert stats.tear_down_successes == approx(tear_down_successes, rel=rel)
-        assert stats.tear_down_failures == approx(tear_down_failures, rel=rel)
-        assert stats.restart_attempts == (
-            stats.restart_successes + stats.restart_failures
-        )
-        assert stats.restart_successes == approx(restart_successes, rel=rel)
-        assert stats.restart_failures == approx(restart_failures, rel=rel)
-        assert stats.stops == stops
-
     def _assert_stats_no_runs(
         self,
         looper: Looper[Any],
@@ -1349,14 +1378,14 @@ class TestLooper:
         *,
         entries: int = 0,
         stops: int = 0,
-        rel: float = 0.75,
+        rel: float = _REL,
     ) -> None:
-        self._assert_stats(looper, entries=entries, stops=stops, rel=rel)
+        assert_looper_stats(looper, entries=entries, stops=stops, rel=rel)
 
     def _assert_stats_full(
-        self, looper: Looper[Any], /, *, stops: int = 0, rel: float = 0.75
+        self, looper: Looper[Any], /, *, stops: int = 0, rel: float = _REL
     ) -> None:
-        self._assert_stats(
+        assert_looper_stats(
             looper,
             entries=1,
             core_successes=45,
@@ -1369,9 +1398,9 @@ class TestLooper:
         )
 
     def _assert_stats_half(
-        self, looper: Looper[Any], /, *, stops: int = 0, rel: float = 0.75
+        self, looper: Looper[Any], /, *, stops: int = 0, rel: float = _REL
     ) -> None:
-        self._assert_stats(
+        assert_looper_stats(
             looper,
             entries=1,
             core_successes=56,
@@ -1384,9 +1413,9 @@ class TestLooper:
         )
 
     def _assert_stats_third(
-        self, looper: Looper[Any], /, *, stops: int = 0, rel: float = 0.75
+        self, looper: Looper[Any], /, *, stops: int = 0, rel: float = _REL
     ) -> None:
-        self._assert_stats(
+        assert_looper_stats(
             looper,
             entries=1,
             core_successes=49,
@@ -1399,9 +1428,9 @@ class TestLooper:
         )
 
     def _assert_stats_quarter(
-        self, looper: Looper[Any], /, *, stops: int = 0, rel: float = 0.75
+        self, looper: Looper[Any], /, *, stops: int = 0, rel: float = _REL
     ) -> None:
-        self._assert_stats(
+        assert_looper_stats(
             looper,
             entries=1,
             core_successes=35,

dycw_utilities-0.126.12/src/tests/test_asyncio_classes/loopers.py

@@ -0,0 +1,310 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Literal, override
+
+from pytest import approx
+
+from utilities.asyncio import Looper
+from utilities.contextlib import suppress_super_object_attribute_error
+from utilities.datetime import MILLISECOND
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from utilities.types import Duration
+
+_FREQ: Duration = 10 * MILLISECOND
+_BACKOFF: Duration = 100 * MILLISECOND
+_REL: float = 0.75
+
+
+# assert
+
+
+def assert_looper_stats(
+    looper: Looper[Any],
+    /,
+    *,
+    entries: int = 0,
+    core_successes: int | tuple[Literal[">="], int] = 0,
+    core_failures: int = 0,
+    initialization_successes: int = 0,
+    initialization_failures: int = 0,
+    tear_down_successes: int = 0,
+    tear_down_failures: int = 0,
+    restart_successes: int = 0,
+    restart_failures: int = 0,
+    stops: int = 0,
+    rel: float = _REL,
+) -> None:
+    stats = looper.stats
+    assert stats.entries == entries, f"{stats=}, {entries=}"
+    assert stats.core_attempts == (stats.core_successes + stats.core_failures), (
+        f"{stats=}"
+    )
+    match core_successes:
+        case int():
+            assert stats.core_successes == approx(core_successes, rel=rel), (
+                f"{stats=}, {core_successes=}"
+            )
+        case ">=", int() as min_successes:
+            assert stats.core_successes >= min_successes, f"{stats=}, {min_successes=}"
+    assert stats.core_failures == approx(core_failures, rel=rel), (
+        f"{stats=}, {core_failures=}"
+    )
+    assert stats.initialization_attempts == (
+        stats.initialization_successes + stats.initialization_failures
+    ), f"{stats=}"
+    assert stats.initialization_successes == approx(
+        initialization_successes, rel=rel
+    ), f"{stats=}, {initialization_successes=}"
+    assert stats.initialization_failures == approx(initialization_failures, rel=rel), (
+        f"{stats=}, {initialization_failures=}"
+    )
+    assert stats.tear_down_attempts == (
+        stats.tear_down_successes + stats.tear_down_failures
+    ), f"{stats=}"
+    assert stats.tear_down_successes == approx(tear_down_successes, rel=rel), (
+        f"{stats=}, {tear_down_successes=}"
+    )
+    assert stats.tear_down_failures == approx(tear_down_failures, rel=rel), (
+        f"{stats=}, {initialization_failures=}"
+    )
+    assert stats.restart_attempts == (
+        stats.restart_successes + stats.restart_failures
+    ), f"{stats=}"
+    assert stats.restart_successes == approx(restart_successes, rel=rel), (
+        f"{stats=}, {restart_successes=}"
+    )
+    assert stats.restart_failures == approx(restart_failures, rel=rel), (
+        f"{stats=}, {restart_failures=}"
+    )
+    assert stats.stops == stops, f"{stats=}, {stops=}"
+
+
+def assert_looper_full(
+    looper: Looper[Any], /, *, stops: int = 0, rel: float = _REL
+) -> None:
+    assert_looper_stats(
+        looper,
+        entries=1,
+        core_successes=99,
+        initialization_successes=1,
+        stops=stops,
+        rel=rel,
+    )
+
+
+# counting looper
+
+
+@dataclass(kw_only=True)
+class CountingLooper(Looper[Any]):
+    freq: Duration = field(default=_FREQ, repr=False)
+    backoff: Duration = field(default=_BACKOFF, repr=False)
+    _debug: bool = field(default=True, repr=False)
+    count: int = 0
+    max_count: int = 10
+
+    @override
+    async def _initialize_core(self) -> None:
+        await super()._initialize_core()
+        self.count = 0
+
+    @override
+    async def core(self) -> None:
+        await super().core()
+        self.count += 1
+        if self.count >= self.max_count:
+            raise CountingLooperError
+
+
+class CountingLooperError(Exception): ...
+
+
+# one sub looper
+
+
+@dataclass(kw_only=True)
+class OuterCountingLooper(CountingLooper):
+    inner: CountingLooper = field(init=False, repr=False)
+    inner_auto_start: bool = False
+
+    @override
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self.inner = CountingLooper(
+            auto_start=self.inner_auto_start,
+            freq=self.freq / 2,
+            backoff=self.backoff / 2,
+            max_count=round(self.max_count / 2),
+        )
+
+    @override
+    def _yield_sub_loopers(self) -> Iterator[Looper]:
+        yield from super()._yield_sub_loopers()
+        yield self.inner
+
+
+# two sub loopers
+
+
+@dataclass(kw_only=True)
+class MultipleSubLoopers(CountingLooper):
+    inner1: CountingLooper = field(init=False, repr=False)
+    inner2: CountingLooper = field(init=False, repr=False)
+    inner1_auto_start: bool = False
+    inner2_auto_start: bool = False
+
+    @override
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self.inner1 = CountingLooper(
+            auto_start=self.inner1_auto_start,
+            freq=self.freq / 2,
+            backoff=self.backoff / 2,
+            max_count=round(self.max_count / 2),
+        )
+        self.inner2 = CountingLooper(
+            auto_start=self.inner2_auto_start,
+            freq=self.freq / 3,
+            backoff=self.backoff / 3,
+            max_count=round(self.max_count / 3),
+        )
+
+    @override
+    def _yield_sub_loopers(self) -> Iterator[Looper]:
+        yield from super()._yield_sub_loopers()
+        yield self.inner1
+        yield self.inner2
+
+
+# nested sub loopers
+
+
+@dataclass(kw_only=True)
+class Outer2CountingLooper(CountingLooper):
+    middle: OuterCountingLooper = field(init=False, repr=False)
+    middle_auto_start: bool = False
+    inner_auto_start: bool = False
+
+    @override
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self.middle = OuterCountingLooper(
+            auto_start=self.middle_auto_start,
+            freq=self.freq / 2,
+            backoff=self.backoff / 2,
+            max_count=round(self.max_count / 2),
+            inner_auto_start=self.inner_auto_start,
+        )
+
+    @override
+    def _yield_sub_loopers(self) -> Iterator[Looper]:
+        yield from super()._yield_sub_loopers()
+        yield self.middle
+
+
+# one mixin
+
+
+@dataclass(kw_only=True)
+class CounterMixin:
+    freq: Duration = field(default=_FREQ, repr=False)
+    backoff: Duration = field(default=_BACKOFF, repr=False)
+    _debug: bool = field(default=True, repr=False)
+    count: int = 0
+    max_count: int = 10
+    counter_auto_start: bool = False
+    _counter: CountingLooper = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        with suppress_super_object_attribute_error():
+            super().__post_init__()  # pyright: ignore[reportAttributeAccessIssue]
+        self._counter = CountingLooper(
+            auto_start=self.counter_auto_start,
+            freq=self.freq / 2,
+            backoff=self.backoff / 2,
+            max_count=round(self.max_count / 2),
+        )
+
+    def _yield_sub_loopers(self) -> Iterator[Looper[Any]]:
+        with suppress_super_object_attribute_error():
+            yield from super()._yield_sub_loopers()  # pyright: ignore[reportAttributeAccessIssue]
+        yield self._counter
+
+
+@dataclass(kw_only=True)
+class LooperWithCounterMixin(CounterMixin, Looper): ...
+
+
+# two mixins
+
+
+@dataclass(kw_only=True)
+class CounterMixin1:
+    freq: Duration = field(default=_FREQ, repr=False)
+    backoff: Duration = field(default=_BACKOFF, repr=False)
+    _debug: bool = field(default=True, repr=False)
+    count: int = 0
+    max_count: int = 10
+    counter1_auto_start: bool = False
+    _counter1: CountingLooper = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        with suppress_super_object_attribute_error():
+            super().__post_init__()  # pyright: ignore[reportAttributeAccessIssue]
+        self._counter1 = CountingLooper(
+            auto_start=self.counter1_auto_start,
+            freq=self.freq / 2,
+            backoff=self.backoff / 2,
+            max_count=round(self.max_count / 2),
+        )
+
+    def _yield_sub_loopers(self) -> Iterator[Looper[Any]]:
+        with suppress_super_object_attribute_error():
+            yield from super()._yield_sub_loopers()  # pyright: ignore[reportAttributeAccessIssue]
+        yield self._counter1
+
+
+@dataclass(kw_only=True)
+class CounterMixin2:
+    freq: Duration = field(default=_FREQ, repr=False)
+    backoff: Duration = field(default=_BACKOFF, repr=False)
+    _debug: bool = field(default=True, repr=False)
+    count: int = 0
+    max_count: int = 10
+    counter2_auto_start: bool = False
+    _counter2: CountingLooper = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        with suppress_super_object_attribute_error():
+            super().__post_init__()  # pyright: ignore[reportAttributeAccessIssue]
+        self._counter2 = CountingLooper(
+            auto_start=self.counter2_auto_start,
+            freq=self.freq / 3,
+            backoff=self.backoff / 3,
+            max_count=round(self.max_count / 3),
+        )
+
+    def _yield_sub_loopers(self) -> Iterator[Looper[Any]]:
+        with suppress_super_object_attribute_error():
+            yield from super()._yield_sub_loopers()  # pyright: ignore[reportAttributeAccessIssue]
+        yield self._counter2
+
+
+@dataclass(kw_only=True)
+class LooperWithCounterMixins(CounterMixin1, CounterMixin2, Looper): ...
+
+
+# queue looper
+
+
+@dataclass(kw_only=True)
+class QueueLooper(Looper[int]):
+    @override
+    async def core(self) -> None:
+        await super().core()
+        if not self.empty():
+            _ = self.get_left_nowait()

dycw_utilities-0.126.12/src/tests/test_asyncio_classes/redis.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from tests.test_asyncio_classes.loopers import _BACKOFF, _FREQ
+from utilities.asyncio import Looper
+from utilities.redis import PublishServiceMixin, SubscribeServiceMixin
+from utilities.text import unique_str
+
+if TYPE_CHECKING:
+    from utilities.types import Duration
+
+
+@dataclass(kw_only=True)
+class LooperWithPublishAndSubscribeMixins(
+    PublishServiceMixin[Any], SubscribeServiceMixin[Any], Looper[Any]
+):
+    freq: Duration = field(default=_FREQ, repr=False)
+    backoff: Duration = field(default=_BACKOFF, repr=False)
+    _debug: bool = field(default=True, repr=False)
+    publish_service_freq: Duration = field(default=_FREQ, repr=False)
+    publish_service_backoff: Duration = field(default=_BACKOFF, repr=False)
+    publish_service_debug: bool = field(default=True, repr=False)
+    subscribe_service_freq: Duration = field(default=_FREQ, repr=False)
+    subscribe_service_backoff: Duration = field(default=_BACKOFF, repr=False)
+    subscribe_service_debug: bool = field(default=True, repr=False)
+    subscribe_service_channel: str = field(default_factory=unique_str)