gooddata-sdk 1.60.1.dev2__tar.gz → 1.61.1.dev1__tar.gz

{gooddata_sdk-1.60.1.dev2 → gooddata_sdk-1.61.1.dev1}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: gooddata-sdk
-Version: 1.60.1.dev2
+Version: 1.61.1.dev1
 Summary: GoodData Cloud Python SDK
-Project-URL: Documentation, https://www.gooddata.com/docs/python-sdk/1.60.1.dev2
+Project-URL: Documentation, https://www.gooddata.com/docs/python-sdk/1.61.1.dev1
 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.60.1.dev2
+Requires-Dist: gooddata-api-client~=1.61.1.dev1
 Requires-Dist: python-dateutil>=2.5.3
 Requires-Dist: python-dotenv<2.0.0,>=1.0.0
 Requires-Dist: pyyaml>=6.0
@@ -45,7 +45,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.60.1.dev2) for more details.
+See [DOCUMENTATION](https://www.gooddata.com/docs/python-sdk/1.61.1.dev1) for more details.
 
 ## Requirements
 

{gooddata_sdk-1.60.1.dev2 → gooddata_sdk-1.61.1.dev1}/README.md

@@ -13,7 +13,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.60.1.dev2) for more details.
+See [DOCUMENTATION](https://www.gooddata.com/docs/python-sdk/1.61.1.dev1) for more details.
 
 ## Requirements
 

{gooddata_sdk-1.60.1.dev2 → gooddata_sdk-1.61.1.dev1}/pyproject.toml

@@ -1,7 +1,7 @@
 # (C) 2025 GoodData Corporation
 [project]
 name = "gooddata-sdk"
-version = "1.60.1.dev2"
+version = "1.61.1.dev1"
 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.60.1.dev2",
+    "gooddata-api-client~=1.61.1.dev1",
     "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.60.1.dev2"
+Documentation = "https://www.gooddata.com/docs/python-sdk/1.61.1.dev1"
 Source = "https://github.com/gooddata/gooddata-python-sdk"
 
 [project.scripts]

{gooddata_sdk-1.60.1.dev2 → gooddata_sdk-1.61.1.dev1}/src/gooddata_sdk/__init__.py

@@ -29,6 +29,7 @@ from gooddata_sdk.catalog.data_source.entity_model.data_source import (
     CatalogDataSource,
     CatalogDataSourceBigQuery,
     CatalogDataSourceDatabricks,
+    CatalogDataSourceGdStorage,
     CatalogDataSourceGreenplum,
     CatalogDataSourceMariaDb,
     CatalogDataSourceMotherDuck,
@@ -103,6 +104,19 @@ from gooddata_sdk.catalog.organization.entity_model.llm_endpoint import (
     CatalogLlmEndpoint,
     CatalogLlmEndpointDocument,
 )
+from gooddata_sdk.catalog.organization.entity_model.llm_provider import (
+    CatalogAwsBedrockProviderConfig,
+    CatalogAzureFoundryApiKeyAuth,
+    CatalogAzureFoundryProviderConfig,
+    CatalogBedrockAccessKeyAuth,
+    CatalogLlmProvider,
+    CatalogLlmProviderDocument,
+    CatalogLlmProviderModel,
+    CatalogLlmProviderPatch,
+    CatalogLlmProviderPatchDocument,
+    CatalogOpenAiApiKeyAuth,
+    CatalogOpenAiProviderConfig,
+)
 from gooddata_sdk.catalog.organization.entity_model.organization import CatalogOrganization
 from gooddata_sdk.catalog.organization.entity_model.setting import CatalogOrganizationSetting
 from gooddata_sdk.catalog.organization.layout.export_template import (

{gooddata_sdk-1.60.1.dev2 → gooddata_sdk-1.61.1.dev1}/src/gooddata_sdk/catalog/data_source/entity_model/data_source.py

@@ -296,3 +296,25 @@ class MotherDuckAttributes(DatabaseAttributes):
 class CatalogDataSourceMotherDuck(CatalogDataSource):
     _URL_TMPL: ClassVar[str] = "jdbc:duckdb:md:{db_name}"
     type: str = "MOTHERDUCK"
+
+
+class _NoCredentials(Credentials):
+    """Placeholder credentials for data sources that do not require authentication."""
+
+    def to_api_args(self) -> dict[str, Any]:
+        return {}
+
+    @classmethod
+    def is_part_of_api(cls, entity: dict[str, Any]) -> bool:
+        return True
+
+    @classmethod
+    def from_api(cls, entity: dict[str, Any]) -> _NoCredentials:
+        return cls()
+
+
+@define(kw_only=True, eq=False)
+class CatalogDataSourceGdStorage(CatalogDataSource):
+    type: str = "GDSTORAGE"
+    schema: str = ""
+    credentials: Credentials = field(factory=_NoCredentials, repr=False)

{gooddata_sdk-1.60.1.dev2 → gooddata_sdk-1.61.1.dev1}/src/gooddata_sdk/catalog/data_source/service.py

@@ -6,6 +6,14 @@ from pathlib import Path
 from typing import Any, Union
 
 from gooddata_api_client.exceptions import NotFoundException
+from gooddata_api_client.model.analyze_csv_request import AnalyzeCsvRequest
+from gooddata_api_client.model.analyze_csv_request_item import AnalyzeCsvRequestItem
+from gooddata_api_client.model.analyze_csv_response import AnalyzeCsvResponse
+from gooddata_api_client.model.delete_files_request import DeleteFilesRequest
+from gooddata_api_client.model.import_csv_request import ImportCsvRequest
+from gooddata_api_client.model.import_csv_request_table import ImportCsvRequestTable
+from gooddata_api_client.model.import_csv_request_table_source import ImportCsvRequestTableSource
+from gooddata_api_client.model.import_csv_request_table_source_config import ImportCsvRequestTableSourceConfig
 
 from gooddata_sdk.catalog.catalog_service_base import CatalogServiceBase
 from gooddata_sdk.catalog.data_source.action_model.requests.ldm_request import (
@@ -504,6 +512,108 @@ class CatalogDataSourceService(CatalogServiceBase):
                 message.append(f"Test connection for data source id {k} ended with the following error {v}.")
             raise ValueError("\n".join(message))
 
+    def staging_upload(self, csv_file: Path) -> str:
+        """Upload a CSV file to the staging area.
+
+        Args:
+            csv_file (Path):
+                Path to the CSV file to upload.
+
+        Returns:
+            str:
+                Location string referencing the uploaded file in staging.
+        """
+        with open(csv_file, "rb") as f:
+            response = self._actions_api.staging_upload(file=f)
+        return response["location"]
+
+    def analyze_csv(self, location: str) -> AnalyzeCsvResponse:
+        """Analyze an uploaded CSV file in the staging area.
+
+        Returns column metadata, detected types, and a config object
+        that can be passed directly to import_csv.
+
+        Args:
+            location (str):
+                Location string returned by staging_upload.
+
+        Returns:
+            AnalyzeCsvResponse:
+                Analysis result with columns, preview data, and config.
+        """
+        request = AnalyzeCsvRequest(analyze_requests=[AnalyzeCsvRequestItem(location=location)])
+        responses = self._actions_api.analyze_csv(request, _check_return_type=False)
+        return responses[0]
+
+    def import_csv(
+        self,
+        data_source_id: str,
+        table_name: str,
+        location: str,
+        config: dict[str, Any] | None = None,
+    ) -> None:
+        """Import a CSV file from staging into a GDSTORAGE data source.
+
+        Args:
+            data_source_id (str):
+                Data source identification string.
+            table_name (str):
+                Name for the table to create or replace.
+            location (str):
+                Location string returned by staging_upload.
+            config (Optional[dict[str, Any]]):
+                Source config dict, typically from analyze_csv response.
+                Passed as ImportCsvRequestTableSourceConfig kwargs.
+
+        Returns:
+            None
+        """
+        source_kwargs: dict[str, Any] = {"location": location}
+        if config:
+            source_kwargs["config"] = ImportCsvRequestTableSourceConfig(**config)
+        source = ImportCsvRequestTableSource(**source_kwargs)
+        table = ImportCsvRequestTable(name=table_name, source=source)
+        request = ImportCsvRequest(tables=[table])
+        self._actions_api.import_csv(data_source_id, request)
+
+    def delete_csv_files(self, data_source_id: str, file_names: list[str]) -> None:
+        """Delete files from a GDSTORAGE data source.
+
+        Args:
+            data_source_id (str):
+                Data source identification string.
+            file_names (list[str]):
+                List of file names to delete.
+
+        Returns:
+            None
+        """
+        request = DeleteFilesRequest(file_names=file_names)
+        self._actions_api.delete_files(data_source_id, request)
+
+    def upload_csv(self, data_source_id: str, csv_file: Path, table_name: str) -> None:
+        """Upload a CSV file and import it into a GDSTORAGE data source.
+
+        Convenience method that orchestrates the full flow:
+        staging_upload → analyze_csv → import_csv → register_upload_notification.
+
+        Args:
+            data_source_id (str):
+                Data source identification string for a GDSTORAGE data source.
+            csv_file (Path):
+                Path to the CSV file to upload.
+            table_name (str):
+                Name for the table to create or replace in the data source.
+
+        Returns:
+            None
+        """
+        location = self.staging_upload(csv_file)
+        analysis = self.analyze_csv(location)
+        config = analysis.to_dict().get("config")
+        self.import_csv(data_source_id, table_name, location, config=config)
+        self.register_upload_notification(data_source_id)
+
     # Help methods are listed below
 
     @staticmethod

gooddata_sdk-1.61.1.dev1/src/gooddata_sdk/catalog/organization/entity_model/llm_provider.py

@@ -0,0 +1,336 @@
+# (C) 2026 GoodData Corporation
+from __future__ import annotations
+
+from typing import Any, Union
+
+from attr import define
+from gooddata_api_client.model.aws_bedrock_provider_config import AwsBedrockProviderConfig
+from gooddata_api_client.model.azure_foundry_provider_auth import AzureFoundryProviderAuth
+from gooddata_api_client.model.azure_foundry_provider_config import AzureFoundryProviderConfig
+from gooddata_api_client.model.bedrock_provider_auth import BedrockProviderAuth
+from gooddata_api_client.model.json_api_llm_provider_in import JsonApiLlmProviderIn
+from gooddata_api_client.model.json_api_llm_provider_in_attributes import JsonApiLlmProviderInAttributes
+from gooddata_api_client.model.json_api_llm_provider_in_attributes_models_inner import (
+    JsonApiLlmProviderInAttributesModelsInner,
+)
+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_attributes import JsonApiLlmProviderPatchAttributes
+from gooddata_api_client.model.json_api_llm_provider_patch_document import JsonApiLlmProviderPatchDocument
+from gooddata_api_client.model.open_ai_provider_auth import OpenAiProviderAuth
+from gooddata_api_client.model.open_ai_provider_config import OpenAIProviderConfig
+
+from gooddata_sdk.catalog.base import Base
+from gooddata_sdk.utils import safeget
+
+# --- OpenAI auth ---
+
+
+@define(kw_only=True)
+class CatalogOpenAiApiKeyAuth(Base):
+    """API key authentication for the OpenAI provider."""
+
+    api_key: str | None = None
+    type: str = "API_KEY"
+
+    @staticmethod
+    def client_class() -> type[OpenAiProviderAuth]:
+        return OpenAiProviderAuth
+
+
+CatalogOpenAiAuth = Union[CatalogOpenAiApiKeyAuth]
+
+# --- AWS Bedrock auth ---
+
+
+@define(kw_only=True)
+class CatalogBedrockAccessKeyAuth(Base):
+    """AWS access key authentication for the Bedrock provider."""
+
+    access_key_id: str | None = None
+    secret_access_key: str | None = None
+    session_token: str | None = None
+    type: str = "ACCESS_KEY"
+
+    @staticmethod
+    def client_class() -> type[BedrockProviderAuth]:
+        return BedrockProviderAuth
+
+
+CatalogBedrockAuth = Union[CatalogBedrockAccessKeyAuth]
+
+# --- Azure Foundry auth ---
+
+
+@define(kw_only=True)
+class CatalogAzureFoundryApiKeyAuth(Base):
+    """API key authentication for the Azure Foundry provider."""
+
+    api_key: str | None = None
+    type: str = "API_KEY"
+
+    @staticmethod
+    def client_class() -> type[AzureFoundryProviderAuth]:
+        return AzureFoundryProviderAuth
+
+
+CatalogAzureFoundryAuth = Union[CatalogAzureFoundryApiKeyAuth]
+
+# --- Provider config types ---
+
+
+@define(kw_only=True)
+class CatalogOpenAiProviderConfig(Base):
+    """OpenAI provider configuration."""
+
+    auth: CatalogOpenAiAuth | None = None
+    base_url: str | None = None
+    organization: str | None = None
+    type: str = "OPENAI"
+
+    @staticmethod
+    def client_class() -> type[OpenAIProviderConfig]:
+        return OpenAIProviderConfig
+
+
+@define(kw_only=True)
+class CatalogAwsBedrockProviderConfig(Base):
+    """AWS Bedrock provider configuration."""
+
+    auth: CatalogBedrockAuth | None = None
+    region: str | None = None
+    type: str = "AWS_BEDROCK"
+
+    @staticmethod
+    def client_class() -> type[AwsBedrockProviderConfig]:
+        return AwsBedrockProviderConfig
+
+
+@define(kw_only=True)
+class CatalogAzureFoundryProviderConfig(Base):
+    """Azure Foundry provider configuration."""
+
+    auth: CatalogAzureFoundryAuth | None = None
+    endpoint: str | None = None
+    type: str = "AZURE_FOUNDRY"
+
+    @staticmethod
+    def client_class() -> type[AzureFoundryProviderConfig]:
+        return AzureFoundryProviderConfig
+
+
+CatalogLlmProviderConfig = Union[
+    CatalogOpenAiProviderConfig,
+    CatalogAwsBedrockProviderConfig,
+    CatalogAzureFoundryProviderConfig,
+]
+
+
+def _openai_auth_from_api(data: dict[str, Any]) -> CatalogOpenAiAuth:
+    auth_type = safeget(data, ["type"]) or "API_KEY"
+    if auth_type == "API_KEY":
+        return CatalogOpenAiApiKeyAuth(
+            api_key="",  # Credentials are not returned for security reasons
+            type=auth_type,
+        )
+    raise ValueError(f"Unknown OpenAI auth type: {auth_type}")
+
+
+def _bedrock_auth_from_api(data: dict[str, Any]) -> CatalogBedrockAuth:
+    auth_type = safeget(data, ["type"]) or "ACCESS_KEY"
+    if auth_type == "ACCESS_KEY":
+        return CatalogBedrockAccessKeyAuth(
+            access_key_id="",  # Credentials are not returned for security reasons
+            secret_access_key="",
+            session_token=safeget(data, ["sessionToken"]),
+            type=auth_type,
+        )
+    raise ValueError(f"Unknown Bedrock auth type: {auth_type}")
+
+
+def _azure_foundry_auth_from_api(data: dict[str, Any]) -> CatalogAzureFoundryAuth:
+    auth_type = safeget(data, ["type"]) or "API_KEY"
+    if auth_type == "API_KEY":
+        return CatalogAzureFoundryApiKeyAuth(
+            api_key="",  # Credentials are not returned for security reasons
+            type=auth_type,
+        )
+    raise ValueError(f"Unknown Azure Foundry auth type: {auth_type}")
+
+
+def _provider_config_from_api(data: dict[str, Any]) -> CatalogLlmProviderConfig:
+    provider_type = safeget(data, ["type"]) or "OPENAI"
+    auth_data = safeget(data, ["auth"])
+
+    if provider_type == "AWS_BEDROCK":
+        return CatalogAwsBedrockProviderConfig(
+            auth=_bedrock_auth_from_api(auth_data) if auth_data is not None else None,
+            region=safeget(data, ["region"]),
+        )
+
+    if provider_type == "AZURE_FOUNDRY":
+        return CatalogAzureFoundryProviderConfig(
+            auth=_azure_foundry_auth_from_api(auth_data) if auth_data is not None else None,
+            endpoint=safeget(data, ["endpoint"]),
+        )
+
+    # Default: OpenAI
+    return CatalogOpenAiProviderConfig(
+        auth=_openai_auth_from_api(auth_data) if auth_data is not None else None,
+        base_url=safeget(data, ["baseUrl"]),
+        organization=safeget(data, ["organization"]),
+    )
+
+
+# --- Document wrappers ---
+
+
+@define(kw_only=True)
+class CatalogLlmProviderDocument(Base):
+    data: CatalogLlmProvider
+
+    @staticmethod
+    def client_class() -> type[JsonApiLlmProviderInDocument]:
+        return JsonApiLlmProviderInDocument
+
+
+@define(kw_only=True)
+class CatalogLlmProviderPatchDocument(Base):
+    data: CatalogLlmProviderPatch
+
+    @staticmethod
+    def client_class() -> type[JsonApiLlmProviderPatchDocument]:
+        return JsonApiLlmProviderPatchDocument
+
+
+# --- Model type ---
+
+
+@define(kw_only=True)
+class CatalogLlmProviderModel(Base):
+    """Represents a single LLM model available for a provider."""
+
+    id: str
+    family: str
+
+    @staticmethod
+    def client_class() -> type[JsonApiLlmProviderInAttributesModelsInner]:
+        return JsonApiLlmProviderInAttributesModelsInner
+
+
+# --- Main entity types ---
+
+
+@define(kw_only=True)
+class CatalogLlmProvider(Base):
+    id: str
+    attributes: CatalogLlmProviderAttributes | None = None
+
+    @staticmethod
+    def client_class() -> type[JsonApiLlmProviderIn]:
+        return JsonApiLlmProviderIn
+
+    @classmethod
+    def init(
+        cls,
+        id: str,
+        models: list[CatalogLlmProviderModel],
+        provider_config: CatalogLlmProviderConfig,
+        name: str | None = None,
+        description: str | None = None,
+        default_model_id: str | None = None,
+    ) -> CatalogLlmProvider:
+        return cls(
+            id=id,
+            attributes=CatalogLlmProviderAttributes(
+                models=models,
+                provider_config=provider_config,
+                name=name,
+                description=description,
+                default_model_id=default_model_id,
+            ),
+        )
+
+    @classmethod
+    def from_api(cls, entity: dict[str, Any]) -> CatalogLlmProvider:
+        ea = entity["attributes"]
+        raw_models = safeget(ea, ["models"]) or []
+        models = [
+            CatalogLlmProviderModel(
+                id=safeget(m, ["id"]),
+                family=safeget(m, ["family"]),
+            )
+            for m in raw_models
+        ]
+        raw_config = safeget(ea, ["providerConfig"]) or {}
+        provider_config = _provider_config_from_api(raw_config)
+        return cls(
+            id=entity["id"],
+            attributes=CatalogLlmProviderAttributes(
+                models=models,
+                provider_config=provider_config,
+                name=safeget(ea, ["name"]),
+                description=safeget(ea, ["description"]),
+                default_model_id=safeget(ea, ["defaultModelId"]),
+            ),
+        )
+
+
+@define(kw_only=True)
+class CatalogLlmProviderPatch(Base):
+    id: str
+    attributes: CatalogLlmProviderPatchAttributes | None = None
+
+    @staticmethod
+    def client_class() -> type[JsonApiLlmProviderPatch]:
+        return JsonApiLlmProviderPatch
+
+    @classmethod
+    def init(
+        cls,
+        id: str,
+        models: list[CatalogLlmProviderModel] | None = None,
+        provider_config: CatalogLlmProviderConfig | None = None,
+        name: str | None = None,
+        description: str | None = None,
+        default_model_id: str | None = None,
+    ) -> CatalogLlmProviderPatch:
+        return cls(
+            id=id,
+            attributes=CatalogLlmProviderPatchAttributes(
+                models=models,
+                provider_config=provider_config,
+                name=name,
+                description=description,
+                default_model_id=default_model_id,
+            ),
+        )
+
+
+# --- Attributes ---
+
+
+@define(kw_only=True)
+class CatalogLlmProviderAttributes(Base):
+    models: list[CatalogLlmProviderModel]
+    provider_config: CatalogLlmProviderConfig
+    name: str | None = None
+    description: str | None = None
+    default_model_id: str | None = None
+
+    @staticmethod
+    def client_class() -> type[JsonApiLlmProviderInAttributes]:
+        return JsonApiLlmProviderInAttributes
+
+
+@define(kw_only=True)
+class CatalogLlmProviderPatchAttributes(Base):
+    models: list[CatalogLlmProviderModel] | None = None
+    provider_config: CatalogLlmProviderConfig | None = None
+    name: str | None = None
+    description: str | None = None
+    default_model_id: str | None = None
+
+    @staticmethod
+    def client_class() -> type[JsonApiLlmProviderPatchAttributes]:
+        return JsonApiLlmProviderPatchAttributes

{gooddata_sdk-1.60.1.dev2 → gooddata_sdk-1.61.1.dev1}/src/gooddata_sdk/catalog/organization/service.py

@@ -29,6 +29,12 @@ from gooddata_sdk.catalog.organization.entity_model.llm_endpoint import (
     CatalogLlmEndpointPatch,
     CatalogLlmEndpointPatchDocument,
 )
+from gooddata_sdk.catalog.organization.entity_model.llm_provider import (
+    CatalogLlmProvider,
+    CatalogLlmProviderDocument,
+    CatalogLlmProviderPatch,
+    CatalogLlmProviderPatchDocument,
+)
 from gooddata_sdk.catalog.organization.entity_model.setting import CatalogOrganizationSetting
 from gooddata_sdk.catalog.organization.layout.identity_provider import CatalogDeclarativeIdentityProvider
 from gooddata_sdk.catalog.organization.layout.notification_channel import CatalogDeclarativeNotificationChannel
@@ -640,6 +646,92 @@ class CatalogOrganizationService(CatalogServiceBase):
         """
         self._entities_api.delete_entity_llm_endpoints(id, _check_return_type=False)
 
+    def get_llm_provider(self, id: str) -> CatalogLlmProvider:
+        """Get LLM provider by ID.
+
+        Args:
+            id: LLM provider identifier
+
+        Returns:
+            CatalogLlmProvider: Retrieved LLM provider
+        """
+        response = self._entities_api.get_entity_llm_providers(id, _check_return_type=False)
+        return CatalogLlmProvider.from_api(response.data)
+
+    def list_llm_providers(
+        self,
+        filter: str | None = None,
+        page: int | None = None,
+        size: int | None = None,
+        sort: list[str] | None = None,
+        meta_include: list[str] | None = None,
+    ) -> list[CatalogLlmProvider]:
+        """List all LLM providers.
+
+        Args:
+            filter: Optional filter string
+            page: Zero-based page index (0..N)
+            size: The size of the page to be returned
+            sort: Sorting criteria in the format: property,(asc|desc). Multiple sort criteria are supported.
+            meta_include: Include Meta objects
+
+        Returns:
+            list[CatalogLlmProvider]: List of LLM providers
+        """
+        kwargs: dict[str, Any] = {}
+        if filter is not None:
+            kwargs["filter"] = filter
+        if page is not None:
+            kwargs["page"] = page
+        if size is not None:
+            kwargs["size"] = size
+        if sort is not None:
+            kwargs["sort"] = sort
+        if meta_include is not None:
+            kwargs["meta_include"] = meta_include
+        kwargs["_check_return_type"] = False
+
+        response = self._entities_api.get_all_entities_llm_providers(**kwargs)
+        return [CatalogLlmProvider.from_api(provider) for provider in response.data]
+
+    def create_llm_provider(self, llm_provider: CatalogLlmProvider) -> CatalogLlmProvider:
+        """Create a new LLM provider.
+
+        Args:
+            llm_provider: LLM provider object to create
+
+        Returns:
+            CatalogLlmProvider: Created LLM provider
+        """
+        llm_provider_document = CatalogLlmProviderDocument(data=llm_provider)
+        response = self._entities_api.create_entity_llm_providers(
+            json_api_llm_provider_in_document=llm_provider_document.to_api(), _check_return_type=False
+        )
+        return CatalogLlmProvider.from_api(response.data)
+
+    def update_llm_provider(self, llm_provider_patch: CatalogLlmProviderPatch) -> CatalogLlmProvider:
+        """Update an existing LLM provider using PATCH semantics.
+
+        Args:
+            llm_provider_patch: LLM provider patch object with fields to update
+
+        Returns:
+            CatalogLlmProvider: Updated LLM provider
+        """
+        llm_provider_patch_document = CatalogLlmProviderPatchDocument(data=llm_provider_patch)
+        response = self._entities_api.patch_entity_llm_providers(
+            llm_provider_patch.id, llm_provider_patch_document.to_api(), _check_return_type=False
+        )
+        return CatalogLlmProvider.from_api(response.data)
+
+    def delete_llm_provider(self, id: str) -> None:
+        """Delete an LLM provider.
+
+        Args:
+            id: LLM provider identifier
+        """
+        self._entities_api.delete_entity_llm_providers(id, _check_return_type=False)
+
     # Layout APIs
 
     def get_declarative_notification_channels(self) -> list[CatalogDeclarativeNotificationChannel]:

{gooddata_sdk-1.60.1.dev2 → gooddata_sdk-1.61.1.dev1}/src/gooddata_sdk/utils.py

@@ -166,8 +166,7 @@ def get_sorted_yaml_files(folder: Path) -> list[Path]:
 
 
 def create_directory(path: Path) -> None:
-    if not os.path.exists(path):
-        os.makedirs(path)
+    os.makedirs(path, exist_ok=True)
 
 
 def recreate_directory(path: Path) -> None: