anaplan-sdk 0.4.4a4__py3-none-any.whl → 0.5.0a1__py3-none-any.whl

anaplan_sdk/_async_clients/_bulk.py

@@ -15,6 +15,7 @@ from anaplan_sdk.models import (
     File,
     Import,
     Model,
+    ModelDeletionResult,
     Process,
     TaskStatus,
     TaskSummary,
@@ -26,7 +27,6 @@ from ._audit import _AsyncAuditClient
 from ._cloud_works import _AsyncCloudWorksClient
 from ._transactional import _AsyncTransactionalClient
 
-logging.getLogger("httpx").setLevel(logging.CRITICAL)
 logger = logging.getLogger("anaplan_sdk")
 
 
@@ -107,13 +107,17 @@ class AsyncClient(_AsyncBaseClient):
             ),
             timeout=timeout,
         )
+        self._workspace_id = workspace_id
+        self._model_id = model_id
         self._retry_count = retry_count
         self._url = f"https://api.anaplan.com/2/0/workspaces/{workspace_id}/models/{model_id}"
         self._transactional_client = (
             _AsyncTransactionalClient(_client, model_id, retry_count) if model_id else None
         )
         self._alm_client = (
-            _AsyncAlmClient(_client, model_id, self._retry_count) if model_id else None
+            _AsyncAlmClient(_client, model_id, self._retry_count, status_poll_delay)
+            if model_id
+            else None
         )
         self._audit = _AsyncAuditClient(_client, self._retry_count)
         self._cloud_works = _AsyncCloudWorksClient(_client, self._retry_count)
@@ -123,23 +127,37 @@ class AsyncClient(_AsyncBaseClient):
         super().__init__(retry_count, _client)
 
     @classmethod
-    def from_existing(cls, existing: Self, workspace_id: str, model_id: str) -> Self:
+    def from_existing(
+        cls, existing: Self, *, workspace_id: str | None = None, model_id: str | None = None
+    ) -> Self:
         """
         Create a new instance of the Client from an existing instance. This is useful if you want
         to interact with multiple models or workspaces in the same script but share the same
         authentication and configuration. This creates a shallow copy of the existing client and
-        update the relevant attributes to the new workspace and model.
+        optionally updates the relevant attributes to the new workspace and model. You can provide
+        either a new workspace Id or a new model Id, or both. If you do not provide one of them,
+        the existing value will be used. If you omit both, the new instance will be an identical
+        copy of the existing instance.
+
         :param existing: The existing instance to copy.
-        :param workspace_id: The workspace Id to use.
-        :param model_id: The model Id to use.
+        :param workspace_id: The workspace Id to use or None to use the existing workspace Id.
+        :param model_id: The model Id to use or None to use the existing model Id.
         :return: A new instance of the Client.
         """
         client = copy(existing)
-        client._url = f"https://api.anaplan.com/2/0/workspaces/{workspace_id}/models/{model_id}"
+        new_ws_id = workspace_id or existing._workspace_id
+        new_model_id = model_id or existing._model_id
+        logger.debug(
+            f"Creating a new AsyncClient from existing instance "
+            f"with workspace_id={new_ws_id}, model_id={new_model_id}."
+        )
+        client._url = f"https://api.anaplan.com/2/0/workspaces/{new_ws_id}/models/{new_model_id}"
         client._transactional_client = _AsyncTransactionalClient(
-            existing._client, model_id, existing._retry_count
+            existing._client, new_model_id, existing._retry_count
+        )
+        client._alm_client = _AsyncAlmClient(
+            existing._client, new_model_id, existing._retry_count, existing.status_poll_delay
         )
-        client._alm_client = _AsyncAlmClient(existing._client, model_id, existing._retry_count)
         return client
 
     @property
@@ -197,7 +215,7 @@ class AsyncClient(_AsyncBaseClient):
             )
         return self._alm_client
 
-    async def list_workspaces(self, search_pattern: str | None = None) -> list[Workspace]:
+    async def get_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,
@@ -216,13 +234,13 @@ class AsyncClient(_AsyncBaseClient):
             )
         ]
 
