dycw-utilities 0.131.7__tar.gz → 0.131.8__tar.gz

{dycw_utilities-0.131.7 → dycw_utilities-0.131.8}/PKG-INFO

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

{dycw_utilities-0.131.7 → dycw_utilities-0.131.8}/pyproject.toml

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

{dycw_utilities-0.131.7 → dycw_utilities-0.131.8}/src/tests/test_aiolimiter.py

@@ -6,6 +6,7 @@ from typing import ClassVar
 from utilities.aiolimiter import get_async_limiter
 from utilities.text import unique_str
 from utilities.timer import Timer
+from utilities.whenever2 import SECOND
 
 
 class TestGetAsyncLimiter:
@@ -22,7 +23,7 @@ class TestGetAsyncLimiter:
             for _ in range(2):
                 async with get_async_limiter(name, rate=0.5):
                     await increment()
-        assert timer >= 0.48
+        assert timer >= 0.48 * SECOND
 
     shared: ClassVar[str] = unique_str()
 

{dycw_utilities-0.131.7 → dycw_utilities-0.131.8}/src/tests/test_asyncio.py

@@ -177,14 +177,14 @@ class TestEnhancedTaskGroup:
             async with EnhancedTaskGroup() as tg:
                 for _ in range(10):
                     _ = tg.create_task(sleep(0.01))
-        assert timer <= 0.05
+        assert timer.timedelta.in_seconds() <= 0.05
 
     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 >= 0.05
+        assert timer.timedelta.in_seconds() >= 0.05
 
     async def test_timeout_pass(self) -> None:
         async with EnhancedTaskGroup(timeout=0.2) as tg:
@@ -610,7 +610,7 @@ class TestLooper:
         looper = Example()
         with Timer() as timer:
             await looper.restart()
-        assert timer.timedelta >= self._restart_min_elapsed
+        assert timer.timedelta.py_timedelta() >= 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 +627,7 @@ class TestLooper:
         looper = Example()
         with Timer() as timer:
             await looper.restart()
-        assert timer.timedelta >= self._restart_min_elapsed
+        assert timer.timedelta.py_timedelta() >= 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 +650,7 @@ class TestLooper:
         looper = Example()
         with Timer() as timer:
             await looper.restart()
-        assert timer.timedelta >= self._restart_min_elapsed
+        assert timer.timedelta.py_timedelta() >= 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,7 +658,7 @@ class TestLooper:
         looper = CountingLooper()
         with Timer() as timer:
             await looper.restart()
-        assert timer.timedelta <= self._restart_max_elapsed
+        assert timer.timedelta.py_timedelta() <= self._restart_max_elapsed
         pattern = r": finished restarting$"
         _ = one(m for m in caplog.messages if search(pattern, m))
 
@@ -911,12 +911,14 @@ class TestSleepDur:
     async def test_main(self, *, duration: Duration) -> None:
         with Timer() as timer:
             await sleep_dur(duration=duration)
-        assert timer <= datetime_duration_to_timedelta(2 * duration)
+        assert timer.timedelta.py_timedelta() <= datetime_duration_to_timedelta(
+            2 * duration
+        )
 
     async def test_none(self) -> None:
         with Timer() as timer:
             await sleep_dur()
-        assert timer <= 0.01
+        assert timer.timedelta.in_seconds() <= 0.01
 
 
 class TestSleepMaxDur:
@@ -925,12 +927,14 @@ class TestSleepMaxDur:
     async def test_main(self, *, duration: Duration) -> None:
         with Timer() as timer:
             await sleep_max_dur(duration=duration)
-        assert timer <= datetime_duration_to_timedelta(2 * duration)
+        assert timer.timedelta.py_timedelta() <= datetime_duration_to_timedelta(
+            2 * duration
+        )
 
     async def test_none(self) -> None:
         with Timer() as timer:
             await sleep_max_dur()
-        assert timer <= 0.01
+        assert timer.timedelta.in_seconds() <= 0.01
 
 
 class TestSleepUntil:

{dycw_utilities-0.131.7 → dycw_utilities-0.131.8}/src/tests/test_timer.py

@@ -1,15 +1,16 @@
 from __future__ import annotations
 
-import datetime as dt
 from operator import add, eq, ge, gt, le, lt, mul, ne, sub, truediv
 from re import search
 from time import sleep
 from typing import TYPE_CHECKING, Any
 
 from pytest import mark, param, raises
+from whenever import TimeDelta
 
-from utilities.datetime import SECOND, ZERO_TIME
+from utilities.asyncio import sleep_dur
 from utilities.timer import Timer
+from utilities.whenever2 import SECOND, ZERO_TIME
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -17,32 +18,27 @@ if TYPE_CHECKING:
 
 class TestTimer:
     @mark.parametrize(
-        ("op", "other", "cls"),
+        ("op", "other"),
         [
-            param(add, 0, dt.timedelta),
-            param(add, 0.0, dt.timedelta),
-            param(add, ZERO_TIME, dt.timedelta),
-            param(sub, 0, dt.timedelta),
-            param(sub, 0.0, dt.timedelta),
-            param(sub, ZERO_TIME, dt.timedelta),
-            param(mul, 1, dt.timedelta),
-            param(mul, 1.0, dt.timedelta),
-            param(truediv, 1, dt.timedelta),
-            param(truediv, 1.0, dt.timedelta),
-            param(truediv, SECOND, float),
+            param(add, ZERO_TIME),
+            param(sub, ZERO_TIME),
+            param(mul, 1),
+            param(mul, 1.0),
+            param(truediv, 1),
+            param(truediv, 1.0),
         ],
         ids=str,
     )
     def test_arithmetic_against_numbers_or_timedeltas(
-        self, *, op: Callable[[Any, Any], Any], other: Any, cls: type[Any]
+        self, *, op: Callable[[Any, Any], Any], other: Any
     ) -> None:
         with Timer() as timer:
             pass
-        assert isinstance(op(timer, other), cls)
+        assert isinstance(op(timer, other), TimeDelta)
 
     @mark.parametrize(
         ("op", "cls"),
-        [param(add, dt.timedelta), param(sub, dt.timedelta), param(truediv, float)],
+        [param(add, TimeDelta), param(sub, TimeDelta), param(truediv, float)],
         ids=str,
     )
     def test_arithmetic_against_another_timer(
@@ -83,15 +79,12 @@ class TestTimer:
         ],
         ids=str,
     )
-    @mark.parametrize(
-        "dur", [param(1), param(1.0), param(dt.timedelta(seconds=1))], ids=str
-    )
     def test_comparison(
-        self, *, op: Callable[[Any, Any], bool], dur: Any, expected: bool
+        self, *, op: Callable[[Any, Any], bool], expected: bool
     ) -> None:
         with Timer() as timer:
             pass
