anaplan-sdk 0.2.8__tar.gz → 0.2.10__tar.gz

{anaplan_sdk-0.2.8 → anaplan_sdk-0.2.10}/.github/workflows/tests.yml

@@ -18,7 +18,7 @@ jobs:
     runs-on: "ubuntu-latest"
 
     strategy:
-      max-parallel: 1
+      max-parallel: 4
       matrix:
         python-version: [ "3.10.4", "3.11", "3.12", "3.13" ]
 
@@ -32,4 +32,4 @@ jobs:
           pip install uv
           uv sync
       - name: "Run tests"
-        run: "uv run python -m pytest -n 6 --dist loadfile  tests/"
+        run: "uv run python -m pytest -n 8 --dist loadfile tests/"

{anaplan_sdk-0.2.8 → anaplan_sdk-0.2.10}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: anaplan-sdk
-Version: 0.2.8
+Version: 0.2.10
 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
 Project-URL: Documentation, https://vinzenzklass.github.io/anaplan-sdk/
-Author-email: Vinzenz Klass <vinzenz.klass@ba.valantic.com>
+Author-email: Vinzenz Klass <vinzenz.klass@valantic.com>
 License-Expression: Apache-2.0
 License-File: LICENSE
-Keywords: anaplan,anaplan alm api,anaplan api,anaplan bulk api,anaplan integration
+Keywords: anaplan,anaplan alm api,anaplan api,anaplan audit api,anaplan bulk api,anaplan integration
 Requires-Python: >=3.10.4
 Requires-Dist: cryptography<45.0.0,>=42.0.7
 Requires-Dist: httpx<1.0.0,>=0.27.0

{anaplan_sdk-0.2.8 → anaplan_sdk-0.2.10}/anaplan_sdk/_async_clients/_alm.py

@@ -1,8 +1,12 @@
+import warnings
+
 import httpx
 
 from anaplan_sdk._base import _AsyncBaseClient
 from anaplan_sdk.models import ModelRevision, Revision, SyncTask, User
 
+warnings.filterwarnings("always", category=DeprecationWarning)
+
 
 class _AsyncAlmClient(_AsyncBaseClient):
     def __init__(self, client: httpx.AsyncClient, model_id: str, retry_count: int) -> None:
