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

anaplan_sdk/_async_clients/_alm.py

@@ -1,7 +1,7 @@
 import logging
 from typing import Literal, overload
 
-from anaplan_sdk._services import _AsyncHttpService
+from anaplan_sdk._services import _AsyncHttpService, sort_params
 from anaplan_sdk.exceptions import AnaplanActionError
 from anaplan_sdk.models import (
     ModelRevision,
@@ -29,13 +29,21 @@ class _AsyncAlmClient:
         logger.info(f"Changed model status to '{status}' for model {self._model_id}.")
         await self._http.put(f"{self._url}/onlineStatus", json={"status": status})
 
-    async def get_revisions(self) -> list[Revision]:
+    async def get_revisions(
+        self,
+        sort_by: Literal["id", "name", "applied_on", "created_on"] | None = None,
+        descending: bool = False,
+    ) -> list[Revision]:
         """
         Use this call to return a list of revisions for a specific model.
+        :param sort_by: The field to sort the results by.
+        :param descending: If True, the results will be sorted in descending order.
         :return: A list of revisions for a specific model.
         """
-        res = await self._http.get(f"{self._url}/alm/revisions")
-        return [Revision.model_validate(e) for e in res.get("revisions", [])]
+        res = await self._http.get_paginated(
+            f"{self._url}/alm/revisions", "revisions", params=sort_params(sort_by, descending)
+        )
+        return [Revision.model_validate(e) for e in res]
 
     async def get_latest_revision(self) -> Revision | None:
         """

anaplan_sdk/_async_clients/_audit.py

@@ -1,9 +1,10 @@
 from typing import Any, Literal
 
-from anaplan_sdk._services import _AsyncHttpService
+from anaplan_sdk._services import _AsyncHttpService, sort_params
 from anaplan_sdk.models import User
 
 Event = Literal["all", "byok", "user_activity"]
+UserSortBy = Literal["first_name", "last_name", "email", "active", "last_login_date"] | None
 
 
 class _AsyncAuditClient:
@@ -12,22 +13,29 @@ class _AsyncAuditClient:
         self._limit = 10_000
         self._url = "https://audit.anaplan.com/audit/api/1/events"
 
-    async def get_users(self, search_pattern: str | None = None) -> list[User]:
+    async def get_users(
+        self,
+        search_pattern: str | None = None,
+        sort_by: UserSortBy = None,
+        descending: bool = False,
+    ) -> list[User]:
         """
         Lists all the Users in the authenticated users default tenant.
         :param search_pattern: Optionally filter for specific users. When provided,
                case-insensitive matches users with emails or 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 Users.
         """
-        params = {"s": search_pattern} if search_pattern else None
-        return [
-            User.model_validate(e)
-            for e in await self._http.get_paginated(
-                "https://api.anaplan.com/2/0/users", "users", params=params
-            )
-        ]
+        params = sort_params(sort_by, descending)
+        if search_pattern:
+            params["s"] = search_pattern
+        res = await self._http.get_paginated(
+            "https://api.anaplan.com/2/0/users", "users", params=params
+        )
+        return [User.model_validate(e) for e in res]
 
     async def get_user(self, user_id: str = "me") -> User:
         """

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,
@@ -27,6 +27,8 @@ from ._audit import _AsyncAuditClient
 from ._cloud_works import _AsyncCloudWorksClient
 from ._transactional import _AsyncTransactionalClient
 
+SortBy = Literal["id", "name"] | None
+
 logger = logging.getLogger("anaplan_sdk")
 
 
@@ -49,6 +51,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 +90,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 +119,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 +138,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,43 +227,53 @@ 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"] | None = None,
+        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 [
-            Workspace.model_validate(e)
-            for e in await self._http.get_paginated(
-                "https://api.anaplan.com/2/0/workspaces", "workspaces", params=params
-            )
-        ]
+        res = await self._http.get_paginated(
+            "https://api.anaplan.com/2/0/workspaces", "workspaces", params=params
+        )
+        return [Workspace.model_validate(e) for e in res]
 
-    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"] | None = None,
+        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 [
-            Model.model_validate(e)
-            for e in await self._http.get_paginated(
-                "https://api.anaplan.com/2/0/models", "models", params=params
-            )
-        ]
+        res = await self._http.get_paginated(
+            "https://api.anaplan.com/2/0/models", "models", params=params
+        )
+        return [Model.model_validate(e) for e in res]
 
     async def delete_models(self, model_ids: list[str]) -> ModelDeletionResult:
         """
@@ -260,57 +289,69 @@ class AsyncClient:
         )
         return ModelDeletionResult.model_validate(res)
 
-    async def get_files(self) -> list[File]:
+    async def get_files(self, sort_by: SortBy = None, 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: SortBy = None, 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: SortBy = None, 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: SortBy = None, 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: SortBy = None, 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/_async_clients/_cloud_works.py

@@ -99,14 +99,15 @@ class _AsyncCloudWorksClient:
         logger.info(f"Deleted connection '{con_id}'.")
 
     async def get_integrations(
-        self, sort_by_name: Literal["ascending", "descending"] = "ascending"
+        self, sort_by: Literal["name"] | None = None, descending: bool = False
     ) -> list[Integration]:
         """
         List all integrations in CloudWorks.
-        :param sort_by_name: Sort the integrations by name in ascending or descending order.
+        :param sort_by: The field to sort the results by.
+        :param descending: If True, the results will be sorted in descending order.
         :return: A list of integrations.
         """
-        params = {"sortBy": "name" if sort_by_name == "ascending" else "-name"}
+        params = {"sortBy": f"{'-' if descending else ''}{sort_by}"} if sort_by else None
         return [
             Integration.model_validate(e)
             for e in await self._http.get_paginated(f"{self._url}", "integrations", params=params)

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/_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
@@ -29,6 +30,8 @@ from anaplan_sdk.models import (
     ViewInfo,
 )
 
+SortBy = Literal["id", "name"] | None
+
 logger = logging.getLogger("anaplan_sdk")
 
 
@@ -68,23 +71,29 @@ class _AsyncTransactionalClient:
         )
         logger.info(f"Closed model '{self._model_id}'.")
 
-    async def get_modules(self) -> list[Module]:
+    async def get_modules(self, sort_by: SortBy = None, 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"] | None = None, 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,17 @@ 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: SortBy = None, 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/_clients/_alm.py

@@ -1,7 +1,7 @@
 import logging
 from typing import Literal, overload
 
-from anaplan_sdk._services import _HttpService
+from anaplan_sdk._services import _HttpService, sort_params
 from anaplan_sdk.exceptions import AnaplanActionError
 from anaplan_sdk.models import (
     ModelRevision,
@@ -29,13 +29,21 @@ class _AlmClient:
         logger.info(f"Changed model status to '{status}' for model {self._model_id}.")
         self._http.put(f"{self._url}/onlineStatus", json={"status": status})
 
-    def get_revisions(self) -> list[Revision]:
+    def get_revisions(
+        self,
+        sort_by: Literal["id", "name", "applied_on", "created_on"] | None = None,
+        descending: bool = False,
+    ) -> list[Revision]:
         """
         Use this call to return a list of revisions for a specific model.
+        :param sort_by: The field to sort the results by.
+        :param descending: If True, the results will be sorted in descending order.
         :return: A list of revisions for a specific model.
         """
-        res = self._http.get(f"{self._url}/alm/revisions")
-        return [Revision.model_validate(e) for e in res.get("revisions", [])]
+        res = self._http.get_paginated(
+            f"{self._url}/alm/revisions", "revisions", params=sort_params(sort_by, descending)
+        )
+        return [Revision.model_validate(e) for e in res]
 
     def get_latest_revision(self) -> Revision | None:
         """

anaplan_sdk/_clients/_audit.py

@@ -1,9 +1,10 @@
 from typing import Any, Literal
 
-from anaplan_sdk._services import _HttpService
+from anaplan_sdk._services import _HttpService, sort_params
 from anaplan_sdk.models import User
 
 Event = Literal["all", "byok", "user_activity"]
+UserSortBy = Literal["first_name", "last_name", "email", "active", "last_login_date"] | None
 
 
 class _AuditClient:
@@ -12,20 +13,27 @@ class _AuditClient:
         self._limit = 10_000
         self._url = "https://audit.anaplan.com/audit/api/1/events"
 
-    def get_users(self, search_pattern: str | None = None) -> list[User]:
+    def get_users(
+        self,
+        search_pattern: str | None = None,
+        sort_by: UserSortBy = None,
+        descending: bool = False,
+    ) -> list[User]:
         """
         Lists all the Users in the authenticated users default tenant.
-        :param search_pattern: Optional filter for users. When provided, case-insensitive matches
-               users with emails containing this string. When None (default), returns all users.
+        :param search_pattern: Optionally filter for specific users. When provided,
+               case-insensitive matches users with emails or 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 Users.
         """
-        params = {"s": search_pattern} if search_pattern else None
-        return [
-            User.model_validate(e)
-            for e in self._http.get_paginated(
-                "https://api.anaplan.com/2/0/users", "users", params=params
-            )
-        ]
+        params = sort_params(sort_by, descending)
+        if search_pattern:
+            params["s"] = search_pattern
+        res = self._http.get_paginated("https://api.anaplan.com/2/0/users", "users", params=params)
+        return [User.model_validate(e) for e in res]
 
     def get_user(self, user_id: str = "me") -> User:
         """

anaplan_sdk/_clients/_bulk.py

@@ -2,13 +2,13 @@ import logging
 import multiprocessing
 from concurrent.futures import ThreadPoolExecutor
 from copy import copy
-from typing import Iterator
+from typing import Iterator, Literal
 
 import httpx
 from typing_extensions import Self
 
 from anaplan_sdk._auth import _create_auth
-from anaplan_sdk._services import _HttpService, action_url
+from anaplan_sdk._services import _HttpService, action_url, sort_params
 from anaplan_sdk.exceptions import AnaplanActionError, InvalidIdentifierException
 from anaplan_sdk.models import (
     Action,
@@ -28,6 +28,8 @@ from ._audit import _AuditClient
 from ._cloud_works import _CloudWorksClient
 from ._transactional import _TransactionalClient
 
+SortBy = Literal["id", "name"] | None
+
 logger = logging.getLogger("anaplan_sdk")
 
 
@@ -50,6 +52,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 +91,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 +122,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 +145,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(
@@ -215,42 +232,53 @@ class Client:
             )
         return self._alm_client
 
-    def get_workspaces(self, search_pattern: str | None = None) -> list[Workspace]:
+    def get_workspaces(
+        self,
+        search_pattern: str | None = None,
+        sort_by: Literal["size_allowance", "name"] | None = None,
+        descending: bool = False,
+    ) -> list[Workspace]:
         """
         Lists all the Workspaces the authenticated user has access to.
-        :param search_pattern: Optional filter for workspaces. When provided, case-insensitive
-               matches workspaces with names containing this string. When None (default),
-               returns all workspaces.
+        :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 [
-            Workspace.model_validate(e)
-            for e in self._http.get_paginated(
-                "https://api.anaplan.com/2/0/workspaces", "workspaces", params=params
-            )
-        ]
+        res = self._http.get_paginated(
+            "https://api.anaplan.com/2/0/workspaces", "workspaces", params=params
+        )
+        return [Workspace.model_validate(e) for e in res]
 
-    def get_models(self, search_pattern: str | None = None) -> list[Model]:
+    def get_models(
+        self,
+        search_pattern: str | None = None,
+        sort_by: Literal["active_state", "name"] | None = None,
+        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 [
-            Model.model_validate(e)
-            for e in self._http.get_paginated(
-                "https://api.anaplan.com/2/0/models", "models", params=params
-            )
-        ]
+        res = self._http.get_paginated(
+            "https://api.anaplan.com/2/0/models", "models", params=params
+        )
+        return [Model.model_validate(e) for e in res]
 
     def delete_models(self, model_ids: list[str]) -> ModelDeletionResult:
         """
@@ -266,56 +294,69 @@ class Client:
         )
         return ModelDeletionResult.model_validate(res)
 
-    def get_files(self) -> list[File]:
+    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 self._http.get_paginated(f"{self._url}/files", "files")
-        ]
+        res = self._http.get_paginated(
+            f"{self._url}/files", "files", params=sort_params(sort_by, descending)
+        )
+        return [File.model_validate(e) for e in res]
 
-    def get_actions(self) -> list[Action]:
+    def get_actions(self, sort_by: SortBy = None, 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 self._http.get_paginated(f"{self._url}/actions", "actions")
-        ]
+        res = self._http.get_paginated(
+            f"{self._url}/actions", "actions", params=sort_params(sort_by, descending)
+        )
+        return [Action.model_validate(e) for e in res]
 
-    def get_processes(self) -> list[Process]:
+    def get_processes(self, sort_by: SortBy = None, 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 self._http.get_paginated(f"{self._url}/processes", "processes")
-        ]
+        res = self._http.get_paginated(
+            f"{self._url}/processes", "processes", params=sort_params(sort_by, descending)
+        )
+        return [Process.model_validate(e) for e in res]
 
-    def get_imports(self) -> list[Import]:
+    def get_imports(self, sort_by: SortBy = None, 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 self._http.get_paginated(f"{self._url}/imports", "imports")
-        ]
+        res = self._http.get_paginated(
+            f"{self._url}/imports", "imports", params=sort_params(sort_by, descending)
+        )
+        return [Import.model_validate(e) for e in res]
 
-    def get_exports(self) -> list[Export]:
+    def get_exports(self, sort_by: SortBy = None, 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 (self._http.get(f"{self._url}/exports")).get("exports", [])
-        ]
+        res = self._http.get_paginated(
+            f"{self._url}/exports", "exports", params=sort_params(sort_by, descending)
+        )
+        return [Export.model_validate(e) for e in res]
 
     def run_action(self, action_id: int, wait_for_completion: bool = True) -> TaskStatus:
         """

anaplan_sdk/_clients/_cloud_works.py

@@ -95,14 +95,15 @@ class _CloudWorksClient:
         logger.info(f"Deleted connection '{con_id}'.")
 
     def get_integrations(
-        self, sort_by_name: Literal["ascending", "descending"] = "ascending"
+        self, sort_by: Literal["name"] | None = None, descending: bool = False
     ) -> list[Integration]:
         """
         List all integrations in CloudWorks.
-        :param sort_by_name: Sort the integrations by name in ascending or descending order.
+        :param sort_by: The field to sort the results by.
+        :param descending: If True, the results will be sorted in descending order.
         :return: A list of integrations.
         """
-        params = {"sortBy": "name" if sort_by_name == "ascending" else "-name"}
+        params = {"sortBy": f"{'-' if descending else ''}{sort_by}"} if sort_by else None
         return [
             Integration.model_validate(e)
             for e in self._http.get_paginated(f"{self._url}", "integrations", params=params)
@@ -307,7 +308,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/_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/_clients/_transactional.py

@@ -7,6 +7,7 @@ from anaplan_sdk._services import (
     _HttpService,
     parse_calendar_response,
     parse_insertion_response,
+    sort_params,
     validate_dimension_id,
 )
 from anaplan_sdk.exceptions import InvalidIdentifierException
@@ -29,6 +30,8 @@ from anaplan_sdk.models import (
     ViewInfo,
 )
 
+SortBy = Literal["id", "name"] | None
+
 logger = logging.getLogger("anaplan_sdk")
 
 
@@ -66,24 +69,32 @@ class _TransactionalClient:
         self._http.post_empty(f"{self._url}/close", headers={"Content-Type": "application/text"})
         logger.info(f"Closed model '{self._model_id}'.")
 
-    def get_modules(self) -> list[Module]:
+    def get_modules(self, sort_by: SortBy = None, 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 self._http.get_paginated(f"{self._url}/modules", "modules")
-        ]
+        res = self._http.get_paginated(
+            f"{self._url}/modules", "modules", params=sort_params(sort_by, descending)
+        )
+        return [Module.model_validate(e) for e in res]
 
-    def get_views(self) -> list[View]:
+    def get_views(
+        self, sort_by: Literal["id", "module_id", "name"] | None = None, 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} | sort_params(sort_by, descending)
         return [
-            View.model_validate(e) for e in self._http.get_paginated(f"{self._url}/views", "views")
+            View.model_validate(e)
+            for e in self._http.get_paginated(f"{self._url}/views", "views", params=params)
         ]
 
     def get_view_info(self, view_id: int) -> ViewInfo:
@@ -107,14 +118,17 @@ class _TransactionalClient:
         )
         return [LineItem.model_validate(e) for e in self._http.get(url).get("items", [])]
 
-    def get_lists(self) -> list[List]:
+    def get_lists(self, sort_by: SortBy = None, 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 self._http.get_paginated(f"{self._url}/lists", "lists")
-        ]
+        res = self._http.get_paginated(
+            f"{self._url}/lists", "lists", params=sort_params(sort_by, descending)
+        )
+        return [List.model_validate(e) for e in res]
 
     def get_list_metadata(self, list_id: int) -> ListMetadata:
         """

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 (
@@ -33,6 +33,15 @@ from .models.cloud_works import (
     ScheduleInput,
 )
 
+SORT_WARNING = (
+    "If you are sorting by a field that is potentially ambiguous (e.g., name), the order of "
+    "results is not guaranteed to be internally consistent across multiple requests. This will "
+    "lead to wrong results when paginating through result sets where the ambiguous order can cause "
+    "records to slip between pages or be duplicated on multiple pages. The only way to ensure "
+    "correct results when sorting is to make sure the entire result set fits in one page, or to "
+    "sort by a field that is guaranteed to be unique (e.g., id)."
+)
+
 logger = logging.getLogger("anaplan_sdk")
 
 _json_header = {"Content-Type": "application/json"}
@@ -43,9 +52,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 +102,47 @@ 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.")
+        if kwargs and (kwargs.get("params") or {}).get("sort", None):
+            logger.warning(SORT_WARNING)
+        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 +151,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 +168,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 +221,46 @@ 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)
+        if kwargs and (kwargs.get("params") or {}).get("sort", None):
+            logger.warning(SORT_WARNING)
         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 +271,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 +286,18 @@ class _AsyncHttpService:
         raise AnaplanException("Exhausted all retries without a successful response or Error.")
 
 
+def sort_params(sort_by: str | None, 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.
+    """
+    if not sort_by:
+        return {}
+    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/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."
     )

{anaplan_sdk-0.5.0a2.dist-info → anaplan_sdk-0.5.0a4.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: anaplan-sdk
-Version: 0.5.0a2
-Summary: Streamlined Python Interface for Anaplan
+Version: 0.5.0a4
+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.0a4.dist-info/RECORD

@@ -0,0 +1,30 @@
+anaplan_sdk/__init__.py,sha256=WScEKtXlnRLjCb-j3qW9W4kEACTyPsTLFs-L54et2TQ,351
+anaplan_sdk/_auth.py,sha256=l5z2WCcfQ05OkuQ1dcmikp6dB87Rw1qy2zu8bbaAQTs,16620
+anaplan_sdk/_oauth.py,sha256=AynlJDrGIinQT0jwxI2RSvtU4D7Wasyw3H1uicdlLVI,12672
+anaplan_sdk/_services.py,sha256=isBMmeoxgQi2Xoc5wdD7qtraIHBqYJNAp-CEKWyhqj4,20104
+anaplan_sdk/exceptions.py,sha256=ALkA9fBF0NQ7dufFxV6AivjmHyuJk9DOQ9jtJV2n7f0,1809
+anaplan_sdk/_async_clients/__init__.py,sha256=pZXgMMg4S9Aj_pxQCaSiPuNG-sePVGBtNJ0133VjqW4,364
+anaplan_sdk/_async_clients/_alm.py,sha256=zvKEvXlxNkcQim_XvyZLCbDafFldljg8APHqhAAIfvw,13147
+anaplan_sdk/_async_clients/_audit.py,sha256=j9CeWzIuGsZrVBbjS_T8w6le2cjieW7NW6fDiCY34TA,2718
+anaplan_sdk/_async_clients/_bulk.py,sha256=TTdTMXu1-3iNlD9oxGAbh58JXSRHiFAxnMt70zLz8kk,29929
+anaplan_sdk/_async_clients/_cloud_works.py,sha256=VB4l93426A0Xes5dZ6DsDu0go-BVNhs2RZn2zX5DSOc,17675
+anaplan_sdk/_async_clients/_cw_flow.py,sha256=_allKIOP-qb33wrOj6GV5VAOvrCXOVJ1QXvck-jsocQ,3935
+anaplan_sdk/_async_clients/_transactional.py,sha256=U6X5pW7By387JOgvHx-GmgVRi7MRJKALpx0lWI6xRMo,18024
+anaplan_sdk/_clients/__init__.py,sha256=FsbwvZC1FHrxuRXwbPxUzbhz_lO1DpXIxEOjx6-3QuA,219
+anaplan_sdk/_clients/_alm.py,sha256=3U7Cy5U5TsePF1YPogXvsOzNeQlQm_ezO5TlmD-Xbbs,12874
+anaplan_sdk/_clients/_audit.py,sha256=b7l9xNbUGLceeNlS2No53RKJmksUeIICDTCuYPXgyV0,2641
+anaplan_sdk/_clients/_bulk.py,sha256=lZhsbw-Zqtrwofgzds7Lct1HnUfN5M4QDxWP-PocotE,30085
+anaplan_sdk/_clients/_cloud_works.py,sha256=FsCp2wPxIoArAN1vcIfOI6ANNkK2ZebQ4MWJZB-nFJU,17466
+anaplan_sdk/_clients/_cw_flow.py,sha256=O6t4utbDZdSVXGC0PXUcPpQ4oXrPohU9_8SUBCpxTXw,3824
+anaplan_sdk/_clients/_transactional.py,sha256=SaHAnaGLZrhXmM8d6JnWWkwf-sVCEDW0nL2a4_wvjfk,17849
+anaplan_sdk/models/__init__.py,sha256=zfwDQJQrXuLEXSpbJcm08a_YK1P7a7u-kMhwtJiJFmA,1783
+anaplan_sdk/models/_alm.py,sha256=oeENd0YM7-LoIRBq2uATIQTxVgIP9rXx3UZE2UnQAp0,4670
+anaplan_sdk/models/_base.py,sha256=6AZc9CfireUKgpZfMxYKu4MbwiyHQOsGLjKrxGXBLic,508
+anaplan_sdk/models/_bulk.py,sha256=S72qujNr5STdiyKaCEvrQjKYHik_aemiJFNKE7docpI,8405
+anaplan_sdk/models/_transactional.py,sha256=2bH10zvtMb5Lfh6DC7iQk72aEwq6tyLQ-XnH_0wYSqI,14172
+anaplan_sdk/models/cloud_works.py,sha256=APUGDt_e-JshtXkba5cQh5rZkXOZBz0Aix0qVNdEWgw,19501
+anaplan_sdk/models/flows.py,sha256=SuLgNj5-2SeE3U1i8iY8cq2IkjuUgd_3M1n2ENructk,3625
+anaplan_sdk-0.5.0a4.dist-info/METADATA,sha256=GQk0AT6_rIKYU7o79QBL1ur0DKfYGZ4fqxKv_hqajsg,3678
+anaplan_sdk-0.5.0a4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+anaplan_sdk-0.5.0a4.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+anaplan_sdk-0.5.0a4.dist-info/RECORD,,

anaplan_sdk-0.5.0a2.dist-info/RECORD

@@ -1,30 +0,0 @@
-anaplan_sdk/__init__.py,sha256=WScEKtXlnRLjCb-j3qW9W4kEACTyPsTLFs-L54et2TQ,351
-anaplan_sdk/_auth.py,sha256=l5z2WCcfQ05OkuQ1dcmikp6dB87Rw1qy2zu8bbaAQTs,16620
-anaplan_sdk/_oauth.py,sha256=AynlJDrGIinQT0jwxI2RSvtU4D7Wasyw3H1uicdlLVI,12672
-anaplan_sdk/_services.py,sha256=slsFFx_fCQSfKZo_G0HzEFGErvmEerSMyaVwLXUPCtU,17158
-anaplan_sdk/exceptions.py,sha256=ALkA9fBF0NQ7dufFxV6AivjmHyuJk9DOQ9jtJV2n7f0,1809
-anaplan_sdk/_async_clients/__init__.py,sha256=pZXgMMg4S9Aj_pxQCaSiPuNG-sePVGBtNJ0133VjqW4,364
-anaplan_sdk/_async_clients/_alm.py,sha256=rhVhykUo6wIvA1SBQkpEAviSsVLURumi_3XQlxTf7z8,12788
-anaplan_sdk/_async_clients/_audit.py,sha256=dipSzp4jMvRCHJAVMQfO854_wpmIcYEDinEPSGdoms4,2342
-anaplan_sdk/_async_clients/_bulk.py,sha256=sUDWT01JcN-IWc5RY0thcAA45k54x6lO-lN2WMoCrZE,27278
-anaplan_sdk/_async_clients/_cloud_works.py,sha256=ecm7DqT39J56xQwYxJMKd_ZVqxzXZdpmagwJUvqKBj4,17613
-anaplan_sdk/_async_clients/_cw_flow.py,sha256=PTi-jKeRtYgibqrcE7SCsEgus18nE7ZCs7Awzk4u6Dk,3981
-anaplan_sdk/_async_clients/_transactional.py,sha256=dRh4poYLWcV0kJyCG0MSFzJCzLW7fZ_1-j3c_Lx7zHY,17203
-anaplan_sdk/_clients/__init__.py,sha256=FsbwvZC1FHrxuRXwbPxUzbhz_lO1DpXIxEOjx6-3QuA,219
-anaplan_sdk/_clients/_alm.py,sha256=_LlZIRCE3HxZ4OzU13LOGnX4MQ26j2puSPTy9WGJa3o,12515
-anaplan_sdk/_clients/_audit.py,sha256=9mq7VGYsl6wOdIU7G3GvzP3O7r1ZDCFg5eAu7k4RgxM,2154
-anaplan_sdk/_clients/_bulk.py,sha256=Aw2cu8fAQ0lb4kc0kuYtVXr1BMuEry2yR7dlPR8CBEc,27330
-anaplan_sdk/_clients/_cloud_works.py,sha256=b7LpFcRbUxcN7_9_5GgVIlGf1X1ZmQWFZgnCQKaU55s,17405
-anaplan_sdk/_clients/_cw_flow.py,sha256=rwoQRdtxaigdBavr4LHtnrWsNpAgzt2zuIJOFV9ZE50,3870
-anaplan_sdk/_clients/_transactional.py,sha256=avqww59ccM3FqYMeK1oE-8UH4jyk_pKSCETzhSGKyxA,16936
-anaplan_sdk/models/__init__.py,sha256=zfwDQJQrXuLEXSpbJcm08a_YK1P7a7u-kMhwtJiJFmA,1783
-anaplan_sdk/models/_alm.py,sha256=oeENd0YM7-LoIRBq2uATIQTxVgIP9rXx3UZE2UnQAp0,4670
-anaplan_sdk/models/_base.py,sha256=6AZc9CfireUKgpZfMxYKu4MbwiyHQOsGLjKrxGXBLic,508
-anaplan_sdk/models/_bulk.py,sha256=S72qujNr5STdiyKaCEvrQjKYHik_aemiJFNKE7docpI,8405
-anaplan_sdk/models/_transactional.py,sha256=2bH10zvtMb5Lfh6DC7iQk72aEwq6tyLQ-XnH_0wYSqI,14172
-anaplan_sdk/models/cloud_works.py,sha256=nfn_LHPR-KmW7Tpvz-5qNCzmR8SYgvsVV-lx5iDlyqI,19425
-anaplan_sdk/models/flows.py,sha256=SuLgNj5-2SeE3U1i8iY8cq2IkjuUgd_3M1n2ENructk,3625
-anaplan_sdk-0.5.0a2.dist-info/METADATA,sha256=82p3Dx0kw_5MNBdZYtbNzsCC8s7GM6hnFqpdpan-Ggo,3669
-anaplan_sdk-0.5.0a2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-anaplan_sdk-0.5.0a2.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-anaplan_sdk-0.5.0a2.dist-info/RECORD,,