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

utilities/operator.py

@@ -1,35 +1,27 @@
 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
+from typing import TYPE_CHECKING, Any, 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
+from utilities.typing import is_dataclass_instance
 
 if TYPE_CHECKING:
-    from utilities.types import Dataclass, DateOrDateTime, Number
+    from utilities.types import Dataclass, Number
 
-_T = TypeVar("_T")
 
-
-def is_equal(
+def is_equal[T](
     x: Any,
     y: Any,
     /,
     *,
     rel_tol: float | None = None,
     abs_tol: float | None = None,
-    extra: Mapping[type[_T], Callable[[_T, _T], bool]] | None = None,
+    extra: Mapping[type[T], Callable[[T, T], bool]] | None = None,
 ) -> bool:
     """Check if two objects are equal."""
     if type(x) is type(y):
@@ -40,8 +32,8 @@ def is_equal(
             except StopIteration:
                 pass
             else:
-                x = cast("_T", x)
-                y = cast("_T", y)
+                x = cast("T", x)
+                y = cast("T", y)
                 return cmp(x, y)
 
         # singletons
@@ -51,12 +43,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)
@@ -66,6 +52,14 @@ def is_equal(
             return is_equal(x.args, y.args)
 
         # collections
+        if isinstance(x, AbstractSet):
+            y = cast("AbstractSet[Any]", y)
+            try:
+                x_sorted = sort_iterable(x)
+                y_sorted = sort_iterable(y)
+            except SortIterableError:
+                return _is_in(x, y) and _is_in(y, x)
+            return is_equal(x_sorted, y_sorted, rel_tol=rel_tol, abs_tol=abs_tol)
         if isinstance(x, Mapping):
             y = cast("Mapping[Any, Any]", y)
             x_keys = set(x)
@@ -75,14 +69,6 @@ def is_equal(
             x_values = [x[i] for i in x]
             y_values = [y[i] for i in x]
             return is_equal(x_values, y_values, rel_tol=rel_tol, abs_tol=abs_tol)
-        if isinstance(x, AbstractSet):
-            y = cast("AbstractSet[Any]", y)
-            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
-            return is_equal(x_sorted, y_sorted, rel_tol=rel_tol, abs_tol=abs_tol)
         if isinstance(x, Sequence):
             y = cast("Sequence[Any]", y)
             if len(x) != len(y):
@@ -98,6 +84,24 @@ def is_equal(
     return (type(x) is type(y)) and (x == y)
 
 
+def _is_in[T](
+    x: AbstractSet[Any],
+    y: AbstractSet[Any],
+    /,
+    *,
+    rel_tol: float | None = None,
+    abs_tol: float | None = None,
+    extra: Mapping[type[T], Callable[[T, T], bool]] | None = None,
+) -> bool:
+    return 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
+    )
+
+
 @dataclass(kw_only=True, slots=True)
 class IsEqualError(Exception):
     x: Any

utilities/optuna.py

@@ -6,6 +6,8 @@ from typing import TYPE_CHECKING
 from optuna import create_study
 from sqlalchemy import URL
 
+from utilities.types import Dataclass
+
 if TYPE_CHECKING:
     from collections.abc import Callable, Sequence
 
@@ -14,7 +16,7 @@ if TYPE_CHECKING:
     from optuna.samplers import BaseSampler
     from optuna.study import StudyDirection
 
-    from utilities.types import PathLike, TDataclass
+    from utilities.types import PathLike
 
 
 def create_sqlite_study(
@@ -45,7 +47,7 @@ def create_sqlite_study(
 ##
 
 
-def get_best_params(study: Study, cls: type[TDataclass], /) -> TDataclass:
+def get_best_params[T: Dataclass](study: Study, cls: type[T], /) -> T:
     """Get the best params as a dataclass."""
     return cls(**study.best_params)
 
@@ -53,10 +55,8 @@ def get_best_params(study: Study, cls: type[TDataclass], /) -> TDataclass:
 ##
 
 
-def make_objective(
-    suggest_params: Callable[[Trial], TDataclass],
-    objective: Callable[[TDataclass], float],
-    /,
+def make_objective[T: Dataclass](
+    suggest_params: Callable[[Trial], T], objective: Callable[[T], float], /
 ) -> Callable[[Trial], float]:
     """Make an objective given separate trialling & evaluating functions."""