anaplan-sdk 0.5.0a2__tar.gz → 0.5.0a3__tar.gz

{anaplan_sdk-0.5.0a2 → anaplan_sdk-0.5.0a3}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: anaplan-sdk
-Version: 0.5.0a2
-Summary: Streamlined Python Interface for Anaplan
+Version: 0.5.0a3
+Summary: Streamlined Python Interface for the Anaplan API.
 Project-URL: Homepage, https://vinzenzklass.github.io/anaplan-sdk/
 Project-URL: Repository, https://github.com/VinzenzKlass/anaplan-sdk
 Project-URL: Documentation, https://vinzenzklass.github.io/anaplan-sdk/

{anaplan_sdk-0.5.0a2 → anaplan_sdk-0.5.0a3}/anaplan_sdk/_async_clients/_bulk.py

@@ -1,13 +1,13 @@
 import logging
 from asyncio import gather
 from copy import copy
-from typing import AsyncIterator, Iterator
+from typing import AsyncIterator, Iterator, Literal
 
 import httpx
 from typing_extensions import Self
 
 from anaplan_sdk._auth import _create_auth
-from anaplan_sdk._services import _AsyncHttpService, action_url
+from anaplan_sdk._services import _AsyncHttpService, action_url, sort_params
 from anaplan_sdk.exceptions import AnaplanActionError, InvalidIdentifierException
 from anaplan_sdk.models import (
     Action,
@@ -49,6 +49,8 @@ class AsyncClient:
         auth: httpx.Auth | None = None,
         timeout: float | httpx.Timeout = 30,
         retry_count: int = 2,
+        backoff: float = 1.0,
+        backoff_factor: float = 2.0,
         page_size: int = 5_000,
         status_poll_delay: int = 1,
         upload_chunk_size: int = 25_000_000,
@@ -86,6 +88,11 @@ class AsyncClient:
         :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 backoff: The initial backoff time in seconds for the retry mechanism. This is the
+               time to wait before the first retry.
+        :param backoff_factor: The factor by which the backoff time is multiplied after each retry.
+               For example, if the initial backoff is 1 second and the factor is 2, the second
+               retry will wait 2 seconds, the third retry will wait 4 seconds, and so on.
         :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.
@@ -110,7 +117,14 @@ class AsyncClient:
             private_key_password=private_key_password,
         )
         _client = httpx.AsyncClient(auth=_auth, timeout=timeout, **httpx_kwargs)
-        self._http = _AsyncHttpService(_client, retry_count, page_size, status_poll_delay)
+        self._http = _AsyncHttpService(
+            _client,
+            retry_count=retry_count,
+            backoff=backoff,
+            backoff_factor=backoff_factor,
+            page_size=page_size,
+            poll_delay=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}"
@@ -122,6 +136,9 @@ class AsyncClient:
         self._cloud_works = _AsyncCloudWorksClient(self._http)
         self.upload_chunk_size = upload_chunk_size
         self.allow_file_creation = allow_file_creation
+        logger.debug(
+            f"Initialized AsyncClient with workspace_id={workspace_id}, model_id={model_id}"
+        )
 
     @classmethod
     def from_existing(
@@ -208,16 +225,23 @@ class AsyncClient:
             )
         return self._alm_client
 
-    async def get_workspaces(self, search_pattern: str | None = None) -> list[Workspace]:
+    async def get_workspaces(
+        self,
+        search_pattern: str | None = None,
+        sort_by: Literal["size_allowance", "name"] = "name",
+        descending: bool = False,
+    ) -> list[Workspace]:
         """
         Lists all the Workspaces the authenticated user has access to.
         :param search_pattern: Optionally filter for specific workspaces. When provided,
                case-insensitive matches workspaces with names containing this string.
                You can use the wildcards `%` for 0-n characters, and `_` for exactly 1 character.
                When None (default), returns all users.
+        :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 Workspaces.
         """
-        params = {"tenantDetails": "true"}
+        params = {"tenantDetails": "true"} | sort_params(sort_by, descending)
         if search_pattern:
             params["s"] = search_pattern
         return [
@@ -227,16 +251,23 @@ class AsyncClient:
             )
         ]
 
-    async def get_models(self, search_pattern: str | None = None) -> list[Model]:
+    async def get_models(
+        self,
+        search_pattern: str | None = None,
+        sort_by: Literal["active_state", "name"] = "name",
+        descending: bool = False,
+    ) -> 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 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.
+        :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 Models.
         """
-        params = {"modelDetails": "true"}
+        params = {"modelDetails": "true"} | sort_params(sort_by, descending)
         if search_pattern:
             params["s"] = search_pattern
         return [
@@ -260,57 +291,77 @@ class AsyncClient:
         )
         return ModelDeletionResult.model_validate(res)
 
-    async def get_files(self) -> list[File]:
+    async def get_files(
+        self, sort_by: Literal["id", "name"] = "id", descending: bool = False
+    ) -> list[File]:
         """
         Lists all the Files 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 Files.
         """
-        return [
-            File.model_validate(e)
-            for e in await self._http.get_paginated(f"{self._url}/files", "files")
-        ]
+        res = await self._http.get_paginated(
+            f"{self._url}/files", "files", params=sort_params(sort_by, descending)
+        )
+        return [File.model_validate(e) for e in res]
 
-    async def get_actions(self) -> list[Action]:
+    async def get_actions(
+        self, sort_by: Literal["id", "name"] = "id", descending: bool = False
+    ) -> 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
         methods instead.
+        :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 Actions.
         """
-        return [
-            Action.model_validate(e)
-            for e in await self._http.get_paginated(f"{self._url}/actions", "actions")
-        ]
+        res = await self._http.get_paginated(
+            f"{self._url}/actions", "actions", params=sort_params(sort_by, descending)
+        )
+        return [Action.model_validate(e) for e in res]
 
-    async def get_processes(self) -> list[Process]:
+    async def get_processes(
+        self, sort_by: Literal["id", "name"] = "id", descending: bool = False
+    ) -> list[Process]:
         """
         Lists all the Processes 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 Processes.
         """
-        return [
-            Process.model_validate(e)
-            for e in await self._http.get_paginated(f"{self._url}/processes", "processes")
-        ]
+        res = await self._http.get_paginated(
+            f"{self._url}/processes", "processes", params=sort_params(sort_by, descending)
+        )
+        return [Process.model_validate(e) for e in res]
 
-    async def get_imports(self) -> list[Import]:
+    async def get_imports(
+        self, sort_by: Literal["id", "name"] = "id", descending: bool = False
+    ) -> list[Import]:
         """
         Lists all the Imports 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 Imports.
         """
-        return [
-            Import.model_validate(e)
-            for e in await self._http.get_paginated(f"{self._url}/imports", "imports")
-        ]
+        res = await self._http.get_paginated(
+            f"{self._url}/imports", "imports", params=sort_params(sort_by, descending)
+        )
+        return [Import.model_validate(e) for e in res]
 
-    async def get_exports(self) -> list[Export]:
+    async def get_exports(
+        self, sort_by: Literal["id", "name"] = "id", descending: bool = False
+    ) -> list[Export]:
         """
         Lists all the Exports 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 Exports.
         """
-        return [
-            Export.model_validate(e)
-            for e in await self._http.get_paginated(f"{self._url}/exports", "exports")
-        ]
+        res = await self._http.get_paginated(
+            f"{self._url}/exports", "exports", params=sort_params(sort_by, descending)
+        )
+        return [Export.model_validate(e) for e in res]
 
     async def run_action(self, action_id: int, wait_for_completion: bool = True) -> TaskStatus:
         """

{anaplan_sdk-0.5.0a2 → anaplan_sdk-0.5.0a3}/anaplan_sdk/_async_clients/_cw_flow.py

@@ -21,9 +21,7 @@ class _AsyncFlowClient:
         params = {"myIntegrations": 1 if current_user_only else 0}
         return [
             FlowSummary.model_validate(e)
-            for e in await self._http.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:

{anaplan_sdk-0.5.0a2 → anaplan_sdk-0.5.0a3}/anaplan_sdk/_async_clients/_transactional.py

@@ -7,6 +7,7 @@ from anaplan_sdk._services import (
     _AsyncHttpService,
     parse_calendar_response,
     parse_insertion_response,
+    sort_params,
     validate_dimension_id,
 )
 from anaplan_sdk.exceptions import InvalidIdentifierException
@@ -68,23 +69,31 @@ class _AsyncTransactionalClient:
         )
         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._http.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._http.get_paginated(f"{self._url}/views", "views", params=params)
@@ -111,15 +120,19 @@ class _AsyncTransactionalClient:
         )
         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._http.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:
         """

