gooddata-sdk 1.62.0__tar.gz → 1.62.1.dev2__tar.gz

{gooddata_sdk-1.62.0 → gooddata_sdk-1.62.1.dev2}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: gooddata-sdk
-Version: 1.62.0
+Version: 1.62.1.dev2
 Summary: GoodData Cloud Python SDK
-Project-URL: Documentation, https://www.gooddata.com/docs/python-sdk/1.62.0
+Project-URL: Documentation, https://www.gooddata.com/docs/python-sdk/1.62.1.dev2
 Project-URL: Source, https://github.com/gooddata/gooddata-python-sdk
 Author-email: GoodData <support@gooddata.com>
 License-Expression: MIT
@@ -23,7 +23,7 @@ Requires-Python: <4.0,>=3.10
 Requires-Dist: attrs<=24.2.0,>=21.4.0
 Requires-Dist: brotli==1.2.0
 Requires-Dist: cattrs<=24.1.1,>=22.1.0
-Requires-Dist: gooddata-api-client~=1.62.0
+Requires-Dist: gooddata-api-client~=1.62.1.dev2
 Requires-Dist: python-dateutil>=2.5.3
 Requires-Dist: python-dotenv<2.0.0,>=1.0.0
 Requires-Dist: pyyaml>=6.0
@@ -46,7 +46,7 @@ At the moment the SDK provides services to inspect and interact with the Semanti
 * Compute Service
 * Table Service
 
-See [DOCUMENTATION](https://www.gooddata.com/docs/python-sdk/1.62.0) for more details.
+See [DOCUMENTATION](https://www.gooddata.com/docs/python-sdk/1.62.1.dev2) for more details.
 
 ## Requirements
 

{gooddata_sdk-1.62.0 → gooddata_sdk-1.62.1.dev2}/README.md

@@ -14,7 +14,7 @@ At the moment the SDK provides services to inspect and interact with the Semanti
 * Compute Service
 * Table Service
 
-See [DOCUMENTATION](https://www.gooddata.com/docs/python-sdk/1.62.0) for more details.
+See [DOCUMENTATION](https://www.gooddata.com/docs/python-sdk/1.62.1.dev2) for more details.
 
 ## Requirements
 

{gooddata_sdk-1.62.0 → gooddata_sdk-1.62.1.dev2}/pyproject.toml

@@ -1,7 +1,7 @@
 # (C) 2025 GoodData Corporation
 [project]
 name = "gooddata-sdk"
-version = "1.62.0"
+version = "1.62.1.dev2"
 description = "GoodData Cloud Python SDK"
 readme = "README.md"
 license = "MIT"
@@ -26,7 +26,7 @@ keywords = [
 ]
 requires-python = ">=3.10,<4.0"
 dependencies = [
-    "gooddata-api-client~=1.62.0",
+    "gooddata-api-client~=1.62.1.dev2",
     "python-dateutil>=2.5.3",
     "pyyaml>=6.0",
     "attrs>=21.4.0,<=24.2.0",
@@ -50,7 +50,7 @@ classifiers = [
 ]
 
 [project.urls]
-Documentation = "https://www.gooddata.com/docs/python-sdk/1.62.0"
+Documentation = "https://www.gooddata.com/docs/python-sdk/1.62.1.dev2"
 Source = "https://github.com/gooddata/gooddata-python-sdk"
 
 [project.scripts]

{gooddata_sdk-1.62.0 → gooddata_sdk-1.62.1.dev2}/src/gooddata_sdk/__init__.py

@@ -278,6 +278,7 @@ from gooddata_sdk.compute.model.filter import (
     CompoundMetricValueFilter,
     Filter,
     InlineFilter,
+    MatchAttributeFilter,
     MetricValueComparisonCondition,
     MetricValueFilter,
     MetricValueRangeCondition,

{gooddata_sdk-1.62.0 → gooddata_sdk-1.62.1.dev2}/src/gooddata_sdk/compute/compute_to_sdk_converter.py

@@ -10,6 +10,7 @@ from gooddata_sdk.compute.model.filter import (
     CompoundMetricValueFilter,
     Filter,
     InlineFilter,
+    MatchAttributeFilter,
     MetricValueComparisonCondition,
     MetricValueFilter,
     MetricValueRangeCondition,
@@ -75,6 +76,16 @@ class ComputeToSdkConverter:
             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"]
 

{gooddata_sdk-1.62.0 → gooddata_sdk-1.62.1.dev2}/src/gooddata_sdk/compute/model/filter.py

@@ -21,6 +21,7 @@ from gooddata_api_client.models import (
 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 @@ class NegativeAttributeFilter(AttributeFilter):
         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 @@ class MetricValueFilter(Filter):
     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:

{gooddata_sdk-1.62.0 → gooddata_sdk-1.62.1.dev2}/src/gooddata_sdk/compute/visualization_to_sdk_converter.py

@@ -8,6 +8,7 @@ from gooddata_sdk.compute.model.filter import (
     AllTimeDateFilter,
     BoundedFilter,
     Filter,
+    MatchAttributeFilter,
     NegativeAttributeFilter,
     PositiveAttributeFilter,
     RelativeDateFilter,
@@ -43,6 +44,10 @@ class VisualizationToSdkConverter:
             - 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
@@ -50,6 +55,7 @@ class VisualizationToSdkConverter:
             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 @@ class VisualizationToSdkConverter:
         _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:

{gooddata_sdk-1.62.0 → gooddata_sdk-1.62.1.dev2}/src/gooddata_sdk/visualization.py

@@ -15,6 +15,7 @@ from gooddata_sdk.compute.model.filter import (
     AllTimeDateFilter,
     BoundedFilter,
     Filter,
+    MatchAttributeFilter,
     MetricValueFilter,
     NegativeAttributeFilter,
     PositiveAttributeFilter,
@@ -80,6 +81,12 @@ _ARITHMETIC_CONVERSION = {
     "change": "CHANGE",
 }
 
+_MATCH_OPERATOR_CONVERSION = {
+    "contains": "CONTAINS",
+    "startsWith": "STARTS_WITH",
+    "endsWith": "ENDS_WITH",
+}
+
 
 class BucketType(Enum):
     """
@@ -178,6 +185,22 @@ 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 "arbitraryAttributeFilter" in filter_obj:
+        f = filter_obj["arbitraryAttributeFilter"]
+        label = ref_extract(f["label"])
+        values = f.get("values", [])
+        if f.get("negativeSelection", False):
+            return NegativeAttributeFilter(label=label, values=values)
+        return PositiveAttributeFilter(label=label, values=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"]
 

{gooddata_sdk-1.62.0 → gooddata_sdk-1.62.1.dev2}/tests/compute/test_compute_to_sdk_converter.py

@@ -8,6 +8,7 @@ from gooddata_sdk import (
     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(
         """

gooddata_sdk-1.62.1.dev2/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
+    }
+}

gooddata_sdk-1.62.1.dev2/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
+    }
+}

gooddata_sdk-1.62.1.dev2/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
+    }
+}

gooddata_sdk-1.62.1.dev2/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
+    }
+}

gooddata_sdk-1.62.1.dev2/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
+    }
+}

gooddata_sdk-1.62.1.dev2/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
+    }
+}

gooddata_sdk-1.62.1.dev2/tests/compute_model/attribute_filters/negated_contains_filter.snapshot.json

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

gooddata_sdk-1.62.1.dev2/tests/compute_model/attribute_filters/negated_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": true
+    }
+}

gooddata_sdk-1.62.1.dev2/tests/compute_model/attribute_filters/negated_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": true
+    }
+}