gooddata-pipelines 1.47.1.dev1__py3-none-any.whl

gooddata_pipelines/provisioning/entities/workspaces/workspace_data_validator.py

@@ -0,0 +1,188 @@
+# (C) 2025 GoodData Corporation
+
+"""Module for validating workspace data integrity in GoodData Cloud."""
+
+from typing import Any
+
+from requests import Response
+
+from gooddata_pipelines.api import GoodDataApi
+from gooddata_pipelines.logger.logger import LogObserver
+from gooddata_pipelines.provisioning.entities.workspaces.models import (
+    WorkspaceFullLoad,
+)
+from gooddata_pipelines.provisioning.utils.context_objects import (
+    WorkspaceContext,
+)
+from gooddata_pipelines.provisioning.utils.exceptions import (
+    WorkspaceDataIntegrityException,
+    WorkspaceException,
+)
+
+
+class WorkspaceDataValidator:
+    """Class for validating workspace data integrity before provisioning."""
+
+    def __init__(self, api: GoodDataApi):
+        """
+        Initializes the WorkspaceDataValidator with the GoodData API instance.
+
+        Args:
+            api (GoodDataApi): An instance of the GoodData API client.
+        """
+        self.api = api
+        self.logger = LogObserver()
+
+    def _check_basic_integrity(
+        self,
+        source_group: list[WorkspaceFullLoad],
+    ) -> tuple[set[str], dict[str, list[str]]]:
+        """
+        Checks that mandatory fields are not empty and that that the combinations
+        of values are unique.
+
+        Returns a set of parent workspaces and a dictionary of parent-wdf mappings.
+        """
+        parent_workspaces: set[str] = set()
+        parent_wdf_map: dict[str, list[str]] = {}
+        parent_child_wdf_ids: list[tuple[str, str, str | None]] = []
+
+        # Check that fields are not empty
+        for workspace in source_group:
+            parent_id: str | None = workspace.parent_id
+            workspace_id: str | None = workspace.workspace_id
+            workspace_name: str | None = workspace.workspace_name
+            wdf_id: str | None = workspace.workspace_data_filter_id
+            wdf_values: list[str] | None = (
+                workspace.workspace_data_filter_values
+            )
+
+            # Create a context for the workspace validation
+            validation_context: WorkspaceContext = WorkspaceContext(
+                workspace_id=workspace_id,
+                workspace_name=workspace_name,
+                wdf_id=wdf_id,
+                wdf_values=wdf_values,
+            )
+
+            # Raise specific error if both parent_id and workspace_id are not defined
+            if (parent_id is None or parent_id == "") and (
+                workspace_id is None or workspace_id == ""
+            ):
+                raise WorkspaceDataIntegrityException(
+                    "Parent ID and workspace ID are not defined for at least one row. Please check the source data."
+                )
+
+            # Raise error if parent_id is not defined
+            if parent_id is None or parent_id == "":
+                raise WorkspaceDataIntegrityException(
+                    "Parent ID is not defined in source data.",
+                    validation_context,
+                )
+
+            # Add parent_id to the set of unique parent workspaces
+            parent_workspaces.add(parent_id)
+
+            # Raise error if workspace_id is not defined
+            if workspace_id is None or workspace_id == "":
+                raise WorkspaceDataIntegrityException(
+                    f"Workspace ID is not defined for parent {parent_id}"
+                )
+
+            # Raise error if wdf_id is not defined but has values
+            if wdf_id is not None and wdf_id != "":
+                if wdf_values is None or wdf_values == []:
+                    raise WorkspaceDataIntegrityException(
+                        "WDF ID is defined but no WDF values are provided",
+                        validation_context,
+                    )
+
+                # Add wdf_id to the parent-wdf dict if the value is defined
+                if not parent_wdf_map.get(parent_id):
+                    parent_wdf_map[parent_id] = []
+
+                parent_wdf_map[parent_id].append(wdf_id)
+
+            # Raise error if wdf_values are defined but wdf_id is not defined
+            if wdf_values is not None and wdf_values != []:
+                if wdf_id is None or wdf_id == "":
+                    raise WorkspaceDataIntegrityException(
+                        "WDF values are provided but WDF ID is not defined.",
+                        validation_context,
+                    )
+
+            parent_child_wdf_ids.append((parent_id, workspace_id, wdf_id))
+
+        # Check whether there are non-unique combinations in data
+        if len(parent_child_wdf_ids) != len(set(parent_child_wdf_ids)):
+            # Log the error to the database as a warning, but continue execution
+            self.logger.warning(
+                "Duplicate combinations of parent_id, workspace_id, "
+                + "wdf_id exist in the source data."
+            )
+
+        return parent_workspaces, parent_wdf_map
+
+    def _check_parent_exist(self, parent_id: str) -> None:
+        """
+        Raises an error if a parent workspace does not exist in Panther.
+        """
+        if not self.api.check_workspace_exists(parent_id):
+            raise WorkspaceException(
+                f"Parent workspace {parent_id} does not exist in Panther.",
+                workspace_id=parent_id,
+            )
+
+    def _check_wdf_is_set_on_parent(
+        self, parent_id: str, source_wdf_ids: list[str]
+    ) -> None:
+        """Raises an error if the parent workspace does not contain any of the defined wdf_id."""
+        wdf_response: Response = self.api.get_all_workspace_data_filters(
+            parent_id
+        )
+        wdf_json: dict[str, Any] = wdf_response.json()
+        wdf_data: list[dict[str, Any]] = wdf_json.get("data", [])
+        wdf_ids_on_parent: set[str] = {wdf["id"] for wdf in wdf_data}
+
+        for source_wdf_id in source_wdf_ids:
+            if source_wdf_id not in wdf_ids_on_parent:
+                raise WorkspaceException(
+                    f"WDF is not set on parent workspace {parent_id}.",
+                    wdf_id=source_wdf_id,
+                    workspace_id=parent_id,
+                )
+
+    def validate_source_data(
+        self, source_group: list[WorkspaceFullLoad]
+    ) -> None:
+        """
+        Validates the source data integrity.
+
+        **Raises error when**:
+        - the list of workspaces is empty
+        - parent_id is not defined
+        - workspace_id is not defined
+        - The parent workspace does not exist
+        - The parent workspace does not contain defined wdf_id.
+        - wdf_id is defined but wdf_values is not defined
+        - wdf_values are defined but wdf_id is not defined
+
+        **Logs a warning when**:
+        - There are more values for the parent_id, workspace_id, wdf_id combination.
+        """
+        if not source_group:
+            # Raise error if source is empty
+            raise WorkspaceException(
+                "No workspaces found in the source database."
+            )
+
+        unique_parents, parent_wdf_map = self._check_basic_integrity(
+            source_group
+        )
+
+        for parent_id in unique_parents:
+            self._check_parent_exist(parent_id)
+
+            self._check_wdf_is_set_on_parent(
+                parent_id, parent_wdf_map[parent_id]
+            )

