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

utilities/fastapi.py

@@ -8,17 +8,16 @@ from fastapi import FastAPI
 from uvicorn import Config, Server
 
 from utilities.asyncio import Looper
-from utilities.datetime import SECOND, datetime_duration_to_float
-from utilities.whenever2 import get_now_local
+from utilities.whenever2 import SECOND, get_now_local
 
 if TYPE_CHECKING:
     from types import TracebackType
 
-    from utilities.types import Duration
+    from whenever import TimeDelta
 
 
 _LOCALHOST: str = "localhost"
-_TIMEOUT: Duration = SECOND
+_TIMEOUT: TimeDelta = SECOND
 
 
 class _PingerReceiverApp(FastAPI):
@@ -71,16 +70,15 @@ class PingReceiver(Looper[None]):
 
     @classmethod
     async def ping(
-        cls, port: int, /, *, host: str = _LOCALHOST, timeout: Duration = _TIMEOUT
+        cls, port: int, /, *, host: str = _LOCALHOST, timeout: TimeDelta = _TIMEOUT
     ) -> str | Literal[False]:
         """Ping the receiver."""
         from httpx import AsyncClient, ConnectError  # skipif-ci
 
         url = f"http://{host}:{port}/ping"  # skipif-ci
-        timeout_use = datetime_duration_to_float(timeout)  # skipif-ci
         try:  # skipif-ci
             async with AsyncClient() as client:
-                response = await client.get(url, timeout=timeout_use)
+                response = await client.get(url, timeout=timeout.in_seconds())
         except ConnectError:  # skipif-ci
             return False
         return response.text if response.status_code == 200 else False  # skipif-ci

utilities/functions.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import datetime as dt
 from collections.abc import Callable, Iterable, Iterator, Sequence
 from dataclasses import asdict, dataclass, is_dataclass
 from functools import _lru_cache_wrapper, cached_property, partial, reduce, wraps
@@ -28,6 +27,7 @@ from typing import (
 )
 
 from typing_extensions import ParamSpec
+from whenever import Date, PlainDateTime, Time, TimeDelta, ZonedDateTime
 
 from utilities.reprlib import get_repr, get_repr_and_class
 from utilities.sentinel import Sentinel, sentinel
@@ -210,13 +210,13 @@ class EnsureClassError(Exception):
 
 
 @overload
-def ensure_date(obj: Any, /, *, nullable: bool) -> dt.date | None: ...
+def ensure_date(obj: Any, /, *, nullable: bool) -> Date | None: ...
 @overload
-def ensure_date(obj: Any, /, *, nullable: Literal[False] = False) -> dt.date: ...
-def ensure_date(obj: Any, /, *, nullable: bool = False) -> dt.date | None:
+def ensure_date(obj: Any, /, *, nullable: Literal[False] = False) -> Date: ...
+def ensure_date(obj: Any, /, *, nullable: bool = False) -> Date | None:
     """Ensure an object is a date."""
     try:
-        return ensure_class(obj, dt.date, nullable=nullable)
+        return ensure_class(obj, Date, nullable=nullable)
     except EnsureClassError as error:
         raise EnsureDateError(obj=error.obj, nullable=nullable) from None
 
@@ -234,33 +234,6 @@ class EnsureDateError(Exception):
 ##
 
 
-@overload
-def ensure_datetime(obj: Any, /, *, nullable: bool) -> dt.datetime | None: ...
-@overload
-def ensure_datetime(
-    obj: Any, /, *, nullable: Literal[False] = False
-) -> dt.datetime: ...
-def ensure_datetime(obj: Any, /, *, nullable: bool = False) -> dt.datetime | None:
-    """Ensure an object is a datetime."""
-    try:
-        return ensure_class(obj, dt.datetime, nullable=nullable)
-    except EnsureClassError as error:
-        raise EnsureDateTimeError(obj=error.obj, nullable=nullable) from None
-
-
-@dataclass(kw_only=True, slots=True)
-class EnsureDateTimeError(Exception):
-    obj: Any
-    nullable: bool
-
-    @override
-    def __str__(self) -> str:
-        return _make_error_msg(self.obj, "a datetime", nullable=self.nullable)
-
-
-##
-
-
 @overload
 def ensure_float(obj: Any, /, *, nullable: bool) -> float | None: ...
 @overload
