dycw-utilities 0.131.17__py3-none-any.whl → 0.131.18__py3-none-any.whl

{dycw_utilities-0.131.17.dist-info → dycw_utilities-0.131.18.dist-info}/METADATA

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

{dycw_utilities-0.131.17.dist-info → dycw_utilities-0.131.18.dist-info}/RECORD

@@ -1,4 +1,4 @@
-utilities/__init__.py,sha256=VaWub7ik43R7i6IUMJibr6EG62sAZ7zSqzl9IaPeNEs,61
+utilities/__init__.py,sha256=653kI0IdCJCyIvZc8ekfN8j8dOnjrRtGJKRx9UDXVvM,61
 utilities/aiolimiter.py,sha256=mD0wEiqMgwpty4XTbawFpnkkmJS6R4JRsVXFUaoitSU,628
 utilities/altair.py,sha256=HeZBVUocjkrTNwwKrClppsIqgNFF-ykv05HfZSoHYno,9104
 utilities/asyncio.py,sha256=mHnlSA4KPeDaBRts8Rn4sNA_4urodj7gQzs-_8Z-F7A,37587
@@ -12,7 +12,7 @@ utilities/contextvars.py,sha256=RsSGGrbQqqZ67rOydnM7WWIsM2lIE31UHJLejnHJPWY,505
 utilities/cryptography.py,sha256=_CiK_K6c_-uQuUhsUNjNjTL-nqxAh4_1zTfS11Xe120,972
 utilities/cvxpy.py,sha256=Rv1-fD-XYerosCavRF8Pohop2DBkU3AlFaGTfD8AEAA,13776
 utilities/dataclasses.py,sha256=iiC1wpGXWhaocIikzwBt8bbLWyImoUlOlcDZJGejaIg,33011
-utilities/datetime.py,sha256=uPQdUgJJ9KuF-pogjYRbI9lOK-i5UBzPHexWe4pOVEo,38713
+utilities/datetime.py,sha256=bt9tgxHfjSbl0g5H7W2YSwNm-1HsbKjX5AsYcyEO1mU,30361
 utilities/enum.py,sha256=HoRwVCWzsnH0vpO9ZEcAAIZLMv0Sn2vJxxA4sYMQgDs,5793
 utilities/errors.py,sha256=nC7ZYtxxDBMfrTHtT_MByBfup_wfGQFRo3eDt-0ZPe8,1045
 utilities/eventkit.py,sha256=6M5Xu1SzN-juk9PqBHwy5dS-ta7T0qA6SMpDsakOJ0E,13039
@@ -28,7 +28,7 @@ utilities/hypothesis.py,sha256=fcklSUIagoDZOTn8ITbkIU7BOZMV4g1Owj0khiz9yBY,43401
 utilities/importlib.py,sha256=mV1xT_O_zt_GnZZ36tl3xOmMaN_3jErDWY54fX39F6Y,429
 utilities/inflect.py,sha256=DbqB5Q9FbRGJ1NbvEiZBirRMxCxgrz91zy5jCO9ZIs0,347
 utilities/ipython.py,sha256=V2oMYHvEKvlNBzxDXdLvKi48oUq2SclRg5xasjaXStw,763
-utilities/iterables.py,sha256=mDqw2_0MUVp-P8FklgcaVTi2TXduH0MxbhTDzzhSBho,44915
+utilities/iterables.py,sha256=cuebB4ivKlZuKm8S3PQIfjavn9h-5mBGmvYq4FpSxFg,43812
 utilities/jupyter.py,sha256=ft5JA7fBxXKzP-L9W8f2-wbF0QeYc_2uLQNFDVk4Z-M,2917
 utilities/libcst.py,sha256=Jto5ppzRzsxn4AD32IS8n0lbgLYXwsVJB6EY8giNZyY,4974
 utilities/lightweight_charts.py,sha256=JrkrAZMo6JID2Eoc9QCc05Y_pK4l2zsApIhmii1z2Ig,2764
@@ -39,11 +39,11 @@ utilities/memory_profiler.py,sha256=tf2C51P2lCujPGvRt2Rfc7VEw5LDXmVPCG3z_AvBmbU,
 utilities/modules.py,sha256=iuvLluJya-hvl1Q25-Jk3dLgx2Es3ck4SjJiEkAlVTs,3195
 utilities/more_itertools.py,sha256=tBbjjKx8_Uv_TCjxhPwrGfAx_jRHtvLIZqXVWAsjzqA,8842
 utilities/numpy.py,sha256=Xn23sA2ZbVNqwUYEgNJD3XBYH6IbCri_WkHSNhg3NkY,26122
-utilities/operator.py,sha256=0M2yZJ0PODH47ogFEnkGMBe_cfxwZR02T_92LZVZvHo,3715
+utilities/operator.py,sha256=DuiWdkmK0D-ddvFqOayDkazTQE1Ysvtl6-UiBN5gns8,3857
 utilities/optuna.py,sha256=loyJGWTzljgdJaoLhP09PT8Jz6o_pwBOwehY33lHkhw,1923
-utilities/orjson.py,sha256=lhBSO-QCm2g-uhUE0hKe-PVhAt1TKRRx0iZLSFPmew4,36970
+utilities/orjson.py,sha256=7CraMEtaJtKTDTTVS4fQU6PeuFcG0V8SGwD3sqZ8kSI,36475
 utilities/os.py,sha256=D_FyyT-6TtqiN9KSS7c9g1fnUtgxmyMtzAjmYLkk46A,3587
-utilities/parse.py,sha256=vsZ2jf_ceSI_Kta9titixufysJaVXh0Whjz1T4awJZw,18938
+utilities/parse.py,sha256=YE2VWYKDm9WYf5wcOWrOxVfM6UWvhkSxSkwdxRQNsA0,17633
 utilities/pathlib.py,sha256=PK41rf1c9Wqv7h8f5R7H3_Lhq_gQZTUJD5tu3gMHVaU,3247
 utilities/period.py,sha256=opqpBevBGSGXbA7NYfRJjtthi1JPxdMaZ7QV3xosnTc,4774
 utilities/pickle.py,sha256=MBT2xZCsv0pH868IXLGKnlcqNx2IRVKYNpRcqiQQqxw,653
@@ -87,11 +87,11 @@ utilities/tzlocal.py,sha256=xbBBzVIUKMk8AkhuIp1qxGRNBioIa5I09dpeoBnIOOU,662
 utilities/uuid.py,sha256=jJTFxz-CWgltqNuzmythB7iEQ-Q1mCwPevUfKthZT3c,611
 utilities/version.py,sha256=ufhJMmI6KPs1-3wBI71aj5wCukd3sP_m11usLe88DNA,5117
 utilities/warnings.py,sha256=un1LvHv70PU-LLv8RxPVmugTzDJkkGXRMZTE2-fTQHw,1771
-utilities/whenever.py,sha256=oO0sgIIv4tvhIYmlZ4RFFfY6P54CPeyJCY9A4XHuyqo,11916
+utilities/whenever.py,sha256=tUNfGB_72YSCxbDKiQ7ulWtISC3AgVBrW1s3XlFPkuw,6883
 utilities/whenever2.py,sha256=Jd_fEavXCWTdMj29L7j-HbeMvrl8e3Ah_nxcLEFAwOU,12026
 utilities/zipfile.py,sha256=24lQc9ATcJxHXBPc_tBDiJk48pWyRrlxO2fIsFxU0A8,699
 utilities/zoneinfo.py,sha256=gJPr9l7V8s3Y7TXpCGYEM1S81Rplb9e4MoV9Nvy2VU8,1852
-dycw_utilities-0.131.17.dist-info/METADATA,sha256=H8TXOjXCrBtmH2V30ZUSMr1mz56J-27FJYHgaoof7Oc,1585
-dycw_utilities-0.131.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.131.17.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.131.17.dist-info/RECORD,,
+dycw_utilities-0.131.18.dist-info/METADATA,sha256=nfjJB5vwmQGGegP4Ma-fxV0cKOE67JbPGxKLmZ0Rd78,1585
+dycw_utilities-0.131.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.131.18.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.131.18.dist-info/RECORD,,

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.131.17"
+__version__ = "0.131.18"

utilities/datetime.py

@@ -11,7 +11,6 @@ from typing import (
     Literal,
     Self,
     SupportsFloat,
-    TypeGuard,
     assert_never,
     overload,
     override,
@@ -23,7 +22,7 @@ from utilities.platform import SYSTEM
 from utilities.sentinel import Sentinel, sentinel
 from utilities.types import MaybeCallablePyDate, MaybeCallablePyDateTime, MaybeStr
 from utilities.typing import is_instance_gen
-from utilities.zoneinfo import UTC, ensure_time_zone, get_time_zone_name
+from utilities.zoneinfo import UTC, ensure_time_zone
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -114,50 +113,6 @@ class AddWeekdaysError(Exception): ...
 ##
 
 
-def are_equal_date_durations(x: Duration, y: Duration, /) -> bool:
-    """Check if x == y for durations."""
-    x_timedelta = date_duration_to_timedelta(x)
-    y_timedelta = date_duration_to_timedelta(y)
-    return x_timedelta == y_timedelta
-
-
-##
-
-
-def are_equal_dates_or_datetimes(
-    x: DateOrDateTime, y: DateOrDateTime, /, *, strict: bool = False
-) -> bool:
-    """Check if x == y for dates/datetimes."""
-    if is_instance_gen(x, dt.date) and is_instance_gen(y, dt.date):
-        return x == y
-    if is_instance_gen(x, dt.datetime) and is_instance_gen(y, dt.datetime):
-        return are_equal_datetimes(x, y, strict=strict)
-    raise AreEqualDatesOrDateTimesError(x=x, y=y)
-
-
-@dataclass(kw_only=True, slots=True)
-class AreEqualDatesOrDateTimesError(Exception):
-    x: DateOrDateTime
-    y: DateOrDateTime
-
-    @override
-    def __str__(self) -> str:
-        return f"Cannot compare date and datetime ({self.x}, {self.y})"
-
-
-##
-
-
-def are_equal_datetime_durations(x: Duration, y: Duration, /) -> bool:
-    """Check if x == y for durations."""
-    x_timedelta = datetime_duration_to_timedelta(x)
-    y_timedelta = datetime_duration_to_timedelta(y)
-    return x_timedelta == y_timedelta
-
-
-##
-
-
 def are_equal_datetimes(
     x: dt.datetime, y: dt.datetime, /, *, strict: bool = False
 ) -> bool:
@@ -186,16 +141,6 @@ class AreEqualDateTimesError(Exception):
 ##
 
 
-def are_equal_months(x: DateOrMonth, y: DateOrMonth, /) -> bool:
-    """Check if x == y as months."""
-    x_month = Month.from_date(x) if isinstance(x, dt.date) else x
-    y_month = Month.from_date(y) if isinstance(y, dt.date) else y
-    return x_month == y_month
-
-
-##
-
-
 def check_date_not_datetime(date: dt.date, /) -> None:
     """Check if a date is not a datetime."""
     if not is_instance_gen(date, dt.date):
@@ -214,19 +159,6 @@ class CheckDateNotDateTimeError(Exception):
 ##
 
 
-def date_to_datetime(
-    date: dt.date, /, *, time: dt.time | None = None, time_zone: TimeZoneLike = UTC
-) -> dt.datetime:
-    """Expand a date into a datetime."""
-    check_date_not_datetime(date)
-    time_use = dt.time(0) if time is None else time
-    time_zone_use = ensure_time_zone(time_zone)
-    return dt.datetime.combine(date, time_use, tzinfo=time_zone_use)
-
-
-##
-
-
 def date_to_month(date: dt.date, /) -> Month:
     """Collapse a date into a month."""
     check_date_not_datetime(date)
@@ -337,32 +269,6 @@ def datetime_duration_to_microseconds(duration: Duration, /) -> int:
     )
 
 
-@overload
-def datetime_duration_to_milliseconds(
-    duration: Duration, /, *, strict: Literal[True]
-) -> int: ...
-@overload
-def datetime_duration_to_milliseconds(
-    duration: Duration, /, *, strict: bool = False
-) -> float: ...
-def datetime_duration_to_milliseconds(
-    duration: Duration, /, *, strict: bool = False
-) -> int | float:
-    """Compute the number of milliseconds in a datetime duration."""
-    timedelta = datetime_duration_to_timedelta(duration)
-    microseconds = datetime_duration_to_microseconds(timedelta)
-    milliseconds, remainder = divmod(microseconds, _MICROSECONDS_PER_MILLISECOND)
-    match remainder, strict:
-        case 0, _:
-            return milliseconds
-        case _, True:
-            raise TimedeltaToMillisecondsError(duration=duration, remainder=remainder)
-        case _, False:
-            return milliseconds + remainder / _MICROSECONDS_PER_MILLISECOND
-        case _ as never:
-            assert_never(never)
-
-
 @dataclass(kw_only=True, slots=True)
 class TimedeltaToMillisecondsError(Exception):
     duration: Duration
@@ -370,7 +276,7 @@ class TimedeltaToMillisecondsError(Exception):
 
     @override
     def __str__(self) -> str:
-        return f"Unable to convert {self.duration} to milliseconds; got {self.remainder} microsecond(s)"
+        return f"Unable to convert {self.duration} to milliseconds; got {self.remainder} microsecond(s)"  # pragma: no cover
 
 
 def datetime_duration_to_timedelta(duration: Duration, /) -> dt.timedelta:
@@ -413,20 +319,6 @@ def datetime_utc(
 ##
 
 
-def days_since_epoch(date: dt.date, /) -> int:
-    """Compute the number of days since the epoch."""
-    check_date_not_datetime(date)
-    return timedelta_since_epoch(date).days
-
-
-def days_since_epoch_to_date(days: int, /) -> dt.date:
-    """Convert a number of days since the epoch to a date."""
-    return EPOCH_DATE + days * DAY
-
-
-##
-
-
 def ensure_month(month: MonthLike, /) -> Month:
     """Ensure the object is a month."""
     if isinstance(month, Month):
@@ -449,25 +341,6 @@ class EnsureMonthError(Exception):
 ##
 
 
-def format_datetime_local_and_utc(datetime: dt.datetime, /) -> str:
-    """Format a plain datetime locally & in UTC."""
-    time_zone = ensure_time_zone(datetime)
-    if time_zone is UTC:
-        return datetime.strftime("%Y-%m-%d %H:%M:%S (%a, UTC)")
-    as_utc = datetime.astimezone(UTC)
-    local = get_time_zone_name(time_zone)
-    if datetime.year != as_utc.year:
-        return f"{datetime:%Y-%m-%d %H:%M:%S (%a}, {local}, {as_utc:%Y-%m-%d %H:%M:%S} UTC)"
-    if (datetime.month != as_utc.month) or (datetime.day != as_utc.day):
-        return (
-            f"{datetime:%Y-%m-%d %H:%M:%S (%a}, {local}, {as_utc:%m-%d %H:%M:%S} UTC)"
-        )
-    return f"{datetime:%Y-%m-%d %H:%M:%S (%a}, {local}, {as_utc:%H:%M:%S} UTC)"
-
-
-##
-
-
 @overload
 def get_date(*, date: MaybeCallablePyDate) -> dt.date: ...
 @overload
@@ -691,14 +564,6 @@ def is_integral_timedelta(duration: Duration, /) -> bool:
 ##
 
 
-def is_plain_datetime(obj: Any, /) -> TypeGuard[dt.datetime]:
-    """Check if an object is a plain datetime."""
-    return isinstance(obj, dt.datetime) and (obj.tzinfo is None)
-
-
-##
-
-
 _FRIDAY = 5
 
 
@@ -719,14 +584,6 @@ def is_zero_time(duration: Duration, /) -> bool:
 ##
 
 
-def is_zoned_datetime(obj: Any, /) -> TypeGuard[dt.datetime]:
-    """Check if an object is a zoned datetime."""
-    return isinstance(obj, dt.datetime) and (obj.tzinfo is not None)
-
-
-##
-
-
 def maybe_sub_pct_y(text: str, /) -> str:
     """Substitute the `%Y' token with '%4Y' if necessary."""
     match SYSTEM:
@@ -839,54 +696,6 @@ def microseconds_since_epoch_to_datetime(
 ##
 
 
-@overload
-def milliseconds_since_epoch(
-    datetime: dt.datetime, /, *, strict: Literal[True]
-) -> int: ...
-@overload
-def milliseconds_since_epoch(
-    datetime: dt.datetime, /, *, strict: bool = False
-) -> float: ...
-def milliseconds_since_epoch(
-    datetime: dt.datetime, /, *, strict: bool = False
-) -> float:
-    """Compute the number of milliseconds since the epoch."""
-    microseconds = microseconds_since_epoch(datetime)
-    milliseconds, remainder = divmod(microseconds, _MICROSECONDS_PER_MILLISECOND)
-    if strict:
-        if remainder == 0:
-            return milliseconds
-        raise MillisecondsSinceEpochError(datetime=datetime, remainder=remainder)
-    return milliseconds + remainder / _MICROSECONDS_PER_MILLISECOND
-
-
-@dataclass(kw_only=True, slots=True)
-class MillisecondsSinceEpochError(Exception):
-    datetime: dt.datetime
-    remainder: int
-
-    @override
-    def __str__(self) -> str:
-        return f"Unable to convert {self.datetime} to milliseconds since epoch; got {self.remainder} microsecond(s)"
-
-
-def milliseconds_since_epoch_to_datetime(
-    milliseconds: int, /, *, time_zone: dt.tzinfo | None = None
-) -> dt.datetime:
-    """Convert a number of milliseconds since the epoch to a datetime."""
-    epoch = EPOCH_NAIVE if time_zone is None else EPOCH_UTC
-    timedelta = milliseconds_to_timedelta(milliseconds)
-    return epoch + timedelta
-
-
-def milliseconds_to_timedelta(milliseconds: int, /) -> dt.timedelta:
-    """Compute a timedelta given a number of milliseconds."""
-    return microseconds_to_timedelta(_MICROSECONDS_PER_MILLISECOND * milliseconds)
-
-
-##
-
-
 @dataclass(order=True, unsafe_hash=True, slots=True)
 class Month:
     """Represents a month in time."""
@@ -1070,70 +879,6 @@ def _round_to_weekday(
 ##
 
 
-def serialize_compact(date_or_datetime: DateOrDateTime, /) -> str:
-    """Serialize a date/datetime using a compact format."""
-    match date_or_datetime:
-        case dt.datetime() as datetime:
-            if datetime.tzinfo is None:
-                raise SerializeCompactError(datetime=datetime)
-            format_ = "%Y%m%dT%H%M%S"
-        case dt.date():
-            format_ = "%Y%m%d"
-        case _ as never:
-            assert_never(never)
-    return date_or_datetime.strftime(maybe_sub_pct_y(format_))
-
-
-@dataclass(kw_only=True, slots=True)
-class SerializeCompactError(Exception):
-    datetime: dt.datetime
-
-    @override
-    def __str__(self) -> str:
-        return f"Unable to serialize plain datetime {self.datetime}"
-
-
-def parse_date_compact(text: str, /) -> dt.date:
-    """Parse a compact string into a date."""
-    try:
-        datetime = dt.datetime.strptime(text, "%Y%m%d").replace(tzinfo=UTC)
-    except ValueError:
-        raise ParseDateCompactError(text=text) from None
-    return datetime.date()
-
-
-@dataclass(kw_only=True, slots=True)
-class ParseDateCompactError(Exception):
-    text: str
-
-    @override
-    def __str__(self) -> str:
-        return f"Unable to parse {self.text!r} into a date"
-
-
-def parse_datetime_compact(
-    text: str, /, *, time_zone: TimeZoneLike = UTC
-) -> dt.datetime:
-    """Parse a compact string into a datetime."""
-    time_zone = ensure_time_zone(time_zone)
-    try:
-        return dt.datetime.strptime(text, "%Y%m%dT%H%M%S").replace(tzinfo=time_zone)
-    except ValueError:
-        raise ParseDateTimeCompactError(text=text) from None
-
-
-@dataclass(kw_only=True, slots=True)
-class ParseDateTimeCompactError(Exception):
-    text: str
-
-    @override
-    def __str__(self) -> str:
-        return f"Unable to parse {self.text!r} into a datetime"
-
-
-##
-
-
 def serialize_month(month: Month, /) -> str:
     """Serialize a month."""
     return f"{month.year:04}-{month.month:02}"
@@ -1323,46 +1068,32 @@ __all__ = [
     "AddDurationError",
     "AddWeekdaysError",
     "AreEqualDateTimesError",
-    "AreEqualDatesOrDateTimesError",
     "CheckDateNotDateTimeError",
     "DateOrMonth",
     "EnsureMonthError",
     "GetMinMaxDateError",
     "MeanDateTimeError",
     "MeanTimeDeltaError",
-    "MillisecondsSinceEpochError",
     "Month",
     "MonthError",
     "MonthLike",
-    "ParseDateCompactError",
-    "ParseDateTimeCompactError",
     "ParseMonthError",
-    "SerializeCompactError",
     "SubDurationError",
     "TimedeltaToMillisecondsError",
     "YieldDaysError",
     "YieldWeekdaysError",
     "add_duration",
     "add_weekdays",
-    "are_equal_date_durations",
-    "are_equal_dates_or_datetimes",
-    "are_equal_datetime_durations",
     "are_equal_datetimes",
-    "are_equal_months",
     "check_date_not_datetime",
     "date_duration_to_int",
     "date_duration_to_timedelta",
-    "date_to_datetime",
     "date_to_month",
     "datetime_duration_to_float",
     "datetime_duration_to_microseconds",
-    "datetime_duration_to_milliseconds",
     "datetime_duration_to_timedelta",
     "datetime_utc",
-    "days_since_epoch",
-    "days_since_epoch_to_date",
     "ensure_month",
-    "format_datetime_local_and_utc",
     "get_date",
     "get_datetime",
     "get_half_years",
@@ -1373,27 +1104,19 @@ __all__ = [
     "get_today",
     "get_years",
     "is_integral_timedelta",
-    "is_plain_datetime",
     "is_weekday",
     "is_zero_time",
-    "is_zoned_datetime",
     "maybe_sub_pct_y",
     "mean_datetime",
     "mean_timedelta",
     "microseconds_since_epoch",
     "microseconds_since_epoch_to_datetime",
     "microseconds_to_timedelta",
-    "milliseconds_since_epoch",
-    "milliseconds_since_epoch_to_datetime",
-    "milliseconds_to_timedelta",
-    "parse_date_compact",
-    "parse_datetime_compact",
     "parse_month",
     "parse_two_digit_year",
     "round_datetime",
     "round_to_next_weekday",
     "round_to_prev_weekday",
-    "serialize_compact",
     "serialize_month",
     "sub_duration",
     "timedelta_since_epoch",

utilities/iterables.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import builtins
-import datetime as dt
 from collections import Counter
 from collections.abc import (
     Callable,
@@ -34,7 +33,7 @@ from typing import (
 )
 
 from utilities.errors import ImpossibleCaseError
-from utilities.functions import ensure_hashable, ensure_not_none, ensure_str
+from utilities.functions import ensure_hashable, ensure_str
 from utilities.math import (
     _CheckIntegerEqualError,
     _CheckIntegerEqualOrApproxError,
@@ -45,7 +44,6 @@ from utilities.math import (
 from utilities.reprlib import get_repr
 from utilities.sentinel import Sentinel, sentinel
 from utilities.types import Sign, THashable, TSupportsAdd, TSupportsLT
-from utilities.zoneinfo import UTC
 
 if TYPE_CHECKING:
     from types import NoneType
@@ -1326,9 +1324,6 @@ def _sort_iterable_cmp(x: Any, y: Any, /) -> Sign:
     if x is None:
         y = cast("NoneType", y)
         return 0
-    if isinstance(x, dt.datetime):
-        y = cast("dt.datetime", y)
-        return _sort_iterable_cmp_datetimes(x, y)
     if isinstance(x, float):
         y = cast("float", y)
         return _sort_iterable_cmp_floats(x, y)
@@ -1371,30 +1366,6 @@ class SortIterableError(Exception):
         return f"Unable to sort {get_repr(self.x)} and {get_repr(self.y)}"
 
 
-def _sort_iterable_cmp_datetimes(x: dt.datetime, y: dt.datetime, /) -> Sign:
-    """Compare two datetimes."""
-    match x.tzinfo, y.tzinfo:
-        case None, None:
-            return cast("Sign", (x > y) - (x < y))
-        case dt.tzinfo(), None:
-            return 1
-        case None, dt.tzinfo():
-            return -1
-        case dt.tzinfo(), dt.tzinfo():
-            x_utc = x.astimezone(tz=UTC)
-            y_utc = y.astimezone(tz=UTC)
-            result = cast("Sign", (x_utc > y_utc) - (x_utc < y_utc))
-            if result != 0:
-                return result
-            x_time_zone = ensure_not_none(ensure_not_none(x.tzinfo).tzname(x))
-            y_time_zone = ensure_not_none(ensure_not_none(y.tzinfo).tzname(y))
-            return cast(
-                "Sign", (x_time_zone > y_time_zone) - (x_time_zone < y_time_zone)
-            )
-        case _ as never:
-            assert_never(never)
-
-
 def _sort_iterable_cmp_floats(x: float, y: float, /) -> Sign:
     """Compare two floats."""
     x_nan, y_nan = map(isnan, [x, y])

utilities/operator.py

@@ -1,23 +1,17 @@
 from __future__ import annotations
 
-import datetime as dt
 from collections.abc import Callable, Mapping, Sequence
 from collections.abc import Set as AbstractSet
 from dataclasses import asdict, dataclass
 from typing import TYPE_CHECKING, Any, TypeVar, cast, override
 
 import utilities.math
-from utilities.datetime import (
-    AreEqualDatesOrDateTimesError,
-    AreEqualDateTimesError,
-    are_equal_dates_or_datetimes,
-)
 from utilities.functions import is_dataclass_instance
 from utilities.iterables import SortIterableError, sort_iterable
 from utilities.reprlib import get_repr
 
 if TYPE_CHECKING:
-    from utilities.types import Dataclass, DateOrDateTime, Number
+    from utilities.types import Dataclass, Number
 
 _T = TypeVar("_T")
 
@@ -51,12 +45,6 @@ def is_equal(
         if isinstance(x, str):  # else Sequence
             y = cast("str", y)
             return x == y
-        if isinstance(x, dt.date | dt.datetime):
-            y = cast("DateOrDateTime", y)
-            try:
-                return are_equal_dates_or_datetimes(x, y)
-            except (AreEqualDateTimesError, AreEqualDatesOrDateTimesError):
-                return False
         if is_dataclass_instance(x):
             y = cast("Dataclass", y)
             x_values = asdict(x)
@@ -80,8 +68,26 @@ def is_equal(
             try:
                 x_sorted = sort_iterable(x)
                 y_sorted = sort_iterable(y)
-            except SortIterableError as error:
-                raise IsEqualError(x=error.x, y=error.y) from None
+            except SortIterableError:
+                x_in_y = all(
+                    any(
+                        is_equal(
+                            x_i, y_i, rel_tol=rel_tol, abs_tol=abs_tol, extra=extra
+                        )
+                        for y_i in y
+                    )
+                    for x_i in x
+                )
+                y_in_x = all(
+                    any(
+                        is_equal(
+                            x_i, y_i, rel_tol=rel_tol, abs_tol=abs_tol, extra=extra
+                        )
+                        for x_i in x
+                    )
+                    for y_i in y
+                )
+                return x_in_y and y_in_x
             return is_equal(x_sorted, y_sorted, rel_tol=rel_tol, abs_tol=abs_tol)
         if isinstance(x, Sequence):
             y = cast("Sequence[Any]", y)

utilities/orjson.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import datetime as dt
 import re
 from collections.abc import Callable, Iterable, Mapping, Sequence
 from contextlib import suppress
@@ -23,7 +22,15 @@ from orjson import (
     dumps,
     loads,
 )
-from whenever import ZonedDateTime
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    PlainDateTime,
+    Time,
+    TimeDelta,
+    ZonedDateTime,
+)
 
 from utilities.concurrent import concurrent_map
 from utilities.dataclasses import dataclass_to_dict
@@ -39,27 +46,13 @@ from utilities.logging import get_logging_level_number
 from utilities.math import MAX_INT64, MIN_INT64
 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 (
-    parse_date,
-    parse_plain_datetime,
-    parse_time,
-    parse_timedelta,
-    parse_zoned_datetime,
-    serialize_date,
-    serialize_datetime,
-    serialize_time,
-    serialize_timedelta,
-)
 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
 
 
@@ -70,26 +63,25 @@ if TYPE_CHECKING:
 class _Prefixes(Enum):
     dataclass = "dc"
     date = "d"
-    datetime = "dt"
+    date_delta = "dd"
+    date_time_delta = "D"
     enum = "e"
-    exception_class = "exc"
-    exception_instance = "exi"
+    exception_class = "Ex"
+    exception_instance = "ex"
     float_ = "fl"
     frozenset_ = "fr"
     list_ = "l"
-    nan = "nan"
     none = "none"
     path = "p"
-    pos_inf = "pos_inf"
-    neg_inf = "neg_inf"
+    plain_date_time = "pd"
     set_ = "s"
-    timedelta = "td"
-    time = "tm"
+    time = "ti"
+    time_delta = "td"
     tuple_ = "tu"
     unserializable = "un"
     uuid = "uu"
     version = "v"
-    zoned_datetime = "zd"
+    zoned_date_time = "zd"
 
 
 type _DataclassHook = Callable[[type[Dataclass], StrMapping], StrMapping]
@@ -160,14 +152,12 @@ def _pre_process(
         # singletons
         case None:
             return f"[{_Prefixes.none.value}]"
-        case dt.datetime() as datetime:
-            return f"[{_Prefixes.datetime.value}]{serialize_datetime(datetime)}"
-        case dt.date() as date:  # after datetime
-            return f"[{_Prefixes.date.value}]{serialize_date(date)}"
-        case dt.time() as time:
-            return f"[{_Prefixes.time.value}]{serialize_time(time)}"
-        case dt.timedelta() as timedelta:
-            return f"[{_Prefixes.timedelta.value}]{serialize_timedelta(timedelta)}"
+        case Date() as date:
+            return f"[{_Prefixes.date.value}]{date}"
+        case DateDelta() as date:
+            return f"[{_Prefixes.date_delta.value}]{date}"
+        case DateTimeDelta() as date:
+            return f"[{_Prefixes.date_time_delta.value}]{date}"
         case Exception() as error_:
             return {
                 f"[{_Prefixes.exception_instance.value}|{type(error_).__qualname__}]": pre(
@@ -182,18 +172,24 @@ def _pre_process(
             if MIN_INT64 <= int_ <= MAX_INT64:
                 return int_
             raise _SerializeIntegerError(obj=int_)
-        case UUID() as uuid:
-            return f"[{_Prefixes.uuid.value}]{uuid}"
         case Path() as path:
             return f"[{_Prefixes.path.value}]{path!s}"
+        case PlainDateTime() as datetime:
+            return f"[{_Prefixes.plain_date_time.value}]{datetime}"
         case str() as str_:
             return str_
+        case Time() as time:
+            return f"[{_Prefixes.time.value}]{time}"
+        case TimeDelta() as time_delta:
+            return f"[{_Prefixes.time_delta.value}]{time_delta}"
         case type() as error_cls if issubclass(error_cls, Exception):
             return f"[{_Prefixes.exception_class.value}|{error_cls.__qualname__}]"
+        case UUID() as uuid:
+            return f"[{_Prefixes.uuid.value}]{uuid}"
         case Version() as version:
             return f"[{_Prefixes.version.value}]{version!s}"
         case ZonedDateTime() as datetime:
-            return f"[{_Prefixes.zoned_datetime.value}]{datetime}"
+            return f"[{_Prefixes.zoned_date_time.value}]{datetime}"
         # contains
         case Dataclass() as dataclass:
             asdict = dataclass_to_dict(
@@ -338,51 +334,36 @@ def deserialize(
     )
 
 
-_NONE_PATTERN = re.compile(r"^\[" + _Prefixes.none.value + r"\]$")
-_LOCAL_DATETIME_PATTERN = re.compile(
-    r"^\["
-    + _Prefixes.datetime.value
-    + r"\](\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?)$"
-)
-_UUID_PATTERN = re.compile(r"^\[" + _Prefixes.uuid.value + r"\](" + UUID_PATTERN + ")$")
-_ZONED_DATETIME_PATTERN = re.compile(
-    r"^\["
-    + _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]:
-    return re.compile(r"^\[" + prefix.value + r"\](.+)$")
-
-
 (
     _DATE_PATTERN,
+    _DATE_DELTA_PATTERN,
+    _DATE_TIME_DELTA_PATTERN,
     _FLOAT_PATTERN,
+    _NONE_PATTERN,
     _PATH_PATTERN,
+    _PLAIN_DATE_TIME_PATTERN,
     _TIME_PATTERN,
-    _TIMEDELTA_PATTERN,
+    _TIME_DELTA_PATTERN,
+    _UUID_PATTERN,
     _VERSION_PATTERN,
-) = map(
-    _make_unit_pattern,
-    [
+    _ZONED_DATE_TIME_PATTERN,
+) = [
+    re.compile(r"^\[" + p.value + r"\](" + ".*" + ")$")
+    for p in [
         _Prefixes.date,
+        _Prefixes.date_delta,
+        _Prefixes.date_time_delta,
         _Prefixes.float_,
+        _Prefixes.none,
         _Prefixes.path,
+        _Prefixes.plain_date_time,
         _Prefixes.time,
-        _Prefixes.timedelta,
+        _Prefixes.time_delta,
+        _Prefixes.uuid,
         _Prefixes.version,
-    ],
-)
-
-
-def _make_container_pattern(prefix: _Prefixes, /) -> Pattern[str]:
-    return re.compile(r"^\[" + prefix.value + r"(?:\|(.+))?\]$")
+        _Prefixes.zoned_date_time,
+    ]
+]
 
 
 (
@@ -394,9 +375,9 @@ def _make_container_pattern(prefix: _Prefixes, /) -> Pattern[str]:
     _LIST_PATTERN,
     _SET_PATTERN,
     _TUPLE_PATTERN,
-) = map(
-    _make_container_pattern,
-    [
+) = [
+    re.compile(r"^\[" + p.value + r"(?:\|(.+))?\]$")
+    for p in [
         _Prefixes.dataclass,
         _Prefixes.enum,
         _Prefixes.exception_class,
@@ -405,8 +386,8 @@ def _make_container_pattern(prefix: _Prefixes, /) -> Pattern[str]:
         _Prefixes.list_,
         _Prefixes.set_,
         _Prefixes.tuple_,
-    ],
-)
+    ]
+]
 
 
 def _object_hook(
@@ -425,24 +406,26 @@ def _object_hook(
             if match := _NONE_PATTERN.search(text):
                 return None
             if match := _DATE_PATTERN.search(text):
-                return parse_date(match.group(1))
+                return Date.parse_common_iso(match.group(1))
+            if match := _DATE_DELTA_PATTERN.search(text):
+                return DateDelta.parse_common_iso(match.group(1))
+            if match := _DATE_TIME_DELTA_PATTERN.search(text):
+                return DateTimeDelta.parse_common_iso(match.group(1))
             if match := _FLOAT_PATTERN.search(text):
                 return float(match.group(1))
-            if match := _LOCAL_DATETIME_PATTERN.search(text):
-                return parse_plain_datetime(match.group(1))
             if match := _PATH_PATTERN.search(text):
                 return Path(match.group(1))
+            if match := _PLAIN_DATE_TIME_PATTERN.search(text):
+                return PlainDateTime.parse_common_iso(match.group(1))
             if match := _TIME_PATTERN.search(text):
-                return parse_time(match.group(1))
-            if match := _TIMEDELTA_PATTERN.search(text):
-                return parse_timedelta(match.group(1))
+                return Time.parse_common_iso(match.group(1))
+            if match := _TIME_DELTA_PATTERN.search(text):
+                return TimeDelta.parse_common_iso(match.group(1))
             if match := _UUID_PATTERN.search(text):
                 return UUID(match.group(1))
             if match := _VERSION_PATTERN.search(text):
                 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):
+            if match := _ZONED_DATE_TIME_PATTERN.search(text):
                 return ZonedDateTime.parse_common_iso(match.group(1))
             if (
                 exc_class := _object_hook_exception_class(

utilities/parse.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import datetime as dt
 from contextlib import suppress
 from dataclasses import dataclass
 from enum import Enum
@@ -9,6 +8,16 @@ from re import DOTALL
 from types import NoneType
 from typing import TYPE_CHECKING, Any, override
 
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    PlainDateTime,
+    Time,
+    TimeDelta,
+    ZonedDateTime,
+)
+
 from utilities.enum import ParseEnumError, parse_enum
 from utilities.iterables import OneEmptyError, OneNonUniqueError, one, one_str
 from utilities.math import ParseNumberError, parse_number
@@ -26,7 +35,7 @@ from utilities.text import (
     split_key_value_pairs,
     split_str,
 )
-from utilities.types import Duration, Number, ParseObjectExtra, SerializeObjectExtra
+from utilities.types import Number, ParseObjectExtra, SerializeObjectExtra
 from utilities.typing import (
     get_args,
     is_dict_type,
@@ -182,6 +191,14 @@ def _parse_object_type(
             return parse_enum(text, cls, case_sensitive=case_sensitive)
         except ParseEnumError:
             raise _ParseObjectParseError(type_=cls, text=text) from None
+    if issubclass(
+        cls,
+        (Date, DateDelta, DateTimeDelta, PlainDateTime, Time, TimeDelta, ZonedDateTime),
+    ):
+        try:
+            return cls.parse_common_iso(text)
+        except ValueError:
+            raise _ParseObjectParseError(type_=cls, text=text) from None
     if issubclass(cls, Path):
         return Path(text).expanduser()
     if issubclass(cls, Sentinel):
@@ -194,34 +211,6 @@ def _parse_object_type(
             return parse_version(text)
         except ParseVersionError:
             raise _ParseObjectParseError(type_=cls, text=text) from None
-    if is_subclass_gen(cls, dt.date):
-        from utilities.whenever import ParseDateError, parse_date
-
-        try:
-            return parse_date(text)
-        except ParseDateError:
-            raise _ParseObjectParseError(type_=cls, text=text) from None
-    if is_subclass_gen(cls, dt.datetime):
-        from utilities.whenever import ParseDateTimeError, parse_datetime
-
-        try:
-            return parse_datetime(text)
-        except ParseDateTimeError:
-            raise _ParseObjectParseError(type_=cls, text=text) from None
-    if issubclass(cls, dt.time):
-        from utilities.whenever import ParseTimeError, parse_time
-
-        try:
-            return parse_time(text)
-        except ParseTimeError:
-            raise _ParseObjectParseError(type_=cls, text=text) from None
-    if issubclass(cls, dt.timedelta):
-        from utilities.whenever import ParseTimedeltaError, parse_timedelta
-
-        try:
-            return parse_timedelta(text)
-        except ParseTimedeltaError:
-            raise _ParseObjectParseError(type_=cls, text=text) from None
     raise _ParseObjectParseError(type_=cls, text=text)
 
 
@@ -374,13 +363,6 @@ def _parse_object_union_type(type_: Any, text: str, /) -> Any:
             return parse_number(text)
         except ParseNumberError:
             raise _ParseObjectParseError(type_=type_, text=text) from None
-    if type_ is Duration:
-        from utilities.whenever import ParseDurationError, parse_duration
-
-        try:
-            return parse_duration(text)
-        except ParseDurationError:
-            raise _ParseObjectParseError(type_=type_, text=text) from None
     raise _ParseObjectParseError(type_=type_, text=text) from None
 
 
@@ -464,22 +446,11 @@ def serialize_object(
         obj, bool | int | float | str | Path | Sentinel | Version
     ):
         return str(obj)
-    if is_instance_gen(obj, dt.date):
-        from utilities.whenever import serialize_date
-
-        return serialize_date(obj)
-    if is_instance_gen(obj, dt.datetime):
-        from utilities.whenever import serialize_datetime
-
-        return serialize_datetime(obj)
-    if isinstance(obj, dt.time):
-        from utilities.whenever import serialize_time
-
-        return serialize_time(obj)
-    if isinstance(obj, dt.timedelta):
-        from utilities.whenever import serialize_timedelta
-
-        return serialize_timedelta(obj)
+    if isinstance(
+        obj,
+        (Date, DateDelta, DateTimeDelta, PlainDateTime, Time, TimeDelta, ZonedDateTime),
+    ):
+        return obj.format_common_iso()
     if isinstance(obj, Enum):
         return obj.name
     if isinstance(obj, dict):

utilities/whenever.py

@@ -1,27 +1,17 @@
 from __future__ import annotations
 
 import datetime as dt
-import re
 from contextlib import suppress
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, override
 
-from whenever import (
-    Date,
-    DateTimeDelta,
-    PlainDateTime,
-    Time,
-    TimeZoneNotFoundError,
-    ZonedDateTime,
-)
+from whenever import DateTimeDelta, TimeZoneNotFoundError, ZonedDateTime
 
 from utilities.datetime import (
     _MICROSECONDS_PER_DAY,
     _MICROSECONDS_PER_SECOND,
     ZERO_TIME,
-    check_date_not_datetime,
     datetime_duration_to_microseconds,
-    parse_two_digit_year,
 )
 from utilities.math import ParseNumberError, parse_number
 from utilities.re import (
@@ -35,7 +25,6 @@ from utilities.zoneinfo import UTC, ensure_time_zone, get_time_zone_name
 if TYPE_CHECKING:
     from utilities.types import Duration
 
-
 MAX_SERIALIZABLE_TIMEDELTA = dt.timedelta(days=3652060, microseconds=-1)
 MIN_SERIALIZABLE_TIMEDELTA = -MAX_SERIALIZABLE_TIMEDELTA
 
@@ -84,56 +73,6 @@ class _CheckValidZonedDateTimeUnequalError(CheckValidZonedDateTimeError):
 ##
 
 
-_PARSE_DATE_YYMMDD_REGEX = re.compile(r"^(\d{2})(\d{2})(\d{2})$")
-
-
-def parse_date(date: str, /) -> dt.date:
-    """Parse a string into a date."""
-    try:
-        w_date = Date.parse_common_iso(date)
-    except ValueError:
-        try:
-            ((year2, month, day),) = _PARSE_DATE_YYMMDD_REGEX.findall(date)
-        except ValueError:
-            raise ParseDateError(date=date) from None
-        year = parse_two_digit_year(year2)
-        return dt.date(year=int(year), month=int(month), day=int(day))
-    return w_date.py_date()
-
-
-@dataclass(kw_only=True, slots=True)
-class ParseDateError(Exception):
-    date: str
-
-    @override
-    def __str__(self) -> str:
-        return f"Unable to parse date; got {self.date!r}"
-
-
-##
-
-
-def parse_datetime(datetime: str, /) -> dt.datetime:
-    """Parse a string into a datetime."""
-    with suppress(ParsePlainDateTimeError):
-        return parse_plain_datetime(datetime)
-    with suppress(ParseZonedDateTimeError):
-        return parse_zoned_datetime(datetime)
-    raise ParseDateTimeError(datetime=datetime) from None
-
-
-@dataclass(kw_only=True, slots=True)
-class ParseDateTimeError(Exception):
-    datetime: str
-
-    @override
-    def __str__(self) -> str:
-        return f"Unable to parse datetime; got {self.datetime!r}"
-
-
-##
-
-
 def parse_duration(duration: str, /) -> Duration:
     """Parse a string into a Duration."""
     with suppress(ParseNumberError):
@@ -156,48 +95,6 @@ class ParseDurationError(Exception):
 ##
 
 
-def parse_plain_datetime(datetime: str, /) -> dt.datetime:
-    """Parse a string into a plain datetime."""
-    try:
-        ldt = PlainDateTime.parse_common_iso(datetime)
-    except ValueError:
-        raise ParsePlainDateTimeError(datetime=datetime) from None
-    return ldt.py_datetime()
-
-
-@dataclass(kw_only=True, slots=True)
-class ParsePlainDateTimeError(Exception):
-    datetime: str
-
-    @override
-    def __str__(self) -> str:
-        return f"Unable to parse plain datetime; got {self.datetime!r}"
-
-
-##
-
-
-def parse_time(time: str, /) -> dt.time:
-    """Parse a string into a time."""
-    try:
-        w_time = Time.parse_common_iso(time)
-    except ValueError:
-        raise ParseTimeError(time=time) from None
-    return w_time.py_time()
-
-
-@dataclass(kw_only=True, slots=True)
-class ParseTimeError(Exception):
-    time: str
-
-    @override
-    def __str__(self) -> str:
-        return f"Unable to parse time; got {self.time!r}"
-
-
-##
-
-
 def parse_timedelta(timedelta: str, /) -> dt.timedelta:
     """Parse a string into a timedelta."""
     with suppress(ExtractGroupError):
@@ -245,47 +142,6 @@ class _ParseTimedeltaNanosecondError(ParseTimedeltaError):
 ##
 
 
-def parse_zoned_datetime(datetime: str, /) -> dt.datetime:
-    """Parse a string into a zoned datetime."""
-    try:
-        zdt = ZonedDateTime.parse_common_iso(datetime)
-    except ValueError:
-        raise ParseZonedDateTimeError(datetime=datetime) from None
-    return zdt.py_datetime()
-
-
-@dataclass(kw_only=True, slots=True)
-class ParseZonedDateTimeError(Exception):
-    datetime: str
-
-    @override
-    def __str__(self) -> str:
-        return f"Unable to parse zoned datetime; got {self.datetime!r}"
-
-
-##
-
-
-def serialize_date(date: dt.date, /) -> str:
-    """Serialize a date."""
-    check_date_not_datetime(date)
-    return Date.from_py_date(date).format_common_iso()
-
-
-##
-
-
-def serialize_datetime(datetime: dt.datetime, /) -> str:
-    """Serialize a datetime."""
-    try:
-        return serialize_plain_datetime(datetime)
-    except SerializePlainDateTimeError:
-        return serialize_zoned_datetime(datetime)
-
-
-##
-
-
 def serialize_duration(duration: Duration, /) -> str:
     """Serialize a duration."""
     if isinstance(duration, int | float):
@@ -308,35 +164,6 @@ class SerializeDurationError(Exception):
 ##
 
 
-def serialize_plain_datetime(datetime: dt.datetime, /) -> str:
-    """Serialize a plain datetime."""
-    try:
-        pdt = PlainDateTime.from_py_datetime(datetime)
-    except ValueError:
-        raise SerializePlainDateTimeError(datetime=datetime) from None
-    return pdt.format_common_iso()
-
-
-@dataclass(kw_only=True, slots=True)
-class SerializePlainDateTimeError(Exception):
-    datetime: dt.datetime
-
-    @override
-    def __str__(self) -> str:
-        return f"Unable to serialize plain datetime; got {self.datetime}"
-
-
-##
-
-
-def serialize_time(time: dt.time, /) -> str:
-    """Serialize a time."""
-    return Time.from_py_time(time).format_common_iso()
-
-
-##
-
-
 def serialize_timedelta(timedelta: dt.timedelta, /) -> str:
     """Serialize a timedelta."""
     try:
@@ -358,31 +185,6 @@ class SerializeTimeDeltaError(Exception):
 ##
 
 
-def serialize_zoned_datetime(datetime: dt.datetime, /) -> str:
-    """Serialize a zoned datetime."""
-    if datetime.tzinfo is dt.UTC:
-        return serialize_zoned_datetime(  # skipif-ci-and-windows
-            datetime.replace(tzinfo=UTC)
-        )
-    try:
-        zdt = ZonedDateTime.from_py_datetime(datetime)
-    except ValueError:
-        raise SerializeZonedDateTimeError(datetime=datetime) from None
-    return zdt.format_common_iso()
-
-
-@dataclass(kw_only=True, slots=True)
-class SerializeZonedDateTimeError(Exception):
-    datetime: dt.datetime
-
-    @override
-    def __str__(self) -> str:
-        return f"Unable to serialize zoned datetime; got {self.datetime}"
-
-
-##
-
-
 def _to_datetime_delta(timedelta: dt.timedelta, /) -> DateTimeDelta:
     """Serialize a timedelta."""
     total_microseconds = datetime_duration_to_microseconds(timedelta)
@@ -415,30 +217,14 @@ __all__ = [
     "MAX_SERIALIZABLE_TIMEDELTA",
     "MIN_SERIALIZABLE_TIMEDELTA",
     "CheckValidZonedDateTimeError",
-    "ParseDateError",
-    "ParseDateTimeError",
     "ParseDurationError",
-    "ParsePlainDateTimeError",
-    "ParseTimeError",
     "ParseTimedeltaError",
-    "ParseZonedDateTimeError",
     "SerializeDurationError",
-    "SerializePlainDateTimeError",
     "SerializeTimeDeltaError",
-    "SerializeZonedDateTimeError",
     "check_valid_zoned_datetime",
-    "parse_date",
-    "parse_datetime",
+    "check_valid_zoned_datetime",
     "parse_duration",
-    "parse_plain_datetime",
-    "parse_time",
     "parse_timedelta",
-    "parse_zoned_datetime",
-    "serialize_date",
-    "serialize_datetime",
     "serialize_duration",
-    "serialize_plain_datetime",
-    "serialize_time",
     "serialize_timedelta",
-    "serialize_zoned_datetime",
 ]