{anaplan_sdk-0.5.0a2 → anaplan_sdk-0.5.0a3}/anaplan_sdk/_clients/_bulk.py

@@ -50,6 +50,8 @@ class Client:
         auth: httpx.Auth | None = None,
         timeout: float | httpx.Timeout = 30,
         retry_count: int = 2,
+        backoff: float = 1.0,
+        backoff_factor: float = 2.0,
         page_size: int = 5_000,
         status_poll_delay: int = 1,
         upload_parallel: bool = True,
@@ -87,6 +89,11 @@ class Client:
                an instance of `httpx.Timeout` to set the timeout for the HTTP requests.
         :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
+        :param backoff: The initial backoff time in seconds for the retry mechanism. This is the
+               time to wait before the first retry.
+        :param backoff_factor: The factor by which the backoff time is multiplied after each retry.
+               For example, if the initial backoff is 1 second and the factor is 2, the second
+               retry will wait 2 seconds, the third retry will wait 4 seconds, and so on.
                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
@@ -113,7 +120,14 @@ class Client:
             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._http = _HttpService(
+            _client,
+            retry_count=retry_count,
+            backoff=backoff,
+            backoff_factor=backoff_factor,
+            page_size=page_size,
+            poll_delay=status_poll_delay,
+        )
         self._retry_count = retry_count
         self._workspace_id = workspace_id
         self._model_id = model_id
@@ -129,6 +143,7 @@ class Client:
         self.upload_parallel = upload_parallel
         self.upload_chunk_size = upload_chunk_size
         self.allow_file_creation = allow_file_creation
