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

anaplan_sdk/_async_clients/_cw_flow.py

@@ -0,0 +1,80 @@
+from typing import Any
+
+import httpx
+
+from anaplan_sdk._base import _AsyncBaseClient, construct_payload
+from anaplan_sdk.models.flows import Flow, FlowInput, FlowSummary
+
+
+class _AsyncFlowClient(_AsyncBaseClient):
+    def __init__(self, client: httpx.AsyncClient, retry_count: int) -> None:
+        self._url = "https://api.cloudworks.anaplan.com/2/0/integrationflows"
+        super().__init__(retry_count, client)
+
+    async def list_flows(self, current_user_only: bool = False) -> list[FlowSummary]:
+        """
+        List all flows in CloudWorks.
+        :param current_user_only: Filters the flows to only those created by the current user.
+        :return: A list of FlowSummaries.
+        """
+        params = {"myIntegrations": 1 if current_user_only else 0}
+        return [
+            FlowSummary.model_validate(e)
+            for e in await self._get_paginated(
+                self._url, "integrationFlows", page_size=25, params=params
+            )
+        ]
+
+    async def get_flow(self, flow_id: str) -> Flow:
+        """
+        Get a flow by its ID. This returns the full flow object, including the contained steps and
+        continuation behavior.
+        :param flow_id: The ID of the flow to get.
+        :return: The Flow object.
+        """
+        return Flow.model_validate((await self._get(f"{self._url}/{flow_id}"))["integrationFlow"])
+
+    async def run_flow(self, flow_id: str, only_steps: list[str] = None) -> str:
+        """
+        Run a flow by its ID. Make sure that neither the flow nor any of its contained are running.
+        If this is the case, the task will error. Anaplan neither schedules these tasks nor can it
+        handle concurrent executions.
+        :param flow_id: The ID of the flow to run.
+        :param only_steps: A list of step IDs to run. If not provided, only these will be run.
+        :return: The ID of the run.
+        """
+        url = f"{self._url}/{flow_id}/run"
+        res = await (
+            self._post(url, json={"stepsToRun": only_steps})
+            if only_steps
+            else self._post_empty(url)
+        )
+        return res["run"]["id"]
+
+    async def create_flow(self, flow: FlowInput | dict[str, Any]) -> str:
+        """
+        Create a new flow in CloudWorks. Be careful not to omit the `depends_on` field. Anaplan
+        will accept these values, but an invalid, corrupted flow will be created, as all Flows must
+        have at least 2 Steps, and they must always be sequential
+        :param flow: The flow to create. This can be a FlowInput object or a dictionary.
+        :return: The ID of the created flow.
+        """
+        res = await self._post(self._url, json=construct_payload(FlowInput, flow))
+        return res["integrationFlow"]["integrationFlowId"]
+
+    async def update_flow(self, flow_id: str, flow: FlowInput | dict[str, Any]) -> None:
+        """
+        Update a flow in CloudWorks. You must provide the full flow object, partial updates are not
+        supported.
+        :param flow_id: The ID of the flow to update.
+        :param flow: The flow to update. This can be a FlowInput object or a dictionary.
+        """
+        await self._put(f"{self._url}/{flow_id}", json=construct_payload(FlowInput, flow))
+
+    async def delete_flow(self, flow_id: str) -> None:
+        """
+        Delete a flow in CloudWorks. This will not delete its contained steps. This will fail if
+        the flow is running or if it has any running steps.
+        :param flow_id: The ID of the flow to delete.
+        """
+        await self._delete(f"{self._url}/{flow_id}")

anaplan_sdk/_async_clients/_transactional.py

@@ -1,4 +1,3 @@
-import warnings
 from asyncio import gather
 from itertools import chain
 from typing import Any
@@ -16,12 +15,9 @@ from anaplan_sdk.models import (
     Module,
 )
 
-warnings.filterwarnings("always", category=DeprecationWarning)
-
 
 class _AsyncTransactionalClient(_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}"
         super().__init__(retry_count, client)
 
@@ -96,7 +92,15 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         """
         Insert new items to the given list. The items must be a list of dictionaries with at least
         the keys `code` and `name`. You can optionally pass further keys for parents, extra
-        properties etc.
+        properties etc. If you pass a long list, it will be split into chunks of 100,000 items, the
+        maximum allowed by the API.
+
+        **Warning**: If one or some of the requests timeout during large batch operations, the
+        operation may actually complete on the server. Retries for these chunks will then report
+        these items as "ignored" rather than "added", leading to misleading results. The results in
+        Anaplan will be correct, but this function may report otherwise. Be generous with your
+        timeouts and retries if you are using this function for large batch operations.
+
         :param list_id: The ID of the List.
         :param items: The items to insert into the List.
         :return: The result of the insertion, indicating how many items were added,
@@ -127,7 +131,16 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
 
     async def delete_list_items(self, list_id: int, items: list[dict[str, str | int]]) -> int:
         """
-        Deletes items from a List.
+        Deletes items from a List. If you pass a long list, it will be split into chunks of 100,000
+        items, the maximum allowed by the API.
+
+        **Warning**: If one or some of the requests timeout during large batch operations, the
+        operation may actually complete on the server. Retries for these chunks will then report
+        none of these items as deleted, since on the retry none are removed, leading to misleading
+        results. The results in Anaplan will be correct, but this function may report otherwise.
+        Be generous with your timeouts and retries if you are using this function for large batch
+        operations.
+
         :param list_id: The ID of the List.
         :param items: The items to delete from the List. Must be a dict with either `code` or `id`
                       as the keys to identify the records to delete.
@@ -162,33 +175,16 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         """
         Write the passed items to the specified module. If successful, the number of cells changed
         is returned, if only partially successful or unsuccessful, the response with the according
-        details is returned instead. For more details,
-        see: https://anaplan.docs.apiary.io/#UpdateModuleCellData.
+        details is returned instead.
+
+        **You can update a maximum of 100,000 cells or 15 MB of data (whichever is lower) in a
+        single request.** You must chunk your data accordingly. This is not done by this SDK,
+        since it is discouraged. For larger imports, you should use the Bulk API instead.
+
+        For more details see: https://anaplan.docs.apiary.io/#UpdateModuleCellData.
         :param module_id: The ID of the Module.
         :param data: The data to write to the Module.
         :return: The number of cells changed or the response with the according error details.
         """
         res = await self._post(f"{self._url}/modules/{module_id}/data", json=data)
         return res if "failures" in res else res["numberOfCellsChanged"]
-
-    async def write_to_module(
-        self, module_id: int, data: list[dict[str, Any]]
-    ) -> int | dict[str, Any]:
-        warnings.warn(
-            "`write_to_module()` is deprecated and will be removed in a future version. "
-            "Use `update_module_data()` instead.",
-            DeprecationWarning,
-            stacklevel=1,
-        )
-        return await self.update_module_data(module_id, data)
-
-    async def add_items_to_list(
-        self, list_id: int, items: list[dict[str, str | int | dict]]
-    ) -> InsertionResult:
-        warnings.warn(
-            "`add_items_to_list()` is deprecated and will be removed in a future version. "
-            "Use `insert_list_items()` instead.",
-            DeprecationWarning,
-            stacklevel=1,
-        )
-        return await self.insert_list_items(list_id, items)

anaplan_sdk/_auth.py

@@ -1,17 +1,9 @@
-"""
-Custom Authentication class to pass to httpx alongside some helper functions.
-"""
-
 import logging
 import os
 from base64 import b64encode
+from typing import Callable
 
 import httpx
-from cryptography.exceptions import InvalidKey, UnsupportedAlgorithm
-from cryptography.hazmat.backends import default_backend
-from cryptography.hazmat.primitives import hashes, serialization
-from cryptography.hazmat.primitives.asymmetric.padding import PKCS1v15
-from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey
 
 from .exceptions import AnaplanException, InvalidCredentialsException, InvalidPrivateKeyException
 
@@ -21,12 +13,12 @@ logger = logging.getLogger("anaplan_sdk")
 class _AnaplanAuth(httpx.Auth):
     requires_response_body = True
 
-    def __init__(self):
-        self._auth_request = self._build_auth_request()
-        logger.info("Creating Authentication Token.")
-        with httpx.Client(timeout=15.0) as client:
-            res = client.send(self._auth_request)
-            self._parse_auth_response(res)
+    def __init__(self, pre_authed: bool = False):
+        if not pre_authed:
+            logger.info("Creating Authentication Token.")
+            with httpx.Client(timeout=15.0) as client:
+                res = client.send(self._build_auth_request())
+                self._parse_auth_response(res)
 
     def _build_auth_request(self) -> httpx.Request:
         raise NotImplementedError("Must be implemented in subclass.")
@@ -36,7 +28,7 @@ class _AnaplanAuth(httpx.Auth):
         response = yield request
         if response.status_code == 401:
             logger.info("Token expired, refreshing.")
-            auth_res = yield self._auth_request
+            auth_res = yield self._build_auth_request()
             self._parse_auth_response(auth_res)
             request.headers["Authorization"] = f"AnaplanAuthToken {self._token}"
             yield request
@@ -67,9 +59,14 @@ class AnaplanBasicAuth(_AnaplanAuth):
 class AnaplanCertAuth(_AnaplanAuth):
     requires_request_body = True
 
-    def __init__(self, certificate: bytes, private_key: RSAPrivateKey):
-        self._certificate = certificate
-        self._private_key = private_key
+    def __init__(
+        self,
+        certificate: str | bytes,
+        private_key: str | bytes,
+        private_key_password: str | bytes | None = None,
+    ):
+        self.__set_certificate(certificate)
+        self.__set_private_key(private_key, private_key_password)
         super().__init__()
 
     def _build_auth_request(self) -> httpx.Request:
@@ -85,6 +82,9 @@ class AnaplanCertAuth(_AnaplanAuth):
         )
 
     def _prep_credentials(self) -> tuple[str, str, str]:
+        from cryptography.hazmat.primitives import hashes
+        from cryptography.hazmat.primitives.asymmetric.padding import PKCS1v15
+
         message = os.urandom(150)
         return (
             b64encode(self._certificate).decode(),
@@ -92,44 +92,157 @@ class AnaplanCertAuth(_AnaplanAuth):
             b64encode(self._private_key.sign(message, PKCS1v15(), hashes.SHA512())).decode(),
         )
 
-
-def get_certificate(certificate: str | bytes) -> bytes:
-    """
-    Get the certificate from a file or string.
-    :param certificate: The certificate to use.
-    :return: The certificate as bytes.
-    """
-    if isinstance(certificate, str):
-        if os.path.isfile(certificate):
-            with open(certificate, "rb") as f:
-                return f.read()
-        return certificate.encode()
-    return certificate
-
-
-def get_private_key(private_key: str | bytes, private_key_password: str | bytes) -> RSAPrivateKey:
-    """
-    Get the private key from a file or string.
-    :param private_key: The private key to use.
-    :param private_key_password: The password for the private key.
-    :return: The private key as an RSAPrivateKey object.
-    """
-    try:
-        if isinstance(private_key, str):
-            if os.path.isfile(private_key):
-                with open(private_key, "rb") as f:
-                    data = f.read()
+    def __set_certificate(self, certificate: str | bytes) -> None:
+        if isinstance(certificate, str):
+            if os.path.isfile(certificate):
+                with open(certificate, "rb") as f:
+                    self._certificate = f.read()
             else:
-                data = private_key.encode()
+                self._certificate = certificate.encode()
         else:
-            data = private_key
-
-        password = None
-        if private_key_password:
-            if isinstance(private_key_password, str):
-                password = private_key_password.encode()
+            self._certificate = certificate
+
+    def __set_private_key(
+        self, private_key: str | bytes, private_key_password: str | bytes
+    ) -> None:
+        try:
+            from cryptography.exceptions import InvalidKey, UnsupportedAlgorithm
+            from cryptography.hazmat.backends import default_backend
+            from cryptography.hazmat.primitives import serialization
+            from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey
+        except ImportError as e:
+            raise AnaplanException(
+                "cryptography is not available. Please install anaplan-sdk with the cert extra "
+                "`pip install anaplan-sdk[cert]` or install cryptography separately."
+            ) from e
+        try:
+            if isinstance(private_key, str):
+                if os.path.isfile(private_key):
+                    with open(private_key, "rb") as f:
+                        data = f.read()
+                else:
+                    data = private_key.encode()
             else:
-                password = private_key_password
-        return serialization.load_pem_private_key(data, password, backend=default_backend())
-    except (IOError, InvalidKey, UnsupportedAlgorithm) as error:
-        raise InvalidPrivateKeyException from error
+                data = private_key
+            password = (
+                private_key_password.encode()
+                if isinstance(private_key_password, str)
+                else private_key_password
+            )
+            self._private_key: RSAPrivateKey = serialization.load_pem_private_key(
+                data, password, backend=default_backend()
+            )
+        except (IOError, InvalidKey, UnsupportedAlgorithm) as error:
+            raise InvalidPrivateKeyException from error
+
+
+class AnaplanOauth2AuthCodeAuth(_AnaplanAuth):
+    def __init__(
+        self,
+        client_id: str,
+        client_secret: str,
+        redirect_uri: str,
+        refresh_token: str | None = None,
+        scope: str = "openid profile email offline_access",
+        on_token_refresh: Callable[[dict[str, str]], None] | None = None,
+    ):
+        try:
+            from oauthlib.oauth2 import WebApplicationClient
+        except ImportError as e:
+            raise AnaplanException(
+                "oauthlib is not available. Please install anaplan-sdk with the oauth extra "
+                "`pip install anaplan-sdk[oauth]` or install oauthlib separately."
+            ) from e
+        self._oauth = WebApplicationClient(
+            client_id=client_id, client_secret=client_secret, refresh_token=refresh_token
+        )
+        self._token_url = "https://us1a.app.anaplan.com/oauth/token"
+        self._client_id = client_id
+        self._client_secret = client_secret
+        self._redirect_uri = redirect_uri
+        self._refresh_token = refresh_token
+        self._scope = scope
+        self._id_token = None
+        self._on_token_refresh = on_token_refresh
+        if not refresh_token:
+            self.__auth_code_flow()
+        super().__init__(pre_authed=not refresh_token)
+
+    def _build_auth_request(self) -> httpx.Request:
+        url, headers, body = self._oauth.prepare_refresh_token_request(
+            token_url=self._token_url,
+            refresh_token=self._refresh_token,
+            client_secret=self._client_secret,
+            client_id=self._client_id,
+        )
+        return httpx.Request(method="post", url=url, headers=headers, content=body)
+
+    def _parse_auth_response(self, response: httpx.Response) -> None:
+        if response.status_code == 401:
+            raise InvalidCredentialsException
+        if not response.is_success:
+            raise AnaplanException(f"Authentication failed: {response.status_code} {response.text}")
+        token = response.json()
+        self._token = token["access_token"]
+        self._refresh_token = token["refresh_token"]
+        if self._on_token_refresh:
+            self._on_token_refresh(token)
+        self._id_token = token.get("id_token")
+
+    def __auth_code_flow(self):
+        from oauthlib.oauth2 import OAuth2Error
+
+        try:
+            logger.info("Creating Authentication Token with OAuth2 Authorization Code Flow.")
+            url, _, _ = self._oauth.prepare_authorization_request(
+                "https://us1a.app.anaplan.com/auth/authorize",
+                redirect_url=self._redirect_uri,
+                scope=self._scope,
+            )
+            authorization_response = input(
+                f"Please go to {url} and authorize the app.\n"
+                "Then paste the entire redirect URL here: "
+            )
+            url, headers, body = self._oauth.prepare_token_request(
+                token_url=self._token_url,
+                redirect_url=self._redirect_uri,
+                authorization_response=authorization_response,
+                client_secret=self._client_secret,
+            )
+            self._parse_auth_response(httpx.post(url=url, headers=headers, content=body))
+        except (httpx.HTTPError, ValueError, TypeError, OAuth2Error) as error:
+            raise AnaplanException("Error during OAuth2 authorization flow.") from error
+
+
+def create_auth(
+    user_email: str | None = None,
+    password: str | None = None,
+    certificate: str | bytes | None = None,
+    private_key: str | bytes | None = None,
+    private_key_password: str | bytes | None = None,
+    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,
+) -> _AnaplanAuth:
+    if certificate and private_key:
+        return AnaplanCertAuth(certificate, private_key, private_key_password)
+    if user_email and password:
+        return AnaplanBasicAuth(user_email=user_email, password=password)
+    if client_id and client_secret and redirect_uri:
+        return AnaplanOauth2AuthCodeAuth(
+            client_id=client_id,
+            client_secret=client_secret,
+            redirect_uri=redirect_uri,
+            refresh_token=refresh_token,
+            scope=oauth2_scope,
+            on_token_refresh=on_token_refresh,
+        )
+    raise ValueError(
+        "No valid authentication parameters provided. Please provide either:\n"
+        "- user_email and password, or\n"
+        "- certificate and private_key, or\n"
+        "- client_id, client_secret, and redirect_uri"
+    )

anaplan_sdk/_base.py

@@ -1,7 +1,3 @@
-"""
-Provides Base Classes for this project.
-"""
-
 import asyncio
 import logging
 import random
@@ -11,19 +7,30 @@ from concurrent.futures import ThreadPoolExecutor
 from gzip import compress
 from itertools import chain
 from math import ceil
-from typing import Any, Callable, Coroutine, Iterator, Literal
+from typing import Any, Callable, Coroutine, Iterator, Literal, Type, TypeVar
 
 import httpx
 from httpx import HTTPError, Response
 
-from anaplan_sdk.exceptions import (
-    AnaplanException,
-    AnaplanTimeoutException,
-    InvalidIdentifierException,
+from .exceptions import AnaplanException, AnaplanTimeoutException, InvalidIdentifierException
+from .models import AnaplanModel
+from .models.cloud_works import (
+    AmazonS3ConnectionInput,
+    AzureBlobConnectionInput,
+    ConnectionBody,
+    GoogleBigQueryConnectionInput,
+    IntegrationInput,
+    IntegrationProcessInput,
+    ScheduleInput,
 )
 
 logger = logging.getLogger("anaplan_sdk")
 
+_json_header = {"Content-Type": "application/json"}
+_gzip_header = {"Content-Type": "application/x-gzip"}
+
+T = TypeVar("T", bound=AnaplanModel)
+
 
 class _BaseClient:
     def __init__(self, retry_count: int, client: httpx.Client):
@@ -37,27 +44,34 @@ class _BaseClient:
         return self._run_with_retry(self._client.get, url).content
 
     def _post(self, url: str, json: dict | list) -> dict[str, Any]:
-        return self._run_with_retry(
-            self._client.post, url, headers={"Content-Type": "application/json"}, json=json
+        return self._run_with_retry(self._client.post, url, headers=_json_header, json=json).json()
+
+    def _put(self, url: str, json: dict | list) -> dict[str, Any]:
+        return (self._run_with_retry(self._client.put, url, headers=_json_header, json=json)).json()
+
+    def _patch(self, url: str, json: dict | list) -> dict[str, Any]:
+        return (
+            self._run_with_retry(self._client.patch, url, headers=_json_header, json=json)
         ).json()
 
-    def _post_empty(self, url: str) -> None:
-        self._run_with_retry(self._client.post, url)
+    def _delete(self, url: str) -> dict[str, Any]:
+        return (self._run_with_retry(self._client.delete, url, headers=_json_header)).json()
+
+    def _post_empty(self, url: str) -> dict[str, Any]:
+        res = self._run_with_retry(self._client.post, url)
+        return res.json() if res.num_bytes_downloaded > 0 else {}
 
     def _put_binary_gzip(self, url: str, content: bytes) -> Response:
         return self._run_with_retry(
-            self._client.put,
-            url,
-            headers={"Content-Type": "application/x-gzip"},
-            content=compress(content),
+            self._client.put, url, headers=_gzip_header, content=compress(content)
         )
 
     def __get_page(self, url: str, limit: int, offset: int, result_key: str, **kwargs) -> list:
-        kwargs["params"] = kwargs.get("params", {}) | {"limit": limit, "offset": offset}
+        kwargs["params"] = kwargs.get("params") or {} | {"limit": limit, "offset": offset}
         return self._get(url, **kwargs).get(result_key, [])
 
     def __get_first_page(self, url: str, limit: int, result_key: str, **kwargs) -> tuple[list, int]:
-        kwargs["params"] = kwargs.get("params", {}) | {"limit": limit}
+        kwargs["params"] = kwargs.get("params") or {} | {"limit": limit}
         res = self._get(url, **kwargs)
         return res.get(result_key, []), res["meta"]["paging"]["totalSize"]
 
@@ -111,32 +125,41 @@ class _AsyncBaseClient:
 
     async def _post(self, url: str, json: dict | list) -> dict[str, Any]:
         return (
-            await self._run_with_retry(
-                self._client.post, url, headers={"Content-Type": "application/json"}, json=json
-            )
+            await self._run_with_retry(self._client.post, url, headers=_json_header, json=json)
+        ).json()
+
+    async def _put(self, url: str, json: dict | list) -> dict[str, Any]:
+        return (
+            await self._run_with_retry(self._client.put, url, headers=_json_header, json=json)
         ).json()
 
-    async def _post_empty(self, url: str) -> None:
-        await self._run_with_retry(self._client.post, url)
+    async def _patch(self, url: str, json: dict | list) -> dict[str, Any]:
+        return (
+            await self._run_with_retry(self._client.patch, url, headers=_json_header, json=json)
+        ).json()
+
+    async def _delete(self, url: str) -> dict[str, Any]:
+        return (await self._run_with_retry(self._client.delete, url, headers=_json_header)).json()
+
+    async def _post_empty(self, url: str) -> dict[str, Any]:
+        res = await self._run_with_retry(self._client.post, url)
+        return res.json() if res.num_bytes_downloaded > 0 else {}
 
     async def _put_binary_gzip(self, url: str, content: bytes) -> Response:
         return await self._run_with_retry(
-            self._client.put,
-            url,
-            headers={"Content-Type": "application/x-gzip"},
-            content=compress(content),
+            self._client.put, url, headers=_gzip_header, content=compress(content)
         )
 
     async def __get_page(
         self, url: str, limit: int, offset: int, result_key: str, **kwargs
     ) -> list:
-        kwargs["params"] = kwargs.get("params", {}) | {"limit": limit, "offset": offset}
+        kwargs["params"] = kwargs.get("params") or {} | {"limit": limit, "offset": offset}
         return (await self._get(url, **kwargs)).get(result_key, [])
 
     async def __get_first_page(
         self, url: str, limit: int, result_key: str, **kwargs
     ) -> tuple[list, int]:
-        kwargs["params"] = kwargs.get("params", {}) | {"limit": limit}
+        kwargs["params"] = kwargs.get("params") or {} | {"limit": limit}
         res = await self._get(url, **kwargs)
         return res.get(result_key, []), res["meta"]["paging"]["totalSize"]
 
@@ -178,6 +201,68 @@ class _AsyncBaseClient:
         raise AnaplanException("Exhausted all retries without a successful response or Error.")
 
 
+def construct_payload(model: Type[T], body: T | dict[str, Any]) -> dict[str, Any]:
+    """
+    Construct a payload for the given model and body.
+    :param model: The model class to use for validation.
+    :param body: The body to validate and optionally convert to a dictionary.
+    :return: A dictionary representation of the validated body.
+    """
+    if isinstance(body, dict):
+        body = model.model_validate(body)
+    return body.model_dump(exclude_none=True, by_alias=True)
+
+
+def connection_body_payload(body: ConnectionBody | dict[str, Any]) -> dict[str, Any]:
+    """
+    Construct a payload for the given integration body.
+    :param body: The body to validate and optionally convert to a dictionary.
+    :return: A dictionary representation of the validated body.
+    """
+    if isinstance(body, dict):
+        if "sasToken" in body:
+            body = AzureBlobConnectionInput.model_validate(body)
+        elif "secretAccessKey" in body:
+            body = AmazonS3ConnectionInput.model_validate(body)
+        else:
+            body = GoogleBigQueryConnectionInput.model_validate(body)
+    return body.model_dump(exclude_none=True, by_alias=True)
+
+
+def integration_payload(
+    body: IntegrationInput | IntegrationProcessInput | dict[str, Any],
+) -> dict[str, Any]:
+    """
+    Construct a payload for the given integration body.
+    :param body: The body to validate and optionally convert to a dictionary.
+    :return: A dictionary representation of the validated body.
+    """
+    if isinstance(body, dict):
+        body = (
+            IntegrationInput.model_validate(body)
+            if "jobs" in body
+            else IntegrationProcessInput.model_validate(body)
+        )
+    return body.model_dump(exclude_none=True, by_alias=True)
+
+
+def schedule_payload(
+    integration_id: str, schedule: ScheduleInput | dict[str, Any]
+) -> dict[str, Any]:
+    """
+    Construct a payload for the given integration ID and schedule.
+    :param integration_id: The ID of the integration.
+    :param schedule: The schedule to validate and optionally convert to a dictionary.
+    :return: A dictionary representation of the validated schedule.
+    """
+    if isinstance(schedule, dict):
+        schedule = ScheduleInput.model_validate(schedule)
+    return {
+        "integrationId": integration_id,
+        "schedule": schedule.model_dump(exclude_none=True, by_alias=True),
+    }
+
+
 def action_url(action_id: int) -> Literal["imports", "exports", "actions", "processes"]:
     """
     Determine the type of action based on its identifier.