gooddata-eval 1.78.1.dev1__py3-none-any.whl → 1.78.1.dev2__py3-none-any.whl

gooddata_eval/cli/agentic_runner.py

@@ -26,7 +26,7 @@ from gooddata_eval.core.agentic.visualization import evaluate_agentic_visualizat
 from gooddata_eval.core.agentic.what_if import evaluate_agentic_what_if
 from gooddata_eval.core.config import ReasoningEffort
 from gooddata_eval.core.evaluators._llm_judge import JudgeResponseError
-from gooddata_eval.core.evaluators.visualization import requires_execution_of
+from gooddata_eval.core.evaluators.visualization import expectation_options
 from gooddata_eval.core.models import AgenticEvalOutcome, CreatedVisualization, DatasetItem
 from gooddata_eval.core.runner import EvalReport, ItemReport
 from gooddata_eval.core.timing import TraceRecorder
@@ -119,6 +119,8 @@ def _parse_visualization_expected(expected_output: Any) -> list[CreatedVisualiza
       {"visualization": {...}} or {"visualization": [{...}]}  <- single/multi candidate
       [{"visualization": {...}}, ...]                          <- bare list
     """
+    if isinstance(expected_output, dict) and expected_output.get("expects_visualization") is False:
+        return []
     if isinstance(expected_output, dict):
         raw_list = expected_output.get("expected_outputs")
         if raw_list is not None:
@@ -187,7 +189,7 @@ def _dispatch_agentic(
             workspace_id=workspace_id,
             question=item.question,
             expected_outputs=_parse_visualization_expected(eo),
-            requires_execution=requires_execution_of(eo),
+            options=expectation_options(eo),
             k=k,
             gate=gate,
             agent_id=agent_id,

gooddata_eval/core/agentic/dashboard_skill.py

@@ -40,6 +40,7 @@ from gooddata_eval.core.models import (
     build_latency_breakdown,
     shift_and_index_events,
 )
+from gooddata_eval.core.scoring import AAC_VISUALIZATION_TYPES, same_viz_type
 from gooddata_eval.core.timing import PhaseTimings, log_timer, sum_timings
 
 _DEFAULT_K = 1
@@ -582,6 +583,64 @@ def _check_date_bindings(widgets: list[dict], new_ids: set[str], expected: list[
     return failures
 
 
+def _has_chart_types(expected_output: dict) -> bool:
+    """Whether any expected chart states the type it must be placed as."""
+    return any(isinstance(v, dict) and "chart_type" in v for v in expected_output.get("visualizations") or [])
+
+
+def _bodies_by_id(*references: dict) -> dict[str, dict]:
+    """Every chart body the response's references carry, existing and authored, by chart id."""
+    bodies: dict[str, dict] = {}
+    for refs in references:
+        for key in ("visualizations", "new_visualizations"):
+            for body in refs.get(key) or []:
+                if isinstance(body, dict) and body.get("id"):
+                    bodies[body["id"]] = body
+    return bodies
+
+
+def _check_chart_types(
+    widgets: list[dict], new_ids: set[str], expected: list[dict], bodies: dict[str, dict]
+) -> tuple[list[str], list[str]]:
+    """Every widget of a chart that states a ``chart_type`` must show a chart of exactly that type.
+
+    A widget names only the chart id, so the type is read from the chart body the references
+    carry. The title alone cannot catch a chart authored as another type than the one asked
+    for, which is the silent swap GDAI-2054 rules out.
+
+    Returns the failures and the notes. A widget whose chart has no body in the references
+    cannot be checked: gen-ai carries a body only when it could resolve one, so a missing
+    body is a platform fault, noted as ``_check_references`` notes a missing id, and not
+    scored as the agent's.
+    """
+    failures: list[str] = []
+    notes: list[str] = []
+    for exp in expected:
+        if not isinstance(exp, dict) or "chart_type" not in exp:
+            continue
+        wanted = exp["chart_type"]
+        label = exp.get("title") if exp.get("id") is None else exp.get("id")
+        candidates = _matching_widgets(widgets, new_ids, exp)
+        if not candidates:
+            failures.append(f"cannot check the type of chart {label!r}: it is not on the dashboard")
+            continue
+        types: list[str] = []
+        for widget in candidates:
+            chart_type = (bodies.get(widget.get("visualization")) or {}).get("type")
+            if isinstance(chart_type, str):
+                types.append(chart_type)
+            else:
+                notes.append(
+                    f"cannot check the type of chart {label!r}: the response's references carry no body "
+                    f"for {widget.get('visualization')!r}"
+                )
+        # Every placement, as for date bindings: one right placement must not hide a wrong one.
+        if not all(same_viz_type(wanted, t) for t in types):
+            found = ", ".join(repr(t) for t in types)
+            failures.append(f"chart {label!r} is {found}, expected {wanted!r}")
+    return failures, notes
+
+
 def _tabs_of(dashboard: dict) -> list[dict]:
     """The dashboard's tabs, reading a document with root sections as its single tab."""
     tabs = dashboard.get("tabs")
@@ -936,6 +995,12 @@ def _validate_layout_expectations(expected_output: dict) -> None:
     for chart in expected_output.get("visualizations") or []:
         if isinstance(chart, dict) and "date_dataset" in chart and not _is_dataset_or_null(chart["date_dataset"]):
             raise ValueError(f"date_dataset must name a date dataset or be null, got {chart!r}")
+        if (
+            isinstance(chart, dict)
+            and "chart_type" in chart
+            and (not isinstance(chart["chart_type"], str) or chart["chart_type"] not in AAC_VISUALIZATION_TYPES)
+        ):
+            raise ValueError(f"chart_type must be an AAC visualization type, got {chart!r}")
 
     if "tabs" in expected_output:
         tabs = expected_output["tabs"]
@@ -1037,6 +1102,7 @@ class _Applies:
     tab_filters: bool = False
     date_filters: bool = False
     preserved_widgets: bool = False
+    chart_types: bool = False
 
     @classmethod
     def of(cls, expected_output: dict) -> _Applies:
@@ -1049,6 +1115,7 @@ class _Applies:
             tab_filters="tab_filters" in expected_output,
             date_filters="date_filters" in expected_output,
             preserved_widgets="preserved_widgets" in expected_output,
+            chart_types=_has_chart_types(expected_output),
         )
 
 
@@ -1089,6 +1156,7 @@ class DashboardEvaluation:
     tab_filters_correct: bool = False
     date_filters_correct: bool = False
     widgets_preserved: bool = False
+    chart_types_correct: bool = False
     failures: list[str] = field(default_factory=list)
     notes: list[str] = field(default_factory=list)
 
@@ -1129,6 +1197,8 @@ class DashboardEvaluation:
             checks["dashboard_date_filters_correct"] = self.date_filters_correct
         if self.applies.preserved_widgets:
             checks["dashboard_widgets_preserved"] = self.widgets_preserved
+        if self.applies.chart_types:
+            checks["dashboard_chart_types_correct"] = self.chart_types_correct
         return checks
 
     @property
@@ -1280,12 +1350,14 @@ def evaluate_dashboard_response(
             | {v.get("id") for v in patch_references.get("visualizations") or [] if v.get("id")}
             | new_ids
         )
+        bodies = _bodies_by_id(base_references, patch_references)
     else:
         if actual_saved_id is not None:
             saved_failures.append(f"a new draft must not be saved yet, but it reports id {actual_saved_id!r}")
         document = base
         new_ids = {v.get("id") for v in base_references.get("new_visualizations") or [] if v.get("id")}
         known_ids = {v.get("id") for v in base_references.get("visualizations") or [] if v.get("id")} | new_ids
+        bodies = _bodies_by_id(base_references)
 
     if document is None:
         return DashboardEvaluation(
@@ -1337,6 +1409,11 @@ def evaluate_dashboard_response(
     preserved_failures = (
         _check_preserved_widgets(widgets, expected_output["preserved_widgets"]) if applies.preserved_widgets else []
     )
+    chart_type_failures, chart_type_notes = (
+        _check_chart_types(widgets, new_ids, expected_output.get("visualizations") or [], bodies)
+        if applies.chart_types
+        else ([], [])
+    )
 
     return DashboardEvaluation(
         drafted=True,
@@ -1356,6 +1433,7 @@ def evaluate_dashboard_response(
         tab_filters_correct=not tab_filter_failures,
         date_filters_correct=not date_filter_failures,
         widgets_preserved=not preserved_failures,
+        chart_types_correct=not chart_type_failures,
         failures=[
             *chart_failures,
             *saved_failures,
@@ -1366,9 +1444,10 @@ def evaluate_dashboard_response(
             *tab_filter_failures,
             *date_filter_failures,
             *preserved_failures,
+            *chart_type_failures,
             *new_failures,
         ],
-        notes=[*title_notes, *reference_notes],
+        notes=[*title_notes, *reference_notes, *chart_type_notes],
     )
 
 

gooddata_eval/core/agentic/visualization.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 import os
 import time
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 
 from gooddata_eval.core.agentic._failed_runs import build_failed_runs
 from gooddata_eval.core.agentic._gate import (
@@ -34,10 +34,12 @@ from gooddata_eval.core.chat.sse_client import ChatClient, ChatError
 from gooddata_eval.core.config import ReasoningEffort
 from gooddata_eval.core.evaluators.visualization import (
     EvaluationResult,
+    ExpectationOptions,
     _check_visualization_skill_activated,
     _evaluate_against_candidates,
     evaluation_result_detail,
     with_execution,
+    with_options,
 )
 from gooddata_eval.core.langfuse.item_scope import item_scope
 from gooddata_eval.core.models import (
@@ -64,7 +66,8 @@ class RunResult:
     conversation_id: str
     actual_output: CreatedVisualization | None
     eval_result: EvaluationResult
-    best_expected: CreatedVisualization
+    # None for an item that expects no chart.
+    best_expected: CreatedVisualization | None
     total_turns: int
     total_steps: int
     reasoning_steps: list[str] = field(default_factory=list)
@@ -76,6 +79,8 @@ class RunResult:
     exit_reason: LoopExit = LoopExit.BUDGET_EXHAUSTED
     # This run's own wall time, from just before its first chat call to the end of its scoring.
     run_latency_s: float = 0.0
+    # Everything the final turn said, which the answer patterns are matched against.
+    answer_text: str = ""
 
 
 @dataclass
@@ -196,8 +201,13 @@ def _execute_single_run(
     expected_outputs: list[CreatedVisualization],
     max_iterations: int = _DEFAULT_MAX_ITERATIONS,
     requires_execution: bool = False,
+    options: ExpectationOptions | None = None,
 ) -> RunResult:
     """Drive one full multi-turn conversation and evaluate the result."""
+    options = _effective_options(options, requires_execution)
+    one_turn = not options.expects_visualization or options.visualization_optional
+    if one_turn:
+        max_iterations = min(max_iterations, 1)
     total_turns = 0
     total_steps = 0
     all_tool_call_events: list[ToolCallEvent] = []
@@ -207,7 +217,8 @@ def _execute_single_run(
     turn_offset = 0.0  # each turn's call_ts/ts restarts near 0 -- shift by prior turns' wall time
     reasoning_index_offset = 0  # ditto for ReasoningStepEvent.index, which also restarts per turn
     tool_index_offset = 0  # ditto for ToolCallEvent.index
-    simulated_response_guide = expected_outputs[0]  # primary candidate guides the simulated user
+    # The primary candidate guides the simulated user. An item with no chart never replies.
+    simulated_response_guide = expected_outputs[0] if expected_outputs else None
 
     # Defaults to BUDGET_EXHAUSTED: every other exit assigns explicitly, so a loop that
     # simply runs out of range() is labelled correctly with no trailing else.
@@ -258,7 +269,11 @@ def _execute_single_run(
         if not response_text:
             exit_reason = LoopExit.AGENT_SILENT
             break
-        if iteration >= max_iterations - 1:
+        if one_turn:
+            # Answering without a chart is an outcome this item accepts.
+            exit_reason = LoopExit.SUCCESS
+            break
+        if iteration >= max_iterations - 1 or simulated_response_guide is None:
             break
 
         try:
@@ -288,7 +303,18 @@ def _execute_single_run(
         actual_output = current_result.created_visualizations.objects[0]
 
     eval_result, best_expected = _evaluate_against_candidates(expected_outputs, actual_output, skill_activated)
-    eval_result = with_execution(eval_result, all_tool_call_events, current_result.text_response, requires_execution)
+    eval_result = with_execution(
+        eval_result, all_tool_call_events, current_result.text_response, options.requires_execution
+    )
+    answer_text = render_answer_text(current_result)
+    eval_result = with_options(
+        eval_result,
+        options,
+        actual_output,
+        all_tool_call_events,
+        answer_text,
+        interrupted=exit_reason is LoopExit.CHAT_ERROR,
+    )
 
     return RunResult(
         conversation_id=conversation_id,
@@ -303,9 +329,16 @@ def _execute_single_run(
         reasoning_step_events=all_reasoning_step_events,
         exit_reason=exit_reason,
         run_latency_s=time.monotonic() - run_started,
+        answer_text=answer_text,
     )
 
 
+def _effective_options(options: ExpectationOptions | None, requires_execution: bool) -> ExpectationOptions:
+    """``options`` with the separate ``requires_execution`` argument folded in."""
+    options = options or ExpectationOptions()
+    return replace(options, requires_execution=True) if requires_execution else options
+
+
 def run_agentic_visualization(
     host: str,
     token: str,
@@ -319,6 +352,7 @@ def run_agentic_visualization(
     agent_id: str | None = None,
     user_context: dict | None = None,
     requires_execution: bool = False,
+    options: ExpectationOptions | None = None,
 ) -> AgenticRunSummary:
     """Run K independent conversations and return evaluation results.
 
@@ -328,7 +362,18 @@ def run_agentic_visualization(
     conversations created by this function are deleted on completion.
 
     ``requires_execution`` fails a run whose agent built the chart but never ran it.
+
+    Raises:
+        ValueError: ``expected_outputs`` and ``options.expects_visualization`` disagree. An
+            empty candidate list is only right for an item that expects no chart, and the
+            scorer would otherwise read the default ``expects_visualization`` and fail it.
     """
+    expects_visualization = (options or ExpectationOptions()).expects_visualization
+    if expects_visualization != bool(expected_outputs):
+        raise ValueError(
+            "expected_outputs must list the candidate charts unless options.expects_visualization is false, "
+            f"got {len(expected_outputs)} candidate(s) with expects_visualization={expects_visualization}"
+        )
     client = ChatClient(
         host=host,
         token=token,
@@ -343,7 +388,9 @@ def run_agentic_visualization(
         conv_id_0 = initial_conversation_id if initial_conversation_id is not None else client.create_conversation()
         try:
             run_results.append(
-                _execute_single_run(client, conv_id_0, question, expected_outputs, max_iterations, requires_execution)
+                _execute_single_run(
+                    client, conv_id_0, question, expected_outputs, max_iterations, requires_execution, options
+                )
             )
         finally:
             if initial_conversation_id is None:
@@ -353,7 +400,9 @@ def run_agentic_visualization(
             conv_id = client.create_conversation()
             try:
                 run_results.append(
-                    _execute_single_run(client, conv_id, question, expected_outputs, max_iterations, requires_execution)
+                    _execute_single_run(
+                        client, conv_id, question, expected_outputs, max_iterations, requires_execution, options
+                    )
                 )
             finally:
                 client.delete_conversation(conv_id)
@@ -393,6 +442,68 @@ def _run_detail(run: RunResult) -> dict:
     }
 
 
+def _strict_checks(ev: EvaluationResult) -> dict[str, bool]:
+    """The scores one run is gated on, by their Langfuse names.
+
+    An item that expects no chart is scored on that and on its answer only: the chart checks
+    would all read False and say nothing about it.
+    """
+    if ev.scored_without_chart:
+        checks = {"assertion-vis-no-chart": not ev.visualization_created}
+    else:
+        checks = {
+            "assertion-cross-ref-valid": ev.cross_ref_valid,
+            "assertion-vis-metric": ev.metrics_correct,
+            "assertion-vis-dimensions": ev.dimensions_correct,
+            "assertion-vis-filters": ev.filters_correct,
+            "assertion-vis-type": ev.viz_type_hard,
+        }
+        if ev.requires_execution:
+            checks["assertion-vis-executed"] = ev.executed
+        # Only when the expectation sorts: an item without a sort accepts any order, so the check
+        # would always read True and only dilute the quality score.
+        if ev.expected_sorts:
+            checks["assertion-vis-sort"] = ev.sorts_correct
+        if ev.buckets_correct is not None:
+            checks["assertion-vis-buckets"] = ev.buckets_correct
+        if ev.format_correct is not None:
+            checks["assertion-vis-format"] = ev.format_correct
+        if ev.part_present is not None:
+            checks["assertion-vis-part-present"] = ev.part_present
+    if ev.answer_correct is not None:
+        checks["assertion-vis-answer"] = ev.answer_correct
+    return checks
+
+
+def _options_lines(ev: EvaluationResult, answer_text: str) -> str:
+    """The item-level verdicts for the failure summary; only the ones the item asks for."""
+    lines = ""
+    if ev.scored_without_chart:
+        lines += f"  No Chart              : {not ev.visualization_created}\n"
+    if ev.answer_correct is not None:
+        lines += f"  Answer Correct        : {ev.answer_correct}\n"
+        lines += "".join(f"    {problem}\n" for problem in ev.answer_problems)
+        if ev.answer_problems:
+            lines += f"    answer   : {answer_text[:500]!r}\n"
+    if ev.format_correct is not None:
+        lines += f"  Format Correct        : {ev.format_correct}\n"
+        lines += "".join(f"    {problem}\n" for problem in ev.format_problems)
+    if ev.part_present is not None:
+        lines += f"  Part Present          : {ev.part_present}\n"
+    return lines
+
+
+def _buckets_line(ev: EvaluationResult) -> str:
+    """The bucket-by-bucket verdict for the failure summary, or "" when the item does not ask for it."""
+    lines = "".join(f"    {problem}\n" for problem in ev.metric_layout_problems)
+    if ev.buckets_correct is None:
+        return lines
+    lines += f"  Buckets Correct       : {ev.buckets_correct}\n"
+    if not ev.buckets_correct:
+        lines += f"    expected : {ev.expected_buckets}\n    actual   : {ev.actual_buckets}\n"
+    return lines
+
+
 def _filter_diff(category: str, ev: EvaluationResult) -> str:
     """Expected-vs-actual lines for one filter category, or "" when they matched.
 
@@ -426,6 +537,7 @@ def evaluate_agentic_visualization(
     submit_trace_link: SubmitTraceLink = run_trace_link_inline,
     user_context: dict | None = None,
     requires_execution: bool = False,
+    options: ExpectationOptions | None = None,
     gate: EvalGate = DEFAULT_GATE,
 ) -> AgenticEvalOutcome:
     """Run visualization evaluation, log to Langfuse, and raise VisualizationAssertionError on failure.
@@ -461,6 +573,7 @@ def evaluate_agentic_visualization(
             agent_id=agent_id,
             user_context=user_context,
             requires_execution=requires_execution,
+            options=options,
         )
 
     if langfuse is not None and dataset_item_id:
@@ -474,21 +587,12 @@ def evaluate_agentic_visualization(
             for run_idx, run in enumerate(summary.run_results):
                 pt = ctx.trace(run.conversation_id)
                 ev = run.eval_result
-                strict_checks = {
-                    "assertion-cross-ref-valid": ev.cross_ref_valid,
-                    "assertion-vis-metric": ev.metrics_correct,
-                    "assertion-vis-dimensions": ev.dimensions_correct,
-                    "assertion-vis-filters": ev.filters_correct,
-                    "assertion-vis-type": ev.viz_type_hard,
-                }
-                if ev.requires_execution:
-                    strict_checks["assertion-vis-executed"] = ev.executed
+                strict_checks = _strict_checks(ev)
                 with ctx.observe(pt, run_idx, conversation_id=run.conversation_id, output=strict_checks) as tid:
-                    ctx.score(tid, name="assertion-cross-ref-valid", value=ev.cross_ref_valid, data_type="BOOLEAN")
-                    ctx.score(tid, name="assertion-vis-metric", value=ev.metrics_correct, data_type="BOOLEAN")
-                    ctx.score(tid, name="assertion-vis-dimensions", value=ev.dimensions_correct, data_type="BOOLEAN")
-                    ctx.score(tid, name="assertion-vis-filters", value=ev.filters_correct, data_type="BOOLEAN")
-                    ctx.score(tid, name="assertion-vis-type", value=ev.viz_type_hard, data_type="BOOLEAN")
+                    for score_name, value in strict_checks.items():
+                        # Scored below on every item, gating or not.
+                        if score_name != "assertion-vis-executed":
+                            ctx.score(tid, name=score_name, value=value, data_type="BOOLEAN")
                     ctx.score(tid, name="skill_selection", value=ev.skill_activated, data_type="BOOLEAN")
                     # Scored on every item, gating or not, so the run rate is visible per model.
                     ctx.score(tid, name="assertion-vis-executed", value=ev.executed, data_type="BOOLEAN")
@@ -557,7 +661,11 @@ def evaluate_agentic_visualization(
         n = len(expected_outputs)
         candidate_note = f" (closest of {n} candidates)" if n > 1 else ""
         cross_ref_detail = (" → " + "; ".join(ev.cross_ref_errors)) if ev.cross_ref_errors else ""
-        expected_dump = best.best_expected.model_dump(exclude_none=True)
+        expected_dump = (
+            best.best_expected.model_dump(exclude_none=True)
+            if best.best_expected is not None
+            else {"expects_visualization": False}
+        )
         actual_dump = best.actual_output.model_dump(exclude_none=True) if best.actual_output else None
         exc = VisualizationAssertionError(
             "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
@@ -587,7 +695,9 @@ def evaluate_agentic_visualization(
             f"    attribute : {ev.filter_attribute_score}\n"
             f"{_filter_diff('attribute', ev)}"
             f"  Viz Type Hard         : {ev.viz_type_hard}\n"
+            f"{_buckets_line(ev)}"
             f"  Executed              : {ev.executed}{' (required)' if ev.requires_execution else ''}\n"
+            f"{_options_lines(ev, best.answer_text)}"
             f"  Stated Value Matches  : {ev.stated_value_matches} (reported only)\n"
             "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
         )

gooddata_eval/core/chat/sse_client.py

@@ -52,7 +52,7 @@ _METADATA_SYNC_MARKER = "METADATA_SYNC_IN_PROGRESS"
 _TURN_INCOMPLETE_REASONS: frozenset[str] = frozenset({"max_iterations", "max_tokens", "content_filter"})
 # Stands in for the `id` a persisted visualization would carry, on the fallback path
 # where the agent's create_adhoc_visualization call failed and only its arguments survive.
-_ADHOC_VIZ_ID = "adhoc-visualization-not-persisted"
+ADHOC_VIZ_ID = "adhoc-visualization-not-persisted"
 
 _KNOWN_PART_TYPES: frozenset[str] = frozenset(
     {
@@ -311,7 +311,8 @@ def _build_chat_result(acc: _SseAccumulator) -> ChatResult:
         # accessible). The last attempt is the agent's best answer.
         #
         # These are raw tool-call arguments, so they carry no `id` -- the server
-        # mints it. The sentinel marks the chart as never persisted. Logged because
+        # mints it. The sentinel marks the chart as never persisted, and goes last so
+        # that an `id` in the arguments cannot hide that. Logged because
         # a turn that called the tool and answered without a chart is otherwise
         # invisible: the user saw no chart either.
         _log.warning(
@@ -320,7 +321,7 @@ def _build_chat_result(acc: _SseAccumulator) -> ChatResult:
             len(acc.adhoc_viz_args),
         )
         payload["createdVisualizations"] = {
-            "objects": [{"id": _ADHOC_VIZ_ID, **acc.adhoc_viz_args[-1]}],
+            "objects": [{**acc.adhoc_viz_args[-1], "id": ADHOC_VIZ_ID}],
             "reasoning": "\n".join(acc.viz_reasoning_parts),
         }
     result = ChatResult.model_validate(payload)

gooddata_eval/core/dataset/from_insights.py

@@ -146,13 +146,14 @@ def list_ids(directory: Path) -> set[str]:
     return ids
 
 
-def aliases(bucket: list[AacBucketRef | str]) -> list[str]:
+def aliases(bucket: list[AacBucketRef | str] | list[AacBucketRef | str | None]) -> list[str]:
     """A bucket's field aliases.
 
     A bucket item is an alias, or an `AacBucketRef` carrying `format`, `axis`, `totals`
-    or `display_as` -- presentation, which nothing here or in the scorer reads.
+    or `display_as` -- presentation, which nothing here reads. A null metric only holds a
+    position and names no field.
     """
-    return [item if isinstance(item, str) else item.field for item in bucket]
+    return [item if isinstance(item, str) else item.field for item in bucket if item is not None]
 
 
 def _reject_unscorable(spec: CreatedVisualization) -> None:
@@ -164,7 +165,7 @@ def _reject_unscorable(spec: CreatedVisualization) -> None:
     field where `check_filters` never looks, and a repeater lists labels among its
     metrics. Teach the comparator about one and its line here can go.
     """
-    for alias in aliases(spec.metrics):
+    for alias in aliases(spec.metrics) + aliases(spec.size_by):
         field = spec.query.fields[alias]
         if isinstance(field, str):
             using, aggregated = field, False
@@ -257,9 +258,12 @@ def convert(viz: dict) -> CreatedVisualization:
     # scorer never reads them, so they do not belong in an expected output.
     spec.config = None
     spec.query.filter_by = _normalize_filters(spec.query.filter_by)
-    for bucket in ("metrics", "view_by", "segment_by", "columns", "rows"):
+    # A null metric holds a position: a bubble with no x measure is `[null, y]`, and dropping
+    # the null would move y onto the x axis.
+    spec.metrics = [None if item is None else aliases([item])[0] for item in spec.metrics]
+    for bucket in ("view_by", "segment_by", "columns", "rows", "size_by"):
         setattr(spec, bucket, aliases(getattr(spec, bucket)))
-    if not spec.metrics:
+    if not aliases(spec.metrics):
         raise Unsupported("no measures")
     _reject_unscorable(spec)
     return spec