anaplan-sdk 0.4.5__py3-none-any.whl → 0.5.0a1__py3-none-any.whl

anaplan_sdk/_clients/_bulk.py

@@ -1,8 +1,8 @@
 import logging
 import multiprocessing
-import time
 from concurrent.futures import ThreadPoolExecutor
 from copy import copy
+from time import sleep
 from typing import Iterator
 
 import httpx
@@ -17,6 +17,7 @@ from anaplan_sdk.models import (
     File,
     Import,
     Model,
+    ModelDeletionResult,
     Process,
     TaskStatus,
     TaskSummary,
@@ -28,7 +29,6 @@ from ._audit import _AuditClient
 from ._cloud_works import _CloudWorksClient
 from ._transactional import _TransactionalClient
 
-logging.getLogger("httpx").setLevel(logging.CRITICAL)
 logger = logging.getLogger("anaplan_sdk")
 
 
@@ -112,11 +112,17 @@ class Client(_BaseClient):
             timeout=timeout,
         )
         self._retry_count = retry_count
+        self._workspace_id = workspace_id
+        self._model_id = model_id
         self._url = f"https://api.anaplan.com/2/0/workspaces/{workspace_id}/models/{model_id}"
         self._transactional_client = (
             _TransactionalClient(_client, model_id, self._retry_count) if model_id else None
         )
-        self._alm_client = _AlmClient(_client, model_id, self._retry_count) if model_id else None
+        self._alm_client = (
+            _AlmClient(_client, model_id, self._retry_count, status_poll_delay)
+            if model_id
+            else None
+        )
         self._cloud_works = _CloudWorksClient(_client, self._retry_count)
         self._thread_count = multiprocessing.cpu_count()
         self._audit = _AuditClient(_client, self._retry_count, self._thread_count)
@@ -127,23 +133,37 @@ class Client(_BaseClient):
         super().__init__(self._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 = _TransactionalClient(
-            existing._client, model_id, existing._retry_count
+            existing._client, new_model_id, existing._retry_count
+        )
+        client._alm_client = _AlmClient(
+            existing._client, new_model_id, existing._retry_count, existing.status_poll_delay
         )
-        client._alm_client = _AlmClient(existing._client, model_id, existing._retry_count)
         return client
 
     @property
@@ -201,7 +221,7 @@ class Client(_BaseClient):
             )
         return self._alm_client
 
-    def list_workspaces(self, search_pattern: str | None = None) -> list[Workspace]:
+    def get_workspaces(self, search_pattern: str | None = None) -> list[Workspace]:
         """
         Lists all the Workspaces the authenticated user has access to.
         :param search_pattern: Optional filter for workspaces. When provided, case-insensitive
@@ -219,11 +239,13 @@ class Client(_BaseClient):
             )
         ]
 
-    def list_models(self, search_pattern: str | None = None) -> list[Model]:
+    def get_models(self, search_pattern: str | None = None) -> list[Model]:
         """
         Lists all the Models the authenticated user has access to.
-        :param search_pattern: Optional filter for models. When provided, case-insensitive matches
-               models with names containing this string. When None (default), returns all models.
+        :param search_pattern: Optionally filter for specific models. When provided,
+               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 models.
         :return: The List of Models.
         """
         params = {"modelDetails": "true"}
@@ -236,14 +258,28 @@ class Client(_BaseClient):
             )
         ]
 
-    def list_files(self) -> list[File]:
+    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 = self._post(
+            f"https://api.anaplan.com/2/0/workspaces/{self._workspace_id}/bulkDeleteModels",
+            json={"modelIdsToDelete": model_ids},
+        )
+        return ModelDeletionResult.model_validate(res)
+
+    def get_files(self) -> list[File]:
         """
         Lists all the Files in the Model.
         :return: The List of Files.
         """
         return [File.model_validate(e) for e in self._get_paginated(f"{self._url}/files", "files")]
 
-    def list_actions(self) -> list[Action]:
+    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
@@ -254,7 +290,7 @@ class Client(_BaseClient):
             Action.model_validate(e) for e in self._get_paginated(f"{self._url}/actions", "actions")
         ]
 
-    def list_processes(self) -> list[Process]:
+    def get_processes(self) -> list[Process]:
         """
         Lists all the Processes in the Model.
         :return: The List of Processes.
@@ -264,7 +300,7 @@ class Client(_BaseClient):
             for e in self._get_paginated(f"{self._url}/processes", "processes")
         ]
 