@@ -432,6 +405,35 @@ class EnsurePathError(Exception):
 ##
 
 
+@overload
+def ensure_plain_date_time(obj: Any, /, *, nullable: bool) -> PlainDateTime | None: ...
+@overload
+def ensure_plain_date_time(
+    obj: Any, /, *, nullable: Literal[False] = False
+) -> PlainDateTime: ...
+def ensure_plain_date_time(
+    obj: Any, /, *, nullable: bool = False
+) -> PlainDateTime | None:
+    """Ensure an object is a plain date-time."""
+    try:
+        return ensure_class(obj, PlainDateTime, nullable=nullable)
+    except EnsureClassError as error:
+        raise EnsurePlainDateTimeError(obj=error.obj, nullable=nullable) from None
+
+
+@dataclass(kw_only=True, slots=True)
+class EnsurePlainDateTimeError(Exception):
+    obj: Any
+    nullable: bool
+
+    @override
+    def __str__(self) -> str:
+        return _make_error_msg(self.obj, "a plain date-time", nullable=self.nullable)
+
+
+##
+
+
 def ensure_sized(obj: Any, /) -> Sized:
     """Ensure an object is sized."""
     if is_sized(obj):
@@ -496,13 +498,13 @@ class EnsureStrError(Exception):
 
 
 @overload
-def ensure_time(obj: Any, /, *, nullable: bool) -> dt.time | None: ...
+def ensure_time(obj: Any, /, *, nullable: bool) -> Time | None: ...
 @overload
-def ensure_time(obj: Any, /, *, nullable: Literal[False] = False) -> dt.time: ...
-def ensure_time(obj: Any, /, *, nullable: bool = False) -> dt.time | None:
+def ensure_time(obj: Any, /, *, nullable: Literal[False] = False) -> Time: ...
+def ensure_time(obj: Any, /, *, nullable: bool = False) -> Time | None:
     """Ensure an object is a time."""
     try:
-        return ensure_class(obj, dt.time, nullable=nullable)
+        return ensure_class(obj, Time, nullable=nullable)
     except EnsureClassError as error:
         raise EnsureTimeError(obj=error.obj, nullable=nullable) from None
 
@@ -521,15 +523,15 @@ class EnsureTimeError(Exception):
 
 
 @overload
-def ensure_timedelta(obj: Any, /, *, nullable: bool) -> dt.timedelta | None: ...
+def ensure_time_delta(obj: Any, /, *, nullable: bool) -> TimeDelta | None: ...
 @overload
-def ensure_timedelta(
+def ensure_time_delta(
     obj: Any, /, *, nullable: Literal[False] = False
-) -> dt.timedelta: ...
-def ensure_timedelta(obj: Any, /, *, nullable: bool = False) -> dt.timedelta | None:
+) -> TimeDelta: ...
+def ensure_time_delta(obj: Any, /, *, nullable: bool = False) -> TimeDelta | None:
     """Ensure an object is a timedelta."""
     try:
-        return ensure_class(obj, dt.timedelta, nullable=nullable)
+        return ensure_class(obj, TimeDelta, nullable=nullable)
     except EnsureClassError as error:
         raise EnsureTimeDeltaError(obj=error.obj, nullable=nullable) from None
 
@@ -541,7 +543,36 @@ class EnsureTimeDeltaError(Exception):
 
     @override
     def __str__(self) -> str:
-        return _make_error_msg(self.obj, "a timedelta", nullable=self.nullable)
+        return _make_error_msg(self.obj, "a time-delta", nullable=self.nullable)
+
+
+##
+
+
+@overload
+def ensure_zoned_date_time(obj: Any, /, *, nullable: bool) -> ZonedDateTime | None: ...
+@overload
+def ensure_zoned_date_time(
+    obj: Any, /, *, nullable: Literal[False] = False
+) -> ZonedDateTime: ...
+def ensure_zoned_date_time(
+    obj: Any, /, *, nullable: bool = False
+) -> ZonedDateTime | None:
+    """Ensure an object is a zoned date-time."""
+    try:
+        return ensure_class(obj, ZonedDateTime, nullable=nullable)
+    except EnsureClassError as error:
+        raise EnsureZonedDateTimeError(obj=error.obj, nullable=nullable) from None
+
+
+@dataclass(kw_only=True, slots=True)
+class EnsureZonedDateTimeError(Exception):
+    obj: Any
+    nullable: bool
+
+    @override
+    def __str__(self) -> str:
+        return _make_error_msg(self.obj, "a zoned date-time", nullable=self.nullable)
 
 
 ##
@@ -988,7 +1019,6 @@ __all__ = [
     "EnsureBytesError",
     "EnsureClassError",
     "EnsureDateError",
-    "EnsureDateTimeError",
     "EnsureFloatError",
     "EnsureHashableError",
     "EnsureIntError",
@@ -996,11 +1026,13 @@ __all__ = [
     "EnsureNotNoneError",
     "EnsureNumberError",
     "EnsurePathError",
+    "EnsurePlainDateTimeError",
     "EnsureSizedError",
     "EnsureSizedNotStrError",
     "EnsureStrError",
     "EnsureTimeDeltaError",
     "EnsureTimeError",
+    "EnsureZonedDateTimeError",
     "MaxNullableError",
     "MinNullableError",
     "apply_decorators",
@@ -1008,7 +1040,6 @@ __all__ = [
     "ensure_bytes",
     "ensure_class",
     "ensure_date",
-    "ensure_datetime",
     "ensure_float",
     "ensure_hashable",
     "ensure_int",
@@ -1016,11 +1047,13 @@ __all__ = [
     "ensure_not_none",
     "ensure_number",
     "ensure_path",
+    "ensure_plain_date_time",
     "ensure_sized",
     "ensure_sized_not_str",
     "ensure_str",
     "ensure_time",
-    "ensure_timedelta",
+    "ensure_time_delta",
+    "ensure_zoned_date_time",
     "first",
     "get_class",
     "get_class_name",

utilities/hypothesis.py

@@ -1,12 +1,9 @@
 from __future__ import annotations
 
 import builtins
-import datetime as dt
 from contextlib import contextmanager
 from dataclasses import dataclass
-from datetime import timezone
 from enum import Enum, auto
-from functools import partial
 from math import ceil, floor, inf, isclose, isfinite, nan
 from os import environ
 from pathlib import Path
@@ -44,7 +41,6 @@ from hypothesis.strategies import (
     sampled_from,
     sets,
     text,
-    timedeltas,
     uuids,
 )
 from hypothesis.utils.conventions import not_set
@@ -53,30 +49,23 @@ from whenever import (
     DateDelta,
     DateTimeDelta,
     PlainDateTime,
+    RepeatedTime,
+    SkippedTime,
     Time,
     TimeDelta,
+    TimeZoneNotFoundError,
     ZonedDateTime,
 )
 
 from utilities.datetime import (
-    DATETIME_MAX_NAIVE,
-    DATETIME_MAX_UTC,
-    DATETIME_MIN_NAIVE,
-    DATETIME_MIN_UTC,
-    DAY,
     MAX_DATE_TWO_DIGIT_YEAR,
     MAX_MONTH,
     MIN_DATE_TWO_DIGIT_YEAR,
     MIN_MONTH,
     Month,
-    date_duration_to_int,
-    date_duration_to_timedelta,
     date_to_month,
-    datetime_duration_to_float,
-    datetime_duration_to_timedelta,
-    round_datetime,
 )
-from utilities.functions import ensure_int, ensure_str, max_nullable, min_nullable
+from utilities.functions import ensure_int, ensure_str
 from utilities.math import (
     MAX_FLOAT32,
     MAX_FLOAT64,
@@ -109,6 +98,7 @@ from utilities.whenever2 import (
     DATE_TIME_DELTA_MIN,
     DATE_TIME_DELTA_PARSABLE_MAX,
     DATE_TIME_DELTA_PARSABLE_MIN,
+    DAY,
     PLAIN_DATE_TIME_MAX,
     PLAIN_DATE_TIME_MIN,
     TIME_DELTA_MAX,
@@ -122,14 +112,14 @@ from utilities.whenever2 import (
 from utilities.zoneinfo import UTC, ensure_time_zone
 
 if TYPE_CHECKING:
-    from collections.abc import Collection, Hashable, Iterable, Iterator, Sequence
-    from zoneinfo import ZoneInfo
+    import datetime as dt
+    from collections.abc import Collection, Hashable, Iterable, Iterator
 
     from hypothesis.database import ExampleDatabase
     from numpy.random import RandomState
 
     from utilities.numpy import NDArrayB, NDArrayF, NDArrayI, NDArrayO
-    from utilities.types import Duration, MathRoundMode, Number, TimeZoneLike
+    from utilities.types import Number, TimeZoneLike
 
 
 _T = TypeVar("_T")
@@ -226,68 +216,6 @@ def date_deltas_whenever(
 ##
 
 
-@composite
-def date_durations(
-    draw: DrawFn,
-    /,
-    *,
-    min_int: MaybeSearchStrategy[int | None] = None,
-    max_int: MaybeSearchStrategy[int | None] = None,
-    min_timedelta: MaybeSearchStrategy[dt.timedelta | None] = None,
-    max_timedelta: MaybeSearchStrategy[dt.timedelta | None] = None,
-    two_way: bool = False,
-) -> Duration:
-    """Strategy for generating datetime durations."""
-    min_int_, max_int_ = [draw2(draw, v) for v in [min_int, max_int]]
-    min_timedelta_, max_timedelta_ = [
-        draw2(draw, v) for v in [min_timedelta, max_timedelta]
-    ]
-    min_parts: Sequence[dt.timedelta | None] = [dt.timedelta.min, min_timedelta_]
-    if min_int_ is not None:
-        with assume_does_not_raise(OverflowError):
-            min_parts.append(date_duration_to_timedelta(min_int_))
-    if two_way:
-        from utilities.whenever import MIN_SERIALIZABLE_TIMEDELTA
-
-        min_parts.append(MIN_SERIALIZABLE_TIMEDELTA)
-    min_timedelta_use = max_nullable(min_parts)
-    max_parts: Sequence[dt.timedelta | None] = [dt.timedelta.max, max_timedelta_]
-    if max_int_ is not None:
-        with assume_does_not_raise(OverflowError):
-            max_parts.append(date_duration_to_timedelta(max_int_))
-    if two_way:
-        from utilities.whenever import MAX_SERIALIZABLE_TIMEDELTA
-
-        max_parts.append(MAX_SERIALIZABLE_TIMEDELTA)
-    max_timedelta_use = min_nullable(max_parts)
-    _ = assume(min_timedelta_use <= max_timedelta_use)
-    st_timedeltas = (
-        timedeltas(min_value=min_timedelta_use, max_value=max_timedelta_use)
-        .map(_round_timedelta)
-        .filter(
-            partial(
-                _is_between_timedelta, min_=min_timedelta_use, max_=max_timedelta_use
-            )
-        )
-    )
-    st_integers = st_timedeltas.map(date_duration_to_int)
-    st_floats = st_integers.map(float)
-    return draw(st_integers | st_floats | st_timedeltas)
-
-
-def _round_timedelta(timedelta: dt.timedelta, /) -> dt.timedelta:
-    return dt.timedelta(days=timedelta.days)
-
-
-def _is_between_timedelta(
-    timedelta: dt.timedelta, /, *, min_: dt.timedelta, max_: dt.timedelta
-) -> bool:
-    return min_ <= timedelta <= max_
-
-
-##
-
-
 @composite
 def date_time_deltas_whenever(
     draw: DrawFn,
@@ -375,53 +303,6 @@ def dates_whenever(
 ##
 
 
-@composite
-def datetime_durations(
-    draw: DrawFn,
-    /,
-    *,
-    min_number: MaybeSearchStrategy[Number | None] = None,
-    max_number: MaybeSearchStrategy[Number | None] = None,
-    min_timedelta: MaybeSearchStrategy[dt.timedelta | None] = None,
-    max_timedelta: MaybeSearchStrategy[dt.timedelta | None] = None,
-    two_way: bool = False,
-) -> Duration:
-    """Strategy for generating datetime durations."""
-    min_number_, max_number_ = [draw2(draw, v) for v in [min_number, max_number]]
-    min_timedelta_, max_timedelta_ = [
-        draw2(draw, v) for v in [min_timedelta, max_timedelta]
-    ]
-    min_parts = [min_timedelta_, dt.timedelta.min]
-    if min_number_ is not None:
-        with assume_does_not_raise(OverflowError):
-            min_parts.append(datetime_duration_to_timedelta(min_number_))
-    if two_way:
-        from utilities.whenever import MIN_SERIALIZABLE_TIMEDELTA
-
-        min_parts.append(MIN_SERIALIZABLE_TIMEDELTA)
-    min_timedelta_use = max_nullable(min_parts)
-    max_parts = [max_timedelta_, dt.timedelta.max]
-    if max_number_ is not None:
-        with assume_does_not_raise(OverflowError):
-            max_parts.append(datetime_duration_to_timedelta(max_number_))
-    if two_way:
-        from utilities.whenever import MAX_SERIALIZABLE_TIMEDELTA
-
-        max_parts.append(MAX_SERIALIZABLE_TIMEDELTA)
-    max_timedelta_use = min_nullable(max_parts)
-    _ = assume(min_timedelta_use <= max_timedelta_use)
-    min_float_use, max_float_use = map(
-        datetime_duration_to_float, [min_timedelta_use, max_timedelta_use]
-    )
-    _ = assume(min_float_use <= max_float_use)
-    st_numbers = numbers(min_value=min_float_use, max_value=max_float_use)
-    st_timedeltas = timedeltas(min_value=min_timedelta_use, max_value=max_timedelta_use)
-    return draw(st_numbers | st_timedeltas)
-
-
-##
-
-
 @overload
 def draw2(
     data_or_draw: DataObject | DrawFn,
@@ -853,43 +734,6 @@ def paths() -> SearchStrategy[Path]:
 ##
 
 
-@composite
-def plain_datetimes(
-    draw: DrawFn,
-    /,
-    *,
-    min_value: MaybeSearchStrategy[dt.datetime] = DATETIME_MIN_NAIVE,
-    max_value: MaybeSearchStrategy[dt.datetime] = DATETIME_MAX_NAIVE,
-    round_: MathRoundMode | None = None,
-    timedelta: dt.timedelta | None = None,
-    rel_tol: float | None = None,
-    abs_tol: float | None = None,
-) -> dt.datetime:
-    """Strategy for generating plain datetimes."""
-    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    datetime = draw(datetimes(min_value=min_value_, max_value=max_value_))
-    if round_ is not None:
-        if timedelta is None:
-            raise PlainDateTimesError(round_=round_)
-        datetime = round_datetime(
-            datetime, timedelta, mode=round_, rel_tol=rel_tol, abs_tol=abs_tol
-        )
-        _ = assume(min_value_ <= datetime <= max_value_)
-    return datetime
-
-
-@dataclass(kw_only=True, slots=True)
-class PlainDateTimesError(Exception):
-    round_: MathRoundMode
-
-    @override
-    def __str__(self) -> str:
-        return "Rounding requires a timedelta; got None"
-
-
-##
-
-
 @composite
 def plain_datetimes_whenever(
     draw: DrawFn,
@@ -1266,32 +1110,6 @@ def time_deltas_whenever(
 ##
 
 
-@composite
-def timedeltas_2w(
-    draw: DrawFn,
-    /,
-    *,
-    min_value: MaybeSearchStrategy[dt.timedelta] = dt.timedelta.min,
-    max_value: MaybeSearchStrategy[dt.timedelta] = dt.timedelta.max,
-) -> dt.timedelta:
-    """Strategy for generating timedeltas which can be se/deserialized."""
-    from utilities.whenever import (
-        MAX_SERIALIZABLE_TIMEDELTA,
-        MIN_SERIALIZABLE_TIMEDELTA,
-    )
-
-    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    return draw(
-        timedeltas(
-            min_value=max(min_value_, MIN_SERIALIZABLE_TIMEDELTA),
-            max_value=min(max_value_, MAX_SERIALIZABLE_TIMEDELTA),
-        )
-    )
-
-
-##
-
-
 @composite
 def times_whenever(
     draw: DrawFn,
@@ -1393,73 +1211,6 @@ def versions(draw: DrawFn, /, *, suffix: MaybeSearchStrategy[bool] = False) -> V
 ##
 
 
-@composite
-def zoned_datetimes(
-    draw: DrawFn,
-    /,
-    *,
-    min_value: MaybeSearchStrategy[dt.datetime] = DATETIME_MIN_UTC + DAY,
-    max_value: MaybeSearchStrategy[dt.datetime] = DATETIME_MAX_UTC - DAY,
-    time_zone: MaybeSearchStrategy[ZoneInfo | timezone] = UTC,
-    round_: MathRoundMode | None = None,
-    timedelta: dt.timedelta | None = None,
-    rel_tol: float | None = None,
-    abs_tol: float | None = None,
-    valid: bool = False,
-) -> dt.datetime:
-    """Strategy for generating zoned datetimes."""
-    from utilities.whenever import (
-        CheckValidZonedDateTimeError,
-        check_valid_zoned_datetime,
-    )
-
-    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    time_zone_ = draw2(draw, time_zone)
-    if min_value_.tzinfo is None:
-        min_value_ = min_value_.replace(tzinfo=time_zone_)
-    else:
-        with assume_does_not_raise(OverflowError, match="date value out of range"):
-            min_value_ = min_value_.astimezone(time_zone_)
-    if max_value_.tzinfo is None:
-        max_value_ = max_value_.replace(tzinfo=time_zone_)
-    else:
-        with assume_does_not_raise(OverflowError, match="date value out of range"):
-            max_value_ = max_value_.astimezone(time_zone_)
-    try:
-        datetime = draw(
-            plain_datetimes(
-                min_value=min_value_.replace(tzinfo=None),
-                max_value=max_value_.replace(tzinfo=None),
-                round_=round_,
-                timedelta=timedelta,
-                rel_tol=rel_tol,
-                abs_tol=abs_tol,
-            )
-        )
-    except PlainDateTimesError as error:
-        raise ZonedDateTimesError(round_=error.round_) from None
-    datetime = datetime.replace(tzinfo=time_zone_)
-    _ = assume(min_value_ <= datetime <= max_value_)
-    if valid:
-        with assume_does_not_raise(  # skipif-ci-and-windows
-            CheckValidZonedDateTimeError
-        ):
-            check_valid_zoned_datetime(datetime)
-    return datetime
-
-
-@dataclass(kw_only=True, slots=True)
-class ZonedDateTimesError(Exception):
-    round_: MathRoundMode
-
-    @override
-    def __str__(self) -> str:
-        return "Rounding requires a timedelta; got None"
-
-
-##
-
-
 @composite
 def zoned_datetimes_whenever(
     draw: DrawFn,
@@ -1488,27 +1239,30 @@ def zoned_datetimes_whenever(
                 max_value_ = max_value_.to_tz(time_zone_.key).to_plain()
         case _ as never:
             assert_never(never)
-    plain_datetime = draw(
-        plain_datetimes_whenever(min_value=min_value_, max_value=max_value_)
-    )
-    with assume_does_not_raise(ValueError):
-        return plain_datetime.assume_tz(time_zone_.key, disambiguate="raise")
+    plain = draw(plain_datetimes_whenever(min_value=min_value_, max_value=max_value_))
+    with (
+        assume_does_not_raise(RepeatedTime),
+        assume_does_not_raise(SkippedTime),
+        assume_does_not_raise(TimeZoneNotFoundError),
+        assume_does_not_raise(ValueError, match="Resulting datetime is out of range"),
+    ):
+        zoned = plain.assume_tz(time_zone_.key, disambiguate="raise")
+    with assume_does_not_raise(OverflowError, match="date value out of range"):
+        if not ((DATE_MIN + DAY) <= zoned.date() <= (DATE_MAX - DAY)):
+            _ = zoned.py_datetime()
+    return zoned
 
 
 __all__ = [
     "Draw2Error",
     "MaybeSearchStrategy",
-    "PlainDateTimesError",
     "Shape",
-    "ZonedDateTimesError",
     "assume_does_not_raise",
     "bool_arrays",
     "date_deltas_whenever",
-    "date_durations",
     "date_time_deltas_whenever",
     "dates_two_digit_year",
     "dates_whenever",
-    "datetime_durations",
     "draw2",
     "float32s",
     "float64s",
@@ -1525,7 +1279,6 @@ __all__ = [
     "numbers",
     "pairs",
     "paths",
-    "plain_datetimes",
     "plain_datetimes_whenever",
     "random_states",
     "sentinels",
@@ -1542,12 +1295,10 @@ __all__ = [
     "text_digits",
     "text_printable",
     "time_deltas_whenever",
-    "timedeltas_2w",
     "times_whenever",
     "triples",
     "uint32s",
     "uint64s",
     "versions",
-    "zoned_datetimes",
     "zoned_datetimes_whenever",
 ]

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()