anaplan-sdk 0.4.4a4__tar.gz → 0.5.0__tar.gz

{anaplan_sdk-0.4.4a4 → anaplan_sdk-0.5.0}/.github/workflows/docs.yml

@@ -3,11 +3,13 @@ on:
   push:
     branches:
       - master
+  workflow_dispatch:
+
 permissions:
   contents: write
 jobs:
   deploy:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v4
       - name: Configure Git Credentials
@@ -17,13 +19,6 @@ jobs:
       - uses: actions/setup-python@v5
         with:
           python-version: 3.13
-      - run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV
-      - uses: actions/cache@v4
-        with:
-          key: mkdocs-material-${{ env.cache_id }}
-          path: .cache
-          restore-keys: |
-            mkdocs-material-
       - name: "Setup"
         run: |
           pip install uv

{anaplan_sdk-0.4.4a4 → anaplan_sdk-0.5.0}/.github/workflows/lint.yml

@@ -2,7 +2,7 @@ name: Ruff
 on: [ push, pull_request ]
 jobs:
   ruff:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v4
       - uses: astral-sh/ruff-action@v3

{anaplan_sdk-0.4.4a4 → anaplan_sdk-0.5.0}/.github/workflows/tests.yml

@@ -17,7 +17,7 @@ jobs:
       AZ_STORAGE_SAS_TOKEN: ${{secrets.AZ_STORAGE_SAS_TOKEN}}
 
     name: "Python ${{ matrix.python-version }}"
-    runs-on: "ubuntu-latest"
+    runs-on: ubuntu-22.04
 
     strategy:
       max-parallel: 4
@@ -34,4 +34,4 @@ jobs:
           pip install uv
           uv sync
       - name: "Run tests"
-        run: "uv run python -m pytest -n 12 --dist loadfile tests/"
+        run: "uv run python -m pytest -n 15 --dist loadfile tests/"

{anaplan_sdk-0.4.4a4 → anaplan_sdk-0.5.0}/.pre-commit-config.yaml

@@ -1,11 +1,11 @@
 repos:
   - repo: https://github.com/astral-sh/uv-pre-commit
-    rev: 0.7.3
+    rev: 0.8.3
     hooks:
       - id: uv-lock
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.9
+    rev: v0.12.7
     hooks:
-      - id: ruff
+      - id: ruff-check
         args: [ --fix ]
       - id: ruff-format

{anaplan_sdk-0.4.4a4 → anaplan_sdk-0.5.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: anaplan-sdk
-Version: 0.4.4a4
-Summary: Streamlined Python Interface for Anaplan
+Version: 0.5.0
+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/
@@ -60,7 +60,8 @@ abstractions over all Anaplan APIs, allowing you to focus on business requiremen
 
 ## Getting Started
 
-Head over to the [Quick Start](quickstart.md) for basic usage instructions and examples.
+Head over to the [Quick Start](https://vinzenzklass.github.io/anaplan-sdk/quickstart/) for basic usage instructions and
+examples.
 
 ## Contributing
 

{anaplan_sdk-0.4.4a4 → anaplan_sdk-0.5.0}/README.md

@@ -38,7 +38,8 @@ abstractions over all Anaplan APIs, allowing you to focus on business requiremen
 
 ## Getting Started
 
-Head over to the [Quick Start](quickstart.md) for basic usage instructions and examples.
+Head over to the [Quick Start](https://vinzenzklass.github.io/anaplan-sdk/quickstart/) for basic usage instructions and
+examples.
 
 ## Contributing
 

{anaplan_sdk-0.4.4a4 → anaplan_sdk-0.5.0}/anaplan_sdk/__init__.py

@@ -2,6 +2,7 @@ from ._async_clients import AsyncClient
 from ._auth import AnaplanLocalOAuth, AnaplanRefreshTokenAuth
 from ._clients import Client
 from ._oauth import AsyncOauth, Oauth
+from .models.scim import field
 
 __all__ = [
     "AsyncClient",
@@ -12,4 +13,5 @@ __all__ = [
     "Oauth",
     "models",
     "exceptions",
+    "field",
 ]

{anaplan_sdk-0.4.4a4 → anaplan_sdk-0.5.0}/anaplan_sdk/_async_clients/__init__.py

@@ -2,6 +2,8 @@ from ._alm import _AsyncAlmClient
 from ._audit import _AsyncAuditClient
 from ._bulk import AsyncClient
 from ._cloud_works import _AsyncCloudWorksClient
+from ._cw_flow import _AsyncFlowClient
+from ._scim import _AsyncScimClient
 from ._transactional import _AsyncTransactionalClient
 
 __all__ = [
@@ -9,5 +11,7 @@ __all__ = [
     "_AsyncAlmClient",
     "_AsyncAuditClient",
     "_AsyncCloudWorksClient",
+    "_AsyncFlowClient",
     "_AsyncTransactionalClient",
+    "_AsyncScimClient",
 ]

anaplan_sdk-0.5.0/anaplan_sdk/_async_clients/_alm.py

@@ -0,0 +1,289 @@
+import logging
+from typing import Literal, overload
+
+from anaplan_sdk._services import _AsyncHttpService
+from anaplan_sdk._utils import sort_params
+from anaplan_sdk.exceptions import AnaplanActionError
+from anaplan_sdk.models import (
+    ModelRevision,
+    ReportTask,
+    Revision,
+    SummaryReport,
+    SyncTask,
+    TaskSummary,
+)
+
+logger = logging.getLogger("anaplan_sdk")
+
+
+class _AsyncAlmClient:
+    def __init__(self, http: _AsyncHttpService, model_id: str) -> None:
+        self._http = http
+        self._model_id = model_id
+        self._url = f"https://api.anaplan.com/2/0/models/{model_id}"
+
+    async def change_model_status(self, status: Literal["online", "offline"]) -> None:
+        """
+        Use this call to change the status of a model.
+        :param status: The status of the model. Can be either "online" or "offline".
+        """
+        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,
+        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_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:
+        """
+        Use this call to return the latest revision for a specific model. The response is in the
+        same format as in Getting a list of syncable revisions between two models.
+
+        If a revision exists, the return list should contain one element only which is the
+        latest revision.
+        :return: The latest revision for a specific model, or None if no revisions exist.
+        """
+        res = (await self._http.get(f"{self._url}/alm/latestRevision")).get("revisions")
+        return Revision.model_validate(res[0]) if res else None
+
+    async def get_syncable_revisions(self, source_model_id: str) -> list[Revision]:
+        """
+        Use this call to return the list of revisions from your source model that can be
+        synchronized to your target model.
+
+        The returned list displays in descending order, by creation date and time. This is
+        consistent with how revisions are displayed in the user interface (UI).
+        :param source_model_id: The ID of the source model.
+        :return: A list of revisions that can be synchronized to the target model.
+        """
+        res = await self._http.get(
+            f"{self._url}/alm/syncableRevisions?sourceModelId={source_model_id}"
+        )
+        return [Revision.model_validate(e) for e in res.get("revisions", [])]
+
+    async def create_revision(self, name: str, description: str) -> Revision:
+        """
+        Create a new revision for the model.
+        :param name: The name (title) of the revision.
+        :param description: The description of the revision.
+        :return: The created Revision Info.
+        """
+        res = await self._http.post(
+            f"{self._url}/alm/revisions", json={"name": name, "description": description}
+        )
+        rev = Revision.model_validate(res["revision"])
+        logger.info(f"Created revision '{name} ({rev.id})'for model {self._model_id}.")
+        return rev
+
+    async def get_sync_tasks(self) -> list[TaskSummary]:
+        """
+        List the sync tasks for a target mode. The returned the tasks are either in progress, or
+        they completed within the last 48 hours.
+        :return: A list of sync tasks in descending order of creation time.
+        """
+        res = await self._http.get(f"{self._url}/alm/syncTasks")
+        return [TaskSummary.model_validate(e) for e in res.get("tasks", [])]
+
+    async def get_sync_task(self, task_id: str) -> SyncTask:
+        """
+        Get the information for a specific sync task.
+        :param task_id: The ID of the sync task.
+        :return: The sync task information.
+        """
+        res = await self._http.get(f"{self._url}/alm/syncTasks/{task_id}")
+        return SyncTask.model_validate(res["task"])
+
+    async def sync_models(
+        self,
+        source_revision_id: str,
+        source_model_id: str,
+        target_revision_id: str,
+        wait_for_completion: bool = True,
+    ) -> SyncTask:
+        """
+        Create a synchronization task between two revisions. This will synchronize the
+        source revision of the source model to the target revision of the target model. This will
+        fail if the source revision is incompatible with the target revision.
+        :param source_revision_id: The ID of the source revision.
+        :param source_model_id: The ID of the source model.
+        :param target_revision_id: The ID of the target revision.
+        :param wait_for_completion: If True, the method will poll the task status and not return
+               until the task is complete. If False, it will spawn the task and return immediately.
+        :return: The created sync task.
+        """
+        payload = {
+            "sourceRevisionId": source_revision_id,
+            "sourceModelId": source_model_id,
+            "targetRevisionId": target_revision_id,
+        }
+        res = await self._http.post(f"{self._url}/alm/syncTasks", json=payload)
+        task = await self.get_sync_task(res["task"]["taskId"])
+        logger.info(
+            f"Started sync task '{task.id}' from Model '{source_model_id}' "
+            f"(Revision '{source_revision_id}') to Model '{self._model_id}'."
+        )
+        if not wait_for_completion:
+            return task
+        task = await self._http.poll_task(self.get_sync_task, task.id)
+        if not task.result.successful:
+            msg = f"Sync task {task.id} completed with errors: {task.result.error}."
+            logger.error(msg)
+            raise AnaplanActionError(msg)
+        logger.info(f"Sync task {task.id} completed successfully.")
+        return task
+
+    async def get_models_for_revision(self, revision_id: str) -> list[ModelRevision]:
+        """
+        Use this call when you need a list of the models that had a specific revision applied
+        to them.
+        :param revision_id: The ID of the revision.
+        :return: A list of models that had a specific revision applied to them.
+        """
+        res = await self._http.get(f"{self._url}/alm/revisions/{revision_id}/appliedToModels")
+        return [ModelRevision.model_validate(e) for e in res.get("appliedToModels", [])]
+
+    async def create_comparison_report(
+        self,
+        source_revision_id: str,
+        source_model_id: str,
+        target_revision_id: str,
+        wait_for_completion: bool = True,
+    ) -> ReportTask:
+        """
+        Generate a full comparison report between two revisions. This will list all the changes made
+        to the source revision compared to the target revision.
+        :param source_revision_id: The ID of the source revision.
+        :param source_model_id: The ID of the source model.
+        :param target_revision_id: The ID of the target revision.
+        :param wait_for_completion: If True, the method will poll the task status and not return
+               until the task is complete. If False, it will spawn the task and return immediately.
+        :return: The created report task summary.
+        """
+        payload = {
+            "sourceRevisionId": source_revision_id,
+            "sourceModelId": source_model_id,
+            "targetRevisionId": target_revision_id,
+        }
+        res = await self._http.post(f"{self._url}/alm/comparisonReportTasks", json=payload)
+        task = await self.get_comparison_report_task(res["task"]["taskId"])
+        logger.info(
+            f"Started Comparison Report task '{task.id}' between Model '{source_model_id}' "
+            f"(Revision '{source_revision_id}') and Model '{self._model_id}'."
+        )
+        if not wait_for_completion:
+            return task
+        task = await self._http.poll_task(self.get_comparison_report_task, task.id)
+        if not task.result.successful:
+            msg = f"Comparison Report task {task.id} completed with errors: {task.result.error}."
+            logger.error(msg)
+            raise AnaplanActionError(msg)
+        logger.info(f"Comparison Report task {task.id} completed successfully.")
+        return task
+
+    async def get_comparison_report_task(self, task_id: str) -> ReportTask:
+        """
+        Get the task information for a comparison report task.
+        :param task_id: The ID of the comparison report task.
+        :return: The report task information.
+        """
+        res = await self._http.get(f"{self._url}/alm/comparisonReportTasks/{task_id}")
+        return ReportTask.model_validate(res["task"])
+
+    async def get_comparison_report(self, task: ReportTask) -> bytes:
+        """
+        Get the report for a specific task.
+        :param task: The report task object containing the task ID.
+        :return: The binary content of the comparison report.
+        """
+        return await self._http.get_binary(
+            f"{self._url}/alm/comparisonReports/"
+            f"{task.result.target_revision_id}/{task.result.source_revision_id}"
+        )
+
+    @overload
+    async def create_comparison_summary(
+        self,
+        source_revision_id: str,
+        source_model_id: str,
+        target_revision_id: str,
+        wait_for_completion: Literal[True] = True,
+    ) -> SummaryReport: ...
+
+    @overload
+    async def create_comparison_summary(
+        self,
+        source_revision_id: str,
+        source_model_id: str,
+        target_revision_id: str,
+        wait_for_completion: Literal[False] = False,
+    ) -> ReportTask: ...
+
+    async def create_comparison_summary(
+        self,
+        source_revision_id: str,
+        source_model_id: str,
+        target_revision_id: str,
+        wait_for_completion: bool = True,
+    ) -> ReportTask | SummaryReport:
+        """
+        Generate a comparison summary between two revisions.
+        :param source_revision_id: The ID of the source revision.
+        :param source_model_id: The ID of the source model.
+        :param target_revision_id: The ID of the target revision.
+        :param wait_for_completion: If True, the method will poll the task status and not return
+               until the task is complete. If False, it will spawn the task and return immediately.
+        :return: The created summary task or the summary report, if `wait_for_completion` is True.
+        """
+        payload = {
+            "sourceRevisionId": source_revision_id,
+            "sourceModelId": source_model_id,
+            "targetRevisionId": target_revision_id,
+        }
+        res = await self._http.post(f"{self._url}/alm/summaryReportTasks", json=payload)
+        task = await self.get_comparison_summary_task(res["task"]["taskId"])
+        logger.info(
+            f"Started Comparison Summary task '{task.id}' between Model '{source_model_id}' "
+            f"(Revision '{source_revision_id}') and Model '{self._model_id}'."
+        )
+        if not wait_for_completion:
+            return task
+        task = await self._http.poll_task(self.get_comparison_summary_task, task.id)
+        if not task.result.successful:
+            msg = f"Comparison Summary task {task.id} completed with errors: {task.result.error}."
+            logger.error(msg)
+            raise AnaplanActionError(msg)
+        logger.info(f"Comparison Summary task {task.id} completed successfully.")
+        return await self.get_comparison_summary(task)
+
+    async def get_comparison_summary_task(self, task_id: str) -> ReportTask:
+        """
+        Get the task information for a comparison summary task.
+        :param task_id: The ID of the comparison summary task.
+        :return: The report task information.
+        """
+        res = await self._http.get(f"{self._url}/alm/summaryReportTasks/{task_id}")
+        return ReportTask.model_validate(res["task"])
+
+    async def get_comparison_summary(self, task: ReportTask) -> SummaryReport:
+        """
+        Get the comparison summary for a specific task.
+        :param task: The summary task object containing the task ID.
+        :return: The binary content of the comparison summary.
+        """
+        res = await self._http.get(
+            f"{self._url}/alm/summaryReports/"
+            f"{task.result.target_revision_id}/{task.result.source_revision_id}"
+        )
+        return SummaryReport.model_validate(res["summaryReport"])

anaplan_sdk-0.5.0/anaplan_sdk/_async_clients/_audit.py

@@ -0,0 +1,67 @@
+from typing import Any, Literal
+
+from anaplan_sdk._services import _AsyncHttpService
+from anaplan_sdk._utils import 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:
+    def __init__(self, http: _AsyncHttpService) -> None:
+        self._http = http
+        self._url = "https://audit.anaplan.com/audit/api/1/events"
+
+    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: **Caution: This is an undocumented Feature and may behave
+               unpredictably. It requires the Tenant Admin role. For non-admin users, it is
+               ignored.** 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 = 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:
+        """
+        Retrieves information about the specified user, or the authenticated user if none specified.
+        :return: The requested or currently authenticated User.
+        """
+        return User.model_validate(
+            (await self._http.get(f"https://api.anaplan.com/2/0/users/{user_id}")).get("user")
+        )
+
+    async def get_events(
+        self, days_into_past: int = 30, event_type: Event = "all"
+    ) -> list[dict[str, Any]]:
+        """
+        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 log entries, each containing a dictionary with event details.
+        """
+        return list(
+            await self._http.get_paginated(
+                self._url,
+                "response",
+                params={"type": event_type, "intervalInHours": days_into_past * 24},
+            )
+        )