dycw-utilities 0.150.10__tar.gz → 0.150.12__tar.gz

{dycw_utilities-0.150.10 → dycw_utilities-0.150.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.150.10
+Version: 0.150.12
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -12,7 +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.0; extra == 'test'
+Requires-Dist: hypothesis<6.137,>=6.136.1; extra == 'test'
 Requires-Dist: pudb<2025.2,>=2025.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'

{dycw_utilities-0.150.10 → dycw_utilities-0.150.12}/pyproject.toml

@@ -7,103 +7,232 @@ requires = ["hatchling"]
 
 # dependency groups
 [dependency-groups]
-altair = ["altair >= 5.5.0, < 5.6"]
+altair = [
+  "altair >=5.5.0, <5.6",
+]
 altair-test = [
   "polars",
   "img2pdf",
   "vl-convert-python",
 ]
-atools = ["atools >= 0.14.2, < 0.15"]
-cachetools = ["cachetools >= 6.1.0, < 6.2"]
-click = ["click >= 8.2.1, < 8.3"]
+atools = [
+  "atools >=0.14.2, <0.15",
+]
+cachetools = [
+  "cachetools >=6.1.0, <6.2",
+]
+click = [
+  "click >=8.2.1, <8.3",
+]
 core = [
-  "atomicwrites >= 1.4.1, < 1.5",
-  "typing-extensions >= 4.14.1, < 4.15",
-  "tzlocal >= 5.3.1, < 5.4",
-  "whenever >= 0.8.7, < 0.9",
-]
-cryptography = ["cryptography >= 45.0.4, < 45.1"]
-cvxpy = ["cvxpy >= 1.7.1, < 1.8"]
-dataclasses-test = ["orjson", "polars"]
+  "atomicwrites >=1.4.1, <1.5",
+  "typing-extensions >=4.14.1, <4.15",
+  "tzlocal >=5.3.1, <5.4",
+  "whenever >=0.8.7, <0.9",
+]
+cryptography = [
+  "cryptography >=45.0.4, <45.1",
+]
+cvxpy = [
+  "cvxpy >=1.7.1, <1.8",
+]
+dataclasses-test = [
+  "orjson",
+  "polars",
+]
 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",