@@ -15,6 +19,12 @@ class _AsyncAlmClient(_AsyncBaseClient):
         Lists all the Users in the authenticated users default tenant.
         :return: The List of Users.
         """
+        warnings.warn(
+            "`list_users()` on the ALM client is deprecated and will be removed in a "
+            "future version. Use `list_users()` on the Audit client instead.",
+            DeprecationWarning,
+            stacklevel=1,
+        )
         return [
             User.model_validate(e)
             for e in (await self._get("https://api.anaplan.com/2/0/users")).get("users")

{anaplan_sdk-0.2.8 → anaplan_sdk-0.2.10}/anaplan_sdk/_async_clients/_audit.py

@@ -6,6 +6,7 @@ from typing import Literal
 import httpx
 
 from anaplan_sdk._base import _AsyncBaseClient
+from anaplan_sdk.models import User
 
 Event = Literal["all", "byok", "user_activity"]
 
@@ -17,6 +18,43 @@ class _AsyncAuditClient(_AsyncBaseClient):
         self._url = "https://audit.anaplan.com/audit/api/1/events"
         super().__init__(retry_count, client)
 
+    async def list_users(self) -> list[User]:
+        """
+        Lists all the Users in the authenticated users default tenant.
+        :return: The List of Users.
+        """
+        return [
+            User.model_validate(e)
+            for e in (await self._get("https://api.anaplan.com/2/0/users")).get("users")
+        ]
+
+    async def get_events(self, days_into_past: int = 30, event_type: Event = "all") -> list:
+        """
+        Get audit events from Anaplan Audit API.
+        :param days_into_past: The nuber of days into the past to get events for. The API provides
+        data for up to 30 days.
+        :param event_type: The type of events to get.
+        :return: A list of audit events.
+        """
+        total = await self._get_total(days_into_past, event_type)
+        if total == 0:
+            return []
+        if total <= 10_000:
+            return await self._get_result_page(days_into_past, event_type)
+
+        return list(
+            chain.from_iterable(
+                await gather(
+                    *(
+                        self._get_result_page(
+                            days_into_past, event_type, self._limit, n * self._limit
+                        )
+                        for n in range(ceil(total / self._limit))
+                    )
+                )
+            )
+        )
+
     async def _get_total(self, days_into_past: int = 60, event_type: Event = "all") -> int:
         return (  # noqa
             await self._get(
@@ -47,30 +85,3 @@ class _AsyncAuditClient(_AsyncBaseClient):
                 },
             )
         ).get("response", [])
-
-    async def get_events(self, days_into_past: int = 30, event_type: Event = "all") -> list:
-        """
-        Get audit events from Anaplan Audit API.
-        :param days_into_past: The nuber of days into the past to get events for. The API provides
-        data for up to 30 days.
-        :param event_type: The type of events to get.
-        :return: A list of audit events.
-        """
-        total = await self._get_total(days_into_past, event_type)
-        if total == 0:
-            return []
-        if total <= 10_000:
-            return await self._get_result_page(days_into_past, event_type)
-
-        return list(
-            chain.from_iterable(
-                await gather(
-                    *(
-                        self._get_result_page(
-                            days_into_past, event_type, self._limit, n * self._limit
-                        )
-                        for n in range(ceil(total / self._limit))
-                    )
-                )
-            )
-        )

{anaplan_sdk-0.2.8 → anaplan_sdk-0.2.10}/anaplan_sdk/_async_clients/_bulk.py

@@ -133,6 +133,7 @@ class AsyncClient(_AsyncBaseClient):
         client._transactional_client = _AsyncTransactionalClient(
             existing._client, model_id, existing._retry_count
         )
+        client._alm_client = _AsyncAlmClient(existing._client, model_id, existing._retry_count)
         return client
 
     @property

{anaplan_sdk-0.2.8 → anaplan_sdk-0.2.10}/anaplan_sdk/_clients/_alm.py

@@ -1,8 +1,12 @@
+import warnings
+
 import httpx
 
 from anaplan_sdk._base import _BaseClient
 from anaplan_sdk.models import ModelRevision, Revision, SyncTask, User
 
+warnings.filterwarnings("always", category=DeprecationWarning)
+
 
 class _AlmClient(_BaseClient):
     def __init__(self, client: httpx.Client, model_id: str, retry_count: int) -> None:
@@ -15,6 +19,12 @@ class _AlmClient(_BaseClient):
         Lists all the Users in the authenticated users default tenant.
         :return: The List of Users.
         """
