save

Author: dycw

src/tests/test_asyncio.py

@@ -20,7 +20,7 @@
     to_list,
     try_await,
 )
-from utilities.datetime import MILLISECOND, ZERO_TIME, duration_to_timedelta
+from utilities.datetime import MILLISECOND, ZERO_TIME, datetime_duration_to_timedelta
 from utilities.hypothesis import durations
 from utilities.pytest import skipif_windows
 from utilities.timer import Timer
@@ -125,7 +125,7 @@ class TestSleepDur:
     async def test_main(self, *, duration: Duration) -> None:
         with Timer() as timer:
             await sleep_dur(duration=duration)
-        assert timer >= duration_to_timedelta(duration / 2)
+        assert timer >= datetime_duration_to_timedelta(duration / 2)
 
     async def test_none(self) -> None:
         with Timer() as timer:

src/tests/test_datetime.py

@@ -45,10 +45,11 @@
     TODAY_UTC,
     WEEK,
     YEAR,
+    ZERO_TIME,
+    AddDurationError,
     AddWeekdaysError,
     CheckDateNotDatetimeError,
     CheckZonedDatetimeError,
-    DateAddTimeDeltaError,
     EnsureMonthError,
     MillisecondsSinceEpochError,
     Month,
@@ -57,18 +58,18 @@
     TimedeltaToMillisecondsError,
     YieldDaysError,
     YieldWeekdaysError,
+    add_duration,
     add_weekdays,
     check_date_not_datetime,
     check_zoned_datetime,
-    date_add_timedelta,
     date_to_datetime,
     date_to_month,
+    datetime_duration_to_float,
+    datetime_duration_to_timedelta,
     days_since_epoch,
     days_since_epoch_to_date,
     drop_microseconds,
     drop_milli_and_microseconds,
-    duration_to_float,
-    duration_to_timedelta,
     ensure_month,
     format_datetime_local_and_utc,
     get_half_years,
@@ -84,6 +85,7 @@
     is_equal_as_months,
     is_equal_mod_tz,
     is_instance_date_not_datetime,
+    is_integral_timedelta,
     is_local_datetime,
     is_subclass_date_not_datetime,
     is_weekday,
@@ -120,6 +122,34 @@
     from utilities.types import Number
 
 
+class TestAddDuration:
+    @given(date=dates(), days=integers())
+    def test_date(self, *, date: dt.date, days: int) -> None:
+        with assume_does_not_raise(OverflowError):
+            timedelta = days * DAY
+        with assume_does_not_raise(OverflowError):
+            result = add_duration(date, timedelta=timedelta)
+        assert is_instance_date_not_datetime(result)
+
+    @given(date=dates(), timedelta=timedeltas())
+    def test_datetime(self, *, date: dt.date, days: int) -> None:
+        with assume_does_not_raise(OverflowError):
+            timedelta = days * DAY
+        with assume_does_not_raise(OverflowError):
+            result = add_duration(date, timedelta=timedelta)
+        assert is_instance_date_not_datetime(result)
+
+    @given(date=dates())
+    def test_none(self, *, date: dt.date) -> None:
+        result = add_duration(date)
+        assert result == date
+
+    @given(date=dates())
+    def test_error(self, *, date: dt.date) -> None:
+        with raises(AddDurationError, match="Timedelta must be day-only; got .*"):
+            _ = add_duration(date, timedelta=SECOND)
+
+
 class TestAddWeekdays:
     @given(date=dates(), n=integers(-10, 10))
     @mark.parametrize("predicate", [param(gt), param(lt)])
@@ -178,26 +208,6 @@ def test_datetime(self, *, datetime: dt.datetime) -> None:
             check_zoned_datetime(datetime)
 
 
-class TestDateAddTimedelta:
-    @given(date=dates(), days=integers())
-    def test_main(self, *, date: dt.date, days: int) -> None:
-        with assume_does_not_raise(OverflowError):
-            timedelta = days * DAY
-        with assume_does_not_raise(OverflowError):
-            result = date_add_timedelta(date, timedelta=timedelta)
-        assert is_instance_date_not_datetime(result)
-
-    @given(date=dates())
-    def test_none(self, *, date: dt.date) -> None:
-        result = date_add_timedelta(date)
-        assert result == date
-
-    @given(date=dates())
-    def test_error(self, *, date: dt.date) -> None:
-        with raises(DateAddTimeDeltaError, match="Timedelta must be day-only; got .*"):
-            _ = date_add_timedelta(date, timedelta=SECOND)
-
-
 class TestDateToDatetime:
     @given(date=dates())
     def test_main(self, *, date: dt.date) -> None:
@@ -212,6 +222,18 @@ def test_main(self, *, date: dt.date) -> None:
         assert result == date
 
 
+class TestDateTimeDurationToFloat:
+    @given(duration=integers(0, 10) | floats(0.0, 10.0))
+    def test_number(self, *, duration: Number) -> None:
+        result = datetime_duration_to_float(duration)
+        assert result == duration
+
+    @given(duration=timedeltas())
+    def test_timedelta(self, *, duration: dt.timedelta) -> None:
+        result = datetime_duration_to_float(duration)
+        assert result == duration.total_seconds()
+
+
 class TestDaysSinceEpoch:
     @given(date=dates())
     def test_datetime_to_microseconds(self, *, date: dt.date) -> None:
@@ -235,33 +257,21 @@ def test_main(self, *, datetime: dt.datetime) -> None:
         assert result.microsecond == 0
 
 
-class TestDurationToFloat:
-    @given(duration=integers(0, 10) | floats(0.0, 10.0))
-    def test_number(self, *, duration: Number) -> None:
-        result = duration_to_float(duration)
-        assert result == duration
-
-    @given(duration=timedeltas())
-    def test_timedelta(self, *, duration: dt.timedelta) -> None:
-        result = duration_to_float(duration)
-        assert result == duration.total_seconds()
-
-
 class TestDurationToTimedelta:
     @given(duration=integers(0, 10))
     def test_int(self, *, duration: int) -> None:
-        result = duration_to_timedelta(duration)
+        result = datetime_duration_to_timedelta(duration)
         assert result.total_seconds() == duration
 
     @given(duration=floats(0.0, 10.0))
     def test_float(self, *, duration: float) -> None:
         duration = round(10 * duration) / 10
-        result = duration_to_timedelta(duration)
+        result = datetime_duration_to_timedelta(duration)
         assert isclose(result.total_seconds(), duration)
 
     @given(duration=timedeltas())
     def test_timedelta(self, *, duration: dt.timedelta) -> None:
-        result = duration_to_timedelta(duration)
+        result = datetime_duration_to_timedelta(duration)
         assert result == duration
 
 
@@ -428,6 +438,25 @@ def test_local_vs_zoned(
         assert result is expected
 
 
+class TestIsIntegralTimeDelta:
+    @given(n=integers())
+    def test_integral(self, *, n: int) -> None:
+        with assume_does_not_raise(OverflowError):
+            timedelta = dt.timedelta(days=n)
+        assert is_integral_timedelta(timedelta)
+
+    @given(
+        n=integers(),
+        frac=timedeltas(
+            min_value=-(DAY - MICROSECOND), max_value=DAY - MICROSECOND
+        ).filter(lambda x: x != ZERO_TIME),
+    )
+    def test_non_integral(self, *, n: int, frac: dt.timedelta) -> None:
+        with assume_does_not_raise(OverflowError):
+            timedelta = dt.timedelta(days=n) + frac
+        assert not is_integral_timedelta(timedelta)
+
+
 class TestIsLocalDateTime:
     @mark.parametrize(
         ("obj", "expected"),

src/tests/test_hypothesis.py

@@ -33,7 +33,11 @@
 from sqlalchemy.ext.asyncio import AsyncEngine
 
 from tests.conftest import FLAKY, SKIPIF_CI_AND_NOT_LINUX, SKIPIF_CI_AND_WINDOWS
-from utilities.datetime import duration_to_float, is_local_datetime, is_zoned_datetime
+from utilities.datetime import (
+    datetime_duration_to_float,
+    is_local_datetime,
+    is_zoned_datetime,
+)
 from utilities.functions import make_isinstance
 from utilities.git import _GIT_REMOTE_GET_URL_ORIGIN, _GIT_REV_PARSE_ABBREV_REV_HEAD
 from utilities.hypothesis import (
@@ -200,7 +204,7 @@ def test_int_and_float_bounds(self, *, data: DataObject) -> None:
         max_number = data.draw(floats(0.0, 10.0))
         duration = data.draw(durations(min_number=min_number, max_number=max_number))
         _ = assume(isinstance(duration, int | float))
-        as_float = duration_to_float(duration)
+        as_float = datetime_duration_to_float(duration)
         assert min_number <= as_float <= max_number
 
     @given(

src/utilities/asyncio.py

@@ -18,7 +18,7 @@
 from sys import stderr, stdout
 from typing import TYPE_CHECKING, Any, TextIO, TypeAlias, TypeGuard, TypeVar, cast
 
-from utilities.datetime import duration_to_float
+from utilities.datetime import datetime_duration_to_float
 from utilities.functions import EnsureStrError, ensure_int, ensure_not_none, ensure_str
 from utilities.iterables import OneError, one
 from utilities.types import MaybeAwaitable
@@ -75,7 +75,7 @@ async def sleep_dur(*, duration: Duration | None = None) -> None:
     """Sleep which accepts durations."""
     if duration is None:
         return
-    await sleep(duration_to_float(duration))
+    await sleep(datetime_duration_to_float(duration))
 
 
 @dataclass(kw_only=True, slots=True)
@@ -127,7 +127,7 @@ async def _stream_one(
 
 def timeout_dur(*, duration: Duration | None = None) -> Timeout:
     """Timeout context manager which accepts durations."""
-    delay = None if duration is None else duration_to_float(duration)
+    delay = None if duration is None else datetime_duration_to_float(duration)
     return timeout(delay)
 
 

src/utilities/atools.py

@@ -19,7 +19,7 @@
 from atools._memoize_decorator import Pickler, _AsyncMemoize
 from typing_extensions import override
 
-from utilities.datetime import duration_to_timedelta
+from utilities.datetime import datetime_duration_to_timedelta
 from utilities.functions import ensure_class
 from utilities.types import Coroutine1, Duration
 from utilities.typing import get_args
@@ -136,7 +136,7 @@ async def call_memoized(
     """Call an asynchronous function, with possible memoization."""
     if refresh is None:
         return await func(*args, **kwargs)
-    timedelta = duration_to_timedelta(refresh)
+    timedelta = datetime_duration_to_timedelta(refresh)
     try:
         memoized = _MEMOIZED_FUNCS[(func, timedelta)]
     except KeyError:

src/utilities/cachetools.py

@@ -5,7 +5,7 @@
 
 from cachetools.func import ttl_cache
 
-from utilities.datetime import duration_to_float
+from utilities.datetime import datetime_duration_to_float
 from utilities.functions import identity
 from utilities.functools import lru_cache
 
@@ -20,7 +20,7 @@ def cache(
 ) -> Callable[[_F], _F]:
     """Decorate a function with `max_size` and/or `ttl` settings."""
     if max_duration is not None:
-        return ttl_cache(maxsize=max_size, ttl=duration_to_float(max_duration))
+        return ttl_cache(maxsize=max_size, ttl=datetime_duration_to_float(max_duration))
     if max_size is not None:
         return cast(Any, lru_cache(max_size=max_size))
     return identity