dycw-utilities 0.131.12__tar.gz → 0.131.13__tar.gz

{dycw_utilities-0.131.12 → dycw_utilities-0.131.13}/PKG-INFO

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

{dycw_utilities-0.131.12 → dycw_utilities-0.131.13}/pyproject.toml

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

{dycw_utilities-0.131.12 → dycw_utilities-0.131.13}/src/tests/test_atools.py

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

{dycw_utilities-0.131.12 → dycw_utilities-0.131.13}/src/tests/test_cachetools.py

@@ -1,20 +1,32 @@
 from __future__ import annotations
 
-from time import sleep
+from typing import TYPE_CHECKING
 
 from hypothesis import example, given
-from hypothesis.strategies import floats, integers, none
+from hypothesis.strategies import integers, none
 
+from utilities.asyncio import sleep_dur
 from utilities.cachetools import TTLSet, cache
+from utilities.hypothesis import time_deltas_whenever
+from utilities.whenever2 import SECOND
+
+if TYPE_CHECKING:
+    from whenever import TimeDelta
 
 
 class TestCache:
     @example(max_size=None, max_duration=None)
-    @example(max_size=None, max_duration=1.0)
+    @example(max_size=None, max_duration=SECOND)
     @example(max_size=1, max_duration=None)
-    @example(max_size=1, max_duration=1.0)
-    @given(max_size=integers(1, 10) | none(), max_duration=floats(0.1, 10.0) | none())
-    def test_main(self, *, max_size: int, max_duration: float) -> None:
+    @example(max_size=1, max_duration=SECOND)
+    @given(
+        max_size=integers(1, 10) | none(),
+        max_duration=time_deltas_whenever(
+            min_value=0.1 * SECOND, max_value=10.0 * SECOND
+        )
+        | none(),
+    )
+    def test_main(self, *, max_size: int, max_duration: TimeDelta) -> None:
         counter = 0
 
         @cache(max_size=max_size, max_duration=max_duration)
@@ -48,10 +60,11 @@ class TestTTLSet:
         set_ = TTLSet(range(3))
         assert len(set_) == 3
 
-    def test_max_duration(self) -> None:
-        set_ = TTLSet(range(3), max_duration=0.1)
+    async def test_max_duration(self) -> None:
+        delta = 0.1 * SECOND
+        set_ = TTLSet(range(3), max_duration=delta)
         assert set_ == {0, 1, 2}
-        sleep(0.2)
+        await sleep_dur(duration=2 * delta)
         assert set_ == set()
 
     def test_max_size(self) -> None:

{dycw_utilities-0.131.12 → dycw_utilities-0.131.13}/src/tests/test_hypothesis.py

