dycw-utilities 0.131.16__tar.gz → 0.131.17__tar.gz

{dycw_utilities-0.131.16 → dycw_utilities-0.131.17}/PKG-INFO

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

{dycw_utilities-0.131.16 → dycw_utilities-0.131.17}/pyproject.toml

@@ -59,7 +59,6 @@ dev = [
   "sqlalchemy >= 2.0.41, < 2.1",
   "statsmodels >= 0.14.4, < 0.15",
   "streamlit >= 1.45.0, < 1.46",
-  "tenacity >= 8.5.0, < 9.0",  # limited by luigi
   "tomlkit >= 0.13.2, < 0.14",
   "typed-settings >= 24.6.0, < 24.7",
   "tzdata >= 2025.2, < 2025.3",
@@ -95,7 +94,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.131.16"
+version = "0.131.17"
 
 [project.optional-dependencies]
 logging = [
@@ -122,7 +121,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.131.16"
+current_version = "0.131.17"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.131.16 → dycw_utilities-0.131.17}/src/tests/test_asyncio.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from asyncio import Event, Queue, run, sleep, timeout
+from asyncio import Event, Queue, run
 from collections import deque
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
@@ -8,7 +8,7 @@ from itertools import chain
 from re import search
 from typing import TYPE_CHECKING, Any, ClassVar, Self, override
 
-from hypothesis import Phase, assume, given, settings
+from hypothesis import assume, given
 from hypothesis.strategies import (
     DataObject,
     booleans,
@@ -49,27 +49,28 @@ from utilities.asyncio import (
     get_items_nowait,
     put_items,
     put_items_nowait,
-    sleep_dur,
-    sleep_max_dur,
+    sleep_max,
+    sleep_rounded,
+    sleep_td,
     sleep_until,
-    sleep_until_rounded,
     stream_command,
-    timeout_dur,
+    timeout_td,
 )
 from utilities.dataclasses import replace_non_sentinel
-from utilities.datetime import MILLISECOND, datetime_duration_to_timedelta, get_now
 from utilities.functions import get_class_name
 from utilities.hypothesis import sentinels, text_ascii
 from utilities.iterables import one, unique_everseen
 from utilities.pytest import skipif_windows
 from utilities.sentinel import Sentinel, sentinel
 from utilities.timer import Timer
+from utilities.whenever2 import SECOND, get_now
 
 if TYPE_CHECKING:
-    import datetime as dt
     from collections.abc import AsyncIterator
 
-    from utilities.types import Duration, MaybeCallableEvent
+    from whenever import TimeDelta
+
+    from utilities.types import MaybeCallableEvent
 
 
 class TestEnhancedQueue:
@@ -144,6 +145,8 @@ class TestEnhancedQueue:
 
 
 class TestEnhancedTaskGroup:
+    delta: ClassVar[TimeDelta] = 0.05 * SECOND
+
     async def test_create_task_context_coroutine(self) -> None:
         flag: bool = False
 
@@ -157,43 +160,43 @@ class TestEnhancedTaskGroup:
                 flag = False
 
         assert not flag
-        async with EnhancedTaskGroup(timeout=0.1) as tg:
+        async with EnhancedTaskGroup(timeout=2 * self.delta) as tg:
             _ = tg.create_task_context(yield_true())
-            await sleep(0.05)
+            await sleep_td(self.delta)
             assert flag
         assert not flag
 
     async def test_create_task_context_looper(self) -> None:
-        looper = CountingLooper().replace(timeout=1.0)
+        looper = CountingLooper().replace(timeout=10 * self.delta)
         assert looper._core_attempts == 0
-        async with EnhancedTaskGroup(timeout=0.1) as tg:
+        async with EnhancedTaskGroup(timeout=2 * self.delta) as tg:
             assert looper._core_attempts == 0
             _ = tg.create_task_context(looper)
-            await sleep(0.05)
+            await sleep_td(self.delta)
         assert looper._core_attempts >= 1
 
     async def test_max_tasks_disabled(self) -> None:
         with Timer() as timer:
             async with EnhancedTaskGroup() as tg:
                 for _ in range(10):
-                    _ = tg.create_task(sleep(0.01))
-        assert timer.timedelta.in_seconds() <= 0.05
+                    _ = tg.create_task(sleep_td(self.delta))
+        assert timer <= 2 * self.delta
 
     async def test_max_tasks_enabled(self) -> None:
         with Timer() as timer:
             async with EnhancedTaskGroup(max_tasks=2) as tg:
                 for _ in range(10):
-                    _ = tg.create_task(sleep(0.01))
-        assert timer.timedelta.in_seconds() >= 0.05
+                    _ = tg.create_task(sleep_td(self.delta))
+        assert timer >= self.delta
 
     async def test_timeout_pass(self) -> None:
-        async with EnhancedTaskGroup(timeout=0.2) as tg:
-            _ = tg.create_task(sleep(0.1))
+        async with EnhancedTaskGroup(timeout=2 * self.delta) as tg:
+            _ = tg.create_task(sleep_td(self.delta))
 
     async def test_timeout_fail(self) -> None:
         with raises(ExceptionGroup) as exc_info:
-            async with EnhancedTaskGroup(timeout=0.05) as tg:
-                _ = tg.create_task(sleep(0.1))
+            async with EnhancedTaskGroup(timeout=self.delta) as tg:
+                _ = tg.create_task(sleep_td(2 * self.delta))
         assert len(exc_info.value.exceptions) == 1
         error = one(exc_info.value.exceptions)
         assert isinstance(error, TimeoutError)
@@ -202,8 +205,8 @@ class TestEnhancedTaskGroup:
         class CustomError(Exception): ...
 
         with raises(ExceptionGroup) as exc_info:
-            async with EnhancedTaskGroup(timeout=0.05, error=CustomError) as tg:
-                _ = tg.create_task(sleep(0.1))
+            async with EnhancedTaskGroup(timeout=self.delta, error=CustomError) as tg:
+                _ = tg.create_task(sleep_td(2 * self.delta))
         assert len(exc_info.value.exceptions) == 1
         error = one(exc_info.value.exceptions)
         assert isinstance(error, CustomError)
@@ -259,12 +262,8 @@ class TestGetItems:
 
 
 class TestLooper:
-    _restart_min_elapsed: ClassVar[dt.timedelta] = datetime_duration_to_timedelta(
-        (0.8 if IS_CI else 1.0) * _BACKOFF
-    )
-    _restart_max_elapsed: ClassVar[dt.timedelta] = datetime_duration_to_timedelta(
-        (1.2 if IS_CI else 1.0) * _FREQ
-    )
+    _restart_min_elapsed: ClassVar[TimeDelta] = (0.8 if IS_CI else 1.0) * _BACKOFF
+    _restart_max_elapsed: ClassVar[TimeDelta] = (1.2 if IS_CI else 1.0) * _FREQ
     skip_sleep_if_failure_cases: ClassVar[list[Any]] = [
         param(True, ""),
         param(False, "; sleeping for .*"),
@@ -279,12 +278,12 @@ class TestLooper:
     async def test_auto_start(self) -> None:
         looper = CountingLooper(auto_start=True)
         with raises(TimeoutError):
-            async with timeout(1.0), looper:
+            async with timeout_td(SECOND), looper:
                 ...
         self._assert_stats_full(looper)
 
     async def test_auto_start_and_timeout(self) -> None:
-        looper = CountingLooper(auto_start=True, timeout=1.0)
+        looper = CountingLooper(auto_start=True, timeout=SECOND)
         async with looper:
             ...
         self._assert_stats_full(looper, stops=1)
@@ -298,7 +297,7 @@ class TestLooper:
     async def test_context_manager_already_entered(
         self, *, caplog: LogCaptureFixture
     ) -> None:
-        looper = CountingLooper(timeout=1.0)
+        looper = CountingLooper(timeout=SECOND)
         async with looper, looper:
             ...
         _ = one(m for m in caplog.messages if search(": already entered$", m))
@@ -311,10 +310,10 @@ class TestLooper:
         assert not looper.empty()
 
     async def test_empty_upon_exit(self) -> None:
-        looper = QueueLooper(freq=0.05, empty_upon_exit=True)
+        looper = QueueLooper(freq=0.05 * SECOND, empty_upon_exit=True)
         looper.put_right_nowait(0)
         assert not looper.empty()
-        async with timeout(1.0), looper:
+        async with timeout_td(SECOND), looper:
             ...
         self._assert_stats_no_runs(looper, entries=1, stops=1)
         assert looper.empty()
@@ -322,7 +321,7 @@ class TestLooper:
     async def test_explicit_start(self) -> None:
         looper = CountingLooper()
         with raises(TimeoutError):
-            async with timeout(1.0), looper:
+            async with timeout_td(SECOND), looper:
                 await looper
         self._assert_stats_full(looper, stops=1)
 
@@ -373,11 +372,11 @@ class TestLooper:
     @mark.parametrize("counter_auto_start", [param(True), param(False)])
     async def test_mixin(self, *, counter_auto_start: bool) -> None:
         looper = LooperWithCounterMixin(
-            auto_start=True, timeout=1.0, counter_auto_start=counter_auto_start
+            auto_start=True, timeout=SECOND, counter_auto_start=counter_auto_start
         )
         if counter_auto_start:
             with raises(TimeoutError):
-                async with timeout(1.0), looper:
+                async with timeout_td(SECOND), looper:
                     ...
             self._assert_stats_half(looper._counter)
         else:
@@ -388,7 +387,7 @@ class TestLooper:
     @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
+            auto_start=True, timeout=SECOND, counter_auto_start=counter_auto_start
         )
         with raises(ExceptionGroup) as exc_info:
             async with EnhancedTaskGroup(timeout=looper.timeout) as tg:
@@ -404,21 +403,21 @@ class TestLooper:
     ) -> None:
         looper = LooperWithCounterMixins(
             auto_start=True,
-            timeout=1.0,
+            timeout=SECOND,
             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:
+                    async with timeout_td(SECOND), 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:
+                    async with timeout_td(SECOND), looper:
                         ...
                 assert_looper_full(looper)
                 self._assert_stats_half(looper._counter1)
@@ -433,13 +432,13 @@ class TestLooper:
     @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
+            auto_start=True, timeout=SECOND, counter_auto_start=counter_auto_start
         )
         looper2 = LooperWithCounterMixin(
-            auto_start=True, timeout=1.0, counter_auto_start=counter_auto_start
+            auto_start=True, timeout=SECOND, counter_auto_start=counter_auto_start
         )
         with raises(ExceptionGroup) as exc_info:  # noqa: PT012
-            async with EnhancedTaskGroup(timeout=1.0) as tg:
+            async with EnhancedTaskGroup(timeout=SECOND) as tg:
                 _ = tg.create_task_context(looper1)
                 _ = tg.create_task_context(looper2)
         errors = exc_info.value.exceptions
@@ -450,8 +449,8 @@ class TestLooper:
         self._assert_stats_half(looper2._counter)
 
     def test_replace(self) -> None:
-        looper = CountingLooper().replace(freq=10.0)
-        assert looper.freq == 10.0
+        looper = CountingLooper().replace(freq=10 * SECOND)
+        assert looper.freq == 10 * SECOND
 
     async def test_request_back_off(self) -> None:
         class Example(CountingLooper):
@@ -463,7 +462,7 @@ class TestLooper:
                 ):
                     self.request_back_off()
 
-        looper = Example(auto_start=True, timeout=1.0)
+        looper = Example(auto_start=True, timeout=SECOND)
         async with looper:
             ...
         assert_looper_stats(
@@ -497,7 +496,7 @@ class TestLooper:
                 ):
                     self.request_restart()
 
-        looper = Example(auto_start=True, timeout=1.0)
+        looper = Example(auto_start=True, timeout=SECOND)
         async with looper:
             ...
         assert_looper_stats(
@@ -531,7 +530,7 @@ class TestLooper:
                 ):
                     self.request_stop()
 
-        looper = Example(auto_start=True, timeout=1.0)
+        looper = Example(auto_start=True, timeout=SECOND)
         async with looper:
             ...
         assert_looper_stats(
@@ -565,7 +564,7 @@ class TestLooper:
                         _ = self.get_right_nowait()
                 self.request_stop_when_empty()
 
-        looper = Example(auto_start=True, timeout=1.0)
+        looper = Example(auto_start=True, timeout=SECOND)
         for i in range(25):
             match i % 2 == 0:
                 case True:
@@ -610,7 +609,7 @@ class TestLooper:
         looper = Example()
         with Timer() as timer:
             await looper.restart()
-        assert timer.timedelta.py_timedelta() >= self._restart_min_elapsed
+        assert timer >= self._restart_min_elapsed
         pattern = rf": encountered {get_class_name(CountingLooperError)}\(\) whilst restarting \(initialize\); sleeping for .*\.\.\.$"
         _ = one(m for m in caplog.messages if search(pattern, m))
 
@@ -627,7 +626,7 @@ class TestLooper:
         looper = Example()
         with Timer() as timer:
             await looper.restart()
-        assert timer.timedelta.py_timedelta() >= self._restart_min_elapsed
+        assert timer >= self._restart_min_elapsed
         pattern = rf": encountered {get_class_name(CountingLooperError)}\(\) whilst restarting \(tear down\); sleeping for .*\.\.\.$"
         _ = one(m for m in caplog.messages if search(pattern, m))
 
@@ -650,7 +649,7 @@ class TestLooper:
         looper = Example()
         with Timer() as timer:
             await looper.restart()
-        assert timer.timedelta.py_timedelta() >= self._restart_min_elapsed
+        assert timer >= self._restart_min_elapsed
         pattern = rf": encountered {get_class_name(CountingLooperError)}\(\) \(tear down\) and then {get_class_name(CountingLooperError)}\(\) \(initialization\) whilst restarting; sleeping for .*\.\.\.$"
         _ = one(m for m in caplog.messages if search(pattern, m))
 
@@ -658,26 +657,26 @@ class TestLooper:
         looper = CountingLooper()
         with Timer() as timer:
             await looper.restart()
-        assert timer.timedelta.py_timedelta() <= self._restart_max_elapsed
+        assert timer <= self._restart_max_elapsed
         pattern = r": finished restarting$"
         _ = one(m for m in caplog.messages if search(pattern, m))
 
     @mark.parametrize("n", [param(0), param(1), param(2)])
     async def test_run_until_empty(self, *, n: int) -> None:
-        looper = QueueLooper(freq=0.05)
+        looper = QueueLooper(freq=0.05 * SECOND)
         looper.put_right_nowait(*range(n))
-        async with timeout(1.0), looper:
+        async with timeout_td(SECOND), looper:
             await looper.run_until_empty()
         assert looper.empty()
 
     @mark.parametrize("inner_auto_start", [param(True), param(False)])
     async def test_sub_looper_one(self, *, inner_auto_start: bool) -> None:
         looper = OuterCountingLooper(
-            auto_start=True, timeout=1.0, inner_auto_start=inner_auto_start
+            auto_start=True, timeout=SECOND, inner_auto_start=inner_auto_start
         )
         if inner_auto_start:
             with raises(TimeoutError):
-                async with timeout(1.0), looper:
+                async with timeout_td(SECOND), looper:
                     ...
             self._assert_stats_full(looper)
             self._assert_stats_half(looper.inner)
@@ -694,21 +693,21 @@ class TestLooper:
     ) -> None:
         looper = MultipleSubLoopers(
             auto_start=True,
-            timeout=1.0,
+            timeout=SECOND,
             inner1_auto_start=inner1_auto_start,
             inner2_auto_start=inner2_auto_start,
         )
         match inner1_auto_start, inner2_auto_start:
             case True, _:
                 with raises(TimeoutError):
