anaplan-sdk 0.5.0a1__py3-none-any.whl → 0.5.0a2__py3-none-any.whl

anaplan_sdk/_async_clients/_alm.py

@@ -1,10 +1,7 @@
 import logging
-from asyncio import sleep
 from typing import Literal, overload
 
-import httpx
-
-from anaplan_sdk._base import _AsyncBaseClient
+from anaplan_sdk._services import _AsyncHttpService
 from anaplan_sdk.exceptions import AnaplanActionError
 from anaplan_sdk.models import (
     ModelRevision,
@@ -18,14 +15,11 @@ from anaplan_sdk.models import (
 logger = logging.getLogger("anaplan_sdk")
 
 
-class _AsyncAlmClient(_AsyncBaseClient):
-    def __init__(
-        self, client: httpx.AsyncClient, model_id: str, retry_count: int, status_poll_delay: int
-    ) -> None:
-        self.status_poll_delay = status_poll_delay
+class _AsyncAlmClient:
+    def __init__(self, http: _AsyncHttpService, model_id: str) -> None:
+        self._http = http
         self._model_id = model_id
         self._url = f"https://api.anaplan.com/2/0/models/{model_id}"
-        super().__init__(retry_count, client)
 
     async def change_model_status(self, status: Literal["online", "offline"]) -> None:
         """
@@ -33,14 +27,14 @@ class _AsyncAlmClient(_AsyncBaseClient):
         :param status: The status of the model. Can be either "online" or "offline".
         """
         logger.info(f"Changed model status to '{status}' for model {self._model_id}.")
-        await self._put(f"{self._url}/onlineStatus", json={"status": status})
+        await self._http.put(f"{self._url}/onlineStatus", json={"status": status})
 
     async def get_revisions(self) -> list[Revision]:
         """
         Use this call to return a list of revisions for a specific model.
         :return: A list of revisions for a specific model.
         """
-        res = await self._get(f"{self._url}/alm/revisions")
+        res = await self._http.get(f"{self._url}/alm/revisions")
         return [Revision.model_validate(e) for e in res.get("revisions", [])]
 
     async def get_latest_revision(self) -> Revision | None:
@@ -52,7 +46,7 @@ class _AsyncAlmClient(_AsyncBaseClient):
         latest revision.
         :return: The latest revision for a specific model, or None if no revisions exist.
         """
-        res = (await self._get(f"{self._url}/alm/latestRevision")).get("revisions")
+        res = (await self._http.get(f"{self._url}/alm/latestRevision")).get("revisions")
         return Revision.model_validate(res[0]) if res else None
 
     async def get_syncable_revisions(self, source_model_id: str) -> list[Revision]:
@@ -65,7 +59,9 @@ class _AsyncAlmClient(_AsyncBaseClient):
         :param source_model_id: The ID of the source model.
         :return: A list of revisions that can be synchronized to the target model.
         """
-        res = await self._get(f"{self._url}/alm/syncableRevisions?sourceModelId={source_model_id}")
+        res = await self._http.get(
+            f"{self._url}/alm/syncableRevisions?sourceModelId={source_model_id}"
+        )
         return [Revision.model_validate(e) for e in res.get("revisions", [])]
 
     async def create_revision(self, name: str, description: str) -> Revision:
@@ -75,7 +71,7 @@ class _AsyncAlmClient(_AsyncBaseClient):
         :param description: The description of the revision.
         :return: The created Revision Info.
         """
-        res = await self._post(
+        res = await self._http.post(
             f"{self._url}/alm/revisions", json={"name": name, "description": description}
         )
         rev = Revision.model_validate(res["revision"])
@@ -88,7 +84,7 @@ class _AsyncAlmClient(_AsyncBaseClient):
         they completed within the last 48 hours.
         :return: A list of sync tasks in descending order of creation time.
         """
-        res = await self._get(f"{self._url}/alm/syncTasks")
+        res = await self._http.get(f"{self._url}/alm/syncTasks")
         return [TaskSummary.model_validate(e) for e in res.get("tasks", [])]
 
     async def get_sync_task(self, task_id: str) -> SyncTask:
@@ -97,7 +93,7 @@ class _AsyncAlmClient(_AsyncBaseClient):
         :param task_id: The ID of the sync task.
         :return: The sync task information.
         """
-        res = await self._get(f"{self._url}/alm/syncTasks/{task_id}")
+        res = await self._http.get(f"{self._url}/alm/syncTasks/{task_id}")
         return SyncTask.model_validate(res["task"])
 
     async def sync_models(
@@ -123,7 +119,7 @@ class _AsyncAlmClient(_AsyncBaseClient):
             "sourceModelId": source_model_id,
             "targetRevisionId": target_revision_id,
         }
-        res = await self._post(f"{self._url}/alm/syncTasks", json=payload)
+        res = await self._http.post(f"{self._url}/alm/syncTasks", json=payload)
         task = await self.get_sync_task(res["task"]["taskId"])
         logger.info(
             f"Started sync task '{task.id}' from Model '{source_model_id}' "
@@ -131,8 +127,7 @@ class _AsyncAlmClient(_AsyncBaseClient):
         )
         if not wait_for_completion:
             return task
-        while (task := await self.get_sync_task(task.id)).task_state != "COMPLETE":
-            await sleep(self.status_poll_delay)
+        task = await self._http.poll_task(self.get_sync_task, task.id)
         if not task.result.successful:
             msg = f"Sync task {task.id} completed with errors: {task.result.error}."
             logger.error(msg)
@@ -147,7 +142,7 @@ class _AsyncAlmClient(_AsyncBaseClient):
         :param revision_id: The ID of the revision.
         :return: A list of models that had a specific revision applied to them.
         """
-        res = await self._get(f"{self._url}/alm/revisions/{revision_id}/appliedToModels")
+        res = await self._http.get(f"{self._url}/alm/revisions/{revision_id}/appliedToModels")
         return [ModelRevision.model_validate(e) for e in res.get("appliedToModels", [])]
 
     async def create_comparison_report(
@@ -172,7 +167,7 @@ class _AsyncAlmClient(_AsyncBaseClient):
             "sourceModelId": source_model_id,
             "targetRevisionId": target_revision_id,
         }
-        res = await self._post(f"{self._url}/alm/comparisonReportTasks", json=payload)
+        res = await self._http.post(f"{self._url}/alm/comparisonReportTasks", json=payload)
         task = await self.get_comparison_report_task(res["task"]["taskId"])
         logger.info(
             f"Started Comparison Report task '{task.id}' between Model '{source_model_id}' "
@@ -180,8 +175,7 @@ class _AsyncAlmClient(_AsyncBaseClient):
         )
         if not wait_for_completion:
             return task
-        while (task := await self.get_comparison_report_task(task.id)).task_state != "COMPLETE":
-            await sleep(self.status_poll_delay)
+        task = await self._http.poll_task(self.get_comparison_report_task, task.id)
         if not task.result.successful:
             msg = f"Comparison Report task {task.id} completed with errors: {task.result.error}."
             logger.error(msg)
@@ -195,7 +189,7 @@ class _AsyncAlmClient(_AsyncBaseClient):
         :param task_id: The ID of the comparison report task.
         :return: The report task information.
         """
-        res = await self._get(f"{self._url}/alm/comparisonReportTasks/{task_id}")
+        res = await self._http.get(f"{self._url}/alm/comparisonReportTasks/{task_id}")
         return ReportTask.model_validate(res["task"])
 
     async def get_comparison_report(self, task: ReportTask) -> bytes:
@@ -204,7 +198,7 @@ class _AsyncAlmClient(_AsyncBaseClient):
         :param task: The report task object containing the task ID.
         :return: The binary content of the comparison report.
         """
-        return await self._get_binary(
+        return await self._http.get_binary(
             f"{self._url}/alm/comparisonReports/"
             f"{task.result.target_revision_id}/{task.result.source_revision_id}"
         )
@@ -248,7 +242,7 @@ class _AsyncAlmClient(_AsyncBaseClient):
             "sourceModelId": source_model_id,
             "targetRevisionId": target_revision_id,
         }
-        res = await self._post(f"{self._url}/alm/summaryReportTasks", json=payload)
+        res = await self._http.post(f"{self._url}/alm/summaryReportTasks", json=payload)
         task = await self.get_comparison_summary_task(res["task"]["taskId"])
         logger.info(
             f"Started Comparison Summary task '{task.id}' between Model '{source_model_id}' "
@@ -256,8 +250,7 @@ class _AsyncAlmClient(_AsyncBaseClient):
         )
         if not wait_for_completion:
             return task
-        while (task := await self.get_comparison_summary_task(task.id)).task_state != "COMPLETE":
-            await sleep(self.status_poll_delay)
+        task = await self._http.poll_task(self.get_comparison_summary_task, task.id)
         if not task.result.successful:
             msg = f"Comparison Summary task {task.id} completed with errors: {task.result.error}."
             logger.error(msg)
@@ -271,7 +264,7 @@ class _AsyncAlmClient(_AsyncBaseClient):
         :param task_id: The ID of the comparison summary task.
         :return: The report task information.
         """
-        res = await self._get(f"{self._url}/alm/summaryReportTasks/{task_id}")
+        res = await self._http.get(f"{self._url}/alm/summaryReportTasks/{task_id}")
         return ReportTask.model_validate(res["task"])
 
     async def get_comparison_summary(self, task: ReportTask) -> SummaryReport:
@@ -280,7 +273,7 @@ class _AsyncAlmClient(_AsyncBaseClient):
         :param task: The summary task object containing the task ID.
         :return: The binary content of the comparison summary.
         """
-        res = await self._get(
+        res = await self._http.get(
             f"{self._url}/alm/summaryReports/"
             f"{task.result.target_revision_id}/{task.result.source_revision_id}"
         )

anaplan_sdk/_async_clients/_audit.py

@@ -1,18 +1,16 @@
 from typing import Any, Literal
 
-import httpx
-
-from anaplan_sdk._base import _AsyncBaseClient
+from anaplan_sdk._services import _AsyncHttpService
 from anaplan_sdk.models import User
 
 Event = Literal["all", "byok", "user_activity"]
 
 
-class _AsyncAuditClient(_AsyncBaseClient):
-    def __init__(self, client: httpx.AsyncClient, retry_count: int) -> None:
+class _AsyncAuditClient:
+    def __init__(self, http: _AsyncHttpService) -> None:
+        self._http = http
         self._limit = 10_000
         self._url = "https://audit.anaplan.com/audit/api/1/events"
-        super().__init__(retry_count, client)
 
     async def get_users(self, search_pattern: str | None = None) -> list[User]:
         """
@@ -26,7 +24,7 @@ class _AsyncAuditClient(_AsyncBaseClient):
         params = {"s": search_pattern} if search_pattern else None
         return [
             User.model_validate(e)
-            for e in await self._get_paginated(
+            for e in await self._http.get_paginated(
                 "https://api.anaplan.com/2/0/users", "users", params=params
             )
         ]
@@ -37,7 +35,7 @@ class _AsyncAuditClient(_AsyncBaseClient):
         :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")
+            (await self._http.get(f"https://api.anaplan.com/2/0/users/{user_id}")).get("user")
         )
 
     async def get_events(
@@ -51,7 +49,7 @@ class _AsyncAuditClient(_AsyncBaseClient):
         :return: A list of log entries, each containing a dictionary with event details.
         """
         return list(
-            await self._get_paginated(
+            await self._http.get_paginated(
                 self._url,
                 "response",
                 params={"type": event_type, "intervalInHours": days_into_past * 24},

anaplan_sdk/_async_clients/_bulk.py

@@ -1,5 +1,5 @@
 import logging
-from asyncio import gather, sleep
+from asyncio import gather
 from copy import copy
 from typing import AsyncIterator, Iterator
 
@@ -7,7 +7,7 @@ import httpx
 from typing_extensions import Self
 
 from anaplan_sdk._auth import _create_auth
-from anaplan_sdk._base import _AsyncBaseClient, action_url
+from anaplan_sdk._services import _AsyncHttpService, action_url
 from anaplan_sdk.exceptions import AnaplanActionError, InvalidIdentifierException
 from anaplan_sdk.models import (
     Action,
@@ -30,7 +30,7 @@ from ._transactional import _AsyncTransactionalClient
 logger = logging.getLogger("anaplan_sdk")
 
 
-class AsyncClient(_AsyncBaseClient):
+class AsyncClient:
     """
     Asynchronous Anaplan Client. For guides and examples
     refer to https://vinzenzklass.github.io/anaplan-sdk.
@@ -49,9 +49,11 @@ class AsyncClient(_AsyncBaseClient):
         auth: httpx.Auth | None = None,
         timeout: float | httpx.Timeout = 30,
         retry_count: int = 2,
+        page_size: int = 5_000,
         status_poll_delay: int = 1,
         upload_chunk_size: int = 25_000_000,
         allow_file_creation: bool = False,
+        **httpx_kwargs,
     ) -> None:
         """
         Asynchronous Anaplan Client. For guides and examples
@@ -84,6 +86,9 @@ class AsyncClient(_AsyncBaseClient):
         :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.
+        :param page_size: The number of items to return per page when paginating through results.
+               Defaults to 5000. This is the maximum number of items that can be returned per
+               request. If you pass a value greater than 5000, it will be capped to 5000.
         :param status_poll_delay: The delay between polling the status of a task.
         :param upload_chunk_size: The size of the chunks to upload. This is the maximum size of
                each chunk. Defaults to 25MB.
@@ -92,39 +97,31 @@ class AsyncClient(_AsyncBaseClient):
                altogether. A file that is created this way will not be referenced by any action in
                anaplan until manually assigned so there is typically no value in dynamically
                creating new files and uploading content to them.
-        """
-        _client = httpx.AsyncClient(
-            auth=(
-                auth
-                or _create_auth(
-                    token=token,
-                    user_email=user_email,
-                    password=password,
-                    certificate=certificate,
-                    private_key=private_key,
-                    private_key_password=private_key_password,
-                )
-            ),
-            timeout=timeout,
+        :param httpx_kwargs: Additional keyword arguments to pass to the `httpx.AsyncClient`.
+               This can be used to set additional options such as proxies, headers, etc. See
+               https://www.python-httpx.org/api/#asyncclient for the full list of arguments.
+        """
+        _auth = auth or _create_auth(
+            token=token,
+            user_email=user_email,
+            password=password,
+            certificate=certificate,
+            private_key=private_key,
+            private_key_password=private_key_password,
         )
+        _client = httpx.AsyncClient(auth=_auth, timeout=timeout, **httpx_kwargs)
+        self._http = _AsyncHttpService(_client, retry_count, page_size, status_poll_delay)
         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, status_poll_delay)
-            if model_id
-            else None
+            _AsyncTransactionalClient(self._http, model_id) if model_id else None
         )
-        self._audit = _AsyncAuditClient(_client, self._retry_count)
-        self._cloud_works = _AsyncCloudWorksClient(_client, self._retry_count)
-        self.status_poll_delay = status_poll_delay
+        self._alm_client = _AsyncAlmClient(self._http, model_id) if model_id else None
+        self._audit = _AsyncAuditClient(self._http)
+        self._cloud_works = _AsyncCloudWorksClient(self._http)
         self.upload_chunk_size = upload_chunk_size
         self.allow_file_creation = allow_file_creation
-        super().__init__(retry_count, _client)
 
     @classmethod
     def from_existing(
@@ -152,12 +149,8 @@ class AsyncClient(_AsyncBaseClient):
             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, new_model_id, existing._retry_count
-        )
-        client._alm_client = _AsyncAlmClient(
-            existing._client, new_model_id, existing._retry_count, existing.status_poll_delay
-        )
+        client._transactional_client = _AsyncTransactionalClient(existing._http, new_model_id)
+        client._alm_client = _AsyncAlmClient(existing._http, new_model_id)
         return client
 
     @property
@@ -177,14 +170,14 @@ class AsyncClient(_AsyncBaseClient):
         return self._cloud_works
 
     @property
-    def transactional(self) -> _AsyncTransactionalClient:
+    def tr(self) -> _AsyncTransactionalClient:
         """
         The Transactional Client provides access to the Anaplan Transactional API. This is useful
         for more advanced use cases where you need to interact with the Anaplan Model in a more
         granular way.
 
         If you instantiated the client without the field `model_id`, this will raise a
-        :py:class:`ValueError`, since none of the endpoints can be invoked without the model Id.
+        `ValueError`, since none of the endpoints can be invoked without the model Id.
         :return: The Transactional Client.
         """
         if not self._transactional_client:
@@ -229,7 +222,7 @@ class AsyncClient(_AsyncBaseClient):
             params["s"] = search_pattern
         return [
             Workspace.model_validate(e)
-            for e in await self._get_paginated(
+            for e in await self._http.get_paginated(
                 "https://api.anaplan.com/2/0/workspaces", "workspaces", params=params
             )
         ]
@@ -248,7 +241,7 @@ class AsyncClient(_AsyncBaseClient):
             params["s"] = search_pattern
         return [
             Model.model_validate(e)
-            for e in await self._get_paginated(
+            for e in await self._http.get_paginated(
                 "https://api.anaplan.com/2/0/models", "models", params=params
             )
         ]
@@ -261,7 +254,7 @@ class AsyncClient(_AsyncBaseClient):
         :return:
         """
         logger.info(f"Deleting Models: {', '.join(model_ids)}.")
-        res = await self._post(
+        res = await self._http.post(
             f"https://api.anaplan.com/2/0/workspaces/{self._workspace_id}/bulkDeleteModels",
             json={"modelIdsToDelete": model_ids},
         )
@@ -273,7 +266,8 @@ class AsyncClient(_AsyncBaseClient):
         :return: The List of Files.
         """
         return [
-            File.model_validate(e) for e in await self._get_paginated(f"{self._url}/files", "files")
+            File.model_validate(e)
+            for e in await self._http.get_paginated(f"{self._url}/files", "files")
         ]
 
     async def get_actions(self) -> list[Action]:
@@ -285,7 +279,7 @@ class AsyncClient(_AsyncBaseClient):
         """
         return [
             Action.model_validate(e)
-            for e in await self._get_paginated(f"{self._url}/actions", "actions")
+            for e in await self._http.get_paginated(f"{self._url}/actions", "actions")
         ]
 
     async def get_processes(self) -> list[Process]:
@@ -295,7 +289,7 @@ class AsyncClient(_AsyncBaseClient):
         """
         return [
             Process.model_validate(e)
-            for e in await self._get_paginated(f"{self._url}/processes", "processes")
+            for e in await self._http.get_paginated(f"{self._url}/processes", "processes")
         ]
 
     async def get_imports(self) -> list[Import]:
@@ -305,7 +299,7 @@ class AsyncClient(_AsyncBaseClient):
         """
         return [
             Import.model_validate(e)
-            for e in await self._get_paginated(f"{self._url}/imports", "imports")
+            for e in await self._http.get_paginated(f"{self._url}/imports", "imports")
         ]
 
     async def get_exports(self) -> list[Export]:
@@ -315,7 +309,7 @@ class AsyncClient(_AsyncBaseClient):
         """
         return [
             Export.model_validate(e)
-            for e in await self._get_paginated(f"{self._url}/exports", "exports")
+            for e in await self._http.get_paginated(f"{self._url}/exports", "exports")
         ]
 
     async def run_action(self, action_id: int, wait_for_completion: bool = True) -> TaskStatus:
@@ -330,18 +324,17 @@ class AsyncClient(_AsyncBaseClient):
                until the task is complete. If False, it will spawn the task and return immediately.
         """
         body = {"localeName": "en_US"}
-        res = await self._post(f"{self._url}/{action_url(action_id)}/{action_id}/tasks", json=body)
+        res = await self._http.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}'.")
 
         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)
-
+        status = await self._http.poll_task(self.get_task_status, action_id, task_id)
         if status.task_state == "COMPLETE" and not status.result.successful:
-            logger.error(f"Task '{task_id}' completed with errors: {status.result.error_message}")
+            logger.error(f"Task '{task_id}' completed with errors.")
             raise AnaplanActionError(f"Task '{task_id}' completed with errors.")
 
         logger.info(f"Task '{task_id}' of '{action_id}' completed successfully.")
@@ -356,11 +349,11 @@ class AsyncClient(_AsyncBaseClient):
         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}")
+            return await self._http.get_binary(f"{self._url}/files/{file_id}")
         return b"".join(
             await gather(
                 *(
-                    self._get_binary(f"{self._url}/files/{file_id}/chunks/{i}")
+                    self._http.get_binary(f"{self._url}/files/{file_id}/chunks/{i}")
                     for i in range(chunk_count)
                 )
             )
@@ -380,13 +373,13 @@ class AsyncClient(_AsyncBaseClient):
         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}")
+            yield await self._http.get_binary(f"{self._url}/files/{file_id}")
             return
 
         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}")
+                    self._http.get_binary(f"{self._url}/files/{file_id}/chunks/{i}")
                     for i in range(batch_start, min(batch_start + batch_size, chunk_count))
                 )
             )
@@ -462,21 +455,26 @@ class AsyncClient(_AsyncBaseClient):
             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})
+        await self._http.post(f"{self._url}/files/{file_id}/complete", json={"id": 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:
+    async def upload_and_import(
+        self, file_id: int, content: str | bytes, action_id: int, wait_for_completion: bool = True
+    ) -> TaskStatus:
         """
         Convenience wrapper around `upload_file()` and `run_action()` to upload content to a file
         and run an import action in one call.
         :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 to avoid redundant
+               work.**
         :param action_id: The identifier of the action to run after uploading the content.
+        :param wait_for_completion: If True, the method will poll the import task status and not
+               return until the task is complete. If False, it will spawn the import task and
+               return immediately.
         """
         await self.upload_file(file_id, content)
-        await self.run_action(action_id)
+        return await self.run_action(action_id, wait_for_completion)
 
     async def export_and_download(self, action_id: int) -> bytes:
         """
@@ -496,7 +494,7 @@ class AsyncClient(_AsyncBaseClient):
         """
         return [
             TaskSummary.model_validate(e)
-            for e in await self._get_paginated(
+            for e in await self._http.get_paginated(
                 f"{self._url}/{action_url(action_id)}/{action_id}/tasks", "tasks"
             )
         ]
@@ -510,7 +508,9 @@ class AsyncClient(_AsyncBaseClient):
         """
         return TaskStatus.model_validate(
             (
-                await self._get(f"{self._url}/{action_url(action_id)}/{action_id}/tasks/{task_id}")
+                await self._http.get(
+                    f"{self._url}/{action_url(action_id)}/{action_id}/tasks/{task_id}"
+                )
             ).get("task")
         )
 
@@ -521,7 +521,7 @@ class AsyncClient(_AsyncBaseClient):
         :param task_id: The Task identifier, sometimes also referred to as the Correlation Id.
         :return: The content of the solution logs.
         """
-        return await self._get_binary(
+        return await self._http.get_binary(
             f"{self._url}/optimizeActions/{action_id}/tasks/{task_id}/solutionLogs"
         )
 
@@ -532,7 +532,7 @@ class AsyncClient(_AsyncBaseClient):
         return file.chunk_count
 
     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)
+        await self._http.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:
@@ -542,7 +542,9 @@ class AsyncClient(_AsyncBaseClient):
                 "to avoid this error, set `allow_file_creation=True` on the calling instance. "
                 "Make sure you have understood the implications of this before doing so. "
             )
-        response = await self._post(f"{self._url}/files/{file_id}", json={"chunkCount": num_chunks})
+        response = await self._http.post(
+            f"{self._url}/files/{file_id}", json={"chunkCount": num_chunks}
+        )
         optionally_new_file = int(response.get("file").get("id"))
         if optionally_new_file != file_id:
             if self.allow_file_creation: