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

{anaplan_sdk-0.5.0a2 → anaplan_sdk-0.5.0a4}/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.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.0a2 → anaplan_sdk-0.5.0a4}/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-0.5.0a2 → anaplan_sdk-0.5.0a4}/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-0.5.0a2 → anaplan_sdk-0.5.0a4}/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-0.5.0a2 → anaplan_sdk-0.5.0a4}/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-0.5.0a2 → anaplan_sdk-0.5.0a4}/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.0a4}/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-0.5.0a2 → anaplan_sdk-0.5.0a4}/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-0.5.0a2 → anaplan_sdk-0.5.0a4}/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:
         """