gooddata-sdk 1.65.0__tar.gz → 1.65.1.dev2__tar.gz

{gooddata_sdk-1.65.0 → gooddata_sdk-1.65.1.dev2}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: gooddata-sdk
-Version: 1.65.0
+Version: 1.65.1.dev2
 Summary: GoodData Cloud Python SDK
-Project-URL: Documentation, https://www.gooddata.ai/docs/python-sdk/1.65.0
+Project-URL: Documentation, https://www.gooddata.ai/docs/python-sdk/1.65.1.dev2
 Project-URL: Source, https://github.com/gooddata/gooddata-python-sdk
 Author-email: GoodData <support@gooddata.com>
 License-Expression: MIT
@@ -23,8 +23,8 @@ 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.65.0
-Requires-Dist: gooddata-code-convertors
+Requires-Dist: gooddata-api-client~=1.65.1.dev2
+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
 Requires-Dist: pyyaml>=6.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.65.0) for more details.
+See [DOCUMENTATION](https://www.gooddata.ai/docs/python-sdk/1.65.1.dev2) for more details.
 
 ## Requirements
 

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

{gooddata_sdk-1.65.0 → gooddata_sdk-1.65.1.dev2}/pyproject.toml

@@ -1,7 +1,7 @@
 # (C) 2025 GoodData Corporation
 [project]
 name = "gooddata-sdk"
-version = "1.65.0"
+version = "1.65.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.65.0",
+    "gooddata-api-client~=1.65.1.dev2",
     "python-dateutil>=2.5.3",
     "pyyaml>=6.0",
     "attrs>=21.4.0,<=24.2.0",
@@ -34,7 +34,7 @@ dependencies = [
     "brotli==1.2.0",
     "requests~=2.32.0",
     "python-dotenv>=1.0.0,<2.0.0",
-    "gooddata-code-convertors",
+    "gooddata-code-convertors>=11.35.0a2",
 ]
 classifiers = [
     "Development Status :: 5 - Production/Stable",
@@ -54,7 +54,7 @@ classifiers = [
 arrow = ["pyarrow>=23.0.1"]
 
 [project.urls]
-Documentation = "https://www.gooddata.ai/docs/python-sdk/1.65.0"
+Documentation = "https://www.gooddata.ai/docs/python-sdk/1.65.1.dev2"
 Source = "https://github.com/gooddata/gooddata-python-sdk"
 
 [project.scripts]

{gooddata_sdk-1.65.0 → gooddata_sdk-1.65.1.dev2}/src/gooddata_sdk/__init__.py

@@ -7,6 +7,11 @@ At the moment the SDK provides services to inspect and interact with the Semanti
 import logging
 
 from gooddata_sdk._version import __version__
+from gooddata_sdk.catalog.ai_lake.service import (
+    CatalogAILakeOperation,
+    CatalogAILakeOperationError,
+    CatalogAILakeService,
+)
 from gooddata_sdk.catalog.appearance.entity_model.color_palette import (
     CatalogColorPalette,
     CatalogColorPaletteAttributes,
@@ -132,7 +137,12 @@ from gooddata_sdk.catalog.organization.layout.notification_channel import (
     CatalogDeclarativeNotificationChannel,
     CatalogWebhook,
 )
-from gooddata_sdk.catalog.organization.service import CatalogOrganizationService
+from gooddata_sdk.catalog.organization.service import (
+    HLL_TYPE_SETTING_ID,
+    HLL_TYPE_SETTING_TYPE,
+    CatalogOrganizationService,
+    HLLType,
+)
 from gooddata_sdk.catalog.permission.declarative_model.dashboard_assignees import (
     CatalogAvailableAssignees,
     CatalogUserAssignee,

gooddata_sdk-1.65.1.dev2/src/gooddata_sdk/catalog/ai_lake/service.py

@@ -0,0 +1,144 @@
+# (C) 2026 GoodData Corporation
+"""SDK wrapper for the AI Lake long-running-operation surface.
+
+Today this exposes only the operations needed by aggregate-aware LDMs:
+
+- `analyze_statistics` triggers `ANALYZE TABLE` over a database instance so
+  CBO statistics catch up after a schema or data change. Required after
+  registering a pre-aggregation table whose dim attributes the platform will
+  later resolve via filter pushdown.
+- `get_operation` and `wait_for_operation` cover the polling side of the
+  long-running operation contract that `analyze_statistics` returns.
+
+The full AI Lake API surface (database provisioning, pipe-table
+registration, service commands) is not yet wrapped here; consumers that
+need those should call `client.ai_lake_api.<method>` directly until a
+ticket adds typed wrappers.
+"""
+
+from __future__ import annotations
+
+import time
+import uuid
+from typing import Any, Literal
+
+from attrs import define
+from gooddata_api_client.api.ai_lake_api import AILakeApi
+from gooddata_api_client.model.analyze_statistics_request import AnalyzeStatisticsRequest
+
+from gooddata_sdk.catalog.base import Base
+from gooddata_sdk.client import GoodDataApiClient
+
+# AI Lake operation status values (lower-case on the wire — these are the
+# discriminator values of the `Operation` oneOf on the OpenAPI side).
+OperationStatus = Literal["pending", "succeeded", "failed"]
+TERMINAL_STATUSES: frozenset[OperationStatus] = frozenset({"succeeded", "failed"})
+
+
+@define(kw_only=True)
+class CatalogAILakeOperation(Base):
+    """Long-running-operation handle returned by AI Lake actions."""
+
+    id: str
+    kind: str
+    status: OperationStatus
+    result: dict[str, Any] | None = None
+    error: dict[str, Any] | None = None
+
+    @property
+    def is_terminal(self) -> bool:
+        return self.status in TERMINAL_STATUSES
+
+    @property
+    def is_succeeded(self) -> bool:
+        return self.status == "succeeded"
+
+    @property
+    def is_failed(self) -> bool:
+        return self.status == "failed"
+
+
+class CatalogAILakeOperationError(RuntimeError):
+    """Raised when an AI Lake long-running operation finishes in `failed` state."""
+
+    def __init__(self, operation: CatalogAILakeOperation) -> None:
+        self.operation = operation
+        message = f"AI Lake operation {operation.id} ({operation.kind}) failed"
+        if operation.error:
+            message = f"{message}: {operation.error}"
+        super().__init__(message)
+
+
+class CatalogAILakeService:
+    """Typed access to the AI Lake long-running-operation surface."""
+
+    def __init__(self, api_client: GoodDataApiClient) -> None:
+        self._client = api_client
+        self._ai_lake_api: AILakeApi = AILakeApi(api_client._api_client)
+
+    def analyze_statistics(
+        self,
+        instance_id: str,
+        table_names: list[str] | None = None,
+        operation_id: str | None = None,
+    ) -> str:
+        """Trigger ANALYZE TABLE for tables in an AI Lake database instance.
+
+        Args:
+            instance_id: Database instance name (preferred) or UUID.
+            table_names: Tables to analyze; if `None` or empty, every table
+                in the instance is analyzed.
+            operation_id: Optional client-supplied operation identifier. If
+                omitted, a fresh UUID is generated. Pass the same value that
+                `wait_for_operation` will poll on.
+
+        Returns:
+            The operation ID (UUID string) the platform will track this run
+            under. Pass it to `get_operation` / `wait_for_operation` to poll.
+        """
+        op_id = operation_id or str(uuid.uuid4())
+        request = AnalyzeStatisticsRequest(table_names=list(table_names) if table_names else [])
+        # Body return is `Unit`; the platform tracks the operation under the
+        # client-supplied or server-generated `operation-id` header. We seed
+        # it ourselves so the caller gets a known polling handle without
+        # having to read response headers.
+        self._ai_lake_api.analyze_statistics(instance_id, request, operation_id=op_id)
+        return op_id
+
+    def get_operation(self, operation_id: str) -> CatalogAILakeOperation:
+        """Fetch the current state of a long-running AI Lake operation."""
+        response = self._ai_lake_api.get_ai_lake_operation(operation_id)
+        # The api-client returns the oneOf'd operation as a dict-like object
+        # whose concrete subtype depends on `status`. Normalize via to_dict.
+        data = response.to_dict() if hasattr(response, "to_dict") else dict(response)
+        return CatalogAILakeOperation(
+            id=data["id"],
+            kind=data["kind"],
+            status=data["status"],
+            result=data.get("result"),
+            error=data.get("error"),
+        )
+
+    def wait_for_operation(
+        self,
+        operation_id: str,
+        timeout_s: float = 300.0,
+        poll_s: float = 2.0,
+    ) -> CatalogAILakeOperation:
+        """Block until an AI Lake operation reaches a terminal status.
+
+        Raises `CatalogAILakeOperationError` on `failed` and `TimeoutError`
+        if the operation does not reach a terminal state in time.
+        """
+        deadline = time.monotonic() + timeout_s
+        while True:
+            op = self.get_operation(operation_id)
+            if op.is_succeeded:
+                return op
+            if op.is_failed:
+                raise CatalogAILakeOperationError(op)
+            if time.monotonic() >= deadline:
+                raise TimeoutError(
+                    f"AI Lake operation {operation_id} did not finish within {timeout_s}s (last status: {op.status})"
+                )
+            time.sleep(poll_s)

{gooddata_sdk-1.65.0 → gooddata_sdk-1.65.1.dev2}/src/gooddata_sdk/catalog/identifier.py

@@ -15,10 +15,10 @@ from gooddata_api_client.model.declarative_notification_channel_identifier impor
 )
 from gooddata_api_client.model.declarative_user_group_identifier import DeclarativeUserGroupIdentifier
 from gooddata_api_client.model.declarative_user_identifier import DeclarativeUserIdentifier
-from gooddata_api_client.model.fact_identifier import FactIdentifier
 from gooddata_api_client.model.grain_identifier import GrainIdentifier
 from gooddata_api_client.model.label_identifier import LabelIdentifier
 from gooddata_api_client.model.reference_identifier import ReferenceIdentifier
+from gooddata_api_client.model.source_reference_identifier import SourceReferenceIdentifier
 from gooddata_api_client.model.workspace_identifier import WorkspaceIdentifier
 
 from gooddata_sdk.catalog.base import Base, value_in_allowed
@@ -84,12 +84,16 @@ class CatalogUserIdentifier(Base):
 
 @define(kw_only=True)
 class CatalogFactIdentifier(Base):
+    # Backed by SourceReferenceIdentifier on the API side: the backend
+    # consolidated FactIdentifier into a polymorphic identifier whose `type`
+    # is FACT or ATTRIBUTE, so a single reference shape now covers both
+    # plain facts and HLL APPROXIMATE_COUNT targets (which point at attributes).
     id: str
     type: str = field(validator=value_in_allowed)
 
     @staticmethod
-    def client_class() -> builtins.type[FactIdentifier]:
-        return FactIdentifier
+    def client_class() -> builtins.type[SourceReferenceIdentifier]:
+        return SourceReferenceIdentifier
 
 
 @define(kw_only=True)

{gooddata_sdk-1.65.0 → gooddata_sdk-1.65.1.dev2}/src/gooddata_sdk/catalog/organization/service.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 import functools
-from typing import Any
+from typing import Any, Literal
 
 from gooddata_api_client.exceptions import NotFoundException
 from gooddata_api_client.model.declarative_export_templates import DeclarativeExportTemplates
@@ -35,6 +35,16 @@ from gooddata_sdk.catalog.organization.layout.notification_channel import Catalo
 from gooddata_sdk.client import GoodDataApiClient
 from gooddata_sdk.utils import load_all_entities, load_all_entities_dict
 
+# Org-level setting controlling which HLL function family calcique uses when
+# generating SQL over HLL synopses. `Native` (default) emits StarRocks-native
+# `HLL_*` functions; `Presto` emits the Presto-compatible HLL function family
+# and assumes the StarRocks deployment carries the Presto HLL UDFs. Pick
+# `Presto` when synopses are produced by an upstream Presto pipeline (the
+# binary layout / hash family differ between the two).
+HLLType = Literal["Native", "Presto"]
+HLL_TYPE_SETTING_ID = "hyperLogLogType"
+HLL_TYPE_SETTING_TYPE = "HLL_TYPE"
+
 
 class CatalogOrganizationService(CatalogServiceBase):
     def __init__(self, api_client: GoodDataApiClient) -> None:
@@ -217,6 +227,40 @@ class CatalogOrganizationService(CatalogServiceBase):
                 f"This organization setting does not exist."
             )
 
+    def set_hll_type(self, value: HLLType) -> None:
+        """Set the organization-level HyperLogLog function family.
+
+        Idempotent: creates the `hyperLogLogType` setting if missing,
+        otherwise updates the existing one. The platform exposes this as
+        the `HLL_TYPE` org setting (gdc-nas `HLL_TYPE("hyperLogLogType",
+        SettingConfiguration.HyperLogLogType)`).
+
+        Args:
+            value: `"Native"` for StarRocks-native HLL functions (default
+                on the platform side), or `"Presto"` for Presto-compatible
+                HLL functions (use when synopses come from a Presto
+                pipeline; requires the Presto HLL UDFs registered in
+                StarRocks).
+        """
+        setting = CatalogOrganizationSetting.init(
+            setting_id=HLL_TYPE_SETTING_ID,
+            setting_type=HLL_TYPE_SETTING_TYPE,
+            content={"value": value},
+        )
+        try:
+            self.update_organization_setting(setting)
+        except ValueError:
+            self.create_organization_setting(setting)
+
+    def get_hll_type(self) -> HLLType | None:
+        """Return the current `hyperLogLogType` value, or `None` if unset."""
+        try:
+            setting = self.get_organization_setting(HLL_TYPE_SETTING_ID)
+        except NotFoundException:
+            return None
+        value = setting.attributes.content.get("value")
+        return value if value in ("Native", "Presto") else None
+
     def update_organization_setting(self, organization_setting: CatalogOrganizationSetting) -> None:
         """Update an organization setting.
 

{gooddata_sdk-1.65.0 → gooddata_sdk-1.65.1.dev2}/src/gooddata_sdk/catalog/workspace/declarative_model/workspace/logical_model/dataset/dataset.py

@@ -1,7 +1,9 @@
 # (C) 2022 GoodData Corporation
 from __future__ import annotations
 
+import builtins
 from pathlib import Path
+from typing import Literal
 
 from attrs import define, field
 from gooddata_api_client.model.data_source_table_identifier import DataSourceTableIdentifier
@@ -14,7 +16,7 @@ from gooddata_api_client.model.declarative_label import DeclarativeLabel
 from gooddata_api_client.model.declarative_label_translation import DeclarativeLabelTranslation
 from gooddata_api_client.model.declarative_reference import DeclarativeReference
 from gooddata_api_client.model.declarative_reference_source import DeclarativeReferenceSource
-from gooddata_api_client.model.declarative_source_fact_reference import DeclarativeSourceFactReference
+from gooddata_api_client.model.declarative_source_reference import DeclarativeSourceReference
 from gooddata_api_client.model.declarative_workspace_data_filter_column import DeclarativeWorkspaceDataFilterColumn
 from gooddata_api_client.model.geo_area_config import GeoAreaConfig
 from gooddata_api_client.model.geo_collection_identifier import GeoCollectionIdentifier
@@ -36,6 +38,16 @@ LAYOUT_DATASETS_DIR = "datasets"
 
 @define(kw_only=True)
 class CatalogDeclarativeDataset(Base):
+    # NOTE: this single class models both NORMAL and AUXILIARY datasets, mirroring
+    # the api-client schema where the two are distinguished only by the `type`
+    # discriminator. The platform validator enforces field exclusions per type
+    # (e.g. AUXILIARY must NOT have `aggregatedFacts`, `sql`, `dataSourceTableId`,
+    # `workspaceDataFilterReferences`, or `precedence`); they are not type-checked
+    # here. TODO: optionally add typed factory constructors
+    # `CatalogDeclarativeDataset.normal(...)` / `.auxiliary(...)` that set
+    # type-appropriate defaults and reject contradictory args, giving consumers
+    # safer construction without splitting into two classes (which would diverge
+    # from the api-client one-schema-with-discriminator design).
     id: str
     title: str
     grain: list[CatalogGrainIdentifier]
@@ -48,11 +60,18 @@ class CatalogDeclarativeDataset(Base):
     data_source_table_id: CatalogDataSourceTableIdentifier | None = None
     sql: CatalogDeclarativeDatasetSql | None = None
     tags: list[str] | None = None
+    # Mirrors the api-client `DeclarativeDataset.allowed_values["type"]`. Kept as
+    # a Literal for IDE / mypy autocomplete; if the platform adds a new dataset
+    # type, regenerate the api-client and extend this Literal in lockstep.
+    type: Literal["NORMAL", "AUXILIARY"] | None = None
     workspace_data_filter_columns: list[CatalogDeclarativeWorkspaceDataFilterColumn] | None = None
     workspace_data_filter_references: list[CatalogDeclarativeWorkspaceDataFilterReferences] | None = None
 
     @staticmethod
-    def client_class() -> type[DeclarativeDataset]:
+    def client_class() -> builtins.type[DeclarativeDataset]:
+        # `builtins.type[...]` (not bare `type[...]`) because the class
+        # defines a `type: Literal[...]` field that shadows the builtin
+        # inside the class body, which trips ty.
         return DeclarativeDataset
 
     def store_to_disk(self, datasets_folder: Path, sort: bool = False) -> None:
@@ -69,8 +88,10 @@ class CatalogDeclarativeDataset(Base):
 class CatalogDeclarativeAttribute(Base):
     id: str
     title: str
-    source_column: str
-    labels: list[CatalogDeclarativeLabel]
+    # `source_column` is optional in the OpenAPI spec and must be omitted on
+    # AUXILIARY datasets, where attributes are synthetic (no physical column).
+    source_column: str | None = None
+    labels: list[CatalogDeclarativeLabel] = field(factory=list)
     source_column_data_type: str | None = None
     default_view: CatalogLabelIdentifier | None = None
     sort_column: str | None = None
@@ -91,7 +112,9 @@ class CatalogDeclarativeAttribute(Base):
 class CatalogDeclarativeFact(Base):
     id: str
     title: str
-    source_column: str
+    # Optional in the OpenAPI spec and omitted on AUXILIARY datasets, whose
+    # facts are synthetic (no physical column on the AUX itself).
+    source_column: str | None = None
     source_column_data_type: str | None = None
     description: str | None = None
     tags: list[str] | None = None
@@ -106,12 +129,15 @@ class CatalogDeclarativeFact(Base):
 
 @define(kw_only=True)
 class CatalogDeclarativeSourceFactReference(Base):
+    # Backed by DeclarativeSourceReference on the API side: the reference now
+    # accepts both FACT and ATTRIBUTE targets (the latter is required for HLL
+    # APPROXIMATE_COUNT, which aggregates over an attribute).
     operation: str
     reference: CatalogFactIdentifier
 
     @staticmethod
-    def client_class() -> type[DeclarativeSourceFactReference]:
-        return DeclarativeSourceFactReference
+    def client_class() -> type[DeclarativeSourceReference]:
+        return DeclarativeSourceReference
 
 
 @define(kw_only=True)
@@ -165,7 +191,9 @@ class CatalogDeclarativeLabelTranslation(Base):
 class CatalogDeclarativeLabel(Base):
     id: str
     title: str
-    source_column: str
+    # Optional in the OpenAPI spec; AUXILIARY datasets don't carry physical
+    # columns, so labels there must be representable without `source_column`.
+    source_column: str | None = None
     source_column_data_type: str | None = None
     description: str | None = None
     tags: list[str] | None = None

{gooddata_sdk-1.65.0 → gooddata_sdk-1.65.1.dev2}/src/gooddata_sdk/client.py

@@ -3,6 +3,7 @@
 
 from __future__ import annotations
 
+import os
 from pathlib import Path
 
 import gooddata_api_client as api_client
@@ -26,6 +27,7 @@ class GoodDataApiClient:
         extra_user_agent: str | None = None,
         executions_cancellable: bool = False,
         ssl_ca_cert: str | None = None,
+        proxy: str | None = None,
     ) -> None:
         """Take url, token for connecting to GoodData.CN.
 
@@ -38,6 +40,10 @@ class GoodDataApiClient:
         `executions_cancellable` is a flag that sets all executions computed through this client as cancellable.
         In case a request for a result is interrupted, the GD server will try to free resources like killing sql queries
         related to the given execution.
+
+        `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.
         """
         self._hostname = host
         self._token = token
@@ -53,7 +59,18 @@ class GoodDataApiClient:
                     f"ssl_ca_cert file path specified but the file does not exist. Path: {ssl_ca_cert_path}."
                 )
 
+        if proxy is None:
+            proxy = (
+                os.environ.get("HTTPS_PROXY")
+                or os.environ.get("https_proxy")
+                or os.environ.get("HTTP_PROXY")
+                or os.environ.get("http_proxy")
+                or None
+            )
+
         self._api_config = api_client.Configuration(host=host, ssl_ca_cert=ssl_ca_cert)
+        if proxy:
+            self._api_config.proxy = proxy
         self._api_client = api_client.ApiClient(
             configuration=self._api_config,
             header_name="Authorization",
@@ -71,6 +88,7 @@ class GoodDataApiClient:
         self._actions_api = apis.ActionsApi(self._api_client)
         self._user_management_api = apis.UserManagementApi(self._api_client)
         self._appearance_api = apis.AppearanceApi(self._api_client)
+        self._ai_lake_api = apis.AILakeApi(self._api_client)
         self._executions_cancellable = executions_cancellable
 
     def _do_post_request(
@@ -158,6 +176,10 @@ class GoodDataApiClient:
     def appearance_api(self) -> apis.AppearanceApi:
         return self._appearance_api
 
+    @property
+    def ai_lake_api(self) -> apis.AILakeApi:
+        return self._ai_lake_api
+
     @property
     def executions_cancellable(self) -> bool:
         return self._executions_cancellable

{gooddata_sdk-1.65.0 → gooddata_sdk-1.65.1.dev2}/src/gooddata_sdk/sdk.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 from pathlib import Path
 
+from gooddata_sdk.catalog.ai_lake.service import CatalogAILakeService
 from gooddata_sdk.catalog.appearance.service import CatalogAppearanceService
 from gooddata_sdk.catalog.data_source.service import CatalogDataSourceService
 from gooddata_sdk.catalog.export.service import ExportService
@@ -49,6 +50,7 @@ class GoodDataSdk:
         *,
         ssl_ca_cert: str | None = None,
         executions_cancellable: bool = False,
+        proxy: str | None = None,
         **custom_headers_: str | None,
     ) -> GoodDataSdk:
         """
@@ -56,6 +58,10 @@ class GoodDataSdk:
         Custom headers are filtered. Headers with None value are removed. It simplifies usage because headers
         can be created directly from optional values.
 
+        ``proxy`` is an optional HTTP(S) proxy URL (e.g. ``http://proxy:8080``).
+        When not set, the standard ``HTTPS_PROXY`` / ``https_proxy`` / ``HTTP_PROXY``
+        / ``http_proxy`` environment variables are checked automatically.
+
         This is preferred way of creating GoodDataSdk, when no tweaks are needed.
         """
         filtered_headers = {key: value for key, value in custom_headers_.items() if value is not None}
@@ -66,6 +72,7 @@ class GoodDataSdk:
             extra_user_agent=extra_user_agent_,
             executions_cancellable=executions_cancellable,
             ssl_ca_cert=ssl_ca_cert,
+            proxy=proxy,
         )
         return cls(client)
 
@@ -88,6 +95,7 @@ class GoodDataSdk:
         self._tables = TableService(self._client)
         self._support = SupportService(self._client)
         self._catalog_permission = CatalogPermissionService(self._client)
+        self._catalog_ai_lake = CatalogAILakeService(self._client)
         self._export = ExportService(self._client)
 
     @property
@@ -138,6 +146,10 @@ class GoodDataSdk:
     def export(self) -> ExportService:
         return self._export
 
+    @property
+    def catalog_ai_lake(self) -> CatalogAILakeService:
+        return self._catalog_ai_lake
+
     @property
     def client(self) -> GoodDataApiClient:
         return self._client

{gooddata_sdk-1.65.0 → gooddata_sdk-1.65.1.dev2}/tests/catalog/test_aac.py

@@ -1,6 +1,8 @@
 # (C) 2026 GoodData Corporation
 from __future__ import annotations
 
+import shutil
+import tempfile
 from pathlib import Path
 
 import yaml
@@ -16,6 +18,9 @@ from gooddata_sdk.catalog.workspace.aac import (
     load_aac_workspace_from_disk,
     store_aac_workspace_to_disk,
 )
+from gooddata_sdk.catalog.workspace.declarative_model.workspace.workspace import (
+    CatalogDeclarativeWorkspaceModel,
+)
 from gooddata_sdk.config import AacConfig
 
 _FIXTURES_DIR = Path(__file__).parent / "unit_tests" / "aac_tests"
@@ -243,9 +248,6 @@ class TestWorkspaceLoadStore:
     def test_load_aac_workspace_from_fixtures(self) -> None:
         """Load fixtures excluding dashboards (WASM crypto limitation)."""
         # Use a temp dir with only datasets, metrics, visualizations
-        import shutil
-        import tempfile
-
         with tempfile.TemporaryDirectory() as tmp:
             tmp_path = Path(tmp)
             for subdir in ("datasets", "metrics", "visualisations"):
@@ -280,10 +282,6 @@ class TestWorkspaceLoadStore:
         metrics_declarative = [aac_metric_to_declarative(m) for m in aac_metrics]
 
         model_dict = {"analytics": {"metrics": metrics_declarative}}
-        from gooddata_sdk.catalog.workspace.declarative_model.workspace.workspace import (
-            CatalogDeclarativeWorkspaceModel,
-        )
-
         model = CatalogDeclarativeWorkspaceModel.from_dict(model_dict)
         store_aac_workspace_to_disk(model, tmp_path)
 
@@ -316,10 +314,6 @@ class TestWorkspaceLoadStore:
         vis_declarative = [aac_visualization_to_declarative(aac_vis)]
 
         model_dict = {"analytics": {"visualizationObjects": vis_declarative}}
-        from gooddata_sdk.catalog.workspace.declarative_model.workspace.workspace import (
-            CatalogDeclarativeWorkspaceModel,
-        )
-
         model = CatalogDeclarativeWorkspaceModel.from_dict(model_dict)
         store_aac_workspace_to_disk(model, tmp_path)
 
@@ -334,9 +328,6 @@ class TestWorkspaceLoadStore:
 
     def test_store_and_reload_from_fixtures(self, tmp_path: Path) -> None:
         """Load fixtures, store to disk, reload — full round-trip."""
-        import shutil
-        import tempfile
-
         with tempfile.TemporaryDirectory() as tmp:
             fixture_path = Path(tmp)
             for subdir in ("datasets", "metrics", "visualisations"):

{gooddata_sdk-1.65.0 → gooddata_sdk-1.65.1.dev2}/tests/catalog/test_catalog_user_service.py

@@ -37,11 +37,12 @@ from gooddata_sdk import (
     GoodDataApiClient,
     GoodDataSdk,
 )
+from gooddata_sdk.catalog.permission.declarative_model.permission import CatalogDeclarativeWorkspacePermissions
 from gooddata_sdk.utils import recreate_directory
 from tests_support.file_utils import load_json
 from tests_support.vcrpy_utils import get_vcr
 
-from .conftest import safe_delete
+from .conftest import load_expected_data_sources, safe_delete
 
 gd_vcr = get_vcr()
 
@@ -194,8 +195,6 @@ def _restore_demo2_permissions(sdk: GoodDataSdk, test_config: dict) -> None:
     Note: This function makes HTTP calls. When used in tests with VCR cassettes,
     ensure the cassette includes the restoration calls (in finally blocks).
     """
-    from .conftest import load_expected_data_sources
-
     # Restore data source permissions
     expected_ds_path = _current_dir / "expected" / "declarative_data_sources.json"
     credentials_path = _current_dir / "load" / "data_source_credentials" / "data_sources_credentials.yaml"
@@ -203,8 +202,6 @@ def _restore_demo2_permissions(sdk: GoodDataSdk, test_config: dict) -> None:
     sdk.catalog_data_source.put_declarative_data_sources(data_sources, credentials_path)
 
     # Restore workspace permissions
-    from gooddata_sdk.catalog.permission.declarative_model.permission import CatalogDeclarativeWorkspacePermissions
-
     expected_ws_path = _current_dir / "expected" / "declarative_workspace_permissions.json"
     ws_data = load_json(expected_ws_path)
     ws_permissions = CatalogDeclarativeWorkspacePermissions.from_dict(ws_data, camel_case=True)