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

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)