dycw-utilities 0.129.10__py3-none-any.whl → 0.175.17__py3-none-any.whl

utilities/functions.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 
-import datetime as dt
-from collections.abc import Callable, Iterable, Iterator, Sequence
-from dataclasses import asdict, dataclass, is_dataclass
+from collections.abc import Callable, Iterable, Iterator
+from dataclasses import asdict, dataclass
 from functools import _lru_cache_wrapper, cached_property, partial, reduce, wraps
 from inspect import getattr_static
 from pathlib import Path
@@ -15,59 +14,26 @@ from types import (
     MethodWrapperType,
     WrapperDescriptorType,
 )
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Generic,
-    Literal,
-    TypeGuard,
-    TypeVar,
-    cast,
-    overload,
-    override,
-)
+from typing import TYPE_CHECKING, Any, Literal, TypeGuard, cast, overload, override
 
-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
-from utilities.types import (
-    Dataclass,
-    Number,
-    StrMapping,
-    TCallable,
-    TCallable1,
-    TCallable2,
-    TSupportsRichComparison,
-    TupleOrStrMapping,
-    TypeLike,
-)
+from utilities.sentinel import Sentinel, is_sentinel, sentinel
+from utilities.types import Dataclass, Number, SupportsRichComparison, TypeLike
 
 if TYPE_CHECKING:
-    from collections.abc import Container, Hashable, Sized
-
-
-_P = ParamSpec("_P")
-_T = TypeVar("_T")
-_T1 = TypeVar("_T1")
-_T2 = TypeVar("_T2")
-_T3 = TypeVar("_T3")
-_T4 = TypeVar("_T4")
-_T5 = TypeVar("_T5")
-_U = TypeVar("_U")
-
-
-##
+    from collections.abc import Container
 
 
-def apply_decorators(
-    func: TCallable1, /, *decorators: Callable[[TCallable2], TCallable2]
-) -> TCallable1:
+def apply_decorators[F1: Callable, F2: Callable](
+    func: F1, /, *decorators: Callable[[F2], F2]
+) -> F1:
     """Apply a set of decorators to a function."""
     return reduce(_apply_decorators_one, decorators, func)
 
 
-def _apply_decorators_one(acc: TCallable, el: Callable[[Any], Any], /) -> TCallable:
+def _apply_decorators_one[F: Callable](acc: F, el: Callable[[Any], Any], /) -> F:
     return el(acc)
 
 
@@ -125,66 +91,64 @@ class EnsureBytesError(Exception):
 
 
 @overload
-def ensure_class(obj: Any, cls: type[_T], /, *, nullable: bool) -> _T | None: ...
+def ensure_class[T](obj: Any, cls: type[T], /, *, nullable: bool) -> T | None: ...
 @overload
-def ensure_class(
-    obj: Any, cls: type[_T], /, *, nullable: Literal[False] = False
-) -> _T: ...
+def ensure_class[T](
+    obj: Any, cls: type[T], /, *, nullable: Literal[False] = False
+) -> T: ...
 @overload
-def ensure_class(
-    obj: Any, cls: tuple[type[_T1], type[_T2]], /, *, nullable: bool
-) -> _T1 | _T2 | None: ...
+def ensure_class[T1, T2](
+    obj: Any, cls: tuple[type[T1], type[T2]], /, *, nullable: bool
+) -> T1 | T2 | None: ...
 @overload
-def ensure_class(
-    obj: Any, cls: tuple[type[_T1], type[_T2]], /, *, nullable: Literal[False] = False
-) -> _T1 | _T2: ...
+def ensure_class[T1, T2](
+    obj: Any, cls: tuple[type[T1], type[T2]], /, *, nullable: Literal[False] = False
+) -> T1 | T2: ...
 @overload
-def ensure_class(
-    obj: Any, cls: tuple[type[_T1], type[_T2], type[_T3]], /, *, nullable: bool
-) -> _T1 | _T2 | _T3 | None: ...
+def ensure_class[T1, T2, T3](
+    obj: Any, cls: tuple[type[T1], type[T2], type[T3]], /, *, nullable: bool
+) -> T1 | T2 | T3 | None: ...
 @overload
-def ensure_class(
+def ensure_class[T1, T2, T3](
     obj: Any,
-    cls: tuple[type[_T1], type[_T2], type[_T3]],
+    cls: tuple[type[T1], type[T2], type[T3]],
     /,
     *,
     nullable: Literal[False] = False,
-) -> _T1 | _T2 | _T3: ...
+) -> T1 | T2 | T3: ...
 @overload
-def ensure_class(
-    obj: Any,
-    cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4]],
-    /,
-    *,
-    nullable: bool,
-) -> _T1 | _T2 | _T3 | _T4 | None: ...
+def ensure_class[T1, T2, T3, T4](
+    obj: Any, cls: tuple[type[T1], type[T2], type[T3], type[T4]], /, *, nullable: bool
+) -> T1 | T2 | T3 | T4 | None: ...
 @overload
-def ensure_class(
+def ensure_class[T1, T2, T3, T4](
     obj: Any,
-    cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4]],
+    cls: tuple[type[T1], type[T2], type[T3], type[T4]],
     /,
     *,
     nullable: Literal[False] = False,
-) -> _T1 | _T2 | _T3 | _T4: ...
+) -> T1 | T2 | T3 | T4: ...
 @overload
-def ensure_class(
+def ensure_class[T1, T2, T3, T4, T5](
     obj: Any,
-    cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4], type[_T5]],
+    cls: tuple[type[T1], type[T2], type[T3], type[T4], type[T5]],
     /,
     *,
     nullable: bool,
-) -> _T1 | _T2 | _T3 | _T4 | _T5 | None: ...
+) -> T1 | T2 | T3 | T4 | T5 | None: ...
 @overload
-def ensure_class(
+def ensure_class[T1, T2, T3, T4, T5](
     obj: Any,
-    cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4], type[_T5]],
+    cls: tuple[type[T1], type[T2], type[T3], type[T4], type[T5]],
     /,
     *,
     nullable: Literal[False] = False,
-) -> _T1 | _T2 | _T3 | _T4 | _T5: ...
+) -> T1 | T2 | T3 | T4 | T5: ...
 @overload
-def ensure_class(obj: Any, cls: TypeLike[_T], /, *, nullable: bool = False) -> Any: ...
-def ensure_class(obj: Any, cls: TypeLike[_T], /, *, nullable: bool = False) -> Any:
+def ensure_class[T](
+    obj: Any, cls: TypeLike[T], /, *, nullable: bool = False
+) -> Any: ...
+def ensure_class[T](obj: Any, cls: TypeLike[T], /, *, nullable: bool = False) -> Any:
     """Ensure an object is of the required class."""
     if isinstance(obj, cls) or ((obj is None) and nullable):
         return obj
@@ -210,13 +174,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 +198,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
@@ -286,25 +223,6 @@ class EnsureFloatError(Exception):
 ##
 
 
-def ensure_hashable(obj: Any, /) -> Hashable:
-    """Ensure an object is hashable."""
-    if is_hashable(obj):
-        return obj
-    raise EnsureHashableError(obj=obj)
-
-
-@dataclass(kw_only=True, slots=True)
-class EnsureHashableError(Exception):
-    obj: Any
-
-    @override
-    def __str__(self) -> str:
-        return _make_error_msg(self.obj, "hashable")
-
-
-##
-
-
 @overload
 def ensure_int(obj: Any, /, *, nullable: bool) -> int | None: ...
 @overload
@@ -331,16 +249,16 @@ class EnsureIntError(Exception):
 
 
 @overload
-def ensure_member(
-    obj: Any, container: Container[_T], /, *, nullable: bool
-) -> _T | None: ...
+def ensure_member[T](
+    obj: Any, container: Container[T], /, *, nullable: bool
+) -> T | None: ...
 @overload
-def ensure_member(
-    obj: Any, container: Container[_T], /, *, nullable: Literal[False] = False
-) -> _T: ...
-def ensure_member(
-    obj: Any, container: Container[_T], /, *, nullable: bool = False
-) -> _T | None:
+def ensure_member[T](
+    obj: Any, container: Container[T], /, *, nullable: Literal[False] = False
+) -> T: ...
+def ensure_member[T](
+    obj: Any, container: Container[T], /, *, nullable: bool = False
+) -> T | None:
     """Ensure an object is a member of the container."""
     if (obj in container) or ((obj is None) and nullable):
         return obj
@@ -363,7 +281,7 @@ class EnsureMemberError(Exception):
 ##
 
 
-def ensure_not_none(obj: _T | None, /, *, desc: str = "Object") -> _T:
+def ensure_not_none[T](obj: T | None, /, *, desc: str = "Object") -> T:
     """Ensure an object is not None."""
     if obj is None:
         raise EnsureNotNoneError(desc=desc)
@@ -432,39 +350,30 @@ class EnsurePathError(Exception):
 ##
 
 
-def ensure_sized(obj: Any, /) -> Sized:
-    """Ensure an object is sized."""
-    if is_sized(obj):
-        return obj
-    raise EnsureSizedError(obj=obj)
-
-
-@dataclass(kw_only=True, slots=True)
-class EnsureSizedError(Exception):
-    obj: Any
-
-    @override
-    def __str__(self) -> str:
-        return _make_error_msg(self.obj, "sized")
-
-
-##
-
-
-def ensure_sized_not_str(obj: Any, /) -> Sized:
-    """Ensure an object is sized, but not a string."""
-    if is_sized_not_str(obj):
-        return obj
-    raise EnsureSizedNotStrError(obj=obj)
+@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 EnsureSizedNotStrError(Exception):
+class EnsurePlainDateTimeError(Exception):
     obj: Any
+    nullable: bool
 
     @override
     def __str__(self) -> str:
-        return _make_error_msg(self.obj, "sized and not a string")
+        return _make_error_msg(self.obj, "a plain date-time", nullable=self.nullable)
 
 
 ##
@@ -496,13 +405,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 +430,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,13 +450,42 @@ 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)
 
 
 ##
 
 
-def first(pair: tuple[_T, Any], /) -> _T:
+@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)
+
+
+##
+
+
+def first[T](pair: tuple[T, Any], /) -> T:
     """Get the first element in a pair."""
     return pair[0]
 
@@ -556,10 +494,10 @@ def first(pair: tuple[_T, Any], /) -> _T:
 
 
 @overload
-def get_class(obj: type[_T], /) -> type[_T]: ...
+def get_class[T](obj: type[T], /) -> type[T]: ...
 @overload
-def get_class(obj: _T, /) -> type[_T]: ...
-def get_class(obj: _T | type[_T], /) -> type[_T]:
+def get_class[T](obj: T, /) -> type[T]: ...
+def get_class[T](obj: T | type[T], /) -> type[T]:
     """Get the class of an object, unless it is already a class."""
     return obj if isinstance(obj, type) else type(obj)
 
@@ -623,7 +561,7 @@ def get_func_qualname(obj: Callable[..., Any], /) -> str:
 ##
 
 
-def identity(obj: _T, /) -> _T:
+def identity[T](obj: T, /) -> T:
     """Return the object itself."""
     return obj
 
@@ -631,65 +569,7 @@ def identity(obj: _T, /) -> _T:
 ##
 
 
-def is_dataclass_class(obj: Any, /) -> TypeGuard[type[Dataclass]]:
-    """Check if an object is a dataclass."""
-    return isinstance(obj, type) and is_dataclass(obj)
-
-
-##
-
-
-def is_dataclass_instance(obj: Any, /) -> TypeGuard[Dataclass]:
-    """Check if an object is an instance of a dataclass."""
-    return (not isinstance(obj, type)) and is_dataclass(obj)
-
-
-##
-
-
-def is_hashable(obj: Any, /) -> TypeGuard[Hashable]:
-    """Check if an object is hashable."""
-    try:
-        _ = hash(obj)
-    except TypeError:
-        return False
-    return True
-
-
-##
-
-
-@overload
-def is_iterable_of(obj: Any, cls: type[_T], /) -> TypeGuard[Iterable[_T]]: ...
-@overload
-def is_iterable_of(obj: Any, cls: tuple[type[_T1]], /) -> TypeGuard[Iterable[_T1]]: ...
-@overload
-def is_iterable_of(
-    obj: Any, cls: tuple[type[_T1], type[_T2]], /
-) -> TypeGuard[Iterable[_T1 | _T2]]: ...
-@overload
-def is_iterable_of(
-    obj: Any, cls: tuple[type[_T1], type[_T2], type[_T3]], /
-) -> TypeGuard[Iterable[_T1 | _T2 | _T3]]: ...
-@overload
-def is_iterable_of(
-    obj: Any, cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4]], /
-) -> TypeGuard[Iterable[_T1 | _T2 | _T3 | _T4]]: ...
-@overload
-def is_iterable_of(
-    obj: Any, cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4], type[_T5]], /
-) -> TypeGuard[Iterable[_T1 | _T2 | _T3 | _T4 | _T5]]: ...
-@overload
-def is_iterable_of(obj: Any, cls: TypeLike[_T], /) -> TypeGuard[Iterable[_T]]: ...
-def is_iterable_of(obj: Any, cls: TypeLike[_T], /) -> TypeGuard[Iterable[_T]]:
-    """Check if an object is a iterable of tuple or string mappings."""
-    return isinstance(obj, Iterable) and all(map(make_isinstance(cls), obj))
-
-
-##
-
-
-def is_none(obj: Any, /) -> bool:
+def is_none(obj: Any, /) -> TypeGuard[None]:
     """Check if an object is `None`."""
     return obj is None
 
@@ -705,131 +585,9 @@ def is_not_none(obj: Any, /) -> bool:
 ##
 
 
-@overload
-def is_sequence_of(obj: Any, cls: type[_T], /) -> TypeGuard[Sequence[_T]]: ...
-@overload
-def is_sequence_of(obj: Any, cls: tuple[type[_T1]], /) -> TypeGuard[Sequence[_T1]]: ...
-@overload
-def is_sequence_of(
-    obj: Any, cls: tuple[type[_T1], type[_T2]], /
-) -> TypeGuard[Sequence[_T1 | _T2]]: ...
-@overload
-def is_sequence_of(
-    obj: Any, cls: tuple[type[_T1], type[_T2], type[_T3]], /
-) -> TypeGuard[Sequence[_T1 | _T2 | _T3]]: ...
-@overload
-def is_sequence_of(
-    obj: Any, cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4]], /
-) -> TypeGuard[Sequence[_T1 | _T2 | _T3 | _T4]]: ...
-@overload
-def is_sequence_of(
-    obj: Any, cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4], type[_T5]], /
-) -> TypeGuard[Sequence[_T1 | _T2 | _T3 | _T4 | _T5]]: ...
-@overload
-def is_sequence_of(obj: Any, cls: TypeLike[_T], /) -> TypeGuard[Sequence[_T]]: ...
-def is_sequence_of(obj: Any, cls: TypeLike[_T], /) -> TypeGuard[Sequence[_T]]:
-    """Check if an object is a sequence of tuple or string mappings."""
-    return isinstance(obj, Sequence) and is_iterable_of(obj, cls)
-
-
-##
-
-
-def is_sequence_of_tuple_or_str_mapping(
-    obj: Any, /
-) -> TypeGuard[Sequence[TupleOrStrMapping]]:
-    """Check if an object is a sequence of tuple or string mappings."""
-    return isinstance(obj, Sequence) and all(map(is_tuple_or_str_mapping, obj))
-
-
-##
-
-
-def is_sized(obj: Any, /) -> TypeGuard[Sized]:
-    """Check if an object is sized."""
-    try:
-        _ = len(obj)
-    except TypeError:
-        return False
-    return True
-
-
-##
-
-
-def is_sized_not_str(obj: Any, /) -> TypeGuard[Sized]:
-    """Check if an object is sized, but not a string."""
-    return is_sized(obj) and not isinstance(obj, str)
-
-
-##
-
-
-def is_string_mapping(obj: Any, /) -> TypeGuard[StrMapping]:
-    """Check if an object is a string mapping."""
-    return isinstance(obj, dict) and is_iterable_of(obj, str)
-
-
-##
-
-
-def is_tuple(obj: Any, /) -> TypeGuard[tuple[Any, ...]]:
-    """Check if an object is a tuple or string mapping."""
-    return make_isinstance(tuple)(obj)
-
-
-##
-
-
-def is_tuple_or_str_mapping(obj: Any, /) -> TypeGuard[TupleOrStrMapping]:
-    """Check if an object is a tuple or string mapping."""
-    return is_tuple(obj) or is_string_mapping(obj)
-
-
-##
-
-
-@overload
-def make_isinstance(cls: type[_T], /) -> Callable[[Any], TypeGuard[_T]]: ...
-@overload
-def make_isinstance(cls: tuple[type[_T1]], /) -> Callable[[Any], TypeGuard[_T1]]: ...
-@overload
-def make_isinstance(
-    cls: tuple[type[_T1], type[_T2]], /
-) -> Callable[[Any], TypeGuard[_T1 | _T2]]: ...
-@overload
-def make_isinstance(
-    cls: tuple[type[_T1], type[_T2], type[_T3]], /
-) -> Callable[[Any], TypeGuard[_T1 | _T2 | _T3]]: ...
-@overload
-def make_isinstance(
-    cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4]], /
-) -> Callable[[Any], TypeGuard[_T1 | _T2 | _T3 | _T4]]: ...
-@overload
-def make_isinstance(
-    cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4], type[_T5]], /
-) -> Callable[[Any], TypeGuard[_T1 | _T2 | _T3 | _T4 | _T5]]: ...
-@overload
-def make_isinstance(cls: TypeLike[_T], /) -> Callable[[Any], TypeGuard[_T]]: ...
-def make_isinstance(cls: TypeLike[_T], /) -> Callable[[Any], TypeGuard[_T]]:
-    """Make a curried `isinstance` function."""
-    return partial(_make_instance_core, cls=cls)
-
-
-def _make_instance_core(obj: Any, /, *, cls: TypeLike[_T]) -> TypeGuard[_T]:
-    return isinstance(obj, cls)
-
-
-##
-
-
-def map_object(
-    func: Callable[[Any], Any],
-    obj: _T,
-    /,
-    *,
-    before: Callable[[Any], Any] | None = None,
-) -> _T:
+def map_object[T](
+    func: Callable[[Any], Any], obj: T, /, *, before: Callable[[Any], Any] | None = None
+) -> T:
     """Map a function over an object, across a variety of structures."""
     if before is not None:
         obj = before(obj)
@@ -850,22 +608,19 @@ def map_object(
 
 
 @overload
-def min_nullable(
-    iterable: Iterable[TSupportsRichComparison | None], /, *, default: Sentinel = ...
-) -> TSupportsRichComparison: ...
+def min_nullable[T: SupportsRichComparison](
+    iterable: Iterable[T | None], /, *, default: Sentinel = ...
+) -> T: ...
 @overload
-def min_nullable(
-    iterable: Iterable[TSupportsRichComparison | None], /, *, default: _U = ...
-) -> TSupportsRichComparison | _U: ...
-def min_nullable(
-    iterable: Iterable[TSupportsRichComparison | None],
-    /,
-    *,
-    default: _U | Sentinel = sentinel,
-) -> TSupportsRichComparison | _U:
+def min_nullable[T: SupportsRichComparison, U](
+    iterable: Iterable[T | None], /, *, default: U = ...
+) -> T | U: ...
+def min_nullable[T: SupportsRichComparison, U](
+    iterable: Iterable[T | None], /, *, default: U | Sentinel = sentinel
+) -> T | U:
     """Compute the minimum of a set of values; ignoring nulls."""
     values = (i for i in iterable if i is not None)
-    if isinstance(default, Sentinel):
+    if is_sentinel(default):
         try:
             return min(values)
         except ValueError:
@@ -874,8 +629,8 @@ def min_nullable(
 
 
 @dataclass(kw_only=True, slots=True)
-class MinNullableError(Exception, Generic[TSupportsRichComparison]):
-    values: Iterable[TSupportsRichComparison]
+class MinNullableError[T: SupportsRichComparison](Exception):
+    values: Iterable[T]
 
     @override
     def __str__(self) -> str:
@@ -883,22 +638,19 @@ class MinNullableError(Exception, Generic[TSupportsRichComparison]):
 
 
 @overload
-def max_nullable(
-    iterable: Iterable[TSupportsRichComparison | None], /, *, default: Sentinel = ...
-) -> TSupportsRichComparison: ...
+def max_nullable[T: SupportsRichComparison](
+    iterable: Iterable[T | None], /, *, default: Sentinel = ...
+) -> T: ...
 @overload
-def max_nullable(
-    iterable: Iterable[TSupportsRichComparison | None], /, *, default: _U = ...
-) -> TSupportsRichComparison | _U: ...
-def max_nullable(
-    iterable: Iterable[TSupportsRichComparison | None],
-    /,
-    *,
-    default: _U | Sentinel = sentinel,
-) -> TSupportsRichComparison | _U:
+def max_nullable[T: SupportsRichComparison, U](
+    iterable: Iterable[T | None], /, *, default: U = ...
+) -> T | U: ...
+def max_nullable[T: SupportsRichComparison, U](
+    iterable: Iterable[T | None], /, *, default: U | Sentinel = sentinel
+) -> T | U:
     """Compute the maximum of a set of values; ignoring nulls."""
     values = (i for i in iterable if i is not None)
-    if isinstance(default, Sentinel):
+    if is_sentinel(default):
         try:
             return max(values)
         except ValueError:
@@ -907,7 +659,7 @@ def max_nullable(
 
 
 @dataclass(kw_only=True, slots=True)
-class MaxNullableError(Exception, Generic[TSupportsRichComparison]):
+class MaxNullableError[TSupportsRichComparison](Exception):
     values: Iterable[TSupportsRichComparison]
 
     @override
@@ -918,11 +670,11 @@ class MaxNullableError(Exception, Generic[TSupportsRichComparison]):
 ##
 
 
-def not_func(func: Callable[_P, bool], /) -> Callable[_P, bool]:
+def not_func[**P](func: Callable[P, bool], /) -> Callable[P, bool]:
     """Lift a boolean-valued function to return its conjugation."""
 
     @wraps(func)
-    def wrapped(*args: _P.args, **kwargs: _P.kwargs) -> bool:
+    def wrapped(*args: P.args, **kwargs: P.kwargs) -> bool:
         return not func(*args, **kwargs)
 
     return wrapped
@@ -931,7 +683,7 @@ def not_func(func: Callable[_P, bool], /) -> Callable[_P, bool]:
 ##
 
 
-def second(pair: tuple[Any, _U], /) -> _U:
+def second[U](pair: tuple[Any, U], /) -> U:
     """Get the second element in a pair."""
     return pair[1]
 
@@ -939,6 +691,21 @@ def second(pair: tuple[Any, _U], /) -> _U:
 ##
 
 
+def skip_if_optimize[**P](func: Callable[P, None], /) -> Callable[P, None]:
+    """Skip a function if we are in the optimized mode."""
+    if __debug__:  # pragma: no cover
+        return func
+
+    @wraps(func)
+    def wrapped(*args: P.args, **kwargs: P.kwargs) -> None:
+        _ = (args, kwargs)
+
+    return wrapped
+
+
+##
+
+
 def yield_object_attributes(
     obj: Any,
     /,
@@ -988,19 +755,17 @@ __all__ = [
     "EnsureBytesError",
     "EnsureClassError",
     "EnsureDateError",
-    "EnsureDateTimeError",
     "EnsureFloatError",
-    "EnsureHashableError",
     "EnsureIntError",
     "EnsureMemberError",
     "EnsureNotNoneError",
     "EnsureNumberError",
     "EnsurePathError",
-    "EnsureSizedError",
-    "EnsureSizedNotStrError",
+    "EnsurePlainDateTimeError",
     "EnsureStrError",
     "EnsureTimeDeltaError",
     "EnsureTimeError",
+    "EnsureZonedDateTimeError",
     "MaxNullableError",
     "MinNullableError",
     "apply_decorators",
@@ -1008,43 +773,31 @@ __all__ = [
     "ensure_bytes",
     "ensure_class",
     "ensure_date",
-    "ensure_datetime",
     "ensure_float",
-    "ensure_hashable",
     "ensure_int",
     "ensure_member",
     "ensure_not_none",
     "ensure_number",
     "ensure_path",
-    "ensure_sized",
-    "ensure_sized_not_str",
+    "ensure_plain_date_time",
     "ensure_str",
     "ensure_time",
-    "ensure_timedelta",
+    "ensure_time_delta",
+    "ensure_zoned_date_time",
     "first",
     "get_class",
     "get_class_name",
     "get_func_name",
     "get_func_qualname",
     "identity",
-    "is_dataclass_class",
-    "is_dataclass_instance",
-    "is_hashable",
-    "is_iterable_of",
     "is_none",
     "is_not_none",
-    "is_sequence_of_tuple_or_str_mapping",
-    "is_sized",
-    "is_sized_not_str",
-    "is_string_mapping",
-    "is_tuple",
-    "is_tuple_or_str_mapping",
-    "make_isinstance",
     "map_object",
     "max_nullable",
     "min_nullable",
     "not_func",
     "second",
+    "skip_if_optimize",
     "yield_object_attributes",
     "yield_object_cached_properties",
     "yield_object_properties",