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

anaplan_sdk/_clients/_alm.py

@@ -1,10 +1,7 @@
 import logging
-from time import sleep
 from typing import Literal, overload
 
-import httpx
-
-from anaplan_sdk._base import _BaseClient
+from anaplan_sdk._services import _HttpService
 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 _AlmClient(_BaseClient):
-    def __init__(
-        self, client: httpx.Client, model_id: str, retry_count: int, status_poll_delay: int
-    ) -> None:
-        self.status_poll_delay = status_poll_delay
+class _AlmClient:
+    def __init__(self, http: _HttpService, 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)
 
     def change_model_status(self, status: Literal["online", "offline"]) -> None:
         """
@@ -33,14 +27,14 @@ class _AlmClient(_BaseClient):
         :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}.")
-        self._put(f"{self._url}/onlineStatus", json={"status": status})
+        self._http.put(f"{self._url}/onlineStatus", json={"status": status})
 
     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 = self._get(f"{self._url}/alm/revisions")
+        res = self._http.get(f"{self._url}/alm/revisions")
         return [Revision.model_validate(e) for e in res.get("revisions", [])]
 
     def get_latest_revision(self) -> Revision | None:
@@ -52,7 +46,7 @@ class _AlmClient(_BaseClient):
         latest revision.
         :return: The latest revision for a specific model, or None if no revisions exist.
         """
-        res = (self._get(f"{self._url}/alm/latestRevision")).get("revisions")
+        res = (self._http.get(f"{self._url}/alm/latestRevision")).get("revisions")
         return Revision.model_validate(res[0]) if res else None
 
     def get_syncable_revisions(self, source_model_id: str) -> list[Revision]:
@@ -65,7 +59,7 @@ class _AlmClient(_BaseClient):
         :param source_model_id: The ID of the source model.
         :return: A list of revisions that can be synchronized to the target model.
         """
-        res = self._get(f"{self._url}/alm/syncableRevisions?sourceModelId={source_model_id}")
+        res = self._http.get(f"{self._url}/alm/syncableRevisions?sourceModelId={source_model_id}")
         return [Revision.model_validate(e) for e in res.get("revisions", [])]
 
     def create_revision(self, name: str, description: str) -> Revision:
@@ -75,7 +69,7 @@ class _AlmClient(_BaseClient):
         :param description: The description of the revision.
         :return: The created Revision Info.
         """
-        res = self._post(
+        res = self._http.post(
             f"{self._url}/alm/revisions", json={"name": name, "description": description}
         )
         rev = Revision.model_validate(res["revision"])
@@ -88,7 +82,7 @@ class _AlmClient(_BaseClient):
         they completed within the last 48 hours.
         :return: A list of sync tasks in descending order of creation time.
         """
-        res = self._get(f"{self._url}/alm/syncTasks")
+        res = self._http.get(f"{self._url}/alm/syncTasks")
         return [TaskSummary.model_validate(e) for e in res.get("tasks", [])]
 
     def get_sync_task(self, task_id: str) -> SyncTask:
@@ -97,7 +91,7 @@ class _AlmClient(_BaseClient):
         :param task_id: The ID of the sync task.
         :return: The sync task information.
         """
-        res = self._get(f"{self._url}/alm/syncTasks/{task_id}")
+        res = self._http.get(f"{self._url}/alm/syncTasks/{task_id}")
         return SyncTask.model_validate(res["task"])
 
     def sync_models(
@@ -123,7 +117,7 @@ class _AlmClient(_BaseClient):
             "sourceModelId": source_model_id,
             "targetRevisionId": target_revision_id,
         }
-        res = self._post(f"{self._url}/alm/syncTasks", json=payload)
+        res = self._http.post(f"{self._url}/alm/syncTasks", json=payload)
         task = self.get_sync_task(res["task"]["taskId"])
         logger.info(
             f"Started sync task '{task.id}' from Model '{source_model_id}' "
@@ -131,8 +125,7 @@ class _AlmClient(_BaseClient):
         )
         if not wait_for_completion:
             return task
-        while (task := self.get_sync_task(task.id)).task_state != "COMPLETE":
-            sleep(self.status_poll_delay)
+        task = 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 +140,7 @@ class _AlmClient(_BaseClient):
         :param revision_id: The ID of the revision.
         :return: A list of models that had a specific revision applied to them.
         """
-        res = self._get(f"{self._url}/alm/revisions/{revision_id}/appliedToModels")
+        res = self._http.get(f"{self._url}/alm/revisions/{revision_id}/appliedToModels")
         return [ModelRevision.model_validate(e) for e in res.get("appliedToModels", [])]
 
     def create_comparison_report(
@@ -172,7 +165,7 @@ class _AlmClient(_BaseClient):
             "sourceModelId": source_model_id,
             "targetRevisionId": target_revision_id,
         }
-        res = self._post(f"{self._url}/alm/comparisonReportTasks", json=payload)
+        res = self._http.post(f"{self._url}/alm/comparisonReportTasks", json=payload)
         task = self.get_comparison_report_task(res["task"]["taskId"])
         logger.info(
             f"Started Comparison Report task '{task.id}' between Model '{source_model_id}' "
@@ -180,8 +173,7 @@ class _AlmClient(_BaseClient):
         )
         if not wait_for_completion:
             return task
-        while (task := self.get_comparison_report_task(task.id)).task_state != "COMPLETE":
-            sleep(self.status_poll_delay)
+        task = 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 +187,7 @@ class _AlmClient(_BaseClient):
         :param task_id: The ID of the comparison report task.
         :return: The report task information.
         """
-        res = self._get(f"{self._url}/alm/comparisonReportTasks/{task_id}")
+        res = self._http.get(f"{self._url}/alm/comparisonReportTasks/{task_id}")
         return ReportTask.model_validate(res["task"])
 
     def get_comparison_report(self, task: ReportTask) -> bytes:
@@ -204,7 +196,7 @@ class _AlmClient(_BaseClient):
         :param task: The report task object containing the task ID.
         :return: The binary content of the comparison report.
         """
-        return self._get_binary(
+        return self._http.get_binary(
             f"{self._url}/alm/comparisonReports/"
             f"{task.result.target_revision_id}/{task.result.source_revision_id}"
         )
@@ -248,7 +240,7 @@ class _AlmClient(_BaseClient):
             "sourceModelId": source_model_id,
             "targetRevisionId": target_revision_id,
         }
-        res = self._post(f"{self._url}/alm/summaryReportTasks", json=payload)
+        res = self._http.post(f"{self._url}/alm/summaryReportTasks", json=payload)
         task = self.get_comparison_summary_task(res["task"]["taskId"])
         logger.info(
             f"Started Comparison Summary task '{task.id}' between Model '{source_model_id}' "
@@ -256,8 +248,7 @@ class _AlmClient(_BaseClient):
         )
         if not wait_for_completion:
             return task
-        while (task := self.get_comparison_summary_task(task.id)).task_state != "COMPLETE":
-            sleep(self.status_poll_delay)
+        task = 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 +262,7 @@ class _AlmClient(_BaseClient):
         :param task_id: The ID of the comparison summary task.
         :return: The report task information.
         """
-        res = self._get(f"{self._url}/alm/summaryReportTasks/{task_id}")
+        res = self._http.get(f"{self._url}/alm/summaryReportTasks/{task_id}")
         return ReportTask.model_validate(res["task"])
 
     def get_comparison_summary(self, task: ReportTask) -> SummaryReport:
@@ -280,7 +271,7 @@ class _AlmClient(_BaseClient):
         :param task: The summary task object containing the task ID.
         :return: The binary content of the comparison summary.
         """
-        res = self._get(
+        res = self._http.get(
             f"{self._url}/alm/summaryReports/"
             f"{task.result.target_revision_id}/{task.result.source_revision_id}"
         )

anaplan_sdk/_clients/_audit.py

@@ -1,19 +1,16 @@
 from typing import Any, Literal
 
-import httpx
-
-from anaplan_sdk._base import _BaseClient
+from anaplan_sdk._services import _HttpService
 from anaplan_sdk.models import User
 
 Event = Literal["all", "byok", "user_activity"]
 
 
-class _AuditClient(_BaseClient):
-    def __init__(self, client: httpx.Client, retry_count: int, thread_count: int) -> None:
+class _AuditClient:
+    def __init__(self, http: _HttpService) -> None:
+        self._http = http
         self._limit = 10_000
-        self._thread_count = thread_count
         self._url = "https://audit.anaplan.com/audit/api/1/events"
-        super().__init__(retry_count, client)
 
     def get_users(self, search_pattern: str | None = None) -> list[User]:
         """
@@ -25,7 +22,7 @@ class _AuditClient(_BaseClient):
         params = {"s": search_pattern} if search_pattern else None
         return [
             User.model_validate(e)
-            for e in self._get_paginated(
+            for e in self._http.get_paginated(
                 "https://api.anaplan.com/2/0/users", "users", params=params
             )
         ]
@@ -36,7 +33,7 @@ class _AuditClient(_BaseClient):
         :return: The requested or currently authenticated User.
         """
         return User.model_validate(
-            self._get(f"https://api.anaplan.com/2/0/users/{user_id}").get("user")
+            self._http.get(f"https://api.anaplan.com/2/0/users/{user_id}").get("user")
         )
 
     def get_events(
@@ -50,7 +47,7 @@ class _AuditClient(_BaseClient):
         :return: A list of log entries, each containing a dictionary with event details.
         """
         return list(
-            self._get_paginated(
+            self._http.get_paginated(
                 self._url,
                 "response",
                 params={"type": event_type, "intervalInHours": days_into_past * 24},

anaplan_sdk/_clients/_bulk.py

@@ -2,14 +2,13 @@ import logging
 import multiprocessing
 from concurrent.futures import ThreadPoolExecutor
 from copy import copy
-from time import sleep
 from typing import Iterator
 
 import httpx
 from typing_extensions import Self
 
 from anaplan_sdk._auth import _create_auth
-from anaplan_sdk._base import _BaseClient, action_url
+from anaplan_sdk._services import _HttpService, action_url
 from anaplan_sdk.exceptions import AnaplanActionError, InvalidIdentifierException
 from anaplan_sdk.models import (
     Action,
@@ -32,7 +31,7 @@ from ._transactional import _TransactionalClient
 logger = logging.getLogger("anaplan_sdk")
 
 
-class Client(_BaseClient):
+class Client:
     """
     Synchronous Anaplan Client. For guides and examples
     refer to https://vinzenzklass.github.io/anaplan-sdk.
@@ -51,10 +50,12 @@ class Client(_BaseClient):
         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_parallel: bool = True,
         upload_chunk_size: int = 25_000_000,
         allow_file_creation: bool = False,
+        **httpx_kwargs,
     ) -> None:
         """
         Synchronous Anaplan Client. For guides and examples
@@ -87,6 +88,9 @@ class Client(_BaseClient):
         :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_parallel: Whether to upload chunks in parallel when uploading files.
         :param upload_chunk_size: The size of the chunks to upload. This is the maximum size of
@@ -96,41 +100,35 @@ class Client(_BaseClient):
                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.Client(
-            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.Client`.
+               This can be used to set additional options such as proxies, headers, etc. See
+               https://www.python-httpx.org/api/#client 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.Client(auth=auth, timeout=timeout, **httpx_kwargs)
+        self._http = _HttpService(_client, retry_count, page_size, status_poll_delay)
         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, status_poll_delay)
-            if model_id
-            else None
+            _TransactionalClient(self._http, model_id) if model_id else None
         )
-        self._cloud_works = _CloudWorksClient(_client, self._retry_count)
+        self._alm_client = _AlmClient(self._http, model_id) if model_id else None
+        self._cloud_works = _CloudWorksClient(self._http)
         self._thread_count = multiprocessing.cpu_count()
-        self._audit = _AuditClient(_client, self._retry_count, self._thread_count)
+        self._audit = _AuditClient(self._http)
         self.status_poll_delay = status_poll_delay
         self.upload_parallel = upload_parallel
         self.upload_chunk_size = upload_chunk_size
         self.allow_file_creation = allow_file_creation
-        super().__init__(self._retry_count, _client)
 
     @classmethod
     def from_existing(
@@ -158,12 +156,8 @@ class Client(_BaseClient):
             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, new_model_id, existing._retry_count
-        )
-        client._alm_client = _AlmClient(
-            existing._client, new_model_id, existing._retry_count, existing.status_poll_delay
-        )
+        client._transactional_client = _TransactionalClient(existing._http, new_model_id)
+        client._alm_client = _AlmClient(existing._http, new_model_id)
         return client
 
     @property
@@ -183,14 +177,14 @@ class Client(_BaseClient):
         return self._cloud_works
 
     @property
-    def transactional(self) -> _TransactionalClient:
+    def tr(self) -> _TransactionalClient:
         """
         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:
@@ -234,7 +228,7 @@ class Client(_BaseClient):
             params["s"] = search_pattern
         return [
             Workspace.model_validate(e)
-            for e in self._get_paginated(
+            for e in self._http.get_paginated(
                 "https://api.anaplan.com/2/0/workspaces", "workspaces", params=params
             )
         ]
@@ -253,7 +247,7 @@ class Client(_BaseClient):
             params["s"] = search_pattern
         return [
             Model.model_validate(e)
-            for e in self._get_paginated(
+            for e in self._http.get_paginated(
                 "https://api.anaplan.com/2/0/models", "models", params=params
             )
         ]
@@ -266,7 +260,7 @@ class Client(_BaseClient):
         :return:
         """
         logger.info(f"Deleting Models: {', '.join(model_ids)}.")
-        res = self._post(
+        res = self._http.post(
             f"https://api.anaplan.com/2/0/workspaces/{self._workspace_id}/bulkDeleteModels",
             json={"modelIdsToDelete": model_ids},
         )
@@ -277,7 +271,9 @@ class Client(_BaseClient):
         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")]
+        return [
+            File.model_validate(e) for e in self._http.get_paginated(f"{self._url}/files", "files")
+        ]
 
     def get_actions(self) -> list[Action]:
         """
@@ -287,7 +283,8 @@ class Client(_BaseClient):
         :return: The List of Actions.
         """
         return [
-            Action.model_validate(e) for e in self._get_paginated(f"{self._url}/actions", "actions")
+            Action.model_validate(e)
+            for e in self._http.get_paginated(f"{self._url}/actions", "actions")
         ]
 
     def get_processes(self) -> list[Process]:
@@ -297,7 +294,7 @@ class Client(_BaseClient):
         """
         return [
             Process.model_validate(e)
-            for e in self._get_paginated(f"{self._url}/processes", "processes")
+            for e in self._http.get_paginated(f"{self._url}/processes", "processes")
         ]
 
     def get_imports(self) -> list[Import]:
@@ -306,7 +303,8 @@ class Client(_BaseClient):
         :return: The List of Imports.
         """
         return [
-            Import.model_validate(e) for e in self._get_paginated(f"{self._url}/imports", "imports")
+            Import.model_validate(e)
+            for e in self._http.get_paginated(f"{self._url}/imports", "imports")
         ]
 
     def get_exports(self) -> list[Export]:
@@ -315,7 +313,8 @@ class Client(_BaseClient):
         :return: The List of Exports.
         """
         return [
-            Export.model_validate(e) for e in (self._get(f"{self._url}/exports")).get("exports", [])
+            Export.model_validate(e)
+            for e in (self._http.get(f"{self._url}/exports")).get("exports", [])
         ]
 
     def run_action(self, action_id: int, wait_for_completion: bool = True) -> TaskStatus:
@@ -330,18 +329,15 @@ class Client(_BaseClient):
                until the task is complete. If False, it will spawn the task and return immediately.
         """
         body = {"localeName": "en_US"}
-        res = self._post(f"{self._url}/{action_url(action_id)}/{action_id}/tasks", json=body)
+        res = 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(self.get_task_status(action_id, task_id))
-
-        while (status := self.get_task_status(action_id, task_id)).task_state != "COMPLETE":
-            sleep(self.status_poll_delay)
-
+        status = 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 '{action_id}' completed successfully.")
@@ -356,10 +352,10 @@ class Client(_BaseClient):
         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}")
+            return self._http.get_binary(f"{self._url}/files/{file_id}")
         with ThreadPoolExecutor(max_workers=self._thread_count) as executor:
             chunks = executor.map(
-                self._get_binary,
+                self._http.get_binary,
                 (f"{self._url}/files/{file_id}/chunks/{i}" for i in range(chunk_count)),
             )
             return b"".join(chunks)
@@ -378,13 +374,13 @@ class Client(_BaseClient):
         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}")
+            yield self._http.get_binary(f"{self._url}/files/{file_id}")
             return
 
         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,
+                    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))
@@ -458,21 +454,26 @@ class Client(_BaseClient):
         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})
+        self._http.post(f"{self._url}/files/{file_id}/complete", json={"id": 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:
+    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.
         """
         self.upload_file(file_id, content)
-        self.run_action(action_id)
+        return self.run_action(action_id, wait_for_completion)
 
     def export_and_download(self, action_id: int) -> bytes:
         """
@@ -492,7 +493,7 @@ class Client(_BaseClient):
         """
         return [
             TaskSummary.model_validate(e)
-            for e in self._get_paginated(
+            for e in self._http.get_paginated(
                 f"{self._url}/{action_url(action_id)}/{action_id}/tasks", "tasks"
             )
         ]
@@ -505,7 +506,7 @@ class Client(_BaseClient):
         :return: The status of the task.
         """
         return TaskStatus.model_validate(
-            self._get(f"{self._url}/{action_url(action_id)}/{action_id}/tasks/{task_id}").get(
+            self._http.get(f"{self._url}/{action_url(action_id)}/{action_id}/tasks/{task_id}").get(
                 "task"
             )
         )
@@ -517,7 +518,7 @@ class Client(_BaseClient):
         :param task_id: The Task identifier, sometimes also referred to as the Correlation Id.
         :return: The content of the solution logs.
         """
-        return self._get_binary(
+        return self._http.get_binary(
             f"{self._url}/optimizeActions/{action_id}/tasks/{task_id}/solutionLogs"
         )
 
@@ -528,7 +529,7 @@ class Client(_BaseClient):
         return file.chunk_count
 
     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)
+        self._http.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:
@@ -539,7 +540,7 @@ class Client(_BaseClient):
                 "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 = self._post(f"{self._url}/files/{file_id}", json={"chunkCount": num_chunks})
+        response = 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: