anaplan-sdk 0.3.1b1__py3-none-any.whl → 0.4.0a2__py3-none-any.whl

anaplan_sdk/_async_clients/__init__.py

@@ -1,6 +1,13 @@
 from ._alm import _AsyncAlmClient
 from ._audit import _AsyncAuditClient
 from ._bulk import AsyncClient
+from ._cloud_works import _AsyncCloudWorksClient
 from ._transactional import _AsyncTransactionalClient
 
-__all__ = ["AsyncClient", "_AsyncAlmClient", "_AsyncAuditClient", "_AsyncTransactionalClient"]
+__all__ = [
+    "AsyncClient",
+    "_AsyncAlmClient",
+    "_AsyncAuditClient",
+    "_AsyncCloudWorksClient",
+    "_AsyncTransactionalClient",
+]

anaplan_sdk/_async_clients/_alm.py

@@ -1,35 +1,14 @@
-import warnings
-
 import httpx
 
 from anaplan_sdk._base import _AsyncBaseClient
-from anaplan_sdk.models import ModelRevision, Revision, SyncTask, User
-
-warnings.filterwarnings("always", category=DeprecationWarning)
+from anaplan_sdk.models import ModelRevision, Revision, SyncTask
 
 
 class _AsyncAlmClient(_AsyncBaseClient):
     def __init__(self, client: httpx.AsyncClient, model_id: str, retry_count: int) -> None:
-        self._client = client
         self._url = f"https://api.anaplan.com/2/0/models/{model_id}/alm"
         super().__init__(retry_count, client)
 
-    async def list_users(self) -> list[User]:
-        """
-        Lists all the Users in the authenticated users default tenant.
-        :return: The List of Users.
-        """
-        warnings.warn(
-            "`list_users()` on the ALM client is deprecated and will be removed in a "
-            "future version. Use `list_users()` on the Audit client instead.",
-            DeprecationWarning,
-            stacklevel=1,
-        )
-        return [
-            User.model_validate(e)
-            for e in (await self._get("https://api.anaplan.com/2/0/users")).get("users")
-        ]
-
     async def get_syncable_revisions(self, source_model_id: str) -> list[Revision]:
         """
         Use this call to return the list of revisions from your source model that can be

anaplan_sdk/_async_clients/_audit.py

@@ -10,21 +10,36 @@ Event = Literal["all", "byok", "user_activity"]
 
 class _AsyncAuditClient(_AsyncBaseClient):
     def __init__(self, client: httpx.AsyncClient, retry_count: int) -> None:
-        self._client = client
         self._limit = 10_000
         self._url = "https://audit.anaplan.com/audit/api/1/events"
         super().__init__(retry_count, client)
 
-    async def list_users(self) -> list[User]:
+    async def list_users(self, search_pattern: str | None = None) -> list[User]:
         """
         Lists all the Users in the authenticated users default tenant.
+        :param search_pattern: Optionally filter for specific users. When provided,
+               case-insensitive matches users with emails or names containing this string.
+               You can use the wildcards `%` for 0-n characters, and `_` for exactly 1 character.
+               When None (default), returns all users.
         :return: The List of Users.
         """
+        params = {"s": search_pattern} if search_pattern else None
         return [
             User.model_validate(e)
-            for e in await self._get_paginated("https://api.anaplan.com/2/0/users", "users")
+            for e in await self._get_paginated(
+                "https://api.anaplan.com/2/0/users", "users", params=params
+            )
         ]
 
+    async def get_user(self, user_id: str = "me") -> User:
+        """
+        Retrieves information about the specified user, or the authenticated user if none specified.
+        :return: The requested or currently authenticated User.
+        """
+        return User.model_validate(
+            (await self._get(f"https://api.anaplan.com/2/0/users/{user_id}")).get("user")
+        )
+
     async def get_events(self, days_into_past: int = 30, event_type: Event = "all") -> list:
         """
         Get audit events from Anaplan Audit API.

anaplan_sdk/_async_clients/_bulk.py

@@ -1,16 +1,12 @@
-"""
-Asynchronous Client.
-"""
-
 import logging
 from asyncio import gather, sleep
 from copy import copy
-from typing import AsyncIterator, Iterator
+from typing import AsyncIterator, Callable, Iterator
 
 import httpx
 from typing_extensions import Self
 
-from anaplan_sdk._auth import AnaplanBasicAuth, AnaplanCertAuth, get_certificate, get_private_key
+from anaplan_sdk._auth import create_auth
 from anaplan_sdk._base import _AsyncBaseClient, action_url
 from anaplan_sdk.exceptions import AnaplanActionError, InvalidIdentifierException
 from anaplan_sdk.models import (
@@ -27,6 +23,7 @@ from anaplan_sdk.models import (
 
 from ._alm import _AsyncAlmClient
 from ._audit import _AsyncAuditClient
+from ._cloud_works import _AsyncCloudWorksClient
 from ._transactional import _AsyncTransactionalClient
 
 logging.getLogger("httpx").setLevel(logging.CRITICAL)
@@ -54,7 +51,13 @@ class AsyncClient(_AsyncBaseClient):
         certificate: str | bytes | None = None,
         private_key: str | bytes | None = None,
         private_key_password: str | bytes | None = None,
-        timeout: float = 30,
+        client_id: str | None = None,
+        client_secret: str | None = None,
+        redirect_uri: str | None = None,
+        refresh_token: str | None = None,
+        oauth2_scope: str = "openid profile email offline_access",
+        on_token_refresh: Callable[[dict[str, str]], None] | None = None,
+        timeout: float | httpx.Timeout = 30,
         retry_count: int = 2,
         status_poll_delay: int = 1,
         upload_chunk_size: int = 25_000_000,
@@ -82,7 +85,19 @@ class AsyncClient(_AsyncBaseClient):
                             itself.
         :param private_key: The absolute path to the private key file or the private key itself.
         :param private_key_password: The password to access the private key if there is one.
-        :param timeout: The timeout in seconds for the HTTP requests.
+        :param client_id: The client Id of the Oauth2 Anaplan Client.
+        :param client_secret: The client secret for your Oauth2 Anaplan Client.
+        :param redirect_uri: The redirect URI for your Oauth2 Anaplan Client.
+        :param refresh_token: If you have a valid refresh token, you can pass it to skip the
+                              interactive authentication code step.
+        :param oauth2_scope: The scope of the Oauth2 token, if you want to narrow it.
+        :param on_token_refresh: A callback function that is called whenever the token is refreshed.
+                                 With this you can for example securely store the token in your
+                                 application or on your server for later reuse. The function
+                                 must accept a single argument, which is the token dictionary
+                                 returned by the Oauth2 token endpoint and does not return anything.
+        :param timeout: The timeout in seconds for the HTTP requests. Alternatively, you can pass
+                        an instance of `httpx.Timeout` to set the timeout for the HTTP requests.
         :param retry_count: The number of times to retry an HTTP request if it fails. Set this to 0
                             to never retry. Defaults to 2, meaning each HTTP Operation will be
                             tried a total number of 2 times.
@@ -96,34 +111,38 @@ class AsyncClient(_AsyncBaseClient):
                             manually assigned so there is typically no value in dynamically
                             creating new files and uploading content to them.
         """
-        if not ((user_email and password) or (certificate and private_key)):
-            raise ValueError(
-                "Must provide `certificate` and `private_key` or `user_email` and `password`."
-                "If you Private Key is Password protected, must also pass `private_key_password`."
-            )
-        self._client = httpx.AsyncClient(
+        _client = httpx.AsyncClient(
             auth=(
-                AnaplanCertAuth(
-                    get_certificate(certificate), get_private_key(private_key, private_key_password)
+                create_auth(
+                    user_email=user_email,
+                    password=password,
+                    certificate=certificate,
+                    private_key=private_key,
+                    private_key_password=private_key_password,
+                    client_id=client_id,
+                    client_secret=client_secret,
+                    redirect_uri=redirect_uri,
+                    refresh_token=refresh_token,
+                    oauth2_scope=oauth2_scope,
+                    on_token_refresh=on_token_refresh,
                 )
-                if certificate
-                else AnaplanBasicAuth(user_email=user_email, password=password)
             ),
             timeout=timeout,
         )
         self._retry_count = retry_count
         self._url = f"https://api.anaplan.com/2/0/workspaces/{workspace_id}/models/{model_id}"
         self._transactional_client = (
-            _AsyncTransactionalClient(self._client, model_id, retry_count) if model_id else None
+            _AsyncTransactionalClient(_client, model_id, retry_count) if model_id else None
         )
         self._alm_client = (
-            _AsyncAlmClient(self._client, model_id, self._retry_count) if model_id else None
+            _AsyncAlmClient(_client, model_id, self._retry_count) if model_id else None
         )
-        self.audit = _AsyncAuditClient(self._client, self._retry_count)
+        self._audit = _AsyncAuditClient(_client, self._retry_count)
+        self._cloud_works = _AsyncCloudWorksClient(_client, self._retry_count)
         self.status_poll_delay = status_poll_delay
         self.upload_chunk_size = upload_chunk_size
         self.allow_file_creation = allow_file_creation
-        super().__init__(retry_count, self._client)
+        super().__init__(retry_count, _client)
 
     @classmethod
     def from_existing(cls, existing: Self, workspace_id: str, model_id: str) -> Self:
@@ -145,6 +164,22 @@ class AsyncClient(_AsyncBaseClient):
         client._alm_client = _AsyncAlmClient(existing._client, model_id, existing._retry_count)
         return client
 
+    @property
+    def audit(self) -> _AsyncAuditClient:
+        """
+        The Audit Client provides access to the Anaplan Audit API.
+        For details, see https://vinzenzklass.github.io/anaplan-sdk/guides/audit/.
+        """
+        return self._audit
+
+    @property
+    def cw(self) -> _AsyncCloudWorksClient:
+        """
+        The Cloud Works Client provides access to the Anaplan Cloud Works API.
+        For details, see https://vinzenzklass.github.io/anaplan-sdk/guides/cloud_works/.
+        """
+        return self._cloud_works
+
     @property
     def transactional(self) -> _AsyncTransactionalClient:
         """
@@ -184,29 +219,41 @@ class AsyncClient(_AsyncBaseClient):
             )
         return self._alm_client
 
-    async def list_workspaces(self) -> list[Workspace]:
+    async def list_workspaces(self, search_pattern: str | None = None) -> list[Workspace]:
         """
         Lists all the Workspaces the authenticated user has access to.
+        :param search_pattern: Optionally filter for specific workspaces. When provided,
+               case-insensitive matches workspaces with names containing this string.
+               You can use the wildcards `%` for 0-n characters, and `_` for exactly 1 character.
+               When None (default), returns all users.
         :return: The List of Workspaces.
         """
+        params = {"tenantDetails": "true"}
+        if search_pattern:
+            params["s"] = search_pattern
         return [
             Workspace.model_validate(e)
             for e in await self._get_paginated(
-                "https://api.anaplan.com/2/0/workspaces",
-                "workspaces",
-                params={"tenantDetails": "true"},
+                "https://api.anaplan.com/2/0/workspaces", "workspaces", params=params
             )
         ]
 
-    async def list_models(self) -> list[Model]:
+    async def list_models(self, search_pattern: str | None = None) -> list[Model]:
         """
         Lists all the Models the authenticated user has access to.
+        :param search_pattern: Optionally filter for specific models. When provided,
+               case-insensitive matches models names containing this string.
+               You can use the wildcards `%` for 0-n characters, and `_` for exactly 1 character.
+               When None (default), returns all users.
         :return: The List of Models.
         """
+        params = {"modelDetails": "true"}
+        if search_pattern:
+            params["s"] = search_pattern
         return [
             Model.model_validate(e)
             for e in await self._get_paginated(
-                "https://api.anaplan.com/2/0/models", "models", params={"modelDetails": "true"}
+                "https://api.anaplan.com/2/0/models", "models", params=params
             )
         ]
 

anaplan_sdk/_async_clients/_cloud_works.py

@@ -0,0 +1,344 @@
+from typing import Any, Literal
+
+import httpx
+
+from anaplan_sdk._base import (
+    _AsyncBaseClient,
+    connection_body_payload,
+    construct_payload,
+    integration_payload,
+    schedule_payload,
+)
+from anaplan_sdk.models.cloud_works import (
+    Connection,
+    ConnectionBody,
+    ConnectionInput,
+    Integration,
+    IntegrationInput,
+    IntegrationProcessInput,
+    NotificationConfig,
+    NotificationInput,
+    RunError,
+    RunStatus,
+    RunSummary,
+    ScheduleInput,
+    SingleIntegration,
+)
+
+from ._cw_flow import _AsyncFlowClient
+
+
+class _AsyncCloudWorksClient(_AsyncBaseClient):
+    def __init__(self, client: httpx.AsyncClient, retry_count: int) -> None:
+        self._url = "https://api.cloudworks.anaplan.com/2/0/integrations"
+        self._flow = _AsyncFlowClient(client, retry_count)
+        super().__init__(retry_count, client)
+
+    @property
+    def flows(self) -> _AsyncFlowClient:
+        """
+        Access the Integration Flow APIs.
+        """
+        return self._flow
+
+    async def list_connections(self) -> list[Connection]:
+        """
+        List all Connections available in CloudWorks.
+        :return: A list of connections.
+        """
+        return [
+            Connection.model_validate(e)
+            for e in await self._get_paginated(f"{self._url}/connections", "connections")
+        ]
+
+    async def create_connection(self, con_info: ConnectionInput | dict[str, Any]) -> str:
+        """
+        Create a new connection in CloudWorks.
+        :param con_info: The connection information. This can be a ConnectionInput instance or a
+               dictionary as per the documentation. If a dictionary is passed, it will be validated
+               against the ConnectionInput model before sending the request.
+        :return: The ID of the new connection.
+        """
+        res = await self._post(
+            f"{self._url}/connections", json=construct_payload(ConnectionInput, con_info)
+        )
+        return res["connections"]["connectionId"]
+
+    async def update_connection(
+        self, con_id: str, con_info: ConnectionBody | dict[str, Any]
+    ) -> None:
+        """
+        Update an existing connection in CloudWorks.
+        :param con_id: The ID of the connection to update.
+        :param con_info: The name and details of the connection. You must pass all the same details
+               as when initially creating the connection again. If you want to update only some of
+               the details, use the `patch_connection` method instead.
+        """
+        await self._put(f"{self._url}/connections/{con_id}", json=connection_body_payload(con_info))
+
+    async def patch_connection(self, con_id: str, body: dict[str, Any]) -> None:
+        """
+        Update an existing connection in CloudWorks.
+        :param con_id: The ID of the connection to update.
+        :param body: The name and details of the connection. You can pass all the same details as
+               when initially creating the connection again, or just any one of them.
+        """
+        await self._patch(f"{self._url}/connections/{con_id}", json=body)
+
+    async def delete_connection(self, con_id: str) -> None:
+        """
+        Delete an existing connection in CloudWorks.
+        :param con_id: The ID of the connection to delete.
+        """
+        await self._delete(f"{self._url}/connections/{con_id}")
+
+    async def list_integrations(
+        self, sort_by_name: Literal["ascending", "descending"] = "ascending"
+    ) -> list[Integration]:
+        """
+        List all integrations in CloudWorks.
+        :param sort_by_name: Sort the integrations by name in ascending or descending order.
+        :return: A list of integrations.
+        """
+        params = {"sortBy": "name" if sort_by_name == "ascending" else "-name"}
+        return [
+            Integration.model_validate(e)
+            for e in await self._get_paginated(f"{self._url}", "integrations", params=params)
+        ]
+
+    async def get_integration(self, integration_id: str) -> SingleIntegration:
+        """
+        Get the details of a specific integration in CloudWorks.
+
+        **Note: This will not include the integration type! While present when listing integrations,
+        the integration type is not included in the details of a single integration.**
+        :param integration_id: The ID of the integration to retrieve.
+        :return: The details of the integration, without the integration type.
+        """
+        return SingleIntegration.model_validate(
+            (await self._get(f"{self._url}/{integration_id}"))["integration"]
+        )
+
+    async def create_integration(
+        self, body: IntegrationInput | IntegrationProcessInput | dict[str, Any]
+    ) -> str:
+        """
+        Create a new integration in CloudWorks. If not specified, the integration type will be
+        either "Import" or "Export" based on the source and target you provide.
+
+        If you want to instead create a process Integration, you can do so by specifying
+        the `process_id` parameter and passing several jobs. **Be careful to ensure, that all ids
+        specified in the job inputs match what is defined in your model and matches the process.**
+        If this is not the case, this will error, occasionally with a misleading error message,
+        i.e. `XYZ is not defined in your model` even though it is, Anaplan just does not know what
+        to do with it in the location you specified.
+
+        You can also use CloudWorks Integrations to simply schedule a process. To do this, you
+        can simply pass an IntegrationProcessInput instance with the process_id and no jobs. This
+        will create a process integration that will run the process you specified.
+        :param body: The integration information. This can be an
+               IntegrationInput | IntegrationProcessInput instance or a dictionary as per the
+               documentation. If a dictionary is passed, it will be validated against the
+               IntegrationInput model before sending the request.
+        :return: The ID of the new integration.
+        """
+        json = integration_payload(body)
+        return (await self._post(f"{self._url}", json=json))["integration"]["integrationId"]
+
+    async def update_integration(
+        self, integration_id: str, body: IntegrationInput | IntegrationProcessInput | dict[str, Any]
+    ) -> None:
+        """
+        Update an existing integration in CloudWorks.
+        :param integration_id: The ID of the integration to update.
+        :param body: The name and details of the integration. You must pass all the same details
+               as when initially creating the integration again. If you want to update only some
+               of the details, use the `patch_integration` method instead.
+        """
+        json = integration_payload(body)
+        await self._put(f"{self._url}/{integration_id}", json=json)
+
+    async def run_integration(self, integration_id: str) -> str:
+        """
+        Run an integration in CloudWorks.
+        :param integration_id: The ID of the integration to run.
+        :return: The ID of the run instance.
+        """
+        return (await self._post_empty(f"{self._url}/{integration_id}/run"))["run"]["id"]
+
+    async def delete_integration(self, integration_id: str) -> None:
+        """
+        Delete an existing integration in CloudWorks.
+        :param integration_id: The ID of the integration to delete.
+        """
+        await self._delete(f"{self._url}/{integration_id}")
+
+    async def get_run_history(self, integration_id: str) -> list[RunSummary]:
+        """
+        Get the run history of a specific integration in CloudWorks.
+        :param integration_id: The ID of the integration to retrieve the run history for.
+        :return: A list of run statuses.
+        """
+        return [
+            RunSummary.model_validate(e)
+            for e in (await self._get(f"{self._url}/runs/{integration_id}"))["history_of_runs"].get(
+                "runs", []
+            )
+        ]
+
+    async def get_run_status(self, run_id: str) -> RunStatus:
+        """
+        Get the status of a specific run in CloudWorks.
+        :param run_id: The ID of the run to retrieve.
+        :return: The details of the run.
+        """
+        return RunStatus.model_validate((await self._get(f"{self._url}/run/{run_id}"))["run"])
+
+    async def get_run_error(self, run_id: str) -> RunError | None:
+        """
+        Get the error details of a specific run in CloudWorks. This exposes potential underlying
+        errors like the error of the invoked action, failure dumps and other details.
+        :param run_id: The ID of the run to retrieve.
+        :return: The details of the run error.
+        """
+        run = await self._get(f"{self._url}/runerror/{run_id}")
+        return RunError.model_validate(run["runs"]) if run.get("runs") else None
+
+    async def create_schedule(
+        self, integration_id: str, schedule: ScheduleInput | dict[str, Any]
+    ) -> None:
+        """
+        Schedule an integration in CloudWorks.
+        :param integration_id: The ID of the integration to schedule.
+        :param schedule: The schedule information. This can be a ScheduleInput instance or a
+               dictionary as per the documentation. If a dictionary is passed, it will be validated
+               against the ScheduleInput model before sending the request.
+        """
+        await self._post(
+            f"{self._url}/{integration_id}/schedule",
+            json=schedule_payload(integration_id, schedule),
+        )
+
+    async def update_schedule(
+        self, integration_id: str, schedule: ScheduleInput | dict[str, Any]
+    ) -> None:
+        """
+        Update an integration Schedule in CloudWorks. A schedule must already exist.
+        :param integration_id: The ID of the integration to schedule.
+        :param schedule: The schedule information. This can be a ScheduleInput instance or a
+               dictionary as per the documentation. If a dictionary is passed, it will be validated
+               against the ScheduleInput model before sending the request.
+        """
+        await self._put(
+            f"{self._url}/{integration_id}/schedule",
+            json=schedule_payload(integration_id, schedule),
+        )
+
+    async def set_schedule_status(
+        self, integration_id: str, status: Literal["enabled", "disabled"]
+    ) -> None:
+        """
+        Set the status of an integration schedule in CloudWorks. A schedule must already exist.
+        :param integration_id: The ID of the integration to schedule.
+        :param status: The status of the schedule. This can be either "enabled" or "disabled".
+        """
+        await self._post_empty(f"{self._url}/{integration_id}/schedule/status/{status}")
+
+    async def delete_schedule(self, integration_id: str) -> None:
+        """
+        Delete an integration schedule in CloudWorks. A schedule must already exist.
+        :param integration_id: The ID of the integration to schedule.
+        """
+        await self._delete(f"{self._url}/{integration_id}/schedule")
+
+    async def get_notification_config(
+        self, notification_id: str | None = None, integration_id: str | None = None
+    ) -> NotificationConfig:
+        """
+        Get the notification configuration, either by its Id, or the notification configuration
+        for a specific integration. If the integration_id is specified, the notification_id
+        will be ignored.
+        :param notification_id: The ID of the notification configuration to retrieve.
+        :param integration_id: The ID of the integration to retrieve the notification
+               configuration for.
+        :return: The details of the notification configuration.
+        """
+        if not (notification_id or integration_id):
+            raise ValueError("Either notification_id or integration_id must be specified.")
+        if integration_id:
+            notification_id = (await self.get_integration(integration_id)).notification_id
+        return NotificationConfig.model_validate(
+            (await self._get(f"{self._url}/notification/{notification_id}"))["notifications"]
+        )
+
+    async def create_notification_config(self, config: NotificationInput | dict[str, Any]) -> str:
+        """
+        Create a notification configuration for an integration in CloudWorks. This will error if
+        there is already a notification configuration for the integration, which is also the case
+        by default. In this case, you will want to use the `update_notification_config` method
+        instead, to partially update the existing configuration or overwrite it.
+        :param config: The notification configuration. This can be a NotificationInput instance or
+               a dictionary as per the documentation. If a dictionary is passed, it will be
+               validated against the NotificationConfig model before sending the request.
+        :return: The ID of the new notification configuration.
+        """
+        res = await self._post(
+            f"{self._url}/notification", json=construct_payload(NotificationInput, config)
+        )
+        return res["notification"]["notificationId"]
+
+    async def update_notification_config(
+        self, notification_id: str, config: NotificationInput | dict[str, Any]
+    ) -> None:
+        """
+        Update a notification configuration for an integration in CloudWorks. You cannot pass empty
+        values or nulls to any of the fields If you want to for e.g. override  an existing list of
+        users with an empty one, you must delete the notification configuration and create a new
+        one with only the values you want to keep.
+        :param notification_id: The ID of the notification configuration to update.
+        :param config: The notification configuration. This can be a NotificationInput instance or
+               a dictionary as per the documentation. If a dictionary is passed, it will be
+               validated against the NotificationConfig model before sending the request.
+        """
+        await self._put(
+            f"{self._url}/notification/{notification_id}",
+            json=construct_payload(NotificationInput, config),
+        )
+
+    async def delete_notification_config(
+        self, notification_id: str | None = None, integration_id: str | None = None
+    ) -> None:
+        """
+        Delete a notification configuration for an integration in CloudWorks, either by its Id, or
+        the notification configuration for a specific integration. If the integration_id is
+        specified, the notification_id will be ignored.
+        :param notification_id: The ID of the notification configuration to delete.
+        :param integration_id: The ID of the integration to delete the notification config of.
+        """
+        if not (notification_id or integration_id):
+            raise ValueError("Either notification_id or integration_id must be specified.")
+        if integration_id:
+            notification_id = (await self.get_integration(integration_id)).notification_id
+        await self._delete(f"{self._url}/notification/{notification_id}")
+
+    async def get_import_error_dump(self, run_id: str) -> bytes:
+        """
+        Get the error dump of a specific import run in CloudWorks. Calling this for a run_id that
+        did not generate any failure dumps will produce an error.
+
+        **Note that if you need the error dump of an action in a process, you must use the
+        `get_process_error_dump` method instead.**
+        :param run_id: The ID of the run to retrieve.
+        :return: The error dump.
+        """
+        return await self._get_binary(f"{self._url}/run/{run_id}/dump")
+
+    async def get_process_error_dump(self, run_id: str, action_id: int | str) -> bytes:
+        """
+        Get the error dump of a specific import run in CloudWorks, that is part of a process.
+        Calling this for a run_id that did not generate any failure dumps will produce an error.
+        :param run_id: The ID of the run to retrieve.
+        :param action_id: The ID of the action to retrieve. This can be found in the RunError.
+        :return: The error dump.
+        """
+        return await self._get_binary(f"{self._url}/run/{run_id}/process/import/{action_id}/dumps")