anaplan-sdk 0.5.0a6__py3-none-any.whl → 0.5.1__py3-none-any.whl

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/_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/_async_clients/_audit.py

@@ -11,7 +11,6 @@ UserSortBy = Literal["first_name", "last_name", "email", "active", "last_login_d
 class _AsyncAuditClient:
     def __init__(self, http: _AsyncHttpService) -> None:
         self._http = http
-        self._limit = 10_000
         self._url = "https://audit.anaplan.com/audit/api/1/events"
 
     async def get_users(

anaplan_sdk/_async_clients/_bulk.py

@@ -26,6 +26,7 @@ from anaplan_sdk.models import (
 from ._alm import _AsyncAlmClient
 from ._audit import _AsyncAuditClient
 from ._cloud_works import _AsyncCloudWorksClient
+from ._scim import _AsyncScimClient
 from ._transactional import _AsyncTransactionalClient
 
 SortBy = Literal["id", "name"] | None
@@ -135,7 +136,8 @@ class AsyncClient:
             _AsyncTransactionalClient(self._http, model_id) if model_id else None
         )
         self._alm_client = _AsyncAlmClient(self._http, model_id) if model_id else None
-        self._audit = _AsyncAuditClient(self._http)
+        self._audit_client = _AsyncAuditClient(self._http)
+        self._scim_client = _AsyncScimClient(self._http)
         self._cloud_works = _AsyncCloudWorksClient(self._http)
         self.upload_chunk_size = upload_chunk_size
         self.allow_file_creation = allow_file_creation
@@ -169,7 +171,7 @@ class AsyncClient:
         The Audit Client provides access to the Anaplan Audit API.
         For details, see https://vinzenzklass.github.io/anaplan-sdk/guides/audit/.
         """
-        return self._audit
+        return self._audit_client
 
     @property
     def cw(self) -> _AsyncCloudWorksClient:
@@ -218,6 +220,15 @@ class AsyncClient:
             )
         return self._alm_client
 
+    @property
+    def scim(self) -> _AsyncScimClient:
+        """
+        To use the SCIM API, you must be User Admin. The SCIM API allows managing internal users.
+        Visiting users are excluded from the SCIM API.
+        :return: The SCIM Client.
+        """
+        return self._scim_client
+
     async def get_workspaces(
         self,
         search_pattern: str | None = None,

anaplan_sdk/_async_clients/_scim.py

@@ -0,0 +1,148 @@
+import logging
+from asyncio import gather
+from itertools import chain
+from typing import Any
+
+from anaplan_sdk._services import _AsyncHttpService
+from anaplan_sdk._utils import construct_payload
+from anaplan_sdk.models.scim import (
+    Operation,
+    ReplaceUserInput,
+    Resource,
+    Schema,
+    ServiceProviderConfig,
+    User,
+    UserInput,
+    field,
+)
+
+logger = logging.getLogger("anaplan_sdk")
+
+
+class _AsyncScimClient:
+    def __init__(self, http: _AsyncHttpService) -> None:
+        self._http = http
+        self._url = "https://api.anaplan.com/scim/1/0/v2"
+
+    async def get_service_provider_config(self) -> ServiceProviderConfig:
+        """
+        Get the SCIM Service Provider Configuration.
+        :return: The ServiceProviderConfig object describing the available SCIM features.
+        """
+        res = await self._http.get(f"{self._url}/ServiceProviderConfig")
+        return ServiceProviderConfig.model_validate(res)
+
+    async def get_resource_types(self) -> list[Resource]:
+        """
+        Get the SCIM Resource Types.
+        :return: A list of Resource objects describing the SCIM resource types.
+        """
+        res = await self._http.get(f"{self._url}/ResourceTypes")
+        return [Resource.model_validate(e) for e in res.get("Resources", [])]
+
+    async def get_resource_schemas(self) -> list[Schema]:
+        """
+        Get the SCIM Resource Schemas.
+        :return: A list of Schema objects describing the SCIM resource schemas.
+        """
+        res = await self._http.get(f"{self._url}/Schemas")
+        return [Schema.model_validate(e) for e in res.get("Resources", [])]
+
+    async def get_users(self, predicate: str | field = None, page_size: int = 100) -> list[User]:
+        """
+        Get a list of users, optionally filtered by a predicate. Keep in mind that this will only
+        return internal users. To get a list of all users in the tenant, use the `get_users()`
+        in the `audit` namespace instead.
+        :param predicate: A filter predicate to filter the users. This can either be a string,
+               in which case it will be passed as-is, or an expression. Anaplan supports filtering
+               on the following fields: "id", "externalId", "userName", "name.familyName",
+               "name.givenName" and "active". It supports the operators "eq", "ne", "gt", "ge",
+               "lt", "le" and "pr". It supports logical operators "and" and "or", "not" is not
+               supported. It supports grouping with parentheses.
+        :param page_size: The number of users to fetch per page. Values above 100 will error.
+        :return: The internal users optionally matching the filter.
+        """
+        params: dict[str, int | str] = {"startIndex": 1, "count": page_size}
+        if predicate is not None:
+            _predicate = predicate if isinstance(predicate, str) else str(predicate)
+            logger.debug(f"Searching for users with predicate: {_predicate}")
+            params["filter"] = _predicate
+        res = await self._http.get(f"{self._url}/Users", params=params)
+        users = [User.model_validate(e) for e in res.get("Resources", [])]
+        if (total := res["totalResults"]) <= page_size:
+            return users
+        pages = await gather(
+            *(
+                self._http.get(
+                    f"{self._url}/Users", params=(params | {"startIndex": i, "count": page_size})
+                )
+                for i in range(page_size + 1, total + 1, page_size)
+            )
+        )
+        for user in chain(*(p.get("Resources", []) for p in pages)):
+            users.append(User.model_validate(user))
+        return users
+
+    async def get_user(self, user_id: str) -> User:
+        """
+        Get a user by their ID.
+        :param user_id: The ID of the user to fetch.
+        :return: The User object.
+        """
+        res = await self._http.get(f"{self._url}/Users/{user_id}")
+        return User.model_validate(res)
+
+    async def add_user(self, user: UserInput | dict[str, Any]) -> User:
+        """
+        Add a new user to your Anaplan tenant.
+        :param user: The user info to add. Can either be a UserInput object or a dict. If you pass
+               a dict, it will be validated against the UserInput model before sending. If the info
+               you provided is invalid or incomplete, this will raise a pydantic.ValidationError.
+        :return: The created User object.
+        """
+        res = await self._http.post(f"{self._url}/Users", json=construct_payload(UserInput, user))
+        user = User.model_validate(res)
+        logger.info(f"Added user '{user.user_name}' with ID '{user.id}'.")
+        return user
+
+    async def replace_user(self, user_id: str, user: ReplaceUserInput | dict[str, Any]):
+        """
+        Replace an existing user with new information. Note that this will replace all fields of the
+        :param user_id: ID of the user to replace.
+        :param user: The new user info. Can either be a ReplaceUserInput object or a dict. If you
+               pass a dict, it will be validated against the ReplaceUserInput model before sending.
+               If the info you provided is invalid or incomplete, this will raise a
+               pydantic.ValidationError.
+        :return: The updated User object.
+        """
+        res = await self._http.put(
+            f"{self._url}/Users/{user_id}", json=construct_payload(ReplaceUserInput, user)
+        )
+        user = User.model_validate(res)
+        logger.info(f"Replaced user with ID '{user_id}' with '{user.user_name}'.")
+        return user
+
+    async def update_user(
+        self, user_id: str, operations: list[Operation] | list[dict[str, Any]]
+    ) -> User:
+        """
+        Update an existing user with a list of operations. This allows you to update only specific
+        fields of the user without replacing the entire user.
+        :param user_id: The ID of the user to update.
+        :param operations: A list of operations to perform on the user. Each operation can either be
+               an Operation object or a dict. If you pass a dict, it will be validated against
+               the Operation model before sending. If the operation is invalid, this will raise a
+               pydantic.ValidationError. You can also use the models Replace, Add and Remove which
+               are subclasses of Operation and provide a more convenient way to create operations.
+        :return: The updated User object.
+        """
+        res = await self._http.patch(
+            f"{self._url}/Users/{user_id}",
+            json={
+                "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"],
+                "Operations": [construct_payload(Operation, e) for e in operations],
+            },
+        )
+        user = User.model_validate(res)
+        logger.info(f"Updated user with ID '{user_id}'.")
+        return user

anaplan_sdk/_clients/__init__.py

@@ -1,6 +1,17 @@
 from ._alm import _AlmClient
 from ._audit import _AuditClient
 from ._bulk import Client
+from ._cloud_works import _CloudWorksClient
+from ._cw_flow import _FlowClient
+from ._scim import _ScimClient
 from ._transactional import _TransactionalClient
 
-__all__ = ["Client", "_AlmClient", "_AuditClient", "_TransactionalClient"]
+__all__ = [
+    "Client",
+    "_AlmClient",
+    "_AuditClient",
+    "_CloudWorksClient",
+    "_FlowClient",
+    "_ScimClient",
+    "_TransactionalClient",
+]

anaplan_sdk/_clients/_bulk.py

@@ -27,6 +27,7 @@ from anaplan_sdk.models import (
 from ._alm import _AlmClient
 from ._audit import _AuditClient
 from ._cloud_works import _CloudWorksClient
+from ._scim import _ScimClient
 from ._transactional import _TransactionalClient
 
 SortBy = Literal["id", "name"] | None
@@ -139,9 +140,10 @@ class Client:
             _TransactionalClient(self._http, model_id) if model_id else None
         )
         self._alm_client = _AlmClient(self._http, model_id) if model_id else None
+        self._audit_client = _AuditClient(self._http)
+        self._scim_client = _ScimClient(self._http)
         self._cloud_works = _CloudWorksClient(self._http)
         self._thread_count = multiprocessing.cpu_count()
-        self._audit = _AuditClient(self._http)
         self.status_poll_delay = status_poll_delay
         self.upload_parallel = upload_parallel
         self.upload_chunk_size = upload_chunk_size
@@ -174,7 +176,7 @@ class Client:
         The Audit Client provides access to the Anaplan Audit API.
         For details, see https://vinzenzklass.github.io/anaplan-sdk/guides/audit/.
         """
-        return self._audit
+        return self._audit_client
 
     @property
     def cw(self) -> _CloudWorksClient:
@@ -223,6 +225,15 @@ class Client:
             )
         return self._alm_client
 
+    @property
+    def scim(self) -> _ScimClient:
+        """
+        To use the SCIM API, you must be User Admin. The SCIM API allows managing internal users.
+        Visiting users are excluded from the SCIM API.
+        :return: The SCIM Client.
+        """
+        return self._scim_client
+
     def get_workspaces(
         self,
         search_pattern: str | None = None,

anaplan_sdk/_clients/_scim.py

@@ -0,0 +1,145 @@
+import logging
+from concurrent.futures import ThreadPoolExecutor
+from itertools import chain
+from typing import Any
+
+from anaplan_sdk._services import _HttpService
+from anaplan_sdk._utils import construct_payload
+from anaplan_sdk.models.scim import (
+    Operation,
+    ReplaceUserInput,
+    Resource,
+    Schema,
+    ServiceProviderConfig,
+    User,
+    UserInput,
+    field,
+)
+
+logger = logging.getLogger("anaplan_sdk")
+
+
+class _ScimClient:
+    def __init__(self, http: _HttpService) -> None:
+        self._http = http
+        self._url = "https://api.anaplan.com/scim/1/0/v2"
+
+    def get_service_provider_config(self) -> ServiceProviderConfig:
+        """
+        Get the SCIM Service Provider Configuration.
+        :return: The ServiceProviderConfig object describing the available SCIM features.
+        """
+        res = self._http.get(f"{self._url}/ServiceProviderConfig")
+        return ServiceProviderConfig.model_validate(res)
+
+    def get_resource_types(self) -> list[Resource]:
+        """
+        Get the SCIM Resource Types.
+        :return: A list of Resource objects describing the SCIM resource types.
+        """
+        res = self._http.get(f"{self._url}/ResourceTypes")
+        return [Resource.model_validate(e) for e in res.get("Resources", [])]
+
+    def get_resource_schemas(self) -> list[Schema]:
+        """
+        Get the SCIM Resource Schemas.
+        :return: A list of Schema objects describing the SCIM resource schemas.
+        """
+        res = self._http.get(f"{self._url}/Schemas")
+        return [Schema.model_validate(e) for e in res.get("Resources", [])]
+
+    def get_users(self, predicate: str | field = None, page_size: int = 100) -> list[User]:
+        """
+        Get a list of users, optionally filtered by a predicate. Keep in mind that this will only
+        return internal users. To get a list of all users in the tenant, use the `get_users()`
+        in the `audit` namespace instead.
+        :param predicate: A filter predicate to filter the users. This can either be a string,
+               in which case it will be passed as-is, or an expression. Anaplan supports filtering
+               on the following fields: "id", "externalId", "userName", "name.familyName",
+               "name.givenName" and "active". It supports the operators "eq", "ne", "gt", "ge",
+               "lt", "le" and "pr". It supports logical operators "and" and "or", "not" is not
+               supported. It supports grouping with parentheses.
+        :param page_size: The number of users to fetch per page. Values above 100 will error.
+        :return: The internal users optionally matching the filter.
+        """
+        params: dict[str, int | str] = {"startIndex": 1, "count": page_size}
+        if predicate is not None:
+            _predicate = predicate if isinstance(predicate, str) else str(predicate)
+            logger.debug(f"Searching for users with predicate: {_predicate}")
+            params["filter"] = _predicate
+        res = self._http.get(f"{self._url}/Users", params=params)
+        users = [User.model_validate(e) for e in res.get("Resources", [])]
+        if (total := res["totalResults"]) <= page_size:
+            return users
+        with ThreadPoolExecutor() as executor:
+            pages = executor.map(
+                lambda i: self._http.get(
+                    f"{self._url}/Users", params=(params | {"startIndex": i, "count": page_size})
+                ),
+                range(page_size + 1, total + 1, page_size),
+            )
+        for user in chain(*(p.get("Resources", []) for p in pages)):
+            users.append(User.model_validate(user))
+        return users
+
+    def get_user(self, user_id: str) -> User:
+        """
+        Get a user by their ID.
+        :param user_id: The ID of the user to fetch.
+        :return: The User object.
+        """
+        res = self._http.get(f"{self._url}/Users/{user_id}")
+        return User.model_validate(res)
+
+    def add_user(self, user: UserInput | dict[str, Any]) -> User:
+        """
+        Add a new user to your Anaplan tenant.
+        :param user: The user info to add. Can either be a UserInput object or a dict. If you pass
+               a dict, it will be validated against the UserInput model before sending. If the info
+               you provided is invalid or incomplete, this will raise a pydantic.ValidationError.
+        :return: The created User object.
+        """
+        res = self._http.post(f"{self._url}/Users", json=construct_payload(UserInput, user))
+        user = User.model_validate(res)
+        logger.info(f"Added user '{user.user_name}' with ID '{user.id}'.")
+        return user
+
+    def replace_user(self, user_id: str, user: ReplaceUserInput | dict[str, Any]):
+        """
+        Replace an existing user with new information. Note that this will replace all fields of the
+        :param user_id: ID of the user to replace.
+        :param user: The new user info. Can either be a ReplaceUserInput object or a dict. If you
+               pass a dict, it will be validated against the ReplaceUserInput model before sending.
+               If the info you provided is invalid or incomplete, this will raise a
+               pydantic.ValidationError.
+        :return: The updated User object.
+        """
+        res = self._http.put(
+            f"{self._url}/Users/{user_id}", json=construct_payload(ReplaceUserInput, user)
+        )
+        user = User.model_validate(res)
+        logger.info(f"Replaced user with ID '{user_id}' with '{user.user_name}'.")
+        return user
+
+    def update_user(self, user_id: str, operations: list[Operation] | list[dict[str, Any]]) -> User:
+        """
+        Update an existing user with a list of operations. This allows you to update only specific
+        fields of the user without replacing the entire user.
+        :param user_id: The ID of the user to update.
+        :param operations: A list of operations to perform on the user. Each operation can either be
+               an Operation object or a dict. If you pass a dict, it will be validated against
+               the Operation model before sending. If the operation is invalid, this will raise a
+               pydantic.ValidationError. You can also use the models Replace, Add and Remove which
+               are subclasses of Operation and provide a more convenient way to create operations.
+        :return: The updated User object.
+        """
+        res = self._http.patch(
+            f"{self._url}/Users/{user_id}",
+            json={
+                "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"],
+                "Operations": [construct_payload(Operation, e) for e in operations],
+            },
+        )
+        user = User.model_validate(res)
+        logger.info(f"Updated user with ID '{user_id}'.")
+        return user

anaplan_sdk/_services.py

@@ -257,7 +257,7 @@ def _extract_first_page(
     actual_page_size = res["meta"]["paging"]["currentPageSize"]
     if actual_page_size < page_size and not actual_page_size == total_items:
         logger.warning(
-            f"Page size {page_size} was silently truncated to {actual_page_size}."
+            f"Page size {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.")

anaplan_sdk/models/scim.py

@@ -0,0 +1,282 @@
+from typing import Any, Literal
+
+from pydantic import Field
+from typing_extensions import Self
+
+from anaplan_sdk.models import AnaplanModel
+
+AnaplanFilterFields = Literal[
+    "id", "externalId", "userName", "name.familyName", "name.givenName", "active"
+]
+
+
+class _FilterExpression:
+    def __init__(self, _field: AnaplanFilterFields) -> None:
+        self._field: AnaplanFilterFields = _field
+        self._exprs: list[str] = []
+        self._operators = []
+
+    def __str__(self) -> str:
+        if not self._exprs:
+            return "active eq true" if self._field == "active" else f"{self._field} pr"
+        parts = []
+        for i, expr in enumerate(self._exprs):
+            if i > 0:
+                parts.append(self._operators[i - 1])
+            parts.append(expr)
+        return " ".join(parts)
+
+    def __invert__(self) -> Self:
+        self._exprs.append(
+            "active eq false" if self._field == "active" else f"{self._field} eq null"
+        )
+        return self
+
+    def __and__(self, other: Self) -> Self:
+        return self._combine(other, "and")
+
+    def __or__(self, other: Self) -> Self:
+        return self._combine(other, "or")
+
+    def _combine(self, other: Self, operator: Literal["and", "or"]) -> Self:
+        if self._requires_grouping(operator):
+            self._exprs = [f"({str(self)})"]
+            self._operators = []
+        self._operators.append(operator)
+        if not self._exprs:
+            self._exprs.append(str(self))
+        self._exprs.append(f"({str(other)})" if other._requires_grouping(operator) else str(other))
+        return self
+
+    def _requires_grouping(self, operator: Literal["and", "or"]) -> bool:
+        return len(self._operators) > 0 and ("or" in self._operators or operator == "or")
+
+    def __eq__(self, other: Any) -> Self:
+        self._exprs.append(f'{self._field} eq "{other}"')
+        return self
+
+    def __ne__(self, other: Any) -> Self:
+        self._exprs.append(f'{self._field} ne "{other}"')
+        return self
+
+    def __gt__(self, other: Any) -> Self:
+        self._exprs.append(f'{self._field} gt "{other}"')
+        return self
+
+    def __ge__(self, other: Any) -> Self:
+        self._exprs.append(f'{self._field} ge "{other}"')
+        return self
+
+    def __lt__(self, other: Any) -> Self:
+        self._exprs.append(f'{self._field} lt "{other}"')
+        return self
+
+    def __le__(self, other: Any) -> Self:
+        self._exprs.append(f'{self._field} le "{other}"')
+        return self
+
+
+field = _FilterExpression
+
+
+class NameInput(AnaplanModel):
+    family_name: str = Field(
+        description="The family name of the User, or last name in most Western languages"
+    )
+    given_name: str = Field(
+        description="The given name of the User, or first name in most Western languages"
+    )
+
+
+class Name(NameInput):
+    formatted: str = Field(
+        description=(
+            "The formatted full name, including given name and family name. Anaplan does as of now "
+            "not have other standard SCIM fields such as middle name or honorific pre- or suffixes."
+        )
+    )
+
+
+class Email(AnaplanModel):
+    value: str = Field(description="Email address of the User")
+    type: Literal["work", "home", "other"] = Field(
+        default=None, description="A label indicating the emails's function, e.g., 'work' or 'home'"
+    )
+    primary: bool | None = Field(
+        default=None, description="Indicates if this is the primary or 'preferred' email"
+    )
+
+
+class EntitlementInput(AnaplanModel):
+    value: str = Field(description="The value of an entitlement.")
+    type: Literal["WORKSPACE", "WORKSPACE_IDS", "WORKSPACE_NAMES"] = Field(
+        description="A label indicating the attribute's function."
+    )
+
+
+class Entitlement(EntitlementInput):
+    display: str | None = Field(
+        default=None, description="A human-readable name, primarily used for display purposes."
+    )
+    primary: bool | None = Field(
+        default=None,
+        description="Indicating the 'primary' or preferred attribute value for this attribute.",
+    )
+
+
+class _BaseUser(AnaplanModel):
+    schemas: list[str] = Field(default=["urn:ietf:params:scim:schemas:core:2.0:User"])
+    user_name: str = Field(description="Unique name for the User.")
+
+
+class User(_BaseUser):
+    id: str = Field(description="The unique identifier for the User.")
+    name: Name = Field(description="The user's real name.")
+    active: bool = Field(description="Indicating the User's active status.")
+    emails: list[Email] = Field(default=[], description="Email addresses for the user.")
+    display_name: str = Field(description="Display Name for the User.")
+    entitlements: list[Entitlement] = Field(
+        default=[], description="A list of entitlements (Workspaces) the User has."
+    )
+
+
+class ReplaceUserInput(_BaseUser):
+    id: str = Field(description="The unique identifier for the User.")
+    name: NameInput = Field(description="The user's real name.")
+    active: bool | None = Field(default=None, description="Indicating the User's active status.")
+    display_name: str | None = Field(default=None, description="Display Name for the User.")
+    entitlements: list[EntitlementInput] | None = Field(
+        default=None, description="A list of entitlements (Workspaces) the User has."
+    )
+
+
+class UserInput(_BaseUser):
+    external_id: str = Field(
+        description="Your unique id for this user (as stored in your company systems)."
+    )
+    name: NameInput = Field(description="The user's real name.")
+
+
+class Meta(AnaplanModel):
+    resource_type: str = Field(description="The type of the resource.")
+    location: str = Field(description="The URI of the resource.")
+
+
+class MetaWithDates(Meta):
+    created: str = Field(description="The timestamp when the resource was created.")
+    last_modified: str = Field(description="The timestamp when the resource was last modified.")
+
+
+class Supported(AnaplanModel):
+    supported: bool = Field(description="Indicates whether the Feature is supported.")
+
+
+class BulkConfig(Supported):
+    max_operations: int = Field(
+        description="The maximum number of operations permitted in a single request."
+    )
+    max_payload_size: int = Field(description="The maximum payload size in bytes.")
+
+
+class FilterConfig(Supported):
+    max_results: int = Field(
+        description="The maximum number of results returned from a filtered query."
+    )
+
+
+class AuthenticationScheme(AnaplanModel):
+    name: str = Field(description="The name of the authentication scheme.")
+    type: str = Field(description="The type of the authentication scheme.")
+    description: str = Field(description="A description of the authentication scheme.")
+    spec_uri: str = Field(
+        description="The URI that points to the specification of the authentication scheme."
+    )
+    documentation_uri: str = Field(
+        description="The URI that points to the documentation of the authentication scheme."
+    )
+
+
+class ServiceProviderConfig(AnaplanModel):
+    schemas: list[str] = Field(
+        default=["urn:ietf:params:scim:schemas:core:2.0:ServiceProviderConfig"],
+        description="Schemas for this resource.",
+    )
+    meta: MetaWithDates = Field(description="Metadata about the resource.")
+    documentation_uri: str = Field(description="URI of the service provider's documentation.")
+    patch: Supported = Field(description="Configuration for PATCH operations.")
+    bulk: BulkConfig = Field(description="Configuration for bulk operations.")
+    filter: FilterConfig = Field(description="Configuration for filtering.")
+    change_password: Supported = Field(description="Configuration for password changes.")
+    sort: Supported = Field(description="Configuration for sorting.")
+    etag: Supported = Field(description="Configuration for ETags.")
+    authentication_schemes: list[AuthenticationScheme] = Field(
+        description="List of supported authentication schemes."
+    )
+
+
+class Resource(AnaplanModel):
+    schemas: list[str] = Field(
+        default=["urn:ietf:params:scim:schemas:core:2.0:ResourceType"],
+        description="Schemas for this resource.",
+    )
+    meta: Meta = Field(description="Metadata about the resource.")
+    id: str = Field(description="The identifier of the resource type.")
+    name: str = Field(description="The name of the resource type.")
+    endpoint: str = Field(description="The endpoint where resources of this type may be accessed.")
+    description: str = Field(description="A description of the resource type.")
+
+
+class Attribute(AnaplanModel):
+    name: str = Field(description="The name of the attribute.")
+    type: str = Field(description="The data type of the attribute.")
+    multi_valued: bool = Field(description="Indicates if the attribute can have multiple values.")
+    description: str = Field(description="A human-readable description of the attribute.")
+    required: bool = Field(description="Indicates if the attribute is required.")
+    case_exact: bool = Field(
+        description="Indicates if case sensitivity should be considered when comparing values."
+    )
+    mutability: str = Field(description="Indicates if and how the attribute can be modified.")
+    returned: str = Field(
+        description="Indicates when the attribute's values are returned in a response."
+    )
+    uniqueness: str = Field(
+        description="Indicates how uniqueness is enforced on the attribute value."
+    )
+    sub_attributes: list["Attribute"] | None = Field(
+        default=None, description="A list of sub-attributes if the attribute is complex."
+    )
+
+
+class Schema(AnaplanModel):
+    meta: Meta = Field(description="Metadata about the schema resource.")
+    id: str = Field(description="The unique identifier for the schema.")
+    name: str = Field(description="The name of the schema.")
+    description: str = Field(description="A description of the schema.")
+    attributes: list[Attribute] = Field(description="A list of attributes that define the schema.")
+
+
+class Operation(AnaplanModel):
+    op: Literal["add", "remove", "replace"] = Field(description="The operation to be performed.")
+    path: str = Field(
+        description=(
+            "A string containing a JSON-Pointer value that references a location within the target "
+            "resource."
+        )
+    )
+    value: Any | None = Field(default=None, description="The value to be used in the operation.")
+
+
+class Replace(Operation):
+    op: Literal["replace"] = Field(
+        default="replace", description="Replace the value at path with the new given value."
+    )
+
+
+class Add(Operation):
+    op: Literal["add"] = Field(
+        default="add", description="Add the given value to the attribute at path."
+    )
+
+
+class Remove(Operation):
+    op: Literal["remove"] = Field(default="remove", description="Remove the value at path.")

{anaplan_sdk-0.5.0a6.dist-info → anaplan_sdk-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anaplan-sdk
-Version: 0.5.0a6
+Version: 0.5.1
 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
@@ -29,7 +29,7 @@ Description-Content-Type: text/markdown
 </h3>
 
 <p align="center" style="font-size: 1.2rem; font-weight: 300; margin: 15px 0">
-    Streamlined Python Interface for Anaplan
+    Streamlined Python Interface for the Anaplan API.
 </p>
 
 <div align="center">
@@ -45,9 +45,11 @@ Description-Content-Type: text/markdown
 </div>
 
 ---
+Streamlined Python Interface for the Anaplan API. Get up and running with the Anaplan API in minutes.
 
 Anaplan SDK is an independent, unofficial project providing pythonic access to Anaplan. It delivers high-level
-abstractions over all Anaplan APIs, allowing you to focus on business requirements rather than implementation details.
+abstractions over all parts of the Anaplan API, allowing you to focus on business requirements rather than
+implementation details.
 
 ## Key Features
 

{anaplan_sdk-0.5.0a6.dist-info → anaplan_sdk-0.5.1.dist-info}/RECORD

@@ -1,22 +1,24 @@
-anaplan_sdk/__init__.py,sha256=WScEKtXlnRLjCb-j3qW9W4kEACTyPsTLFs-L54et2TQ,351
+anaplan_sdk/__init__.py,sha256=wkK6fPTp2-YiR9XVC-O1Iyf1FhVAcAxvJbX_YrF0p_c,397
 anaplan_sdk/_auth.py,sha256=l5z2WCcfQ05OkuQ1dcmikp6dB87Rw1qy2zu8bbaAQTs,16620
 anaplan_sdk/_oauth.py,sha256=AynlJDrGIinQT0jwxI2RSvtU4D7Wasyw3H1uicdlLVI,12672
-anaplan_sdk/_services.py,sha256=n14DvTC2I5ub7yzjWBaAAX9YMF7LwI_BU7zuofAj0l4,13026
+anaplan_sdk/_services.py,sha256=zW0ePBQNyP759OvagDuM02SwkXxyE71IuJNz6wcWVsw,13027
 anaplan_sdk/_utils.py,sha256=jsrhdfLpriMoANukVvXpjpEJ5hWDNx7ZJKAguLvKgJA,7517
 anaplan_sdk/exceptions.py,sha256=ALkA9fBF0NQ7dufFxV6AivjmHyuJk9DOQ9jtJV2n7f0,1809
-anaplan_sdk/_async_clients/__init__.py,sha256=pZXgMMg4S9Aj_pxQCaSiPuNG-sePVGBtNJ0133VjqW4,364
+anaplan_sdk/_async_clients/__init__.py,sha256=oDYqtZIHWMA0iAfAv49htKaiS3sBBouqD_hEqaTWQL8,491
 anaplan_sdk/_async_clients/_alm.py,sha256=_PTD9Eght879HAadjcsfdvS0KCN93jgwpPOF8r3_E14,13178
-anaplan_sdk/_async_clients/_audit.py,sha256=MkCTt7s6039GfDoyyINmDA1vAkZn2xPL4hFK8D4CYsE,2927
-anaplan_sdk/_async_clients/_bulk.py,sha256=TsUUIGK_RPo1yKUyEbaGoFXFMBd0H4YHXI-ABYieZog,30100
+anaplan_sdk/_async_clients/_audit.py,sha256=6s6IceSyz1GXxigH1JAYarL9WMCxUdaCCAj4AjCgY_E,2897
+anaplan_sdk/_async_clients/_bulk.py,sha256=v-nyyf68NTs0PbQ-_5tGKbyUJZhRwZ8k0Pop5Yfg2K8,30517
 anaplan_sdk/_async_clients/_cloud_works.py,sha256=aSgmJQvE7dSJawwK0A7GEBWs7wokWk7eCwRiQuiVg6I,17701
 anaplan_sdk/_async_clients/_cw_flow.py,sha256=qJJFfnwLR7zIdZ_ay4fVI9zr3eP5B-qMcs4GlC9vqQY,3966
+anaplan_sdk/_async_clients/_scim.py,sha256=pBIrxP31n5YhFnDEu0eu8VpQas8SBy6JIdCBn_Z9oNM,7036
 anaplan_sdk/_async_clients/_transactional.py,sha256=f-NlIjvRJ0NIKRcI6ZaO2YatLERwIaC0TY0fKvgUJ5Q,18050
-anaplan_sdk/_clients/__init__.py,sha256=FsbwvZC1FHrxuRXwbPxUzbhz_lO1DpXIxEOjx6-3QuA,219
+anaplan_sdk/_clients/__init__.py,sha256=RB2ZYSW5vDrw8oAeDAkf7jmxu-Fr4yFLt3ebTtigE4Y,421
 anaplan_sdk/_clients/_alm.py,sha256=oRHTjnCuwQYZDE2CBWA1u410jSImIroCsDOSeP9U9w8,12905
 anaplan_sdk/_clients/_audit.py,sha256=Am6VviRw88_VC5i0N7TQTXEm6pJAHZb7xNaJTljD0fc,2850
-anaplan_sdk/_clients/_bulk.py,sha256=9kN8LU3c0iDF-Ov47utBl-dj_hxX3twf7TOcolzogyI,30257
+anaplan_sdk/_clients/_bulk.py,sha256=e1yRHcskAALhG1JClLYknRo_kXZUQkmG_Zc6TXY6IUk,30659
 anaplan_sdk/_clients/_cloud_works.py,sha256=1bbMYM_g8MSorxTI9Au_dFzbJZgKGJVBE6DYlbWBR0U,17492
 anaplan_sdk/_clients/_cw_flow.py,sha256=x64Ua2FwCpt8vab6gaLV8tDwW_ugJrDfU5dv-TnmM2M,3855
+anaplan_sdk/_clients/_scim.py,sha256=a5i7CNVNzF45YMbLY70ta_UumFumthZRmlfNm8rj2O0,6960
 anaplan_sdk/_clients/_transactional.py,sha256=IgkvBaq1Ep5mB-uxu6QoE17cUCfsodvV8dppASQrIT4,17875
 anaplan_sdk/models/__init__.py,sha256=zfwDQJQrXuLEXSpbJcm08a_YK1P7a7u-kMhwtJiJFmA,1783
 anaplan_sdk/models/_alm.py,sha256=oeENd0YM7-LoIRBq2uATIQTxVgIP9rXx3UZE2UnQAp0,4670
@@ -25,7 +27,8 @@ anaplan_sdk/models/_bulk.py,sha256=C0s6XdvHxuJHrPXU-pnZ1JXK1PJOl9FScHArpaox_mQ,8
 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.0a6.dist-info/METADATA,sha256=VZfvzZQlLtBEOFFXMexsiEaetmGPe8fLilZBewT7iOg,3678
-anaplan_sdk-0.5.0a6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-anaplan_sdk-0.5.0a6.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-anaplan_sdk-0.5.0a6.dist-info/RECORD,,
+anaplan_sdk/models/scim.py,sha256=jxPrn-LgoZFYm5rtfCwmceD6i8rkJwAZUlgLx036gjg,11099
+anaplan_sdk-0.5.1.dist-info/METADATA,sha256=Mmspki0fIDEGKOA4hjAmUdi6eGz1iOO8G9TM5lT1Rto,3799
+anaplan_sdk-0.5.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+anaplan_sdk-0.5.1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+anaplan_sdk-0.5.1.dist-info/RECORD,,