dycw-utilities 0.131.10__py3-none-any.whl → 0.131.12__py3-none-any.whl

utilities/math.py

@@ -8,9 +8,10 @@ from re import Match, search
 from typing import TYPE_CHECKING, Literal, assert_never, overload, override
 
 from utilities.errors import ImpossibleCaseError
+from utilities.re import ExtractGroupsError, extract_groups
 
 if TYPE_CHECKING:
-    from utilities.types import Number, RoundMode, Sign
+    from utilities.types import MathRoundMode, Number, Sign
 
 
 MIN_FLOAT32, MAX_FLOAT32 = -3.4028234663852886e38, 3.4028234663852886e38
@@ -708,7 +709,7 @@ def round_(
     x: float,
     /,
     *,
-    mode: RoundMode = "standard",
+    mode: MathRoundMode = "standard",
     rel_tol: float | None = None,
     abs_tol: float | None = None,
 ) -> int:
@@ -748,7 +749,7 @@ def round_(
 
 def _round_tie_standard(
     x: float,
-    mode: RoundMode,
+    mode: MathRoundMode,
     /,
     *,
     rel_tol: float | None = None,
@@ -757,9 +758,9 @@ def _round_tie_standard(
     """Round a float to an integer using the standard method."""
     frac, _ = modf(x)
     if _is_close(abs(frac), 0.5, rel_tol=rel_tol, abs_tol=abs_tol):
-        mode_use: RoundMode = mode
+        mode_use: MathRoundMode = mode
     else:
-        mode_use: RoundMode = "standard"
+        mode_use: MathRoundMode = "standard"
     return round_(x, mode=mode_use)
 
 
@@ -775,9 +776,9 @@ def round_float_imprecisions(
 ) -> float:
     """Round a float, removing binary representation imprecisions."""
     try:
-        ((head, tail),) = _ROUND_FLOAT_IMPRECISIONS_PATTERN.findall(str(x))
-    except ValueError:
-        ((head, tail),) = _ROUND_FLOAT_IMPRECISIONS_PATTERN.findall(f"{x:.20f}")
+        head, tail = extract_groups(_ROUND_FLOAT_IMPRECISIONS_PATTERN, str(x))
+    except ExtractGroupsError:
+        head, tail = extract_groups(_ROUND_FLOAT_IMPRECISIONS_PATTERN, f"{x:.20f}")
     half = ceil(decimals / 2)
     pattern0 = search(rf"^([0-9]+?)(0{{{half},}})([0-9]+?)$", tail)
     pattern9 = search(rf"^(0*)([0-9]+?)(9{{{half},}})([0-9]+?)$", tail)
@@ -823,7 +824,7 @@ def round_to_float(
     y: float,
     /,
     *,
-    mode: RoundMode = "standard",
+    mode: MathRoundMode = "standard",
     rel_tol: float | None = None,
     abs_tol: float | None = None,
 ) -> float:

utilities/orjson.py

@@ -14,6 +14,7 @@ from pathlib import Path
 from re import Pattern, search
 from typing import TYPE_CHECKING, Any, Literal, Self, assert_never, overload, override
 from uuid import UUID
+from zoneinfo import ZoneInfo
 
 from orjson import (
     OPT_PASSTHROUGH_DATACLASS,
@@ -22,6 +23,7 @@ from orjson import (
     dumps,
     loads,
 )
+from whenever import ZonedDateTime
 
 from utilities.concurrent import concurrent_map
 from utilities.dataclasses import dataclass_to_dict
@@ -35,15 +37,8 @@ from utilities.iterables import (
 )
 from utilities.logging import get_logging_level_number
 from utilities.math import MAX_INT64, MIN_INT64
-from utilities.types import (
-    Dataclass,
-    DateOrDateTime,
-    LogLevel,
-    MaybeIterable,
-    PathLike,
-    StrMapping,
-)
-from utilities.tzlocal import get_local_time_zone
+from utilities.types import Dataclass, LogLevel, MaybeIterable, PathLike, StrMapping
+from utilities.tzlocal import LOCAL_TIME_ZONE
 from utilities.uuid import UUID_PATTERN
 from utilities.version import Version, parse_version
 from utilities.whenever import (
@@ -57,12 +52,14 @@ from utilities.whenever import (
     serialize_time,
     serialize_timedelta,
 )
-from utilities.zoneinfo import ensure_time_zone
+from utilities.whenever2 import from_timestamp
 
 if TYPE_CHECKING:
     from collections.abc import Set as AbstractSet
     from logging import _FormatStyle
 
+    from whenever import Date
+
     from utilities.types import Parallelism
 
 
@@ -92,6 +89,7 @@ class _Prefixes(Enum):
     unserializable = "un"
     uuid = "uu"
     version = "v"
+    zoned_datetime = "zd"
 
 
 type _DataclassHook = Callable[[type[Dataclass], StrMapping], StrMapping]
@@ -194,6 +192,8 @@ def _pre_process(
             return f"[{_Prefixes.exception_class.value}|{error_cls.__qualname__}]"
         case Version() as version:
             return f"[{_Prefixes.version.value}]{version!s}"
+        case ZonedDateTime() as datetime:
+            return f"[{_Prefixes.zoned_datetime.value}]{datetime}"
         # contains
         case Dataclass() as dataclass:
             asdict = dataclass_to_dict(
@@ -350,6 +350,11 @@ _ZONED_DATETIME_PATTERN = re.compile(
     + _Prefixes.datetime.value
     + r"\](\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?[\+\-]\d{2}:\d{2}(?::\d{2})?\[(?!(?:dt\.)).+?\])$"
 )
+_ZONED_DATETIME_PATTERN2 = re.compile(
+    r"^\["
+    + _Prefixes.zoned_datetime.value
+    + r"\](\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?[\+\-]\d{2}:\d{2}(?::\d{2})?\[(?!(?:dt\.)).+?\])$"
+)
 
 
 def _make_unit_pattern(prefix: _Prefixes, /) -> Pattern[str]:
@@ -437,6 +442,8 @@ def _object_hook(
                 return parse_version(match.group(1))
             if match := _ZONED_DATETIME_PATTERN.search(text):
                 return parse_zoned_datetime(match.group(1))
+            if match := _ZONED_DATETIME_PATTERN2.search(text):
+                return ZonedDateTime.parse_common_iso(match.group(1))
             if (
                 exc_class := _object_hook_exception_class(
                     text, data=data, objects=objects, redirects=redirects
@@ -753,9 +760,7 @@ class OrjsonFormatter(Formatter):
             path_name=Path(record.pathname),
             line_num=record.lineno,
             message=record.getMessage(),
-            datetime=dt.datetime.fromtimestamp(
-                record.created, tz=get_local_time_zone()
-            ),
+            datetime=from_timestamp(record.created, time_zone="local"),
             func_name=record.funcName,
             extra=extra if len(extra) >= 1 else None,
         )
@@ -859,11 +864,16 @@ class GetLogRecordsOutput:
             for r in self.records
         ]
         if len(records) >= 1:
-            time_zone = one_unique(ensure_time_zone(r.datetime) for r in records)
+            time_zone = one_unique(ZoneInfo(r.datetime.tz) for r in records)
         else:
-            time_zone = get_local_time_zone()
+            time_zone = LOCAL_TIME_ZONE
         return DataFrame(
-            data=[dataclass_to_dict(r, recursive=False) for r in records],
+            data=[
+                dataclass_to_dict(
+                    replace(r, datetime=r.datetime.py_datetime()), recursive=False
+                )
+                for r in records
+            ],
             schema={
                 "index": UInt64,
                 "name": String,
@@ -891,9 +901,12 @@ class GetLogRecordsOutput:
         level: LogLevel | None = None,
         min_level: LogLevel | None = None,
         max_level: LogLevel | None = None,
-        date_or_datetime: DateOrDateTime | None = None,
-        min_date_or_datetime: DateOrDateTime | None = None,
-        max_date_or_datetime: DateOrDateTime | None = None,
+        date: Date | None = None,
+        min_date: Date | None = None,
+        max_date: Date | None = None,
+        datetime: ZonedDateTime | None = None,
+        min_datetime: ZonedDateTime | None = None,
+        max_datetime: ZonedDateTime | None = None,
         func_name: bool | str | None = None,
         extra: bool | MaybeIterable[str] | None = None,
         log_file: bool | PathLike | None = None,
@@ -932,30 +945,18 @@ class GetLogRecordsOutput:
             records = [
                 r for r in records if r.level <= get_logging_level_number(max_level)
             ]
-        if date_or_datetime is not None:
-            match date_or_datetime:
-                case dt.datetime() as datetime:
-                    records = [r for r in records if r.datetime == datetime]
-                case dt.date() as date:
-                    records = [r for r in records if r.date == date]
-                case _ as never:
-                    assert_never(never)
-        if min_date_or_datetime is not None:
-            match min_date_or_datetime:
-                case dt.datetime() as min_datetime:
-                    records = [r for r in records if r.datetime >= min_datetime]
-                case dt.date() as min_date:
-                    records = [r for r in records if r.date >= min_date]
-                case _ as never:
-                    assert_never(never)
-        if max_date_or_datetime is not None:
-            match max_date_or_datetime:
-                case dt.datetime() as max_datetime:
-                    records = [r for r in records if r.datetime <= max_datetime]
-                case dt.date() as max_date:
-                    records = [r for r in records if r.date <= max_date]
-                case _ as never:
-                    assert_never(never)
+        if date is not None:
+            records = [r for r in records if r.date == date]
+        if min_date is not None:
+            records = [r for r in records if r.date >= min_date]
+        if max_date is not None:
+            records = [r for r in records if r.date <= max_date]
+        if datetime is not None:
+            records = [r for r in records if r.datetime == datetime]
+        if min_datetime is not None:
+            records = [r for r in records if r.datetime >= min_datetime]
+        if max_datetime is not None:
+            records = [r for r in records if r.datetime <= max_datetime]
         if func_name is not None:
             match func_name:
                 case bool() as has_func_name:
@@ -1058,7 +1059,7 @@ class OrjsonLogRecord:
     level: int
     path_name: Path
     line_num: int
-    datetime: dt.datetime
+    datetime: ZonedDateTime
     func_name: str | None = None
     stack_info: str | None = None
     extra: StrMapping | None = None
@@ -1066,7 +1067,7 @@ class OrjsonLogRecord:
     log_file_line_num: int | None = None
 
     @cached_property
-    def date(self) -> dt.date:
+    def date(self) -> Date:
         return self.datetime.date()
 
 

utilities/pyinstrument.py

@@ -7,9 +7,8 @@ from typing import TYPE_CHECKING
 from pyinstrument.profiler import Profiler
 
 from utilities.atomicwrites import writer
-from utilities.datetime import serialize_compact
 from utilities.pathlib import get_path
-from utilities.tzlocal import get_now_local
+from utilities.whenever2 import format_compact, get_now
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -23,7 +22,7 @@ def profile(*, path: MaybeCallablePathLike | None = Path.cwd) -> Iterator[None]:
     with Profiler() as profiler:
         yield
     filename = get_path(path=path).joinpath(
-        f"profile__{serialize_compact(get_now_local())}.html"
+        f"profile__{format_compact(get_now())}.html"
     )
     with writer(filename) as temp, temp.open(mode="w") as fh:
         _ = fh.write(profiler.output_html())

utilities/re.py

@@ -5,8 +5,6 @@ from dataclasses import dataclass
 from re import Pattern
 from typing import TYPE_CHECKING, assert_never, override
 
-from utilities.iterables import OneEmptyError, OneNonUniqueError, one
-
 if TYPE_CHECKING:
     from utilities.types import PatternLike
 
@@ -36,16 +34,17 @@ def extract_group(pattern: PatternLike, text: str, /, *, flags: int = 0) -> str:
             raise _ExtractGroupNoCaptureGroupsError(pattern=pattern_use, text=text)
         case 1:
             matches: list[str] = pattern_use.findall(text)
-            try:
-                return one(matches)
-            except OneEmptyError:
-                raise _ExtractGroupNoMatchesError(
-                    pattern=pattern_use, text=text
-                ) from None
-            except OneNonUniqueError:
-                raise _ExtractGroupMultipleMatchesError(
-                    pattern=pattern_use, text=text, matches=matches
-                ) from None
+            match len(matches):
+                case 0:
+                    raise _ExtractGroupNoMatchesError(
+                        pattern=pattern_use, text=text
+                    ) from None
+                case 1:
+                    return matches[0]
+                case _:
+                    raise _ExtractGroupMultipleMatchesError(
+                        pattern=pattern_use, text=text, matches=matches
+                    ) from None
         case _:
             raise _ExtractGroupMultipleCaptureGroupsError(
                 pattern=pattern_use, text=text
@@ -109,7 +108,7 @@ def extract_groups(pattern: PatternLike, text: str, /, *, flags: int = 0) -> lis
         case 1, 1:
             return matches
         case 1, _:
-            return list(one(matches))
+            return list(matches[0])
         case _:
             raise _ExtractGroupsMultipleMatchesError(
                 pattern=pattern_use, text=text, matches=matches

utilities/traceback.py

@@ -14,7 +14,6 @@ from traceback import TracebackException
 from typing import TYPE_CHECKING, override
 
 from utilities.atomicwrites import writer
-from utilities.datetime import get_datetime, get_now, serialize_compact
 from utilities.errors import repr_error
 from utilities.iterables import OneEmptyError, one
 from utilities.pathlib import get_path
@@ -27,16 +26,19 @@ from utilities.reprlib import (
     RICH_MAX_WIDTH,
     yield_mapping_repr,
 )
-from utilities.tzlocal import get_local_time_zone, get_now_local
 from utilities.version import get_version
-from utilities.whenever import serialize_duration, serialize_zoned_datetime
+from utilities.whenever2 import format_compact, get_now, to_zoned_date_time
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterator, Sequence
     from traceback import FrameSummary
     from types import TracebackType
 
-    from utilities.types import MaybeCallableDateTime, MaybeCallablePathLike, PathLike
+    from utilities.types import (
+        MaybeCallablePathLike,
+        MaybeCallableZonedDateTime,
+        PathLike,
+    )
     from utilities.version import MaybeCallableVersionLike
 
 
@@ -51,7 +53,7 @@ def format_exception_stack(
     /,
     *,
     header: bool = False,
-    start: MaybeCallableDateTime | None = _START,
+    start: MaybeCallableZonedDateTime | None = _START,
     version: MaybeCallableVersionLike | None = None,
     capture_locals: bool = False,
     max_width: int = RICH_MAX_WIDTH,
@@ -82,21 +84,18 @@ def format_exception_stack(
 
 def _yield_header_lines(
     *,
-    start: MaybeCallableDateTime | None = _START,
+    start: MaybeCallableZonedDateTime | None = _START,
     version: MaybeCallableVersionLike | None = None,
 ) -> Iterator[str]:
     """Yield the header lines."""
-    now = get_now_local()
-    start_use = get_datetime(datetime=start)
-    start_use = (
-        None if start_use is None else start_use.astimezone(get_local_time_zone())
-    )
-    yield f"Date/time | {serialize_zoned_datetime(now)}"
-    start_str = "" if start_use is None else serialize_zoned_datetime(start_use)
+    now = get_now()
+    start_use = to_zoned_date_time(date_time=start)
+    yield f"Date/time | {format_compact(now)}"
+    start_str = "" if start_use is None else format_compact(start_use)
     yield f"Started   | {start_str}"
-    duration = None if start_use is None else (now - start_use)
-    duration_str = "" if duration is None else serialize_duration(duration)
-    yield f"Duration  | {duration_str}"
+    delta = None if start_use is None else (now - start_use)
+    delta_str = "" if delta is None else delta.format_common_iso()
+    yield f"Duration  | {delta_str}"
     yield f"User      | {getuser()}"
     yield f"Host      | {gethostname()}"
     version_use = "" if version is None else get_version(version=version)
@@ -193,7 +192,7 @@ def _trim_path(path: PathLike, pattern: str, /) -> Path | None:
 
 def make_except_hook(
     *,
-    start: MaybeCallableDateTime | None = _START,
+    start: MaybeCallableZonedDateTime | None = _START,
     version: MaybeCallableVersionLike | None = None,
     path: MaybeCallablePathLike | None = None,
     max_width: int = RICH_MAX_WIDTH,
@@ -228,7 +227,7 @@ def _make_except_hook_inner(
     traceback: TracebackType | None,
     /,
     *,
-    start: MaybeCallableDateTime | None = _START,
+    start: MaybeCallableZonedDateTime | None = _START,
     version: MaybeCallableVersionLike | None = None,
     path: MaybeCallablePathLike | None = None,
     max_width: int = RICH_MAX_WIDTH,
@@ -247,9 +246,7 @@ def _make_except_hook_inner(
     _ = sys.stderr.write(f"{slim}\n")  # don't 'from sys import stderr'
     if path is not None:
         path = (
-            get_path(path=path)
-            .joinpath(serialize_compact(get_now_local()))
-            .with_suffix(".txt")
+            get_path(path=path).joinpath(format_compact(get_now())).with_suffix(".txt")
         )
         full = format_exception_stack(
             exc_val,

utilities/types.py

@@ -20,6 +20,16 @@ from typing import (
 )
 from zoneinfo import ZoneInfo
 
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    PlainDateTime,
+    Time,
+    TimeDelta,
+    ZonedDateTime,
+)
+
 _T_co = TypeVar("_T_co", covariant=True)
 _T_contra = TypeVar("_T_contra", contravariant=True)
 
@@ -88,17 +98,16 @@ TDataclass = TypeVar("TDataclass", bound=Dataclass)
 
 
 # datetime
-type DateLike = MaybeStr[dt.date]
-type DateTimeLike = MaybeStr[dt.datetime]
 type DateOrDateTime = dt.date | dt.datetime
+type DateTimeLike = MaybeStr[dt.datetime]
 type Duration = Number | dt.timedelta
 type DurationLike = MaybeStr[Duration]
 type DurationOrEveryDuration = Duration | tuple[Literal["every"], Duration]
-type MaybeCallableDate = MaybeCallable[dt.date]
-type MaybeCallableDateTime = MaybeCallable[dt.datetime]
-type TimeLike = MaybeStr[dt.time]
-type TimeDeltaLike = MaybeStr[dt.timedelta]
-type WeekDay = Literal["mon", "tue", "wed", "thu", "fri", "sat", "sun"]
+type MaybeCallablePyDate = MaybeCallable[dt.date]
+type MaybeCallablePyDateTime = MaybeCallable[dt.datetime]
+type PyDateLike = MaybeStr[dt.date]
+type PyTimeDeltaLike = MaybeStr[dt.timedelta]
+type PyTimeLike = MaybeStr[dt.time]
 
 
 # enum
@@ -133,7 +142,7 @@ type LoggerOrName = MaybeStr[Logger]
 
 # math
 type Number = int | float
-type RoundMode = Literal[
+type MathRoundMode = Literal[
     "standard",
     "floor",
     "ceil",
@@ -259,6 +268,25 @@ type ExcInfo = tuple[type[BaseException], BaseException, TracebackType]
 type OptExcInfo = ExcInfo | tuple[None, None, None]
 
 
+# whenever
+type DateDeltaLike = MaybeStr[DateDelta]
+type DateLike = MaybeStr[Date]
+type DateTimeDeltaLike = MaybeStr[DateTimeDelta]
+type MaybeCallableDate = MaybeCallable[Date]
+type MaybeCallableZonedDateTime = MaybeCallable[ZonedDateTime]
+type PlainDateTimeLike = MaybeStr[PlainDateTime]
+type TimeDeltaLike = MaybeStr[TimeDelta]
+type TimeLike = MaybeStr[Time]
+type ZonedDateTimeLike = MaybeStr[ZonedDateTime]
+type DateTimeRoundUnit = Literal[
+    "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"
+]
+type DateTimeRoundMode = Literal[
+    "ceil", "floor", "half_ceil", "half_floor", "half_even"
+]
+type WeekDay = Literal["mon", "tue", "wed", "thu", "fri", "sat", "sun"]
+
+
 # zoneinfo
 # fmt: off
 type TimeZone = Literal[
@@ -271,9 +299,13 @@ type TimeZoneLike = ZoneInfo | Literal["local"] | TimeZone | dt.tzinfo | dt.date
 __all__ = [
     "Coroutine1",
     "Dataclass",
+    "DateDeltaLike",
     "DateLike",
     "DateOrDateTime",
+    "DateTimeDeltaLike",
     "DateTimeLike",
+    "DateTimeRoundMode",
+    "DateTimeRoundUnit",
     "Duration",
     "DurationLike",
     "DurationOrEveryDuration",
@@ -282,12 +314,15 @@ __all__ = [
     "IterableHashable",
     "LogLevel",
     "LoggerOrName",
+    "MathRoundMode",
     "MaybeAwaitable",
     "MaybeCallable",
     "MaybeCallableDate",
-    "MaybeCallableDateTime",
     "MaybeCallableEvent",
     "MaybeCallablePathLike",
+    "MaybeCallablePyDate",
+    "MaybeCallablePyDateTime",
+    "MaybeCallableZonedDateTime",
     "MaybeCoroutine1",
     "MaybeIterable",
     "MaybeIterableHashable",
@@ -300,7 +335,10 @@ __all__ = [
     "ParseObjectExtra",
     "PathLike",
     "PatternLike",
-    "RoundMode",
+    "PlainDateTimeLike",
+    "PyDateLike",
+    "PyTimeDeltaLike",
+    "PyTimeLike",
     "Seed",
     "SerializeObjectExtra",
     "Sign",
@@ -343,4 +381,5 @@ __all__ = [
     "TupleOrStrMapping",
     "TypeLike",
     "WeekDay",
+    "ZonedDateTimeLike",
 ]

utilities/typing.py

@@ -25,6 +25,16 @@ from typing import get_type_hints as _get_type_hints
 from uuid import UUID
 from warnings import warn
 
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    PlainDateTime,
+    Time,
+    TimeDelta,
+    ZonedDateTime,
+)
+
 from utilities.iterables import unique_everseen
 from utilities.sentinel import Sentinel
 from utilities.types import StrMapping
@@ -133,7 +143,21 @@ def get_type_hints(
 ) -> dict[str, Any]:
     """Get the type hints of an object."""
     result: dict[str, Any] = obj.__annotations__
-    _ = {Literal, Path, Sentinel, StrMapping, UUID, dt}
+    _ = {
+        Date,
+        DateDelta,
+        DateTimeDelta,
+        Literal,
+        Path,
+        PlainDateTime,
+        Sentinel,
+        StrMapping,
+        Time,
+        TimeDelta,
+        UUID,
+        ZonedDateTime,
+        dt,
+    }
     globalns_use = globals() | ({} if globalns is None else dict(globalns))
     localns_use = {} if localns is None else dict(localns)
     try:

utilities/tzlocal.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import datetime as dt
 from logging import getLogger
 from typing import TYPE_CHECKING
 
@@ -21,30 +20,7 @@ def get_local_time_zone() -> ZoneInfo:
 
 
 LOCAL_TIME_ZONE = get_local_time_zone()
+LOCAL_TIME_ZONE_NAME = LOCAL_TIME_ZONE.key
 
 
-def get_now_local() -> dt.datetime:
-    """Get the current local time."""
-    return dt.datetime.now(tz=LOCAL_TIME_ZONE)
-
-
-NOW_LOCAL = get_now_local()
-
-
-def get_today_local() -> dt.date:
-    """Get the current, timezone-aware local date."""
-    return get_now_local().date()
-
-
-TODAY_LOCAL = get_today_local()
-
-
-__all__ = [
-    "LOCAL_TIME_ZONE",
-    "LOCAL_TIME_ZONE",
-    "NOW_LOCAL",
-    "TODAY_LOCAL",
-    "get_local_time_zone",
-    "get_now_local",
-    "get_today_local",
-]
+__all__ = ["LOCAL_TIME_ZONE", "LOCAL_TIME_ZONE_NAME", "get_local_time_zone"]

utilities/whenever.py

@@ -34,12 +34,12 @@ from utilities.zoneinfo import UTC, ensure_time_zone, get_time_zone_name
 
 if TYPE_CHECKING:
     from utilities.types import (
-        DateLike,
         DateTimeLike,
         Duration,
         DurationLike,
-        TimeDeltaLike,
-        TimeLike,
+        PyDateLike,
+        PyTimeDeltaLike,
+        PyTimeLike,
     )
 
 
@@ -91,7 +91,7 @@ class _CheckValidZonedDateTimeUnequalError(CheckValidZonedDateTimeError):
 ##
 
 
-def ensure_date(date: DateLike, /) -> dt.date:
+def ensure_date(date: PyDateLike, /) -> dt.date:
     """Ensure the object is a date."""
     if isinstance(date, dt.date):
         check_date_not_datetime(date)
@@ -180,7 +180,7 @@ class EnsurePlainDateTimeError(Exception):
 ##
 
 
-def ensure_time(time: TimeLike, /) -> dt.time:
+def ensure_time(time: PyTimeLike, /) -> dt.time:
     """Ensure the object is a time."""
     if isinstance(time, dt.time):
         return time
@@ -202,7 +202,7 @@ class EnsureTimeError(Exception):
 ##
 
 
-def ensure_timedelta(timedelta: TimeDeltaLike, /) -> dt.timedelta:
+def ensure_timedelta(timedelta: PyTimeDeltaLike, /) -> dt.timedelta:
     """Ensure the object is a timedelta."""
     if isinstance(timedelta, dt.timedelta):
         return timedelta