gooddata_pipelines/provisioning/provisioning.py

@@ -0,0 +1,132 @@
+# (C) 2025 GoodData Corporation
+
+"""Provisioning base class for GoodData Pipelines."""
+
+from pathlib import Path
+from typing import Generic, Type, TypeVar
+
+from gooddata_sdk.utils import PROFILES_FILE_PATH, profile_content
+
+from gooddata_pipelines.api import GoodDataApi
+from gooddata_pipelines.logger.logger import (
+    LogObserver,
+)
+from gooddata_pipelines.provisioning.utils.utils import EntityGroupIds
+
+TFullLoadSourceData = TypeVar("TFullLoadSourceData")
+TIncrementalSourceData = TypeVar("TIncrementalSourceData")
+
+
+class Provisioning(Generic[TFullLoadSourceData, TIncrementalSourceData]):
+    """Base provisioning class."""
+
+    TProvisioning = TypeVar("TProvisioning", bound="Provisioning")
+    source_group_full: list[TFullLoadSourceData]
+    source_group_incremental: list[TIncrementalSourceData]
+
+    def __init__(self, host: str, token: str) -> None:
+        self.source_id: set[str] = set()
+        self.upstream_id: set[str] = set()
+        self._api = GoodDataApi(host, token)
+        self.logger: LogObserver = LogObserver()
+        self.fatal_exception: str = ""
+
+    @classmethod
+    def create(
+        cls: Type[TProvisioning], host: str, token: str
+    ) -> TProvisioning:
+        """Creates a provisioner instance using provided host and token."""
+        return cls(host=host, token=token)
+
+    @classmethod
+    def create_from_profile(
+        cls: Type[TProvisioning],
+        profile: str = "default",
+        profiles_path: Path = PROFILES_FILE_PATH,
+    ) -> TProvisioning:
+        """Creates a provisioner instance using a GoodData profile file."""
+        content = profile_content(profile, profiles_path)
+        return cls(**content)
+
+    @staticmethod
+    def _create_groups(
+        source_id: set[str], panther_id: set[str]
+    ) -> EntityGroupIds:
+        """Creates groups for provisioning as sets of IDs.
+
+        Sorts the IDs into three categories:
+        - IDs that exist both source and upstream (to be checked further)
+        - IDs that exist upstream but not in source (to be deleted)
+        - IDs that exist in source but not upstream (to be created)
+        """
+        ids_in_both_systems: set[str] = source_id.intersection(panther_id)
+        ids_to_delete: set[str] = panther_id.difference(source_id)
+        ids_to_create: set[str] = source_id.difference(panther_id)
+
+        return EntityGroupIds(
+            ids_in_both_systems=ids_in_both_systems,
+            ids_to_delete=ids_to_delete,
+            ids_to_create=ids_to_create,
+        )
+
+    def _provision_incremental_load(self) -> None:
+        raise NotImplementedError(
+            "Provisioning method to be implemented in the subclass."
+        )
+
+    def _provision_full_load(self) -> None:
+        raise NotImplementedError(
+            "Provisioning method to be implemented in the subclass."
+        )
+
+    def full_load(self, source_data: list[TFullLoadSourceData]) -> None:
+        """Runs full provisioning workflow with the provided source data.
+
+        Full provisioning is a full load of the source data, where the source data
+        is assumed to a single source of truth and the upstream workspaces are updated
+        to match it.
+
+        That means:
+        - All workspaces declared in the source data are created if missing, or
+        updated to match the source data
+        - All workspaces not declared in the source data are deleted
+        """
+        self.source_group_full = source_data
+
+        try:
+            self._provision_full_load()
+            self.logger.info("Provisioning completed successfully.")
+        except Exception as e:
+            self.fatal_exception = str(e)
+            self.logger.error(
+                f"Provisioning failed. Error: {self.fatal_exception} "
+                + f"Context: {e.__dict__}"
+            )
+
+    def incremental_load(
+        self, source_data: list[TIncrementalSourceData]
+    ) -> None:
+        """Runs incremental provisioning workflow with the provided source data.
+
+        Incremental provisioning is used to modify a subset of the upstream workspaces
+        based on the source data provided.
+        """
+        self.source_group_incremental = source_data
+
+        try:
+            self._provision_incremental_load()
+            self.logger.info("Provisioning completed successfully.")
+        except Exception as e:
+            self.fatal_exception = str(e)
+            self.logger.error(
+                f"Provisioning failed. Error: {self.fatal_exception} "
+                + f"Context: {e.__dict__}"
+            )
+
+    # TODO: implement a sceond provisioning method and name the two differently:
+    #  1) provision_incremental - will use the is_active logic, such as user provisioning now
+    #  2) provision_full - full load of the source data, like workspaces now
+    #  Each will have its own implementation and source data model.
+    #  Both use cases are required and need to be supported.
+    #  This will also improve the clarity of the code as now provisioning of each
+    #   entity works differently, leading to confusion.

gooddata_pipelines/provisioning/utils/__init__.py

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

gooddata_pipelines/provisioning/utils/context_objects.py

@@ -0,0 +1,32 @@
+# (C) 2025 GoodData Corporation
+
+"""Module for context objects used in GoodData Pipelines provisioning."""
+
+
+class WorkspaceContext:
+    workspace_id: str
+    workspace_name: str | None
+    wdf_id: str | None
+    wdf_values: list[str] | None
+
+    def __init__(
+        self,
+        workspace_id: str | None,
+        workspace_name: str | None,
+        wdf_id: str | None = None,
+        wdf_values: list[str] | None = None,
+    ):
+        self.workspace_id: str = workspace_id if workspace_id else "NA"
+        self.workspace_name: str | None = workspace_name
+        self.wdf_id: str | None = wdf_id
+        self.wdf_values: list[str] | None = wdf_values
+
+
+class UserContext:
+    user_id: str
+    user_groups: str
+
+    def __init__(self, user_id: str, user_groups: list[str]):
+        """User context object, stringifies list of user groups"""
+        self.user_id: str = user_id
+        self.user_groups: str = ",".join(user_groups)

gooddata_pipelines/provisioning/utils/exceptions.py

@@ -0,0 +1,95 @@
+# (C) 2025 GoodData Corporation
+
+"""Module for exceptions used in GoodData Pipelines provisioning."""
+
+from gooddata_pipelines.provisioning.utils.utils import AttributesMixin
+
+
+# TODO: Use the generic context exception and phase out the specific ones
+#  - we don't need to conform to process-specific schema anymore
+class ContextException(Exception, AttributesMixin):
+    def __init__(
+        self, message: str, *context_objects: object, **kwargs: str
+    ) -> None:
+        """Exception raised during context processing."""
+        super().__init__(message)
+        attributes = self.get_attrs(*context_objects, overrides=kwargs)
+
+        for key, value in attributes.items():
+            setattr(self, key, value)
+
+
+class ProvisioningException(Exception, AttributesMixin):
+    def __init__(
+        self, message: str, *context_objects: object, **kwargs: str
+    ) -> None:
+        """Exception raised during provisioning."""
+        super().__init__(message)
+        self.attributes = self.get_attrs(*context_objects, overrides=kwargs)
+        self.error_message: str = message
+
+
+class WorkspaceException(ProvisioningException):
+    def __init__(
+        self,
+        message: str,
+        *context_objects: object,
+        **kwargs: str,
+    ) -> None:
+        """Exception raised during workspace provisioning."""
+        super().__init__(message, *context_objects, **kwargs)
+
+        self.http_status: str = self.attributes.get(
+            "http_status", "500 Internal Server Error"
+        )
+        self.http_method: str | None = self.attributes.get("http_method", "NA")
+        self.workspace_id: str = self.attributes.get("workspace_id", "NA")
+        self.workspace_name: str | None = self.attributes.get(
+            "workspace_name", "NA"
+        )
+        self.wdf_id: str | None = self.attributes.get("wdf_id", None)
+        self.wdf_values: str | None = self.attributes.get("wdf_values", None)
+        self.api_endpoint: str = self.attributes.get(
+            "api_endpoint", "workspace_provisioning"
+        )
+
+
+class WorkspaceDataIntegrityException(WorkspaceException):
+    def __init__(
+        self, message: str, *context_objects: object, **kwargs: str
+    ) -> None:
+        """Exception raised during workspace validation."""
+        super().__init__(message, *context_objects, **kwargs)
+
+        self.workspace_id: str = self.attributes.get("workspace_id", "NA")
+        self.workspace_name: str | None = self.attributes.get(
+            "workspace_name", None
+        )
+        self.wdf_id: str | None = self.attributes.get("wdf_id", None)
+        self.wdf_values: str | None = self.attributes.get("wdf_values", None)
+        self.api_endpoint: str = self.attributes.get(
+            "api_endpoint", "workspace_data_validation"
+        )
+
+
+class BaseUserException(ProvisioningException):
+    def __init__(
+        self, message: str, *context_objects: object, **kwargs: str
+    ) -> None:
+        """Exception raised during user provisioning."""
+        super().__init__(message, *context_objects, **kwargs)
+
+        self.http_status: str = self.attributes.get(
+            "http_status", "500 Internal Server Error"
+        )
+        self.http_method: str | None = self.attributes.get("http_method", None)
+        self.workspace_id: str | None = self.attributes.get(
+            "workspace_id", None
+        )
+        self.user_id: str | None = self.attributes.get("user_id", None)
+        self.user_group_id: str | None = self.attributes.get(
+            "user_group_id", None
+        )
+        self.api_endpoint: str = self.attributes.get(
+            "api_endpoint", "user_provisioning"
+        )

