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

anaplan_sdk/_async_clients/_cloud_works.py

@@ -1,10 +1,8 @@
 import logging
 from typing import Any, Literal
 
-import httpx
-
-from anaplan_sdk._base import (
-    _AsyncBaseClient,
+from anaplan_sdk._services import (
+    _AsyncHttpService,
     connection_body_payload,
     construct_payload,
     integration_payload,
@@ -31,11 +29,11 @@ from ._cw_flow import _AsyncFlowClient
 logger = logging.getLogger("anaplan_sdk")
 
 
-class _AsyncCloudWorksClient(_AsyncBaseClient):
-    def __init__(self, client: httpx.AsyncClient, retry_count: int) -> None:
+class _AsyncCloudWorksClient:
+    def __init__(self, http: _AsyncHttpService) -> None:
+        self._http = http
         self._url = "https://api.cloudworks.anaplan.com/2/0/integrations"
-        self._flow = _AsyncFlowClient(client, retry_count)
-        super().__init__(retry_count, client)
+        self._flow = _AsyncFlowClient(http)
 
     @property
     def flows(self) -> _AsyncFlowClient:
@@ -51,7 +49,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         """
         return [
             Connection.model_validate(e)
-            for e in await self._get_paginated(f"{self._url}/connections", "connections")
+            for e in await self._http.get_paginated(f"{self._url}/connections", "connections")
         ]
 
     async def create_connection(self, con_info: ConnectionInput | dict[str, Any]) -> str:
@@ -62,7 +60,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
                against the ConnectionInput model before sending the request.
         :return: The ID of the new connection.
         """
-        res = await self._post(
+        res = await self._http.post(
             f"{self._url}/connections", json=construct_payload(ConnectionInput, con_info)
         )
         connection_id = res["connections"]["connectionId"]
@@ -79,7 +77,9 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
                as when initially creating the connection again. If you want to update only some of
                the details, use the `patch_connection` method instead.
         """
-        await self._put(f"{self._url}/connections/{con_id}", json=connection_body_payload(con_info))
+        await self._http.put(
+            f"{self._url}/connections/{con_id}", json=connection_body_payload(con_info)
+        )
 
     async def patch_connection(self, con_id: str, body: dict[str, Any]) -> None:
         """
@@ -88,14 +88,14 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :param body: The name and details of the connection. You can pass all the same details as
                when initially creating the connection again, or just any one of them.
         """
-        await self._patch(f"{self._url}/connections/{con_id}", json=body)
+        await self._http.patch(f"{self._url}/connections/{con_id}", json=body)
 
     async def delete_connection(self, con_id: str) -> None:
         """
         Delete an existing connection in CloudWorks.
         :param con_id: The ID of the connection to delete.
         """
-        await self._delete(f"{self._url}/connections/{con_id}")
+        await self._http.delete(f"{self._url}/connections/{con_id}")
         logger.info(f"Deleted connection '{con_id}'.")
 
     async def get_integrations(
@@ -109,7 +109,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         params = {"sortBy": "name" if sort_by_name == "ascending" else "-name"}
         return [
             Integration.model_validate(e)
-            for e in await self._get_paginated(f"{self._url}", "integrations", params=params)
+            for e in await self._http.get_paginated(f"{self._url}", "integrations", params=params)
         ]
 
     async def get_integration(self, integration_id: str) -> SingleIntegration:
@@ -122,7 +122,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :return: The details of the integration, without the integration type.
         """
         return SingleIntegration.model_validate(
-            (await self._get(f"{self._url}/{integration_id}"))["integration"]
+            (await self._http.get(f"{self._url}/{integration_id}"))["integration"]
         )
 
     async def create_integration(
@@ -149,7 +149,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :return: The ID of the new integration.
         """
         json = integration_payload(body)
-        res = await self._post(f"{self._url}", json=json)
+        res = await self._http.post(f"{self._url}", json=json)
         integration_id = res["integration"]["integrationId"]
         logger.info(f"Created integration '{integration_id}'.")
         return integration_id
@@ -165,7 +165,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
                of the details, use the `patch_integration` method instead.
         """
         json = integration_payload(body)
-        await self._put(f"{self._url}/{integration_id}", json=json)
+        await self._http.put(f"{self._url}/{integration_id}", json=json)
 
     async def run_integration(self, integration_id: str) -> str:
         """
@@ -173,7 +173,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :param integration_id: The ID of the integration to run.
         :return: The ID of the run instance.
         """
-        run_id = (await self._post_empty(f"{self._url}/{integration_id}/run"))["run"]["id"]
+        run_id = (await self._http.post_empty(f"{self._url}/{integration_id}/run"))["run"]["id"]
         logger.info(f"Started integration run '{run_id}' for integration '{integration_id}'.")
         return run_id
 
@@ -182,7 +182,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         Delete an existing integration in CloudWorks.
         :param integration_id: The ID of the integration to delete.
         """
-        await self._delete(f"{self._url}/{integration_id}")
+        await self._http.delete(f"{self._url}/{integration_id}")
         logger.info(f"Deleted integration '{integration_id}'.")
 
     async def get_run_history(self, integration_id: str) -> list[RunSummary]:
@@ -193,9 +193,9 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         """
         return [
             RunSummary.model_validate(e)
-            for e in (await self._get(f"{self._url}/runs/{integration_id}"))["history_of_runs"].get(
-                "runs", []
-            )
+            for e in (await self._http.get(f"{self._url}/runs/{integration_id}"))[
+                "history_of_runs"
+            ].get("runs", [])
         ]
 
     async def get_run_status(self, run_id: str) -> RunStatus:
@@ -204,7 +204,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :param run_id: The ID of the run to retrieve.
         :return: The details of the run.
         """
-        return RunStatus.model_validate((await self._get(f"{self._url}/run/{run_id}"))["run"])
+        return RunStatus.model_validate((await self._http.get(f"{self._url}/run/{run_id}"))["run"])
 
     async def get_run_error(self, run_id: str) -> RunError | None:
         """
@@ -213,7 +213,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :param run_id: The ID of the run to retrieve.
         :return: The details of the run error.
         """
-        run = await self._get(f"{self._url}/runerror/{run_id}")
+        run = await self._http.get(f"{self._url}/runerror/{run_id}")
         return RunError.model_validate(run["runs"]) if run.get("runs") else None
 
     async def create_schedule(
@@ -226,7 +226,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
                dictionary as per the documentation. If a dictionary is passed, it will be validated
                against the ScheduleInput model before sending the request.
         """
-        await self._post(
+        await self._http.post(
             f"{self._url}/{integration_id}/schedule",
             json=schedule_payload(integration_id, schedule),
         )
@@ -242,7 +242,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
                dictionary as per the documentation. If a dictionary is passed, it will be validated
                against the ScheduleInput model before sending the request.
         """
-        await self._put(
+        await self._http.put(
             f"{self._url}/{integration_id}/schedule",
             json=schedule_payload(integration_id, schedule),
         )
@@ -255,14 +255,14 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :param integration_id: The ID of the integration to schedule.
         :param status: The status of the schedule. This can be either "enabled" or "disabled".
         """
-        await self._post_empty(f"{self._url}/{integration_id}/schedule/status/{status}")
+        await self._http.post_empty(f"{self._url}/{integration_id}/schedule/status/{status}")
 
     async def delete_schedule(self, integration_id: str) -> None:
         """
         Delete an integration schedule in CloudWorks. A schedule must already exist.
         :param integration_id: The ID of the integration to schedule.
         """
-        await self._delete(f"{self._url}/{integration_id}/schedule")
+        await self._http.delete(f"{self._url}/{integration_id}/schedule")
         logger.info(f"Deleted schedule for integration '{integration_id}'.")
 
     async def get_notification_config(
@@ -282,7 +282,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         if integration_id:
             notification_id = (await self.get_integration(integration_id)).notification_id
         return NotificationConfig.model_validate(
-            (await self._get(f"{self._url}/notification/{notification_id}"))["notifications"]
+            (await self._http.get(f"{self._url}/notification/{notification_id}"))["notifications"]
         )
 
     async def create_notification_config(self, config: NotificationInput | dict[str, Any]) -> str:
@@ -296,7 +296,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
                validated against the NotificationConfig model before sending the request.
         :return: The ID of the new notification configuration.
         """
-        res = await self._post(
+        res = await self._http.post(
             f"{self._url}/notification", json=construct_payload(NotificationInput, config)
         )
         notification_id = res["notification"]["notificationId"]
@@ -316,7 +316,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
                a dictionary as per the documentation. If a dictionary is passed, it will be
                validated against the NotificationConfig model before sending the request.
         """
-        await self._put(
+        await self._http.put(
             f"{self._url}/notification/{notification_id}",
             json=construct_payload(NotificationInput, config),
         )
@@ -335,7 +335,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
             raise ValueError("Either notification_id or integration_id must be specified.")
         if integration_id:
             notification_id = (await self.get_integration(integration_id)).notification_id
-        await self._delete(f"{self._url}/notification/{notification_id}")
+        await self._http.delete(f"{self._url}/notification/{notification_id}")
         logger.info(f"Deleted notification configuration '{notification_id}'.")
 
     async def get_import_error_dump(self, run_id: str) -> bytes:
@@ -348,7 +348,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :param run_id: The ID of the run to retrieve.
         :return: The error dump.
         """
-        return await self._get_binary(f"{self._url}/run/{run_id}/dump")
+        return await self._http.get_binary(f"{self._url}/run/{run_id}/dump")
 
     async def get_process_error_dump(self, run_id: str, action_id: int | str) -> bytes:
         """
@@ -358,4 +358,6 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :param action_id: The ID of the action to retrieve. This can be found in the RunError.
         :return: The error dump.
         """
-        return await self._get_binary(f"{self._url}/run/{run_id}/process/import/{action_id}/dumps")
+        return await self._http.get_binary(
+            f"{self._url}/run/{run_id}/process/import/{action_id}/dumps"
+        )

anaplan_sdk/_async_clients/_cw_flow.py

@@ -1,18 +1,16 @@
 import logging
 from typing import Any
 
-import httpx
-
-from anaplan_sdk._base import _AsyncBaseClient, construct_payload
+from anaplan_sdk._services import _AsyncHttpService, construct_payload
 from anaplan_sdk.models.flows import Flow, FlowInput, FlowSummary
 
 logger = logging.getLogger("anaplan_sdk")
 
 
-class _AsyncFlowClient(_AsyncBaseClient):
-    def __init__(self, client: httpx.AsyncClient, retry_count: int) -> None:
+class _AsyncFlowClient:
+    def __init__(self, http: _AsyncHttpService) -> None:
+        self._http = http
         self._url = "https://api.cloudworks.anaplan.com/2/0/integrationflows"
-        super().__init__(retry_count, client)
 
     async def get_flows(self, current_user_only: bool = False) -> list[FlowSummary]:
         """
@@ -23,9 +21,7 @@ class _AsyncFlowClient(_AsyncBaseClient):
         params = {"myIntegrations": 1 if current_user_only else 0}
         return [
             FlowSummary.model_validate(e)
-            for e in await self._get_paginated(
-                self._url, "integrationFlows", page_size=25, params=params
-            )
+            for e in await self._http.get_paginated(self._url, "integrationFlows", params=params)
         ]
 
     async def get_flow(self, flow_id: str) -> Flow:
@@ -35,7 +31,9 @@ class _AsyncFlowClient(_AsyncBaseClient):
         :param flow_id: The ID of the flow to get.
         :return: The Flow object.
         """
-        return Flow.model_validate((await self._get(f"{self._url}/{flow_id}"))["integrationFlow"])
+        return Flow.model_validate(
+            (await self._http.get(f"{self._url}/{flow_id}"))["integrationFlow"]
+        )
 
     async def run_flow(self, flow_id: str, only_steps: list[str] = None) -> str:
         """
@@ -48,9 +46,9 @@ class _AsyncFlowClient(_AsyncBaseClient):
         """
         url = f"{self._url}/{flow_id}/run"
         res = await (
-            self._post(url, json={"stepsToRun": only_steps})
+            self._http.post(url, json={"stepsToRun": only_steps})
             if only_steps
-            else self._post_empty(url)
+            else self._http.post_empty(url)
         )
         run_id = res["run"]["id"]
         logger.info(f"Started flow run '{run_id}' for flow '{flow_id}'.")
@@ -64,7 +62,7 @@ class _AsyncFlowClient(_AsyncBaseClient):
         :param flow: The flow to create. This can be a FlowInput object or a dictionary.
         :return: The ID of the created flow.
         """
-        res = await self._post(self._url, json=construct_payload(FlowInput, flow))
+        res = await self._http.post(self._url, json=construct_payload(FlowInput, flow))
         flow_id = res["integrationFlow"]["integrationFlowId"]
         logger.info(f"Created flow '{flow_id}'.")
         return flow_id
@@ -76,7 +74,7 @@ class _AsyncFlowClient(_AsyncBaseClient):
         :param flow_id: The ID of the flow to update.
         :param flow: The flow to update. This can be a FlowInput object or a dictionary.
         """
-        await self._put(f"{self._url}/{flow_id}", json=construct_payload(FlowInput, flow))
+        await self._http.put(f"{self._url}/{flow_id}", json=construct_payload(FlowInput, flow))
         logger.info(f"Updated flow '{flow_id}'.")
 
     async def delete_flow(self, flow_id: str) -> None:
@@ -85,5 +83,5 @@ class _AsyncFlowClient(_AsyncBaseClient):
         the flow is running or if it has any running steps.
         :param flow_id: The ID of the flow to delete.
         """
-        await self._delete(f"{self._url}/{flow_id}")
+        await self._http.delete(f"{self._url}/{flow_id}")
         logger.info(f"Deleted flow '{flow_id}'.")

anaplan_sdk/_async_clients/_transactional.py

@@ -3,12 +3,11 @@ from asyncio import gather
 from itertools import chain
 from typing import Any, Literal, overload
 
-import httpx
-
-from anaplan_sdk._base import (
-    _AsyncBaseClient,
+from anaplan_sdk._services import (
+    _AsyncHttpService,
     parse_calendar_response,
     parse_insertion_response,
+    sort_params,
     validate_dimension_id,
 )
 from anaplan_sdk.exceptions import InvalidIdentifierException
@@ -20,6 +19,7 @@ from anaplan_sdk.models import (
     InsertionResult,
     LineItem,
     List,
+    ListDeletionResult,
     ListItem,
     ListMetadata,
     Model,
@@ -29,23 +29,22 @@ from anaplan_sdk.models import (
     View,
     ViewInfo,
 )
-from anaplan_sdk.models._transactional import ListDeletionResult
 
 logger = logging.getLogger("anaplan_sdk")
 
 
-class _AsyncTransactionalClient(_AsyncBaseClient):
-    def __init__(self, client: httpx.AsyncClient, model_id: str, retry_count: int) -> None:
+class _AsyncTransactionalClient:
+    def __init__(self, http: _AsyncHttpService, model_id: str) -> None:
+        self._http = http
         self._url = f"https://api.anaplan.com/2/0/models/{model_id}"
         self._model_id = model_id
-        super().__init__(retry_count, client)
 
     async def get_model_details(self) -> Model:
         """
         Retrieves the Model details for the current Model.
         :return: The Model details.
         """
-        res = await self._get(self._url, params={"modelDetails": "true"})
+        res = await self._http.get(self._url, params={"modelDetails": "true"})
         return Model.model_validate(res["model"])
 
     async def get_model_status(self) -> ModelStatus:
@@ -53,39 +52,51 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         Gets the current status of the Model.
         :return: The current status of the Model.
         """
-        res = await self._get(f"{self._url}/status")
+        res = await self._http.get(f"{self._url}/status")
         return ModelStatus.model_validate(res["requestStatus"])
 
     async def wake_model(self) -> None:
         """Wake up the current model."""
-        await self._post_empty(f"{self._url}/open", headers={"Content-Type": "application/text"})
+        await self._http.post_empty(
+            f"{self._url}/open", headers={"Content-Type": "application/text"}
+        )
         logger.info(f"Woke up model '{self._model_id}'.")
 
     async def close_model(self) -> None:
         """Close the current model."""
-        await self._post_empty(f"{self._url}/close", headers={"Content-Type": "application/text"})
+        await self._http.post_empty(
+            f"{self._url}/close", headers={"Content-Type": "application/text"}
+        )
         logger.info(f"Closed model '{self._model_id}'.")
 
-    async def get_modules(self) -> list[Module]:
+    async def get_modules(
+        self, sort_by: Literal["id", "name"] = "id", descending: bool = False
+    ) -> list[Module]:
         """
         Lists all the Modules in the Model.
+        :param sort_by: The field to sort the results by.
+        :param descending: If True, the results will be sorted in descending order.
         :return: The List of Modules.
         """
-        return [
-            Module.model_validate(e)
-            for e in await self._get_paginated(f"{self._url}/modules", "modules")
-        ]
+        res = await self._http.get_paginated(
+            f"{self._url}/modules", "modules", params=sort_params(sort_by, descending)
+        )
+        return [Module.model_validate(e) for e in res]
 
-    async def get_views(self) -> list[View]:
+    async def get_views(
+        self, sort_by: Literal["id", "module_id", "name"] = "id", descending: bool = False
+    ) -> list[View]:
         """
         Lists all the Views in the Model. This will include all Modules and potentially other saved
         views.
+        :param sort_by: The field to sort the results by.
+        :param descending: If True, the results will be sorted in descending order.
         :return: The List of Views.
         """
-        params = {"includesubsidiaryviews": True}
+        params = {"includesubsidiaryviews": True} | sort_params(sort_by, descending)
         return [
             View.model_validate(e)
-            for e in await self._get_paginated(f"{self._url}/views", "views", params=params)
+            for e in await self._http.get_paginated(f"{self._url}/views", "views", params=params)
         ]
 
     async def get_view_info(self, view_id: int) -> ViewInfo:
@@ -94,7 +105,7 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         :param view_id: The ID of the View.
         :return: The information about the View.
         """
-        return ViewInfo.model_validate((await self._get(f"{self._url}/views/{view_id}")))
+        return ViewInfo.model_validate((await self._http.get(f"{self._url}/views/{view_id}")))
 
     async def get_line_items(self, only_module_id: int | None = None) -> list[LineItem]:
         """
@@ -102,21 +113,26 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         :param only_module_id: If provided, only Line Items from this Module will be returned.
         :return: All Line Items on this Model or only from the specified Module.
         """
-        res = await self._get(
+        res = await self._http.get(
             f"{self._url}/modules/{only_module_id}/lineItems?includeAll=true"
             if only_module_id
             else f"{self._url}/lineItems?includeAll=true"
         )
         return [LineItem.model_validate(e) for e in res.get("items", [])]
 
-    async def get_lists(self) -> list[List]:
+    async def get_lists(
+        self, sort_by: Literal["id", "name"] = "id", descending: bool = False
+    ) -> list[List]:
         """
         Lists all the Lists in the Model.
+        :param sort_by: The field to sort the results by.
+        :param descending: If True, the results will be sorted in descending order.
         :return: All Lists on this model.
         """
-        return [
-            List.model_validate(e) for e in await self._get_paginated(f"{self._url}/lists", "lists")
-        ]
+        res = await self._http.get_paginated(
+            f"{self._url}/lists", "lists", params=sort_params(sort_by, descending)
+        )
+        return [List.model_validate(e) for e in res]
 
     async def get_list_metadata(self, list_id: int) -> ListMetadata:
         """
@@ -126,7 +142,7 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         """
 
         return ListMetadata.model_validate(
-            (await self._get(f"{self._url}/lists/{list_id}")).get("metadata")
+            (await self._http.get(f"{self._url}/lists/{list_id}")).get("metadata")
         )
 
     @overload
@@ -150,7 +166,7 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
                data, you will want to set this to avoid unnecessary (de-)serialization.
         :return: All items in the List.
         """
-        res = await self._get(f"{self._url}/lists/{list_id}/items?includeAll=true")
+        res = await self._http.get(f"{self._url}/lists/{list_id}/items?includeAll=true")
         if return_raw:
             return res.get("listItems", [])
         return [ListItem.model_validate(e) for e in res.get("listItems", [])]
@@ -179,7 +195,7 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
             return InsertionResult(added=0, ignored=0, failures=[], total=0)
         if len(items) <= 100_000:
             result = InsertionResult.model_validate(
-                await self._post(
+                await self._http.post(
                     f"{self._url}/lists/{list_id}/items?action=add", json={"items": items}
                 )
             )
@@ -187,7 +203,9 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
             return result
         responses = await gather(
             *(
-                self._post(f"{self._url}/lists/{list_id}/items?action=add", json={"items": chunk})
+                self._http.post(
+                    f"{self._url}/lists/{list_id}/items?action=add", json={"items": chunk}
+                )
                 for chunk in (items[i : i + 100_000] for i in range(0, len(items), 100_000))
             )
         )
@@ -217,7 +235,7 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         if not items:
             return ListDeletionResult(deleted=0, failures=[])
         if len(items) <= 100_000:
-            res = await self._post(
+            res = await self._http.post(
                 f"{self._url}/lists/{list_id}/items?action=delete", json={"items": items}
             )
             info = ListDeletionResult.model_validate(res)
@@ -226,7 +244,7 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
 
         responses = await gather(
             *(
-                self._post(
+                self._http.post(
                     f"{self._url}/lists/{list_id}/items?action=delete", json={"items": chunk}
                 )
                 for chunk in (items[i : i + 100_000] for i in range(0, len(items), 100_000))
@@ -244,7 +262,7 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         Resets the index of a List. The List must be empty to do so.
         :param list_id: The ID of the List.
         """
-        await self._post_empty(f"{self._url}/lists/{list_id}/resetIndex")
+        await self._http.post_empty(f"{self._url}/lists/{list_id}/resetIndex")
         logger.info(f"Reset index for list '{list_id}'.")
 
     async def update_module_data(
@@ -264,7 +282,7 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         :param data: The data to write to the Module.
         :return: The number of cells changed or the response with the according error details.
         """
-        res = await self._post(f"{self._url}/modules/{module_id}/data", json=data)
+        res = await self._http.post(f"{self._url}/modules/{module_id}/data", json=data)
         if "failures" not in res:
             logger.info(f"Updated {res['numberOfCellsChanged']} cells in module '{module_id}'.")
         return res if "failures" in res else res["numberOfCellsChanged"]
@@ -274,7 +292,7 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         Gets the current period of the model.
         :return: The current period of the model.
         """
-        res = await self._get(f"{self._url}/currentPeriod")
+        res = await self._http.get(f"{self._url}/currentPeriod")
         return CurrentPeriod.model_validate(res["currentPeriod"])
 
     async def set_current_period(self, date: str) -> CurrentPeriod:
@@ -283,7 +301,7 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         :param date: The date to set the current period to, in the format 'YYYY-MM-DD'.
         :return: The updated current period of the model.
         """
-        res = await self._put(f"{self._url}/currentPeriod", {"date": date})
+        res = await self._http.put(f"{self._url}/currentPeriod", {"date": date})
         logger.info(f"Set current period to '{date}'.")
         return CurrentPeriod.model_validate(res["currentPeriod"])
 
@@ -293,7 +311,7 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         :param year: The fiscal year to set, in the format specified in the model, e.g. FY24.
         :return: The updated fiscal year of the model.
         """
-        res = await self._put(f"{self._url}/modelCalendar/fiscalYear", {"year": year})
+        res = await self._http.put(f"{self._url}/modelCalendar/fiscalYear", {"year": year})
         logger.info(f"Set current fiscal year to '{year}'.")
         return FiscalYear.model_validate(res["modelCalendar"]["fiscalYear"])
 
@@ -302,7 +320,7 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         Get the calendar settings of the model.
         :return: The calendar settings of the model.
         """
-        return parse_calendar_response(await self._get(f"{self._url}/modelCalendar"))
+        return parse_calendar_response(await self._http.get(f"{self._url}/modelCalendar"))
 
     async def get_dimension_items(self, dimension_id: int) -> list[DimensionWithCode]:
         """
@@ -318,7 +336,9 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         :param dimension_id: The ID of the dimension to list items for.
         :return: A list of Dimension items.
         """
-        res = await self._get(f"{self._url}/dimensions/{validate_dimension_id(dimension_id)}/items")
+        res = await self._http.get(
+            f"{self._url}/dimensions/{validate_dimension_id(dimension_id)}/items"
+        )
         return [DimensionWithCode.model_validate(e) for e in res.get("items", [])]
 
     async def lookup_dimension_items(
@@ -350,7 +370,7 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
                 "Invalid dimension_id. Must be a List (101xxxxxxxxx), Time (20000000003), "
                 "Version (20000000020), or Users (101999999999)."
             )
-        res = await self._post(
+        res = await self._http.post(
             f"{self._url}/dimensions/{dimension_id}/items", json={"codes": codes, "names": names}
         )
         return [DimensionWithCode.model_validate(e) for e in res.get("items", [])]
@@ -367,7 +387,7 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         :param dimension_id: The ID of the Dimension to get items for.
         :return: A list of Dimensions used in the View.
         """
-        res = await self._get(f"{self._url}/views/{view_id}/dimensions/{dimension_id}/items")
+        res = await self._http.get(f"{self._url}/views/{view_id}/dimensions/{dimension_id}/items")
         return [Dimension.model_validate(e) for e in res.get("items", [])]
 
     async def get_line_item_dimensions(self, line_item_id: int) -> list[Dimension]:
@@ -377,5 +397,5 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         :param line_item_id: The ID of the Line Item.
         :return: A list of Dimensions used in the Line Item.
         """
-        res = await self._get(f"{self._url}/lineItems/{line_item_id}/dimensions")
+        res = await self._http.get(f"{self._url}/lineItems/{line_item_id}/dimensions")
         return [Dimension.model_validate(e) for e in res.get("dimensions", [])]