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

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/polars.py

@@ -1005,6 +1005,7 @@ def dataclass_to_dataframe(
     *,
     globalns: StrMapping | None = None,
     localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
 ) -> DataFrame:
     """Convert a dataclass/es into a DataFrame."""
     objs = list(always_iterable(objs))
@@ -1018,12 +1019,14 @@ def dataclass_to_dataframe(
         ) from None
     data = list(map(asdict, objs))
     first, *_ = objs
-    schema = dataclass_to_schema(first, globalns=globalns, localns=localns)
+    schema = dataclass_to_schema(
+        first, globalns=globalns, localns=localns, warn_name_errors=warn_name_errors
+    )
     df = DataFrame(data, schema=schema, orient="row")
-    return map_over_columns(_dataclass_to_dataframe_uuid, df)
+    return map_over_columns(_dataclass_to_dataframe_cast, df)
 
 
-def _dataclass_to_dataframe_uuid(series: Series, /) -> Series:
+def _dataclass_to_dataframe_cast(series: Series, /) -> Series:
     if series.dtype == Object:
         is_path = series.map_elements(make_isinstance(Path), return_dtype=Boolean).all()
         is_uuid = series.map_elements(make_isinstance(UUID), return_dtype=Boolean).all()