anaplan-sdk 0.3.1b1__tar.gz → 0.4.0a1__tar.gz

anaplan_sdk-0.4.0a1/.github/workflows/lint.yml

@@ -0,0 +1,9 @@
+name: Ruff
+on: [ push, pull_request ]
+jobs:
+  ruff:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/ruff-action@v3
+      - run: ruff format --check

{anaplan_sdk-0.3.1b1 → anaplan_sdk-0.4.0a1}/.github/workflows/tests.yml

@@ -13,6 +13,8 @@ jobs:
       ANAPLAN_SDK_TEST_MODEL_ID: ${{secrets.ANAPLAN_SDK_TEST_MODEL_ID}}
       ANAPLAN_SDK_TEST_CERT: ${{secrets.ANAPLAN_SDK_TEST_CERT}}
       ANAPLAN_SDK_TEST_PK: ${{secrets.ANAPLAN_SDK_TEST_PK}}
+      AZ_STORAGE_ACCOUNT: ${{secrets.AZ_STORAGE_ACCOUNT}}
+      AZ_STORAGE_SAS_TOKEN: ${{secrets.AZ_STORAGE_SAS_TOKEN}}
 
     name: "Python ${{ matrix.python-version }}"
     runs-on: "ubuntu-latest"
@@ -32,4 +34,4 @@ jobs:
           pip install uv
           uv sync
       - name: "Run tests"
-        run: "uv run python -m pytest -n 8 --dist loadfile tests/"
+        run: "uv run python -m pytest -n 12 --dist loadfile tests/"

{anaplan_sdk-0.3.1b1 → anaplan_sdk-0.4.0a1}/.pre-commit-config.yaml

@@ -1,10 +1,10 @@
 repos:
   - repo: https://github.com/astral-sh/uv-pre-commit
-    rev: 0.5.29
+    rev: 0.7.3
     hooks:
       - id: uv-lock
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.9.6
+    rev: v0.11.9
     hooks:
       - id: ruff
         args: [ --fix ]

{anaplan_sdk-0.3.1b1 → anaplan_sdk-0.4.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anaplan-sdk
-Version: 0.3.1b1
+Version: 0.4.0a1
 Summary: Provides pythonic access to the Anaplan API
 Project-URL: Homepage, https://vinzenzklass.github.io/anaplan-sdk/
 Project-URL: Repository, https://github.com/VinzenzKlass/anaplan-sdk
@@ -10,9 +10,12 @@ License-Expression: Apache-2.0
 License-File: LICENSE
 Keywords: anaplan,anaplan alm api,anaplan api,anaplan audit api,anaplan bulk api,anaplan integration
 Requires-Python: >=3.10.4
-Requires-Dist: cryptography<45.0.0,>=42.0.7
 Requires-Dist: httpx<1.0.0,>=0.27.0
 Requires-Dist: pydantic<3.0.0,>=2.7.2
+Provides-Extra: cert
+Requires-Dist: cryptography<45.0.0,>=42.0.7; extra == 'cert'
+Provides-Extra: oauth
+Requires-Dist: oauthlib<4.0.0,>=3.0.0; extra == 'oauth'
 Description-Content-Type: text/markdown
 
 <p align="center" style="margin: 0 0 10px">
@@ -44,6 +47,9 @@ providing both synchronous and asynchronous Clients.
 
 Visit [Anaplan SDK](https://vinzenzklass.github.io/anaplan-sdk/) for documentation.
 
+If you find any issues or feel that this SDK is not adequately covering your use case,
+please [open an issue](https://github.com/VinzenzKlass/anaplan-sdk/issues/new).
+
 ---
 
 ### Install Anaplan SDK using pip
@@ -107,3 +113,28 @@ for model in models:
 
 For more information, API reference and detailed guides,
 visit [Anaplan SDK](https://vinzenzklass.github.io/anaplan-sdk/).
+
+### Contributing
+
+Pull Requests are welcome. For major changes, please open an issue first to discuss what you would like to change. To
+submit a pull request, please follow the
+standard [Fork & Pull Request workflow](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request-from-a-fork).
+
+Before submitting your pull request, please ensure that all the files pass linting and formatting checks. You can do
+this by running the following command:
+
+```shell
+uv sync --dev
+
+ruff check
+ruff format
+```
+
+You can also enable [pre-commit](https://pre-commit.com/) hooks to automatically format and lint your code before
+committing:
+
+```shell
+pre-commit install
+```
+
+If your PR goes beyond a simple bug fix or small changes, please add tests to cover your changes.

{anaplan_sdk-0.3.1b1 → anaplan_sdk-0.4.0a1}/README.md

@@ -27,6 +27,9 @@ providing both synchronous and asynchronous Clients.
 
 Visit [Anaplan SDK](https://vinzenzklass.github.io/anaplan-sdk/) for documentation.
 
+If you find any issues or feel that this SDK is not adequately covering your use case,
+please [open an issue](https://github.com/VinzenzKlass/anaplan-sdk/issues/new).
+
 ---
 
 ### Install Anaplan SDK using pip
@@ -90,3 +93,28 @@ for model in models:
 
 For more information, API reference and detailed guides,
 visit [Anaplan SDK](https://vinzenzklass.github.io/anaplan-sdk/).
+
+### Contributing
+
+Pull Requests are welcome. For major changes, please open an issue first to discuss what you would like to change. To
+submit a pull request, please follow the
+standard [Fork & Pull Request workflow](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request-from-a-fork).
+
+Before submitting your pull request, please ensure that all the files pass linting and formatting checks. You can do
+this by running the following command:
+
+```shell
+uv sync --dev
+
+ruff check
+ruff format
+```
+
+You can also enable [pre-commit](https://pre-commit.com/) hooks to automatically format and lint your code before
+committing:
+
+```shell
+pre-commit install
+```
+
+If your PR goes beyond a simple bug fix or small changes, please add tests to cover your changes.

anaplan_sdk-0.4.0a1/anaplan_sdk/_async_clients/__init__.py

@@ -0,0 +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",
+    "_AsyncCloudWorksClient",
+    "_AsyncTransactionalClient",
+]

{anaplan_sdk-0.3.1b1 → anaplan_sdk-0.4.0a1}/anaplan_sdk/_async_clients/_alm.py

@@ -10,7 +10,6 @@ warnings.filterwarnings("always", category=DeprecationWarning)
 
 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)
 

{anaplan_sdk-0.3.1b1 → anaplan_sdk-0.4.0a1}/anaplan_sdk/_async_clients/_audit.py

@@ -10,7 +10,6 @@ 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)
@@ -25,6 +24,15 @@ class _AsyncAuditClient(_AsyncBaseClient):
             for e in await self._get_paginated("https://api.anaplan.com/2/0/users", "users")
         ]
 
+    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-0.3.1b1 → anaplan_sdk-0.4.0a1}/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:
         """

anaplan_sdk-0.4.0a1/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")