dycw-utilities 0.131.19__tar.gz → 0.132.0__tar.gz

{dycw_utilities-0.131.19 → dycw_utilities-0.132.0}/PKG-INFO

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

{dycw_utilities-0.131.19 → dycw_utilities-0.132.0}/pyproject.toml

@@ -14,7 +14,7 @@ dev = [
   "altair >= 5.5.0, < 5.6",
   "asyncpg >= 0.30.0, < 0.31",  # for sqlalchemy async
   "atools >= 0.14.2, < 0.15",
-  "cachetools >= 5.5.2, < 5.6",
+  "cachetools >= 5.5.2, < 5.6",  # blocked by streamlit
   "click >= 8.2.1, < 8.3",
   "coloredlogs >= 15.0.1, < 15.1",
   "cryptography >= 45.0.4, < 45.1",
@@ -94,7 +94,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.131.19"
+version = "0.132.0"
 
 [project.optional-dependencies]
 logging = [
@@ -121,7 +121,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.131.19"
+current_version = "0.132.0"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.131.19 → dycw_utilities-0.132.0}/src/tests/conftest.py

@@ -14,7 +14,7 @@ from whenever import PlainDateTime
 from utilities.platform import IS_NOT_LINUX, IS_WINDOWS
 from utilities.re import ExtractGroupError, extract_group
 from utilities.tzlocal import LOCAL_TIME_ZONE_NAME
-from utilities.whenever2 import MINUTE, get_now
+from utilities.whenever import MINUTE, get_now
 
 if TYPE_CHECKING:
     from collections.abc import Iterator, Sequence

{dycw_utilities-0.131.19 → dycw_utilities-0.132.0}/src/tests/test_aiolimiter.py

@@ -6,7 +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
+from utilities.whenever import SECOND
 
 
 class TestGetAsyncLimiter:

{dycw_utilities-0.131.19 → dycw_utilities-0.132.0}/src/tests/test_altair.py

@@ -27,10 +27,10 @@ from utilities.altair import (
     vconcat_charts,
 )
 from utilities.functions import ensure_class
-from utilities.hypothesis import dates_whenever, text_ascii, zoned_datetimes_whenever
+from utilities.hypothesis import dates, text_ascii, zoned_datetimes
 from utilities.polars import DatetimeUTC, zoned_datetime
 from utilities.tzdata import HongKong, Tokyo
-from utilities.whenever2 import get_now
+from utilities.whenever import get_now
 from utilities.zoneinfo import UTC
 
 if TYPE_CHECKING:
@@ -105,7 +105,7 @@ class TestPlotDataFrames:
         expected = dt.datetime(2000, 1, 1, 12, tzinfo=time_zone).replace(tzinfo=None)
         assert datetime == expected
 
-    @given(data=lists(tuples(dates_whenever(), floats(-10, 10))))
+    @given(data=lists(tuples(dates(), floats(-10, 10))))
     def test_tooltip_format_date(
         self, *, data: list[tuple[whenever.Date, float]]
     ) -> None:
@@ -116,7 +116,7 @@ class TestPlotDataFrames:
         )
         _ = plot_dataframes(df, x="index", y="value")
 
-    @given(data=lists(tuples(zoned_datetimes_whenever(), floats(-10, 10))))
+    @given(data=lists(tuples(zoned_datetimes(), floats(-10, 10))))
     def test_tooltip_format_date_time(
         self, *, data: list[tuple[ZonedDateTime, float]]
     ) -> None:

{dycw_utilities-0.131.19 → dycw_utilities-0.132.0}/src/tests/test_asyncio.py

@@ -63,7 +63,7 @@ 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
+from utilities.whenever import SECOND, get_now
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator

{dycw_utilities-0.131.19 → dycw_utilities-0.132.0}/src/tests/test_asyncio_classes/loopers.py

@@ -8,7 +8,7 @@ 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.whenever2 import SECOND
+from utilities.whenever import SECOND
 
 if TYPE_CHECKING:
     from collections.abc import Iterator

{dycw_utilities-0.131.19 → dycw_utilities-0.132.0}/src/tests/test_atools.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from utilities.asyncio import sleep_td
 from utilities.atools import call_memoized
