gooddata-pipelines 1.50.1.dev1__py3-none-any.whl → 1.51.0__py3-none-any.whl

gooddata_pipelines/__init__.py

@@ -6,11 +6,22 @@ from ._version import __version__
 from .backup_and_restore.backup_manager import BackupManager
 from .backup_and_restore.models.storage import (
     BackupRestoreConfig,
+    LocalStorageConfig,
+    S3StorageConfig,
     StorageType,
 )
 from .backup_and_restore.storage.local_storage import LocalStorage
 from .backup_and_restore.storage.s3_storage import S3Storage
 
+# -------- LDM Extension --------
+from .ldm_extension.ldm_extension_manager import LdmExtensionManager
+from .ldm_extension.models.custom_data_object import (
+    ColumnDataType,
+    CustomDatasetDefinition,
+    CustomFieldDefinition,
+    CustomFieldType,
+)
+
 # -------- Provisioning --------
 from .provisioning.entities.user_data_filters.models.udf_models import (
     UserDataFilterFullLoad,
@@ -51,6 +62,8 @@ __all__ = [
     "UserIncrementalLoad",
     "UserGroupIncrementalLoad",
     "PermissionFullLoad",
+    "LocalStorageConfig",
+    "S3StorageConfig",
     "PermissionIncrementalLoad",
     "UserFullLoad",
     "UserGroupFullLoad",
@@ -61,5 +74,10 @@ __all__ = [
     "UserDataFilterProvisioner",
     "UserDataFilterFullLoad",
     "EntityType",
+    "LdmExtensionManager",
+    "CustomDatasetDefinition",
+    "CustomFieldDefinition",
+    "ColumnDataType",
+    "CustomFieldType",
     "__version__",
 ]

gooddata_pipelines/api/gooddata_api.py

@@ -174,6 +174,49 @@ class ApiMethods:
         )
         return self._get(endpoint)
 
+    def get_all_metrics(self, workspace_id: str) -> requests.Response:
+        """Get all metrics from the specified workspace.
+
+        Args:
+            workspace_id (str): The ID of the workspace to retrieve metrics from.
+        Returns:
+            requests.Response: The response containing the metrics.
+        """
+        endpoint = f"/entities/workspaces/{workspace_id}/metrics"
+        headers = {**self.headers, "X-GDC-VALIDATE-RELATIONS": "true"}
+        return self._get(endpoint, headers=headers)
+
+    def get_all_visualization_objects(
+        self, workspace_id: str
+    ) -> requests.Response:
+        """Get all visualizations from the specified workspace.
+
+        Args:
+            workspace_id (str): The ID of the workspace to retrieve visualizations from.
+        Returns:
+            requests.Response: The response containing the visualizations.
+        """
+        endpoint = f"/entities/workspaces/{workspace_id}/visualizationObjects"
+        headers = {**self.headers, "X-GDC-VALIDATE-RELATIONS": "true"}
+        return self._get(endpoint, headers=headers)
+
+    def get_all_dashboards(self, workspace_id: str) -> requests.Response:
+        """Get all dashboards from the specified workspace.
+
+        Args:
+            workspace_id (str): The ID of the workspace to retrieve dashboards from.
+        Returns:
+            requests.Response: The response containing the dashboards.
+        """
+        endpoint = f"/entities/workspaces/{workspace_id}/analyticalDashboards"
+        headers = {**self.headers, "X-GDC-VALIDATE-RELATIONS": "true"}
+        return self._get(endpoint, headers=headers)
+
+    def get_profile(self) -> requests.Response:
+        """Returns organization and current user information."""
+        endpoint = "/profile"
+        return self._get(endpoint)
+
     def _get(
         self, endpoint: str, headers: dict[str, str] | None = None
     ) -> requests.Response:
@@ -253,3 +296,15 @@ class ApiMethods:
         url = self._get_url(endpoint)
 
         return requests.delete(url, headers=self.headers, timeout=TIMEOUT)
+
+    @staticmethod
+    def raise_if_response_not_ok(*responses: requests.Response) -> None:
+        """Check if responses from API calls are OK.
+
+        Raises ValueError if any response is not OK (status code not 2xx).
+        """
+        for response in responses:
+            if not response.ok:
+                raise ValueError(
+                    f"Request to {response.url} failed with status code {response.status_code}: {response.text}"
+                )

gooddata_pipelines/ldm_extension/__init__.py

@@ -0,0 +1 @@
+# (C) 2025 GoodData Corporation

gooddata_pipelines/ldm_extension/input_processor.py

@@ -0,0 +1,286 @@
+# (C) 2025 GoodData Corporation
+"""Module for processing validated custom datasets and fields data.
+
+This module is responsible for converting validated custom datasets and fields
+into objects defined in the GoodData Python SDK.
+"""
+
+from gooddata_sdk.catalog.identifier import (
+    CatalogDatasetWorkspaceDataFilterIdentifier,
+    CatalogGrainIdentifier,
+    CatalogReferenceIdentifier,
+)
+from gooddata_sdk.catalog.workspace.declarative_model.workspace.logical_model.data_filter_references import (
+    CatalogDeclarativeWorkspaceDataFilterReferences,
+)
+from gooddata_sdk.catalog.workspace.declarative_model.workspace.logical_model.dataset.dataset import (
+    CatalogDataSourceTableIdentifier,
+    CatalogDeclarativeAttribute,
+    CatalogDeclarativeDataset,
+    CatalogDeclarativeDatasetSql,
+    CatalogDeclarativeFact,
+    CatalogDeclarativeReference,
+    CatalogDeclarativeReferenceSource,
+    CatalogDeclarativeWorkspaceDataFilterColumn,
+)
+from gooddata_sdk.catalog.workspace.declarative_model.workspace.logical_model.date_dataset.date_dataset import (
+    CatalogDeclarativeDateDataset,
+    CatalogGranularitiesFormatting,
+)
+from gooddata_sdk.catalog.workspace.declarative_model.workspace.logical_model.ldm import (
+    CatalogDeclarativeLdm,
+    CatalogDeclarativeModel,
+)
+
+from gooddata_pipelines.ldm_extension.models.aliases import DatasetId
+from gooddata_pipelines.ldm_extension.models.custom_data_object import (
+    ColumnDataType,
+    CustomDataset,
+    CustomFieldDefinition,
+    CustomFieldType,
+)
+
+
+class LdmExtensionDataProcessor:
+    """Create GoodData LDM from validated custom datasets and fields."""
+
+    DATE_GRANULARITIES: list[str] = [
+        "MINUTE",
+        "HOUR",
+        "DAY",
+        "WEEK",
+        "MONTH",
+        "QUARTER",
+        "YEAR",
+        "MINUTE_OF_HOUR",
+        "HOUR_OF_DAY",
+        "DAY_OF_WEEK",
+        "DAY_OF_MONTH",
+        "DAY_OF_YEAR",
+        "WEEK_OF_YEAR",
+        "MONTH_OF_YEAR",
+        "QUARTER_OF_YEAR",
+    ]
+
+    @staticmethod
+    def _attribute_from_field(
+        dataset_name: str,
+        custom_field: CustomFieldDefinition,
+    ) -> CatalogDeclarativeAttribute:
+        """Assign a declarative attribute from a custom field definition."""
+        return CatalogDeclarativeAttribute(
+            id=custom_field.custom_field_id,
+            title=custom_field.custom_field_name,
+            source_column=custom_field.custom_field_source_column,
+            labels=[],
+            source_column_data_type=custom_field.custom_field_source_column_data_type.value,
+            tags=[dataset_name],
+        )
+
+    @staticmethod
+    def _fact_from_field(
+        dataset_name: str,
+        custom_field: CustomFieldDefinition,
+    ) -> CatalogDeclarativeFact:
+        """Assign a declarative fact from a custom field definition."""
+        return CatalogDeclarativeFact(
+            id=custom_field.custom_field_id,
+            title=custom_field.custom_field_name,
+            source_column=custom_field.custom_field_source_column,
+            source_column_data_type=custom_field.custom_field_source_column_data_type.value,
+            tags=[dataset_name],
+        )
+
+    def _date_from_field(
+        self,
+        dataset_name: str,
+        custom_field: CustomFieldDefinition,
+    ) -> CatalogDeclarativeDateDataset:
+        """Assign a declarative date dataset from a custom field definition."""
+
+        return CatalogDeclarativeDateDataset(
+            id=custom_field.custom_field_id,
+            title=custom_field.custom_field_name,
+            granularities_formatting=CatalogGranularitiesFormatting(
+                title_base="",
+                title_pattern="%titleBase - %granularityTitle",
+            ),
+            granularities=self.DATE_GRANULARITIES,
+            tags=[dataset_name],
+        )
+
+    @staticmethod
+    def _date_ref_from_field(
+        custom_field: CustomFieldDefinition,
+    ) -> CatalogDeclarativeReference:
+        """Create a date reference from a custom field definition."""
+        return CatalogDeclarativeReference(
+            identifier=CatalogReferenceIdentifier(
+                id=custom_field.custom_field_id
+            ),
+            multivalue=False,
+            sources=[
+                CatalogDeclarativeReferenceSource(
+                    column=custom_field.custom_field_source_column,
+                    target=CatalogGrainIdentifier(
+                        id=custom_field.custom_field_id,
+                        type=CustomFieldType.DATE.value,
+                    ),
+                    data_type=custom_field.custom_field_source_column_data_type.value,
+                )
+            ],
+        )
+
+    @staticmethod
+    def _get_sources(
+        dataset: CustomDataset,
+    ) -> tuple[
+        CatalogDataSourceTableIdentifier | None,
+        CatalogDeclarativeDatasetSql | None,
+    ]:
+        """Get the data source table and SQL from the dataset definition."""
+        # We will have either a table id or a sql statement. Let's store
+        # whatever data is available to variables and pass it to the
+        # dataset. Both can be object instances or None, but at least one
+        # should be valid as per prior validation.
+        dataset_source_table_id = (
+            CatalogDataSourceTableIdentifier(
+                id=dataset.definition.dataset_source_table,
+                data_source_id=dataset.definition.dataset_datasource_id,
+                path=[dataset.definition.dataset_source_table],
+            )
+            if dataset.definition.dataset_source_table
+            else None
+        )
+
+        dataset_sql = (
+            CatalogDeclarativeDatasetSql(
+                statement=dataset.definition.dataset_source_sql,
+                data_source_id=dataset.definition.dataset_datasource_id,
+            )
+            if dataset.definition.dataset_source_sql
+            else None
+        )
+        return dataset_source_table_id, dataset_sql
+
+    def datasets_to_ldm(
+        self, datasets: dict[DatasetId, CustomDataset]
+    ) -> CatalogDeclarativeModel:
+        """Convert validated datasets to GoodData declarative model.
+
+        Args:
+            datasets (dict[DatasetId, CustomDataset]): Dictionary of validated
+                datasets.
+        Returns:
+            CatalogDeclarativeModel: GoodData declarative model representation
+                of the datasets.
+        """
+
+        declarative_datasets: list[CatalogDeclarativeDataset] = []
+
+        # Date dimensions are not stored in a dataset, but as a separate datasets
+        # in `date_instances` object on the LDM
+        date_instances: list[CatalogDeclarativeDateDataset] = []
+
+        for dataset in datasets.values():
+            date_references: list[CatalogDeclarativeReference] = []
+            attributes: list[CatalogDeclarativeAttribute] = []
+            facts: list[CatalogDeclarativeFact] = []
+
+            # Iterate through the custom fields and create the appropriate objects
+            for custom_field in dataset.custom_fields:
+                if custom_field.custom_field_type == CustomFieldType.ATTRIBUTE:
+                    attributes.append(
+                        self._attribute_from_field(
+                            dataset.definition.dataset_name, custom_field
+                        )
+                    )
+
+                elif custom_field.custom_field_type == CustomFieldType.FACT:
+                    facts.append(
+                        self._fact_from_field(
+                            dataset.definition.dataset_name, custom_field
+                        )
+                    )
+
+                # Process date dimensions and store them to date_instances. Date
+                # dimensions are not stored in a dataset, but as a separate dataset.
+                # However, they need to be referenced in the dataset references to
+                # create the connection between the dataset and the date dimension
+                # in the GoodData Logical Data Model.
+                elif custom_field.custom_field_type == CustomFieldType.DATE:
+                    # Add the date dimension to the date_instances
+                    date_instances.append(
+                        self._date_from_field(
+                            dataset.definition.dataset_name, custom_field
+                        )
+                    )
+
+                    # Create a reference so that the date dimension is connected
+                    # to the dataset in the GoodData Logical Data Model.
+                    date_references.append(
+                        self._date_ref_from_field(custom_field)
+                    )
+
+                else:
+                    raise ValueError(
+                        f"Unsupported custom field type: {custom_field.custom_field_type}"
+                    )
+
+            # Get the data source info
+            dataset_source_table_id, dataset_sql = self._get_sources(dataset)
+
+            # Construct the declarative dataset object and append it to the list.
+            declarative_datasets.append(
+                CatalogDeclarativeDataset(
+                    id=dataset.definition.dataset_id,
+                    title=dataset.definition.dataset_name,
+                    grain=[],
+                    references=[
+                        CatalogDeclarativeReference(
+                            identifier=CatalogReferenceIdentifier(
+                                id=dataset.definition.parent_dataset_reference,
+                            ),
+                            multivalue=True,
+                            sources=[
+                                CatalogDeclarativeReferenceSource(
+                                    column=dataset.definition.dataset_reference_source_column,
+                                    data_type=dataset.definition.dataset_reference_source_column_data_type.value,
+                                    target=CatalogGrainIdentifier(
+                                        id=dataset.definition.parent_dataset_reference_attribute_id,
+                                        type=CustomFieldType.ATTRIBUTE.value,
+                                    ),
+                                )
+                            ],
+                        ),
+                    ]
+                    + date_references,
+                    description=None,
+                    attributes=attributes,
+                    facts=facts,
+                    data_source_table_id=dataset_source_table_id,
+                    sql=dataset_sql,
+                    workspace_data_filter_columns=[
+                        CatalogDeclarativeWorkspaceDataFilterColumn(
+                            name=dataset.definition.workspace_data_filter_column_name,
+                            data_type=ColumnDataType.STRING.value,
+                        )
+                    ],
+                    workspace_data_filter_references=[
+                        CatalogDeclarativeWorkspaceDataFilterReferences(
+                            filter_id=CatalogDatasetWorkspaceDataFilterIdentifier(
+                                id=dataset.definition.workspace_data_filter_id
+                            ),
+                            filter_column=dataset.definition.workspace_data_filter_column_name,
+                            filter_column_data_type=ColumnDataType.STRING.value,
+                        )
+                    ],
+                    tags=[dataset.definition.dataset_name],
+                )
+            )
+
+        # Create the Logical Data Model from the datasets and the date instances.
+        ldm = CatalogDeclarativeLdm(
+            datasets=declarative_datasets, date_instances=date_instances
+        )
+        return CatalogDeclarativeModel(ldm=ldm)

gooddata_pipelines/ldm_extension/input_validator.py

@@ -0,0 +1,185 @@
+# (C) 2025 GoodData Corporation
+"""Module for validating custom fields input data.
+
+This module is responsible for validating custom fields input data checking for
+row level and aggregated constraints.
+"""
+
+from collections import Counter
+from typing import Any, TypeVar
+
+from pydantic import BaseModel
+
+from gooddata_pipelines.ldm_extension.models.aliases import (
+    DatasetId,
+    WorkspaceId,
+)
+from gooddata_pipelines.ldm_extension.models.custom_data_object import (
+    CustomDataset,
+    CustomDatasetDefinition,
+    CustomFieldDefinition,
+    CustomFieldType,
+)
+
+
+class LdmExtensionDataValidator:
+    ModelT = TypeVar("ModelT", bound=BaseModel)
+
+    def validate(
+        self,
+        dataset_definitions: list[CustomDatasetDefinition],
+        field_definitions: list[CustomFieldDefinition],
+    ) -> dict[WorkspaceId, dict[DatasetId, CustomDataset]]:
+        """Validate dataset and field definitions.
+
+        Validates the dataset definitions and field definitions by using Pydantic
+        models to check row level constraints, then aggregates the definitions
+        per workspace, while checking for integrity on aggregated level, i.e.,
+        uniqueness of combinations of identifieres on workspace level.
+
+        Args:
+            raw_dataset_definitions (list[dict[str, str]]): List of raw dataset definitions to validate.
+            raw_field_definitions (list[dict[str, str]]): List of raw field definitions to validate.
+        Returns:
+            dict[WorkspaceId, dict[DatasetId, CustomDataset]]:
+                Dictionary of validated dataset definitions per workspace,
+                where each dataset contains its custom fields:
+                ```python
+                {
+                    "workspace_id_1": {
+                        "dataset_id_1": CustomDataset(...),
+                        "dataset_id_2": CustomDataset(...),
+                    },
+                    ...
+                }
+                ```
+        """
+
+        # First, validate the dataset definitions and aggregate them per workspace.
+        validated_data = self._validate_dataset_definitions(dataset_definitions)
+
+        # Then validate the field definitions and connect them to the datasets
+        validated_data = self._validate_field_definitions(
+            validated_data, field_definitions
+        )
+
+        return validated_data
+
+    def _validate_dataset_definitions(
+        self,
+        dataset_definitions: list[CustomDatasetDefinition],
+    ) -> dict[WorkspaceId, dict[DatasetId, CustomDataset]]:
+        self._check_dataset_combinations(dataset_definitions)
+
+        validated_definitions: dict[
+            WorkspaceId, dict[DatasetId, CustomDataset]
+        ] = {}
+        for definition in dataset_definitions:
+            validated_definitions.setdefault(definition.workspace_id, {})[
+                definition.dataset_id
+            ] = CustomDataset(definition=definition, custom_fields=[])
+
+        return validated_definitions
+
+    def _check_dataset_combinations(
+        self, dataset_definitions: list[CustomDatasetDefinition]
+    ) -> None:
+        """Check integrity of provided dataset definitions.
+
+        Validation criteria:
+            - workspace_id + dataset_id must be unique across all dataset definitions.
+
+        Args:
+            dataset_definitions (list[CustomDatasetDefinition]): List of dataset definitions to check.
+        Raises:
+            ValueError: If there are duplicate dataset definitions based on workspace_id and dataset_id.
+        """
+        workspace_dataset_combinations = [
+            (definition.workspace_id, definition.dataset_id)
+            for definition in dataset_definitions
+        ]
+        if len(workspace_dataset_combinations) != len(
+            set(workspace_dataset_combinations)
+        ):
+            duplicates = self._get_duplicates(workspace_dataset_combinations)
+            raise ValueError(
+                "Duplicate dataset definitions found in the raw dataset "
+                + f"definitions (workspace_id, dataset_id): {duplicates}"
+            )
+
+    @staticmethod
+    def _get_duplicates(list_to_check: list[Any]) -> list[Any]:
+        """Get duplicates from a list.
+
+        Args:
+            list_to_check (list[Any]): List of items to check for duplicates.
+        Returns:
+            list[Any]: List of duplicate items.
+        """
+        counts = Counter(list_to_check)
+        return [item for item, count in counts.items() if count > 1]
+
+    def _check_field_combinations(
+        self, field_definitions: list[CustomFieldDefinition]
+    ) -> None:
+        """Check integrity of provided field definitions.
+
+        Validation criteria (per workspace):
+            - unique workspace_id + cf_id combinations (only for attribute and fact custom_field_type)
+            - there is no row with the same dataset_id and cf_id (only for date custom_field_type)
+
+        Args:
+            field_definitions (list[CustomFieldDefinition]): List of field definitions to check.
+        Raises:
+            ValueError: If there are duplicate field definitions based on workspace_id and cf_id.
+        """
+        workspace_field_combinations: set[tuple[str, str]] = set()
+        dataset_field_combinations: set[tuple[str, str]] = set()
+
+        for field in field_definitions:
+            if field.custom_field_type in [
+                CustomFieldType.ATTRIBUTE,
+                CustomFieldType.FACT,
+            ]:
+                combination = (field.workspace_id, field.custom_field_id)
+                if combination in workspace_field_combinations:
+                    raise ValueError(
+                        f"Duplicate custom field found for workspace {field.workspace_id} "
+                        + f"with field ID {field.custom_field_id}"
+                    )
+                workspace_field_combinations.add(combination)
+
+            elif field.custom_field_type == CustomFieldType.DATE:
+                combination = (field.dataset_id, field.custom_field_id)
+                if combination in dataset_field_combinations:
+                    raise ValueError(
+                        f"Duplicate custom field found for dataset {field.dataset_id} "
+                        + f"with field ID {field.custom_field_id}"
+                    )
+                dataset_field_combinations.add(combination)
+
+    def _validate_field_definitions(
+        self,
+        validated_definitions: dict[
+            WorkspaceId, dict[DatasetId, CustomDataset]
+        ],
+        field_definitions: list[CustomFieldDefinition],
+    ) -> dict[WorkspaceId, dict[DatasetId, CustomDataset]]:
+        """Validates custom field definitions amd connects them to the datasets.
+
+        Args:
+            validated_definitions (dict[WorkspaceId, dict[DatasetId, CustomDataset]]):
+                Dictionary of validated dataset definitions per workspace.
+            raw_field_definitions (list[dict[str, str]]): List of raw field definitions to validate.
+        Returns:
+            dict[WorkspaceId, dict[DatasetId, CustomDataset]]:
+                Updated dictionary of validated dataset definitions with custom fields added.
+        """
+        self._check_field_combinations(field_definitions)
+
+        for field_definition in field_definitions:
+            validated_definitions[field_definition.workspace_id][
+                field_definition.dataset_id
+            ].custom_fields.append(field_definition)
+
+        return validated_definitions

gooddata_pipelines/ldm_extension/ldm_extension_manager.py

@@ -0,0 +1,283 @@
+# (C) 2025 GoodData Corporation
+"""Module orchestrating the custom fields logic."""
+
+from pathlib import Path
+
+from gooddata_sdk.sdk import GoodDataSdk
+from gooddata_sdk.utils import PROFILES_FILE_PATH, profile_content
+
+from gooddata_pipelines.api import GoodDataApi
+from gooddata_pipelines.ldm_extension.input_processor import (
+    LdmExtensionDataProcessor,
+)
+from gooddata_pipelines.ldm_extension.input_validator import (
+    LdmExtensionDataValidator,
+)
+from gooddata_pipelines.ldm_extension.models.aliases import (
+    DatasetId,
+    WorkspaceId,
+)
+from gooddata_pipelines.ldm_extension.models.analytical_object import (
+    AnalyticalObject,
+    AnalyticalObjects,
+)
+from gooddata_pipelines.ldm_extension.models.custom_data_object import (
+    CustomDataset,
+    CustomDatasetDefinition,
+    CustomFieldDefinition,
+)
+from gooddata_pipelines.logger.logger import LogObserver
+
+
+class LdmExtensionManager:
+    """Manager for creating custom datasets and fields in GoodData workspaces."""
+
+    INDENT = " " * 2
+
+    @classmethod
+    def create(cls, host: str, token: str) -> "LdmExtensionManager":
+        return cls(host=host, token=token)
+
+    @classmethod
+    def create_from_profile(
+        cls,
+        profile: str = "default",
+        profiles_path: Path = PROFILES_FILE_PATH,
+    ) -> "LdmExtensionManager":
+        """Creates a provisioner instance using a GoodData profile file."""
+        content = profile_content(profile, profiles_path)
+        return cls(host=content["host"], token=content["token"])
+
+    def __init__(self, host: str, token: str):
+        self._validator = LdmExtensionDataValidator()
+        self._processor = LdmExtensionDataProcessor()
+        self._sdk = GoodDataSdk.create(host_=host, token_=token)
+        self._api = GoodDataApi(host=host, token=token)
+        self.logger = LogObserver()
+
+    def _get_objects_with_invalid_relations(
+        self, workspace_id: str
+    ) -> list[AnalyticalObject]:
+        """Check for invalid references in the provided analytical objects.
+
+        This method checks if the references in the provided analytical objects
+        are valid. It returns a set of analytical objects that have invalid references.
+
+        Args:
+            workspace_id (str): The ID of the workspace to check.
+
+        Returns:
+            list[AnalyticalObject]: Set of analytical objects with invalid references.
+        """
+
+        analytical_objects: list[AnalyticalObject] = (
+            self._get_analytical_objects(workspace_id=workspace_id)
+        )
+
+        objects_with_invalid_relations = [
+            obj
+            for obj in analytical_objects
+            if not obj.attributes.are_relations_valid
+        ]
+        return objects_with_invalid_relations
+
+    def _get_analytical_objects(
+        self, workspace_id: str
+    ) -> list[AnalyticalObject]:
+        """Get analytical objects in the workspace.
+
+        This method retrieves all analytical objects (metrics, visualizations, dashboards)
+        in the specified workspace and returns them as a list.
+
+        Args:
+            workspace_id (str): The ID of the workspace to retrieve objects from.
+
+        Returns:
+            list[AnalyticalObject]: List of analytical objects in the workspace.
+        """
+        metrics_response = self._api.get_all_metrics(workspace_id)
+        visualizations_response = self._api.get_all_visualization_objects(
+            workspace_id
+        )
+        dashboards_response = self._api.get_all_dashboards(workspace_id)
+
+        self._api.raise_if_response_not_ok(
+            metrics_response,
+            visualizations_response,
+            dashboards_response,
+        )
+        metrics = AnalyticalObjects(**metrics_response.json())
+        visualizations = AnalyticalObjects(**visualizations_response.json())
+        dashboards = AnalyticalObjects(**dashboards_response.json())
+
+        return metrics.data + visualizations.data + dashboards.data
+
+    @staticmethod
+    def _new_ldm_does_not_invalidate_relations(
+        current_invalid_relations: list[AnalyticalObject],
+        new_invalid_relations: list[AnalyticalObject],
+    ) -> bool:
+        """Check if the new LDM does not invalidate any new relations.
+
+        This method compares the lists of analytical objects containing invalid
+        relations. It creates sets of object IDs for each list and compares them.
+
+        If the set of new invalid relations is a subset of the set of current
+        invalid relations (that is before the changes to the LDM), the new LDM
+        does not invalidate any new relations and `True` is returned.
+
+        If the set of new invalid relations is not a subset of the current one,
+        it means that the new LDM invalidates new relations and `False` is returned.
+
+        Args:
+            current_invalid_relations (list[AnalyticalObject]): The current (before
+                changes to LDM) invalid relations.
+            new_invalid_relations (list[AnalyticalObject]): The new (after changes to
+                LDM) invalid relations.
+
+        Returns:
+            bool: True if the new LDM does not invalidate any relations, False otherwise.
+        """
+        # Create a set of IDs for each group, then compare those sets
+        set_current_invalid_relations = {
+            obj.id for obj in current_invalid_relations
+        }
+        set_new_invalid_relations = {obj.id for obj in new_invalid_relations}
+
+        # If the set of new invalid relations is a subset of the current one,
+        return set_new_invalid_relations.issubset(set_current_invalid_relations)
+
+    def _process_with_relations_check(
+        self,
+        validated_data: dict[WorkspaceId, dict[DatasetId, CustomDataset]],
+    ) -> None:
+        """Check whether relations of analytical objects are valid before and after
+        updating the LDM in the GoodData workspace.
+        """
+        # Iterate through the workspaces.
+        for workspace_id, datasets in validated_data.items():
+            self.logger.info(f"⚙️ Processing workspace {workspace_id}...")
+            # Get current workspace layout
+            current_layout = (
+                self._sdk.catalog_workspace.get_declarative_workspace(
+                    workspace_id
+                )
+            )
+            # Get a set of objects with invalid relations from current workspace state
+            current_invalid_relations = (
+                self._get_objects_with_invalid_relations(
+                    workspace_id=workspace_id
+                )
+            )
+
+            # Put the LDM with custom datasets into the GoodData workspace.
+            self._sdk.catalog_workspace_content.put_declarative_ldm(
+                workspace_id=workspace_id,
+                ldm=self._processor.datasets_to_ldm(datasets),
+            )
+
+            # Get a set of objects with invalid relations from the new workspace state
+            new_invalid_relations = self._get_objects_with_invalid_relations(
+                workspace_id=workspace_id
+            )
+
+            if self._new_ldm_does_not_invalidate_relations(
+                current_invalid_relations, new_invalid_relations
+            ):
+                self._log_success_message(workspace_id)
+                continue
+
+            self.logger.error(
+                f"❌ Difference in invalid relations found in workspace {workspace_id}."
+            )
+            self._log_diff_invalid_relations(
+                current_invalid_relations, new_invalid_relations
+            )
+
+            self.logger.info(
+                f"{self.INDENT}⚠️ Reverting the workspace layout to the original state."
+            )
+            # Put the original workspace layout back to the workspace
+            try:
+                self._sdk.catalog_workspace.put_declarative_workspace(
+                    workspace_id=workspace_id, workspace=current_layout
+                )
+            except Exception as e:
+                self.logger.error(
+                    f"Failed to revert workspace layout in {workspace_id}: {e}"
+                )
+
+    def _log_diff_invalid_relations(
+        self,
+        current_invalid_relations: list[AnalyticalObject],
+        new_invalid_relations: list[AnalyticalObject],
+    ) -> None:
+        """Logs objects with newly invalid relations.
+
+        Objects which previously did not have invalid relations, but do so after
+        updating the LDM, are logged.
+        """
+        # TODO: test !
+        diff_to_log: list[str] = []
+        for obj in new_invalid_relations:
+            if obj not in current_invalid_relations:
+                diff_to_log.append(
+                    f"{self.INDENT}∙ {obj.id} ({obj.type}) {obj.attributes.title}"
+                )
+        joined_diff_to_log = "\n".join(diff_to_log)
+        error_message = f"{self.INDENT}Objects with newly invalidated relations:\n{joined_diff_to_log}"
+
+        self.logger.error(error_message)
+
+    def _process_without_relations_check(
+        self,
+        validated_data: dict[WorkspaceId, dict[DatasetId, CustomDataset]],
+    ) -> None:
+        """Update the LDM in the GoodData workspace without checking relations."""
+        for workspace_id, datasets in validated_data.items():
+            # Put the LDM with custom datasets into the GoodData workspace.
+            self._sdk.catalog_workspace_content.put_declarative_ldm(
+                workspace_id=workspace_id,
+                ldm=self._processor.datasets_to_ldm(datasets),
+            )
+            self._log_success_message(workspace_id)
+
+    def _log_success_message(self, workspace_id: str) -> None:
+        """Log a success message after updating the workspace LDM."""
+        self.logger.info(f"✅ LDM in {workspace_id} updated successfully.")
+
+    def process(
+        self,
+        custom_datasets: list[CustomDatasetDefinition],
+        custom_fields: list[CustomFieldDefinition],
+        check_relations: bool = True,
+    ) -> None:
+        """Create custom datasets and fields in GoodData workspaces.
+
+        Creates custom datasets and fields to extend the Logical Data Model (LDM)
+        in GoodData workspaces based on the provided raw data definitions. The raw
+        data is validated by Pydantic models (CustomDatasetDefinition and CustomFieldDefinition).
+        The defined datasets and fields are then uploaded to GoodData Cloud.
+
+        Args:
+            custom_datasets (list[CustomDatasetDefinition]): List of custom dataset definitions.
+            custom_fields (list[CustomFieldDefinition]): List of custom field definitions.
+            check_relations (bool): If True, checks for invalid relations in the workspace
+                after updating the LDM. If the number of invalid relations increases,
+                the LDM will be reverted to its previous state. If False, the check
+                is skiped and the LDM is updated directly. Defaults to True.
+
+        Raises:
+            ValueError: If there are validation errors in the dataset or field definitions.
+        """
+        # Validate raw data and aggregate the custom field and dataset
+        # definitions per workspace.
+        validated_data: dict[WorkspaceId, dict[DatasetId, CustomDataset]] = (
+            self._validator.validate(custom_datasets, custom_fields)
+        )
+
+        if check_relations:
+            # Process the validated data with relations check.
+            self._process_with_relations_check(validated_data)
+        else:
+            self._process_without_relations_check(validated_data)

gooddata_pipelines/ldm_extension/models/__init__.py

@@ -0,0 +1 @@
+# (C) 2025 GoodData Corporation

gooddata_pipelines/ldm_extension/models/aliases.py

@@ -0,0 +1,9 @@
+# (C) 2025 GoodData Corporation
+"""This module defines type aliases intended to improve readability."""
+
+from typing import TypeAlias
+
+WorkspaceId: TypeAlias = str
+DatasetId: TypeAlias = str
+
+__all__ = ["WorkspaceId", "DatasetId"]

gooddata_pipelines/ldm_extension/models/analytical_object.py

@@ -0,0 +1,33 @@
+# (C) 2025 GoodData Corporation
+"""This module defines the AnalyticalObjects Pydantic model.
+
+The model is used to represent features of analytical objects important for
+checking the validity of references.
+"""
+
+from pydantic import BaseModel, Field
+
+
+class Attributes(BaseModel):
+    title: str
+    are_relations_valid: bool = Field(alias="areRelationsValid")
+
+
+class AnalyticalObject(BaseModel):
+    id: str
+    type: str
+    attributes: Attributes
+
+
+class AnalyticalObjects(BaseModel):
+    """Simplified model representing response obtained from GoodData API when querying
+    analytical objects.
+
+    This model is used to represent analytical objects such as metrics, visualizations,
+    and dashboard in a simplified manner, with the purpose of checkinf the validity
+    of references of these objects.
+
+    This is not a complete schema of the analytical objects!
+    """
+
+    data: list[AnalyticalObject]

gooddata_pipelines/ldm_extension/models/custom_data_object.py

@@ -0,0 +1,90 @@
+# (C) 2025 GoodData Corporation
+"""This module defines enums and models used to represent the input data.
+
+Models defined here are used to validate and structure the input data before
+further processing.
+"""
+
+from enum import Enum
+
+from pydantic import BaseModel, model_validator
+
+
+class CustomFieldType(str, Enum):
+    """GoodData field types."""
+
+    # NOTE: Start using StrEnum with Python 3.11
+    ATTRIBUTE = "attribute"
+    FACT = "fact"
+    DATE = "date"
+
+
+class ColumnDataType(str, Enum):
+    """Supported data types"""
+
+    # NOTE: Start using StrEnum with Python 3.11
+    INT = "INT"
+    STRING = "STRING"
+    DATE = "DATE"
+    NUMERIC = "NUMERIC"
+    TIMESTAMP = "TIMESTAMP"
+    TIMESTAMP_TZ = "TIMESTAMP_TZ"
+    BOOLEAN = "BOOLEAN"
+
+
+class CustomFieldDefinition(BaseModel):
+    """Input model for custom field definition."""
+
+    workspace_id: str
+    dataset_id: str
+    custom_field_id: str
+    custom_field_name: str
+    custom_field_type: CustomFieldType
+    custom_field_source_column: str
+    custom_field_source_column_data_type: ColumnDataType
+
+    @model_validator(mode="after")
+    def check_ids_not_equal(self) -> "CustomFieldDefinition":
+        """Check that custom field ID is not the same as dataset ID."""
+        if self.custom_field_id == self.dataset_id:
+            raise ValueError(
+                f"Custom field ID {self.custom_field_id} cannot be the same as dataset ID {self.dataset_id}"
+            )
+        return self
+
+
+class CustomDatasetDefinition(BaseModel):
+    """Input model for custom dataset definition."""
+
+    workspace_id: str
+    dataset_id: str
+    dataset_name: str
+    dataset_datasource_id: str
+    dataset_source_table: str | None
+    dataset_source_sql: str | None
+    parent_dataset_reference: str
+    parent_dataset_reference_attribute_id: str
+    dataset_reference_source_column: str
+    dataset_reference_source_column_data_type: ColumnDataType
+    workspace_data_filter_id: str
+    workspace_data_filter_column_name: str
+
+    @model_validator(mode="after")
+    def check_source(self) -> "CustomDatasetDefinition":
+        """At least one of dataset_source_table or dataset_source_sql is provided."""
+        if not (self.dataset_source_table or self.dataset_source_sql):
+            raise ValueError(
+                "One of dataset_source_table and dataset_source_sql must be provided"
+            )
+        if self.dataset_source_table and self.dataset_source_sql:
+            raise ValueError(
+                "Only one of dataset_source_table and dataset_source_sql can be provided"
+            )
+        return self
+
+
+class CustomDataset(BaseModel):
+    """Custom dataset with its definition and custom fields."""
+
+    definition: CustomDatasetDefinition
+    custom_fields: list[CustomFieldDefinition]

gooddata_pipelines/provisioning/entities/users/models/users.py

@@ -3,7 +3,16 @@
 from typing import Any
 
 from gooddata_sdk.catalog.user.entity_model.user import CatalogUser
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
+
+
+class UserProfile(BaseModel):
+    """Minimal model of api/v1/profile response.
+
+    Does not contain all fields from the response.
+    """
+
+    user_id: str = Field(alias="userId")
 
 
 class BaseUser(BaseModel):

gooddata_pipelines/provisioning/entities/users/users.py

@@ -11,6 +11,7 @@ from gooddata_sdk.catalog.user.entity_model.user_group import CatalogUserGroup
 from gooddata_pipelines.provisioning.entities.users.models.users import (
     UserFullLoad,
     UserIncrementalLoad,
+    UserProfile,
 )
 from gooddata_pipelines.provisioning.provisioning import Provisioning
 from gooddata_pipelines.provisioning.utils.context_objects import UserContext
@@ -30,6 +31,8 @@ class UserProvisioner(Provisioning[UserFullLoad, UserIncrementalLoad]):
     source_group_incremental: list[UserIncrementalLoad]
     source_group_full: list[UserFullLoad]
 
+    current_user_id: str
+
     FULL_LOAD_TYPE: type[UserFullLoad] = UserFullLoad
     INCREMENTAL_LOAD_TYPE: type[UserIncrementalLoad] = UserIncrementalLoad
 
@@ -37,6 +40,19 @@ class UserProvisioner(Provisioning[UserFullLoad, UserIncrementalLoad]):
         super().__init__(host, token)
         self.upstream_user_cache: dict[UserId, UserModel] = {}
 
+    def _get_current_user_id(self) -> str:
+        """Gets the current user ID."""
+
+        profile_response = self._api.get_profile()
+
+        if not profile_response.ok:
+            raise Exception("Failed to get current user profile")
+
+        profile_json = profile_response.json()
+        profile = UserProfile.model_validate(profile_json)
+
+        return profile.user_id
+
     def _try_get_user(
         self, user: UserModel, model: type[UserModel]
     ) -> UserModel | None:
@@ -99,6 +115,14 @@ class UserProvisioner(Provisioning[UserFullLoad, UserIncrementalLoad]):
         for its existence and create it if needed.
 
         """
+
+        if user.user_id == self.current_user_id:
+            self.logger.warning(
+                f"Skipping creation/update of current user: {user.user_id}. "
+                + "Current user should not be modified.",
+            )
+            return
+
         user_context = UserContext(
             user_id=user.user_id,
             user_groups=user.user_groups,
@@ -118,6 +142,13 @@ class UserProvisioner(Provisioning[UserFullLoad, UserIncrementalLoad]):
 
     def _delete_user(self, user_id: str) -> None:
         """Deletes user from the project."""
+        if user_id == self.current_user_id:
+            self.logger.warning(
+                f"Skipping deletion of current user: {user_id}."
+                + " Current user should not be deleted.",
+            )
+            return
+
         try:
             self._api._sdk.catalog_user.get_user(user_id)
         except NotFoundException:
@@ -135,6 +166,9 @@ class UserProvisioner(Provisioning[UserFullLoad, UserIncrementalLoad]):
 
     def _provision_incremental_load(self) -> None:
         """Runs the incremental provisioning logic."""
+        # Set the current user ID
+        self.current_user_id = self._get_current_user_id()
+
         for user in self.source_group_incremental:
             # Attempt to process each user. On failure, log the error and continue
             try:
@@ -146,6 +180,10 @@ class UserProvisioner(Provisioning[UserFullLoad, UserIncrementalLoad]):
 
     def _provision_full_load(self) -> None:
         """Runs the full load provisioning logic."""
+
+        # Set the current user ID
+        self.current_user_id = self._get_current_user_id()
+
         # Get all upstream users
         catalog_upstream_users: list[CatalogUser] = self._api.list_users()
 

gooddata_pipelines/provisioning/provisioning.py

@@ -50,7 +50,7 @@ class Provisioning(Generic[TFullLoadSourceData, TIncrementalSourceData]):
     ) -> TProvisioning:
         """Creates a provisioner instance using a GoodData profile file."""
         content = profile_content(profile, profiles_path)
-        return cls(**content)
+        return cls(host=content["host"], token=content["token"])
 
     @staticmethod
     def _validate_credentials(host: str, token: str) -> None:
@@ -165,5 +165,4 @@ class Provisioning(Generic[TFullLoadSourceData, TIncrementalSourceData]):
 
         self.logger.error(exception_message)
 
-        if not self.logger.subscribers:
-            raise Exception(exception_message)
+        raise Exception(exception_message)

{gooddata_pipelines-1.50.1.dev1.dist-info → gooddata_pipelines-1.51.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gooddata-pipelines
-Version: 1.50.1.dev1
+Version: 1.51.0
 Summary: GoodData Cloud lifecycle automation pipelines
 Author-email: GoodData <support@gooddata.com>
 License: MIT
@@ -8,7 +8,7 @@ License-File: LICENSE.txt
 Requires-Python: >=3.10
 Requires-Dist: boto3-stubs<2.0.0,>=1.39.3
 Requires-Dist: boto3<2.0.0,>=1.39.3
-Requires-Dist: gooddata-sdk~=1.50.1.dev1
+Requires-Dist: gooddata-sdk~=1.51.0
 Requires-Dist: pydantic<3.0.0,>=2.11.3
 Requires-Dist: requests<3.0.0,>=2.32.3
 Requires-Dist: types-pyyaml<7.0.0,>=6.0.12.20250326
@@ -74,4 +74,12 @@ full_load_data: list[UserFullLoad] = UserFullLoad.from_list_of_dicts(
 provisioner.full_load(full_load_data)
 ```
 
-Ready-made scripts covering the basic use cases can be found here in the [GoodData Productivity Tools](https://github.com/gooddata/gooddata-productivity-tools) repository
+## Bugs & Requests
+
+Please use the [GitHub issue tracker](https://github.com/gooddata/gooddata-python-sdk/issues) to submit bugs
+or request features.
+
+## Changelog
+
+See  [Github releases](https://github.com/gooddata/gooddata-python-sdk/releases) for released versions
+and a list of changes.

{gooddata_pipelines-1.50.1.dev1.dist-info → gooddata_pipelines-1.51.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-gooddata_pipelines/__init__.py,sha256=AEKIRuGBPMA_RkL14RF-recw9hS4dGV8cVqgDM3XmrA,1931
+gooddata_pipelines/__init__.py,sha256=UyE19wWfPh2R_5O0KSAS4XLllP3km3iGkDzRQFBd7jQ,2415
 gooddata_pipelines/_version.py,sha256=Zi8Ht5ofjFeSYGG5USixQtJNB1po6okh0Rez8VyAsFM,200
 gooddata_pipelines/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gooddata_pipelines/api/__init__.py,sha256=0WaBI2XMdkkZgnUsQ9kqipNzh2l2zamZvUt_qjp8xCk,106
 gooddata_pipelines/api/exceptions.py,sha256=rddQXfv8Ktckz7RONKBnKfm53M7dzPCh50Dl1k-8hqs,1545
-gooddata_pipelines/api/gooddata_api.py,sha256=ALuxTgu3KOK5S2b0C5HpDyvmT_UNfGeF-eqbvxXhDQM,8667
+gooddata_pipelines/api/gooddata_api.py,sha256=8AZ5-mGGvo_4pPFjaf_DxkzQQqp2dRtiRPTM2sIdfYs,10934
 gooddata_pipelines/api/gooddata_api_wrapper.py,sha256=t7dFrXJ6X4yXS9XDthOmvd2CyzdnDDNPeIngTEW72YU,1152
 gooddata_pipelines/api/gooddata_sdk.py,sha256=wd5O4e9BQLWUawt6odrs5a51nqFGthBkvqh9WOiW36Q,13734
 gooddata_pipelines/api/utils.py,sha256=3QY_aYH17I9THoCINE3l-n5oj52k-gNeT1wv6Z_VxN8,1433
@@ -20,10 +20,18 @@ gooddata_pipelines/backup_and_restore/storage/__init__.py,sha256=-BG28PGDbalLyZG
 gooddata_pipelines/backup_and_restore/storage/base_storage.py,sha256=67wdItlG3neExeb_eCUDQhswdUB62X5Nyj9sOImB_Hg,487
 gooddata_pipelines/backup_and_restore/storage/local_storage.py,sha256=NvhPRzRAvuSpc5qCDyPqZaMB0i1jeZOZczaSwjUSGEg,1155
 gooddata_pipelines/backup_and_restore/storage/s3_storage.py,sha256=ZAysu4sPMAvdWs3RUroHHp2XZLHeU_LhJ5qBHlBQ7n4,3732
+gooddata_pipelines/ldm_extension/__init__.py,sha256=-BG28PGDbalLyZGQjpFG0pjdIvtf25ut0r8ZwZVbi4s,32
+gooddata_pipelines/ldm_extension/input_processor.py,sha256=lNIx6YfU4OJpSLyAitCoPwwf6eFIT6OyivRnqYX5O-o,11678
+gooddata_pipelines/ldm_extension/input_validator.py,sha256=sAl-tixrS69G_lP19U9CjKHiWZinXOcjeAqwiydVctQ,7459
+gooddata_pipelines/ldm_extension/ldm_extension_manager.py,sha256=XHNBMAaiUvIzBib3zz9mYcmGk6YOkIhqrxYfQaV9s9Q,11483
+gooddata_pipelines/ldm_extension/models/__init__.py,sha256=-BG28PGDbalLyZGQjpFG0pjdIvtf25ut0r8ZwZVbi4s,32
+gooddata_pipelines/ldm_extension/models/aliases.py,sha256=vmac3fGhTjGQqclW3Be42kE-ooC3ZBtYS8JqpXmBy_g,231
+gooddata_pipelines/ldm_extension/models/analytical_object.py,sha256=biWgRdczuF-IRz7zQNWrWAWmc-r7_OpSdDJA7klI7ME,913
+gooddata_pipelines/ldm_extension/models/custom_data_object.py,sha256=wH2ZrgjKiuFCDB2BTUntyGbEw-oFuwtaepYKdtSwgHY,2771
 gooddata_pipelines/logger/__init__.py,sha256=W-fJvMStnsDUY52AYFhx_LnS2cSCFNf3bB47Iew2j04,129
 gooddata_pipelines/logger/logger.py,sha256=yIMdvqsmOSGQLI4U_tQwxX5E2q_FXUu0Ko7Hv39slFM,3549
 gooddata_pipelines/provisioning/__init__.py,sha256=RZDEiv8nla4Jwa2TZXUdp1NSxg2_-lLqz4h7k2c4v5Y,854
-gooddata_pipelines/provisioning/provisioning.py,sha256=Mibf1-ZwPfHzmoAjgIRuYvtakY7LqerDTF36FgPg990,6175
+gooddata_pipelines/provisioning/provisioning.py,sha256=UUHClT0q6O1XDAgiR2M23eFgtU3uEFBp87-b13-m97I,6166
 gooddata_pipelines/provisioning/assets/wdf_setting.json,sha256=nxOLGZkEQiMdARcUDER5ygqr3Zu-MQlLlUyXVhPUq64,280
 gooddata_pipelines/provisioning/entities/__init__.py,sha256=-BG28PGDbalLyZGQjpFG0pjdIvtf25ut0r8ZwZVbi4s,32
 gooddata_pipelines/provisioning/entities/user_data_filters/__init__.py,sha256=-BG28PGDbalLyZGQjpFG0pjdIvtf25ut0r8ZwZVbi4s,32
@@ -33,11 +41,11 @@ gooddata_pipelines/provisioning/entities/user_data_filters/models/udf_models.py,
 gooddata_pipelines/provisioning/entities/users/__init__.py,sha256=-BG28PGDbalLyZGQjpFG0pjdIvtf25ut0r8ZwZVbi4s,32
 gooddata_pipelines/provisioning/entities/users/permissions.py,sha256=2k3oPI7WyABcD2TMmLPsMUDrAjnKM7Vw56kz_RWhcmI,7135
 gooddata_pipelines/provisioning/entities/users/user_groups.py,sha256=-2Nca01ZMjXmnAGDUuKP5G7mqFyn4MnsgZsnS2oy7vg,8511
-gooddata_pipelines/provisioning/entities/users/users.py,sha256=TVfOp3fqQYmzA4K03IBGNYJrqGQAzWH_oay0qsvR8Xo,6633
+gooddata_pipelines/provisioning/entities/users/users.py,sha256=BPTbE0-lvwkgoTVwLUbMqmlq7L597nwRCSK5FaM8F4I,7730
 gooddata_pipelines/provisioning/entities/users/models/__init__.py,sha256=-BG28PGDbalLyZGQjpFG0pjdIvtf25ut0r8ZwZVbi4s,32
 gooddata_pipelines/provisioning/entities/users/models/permissions.py,sha256=buyNtDShvAJL4mFZSV-UqK_9JAL_2-AaIlGYCHibhHo,7244
 gooddata_pipelines/provisioning/entities/users/models/user_groups.py,sha256=Odp4yZoK2vC40jgh7FBKmaIINpwffl62uoaT8Xxr-14,1160
-gooddata_pipelines/provisioning/entities/users/models/users.py,sha256=lwb8Q-slBELs_0882KOumkMgKiFKCL3ZABONsoT5Nw0,2234
+gooddata_pipelines/provisioning/entities/users/models/users.py,sha256=hR5on68NEpw3KAPooR3Z1TRUzV5nbp0jrrOLUDW8P24,2424
 gooddata_pipelines/provisioning/entities/workspaces/__init__.py,sha256=-BG28PGDbalLyZGQjpFG0pjdIvtf25ut0r8ZwZVbi4s,32
 gooddata_pipelines/provisioning/entities/workspaces/models.py,sha256=-ehte9HLNos3l6yLip4mZU6wBcmY_Yzwq0t0m0fhwPI,2031
 gooddata_pipelines/provisioning/entities/workspaces/workspace.py,sha256=jngaEKNlMfhjRr4rQ2ECQDoh0gk7KaZTMuTazPLECnM,11505
@@ -50,7 +58,7 @@ gooddata_pipelines/provisioning/utils/exceptions.py,sha256=1WnAOlPhqOf0xRcvn70lx
 gooddata_pipelines/provisioning/utils/utils.py,sha256=uF3k5hmoM5d6UoWWfPGCQgT_861zcU-ACyaQHHOOncY,2434
 gooddata_pipelines/utils/__init__.py,sha256=s9TtSjKqo1gSGWOVoGrXaGi1TsbRowjRDYKtjmKy7BY,155
 gooddata_pipelines/utils/rate_limiter.py,sha256=owbcEZhUxlTnE7rRHiWQ8XBC-vML2fVPbt41EeGEM7o,2002
-gooddata_pipelines-1.50.1.dev1.dist-info/METADATA,sha256=YcJNGu4zGfjvfMJlzUzm77G5rm0xubtl2-0MUB40jWI,3522
-gooddata_pipelines-1.50.1.dev1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-gooddata_pipelines-1.50.1.dev1.dist-info/licenses/LICENSE.txt,sha256=PNC7WXGIo6OKkNoPLRxlVrw6jaLcjSTUsSxy9Xcu9Jo,560365
-gooddata_pipelines-1.50.1.dev1.dist-info/RECORD,,
+gooddata_pipelines-1.51.0.dist-info/METADATA,sha256=250PnN2MssPWL7c1O0lcZR3eyoRw0WB_9tpY1POc6yU,3632
+gooddata_pipelines-1.51.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+gooddata_pipelines-1.51.0.dist-info/licenses/LICENSE.txt,sha256=PNC7WXGIo6OKkNoPLRxlVrw6jaLcjSTUsSxy9Xcu9Jo,560365
+gooddata_pipelines-1.51.0.dist-info/RECORD,,