feat(gooddata-sdk): [AUTO] Add ExecutionResultLimitBreak schema for partial results

Author: yenkins-admin

packages/gooddata-sdk/pyproject.toml

@@ -76,7 +76,7 @@ test = [
 ]
 
 [tool.ty.analysis]
-allowed-unresolved-imports = ["gooddata_api_client.**"]
+allowed-unresolved-imports = ["gooddata_api_client.**", "pyarrow", "pyarrow.**"]
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/gooddata_sdk"]

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

@@ -290,6 +290,7 @@
     ExecutionDefinition,
     ExecutionResponse,
     ExecutionResult,
+    ExecutionResultLimitBreak,
     ResultCacheMetadata,
     ResultSizeBytesLimitExceeded,
     ResultSizeDimensions,

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

@@ -19,8 +19,8 @@
     import pyarrow as _pyarrow
     from pyarrow import ipc as _ipc
 except ImportError:
-    _pyarrow = None  # type: ignore
-    _ipc = None  # type: ignore
+    _pyarrow = None
+    _ipc = None
 
 from gooddata_sdk.client import GoodDataApiClient
 from gooddata_sdk.compute.model.attribute import Attribute
@@ -219,6 +219,29 @@ def as_api_model(self) -> models.AfmExecution:
 ResultSizeDimensions = tuple[int | None, ...]
 
 
+@define
+class ExecutionResultLimitBreak:
+    """Describes a limit that was broken, resulting in partial data being returned."""
+
+    limit: int
+    """The configured threshold value."""
+
+    limit_type: str
+    """Type of the limit that was broken, e.g. 'rowCount'."""
+
+    value: int | None = None
+    """The actual value that triggered the limit; None when it cannot be determined exactly."""
+
+    @classmethod
+    def from_api(cls, entity: dict[str, Any]) -> ExecutionResultLimitBreak:
+        raw_value = entity.get("value")
+        return cls(
+            limit=entity["limit"],
+            limit_type=entity["limitType"],
+            value=None if raw_value is None else int(raw_value),
+        )
+
+
 class ResultSizeDimensionsLimitsExceeded(Exception):
     def __init__(
         self,
@@ -271,6 +294,18 @@ def paging_offset(self) -> list[int]:
     def metadata(self) -> models.ExecutionResultMetadata:
         return self._metadata
 
+    @property
+    def limit_breaks(self) -> list[ExecutionResultLimitBreak]:
+        """Returns limits that were broken during result computation.
+
+        Returns an empty list when the result is complete (no limits were broken).
+        """
+        metadata: Any = self._metadata
+        raw = metadata.get("limitBreaks")
+        if not raw:
+            return []
+        return [ExecutionResultLimitBreak.from_api(item) for item in raw]
+
     def is_complete(self, dim: int = 0) -> bool:
         return self.paging_offset[dim] + self.paging_count[dim] >= self.paging_total[dim]
 

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

@@ -326,7 +326,7 @@ def __init__(
         self._from_shift = from_shift
         self._to_shift = to_shift
         self._bounded_filter = bounded_filter
-        self._empty_value_handling = empty_value_handling
+        self._empty_value_handling: EmptyValueHandling | None = empty_value_handling
 
     @property
     def dataset(self) -> ObjId:
@@ -435,7 +435,7 @@ def __init__(
 
         self._dataset = dataset
         self._granularity = granularity
-        self._empty_value_handling = empty_value_handling
+        self._empty_value_handling: EmptyValueHandling | None = empty_value_handling
 
     @property
     def dataset(self) -> ObjId:
@@ -490,7 +490,7 @@ def __init__(
         self._dataset = dataset
         self._from_date = from_date
         self._to_date = to_date
-        self._empty_value_handling = empty_value_handling
+        self._empty_value_handling: EmptyValueHandling | None = empty_value_handling
 
     @property
     def dataset(self) -> ObjId:

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

@@ -0,0 +1,81 @@
+# (C) 2026 GoodData Corporation
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from gooddata_sdk import ExecutionResultLimitBreak, GoodDataSdk
+from gooddata_sdk.compute.model.attribute import Attribute
+from gooddata_sdk.compute.model.execution import ExecutionDefinition, ExecutionResult, TableDimension
+from tests_support.vcrpy_utils import get_vcr
+
+gd_vcr = get_vcr()
+_fixtures_dir = Path(__file__).parent / "fixtures"
+
+
+@pytest.mark.parametrize(
+    "scenario,data,expected_limit,expected_limit_type,expected_value",
+    [
+        ("full", {"limit": 1000, "limitType": "rowCount", "value": 1500}, 1000, "rowCount", 1500),
+        ("no_value", {"limit": 500, "limitType": "rowCount"}, 500, "rowCount", None),
+        ("null_value", {"limit": 200, "limitType": "cellCount", "value": None}, 200, "cellCount", None),
+    ],
+)
+def test_limit_break_from_api(scenario, data, expected_limit, expected_limit_type, expected_value):
+    """ExecutionResultLimitBreak.from_api correctly maps camelCase keys and handles absent value."""
+    result = ExecutionResultLimitBreak.from_api(data)
+    assert result.limit == expected_limit
+    assert result.limit_type == expected_limit_type
+    assert result.value == expected_value
+
+
+def _make_execution_result(limit_breaks=None):
+    """Return a minimal ExecutionResult dict for unit testing."""
+    metadata = {"dataSourceMessages": []}
+    if limit_breaks is not None:
+        metadata["limitBreaks"] = limit_breaks
+    return {
+        "data": [],
+        "dimension_headers": [],
+        "grand_totals": [],
+        "metadata": metadata,
+        "paging": {"count": [0], "offset": [0], "total": [0]},
+    }
+
+
+def test_execution_result_limit_breaks_absent():
+    """When limitBreaks is absent from metadata, limit_breaks returns empty list."""
+    raw = _make_execution_result()
+    result = ExecutionResult(raw)  # type: ignore[arg-type]
+    assert result.limit_breaks == []
+
+
+def test_execution_result_limit_breaks_present():
+    """When limitBreaks is present in metadata, limit_breaks returns correctly parsed list."""
+    raw = _make_execution_result(limit_breaks=[{"limit": 1000, "limitType": "rowCount", "value": 1200}])
+    result = ExecutionResult(raw)  # type: ignore[arg-type]
+    breaks = result.limit_breaks
+    assert len(breaks) == 1
+    assert breaks[0].limit == 1000
+    assert breaks[0].limit_type == "rowCount"
+    assert breaks[0].value == 1200
+
+
+@gd_vcr.use_cassette(str(_fixtures_dir / "test_execution_result_limit_breaks.yaml"))
+def test_execution_result_limit_breaks_integration(test_config):
+    """Integration test: limit_breaks property is accessible from a live ExecutionResult."""
+    sdk = GoodDataSdk.create(host_=test_config["host"], token_=test_config["token"])
+    workspace_id = test_config["workspace"]
+
+    exec_def = ExecutionDefinition(
+        attributes=[Attribute(local_id="a1", label="campaign_channel_id")],
+        metrics=[],
+        filters=[],
+        dimensions=[TableDimension(item_ids=["a1"])],
+    )
+
+    execution = sdk.compute.for_exec_def(workspace_id, exec_def)
+    result = execution.read_result(limit=10)
+
+    # limit_breaks returns a list (empty when result is complete, no limits broken)
+    assert isinstance(result.limit_breaks, list)