anaplan-sdk 0.2.10__py3-none-any.whl → 0.2.11__py3-none-any.whl

anaplan_sdk/_async_clients/_transactional.py

@@ -1,3 +1,6 @@
+import warnings
+from asyncio import gather
+from itertools import chain
 from typing import Any
 
 import httpx
@@ -13,6 +16,8 @@ from anaplan_sdk.models import (
     Module,
 )
 
+warnings.filterwarnings("always", category=DeprecationWarning)
+
 
 class _AsyncTransactionalClient(_AsyncBaseClient):
     def __init__(self, client: httpx.AsyncClient, model_id: str, retry_count: int) -> None:
@@ -85,28 +90,64 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
             )
         ]
 
-    async def add_items_to_list(
-        self, list_id: int, items: list[dict[str, str | dict]]
+    async def insert_list_items(
+        self, list_id: int, items: list[dict[str, str | int | dict]]
     ) -> InsertionResult:
         """
-        Adds items to a List.
+        Insert new items to the given list. The items must be a list of dictionaries with at least
+        the keys `code` and `name`. You can optionally pass further keys for parents, extra
+        properties etc.
         :param list_id: The ID of the List.
-        :param items: The items to add to the List.
-        :return: The result of the insertion.
-        """
-        # TODO: Paginate by 100k records.
-        return InsertionResult.model_validate(
-            await self._post(f"{self._url}/lists/{list_id}/items?action=add", json={"items": items})
+        :param items: The items to insert into the List.
+        :return: The result of the insertion, indicating how many items were added,
+                 ignored or failed.
+        """
+        if len(items) <= 100_000:
+            return InsertionResult.model_validate(
+                await self._post(
+                    f"{self._url}/lists/{list_id}/items?action=add", json={"items": items}
+                )
+            )
+        responses = await gather(
+            *(
+                self._post(f"{self._url}/lists/{list_id}/items?action=add", json={"items": chunk})
+                for chunk in (items[i : i + 100_000] for i in range(0, len(items), 100_000))
+            )
+        )
+        failures, added, ignored, total = [], 0, 0, 0
+        for res in responses:
+            failures.append(res.get("failures", []))
+            added += res.get("added", 0)
+            total += res.get("total", 0)
+            ignored += res.get("ignored", 0)
+
+        return InsertionResult(
+            added=added, ignored=ignored, total=total, failures=list(chain.from_iterable(failures))
         )
 
-    async def delete_list_items(self, list_id: int, items: list[dict[str, str | int]]) -> None:
+    async def delete_list_items(self, list_id: int, items: list[dict[str, str | int]]) -> int:
         """
         Deletes items from a List.
         :param list_id: The ID of the List.
         :param items: The items to delete from the List. Must be a dict with either `code` or `id`
                       as the keys to identify the records to delete.
         """
-        await self._post(f"{self._url}/lists/{list_id}/items?action=delete", json={"items": items})
+        if len(items) <= 100_000:
+            return (
+                await self._post(
+                    f"{self._url}/lists/{list_id}/items?action=delete", json={"items": items}
+                )
+            ).get("deleted", 0)
+
+        responses = await gather(
+            *(
+                self._post(
+                    f"{self._url}/lists/{list_id}/items?action=delete", json={"items": chunk}
+                )
+                for chunk in (items[i : i + 100_000] for i in range(0, len(items), 100_000))
+            )
+        )
+        return sum(res.get("deleted", 0) for res in responses)
 
     async def reset_list_index(self, list_id: int) -> None:
         """
@@ -129,3 +170,14 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         """
         res = await self._post(f"{self._url}/modules/{module_id}/data", json=data)
         return res if "failures" in res else res["numberOfCellsChanged"]
+
+    async def add_items_to_list(
+        self, list_id: int, items: list[dict[str, str | int | dict]]
+    ) -> InsertionResult:
+        warnings.warn(
+            "`add_items_to_list()` is deprecated and will be removed in a future version. "
+            "Use `insert_list_items()` instead.",
+            DeprecationWarning,
+            stacklevel=1,
+        )
+        return await self.insert_list_items(list_id, items)

anaplan_sdk/_auth.py

@@ -12,86 +12,67 @@ from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import hashes, serialization
 from cryptography.hazmat.primitives.asymmetric.padding import PKCS1v15
 from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey
-from httpx import HTTPError
 
-from .exceptions import InvalidCredentialsException, InvalidPrivateKeyException
+from .exceptions import AnaplanException, InvalidCredentialsException, InvalidPrivateKeyException
 
 logger = logging.getLogger("anaplan_sdk")
 
 
-class AnaplanBasicAuth(httpx.Auth):
+class _AnaplanAuth(httpx.Auth):
     requires_response_body = True
 
-    def __init__(
-        self,
-        user_email: str,
-        password: str,
-    ):
-        self._user_email = user_email
-        self._password = password
-        self._token = self._init_token()
+    def __init__(self):
+        self._auth_request = self._build_auth_request()
+        logger.info("Creating Authentication Token.")
+        with httpx.Client(timeout=15.0) as client:
+            res = client.send(self._auth_request)
+            self._parse_auth_response(res)
+
+    def _build_auth_request(self) -> httpx.Request:
+        raise NotImplementedError("Must be implemented in subclass.")
 
     def auth_flow(self, request):
         request.headers["Authorization"] = f"AnaplanAuthToken {self._token}"
         response = yield request
         if response.status_code == 401:
             logger.info("Token expired, refreshing.")
-            response = yield self._basic_auth_request()
-            if "tokenInfo" not in response.json():
-                raise InvalidCredentialsException
-            self._token = response.json().get("tokenInfo").get("tokenValue")
+            auth_res = yield self._auth_request
+            self._parse_auth_response(auth_res)
             request.headers["Authorization"] = f"AnaplanAuthToken {self._token}"
             yield request
 
-    def _basic_auth_request(self):
-        credentials = b64encode(f"{self._user_email}:{self._password}".encode()).decode()
+    def _parse_auth_response(self, response: httpx.Response) -> None:
+        if response.status_code == 401:
+            raise InvalidCredentialsException
+        if not response.is_success:
+            raise AnaplanException(f"Authentication failed: {response.status_code} {response.text}")
+        self._token: str = response.json()["tokenInfo"]["tokenValue"]
+
+
+class AnaplanBasicAuth(_AnaplanAuth):
+    def __init__(self, user_email: str, password: str):
+        self.user_email = user_email
+        self.password = password
+        super().__init__()
+
+    def _build_auth_request(self) -> httpx.Request:
+        cred = b64encode(f"{self.user_email}:{self.password}".encode()).decode()
         return httpx.Request(
             method="post",
             url="https://auth.anaplan.com/token/authenticate",
-            headers={"Authorization": f"Basic {credentials}"},
+            headers={"Authorization": f"Basic {cred}"},
         )
 
-    def _init_token(self) -> str:
-        try:
-            logger.info("Creating Authentication Token.")
-            credentials = b64encode(f"{self._user_email}:{self._password}".encode()).decode()
-            res = httpx.post(
-                url="https://auth.anaplan.com/token/authenticate",
-                headers={"Authorization": f"Basic {credentials}"},
-                timeout=15,
-            )
-            res.raise_for_status()
-            return res.json().get("tokenInfo").get("tokenValue")
-        except HTTPError as error:
-            raise InvalidCredentialsException from error
-
-
-class AnaplanCertAuth(httpx.Auth):
-    requires_response_body = True
+
+class AnaplanCertAuth(_AnaplanAuth):
     requires_request_body = True
 
-    def __init__(
-        self,
-        certificate: bytes,
-        private_key: RSAPrivateKey,
-    ):
+    def __init__(self, certificate: bytes, private_key: RSAPrivateKey):
         self._certificate = certificate
         self._private_key = private_key
-        self._token = self._init_token()
+        super().__init__()
 
-    def auth_flow(self, request):
-        request.headers["Authorization"] = f"AnaplanAuthToken {self._token}"
-        response = yield request
-        if response.status_code == 401:
-            logger.info("Token expired or invalid, refreshing.")
-            response = yield self._cert_auth_request()
-            if "tokenInfo" not in response.json():
-                raise InvalidCredentialsException
-            self._token = response.json().get("tokenInfo").get("tokenValue")
-            request.headers["Authorization"] = f"AnaplanAuthToken {self._token}"
-            yield request
-
-    def _cert_auth_request(self):
+    def _build_auth_request(self) -> httpx.Request:
         encoded_cert, encoded_string, encoded_signed_string = self._prep_credentials()
         return httpx.Request(
             method="post",
@@ -103,24 +84,6 @@ class AnaplanCertAuth(httpx.Auth):
             json={"encodedData": encoded_string, "encodedSignedData": encoded_signed_string},
         )
 
-    def _init_token(self) -> str:
-        try:
-            logger.info("Creating Authentication Token.")
-            encoded_cert, encoded_string, encoded_signed_string = self._prep_credentials()
-            res = httpx.post(
-                url="https://auth.anaplan.com/token/authenticate",
-                headers={
-                    "Authorization": f"CACertificate {encoded_cert}",
-                    "Content-Type": "application/json",
-                },
-                json={"encodedData": encoded_string, "encodedSignedData": encoded_signed_string},
-                timeout=15,
-            )
-            res.raise_for_status()
-            return res.json().get("tokenInfo").get("tokenValue")
-        except HTTPError as error:
-            raise InvalidCredentialsException from error
-
     def _prep_credentials(self) -> tuple[str, str, str]:
         message = os.urandom(150)
         return (

anaplan_sdk/_base.py

@@ -2,7 +2,10 @@
 Provides Base Classes for this project.
 """
 
+import asyncio
 import logging
+import random
+import time
 from gzip import compress
 from typing import Any, Callable, Coroutine, Literal
 
@@ -51,6 +54,13 @@ class _BaseClient:
         for i in range(max(self._retry_count, 1)):
             try:
                 response = func(*args, **kwargs)
+                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)
+                    logger.info(f"Rate limited. Retrying in {backoff_time} seconds.")
+                    time.sleep(backoff_time)
+                    continue
                 response.raise_for_status()
                 return response
             except HTTPError as error:
@@ -99,6 +109,13 @@ class _AsyncBaseClient:
         for i in range(max(self._retry_count, 1)):
             try:
                 response = await func(*args, **kwargs)
+                if response.status_code == 429:
+                    if i >= self._retry_count - 1:
+                        raise AnaplanException("Rate limit exceeded.")
+                    backoff_time = (i + 1) * random.randint(3, 5)
+                    logger.info(f"Rate limited. Retrying in {backoff_time} seconds.")
+                    await asyncio.sleep(backoff_time)
+                    continue
                 response.raise_for_status()
                 return response
             except HTTPError as error:

anaplan_sdk/_clients/_transactional.py

@@ -1,3 +1,6 @@
+import warnings
+from concurrent.futures import ThreadPoolExecutor
+from itertools import chain
 from typing import Any
 
 import httpx
@@ -77,28 +80,67 @@ class _TransactionalClient(_BaseClient):
             )
         ]
 
-    def add_items_to_list(
-        self, list_id: int, items: list[dict[str, str | dict]]
+    def insert_list_items(
+        self, list_id: int, items: list[dict[str, str | int | dict]]
     ) -> InsertionResult:
         """
-        Adds items to a List.
+        Insert new items to the given list. The items must be a list of dictionaries with at least
+        the keys `code` and `name`. You can optionally pass further keys for parents, extra
+        properties etc.
         :param list_id: The ID of the List.
-        :param items: The items to add to the List.
-        :return: The result of the insertion.
+        :param items: The items to insert into the List.
+        :return: The result of the insertion, indicating how many items were added,
+                 ignored or failed.
         """
-        # TODO: Paginate by 100k records.
-        return InsertionResult.model_validate(
-            self._post(f"{self._url}/lists/{list_id}/items?action=add", json={"items": items})
+        if len(items) <= 100_000:
+            return InsertionResult.model_validate(
+                self._post(f"{self._url}/lists/{list_id}/items?action=add", json={"items": items})
+            )
+
+        with ThreadPoolExecutor() as executor:
+            responses = list(
+                executor.map(
+                    lambda chunk: self._post(
+                        f"{self._url}/lists/{list_id}/items?action=add", json={"items": chunk}
+                    ),
+                    [items[i : i + 100_000] for i in range(0, len(items), 100_000)],
+                )
+            )
+
+        failures, added, ignored, total = [], 0, 0, 0
+        for res in responses:
+            failures.append(res.get("failures", []))
+            added += res.get("added", 0)
+            total += res.get("total", 0)
+            ignored += res.get("ignored", 0)
+
+        return InsertionResult(
+            added=added, ignored=ignored, total=total, failures=list(chain.from_iterable(failures))
         )
 
-    def delete_list_items(self, list_id: int, items: list[dict[str, str | int]]) -> None:
+    def delete_list_items(self, list_id: int, items: list[dict[str, str | int]]) -> int:
         """
         Deletes items from a List.
         :param list_id: The ID of the List.
         :param items: The items to delete from the List. Must be a dict with either `code` or `id`
                       as the keys to identify the records to delete.
         """
-        self._post(f"{self._url}/lists/{list_id}/items?action=delete", json={"items": items})
+        if len(items) <= 100_000:
+            return self._post(
+                f"{self._url}/lists/{list_id}/items?action=delete", json={"items": items}
+            ).get("deleted", 0)
+
+        with ThreadPoolExecutor() as executor:
+            responses = list(
+                executor.map(
+                    lambda chunk: self._post(
+                        f"{self._url}/lists/{list_id}/items?action=delete", json={"items": chunk}
+                    ),
+                    [items[i : i + 100_000] for i in range(0, len(items), 100_000)],
+                )
+            )
+
+        return sum(res.get("deleted", 0) for res in responses)
 
     def reset_list_index(self, list_id: int) -> None:
         """
@@ -119,3 +161,14 @@ class _TransactionalClient(_BaseClient):
         """
         res = self._post(f"{self._url}/modules/{module_id}/data", json=data)
         return res if "failures" in res else res["numberOfCellsChanged"]
+
+    def add_items_to_list(
+        self, list_id: int, items: list[dict[str, str | int | dict]]
+    ) -> InsertionResult:
+        warnings.warn(
+            "`add_items_to_list()` is deprecated and will be removed in a future version. "
+            "Use `insert_list_items()` instead.",
+            DeprecationWarning,
+            stacklevel=1,
+        )
+        return self.insert_list_items(list_id, items)

{anaplan_sdk-0.2.10.dist-info → anaplan_sdk-0.2.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anaplan-sdk
-Version: 0.2.10
+Version: 0.2.11
 Summary: Provides pythonic access to the Anaplan API
 Project-URL: Homepage, https://vinzenzklass.github.io/anaplan-sdk/
 Project-URL: Repository, https://github.com/VinzenzKlass/anaplan-sdk

{anaplan_sdk-0.2.10.dist-info → anaplan_sdk-0.2.11.dist-info}/RECORD

@@ -1,19 +1,19 @@
 anaplan_sdk/__init__.py,sha256=5fr-SZSsH6f3vkRUTDoK6xdAN31cCpe9Mwz2VNu47Uw,134
-anaplan_sdk/_auth.py,sha256=wRcMpdDiHuV-dtiGAKElDiwzfZAEeTOFWfSfaLwNPoU,6597
-anaplan_sdk/_base.py,sha256=2Te7rg_o8_1KD64NfKsDiPLladaoDxMuzk0PaAUNSr8,5299
+anaplan_sdk/_auth.py,sha256=0d495G_iU8vfpk29BJow7Jw2staf18nXqpJlSfaL9h8,5123
+anaplan_sdk/_base.py,sha256=MEE6LpL788QTkrpAVsYI5hu3RfbzSMLGUj-QSW8-OU0,6160
 anaplan_sdk/exceptions.py,sha256=ALkA9fBF0NQ7dufFxV6AivjmHyuJk9DOQ9jtJV2n7f0,1809
 anaplan_sdk/models.py,sha256=ceMaVctpjwQHk7a71Io_-1YcCQshx5i1YYnqxS51nYw,12491
 anaplan_sdk/_async_clients/__init__.py,sha256=wT6qfi4f_4vLFWTJQTsBw8r3DrHtoTIVqi88p5_j-Cg,259
 anaplan_sdk/_async_clients/_alm.py,sha256=HtpwKNCc5eb6DUgS8nqNocxzaoaHOAMQPo0SaTMaD-A,4021
 anaplan_sdk/_async_clients/_audit.py,sha256=wgJx58aDksWJLu4MU-tOz76KjG41AVzBW0v3jAEv9GE,2897
 anaplan_sdk/_async_clients/_bulk.py,sha256=kviZxMbTolz9ZmbtE_hhOxbnmZghToRo3mxIhVADzho,22299
-anaplan_sdk/_async_clients/_transactional.py,sha256=wX_1U5YS4uwrr8D8MfNkfeA-ylFERMb-6xvewG799xY,4961
+anaplan_sdk/_async_clients/_transactional.py,sha256=yhBt5Fzpt07IGIhvMZWcMoXEIGUlSJwAsxvzaq2vT9c,7056
 anaplan_sdk/_clients/__init__.py,sha256=FsbwvZC1FHrxuRXwbPxUzbhz_lO1DpXIxEOjx6-3QuA,219
 anaplan_sdk/_clients/_alm.py,sha256=wzhibRuNzsK3PZM2EOI3OnSGHfv8CG2fuY5zLbnSqog,3912
 anaplan_sdk/_clients/_audit.py,sha256=jqj_sTGNUaM2jAu91Us747pVULntPUkL_qkA4nKc8so,2981
 anaplan_sdk/_clients/_bulk.py,sha256=hTepWQZ-IxAs2WPqsuTfWF3ExuWWrNiMD9I4viQpUAQ,22314
-anaplan_sdk/_clients/_transactional.py,sha256=4NYhq2HdxNh4K-HqMyYoyAEqKih2eTtFiXDZi8xOaf8,4695
-anaplan_sdk-0.2.10.dist-info/METADATA,sha256=MmE2KsCg0OfKUgnE_hc4TOCRQROmIY35hKAZ3fCRQD0,3618
-anaplan_sdk-0.2.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-anaplan_sdk-0.2.10.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-anaplan_sdk-0.2.10.dist-info/RECORD,,
+anaplan_sdk/_clients/_transactional.py,sha256=-DuNhhfp2h9fc-ENJQRh9qwXsZiBi3OV1LeH3S7Jzsc,6871
+anaplan_sdk-0.2.11.dist-info/METADATA,sha256=1GMwYl98joRinRzgF3edxbhnY0FeDFE236OnrYNK8CY,3618
+anaplan_sdk-0.2.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+anaplan_sdk-0.2.11.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+anaplan_sdk-0.2.11.dist-info/RECORD,,