-                    async with timeout(1.0), looper:
+                    async with timeout_td(SECOND), looper:
                         ...
                 self._assert_stats_full(looper)
                 self._assert_stats_half(looper.inner1)
                 self._assert_stats_no_runs(looper.inner2)
             case False, True:
                 with raises(TimeoutError):
-                    async with timeout(1.0), looper:
+                    async with timeout_td(SECOND), looper:
                         ...
                 self._assert_stats_full(looper)
                 self._assert_stats_half(looper.inner1)
@@ -727,7 +726,7 @@ class TestLooper:
     ) -> None:
         looper = Outer2CountingLooper(
             auto_start=True,
-            timeout=1.0,
+            timeout=SECOND,
             middle_auto_start=middle_auto_start,
             inner_auto_start=inner_auto_start,
         )
@@ -740,7 +739,7 @@ class TestLooper:
                 self._assert_stats_quarter(looper.middle.inner, stops=1)
             case _, _:
                 with raises(TimeoutError):
-                    async with timeout(1.0), looper:
+                    async with timeout_td(SECOND), looper:
                         ...
                 self._assert_stats_full(looper)
                 self._assert_stats_half(looper.middle)
@@ -777,7 +776,7 @@ class TestLooper:
         _ = one(m for m in caplog.messages if search(pattern, m))
 
     async def test_timeout(self) -> None:
-        looper = CountingLooper(timeout=1.0)
+        looper = CountingLooper(timeout=SECOND)
         with Timer() as timer:
             async with looper:
                 await looper
@@ -905,55 +904,53 @@ class TestUniqueQueue:
         assert queue._set == set()
 
 
-class TestSleepDur:
-    @given(duration=sampled_from([0.1, 10 * MILLISECOND]))
-    @settings(phases={Phase.generate})
-    async def test_main(self, *, duration: Duration) -> None:
+class TestSleepMaxDur:
+    delta: ClassVar[TimeDelta] = 0.05 * SECOND
+
+    async def test_main(self) -> None:
         with Timer() as timer:
-            await sleep_dur(duration=duration)
-        assert timer.timedelta.py_timedelta() <= datetime_duration_to_timedelta(
-            2 * duration
-        )
+            await sleep_max(self.delta)
+        assert timer <= 2 * self.delta
 
     async def test_none(self) -> None:
         with Timer() as timer:
-            await sleep_dur()
-        assert timer.timedelta.in_seconds() <= 0.01
+            await sleep_max()
+        assert timer <= self.delta
 
 
-class TestSleepMaxDur:
-    @given(duration=sampled_from([0.1, 10 * MILLISECOND]))
-    @settings(phases={Phase.generate})
-    async def test_main(self, *, duration: Duration) -> None:
+class TestSleepTD:
+    delta: ClassVar[TimeDelta] = 0.05 * SECOND
+
+    async def test_main(self) -> None:
         with Timer() as timer:
