feat: add MatchAttributeFilter to visualization model

This reflects the filter type recently added on the backend.
Support it also in the visualization_to_sdk_converter.

JIRA: CQ-2005
risk: low

Author: no23reason

packages/gooddata-sdk/src/gooddata_sdk/compute/visualization_to_sdk_converter.py

@@ -8,6 +8,7 @@
     AllTimeDateFilter,
     BoundedFilter,
     Filter,
+    MatchAttributeFilter,
     NegativeAttributeFilter,
     PositiveAttributeFilter,
     RelativeDateFilter,
@@ -43,13 +44,18 @@ def convert_filter(filter_dict: dict[str, Any]) -> Filter:
             - using: str - The identifier of the attribute/dataset to filter on
             - include: list[str] (optional) - Values to include in positive filter
             - exclude: list[str] (optional) - Values to exclude in negative filter
+            - literal: str (optional) - Literal value for match attribute filter
+            - matchType: str (optional) - Match type (STARTS_WITH, ENDS_WITH, CONTAINS)
+            - negate: bool (optional) - Whether to negate the match
+            - caseSensitive: bool (optional) - Whether match is case-sensitive
             - from: str (optional) - Start date/shift for date filters
             - to: str (optional) - End date/shift for date filters
             - granularity: str (optional) - Time granularity for relative date filters
         Returns:
             Filter: One of:
                 - PositiveAttributeFilter: When include values specified
                 - NegativeAttributeFilter: When exclude values specified
+                - MatchAttributeFilter: When literal and matchType specified
                 - RelativeDateFilter: When granularity and from/to shifts specified
                 - AbsoluteDateFilter: When from/to dates specified
                 - AllTimeDateFilter: When no date range specified
@@ -61,10 +67,21 @@ def convert_filter(filter_dict: dict[str, Any]) -> Filter:
         _to = filter_dict.get("to")
         granularity = filter_dict.get("granularity")
 
+        literal = filter_dict.get("literal")
+        match_type = filter_dict.get("matchType")
+
         if include is not None:
             return PositiveAttributeFilter(label=ObjId(using, "label"), values=include)
         elif exclude is not None:
             return NegativeAttributeFilter(label=ObjId(using, "label"), values=exclude)
+        elif literal is not None and match_type is not None:
+            return MatchAttributeFilter(
+                label=ObjId(using, "label"),
+                match_type=match_type,
+                literal=literal,
+                negate=filter_dict.get("negate", False),
+                case_sensitive=filter_dict.get("caseSensitive", False),
+            )
         elif granularity is not None and _from is not None and _to is not None:
             bounded_filter = None
             if "boundedFilter" in filter_dict:

packages/gooddata-sdk/src/gooddata_sdk/visualization.py

@@ -15,6 +15,7 @@
     AllTimeDateFilter,
     BoundedFilter,
     Filter,
+    MatchAttributeFilter,
     MetricValueFilter,
     NegativeAttributeFilter,
     PositiveAttributeFilter,
@@ -80,6 +81,12 @@
     "change": "CHANGE",
 }
 
+_MATCH_OPERATOR_CONVERSION = {
+    "contains": "CONTAINS",
+    "startsWith": "STARTS_WITH",
+    "endsWith": "ENDS_WITH",
+}
+
 
 class BucketType(Enum):
     """
@@ -178,6 +185,15 @@ def _convert_filter_to_computable(filter_obj: dict[str, Any]) -> Filter:
         not_in_values = f["notIn"]["values"] if "values" in f["notIn"] else f["notIn"]["uris"]
 
         return NegativeAttributeFilter(label=ref_extract(f["displayForm"]), values=not_in_values)
+    elif "matchAttributeFilter" in filter_obj:
+        f = filter_obj["matchAttributeFilter"]
+        return MatchAttributeFilter(
+            label=ref_extract(f["label"]),
+            match_type=_MATCH_OPERATOR_CONVERSION[f["operator"]],
+            literal=f["literal"],
+            negate=f.get("negativeSelection", False),
+            case_sensitive=f.get("caseSensitive", False),
+        )
     elif "relativeDateFilter" in filter_obj:
         f = filter_obj["relativeDateFilter"]
 

packages/gooddata-sdk/tests/visualization/resources/with_match_attribute_filter.json

@@ -0,0 +1,68 @@
+{
+  "buckets": [
+    {
+      "items": [
+        {
+          "measure": {
+            "definition": {
+              "measureDefinition": {
+                "item": {
+                  "identifier": {
+                    "id": "aangOxLSeztu",
+                    "type": "metric"
+                  }
+                }
+              }
+            },
+            "localIdentifier": "m_aangOxLSeztu"
+          }
+        }
+      ],
+      "localIdentifier": "measures"
+    },
+    {
+      "items": [
+        {
+          "attribute": {
+            "displayForm": {
+              "identifier": {
+                "id": "label.opportunity.id.name",
+                "type": "label"
+              }
+            },
+            "localIdentifier": "a_label.opportunity.id.name"
+          }
+        }
+      ],
+      "localIdentifier": "view"
+    },
+    {
+      "items": [],
+      "localIdentifier": "stack"
+    }
+  ],
+  "filters": [
+    {
+      "matchAttributeFilter": {
+        "label": {
+          "identifier": {
+            "id": "label.opportunity.id.name",
+            "type": "label"
+          }
+        },
+        "operator": "contains",
+        "literal": "search term",
+        "negativeSelection": false,
+        "caseSensitive": true
+      }
+    }
+  ],
+  "identifier": "AreaChart.a97be468994b89529a3efba0a264a799",
+  "properties": {
+    "controls": {}
+  },
+  "sorts": [],
+  "title": "AreaChart - with match attribute filter",
+  "uri": "AreaChart.a97be468994b89529a3efba0a264a799",
+  "visualizationUrl": "local:area"
+}

packages/gooddata-sdk/tests/visualization/snapshots/with_match_attribute_filter.snapshot.json

@@ -0,0 +1,46 @@
+{
+    "attributes": [
+        {
+            "label": {
+                "identifier": {
+                    "id": "label.opportunity.id.name",
+                    "type": "label"
+                }
+            },
+            "local_identifier": "a_label.opportunity.id.name"
+        }
+    ],
+    "filters": [
+        {
+            "match_attribute_filter": {
+                "case_sensitive": true,
+                "label": {
+                    "identifier": {
+                        "id": "label.opportunity.id.name",
+                        "type": "label"
+                    }
+                },
+                "literal": "search term",
+                "match_type": "CONTAINS",
+                "negate": false
+            }
+        }
+    ],
+    "measures": [
+        {
+            "definition": {
+                "measure": {
+                    "compute_ratio": false,
+                    "filters": [],
+                    "item": {
+                        "identifier": {
+                            "id": "aangOxLSeztu",
+                            "type": "metric"
+                        }
+                    }
+                }
+            },
+            "local_identifier": "m_aangOxLSeztu"
+        }
+    ]
+}