-from utilities.whenever2 import SECOND
+from utilities.whenever import SECOND
 
 
 class TestCallMemoized:

{dycw_utilities-0.131.19 → dycw_utilities-0.132.0}/src/tests/test_cachetools.py

@@ -7,8 +7,8 @@ from hypothesis.strategies import integers, none
 
 from utilities.asyncio import sleep_td
 from utilities.cachetools import TTLSet, cache
-from utilities.hypothesis import time_deltas_whenever
-from utilities.whenever2 import SECOND
+from utilities.hypothesis import time_deltas
+from utilities.whenever import SECOND
 
 if TYPE_CHECKING:
     from whenever import TimeDelta
@@ -21,9 +21,7 @@ class TestCache:
     @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
-        )
+        max_duration=time_deltas(min_value=0.1 * SECOND, max_value=10.0 * SECOND)
         | none(),
     )
     def test_main(self, *, max_size: int, max_duration: TimeDelta) -> None:

{dycw_utilities-0.131.19 → dycw_utilities-0.132.0}/src/tests/test_click.py

@@ -21,6 +21,8 @@ from hypothesis.strategies import (
 )
 from pytest import mark, param
 
+import utilities
+import utilities.whenever
 from utilities.click import (
     CONTEXT_SETTINGS_HELP_OPTION_NAMES,
     Date,
@@ -42,18 +44,17 @@ from utilities.click import (
     TimeDelta,
     ZonedDateTime,
 )
-from utilities.datetime import serialize_month
 from utilities.hypothesis import (
-    date_deltas_whenever,
-    date_time_deltas_whenever,
-    dates_whenever,
+    date_deltas,
+    date_time_deltas,
+    dates,
     months,
     pairs,
-    plain_datetimes_whenever,
+    plain_datetimes,
     text_ascii,
-    time_deltas_whenever,
-    times_whenever,
-    zoned_datetimes_whenever,
+    time_deltas,
+    times,
+    zoned_datetimes,
 )
 from utilities.text import join_strs, strip_and_dedent
 
@@ -183,30 +184,28 @@ class TestParameters:
     @mark.parametrize(
         ("param", "exp_repr", "strategy", "serialize", "failable"),
         [
-            param(
-                Date(), "DATE", dates_whenever(), whenever.Date.format_common_iso, True
-            ),
-            param(
-                Enum(_ExampleEnum),
-                "ENUM[_ExampleEnum]",
-                sampled_from(_ExampleEnum),
-                attrgetter("name"),
-                True,
-            ),
+            param(Date(), "DATE", dates(), whenever.Date.format_common_iso, True),
             param(
                 DateDelta(),
                 "DATE DELTA",
-                date_deltas_whenever(parsable=True),
+                date_deltas(parsable=True),
                 whenever.DateDelta.format_common_iso,
                 True,
             ),
             param(
                 DateTimeDelta(),
                 "DATE-TIME DELTA",
-                date_time_deltas_whenever(parsable=True),
+                date_time_deltas(parsable=True),
                 whenever.DateTimeDelta.format_common_iso,
                 True,
             ),
+            param(
+                Enum(_ExampleEnum),
+                "ENUM[_ExampleEnum]",
+                sampled_from(_ExampleEnum),
+                attrgetter("name"),
+                True,
+            ),
             param(
                 FrozenSetChoices(["a", "b", "c"]),
                 "FROZENSET[Choice(['a', 'b', 'c'])]",
@@ -235,28 +234,32 @@ class TestParameters:
                 _lift_serializer(attrgetter("name")),
                 True,
             ),
-            param(Month(), "MONTH", months(), serialize_month, True),
+            param(
+                Month(),
+                "MONTH",
+                months(),
+                utilities.whenever.Month.format_common_iso,
+                True,
+            ),
             param(
                 PlainDateTime(),
                 "PLAIN DATE-TIME",
-                plain_datetimes_whenever(),
+                plain_datetimes(),
                 whenever.PlainDateTime.format_common_iso,
                 True,
             ),
-            param(
-                Time(), "TIME", times_whenever(), whenever.Time.format_common_iso, True
-            ),
+            param(Time(), "TIME", times(), whenever.Time.format_common_iso, True),
             param(
                 TimeDelta(),
                 "TIME-DELTA",
-                time_deltas_whenever(),
+                time_deltas(),
                 whenever.TimeDelta.format_common_iso,
                 True,
             ),
             param(
                 ZonedDateTime(),
                 "ZONED DATE-TIME",
-                zoned_datetimes_whenever(),
+                zoned_datetimes(),
                 whenever.ZonedDateTime.format_common_iso,
                 True,
             ),

{dycw_utilities-0.131.19 → dycw_utilities-0.132.0}/src/tests/test_fastapi.py

@@ -5,7 +5,7 @@ from re import search
 
 from tests.conftest import SKIPIF_CI
 from utilities.fastapi import PingReceiver
-from utilities.whenever2 import SECOND
+from utilities.whenever import SECOND
 
 
 class TestPingReceiver:

{dycw_utilities-0.131.19 → dycw_utilities-0.132.0}/src/tests/test_functions.py

@@ -95,7 +95,7 @@ from utilities.functions import (
     yield_object_properties,
 )
 from utilities.sentinel import sentinel
-from utilities.whenever2 import NOW_UTC, ZERO_TIME, get_now, get_today
+from utilities.whenever import NOW_UTC, ZERO_TIME, get_now, get_today
 
 if TYPE_CHECKING:
     import datetime as dt

{dycw_utilities-0.131.19 → dycw_utilities-0.132.0}/src/tests/test_http.py

@@ -4,7 +4,7 @@ from ipaddress import IPv4Address
 
 from utilities.http import get_public_ip, yield_connection
 from utilities.pytest import throttle
-from utilities.whenever2 import MINUTE
+from utilities.whenever import MINUTE
 
 
 class TestGetPublicIP:

{dycw_utilities-0.131.19 → dycw_utilities-0.132.0}/src/tests/test_hypothesis.py

@@ -5,7 +5,7 @@ from pathlib import Path
 from re import search
 from typing import TYPE_CHECKING, Any, cast
 
-from hypothesis import HealthCheck, Phase, assume, given, settings
+from hypothesis import Phase, assume, given, settings
 from hypothesis.errors import InvalidArgument
 from hypothesis.extra.numpy import array_shapes
 from hypothesis.strategies import (
@@ -36,11 +36,6 @@ from whenever import (
     ZonedDateTime,
 )
 
-from utilities.datetime import (
-    MAX_DATE_TWO_DIGIT_YEAR,
-    MIN_DATE_TWO_DIGIT_YEAR,
-    parse_two_digit_year,
-)
 from utilities.functions import ensure_int
 from utilities.hypothesis import (
     Shape,
@@ -48,10 +43,9 @@ from utilities.hypothesis import (
     _Draw2InputResolvedToSentinelError,
     assume_does_not_raise,
     bool_arrays,
-    date_deltas_whenever,
-    date_time_deltas_whenever,
-    dates_two_digit_year,
-    dates_whenever,
+    date_deltas,
+    date_time_deltas,
+    dates,
     draw2,
     float32s,
     float64s,
@@ -68,7 +62,7 @@ from utilities.hypothesis import (
     numbers,
     pairs,
     paths,
-    plain_datetimes_whenever,
+    plain_datetimes,
     random_states,
     sentinels,
     sets_fixed_length,
@@ -84,13 +78,13 @@ from utilities.hypothesis import (
     text_clean,
     text_digits,
     text_printable,
-    time_deltas_whenever,
-    times_whenever,
+    time_deltas,
+    times,
     triples,
     uint32s,
     uint64s,
     versions,
-    zoned_datetimes_whenever,
+    zoned_datetimes,
 )
 from utilities.math import (
     MAX_FLOAT32,
@@ -110,14 +104,19 @@ from utilities.os import temp_environ
 from utilities.platform import maybe_yield_lower_case
 from utilities.sentinel import Sentinel
 from utilities.version import Version
-from utilities.whenever2 import to_days, to_nanos
+from utilities.whenever import (
+    DATE_TWO_DIGIT_YEAR_MAX,
+    DATE_TWO_DIGIT_YEAR_MIN,
+    Month,
+    to_days,
+    to_nanos,
+)
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
     from collections.abc import Set as AbstractSet
     from zoneinfo import ZoneInfo
 
-    from utilities.datetime import Month
     from utilities.tempfile import TemporaryDirectory
     from utilities.types import Number
 
@@ -165,16 +164,14 @@ class TestBoolArrays:
         assert array.shape == shape
 
 
-class TestDateDeltasWhenever:
+class TestDateDeltas:
     @given(data=data(), parsable=booleans())
     def test_main(self, *, data: DataObject, parsable: bool) -> None:
-        min_value = data.draw(date_deltas_whenever() | none())
-        max_value = data.draw(date_deltas_whenever() | none())
+        min_value = data.draw(date_deltas() | none())
+        max_value = data.draw(date_deltas() | none())
         with assume_does_not_raise(InvalidArgument):
             delta = data.draw(
-                date_deltas_whenever(
-                    min_value=min_value, max_value=max_value, parsable=parsable
-                )
+                date_deltas(min_value=min_value, max_value=max_value, parsable=parsable)
             )
         assert isinstance(delta, DateDelta)
         days = to_days(delta)
@@ -186,14 +183,14 @@ class TestDateDeltasWhenever:
             assert DateDelta.parse_common_iso(delta.format_common_iso()) == delta
 
 
-class TestDateTimeDeltasWhenever:
+class TestDateTimeDeltas:
     @given(data=data(), parsable=booleans())
     def test_main(self, *, data: DataObject, parsable: bool) -> None:
-        min_value = data.draw(date_time_deltas_whenever() | none())
-        max_value = data.draw(date_time_deltas_whenever() | none())
+        min_value = data.draw(date_time_deltas() | none())
+        max_value = data.draw(date_time_deltas() | none())
         with assume_does_not_raise(InvalidArgument):
             delta = data.draw(
-                date_time_deltas_whenever(
+                date_time_deltas(
                     min_value=min_value, max_value=max_value, parsable=parsable
                 )
             )
@@ -207,34 +204,23 @@ class TestDateTimeDeltasWhenever:
             assert DateTimeDelta.parse_common_iso(delta.format_common_iso()) == delta
 
 
-class TestDatesTwoDigitYear:
-    @given(data=data())
-    def test_main(self, *, data: DataObject) -> None:
-        min_value, max_value = data.draw(pairs(dates_two_digit_year(), sorted=True))
-        date = data.draw(dates_two_digit_year(min_value=min_value, max_value=max_value))
-        assert (
-            max(min_value, MIN_DATE_TWO_DIGIT_YEAR)
-            <= date
-            <= min(max_value, MAX_DATE_TWO_DIGIT_YEAR)
-        )
-        year = f"{date:%y}"
-        parsed = parse_two_digit_year(year)
-        assert date.year == parsed
-
-
-class TestDatesWhenever:
-    @given(data=data())
-    def test_main(self, *, data: DataObject) -> None:
-        min_value = data.draw(dates_whenever() | none())
-        max_value = data.draw(dates_whenever() | none())
+class TestDates:
+    @given(data=data(), two_digit=booleans())
+    def test_main(self, *, data: DataObject, two_digit: bool) -> None:
+        min_value = data.draw(dates() | none())
+        max_value = data.draw(dates() | none())
         with assume_does_not_raise(InvalidArgument):
-            date = data.draw(dates_whenever(min_value=min_value, max_value=max_value))
+            date = data.draw(
+                dates(min_value=min_value, max_value=max_value, two_digit=two_digit)
+            )
         assert isinstance(date, Date)
         assert Date.parse_common_iso(date.format_common_iso()) == date
         if min_value is not None:
             assert date >= min_value
         if max_value is not None:
             assert date <= max_value
+        if two_digit:
+            assert DATE_TWO_DIGIT_YEAR_MIN <= date <= DATE_TWO_DIGIT_YEAR_MAX
 
 
 class TestDraw2:
@@ -579,18 +565,23 @@ class TestListsFixedLength:
 
 
 class TestMonths:
-    @given(data=data())
-    def test_main(self, *, data: DataObject) -> None:
-        _ = data.draw(months())
-
-    @given(data=data(), min_value=months(), max_value=months())
-    @settings(suppress_health_check={HealthCheck.filter_too_much})
-    def test_min_and_max_value(
-        self, *, data: DataObject, min_value: Month, max_value: Month
-    ) -> None:
-        _ = assume(min_value <= max_value)
-        month = data.draw(months(min_value=min_value, max_value=max_value))
-        assert min_value <= month <= max_value
+    @given(data=data(), two_digit=booleans())
+    def test_main(self, *, data: DataObject, two_digit: bool) -> None:
+        min_value = data.draw(months() | none())
+        max_value = data.draw(months() | none())
+        with assume_does_not_raise(InvalidArgument):
+            month = data.draw(
+                months(min_value=min_value, max_value=max_value, two_digit=two_digit)
+            )
+        assert isinstance(month, Month)
+        assert Month.parse_common_iso(month.format_common_iso()) == month
+        if min_value is not None:
+            assert month >= min_value
+        if max_value is not None:
+            assert month <= max_value
+        if two_digit:
+            assert month.to_date() >= DATE_TWO_DIGIT_YEAR_MIN
+            assert month.to_date() <= DATE_TWO_DIGIT_YEAR_MAX
 
 
 class TestNamespaceMixins:
@@ -651,14 +642,14 @@ class TestPaths:
         validate_filepath(str(path))
 
 
-class TestPlainDateTimesWhenever:
+class TestPlainDateTimes:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value = data.draw(plain_datetimes_whenever() | none())
-        max_value = data.draw(plain_datetimes_whenever() | none())
+        min_value = data.draw(plain_datetimes() | none())
+        max_value = data.draw(plain_datetimes() | none())
         with assume_does_not_raise(InvalidArgument):
             datetime = data.draw(
-                plain_datetimes_whenever(min_value=min_value, max_value=max_value)
+                plain_datetimes(min_value=min_value, max_value=max_value)
             )
         assert isinstance(datetime, PlainDateTime)
         assert PlainDateTime.parse_common_iso(datetime.format_common_iso()) == datetime
@@ -897,12 +888,10 @@ class TestTextPrintable:
 class TestTimeDeltas:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value = data.draw(time_deltas_whenever() | none())
-        max_value = data.draw(time_deltas_whenever() | none())
+        min_value = data.draw(time_deltas() | none())
+        max_value = data.draw(time_deltas() | none())
         with assume_does_not_raise(InvalidArgument):
-            delta = data.draw(
-                time_deltas_whenever(min_value=min_value, max_value=max_value)
-            )
+            delta = data.draw(time_deltas(min_value=min_value, max_value=max_value))
         assert isinstance(delta, TimeDelta)
         assert TimeDelta.parse_common_iso(delta.format_common_iso()) == delta
         if min_value is not None:
@@ -914,10 +903,10 @@ class TestTimeDeltas:
 class TestTimes:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value = data.draw(times_whenever() | none())
-        max_value = data.draw(times_whenever() | none())
+        min_value = data.draw(times() | none())
+        max_value = data.draw(times() | none())
         with assume_does_not_raise(InvalidArgument):
-            time = data.draw(times_whenever(min_value=min_value, max_value=max_value))
+            time = data.draw(times(min_value=min_value, max_value=max_value))
         assert isinstance(time, Time)
         assert Time.parse_common_iso(time.format_common_iso()) == time
         if min_value is not None:
@@ -967,15 +956,14 @@ class TestVersions:
             assert version.suffix is None
 
 
-class TestZonedDateTimesWhenever:
+class TestZonedDateTimes:
     @given(data=data(), time_zone=timezones())
-    @settings(suppress_health_check={HealthCheck.filter_too_much})
     def test_main(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
-        min_value = data.draw(zoned_datetimes_whenever() | none())
-        max_value = data.draw(zoned_datetimes_whenever() | none())
+        min_value = data.draw(zoned_datetimes() | none())
+        max_value = data.draw(zoned_datetimes() | none())
         with assume_does_not_raise(InvalidArgument):
             datetime = data.draw(
-                zoned_datetimes_whenever(
+                zoned_datetimes(
                     min_value=min_value, max_value=max_value, time_zone=time_zone
                 )
             )
@@ -992,7 +980,5 @@ class TestZonedDateTimesWhenever:
     def test_examples(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
         with assume_does_not_raise(TimeZoneNotFoundError):
             max_value = ZonedDateTime(1, 1, 2, tz=time_zone.key)
-        datetime = data.draw(
-            zoned_datetimes_whenever(max_value=max_value, time_zone=time_zone)
-        )
+        datetime = data.draw(zoned_datetimes(max_value=max_value, time_zone=time_zone))
         _ = datetime.py_datetime()

{dycw_utilities-0.131.19 → dycw_utilities-0.132.0}/src/tests/test_logging.py

@@ -17,7 +17,7 @@ from utilities.hypothesis import (
     pairs,
     temp_paths,
     text_ascii,
-    zoned_datetimes_whenever,
+    zoned_datetimes,
 )
 from utilities.iterables import one
 from utilities.logging import (
@@ -38,7 +38,7 @@ from utilities.logging import (
 from utilities.text import unique_str
 from utilities.types import LogLevel
 from utilities.typing import get_args
-from utilities.whenever2 import format_compact, get_now
+from utilities.whenever import format_compact, get_now
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -315,7 +315,7 @@ class TestRotatingLogFile:
         assert result.start is None
         assert result.end is None
 
-    @given(index=integers(min_value=1), end=zoned_datetimes_whenever())
+    @given(index=integers(min_value=1), end=zoned_datetimes())
     def test_from_path_with_index_and_end(
         self, *, index: int, end: ZonedDateTime
     ) -> None:
@@ -328,10 +328,7 @@ class TestRotatingLogFile:
         assert result.start is None
         assert result.end == end.round()
 
-    @given(
-        index=integers(min_value=1),
-        datetimes=pairs(zoned_datetimes_whenever(), sorted=True),
-    )
+    @given(index=integers(min_value=1), datetimes=pairs(zoned_datetimes(), sorted=True))
     def test_from_path_with_index_start_and_end(
         self, *, index: int, datetimes: tuple[ZonedDateTime, ZonedDateTime]
     ) -> None:
@@ -359,9 +356,7 @@ class TestRotatingLogFile:
         file = _RotatingLogFile(directory=root, stem="log", suffix=".txt", index=index)
         assert file.path == root.joinpath(f"log.{index}.txt")
 
-    @given(
-        root=temp_paths(), index=integers(min_value=1), end=zoned_datetimes_whenever()
-    )
+    @given(root=temp_paths(), index=integers(min_value=1), end=zoned_datetimes())
     def test_path_with_index_and_end(
         self, *, root: Path, index: int, end: ZonedDateTime
     ) -> None:
@@ -373,7 +368,7 @@ class TestRotatingLogFile:
     @given(
         root=temp_paths(),
         index=integers(min_value=1),
-        datetimes=pairs(zoned_datetimes_whenever(), sorted=True),
+        datetimes=pairs(zoned_datetimes(), sorted=True),
     )
     def test_path_with_index_start_and_end(
         self, *, root: Path, index: int, datetimes: tuple[ZonedDateTime, ZonedDateTime]

{dycw_utilities-0.131.19 → dycw_utilities-0.132.0}/src/tests/test_luigi.py

@@ -8,7 +8,7 @@ from hypothesis.strategies import booleans
 from luigi import BoolParameter, Task
 from pytest import mark, param
 
-from utilities.hypothesis import namespace_mixins, temp_paths, zoned_datetimes_whenever
+from utilities.hypothesis import namespace_mixins, temp_paths, zoned_datetimes
 from utilities.luigi import (
     ExternalFile,
     ExternalTask,
@@ -31,7 +31,7 @@ class TestBuild:
 
 
 class TestDateTimeParameter:
-    @given(datetime=zoned_datetimes_whenever())
+    @given(datetime=zoned_datetimes())
     @mark.parametrize("type_", [param("datetime"), param("str")])
     def test_main(
         self, *, datetime: ZonedDateTime, type_: Literal["datetime", "str"]