-    async def list_models(self, search_pattern: str | None = None) -> list[Model]:
+    async def get_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.
+               case-insensitive matches model names containing this string.
                You can use the wildcards `%` for 0-n characters, and `_` for exactly 1 character.
-               When None (default), returns all users.
+               When None (default), returns all models.
         :return: The List of Models.
         """
         params = {"modelDetails": "true"}
@@ -235,7 +253,21 @@ class AsyncClient(_AsyncBaseClient):
             )
         ]
 
-    async def list_files(self) -> list[File]:
+    async def delete_models(self, model_ids: list[str]) -> ModelDeletionResult:
+        """
+        Delete the given Models. Models need to be closed before they can be deleted. If one of the
+        deletions fails, the other deletions will still be attempted and may complete.
+        :param model_ids: The list of Model identifiers to delete.
+        :return:
+        """
+        logger.info(f"Deleting Models: {', '.join(model_ids)}.")
+        res = await self._post(
+            f"https://api.anaplan.com/2/0/workspaces/{self._workspace_id}/bulkDeleteModels",
+            json={"modelIdsToDelete": model_ids},
+        )
+        return ModelDeletionResult.model_validate(res)
+
+    async def get_files(self) -> list[File]:
         """
         Lists all the Files in the Model.
         :return: The List of Files.
@@ -244,7 +276,7 @@ class AsyncClient(_AsyncBaseClient):
             File.model_validate(e) for e in await self._get_paginated(f"{self._url}/files", "files")
         ]
 
-    async def list_actions(self) -> list[Action]:
+    async def get_actions(self) -> list[Action]:
         """
         Lists all the Actions in the Model. This will only return the Actions listed under
         `Other Actions` in Anaplan. For Imports, exports, and processes, see their respective
@@ -256,7 +288,7 @@ class AsyncClient(_AsyncBaseClient):
             for e in await self._get_paginated(f"{self._url}/actions", "actions")
         ]
 
-    async def list_processes(self) -> list[Process]:
+    async def get_processes(self) -> list[Process]:
         """
         Lists all the Processes in the Model.
         :return: The List of Processes.
@@ -266,7 +298,7 @@ class AsyncClient(_AsyncBaseClient):
             for e in await self._get_paginated(f"{self._url}/processes", "processes")
         ]
 
-    async def list_imports(self) -> list[Import]:
+    async def get_imports(self) -> list[Import]:
         """
         Lists all the Imports in the Model.
         :return: The List of Imports.
@@ -276,7 +308,7 @@ class AsyncClient(_AsyncBaseClient):
             for e in await self._get_paginated(f"{self._url}/imports", "imports")
         ]
 
-    async def list_exports(self) -> list[Export]:
+    async def get_exports(self) -> list[Export]:
         """
         Lists all the Exports in the Model.
         :return: The List of Exports.
@@ -286,33 +318,34 @@ class AsyncClient(_AsyncBaseClient):
             for e in await self._get_paginated(f"{self._url}/exports", "exports")
         ]
 
-    async def run_action(self, action_id: int) -> TaskStatus:
+    async def run_action(self, action_id: int, wait_for_completion: bool = True) -> TaskStatus:
         """
-        Runs the specified Anaplan Action and validates the spawned task. If the Action fails or
-        completes with errors, will raise an :py:class:`AnaplanActionError`. Failed Tasks are
-        usually not something you can recover from at runtime and often require manual changes in
-        Anaplan, i.e. updating the mapping of an Import or similar. So, for convenience, this will
-        raise an Exception to handle - if you for e.g. think that one of the uploaded chunks may
-        have been dropped and simply retrying with new data may help - and not return the task
-        status information that needs to be handled by the caller.
-
-        If you need more information or control, you can use `invoke_action()` and
-        `get_task_status()`.
+        Runs the Action and validates the spawned task. If the Action fails or completes with
+        errors, this will raise an AnaplanActionError. Failed Tasks are often not something you
+        can recover from at runtime and often require manual changes in Anaplan, i.e. updating the
+        mapping of an Import or similar.
         :param action_id: The identifier of the Action to run. Can be any Anaplan Invokable;
-                          Processes, Imports, Exports, Other Actions.
+               Processes, Imports, Exports, Other Actions.
+        :param wait_for_completion: If True, the method will poll the task status and not return
+               until the task is complete. If False, it will spawn the task and return immediately.
         """
-        task_id = await self.invoke_action(action_id)
-        task_status = await self.get_task_status(action_id, task_id)
+        body = {"localeName": "en_US"}
+        res = await self._post(f"{self._url}/{action_url(action_id)}/{action_id}/tasks", json=body)
+        task_id = res["task"]["taskId"]
+        logger.info(f"Invoked Action '{action_id}', spawned Task: '{task_id}'.")
 
-        while task_status.task_state != "COMPLETE":
+        if not wait_for_completion:
+            return TaskStatus.model_validate(await self.get_task_status(action_id, task_id))
+
+        while (status := await self.get_task_status(action_id, task_id)).task_state != "COMPLETE":
             await sleep(self.status_poll_delay)
-            task_status = await self.get_task_status(action_id, task_id)
 
-        if task_status.task_state == "COMPLETE" and not task_status.result.successful:
+        if status.task_state == "COMPLETE" and not status.result.successful:
+            logger.error(f"Task '{task_id}' completed with errors: {status.result.error_message}")
             raise AnaplanActionError(f"Task '{task_id}' completed with errors.")
 
-        logger.info(f"Task '{task_id}' completed successfully.")
-        return task_status
+        logger.info(f"Task '{task_id}' of '{action_id}' completed successfully.")
+        return status
 
     async def get_file(self, file_id: int) -> bytes:
         """
@@ -321,58 +354,71 @@ class AsyncClient(_AsyncBaseClient):
         :return: The content of the file.
         """
         chunk_count = await self._file_pre_check(file_id)
+        logger.info(f"File {file_id} has {chunk_count} chunks.")
         if chunk_count <= 1:
             return await self._get_binary(f"{self._url}/files/{file_id}")
-        logger.info(f"File {file_id} has {chunk_count} chunks.")
         return b"".join(
             await gather(
-                *[
+                *(
                     self._get_binary(f"{self._url}/files/{file_id}/chunks/{i}")
                     for i in range(chunk_count)
-                ]
+                )
             )
         )
 
-    async def get_file_stream(self, file_id: int) -> AsyncIterator[bytes]:
+    async def get_file_stream(self, file_id: int, batch_size: int = 1) -> AsyncIterator[bytes]:
         """
         Retrieves the content of the specified file as a stream of chunks. The chunks are yielded
         one by one, so you can process them as they arrive. This is useful for large files where
         you don't want to or cannot load the entire file into memory at once.
         :param file_id: The identifier of the file to retrieve.
+        :param batch_size: Number of chunks to fetch concurrently. If > 1, n chunks will be fetched
+               concurrently. This still yields each chunk individually, only the requests are
+               batched. If 1 (default), each chunk is fetched sequentially.
         :return: A generator yielding the chunks of the file.
         """
         chunk_count = await self._file_pre_check(file_id)
+        logger.info(f"File {file_id} has {chunk_count} chunks.")
         if chunk_count <= 1:
             yield await self._get_binary(f"{self._url}/files/{file_id}")
             return
-        logger.info(f"File {file_id} has {chunk_count} chunks.")
-        for i in range(chunk_count):
-            yield await self._get_binary(f"{self._url}/files/{file_id}/chunks/{i}")
+
+        for batch_start in range(0, chunk_count, batch_size):
+            batch_chunks = await gather(
+                *(
+                    self._get_binary(f"{self._url}/files/{file_id}/chunks/{i}")
+                    for i in range(batch_start, min(batch_start + batch_size, chunk_count))
+                )
+            )
+            for chunk in batch_chunks:
+                yield chunk
 
     async def upload_file(self, file_id: int, content: str | bytes) -> None:
         """
         Uploads the content to the specified file. If there are several chunks, upload of
-        individual chunks are concurrent.
+        individual chunks are uploaded concurrently.
 
         :param file_id: The identifier of the file to upload to.
         :param content: The content to upload. **This Content will be compressed before uploading.
-                        If you are passing the Input as bytes, pass it uncompressed to avoid
-                        redundant work.**
+               If you are passing the Input as bytes, pass it uncompressed.**
         """
-        if isinstance(content, str):
-            content = content.encode()
         chunks = [
             content[i : i + self.upload_chunk_size]
             for i in range(0, len(content), self.upload_chunk_size)
         ]
-        logger.info(f"Content will be uploaded in {len(chunks)} chunks.")
+        logger.info(f"Content for file '{file_id}' will be uploaded in {len(chunks)} chunks.")
         await self._set_chunk_count(file_id, len(chunks))
         await gather(
-            *[self._upload_chunk(file_id, index, chunk) for index, chunk in enumerate(chunks)]
+            *(self._upload_chunk(file_id, index, chunk) for index, chunk in enumerate(chunks))
         )
 
+        logger.info(f"Completed upload for file '{file_id}'.")
+
     async def upload_file_stream(
-        self, file_id: int, content: AsyncIterator[bytes | str] | Iterator[str | bytes]
+        self,
+        file_id: int,
+        content: AsyncIterator[bytes | str] | Iterator[str | bytes],
+        batch_size: int = 1,
     ) -> None:
         """
         Uploads the content to the specified file as a stream of chunks. This is useful either for
@@ -382,25 +428,42 @@ class AsyncClient(_AsyncBaseClient):
         generator that yields the chunks of the file one by one to this method.
 
         :param file_id: The identifier of the file to upload to.
-        :param content: An Iterator or AsyncIterator yielding the chunks of the file.
-               (Most likely a generator).
+        :param content: An Iterator or AsyncIterator yielding the chunks of the file. You can pass
+               any Iterator, but you will most likely want to pass a Generator.
+        :param batch_size: Number of chunks to upload concurrently. If > 1, n chunks will be
+               uploaded concurrently. This can be useful if you either do not control the chunk
+               size, or if you want to keep the chunk size small but still want some concurrency.
         """
+        logger.info(f"Starting upload stream for file '{file_id}' with batch size {batch_size}.")
         await self._set_chunk_count(file_id, -1)
+        tasks = []
         if isinstance(content, Iterator):
             for index, chunk in enumerate(content):
-                await self._upload_chunk(
-                    file_id, index, chunk.encode() if isinstance(chunk, str) else chunk
-                )
+                tasks.append(self._upload_chunk(file_id, index, chunk))
+                if len(tasks) == max(batch_size, 1):
+                    await gather(*tasks)
+                    logger.info(
+                        f"Completed upload stream batch of size {batch_size} for file {file_id}."
+                    )
+                    tasks = []
         else:
             index = 0
             async for chunk in content:
-                await self._upload_chunk(
-                    file_id, index, chunk.encode() if isinstance(chunk, str) else chunk
-                )
+                tasks.append(self._upload_chunk(file_id, index, chunk))
                 index += 1
-
+                if len(tasks) == max(batch_size, 1):
+                    await gather(*tasks)
+                    logger.info(
+                        f"Completed upload stream batch of size {batch_size} for file {file_id}."
+                    )
+                    tasks = []
+        if tasks:
+            await gather(*tasks)
+            logger.info(
+                f"Completed final upload stream batch of size {len(tasks)} for file {file_id}."
+            )
         await self._post(f"{self._url}/files/{file_id}/complete", json={"id": file_id})
-        logger.info(f"Marked all chunks as complete for file '{file_id}'.")
+        logger.info(f"Completed upload stream for '{file_id}'.")
 
     async def upload_and_import(self, file_id: int, content: str | bytes, action_id: int) -> None:
         """
@@ -425,7 +488,7 @@ class AsyncClient(_AsyncBaseClient):
         await self.run_action(action_id)
         return await self.get_file(action_id)
 
-    async def list_task_status(self, action_id: int) -> list[TaskSummary]:
+    async def get_task_summaries(self, action_id: int) -> list[TaskSummary]:
         """
         Retrieves the status of all tasks spawned by the specified action.
         :param action_id: The identifier of the action that was invoked.
@@ -451,34 +514,26 @@ class AsyncClient(_AsyncBaseClient):
             ).get("task")
         )
 
-    async def invoke_action(self, action_id: int) -> str:
+    async def get_optimizer_log(self, action_id: int, task_id: str) -> bytes:
         """
-        You may want to consider using `run_action()` instead.
-
-        Invokes the specified Anaplan Action and returns the spawned Task identifier. This is
-        useful if you want to handle the Task status yourself or if you want to run multiple
-        Actions in parallel.
-        :param action_id: The identifier of the Action to run. Can be any Anaplan Invokable.
-        :return: The identifier of the spawned Task.
+        Retrieves the solution logs of the specified optimization action task.
+        :param action_id: The identifier of the optimization action that was invoked.
+        :param task_id: The Task identifier, sometimes also referred to as the Correlation Id.
+        :return: The content of the solution logs.
         """
-        response = await self._post(
-            f"{self._url}/{action_url(action_id)}/{action_id}/tasks", json={"localeName": "en_US"}
+        return await self._get_binary(
+            f"{self._url}/optimizeActions/{action_id}/tasks/{task_id}/solutionLogs"
         )
-        task_id = response.get("task").get("taskId")
-        logger.info(f"Invoked Action '{action_id}', spawned Task: '{task_id}'.")
-        return task_id
 
     async def _file_pre_check(self, file_id: int) -> int:
-        file = next(filter(lambda f: f.id == file_id, await self.list_files()), None)
+        file = next((f for f in await self.get_files() if f.id == file_id), None)
         if not file:
             raise InvalidIdentifierException(f"File {file_id} not found.")
         return file.chunk_count
 
-    async def _upload_chunk(self, file_id: int, index: int, chunk: bytes) -> None:
-        await self._run_with_retry(
-            self._put_binary_gzip, f"{self._url}/files/{file_id}/chunks/{index}", content=chunk
-        )
-        logger.info(f"Chunk {index} loaded to file '{file_id}'.")
+    async def _upload_chunk(self, file_id: int, index: int, chunk: str | bytes) -> None:
+        await self._put_binary_gzip(f"{self._url}/files/{file_id}/chunks/{index}", chunk)
+        logger.debug(f"Chunk {index} loaded to file '{file_id}'.")
 
     async def _set_chunk_count(self, file_id: int, num_chunks: int) -> None:
         if not self.allow_file_creation and not (113000000000 <= file_id <= 113999999999):

anaplan_sdk/_async_clients/_cloud_works.py

@@ -1,3 +1,4 @@
+import logging
 from typing import Any, Literal
 
 import httpx
@@ -27,6 +28,8 @@ from anaplan_sdk.models.cloud_works import (
 
 from ._cw_flow import _AsyncFlowClient
 
+logger = logging.getLogger("anaplan_sdk")
+
 
 class _AsyncCloudWorksClient(_AsyncBaseClient):
     def __init__(self, client: httpx.AsyncClient, retry_count: int) -> None:
@@ -41,7 +44,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         """
         return self._flow
 
-    async def list_connections(self) -> list[Connection]:
+    async def get_connections(self) -> list[Connection]:
         """
         List all Connections available in CloudWorks.
         :return: A list of connections.
@@ -62,7 +65,9 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         res = await self._post(
             f"{self._url}/connections", json=construct_payload(ConnectionInput, con_info)
         )
-        return res["connections"]["connectionId"]
+        connection_id = res["connections"]["connectionId"]
+        logger.info(f"Created connection '{connection_id}'.")
+        return connection_id
 
     async def update_connection(
         self, con_id: str, con_info: ConnectionBody | dict[str, Any]
@@ -91,8 +96,9 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :param con_id: The ID of the connection to delete.
         """
         await self._delete(f"{self._url}/connections/{con_id}")
+        logger.info(f"Deleted connection '{con_id}'.")
 
-    async def list_integrations(
+    async def get_integrations(
         self, sort_by_name: Literal["ascending", "descending"] = "ascending"
     ) -> list[Integration]:
         """
@@ -143,7 +149,10 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :return: The ID of the new integration.
         """
         json = integration_payload(body)
-        return (await self._post(f"{self._url}", json=json))["integration"]["integrationId"]
+        res = await self._post(f"{self._url}", json=json)
+        integration_id = res["integration"]["integrationId"]
+        logger.info(f"Created integration '{integration_id}'.")
+        return integration_id
 
     async def update_integration(
         self, integration_id: str, body: IntegrationInput | IntegrationProcessInput | dict[str, Any]
@@ -164,7 +173,9 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :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"]
+        run_id = (await self._post_empty(f"{self._url}/{integration_id}/run"))["run"]["id"]
+        logger.info(f"Started integration run '{run_id}' for integration '{integration_id}'.")
+        return run_id
 
     async def delete_integration(self, integration_id: str) -> None:
         """
@@ -172,6 +183,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :param integration_id: The ID of the integration to delete.
         """
         await self._delete(f"{self._url}/{integration_id}")
+        logger.info(f"Deleted integration '{integration_id}'.")
 
     async def get_run_history(self, integration_id: str) -> list[RunSummary]:
         """
@@ -218,6 +230,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
             f"{self._url}/{integration_id}/schedule",
             json=schedule_payload(integration_id, schedule),
         )
+        logger.info(f"Created schedule for integration '{integration_id}'.")
 
     async def update_schedule(
         self, integration_id: str, schedule: ScheduleInput | dict[str, Any]
@@ -250,6 +263,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :param integration_id: The ID of the integration to schedule.
         """
         await self._delete(f"{self._url}/{integration_id}/schedule")
+        logger.info(f"Deleted schedule for integration '{integration_id}'.")
 
     async def get_notification_config(
         self, notification_id: str | None = None, integration_id: str | None = None
@@ -285,7 +299,9 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         res = await self._post(
             f"{self._url}/notification", json=construct_payload(NotificationInput, config)
         )
-        return res["notification"]["notificationId"]
+        notification_id = res["notification"]["notificationId"]
+        logger.info(f"Created notification configuration '{notification_id}'.")
+        return notification_id
 
     async def update_notification_config(
         self, notification_id: str, config: NotificationInput | dict[str, Any]
@@ -320,6 +336,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         if integration_id:
             notification_id = (await self.get_integration(integration_id)).notification_id
         await self._delete(f"{self._url}/notification/{notification_id}")
+        logger.info(f"Deleted notification configuration '{notification_id}'.")
 
     async def get_import_error_dump(self, run_id: str) -> bytes:
         """

anaplan_sdk/_async_clients/_cw_flow.py

@@ -1,3 +1,4 @@
+import logging
 from typing import Any
 
 import httpx
@@ -5,13 +6,15 @@ import httpx
 from anaplan_sdk._base import _AsyncBaseClient, construct_payload
 from anaplan_sdk.models.flows import Flow, FlowInput, FlowSummary
 
+logger = logging.getLogger("anaplan_sdk")
+
 
 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]:
+    async def get_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.
@@ -49,7 +52,9 @@ class _AsyncFlowClient(_AsyncBaseClient):
             if only_steps
             else self._post_empty(url)
         )
-        return res["run"]["id"]
+        run_id = res["run"]["id"]
+        logger.info(f"Started flow run '{run_id}' for flow '{flow_id}'.")
+        return run_id
 
     async def create_flow(self, flow: FlowInput | dict[str, Any]) -> str:
         """
@@ -60,7 +65,9 @@ class _AsyncFlowClient(_AsyncBaseClient):
         :return: The ID of the created flow.
         """
         res = await self._post(self._url, json=construct_payload(FlowInput, flow))
-        return res["integrationFlow"]["integrationFlowId"]
+        flow_id = res["integrationFlow"]["integrationFlowId"]
+        logger.info(f"Created flow '{flow_id}'.")
+        return flow_id
 
     async def update_flow(self, flow_id: str, flow: FlowInput | dict[str, Any]) -> None:
         """
@@ -70,6 +77,7 @@ class _AsyncFlowClient(_AsyncBaseClient):
         :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))
+        logger.info(f"Updated flow '{flow_id}'.")
 
     async def delete_flow(self, flow_id: str) -> None:
         """
@@ -78,3 +86,4 @@ class _AsyncFlowClient(_AsyncBaseClient):
         :param flow_id: The ID of the flow to delete.
         """
         await self._delete(f"{self._url}/{flow_id}")
+        logger.info(f"Deleted flow '{flow_id}'.")