-            await sleep_max_dur(duration=duration)
-        assert timer.timedelta.py_timedelta() <= datetime_duration_to_timedelta(
-            2 * duration
-        )
+            await sleep_td(self.delta)
+        assert timer <= 2 * self.delta
 
     async def test_none(self) -> None:
         with Timer() as timer:
-            await sleep_max_dur()
-        assert timer.timedelta.in_seconds() <= 0.01
+            await sleep_td()
+        assert timer <= self.delta
 
 
 class TestSleepUntil:
     async def test_main(self) -> None:
-        await sleep_until(get_now() + 10 * MILLISECOND)
+        await sleep_until(get_now() + 0.05 * SECOND)
 
 
 class TestSleepUntilRounded:
     async def test_main(self) -> None:
-        await sleep_until_rounded(10 * MILLISECOND)
+        await sleep_rounded(unit="millisecond", increment=10)
 
 
 class TestStreamCommand:
+    delta: ClassVar[TimeDelta] = 0.05 * SECOND
+
     @skipif_windows
     async def test_main(self) -> None:
         output = await stream_command(
             'echo "stdout message" && sleep 0.1 && echo "stderr message" >&2'
         )
-        await sleep(0.01)
+        await sleep_td(self.delta)
         assert output.return_code == 0
         assert output.stdout == "stdout message\n"
         assert output.stderr == "stderr message\n"
@@ -961,7 +958,7 @@ class TestStreamCommand:
     @skipif_windows
     async def test_error(self) -> None:
         output = await stream_command("this-is-an-error")
-        await sleep(0.01)
+        await sleep_td(self.delta)
         assert output.return_code == 127
         assert output.stdout == ""
         assert search(
@@ -969,22 +966,24 @@ class TestStreamCommand:
         )
 
 
-class TestTimeoutDur:
+class TestTimeoutTD:
+    delta: ClassVar[TimeDelta] = 0.05 * SECOND
+
     async def test_pass(self) -> None:
-        async with timeout_dur(duration=0.2):
-            await sleep(0.1)
+        async with timeout_td(2 * self.delta):
+            await sleep_td(self.delta)
 
     async def test_fail(self) -> None:
         with raises(TimeoutError):
-            async with timeout_dur(duration=0.05):
-                await sleep(0.1)
+            async with timeout_td(self.delta):
+                await sleep_td(2 * self.delta)
 
     async def test_custom_error(self) -> None:
         class CustomError(Exception): ...
 
         with raises(CustomError):
-            async with timeout_dur(duration=0.05, error=CustomError):
-                await sleep(0.1)
+            async with timeout_td(self.delta, error=CustomError):
+                await sleep_td(2 * self.delta)
 
 
 if __name__ == "__main__":

{dycw_utilities-0.131.16 → dycw_utilities-0.131.17}/src/tests/test_asyncio_classes/loopers.py

@@ -8,15 +8,16 @@ from pytest import approx
 from tests.conftest import IS_CI
 from utilities.asyncio import Looper
 from utilities.contextlib import suppress_super_object_attribute_error