-    def list_imports(self) -> list[Import]:
+    def get_imports(self) -> list[Import]:
         """
         Lists all the Imports in the Model.
         :return: The List of Imports.
@@ -273,7 +309,7 @@ class Client(_BaseClient):
             Import.model_validate(e) for e in self._get_paginated(f"{self._url}/imports", "imports")
         ]
 
-    def list_exports(self) -> list[Export]:
+    def get_exports(self) -> list[Export]:
         """
         Lists all the Exports in the Model.
         :return: The List of Exports.
@@ -282,33 +318,34 @@ class Client(_BaseClient):
             Export.model_validate(e) for e in (self._get(f"{self._url}/exports")).get("exports", [])
         ]
 
-    def run_action(self, action_id: int) -> TaskStatus:
+    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 = self.invoke_action(action_id)
-        task_status = self.get_task_status(action_id, task_id)
+        body = {"localeName": "en_US"}
+        res = 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":
-            time.sleep(self.status_poll_delay)
-            task_status = self.get_task_status(action_id, task_id)
+        if not wait_for_completion:
+            return TaskStatus.model_validate(self.get_task_status(action_id, task_id))
 
-        if task_status.task_state == "COMPLETE" and not task_status.result.successful:
+        while (status := self.get_task_status(action_id, task_id)).task_state != "COMPLETE":
+            sleep(self.status_poll_delay)
+
+        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 '{action_id}' completed successfully.")
+        return status
 
     def get_file(self, file_id: int) -> bytes:
         """
@@ -317,43 +354,53 @@ class Client(_BaseClient):
         :return: The content of the file.
         """
         chunk_count = self._file_pre_check(file_id)
+        logger.info(f"File {file_id} has {chunk_count} chunks.")
         if chunk_count <= 1:
             return self._get_binary(f"{self._url}/files/{file_id}")
-        logger.info(f"File {file_id} has {chunk_count} chunks.")
         with ThreadPoolExecutor(max_workers=self._thread_count) as executor:
             chunks = executor.map(
                 self._get_binary,
-                [f"{self._url}/files/{file_id}/chunks/{i}" for i in range(chunk_count)],
+                (f"{self._url}/files/{file_id}/chunks/{i}" for i in range(chunk_count)),
             )
             return b"".join(chunks)
 