@@ -68,8 +68,6 @@ from utilities.hypothesis import (
     int_arrays,
     lists_fixed_length,
     min_and_max_datetimes,
-    min_and_maybe_max_datetimes,
-    min_and_maybe_max_sizes,
     months,
     namespace_mixins,
     numbers,
@@ -729,59 +727,6 @@ class TestMinAndMaxDateTimes:
             assert max_datetime == max_value
 
 
-class TestMinAndMaybeMaxDateTimes:
-    @given(
-        data=data(),
-        min_value=zoned_datetimes() | none() | just(zoned_datetimes() | none()),
-        max_value=zoned_datetimes()
-        | none()
-        | sentinels()
-        | just(zoned_datetimes() | none() | sentinels()),
-    )
-    def test_main(
-        self,
-        *,
-        data: DataObject,
-        min_value: MaybeSearchStrategy[dt.datetime | None],
-        max_value: MaybeSearchStrategy[dt.datetime | None | Sentinel],
-    ) -> None:
-        min_datetime, max_datetime = data.draw(
-            min_and_maybe_max_datetimes(min_value=min_value, max_value=max_value)
-        )
-        assert (max_datetime is None) or (min_datetime <= max_datetime)
-        if isinstance(min_value, dt.datetime):
-            assert min_datetime == min_value
-        if isinstance(max_value, dt.datetime) or (max_value is None):
-            assert max_datetime == max_value
-
-
-class TestMinAndMaybeMaxSizes:
-    @given(
-        data=data(),
-        min_value=integers(min_value=0) | none() | just(integers(min_value=0) | none()),
-        max_value=integers(min_value=0)
-        | none()
-        | sentinels()
-        | just(integers(min_value=0) | none() | sentinels()),
-    )
-    def test_main(
-        self,
-        *,
-        data: DataObject,
-        min_value: MaybeSearchStrategy[int | None],
-        max_value: MaybeSearchStrategy[int | None | Sentinel],
-    ) -> None:
-        min_size, max_size = data.draw(
-            min_and_maybe_max_sizes(min_value=min_value, max_value=max_value)
-        )
-        assert min_size >= 0
-        assert (max_size is None) or (min_size <= max_size)
-        if isinstance(min_value, int):
-            assert min_size == min_value
-        if isinstance(max_value, int) or (max_value is None):
-            assert max_size == max_value
-
-
 class TestMonths:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:

{dycw_utilities-0.131.12 → dycw_utilities-0.131.13}/src/tests/test_orjson.py

@@ -81,6 +81,7 @@ from utilities.polars import check_polars_dataframe, zoned_datetime
 from utilities.sentinel import Sentinel, sentinel
 from utilities.types import LogLevel, MaybeIterable, PathLike
 from utilities.typing import get_args
+from utilities.tzlocal import LOCAL_TIME_ZONE
 from utilities.whenever2 import MINUTE, SECOND, get_now
 
 if TYPE_CHECKING:
@@ -169,7 +170,7 @@ class TestGetLogRecords:
                 "level": UInt64,
                 "path_name": String,
                 "line_num": UInt64,
-                "datetime": zoned_datetime(time_zone="local"),
+                "datetime": zoned_datetime(time_zone=LOCAL_TIME_ZONE),
                 "func_name": String,
                 "stack_info": String,
                 "extra": Object,

dycw_utilities-0.131.13/src/tests/test_period.py

@@ -0,0 +1,259 @@
+from __future__ import annotations
+
+from re import search
+from typing import TYPE_CHECKING
+
+from hypothesis import HealthCheck, given, settings
+from hypothesis.strategies import DataObject, data, sampled_from
+from pytest import raises
+
+from utilities.hypothesis import (
+    assume_does_not_raise,
+    date_deltas_whenever,
+    dates_whenever,
+    pairs,
+    plain_datetimes_whenever,
+    time_deltas_whenever,
+    zoned_datetimes_whenever,
+)
+from utilities.period import (
+    DatePeriod,
+    ZonedDateTimePeriod,
+    _PeriodAsDict,
+    _PeriodInvalidError,
+    _PeriodTimeZoneError,
+)
+from utilities.tzdata import USCentral, USEastern
+from utilities.whenever2 import DAY
+from utilities.zoneinfo import UTC, get_time_zone_name
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from whenever import Date, DateDelta, PlainDateTime, TimeDelta, ZonedDateTime
+
+
+class TestDatePeriod:
+    @given(dates=pairs(dates_whenever(), sorted=True), delta=date_deltas_whenever())
+    @settings(suppress_health_check={HealthCheck.filter_too_much})
+    def test_add(self, *, dates: tuple[Date, Date], delta: DateDelta) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        with assume_does_not_raise(ValueError, match="Resulting date out of range"):
+            result = period + delta
+        expected = DatePeriod(start + delta, end + delta)
+        assert result == expected
+
+    @given(date=dates_whenever(), dates=pairs(dates_whenever(), sorted=True))
+    def test_contains(self, *, date: Date, dates: tuple[Date, Date]) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        result = date in period
+        expected = start <= date <= end
+        assert result is expected
+
+    @given(dates=pairs(dates_whenever(), sorted=True))
+    def test_delta(self, *, dates: tuple[Date, Date]) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        assert period.delta == (end - start)
+
+    @given(dates=pairs(dates_whenever(), sorted=True))
+    def test_hashable(self, *, dates: tuple[Date, Date]) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        _ = hash(period)
+
+    @given(dates=pairs(dates_whenever(), sorted=True), func=sampled_from([repr, str]))
+    def test_repr(self, *, dates: tuple[Date, Date], func: Callable[..., str]) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        result = func(period)
+        assert search(r"^DatePeriod\(\d{4}-\d{2}-\d{2}, \d{4}-\d{2}-\d{2}\)$", result)
+
+    @given(
+        dates1=pairs(dates_whenever(), sorted=True),
+        dates2=pairs(dates_whenever(), sorted=True),
+    )
+    def test_sortable(
+        self, *, dates1: tuple[Date, Date], dates2: tuple[Date, Date]
+    ) -> None:
+        start1, end1 = dates1
+        start2, end2 = dates2
+        period1 = DatePeriod(start1, end1)
+        period2 = DatePeriod(start2, end2)
+        _ = sorted([period1, period2])
+
+    @given(dates=pairs(dates_whenever(), sorted=True), delta=date_deltas_whenever())
+    @settings(suppress_health_check={HealthCheck.filter_too_much})
+    def test_sub(self, *, dates: tuple[Date, Date], delta: DateDelta) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        with assume_does_not_raise(ValueError, match="Resulting date out of range"):
+            result = period - delta
+        expected = DatePeriod(start - delta, end - delta)
+        assert result == expected
+
+    @given(dates=pairs(dates_whenever(), sorted=True))
+    def test_to_dict(self, *, dates: tuple[Date, Date]) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        result = period.to_dict()
+        expected = _PeriodAsDict(start=start, end=end)
+        assert result == expected
+
+    @given(dates=pairs(dates_whenever(), unique=True, sorted=True))
+    def test_error_period_invalid(self, *, dates: tuple[Date, Date]) -> None:
+        start, end = dates
+        with raises(_PeriodInvalidError, match="Invalid period; got .* > .*"):
+            _ = DatePeriod(end, start)
+
+
+class TestZonedDateTimePeriod:
+    @given(
+        datetimes=pairs(zoned_datetimes_whenever(), sorted=True),
+        delta=time_deltas_whenever(),
+    )
+    @settings(suppress_health_check={HealthCheck.filter_too_much})
+    def test_add(
+        self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime], delta: TimeDelta
+    ) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        with assume_does_not_raise(ValueError, match="Instant is out of range"):
+            result = period + delta
+        expected = ZonedDateTimePeriod(start + delta, end + delta)
+        assert result == expected
+
+    @given(
+        datetime=zoned_datetimes_whenever(),
+        datetimes=pairs(zoned_datetimes_whenever(), sorted=True),
+    )
+    def test_contains(
+        self, *, datetime: ZonedDateTime, datetimes: tuple[ZonedDateTime, ZonedDateTime]
+    ) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        result = datetime in period
+        expected = start <= datetime <= end
+        assert result is expected
+
+    @given(
+        datetime=zoned_datetimes_whenever(),
+        datetimes=pairs(zoned_datetimes_whenever(), sorted=True),
+    )
+    def test_contain_datetime(
+        self, *, datetime: ZonedDateTime, datetimes: tuple[ZonedDateTime, ZonedDateTime]
+    ) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        result = datetime in period
+        expected = start <= datetime <= end
+        assert result is expected
+
+    @given(datetimes=pairs(zoned_datetimes_whenever(), sorted=True))
+    def test_delta(self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime]) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        assert period.delta == (end - start)
+
+    @given(datetimes=pairs(zoned_datetimes_whenever(), sorted=True))
+    def test_hashable(self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime]) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        _ = hash(period)
+
+    @given(
+        data=data(),
+        datetimes=pairs(zoned_datetimes_whenever(), sorted=True),
+        func=sampled_from([repr, str]),
+    )
+    def test_repr(
+        self,
+        *,
+        data: DataObject,
+        datetimes: tuple[ZonedDateTime, ZonedDateTime],
+        func: Callable[..., str],
+    ) -> None:
+        start, end = datetimes
+        datetimes = data.draw(pairs(zoned_datetimes_whenever(), sorted=True))
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        result = func(period)
+        assert search(
+            r"^ZonedDateTimePeriod\(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,9})?, \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,9})?\[.+\]\)$",
+            result,
+        )
+
+    @given(
+        dates1=pairs(zoned_datetimes_whenever(), sorted=True),
+        dates2=pairs(zoned_datetimes_whenever(), sorted=True),
+    )
+    def test_sortable(
+        self,
+        *,
+        dates1: tuple[ZonedDateTime, ZonedDateTime],
+        dates2: tuple[ZonedDateTime, ZonedDateTime],
+    ) -> None:
+        start1, end1 = dates1
+        start2, end2 = dates2
+        period1 = ZonedDateTimePeriod(start1, end1)
+        period2 = ZonedDateTimePeriod(start2, end2)
+        _ = sorted([period1, period2])
+
+    @given(
+        datetimes=pairs(zoned_datetimes_whenever(), sorted=True),
+        delta=time_deltas_whenever(),
+    )
+    @settings(suppress_health_check={HealthCheck.filter_too_much})
+    def test_sub(
+        self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime], delta: TimeDelta
+    ) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        with assume_does_not_raise(ValueError, match="Instant is out of range"):
+            result = period - delta
+        expected = ZonedDateTimePeriod(start - delta, end - delta)
+        assert result == expected
+
+    @given(datetimes=pairs(zoned_datetimes_whenever(), sorted=True))
+    def test_to_dict(self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime]) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        result = period.to_dict()
+        expected = _PeriodAsDict(start=start, end=end)
+        assert result == expected
+
+    @given(datetimes=pairs(zoned_datetimes_whenever(), sorted=True))
+    def test_to_tz(self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime]) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        with assume_does_not_raise(OverflowError, match="date value out of range"):
+            result = period.to_tz(UTC)
+        assert result.time_zone == UTC
+        name = get_time_zone_name(UTC)
+        expected = ZonedDateTimePeriod(start.to_tz(name), end.to_tz(name))
+        assert result == expected
+
+    @given(datetimes=pairs(zoned_datetimes_whenever(), unique=True, sorted=True))
+    @settings(suppress_health_check={HealthCheck.filter_too_much})
+    def test_error_period_invalid(
+        self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime]
+    ) -> None:
+        start, end = datetimes
+        with raises(_PeriodInvalidError, match="Invalid period; got .* > .*"):
+            _ = ZonedDateTimePeriod(end, start)
+
+    @given(datetimes=pairs(plain_datetimes_whenever(), sorted=True))
+    def test_error_period_time_zone(
+        self, *, datetimes: tuple[PlainDateTime, PlainDateTime]
+    ) -> None:
+        plain_start, plain_end = datetimes
+        with assume_does_not_raise(OverflowError, match="date value out of range"):
+            start = (plain_start - DAY).assume_tz(USCentral.key)
+            end = (plain_end + DAY).assume_tz(USEastern.key)
+        with raises(
+            _PeriodTimeZoneError,
+            match="Period must contain exactly one time zone; got .* and .*",
+        ):
+            _ = ZonedDateTimePeriod(start, end)

