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

gooddata_pipelines/__init__.py

@@ -0,0 +1,59 @@
+# (C) 2025 GoodData Corporation
+
+from ._version import __version__
+
+# -------- Backup and Restore --------
+from .backup_and_restore.backup_manager import BackupManager
+from .backup_and_restore.models.storage import (
+    BackupRestoreConfig,
+    StorageType,
+)
+from .backup_and_restore.storage.local_storage import LocalStorage
+from .backup_and_restore.storage.s3_storage import S3Storage
+
+# -------- Provisioning --------
+from .provisioning.entities.user_data_filters.models.udf_models import (
+    UserDataFilterFullLoad,
+)
+from .provisioning.entities.user_data_filters.user_data_filters import (
+    UserDataFilterProvisioner,
+)
+from .provisioning.entities.users.models.permissions import (
+    PermissionFullLoad,
+    PermissionIncrementalLoad,
+)
+from .provisioning.entities.users.models.user_groups import (
+    UserGroupFullLoad,
+    UserGroupIncrementalLoad,
+)
+from .provisioning.entities.users.models.users import (
+    UserFullLoad,
+    UserIncrementalLoad,
+)
+from .provisioning.entities.users.permissions import PermissionProvisioner
+from .provisioning.entities.users.user_groups import UserGroupProvisioner
+from .provisioning.entities.users.users import UserProvisioner
+from .provisioning.entities.workspaces.models import WorkspaceFullLoad
+from .provisioning.entities.workspaces.workspace import WorkspaceProvisioner
+
+__all__ = [
+    "BackupManager",
+    "BackupRestoreConfig",
+    "StorageType",
+    "LocalStorage",
+    "S3Storage",
+    "WorkspaceFullLoad",
+    "WorkspaceProvisioner",
+    "UserIncrementalLoad",
+    "UserGroupIncrementalLoad",
+    "PermissionFullLoad",
+    "PermissionIncrementalLoad",
+    "UserFullLoad",
+    "UserGroupFullLoad",
+    "UserProvisioner",
+    "UserGroupProvisioner",
+    "PermissionProvisioner",
+    "UserDataFilterProvisioner",
+    "UserDataFilterFullLoad",
+    "__version__",
+]

gooddata_pipelines/_version.py

@@ -0,0 +1,7 @@
+# (C) 2025 GoodData Corporation
+from importlib import metadata
+
+try:
+    __version__ = metadata.version("gooddata-pipelines")
+except metadata.PackageNotFoundError:
+    __version__ = "unknown-version"

gooddata_pipelines/api/__init__.py

@@ -0,0 +1,5 @@
+# (C) 2025 GoodData Corporation
+
+from .gooddata_api_wrapper import GoodDataApi
+
+__all__ = ["GoodDataApi"]

gooddata_pipelines/api/exceptions.py

@@ -0,0 +1,41 @@
+# (C) 2025 GoodData Corporation
+
+"""Exception class for Panther operations.
+
+This module defines the internally used `PantherException` class, which is used
+to handle exceptions that occur during operations related to the Panther SDK or
+GoodData Cloud API.
+"""
+
+
+class GoodDataApiException(Exception):
+    """Exception raised during Panther operations.
+
+    This exception is used to indicate errors that occur during operations
+    related to interactions with the GoodData Python SDK or GoodData Cloud API.
+    It can include additional context provided through keyword arguments.
+    """
+
+    def __init__(self, message: str, **kwargs: str) -> None:
+        """Raise a PantherException with a message and optional context.
+
+        Args:
+            message (str): The error message describing the exception.
+            **kwargs: Additional context for the exception, such as HTTP status,
+                    API endpoint, and HTTP method or any other relevant information.
+        """
+
+        super().__init__(message)
+        self.error_message: str = message
+
+        # Set default values for attributes.
+        # TODO: Consider if the defaults for these are still needed
+        # - the values were necessary for log schema implementations, which
+        #   are not used anymore.
+        self.http_status: str = "500 Internal Server Error"
+        self.api_endpoint: str = "NA"
+        self.http_method: str = "NA"
+
+        # Set attributes from kwargs.
+        for key, value in kwargs.items():
+            setattr(self, key, value)

gooddata_pipelines/api/gooddata_api.py

@@ -0,0 +1,309 @@
+# (C) 2025 GoodData Corporation
+
+"""Interaction with GoodData Cloud via the direct API calls."""
+
+import json
+from typing import Any
+
+import requests
+
+# TODO: Limit the use of "typing.Any". Improve readability by using either models
+#  or typed dicts.
+
+TIMEOUT = 60
+REQUEST_PAGE_SIZE = 250
+API_VERSION = "v1"
+
+
+class ApiMethods:
+    headers: dict[str, str]
+    base_url: str
+
+    @staticmethod
+    def _get_base_url(domain: str) -> str:
+        """Returns the root endpoint for the GoodData Cloud API.
+
+        Method ensures that the URL starts with "https://" and does not
+        end with a trailing slash.
+
+        Args:
+            domain (str): The domain of the GoodData Cloud instance.
+        Returns:
+            str: The base URL for the GoodData Cloud API.
+        """
+        # Remove trailing slash if present.
+        if domain[-1] == "/":
+            domain = domain[:-1]
+
+        if not domain.startswith("https://") and not domain.startswith(
+            "http://"
+        ):
+            domain = f"https://{domain}"
+
+        if domain.startswith("http://") and not domain.startswith("https://"):
+            domain = domain.replace("http://", "https://")
+
+        return f"{domain}/api/{API_VERSION}"
+
+    def _get_url(self, endpoint: str) -> str:
+        """Returns the full URL for a given API endpoint.
+
+        Args:
+            endpoint (str): The API endpoint to be appended to the base URL.
+        Returns:
+            str: The full URL for the API endpoint.
+        """
+        return f"{self.base_url}{endpoint}"
+
+    def get_custom_application_setting(
+        self, workspace_id: str, setting_id: str
+    ) -> requests.Response:
+        """Gets a custom application setting.
+
+        Args:
+            workspace_id (str): The ID of the workspace.
+            setting_id (str): The ID of the custom application setting.
+        Returns:
+            requests.Response: The response from the server containing the
+                custom application setting.
+        """
+        url = f"/entities/workspaces/{workspace_id}/customApplicationSettings/{setting_id}"
+        return self._get(url)
+
+    def put_custom_application_setting(
+        self, workspace_id: str, setting_id: str, data: dict[str, Any]
+    ) -> requests.Response:
+        url = f"/entities/workspaces/{workspace_id}/customApplicationSettings/{setting_id}"
+        return self._put(url, data, self.headers)
+
+    def post_custom_application_setting(
+        self, workspace_id: str, data: dict[str, Any]
+    ) -> requests.Response:
+        """Creates a custom application setting for a given workspace.
+
+        Args:
+            workspace_id (str): The ID of the workspace.
+            data (dict[str, Any]): The data for the custom application setting.
+        Returns:
+            requests.Response: The response from the server containing the
+                created custom application setting.
+        """
+        url = f"/entities/workspaces/{workspace_id}/customApplicationSettings/"
+        return self._post(url, data, self.headers)
+
+    def get_all_workspace_data_filters(
+        self, workspace_id: str
+    ) -> requests.Response:
+        """Gets all workspace data filters for a given workspace.
+
+        Args:
+            workspace_id (str): The ID of the workspace.
+        Returns:
+            requests.Response: The response from the server containing all
+                workspace data filters.
+        """
+        url = f"/entities/workspaces/{workspace_id}/workspaceDataFilters"
+        return self._get(url)
+
+    def get_workspace_data_filter_settings(
+        self, workspace_id: str
+    ) -> requests.Response:
+        """Gets all workspace data filter settings for a given workspace.
+
+        Args:
+            workspace_id (str): The ID of the workspace.
+        Returns:
+            requests.Response: The response from the server containing all
+                workspace data filter settings.
+        """
+        url = f"/entities/workspaces/{workspace_id}/workspaceDataFilterSettings?include=workspaceDataFilters"
+        return self._get(url)
+
+    def get_workspace_data_filter_setting(
+        self, workspace_id: str, wdf_id: str
+    ) -> requests.Response:
+        """Gets a specific workspace data filter setting.
+
+        Args:
+            workspace_id (str): The ID of the workspace.
+            wdf_id (str): The ID of the workspace data filter setting.
+        Returns:
+            requests.Response: The response from the server containing the
+                workspace data filter setting.
+        """
+        url = f"/entities/workspaces/{workspace_id}/workspaceDataFilterSettings/{wdf_id}"
+        return self._get(url)
+
+    def put_workspace_data_filter_setting(
+        self,
+        workspace_id: str,
+        wdf_setting: dict[str, Any],
+    ) -> requests.Response:
+        """Updates a workspace data filter setting.
+
+        Args:
+            workspace_id (str): The ID of the workspace.
+            wdf_setting (dict[str, Any]): The workspace data filter setting to
+                update.
+        Returns:
+            requests.Response: The response from the server containing the
+                updated workspace data filter setting.
+        """
+        wdf_setting_id = wdf_setting["data"]["id"]
+        endpoint = f"/entities/workspaces/{workspace_id}/workspaceDataFilterSettings/{wdf_setting_id}"
+        return self._put(
+            endpoint,
+            wdf_setting,
+            self.headers,
+        )
+
+    def post_workspace_data_filter_setting(
+        self,
+        workspace_id: str,
+        wdf_setting: dict[str, Any],
+    ) -> requests.Response:
+        """Creates a workspace data filter setting for a given workspace.
+
+        Args:
+            workspace_id (str): The ID of the workspace.
+            wdf_setting (dict[str, Any]): The workspace data filter setting to
+                create.
+        Returns:
+            requests.Response: The response from the server containing the
+                created workspace data filter setting.
+        """
+        endpoint = (
+            f"/entities/workspaces/{workspace_id}/workspaceDataFilterSettings/"
+        )
+        return self._post(
+            endpoint,
+            wdf_setting,
+            self.headers,
+        )
+
+    def delete_workspace_data_filter_setting(
+        self,
+        workspace_id: str,
+        wdf_setting_id: str,
+    ) -> requests.Response:
+        """Deletes a workspace data filter setting.
+
+        Args:
+            workspace_id (str): The ID of the workspace.
+            wdf_setting_id (str): The ID of the workspace data filter setting
+                to delete.
+        Returns:
+            requests.Response: The response from the server confirming the
+                deletion of the workspace data filter setting.
+        """
+        endpoint = f"/entities/workspaces/{workspace_id}/workspaceDataFilterSettings/{wdf_setting_id}"
+        return self._delete(
+            endpoint,
+        )
+
+    def post_workspace_data_filter(
+        self, workspace_id: str, data: dict[str, Any]
+    ) -> requests.Response:
+        """Creates a workspace data filter for a given workspace.
+
+        Args:
+            workspace_id (str): The ID of the workspace.
+            data (dict[str, Any]): The data for the workspace data filter.
+        Returns:
+            requests.Response: The response from the server containing the
+                created workspace data filter.
+        """
+        endpoint = f"/entities/workspaces/{workspace_id}/workspaceDataFilters"
+        return self._post(endpoint, data, self.headers)
+
+    def get_user_data_filters(self, workspace_id: str) -> requests.Response:
+        """Gets the user data filters for a given workspace."""
+        endpoint = f"/layout/workspaces/{workspace_id}/userDataFilters"
+        return self._get(endpoint)
+
+    def get_automations(self, workspace_id: str) -> requests.Response:
+        """Gets the automations for a given workspace."""
+        endpoint = (
+            f"/entities/workspaces/{workspace_id}/automations?include=ALL"
+        )
+        return self._get(endpoint)
+
+    def _get(
+        self, endpoint: str, headers: dict[str, str] | None = None
+    ) -> requests.Response:
+        """Sends a GET request to the server.
+
+        Args:
+            endpoint (str): The API endpoint to send the GET request to.
+            headers (dict[str, str] | None): Headers to include in the request.
+                If no headers are provided, the default headers will be used.
+        Returns:
+            requests.Response: The response from the server.
+        """
+        url = self._get_url(endpoint)
+        request_headers = headers if headers else self.headers
+
+        return requests.get(url, headers=request_headers, timeout=TIMEOUT)
+
+    def _post(
+        self,
+        endpoint: str,
+        data: Any,
+        headers: dict | None = None,
+    ) -> requests.Response:
+        """Sends a POST request to the server with a given JSON object.
+
+        Args:
+            endpoint (str): The API endpoint to send the POST request to.
+            data (Any): The JSON data to send in the request body.
+            headers (dict | None): Headers to include in the request.
+                If no headers are provided, the default headers will be used.
+        Returns:
+            requests.Response: The response from the server.
+        """
+        url = self._get_url(endpoint)
+        request_headers = headers if headers else self.headers
+        data_json = json.dumps(data)
+
+        return requests.post(
+            url, data=data_json, headers=request_headers, timeout=TIMEOUT
+        )
+
+    def _put(
+        self,
+        endpoint: str,
+        data: Any,
+        headers: dict | None = None,
+    ) -> requests.Response:
+        """Sends a PUT request to the server with a given JSON object.
+
+        Args:
+            endpoint (str): The API endpoint to send the PUT request to.
+            data (Any): The JSON data to send in the request body.
+            headers (dict | None): Headers to include in the request.
+                If no headers are provided, the default headers will be used.
+        Returns:
+            requests.Response: The response from the server.
+        """
+        url = self._get_url(endpoint)
+        request_headers = headers if headers else self.headers
+        data_json = json.dumps(data)
+
+        return requests.put(
+            url, data=data_json, headers=request_headers, timeout=TIMEOUT
+        )
+
+    def _delete(
+        self,
+        endpoint: str,
+    ) -> requests.Response:
+        """Sends a DELETE request to the server.
+
+        Args:
+            endpoint (str): The API endpoint to send the DELETE request to.
+        Returns:
+            requests.Response: The response from the server.
+        """
+        url = self._get_url(endpoint)
+
+        return requests.delete(url, headers=self.headers, timeout=TIMEOUT)

gooddata_pipelines/api/gooddata_api_wrapper.py

@@ -0,0 +1,36 @@
+# (C) 2025 GoodData Corporation
+
+"""Wrapper for interaction with GoodData Cloud."""
+
+from gooddata_sdk.sdk import GoodDataSdk
+
+from gooddata_pipelines.api.gooddata_api import ApiMethods
+from gooddata_pipelines.api.gooddata_sdk import SdkMethods
+
+
+class GoodDataApi(SdkMethods, ApiMethods):
+    """Wrapper class for the GoodData Cloud API.
+
+    This class combines interactions with the GoodData Python SDK and direct API
+    calls.
+    """
+
+    def __init__(self, host: str, token: str) -> None:
+        """Initialize the GoodDataApi with host and token.
+
+        Args:
+            host (str): The GoodData Cloud host URL.
+            token (str): The authentication token for the GoodData Cloud API.
+        """
+        self._domain: str = host
+        self._token: str = token
+
+        # Initialize the GoodData SDK
+        self._sdk = GoodDataSdk.create(self._domain, self._token)
+
+        # Set up utils for direct API interaction
+        self.base_url = self._get_base_url(self._domain)
+        self.headers: dict = {
+            "Authorization": f"Bearer {self._token}",
+            "Content-Type": "application/vnd.gooddata.api+json",
+        }