-        assert op(timer, dur) is expected
+        assert op(timer, SECOND) is expected
 
     @mark.parametrize(
         "op",
@@ -120,28 +113,27 @@ class TestTimer:
         with raises(TypeError):
             _ = op(timer, "")
 
-    def test_context_manager(self) -> None:
-        duration = 0.01
+    async def test_context_manager(self) -> None:
+        delta = 0.01 * SECOND
         with Timer() as timer:
-            assert isinstance(timer, Timer)
-            sleep(2 * duration)
-        assert timer >= duration
+            await sleep_dur(duration=2 * delta)
+        assert timer >= delta
 
     @mark.parametrize("func", [param(repr), param(str)], ids=str)
     def test_repr_and_str(self, *, func: Callable[[Timer], str]) -> None:
         with Timer() as timer:
             sleep(0.01)
         as_str = func(timer)
-        assert search(r"^\d+:\d{2}:\d{2}\.\d{6}$", as_str)
+        assert search(r"^PT0\.\d+S$", as_str)
 
-    def test_running(self) -> None:
-        duration = 0.01
+    async def test_running(self) -> None:
+        delta = 0.01 * SECOND
         timer = Timer()
-        sleep(2 * duration)
-        assert timer >= duration
-        sleep(2 * duration)
-        assert timer >= 2 * duration
+        await sleep_dur(duration=2 * delta)
+        assert timer >= delta
+        await sleep_dur(duration=2 * delta)
+        assert timer >= 2 * delta
 
     def test_timedelta(self) -> None:
         timer = Timer()
-        assert isinstance(timer.timedelta, dt.timedelta)
+        assert isinstance(timer.timedelta, TimeDelta)

{dycw_utilities-0.131.7 → dycw_utilities-0.131.8}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.131.7"
+__version__ = "0.131.8"

{dycw_utilities-0.131.7 → dycw_utilities-0.131.8}/src/utilities/asyncio.py

@@ -43,6 +43,7 @@ from typing import (
 )
 
 from typing_extensions import deprecated
+from whenever import TimeDelta
 
 from utilities.dataclasses import replace_non_sentinel
 from utilities.datetime import (
@@ -961,11 +962,14 @@ def put_items_nowait(items: Iterable[_T], queue: Queue[_T], /) -> None:
 ##
 
 
-async def sleep_dur(*, duration: Duration | None = None) -> None:
+async def sleep_dur(*, duration: Duration | TimeDelta | None = None) -> None:
     """Sleep which accepts durations."""
     if duration is None:
         return
-    await sleep(datetime_duration_to_float(duration))
+    if isinstance(duration, TimeDelta):
+        await sleep(duration.in_seconds())
+    else:
+        await sleep(datetime_duration_to_float(duration))
 
 
 ##

dycw_utilities-0.131.8/src/utilities/timer.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from operator import add, eq, ge, gt, le, lt, mul, ne, sub, truediv
+from typing import TYPE_CHECKING, Any, Self, override
+
+from utilities.whenever2 import get_now_local
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from whenever import TimeDelta, ZonedDateTime
+
+
+class Timer:
+    """Context manager for timing blocks of code."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._start: ZonedDateTime = get_now_local()
+        self._end: ZonedDateTime | None = None
+
+    # arithmetic
+
+    def __add__(self, other: Any) -> TimeDelta:
+        return self._apply_op(add, other)
+
+    def __float__(self) -> float:
+        return self.timedelta.in_seconds()
+
+    def __sub__(self, other: Any) -> TimeDelta:
+        return self._apply_op(sub, other)
+
+    def __mul__(self, other: Any) -> TimeDelta:
+        return self._apply_op(mul, other)
+
+    def __truediv__(self, other: Any) -> TimeDelta:
+        return self._apply_op(truediv, other)
+
+    # context manager
+
+    def __enter__(self) -> Self:
+        self._start = get_now_local()
+        return self
+
+    def __exit__(self, *_: object) -> bool:
+        self._end = get_now_local()
+        return False
+
+    # repr
+
+    @override
+    def __repr__(self) -> str:
+        return self.timedelta.format_common_iso()
+
+    @override
+    def __str__(self) -> str:
+        return self.timedelta.format_common_iso()
+
+    # comparison
+
+    @override
+    def __eq__(self, other: object) -> bool:
+        return self._apply_op(eq, other)
+
+    def __ge__(self, other: Any) -> bool:
+        return self._apply_op(ge, other)
+
+    def __gt__(self, other: Any) -> bool:
+        return self._apply_op(gt, other)
+
+    def __le__(self, other: Any) -> bool:
+        return self._apply_op(le, other)
+
+    def __lt__(self, other: Any) -> bool:
+        return self._apply_op(lt, other)
+
+    @override
+    def __ne__(self, other: object) -> bool:
+        return self._apply_op(ne, other)
+
+    # properties
+
+    @property
+    def timedelta(self) -> TimeDelta:
+        """The elapsed time, as a `timedelta` object."""
+        end_use = get_now_local() if (end := self._end) is None else end
+        return end_use - self._start
+
+    # private
+
+    def _apply_op(self, op: Callable[[Any, Any], Any], other: Any, /) -> Any:
+        if isinstance(other, Timer):
+            return op(self.timedelta, other.timedelta)
+        return op(self.timedelta, other)
+
+
+__all__ = ["Timer"]

{dycw_utilities-0.131.7 → dycw_utilities-0.131.8}/src/utilities/whenever2.py

@@ -53,7 +53,7 @@ DATE_DELTA_PARSABLE_MAX = DateDelta(days=999999)
 ## common constants
 
 
-ZERO_TIME = Time()
+ZERO_TIME = TimeDelta()
 MICROSECOND = TimeDelta(microseconds=1)
 MILLISECOND = TimeDelta(milliseconds=1)
 SECOND = TimeDelta(seconds=1)

dycw_utilities-0.131.7/src/utilities/timer.py

@@ -1,131 +0,0 @@
-from __future__ import annotations
-
-import datetime as dt
-from operator import add, eq, ge, gt, le, lt, mul, ne, sub, truediv
-from timeit import default_timer
-from typing import TYPE_CHECKING, Any, Self, overload, override
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-    from utilities.types import Number
-
-
-class Timer:
-    """Context manager for timing blocks of code."""
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._start = default_timer()
-        self._end: float | None = None
-
-    # arithmetic
-
-    def __add__(self, other: Any) -> dt.timedelta:
-        if isinstance(other, int | float):
-            return dt.timedelta(seconds=self._apply_op(add, other))
-        if isinstance(other, dt.timedelta | Timer):
-            return self._apply_op(add, other)
-        return NotImplemented
-
-    def __float__(self) -> float:
-        end_use = default_timer() if (end := self._end) is None else end
-        return end_use - self._start
-
-    def __sub__(self, other: Any) -> dt.timedelta:
-        if isinstance(other, int | float):
-            return dt.timedelta(seconds=self._apply_op(sub, other))
-        if isinstance(other, dt.timedelta | Timer):
-            return self._apply_op(sub, other)
-        return NotImplemented
-
-    def __mul__(self, other: Any) -> dt.timedelta:
-        if isinstance(other, int | float):
-            return dt.timedelta(seconds=self._apply_op(mul, other))
-        return NotImplemented
-
-    @overload
-    def __truediv__(self, other: Number) -> dt.timedelta: ...
-    @overload
-    def __truediv__(self, other: dt.timedelta | Timer) -> float: ...
-    def __truediv__(self, other: Any) -> dt.timedelta | float:
-        if isinstance(other, int | float):
-            return dt.timedelta(seconds=self._apply_op(truediv, other))
-        if isinstance(other, dt.timedelta | Timer):
-            return self._apply_op(truediv, other)
-        return NotImplemented
-
-    # context manager
-
-    def __enter__(self) -> Self:
-        self._start = default_timer()
-        return self
-
-    def __exit__(self, *_: object) -> bool:
-        self._end = default_timer()
-        return False
-
-    # repr
-
-    @override
-    def __repr__(self) -> str:
-        return str(self.timedelta)
-
-    @override
-    def __str__(self) -> str:
-        return str(self.timedelta)
-
-    # comparison
-
-    @override
-    def __eq__(self, other: object) -> bool:
-        if isinstance(other, int | float | dt.timedelta | Timer):
-            return self._apply_op(eq, other)
-        return False
-
-    def __ge__(self, other: Any) -> bool:
-        if isinstance(other, int | float | dt.timedelta | Timer):
-            return self._apply_op(ge, other)
-        return NotImplemented
-
-    def __gt__(self, other: Any) -> bool:
-        if isinstance(other, int | float | dt.timedelta | Timer):
-            return self._apply_op(gt, other)
-        return NotImplemented
-
-    def __le__(self, other: Any) -> bool:
-        if isinstance(other, int | float | dt.timedelta | Timer):
-            return self._apply_op(le, other)
-        return NotImplemented
-
-    def __lt__(self, other: Any) -> bool:
-        if isinstance(other, int | float | dt.timedelta | Timer):
-            return self._apply_op(lt, other)
-        return NotImplemented
-
-    @override
-    def __ne__(self, other: object) -> bool:
-        if isinstance(other, int | float | dt.timedelta | Timer):
-            return self._apply_op(ne, other)
-        return True
-
-    # properties
-
-    @property
-    def timedelta(self) -> dt.timedelta:
-        """The elapsed time, as a `timedelta` object."""
-        return dt.timedelta(seconds=float(self))
-
-    # private
-
-    def _apply_op(self, op: Callable[[Any, Any], Any], other: Any, /) -> Any:
-        if isinstance(other, int | float):
-            return op(float(self), other)
-        if isinstance(other, Timer):
-            return op(self.timedelta, other.timedelta)
-        if isinstance(other, dt.timedelta):
-            return op(self.timedelta, other)
-        return NotImplemented  # pragma: no cover
-
-
-__all__ = ["Timer"]