First edition removing hyperparameter from DAG

pyproject.toml

@@ -172,6 +172,7 @@ select = [
 
 ignore = [
   "T201",    # TODO: Remove
+  "COM812",  # Causes issues with ruff formatter
   "D100",
   "D104",    # Missing docstring in public package
   "D105",    # Missing docstring in magic mthod

src/ConfigSpace/__init__.py

@@ -85,51 +85,51 @@
 )
 
 __all__ = [
-    "__authors__",
-    "__version__",
-    "Configuration",
-    "ConfigurationSpace",
-    "CategoricalHyperparameter",
-    "UniformFloatHyperparameter",
-    "UniformIntegerHyperparameter",
+    "ActiveHyperparameterNotSetError",
+    "AmbiguousConditionError",
+    "AndConjunction",
+    "Beta",
     "BetaFloatHyperparameter",
     "BetaIntegerHyperparameter",
-    "NormalFloatHyperparameter",
-    "NormalIntegerHyperparameter",
+    "Categorical",
+    "CategoricalHyperparameter",
+    "ChildNotFoundError",
+    "Configuration",
+    "ConfigurationSpace",
     "Constant",
-    "UnParametrizedHyperparameter",
-    "OrdinalHyperparameter",
-    "AndConjunction",
-    "OrConjunction",
+    "CyclicDependancyError",
+    "Distribution",
     "EqualsCondition",
-    "NotEqualsCondition",
-    "InCondition",
-    "GreaterThanCondition",
-    "LessThanCondition",
+    "Float",
     "ForbiddenAndConjunction",
     "ForbiddenEqualsClause",
-    "ForbiddenInClause",
-    "ForbiddenLessThanRelation",
     "ForbiddenEqualsRelation",
     "ForbiddenGreaterThanRelation",
-    "Beta",
-    "Categorical",
-    "Distribution",
-    "Float",
+    "ForbiddenInClause",
+    "ForbiddenLessThanRelation",
+    "ForbiddenValueError",
+    "GreaterThanCondition",
+    "HyperparameterAlreadyExistsError",
+    "HyperparameterIndexError",
+    "HyperparameterNotFoundError",
+    "IllegalValueError",
+    "InCondition",
+    "InactiveHyperparameterSetError",
     "Integer",
+    "LessThanCondition",
     "Normal",
+    "NormalFloatHyperparameter",
+    "NormalIntegerHyperparameter",
+    "NotEqualsCondition",
+    "OrConjunction",
+    "OrdinalHyperparameter",
+    "ParentNotFoundError",
+    "UnParametrizedHyperparameter",
     "Uniform",
+    "UniformFloatHyperparameter",
+    "UniformIntegerHyperparameter",
+    "__authors__",
+    "__version__",
     "distributions",
     "types",
-    "ForbiddenValueError",
-    "IllegalValueError",
-    "ActiveHyperparameterNotSetError",
-    "InactiveHyperparameterSetError",
-    "HyperparameterNotFoundError",
-    "ChildNotFoundError",
-    "ParentNotFoundError",
-    "HyperparameterIndexError",
-    "AmbiguousConditionError",
-    "HyperparameterAlreadyExistsError",
-    "CyclicDependancyError",
 ]

src/ConfigSpace/_condition_tree.py

@@ -41,7 +41,7 @@
 import numpy as np
 from more_itertools import unique_everseen
 
-from ConfigSpace.conditions import Condition, Conjunction
+from ConfigSpace.conditions import Condition, ConditionLike, Conjunction
 from ConfigSpace.exceptions import (
     AmbiguousConditionError,
     ChildNotFoundError,
@@ -62,7 +62,6 @@
 from ConfigSpace.types import f64
 
 if TYPE_CHECKING:
-    from ConfigSpace.conditions import ConditionLike
     from ConfigSpace.hyperparameters import Hyperparameter
     from ConfigSpace.types import Array
 
@@ -658,6 +657,107 @@ def add(self, hp: Hyperparameter) -> None:
         self.nodes[hp.name] = node
         self.roots[hp.name] = node
 
+    def remove(self, value: Hyperparameter) -> None:
+        """Remove a hyperparameter from the DAG."""
+        if not self._updating:
+            raise RuntimeError(
+                "Cannot remove hyperparameters outside of transaction."
+                "Please use `remove` inside `with dag.transaction():`",
+            )
+
+        existing = self.nodes.get(value.name, None)
+        if existing is None:
+            raise HyperparameterNotFoundError(
+                f"Hyperparameter '{value.name}' does not exist in space.",
+            )
+
+        # Update each condition containing this hyperparameter
+        def remove_hyperparameter_from_condition(
+            target: Conjunction | Condition | ForbiddenRelation | ForbiddenClause,
+        ) -> (
+            Conjunction
+            | Condition
+            | ForbiddenClause
+            | ForbiddenRelation
+            | ForbiddenConjunction
+            | None
+        ):
+            if isinstance(target, ForbiddenRelation) and (
+                value in (target.left, target.right)
+            ):
+                return None
+            if isinstance(target, ForbiddenClause) and target.hyperparameter == value:
+                return None
+            if isinstance(target, Condition) and (
+                value in (target.parent, target.child)
+            ):
+                return None
+            if isinstance(target, (Conjunction, ForbiddenConjunction)):
+                new_components = []
+                for component in target.components:
+                    new_component = remove_hyperparameter_from_condition(component)
+                    if new_component is not None:
+                        new_components.append(new_component)
+                if len(new_components) >= 2:  # Can create a conjunction
+                    return type(target)(*new_components)
+                if len(new_components) == 1:  # Only one component remains
+                    return new_components[0]
+                return None  # No components remain
+            return target  # Nothing to change
+
+        # Update each of the forbiddens containing this hyperparameter
+        for findex, forbidden in enumerate(self.unconditional_forbiddens):
+            self.unconditional_forbiddens[findex] = (
+                remove_hyperparameter_from_condition(forbidden)
+            )
+        for findex, forbidden in enumerate(self.conditional_forbiddens):
+            self.conditional_forbiddens[findex] = remove_hyperparameter_from_condition(
+                forbidden
+            )
+        # Filter None values from the forbiddens
+        self.unconditional_forbiddens = [
+            f for f in self.unconditional_forbiddens if f is not None
+        ]
+        self.conditional_forbiddens = [
+            f for f in self.conditional_forbiddens if f is not None
+        ]
+
+        for node in self.nodes.values():
+            if node.parent_condition is None:
+                continue
+            node.parent_condition = remove_hyperparameter_from_condition(
+                node.parent_condition
+            )
+
+        self.nodes.pop(value.name)
+        for child, _ in existing.children.values():
+            del child.parents[existing.name]
+
+        # Recalculate the depth of the children
+        def mark_children_recursively(node: HPNode, marked: set[str]):
+            for child, _ in node.children.values():
+                if child.maximum_depth == node.maximum_depth + 1:
+                    marked.add(child.name)
+                    mark_children_recursively(child, marked)
+
+        marked_nodes: set[str] = set()
+        mark_children_recursively(existing, marked_nodes)
+        while marked_nodes:  # Update the maximum depth of the marked nodes
+            remove = []
+            for node_name in marked_nodes:
+                node = self.nodes.get(node_name)
+                if not node.parents:
+                    node.maximum_depth = 0
+                    remove.append(node_name)
+                elif all(p.name not in marked_nodes for p, _ in node.parents.values()):
+                    node.maximum_depth = (
+                        max(parent.maximum_depth for parent, _ in node.parents.values())
+                        + 1
+                    )
+                    remove.append(node_name)
+            for node_name in remove:
+                marked_nodes.remove(node_name)
+
     def add_condition(self, condition: ConditionLike) -> None:
         """Add a condition to the DAG."""
         if not self._updating:
@@ -782,8 +882,7 @@ def _minimum_conditions(self) -> list[ConditionNode]:
         # i.e. two hyperparameters both rely on algorithm == "A"
         base_conditions: dict[int, ConditionNode] = {}
         for node in self.nodes.values():
-            # This node has no parent as is a root
-            if node.parent_condition is None:
+            if node.parent_condition is None:  # This node has no parent as it is a root node
                 assert node.name in self.roots
                 continue
 

src/ConfigSpace/api/__init__.py

@@ -3,13 +3,13 @@
 from ConfigSpace.api.types import Categorical, Float, Integer
 
 __all__ = [
-    "types",
-    "distributions",
     "Beta",
-    "Distribution",
-    "Normal",
-    "Uniform",
     "Categorical",
+    "Distribution",
     "Float",
     "Integer",
+    "Normal",
+    "Uniform",
+    "distributions",
+    "types",
 ]

src/ConfigSpace/configuration.py

@@ -73,10 +73,10 @@ def __init__(
                 ConfigSpace package.
         """
         if (
-            values is not None
-            and vector is not None
-            or values is None
-            and vector is None
+            (values is not None
+            and vector is not None)
+            or (values is None
+            and vector is None)
         ):
             raise ValueError(
                 "Specify Configuration as either a dictionary or a vector.",

src/ConfigSpace/configuration_space.py

@@ -350,6 +350,38 @@ def _put_to_list(
         self._len = len(self._dag.nodes)
         self._check_default_configuration()
 
+    def remove(
+        self,
+        *args: Hyperparameter,
+    ) -> None:
+        """Remove a hyperparameter from the configuration space.
+
+        If the hyperparameter has children, the children are also removed.
+        This includes defined conditions and conjunctions!
+
+        !!! note
+
+        If removing multiple hyperparameters, it is better to remove them all
+        at once with one call to `remove()`, as we rebuilt a cache after each
+        call to `remove()`.
+
+        Args:
+            args: Hyperparameter(s) to remove
+        """
+        hps = []
+        for arg in args:
+            if isinstance(arg, Hyperparameter):
+                hps.append(arg)
+            else:
+                raise TypeError(f"Unknown type {type(arg)}")
+
+        with self._dag.update():
+            for hp in hps:
+                self._dag.remove(hp)
+
+        self._len = len(self._dag.nodes)
+        self._check_default_configuration()
+
     def add_configuration_space(
         self,
         prefix: str,
@@ -878,7 +910,7 @@ def __iter__(self) -> Iterator[str]:
         return iter(self._dag.nodes.keys())
 
     def items(self) -> ItemsView[str, Hyperparameter]:
-        """Return an items view of the hyperparameters, same as `dict.items()`."""  # noqa: D402
+        """Return an items view of the hyperparameters, same as `dict.items()`."""
         return {name: node.hp for name, node in self._dag.nodes.items()}.items()
 
     def __len__(self) -> int:

src/ConfigSpace/hyperparameters/__init__.py

@@ -24,7 +24,7 @@
     "NormalIntegerHyperparameter",
     "NumericalHyperparameter",
     "OrdinalHyperparameter",
+    "UnParametrizedHyperparameter",
     "UniformFloatHyperparameter",
     "UniformIntegerHyperparameter",
-    "UnParametrizedHyperparameter",
 ]

src/ConfigSpace/read_and_write/dictionary.py

@@ -56,7 +56,7 @@ def _backwards_compat(item: dict[str, Any]) -> dict[str, Any]:
         )
     if (default := item.pop("default", None)) is not None:
         warnings.warn(
-            "The field 'default' should be 'default_value' !" f"\nFound in item {item}",
+            f"The field 'default' should be 'default_value' !\nFound in item {item}",
             stacklevel=3,
         )
         item["default_value"] = default