gooddata_pipelines/provisioning/utils/utils.py

@@ -0,0 +1,80 @@
+# (C) 2025 GoodData Corporation
+
+"""Module for utilities used in GoodData Pipelines provisioning."""
+
+from pydantic import BaseModel
+from requests import Response
+
+
+class AttributesMixin:
+    """
+    Mixin class to provide a method for getting attributes of an object which may or may not exist.
+    """
+
+    @staticmethod
+    def get_attrs(
+        *objects: object, overrides: dict[str, str] | None = None
+    ) -> dict[str, str]:
+        """
+        Returns a dictionary of attributes from the given objects.
+
+        Args:
+            objects: The objects to get the attributes from. Special handling is implemented for
+                    requests.Response, __dict__ attribute is used for general objects.
+            overrides: A dictionary of attributes to override the object's attributes.
+        Returns:
+            dict: Returns a dictionary of the objects' attributes.
+        """
+        # TODO: This might not work great with nested objects, values  which are lists of objects etc.
+        # If we care about parsing the logs back from the string, we should consider some other approach
+        attrs: dict[str, str] = {}
+        for context_object in objects:
+            if isinstance(context_object, Response):
+                # for request.Response objects, keys need to be renamed to match the log schema
+                attrs.update(
+                    {
+                        "http_status": str(context_object.status_code),
+                        "http_method": getattr(
+                            context_object.request, "method", "NA"
+                        ),
+                        "api_endpoint": getattr(
+                            context_object.request, "url", "NA"
+                        ),
+                    }
+                )
+            else:
+                # Generic handling for other objects
+                for key, value in context_object.__dict__.items():
+                    if value is None:
+                        continue
+
+                    if isinstance(value, list):
+                        attrs[key] = ", ".join(
+                            str(list_item) for list_item in value
+                        )
+                    else:
+                        attrs[key] = str(value)
+
+        if overrides:
+            attrs.update(overrides)
+
+        return attrs
+
+
+class SplitMixin:
+    @staticmethod
+    def split(string_value: str, delimiter: str = ",") -> list[str]:
+        """
+        Splits a string by the given delimiter and returns a list of stripped values.
+        If the input is empty, returns an empty list.
+        """
+        if not string_value:
+            return []
+
+        return [value.strip() for value in string_value.split(delimiter)]
+
+
+class EntityGroupIds(BaseModel):
+    ids_in_both_systems: set[str]
+    ids_to_delete: set[str]
+    ids_to_create: set[str]

gooddata_pipelines-1.47.1.dev1.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: gooddata-pipelines
+Version: 1.47.1.dev1
+Author-email: GoodData <support@gooddata.com>
+License: MIT
+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.47.1.dev1
+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
+Requires-Dist: types-requests<3.0.0,>=2.32.0
+Provides-Extra: dev
+Requires-Dist: moto<6.0.0,>=5.1.6; extra == 'dev'
+Requires-Dist: mypy<2.0.0,>=1.16.0; extra == 'dev'
+Requires-Dist: pytest-mock<4.0.0,>=3.14.0; extra == 'dev'
+Requires-Dist: pytest<9.0.0,>=8.3.5; extra == 'dev'
+Requires-Dist: ruff<0.12.0,>=0.11.2; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# GoodData Pipelines
+
+A high level library for automating the lifecycle of GoodData Cloud (GDC).
+
+You can use the package to manage following resoursec in GDC:
+
+1. Provisioning (create, update, delete)
+   - User profiles
+   - User Groups
+   - User/Group permissions
+   - User Data Filters
+   - Child workspaces (incl. Workspace Data Filter settings)
+1. _[PLANNED]:_ Backup and restore of workspaces
+1. _[PLANNED]:_ Custom fields management
+   - extend the Logical Data Model of a child workspace
+
+In case you are not interested in incorporating a library in your own program, but would like to use a ready-made script, consider having a look at [GoodData Productivity Tools](https://github.com/gooddata/gooddata-productivity-tools).
+
+## Provisioning
+
+The entities can be managed either in _full load_ or _incremental_ way.
+
+Full load means that the input data should represent the full and complete desired state of GDC after the script has finished. For example, you would include specification of all child workspaces you want to exist in GDC in the input data for workspace provisioning. Any workspaces present in GDC and not defined in the source data (i.e., your input) will be deleted.
+
+On the other hand, the incremental load treats the source data as instructions for a specific change, e.g., a creation or a deletion of a specific workspace. You can specify which workspaces you would want to delete or create, while the rest of the workspaces already present in GDC will remain as they are, ignored by the provisioning script.
+
+The provisioning module exposes _Provisioner_ classes reflecting the different entities. The typical usage would involve importing the Provisioner class and the data input data model for the class and planned provisioning method:
+
+```python
+import os
+from csv import DictReader
+from pathlib import Path
+
+# Import the Entity Provisioner class and corresponing model from gooddata_pipelines library
+from gooddata_pipelines import UserFullLoad, UserProvisioner
+
+# Optional: you can set up logging and subscribe it to the Provisioner
+from utils.logger import setup_logging
+
+setup_logging()
+logger = logging.getLogger(__name__)
+
+# Create the Provisioner instance - you can also create the instance from a GDC yaml profile
+provisioner = UserProvisioner(
+    host=os.environ["GDC_HOSTNAME"], token=os.environ["GDC_AUTH_TOKEN"]
+)
+
+# Optional: subscribe to logs
+provisioner.logger.subscribe(logger)
+
+# Load your data from your data source
+source_data_path: Path = Path("path/to/some.csv")
+source_data_reader = DictReader(source_data_path.read_text().splitlines())
+source_data = [row for row in source_data_reader]
+
+# Validate your input data with
+full_load_data: list[UserFullLoad] = UserFullLoad.from_list_of_dicts(
+    source_data
+)
+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

gooddata_pipelines-1.47.1.dev1.dist-info/RECORD

@@ -0,0 +1,54 @@
+gooddata_pipelines/__init__.py,sha256=H1W1_ZuQyoFiM305bALurYv2S3dKc_9I8sFCjcH9XLo,1826
+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=QFTwn5o7xMEvXAg85qqr9VhkpA1UDQElfUAUbvMYS8o,10881
+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
+gooddata_pipelines/backup_and_restore/__init__.py,sha256=-BG28PGDbalLyZGQjpFG0pjdIvtf25ut0r8ZwZVbi4s,32
+gooddata_pipelines/backup_and_restore/backup_input_processor.py,sha256=1-Sh0n4DrBrQ7M3Hzq_iiNe-2cxQx0KDu4QdDok618I,7667
+gooddata_pipelines/backup_and_restore/backup_manager.py,sha256=NS3dKc6C7VVfuFQxG0opQitcc23GwCntbLirAhWQei0,15441
+gooddata_pipelines/backup_and_restore/constants.py,sha256=AO4H6ngsLMs4bCV-RcT7xIi-VZu3smgZWA_3P7lVsQc,907
+gooddata_pipelines/backup_and_restore/csv_reader.py,sha256=0Kw7mJT7REj3Gjqfsc6YT9MbhcqfCGNB_SKBwzTI1rk,1268
+gooddata_pipelines/backup_and_restore/models/__init__.py,sha256=-BG28PGDbalLyZGQjpFG0pjdIvtf25ut0r8ZwZVbi4s,32
+gooddata_pipelines/backup_and_restore/models/input_type.py,sha256=CBKJigKdmZ-NJD9MSfNhq89bo86W0AqCMMoyonbd1QA,239
+gooddata_pipelines/backup_and_restore/models/storage.py,sha256=hIIj5CETEroaMTqezzj0ze0eMpPQrzoj5pyp_HBC-xk,1390
+gooddata_pipelines/backup_and_restore/models/workspace_response.py,sha256=eQbYLgRQc17IRG0yPTAJVrD-Xs05SzuwtzoNrPT2DoY,833
+gooddata_pipelines/backup_and_restore/storage/__init__.py,sha256=-BG28PGDbalLyZGQjpFG0pjdIvtf25ut0r8ZwZVbi4s,32
+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=STA0J-xaP7QQefyYK3OncqwcvWfrtJRRB--5PBfEKDU,2608
+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=ZVD-Jz_MyLDy7f1D62oJ58sHfW03_LNO7Bguuv4C4xA,5042
+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
+gooddata_pipelines/provisioning/entities/user_data_filters/user_data_filters.py,sha256=4Q3tbpTU4FPpCVE1t402mP3lJMrLFTDX4AgWG_pIIg0,8321
+gooddata_pipelines/provisioning/entities/user_data_filters/models/__init__.py,sha256=-BG28PGDbalLyZGQjpFG0pjdIvtf25ut0r8ZwZVbi4s,32
+gooddata_pipelines/provisioning/entities/user_data_filters/models/udf_models.py,sha256=y0q5E91AhxIkf_EHW0swCjNUkiiAOFXarAhvjUKVVKw,740
+gooddata_pipelines/provisioning/entities/users/__init__.py,sha256=-BG28PGDbalLyZGQjpFG0pjdIvtf25ut0r8ZwZVbi4s,32
+gooddata_pipelines/provisioning/entities/users/permissions.py,sha256=05RptbWJ5L9eZ12R7orG3-wF-w69IwlRzHitMzGokiY,5781
+gooddata_pipelines/provisioning/entities/users/user_groups.py,sha256=Up36pwwlOFS_IdYetViZ7gUHfV2hIgXL4th_k9D31Eo,8266
+gooddata_pipelines/provisioning/entities/users/users.py,sha256=1B1bMk8ysughCoCJs1aX0bI9iUIeAc1hIUyJ0hWyC5M,6503
+gooddata_pipelines/provisioning/entities/users/models/__init__.py,sha256=-BG28PGDbalLyZGQjpFG0pjdIvtf25ut0r8ZwZVbi4s,32
+gooddata_pipelines/provisioning/entities/users/models/permissions.py,sha256=Hx-8ac8n5xOyysJJCXu2XpOXL1IqH_w9LKck2qseWBs,8377
+gooddata_pipelines/provisioning/entities/users/models/user_groups.py,sha256=TjlP6oABK6UP7nMKNMlLk3M62eNf9e-3LdKI9-VFwi8,2007
+gooddata_pipelines/provisioning/entities/users/models/users.py,sha256=rKtiRxtelLphw-_BbD-AM_-hPrpp0xqEr1jmuU_oJVg,3767
+gooddata_pipelines/provisioning/entities/workspaces/__init__.py,sha256=-BG28PGDbalLyZGQjpFG0pjdIvtf25ut0r8ZwZVbi4s,32
+gooddata_pipelines/provisioning/entities/workspaces/models.py,sha256=4SR4XLd-qJ4pgpb-diHbm5yqZRmXQ_PgvF4iFfSV740,2155
+gooddata_pipelines/provisioning/entities/workspaces/workspace.py,sha256=qlBwzP9nWTucoB9tLMY35na1fIhifvnZoN5D-PJhudY,9770
+gooddata_pipelines/provisioning/entities/workspaces/workspace_data_filters.py,sha256=0dNcK7tkp40XulCj7EPoB4zVeyQbRx2Tt4yAfgLrm50,10736
+gooddata_pipelines/provisioning/entities/workspaces/workspace_data_parser.py,sha256=hjrLZQKdN8vSFjtX9VPiDYUO0RHj06bqzgNzEQqnfR8,4316
+gooddata_pipelines/provisioning/entities/workspaces/workspace_data_validator.py,sha256=t6RWNsrDpebyOgB4c_ctqrkio72jBHqsXqk-ntBTkA4,7225
+gooddata_pipelines/provisioning/utils/__init__.py,sha256=-BG28PGDbalLyZGQjpFG0pjdIvtf25ut0r8ZwZVbi4s,32
+gooddata_pipelines/provisioning/utils/context_objects.py,sha256=sM22hMsxE0XLI1TU0Vs-2kK0vf4YrB1musoAg__4bjc,936
+gooddata_pipelines/provisioning/utils/exceptions.py,sha256=1WnAOlPhqOf0xRcvn70lxAlLb8Oo6m6WCYS4hj9uzDU,3630
+gooddata_pipelines/provisioning/utils/utils.py,sha256=_Tk-mFgbIGpCixDCF9e-3ZYd-g5Jb3SJiLSH465k4jY,2846
+gooddata_pipelines-1.47.1.dev1.dist-info/METADATA,sha256=03kqiteoy2ls0dwnru9_wBg0CfdOBgewyO2w1U2fWQs,3773
+gooddata_pipelines-1.47.1.dev1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+gooddata_pipelines-1.47.1.dev1.dist-info/licenses/LICENSE.txt,sha256=PNC7WXGIo6OKkNoPLRxlVrw6jaLcjSTUsSxy9Xcu9Jo,560365
+gooddata_pipelines-1.47.1.dev1.dist-info/RECORD,,