feat: add MatchAttributeFilter to compute model

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

JIRA: CQ-2005
risk: low

Author: no23reason

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

@@ -278,6 +278,7 @@
     CompoundMetricValueFilter,
     Filter,
     InlineFilter,
+    MatchAttributeFilter,
     MetricValueComparisonCondition,
     MetricValueFilter,
     MetricValueRangeCondition,

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

@@ -10,6 +10,7 @@
     CompoundMetricValueFilter,
     Filter,
     InlineFilter,
+    MatchAttributeFilter,
     MetricValueComparisonCondition,
     MetricValueFilter,
     MetricValueRangeCondition,
@@ -75,6 +76,16 @@ def convert_filter(filter_dict: dict[str, Any]) -> Filter:
             f = filter_dict["negativeAttributeFilter"]
             return NegativeAttributeFilter(label=ref_extract(f["label"]), values=f["notIn"]["values"])
 
+        if "matchAttributeFilter" in filter_dict:
+            f = filter_dict["matchAttributeFilter"]
+            return MatchAttributeFilter(
+                label=ref_extract(f["label"]),
+                match_type=f["matchType"],
+                literal=f["literal"],
+                case_sensitive=f.get("caseSensitive", False),
+                negate=f.get("negate", False),
+            )
+
         if "relativeDateFilter" in filter_dict:
             f = filter_dict["relativeDateFilter"]
 

packages/gooddata-sdk/src/gooddata_sdk/compute/model/filter.py

@@ -21,6 +21,7 @@
 from gooddata_api_client.models import (
     CompoundMeasureValueFilterCompoundMeasureValueFilter as CompoundMeasureValueFilterBody,
 )
+from gooddata_api_client.models import MatchAttributeFilterMatchAttributeFilter as MatchAttributeFilterBody
 from gooddata_api_client.models import NegativeAttributeFilterNegativeAttributeFilter as NegativeAttributeFilterBody
 from gooddata_api_client.models import PositiveAttributeFilterPositiveAttributeFilter as PositiveAttributeFilterBody
 from gooddata_api_client.models import RangeMeasureValueFilterRangeMeasureValueFilter as RangeMeasureValueFilterBody
@@ -152,6 +153,109 @@ def description(self, labels: dict[str, str], format_locale: str | None = None)
         return f"{labels.get(label_id, label_id)}: {values}"
 
 
+# mapping between the allowed match operators and their human-readable descriptions
+_ATTRIBUTE_MATCH_OPERATORS: dict[str, str] = {
+    "STARTS_WITH": "starts with",
+    "ENDS_WITH": "ends with",
+    "CONTAINS": "contains",
+}
+
+
+class MatchAttributeFilter(Filter):
+    def __init__(
+        self,
+        label: Union[ObjId, str, Attribute],
+        literal: str,
+        match_type: str,
+        negate: bool = False,
+        case_sensitive: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._label = _extract_id_or_local_id(label)
+        self._literal = literal
+
+        if match_type not in _ATTRIBUTE_MATCH_OPERATORS:
+            raise ValueError(
+                f"Match type must be one of {', '.join(_ATTRIBUTE_MATCH_OPERATORS.keys())}, got: {match_type}"
+            )
+
+        self._match_type = match_type
+        self._negate = negate
+        self._case_sensitive = case_sensitive
+
+    @property
+    def label(self) -> Union[ObjId, str]:
+        return self._label
+
+    @label.setter
+    def label(self, label: Union[ObjId, str]) -> None:
+        self._label = label
+
+    @property
+    def literal(self) -> str:
+        return self._literal
+
+    @literal.setter
+    def literal(self, literal: str) -> None:
+        self._literal = literal
+
+    @property
+    def match_type(self) -> str:
+        return self._match_type
+
+    @match_type.setter
+    def match_type(self, match_type: str) -> None:
+        self._match_type = match_type
+
+    @property
+    def negate(self) -> bool:
+        return self._negate
+
+    @negate.setter
+    def negate(self, negate: bool) -> None:
+        self._negate = negate
+
+    @property
+    def case_sensitive(self) -> bool:
+        return self._case_sensitive
+
+    @case_sensitive.setter
+    def case_sensitive(self, case_sensitive: bool) -> None:
+        self._case_sensitive = case_sensitive
+
+    def is_noop(self) -> bool:
+        return (not self._negate) and (not self._literal)
+
+    def as_api_model(self) -> afm_models.MatchAttributeFilter:
+        label_id = _to_identifier(self._label)
+        body = MatchAttributeFilterBody(
+            label=label_id,
+            literal=self._literal,
+            match_type=self._match_type,
+            negate=self._negate,
+            case_sensitive=self._case_sensitive,
+        )
+        return afm_models.MatchAttributeFilter(body)
+
+    def description(self, labels: dict[str, str], format_locale: str | None = None) -> str:
+        label_id = self.label.id if isinstance(self.label, ObjId) else self.label
+        prefix = "not " if self._negate else ""
+        return (
+            f"{labels.get(label_id, label_id)}: {prefix}{_ATTRIBUTE_MATCH_OPERATORS[self._match_type]} {self.literal}"
+        )
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, MatchAttributeFilter)
+            and self._label == other._label
+            and self._literal == other._literal
+            and self._match_type == other._match_type
+            and self._negate == other._negate
+            and self._case_sensitive == other._case_sensitive
+        )
+
+
 _GRANULARITY: set[str] = {
     "YEAR",
     "QUARTER",
@@ -557,7 +661,7 @@ def as_api_model(self) -> Union[afm_models.ComparisonMeasureValueFilter, afm_mod
     def description(self, labels: dict[str, str], format_locale: str | None = None) -> str:
         metric_id = self.metric.id if isinstance(self.metric, ObjId) else self.metric
         if self.operator in ["BETWEEN", "NOT_BETWEEN"] and len(self.values) == 2:
-            not_between = "not" if self.operator == "NOT_BETWEEN" else ""
+            not_between = "not " if self.operator == "NOT_BETWEEN" else ""
             values = cast(tuple[float, float], self.values)
             return f"{labels.get(metric_id, metric_id)}: {not_between}between {values[0]} - {values[1]}"
         else:

packages/gooddata-sdk/tests/compute/test_compute_to_sdk_converter.py

@@ -8,6 +8,7 @@
     CompoundMetricValueFilter,
     ComputeToSdkConverter,
     InlineFilter,
+    MatchAttributeFilter,
     MetricValueComparisonCondition,
     MetricValueFilter,
     MetricValueRangeCondition,
@@ -88,6 +89,60 @@ def test_negative_attribute_filter_conversion():
     assert result.values == ["val1", "val2"]
 
 
+def test_match_attribute_filter_conversion():
+    filter_dict = json.loads(
+        """
+        {
+          "matchAttributeFilter": {
+            "label": {
+              "identifier": { "id": "attribute1", "type": "label" }
+            },
+            "matchType": "CONTAINS",
+            "literal": "search term",
+            "caseSensitive": false,
+            "negate": false
+          }
+        }
+        """
+    )
+
+    result = ComputeToSdkConverter.convert_filter(filter_dict)
+
+    assert isinstance(result, MatchAttributeFilter)
+    assert result.label.id == "attribute1"
+    assert result.match_type == "CONTAINS"
+    assert result.literal == "search term"
+    assert result.case_sensitive is False
+    assert result.negate is False
+
+
+def test_match_attribute_filter_negated_case_sensitive():
+    filter_dict = json.loads(
+        """
+        {
+          "matchAttributeFilter": {
+            "label": {
+              "identifier": { "id": "product_name", "type": "label" }
+            },
+            "matchType": "STARTS_WITH",
+            "literal": "Premium",
+            "caseSensitive": true,
+            "negate": true
+          }
+        }
+        """
+    )
+
+    result = ComputeToSdkConverter.convert_filter(filter_dict)
+
+    assert isinstance(result, MatchAttributeFilter)
+    assert result.label.id == "product_name"
+    assert result.match_type == "STARTS_WITH"
+    assert result.literal == "Premium"
+    assert result.case_sensitive is True
+    assert result.negate is True
+
+
 def test_relative_date_filter_conversion():
     filter_dict = json.loads(
         """

packages/gooddata-sdk/tests/compute_model/attribute_filters/case_sensitive_contains_filter.snapshot.json

@@ -0,0 +1,11 @@
+{
+    "match_attribute_filter": {
+        "case_sensitive": true,
+        "label": {
+            "local_identifier": "local_id"
+        },
+        "literal": "Foo",
+        "match_type": "CONTAINS",
+        "negate": false
+    }
+}

packages/gooddata-sdk/tests/compute_model/attribute_filters/match_contains_filter_using_local_id.snapshot.json

@@ -0,0 +1,11 @@
+{
+    "match_attribute_filter": {
+        "case_sensitive": false,
+        "label": {
+            "local_identifier": "local_id"
+        },
+        "literal": "foo",
+        "match_type": "CONTAINS",
+        "negate": false
+    }
+}

packages/gooddata-sdk/tests/compute_model/attribute_filters/match_contains_filter_using_object_id.snapshot.json

@@ -0,0 +1,14 @@
+{
+    "match_attribute_filter": {
+        "case_sensitive": false,
+        "label": {
+            "identifier": {
+                "id": "label.id",
+                "type": "label"
+            }
+        },
+        "literal": "bar",
+        "match_type": "CONTAINS",
+        "negate": false
+    }
+}

packages/gooddata-sdk/tests/compute_model/attribute_filters/match_ends_with_filter.snapshot.json

@@ -0,0 +1,11 @@
+{
+    "match_attribute_filter": {
+        "case_sensitive": false,
+        "label": {
+            "local_identifier": "local_id"
+        },
+        "literal": "suffix",
+        "match_type": "ENDS_WITH",
+        "negate": false
+    }
+}

packages/gooddata-sdk/tests/compute_model/attribute_filters/match_starts_with_filter.snapshot.json

@@ -0,0 +1,11 @@
+{
+    "match_attribute_filter": {
+        "case_sensitive": false,
+        "label": {
+            "local_identifier": "local_id"
+        },
+        "literal": "prefix",
+        "match_type": "STARTS_WITH",
+        "negate": false
+    }
+}

packages/gooddata-sdk/tests/compute_model/attribute_filters/negated_case_sensitive_starts_with_filter.snapshot.json

@@ -0,0 +1,11 @@
+{
+    "match_attribute_filter": {
+        "case_sensitive": true,
+        "label": {
+            "local_identifier": "local_id"
+        },
+        "literal": "Pre",
+        "match_type": "STARTS_WITH",
+        "negate": true
+    }
+}