dycw-utilities 0.131.15__tar.gz → 0.131.16__tar.gz

{dycw_utilities-0.131.15 → dycw_utilities-0.131.16}/PKG-INFO

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

{dycw_utilities-0.131.15 → dycw_utilities-0.131.16}/pyproject.toml

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

{dycw_utilities-0.131.15 → dycw_utilities-0.131.16}/src/tests/test_click.py

@@ -6,6 +6,7 @@ from operator import attrgetter
 from re import search
 from typing import TYPE_CHECKING, Any, TypeVar
 
+import whenever
 from click import ParamType, argument, command, echo, option
 from click.testing import CliRunner
 from hypothesis import given
@@ -14,70 +15,47 @@ from hypothesis.strategies import (
     SearchStrategy,
     booleans,
     data,
-    dates,
-    datetimes,
-    floats,
     frozensets,
-    integers,
-    just,
     lists,
     sampled_from,
-    times,
-    uuids,
 )
 from pytest import mark, param
 
-import utilities.click
-import utilities.datetime
-import utilities.types
 from utilities.click import (
     CONTEXT_SETTINGS_HELP_OPTION_NAMES,
     Date,
+    DateDelta,
+    DateTimeDelta,
     DirPath,
     Enum,
     ExistingDirPath,
     ExistingFilePath,
     FilePath,
-    FrozenSetBools,
     FrozenSetChoices,
-    FrozenSetDates,
     FrozenSetEnums,
-    FrozenSetFloats,
-    FrozenSetInts,
-    FrozenSetMonths,
     FrozenSetStrs,
-    FrozenSetUUIDs,
-    ListBools,
-    ListDates,
     ListEnums,
-    ListFloats,
-    ListInts,
-    ListMonths,
     ListStrs,
-    ListUUIDs,
+    Month,
     PlainDateTime,
     Time,
-    Timedelta,
+    TimeDelta,
     ZonedDateTime,
 )
-from utilities.datetime import ZERO_TIME, serialize_month
+from utilities.datetime import serialize_month
 from utilities.hypothesis import (
-    datetime_durations,
+    date_deltas_whenever,
+    date_time_deltas_whenever,
+    dates_whenever,
     months,
     pairs,
+    plain_datetimes_whenever,
     text_ascii,
-    timedeltas_2w,
+    time_deltas_whenever,
+    times_whenever,
+    zoned_datetimes_whenever,
 )
 from utilities.text import join_strs, strip_and_dedent
-from utilities.whenever import (
-    serialize_date,
-    serialize_duration,
-    serialize_plain_datetime,
-    serialize_time,
-    serialize_timedelta,
-    serialize_zoned_datetime,
-)
-from utilities.zoneinfo import UTC
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterable
@@ -205,7 +183,9 @@ class TestParameters:
     @mark.parametrize(
         ("param", "exp_repr", "strategy", "serialize", "failable"),
         [
-            param(Date(), "DATE", dates(), serialize_date, True),
+            param(
+                Date(), "DATE", dates_whenever(), whenever.Date.format_common_iso, True
+            ),
             param(
                 Enum(_ExampleEnum),
                 "ENUM[_ExampleEnum]",
@@ -214,24 +194,17 @@ class TestParameters:
                 True,
             ),
             param(
-                utilities.click.Duration(),
-                "DURATION",
-                datetime_durations(min_number=0, min_timedelta=ZERO_TIME, two_way=True),
-                serialize_duration,
+                DateDelta(),
+                "DATE DELTA",
+                date_deltas_whenever(parsable=True),
+                whenever.DateDelta.format_common_iso,
                 True,
             ),
             param(
-                FrozenSetBools(),
-                "FROZENSET[BOOL]",
-                frozensets(booleans()),
-                _lift_serializer(str, sort=True),
-                True,
-            ),
-            param(
-                FrozenSetDates(),
-                "FROZENSET[DATE]",
-                frozensets(dates()),
-                _lift_serializer(serialize_date, sort=True),
+                DateTimeDelta(),
+                "DATE-TIME DELTA",
+                date_time_deltas_whenever(parsable=True),
+                whenever.DateTimeDelta.format_common_iso,
                 True,
             ),
             param(
@@ -248,27 +221,6 @@ class TestParameters:
                 _lift_serializer(attrgetter("name"), sort=True),
                 True,
             ),
-            param(
-                FrozenSetFloats(),
-                "FROZENSET[FLOAT]",
-                frozensets(floats(0, 10)),
-                _lift_serializer(str, sort=True),
-                True,
-            ),
-            param(
-                FrozenSetInts(),
-                "FROZENSET[INT]",
-                frozensets(integers(0, 10)),
-                _lift_serializer(str, sort=True),
-                True,
-            ),
-            param(
-                FrozenSetMonths(),
-                "FROZENSET[MONTH]",
-                frozensets(months()),
-                _lift_serializer(serialize_month, sort=True),
-                True,
-            ),
             param(
                 FrozenSetStrs(),
                 "FROZENSET[STRING]",
@@ -276,27 +228,6 @@ class TestParameters:
                 _lift_serializer(str, sort=True),
                 False,
             ),
-            param(
-                FrozenSetUUIDs(),
-                "FROZENSET[UUID]",
-                frozensets(uuids()),
-                _lift_serializer(str, sort=True),
-                True,
-            ),
-            param(
-                ListBools(),
-                "LIST[BOOL]",
-                lists(booleans()),
-                _lift_serializer(str),
-                True,
-            ),
-            param(
-                ListDates(),
-                "LIST[DATE]",
-                lists(dates()),
-                _lift_serializer(serialize_date),
-                True,
-            ),
             param(
                 ListEnums(_ExampleEnum),
                 "LIST[ENUM[_ExampleEnum]]",
@@ -304,58 +235,29 @@ class TestParameters:
                 _lift_serializer(attrgetter("name")),
                 True,
             ),
+            param(Month(), "MONTH", months(), serialize_month, True),
             param(
-                ListFloats(),
-                "LIST[FLOAT]",
-                lists(floats(0, 10)),
-                _lift_serializer(str),
-                True,
-            ),
-            param(
-                ListInts(),
-                "LIST[INT]",
-                lists(integers(0, 10)),
-                _lift_serializer(str),
-                True,
-            ),
-            param(
-                ListMonths(),
-                "LIST[MONTH]",
-                lists(months()),
-                _lift_serializer(serialize_month),
+                PlainDateTime(),
+                "PLAIN DATE-TIME",
+                plain_datetimes_whenever(),
+                whenever.PlainDateTime.format_common_iso,
                 True,
             ),
             param(
-                ListStrs(),
-                "LIST[STRING]",
-                lists(text_ascii()),
-                _lift_serializer(str),
-                False,
-            ),
-            param(
-                ListUUIDs(), "LIST[UUID]", lists(uuids()), _lift_serializer(str), True
-            ),
-            param(utilities.click.Month(), "MONTH", months(), serialize_month, True),
-            param(
-                PlainDateTime(),
-                "PLAIN DATETIME",
-                datetimes(),
-                serialize_plain_datetime,
-                True,
+                Time(), "TIME", times_whenever(), whenever.Time.format_common_iso, True
             ),
-            param(Time(), "TIME", times(), serialize_time, True),
             param(
-                Timedelta(),
-                "TIMEDELTA",
-                timedeltas_2w(min_value=ZERO_TIME),
-                serialize_timedelta,
+                TimeDelta(),
+                "TIME-DELTA",
+                time_deltas_whenever(),
+                whenever.TimeDelta.format_common_iso,
                 True,
             ),
             param(
                 ZonedDateTime(),
-                "ZONED DATETIME",
-                datetimes(timezones=just(UTC)),
-                serialize_zoned_datetime,
+                "ZONED DATE-TIME",
+                zoned_datetimes_whenever(),
+                whenever.ZonedDateTime.format_common_iso,
                 True,
             ),
         ],

{dycw_utilities-0.131.15 → dycw_utilities-0.131.16}/src/tests/test_hypothesis.py

@@ -28,7 +28,15 @@ from luigi import Task
 from numpy import inf, int64, isfinite, isinf, isnan, ravel, rint
 from pathvalidate import validate_filepath
 from pytest import mark, raises
-from whenever import Date, DateDelta, PlainDateTime, Time, TimeDelta, ZonedDateTime
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    PlainDateTime,
+    Time,
+    TimeDelta,
+    ZonedDateTime,
+)
 
 from tests.conftest import SKIPIF_CI_AND_WINDOWS
 from utilities.datetime import (
@@ -52,6 +60,7 @@ from utilities.hypothesis import (
     bool_arrays,
     date_deltas_whenever,
     date_durations,
+    date_time_deltas_whenever,
     dates_two_digit_year,
     dates_whenever,
     datetime_durations,
@@ -127,6 +136,7 @@ from utilities.whenever import (
     serialize_duration,
     serialize_timedelta,
 )
+from utilities.whenever2 import to_days, to_nanos
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
@@ -193,19 +203,11 @@ class TestDateDeltasWhenever:
                 )
             )
         assert isinstance(delta, DateDelta)
-        years, months, days = delta.in_years_months_days()
-        assert years == 0
-        assert months == 0
+        days = to_days(delta)
         if min_value is not None:
-            min_years, min_months, min_days = min_value.in_years_months_days()
-            assert min_years == 0
-            assert min_months == 0
-            assert days >= min_days
+            assert days >= to_days(min_value)
         if max_value is not None:
-            max_years, max_months, max_days = max_value.in_years_months_days()
-            assert max_years == 0
-            assert max_months == 0
-            assert days <= max_days
+            assert days <= to_days(max_value)
         if parsable:
             assert DateDelta.parse_common_iso(delta.format_common_iso()) == delta
 
@@ -274,6 +276,27 @@ class TestDateDurations:
         _ = parse_duration(ser)
 
 
+class TestDateTimeDeltasWhenever:
+    @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())
+        with assume_does_not_raise(InvalidArgument):
+            delta = data.draw(
+                date_time_deltas_whenever(
+                    min_value=min_value, max_value=max_value, parsable=parsable
+                )
+            )
+        assert isinstance(delta, DateTimeDelta)
+        nanos = to_nanos(delta)
+        if min_value is not None:
+            assert nanos >= to_nanos(min_value)
+        if max_value is not None:
+            assert nanos <= to_nanos(max_value)
+        if parsable:
+            assert DateTimeDelta.parse_common_iso(delta.format_common_iso()) == delta
+
+
 class TestDatesTwoDigitYear:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:

{dycw_utilities-0.131.15 → dycw_utilities-0.131.16}/src/tests/test_typed_settings.py

@@ -8,10 +8,19 @@ from hypothesis import given
 from hypothesis.strategies import DataObject, SearchStrategy, data, tuples
 from pytest import mark, param
 from typed_settings import FileLoader, TomlFormat, load_settings
-from whenever import Date, DateDelta, PlainDateTime, Time, TimeDelta, ZonedDateTime
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    PlainDateTime,
+    Time,
+    TimeDelta,
+    ZonedDateTime,
+)
 
 from utilities.hypothesis import (
     date_deltas_whenever,
+    date_time_deltas_whenever,
     dates_whenever,
     plain_datetimes_whenever,
     temp_paths,
@@ -39,6 +48,11 @@ class TestExtendedTSConverter:
                 date_deltas_whenever(parsable=True),
                 DateDelta.format_common_iso,
             ),
+            param(
+                DateTimeDelta,
+                date_time_deltas_whenever(parsable=True),
+                DateTimeDelta.format_common_iso,
+            ),
             param(
                 PlainDateTime,
                 plain_datetimes_whenever(),

{dycw_utilities-0.131.15 → dycw_utilities-0.131.16}/src/tests/test_whenever.py

@@ -8,8 +8,6 @@ from zoneinfo import ZoneInfo
 
 from hypothesis import assume, example, given
 from hypothesis.strategies import (
-    DataObject,
-    data,
     dates,
     datetimes,
     integers,
@@ -37,19 +35,12 @@ from utilities.hypothesis import (
     assume_does_not_raise,
     datetime_durations,
     plain_datetimes,
-    timedeltas_2w,
     zoned_datetimes,
 )
 from utilities.tzdata import HongKong
 from utilities.whenever import (
     MAX_SERIALIZABLE_TIMEDELTA,
     MIN_SERIALIZABLE_TIMEDELTA,
-    EnsureDateError,
-    EnsureDateTimeError,
-    EnsureDurationError,
-    EnsurePlainDateTimeError,
-    EnsureTimeError,
-    EnsureZonedDateTimeError,
     ParseDateError,
     ParseDateTimeError,
     ParseDurationError,
@@ -61,20 +52,11 @@ from utilities.whenever import (
     SerializeTimeDeltaError,
     SerializeZonedDateTimeError,
     _CheckValidZonedDateTimeUnequalError,
-    _EnsureTimedeltaNanosecondError,
-    _EnsureTimedeltaParseError,
     _ParseTimedeltaNanosecondError,
     _ParseTimedeltaParseError,
     _to_datetime_delta,
     _ToDateTimeDeltaError,
     check_valid_zoned_datetime,
-    ensure_date,
-    ensure_datetime,
-    ensure_duration,
-    ensure_plain_datetime,
-    ensure_time,
-    ensure_timedelta,
-    ensure_zoned_datetime,
     parse_date,
     parse_datetime,
     parse_duration,
@@ -147,16 +129,6 @@ class TestSerializeAndParseDate:
         with raises(ParseDateError, match="Unable to parse date; got 'invalid'"):
             _ = parse_date("invalid")
 
-    @given(data=data(), date=dates())
-    def test_ensure(self, *, data: DataObject, date: dt.date) -> None:
-        str_or_value = data.draw(sampled_from([date, serialize_date(date)]))
-        result = ensure_date(str_or_value)
-        assert result == date
-
-    def test_error_ensure(self) -> None:
-        with raises(EnsureDateError, match="Unable to ensure date; got 'invalid'"):
-            _ = ensure_date("invalid")
-
 
 class TestSerializeAndParseDateTime:
     @given(
@@ -175,23 +147,6 @@ class TestSerializeAndParseDateTime:
         ):
             _ = parse_datetime("invalid")
 
-    @given(
-        data=data(),
-        datetime=plain_datetimes()
-        | zoned_datetimes(time_zone=timezones() | just(dt.UTC), valid=True),
-    )
-    @SKIPIF_CI_AND_WINDOWS
-    def test_ensure(self, *, data: DataObject, datetime: dt.datetime) -> None:
-        str_or_value = data.draw(sampled_from([datetime, serialize_datetime(datetime)]))
-        result = ensure_datetime(str_or_value)
-        assert result == datetime
-
-    def test_error_ensure(self) -> None:
-        with raises(
-            EnsureDateTimeError, match="Unable to ensure datetime; got 'invalid'"
-        ):
-            _ = ensure_datetime("invalid")
-
 
 class TestSerializeAndParseDuration:
     @given(duration=datetime_durations())
@@ -215,18 +170,6 @@ class TestSerializeAndParseDuration:
         ):
             _ = serialize_duration(duration)
 
-    @given(data=data(), duration=datetime_durations(two_way=True))
-    def test_ensure(self, *, data: DataObject, duration: Duration) -> None:
-        str_or_value = data.draw(sampled_from([duration, serialize_duration(duration)]))
-        result = ensure_duration(str_or_value)
-        assert result == duration
-
-    def test_error_ensure(self) -> None:
-        with raises(
-            EnsureDurationError, match="Unable to ensure duration; got 'invalid'"
-        ):
-            _ = ensure_duration("invalid")
-
 
 class TestSerializeAndParsePlainDateTime:
     @given(datetime=datetimes())
@@ -264,21 +207,6 @@ class TestSerializeAndParsePlainDateTime:
         ):
             _ = serialize_plain_datetime(datetime)
 
-    @given(data=data(), datetime=datetimes())
-    def test_ensure(self, *, data: DataObject, datetime: dt.datetime) -> None:
-        str_or_value = data.draw(
-            sampled_from([datetime, serialize_plain_datetime(datetime)])
-        )
-        result = ensure_plain_datetime(str_or_value)
-        assert result == datetime
-
-    def test_error_ensure(self) -> None:
-        with raises(
-            EnsurePlainDateTimeError,
-            match="Unable to ensure plain datetime; got 'invalid'",
-        ):
-            _ = ensure_plain_datetime("invalid")
-
 
 class TestSerializeAndParseTime:
     @given(time=times())
@@ -291,16 +219,6 @@ class TestSerializeAndParseTime:
         with raises(ParseTimeError, match="Unable to parse time; got 'invalid'"):
             _ = parse_time("invalid")
 
-    @given(data=data(), time=times())
-    def test_ensure(self, *, data: DataObject, time: dt.time) -> None:
-        str_or_value = data.draw(sampled_from([time, serialize_time(time)]))
-        result = ensure_time(str_or_value)
-        assert result == time
-
-    def test_error_ensure(self) -> None:
-        with raises(EnsureTimeError, match="Unable to ensure time; got 'invalid'"):
-            _ = ensure_time("invalid")
-
 
 class TestSerializeAndParseTimedelta:
     @given(
@@ -353,28 +271,6 @@ class TestSerializeAndParseTimedelta:
         ):
             _ = serialize_timedelta(timedelta)
 
-    @given(data=data(), timedelta=timedeltas_2w())
-    def test_ensure(self, *, data: DataObject, timedelta: dt.timedelta) -> None:
-        str_or_value = data.draw(
-            sampled_from([timedelta, serialize_timedelta(timedelta)])
-        )
-        result = ensure_timedelta(str_or_value)
-        assert result == timedelta
-
-    def test_error_ensure(self) -> None:
-        with raises(
-            _EnsureTimedeltaParseError,
-            match="Unable to ensure timedelta; got 'invalid'",
-        ):
-            _ = ensure_timedelta("invalid")
-
-    def test_error_ensure_nano_seconds(self) -> None:
-        with raises(
-            _EnsureTimedeltaNanosecondError,
-            match="Unable to ensure timedelta; got 333 nanoseconds",
-        ):
-            _ = ensure_timedelta("PT0.111222333S")
-
 
 class TestSerializeAndParseZonedDateTime:
     @given(datetime=zoned_datetimes(valid=True))
@@ -436,25 +332,6 @@ class TestSerializeAndParseZonedDateTime:
         ):
             _ = serialize_zoned_datetime(datetime)
 
-    @given(
-        data=data(),
-        datetime=zoned_datetimes(time_zone=timezones() | just(dt.UTC), valid=True),
-    )
-    @SKIPIF_CI_AND_WINDOWS
-    def test_ensure(self, *, data: DataObject, datetime: dt.datetime) -> None:
-        str_or_value = data.draw(
-            sampled_from([datetime, serialize_zoned_datetime(datetime)])
-        )
-        result = ensure_zoned_datetime(str_or_value)
-        assert result == datetime
-
-    def test_error_ensure(self) -> None:
-        with raises(
-            EnsureZonedDateTimeError,
-            match="Unable to ensure zoned datetime; got 'invalid'",
-        ):
-            _ = ensure_zoned_datetime("invalid")
-
 
 class TestToDateTimeDelta:
     @given(days=integers(), microseconds=integers())