+        warnings.warn(
+            "`list_users()` on the ALM client is deprecated and will be removed in a "
+            "future version. Use `list_users()` on the Audit client instead.",
+            DeprecationWarning,
+            stacklevel=1,
+        )
         return [
             User.model_validate(e)
             for e in self._get("https://api.anaplan.com/2/0/users").get("users")

{anaplan_sdk-0.2.8 → anaplan_sdk-0.2.10}/anaplan_sdk/_clients/_audit.py

@@ -5,6 +5,7 @@ from typing import Literal
 import httpx
 
 from anaplan_sdk._base import _BaseClient
+from anaplan_sdk.models import User
 
 Event = Literal["all", "byok", "user_activity"]
 
@@ -17,6 +18,42 @@ class _AuditClient(_BaseClient):
         self._url = "https://audit.anaplan.com/audit/api/1/events"
         super().__init__(retry_count, client)
 
+    def list_users(self) -> list[User]:
+        """
+        Lists all the Users in the authenticated users default tenant.
+        :return: The List of Users.
+        """
+        return [
+            User.model_validate(e)
+            for e in self._get("https://api.anaplan.com/2/0/users").get("users")
+        ]
+
+    def get_events(self, days_into_past: int = 30, event_type: Event = "all") -> list:
+        """
+        Get audit events from Anaplan Audit API.
+        :param days_into_past: The nuber of days into the past to get events for. The API provides
+                               data for up to 30 days.
+        :param event_type: The type of events to get.
+        :return: A list of audit events.
+        """
+        total = self._get_total(days_into_past, event_type)
+        if total == 0:
+            return []
+        if total <= 10_000:
+            return self._get_result_page(days_into_past, event_type)
+
+        from concurrent.futures import ThreadPoolExecutor
+
+        with ThreadPoolExecutor(max_workers=self._thread_count) as executor:
+            futures = [
+                executor.submit(
+                    self._get_result_page, days_into_past, event_type, self._limit, n * self._limit
+                )
+                for n in range(ceil(total / self._limit))
+            ]
+            results = [future.result() for future in futures]
+            return list(chain.from_iterable(results))
+
     def _get_total(self, days_into_past: int = 60, event_type: Event = "all") -> int:
         return (  # noqa
             self._get(
@@ -47,29 +84,3 @@ class _AuditClient(_BaseClient):
                 },
             )
         ).get("response", [])
-
-    def get_events(self, days_into_past: int = 30, event_type: Event = "all") -> list:
-        """
-        Get audit events from Anaplan Audit API.
-        :param days_into_past: The nuber of days into the past to get events for. The API provides
-        data for up to 30 days.
-        :param event_type: The type of events to get.
-        :return: A list of audit events.
-        """
-        total = self._get_total(days_into_past, event_type)
-        if total == 0:
-            return []
-        if total <= 10_000:
-            return self._get_result_page(days_into_past, event_type)
-
-        from concurrent.futures import ThreadPoolExecutor
-
-        with ThreadPoolExecutor(max_workers=self._thread_count) as executor:
-            futures = [
-                executor.submit(
-                    self._get_result_page, days_into_past, event_type, self._limit, n * self._limit
-                )
-                for n in range(ceil(total / self._limit))
-            ]
-            results = [future.result() for future in futures]
-            return list(chain.from_iterable(results))

{anaplan_sdk-0.2.8 → anaplan_sdk-0.2.10}/anaplan_sdk/_clients/_bulk.py

@@ -140,6 +140,7 @@ class Client(_BaseClient):
         client._transactional_client = _TransactionalClient(
             existing._client, model_id, existing._retry_count
         )
+        client._alm_client = _AlmClient(existing._client, model_id, existing._retry_count)
         return client
 
     @property

anaplan_sdk-0.2.10/docs/guides/audit.md

@@ -0,0 +1,81 @@
+You can use the Audit API to get fine-grained information about the changes made to any model, usage, user sign-ins,
+most frequently visited pages and much more. The Audit API exposes most the logs collected by Anaplan.
+
+For API details refer to
+[the Documentation](https://auditservice.docs.apiary.io/#).
+
+## Usage
+
+!!! tip "Tenant Level API"
+    Note the absence of `workspace_id` and `model_id` in the Audit API. The Audit API is a tenant level API, meaning it
+    is not scoped to a specific workspace or model. You can use the Audit API to get information about all workspaces and
+    models for the default tenant of the user you are providing the credentials for.
+
+The methods for the Audit API reside in a different namespace for better API navigability and
+comprehensiveness, but are accessible through the same client for convenience. For e.g., you can call
+the `.get_events()` method like so:
+
+/// tab | Synchronous
+
+```python
+import anaplan_sdk
+
+anaplan = anaplan_sdk.Client(
+    certificate="~/certs/anaplan.pem", private_key="~/keys/anaplan.pem"
+)
+events = anaplan.audit.get_events()
+```
+
+///
+/// tab | Asynchronous
+
+```python
+import anaplan_sdk
+
+anaplan = anaplan_sdk.AsyncClient(
+    certificate="~/certs/anaplan.pem", private_key="~/keys/anaplan.pem"
+)
+events = await anaplan.audit.get_events()
+```
+
+///
+
+The Audit API also exposes the `list_users()` method to get a list of all users in the workspace. You can for e.g. use
+the two methods in combination to get a list of events with the username using [polars](https://docs.pola.rs):
+
+/// tab | Synchronous
+
+```python
+import polars as pl
+
+events, users = anaplan.audit.get_events(14), anaplan.audit.list_users()
+df = pl.DataFrame(events, orient="row", infer_schema_length=1_000).join(
+    pl.DataFrame(users, orient="row").select(
+        pl.col("id").alias("userId"), "first_name", "last_name"
+    ),
+    on="userId",
+    how="left",
+)
+```
+
+///
+/// tab | Asynchronous
+
+```python
+import polars as pl
+
+events, users = await gather(
+    anaplan.audit.get_events(14), anaplan.audit.list_users()
+)
+df = pl.DataFrame(events, orient="row", infer_schema_length=1_000).join(
+    pl.DataFrame(users, orient="row").select(
+        pl.col("id").alias("userId"), "first_name", "last_name"
+    ),
+    on="userId",
+    how="left",
+)
+```
+
+///
+
+

{anaplan_sdk-0.2.8 → anaplan_sdk-0.2.10}/docs/index.md

@@ -29,3 +29,6 @@ providing both synchronous and asynchronous Clients.
 
 Head over to the [Quick Start](quickstart.md) to get started with the basics.
 
+If you find any issues or feel that this SDK is not adequately covering your use case,
+please [open an issue](https://github.com/VinzenzKlass/anaplan-sdk/issues/new).
+

{anaplan_sdk-0.2.8 → anaplan_sdk-0.2.10}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "anaplan-sdk"
-version = "0.2.8"
+version = "0.2.10"
 description = "Provides pythonic access to the Anaplan API"
 license = "Apache-2.0"
-authors = [{ name = "Vinzenz Klass", email = "vinzenz.klass@ba.valantic.com" }]
+authors = [{ name = "Vinzenz Klass", email = "vinzenz.klass@valantic.com" }]
 readme = "README.md"
-keywords = ["anaplan", "anaplan api", "anaplan bulk api", "anaplan integration", "anaplan alm api"]
+keywords = ["anaplan", "anaplan api", "anaplan bulk api", "anaplan integration", "anaplan alm api", "anaplan audit api"]
 requires-python = ">=3.10.4"
 dependencies = [
     "pydantic>=2.7.2,<3.0.0",
@@ -18,7 +18,7 @@ dev = [
     "ruff>=0.9.2",
     "pre-commit>=4.0.1",
     "pytest>=8.3.3",
-    "pytest-asyncio>=0.24.0",
+    "pytest-asyncio>=0.26.0",
     "pytest-xdist>=3.6.1",
     "mkdocs>=1.6.1",
     "mkdocs-material>=9.5.41",
@@ -76,7 +76,9 @@ skip-magic-trailing-comma = false
 select = ["E", "F", "B", "I"]
 
 [tool.pytest.ini_options]
-asyncio_default_fixture_loop_scope = "module"
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "session"
+asyncio_default_test_loop_scope = "session"
 minversion = "8.0"
 addopts = "-ra -q"
 pythonpath = "anaplan_sdk/"

anaplan_sdk-0.2.10/tests/async/conftest.py

@@ -0,0 +1,58 @@
+import logging
+import os
+import sys
+from os import getenv
+
+import pytest
+
+import anaplan_sdk
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+logging.getLogger("httpx").setLevel(logging.ERROR)
+logging.getLogger("anaplan_sdk").setLevel(logging.INFO)
+
+
+@pytest.fixture(scope="session")
+def client():
+    return anaplan_sdk.AsyncClient(
+        workspace_id=getenv("ANAPLAN_SDK_TEST_WORKSPACE_ID"),
+        model_id=getenv("ANAPLAN_SDK_TEST_MODEL_ID"),
+        certificate=getenv("ANAPLAN_SDK_TEST_CERT"),
+        private_key=getenv("ANAPLAN_SDK_TEST_PK"),
+        retry_count=3,
+    )
+
+
+@pytest.fixture(scope="session")
+def broken_client():
+    return anaplan_sdk.AsyncClient(
+        workspace_id="random",
+        model_id="nonsense",
+        certificate=os.getenv("ANAPLAN_SDK_TEST_CERT"),
+        private_key=os.getenv("ANAPLAN_SDK_TEST_PK"),
+        retry_count=1,
+    )
+
+
+@pytest.fixture(scope="session")
+def test_file():
+    py_version = sys.version.split(" ")[0]
+    if "3.10" in py_version:
+        return 113000000061
+    if "3.11" in py_version:
+        return 113000000062
+    if "3.12" in py_version:
+        return 113000000063
+    return 113000000064
+
+
+@pytest.fixture(scope="session")
+def test_action():
+    py_version = sys.version.split(" ")[0]
+    if "3.10" in py_version:
+        return 118000000028
+    if "3.11" in py_version:
+        return 118000000027
+    if "3.12" in py_version:
+        return 118000000026
+    return 118000000025

anaplan_sdk-0.2.10/tests/async/test_async_alm_client.py

@@ -0,0 +1,28 @@
+from anaplan_sdk import AsyncClient
+
+
+async def test_get_revisions(client: AsyncClient):
+    revs = await client.alm.get_revisions()
+    assert isinstance(revs, list)
+    assert len(revs) > 0
+
+
+async def test_get_models_for_revision(client: AsyncClient):
+    model_revs = await client.alm.get_models_for_revision("44867AAA4DD94C6EB8A23690A0C11DF4")
+    assert isinstance(model_revs, list)
+    assert len(model_revs) > 0
+
+
+async def test_get_sync_tasks(client: AsyncClient):
+    tasks = await client.alm.get_sync_tasks()
+    assert isinstance(tasks, list)
+
+
+async def test_get_syncable_revisions(client: AsyncClient):
+    models = await client.alm.get_syncable_revisions("327F80BA66344A1C84C69AE82C006CDE")
+    assert isinstance(models, list)
+
+
+async def test_get_latest_revision(client: AsyncClient):
+    revs = await client.alm.get_latest_revision()
+    assert isinstance(revs, list)

anaplan_sdk-0.2.10/tests/async/test_async_audit_client.py

@@ -0,0 +1,12 @@
+from anaplan_sdk import AsyncClient, models
+
+
+async def test_list_users(client: AsyncClient):
+    users = await client.audit.list_users()
+    assert isinstance(users, list)
+    assert isinstance(users[0], models.User)
+
+
+async def test_events(client: AsyncClient):
+    events = await client.audit.get_events(1)
+    assert isinstance(events, list)

anaplan_sdk-0.2.10/tests/async/test_async_client.py

@@ -0,0 +1,91 @@
+from anaplan_sdk import AsyncClient
+from anaplan_sdk.exceptions import InvalidIdentifierException
+
+
+async def test_list_workspaces(client: AsyncClient):
+    workspaces = await client.list_workspaces()
+    assert isinstance(workspaces, list)
+    assert len(workspaces) > 0
+
+
+async def test_broken_list_workspaces_raises_invalid_identifier_error(broken_client):
+    try:
+        await broken_client.list_workspaces()
+    except Exception as error:
+        assert isinstance(error, InvalidIdentifierException)
+
+
+async def test_list_models(client: AsyncClient):
+    models = await client.list_models()
+    assert isinstance(models, list)
+    assert len(models) > 0
+
+
+async def test_list_actions(client: AsyncClient):
+    actions = await client.list_actions()
+    assert isinstance(actions, list)
+    assert len(actions) > 0
+
+
+async def test_list_files(client: AsyncClient):
+    files = await client.list_files()
+    assert isinstance(files, list)
+    assert len(files) > 0
+
+
+async def test_list_processes(client: AsyncClient):
+    processes = await client.list_processes()
+    assert isinstance(processes, list)
+    assert len(processes) > 0
+
+
+async def test_list_imports(client: AsyncClient):
+    imports = await client.list_imports()
+    assert isinstance(imports, list)
+    assert len(imports) > 0
+
+
+async def test_list_exports(client: AsyncClient):
+    exports = await client.list_exports()
+    assert isinstance(exports, list)
+    assert len(exports) > 0
+
+
+async def test_upload_file_stream(client, test_file):
+    await client.upload_file_stream(test_file, (i async for i in _async_range(10)))
+    out = await client.get_file(test_file)
+    assert out == b"0123456789"
+
+
+async def test_get_file_stream(client, test_file):
+    async for chunk in client.get_file_stream(test_file):
+        assert isinstance(chunk, bytes)
+
+
+async def test_upload_and_download_file(client, test_file):
+    await client.upload_file(test_file, "Hi!")
+    out = await client.get_file(test_file)
+    assert out == b"Hi!"
+
+
+async def test_run_process(client, test_action):
+    await client.run_action(test_action)
+
+
+async def test_invoke_action(client, test_action):
+    task_id = await client.invoke_action(test_action)
+    assert isinstance(task_id, str)
+    assert len(task_id) == 32
+
+
+async def test_get_task_status(client, test_action):
+    task_status = await client.get_task_status(test_action, await client.invoke_action(test_action))
+    assert isinstance(task_status, dict)
+    assert "progress" in task_status
+    assert "creationTime" in task_status
+    assert "taskState" in task_status
+
+
+async def _async_range(count: int):
+    for i in range(count):
+        yield str(i)

anaplan_sdk-0.2.10/tests/async/test_async_transactional_client.py

@@ -0,0 +1,60 @@
+from uuid import uuid4
+
+from anaplan_sdk import AsyncClient
+from anaplan_sdk.models import InsertionResult, ListMetadata, ModelStatus
+
+
+async def test_list_workspaces(client: AsyncClient):
+    modules = await client.transactional.list_modules()
+    assert isinstance(modules, list)
+    assert len(modules) > 0
+
+
+async def test_list_lists(client: AsyncClient):
+    lists = await client.transactional.list_lists()
+    assert isinstance(lists, list)
+    assert len(lists) > 0
+
+
+async def test_list_line_items(client: AsyncClient):
+    items = await client.transactional.list_line_items()
+    assert isinstance(items, list)
+    assert len(items) > 0
+
+
+async def test_get_list_items(client: AsyncClient):
+    items = await client.transactional.get_list_items(101000000009)
+    assert isinstance(items, list)
+
+
+async def test_get_list_meta(client: AsyncClient):
+    meta = await client.transactional.get_list_metadata(101000000009)
+    assert isinstance(meta, ListMetadata)
+
+
+async def test_get_model_status(client: AsyncClient):
+    status = await client.transactional.get_model_status()
+    assert isinstance(status, ModelStatus)
+
+
+async def test_list_insertion(client: AsyncClient):
+    result = await client.transactional.add_items_to_list(
+        101000000009, [{"code": str(uuid4()), "name": str(uuid4())}]
+    )
+    assert isinstance(result, InsertionResult)
+    assert result.failures == []
+    assert result.added == 1
+    assert result.ignored == 0
+    assert result.total == 1
+
+
+async def test_delete_list_items(client: AsyncClient):
+    code = str(uuid4())
+    await client.transactional.add_items_to_list(
+        101000000009, [{"code": code, "name": str(uuid4())}]
+    )
+    await client.transactional.delete_list_items(101000000009, [{"code": code}])
+
+
+async def test_reset_list_index(client: AsyncClient):
+    await client.transactional.reset_list_index(101000000010)