anaplan-sdk 0.4.4a4__py3-none-any.whl → 0.5.0__py3-none-any.whl

anaplan_sdk/_async_clients/_cloud_works.py

@@ -1,9 +1,8 @@
+import logging
 from typing import Any, Literal
 
-import httpx
-
-from anaplan_sdk._base import (
-    _AsyncBaseClient,
+from anaplan_sdk._services import _AsyncHttpService
+from anaplan_sdk._utils import (
     connection_body_payload,
     construct_payload,
     integration_payload,
@@ -27,12 +26,14 @@ from anaplan_sdk.models.cloud_works import (
 
 from ._cw_flow import _AsyncFlowClient
 
+logger = logging.getLogger("anaplan_sdk")
+
 
-class _AsyncCloudWorksClient(_AsyncBaseClient):
-    def __init__(self, client: httpx.AsyncClient, retry_count: int) -> None:
+class _AsyncCloudWorksClient:
+    def __init__(self, http: _AsyncHttpService) -> None:
+        self._http = http
         self._url = "https://api.cloudworks.anaplan.com/2/0/integrations"
-        self._flow = _AsyncFlowClient(client, retry_count)
-        super().__init__(retry_count, client)
+        self._flow = _AsyncFlowClient(http)
 
     @property
     def flows(self) -> _AsyncFlowClient:
@@ -41,14 +42,14 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         """
         return self._flow
 
-    async def list_connections(self) -> list[Connection]:
+    async def get_connections(self) -> list[Connection]:
         """
         List all Connections available in CloudWorks.
         :return: A list of connections.
         """
         return [
             Connection.model_validate(e)
-            for e in await self._get_paginated(f"{self._url}/connections", "connections")
+            for e in await self._http.get_paginated(f"{self._url}/connections", "connections")
         ]
 
     async def create_connection(self, con_info: ConnectionInput | dict[str, Any]) -> str:
@@ -59,10 +60,12 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
                against the ConnectionInput model before sending the request.
         :return: The ID of the new connection.
         """
-        res = await self._post(
+        res = await self._http.post(
             f"{self._url}/connections", json=construct_payload(ConnectionInput, con_info)
         )
-        return res["connections"]["connectionId"]
+        connection_id = res["connections"]["connectionId"]
+        logger.info(f"Created connection '{connection_id}'.")
+        return connection_id
 
     async def update_connection(
         self, con_id: str, con_info: ConnectionBody | dict[str, Any]
@@ -74,7 +77,9 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
                as when initially creating the connection again. If you want to update only some of
                the details, use the `patch_connection` method instead.
         """
-        await self._put(f"{self._url}/connections/{con_id}", json=connection_body_payload(con_info))
+        await self._http.put(
+            f"{self._url}/connections/{con_id}", json=connection_body_payload(con_info)
+        )
 
     async def patch_connection(self, con_id: str, body: dict[str, Any]) -> None:
         """
@@ -83,27 +88,29 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :param body: The name and details of the connection. You can pass all the same details as
                when initially creating the connection again, or just any one of them.
         """
-        await self._patch(f"{self._url}/connections/{con_id}", json=body)
+        await self._http.patch(f"{self._url}/connections/{con_id}", json=body)
 
     async def delete_connection(self, con_id: str) -> None:
         """
         Delete an existing connection in CloudWorks.
         :param con_id: The ID of the connection to delete.
         """
-        await self._delete(f"{self._url}/connections/{con_id}")
+        await self._http.delete(f"{self._url}/connections/{con_id}")
+        logger.info(f"Deleted connection '{con_id}'.")
 
-    async def list_integrations(
-        self, sort_by_name: Literal["ascending", "descending"] = "ascending"
+    async def get_integrations(
+        self, sort_by: Literal["name"] | None = None, descending: bool = False
     ) -> list[Integration]:
         """
         List all integrations in CloudWorks.
-        :param sort_by_name: Sort the integrations by name in ascending or descending order.
+        :param sort_by: The field to sort the results by.
+        :param descending: If True, the results will be sorted in descending order.
         :return: A list of integrations.
         """
-        params = {"sortBy": "name" if sort_by_name == "ascending" else "-name"}
+        params = {"sortBy": f"{'-' if descending else ''}{sort_by}"} if sort_by else None
         return [
             Integration.model_validate(e)
-            for e in await self._get_paginated(f"{self._url}", "integrations", params=params)
+            for e in await self._http.get_paginated(f"{self._url}", "integrations", params=params)
         ]
 
     async def get_integration(self, integration_id: str) -> SingleIntegration:
@@ -116,7 +123,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :return: The details of the integration, without the integration type.
         """
         return SingleIntegration.model_validate(
-            (await self._get(f"{self._url}/{integration_id}"))["integration"]
+            (await self._http.get(f"{self._url}/{integration_id}"))["integration"]
         )
 
     async def create_integration(
@@ -143,7 +150,10 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :return: The ID of the new integration.
         """
         json = integration_payload(body)
-        return (await self._post(f"{self._url}", json=json))["integration"]["integrationId"]
+        res = await self._http.post(f"{self._url}", json=json)
+        integration_id = res["integration"]["integrationId"]
+        logger.info(f"Created integration '{integration_id}'.")
+        return integration_id
 
     async def update_integration(
         self, integration_id: str, body: IntegrationInput | IntegrationProcessInput | dict[str, Any]
@@ -156,7 +166,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
                of the details, use the `patch_integration` method instead.
         """
         json = integration_payload(body)
-        await self._put(f"{self._url}/{integration_id}", json=json)
+        await self._http.put(f"{self._url}/{integration_id}", json=json)
 
     async def run_integration(self, integration_id: str) -> str:
         """
@@ -164,14 +174,17 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :param integration_id: The ID of the integration to run.
         :return: The ID of the run instance.
         """
-        return (await self._post_empty(f"{self._url}/{integration_id}/run"))["run"]["id"]
+        run_id = (await self._http.post_empty(f"{self._url}/{integration_id}/run"))["run"]["id"]
+        logger.info(f"Started integration run '{run_id}' for integration '{integration_id}'.")
+        return run_id
 
     async def delete_integration(self, integration_id: str) -> None:
         """
         Delete an existing integration in CloudWorks.
         :param integration_id: The ID of the integration to delete.
         """
-        await self._delete(f"{self._url}/{integration_id}")
+        await self._http.delete(f"{self._url}/{integration_id}")
+        logger.info(f"Deleted integration '{integration_id}'.")
 
     async def get_run_history(self, integration_id: str) -> list[RunSummary]:
         """
@@ -181,9 +194,9 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         """
         return [
             RunSummary.model_validate(e)
-            for e in (await self._get(f"{self._url}/runs/{integration_id}"))["history_of_runs"].get(
-                "runs", []
-            )
+            for e in (await self._http.get(f"{self._url}/runs/{integration_id}"))[
+                "history_of_runs"
+            ].get("runs", [])
         ]
 
     async def get_run_status(self, run_id: str) -> RunStatus:
@@ -192,7 +205,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :param run_id: The ID of the run to retrieve.
         :return: The details of the run.
         """
-        return RunStatus.model_validate((await self._get(f"{self._url}/run/{run_id}"))["run"])
+        return RunStatus.model_validate((await self._http.get(f"{self._url}/run/{run_id}"))["run"])
 
     async def get_run_error(self, run_id: str) -> RunError | None:
         """
@@ -201,7 +214,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :param run_id: The ID of the run to retrieve.
         :return: The details of the run error.
         """
-        run = await self._get(f"{self._url}/runerror/{run_id}")
+        run = await self._http.get(f"{self._url}/runerror/{run_id}")
         return RunError.model_validate(run["runs"]) if run.get("runs") else None
 
     async def create_schedule(
@@ -214,10 +227,11 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
                dictionary as per the documentation. If a dictionary is passed, it will be validated
                against the ScheduleInput model before sending the request.
         """
-        await self._post(
+        await self._http.post(
             f"{self._url}/{integration_id}/schedule",
             json=schedule_payload(integration_id, schedule),
         )
+        logger.info(f"Created schedule for integration '{integration_id}'.")
 
     async def update_schedule(
         self, integration_id: str, schedule: ScheduleInput | dict[str, Any]
@@ -229,7 +243,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
                dictionary as per the documentation. If a dictionary is passed, it will be validated
                against the ScheduleInput model before sending the request.
         """
-        await self._put(
+        await self._http.put(
             f"{self._url}/{integration_id}/schedule",
             json=schedule_payload(integration_id, schedule),
         )
@@ -242,14 +256,15 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :param integration_id: The ID of the integration to schedule.
         :param status: The status of the schedule. This can be either "enabled" or "disabled".
         """
-        await self._post_empty(f"{self._url}/{integration_id}/schedule/status/{status}")
+        await self._http.post_empty(f"{self._url}/{integration_id}/schedule/status/{status}")
 
     async def delete_schedule(self, integration_id: str) -> None:
         """
         Delete an integration schedule in CloudWorks. A schedule must already exist.
         :param integration_id: The ID of the integration to schedule.
         """
-        await self._delete(f"{self._url}/{integration_id}/schedule")
+        await self._http.delete(f"{self._url}/{integration_id}/schedule")
+        logger.info(f"Deleted schedule for integration '{integration_id}'.")
 
     async def get_notification_config(
         self, notification_id: str | None = None, integration_id: str | None = None
@@ -268,7 +283,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         if integration_id:
             notification_id = (await self.get_integration(integration_id)).notification_id
         return NotificationConfig.model_validate(
-            (await self._get(f"{self._url}/notification/{notification_id}"))["notifications"]
+            (await self._http.get(f"{self._url}/notification/{notification_id}"))["notifications"]
         )
 
     async def create_notification_config(self, config: NotificationInput | dict[str, Any]) -> str:
@@ -282,10 +297,12 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
                validated against the NotificationConfig model before sending the request.
         :return: The ID of the new notification configuration.
         """
-        res = await self._post(
+        res = await self._http.post(
             f"{self._url}/notification", json=construct_payload(NotificationInput, config)
         )
-        return res["notification"]["notificationId"]
+        notification_id = res["notification"]["notificationId"]
+        logger.info(f"Created notification configuration '{notification_id}'.")
+        return notification_id
 
     async def update_notification_config(
         self, notification_id: str, config: NotificationInput | dict[str, Any]
@@ -300,7 +317,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
                a dictionary as per the documentation. If a dictionary is passed, it will be
                validated against the NotificationConfig model before sending the request.
         """
-        await self._put(
+        await self._http.put(
             f"{self._url}/notification/{notification_id}",
             json=construct_payload(NotificationInput, config),
         )
@@ -319,7 +336,8 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
             raise ValueError("Either notification_id or integration_id must be specified.")
         if integration_id:
             notification_id = (await self.get_integration(integration_id)).notification_id
-        await self._delete(f"{self._url}/notification/{notification_id}")
+        await self._http.delete(f"{self._url}/notification/{notification_id}")
+        logger.info(f"Deleted notification configuration '{notification_id}'.")
 
     async def get_import_error_dump(self, run_id: str) -> bytes:
         """
@@ -331,7 +349,7 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :param run_id: The ID of the run to retrieve.
         :return: The error dump.
         """
-        return await self._get_binary(f"{self._url}/run/{run_id}/dump")
+        return await self._http.get_binary(f"{self._url}/run/{run_id}/dump")
 
     async def get_process_error_dump(self, run_id: str, action_id: int | str) -> bytes:
         """
@@ -341,4 +359,6 @@ class _AsyncCloudWorksClient(_AsyncBaseClient):
         :param action_id: The ID of the action to retrieve. This can be found in the RunError.
         :return: The error dump.
         """
-        return await self._get_binary(f"{self._url}/run/{run_id}/process/import/{action_id}/dumps")
+        return await self._http.get_binary(
+            f"{self._url}/run/{run_id}/process/import/{action_id}/dumps"
+        )

anaplan_sdk/_async_clients/_cw_flow.py

@@ -1,17 +1,19 @@
+import logging
 from typing import Any
 
-import httpx
-
-from anaplan_sdk._base import _AsyncBaseClient, construct_payload
+from anaplan_sdk._services import _AsyncHttpService
+from anaplan_sdk._utils import construct_payload
 from anaplan_sdk.models.flows import Flow, FlowInput, FlowSummary
 
+logger = logging.getLogger("anaplan_sdk")
+
 
-class _AsyncFlowClient(_AsyncBaseClient):
-    def __init__(self, client: httpx.AsyncClient, retry_count: int) -> None:
+class _AsyncFlowClient:
+    def __init__(self, http: _AsyncHttpService) -> None:
+        self._http = http
         self._url = "https://api.cloudworks.anaplan.com/2/0/integrationflows"
-        super().__init__(retry_count, client)
 
-    async def list_flows(self, current_user_only: bool = False) -> list[FlowSummary]:
+    async def get_flows(self, current_user_only: bool = False) -> list[FlowSummary]:
         """
         List all flows in CloudWorks.
         :param current_user_only: Filters the flows to only those created by the current user.
@@ -20,9 +22,7 @@ class _AsyncFlowClient(_AsyncBaseClient):
         params = {"myIntegrations": 1 if current_user_only else 0}
         return [
             FlowSummary.model_validate(e)
-            for e in await self._get_paginated(
-                self._url, "integrationFlows", page_size=25, params=params
-            )
+            for e in await self._http.get_paginated(self._url, "integrationFlows", params=params)
         ]
 
     async def get_flow(self, flow_id: str) -> Flow:
@@ -32,7 +32,9 @@ class _AsyncFlowClient(_AsyncBaseClient):
         :param flow_id: The ID of the flow to get.
         :return: The Flow object.
         """
-        return Flow.model_validate((await self._get(f"{self._url}/{flow_id}"))["integrationFlow"])
+        return Flow.model_validate(
+            (await self._http.get(f"{self._url}/{flow_id}"))["integrationFlow"]
+        )
 
     async def run_flow(self, flow_id: str, only_steps: list[str] = None) -> str:
         """
@@ -45,11 +47,13 @@ class _AsyncFlowClient(_AsyncBaseClient):
         """
         url = f"{self._url}/{flow_id}/run"
         res = await (
-            self._post(url, json={"stepsToRun": only_steps})
+            self._http.post(url, json={"stepsToRun": only_steps})
             if only_steps
-            else self._post_empty(url)
+            else self._http.post_empty(url)
         )
-        return res["run"]["id"]
+        run_id = res["run"]["id"]
+        logger.info(f"Started flow run '{run_id}' for flow '{flow_id}'.")
+        return run_id
 
     async def create_flow(self, flow: FlowInput | dict[str, Any]) -> str:
         """
@@ -59,8 +63,10 @@ class _AsyncFlowClient(_AsyncBaseClient):
         :param flow: The flow to create. This can be a FlowInput object or a dictionary.
         :return: The ID of the created flow.
         """
-        res = await self._post(self._url, json=construct_payload(FlowInput, flow))
-        return res["integrationFlow"]["integrationFlowId"]
+        res = await self._http.post(self._url, json=construct_payload(FlowInput, flow))
+        flow_id = res["integrationFlow"]["integrationFlowId"]
+        logger.info(f"Created flow '{flow_id}'.")
+        return flow_id
 
     async def update_flow(self, flow_id: str, flow: FlowInput | dict[str, Any]) -> None:
         """
@@ -69,7 +75,8 @@ class _AsyncFlowClient(_AsyncBaseClient):
         :param flow_id: The ID of the flow to update.
         :param flow: The flow to update. This can be a FlowInput object or a dictionary.
         """
-        await self._put(f"{self._url}/{flow_id}", json=construct_payload(FlowInput, flow))
+        await self._http.put(f"{self._url}/{flow_id}", json=construct_payload(FlowInput, flow))
+        logger.info(f"Updated flow '{flow_id}'.")
 
     async def delete_flow(self, flow_id: str) -> None:
         """
@@ -77,4 +84,5 @@ class _AsyncFlowClient(_AsyncBaseClient):
         the flow is running or if it has any running steps.
         :param flow_id: The ID of the flow to delete.
         """
-        await self._delete(f"{self._url}/{flow_id}")
+        await self._http.delete(f"{self._url}/{flow_id}")
+        logger.info(f"Deleted flow '{flow_id}'.")

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