-    def get_file_stream(self, file_id: int) -> Iterator[bytes]:
+    def get_file_stream(self, file_id: int, batch_size: int = 1) -> Iterator[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 = self._file_pre_check(file_id)
+        logger.info(f"File {file_id} has {chunk_count} chunks.")
         if chunk_count <= 1:
             yield 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 self._get_binary(f"{self._url}/files/{file_id}/chunks/{i}")
+
+        with ThreadPoolExecutor(max_workers=batch_size) as executor:
+            for batch_start in range(0, chunk_count, batch_size):
+                batch_chunks = executor.map(
+                    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
 
     def upload_file(self, file_id: int, content: str | bytes) -> None:
         """
-        Uploads the content to the specified file. If `upload_parallel` is set to True on the
-        instance you are invoking this from, will attempt to upload the chunks in parallel for
-        better performance. If you are network bound or are experiencing rate limiting issues, set
-        `upload_parallel` to False.
+        Uploads the content to the specified file. If there are several chunks, upload of
+        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()
@@ -361,7 +408,7 @@ class Client(_BaseClient):
             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.")
         self._set_chunk_count(file_id, len(chunks))
         if self.upload_parallel:
             with ThreadPoolExecutor(max_workers=self._thread_count) as executor:
@@ -371,23 +418,48 @@ class Client(_BaseClient):
         else:
             for index, chunk in enumerate(chunks):
                 self._upload_chunk(file_id, index, chunk)
+        logger.info(f"Completed upload for file '{file_id}'.")
 
-    def upload_file_stream(self, file_id: int, content: Iterator[bytes | str]) -> None:
+    def upload_file_stream(
+        self, file_id: int, content: 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
         large files where you don't want to or cannot load the entire file into memory at once, or
         if you simply do not know the number of chunks ahead of time and instead just want to pass
         on chunks i.e. consumed from a queue until it is exhausted. In this case, you can pass a
         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 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}.")
         self._set_chunk_count(file_id, -1)
-        for index, chunk in enumerate(content):
-            self._upload_chunk(file_id, index, chunk.encode() if isinstance(chunk, str) else chunk)
-
+        indices, chunks = [], []
+        with ThreadPoolExecutor(max_workers=batch_size) as executor:
+            for index, chunk in enumerate(content):
+                indices.append(index)
+                chunks.append(chunk)
+                if len(indices) == max(batch_size, 1):
+                    list(
+                        executor.map(self._upload_chunk, (file_id,) * len(indices), indices, chunks)
+                    )
+                    logger.info(
+                        f"Completed upload stream batch of size {batch_size} for file {file_id}."
+                    )
+                    indices, chunks = [], []
+
+            if indices:
+                executor.map(self._upload_chunk, (file_id,) * len(indices), indices, chunks)
+        logger.info(
+            f"Completed final upload stream batch of size {len(indices)} for file {file_id}."
+        )
         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}'.")
 
     def upload_and_import(self, file_id: int, content: str | bytes, action_id: int) -> None:
         """
@@ -412,7 +484,7 @@ class Client(_BaseClient):
         self.run_action(action_id)
         return self.get_file(action_id)
 
-    def list_task_status(self, action_id: int) -> list[TaskSummary]:
+    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.
@@ -449,34 +521,18 @@ class Client(_BaseClient):
             f"{self._url}/optimizeActions/{action_id}/tasks/{task_id}/solutionLogs"
         )
 
-    def invoke_action(self, action_id: int) -> str:
-        """
-        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.
-        """
-        response = self._post(
-            f"{self._url}/{action_url(action_id)}/{action_id}/tasks", json={"localeName": "en_US"}
-        )
-        task_id = response.get("task").get("taskId")
-        logger.info(f"Invoked Action '{action_id}', spawned Task: '{task_id}'.")
-        return task_id
-
     def _file_pre_check(self, file_id: int) -> int:
-        file = next(filter(lambda f: f.id == file_id, self.list_files()), None)
+        file = next((f for f in self.get_files() if f.id == file_id), None)
         if not file:
             raise InvalidIdentifierException(f"File {file_id} not found.")
         return file.chunk_count
 
-    def _upload_chunk(self, file_id: int, index: int, chunk: bytes) -> None:
-        self._put_binary_gzip(f"{self._url}/files/{file_id}/chunks/{index}", content=chunk)
-        logger.info(f"Chunk {index} loaded to file '{file_id}'.")
+    def _upload_chunk(self, file_id: int, index: int, chunk: str | bytes) -> None:
+        self._put_binary_gzip(f"{self._url}/files/{file_id}/chunks/{index}", chunk)
+        logger.debug(f"Chunk {index} loaded to file '{file_id}'.")
 
     def _set_chunk_count(self, file_id: int, num_chunks: int) -> None:
+        logger.debug(f"Setting chunk count for file '{file_id}' to {num_chunks}.")
         if not self.allow_file_creation and not (113000000000 <= file_id <= 113999999999):
             raise InvalidIdentifierException(
                 f"File with Id {file_id} does not exist. If you want to dynamically create files "

anaplan_sdk/_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 _FlowClient
 
+logger = logging.getLogger("anaplan_sdk")
+
 
 class _CloudWorksClient(_BaseClient):
     def __init__(self, client: httpx.Client, retry_count: int) -> None:
@@ -41,7 +44,7 @@ class _CloudWorksClient(_BaseClient):
         """
         return self._flow
 
-    def list_connections(self) -> list[Connection]:
+    def get_connections(self) -> list[Connection]:
         """
         List all Connections available in CloudWorks.
         :return: A list of connections.
@@ -62,7 +65,9 @@ class _CloudWorksClient(_BaseClient):
         res = 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
 
     def update_connection(self, con_id: str, con_info: ConnectionBody | dict[str, Any]) -> None:
         """
@@ -89,8 +94,9 @@ class _CloudWorksClient(_BaseClient):
         :param con_id: The ID of the connection to delete.
         """
         self._delete(f"{self._url}/connections/{con_id}")
+        logger.info(f"Deleted connection '{con_id}'.")
 
-    def list_integrations(
+    def get_integrations(
         self, sort_by_name: Literal["ascending", "descending"] = "ascending"
     ) -> list[Integration]:
         """
@@ -141,7 +147,9 @@ class _CloudWorksClient(_BaseClient):
         :return: The ID of the new integration.
         """
         json = integration_payload(body)
-        return (self._post(f"{self._url}", json=json))["integration"]["integrationId"]
+        integration_id = (self._post(f"{self._url}", json=json))["integration"]["integrationId"]
+        logger.info(f"Created integration '{integration_id}'.")
+        return integration_id
 
     def update_integration(
         self, integration_id: str, body: IntegrationInput | IntegrationProcessInput | dict[str, Any]
@@ -162,7 +170,9 @@ class _CloudWorksClient(_BaseClient):
         :param integration_id: The ID of the integration to run.
         :return: The ID of the run instance.
         """
-        return (self._post_empty(f"{self._url}/{integration_id}/run"))["run"]["id"]
+        run_id = (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
 
     def delete_integration(self, integration_id: str) -> None:
         """
@@ -170,6 +180,7 @@ class _CloudWorksClient(_BaseClient):
         :param integration_id: The ID of the integration to delete.
         """
         self._delete(f"{self._url}/{integration_id}")
+        logger.info(f"Deleted integration '{integration_id}'.")
 
     def get_run_history(self, integration_id: str) -> list[RunSummary]:
         """
@@ -216,6 +227,7 @@ class _CloudWorksClient(_BaseClient):
             f"{self._url}/{integration_id}/schedule",
             json=schedule_payload(integration_id, schedule),
         )
+        logger.info(f"Created schedule for integration '{integration_id}'.")
 
     def update_schedule(
         self, integration_id: str, schedule: ScheduleInput | dict[str, Any]
@@ -231,6 +243,7 @@ class _CloudWorksClient(_BaseClient):
             f"{self._url}/{integration_id}/schedule",
             json=schedule_payload(integration_id, schedule),
         )
+        logger.info(f"Updated schedule for integration '{integration_id}'.")
 
     def set_schedule_status(
         self, integration_id: str, status: Literal["enabled", "disabled"]
@@ -241,6 +254,7 @@ class _CloudWorksClient(_BaseClient):
         :param status: The status of the schedule. This can be either "enabled" or "disabled".
         """
         self._post_empty(f"{self._url}/{integration_id}/schedule/status/{status}")
+        logger.info(f"Set schedule status to '{status}' for integration '{integration_id}'.")
 
     def delete_schedule(self, integration_id: str) -> None:
         """
@@ -248,6 +262,7 @@ class _CloudWorksClient(_BaseClient):
         :param integration_id: The ID of the integration to schedule.
         """
         self._delete(f"{self._url}/{integration_id}/schedule")
+        logger.info(f"Deleted schedule for integration '{integration_id}'.")
 
     def get_notification_config(
         self, notification_id: str | None = None, integration_id: str | None = None
@@ -283,7 +298,9 @@ class _CloudWorksClient(_BaseClient):
         res = 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
 
     def update_notification_config(
         self, notification_id: str, config: NotificationInput | dict[str, Any]
@@ -318,6 +335,7 @@ class _CloudWorksClient(_BaseClient):
         if integration_id:
             notification_id = (self.get_integration(integration_id)).notification_id
         self._delete(f"{self._url}/notification/{notification_id}")
+        logger.info(f"Deleted notification configuration '{notification_id}'.")
 
     def get_import_error_dump(self, run_id: str) -> bytes:
         """

anaplan_sdk/_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 _BaseClient, construct_payload
 from anaplan_sdk.models.flows import Flow, FlowInput, FlowSummary
 
+logger = logging.getLogger("anaplan_sdk")
+
 
 class _FlowClient(_BaseClient):
     def __init__(self, client: httpx.Client, retry_count: int) -> None:
         self._url = "https://api.cloudworks.anaplan.com/2/0/integrationflows"
         super().__init__(retry_count, client)
 
-    def list_flows(self, current_user_only: bool = False) -> list[FlowSummary]:
+    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.
@@ -47,7 +50,9 @@ class _FlowClient(_BaseClient):
             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
 
     def create_flow(self, flow: FlowInput | dict[str, Any]) -> str:
         """
@@ -58,7 +63,9 @@ class _FlowClient(_BaseClient):
         :return: The ID of the created flow.
         """
         res = 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
 
     def update_flow(self, flow_id: str, flow: FlowInput | dict[str, Any]) -> None:
         """
@@ -68,6 +75,7 @@ class _FlowClient(_BaseClient):
         :param flow: The flow to update. This can be a FlowInput object or a dictionary.
         """
         self._put(f"{self._url}/{flow_id}", json=construct_payload(FlowInput, flow))
+        logger.info(f"Updated flow '{flow_id}'.")
 
     def delete_flow(self, flow_id: str) -> None:
         """
@@ -76,3 +84,4 @@ class _FlowClient(_BaseClient):
         :param flow_id: The ID of the flow to delete.
         """
         self._delete(f"{self._url}/{flow_id}")
+        logger.info(f"Deleted flow '{flow_id}'.")