fix(gooddata-eval): guard out-of-range date offsets and share one scoring anchor

Two defects in relative-date scoring, both found in review of this PR.

An offset far enough out to leave the representable date range raised out of
_absolute_span instead of resolving. Every granularity can be pushed past it: a
YEAR offset of -today.year lands on year 0, large DAY/WEEK_US offsets exceed
timedelta's magnitude limit, and large MONTH/QUARTER offsets leave 1..9999. The
exception escaped through _normalize_date_filter and check_filters, failing the
whole item over one malformed filter. It now resolves to None, putting the
filter back on the literal-comparison path an unresolvable span already takes.

Separately, check_filters shared one anchor across its two sides, but the
evaluator resolved the filters it reports through separate normalized_filters
calls, each taking its own date.today(). A run straddling midnight could report
periods the verdict was never computed from -- a detail contradicting its own
score. The anchor is now captured once in _evaluate_visualization and passed to
check_filters and both normalized_filters calls; _evaluate_against_candidates
captures one too, so candidates are never ranked on spans from different days.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: Tomkess

packages/gooddata-eval/src/gooddata_eval/core/evaluators/visualization.py

@@ -2,6 +2,7 @@
 """Agentic visualization evaluator — ported from gdc-nas tavern-e2e app/vis_agentic.py."""
 
 from dataclasses import dataclass
+from datetime import date
 
 from gooddata_eval.core.evaluators.base import ItemEvaluation
 from gooddata_eval.core.models import (
@@ -85,7 +86,13 @@ def _evaluate_visualization(
     expected: CreatedVisualization,
     actual: CreatedVisualization | None,
     skill_activated: bool = False,
+    today: date | None = None,
 ) -> EvaluationResult:
+    # One anchor for the scoring and for the filters reported beside it. check_filters
+    # already shares an anchor across its two sides, but resolving the reported filters
+    # separately would let a run that straddles midnight report periods the score was
+    # never computed from -- a detail that contradicts its own verdict.
+    today = today or date.today()
     exp_metric_uris = get_metric_uri_set(expected)
     exp_dim_uris = get_dimension_uri_set(expected)
     if actual is None:
@@ -105,13 +112,13 @@ def _evaluate_visualization(
             actual_metric_uris=set(),
             expected_dim_uris=exp_dim_uris,
             actual_dim_uris=set(),
-            expected_filters=normalized_filters(expected),
+            expected_filters=normalized_filters(expected, today),
             actual_filters={category: values.copy() for category, values in _NO_FILTERS.items()},
         )
     cross_ref_valid, cross_ref_errors = validate_cross_references(actual)
     act_metric_uris = get_metric_uri_set(actual)
     act_dim_uris = get_dimension_uri_set(actual)
-    filter_scores = check_filters(expected, actual)
+    filter_scores = check_filters(expected, actual, today)
     return EvaluationResult(
         visualization_created=True,
         cross_ref_valid=cross_ref_valid,
@@ -128,17 +135,21 @@ def _evaluate_visualization(
         actual_metric_uris=act_metric_uris,
         expected_dim_uris=exp_dim_uris,
         actual_dim_uris=act_dim_uris,
-        expected_filters=normalized_filters(expected),
-        actual_filters=normalized_filters(actual),
+        expected_filters=normalized_filters(expected, today),
+        actual_filters=normalized_filters(actual, today),
     )
 
 
 def _evaluate_against_candidates(
     expected_outputs: list[CreatedVisualization],
     actual: CreatedVisualization | None,
     skill_activated: bool = False,
+    today: date | None = None,
 ) -> tuple[EvaluationResult, CreatedVisualization]:
-    pairs = [(_evaluate_visualization(exp, actual, skill_activated), exp) for exp in expected_outputs]
+    # Anchored once here too: the candidates are ranked against each other, so letting
+    # each resolve its own today could rank them on spans from different days.
+    today = today or date.today()
+    pairs = [(_evaluate_visualization(exp, actual, skill_activated, today), exp) for exp in expected_outputs]
     best_result, best_expected = max(pairs, key=lambda p: (p[0].strict_pass, p[0].strict_checks_passed_count))
     return best_result, best_expected
 

packages/gooddata-eval/src/gooddata_eval/core/scoring.py

@@ -122,21 +122,30 @@ def _absolute_span(granularity: str, start_offset: int, end_offset: int, today:
     ``WEEK``, which is not in the AAC granularity enum and states no start-of-week
     convention. ``WEEK_US`` *is* well defined (Sunday-start), so it resolves.
     Guessing the bare case would trade a false negative for a false positive.
+
+    An offset far enough out to leave the representable date range resolves to None
+    rather than raising: every granularity here can be pushed past it (a YEAR offset of
+    ``-today.year`` alone lands on year 0), and letting that escape would abort scoring
+    for the whole item over one malformed filter. None puts the filter back on the
+    literal-comparison path, which is what an unresolvable span already does.
     """
     gran = granularity.upper()
-    if gran == "DAY":
-        return today + timedelta(days=start_offset), today + timedelta(days=end_offset)
-    if gran == "WEEK_US":
-        sunday = today - timedelta(days=(today.weekday() + 1) % 7)
-        return sunday + timedelta(weeks=start_offset), sunday + timedelta(weeks=end_offset, days=6)
-    if gran == "MONTH":
-        return _shift_month(today, start_offset)[0], _shift_month(today, end_offset)[1]
-    if gran == "QUARTER":
-        q_start_month = (today.month - 1) // 3 * 3 + 1
-        anchor = date(today.year, q_start_month, 1)
-        return _shift_month(anchor, start_offset * 3)[0], _shift_month(anchor, end_offset * 3 + 2)[1]
-    if gran == "YEAR":
-        return date(today.year + start_offset, 1, 1), date(today.year + end_offset, 12, 31)
+    try:
+        if gran == "DAY":
+            return today + timedelta(days=start_offset), today + timedelta(days=end_offset)
+        if gran == "WEEK_US":
+            sunday = today - timedelta(days=(today.weekday() + 1) % 7)
+            return sunday + timedelta(weeks=start_offset), sunday + timedelta(weeks=end_offset, days=6)
+        if gran == "MONTH":
+            return _shift_month(today, start_offset)[0], _shift_month(today, end_offset)[1]
+        if gran == "QUARTER":
+            q_start_month = (today.month - 1) // 3 * 3 + 1
+            anchor = date(today.year, q_start_month, 1)
+            return _shift_month(anchor, start_offset * 3)[0], _shift_month(anchor, end_offset * 3 + 2)[1]
+        if gran == "YEAR":
+            return date(today.year + start_offset, 1, 1), date(today.year + end_offset, 12, 31)
+    except (ValueError, OverflowError):
+        return None
     return None
 
 

packages/gooddata-eval/tests/test_scoring.py

@@ -1,6 +1,7 @@
 # (C) 2026 GoodData Corporation
 from datetime import date
 
+import pytest
 from gooddata_eval.core.models import CreatedVisualization
 from gooddata_eval.core.scoring import (
     check_filters,
@@ -270,3 +271,26 @@ def test_check_filters_date_still_distinguishes_the_dataset_it_hangs_off():
     expected = _date_viz(**{"from": -1, "to": -1, "granularity": "MONTH"})
     actual = _date_viz(using="dataset/dt_date", **{"from": -1, "to": -1, "granularity": "MONTH"})
     assert check_filters(expected, actual, _TODAY).date_ok is False
+
+
+@pytest.mark.parametrize(
+    ("granularity", "offset"),
+    [
+        ("YEAR", -_TODAY.year),  # lands on year 0
+        ("DAY", -(10**9)),  # past timedelta's magnitude limit
+        ("WEEK_US", -(10**8)),
+        ("MONTH", -30000),
+        ("QUARTER", -10000),
+    ],
+)
+def test_check_filters_out_of_range_offsets_fall_back_instead_of_raising(granularity, offset):
+    """An offset outside the representable date range must not abort scoring.
+
+    Every granularity can be pushed past date's 1..9999 year range (or timedelta's
+    magnitude limit). Letting the ValueError/OverflowError escape would fail the whole
+    item on one malformed filter, so the span resolves to None and the filter goes back
+    to literal comparison -- which still matches an identically malformed expectation.
+    """
+    expected = _date_viz(**{"from": offset, "to": 0, "granularity": granularity})
+    assert check_filters(expected, _date_viz(**{"from": offset, "to": 0, "granularity": granularity}), _TODAY).date_ok
+    assert not check_filters(expected, _date_viz(**{"from": -1, "to": -1, "granularity": "MONTH"}), _TODAY).date_ok

packages/gooddata-eval/tests/test_visualization_evaluator.py

@@ -1,8 +1,10 @@
 # (C) 2026 GoodData Corporation
 import re
+from datetime import date
 
 from gooddata_eval.core.evaluators import get_evaluator
-from gooddata_eval.core.models import ChatResult, DatasetItem
+from gooddata_eval.core.evaluators.visualization import _evaluate_visualization
+from gooddata_eval.core.models import ChatResult, CreatedVisualization, DatasetItem
 
 
 def _item(expected_viz) -> DatasetItem:
@@ -175,3 +177,35 @@ def test_detail_filters_are_empty_when_no_visualization_was_created():
     result = ev.evaluate(_item(_dated("MONTH", -11, 0)), empty)
     assert result.detail["actual_filters"] == {"date": [], "ranking": [], "attribute": []}
     assert len(result.detail["expected_filters"]["date"]) == 1
+
+
+def _date_filtered_viz():
+    return {
+        "id": "x",
+        "type": "table",
+        "query": {
+            "fields": {"m_rev": {"using": "metric/revenue"}},
+            "filter_by": {
+                "f": {"type": "date_filter", "using": "dataset/dt", "from": -1, "to": -1, "granularity": "MONTH"}
+            },
+        },
+        "metrics": ["m_rev"],
+    }
+
+
+def test_reported_filters_use_the_same_date_anchor_as_the_score():
+    """The filters reported in detail must be resolved against the anchor the score used.
+
+    check_filters shares one anchor across its two sides, but the reported filters were
+    resolved by separate normalized_filters calls, each taking its own date.today(). A run
+    straddling midnight could therefore report periods the verdict was never computed from.
+    Pinning an explicit anchor here fails unless it reaches every one of those calls.
+    """
+    viz = CreatedVisualization.model_validate(_date_filtered_viz())
+    result = _evaluate_visualization(viz, viz, today=date(2026, 3, 15))
+
+    # -1 MONTH from 2026-03-15 is February 2026, not whatever month the suite runs in.
+    assert result.filter_date_score is True
+    assert '"from": "2026-02-01"' in result.expected_filters["date"][0]
+    assert '"to": "2026-02-28"' in result.expected_filters["date"][0]
+    assert result.expected_filters["date"] == result.actual_filters["date"]