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

anaplan_sdk/_clients/_bulk.py

@@ -1,6 +1,5 @@
 import logging
 import multiprocessing
-import time
 from concurrent.futures import ThreadPoolExecutor
 from copy import copy
 from typing import Iterator
@@ -9,7 +8,7 @@ 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,
@@ -17,6 +16,7 @@ from anaplan_sdk.models import (
     File,
     Import,
     Model,
+    ModelDeletionResult,
     Process,
     TaskStatus,
     TaskSummary,
@@ -28,11 +28,10 @@ from ._audit import _AuditClient
 from ._cloud_works import _CloudWorksClient
 from ._transactional import _TransactionalClient
 
-logging.getLogger("httpx").setLevel(logging.CRITICAL)
 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,54 +100,64 @@ 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
+            _TransactionalClient(self._http, model_id) if model_id else None
         )
-        self._alm_client = _AlmClient(_client, model_id, self._retry_count) 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(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 = _TransactionalClient(
-            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 = _AlmClient(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 = _TransactionalClient(existing._http, new_model_id)
+        client._alm_client = _AlmClient(existing._http, new_model_id)
         return client
 
     @property
@@ -163,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:
@@ -201,7 +215,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
@@ -214,16 +228,18 @@ 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
             )
         ]
 
-    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"}
@@ -231,19 +247,35 @@ 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
             )
         ]
 
-    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._http.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")]
+        return [
+            File.model_validate(e) for e in self._http.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
@@ -251,64 +283,65 @@ 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 list_processes(self) -> list[Process]:
+    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 self._get_paginated(f"{self._url}/processes", "processes")
+            for e in self._http.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.
         """
         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 list_exports(self) -> list[Export]:
+    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 (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) -> 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)
-
-        while task_status.task_state != "COMPLETE":
-            time.sleep(self.status_poll_delay)
-            task_status = self.get_task_status(action_id, task_id)
+        body = {"localeName": "en_US"}
+        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 task_status.task_state == "COMPLETE" and not task_status.result.successful:
+        if not wait_for_completion:
+            return TaskStatus.model_validate(self.get_task_status(action_id, task_id))
+        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.")
             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 +350,53 @@ class Client(_BaseClient):
         :return: The content of the file.
         """
         chunk_count = self._file_pre_check(file_id)
-        if chunk_count <= 1:
-            return self._get_binary(f"{self._url}/files/{file_id}")
         logger.info(f"File {file_id} has {chunk_count} chunks.")
+        if chunk_count <= 1:
+            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,
-                [f"{self._url}/files/{file_id}/chunks/{i}" for i in range(chunk_count)],
+                self._http.get_binary,
+                (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}")
+            yield 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 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._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
 
     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 +404,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,36 +414,66 @@ 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)
-
-        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}'.")
+        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._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:
         """
@@ -412,7 +485,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.
@@ -420,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"
             )
         ]
@@ -433,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"
             )
         )
@@ -445,45 +518,29 @@ 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"
         )
 
-    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._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:
+        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 "
                 "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: