Fix what the review found, and teach the audit about inheritance

Five real findings, one of them hiding the others.

**A search needs a tuner, not only a target.** Both evaluation strategies
guarded on `self.optimizer and self.run_optimizable_parameters`; the units kept
only the second half. `Run.optimizer_name` is a plain string and the wizard
leaves it empty when no search is asked for, while the model may still declare
a parameter optimizable -- a combination that has always meant "fit it once
with the values given". It had become a lookup of the empty string in the
registry, surfacing as "Metric is not compatible with the Task. ''", a message
with nothing to do with what happened. Reproduced, fixed with a shared
`_will_search`, and pinned by a test.

**The nested unit was not being audited at all.** `_unit_class` matched only
classes whose direct base is literally `BaseUnit`, so a unit that extends
another unit fell out of every contract check -- and would have failed them,
because its PROVIDES are written by the parent's body rather than its own. It
is the same blindness a shared helper causes, arriving by inheritance instead:
the audit reads one class's source. It now follows the lineage for
declarations, context calls and config reads. 32 audited units became 33.

**The inner splitter was resolved unconditionally**, so a run still carrying a
nested configuration it no longer uses failed on a splitter it would never have
touched.

**The fold branch hardcoded `splits=["TEST"]`** where the holdout branch derives
it from SCORED_SPLITS. Latent today -- no strategy excludes TEST -- but it is
exactly the coupling this work exists to remove.

And a docstring describing `{split: [scores]}` for something shaped
`{split: {metric: [scores]}}`.

Two findings were left alone, deliberately. `best_parameters` is published
without being in PROVIDES, which is the already-declared limitation that there
is no way to express an optional output; the new units repeat it rather than
inventing an exception to it. And per-fold progress reporting is gone, which is
a real regression: restoring it needs a callback in a unit's contract, and a
runtime parameter the engine cannot supply makes the unit unusable as a node --
the static validator rejects it. Both are recorded rather than patched over.

Whole suite: 3692 passed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: Felipedino

DashAI/back/job/model_job.py

@@ -294,7 +294,7 @@ def run(
                         # uses. Whether there is anything to score is the
                         # caller's to know: a session that reserved nothing
                         # leaves that partition empty rather than absent.
-                        if len(x[-1]["test"]) > 0:
+                        if "TEST" in scored_splits and len(x[-1]["test"]) > 0:
                             EvaluateModelUnit(run_id=run_id, splits=["TEST"])(ctx)
                 except Exception as e:
                     log.exception(e)

DashAI/back/units/fit_model_over_folds_unit.py

@@ -96,7 +96,7 @@ def execute(self, ctx: ExecutionContext) -> None:
 
         plot_paths = []
         try:
-            if optimizable_parameters:
+            if self._will_search(optimizable_parameters):
                 # Every read of the context happens in this file rather than in
                 # the shared helper: the contract audit parses it, so a require
                 # moved out makes a declared key look unread.
@@ -221,9 +221,10 @@ def _score_every_fold(self, model, x_folds, y_folds) -> dict:
         Returns
         -------
         dict
-            ``{split name: [one score per fold]}``, in fold order, for whoever
-            aggregates them. A split with no metrics configured is absent
-            rather than present and empty: the two are different statements.
+            ``{split name: {metric name: [one score per fold]}}``, in fold
+            order, for whoever aggregates them. A split with no metrics
+            configured is absent rather than present and empty: the two are
+            different statements.
         """
         scored_splits = self.config.get("scored_splits", TRIAL_SPLITS)
         fold_metrics: dict = {}

DashAI/back/units/fit_model_over_nested_folds_unit.py

@@ -102,11 +102,13 @@ def execute(self, ctx: ExecutionContext) -> None:
         y_folds = ctx.require("y_folds")
         optimizable_parameters = ctx.require("optimizable_parameters")
 
-        # Resolved outside the wrapper below so a splitter that cannot be built
-        # is reported as that, rather than as a training failure.
-        inner_splitter = self._resolve_inner_splitter()
-
-        if optimizable_parameters:
+        if self._will_search(optimizable_parameters):
+            # Resolved here and not at the top: a run with nothing to search
+            # never carves an outer fold, so a session left carrying a nested
+            # configuration it no longer uses must not fail on it. And resolved
+            # outside the wrapper below, so a splitter that cannot be built is
+            # reported as that rather than as a training failure.
+            inner_splitter = self._resolve_inner_splitter()
             try:
                 outer_fold_metrics = self._measure_every_outer_fold(
                     model,

DashAI/back/units/fit_model_unit.py

@@ -84,7 +84,7 @@ def execute(self, ctx: ExecutionContext) -> None:
 
         plot_paths = []
         try:
-            if not optimizable_parameters:
+            if not self._will_search(optimizable_parameters):
                 self._fit_kept_model(model, x, y)
             else:
                 # Every read of the context happens here rather than in the

DashAI/back/units/fit_scope.py

@@ -216,17 +216,31 @@ def _resolve_search(self):
         self._optimizer = optimizer
         return optimizer, goal_metric
 
+    def _will_search(self, optimizable_parameters) -> bool:
+        """Whether there is a search to run: something to tune, and a tuner.
+
+        Both halves are needed. A run can name no optimizer at all -- the
+        column is a plain string and the wizard leaves it empty when the user
+        does not ask for a search -- while the model still declares a parameter
+        as optimizable, and that combination has always meant "fit it once with
+        the values given". Checking only the parameters turns it into a lookup
+        of the empty string in the registry, which fails with a message about
+        the metric being incompatible with the task.
+        """
+        return bool(optimizable_parameters) and bool(
+            self.config["optimizer"]["component"]
+        )
+
     def _validate_search(self, optimizable_parameters) -> None:
         """Refuse an impossible search before anything observable happens.
 
         Handed the value rather than the context: the caller reads it with
         ``ctx.require`` and not ``ctx.get``, because an absent key means the
         model has not been built yet -- a call-order mistake, not "there is
-        nothing to optimize". Only an empty value, the key present and the
-        model declaring none, skips the checks below, so no registry lookup is
-        needed either.
+        nothing to optimize". A run with nothing to search skips the checks
+        below, so no registry lookup is needed either.
         """
-        if not optimizable_parameters:
+        if not self._will_search(optimizable_parameters):
             return
 
         self._resolve_search()

tests/back/units/test_fit_model_unit.py

@@ -379,3 +379,26 @@ def test_the_search_is_handed_the_units_own_objective(tmp_path):
     finally:
         del di["component_registry"]
         del di["config"]
+
+
+def test_a_run_with_no_optimizer_fits_once_even_if_a_parameter_is_optimizable():
+    """Both halves are needed to call something a search: a tuner and a target.
+
+    ``Run.optimizer_name`` is a plain string and the wizard leaves it empty when
+    the user does not ask for a search, while the model may still declare a
+    parameter as optimizable. That combination has always meant "fit it once
+    with the values given". Checking only the parameters turns it into a lookup
+    of the empty string in the registry, which surfaces as a complaint about
+    the metric being incompatible with the task -- a message with nothing to do
+    with what happened.
+    """
+    model = _RecordingModel()
+    ctx = _fit_context(model, _HOLDOUT, _HOLDOUT)
+    ctx.put("optimizable_parameters", [("obj", "C", (0, 1), "number")])
+
+    unit = _unit(optimizer_name="", goal_metric="")
+    unit.validate(ctx)
+    unit(ctx)
+
+    assert model.fits == [{"train": "x-train", "validation": "x-val"}]
+    assert not ctx.has("best_parameters")

tests/back/units/test_unit_contracts.py

@@ -34,26 +34,85 @@ def _string_literals(node):
     }
 
 
+def _all_classes():
+    """Every class defined under ``units/``, by name.
+
+    Built first so a unit that inherits from another unit can be resolved: the
+    audit reads source rather than importing, so a base class is just a name
+    until something maps it back to a definition.
+    """
+    classes = {}
+    for path in _unit_modules():
+        tree = ast.parse(path.read_text(encoding="utf-8"))
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                classes[node.name] = node
+    return classes
+
+
+_CLASSES = _all_classes()
+
+
+def _is_unit(node):
+    """A class deriving from ``BaseUnit``, directly or through another unit."""
+    for base in node.bases:
+        if not isinstance(base, ast.Name):
+            continue
+        if base.id == "BaseUnit":
+            return True
+        parent = _CLASSES.get(base.id)
+        if parent is not None and parent is not node and _is_unit(parent):
+            return True
+    return False
+
+
 def _unit_class(tree):
     for node in ast.walk(tree):
-        if isinstance(node, ast.ClassDef) and any(
-            isinstance(base, ast.Name) and base.id == "BaseUnit" for base in node.bases
-        ):
+        if isinstance(node, ast.ClassDef) and _is_unit(node):
             return node
     return None
 
 
+def _lineage(cls):
+    """The class and the units it inherits from, nearest first.
+
+    Everything below reads the whole lineage rather than one class body. A unit
+    that extends another one inherits both its declarations and the code that
+    honours them, so auditing only its own body would report that it promises
+    keys it never writes -- which is the same blindness a shared helper causes,
+    arriving by a different road.
+    """
+    chain = [cls]
+    for base in cls.bases:
+        if not isinstance(base, ast.Name):
+            continue
+        parent = _CLASSES.get(base.id)
+        if parent is not None and parent is not cls and _is_unit(parent):
+            chain.extend(_lineage(parent))
+    return chain
+
+
 def _declared(cls, name):
-    for node in cls.body:
-        if isinstance(node, ast.Assign) and any(
-            isinstance(t, ast.Name) and t.id == name for t in node.targets
-        ):
-            return _string_literals(node.value)
+    # Nearest declaration wins: a subclass that redeclares PROVIDES replaces
+    # what it inherited rather than adding to it, the way Python resolves it.
+    for ancestor in _lineage(cls):
+        for node in ancestor.body:
+            if isinstance(node, ast.Assign) and any(
+                isinstance(t, ast.Name) and t.id == name for t in node.targets
+            ):
+                return _string_literals(node.value)
     return set()
 
 
 def _context_calls(cls, methods):
-    """Every ``ctx.<method>("key")`` literal inside the class."""
+    """Every ``ctx.<method>("key")`` literal in the class and what it extends."""
+    keys = set()
+    for ancestor in _lineage(cls):
+        keys |= _context_calls_in(ancestor, methods)
+    return keys
+
+
+def _context_calls_in(cls, methods):
     keys = set()
     for node in ast.walk(cls):
         if (
@@ -302,6 +361,13 @@ def _schema_fields(tree):
 
 
 def _config_reads(cls):
+    reads = set()
+    for ancestor in _lineage(cls):
+        reads |= _config_reads_in(ancestor)
+    return reads
+
+
+def _config_reads_in(cls):
     """Every ``self.config["key"]`` and ``self.config.get("key")`` in the class."""
     keys = set()
     for node in ast.walk(cls):