dycw-utilities 0.154.0__tar.gz → 0.155.1__tar.gz

{dycw_utilities-0.154.0 → dycw_utilities-0.155.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.154.0
+Version: 0.155.1
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -12,8 +12,7 @@ Provides-Extra: logging
 Requires-Dist: coloredlogs<15.1,>=15.0.1; extra == 'logging'
 Provides-Extra: test
 Requires-Dist: dycw-pytest-only<2.2,>=2.1.1; extra == 'test'
-Requires-Dist: hypothesis<6.137,>=6.136.7; extra == 'test'
-Requires-Dist: pudb<2025.2,>=2025.1; extra == 'test'
+Requires-Dist: hypothesis<6.138,>=6.137.1; extra == 'test'
 Requires-Dist: pytest-asyncio<1.2,>=1.1.0; extra == 'test'
 Requires-Dist: pytest-cov<6.3,>=6.2.1; extra == 'test'
 Requires-Dist: pytest-instafail<0.6,>=0.5.0; extra == 'test'

{dycw_utilities-0.154.0 → dycw_utilities-0.155.1}/pyproject.toml

@@ -44,7 +44,6 @@ dev = [
   "coloredlogs >=15.0.1, <15.1",
   "coverage-conditional-plugin >=0.9.0, <0.10",
   "dycw-pytest-only >=2.1.1, <2.2",
-  "pudb >=2025.1, <2025.2",
   "pyright[nodejs] >=1.1.401, <1.2",
   "pytest-cov >=6.2.1, <6.3",
   "pytest-timeout >=2.4.0, <2.5",
@@ -69,7 +68,7 @@ http-test = [
   "orjson",
 ]
 hypothesis = [
-  "hypothesis >=6.136.7, <6.137",
+  "hypothesis >=6.137.1, <6.138",
 ]
 hypothesis-test = [
   "libcst",
@@ -119,7 +118,7 @@ orjson-test = [
   "polars",
 ]
 polars = [
-  "polars >=1.32.0, <1.33",
+  "polars >=1.32.2, <1.33",
 ]
 polars-ols = [
   "polars-ols >=0.3.5, <0.4",
@@ -148,7 +147,6 @@ pyinstrument = [
   "pyinstrument >=5.0.3, <5.1",
 ]
 pytest = [
-  "pudb >=2025.1, <2025.2",
   "pytest >=8.4.1, <8.5",
   "pytest-asyncio >=1.1.0, <1.2",
   "pytest-randomly >=3.16.0, <3.17",
@@ -168,7 +166,7 @@ pytest-test = [
   "pytest-rerunfailures",
 ]
 redis = [
-  "redis >=6.2.0, <6.3",
+  "redis >=6.4.0, <6.5",
   "orjson",
 ]
 redis-test = [
@@ -229,7 +227,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.154.0"
+version = "0.155.1"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -241,8 +239,7 @@ logging = [
 ]
 test = [
   "dycw-pytest-only >=2.1.1, <2.2",
-  "hypothesis >=6.136.7, <6.137",
-  "pudb >=2025.1, <2025.2",
+  "hypothesis >=6.137.1, <6.138",
   "pytest >=8.4.1, <8.5",
   "pytest-asyncio >=1.1.0, <1.2",
   "pytest-cov >=6.2.1, <6.3",
@@ -262,7 +259,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.154.0"
+current_version = "0.155.1"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"
@@ -366,7 +363,6 @@ addopts = [
   "--color=auto",
   "--durations=10",
   "--durations-min=10",
-  "--pdbcls=pudb.debugger:Debugger",
   "--strict-markers",
   "--timeout=600",
 ]

{dycw_utilities-0.154.0 → dycw_utilities-0.155.1}/src/tests/test_altair.py

@@ -27,7 +27,7 @@ from utilities.altair import (
     vconcat_charts,
 )
 from utilities.functions import ensure_class
-from utilities.hypothesis import dates, text_ascii, zoned_datetimes
+from utilities.hypothesis import dates, text_ascii, zoned_date_times
 from utilities.polars import DatetimeUTC, zoned_datetime_dtype
 from utilities.tzdata import HongKong, Tokyo
 from utilities.whenever import get_now
@@ -119,7 +119,7 @@ class TestPlotDataFrames:
         )
         _ = plot_dataframes(df, x="index", y="value")
 
-    @given(data=lists(tuples(zoned_datetimes(), floats(-10, 10))))
+    @given(data=lists(tuples(zoned_date_times(), floats(-10, 10))))
     def test_tooltip_format_date_time(
         self, *, data: list[tuple[ZonedDateTime, float]]
     ) -> None:

{dycw_utilities-0.154.0 → dycw_utilities-0.155.1}/src/tests/test_click.py

@@ -57,12 +57,12 @@ from utilities.hypothesis import (
     date_time_deltas,
     dates,
     month_days,
-    plain_datetimes,
+    plain_date_times,
     text_ascii,
     time_deltas,
     times,
     year_months,
-    zoned_datetimes,
+    zoned_date_times,
 )
 from utilities.text import join_strs, strip_and_dedent
 
@@ -304,7 +304,7 @@ class TestParameters:
         _Case(
             param=PlainDateTime(),
             name="plain date-time",
-            strategy=plain_datetimes(),
+            strategy=plain_date_times(),
             serialize=whenever.PlainDateTime.format_common_iso,
             failable=True,
         ),
@@ -335,7 +335,7 @@ class TestParameters:
         _Case(
             param=ZonedDateTime(),
             name="zoned date-time",
-            strategy=zoned_datetimes(),
+            strategy=zoned_date_times(),
             serialize=whenever.ZonedDateTime.format_common_iso,
             failable=True,
         ),

{dycw_utilities-0.154.0 → dycw_utilities-0.155.1}/src/tests/test_hypothesis.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
+import datetime as dt
 from itertools import pairwise
 from pathlib import Path
 from re import search
 from typing import TYPE_CHECKING, Any, cast
 
-from hypothesis import Phase, assume, given, settings
+from hypothesis import assume, given, settings
 from hypothesis.errors import InvalidArgument
 from hypothesis.extra.numpy import array_shapes
 from hypothesis.strategies import (
@@ -46,6 +47,7 @@ from utilities.hypothesis import (
     assume_does_not_raise,
     bool_arrays,
     date_deltas,
+    date_periods,
     date_time_deltas,
     dates,
     draw2,
@@ -57,6 +59,8 @@ from utilities.hypothesis import (
     hashables,
     import_froms,
     imports,
+    int8s,
+    int16s,
     int32s,
     int64s,
     int_arrays,
@@ -65,7 +69,7 @@ from utilities.hypothesis import (
     numbers,
     pairs,
     paths,
-    plain_datetimes,
+    plain_date_times,
     random_states,
     sentinels,
     sets_fixed_length,
@@ -82,6 +86,7 @@ from utilities.hypothesis import (
     text_digits,
     text_printable,
     time_deltas,
+    time_periods,
     times,
     triples,
     uint8s,
@@ -91,13 +96,16 @@ from utilities.hypothesis import (
     urls,
     versions,
     year_months,
-    zoned_datetimes,
+    zoned_date_time_periods,
+    zoned_date_times,
 )
 from utilities.iterables import one
 from utilities.libcst import parse_import
 from utilities.math import (
     MAX_FLOAT32,
     MAX_FLOAT64,
+    MAX_INT8,
+    MAX_INT16,
     MAX_INT32,
     MAX_INT64,
     MAX_UINT8,
@@ -106,6 +114,8 @@ from utilities.math import (
     MAX_UINT64,
     MIN_FLOAT32,
     MIN_FLOAT64,
+    MIN_INT8,
+    MIN_INT16,
     MIN_INT32,
     MIN_INT64,
     MIN_UINT8,
@@ -120,12 +130,15 @@ from utilities.version import Version
 from utilities.whenever import (
     DATE_TWO_DIGIT_YEAR_MAX,
     DATE_TWO_DIGIT_YEAR_MIN,
+    DatePeriod,
+    TimePeriod,
+    ZonedDateTimePeriod,
     to_days,
     to_nanoseconds,
+    to_py_time_delta,
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable
     from collections.abc import Set as AbstractSet
     from zoneinfo import ZoneInfo
 
@@ -186,6 +199,7 @@ class TestDateDeltas:
                 date_deltas(min_value=min_value, max_value=max_value, parsable=parsable)
             )
         assert isinstance(delta, DateDelta)
+        assert isinstance(to_py_time_delta(delta), dt.timedelta)
         days = to_days(delta)
         if min_value is not None:
             assert days >= to_days(min_value)
@@ -195,15 +209,32 @@ class TestDateDeltas:
             assert DateDelta.parse_common_iso(delta.format_common_iso()) == delta
 
 
+class TestDatePeriods:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_value = data.draw(dates() | none())
+        max_value = data.draw(dates() | none())
+        with assume_does_not_raise(InvalidArgument):
+            period = data.draw(date_periods(min_value=min_value, max_value=max_value))
+        assert isinstance(period, DatePeriod)
+        if min_value is not None:
+            assert period.start >= min_value
+        if max_value is not None:
+            assert period.end <= max_value
+
+
 class TestDateTimeDeltas:
-    @given(data=data(), parsable=booleans())
-    def test_main(self, *, data: DataObject, parsable: bool) -> None:
+    @given(data=data(), parsable=booleans(), nativable=booleans())
+    def test_main(self, *, data: DataObject, parsable: bool, nativable: bool) -> 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(
-                    min_value=min_value, max_value=max_value, parsable=parsable
+                    min_value=min_value,
+                    max_value=max_value,
+                    parsable=parsable,
+                    nativable=nativable,
                 )
             )
         assert isinstance(delta, DateTimeDelta)
@@ -214,6 +245,8 @@ class TestDateTimeDeltas:
             assert nanos <= to_nanoseconds(max_value)
         if parsable:
             assert DateTimeDelta.parse_common_iso(delta.format_common_iso()) == delta
+        if nativable:
+            assert isinstance(to_py_time_delta(delta), dt.timedelta)
 
 
 class TestDates:
@@ -347,17 +380,27 @@ class TestDraw2:
 class TestFloat32s:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value, max_value = data.draw(pairs(float32s(), sorted=True))
-        x = data.draw(float32s(min_value=min_value, max_value=max_value))
-        assert max(min_value, MIN_FLOAT32) <= x <= min(max_value, MAX_FLOAT32)
+        min_value, max_value = data.draw(pairs(float32s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(float32s(min_value=min_value, max_value=max_value))
+        assert MIN_FLOAT32 <= x <= MAX_FLOAT32
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
 
 
 class TestFloat64s:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value, max_value = data.draw(pairs(float64s(), sorted=True))
-        x = data.draw(float64s(min_value=min_value, max_value=max_value))
-        assert max(min_value, MIN_FLOAT64) <= x <= min(max_value, MAX_FLOAT64)
+        min_value, max_value = data.draw(pairs(float64s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(float64s(min_value=min_value, max_value=max_value))
+        assert MIN_FLOAT64 <= x <= MAX_FLOAT64
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
 
 
 class TestFloatArrays:
@@ -574,20 +617,56 @@ class TestIntArrays:
             assert len(set(flat)) == len(flat)
 
 
+class TestInt8s:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_value, max_value = data.draw(pairs(int8s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(int8s(min_value=min_value, max_value=max_value))
+        assert MIN_INT8 <= x <= MAX_INT8
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
+
+
+class TestInt16s:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_value, max_value = data.draw(pairs(int16s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(int16s(min_value=min_value, max_value=max_value))
+        assert MIN_INT16 <= x <= MAX_INT16
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
+
+
 class TestInt32s:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value, max_value = data.draw(pairs(int32s(), sorted=True))
-        x = data.draw(int32s(min_value=min_value, max_value=max_value))
-        assert max(min_value, MIN_INT32) <= x <= min(max_value, MAX_INT32)
+        min_value, max_value = data.draw(pairs(int32s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(int32s(min_value=min_value, max_value=max_value))
+        assert MIN_INT32 <= x <= MAX_INT32
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
 
 
 class TestInt64s:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value, max_value = data.draw(pairs(int64s(), sorted=True))
-        x = data.draw(int64s(min_value=min_value, max_value=max_value))
-        assert max(min_value, MIN_INT64) <= x <= min(max_value, MAX_INT64)
+        min_value, max_value = data.draw(pairs(int64s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(int64s(min_value=min_value, max_value=max_value))
+        assert MIN_INT64 <= x <= MAX_INT64
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
 
 
 class TestListsFixedLength:
@@ -655,8 +734,8 @@ class TestPairs:
 class TestPaths:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_depth = data.draw(integers(0, 5) | none())
-        max_depth = data.draw(integers(0, 5) | none())
+        min_depth = data.draw(integers(0, 3) | none())
+        max_depth = data.draw(integers(0, 3) | none())
         with assume_does_not_raise(InvalidArgument):
             path = data.draw(paths(min_depth=min_depth, max_depth=max_depth))
         assert isinstance(path, Path)
@@ -671,11 +750,11 @@ class TestPaths:
 class TestPlainDateTimes:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value = data.draw(plain_datetimes() | none())
-        max_value = data.draw(plain_datetimes() | none())
+        min_value = data.draw(plain_date_times() | none())
+        max_value = data.draw(plain_date_times() | none())
         with assume_does_not_raise(InvalidArgument):
             datetime = data.draw(
-                plain_datetimes(min_value=min_value, max_value=max_value)
+                plain_date_times(min_value=min_value, max_value=max_value)
             )
         assert isinstance(datetime, PlainDateTime)
         assert PlainDateTime.parse_common_iso(datetime.format_common_iso()) == datetime
@@ -722,13 +801,11 @@ class TestSetupHypothesisProfiles:
     def test_main(self) -> None:
         setup_hypothesis_profiles()
         curr = settings()
-        assert Phase.shrink in cast("Iterable[Phase]", curr.phases)
         assert curr.max_examples in {10, 100, 1000}
 
     def test_no_shrink(self) -> None:
         with temp_environ({"HYPOTHESIS_NO_SHRINK": "1"}):
             setup_hypothesis_profiles()
-        assert Phase.shrink not in cast("Iterable[Phase]", settings().phases)
 
     @given(max_examples=integers(1, 100))
     def test_max_examples(self, *, max_examples: int) -> None:
@@ -920,12 +997,27 @@ class TestTimeDeltas:
             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
+        assert isinstance(to_py_time_delta(delta), dt.timedelta)
         if min_value is not None:
             assert delta >= min_value
         if max_value is not None:
             assert delta <= max_value
 
 
+class TestTimePeriods:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_value = data.draw(times() | none())
+        max_value = data.draw(times() | none())
+        with assume_does_not_raise(InvalidArgument):
+            period = data.draw(time_periods(min_value=min_value, max_value=max_value))
+        assert isinstance(period, TimePeriod)
+        if min_value is not None:
+            assert period.start >= min_value
+        if max_value is not None:
+            assert period.end <= max_value
+
+
 class TestTimes:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
@@ -958,33 +1050,53 @@ class TestTriples:
 class TestUInt8s:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value, max_value = data.draw(pairs(uint8s(), sorted=True))
-        x = data.draw(uint8s(min_value=min_value, max_value=max_value))
-        assert max(min_value, MIN_UINT8) <= x <= min(max_value, MAX_UINT8)
+        min_value, max_value = data.draw(pairs(uint8s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(uint8s(min_value=min_value, max_value=max_value))
+        assert MIN_UINT8 <= x <= MAX_UINT8
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
 
 
 class TestUInt16s:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value, max_value = data.draw(pairs(uint16s(), sorted=True))
-        x = data.draw(uint16s(min_value=min_value, max_value=max_value))
-        assert max(min_value, MIN_UINT16) <= x <= min(max_value, MAX_UINT16)
+        min_value, max_value = data.draw(pairs(uint16s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(uint16s(min_value=min_value, max_value=max_value))
+        assert MIN_UINT16 <= x <= MAX_UINT16
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
 
 
 class TestUInt32s:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value, max_value = data.draw(pairs(uint32s(), sorted=True))
-        x = data.draw(uint32s(min_value=min_value, max_value=max_value))
-        assert max(min_value, MIN_UINT32) <= x <= min(max_value, MAX_UINT32)
+        min_value, max_value = data.draw(pairs(uint32s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(uint32s(min_value=min_value, max_value=max_value))
+        assert MIN_UINT32 <= x <= MAX_UINT32
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
 
 
 class TestUInt64s:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value, max_value = data.draw(pairs(uint64s(), sorted=True))
-        x = data.draw(uint64s(min_value=min_value, max_value=max_value))
-        assert max(min_value, MIN_UINT64) <= x <= min(max_value, MAX_UINT64)
+        min_value, max_value = data.draw(pairs(uint64s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(uint64s(min_value=min_value, max_value=max_value))
+        assert MIN_UINT64 <= x <= MAX_UINT64
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
 
 
 class TestURLs:
@@ -1063,14 +1175,33 @@ class TestYearMonths:
             assert year_month.on_day(28) <= DATE_TWO_DIGIT_YEAR_MAX
 
 
+class TestZonedDateTimePeriods:
+    @given(data=data(), time_zone=timezones())
+    def test_main(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
+        min_value = data.draw(zoned_date_times() | none())
+        max_value = data.draw(zoned_date_times() | none())
+        with assume_does_not_raise(InvalidArgument):
+            period = data.draw(
+                zoned_date_time_periods(
+                    min_value=min_value, max_value=max_value, time_zone=time_zone
+                )
+            )
+        assert isinstance(period, ZonedDateTimePeriod)
+        assert period.time_zone is time_zone
+        if min_value is not None:
+            assert period.start >= min_value
+        if max_value is not None:
+            assert period.end <= max_value
+
+
 class TestZonedDateTimes:
     @given(data=data(), time_zone=timezones())
     def test_main(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
-        min_value = data.draw(zoned_datetimes() | none())
-        max_value = data.draw(zoned_datetimes() | none())
+        min_value = data.draw(zoned_date_times() | none())
+        max_value = data.draw(zoned_date_times() | none())
         with assume_does_not_raise(InvalidArgument):
             datetime = data.draw(
-                zoned_datetimes(
+                zoned_date_times(
                     min_value=min_value, max_value=max_value, time_zone=time_zone
                 )
             )
@@ -1087,5 +1218,5 @@ class TestZonedDateTimes:
     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(max_value=max_value, time_zone=time_zone))
+        datetime = data.draw(zoned_date_times(max_value=max_value, time_zone=time_zone))
         _ = datetime.py_datetime()

{dycw_utilities-0.154.0 → dycw_utilities-0.155.1}/src/tests/test_logging.py

@@ -12,7 +12,7 @@ from hypothesis.strategies import booleans, integers
 from pytest import LogCaptureFixture, mark, param, raises
 
 from tests.conftest import SKIPIF_CI_AND_WINDOWS
-from utilities.hypothesis import pairs, temp_paths, text_ascii, zoned_datetimes
+from utilities.hypothesis import pairs, temp_paths, text_ascii, zoned_date_times
 from utilities.iterables import one
 from utilities.logging import (
     GetLoggingLevelNumberError,
@@ -274,7 +274,7 @@ class TestRotatingLogFile:
         assert result.start is None
         assert result.end is None
 
-    @given(index=integers(min_value=1), end=zoned_datetimes())
+    @given(index=integers(min_value=1), end=zoned_date_times())
     def test_from_path_with_index_and_end(
         self, *, index: int, end: ZonedDateTime
     ) -> None:
@@ -287,7 +287,9 @@ class TestRotatingLogFile:
         assert result.start is None
         assert result.end == end.round()
 
-    @given(index=integers(min_value=1), datetimes=pairs(zoned_datetimes(), sorted=True))
+    @given(
+        index=integers(min_value=1), datetimes=pairs(zoned_date_times(), sorted=True)
+    )
     def test_from_path_with_index_start_and_end(
         self, *, index: int, datetimes: tuple[ZonedDateTime, ZonedDateTime]
     ) -> None:
@@ -315,7 +317,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())
+    @given(root=temp_paths(), index=integers(min_value=1), end=zoned_date_times())
     def test_path_with_index_and_end(
         self, *, root: Path, index: int, end: ZonedDateTime
     ) -> None:
@@ -327,7 +329,7 @@ class TestRotatingLogFile:
     @given(
         root=temp_paths(),
         index=integers(min_value=1),
-        datetimes=pairs(zoned_datetimes(), sorted=True),
+        datetimes=pairs(zoned_date_times(), sorted=True),
     )
     def test_path_with_index_start_and_end(
         self, *, root: Path, index: int, datetimes: tuple[ZonedDateTime, ZonedDateTime]

{dycw_utilities-0.154.0 → dycw_utilities-0.155.1}/src/tests/test_objects/objects.py

@@ -37,20 +37,23 @@ from tests.test_typing_funcs.with_future import (
 from utilities.hypothesis import (
     assume_does_not_raise,
     date_deltas,
+    date_periods,
     date_time_deltas,
     dates,
     int64s,
     month_days,
     paths,
-    plain_datetimes,
+    plain_date_times,
     py_datetimes,
     text_ascii,
     text_printable,
     time_deltas,
+    time_periods,
     times,
     versions,
     year_months,
-    zoned_datetimes,
+    zoned_date_time_periods,
+    zoned_date_times,
 )
 from utilities.math import MAX_INT64, MIN_INT64
 
@@ -82,6 +85,7 @@ def objects(
 ) -> SearchStrategy[Any]:
     base = (
         booleans()
+        | date_periods()
         | dates()
         | hypothesis.strategies.dates()
         | py_datetimes(zoned=booleans())
@@ -90,15 +94,17 @@ def objects(
         | month_days()
         | none()
         | paths()
-        | plain_datetimes()
+        | plain_date_times()
         | text_printable().filter(lambda x: not x.startswith("["))
         | time_deltas()
+        | time_periods()
         | times()
         | hypothesis.strategies.times()
         | uuids()
         | versions()
         | year_months()
-        | zoned_datetimes()
+        | zoned_date_time_periods()
+        | zoned_date_times()
     )
     if dataclass_custom_equality:
         base |= builds(DataClassFutureCustomEquality)