gooddata-sdk 1.66.1.dev1__tar.gz → 1.68.0__tar.gz

{gooddata_sdk-1.66.1.dev1 → gooddata_sdk-1.68.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: gooddata-sdk
-Version: 1.66.1.dev1
+Version: 1.68.0
 Summary: GoodData Cloud Python SDK
-Project-URL: Documentation, https://www.gooddata.ai/docs/python-sdk/1.66.1.dev1
+Project-URL: Documentation, https://www.gooddata.ai/docs/python-sdk/1.68.0
 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.66.1.dev1
+Requires-Dist: gooddata-api-client~=1.68.0
 Requires-Dist: gooddata-code-convertors>=11.35.0a2
 Requires-Dist: python-dateutil>=2.5.3
 Requires-Dist: python-dotenv<2.0.0,>=1.0.0
@@ -49,7 +49,7 @@ At the moment the SDK provides services to inspect and interact with the Semanti
 * Compute Service
 * Table Service
 
-See [DOCUMENTATION](https://www.gooddata.ai/docs/python-sdk/1.66.1.dev1) for more details.
+See [DOCUMENTATION](https://www.gooddata.ai/docs/python-sdk/1.68.0) for more details.
 
 ## Requirements
 

{gooddata_sdk-1.66.1.dev1 → gooddata_sdk-1.68.0}/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.ai/docs/python-sdk/1.66.1.dev1) for more details.
+See [DOCUMENTATION](https://www.gooddata.ai/docs/python-sdk/1.68.0) for more details.
 
 ## Requirements
 

{gooddata_sdk-1.66.1.dev1 → gooddata_sdk-1.68.0}/pyproject.toml

@@ -1,7 +1,7 @@
 # (C) 2025 GoodData Corporation
 [project]
 name = "gooddata-sdk"
-version = "1.66.1.dev1"
+version = "1.68.0"
 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.66.1.dev1",
+    "gooddata-api-client~=1.68.0",
     "python-dateutil>=2.5.3",
     "pyyaml>=6.0",
     "attrs>=21.4.0,<=24.2.0",
@@ -54,7 +54,7 @@ classifiers = [
 arrow = ["pyarrow>=23.0.1"]
 
 [project.urls]
-Documentation = "https://www.gooddata.ai/docs/python-sdk/1.66.1.dev1"
+Documentation = "https://www.gooddata.ai/docs/python-sdk/1.68.0"
 Source = "https://github.com/gooddata/gooddata-python-sdk"
 
 [project.scripts]

{gooddata_sdk-1.66.1.dev1 → gooddata_sdk-1.68.0}/src/gooddata_sdk/__init__.py

@@ -109,6 +109,10 @@ from gooddata_sdk.catalog.organization.entity_model.export_template import (
     CatalogExportTemplate,
     CatalogExportTemplateAttributes,
 )
+from gooddata_sdk.catalog.organization.entity_model.ip_allowlist_policy import (
+    CatalogIpAllowlistPolicy,
+    CatalogIpAllowlistPolicyTargets,
+)
 from gooddata_sdk.catalog.organization.entity_model.jwk import (
     CatalogJwk,
     CatalogJwkAttributes,
@@ -123,8 +127,11 @@ from gooddata_sdk.catalog.organization.entity_model.llm_provider import (
     CatalogLlmProvider,
     CatalogLlmProviderDocument,
     CatalogLlmProviderModel,
+    CatalogLlmProviderModelsResult,
     CatalogLlmProviderPatch,
     CatalogLlmProviderPatchDocument,
+    CatalogLlmProviderTestResult,
+    CatalogModelTestResult,
     CatalogOpenAiApiKeyAuth,
     CatalogOpenAiProviderConfig,
 )
@@ -280,7 +287,7 @@ from gooddata_sdk.catalog.workspace.entity_model.user_data_filter import (
     CatalogUserDataFilterRelationships,
 )
 from gooddata_sdk.catalog.workspace.entity_model.workspace import CatalogWorkspace
-from gooddata_sdk.client import GoodDataApiClient
+from gooddata_sdk.client import GoodDataApiClient, GoodDataApiClientRetryConfig
 from gooddata_sdk.compute.compute_to_sdk_converter import ComputeToSdkConverter
 from gooddata_sdk.compute.model.attribute import Attribute
 from gooddata_sdk.compute.model.base import ExecModelEntity, ObjId

gooddata_sdk-1.68.0/src/gooddata_sdk/catalog/organization/entity_model/ip_allowlist_policy.py

@@ -0,0 +1,91 @@
+# (C) 2026 GoodData Corporation
+from __future__ import annotations
+
+from typing import Any
+
+from attrs import define, field
+from gooddata_api_client.model.assignee_identifier import AssigneeIdentifier
+from gooddata_api_client.model.ip_allowlist_policy_targets import IpAllowlistPolicyTargets
+from gooddata_api_client.model.json_api_agent_in_relationships_user_groups import JsonApiAgentInRelationshipsUserGroups
+from gooddata_api_client.model.json_api_automation_in_relationships_recipients import (
+    JsonApiAutomationInRelationshipsRecipients,
+)
+from gooddata_api_client.model.json_api_ip_allowlist_policy_in import JsonApiIpAllowlistPolicyIn
+from gooddata_api_client.model.json_api_ip_allowlist_policy_in_attributes import JsonApiIpAllowlistPolicyInAttributes
+from gooddata_api_client.model.json_api_ip_allowlist_policy_in_document import JsonApiIpAllowlistPolicyInDocument
+from gooddata_api_client.model.json_api_ip_allowlist_policy_in_relationships import (
+    JsonApiIpAllowlistPolicyInRelationships,
+)
+from gooddata_api_client.model.json_api_user_group_linkage import JsonApiUserGroupLinkage
+from gooddata_api_client.model.json_api_user_group_to_many_linkage import JsonApiUserGroupToManyLinkage
+from gooddata_api_client.model.json_api_user_linkage import JsonApiUserLinkage
+from gooddata_api_client.model.json_api_user_to_many_linkage import JsonApiUserToManyLinkage
+
+from gooddata_sdk.catalog.base import Base
+from gooddata_sdk.catalog.identifier import CatalogAssigneeIdentifier
+
+_POLICY_TYPE = "ipAllowlistPolicy"
+
+
+@define(kw_only=True)
+class CatalogIpAllowlistPolicy(Base):
+    """Represents an IP allowlist policy entity."""
+
+    id: str
+    allowed_sources: list[str] = field(factory=list)
+    users: list[CatalogAssigneeIdentifier] = field(factory=list)
+    user_groups: list[CatalogAssigneeIdentifier] = field(factory=list)
+
+    @staticmethod
+    def client_class() -> type[JsonApiIpAllowlistPolicyIn]:
+        return JsonApiIpAllowlistPolicyIn
+
+    @classmethod
+    def from_api(cls, entity: dict[str, Any]) -> CatalogIpAllowlistPolicy:
+        attributes = entity.get("attributes") or {}
+        relationships = entity.get("relationships") or {}
+        users = (relationships.get("users") or {}).get("data") or []
+        user_groups = (relationships.get("userGroups") or {}).get("data") or []
+        return cls(
+            id=entity["id"],
+            allowed_sources=list(attributes.get("allowedSources") or []),
+            users=[CatalogAssigneeIdentifier(id=user["id"], type=user["type"]) for user in users],
+            user_groups=[CatalogAssigneeIdentifier(id=group["id"], type=group["type"]) for group in user_groups],
+        )
+
+    def to_api(self) -> JsonApiIpAllowlistPolicyInDocument:
+        relationships: dict[str, Any] = {}
+        if self.users:
+            relationships["users"] = JsonApiAutomationInRelationshipsRecipients(
+                data=JsonApiUserToManyLinkage([JsonApiUserLinkage(id=user.id, type=user.type) for user in self.users])
+            )
+        if self.user_groups:
+            relationships["user_groups"] = JsonApiAgentInRelationshipsUserGroups(
+                data=JsonApiUserGroupToManyLinkage(
+                    [JsonApiUserGroupLinkage(id=group.id, type=group.type) for group in self.user_groups]
+                )
+            )
+        data_kwargs: dict[str, Any] = {
+            "id": self.id,
+            "type": _POLICY_TYPE,
+            "attributes": JsonApiIpAllowlistPolicyInAttributes(allowed_sources=self.allowed_sources),
+        }
+        if relationships:
+            data_kwargs["relationships"] = JsonApiIpAllowlistPolicyInRelationships(**relationships)
+        return JsonApiIpAllowlistPolicyInDocument(data=JsonApiIpAllowlistPolicyIn(**data_kwargs))
+
+
+@define(kw_only=True)
+class CatalogIpAllowlistPolicyTargets(Base):
+    """Target payload for IP allowlist policy add/remove target actions."""
+
+    targets: list[CatalogAssigneeIdentifier] = field(factory=list)
+
+    @staticmethod
+    def client_class() -> type[IpAllowlistPolicyTargets]:
+        return IpAllowlistPolicyTargets
+
+    def to_api(self) -> IpAllowlistPolicyTargets:
+        return IpAllowlistPolicyTargets(
+            targets=[AssigneeIdentifier(id=target.id, type=target.type) for target in self.targets]
+        )

{gooddata_sdk-1.66.1.dev1 → gooddata_sdk-1.68.0}/src/gooddata_sdk/catalog/organization/entity_model/llm_provider.py

@@ -16,8 +16,11 @@ from gooddata_api_client.model.json_api_llm_provider_in_attributes_models_inner
 from gooddata_api_client.model.json_api_llm_provider_in_document import JsonApiLlmProviderInDocument
 from gooddata_api_client.model.json_api_llm_provider_patch import JsonApiLlmProviderPatch
 from gooddata_api_client.model.json_api_llm_provider_patch_document import JsonApiLlmProviderPatchDocument
+from gooddata_api_client.model.list_llm_provider_models_response import ListLlmProviderModelsResponse
+from gooddata_api_client.model.model_test_result import ModelTestResult
 from gooddata_api_client.model.open_ai_provider_auth import OpenAiProviderAuth
 from gooddata_api_client.model.open_ai_provider_config import OpenAIProviderConfig
+from gooddata_api_client.model.test_llm_provider_response import TestLlmProviderResponse
 
 from gooddata_sdk.catalog.base import Base
 from gooddata_sdk.utils import safeget
@@ -337,3 +340,45 @@ class CatalogLlmProviderPatchAttributes(Base):
     @staticmethod
     def client_class() -> type[JsonApiLlmProviderInAttributes]:
         return JsonApiLlmProviderInAttributes
+
+
+# --- Action result types ---
+
+
+@define(kw_only=True)
+class CatalogModelTestResult(Base):
+    """Result of testing a single model on an LLM provider."""
+
+    model_id: str
+    successful: bool
+    message: str | None = None
+
+    @staticmethod
+    def client_class() -> type[ModelTestResult]:
+        return ModelTestResult
+
+
+@define(kw_only=True)
+class CatalogLlmProviderTestResult(Base):
+    """Result of testing connectivity to an LLM provider."""
+
+    provider_reachable: bool
+    provider_message: str | None = None
+    model_results: list[CatalogModelTestResult] | None = None
+
+    @staticmethod
+    def client_class() -> type[TestLlmProviderResponse]:
+        return TestLlmProviderResponse
+
+
+@define(kw_only=True)
+class CatalogLlmProviderModelsResult(Base):
+    """Result of listing the models available for an LLM provider."""
+
+    success: bool
+    message: str | None = None
+    models: list[CatalogLlmProviderModel] | None = None
+
+    @staticmethod
+    def client_class() -> type[ListLlmProviderModelsResponse]:
+        return ListLlmProviderModelsResponse

{gooddata_sdk-1.66.1.dev1 → gooddata_sdk-1.68.0}/src/gooddata_sdk/catalog/organization/service.py

@@ -16,18 +16,29 @@ from gooddata_api_client.model.json_api_identity_provider_in_document import Jso
 from gooddata_api_client.model.json_api_organization_patch import JsonApiOrganizationPatch
 from gooddata_api_client.model.json_api_organization_patch_document import JsonApiOrganizationPatchDocument
 from gooddata_api_client.model.json_api_organization_setting_in_document import JsonApiOrganizationSettingInDocument
+from gooddata_api_client.model.list_llm_provider_models_request import ListLlmProviderModelsRequest
 from gooddata_api_client.model.switch_identity_provider_request import SwitchIdentityProviderRequest
+from gooddata_api_client.model.test_llm_provider_by_id_request import TestLlmProviderByIdRequest
+from gooddata_api_client.model.test_llm_provider_definition_request import TestLlmProviderDefinitionRequest
 
 from gooddata_sdk import CatalogDeclarativeExportTemplate, CatalogExportTemplate
 from gooddata_sdk.catalog.catalog_service_base import CatalogServiceBase
 from gooddata_sdk.catalog.organization.entity_model.directive import CatalogCspDirective
 from gooddata_sdk.catalog.organization.entity_model.identity_provider import CatalogIdentityProvider
+from gooddata_sdk.catalog.organization.entity_model.ip_allowlist_policy import (
+    CatalogIpAllowlistPolicy,
+    CatalogIpAllowlistPolicyTargets,
+)
 from gooddata_sdk.catalog.organization.entity_model.jwk import CatalogJwk, CatalogJwkDocument
 from gooddata_sdk.catalog.organization.entity_model.llm_provider import (
     CatalogLlmProvider,
+    CatalogLlmProviderConfig,
     CatalogLlmProviderDocument,
+    CatalogLlmProviderModel,
+    CatalogLlmProviderModelsResult,
     CatalogLlmProviderPatch,
     CatalogLlmProviderPatchDocument,
+    CatalogLlmProviderTestResult,
 )
 from gooddata_sdk.catalog.organization.entity_model.setting import CatalogOrganizationSetting
 from gooddata_sdk.catalog.organization.layout.identity_provider import CatalogDeclarativeIdentityProvider
@@ -628,6 +639,139 @@ class CatalogOrganizationService(CatalogServiceBase):
         """
         self._entities_api.delete_entity_llm_providers(id, _check_return_type=False)
 
+    def test_llm_provider(
+        self,
+        provider_config: CatalogLlmProviderConfig,
+        models: list[CatalogLlmProviderModel] | None = None,
+    ) -> CatalogLlmProviderTestResult:
+        """Test connectivity to an unsaved LLM provider configuration.
+
+        Args:
+            provider_config: Provider configuration to test (OpenAI, AWS Bedrock, or Azure Foundry).
+            models: Optional list of models to test against the provider.
+
+        Returns:
+            CatalogLlmProviderTestResult: Reachability and per-model test results.
+        """
+        payload: dict = {"providerConfig": provider_config.to_api().to_dict()}
+        if models is not None:
+            payload["models"] = [m.to_api().to_dict() for m in models]
+        request = TestLlmProviderDefinitionRequest.from_dict(payload)
+        response = self._actions_api.test_llm_provider(request)
+        return CatalogLlmProviderTestResult.from_api(response)
+
+    def test_llm_provider_by_id(
+        self,
+        id: str,
+        models: list[CatalogLlmProviderModel] | None = None,
+    ) -> CatalogLlmProviderTestResult:
+        """Test connectivity to a saved LLM provider by its identifier.
+
+        Args:
+            id: LLM provider identifier.
+            models: Optional list of models to test (overrides the provider's models).
+
+        Returns:
+            CatalogLlmProviderTestResult: Reachability and per-model test results.
+        """
+        kwargs: dict = {}
+        if models is not None:
+            kwargs["test_llm_provider_by_id_request"] = TestLlmProviderByIdRequest.from_dict(
+                {"models": [m.to_api().to_dict() for m in models]}
+            )
+        response = self._actions_api.test_llm_provider_by_id(id, **kwargs)
+        return CatalogLlmProviderTestResult.from_api(response)
+
+    def list_llm_provider_models(
+        self,
+        provider_config: CatalogLlmProviderConfig,
+    ) -> CatalogLlmProviderModelsResult:
+        """List the models available for an unsaved LLM provider configuration.
+
+        Args:
+            provider_config: Provider configuration to query.
+
+        Returns:
+            CatalogLlmProviderModelsResult: Available models and query status.
+        """
+        request = ListLlmProviderModelsRequest.from_dict({"providerConfig": provider_config.to_api().to_dict()})
+        response = self._actions_api.list_llm_provider_models(request)
+        return CatalogLlmProviderModelsResult.from_api(response)
+
+    def list_llm_provider_models_by_id(self, id: str) -> CatalogLlmProviderModelsResult:
+        """List the models available for a saved LLM provider by its identifier.
+
+        Args:
+            id: LLM provider identifier.
+
+        Returns:
+            CatalogLlmProviderModelsResult: Available models and query status.
+        """
+        response = self._actions_api.list_llm_provider_models_by_id(id)
+        return CatalogLlmProviderModelsResult.from_api(response)
+
+    # IP Allowlist Policy APIs
+
+    def get_ip_allowlist_policy(self, policy_id: str) -> CatalogIpAllowlistPolicy:
+        """Get an IP allowlist policy by ID.
+
+        Args:
+            policy_id: IP allowlist policy identifier.
+
+        Returns:
+            CatalogIpAllowlistPolicy: Retrieved policy.
+        """
+        response = self._entities_api.get_entity_ip_allowlist_policies(
+            policy_id, include=["users", "userGroups"], _check_return_type=False
+        )
+        return CatalogIpAllowlistPolicy.from_api(response.data)
+
+    def list_ip_allowlist_policies(self) -> list[CatalogIpAllowlistPolicy]:
+        """Return all IP allowlist policies in the organization."""
+        get_policies = functools.partial(
+            self._entities_api.get_all_entities_ip_allowlist_policies,
+            include=["users", "userGroups"],
+            _check_return_type=False,
+        )
+        policies = load_all_entities(get_policies)
+        return [CatalogIpAllowlistPolicy.from_api(policy) for policy in policies.data]
+
+    def create_ip_allowlist_policy(self, policy: CatalogIpAllowlistPolicy) -> CatalogIpAllowlistPolicy:
+        """Create a new IP allowlist policy."""
+        response = self._entities_api.create_entity_ip_allowlist_policies(
+            json_api_ip_allowlist_policy_in_document=policy.to_api(),
+            include=["users", "userGroups"],
+            _check_return_type=False,
+        )
+        return CatalogIpAllowlistPolicy.from_api(response.data)
+
+    def update_ip_allowlist_policy(self, policy: CatalogIpAllowlistPolicy) -> CatalogIpAllowlistPolicy:
+        """Replace an existing IP allowlist policy."""
+        response = self._entities_api.update_entity_ip_allowlist_policies(
+            policy.id, policy.to_api(), include=["users", "userGroups"], _check_return_type=False
+        )
+        return CatalogIpAllowlistPolicy.from_api(response.data)
+
+    def delete_ip_allowlist_policy(self, policy_id: str) -> None:
+        """Delete an IP allowlist policy."""
+        self._entities_api.delete_entity_ip_allowlist_policies(policy_id, _check_return_type=False)
+
+    def add_targets_to_ip_allowlist_policy(
+        self,
+        policy_id: str,
+        targets: CatalogIpAllowlistPolicyTargets,
+    ) -> None:
+        """Add users or user groups to an IP allowlist policy."""
+        self._actions_api.add_targets(policy_id, targets.to_api())
+
+    def remove_targets_from_ip_allowlist_policy(
+        self,
+        policy_id: str,
+        targets: CatalogIpAllowlistPolicyTargets,
+    ) -> None:
+        """Remove users or user groups from an IP allowlist policy."""
+        self._actions_api.remove_targets(policy_id, targets.to_api())
+
     # Layout APIs
 
     def get_declarative_notification_channels(self) -> list[CatalogDeclarativeNotificationChannel]:

{gooddata_sdk-1.66.1.dev1 → gooddata_sdk-1.68.0}/src/gooddata_sdk/catalog/workspace/entity_model/content_objects/dataset.py

@@ -90,10 +90,7 @@ class CatalogAttribute(AttrCatalogEntity):
 
     def find_label(self, id_obj: IdObjType) -> Union[CatalogLabel, None]:
         obj_key = id_obj_to_key(id_obj)
-        # use cast as mypy is not applying next, it claims, type is filter[CatalogLabel]
-        return cast(
-            Union[CatalogLabel, None], next(filter(lambda x: id_obj_to_key(x.obj_id) == obj_key, self.labels), None)
-        )
+        return next(filter(lambda x: id_obj_to_key(x.obj_id) == obj_key, self.labels), None)
 
     # TODO add missing properties
 

{gooddata_sdk-1.66.1.dev1 → gooddata_sdk-1.68.0}/src/gooddata_sdk/client.py

@@ -3,18 +3,105 @@
 
 from __future__ import annotations
 
+import logging
 import os
+from dataclasses import dataclass, field
 from pathlib import Path
 
 import gooddata_api_client as api_client
 import requests
 from gooddata_api_client import apis
+from requests.adapters import HTTPAdapter
+from urllib3.exceptions import MaxRetryError
+from urllib3.util.retry import Retry
 
 from gooddata_sdk import __version__
 from gooddata_sdk.utils import HttpMethod
 
+logger = logging.getLogger(__name__)
+
 USER_AGENT = f"gooddata-python-sdk/{__version__}"
 
+DEFAULT_RETRY_ALLOWED_METHODS: frozenset[str] = frozenset(
+    ["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE", "POST", "PATCH"]
+)
+
+
+@dataclass(frozen=True)
+class GoodDataApiClientRetryConfig:
+    """Retry policy for transient HTTP failures.
+
+    The same policy is applied to both transport paths:
+    - the generated `gooddata-api-client` (via `urllib3` `Retry`)
+    - the direct `requests`-based POST in `GoodDataApiClient._do_post_request`
+      (via `HTTPAdapter` mounted on a `Session`)
+
+    `Retry-After` from the server is honoured automatically; `backoff_factor`
+    only applies when that header is absent.
+    """
+
+    max_retries: int = 10
+    backoff_factor: float = 0.5
+    backoff_max: float = 60.0
+    status_forcelist: tuple[int, ...] = (429,)
+    allowed_methods: frozenset[str] = field(default_factory=lambda: DEFAULT_RETRY_ALLOWED_METHODS)
+
+
+class _LoggingRetry(Retry):
+    """Retry that logs each rate-limit hit and final exhaustion.
+
+    Logs at WARNING when a configured status (HTTP 429 by default) is
+    received and a retry is scheduled, and at ERROR when retries are
+    exhausted. Other retry causes (connection errors, redirects, etc.)
+    are left to urllib3's own logging.
+    """
+
+    def increment(  # type: ignore[override]
+        self,
+        method=None,
+        url=None,
+        response=None,
+        error=None,
+        _pool=None,
+        _stacktrace=None,
+    ):
+        if response is not None and response.status in self.status_forcelist:
+            logger.warning(
+                "GoodData API rate-limited: %s %s -> %s; Retry-After=%s; retries left=%s",
+                method,
+                url,
+                response.status,
+                response.headers.get("Retry-After"),
+                self.total,
+            )
+            try:
+                return super().increment(method, url, response, error, _pool, _stacktrace)
+            except MaxRetryError:
+                logger.error(
+                    "GoodData API rate-limit retries exhausted: %s %s -> %s",
+                    method,
+                    url,
+                    response.status,
+                )
+                raise
+        return super().increment(method, url, response, error, _pool, _stacktrace)
+
+
+def _build_urllib3_retry(retry_config: GoodDataApiClientRetryConfig) -> Retry:
+    return _LoggingRetry(
+        total=retry_config.max_retries,
+        connect=0,
+        read=0,
+        other=0,
+        status=retry_config.max_retries,
+        backoff_factor=retry_config.backoff_factor,
+        backoff_max=retry_config.backoff_max,
+        status_forcelist=retry_config.status_forcelist,
+        allowed_methods=retry_config.allowed_methods,
+        respect_retry_after_header=True,
+        raise_on_status=False,
+    )
+
 
 class GoodDataApiClient:
     """Provide access to metadata and afm services."""
@@ -28,6 +115,7 @@ class GoodDataApiClient:
         executions_cancellable: bool = False,
         ssl_ca_cert: str | None = None,
         proxy: str | None = None,
+        retry_config: GoodDataApiClientRetryConfig | None = None,
     ) -> None:
         """Take url, token for connecting to GoodData.CN.
 
@@ -44,6 +132,10 @@ class GoodDataApiClient:
         `proxy` is optional URL of an HTTP(S) proxy (e.g. ``http://proxy:8080``).
         When not set, the standard ``HTTPS_PROXY`` / ``https_proxy`` / ``HTTP_PROXY`` /
         ``http_proxy`` environment variables are checked automatically.
+
+        `retry_config` controls retry behaviour for transient HTTP failures
+        (HTTP 429 by default). When omitted, sensible defaults are used and
+        ``Retry-After`` is honoured automatically.
         """
         self._hostname = host
         self._token = token
@@ -68,7 +160,11 @@ class GoodDataApiClient:
                 or None
             )
 
+        self._retry_config = retry_config or GoodDataApiClientRetryConfig()
+        self._retry = _build_urllib3_retry(self._retry_config)
+
         self._api_config = api_client.Configuration(host=host, ssl_ca_cert=ssl_ca_cert)
+        self._api_config.retries = self._retry
         if proxy:
             self._api_config.proxy = proxy
         self._api_client = api_client.ApiClient(
@@ -83,6 +179,11 @@ class GoodDataApiClient:
             self._api_client.default_headers[header_name] = header_value
         self._api_client.user_agent = user_agent
 
+        self._session = requests.Session()
+        adapter = HTTPAdapter(max_retries=_build_urllib3_retry(self._retry_config))
+        self._session.mount("http://", adapter)
+        self._session.mount("https://", adapter)
+
         self._entities_api = apis.EntitiesApi(self._api_client)
         self._layout_api = apis.LayoutApi(self._api_client)
         self._actions_api = apis.ActionsApi(self._api_client)
@@ -110,7 +211,7 @@ class GoodDataApiClient:
         if not self._hostname.endswith("/"):
             endpoint = f"/{endpoint}"
 
-        response = requests.post(
+        response = self._session.post(
             url=f"{self._hostname}{endpoint}",
             headers={
                 "Content-Type": content_type,

{gooddata_sdk-1.66.1.dev1 → gooddata_sdk-1.68.0}/src/gooddata_sdk/compute/model/filter.py

@@ -326,7 +326,7 @@ class RelativeDateFilter(Filter):
         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 @@ class AllTimeDateFilter(Filter):
 
         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 @@ class AbsoluteDateFilter(Filter):
         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: