gooddata-eval 1.71.1.dev2__py3-none-any.whl → 1.71.1.dev3__py3-none-any.whl

gooddata_eval/core/scoring.py

@@ -63,29 +63,46 @@ def uri_to_display_name(uri: str) -> str:
 
 
 def validate_cross_references(viz: CreatedVisualization) -> tuple[bool, list[str]]:
-    """Validate ranking-filter `using`/`attribute` resolve to correct URI prefixes."""
+    """Validate ranking-filter `using`/`attribute` resolve to correct URI prefixes.
+
+    Always returns `(ok, errors)` — a malformed filter produces an error entry, never an
+    exception. Anything unusable (None, empty, non-string) used to reach `.startswith()`
+    or `dict.get()` and blow up with AttributeError/TypeError mid-evaluation.
+
+    `using` is required by the AAC schema, `attribute` is optional (see
+    `_normalize_ranking_filter`), so an absent/None/empty `attribute` is accepted silently.
+    """
     errors: list[str] = []
     fields = viz.query.fields
     for filter_key, filter_dict in viz.query.filter_by.items():
         if filter_dict.get("type") != "ranking_filter":
             continue
-        using_val = filter_dict.get("using", "")
-        using_uri = _resolve_alias_to_uri(using_val, fields)
-        field_def = fields.get(using_val)
-        is_adhoc_agg = isinstance(field_def, AacQueryField) and bool(field_def.aggregation)
-        if not using_uri.startswith(("metric/", "fact/")) and not is_adhoc_agg:
-            errors.append(
-                f"ranking filter '{filter_key}': using='{using_val}' "
-                f"resolves to '{using_uri}' — expected a metric/ or fact/ URI"
-            )
-        if "attribute" in filter_dict:
-            attr_val = filter_dict["attribute"]
-            attr_uri = _resolve_alias_to_uri(attr_val, fields)
-            if not attr_uri.startswith(("label/", "attribute/")):
+        using_val = filter_dict.get("using")
+        if not isinstance(using_val, str) or not using_val:
+            errors.append(f"ranking filter '{filter_key}': using={using_val!r} — a metric/ or fact/ URI is required")
+        else:
+            using_uri = _resolve_alias_to_uri(using_val, fields)
+            field_def = fields.get(using_val)
+            is_adhoc_agg = isinstance(field_def, AacQueryField) and bool(field_def.aggregation)
+            if not using_uri.startswith(("metric/", "fact/")) and not is_adhoc_agg:
                 errors.append(
-                    f"ranking filter '{filter_key}': attribute='{attr_val}' "
-                    f"resolves to '{attr_uri}' — expected a label/ or attribute/ URI"
+                    f"ranking filter '{filter_key}': using='{using_val}' "
+                    f"resolves to '{using_uri}' — expected a metric/ or fact/ URI"
                 )
+        attr_val = filter_dict.get("attribute")
+        if attr_val is None or attr_val == "":
+            continue
+        if not isinstance(attr_val, str):
+            errors.append(
+                f"ranking filter '{filter_key}': attribute={attr_val!r} — expected a label/ or attribute/ URI"
+            )
+            continue
+        attr_uri = _resolve_alias_to_uri(attr_val, fields)
+        if not attr_uri.startswith(("label/", "attribute/")):
+            errors.append(
+                f"ranking filter '{filter_key}': attribute='{attr_val}' "
+                f"resolves to '{attr_uri}' — expected a label/ or attribute/ URI"
+            )
     return len(errors) == 0, errors
 
 
@@ -99,11 +116,43 @@ def _normalize_date_filter(filter_dict: dict, _fields: dict) -> dict:
     }
 
 
-def _normalize_ranking_filter(filter_dict: dict, fields: dict[str, AacQueryField | str]) -> dict:
+def _sole_dimension_uri(viz: CreatedVisualization) -> str | None:
+    """URI of the visualization's only dimension, or None when it has zero or several."""
+    dim_uris = get_dimension_uri_set(viz)
+    return next(iter(dim_uris)) if len(dim_uris) == 1 else None
+
+
+def _normalize_ranking_filter(
+    filter_dict: dict,
+    fields: dict[str, AacQueryField | str],
+    sole_dim_uri: str | None = None,
+) -> dict:
+    """Canonicalize a ranking filter so equivalent filters compare equal.
+
+    `attribute` is optional in the AAC schema (gen-ai models it as `NotRequired[str]` /
+    `str | None`), and when it is omitted AFM ranks over every dimension of the result. For a
+    single-dimension visualization that is exactly "rank by that one dimension", so an omitted
+    attribute is filled in with `sole_dim_uri` instead of comparing as an empty string — the
+    agent and the dataset may legitimately express the same filter either way.
+
+    The substitution is deliberately gated on there being exactly ONE dimension: with two or
+    more, omitting `attribute` ranks over the dimension *tuple*, which is a different filter,
+    so those stay strict. Callers pass the sole dimension of the visualization the filter
+    belongs to, which makes the comparison symmetric — it does not matter which side omitted it.
+
+    Missing, None and "" are all treated as "not specified"; so is a non-string, which
+    `validate_cross_references` reports separately rather than crashing the comparison.
+    """
+    attr_val = filter_dict.get("attribute")
+    if not isinstance(attr_val, str) or not attr_val:
+        dim_uri = sole_dim_uri or ""
+    else:
+        dim_uri = _resolve_alias_to_uri(attr_val, fields)
+    using_val = filter_dict.get("using")
     entry: dict = {
         "type": "ranking_filter",
-        "metric_uri": _resolve_alias_to_uri(filter_dict.get("using", ""), fields),
-        "dim_uri": _resolve_alias_to_uri(filter_dict.get("attribute", ""), fields),
+        "metric_uri": _resolve_alias_to_uri(using_val, fields) if isinstance(using_val, str) else "",
+        "dim_uri": dim_uri,
     }
     if "top" in filter_dict:
         entry["top"] = filter_dict["top"]
@@ -127,12 +176,13 @@ def _split_and_normalize_filters(viz: CreatedVisualization) -> tuple[set[str], s
     ranking_set: set[str] = set()
     attr_set: set[str] = set()
     fields = viz.query.fields
+    sole_dim_uri = _sole_dimension_uri(viz)
     for filter_dict in viz.query.filter_by.values():
         ft = filter_dict.get("type")
         if ft == "date_filter":
             date_set.add(json.dumps(_normalize_date_filter(filter_dict, fields), sort_keys=True))
         elif ft == "ranking_filter":
-            ranking_set.add(json.dumps(_normalize_ranking_filter(filter_dict, fields), sort_keys=True))
+            ranking_set.add(json.dumps(_normalize_ranking_filter(filter_dict, fields, sole_dim_uri), sort_keys=True))
         elif ft == "attribute_filter":
             attr_set.add(json.dumps(_normalize_attribute_filter(filter_dict, fields), sort_keys=True))
     return date_set, ranking_set, attr_set

{gooddata_eval-1.71.1.dev2.dist-info → gooddata_eval-1.71.1.dev3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gooddata-eval
-Version: 1.71.1.dev2
+Version: 1.71.1.dev3
 Summary: Evaluate the GoodData AI agent against your own questions and models.
 Project-URL: Source, https://github.com/gooddata/gooddata-python-sdk
 Author-email: GoodData <support@gooddata.com>
@@ -17,7 +17,7 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: gooddata-sdk~=1.71.1.dev2
+Requires-Dist: gooddata-sdk~=1.71.1.dev3
 Requires-Dist: httpx<1.0,>=0.27
 Requires-Dist: orjson<4.0.0,>=3.9.15
 Requires-Dist: pydantic<3.0,>=2.6

{gooddata_eval-1.71.1.dev2.dist-info → gooddata_eval-1.71.1.dev3.dist-info}/RECORD

@@ -8,7 +8,7 @@ gooddata_eval/core/config.py,sha256=mFtztP727uAhZ6b7twM5pFvzyazzMGVdgTYMvkqZT2Y,
 gooddata_eval/core/connection.py,sha256=mh-Do5-Ti0-DXXikfCIH10eTTUbKuZUAS_sLoPNDJ5I,1229
 gooddata_eval/core/models.py,sha256=FdGGZUSp1Qcs98Ib5U3OhGplBlUZMimlIdAqGLTjFDU,4473
 gooddata_eval/core/runner.py,sha256=sxE7kWDG6ttkSf5kUkZEJJ-B3DqWHXQOFBMEjMr4-D4,8520
-gooddata_eval/core/scoring.py,sha256=7ku48WEXtZl8EhowKikMiBmKfH7BDoZxHVvEOY8h3Rk,6007
+gooddata_eval/core/scoring.py,sha256=NbZnQeDuH1DF0z7RwxoeuQaTN_b4-85uu6Vm1QTjekI,8544
 gooddata_eval/core/workspace.py,sha256=S8exiy5gpDtcRtT8-i2fIRALF34Pbo0J46xm8X_ldus,11846
 gooddata_eval/core/agentic/__init__.py,sha256=nPjJ9sbnJVvsAlo9QMQlnPFgLNTZRzy9-0IKlnRcU8Q,2671
 gooddata_eval/core/agentic/_catalog.py,sha256=eCaeyvLF-FCN0J3UnXSHaKtufU6HvrM2mxnmgyXsY1U,2085
@@ -44,8 +44,8 @@ gooddata_eval/core/reporting/console.py,sha256=kCHt4sCSaSRh0ZWqaSEJOl6_Jgb6uiouS
 gooddata_eval/core/reporting/json_report.py,sha256=sKPG9-uxzDsf6EJyBXoaHVIfN1g-E2rZ8fA0wtyBYb4,2943
 gooddata_eval/core/summary/__init__.py,sha256=U54lANKm34yjqm7dZL9KkGouPbwAaQWC9wiAmb5B5g4,32
 gooddata_eval/core/summary/http_client.py,sha256=dPArJ6zoCu1W9xmYXFA1WMDNsSOkhn3gaCpYgCUp3gk,2174
-gooddata_eval-1.71.1.dev2.dist-info/METADATA,sha256=tYIsUFpURQNMt4xXSE2G77zigVMdvzbvZzWw_wfOxwA,9995
-gooddata_eval-1.71.1.dev2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-gooddata_eval-1.71.1.dev2.dist-info/entry_points.txt,sha256=28nFp5Viknx4haPYgzK9QHlwPFfC6rPF6RmjC2ht8EI,56
-gooddata_eval-1.71.1.dev2.dist-info/licenses/LICENSE.txt,sha256=LVfVlC9maU3K9lgMwdZnClQQsOIbOekdcdVKr9qzJtk,256836
-gooddata_eval-1.71.1.dev2.dist-info/RECORD,,
+gooddata_eval-1.71.1.dev3.dist-info/METADATA,sha256=ylGcgPJSeYQvXqCFnhfKf46z17jI_UZ3hKcoksHvjA0,9995
+gooddata_eval-1.71.1.dev3.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+gooddata_eval-1.71.1.dev3.dist-info/entry_points.txt,sha256=28nFp5Viknx4haPYgzK9QHlwPFfC6rPF6RmjC2ht8EI,56
+gooddata_eval-1.71.1.dev3.dist-info/licenses/LICENSE.txt,sha256=LVfVlC9maU3K9lgMwdZnClQQsOIbOekdcdVKr9qzJtk,256836
+gooddata_eval-1.71.1.dev3.dist-info/RECORD,,