-]
-dnspython = ["dnspython >= 2.7.0, < 2.8"]
-eventkit = ["eventkit >= 1.0.3, < 1.1"]
-fastapi = ["fastapi >= 0.116.0, < 0.117"]
-fastapi-test = ["httpx", "uvicorn"]
-fpdf2 = ["fpdf2 >= 2.8.3, < 2.9"]
-hashlib-test = ["orjson"]
-http-test = ["orjson"]
-hypothesis = ["hypothesis >= 6.136.0, < 6.137"]
-hypothesis-test = ["libcst", "pathvalidate", "numpy", "pytest-rerunfailures"]
-inflect = ["inflect >= 7.5.0, < 7.6"]
-jupyter-test = ["pandas", "polars"]
-libcst = ["libcst >= 1.8.0, < 1.9"]
-lightweight-charts = ["lightweight-charts >= 2.1, < 2.2"]
-lightweight-charts-test = ["polars-lts-cpu", "pyarrow"]
-math-test = ["numpy"]
-memory-profiler = ["memory-profiler >= 0.61.0, < 0.62"]
-more-itertools = ["more-itertools >= 10.7.0, < 10.8"]
-numpy = ["numpy >= 2.3.1, < 2.4"]
-operator = ["polars"]
-optuna = ["optuna >= 4.4.0, < 4.5"]
-orjson = ["orjson >= 3.11.0, < 3.12"]
-orjson-test = ["polars"]
-polars = ["polars >= 1.31.0, < 1.32"]
-polars-ols = ["polars-ols >= 0.3.5, < 0.4"]
-polars-ols-test = ["scikit-learn"]
-polars-test = ["numpy", "statsmodels"]
-pottery = ["pottery >= 3.0.1, < 3.1"]
-pottery-test = ["orjson", "pytest-rerunfailures"]
-pqdm = ["pqdm >= 0.2.0, < 0.3"]
-psutil = ["psutil >= 7.0.0, < 7.1"]
-pyinstrument = ["pyinstrument >= 5.0.3, < 5.1"]
+  "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",
+]
+dnspython = [
+  "dnspython >=2.7.0, <2.8",
+]
+eventkit = [
+  "eventkit >=1.0.3, <1.1",
+]
+fastapi = [
+  "fastapi >=0.116.0, <0.117",
+]
+fastapi-test = [
+  "httpx",
+  "uvicorn",
+]
+fpdf2 = [
+  "fpdf2 >=2.8.3, <2.9",
+]
+hashlib-test = [
+  "orjson",
+]
+http-test = [
+  "orjson",
+]
+hypothesis = [
+  "hypothesis >=6.136.1, <6.137",
+]
+hypothesis-test = [
+  "libcst",
+  "pathvalidate",
+  "numpy",
+  "pytest-rerunfailures",
+]
+inflect = [
+  "inflect >=7.5.0, <7.6",
+]
+jupyter-test = [
+  "pandas",
+  "polars",
+]
+libcst = [
+  "libcst >=1.8.0, <1.9",
+]
+lightweight-charts = [
+  "lightweight-charts >=2.1, <2.2",
+]
+lightweight-charts-test = [
+  "polars-lts-cpu",
+  "pyarrow",
+]
+math-test = [
+  "numpy",
+]
+memory-profiler = [
+  "memory-profiler >=0.61.0, <0.62",
+]
+more-itertools = [
+  "more-itertools >=10.7.0, <10.8",
+]
+numpy = [
+  "numpy >=2.3.1, <2.4",
+]
+operator = [
+  "polars",
+]
+optuna = [
+  "optuna >=4.4.0, <4.5",
+]
+orjson = [
+  "orjson >=3.11.0, <3.12",
+]
+orjson-test = [
+  "polars",
+]
+polars = [
+  "polars >=1.31.0, <1.32",
+]
+polars-ols = [
+  "polars-ols >=0.3.5, <0.4",
+]
+polars-ols-test = [
+  "scikit-learn",
+]
+polars-test = [
+  "numpy",
+  "statsmodels",
+]
+pottery = [
+  "pottery >=3.0.1, <3.1",
+]
+pottery-test = [
+  "orjson",
+  "pytest-rerunfailures",
+]
+pqdm = [
+  "pqdm >=0.2.0, <0.3",
+]
+psutil = [
+  "psutil >=7.0.0, <7.1",
+]
+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",
-  "pytest-timeout >= 2.4.0, < 2.5",
-  "pytest-xdist >= 3.8.0, < 3.9",
-]
-pytest-regressions = ["pytest-regressions >= 2.8.1, < 2.9"]
-pytest-regressions-test = ["orjson", "polars"]
-pytest-test = ["orjson", "pytest-rng", "pytest-rerunfailures"]
-redis = ["redis >= 6.2.0, < 6.3", "orjson"]
-redis-test = ["pytest-rerunfailures"]
-reprlib-test = ["rich"]
-scipy = ["scipy >= 1.16.0, < 1.17"]
-sklearn = ["scikit-learn >= 1.7.0, < 1.8"]
-slack-sdk = ["slack-sdk >= 3.36.0, < 3.37"]
-slack-sdk-test = ["aiohttp"]
-sqlalchemy = ["sqlalchemy >= 2.0.41, < 2.1", "psycopg"]
-sqlalchemy-polars = ["sqlalchemy", "polars"]
-sqlalchemy-polars-test = ["aiosqlite", "asyncpg", "greenlet"]
-sqlalchemy-test = ["aiosqlite", "asyncpg", "greenlet"]
-statsmodels = ["statsmodels >= 0.14.4, < 0.15"]
-typed-settings = ["typed-settings >= 24.6.0, < 24.7"]
-tzdata = ["tzdata >= 2025.2, < 2025.3"]
+  "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",
+  "pytest-timeout >=2.4.0, <2.5",
+  "pytest-xdist >=3.8.0, <3.9",
+]
+pytest-regressions = [
+  "pytest-regressions >=2.8.1, <2.9",
+]
+pytest-regressions-test = [
+  "orjson",
+  "polars",
+]
+pytest-test = [
+  "orjson",
+  "pytest-rng",
+  "pytest-rerunfailures",
+]
+redis = [
+  "redis >=6.2.0, <6.3",
+  "orjson",
+]
+redis-test = [
+  "pytest-rerunfailures",
+]
+reprlib-test = [
+  "rich",
+]
+scipy = [
+  "scipy >=1.16.0, <1.17",
+]
+sklearn = [
+  "scikit-learn >=1.7.0, <1.8",
+]
+slack-sdk = [
+  "slack-sdk >=3.36.0, <3.37",
+]
+slack-sdk-test = [
+  "aiohttp",
+]
+sqlalchemy = [
+  "sqlalchemy >=2.0.41, <2.1",
+  "psycopg",
+]
+sqlalchemy-polars = [
+  "sqlalchemy",
+  "polars",
+]
+sqlalchemy-polars-test = [
+  "aiosqlite",
+  "asyncpg",
+  "greenlet",
+]
+sqlalchemy-test = [
+  "aiosqlite",
+  "asyncpg",
+  "greenlet",
+]
+statsmodels = [
+  "statsmodels >=0.14.4, <0.15",
+]
+typed-settings = [
+  "typed-settings >=24.6.0, <24.7",
+]
+tzdata = [
+  "tzdata >=2025.2, <2025.3",
+]
 
 # project
 [project]
 authors = [{name = "Derek Wan", email = "d.wan@icloud.com"}]
 dependencies = [
-  "atomicwrites >= 1.4.1, < 1.5",
-  "typing-extensions >= 4.14.0, < 4.15",
-  "tzlocal >= 5.3.1, < 5.4",
-  "whenever >= 0.8.7, < 0.9",
+  "atomicwrites >=1.4.1, <1.5",
+  "typing-extensions >=4.14.0, <4.15",
+  "tzlocal >=5.3.1, <5.4",
+  "whenever >=0.8.7, <0.9",
 ]
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.150.10"
+version = "0.150.12"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -111,24 +240,24 @@ pytest-regressions = "utilities.pytest_plugins.pytest_regressions"
 
 [project.optional-dependencies]
 logging = [
-  "coloredlogs >= 15.0.1, < 15.1",
+  "coloredlogs >=15.0.1, <15.1",
 ]
 test = [
-  "dycw-pytest-only >= 2.1.1, < 2.2",
-  "hypothesis >= 6.136.0, < 6.137",
-  "pudb >= 2025.1, < 2025.2",
-  "pytest >= 8.4.1, < 8.5",
-  "pytest-asyncio >= 1.1.0, < 1.2",
-  "pytest-cov >= 6.2.1, < 6.3",
-  "pytest-instafail >= 0.5.0, < 0.6",
-  "pytest-lazy-fixtures >= 1.1.4, < 1.2",
-  "pytest-randomly >= 3.16.0, < 3.17",
-  "pytest-regressions >= 2.8.1, < 2.9",
-  "pytest-repeat >= 0.9.4, < 0.10",
-  "pytest-rerunfailures >= 15.1, < 16",
-  "pytest-rng >= 1.0.0, < 1.1",
-  "pytest-timeout >= 2.4.0, < 2.5",
-  "pytest-xdist >= 3.8.0, < 3.9",
+  "dycw-pytest-only >=2.1.1, <2.2",
+  "hypothesis >=6.136.1, <6.137",
+  "pudb >=2025.1, <2025.2",
+  "pytest >=8.4.1, <8.5",
+  "pytest-asyncio >=1.1.0, <1.2",
+  "pytest-cov >=6.2.1, <6.3",
+  "pytest-instafail >=0.5.0, <0.6",
+  "pytest-lazy-fixtures >=1.1.4, <1.2",
+  "pytest-randomly >=3.16.0, <3.17",
+  "pytest-regressions >=2.8.1, <2.9",
+  "pytest-repeat >=0.9.4, <0.10",
+  "pytest-rerunfailures >=15.1, <16",
+  "pytest-rng >=1.0.0, <1.1",
+  "pytest-timeout >=2.4.0, <2.5",
+  "pytest-xdist >=3.8.0, <3.9",
 ]
 
 [project.scripts]
