dycw-utilities 0.151.8__tar.gz → 0.151.9__tar.gz

{dycw_utilities-0.151.8 → dycw_utilities-0.151.9}/PKG-INFO

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

{dycw_utilities-0.151.8 → dycw_utilities-0.151.9}/pyproject.toml

@@ -232,7 +232,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.151.8"
+version = "0.151.9"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -265,7 +265,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.151.8"
+current_version = "0.151.9"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.151.8 → dycw_utilities-0.151.9}/src/tests/test_period.py

@@ -4,7 +4,7 @@ from re import search
 from typing import TYPE_CHECKING, Any, cast
 
 from hypothesis import HealthCheck, given, settings
-from hypothesis.strategies import DataObject, data
+from hypothesis.strategies import DataObject, data, sampled_from
 from pytest import mark, param, raises
 from whenever import Date, Time, ZonedDateTime
 
@@ -17,6 +17,7 @@ from utilities.hypothesis import (
     time_deltas,
     times,
     zoned_datetimes,
+    zoned_datetimes_2000,
 )
 from utilities.period import (
     DatePeriod,
@@ -145,13 +146,20 @@ class TestDatePeriod:
         expected = DatePeriod(start - delta, end - delta)
         assert result == expected
 
-    @given(dates=pairs(dates(), sorted=True))
-    def test_to_dict(self, *, dates: tuple[Date, Date]) -> None:
+    @given(data=data(), dates=pairs(dates(), sorted=True))
+    def test_to_and_from_dict(
+        self, *, data: DataObject, 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
+        dict1 = period.to_dict()
+        dstart, dend = dict1["start"], dict1["end"]
+        dict2 = _PeriodAsDict(
+            start=data.draw(sampled_from([dstart, dstart.py_date()])),
+            end=data.draw(sampled_from([dend, dend.py_date()])),
+        )
+        result = DatePeriod.from_dict(dict2)
+        assert result == period
 
     @given(dates=pairs(dates(), unique=True, sorted=True))
     def test_error_period_invalid(self, *, dates: tuple[Date, Date]) -> None:
@@ -224,13 +232,20 @@ class TestTimePeriod:
             result,
         )
 
-    @given(times=pairs(times()))
-    def test_to_dict(self, *, times: tuple[Time, Time]) -> None:
+    @given(data=data(), times=pairs(times()))
+    def test_to_and_from_dict(
+        self, *, data: DataObject, times: tuple[Time, Time]
+    ) -> None:
         start, end = times
         period = TimePeriod(start, end)
-        result = period.to_dict()
-        expected = _PeriodAsDict(start=start, end=end)
-        assert result == expected
+        dict1 = period.to_dict()
+        dstart, dend = dict1["start"], dict1["end"]
+        dict2 = _PeriodAsDict(
+            start=data.draw(sampled_from([dstart, dstart.py_time()])),
+            end=data.draw(sampled_from([dend, dend.py_time()])),
+        )
+        result = TimePeriod.from_dict(dict2)
+        assert result == period
 
 
 class TestZonedDateTimePeriod:
@@ -455,13 +470,20 @@ class TestZonedDateTimePeriod:
         expected = ZonedDateTimePeriod(start - delta, end - delta)
         assert result == expected
 
-    @given(datetimes=pairs(zoned_datetimes(), sorted=True))
-    def test_to_dict(self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime]) -> None:
+    @given(data=data(), datetimes=pairs(zoned_datetimes_2000, sorted=True))
+    def test_to_and_from_dict(
+        self, data: DataObject, *, 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
+        dict1 = period.to_dict()
+        dstart, dend = dict1["start"], dict1["end"]
+        dict2 = _PeriodAsDict(
+            start=data.draw(sampled_from([dstart, dstart.py_datetime()])),
+            end=data.draw(sampled_from([dend, dend.py_datetime()])),
+        )
+        result = ZonedDateTimePeriod.from_dict(dict2)
+        assert result == period
 
     @given(datetimes=pairs(zoned_datetimes(), sorted=True))
     def test_to_tz(self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime]) -> None:

{dycw_utilities-0.151.8 → dycw_utilities-0.151.9}/src/tests/test_whenever.py

@@ -32,6 +32,7 @@ from utilities.hypothesis import (
     sentinels,
     times,
     zoned_datetimes,
+    zoned_datetimes_2000,
 )
 from utilities.sentinel import Sentinel, sentinel
 from utilities.tzdata import HongKong, Tokyo
@@ -1184,12 +1185,6 @@ class TestToYears:
             _ = to_years(delta)
 
 
-zoned_datetimes_2000 = zoned_datetimes(
-    min_value=ZonedDateTime(2000, 1, 1, tz=UTC.key),
-    max_value=ZonedDateTime(2000, 12, 31, tz=UTC.key),
-)
-
-
 class TestToZonedDateTime:
     @given(date_time=zoned_datetimes())
     def test_date_time(self, *, date_time: ZonedDateTime) -> None:

{dycw_utilities-0.151.8 → dycw_utilities-0.151.9}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.151.8"
+__version__ = "0.151.9"

{dycw_utilities-0.151.8 → dycw_utilities-0.151.9}/src/utilities/hypothesis.py

@@ -1415,6 +1415,11 @@ def zoned_datetimes(
     return zoned
 
 
+zoned_datetimes_2000 = zoned_datetimes(
+    min_value=ZonedDateTime(2000, 1, 1, tz=UTC.key),
+    max_value=ZonedDateTime(2000, 12, 31, tz=UTC.key),
+)
+
 __all__ = [
     "Draw2Error",
     "MaybeSearchStrategy",
@@ -1468,4 +1473,5 @@ __all__ = [
     "versions",
     "year_months",
     "zoned_datetimes",
+    "zoned_datetimes_2000",
 ]

{dycw_utilities-0.151.8 → dycw_utilities-0.151.9}/src/utilities/period.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import datetime as dt
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Self, TypedDict, assert_never, overload, override
 from zoneinfo import ZoneInfo
@@ -16,7 +17,9 @@ if TYPE_CHECKING:
     from utilities.types import TimeZoneLike
 
 
-class _PeriodAsDict[T: (Date, Time, ZonedDateTime)](TypedDict):
+class _PeriodAsDict[T: Date | Time | ZonedDateTime | dt.date | dt.time | dt.datetime](
+    TypedDict
+):
     start: T
     end: T
 
@@ -81,6 +84,25 @@ class DatePeriod:
             return f"{fc(start)}-{fc(end, fmt='%m%d')}"
         return f"{fc(start)}-{fc(end)}"
 
+    @classmethod
+    def from_dict(cls, mapping: _PeriodAsDict[Date | dt.date], /) -> Self:
+        """Convert the dictionary to a period."""
+        match mapping["start"]:
+            case Date() as start:
+                ...
+            case dt.date() as py_date:
+                start = Date.from_py_date(py_date)
+            case never:
+                assert_never(never)
+        match mapping["end"]:
+            case Date() as end:
+                ...
+            case dt.date() as py_date:
+                end = Date.from_py_date(py_date)
+            case never:
+                assert_never(never)
+        return cls(start=start, end=end)
+
     def replace(
         self, *, start: Date | Sentinel = sentinel, end: Date | Sentinel = sentinel
     ) -> Self:
@@ -104,12 +126,6 @@ class TimePeriod:
         cls = get_class_name(self)
         return f"{cls}({self.start}, {self.end})"
 
-    def replace(
-        self, *, start: Time | Sentinel = sentinel, end: Time | Sentinel = sentinel
-    ) -> Self:
-        """Replace elements of the period."""
-        return replace_non_sentinel(self, start=start, end=end)
-
     def at(
         self, obj: Date | tuple[Date, Date], /, *, time_zone: TimeZoneLike = UTC
     ) -> ZonedDateTimePeriod:
@@ -123,6 +139,31 @@ class TimePeriod:
                 assert_never(never)
         return DatePeriod(start, end).at((self.start, self.end), time_zone=time_zone)
 
+    @classmethod
+    def from_dict(cls, mapping: _PeriodAsDict[Time | dt.time], /) -> Self:
+        """Convert the dictionary to a period."""
+        match mapping["start"]:
+            case Time() as start:
+                ...
+            case dt.time() as py_time:
+                start = Time.from_py_time(py_time)
+            case never:
+                assert_never(never)
+        match mapping["end"]:
+            case Time() as end:
+                ...
+            case dt.time() as py_time:
+                end = Time.from_py_time(py_time)
+            case never:
+                assert_never(never)
+        return cls(start=start, end=end)
+
+    def replace(
+        self, *, start: Time | Sentinel = sentinel, end: Time | Sentinel = sentinel
+    ) -> Self:
+        """Replace elements of the period."""
+        return replace_non_sentinel(self, start=start, end=end)
+
     def to_dict(self) -> _PeriodAsDict[Time]:
         """Convert the period to a dictionary."""
         return _PeriodAsDict(start=self.start, end=self.end)
@@ -229,6 +270,25 @@ class ZonedDateTimePeriod:
             return f"{fc(start.to_plain())}-{fc(end, fmt='%Y%m%dT%H%M')}"
         return f"{fc(start.to_plain())}-{fc(end, fmt='%Y%m%dT%H')}"
 
+    @classmethod
+    def from_dict(cls, mapping: _PeriodAsDict[ZonedDateTime | dt.datetime], /) -> Self:
+        """Convert the dictionary to a period."""
+        match mapping["start"]:
+            case ZonedDateTime() as start:
+                ...
+            case dt.date() as py_datetime:
+                start = ZonedDateTime.from_py_datetime(py_datetime)
+            case never:
+                assert_never(never)
+        match mapping["end"]:
+            case ZonedDateTime() as end:
+                ...
+            case dt.date() as py_datetime:
+                end = ZonedDateTime.from_py_datetime(py_datetime)
+            case never:
+                assert_never(never)
+        return cls(start=start, end=end)
+
     def replace(
         self,
         *,
@@ -258,7 +318,7 @@ class PeriodError(Exception): ...
 
 
 @dataclass(kw_only=True, slots=True)
-class _PeriodInvalidError[T: (Date, ZonedDateTime)](PeriodError):
+class _PeriodInvalidError[T: Date | ZonedDateTime](PeriodError):
     start: T
     end: T