fix(gooddata-sdk): stream Arrow IPC response directly, no BytesIO

Switch read_result_arrow to explicitly request application/vnd.apache.arrow.stream
via Accept header and pipe the HTTP response directly into ipc.open_stream(),
eliminating the intermediate BytesIO buffer. Update tests accordingly.

Author: Martozar

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

@@ -393,19 +393,24 @@ def read_result_arrow(self) -> pyarrow.Table:
             raise ImportError(
                 "pyarrow is required to use read_result_arrow(). Install it with: pip install gooddata-sdk[arrow]"
             )
-        import io
 
-        response = self._actions_api.retrieve_result_binary(
-            workspace_id=self._workspace_id,
-            result_id=self.result_id,
+        header_params: dict = {"Accept": "application/vnd.apache.arrow.stream"}
+        if self.cancel_token:
+            header_params["X-GDC-CANCEL-TOKEN"] = self.cancel_token
+
+        response = self._actions_api.api_client.call_api(
+            resource_path="/api/v1/actions/workspaces/{workspaceId}/execution/afm/execute/result/{resultId}/binary",
+            method="GET",
+            path_params={"workspaceId": self._workspace_id, "resultId": self.result_id},
+            header_params=header_params,
+            response_type=None,
             _preload_content=False,
-            **({"x_gdc_cancel_token": self.cancel_token} if self.cancel_token else {}),
+            _return_http_data_only=True,
         )
         try:
-            buf = io.BytesIO(response.read())
+            return _ipc.open_stream(response).read_all()
         finally:
             response.release_conn()
-        return _ipc.open_file(buf).read_all()
 
     def cancel(self) -> None:
         """

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

@@ -0,0 +1,110 @@
+# (C) 2026 GoodData Corporation
+from __future__ import annotations
+
+import io
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+pyarrow = pytest.importorskip("pyarrow")
+
+
+def _make_ipc_stream_bytes() -> bytes:
+    """Return minimal Arrow IPC stream bytes for a one-row table."""
+    import pyarrow as pa
+    from pyarrow import ipc
+
+    table = pa.table({"x": pa.array([1.0])})
+    buf = io.BytesIO()
+    with ipc.new_stream(buf, table.schema) as writer:
+        writer.write_table(table)
+    return buf.getvalue()
+
+
+class _FakeResponse(io.RawIOBase):
+    """Minimal file-like with release_conn to simulate a urllib3 HTTPResponse."""
+
+    def __init__(self, data: bytes) -> None:
+        super().__init__()
+        self._buf = io.BytesIO(data)
+        self.release_conn = MagicMock()
+
+    def read(self, n: int = -1) -> bytes:
+        return self._buf.read(n)
+
+    def readable(self) -> bool:
+        return True
+
+    def readinto(self, b: bytearray) -> int:
+        data = self._buf.read(len(b))
+        n = len(data)
+        b[:n] = data
+        return n
+
+
+def _make_bare(ipc_bytes: bytes):
+    """Return a BareExecutionResponse backed by a mock API client."""
+    from gooddata_sdk.compute.model.execution import BareExecutionResponse
+
+    mock_api_client = MagicMock()
+    mock_response = _FakeResponse(ipc_bytes)
+    mock_api_client.actions_api.api_client.call_api.return_value = mock_response
+
+    afm_exec_response = {
+        "execution_response": {
+            "links": {"executionResult": "result-id-123"},
+            "dimensions": [],
+        }
+    }
+    bare = BareExecutionResponse(
+        api_client=mock_api_client,
+        workspace_id="ws-id",
+        execution_response=afm_exec_response,
+    )
+    return bare, mock_response
+
+
+def test_read_result_arrow_returns_table() -> None:
+    """read_result_arrow reads the stream from the binary endpoint and returns a pa.Table."""
+    import pyarrow as pa
+
+    ipc_bytes = _make_ipc_stream_bytes()
+    bare, mock_response = _make_bare(ipc_bytes)
+
+    result = bare.read_result_arrow()
+
+    assert isinstance(result, pa.Table)
+    mock_response.release_conn.assert_called_once()
+
+
+def test_read_result_arrow_requests_stream_format() -> None:
+    """read_result_arrow sets Accept: application/vnd.apache.arrow.stream explicitly."""
+    ipc_bytes = _make_ipc_stream_bytes()
+    bare, _ = _make_bare(ipc_bytes)
+
+    bare.read_result_arrow()
+
+    call_kwargs = bare._actions_api.api_client.call_api.call_args.kwargs
+    assert call_kwargs["header_params"]["Accept"] == "application/vnd.apache.arrow.stream"
+
+
+def test_read_result_arrow_without_cancel_token() -> None:
+    """Without a cancel_token the call omits the cancel header."""
+    ipc_bytes = _make_ipc_stream_bytes()
+    bare, _ = _make_bare(ipc_bytes)
+
+    bare.read_result_arrow()
+
+    call_kwargs = bare._actions_api.api_client.call_api.call_args.kwargs
+    assert "X-GDC-CANCEL-TOKEN" not in call_kwargs["header_params"]
+
+
+def test_read_result_arrow_no_pyarrow_raises() -> None:
+    """When pyarrow is not installed, read_result_arrow raises ImportError."""
+    from gooddata_sdk.compute.model import execution as _exec_mod
+
+    ipc_bytes = _make_ipc_stream_bytes()
+    bare, _ = _make_bare(ipc_bytes)
+
+    with patch.object(_exec_mod, "_ipc", None), pytest.raises(ImportError, match="pyarrow is required"):
+        bare.read_result_arrow()