@@ -136,7 +265,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.150.10"
+current_version = "0.150.12"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.150.10 → dycw_utilities-0.150.12}/src/tests/test_period.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any, cast
 from hypothesis import HealthCheck, given, settings
 from hypothesis.strategies import DataObject, data
 from pytest import mark, param, raises
-from whenever import Date, ZonedDateTime
+from whenever import Date, Time, ZonedDateTime
 
 from utilities.hypothesis import (
     assume_does_not_raise,
@@ -15,10 +15,12 @@ from utilities.hypothesis import (
     pairs,
     plain_datetimes,
     time_deltas,
+    times,
     zoned_datetimes,
 )
 from utilities.period import (
     DatePeriod,
+    TimePeriod,
     ZonedDateTimePeriod,
     _PeriodAsDict,
     _PeriodExactEqArgumentsError,
@@ -26,7 +28,7 @@ from utilities.period import (
     _PeriodTimeZoneError,
 )
 from utilities.tzdata import USCentral, USEastern
-from utilities.whenever import DAY
+from utilities.whenever import DAY, SECOND
 from utilities.zoneinfo import UTC, get_time_zone_name
 
 if TYPE_CHECKING:
@@ -46,6 +48,31 @@ class TestDatePeriod:
         expected = DatePeriod(start + delta, end + delta)
         assert result == expected
 
+    @given(dates=pairs(dates(), sorted=True), time=times())
+    def test_at_time(self, *, dates: tuple[Date, Date], time: Time) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        result = period.at(time)
+        expected = ZonedDateTimePeriod(
+            start.at(time).assume_tz(UTC.key), end.at(time).assume_tz(UTC.key)
+        )
+        assert result.exact_eq(expected)
+
+    @given(dates=pairs(dates(), sorted=True), times=pairs(times()))
+    def test_at_times(
+        self, *, dates: tuple[Date, Date], times: tuple[Time, Time]
+    ) -> None:
+        start_date, end_date = dates
+        period = DatePeriod(start_date, end_date)
+        start_time, end_time = times
+        with assume_does_not_raise(_PeriodInvalidError):
+            result = period.at((start_time, end_time))
+        expected = ZonedDateTimePeriod(
+            start_date.at(start_time).assume_tz(UTC.key),
+            end_date.at(end_time).assume_tz(UTC.key),
+        )
+        assert result.exact_eq(expected)
+
     @given(date=dates(), dates=pairs(dates(), sorted=True))
     def test_contains(self, *, date: Date, dates: tuple[Date, Date]) -> None:
         start, end = dates
@@ -82,6 +109,14 @@ class TestDatePeriod:
         period = DatePeriod(start, end)
         _ = hash(period)
 
+    @given(dates=pairs(dates(), sorted=True))
+    def test_replace(self, *, dates: tuple[Date, Date]) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        new = period.replace(start=start - DAY, end=end + DAY)
+        assert new.start == (start - DAY)
+        assert new.end == (end + DAY)
+
     @given(dates=pairs(dates(), sorted=True))
     @mark.parametrize("func", [param(repr), param(str)])
     def test_repr(self, *, dates: tuple[Date, Date], func: Callable[..., str]) -> None:
@@ -125,6 +160,79 @@ class TestDatePeriod:
             _ = DatePeriod(end, start)
 
 
+class TestTimePeriod:
+    @given(times=pairs(times()), date=dates())
+    def test_at_day(self, *, times: tuple[Time, Time], date: Date) -> None:
+        start, end = times
+        period = TimePeriod(start, end)
+        with assume_does_not_raise(_PeriodInvalidError):
+            result = period.at(date)
+        expected = ZonedDateTimePeriod(
+            date.at(start).assume_tz(UTC.key), date.at(end).assume_tz(UTC.key)
+        )
+        assert result.exact_eq(expected)
+
+    @given(times=pairs(times()), dates=pairs(dates(), sorted=True))
+    def test_at_days(
+        self, *, times: tuple[Time, Time], dates: tuple[Date, Date]
+    ) -> None:
+        start_time, end_time = times
+        period = TimePeriod(start_time, end_time)
+        start_date, end_date = dates
+        with assume_does_not_raise(_PeriodInvalidError):
+            result = period.at((start_date, end_date))
+        expected = ZonedDateTimePeriod(
+            start_date.at(start_time).assume_tz(UTC.key),
+            end_date.at(end_time).assume_tz(UTC.key),
+        )
+        assert result.exact_eq(expected)
+
+    @given(dates=pairs(dates(), sorted=True), times=pairs(times()))
+    def test_at_times(
+        self, *, dates: tuple[Date, Date], times: tuple[Time, Time]
+    ) -> None:
+        start_date, end_date = dates
+        period = DatePeriod(start_date, end_date)
+        start_time, end_time = times
+        with assume_does_not_raise(_PeriodInvalidError):
+            result = period.at((start_time, end_time))
+        expected = ZonedDateTimePeriod(
+            start_date.at(start_time).assume_tz(UTC.key),
+            end_date.at(end_time).assume_tz(UTC.key),
+        )
+        assert result.exact_eq(expected)
+
+    @given(times=pairs(times()), new_times=pairs(times()))
+    def test_replace(
+        self, *, times: tuple[Time, Time], new_times: tuple[Time, Time]
+    ) -> None:
+        start, end = times
+        period = TimePeriod(start, end)
+        new_start, new_end = new_times
+        new = period.replace(start=new_start, end=new_end)
+        assert new.start == new_start
+        assert new.end == new_end
+
+    @given(times=pairs(times()))
+    @mark.parametrize("func", [param(repr), param(str)])
+    def test_repr(self, *, times: tuple[Time, Time], func: Callable[..., str]) -> None:
+        start, end = times
+        period = TimePeriod(start, end)
+        result = func(period)
+        assert search(
+            r"^TimePeriod\(\d{2}:\d{2}:\d{2}(\.\d{1,6})?, \d{2}:\d{2}:\d{2}(\.\d{1,6})?\)$",
+            result,
+        )
+
+    @given(times=pairs(times()))
+    def test_to_dict(self, *, 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
+
+
 class TestZonedDateTimePeriod:
     @given(datetimes=pairs(zoned_datetimes(), sorted=True), delta=time_deltas())
     @settings(suppress_health_check={HealthCheck.filter_too_much})
@@ -292,6 +400,14 @@ class TestZonedDateTimePeriod:
         period = ZonedDateTimePeriod(start, end)
         _ = hash(period)
 
+    @given(datetimes=pairs(zoned_datetimes(), sorted=True))
+    def test_replace(self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime]) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        new = period.replace(start=start - SECOND, end=end + SECOND)
+        assert new.start == (start - SECOND)
+        assert new.end == (end + SECOND)
+
     @given(data=data(), datetimes=pairs(zoned_datetimes(), sorted=True))
     @mark.parametrize("func", [param(repr), param(str)])
     def test_repr(

{dycw_utilities-0.150.10 → dycw_utilities-0.150.12}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.150.10"
+__version__ = "0.150.12"

{dycw_utilities-0.150.10 → dycw_utilities-0.150.12}/src/utilities/period.py

@@ -1,22 +1,22 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Self, TypedDict, overload, override
+from typing import TYPE_CHECKING, Any, Self, TypedDict, assert_never, overload, override
 from zoneinfo import ZoneInfo
 
-from whenever import Date, DateDelta, PlainDateTime, TimeDelta, ZonedDateTime
+from whenever import Date, DateDelta, PlainDateTime, Time, TimeDelta, ZonedDateTime
 
 from utilities.dataclasses import replace_non_sentinel
 from utilities.functions import get_class_name
 from utilities.sentinel import Sentinel, sentinel
 from utilities.whenever import format_compact
-from utilities.zoneinfo import get_time_zone_name
+from utilities.zoneinfo import UTC, ensure_time_zone, get_time_zone_name
 
 if TYPE_CHECKING:
     from utilities.types import TimeZoneLike
 
 
-class _PeriodAsDict[T: (Date, ZonedDateTime)](TypedDict):
+class _PeriodAsDict[T: (Date, Time, ZonedDateTime)](TypedDict):
     start: T
     end: T
 
@@ -49,6 +49,22 @@ class DatePeriod:
         """Offset the period."""
         return self.replace(start=self.start - other, end=self.end - other)
 
+    def at(
+        self, obj: Time | tuple[Time, Time], /, *, time_zone: TimeZoneLike = UTC
+    ) -> ZonedDateTimePeriod:
+        """Combine a date with a time to create a datetime."""
+        match obj:
+            case Time() as time:
+                start = end = time
+            case Time() as start, Time() as end:
+                ...
+            case _ as never:
+                assert_never(never)
+        tz = ensure_time_zone(time_zone).key
+        return ZonedDateTimePeriod(
+            self.start.at(start).assume_tz(tz), self.end.at(end).assume_tz(tz)
+        )
+
     @property
     def delta(self) -> DateDelta:
         """The delta of the period."""
@@ -76,6 +92,42 @@ class DatePeriod:
         return _PeriodAsDict(start=self.start, end=self.end)
 
 
+@dataclass(repr=False, order=True, unsafe_hash=True, kw_only=False)
+class TimePeriod:
+    """A period of times."""
+
+    start: Time
+    end: Time
+
+    @override
+    def __repr__(self) -> str:
+        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:
+        """Combine a date with a time to create a datetime."""
+        match obj:
+            case Date() as date:
+                start = end = date
+            case Date() as start, Date() as end:
+                ...
+            case _ as never:
+                assert_never(never)
+        return DatePeriod(start, end).at((self.start, self.end), time_zone=time_zone)
+
+    def to_dict(self) -> _PeriodAsDict[Time]:
+        """Convert the period to a dictionary."""
+        return _PeriodAsDict(start=self.start, end=self.end)
+
+
 @dataclass(repr=False, order=True, unsafe_hash=True, kw_only=False)
 class ZonedDateTimePeriod:
     """A period of time."""
@@ -234,4 +286,4 @@ class _PeriodExactEqArgumentsError(PeriodError):
         return f"Invalid arguments; got {self.args}"
 
 
-__all__ = ["DatePeriod", "PeriodError", "ZonedDateTimePeriod"]
+__all__ = ["DatePeriod", "PeriodError", "TimePeriod", "ZonedDateTimePeriod"]