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

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,
@@ -15,6 +15,7 @@ from anaplan_sdk.models import (
     File,
     Import,
     Model,
+    ModelDeletionResult,
     Process,
     TaskStatus,
     TaskSummary,
@@ -26,11 +27,10 @@ from ._audit import _AsyncAuditClient
 from ._cloud_works import _AsyncCloudWorksClient
 from ._transactional import _AsyncTransactionalClient
 
-logging.getLogger("httpx").setLevel(logging.CRITICAL)
 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,54 +97,60 @@ 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,
         )
-        self._retry_count = retry_count
+        _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._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
+            _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(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}"
-        client._transactional_client = _AsyncTransactionalClient(
-            existing._client, model_id, existing._retry_count
+        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._alm_client = _AsyncAlmClient(existing._client, model_id, existing._retry_count)
+        client._url = f"https://api.anaplan.com/2/0/workspaces/{new_ws_id}/models/{new_model_id}"
+        client._transactional_client = _AsyncTransactionalClient(existing._http, new_model_id)
+        client._alm_client = _AsyncAlmClient(existing._http, new_model_id)
         return client
 
     @property
@@ -159,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:
@@ -197,7 +208,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,
@@ -211,18 +222,18 @@ 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
             )
         ]
 
-    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"}
@@ -230,21 +241,36 @@ 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
             )
         ]
 
-    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._http.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.
         """
         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 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
@@ -253,66 +279,66 @@ 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 list_processes(self) -> list[Process]:
+    async def get_processes(self) -> list[Process]:
         """
         Lists all the Processes in the Model.
         :return: The List of Processes.
         """
         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 list_imports(self) -> list[Import]:
+    async def get_imports(self) -> list[Import]:
         """
         Lists all the Imports in the Model.
         :return: The List of Imports.
         """
         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 list_exports(self) -> list[Export]:
+    async def get_exports(self) -> list[Export]:
         """
         Lists all the Exports in the Model.
         :return: The List of Exports.
         """
         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) -> 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)
-
-        while task_status.task_state != "COMPLETE":
-            await sleep(self.status_poll_delay)
-            task_status = await self.get_task_status(action_id, task_id)
+        body = {"localeName": "en_US"}
+        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 task_status.task_state == "COMPLETE" and not task_status.result.successful:
+        if not wait_for_completion:
+            return TaskStatus.model_validate(await self.get_task_status(action_id, task_id))
+        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.")
             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 +347,71 @@ class AsyncClient(_AsyncBaseClient):
         :return: The content of the file.
         """
         chunk_count = await self._file_pre_check(file_id)
-        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.")
+        if chunk_count <= 1:
+            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)
-                ]
+                )
             )
         )
 
-    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}")
+            yield await self._http.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._http.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,38 +421,60 @@ 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._http.post(f"{self._url}/files/{file_id}/complete", json={"id": file_id})
+        logger.info(f"Completed upload stream for '{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}'.")
-
-    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:
         """
@@ -425,7 +486,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.
@@ -433,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"
             )
         ]
@@ -447,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")
         )
 
@@ -458,38 +521,19 @@ 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"
         )
 
-    async 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 = await 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
-
     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._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:
         if not self.allow_file_creation and not (113000000000 <= file_id <= 113999999999):
@@ -498,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: