anaplan-sdk 0.4.5__py3-none-any.whl → 0.5.0__py3-none-any.whl

anaplan_sdk/_clients/_cloud_works.py

@@ -1,9 +1,8 @@
+import logging
 from typing import Any, Literal
 
-import httpx
-
-from anaplan_sdk._base import (
-    _BaseClient,
+from anaplan_sdk._services import _HttpService
+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 _FlowClient
 
+logger = logging.getLogger("anaplan_sdk")
+
 
-class _CloudWorksClient(_BaseClient):
-    def __init__(self, client: httpx.Client, retry_count: int) -> None:
+class _CloudWorksClient:
+    def __init__(self, http: _HttpService) -> None:
+        self._http = http
         self._url = "https://api.cloudworks.anaplan.com/2/0/integrations"
-        self._flow = _FlowClient(client, retry_count)
-        super().__init__(retry_count, client)
+        self._flow = _FlowClient(self._http)
 
     @property
     def flows(self) -> _FlowClient:
@@ -41,14 +42,14 @@ class _CloudWorksClient(_BaseClient):
         """
         return self._flow
 
-    def list_connections(self) -> list[Connection]:
+    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 self._get_paginated(f"{self._url}/connections", "connections")
+            for e in self._http.get_paginated(f"{self._url}/connections", "connections")
         ]
 
     def create_connection(self, con_info: ConnectionInput | dict[str, Any]) -> str:
@@ -59,10 +60,12 @@ class _CloudWorksClient(_BaseClient):
                against the ConnectionInput model before sending the request.
         :return: The ID of the new connection.
         """
-        res = self._post(
+        res = 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
 
     def update_connection(self, con_id: str, con_info: ConnectionBody | dict[str, Any]) -> None:
         """
@@ -72,7 +75,7 @@ class _CloudWorksClient(_BaseClient):
                as when initially creating the connection again. If you want to update only some of
                the details, use the `patch_connection` method instead.
         """
-        self._put(f"{self._url}/connections/{con_id}", json=connection_body_payload(con_info))
+        self._http.put(f"{self._url}/connections/{con_id}", json=connection_body_payload(con_info))
 
     def patch_connection(self, con_id: str, body: dict[str, Any]) -> None:
         """
@@ -81,27 +84,29 @@ class _CloudWorksClient(_BaseClient):
         :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.
         """
-        self._patch(f"{self._url}/connections/{con_id}", json=body)
+        self._http.patch(f"{self._url}/connections/{con_id}", json=body)
 
     def delete_connection(self, con_id: str) -> None:
         """
         Delete an existing connection in CloudWorks.
         :param con_id: The ID of the connection to delete.
         """
-        self._delete(f"{self._url}/connections/{con_id}")
+        self._http.delete(f"{self._url}/connections/{con_id}")
+        logger.info(f"Deleted connection '{con_id}'.")
 
-    def list_integrations(
-        self, sort_by_name: Literal["ascending", "descending"] = "ascending"
+    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 self._get_paginated(f"{self._url}", "integrations", params=params)
+            for e in self._http.get_paginated(f"{self._url}", "integrations", params=params)
         ]
 
     def get_integration(self, integration_id: str) -> SingleIntegration:
@@ -114,7 +119,7 @@ class _CloudWorksClient(_BaseClient):
         :return: The details of the integration, without the integration type.
         """
         return SingleIntegration.model_validate(
-            (self._get(f"{self._url}/{integration_id}"))["integration"]
+            (self._http.get(f"{self._url}/{integration_id}"))["integration"]
         )
 
     def create_integration(
@@ -141,7 +146,11 @@ class _CloudWorksClient(_BaseClient):
         :return: The ID of the new integration.
         """
         json = integration_payload(body)
-        return (self._post(f"{self._url}", json=json))["integration"]["integrationId"]
+        integration_id = (self._http.post(f"{self._url}", json=json))["integration"][
+            "integrationId"
+        ]
+        logger.info(f"Created integration '{integration_id}'.")
+        return integration_id
 
     def update_integration(
         self, integration_id: str, body: IntegrationInput | IntegrationProcessInput | dict[str, Any]
@@ -154,7 +163,7 @@ class _CloudWorksClient(_BaseClient):
                of the details, use the `patch_integration` method instead.
         """
         json = integration_payload(body)
-        self._put(f"{self._url}/{integration_id}", json=json)
+        self._http.put(f"{self._url}/{integration_id}", json=json)
 
     def run_integration(self, integration_id: str) -> str:
         """
@@ -162,14 +171,17 @@ class _CloudWorksClient(_BaseClient):
         :param integration_id: The ID of the integration to run.
         :return: The ID of the run instance.
         """
-        return (self._post_empty(f"{self._url}/{integration_id}/run"))["run"]["id"]
+        run_id = (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
 
     def delete_integration(self, integration_id: str) -> None:
         """
         Delete an existing integration in CloudWorks.
         :param integration_id: The ID of the integration to delete.
         """
-        self._delete(f"{self._url}/{integration_id}")
+        self._http.delete(f"{self._url}/{integration_id}")
+        logger.info(f"Deleted integration '{integration_id}'.")
 
     def get_run_history(self, integration_id: str) -> list[RunSummary]:
         """
@@ -179,7 +191,7 @@ class _CloudWorksClient(_BaseClient):
         """
         return [
             RunSummary.model_validate(e)
-            for e in (self._get(f"{self._url}/runs/{integration_id}"))["history_of_runs"].get(
+            for e in (self._http.get(f"{self._url}/runs/{integration_id}"))["history_of_runs"].get(
                 "runs", []
             )
         ]
@@ -190,7 +202,7 @@ class _CloudWorksClient(_BaseClient):
         :param run_id: The ID of the run to retrieve.
         :return: The details of the run.
         """
-        return RunStatus.model_validate((self._get(f"{self._url}/run/{run_id}"))["run"])
+        return RunStatus.model_validate((self._http.get(f"{self._url}/run/{run_id}"))["run"])
 
     def get_run_error(self, run_id: str) -> RunError | None:
         """
@@ -199,7 +211,7 @@ class _CloudWorksClient(_BaseClient):
         :param run_id: The ID of the run to retrieve.
         :return: The details of the run error.
         """
-        run = self._get(f"{self._url}/runerror/{run_id}")
+        run = self._http.get(f"{self._url}/runerror/{run_id}")
         return RunError.model_validate(run["runs"]) if run.get("runs") else None
 
     def create_schedule(
@@ -212,10 +224,11 @@ class _CloudWorksClient(_BaseClient):
                dictionary as per the documentation. If a dictionary is passed, it will be validated
                against the ScheduleInput model before sending the request.
         """
-        self._post(
+        self._http.post(
             f"{self._url}/{integration_id}/schedule",
             json=schedule_payload(integration_id, schedule),
         )
+        logger.info(f"Created schedule for integration '{integration_id}'.")
 
     def update_schedule(
         self, integration_id: str, schedule: ScheduleInput | dict[str, Any]
@@ -227,10 +240,11 @@ class _CloudWorksClient(_BaseClient):
                dictionary as per the documentation. If a dictionary is passed, it will be validated
                against the ScheduleInput model before sending the request.
         """
-        self._put(
+        self._http.put(
             f"{self._url}/{integration_id}/schedule",
             json=schedule_payload(integration_id, schedule),
         )
+        logger.info(f"Updated schedule for integration '{integration_id}'.")
 
     def set_schedule_status(
         self, integration_id: str, status: Literal["enabled", "disabled"]
@@ -240,14 +254,16 @@ class _CloudWorksClient(_BaseClient):
         :param integration_id: The ID of the integration to schedule.
         :param status: The status of the schedule. This can be either "enabled" or "disabled".
         """
-        self._post_empty(f"{self._url}/{integration_id}/schedule/status/{status}")
+        self._http.post_empty(f"{self._url}/{integration_id}/schedule/status/{status}")
+        logger.info(f"Set schedule status to '{status}' for integration '{integration_id}'.")
 
     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.
         """
-        self._delete(f"{self._url}/{integration_id}/schedule")
+        self._http.delete(f"{self._url}/{integration_id}/schedule")
+        logger.info(f"Deleted schedule for integration '{integration_id}'.")
 
     def get_notification_config(
         self, notification_id: str | None = None, integration_id: str | None = None
@@ -266,7 +282,7 @@ class _CloudWorksClient(_BaseClient):
         if integration_id:
             notification_id = (self.get_integration(integration_id)).notification_id
         return NotificationConfig.model_validate(
-            (self._get(f"{self._url}/notification/{notification_id}"))["notifications"]
+            (self._http.get(f"{self._url}/notification/{notification_id}"))["notifications"]
         )
 
     def create_notification_config(self, config: NotificationInput | dict[str, Any]) -> str:
@@ -280,17 +296,19 @@ class _CloudWorksClient(_BaseClient):
                validated against the NotificationConfig model before sending the request.
         :return: The ID of the new notification configuration.
         """
-        res = self._post(
+        res = 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
 
     def update_notification_config(
         self, notification_id: str, config: NotificationInput | dict[str, Any]
     ) -> None:
         """
         Update a notification configuration for an integration in CloudWorks. You cannot pass empty
-        values or nulls to any of the fields If you want to for e.g. override  an existing list of
+        values or nulls to any of the fields If you want to for e.g. override an existing list of
         users with an empty one, you must delete the notification configuration and create a new
         one with only the values you want to keep.
         :param notification_id: The ID of the notification configuration to update.
@@ -298,7 +316,7 @@ class _CloudWorksClient(_BaseClient):
                a dictionary as per the documentation. If a dictionary is passed, it will be
                validated against the NotificationConfig model before sending the request.
         """
-        self._put(
+        self._http.put(
             f"{self._url}/notification/{notification_id}",
             json=construct_payload(NotificationInput, config),
         )
@@ -317,7 +335,8 @@ class _CloudWorksClient(_BaseClient):
             raise ValueError("Either notification_id or integration_id must be specified.")
         if integration_id:
             notification_id = (self.get_integration(integration_id)).notification_id
-        self._delete(f"{self._url}/notification/{notification_id}")
+        self._http.delete(f"{self._url}/notification/{notification_id}")
+        logger.info(f"Deleted notification configuration '{notification_id}'.")
 
     def get_import_error_dump(self, run_id: str) -> bytes:
         """
@@ -329,7 +348,7 @@ class _CloudWorksClient(_BaseClient):
         :param run_id: The ID of the run to retrieve.
         :return: The error dump.
         """
-        return self._get_binary(f"{self._url}/run/{run_id}/dump")
+        return self._http.get_binary(f"{self._url}/run/{run_id}/dump")
 
     def get_process_error_dump(self, run_id: str, action_id: int | str) -> bytes:
         """
@@ -339,4 +358,4 @@ class _CloudWorksClient(_BaseClient):
         :param action_id: The ID of the action to retrieve. This can be found in the RunError.
         :return: The error dump.
         """
-        return self._get_binary(f"{self._url}/run/{run_id}/process/import/{action_id}/dumps")
+        return self._http.get_binary(f"{self._url}/run/{run_id}/process/import/{action_id}/dumps")

anaplan_sdk/_clients/_cw_flow.py

@@ -1,17 +1,19 @@
+import logging
 from typing import Any
 
-import httpx
-
-from anaplan_sdk._base import _BaseClient, construct_payload
+from anaplan_sdk._services import _HttpService
+from anaplan_sdk._utils import construct_payload
 from anaplan_sdk.models.flows import Flow, FlowInput, FlowSummary
 
+logger = logging.getLogger("anaplan_sdk")
+
 
-class _FlowClient(_BaseClient):
-    def __init__(self, client: httpx.Client, retry_count: int) -> None:
+class _FlowClient:
+    def __init__(self, http: _HttpService) -> None:
+        self._http = http
         self._url = "https://api.cloudworks.anaplan.com/2/0/integrationflows"
-        super().__init__(retry_count, client)
 
-    def list_flows(self, current_user_only: bool = False) -> list[FlowSummary]:
+    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,7 +22,7 @@ class _FlowClient(_BaseClient):
         params = {"myIntegrations": 1 if current_user_only else 0}
         return [
             FlowSummary.model_validate(e)
-            for e in self._get_paginated(self._url, "integrationFlows", page_size=25, params=params)
+            for e in self._http.get_paginated(self._url, "integrationFlows", params=params)
         ]
 
     def get_flow(self, flow_id: str) -> Flow:
@@ -30,7 +32,7 @@ class _FlowClient(_BaseClient):
         :param flow_id: The ID of the flow to get.
         :return: The Flow object.
         """
-        return Flow.model_validate((self._get(f"{self._url}/{flow_id}"))["integrationFlow"])
+        return Flow.model_validate((self._http.get(f"{self._url}/{flow_id}"))["integrationFlow"])
 
     def run_flow(self, flow_id: str, only_steps: list[str] = None) -> str:
         """
@@ -43,11 +45,13 @@ class _FlowClient(_BaseClient):
         """
         url = f"{self._url}/{flow_id}/run"
         res = (
-            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
 
     def create_flow(self, flow: FlowInput | dict[str, Any]) -> str:
         """
@@ -57,8 +61,10 @@ class _FlowClient(_BaseClient):
         :param flow: The flow to create. This can be a FlowInput object or a dictionary.
         :return: The ID of the created flow.
         """
-        res = self._post(self._url, json=construct_payload(FlowInput, flow))
-        return res["integrationFlow"]["integrationFlowId"]
+        res = 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
 
     def update_flow(self, flow_id: str, flow: FlowInput | dict[str, Any]) -> None:
         """
@@ -67,7 +73,8 @@ class _FlowClient(_BaseClient):
         :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.
         """
-        self._put(f"{self._url}/{flow_id}", json=construct_payload(FlowInput, flow))
+        self._http.put(f"{self._url}/{flow_id}", json=construct_payload(FlowInput, flow))
+        logger.info(f"Updated flow '{flow_id}'.")
 
     def delete_flow(self, flow_id: str) -> None:
         """
@@ -75,4 +82,5 @@ class _FlowClient(_BaseClient):
         the flow is running or if it has any running steps.
         :param flow_id: The ID of the flow to delete.
         """
-        self._delete(f"{self._url}/{flow_id}")
+        self._http.delete(f"{self._url}/{flow_id}")
+        logger.info(f"Deleted flow '{flow_id}'.")

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