gooddata-sdk 1.73.1.dev2__tar.gz → 1.73.1.dev4__tar.gz

{gooddata_sdk-1.73.1.dev2 → gooddata_sdk-1.73.1.dev4}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.5
 Name: gooddata-sdk
-Version: 1.73.1.dev2
+Version: 1.73.1.dev4
 Summary: GoodData Cloud Python SDK
-Project-URL: Documentation, https://www.gooddata.ai/docs/python-sdk/1.73.1.dev2
+Project-URL: Documentation, https://www.gooddata.ai/docs/python-sdk/1.73.1.dev4
 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.73.1.dev2
+Requires-Dist: gooddata-api-client~=1.73.1.dev4
 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.73.1.dev2) for more details.
+See [DOCUMENTATION](https://www.gooddata.ai/docs/python-sdk/1.73.1.dev4) for more details.
 
 ## Requirements
 

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

{gooddata_sdk-1.73.1.dev2 → gooddata_sdk-1.73.1.dev4}/pyproject.toml

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

{gooddata_sdk-1.73.1.dev2 → gooddata_sdk-1.73.1.dev4}/src/gooddata_sdk/__init__.py

@@ -140,6 +140,10 @@ from gooddata_sdk.catalog.organization.layout.export_template import (
 )
 from gooddata_sdk.catalog.organization.layout.notification_channel import (
     CatalogDeclarativeNotificationChannel,
+    CatalogDefaultSmtp,
+    CatalogInPlatform,
+    CatalogNotificationChannelDestination,
+    CatalogSmtp,
     CatalogWebhook,
 )
 from gooddata_sdk.catalog.organization.service import (

gooddata_sdk-1.73.1.dev4/src/gooddata_sdk/catalog/organization/layout/notification_channel.py

@@ -0,0 +1,138 @@
+# (C) 2024 GoodData Corporation
+from __future__ import annotations
+
+import builtins
+from typing import Any, Union
+
+from attrs import define, field
+from attrs import fields as attrs_fields
+from gooddata_api_client.model.declarative_notification_channel import DeclarativeNotificationChannel
+from gooddata_api_client.model.default_smtp import DefaultSmtp
+from gooddata_api_client.model.in_platform import InPlatform
+from gooddata_api_client.model.smtp import Smtp
+from gooddata_api_client.model.webhook import Webhook
+
+from gooddata_sdk.catalog.base import Base
+from gooddata_sdk.utils import safeget
+
+
+@define(kw_only=True)
+class CatalogWebhook(Base):
+    """Webhook destination for notifications."""
+
+    type: str = field(default="WEBHOOK", init=False)
+    url: str
+    token: str | None = field(default=None, eq=False)
+    has_token: bool | None = field(default=None, eq=False)
+
+    @staticmethod
+    def client_class() -> builtins.type[Webhook]:
+        return Webhook
+
+
+@define(kw_only=True)
+class CatalogSmtp(Base):
+    """Custom SMTP destination for notifications.
+
+    `host`, `port`, `username` and `password` are required by the API on create
+    and update, but are optional here because reads never return the password.
+    """
+
+    type: str = field(default="SMTP", init=False)
+    from_email: str | None = None
+    from_email_name: str | None = None
+    host: str | None = None
+    port: int | None = None
+    username: str | None = None
+    password: str | None = field(default=None, eq=False)
+
+    @staticmethod
+    def client_class() -> builtins.type[Smtp]:
+        return Smtp
+
+
+@define(kw_only=True)
+class CatalogDefaultSmtp(Base):
+    """Default SMTP destination for notifications - the platform's own mail server."""
+
+    type: str = field(default="DEFAULT_SMTP", init=False)
+    from_email: str | None = None
+    from_email_name: str | None = None
+
+    @staticmethod
+    def client_class() -> builtins.type[DefaultSmtp]:
+        return DefaultSmtp
+
+
+@define(kw_only=True)
+class CatalogInPlatform(Base):
+    """In-platform destination for notifications."""
+
+    type: str = field(default="IN_PLATFORM", init=False)
+
+    @staticmethod
+    def client_class() -> builtins.type[InPlatform]:
+        return InPlatform
+
+
+CatalogNotificationChannelDestination = Union[
+    CatalogWebhook,
+    CatalogSmtp,
+    CatalogDefaultSmtp,
+    CatalogInPlatform,
+]
+
+_DESTINATION_BY_TYPE: dict[str, builtins.type[CatalogNotificationChannelDestination]] = {
+    "WEBHOOK": CatalogWebhook,
+    "SMTP": CatalogSmtp,
+    "DEFAULT_SMTP": CatalogDefaultSmtp,
+    "IN_PLATFORM": CatalogInPlatform,
+}
+
+
+def _destination_from_api(data: dict[str, Any]) -> CatalogNotificationChannelDestination:
+    """Build the right destination class from a `destination` payload.
+
+    Dispatched on `type` explicitly rather than left to cattrs: the four
+    destination classes have no uniquely-required field to disambiguate a
+    union on (`IN_PLATFORM` carries nothing but its type).
+    """
+    destination_type = safeget(data, ["type"])
+    destination_class = _DESTINATION_BY_TYPE.get(destination_type)
+    if destination_class is None:
+        raise ValueError(f"Unknown notification channel destination type: {destination_type}")
+    # Keep only what the class can take: `type` is init=False (implied by the
+    # class itself) and the API sends fields we do not model - `has_secret_key`
+    # on a webhook, for one. Silently ignoring those matches how cattrs used to
+    # structure this and keeps reads working when the API grows a field.
+    accepted = {f.name for f in attrs_fields(destination_class) if f.init}
+    return destination_class(**{k: v for k, v in data.items() if k in accepted})
+
+
+@define(kw_only=True)
+class CatalogDeclarativeNotificationChannel(Base):
+    id: str
+    name: str | None = None
+    description: str | None = None
+    destination_type: str | None = None
+    custom_dashboard_url: str | None = None
+    allowed_recipients: str | None = None
+    destination: CatalogNotificationChannelDestination | None = None
+
+    @staticmethod
+    def client_class() -> builtins.type[DeclarativeNotificationChannel]:
+        return DeclarativeNotificationChannel
+
+    @classmethod
+    def from_api(cls, entity: dict[str, Any]) -> CatalogDeclarativeNotificationChannel:
+        data = entity if isinstance(entity, dict) else entity.to_dict(camel_case=False)
+        raw_destination = safeget(data, ["destination"])
+        return cls(
+            id=data["id"],
+            name=safeget(data, ["name"]),
+            description=safeget(data, ["description"]),
+            destination_type=safeget(data, ["destination_type"]),
+            custom_dashboard_url=safeget(data, ["custom_dashboard_url"]),
+            allowed_recipients=safeget(data, ["allowed_recipients"]),
+            destination=_destination_from_api(raw_destination) if raw_destination is not None else None,
+        )

gooddata_sdk-1.73.1.dev4/tests/catalog/unit_tests/test_composed_oneof_unions.py

@@ -0,0 +1,179 @@
+# (C) 2026 GoodData Corporation
+"""Regression tests for oneOf/anyOf unions in the generated api client.
+
+openapi-generator's `python-prior` generator flattens a `oneOf`'s members into
+the composed parent model, but for a property that several members declare it
+keeps only the **last** member's value:
+
+- `allowed_values[('type',)]` ends up holding one member's enum, so the parent
+  accepts exactly one variant - and which one depends on the order of the
+  `oneOf` array in the OpenAPI document.
+- `openapi_types[prop]` ends up holding one member's class, so a nested union
+  such as an LLM provider's `auth` cannot carry the other members' payloads.
+
+`model_utils` (via the `model_utils.mustache` / `method_set_attribute.mustache`
+custom templates) widens both back to the union of the members. These tests pin
+that behaviour for the LLM provider config - the instance this was reported
+against - so a template or generator change cannot silently reintroduce it.
+
+The defect was repo-wide (25 collapsed enums and 47 collapsed types across 161
+composed models), so it is worth suspecting whenever a `oneOf` variant is
+inexplicably rejected.
+"""
+
+from __future__ import annotations
+
+import pytest
+from gooddata_api_client.model.json_api_llm_provider_in_attributes_provider_config import (
+    JsonApiLlmProviderInAttributesProviderConfig,
+)
+from gooddata_api_client.model_utils import (
+    composed_union_allowed_values,
+    composed_union_types,
+)
+from gooddata_sdk import (
+    CatalogAwsBedrockProviderConfig,
+    CatalogAzureFoundryApiKeyAuth,
+    CatalogAzureFoundryProviderConfig,
+    CatalogBedrockAccessKeyAuth,
+    CatalogLlmProvider,
+    CatalogLlmProviderModel,
+    CatalogOpenAiApiKeyAuth,
+    CatalogOpenAiProviderConfig,
+)
+
+PROVIDER_CONFIGS = {
+    "OPENAI": (
+        CatalogOpenAiProviderConfig(
+            auth=CatalogOpenAiApiKeyAuth(api_key="dummy"),
+            base_url="https://api.openai.com/v1",
+            organization="org-1",
+        ),
+        {
+            "type": "OPENAI",
+            "base_url": "https://api.openai.com/v1",
+            "organization": "org-1",
+            "auth": {"type": "API_KEY", "api_key": "dummy"},
+        },
+    ),
+    "AWS_BEDROCK": (
+        CatalogAwsBedrockProviderConfig(
+            auth=CatalogBedrockAccessKeyAuth(access_key_id="akid", secret_access_key="secret", session_token="token"),
+            region="us-east-1",
+        ),
+        {
+            "type": "AWS_BEDROCK",
+            "region": "us-east-1",
+            "auth": {
+                "type": "ACCESS_KEY",
+                "access_key_id": "akid",
+                "secret_access_key": "secret",
+                "session_token": "token",
+            },
+        },
+    ),
+    "AZURE_FOUNDRY": (
+        CatalogAzureFoundryProviderConfig(
+            auth=CatalogAzureFoundryApiKeyAuth(api_key="dummy"),
+            endpoint="https://example.openai.azure.com",
+        ),
+        {
+            "type": "AZURE_FOUNDRY",
+            "endpoint": "https://example.openai.azure.com",
+            "auth": {"type": "API_KEY", "api_key": "dummy"},
+        },
+    ),
+}
+
+
+@pytest.mark.parametrize("provider_type", sorted(PROVIDER_CONFIGS))
+def test_llm_provider_to_api_accepts_every_provider_config(provider_type: str) -> None:
+    """Every provider variant must survive `to_api()`, not just the flattened one."""
+    provider_config, expected = PROVIDER_CONFIGS[provider_type]
+    provider = CatalogLlmProvider.init(
+        id=f"test-{provider_type.lower()}",
+        models=[CatalogLlmProviderModel(id="model-1", family="OPENAI")],
+        provider_config=provider_config,
+        name=f"Test {provider_type}",
+        default_model_id="model-1",
+    )
+
+    api_object = provider.to_api()
+
+    assert api_object.to_dict()["attributes"]["provider_config"] == expected
+
+
+@pytest.mark.parametrize("provider_type", sorted(PROVIDER_CONFIGS))
+def test_llm_provider_round_trips_through_from_api(provider_type: str) -> None:
+    provider_config, _ = PROVIDER_CONFIGS[provider_type]
+    provider = CatalogLlmProvider.init(
+        id=f"test-{provider_type.lower()}",
+        models=[CatalogLlmProviderModel(id="model-1", family="OPENAI")],
+        provider_config=provider_config,
+        name=f"Test {provider_type}",
+        default_model_id="model-1",
+    )
+
+    restored = CatalogLlmProvider.from_api(provider.to_dict())
+
+    assert restored.attributes is not None
+    assert restored.attributes.provider_config is not None
+    assert restored.attributes.provider_config.type == provider_type
+
+
+def _oneof_members(model):
+    return model._composed_schemas["oneOf"]
+
+
+def test_provider_config_type_enum_is_the_union_of_its_members() -> None:
+    """The parent's effective enum covers every member, not just the flattened one.
+
+    Asserted against the members themselves rather than a hardcoded list, so
+    adding a provider to the OpenAPI document does not need a test edit.
+    """
+    model = JsonApiLlmProviderInAttributesProviderConfig
+    per_member = {frozenset(member.allowed_values.get(("type",), {})) for member in _oneof_members(model)}
+    expected = frozenset().union(*per_member)
+
+    effective = frozenset(composed_union_allowed_values(model, "type"))
+
+    assert effective == expected
+    # Each member contributes its own single value, so a union of more than one
+    # is what makes this meaningful - and the generator wrote only one of them
+    # onto the parent.
+    assert len(expected) > 1
+    assert frozenset(model.allowed_values.get(("type",), {})) < effective
+
+
+def test_provider_config_auth_accepts_every_members_auth_class() -> None:
+    """`auth` is a nested union; the flattened parent kept only one auth class."""
+    model = JsonApiLlmProviderInAttributesProviderConfig
+    expected = {t for member in _oneof_members(model) for t in member.openapi_types.get("auth", ())}
+
+    effective = set(composed_union_types(model, "auth"))
+
+    assert effective == expected
+    assert len(expected) > 1
+    assert set(model.openapi_types.get("auth", ())) < effective
+
+
+@pytest.mark.parametrize(
+    "union_helper",
+    [composed_union_types, composed_union_allowed_values],
+    ids=["types", "allowed_values"],
+)
+def test_union_helpers_tolerate_a_non_model_member(union_helper, monkeypatch) -> None:
+    """A composed member is not always a model, and primitives have no metadata.
+
+    `oneOf: [$ref, {type: string}]` makes the generator emit
+    `'oneOf': [Thing, str]`. Reading `openapi_types` / `allowed_values` straight
+    off such a member raises AttributeError, which would break every attribute
+    assignment on that model rather than just the union widening.
+    """
+    model = JsonApiLlmProviderInAttributesProviderConfig
+    with_primitive = dict(model._composed_schemas)
+    with_primitive["oneOf"] = tuple(with_primitive["oneOf"]) + (str,)
+    monkeypatch.setattr(model, "_composed_schemas", with_primitive)
+
+    # Must not raise, and must still report what the real members declare.
+    assert union_helper(model, "type")

gooddata_sdk-1.73.1.dev4/tests/catalog/unit_tests/test_notification_channel_destinations.py

@@ -0,0 +1,133 @@
+# (C) 2026 GoodData Corporation
+"""Tests for the notification channel destination union.
+
+`CatalogSmtp` / `CatalogDefaultSmtp` used to be commented out in the SDK with a
+TODO pointing at the generated client: the composed destination model accepted a
+single `type` only, so `to_api()` raised `ApiValueError` for every other
+destination. That was the same oneOf-flattening defect covered by
+`test_composed_oneof_unions.py`; with it fixed in `model_utils`, all four
+destinations are usable and `NotificationChannelDestination.allowed_values` no
+longer has to be monkeypatched at import time.
+"""
+
+from __future__ import annotations
+
+import pytest
+from gooddata_api_client.model.json_api_notification_channel_in_attributes_destination import (
+    JsonApiNotificationChannelInAttributesDestination,
+)
+from gooddata_api_client.model.notification_channel_destination import NotificationChannelDestination
+from gooddata_sdk import (
+    CatalogDeclarativeNotificationChannel,
+    CatalogDefaultSmtp,
+    CatalogInPlatform,
+    CatalogSmtp,
+    CatalogWebhook,
+)
+
+DESTINATIONS = {
+    "WEBHOOK": (
+        CatalogWebhook(url="https://webhook.site/hook", token="secret"),
+        {"type": "WEBHOOK", "url": "https://webhook.site/hook", "token": "secret"},
+    ),
+    "SMTP": (
+        CatalogSmtp(
+            from_email="sender@example.com",
+            from_email_name="Sender",
+            host="smtp.example.com",
+            port=587,
+            username="user",
+            password="secret",
+        ),
+        {
+            "type": "SMTP",
+            "from_email": "sender@example.com",
+            "from_email_name": "Sender",
+            "host": "smtp.example.com",
+            "port": 587,
+            "username": "user",
+            "password": "secret",
+        },
+    ),
+    "DEFAULT_SMTP": (
+        CatalogDefaultSmtp(from_email="sender@example.com", from_email_name="Sender"),
+        {"type": "DEFAULT_SMTP", "from_email": "sender@example.com", "from_email_name": "Sender"},
+    ),
+    "IN_PLATFORM": (CatalogInPlatform(), {"type": "IN_PLATFORM"}),
+}
+
+
+@pytest.mark.parametrize("destination_type", sorted(DESTINATIONS))
+def test_destination_to_api(destination_type: str) -> None:
+    """Every destination must survive `to_api()`, not just WEBHOOK."""
+    destination, expected = DESTINATIONS[destination_type]
+
+    assert destination.to_api().to_dict() == expected
+
+
+@pytest.mark.parametrize("destination_type", sorted(DESTINATIONS))
+def test_notification_channel_to_api_carries_the_destination(destination_type: str) -> None:
+    destination, expected = DESTINATIONS[destination_type]
+    channel = CatalogDeclarativeNotificationChannel(
+        id=f"channel-{destination_type.lower()}",
+        name=f"Channel {destination_type}",
+        destination=destination,
+        allowed_recipients="CREATOR",
+    )
+
+    api_object = channel.to_api()
+
+    assert api_object.to_dict()["destination"] == expected
+
+
+@pytest.mark.parametrize("destination_type", sorted(DESTINATIONS))
+def test_notification_channel_round_trips(destination_type: str) -> None:
+    """`from_api` must rebuild the concrete destination class, not a webhook."""
+    destination, _ = DESTINATIONS[destination_type]
+    channel = CatalogDeclarativeNotificationChannel(
+        id=f"channel-{destination_type.lower()}",
+        name=f"Channel {destination_type}",
+        destination=destination,
+        custom_dashboard_url="https://dashboard.site",
+        allowed_recipients="CREATOR",
+    )
+
+    restored = CatalogDeclarativeNotificationChannel.from_api(channel.to_dict(camel_case=False))
+
+    assert restored == channel
+    assert type(restored.destination) is type(destination)
+    assert restored.destination is not None
+    assert restored.destination.type == destination_type
+
+
+def test_from_api_rejects_an_unknown_destination_type() -> None:
+    with pytest.raises(ValueError, match="Unknown notification channel destination type: TELEPATHY"):
+        CatalogDeclarativeNotificationChannel.from_api({"id": "channel", "destination": {"type": "TELEPATHY"}})
+
+
+@pytest.mark.parametrize(
+    "model",
+    [NotificationChannelDestination, JsonApiNotificationChannelInAttributesDestination],
+    ids=["shared", "json_api"],
+)
+@pytest.mark.parametrize("destination_type", sorted(DESTINATIONS))
+def test_generated_destination_models_accept_every_type(model, destination_type: str) -> None:
+    """Pin the generated composed models too - this is where the defect lived."""
+    _, payload = DESTINATIONS[destination_type]
+
+    destination = model(**payload)
+
+    assert destination.type == destination_type
+
+
+def test_destination_model_class_attribute_is_still_collapsed() -> None:
+    """Guard the reason the monkeypatch could go: the fix is at validation time.
+
+    The generator still writes a single-variant enum onto the composed parent -
+    nothing regenerates that away - so this documents that the models above pass
+    because `model_utils` unions the members, not because the class attribute
+    got fixed.
+    """
+    collapsed = NotificationChannelDestination.allowed_values.get(("type",), {})
+
+    assert len(collapsed) == 1

gooddata_sdk-1.73.1.dev2/src/gooddata_sdk/catalog/organization/layout/notification_channel.py

@@ -1,74 +0,0 @@
-# (C) 2024 GoodData Corporation
-import builtins
-
-from attrs import define, field
-from gooddata_api_client.model.declarative_notification_channel import DeclarativeNotificationChannel
-from gooddata_api_client.model.notification_channel_destination import NotificationChannelDestination
-from gooddata_api_client.model.webhook import Webhook
-
-from gooddata_sdk.catalog.base import Base
-
-# The generator collapses the `type` enums of NotificationChannelDestination's oneOf children
-# into the last child's single value (IN_PLATFORM), so valid destinations of the other types
-# fail client-side validation on both serialization and response parsing. Restore the full set.
-NotificationChannelDestination.allowed_values[("type",)].update(
-    {
-        "WEBHOOK": "WEBHOOK",
-        "SMTP": "SMTP",
-        "DEFAULT_SMTP": "DEFAULT_SMTP",
-        "IN_PLATFORM": "IN_PLATFORM",
-    }
-)
-
-# TODO: there is an issue with generated client which causes these two classes to fail
-# type in gooddata_api_client/model/declarative_notification_channel_destination.py contains only WEBHOOK as valid value
-# @define(kw_only=True)
-# class CatalogDefaultSmtp(Base):
-#     from_email: Optional[str] = None
-#     from_email_name: Optional[str] = None
-#
-#     @staticmethod
-#     def client_class() -> Type[DefaultSmtp]:
-#         return DefaultSmtp
-#
-#
-# @define(kw_only=True)
-# class CatalogSmtp(Base):
-#     from_email: Optional[str] = None
-#     from_email_name: Optional[str] = None
-#     host: Optional[str] = None
-#     password: Optional[str] = None
-#     port: Optional[int] = None
-#     username: Optional[str] = None
-#
-#     @staticmethod
-#     def client_class() -> Type[Smtp]:
-#         return Smtp
-
-
-@define(kw_only=True)
-class CatalogWebhook(Base):
-    type: str = field(default="WEBHOOK", init=False)
-    url: str
-    token: str | None = field(default=None, eq=False)
-    has_token: bool | None = field(default=None, eq=False)
-
-    @staticmethod
-    def client_class() -> builtins.type[Webhook]:
-        return Webhook
-
-
-@define(kw_only=True)
-class CatalogDeclarativeNotificationChannel(Base):
-    id: str
-    name: str | None = None
-    description: str | None = None
-    destination_type: str | None = None
-    custom_dashboard_url: str | None = None
-    allowed_recipients: str | None = None
-    # destination: Optional[Union[CatalogDefaultSmtp, CatalogSmtp, CatalogWebhook]] = None
-    destination: CatalogWebhook | None = None
-
-    @staticmethod
-    def client_class() -> builtins.type[DeclarativeNotificationChannel]:
-        return DeclarativeNotificationChannel