fix formatting

Author: SimonBlanke

src/hyperactive/_registry/_lookup.py

@@ -158,7 +158,7 @@ def all_objects(
     ROOT = str(Path(__file__).parent.parent)  # package root directory
 
     def _coerce_to_str(obj):
-        if isinstance(obj, (list, tuple)):
+        if isinstance(obj, list | tuple):
             return [_coerce_to_str(o) for o in obj]
         if isclass(obj):
             obj = obj.get_tag("object_type")

src/hyperactive/integrations/sklearn/opt_cv.py

@@ -1,7 +1,6 @@
 """opt_cv module for Hyperactive optimization."""
 
 from collections.abc import Callable
-from typing import Union
 
 from sklearn.base import BaseEstimator, clone
 
@@ -107,7 +106,7 @@ def __init__(
         estimator,
         optimizer,
         *,
-        scoring: Union[Callable, str, None] = None,
+        scoring: Callable | str | None = None,
         refit: bool = True,
         cv=None,
     ):

src/hyperactive/opt/_adapters/_search_space_adapter.py

@@ -86,7 +86,8 @@ def validate(self):
         """
         if not isinstance(self._original_space, dict):
             raise TypeError(
-                f"Search space must be a dict, got {type(self._original_space).__name__}"
+                "Search space must be a dict, "
+                f"got {type(self._original_space).__name__}"
             )
 
         if not self._original_space:
@@ -99,13 +100,14 @@ def _validate_dimension(self, name: str, values):
         """Validate a single dimension."""
         if isinstance(values, tuple):
             self._validate_continuous(name, values)
-        elif isinstance(values, (list, np.ndarray)):
+        elif isinstance(values, list | np.ndarray):
             self._validate_discrete(name, values)
         else:
             raise TypeError(
                 f"Parameter '{name}': expected list (discrete) or tuple (continuous), "
                 f"got {type(values).__name__}. "
-                f"Use [a, b, c] for discrete values or (low, high) for continuous ranges."
+                "Use [a, b, c] for discrete values "
+                "or (low, high) for continuous ranges."
             )
 
     def _validate_continuous(self, name: str, values: tuple):
@@ -130,7 +132,7 @@ def _validate_continuous(self, name: str, values: tuple):
         low, high = values[0], values[1]
 
         # Check low and high are numeric
-        if not isinstance(low, (int, float)) or not isinstance(high, (int, float)):
+        if not isinstance(low, int | float) or not isinstance(high, int | float):
             raise TypeError(
                 f"Parameter '{name}': low and high must be numeric, "
                 f"got low={type(low).__name__}, high={type(high).__name__}"
@@ -190,7 +192,7 @@ def _parse_continuous_options(self, name: str, values: tuple):
                         f"Use 'log' for logarithmic scale."
                     )
                 log_scale = True
-            elif isinstance(third, (int, float)):
+            elif isinstance(third, int | float):
                 n_points = int(third)
             else:
                 raise TypeError(
@@ -200,7 +202,7 @@ def _parse_continuous_options(self, name: str, values: tuple):
         elif len(values) == 4:
             # (low, high, n_points, "log")
             third, fourth = values[2], values[3]
-            if not isinstance(third, (int, float)):
+            if not isinstance(third, int | float):
                 raise TypeError(
                     f"Parameter '{name}': n_points must be numeric, "
                     f"got {type(third).__name__}"

src/hyperactive/opt/gridsearch/_sk.py

@@ -159,7 +159,7 @@ def _check_param_grid(self, param_grid):
                 if isinstance(v, np.ndarray) and v.ndim > 1:
                     raise ValueError("Parameter array should be one-dimensional.")
 
-                if isinstance(v, str) or not isinstance(v, (np.ndarray, Sequence)):
+                if isinstance(v, str) or not isinstance(v, np.ndarray | Sequence):
                     raise ValueError(
                         f"Parameter grid for parameter ({name}) needs to"
                         f" be a list or numpy array, but got ({type(v)})."

src/hyperactive/opt/optuna/_grid_optimizer.py

@@ -103,7 +103,7 @@ def _get_optimizer(self):
             for key, space in param_space.items():
                 if isinstance(space, list):
                     search_space[key] = space
-                elif isinstance(space, (tuple,)) and len(space) == 2:
+                elif isinstance(space, tuple) and len(space) == 2:
                     # Convert range to discrete list for grid search
                     low, high = space
                     if isinstance(low, int) and isinstance(high, int):

src/hyperactive/opt/random_search.py

@@ -178,7 +178,7 @@ def _check_param_distributions(self, param_distributions):
                 if isinstance(v, np.ndarray) and v.ndim > 1:
                     raise ValueError("Parameter array should be one-dimensional.")
 
-                if isinstance(v, str) or not isinstance(v, (np.ndarray, Sequence)):
+                if isinstance(v, str) or not isinstance(v, np.ndarray | Sequence):
                     raise ValueError(
                         f"Parameter distribution for ({name}) must be a list, numpy "
                         f"array, or scipy.stats ``rv_frozen``, but got ({type(v)})."

src/hyperactive/tests/test_search_space_adapter.py

@@ -182,7 +182,11 @@ def test_multiple_categorical_dimensions(self):
 
         assert encoded == {"kernel": [0, 1], "solver": [0, 1, 2]}
         assert adapter.categorical_mapping["kernel"] == {0: "rbf", 1: "linear"}
-        assert adapter.categorical_mapping["solver"] == {0: "lbfgs", 1: "sgd", 2: "adam"}
+        assert adapter.categorical_mapping["solver"] == {
+            0: "lbfgs",
+            1: "sgd",
+            2: "adam",
+        }
 
         decoded = adapter.decode({"kernel": 0, "solver": 2})
         assert decoded == {"kernel": "rbf", "solver": "adam"}
@@ -228,7 +232,9 @@ def test_validate_continuous_too_few_values_raises(self):
 
     def test_validate_continuous_too_many_values_raises(self):
         """Continuous tuple with > 4 values raises ValueError."""
-        adapter = SearchSpaceAdapter({"C": (0.1, 10, 50, "log", "extra")}, capabilities={})
+        adapter = SearchSpaceAdapter(
+            {"C": (0.1, 10, 50, "log", "extra")}, capabilities={}
+        )
 
         with pytest.raises(ValueError, match="too many values"):
             adapter.validate()
@@ -280,7 +286,7 @@ class TestContinuousDiscretization:
 
     def test_discretize_linear_default_points(self):
         """Linear discretization with default 100 points."""
-        np = pytest.importorskip("numpy")
+        pytest.importorskip("numpy")
 
         space = {"C": (0.1, 10.0)}
         adapter = SearchSpaceAdapter(space, capabilities={"continuous": False})
@@ -295,7 +301,7 @@ def test_discretize_linear_default_points(self):
 
     def test_discretize_log_scale(self):
         """Log scale discretization."""
-        np = pytest.importorskip("numpy")
+        pytest.importorskip("numpy")
 
         space = {"lr": (1e-5, 1e-1, "log")}
         adapter = SearchSpaceAdapter(space, capabilities={"continuous": False})

src/hyperactive/tests/test_unified_search_space.py

@@ -17,7 +17,7 @@ def sklearn_experiment():
 
 @pytest.fixture
 def simple_search_space():
-    """Simple unified search space format: dict[str, list]."""
+    """Provide unified search space format: dict[str, list]."""
     return {"C": [0.1, 1, 10], "gamma": [0.01, 0.1, 1]}
 
 
@@ -202,7 +202,9 @@ def test_gfo_capability_tags(self):
         opt = RandomSearch.create_test_instance()
 
         assert opt.get_tag("capability:discrete") is True
-        assert opt.get_tag("capability:continuous") is False  # GFO needs lists, not tuples
+        assert (
+            opt.get_tag("capability:continuous") is False
+        )  # GFO needs lists, not tuples
         assert opt.get_tag("capability:categorical") is False  # GFO only numeric
         assert opt.get_tag("capability:constraints") is True
 
@@ -272,7 +274,7 @@ def categorical_search_space(self):
 
     @pytest.fixture
     def function_experiment(self):
-        """Simple function experiment for fast testing."""
+        """Create function experiment for fast testing."""
         from hyperactive.experiment.func import FunctionExperiment
 
         def objective(params):
@@ -388,20 +390,20 @@ def mixed_search_space(self):
 
     @pytest.fixture
     def continuous_function_experiment(self):
-        """Simple function experiment for continuous optimization."""
+        """Create function experiment for continuous optimization."""
         from hyperactive.experiment.func import FunctionExperiment
 
         def objective(params):
             # Simple objective: maximize when x and y are in middle of range
             x = params["x"]
             y = params["y"]
-            return -(x - 5.0) ** 2 - (y - 0.01) ** 2
+            return -((x - 5.0) ** 2) - (y - 0.01) ** 2
 
         return FunctionExperiment(objective)
 
     @pytest.fixture
     def mixed_function_experiment(self):
-        """Function experiment for mixed search space."""
+        """Create function experiment for mixed search space."""
         from hyperactive.experiment.func import FunctionExperiment
 
         def objective(params):