+        logger.debug(f"Initialized Client with workspace_id={workspace_id}, model_id={model_id}")
 
     @classmethod
     def from_existing(

{anaplan_sdk-0.5.0a2 → anaplan_sdk-0.5.0a3}/anaplan_sdk/_clients/_cloud_works.py

@@ -307,7 +307,7 @@ class _CloudWorksClient:
     ) -> None:
         """
         Update a notification configuration for an integration in CloudWorks. You cannot pass empty
-        values or nulls to any of the fields If you want to for e.g. override  an existing list of
+        values or nulls to any of the fields If you want to for e.g. override an existing list of
         users with an empty one, you must delete the notification configuration and create a new
         one with only the values you want to keep.
         :param notification_id: The ID of the notification configuration to update.

{anaplan_sdk-0.5.0a2 → anaplan_sdk-0.5.0a3}/anaplan_sdk/_clients/_cw_flow.py

@@ -21,9 +21,7 @@ class _FlowClient:
         params = {"myIntegrations": 1 if current_user_only else 0}
         return [
             FlowSummary.model_validate(e)
-            for e in self._http.get_paginated(
-                self._url, "integrationFlows", page_size=25, params=params
-            )
+            for e in self._http.get_paginated(self._url, "integrationFlows", params=params)
         ]
 
     def get_flow(self, flow_id: str) -> Flow:

{anaplan_sdk-0.5.0a2 → anaplan_sdk-0.5.0a3}/anaplan_sdk/_services.py

@@ -1,6 +1,5 @@
 import asyncio
 import logging
-import random
 import time
 from asyncio import gather, sleep
 from concurrent.futures import ThreadPoolExecutor
@@ -11,6 +10,7 @@ from typing import Any, Awaitable, Callable, Coroutine, Iterator, Literal, Type,
 
 import httpx
 from httpx import HTTPError, Response
+from pydantic.alias_generators import to_camel
 
 from .exceptions import AnaplanException, AnaplanTimeoutException, InvalidIdentifierException
 from .models import (
@@ -43,9 +43,24 @@ Task = TypeVar("Task", bound=TaskSummary)
 
 
 class _HttpService:
-    def __init__(self, client: httpx.Client, retry_count: int, page_size: int, poll_delay: int):
+    def __init__(
+        self,
+        client: httpx.Client,
+        *,
+        retry_count: int,
+        backoff: float,
+        backoff_factor: float,
+        page_size: int,
+        poll_delay: int,
+    ):
+        logger.debug(
+            f"Initializing HttpService with retry_count={retry_count}, "
+            f"page_size={page_size}, poll_delay={poll_delay}."
+        )
         self._client = client
         self._retry_count = retry_count
+        self._backoff = backoff
+        self._backoff_factor = backoff_factor
         self._poll_delay = poll_delay
         self._page_size = min(page_size, 5_000)
 
@@ -78,42 +93,46 @@ class _HttpService:
         content = compress(content.encode() if isinstance(content, str) else content)
         return self.__run_with_retry(self._client.put, url, headers=_gzip_header, content=content)
 
-    def get_paginated(
-        self, url: str, result_key: str, page_size: int = 5_000, **kwargs
-    ) -> Iterator[dict[str, Any]]:
-        logger.debug(f"Starting paginated fetch from {url} with page_size={page_size}.")
-        first_page, total_items = self._get_first_page(url, page_size, result_key, **kwargs)
-        if total_items <= page_size:
+    def poll_task(self, func: Callable[..., Task], *args) -> Task:
+        while (result := func(*args)).task_state != "COMPLETE":
+            time.sleep(self._poll_delay)
+        return result
+
+    def get_paginated(self, url: str, result_key: str, **kwargs) -> Iterator[dict[str, Any]]:
+        logger.debug(f"Starting paginated fetch from {url} with page_size={self._page_size}.")
+        first_page, total_items, actual_size = self._get_first_page(url, result_key, **kwargs)
+        if total_items <= self._page_size:
             logger.debug("All items fit in first page, no additional requests needed.")
             return iter(first_page)
 
-        pages_needed = ceil(total_items / page_size)
-        logger.debug(f"Fetching {pages_needed - 1} additional pages with {page_size} items each.")
+        pages_needed = ceil(total_items / actual_size)
+        logger.debug(f"Fetching {pages_needed - 1} additional pages with {actual_size} items each.")
         with ThreadPoolExecutor() as executor:
             pages = executor.map(
-                lambda n: self._get_page(url, page_size, n * page_size, result_key, **kwargs),
+                lambda n: self._get_page(url, actual_size, n * actual_size, result_key, **kwargs),
                 range(1, pages_needed),
             )
         logger.debug(f"Completed paginated fetch of {total_items} total items.")
         return chain(first_page, *pages)
 
-    def poll_task(self, func: Callable[..., Task], *args) -> Task:
-        while (result := func(*args)).task_state != "COMPLETE":
-            time.sleep(self._poll_delay)
-        return result
-
     def _get_page(self, url: str, limit: int, offset: int, result_key: str, **kwargs) -> list:
         logger.debug(f"Fetching page: offset={offset}, limit={limit} from {url}.")
-        kwargs["params"] = kwargs.get("params") or {} | {"limit": limit, "offset": offset}
+        kwargs["params"] = (kwargs.get("params") or {}) | {"limit": limit, "offset": offset}
         return self.get(url, **kwargs).get(result_key, [])
 
-    def _get_first_page(self, url: str, limit: int, result_key: str, **kwargs) -> tuple[list, int]:
-        logger.debug(f"Fetching first page with limit={limit} from {url}.")
-        kwargs["params"] = kwargs.get("params") or {} | {"limit": limit}
+    def _get_first_page(self, url: str, result_key: str, **kwargs) -> tuple[list, int, int]:
+        logger.debug(f"Fetching first page with limit={self._page_size} from {url}.")
+        kwargs["params"] = (kwargs.get("params") or {}) | {"limit": self._page_size}
         res = self.get(url, **kwargs)
         total_items, first_page = res["meta"]["paging"]["totalSize"], res.get(result_key, [])
+        actual_page_size = res["meta"]["paging"]["currentPageSize"]
+        if actual_page_size < self._page_size and not actual_page_size == total_items:
+            logger.warning(
+                f"Page size {self._page_size} was silently truncated to {actual_page_size}."
+                f"Using the server-side enforced page size {actual_page_size} for further requests."
+            )
         logger.debug(f"Found {total_items} total items, retrieved {len(first_page)} in first page.")
-        return first_page, total_items
+        return first_page, total_items, actual_page_size
 
     def __run_with_retry(self, func: Callable[..., Response], *args, **kwargs) -> Response:
         for i in range(max(self._retry_count, 1)):
@@ -122,7 +141,7 @@ class _HttpService:
                 if response.status_code == 429:
                     if i >= self._retry_count - 1:
                         raise AnaplanException("Rate limit exceeded.")
-                    backoff_time = max(i, 1) * random.randint(2, 5)
+                    backoff_time = self._backoff * (self._backoff_factor if i > 0 else 1)
                     logger.warning(f"Rate limited. Retrying in {backoff_time} seconds.")
                     time.sleep(backoff_time)
                     continue
@@ -139,10 +158,23 @@ class _HttpService:
 
 class _AsyncHttpService:
     def __init__(
-        self, client: httpx.AsyncClient, retry_count: int, page_size: int, poll_delay: int
+        self,
+        client: httpx.AsyncClient,
+        *,
+        retry_count: int,
+        backoff: float,
+        backoff_factor: float,
+        page_size: int,
+        poll_delay: int,
     ):
+        logger.debug(
+            f"Initializing AsyncHttpService with retry_count={retry_count}, "
+            f"page_size={page_size}, poll_delay={poll_delay}."
+        )
         self._client = client
         self._retry_count = retry_count
+        self._backoff = backoff
+        self._backoff_factor = backoff_factor
         self._poll_delay = poll_delay
         self._page_size = min(page_size, 5_000)
 
@@ -179,42 +211,44 @@ class _AsyncHttpService:
             self._client.put, url, headers=_gzip_header, content=content
         )
 
-    async def get_paginated(
-        self, url: str, result_key: str, page_size: int = 5_000, **kwargs
-    ) -> Iterator[dict[str, Any]]:
-        logger.debug(f"Starting paginated fetch from {url} with page_size={page_size}.")
-        first_page, total_items = await self._get_first_page(url, page_size, result_key, **kwargs)
-        if total_items <= page_size:
+    async def poll_task(self, func: Callable[..., Awaitable[Task]], *args) -> Task:
+        while (result := await func(*args)).task_state != "COMPLETE":
+            await sleep(self._poll_delay)
+        return result
+
+    async def get_paginated(self, url: str, result_key: str, **kwargs) -> Iterator[dict[str, Any]]:
+        logger.debug(f"Starting paginated fetch from {url} with page_size={self._page_size}.")
+        first_page, total_items, actual_size = await self._get_first_page(url, result_key, **kwargs)
+        if total_items <= self._page_size:
             logger.debug("All items fit in first page, no additional requests needed.")
             return iter(first_page)
         pages = await gather(
             *(
-                self._get_page(url, page_size, n * page_size, result_key, **kwargs)
-                for n in range(1, ceil(total_items / page_size))
+                self._get_page(url, actual_size, n * actual_size, result_key, **kwargs)
+                for n in range(1, ceil(total_items / actual_size))
             )
         )
         logger.debug(f"Completed paginated fetch of {total_items} total items.")
         return chain(first_page, *pages)
 
-    async def poll_task(self, func: Callable[..., Awaitable[Task]], *args) -> Task:
-        while (result := await func(*args)).task_state != "COMPLETE":
-            await sleep(self._poll_delay)
-        return result
-
     async def _get_page(self, url: str, limit: int, offset: int, result_key: str, **kwargs) -> list:
         logger.debug(f"Fetching page: offset={offset}, limit={limit} from {url}.")
-        kwargs["params"] = kwargs.get("params") or {} | {"limit": limit, "offset": offset}
+        kwargs["params"] = (kwargs.get("params") or {}) | {"limit": limit, "offset": offset}
         return (await self.get(url, **kwargs)).get(result_key, [])
 
-    async def _get_first_page(
-        self, url: str, limit: int, result_key: str, **kwargs
-    ) -> tuple[list, int]:
-        logger.debug(f"Fetching first page with limit={limit} from {url}.")
-        kwargs["params"] = kwargs.get("params") or {} | {"limit": limit}
+    async def _get_first_page(self, url: str, result_key: str, **kwargs) -> tuple[list, int, int]:
+        logger.debug(f"Fetching first page with limit={self._page_size} from {url}.")
+        kwargs["params"] = (kwargs.get("params") or {}) | {"limit": self._page_size}
         res = await self.get(url, **kwargs)
         total_items, first_page = res["meta"]["paging"]["totalSize"], res.get(result_key, [])
+        actual_page_size = res["meta"]["paging"]["currentPageSize"]
+        if actual_page_size < self._page_size and not actual_page_size == total_items:
+            logger.warning(
+                f"Page size {self._page_size} was silently truncated to {actual_page_size}."
+                f"Using the server-side enforced page size {actual_page_size} for further requests."
+            )
         logger.debug(f"Found {total_items} total items, retrieved {len(first_page)} in first page.")
-        return first_page, total_items
+        return first_page, total_items, actual_page_size
 
     async def _run_with_retry(
         self, func: Callable[..., Coroutine[Any, Any, Response]], *args, **kwargs
@@ -225,7 +259,7 @@ class _AsyncHttpService:
                 if response.status_code == 429:
                     if i >= self._retry_count - 1:
                         raise AnaplanException("Rate limit exceeded.")
-                    backoff_time = (i + 1) * random.randint(3, 5)
+                    backoff_time = self._backoff * (self._backoff_factor if i > 0 else 1)
                     logger.warning(f"Rate limited. Retrying in {backoff_time} seconds.")
                     await asyncio.sleep(backoff_time)
                     continue
@@ -240,6 +274,16 @@ class _AsyncHttpService:
         raise AnaplanException("Exhausted all retries without a successful response or Error.")
 
 
+def sort_params(sort_by: str, descending: bool) -> dict[str, str | bool]:
+    """
+    Construct search parameters for sorting. This also converts snake_case to camelCase.
+    :param sort_by: The field to sort by, optionally in snake_case.
+    :param descending: Whether to sort in descending order.
+    :return: A dictionary of search parameters in Anaplan's expected format.
+    """
+    return {"sort": f"{'-' if descending else '+'}{to_camel(sort_by)}"}
+
+
 def construct_payload(model: Type[T], body: T | dict[str, Any]) -> dict[str, Any]:
     """
     Construct a payload for the given model and body.

{anaplan_sdk-0.5.0a2 → anaplan_sdk-0.5.0a3}/anaplan_sdk/models/cloud_works.py

@@ -141,7 +141,9 @@ class ConnectionInput(AnaplanModel):
 
 
 class Connection(_VersionedBaseModel):
-    connection_id: str = Field(description="The unique identifier of this connection.")
+    id: str = Field(
+        validation_alias="connectionId", description="The unique identifier of this connection."
+    )
     connection_type: ConnectionType = Field(description="The type of this connection.")
     body: AzureBlobConnectionInfo | AmazonS3ConnectionInfo | GoogleBigQueryConnectionInfo = Field(
         description="Connection information."
@@ -237,7 +239,9 @@ class _BaseIntegration(_VersionedBaseModel):
 
 
 class Integration(_BaseIntegration):
-    integration_id: str = Field(description="The unique identifier of this integration.")
+    id: str = Field(
+        validation_alias="integrationId", description="The unique identifier of this integration."
+    )
     integration_type: Literal["Import", "Export", "Process"] = Field(
         description="The type of this integration."
     )