uipath 2.0.0.dev3__py3-none-any.whl → 2.0.1.dev1__py3-none-any.whl

uipath/_services/_base_service.py

@@ -0,0 +1,250 @@
+import inspect
+from logging import getLogger
+from typing import Any, Union
+
+from httpx import (
+    URL,
+    AsyncClient,
+    Client,
+    ConnectTimeout,
+    Headers,
+    Response,
+    TimeoutException,
+)
+from tenacity import (
+    retry,
+    retry_if_exception,
+    retry_if_result,
+    wait_exponential,
+)
+
+from .._config import Config
+from .._execution_context import ExecutionContext
+from .._utils import user_agent_value
+from .._utils.constants import HEADER_USER_AGENT
+
+
+def is_retryable_exception(exception: BaseException) -> bool:
+    return isinstance(exception, (ConnectTimeout, TimeoutException))
+
+
+def is_retryable_status_code(response: Response) -> bool:
+    return response.status_code >= 500 and response.status_code < 600
+
+
+class BaseService:
+    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+        self._logger = getLogger("uipath")
+        self._config = config
+        self._execution_context = execution_context
+        self._tenant_scope_client = Client(
+            base_url=self._config.base_url, headers=Headers(self.default_headers)
+        )
+        self._tenant_scope_client_async = AsyncClient(
+            base_url=self._config.base_url, headers=Headers(self.default_headers)
+        )
+        org_scope_base_url = self.__get_org_scope_base_url()
+        self._org_scope_client = Client(
+            base_url=org_scope_base_url, headers=self.default_headers
+        )
+        self._org_scope_client_async = AsyncClient(
+            base_url=org_scope_base_url, headers=self.default_headers
+        )
+
+        self._logger.debug(f"HEADERS: {self.default_headers}")
+
+        super().__init__()
+
+    @retry(
+        retry=(
+            retry_if_exception(is_retryable_exception)
+            | retry_if_result(is_retryable_status_code)
+        ),
+        wait=wait_exponential(multiplier=1, min=1, max=10),
+    )
+    def request(
+        self,
+        method: str,
+        url: Union[URL, str],
+        **kwargs: Any,
+    ) -> Response:
+        self._logger.debug(f"Request: {method} {url}")
+        self._logger.debug(
+            f"HEADERS: {kwargs.get('headers', self._tenant_scope_client.headers)}"
+        )
+
+        try:
+            stack = inspect.stack()
+
+            # use the third frame because of the retry decorator
+            caller_frame = stack[3].frame
+            function_name = caller_frame.f_code.co_name
+
+            if "self" in caller_frame.f_locals:
+                module_name = type(caller_frame.f_locals["self"]).__name__
+            elif "cls" in caller_frame.f_locals:
+                module_name = caller_frame.f_locals["cls"].__name__
+            else:
+                module_name = ""
+        except Exception:
+            function_name = ""
+            module_name = ""
+
+        specific_component = (
+            f"{module_name}.{function_name}" if module_name and function_name else ""
+        )
+        headers = kwargs.get("headers", {})
+        headers[HEADER_USER_AGENT] = user_agent_value(specific_component)
+
+        response = self._tenant_scope_client.request(method, url, **kwargs)
+        response.raise_for_status()
+
+        return response
+
+    @retry(
+        retry=(
+            retry_if_exception(is_retryable_exception)
+            | retry_if_result(is_retryable_status_code)
+        ),
+        wait=wait_exponential(multiplier=1, min=1, max=10),
+    )
+    async def request_async(
+        self,
+        method: str,
+        url: Union[URL, str],
+        **kwargs: Any,
+    ) -> Response:
+        self._logger.debug(f"Request: {method} {url}")
+        self._logger.debug(
+            f"HEADERS: {kwargs.get('headers', self._tenant_scope_client.headers)}"
+        )
+
+        try:
+            stack = inspect.stack()
+
+            # use the third frame because of the retry decorator
+            caller_frame = stack[3].frame
+            function_name = caller_frame.f_code.co_name
+
+            if "self" in caller_frame.f_locals:
+                module_name = type(caller_frame.f_locals["self"]).__name__
+            elif "cls" in caller_frame.f_locals:
+                module_name = caller_frame.f_locals["cls"].__name__
+            else:
+                module_name = ""
+        except Exception:
+            function_name = ""
+            module_name = ""
+
+        specific_component = (
+            f"{module_name}.{function_name}" if module_name and function_name else ""
+        )
+        headers = kwargs.get("headers", {})
+        headers[HEADER_USER_AGENT] = user_agent_value(specific_component)
+
+        response = await self._tenant_scope_client_async.request(method, url, **kwargs)
+        response.raise_for_status()
+
+        return response
+
+    def request_org_scope(
+        self,
+        method: str,
+        url: Union[URL, str],
+        **kwargs: Any,
+    ) -> Response:
+        self._logger.debug(f"Request: {method} {url}")
+        self._logger.debug(
+            f"HEADERS: {kwargs.get('headers', self._tenant_scope_client.headers)}"
+        )
+
+        try:
+            stack = inspect.stack()
+
+            # use the third frame because of the retry decorator
+            caller_frame = stack[3].frame
+            function_name = caller_frame.f_code.co_name
+
+            if "self" in caller_frame.f_locals:
+                module_name = type(caller_frame.f_locals["self"]).__name__
+            elif "cls" in caller_frame.f_locals:
+                module_name = caller_frame.f_locals["cls"].__name__
+            else:
+                module_name = ""
+        except Exception:
+            function_name = ""
+            module_name = ""
+
+        specific_component = (
+            f"{module_name}.{function_name}" if module_name and function_name else ""
+        )
+        headers = kwargs.get("headers", {})
+        headers[HEADER_USER_AGENT] = user_agent_value(specific_component)
+
+        response = self._org_scope_client.request(method, url, **kwargs)
+        response.raise_for_status()
+
+        return response
+
+    async def request_org_scope_async(
+        self,
+        method: str,
+        url: Union[URL, str],
+        **kwargs: Any,
+    ) -> Response:
+        self._logger.debug(f"Request: {method} {url}")
+        self._logger.debug(
+            f"HEADERS: {kwargs.get('headers', self._tenant_scope_client.headers)}"
+        )
+
+        try:
+            stack = inspect.stack()
+
+            # use the third frame because of the retry decorator
+            caller_frame = stack[3].frame
+            function_name = caller_frame.f_code.co_name
+
+            if "self" in caller_frame.f_locals:
+                module_name = type(caller_frame.f_locals["self"]).__name__
+            elif "cls" in caller_frame.f_locals:
+                module_name = caller_frame.f_locals["cls"].__name__
+            else:
+                module_name = ""
+        except Exception:
+            function_name = ""
+            module_name = ""
+
+        specific_component = (
+            f"{module_name}.{function_name}" if module_name and function_name else ""
+        )
+        headers = kwargs.get("headers", {})
+        headers[HEADER_USER_AGENT] = user_agent_value(specific_component)
+
+        response = await self._org_scope_client_async.request(method, url, **kwargs)
+        response.raise_for_status()
+
+        return response
+
+    @property
+    def default_headers(self) -> dict[str, str]:
+        return {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            **self.auth_headers,
+            **self.custom_headers,
+        }
+
+    @property
+    def auth_headers(self) -> dict[str, str]:
+        header = f"Bearer {self._config.secret}"
+        return {"Authorization": header}
+
+    @property
+    def custom_headers(self) -> dict[str, str]:
+        return {}
+
+    def __get_org_scope_base_url(self) -> str:
+        base_url = str(self._config.base_url)
+        if base_url.endswith("/"):
+            base_url = base_url[:-1]
+        return base_url.rsplit("/", 1)[0] + "/"

uipath/_services/actions_service.py

@@ -0,0 +1,271 @@
+import os
+import uuid
+from json import dumps
+from typing import Any, Dict, Optional, Tuple
+
+from .._config import Config
+from .._execution_context import ExecutionContext
+from .._folder_context import FolderContext
+from .._models import Action, ActionSchema
+from .._utils import Endpoint, RequestSpec
+from .._utils.constants import ENV_TENANT_ID, HEADER_TENANT_ID
+from ._base_service import BaseService
+
+
+def _create_spec(
+    title: str,
+    data: Optional[Dict[str, Any]],
+    action_schema: Optional[ActionSchema],
+    app_key: str = "",
+    app_version: int = -1,
+) -> RequestSpec:
+    field_list = []
+    outcome_list = []
+    if action_schema:
+        if action_schema.inputs:
+            for input_field in action_schema.inputs:
+                field_name = input_field.name
+                field_list.append(
+                    {
+                        "Id": input_field.key,
+                        "Name": field_name,
+                        "Title": field_name,
+                        "Type": "Fact",
+                        "Value": data.get(field_name, "") if data is not None else "",
+                    }
+                )
+        if action_schema.outputs:
+            for output_field in action_schema.outputs:
+                field_name = output_field.name
+                field_list.append(
+                    {
+                        "Id": output_field.key,
+                        "Name": field_name,
+                        "Title": field_name,
+                        "Type": "Fact",
+                        "Value": "",
+                    }
+                )
+        if action_schema.in_outs:
+            for inout_field in action_schema.in_outs:
+                field_name = inout_field.name
+                field_list.append(
+                    {
+                        "Id": inout_field.key,
+                        "Name": field_name,
+                        "Title": field_name,
+                        "Type": "Fact",
+                        "Value": data.get(field_name, "") if data is not None else "",
+                    }
+                )
+        if action_schema.outcomes:
+            for outcome in action_schema.outcomes:
+                outcome_list.append(
+                    {
+                        "Id": action_schema.key,
+                        "Name": outcome.name,
+                        "Title": outcome.name,
+                        "Type": "Action.Http",
+                        "IsPrimary": True,
+                    }
+                )
+
+    return RequestSpec(
+        method="POST",
+        endpoint=Endpoint("/orchestrator_/tasks/AppTasks/CreateAppTask"),
+        content=dumps(
+            {
+                "appId": app_key,
+                "appVersion": app_version,
+                "title": title,
+                "data": data if data is not None else {},
+                "actionableMessageMetaData": {
+                    "fieldSet": {
+                        "id": str(uuid.uuid4()),
+                        "fields": field_list,
+                    }
+                    if len(field_list) != 0
+                    else {},
+                    "actionSet": {
+                        "id": str(uuid.uuid4()),
+                        "actions": outcome_list,
+                    }
+                    if len(outcome_list) != 0
+                    else {},
+                }
+                if action_schema is not None
+                else {},
+            }
+        ),
+    )
+
+
+def _retrieve_action_spec(action_key: str) -> RequestSpec:
+    return RequestSpec(
+        method="GET",
+        endpoint=Endpoint("/orchestrator_/tasks/GenericTasks/GetTaskDataByKey"),
+        params={"taskKey": action_key},
+    )
+
+
+def _assign_task_spec(task_key: str, assignee: str) -> RequestSpec:
+    return RequestSpec(
+        method="POST",
+        endpoint=Endpoint(
+            "/orchestrator_/odata/Tasks/UiPath.Server.Configuration.OData.AssignTasks"
+        ),
+        content=dumps(
+            {"taskAssignments": [{"taskId": task_key, "UserNameOrEmail": assignee}]}
+        ),
+    )
+
+
+def _retrieve_app_key_spec(app_name: str) -> RequestSpec:
+    tenant_id = os.getenv(ENV_TENANT_ID, None)
+    if not tenant_id:
+        raise Exception(f"{ENV_TENANT_ID} env var is not set")
+    return RequestSpec(
+        method="GET",
+        endpoint=Endpoint("/apps_/default/api/v1/default/deployed-action-apps-schemas"),
+        params={"search": app_name},
+        headers={HEADER_TENANT_ID: tenant_id},
+    )
+
+
+class ActionsService(FolderContext, BaseService):
+    """Service for managing UiPath Actions.
+
+    Actions are task-based automation components that can be integrated into
+    applications and processes. They represent discrete units of work that can
+    be triggered and monitored through the UiPath API.
+
+    This service provides methods to create and retrieve actions, supporting
+    both app-specific and generic actions. It inherits folder context management
+    capabilities from FolderContext.
+    """
+
+    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    async def create_async(
+        self,
+        title: str,
+        data: Optional[Dict[str, Any]] = None,
+        *,
+        app_name: str = "",
+        app_key: str = "",
+        app_version: int = -1,
+        assignee: str = "",
+    ) -> Action:
+        (key, action_schema) = (
+            (app_key, None)
+            if app_key
+            else await self.__get_app_key_and_schema_async(app_name)
+        )
+        spec = _create_spec(
+            title=title,
+            data=data,
+            app_key=key,
+            app_version=app_version,
+            action_schema=action_schema,
+        )
+
+        response = await self.request_async(
+            spec.method, spec.endpoint, content=spec.content
+        )
+        json_response = response.json()
+        if assignee:
+            spec = _assign_task_spec(json_response["id"], assignee)
+            await self.request_async(spec.method, spec.endpoint, content=spec.content)
+        return Action.model_validate(json_response)
+
+    def create(
+        self,
+        title: str,
+        data: Optional[Dict[str, Any]] = None,
+        *,
+        app_name: str = "",
+        app_key: str = "",
+        app_version: int = -1,
+        assignee: str = "",
+    ) -> Action:
+        (key, action_schema) = (
+            (app_key, None) if app_key else self.__get_app_key_and_schema(app_name)
+        )
+        spec = _create_spec(
+            title=title,
+            data=data,
+            app_key=key,
+            app_version=app_version,
+            action_schema=action_schema,
+        )
+
+        response = self.request(spec.method, spec.endpoint, content=spec.content)
+        json_response = response.json()
+        if assignee:
+            spec = _assign_task_spec(json_response["id"], assignee)
+            print(spec)
+            self.request(spec.method, spec.endpoint, content=spec.content)
+        return Action.model_validate(json_response)
+
+    def retrieve(
+        self,
+        action_key: str,
+    ) -> Action:
+        spec = _retrieve_action_spec(action_key=action_key)
+        response = self.request(spec.method, spec.endpoint, params=spec.params)
+
+        return Action.model_validate(response.json())
+
+    async def retrieve_async(
+        self,
+        action_key: str,
+    ) -> Action:
+        spec = _retrieve_action_spec(action_key=action_key)
+        response = await self.request_async(
+            spec.method, spec.endpoint, params=spec.params
+        )
+
+        return Action.model_validate(response.json())
+
+    async def __get_app_key_and_schema_async(
+        self, app_name: str
+    ) -> Tuple[str, Optional[ActionSchema]]:
+        if not app_name:
+            raise Exception("appName or appKey is required")
+        spec = _retrieve_app_key_spec(app_name=app_name)
+
+        response = await self.request_org_scope_async(
+            spec.method, spec.endpoint, params=spec.params, headers=spec.headers
+        )
+        deployed_app = response.json()["deployed"][0]
+        return (deployed_app["systemName"], deployed_app["actionSchema"])
+
+    def __get_app_key_and_schema(
+        self, app_name: str
+    ) -> Tuple[str, Optional[ActionSchema]]:
+        if not app_name:
+            raise Exception("appName or appKey is required")
+
+        spec = _retrieve_app_key_spec(app_name=app_name)
+
+        response = self.request_org_scope(
+            spec.method, spec.endpoint, params=spec.params, headers=spec.headers
+        )
+
+        deployed_app = response.json()["deployed"][0]
+        action_schema = deployed_app["actionSchema"]
+        return (
+            deployed_app["systemName"],
+            ActionSchema(
+                key=action_schema["key"],
+                in_outs=action_schema["inOuts"],
+                inputs=action_schema["inputs"],
+                outputs=action_schema["outputs"],
+                outcomes=action_schema["outcomes"],
+            ),
+        )
+
+    @property
+    def custom_headers(self) -> Dict[str, str]:
+        return self.folder_headers

uipath/_services/api_client.py

@@ -0,0 +1,89 @@
+from typing import Any, Union
+
+from httpx import URL, Response
+
+from .._config import Config
+from .._execution_context import ExecutionContext
+from .._folder_context import FolderContext
+from ._base_service import BaseService
+
+
+class ApiClient(FolderContext, BaseService):
+    """Low-level client for making direct HTTP requests to the UiPath API.
+
+    This class provides a flexible way to interact with the UiPath API when the
+    higher-level service classes don't provide the needed functionality. It inherits
+    from both FolderContext and BaseService to provide folder-aware request capabilities
+    with automatic authentication and retry logic.
+    """
+
+    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    def request(
+        self,
+        method: str,
+        url: Union[URL, str],
+        **kwargs: Any,
+    ) -> Response:
+        if kwargs.get("include_folder_headers", False):
+            kwargs["headers"] = {
+                **kwargs.get("headers", self._tenant_scope_client.headers),
+                **self.folder_headers,
+            }
+
+        if "include_folder_headers" in kwargs:
+            del kwargs["include_folder_headers"]
+
+        return super().request(method, url, **kwargs)
+
+    async def request_async(
+        self,
+        method: str,
+        url: Union[URL, str],
+        **kwargs: Any,
+    ) -> Response:
+        if kwargs.get("include_folder_headers", False):
+            kwargs["headers"] = {
+                **kwargs.get("headers", self._tenant_scope_client_async.headers),
+                **self.folder_headers,
+            }
+
+        if "include_folder_headers" in kwargs:
+            del kwargs["include_folder_headers"]
+
+        return await super().request_async(method, url, **kwargs)
+
+    def request_org_scope(
+        self,
+        method: str,
+        url: Union[URL, str],
+        **kwargs: Any,
+    ) -> Response:
+        if kwargs.get("include_folder_headers", False):
+            kwargs["headers"] = {
+                **kwargs.get("headers", self._org_scope_client.headers),
+                **self.folder_headers,
+            }
+
+        if "include_folder_headers" in kwargs:
+            del kwargs["include_folder_headers"]
+
+        return super().request_org_scope(method, url, **kwargs)
+
+    async def request_org_scope_async(
+        self,
+        method: str,
+        url: Union[URL, str],
+        **kwargs: Any,
+    ) -> Response:
+        if kwargs.get("include_folder_headers", False):
+            kwargs["headers"] = {
+                **kwargs.get("headers", self._org_scope_client_async.headers),
+                **self.folder_headers,
+            }
+
+        if "include_folder_headers" in kwargs:
+            del kwargs["include_folder_headers"]
+
+        return await super().request_org_scope_async(method, url, **kwargs)