-from utilities.datetime import MILLISECOND
+from utilities.whenever2 import SECOND
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
-    from utilities.types import Duration
+    from whenever import TimeDelta
 
-_FREQ: Duration = 10 * MILLISECOND
-_BACKOFF: Duration = 100 * MILLISECOND
+
+_FREQ: TimeDelta = 0.01 * SECOND
+_BACKOFF: TimeDelta = 0.1 * SECOND
 _REL: float = 2.0 if IS_CI else 0.25
 
 
@@ -102,8 +103,8 @@ def assert_looper_full(
 
 @dataclass(kw_only=True)
 class CountingLooper(Looper[Any]):
-    freq: Duration = field(default=_FREQ, repr=False)
-    backoff: Duration = field(default=_BACKOFF, repr=False)
+    freq: TimeDelta = field(default=_FREQ, repr=False)
+    backoff: TimeDelta = field(default=_BACKOFF, repr=False)
     _debug: bool = field(default=True, repr=False)
     count: int = 0
     max_count: int = 10
@@ -212,8 +213,8 @@ class Outer2CountingLooper(CountingLooper):
 
 @dataclass(kw_only=True)
 class CounterMixin:
-    freq: Duration = field(default=_FREQ, repr=False)
-    backoff: Duration = field(default=_BACKOFF, repr=False)
+    freq: TimeDelta = field(default=_FREQ, repr=False)
+    backoff: TimeDelta = field(default=_BACKOFF, repr=False)
     _debug: bool = field(default=True, repr=False)
     count: int = 0
     max_count: int = 10
@@ -245,8 +246,8 @@ class LooperWithCounterMixin(CounterMixin, Looper): ...
 
 @dataclass(kw_only=True)
 class CounterMixin1:
-    freq: Duration = field(default=_FREQ, repr=False)
-    backoff: Duration = field(default=_BACKOFF, repr=False)
+    freq: TimeDelta = field(default=_FREQ, repr=False)
+    backoff: TimeDelta = field(default=_BACKOFF, repr=False)
     _debug: bool = field(default=True, repr=False)
     count: int = 0
     max_count: int = 10
@@ -271,8 +272,8 @@ class CounterMixin1:
 
 @dataclass(kw_only=True)
 class CounterMixin2:
-    freq: Duration = field(default=_FREQ, repr=False)
-    backoff: Duration = field(default=_BACKOFF, repr=False)
+    freq: TimeDelta = field(default=_FREQ, repr=False)
+    backoff: TimeDelta = field(default=_BACKOFF, repr=False)
     _debug: bool = field(default=True, repr=False)
     count: int = 0
     max_count: int = 10

{dycw_utilities-0.131.16 → dycw_utilities-0.131.17}/src/tests/test_asyncio_classes/redis.py

@@ -9,20 +9,20 @@ from utilities.redis import PublishServiceMixin, SubscribeServiceMixin
 from utilities.text import unique_str
 
 if TYPE_CHECKING:
-    from utilities.types import Duration
+    from whenever import TimeDelta
 
 
 @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)
+    freq: TimeDelta = field(default=_FREQ, repr=False)
+    backoff: TimeDelta = 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_freq: TimeDelta = field(default=_FREQ, repr=False)
+    publish_service_backoff: TimeDelta = 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_freq: TimeDelta = field(default=_FREQ, repr=False)
+    subscribe_service_backoff: TimeDelta = field(default=_BACKOFF, repr=False)
     subscribe_service_debug: bool = field(default=True, repr=False)
     subscribe_service_channel: str = field(default_factory=unique_str)

{dycw_utilities-0.131.16 → dycw_utilities-0.131.17}/src/tests/test_atools.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from utilities.asyncio import sleep_dur
+from utilities.asyncio import sleep_td
 from utilities.atools import call_memoized
 from utilities.whenever2 import SECOND
 
@@ -20,7 +20,7 @@ class TestCallMemoized:
 
     async def test_refresh(self) -> None:
         counter = 0
-        delta = 0.05 * SECOND
+        delta = 0.1 * SECOND
 
         async def increment() -> int:
             nonlocal counter
@@ -30,7 +30,7 @@ class TestCallMemoized:
         for _ in range(2):
             assert (await call_memoized(increment, delta)) == 1
             assert counter == 1
-        await sleep_dur(duration=2 * delta)
+        await sleep_td(2 * delta)
         for _ in range(2):
             assert (await call_memoized(increment, delta)) == 2
             assert counter == 2