dycw_utilities-0.131.13/src/tests/test_tzdata.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from zoneinfo import ZoneInfo
+
+from hypothesis import given
+from hypothesis.strategies import sampled_from
+
+from utilities.tzdata import HongKong, Tokyo, USCentral, USEastern
+
+
+class TestTimeZones:
+    @given(time_zone=sampled_from([HongKong, Tokyo, USCentral, USEastern]))
+    def test_main(self, *, time_zone: ZoneInfo) -> None:
+        assert isinstance(time_zone, ZoneInfo)

{dycw_utilities-0.131.12 → dycw_utilities-0.131.13}/src/tests/test_zoneinfo.py

@@ -10,7 +10,7 @@ from pytest import raises
 
 from utilities.hypothesis import zoned_datetimes
 from utilities.tzdata import HongKong, Tokyo
-from utilities.tzlocal import get_local_time_zone
+from utilities.tzlocal import LOCAL_TIME_ZONE, LOCAL_TIME_ZONE_NAME
 from utilities.zoneinfo import (
     UTC,
     _EnsureTimeZoneInvalidTZInfoError,
@@ -45,8 +45,7 @@ class TestEnsureTimeZone:
 
     def test_local(self) -> None:
         result = ensure_time_zone("local")
-        expected = get_local_time_zone()
-        assert result is expected
+        assert result is LOCAL_TIME_ZONE
 
     @given(data=data(), time_zone=timezones())
     def test_zoned_datetime(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
@@ -78,8 +77,7 @@ class TestGetTimeZoneName:
 
     def test_local(self) -> None:
         result = get_time_zone_name("local")
-        expected = get_local_time_zone().key
-        assert result is expected
+        assert result == LOCAL_TIME_ZONE_NAME
 
 
 class TestTimeZones:

{dycw_utilities-0.131.12 → dycw_utilities-0.131.13}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.131.12"
+__version__ = "0.131.13"

{dycw_utilities-0.131.12 → dycw_utilities-0.131.13}/src/utilities/atools.py

@@ -5,25 +5,22 @@ from typing import TYPE_CHECKING, ParamSpec, TypeVar
 
 from atools import memoize
 
-from utilities.datetime import datetime_duration_to_timedelta
 from utilities.types import Coroutine1
 
 if TYPE_CHECKING:
-    import datetime as dt
-
-    from utilities.types import Duration
+    from whenever import TimeDelta
 
 
 _P = ParamSpec("_P")
 _R = TypeVar("_R")
 _AsyncFunc = Callable[_P, Coroutine1[_R]]
-type _Key = tuple[_AsyncFunc, dt.timedelta]
+type _Key = tuple[_AsyncFunc, TimeDelta]
 _MEMOIZED_FUNCS: dict[_Key, _AsyncFunc] = {}
 
 
 async def call_memoized(
     func: _AsyncFunc[_P, _R],
-    refresh: Duration | None = None,
+    refresh: TimeDelta | None = None,
     /,
     *args: _P.args,
     **kwargs: _P.kwargs,
@@ -31,13 +28,14 @@ async def call_memoized(
     """Call an asynchronous function, with possible memoization."""
     if refresh is None:
         return await func(*args, **kwargs)
-    timedelta = datetime_duration_to_timedelta(refresh)
-    key: _Key = (func, timedelta)
+    key: _Key = (func, refresh)
     memoized_func: _AsyncFunc[_P, _R]
     try:
         memoized_func = _MEMOIZED_FUNCS[key]
     except KeyError:
-        memoized_func = _MEMOIZED_FUNCS[(key)] = memoize(duration=refresh)(func)
+        memoized_func = _MEMOIZED_FUNCS[(key)] = memoize(duration=refresh.in_seconds())(
+            func
+        )
     return await memoized_func(*args, **kwargs)
 
 

{dycw_utilities-0.131.12 → dycw_utilities-0.131.13}/src/utilities/cachetools.py

@@ -8,10 +8,10 @@ from typing import TYPE_CHECKING, Any, TypeVar, override
 import cachetools
 from cachetools.func import ttl_cache
 
-from utilities.datetime import datetime_duration_to_float
-
 if TYPE_CHECKING:
-    from utilities.types import Duration, TCallable
+    from whenever import TimeDelta
+
+    from utilities.types import TCallable
 
 _K = TypeVar("_K")
 _T = TypeVar("_T")
@@ -25,15 +25,13 @@ class TTLCache(cachetools.TTLCache[_K, _V]):
         self,
         *,
         max_size: int | None = None,
-        max_duration: Duration | None = None,
+        max_duration: TimeDelta | None = None,
         timer: Callable[[], float] = monotonic,
         get_size_of: Callable[[Any], int] | None = None,
     ) -> None:
         super().__init__(
             maxsize=inf if max_size is None else max_size,
-            ttl=inf
-            if max_duration is None
-            else datetime_duration_to_float(max_duration),
+            ttl=inf if max_duration is None else max_duration.in_seconds(),
             timer=timer,
             getsizeof=get_size_of,
         )
@@ -54,7 +52,7 @@ class TTLSet(MutableSet[_T]):
         /,
         *,
         max_size: int | None = None,
-        max_duration: Duration | None = None,
+        max_duration: TimeDelta | None = None,
         timer: Callable[[], float] = monotonic,
         get_size_of: Callable[[Any], int] | None = None,
     ) -> None:
@@ -103,14 +101,14 @@ class TTLSet(MutableSet[_T]):
 def cache(
     *,
     max_size: int | None = None,
-    max_duration: Duration | None = None,
+    max_duration: TimeDelta | None = None,
     timer: Callable[[], float] = monotonic,
     typed_: bool = False,
 ) -> Callable[[TCallable], TCallable]:
     """Decorate a function with `max_size` and/or `ttl` settings."""
     return ttl_cache(
         maxsize=inf if max_size is None else max_size,
-        ttl=inf if max_duration is None else datetime_duration_to_float(max_duration),
+        ttl=inf if max_duration is None else max_duration.in_seconds(),
         timer=timer,
         typed=typed_,
     )