uipath 2.0.63__tar.gz → 2.0.64__tar.gz

{uipath-2.0.63 → uipath-2.0.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.0.63
+Version: 2.0.64
 Summary: Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools.
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-python

{uipath-2.0.63 → uipath-2.0.64}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.0.63"
+version = "2.0.64"
 description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

uipath-2.0.64/src/uipath/_cli/_runtime/_escalation.py

@@ -0,0 +1,235 @@
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+from uipath import UiPath
+from uipath.models.actions import Action
+
+logger = logging.getLogger(__name__)
+
+
+class Escalation:
+    """Class to handle default escalation."""
+
+    def __init__(self, config_path: Union[str, Path] = "uipath.json"):
+        """Initialize the escalation with a config file path.
+
+        Args:
+            config_path: Path to the configuration file (string or Path object)
+        """
+        self.config_path = Path(config_path)
+        self._config = None
+        self._enabled = False
+        self._load_config()
+
+    def _load_config(self) -> None:
+        """Load and validate the default escalation from the config file.
+
+        If the 'defaultEscalation' section exists, validates required fields.
+        Raises error if required fields are missing.
+        """
+        try:
+            config_data = json.loads(self.config_path.read_text(encoding="utf-8"))
+            escalation_config = config_data.get("defaultEscalation")
+
+            if escalation_config:
+                required_fields = {"request", "title"}
+                missing_fields = [
+                    field for field in required_fields if field not in escalation_config
+                ]
+
+                if not any(key in escalation_config for key in ("appName", "appKey")):
+                    missing_fields.append("appName or appKey")
+
+                if missing_fields:
+                    raise ValueError(
+                        f"Missing required fields in configuration: {', '.join(missing_fields)}"
+                    )
+
+                self._config = escalation_config
+                self._enabled = True
+                logger.debug("Escalation configuration loaded successfully")
+            else:
+                self._enabled = False
+
+        except FileNotFoundError:
+            logger.debug(f"Config file not found: {self.config_path}")
+            self._enabled = False
+
+        except json.JSONDecodeError:
+            logger.warning(
+                f"Failed to parse config file {self.config_path}: Invalid JSON"
+            )
+            self._enabled = False
+
+        except ValueError as e:
+            logger.error(str(e))
+            raise
+
+        except Exception as e:
+            logger.error(f"Unexpected error loading config {self.config_path}: {e}")
+            self._enabled = False
+
+    @property
+    def enabled(self) -> bool:
+        """Check if escalation is enabled.
+
+        Returns:
+            True if configuration is valid and loaded
+        """
+        return self._enabled
+
+    def prepare_data(self, value: Any) -> Dict[str, Any]:
+        """Prepare action data by replacing $VALUE placeholders with the provided value.
+
+        Args:
+            value: The value to substitute into the template
+
+        Returns:
+            Prepared data dictionary with substitutions applied
+        """
+        if not self.enabled or not self._config:
+            return {}
+
+        template = self._config.get("request", {})
+
+        if isinstance(value, str):
+            try:
+                value_obj = json.loads(value)
+            except json.JSONDecodeError:
+                value_obj = value
+        else:
+            value_obj = value
+
+        return self._substitute_values(template, value_obj)
+
+    def _substitute_values(
+        self, template: Dict[str, Any], value: Any
+    ) -> Dict[str, Any]:
+        """Replace template placeholders with actual values.
+
+        Args:
+            template: Template dictionary containing placeholders
+            value: Values to substitute into the template
+
+        Returns:
+            Template with values substituted
+        """
+
+        def process_value(template_value):
+            if isinstance(template_value, dict):
+                return {k: process_value(v) for k, v in template_value.items()}
+            elif isinstance(template_value, list):
+                return [process_value(item) for item in template_value]
+            elif isinstance(template_value, str):
+                if template_value == "$VALUE":
+                    return value
+                elif template_value.startswith("$VALUE."):
+                    return self._resolve_value_path(template_value, value)
+
+            return template_value
+
+        return process_value(template)
+
+    def _resolve_value_path(self, path_expr: str, value: Any) -> Any:
+        """Resolve a dot-notation path expression against a value.
+
+        Args:
+            path_expr: Path expression (e.g. "$VALUE.user.name")
+            value: Value object to extract data from
+
+        Returns:
+            Extracted value or None if path doesn't exist
+        """
+        path_parts = path_expr.replace("$VALUE.", "").split(".")
+        current = value
+
+        for part in path_parts:
+            if not isinstance(current, dict) or part not in current:
+                return None
+            current = current.get(part)
+
+        return current
+
+    def extract_response_value(self, action_data: Dict[str, Any]) -> Any:
+        if not self._config:
+            return ""
+
+        response_template = self._config.get("response")
+        if not response_template:
+            return ""
+
+        for key, template_value in response_template.items():
+            if key in action_data:
+                extracted_value = None
+
+                if template_value == "$VALUE":
+                    extracted_value = action_data[key]
+                elif isinstance(template_value, str) and template_value.startswith(
+                    "$VALUE."
+                ):
+                    path_parts = template_value.replace("$VALUE.", "").split(".")
+                    current = action_data[key]
+
+                    valid_path = True
+                    for part in path_parts:
+                        if not isinstance(current, dict) or part not in current:
+                            valid_path = False
+                            break
+                        current = current.get(part)
+
+                    if valid_path:
+                        extracted_value = current
+
+                if extracted_value is not None:
+                    if isinstance(extracted_value, str):
+                        if extracted_value.lower() == "true":
+                            return True
+                        elif extracted_value.lower() == "false":
+                            return False
+
+                        try:
+                            if "." in extracted_value:
+                                return float(extracted_value)
+                            else:
+                                return int(extracted_value)
+                        except ValueError:
+                            pass
+
+                    return extracted_value
+
+        return action_data
+
+    async def create(self, value: Any) -> Optional[Action]:
+        """Create an escalation Action with the prepared data.
+
+        Args:
+            value: The dynamic value to be substituted into the template
+
+        Returns:
+            The created Action object or None if creation fails
+        """
+        if not self.enabled or not self._config:
+            return None
+
+        action_data = self.prepare_data(value)
+
+        if not action_data:
+            logger.warning("Action creation skipped: empty data after preparation")
+            return None
+
+        try:
+            uipath = UiPath()
+            action = uipath.actions.create(
+                title=self._config.get("title", "Default escalation"),
+                app_name=self._config.get("appName"),
+                app_key=self._config.get("appKey"),
+                app_version=self._config.get("appVersion", 1),
+                data=action_data,
+            )
+            logger.info(f"Action created successfully: {action.key}")
+            return action
+        except Exception as e:
+            logger.error(f"Error creating action: {e}")
+            return None

uipath-2.0.64/src/uipath/_cli/_runtime/_hitl.py

@@ -0,0 +1,194 @@
+import json
+import uuid
+from dataclasses import dataclass
+from functools import cached_property
+from typing import Any, Optional
+
+from uipath import UiPath
+from uipath.models import CreateAction, InvokeProcess, WaitAction, WaitJob
+
+from .._runtime._contracts import (
+    UiPathApiTrigger,
+    UiPathErrorCategory,
+    UiPathResumeTrigger,
+    UiPathResumeTriggerType,
+    UiPathRuntimeError,
+    UiPathRuntimeStatus,
+)
+from .._utils._common import serialize_object
+from ._escalation import Escalation
+
+
+def _try_convert_to_json_format(value: str) -> str:
+    try:
+        return json.loads(value)
+    except json.decoder.JSONDecodeError:
+        return value
+
+
+default_escalation = Escalation()
+
+
+class HitlReader:
+    @classmethod
+    async def read(cls, resume_trigger: UiPathResumeTrigger) -> Optional[str]:
+        uipath = UiPath()
+        match resume_trigger.trigger_type:
+            case UiPathResumeTriggerType.ACTION:
+                if resume_trigger.item_key:
+                    action = await uipath.actions.retrieve_async(
+                        resume_trigger.item_key,
+                        app_folder_key=resume_trigger.folder_key,
+                        app_folder_path=resume_trigger.folder_path,
+                    )
+
+                    if default_escalation.enabled:
+                        return default_escalation.extract_response_value(action.data)
+
+                    return action.data
+
+            case UiPathResumeTriggerType.JOB:
+                if resume_trigger.item_key:
+                    job = await uipath.jobs.retrieve_async(
+                        resume_trigger.item_key,
+                        folder_key=resume_trigger.folder_key,
+                        folder_path=resume_trigger.folder_path,
+                    )
+                    if (
+                        job.state
+                        and not job.state.lower()
+                        == UiPathRuntimeStatus.SUCCESSFUL.value.lower()
+                    ):
+                        raise UiPathRuntimeError(
+                            "INVOKED_PROCESS_FAILURE",
+                            "Invoked process did not finish successfully.",
+                            _try_convert_to_json_format(str(job.job_error or job.info)),
+                        )
+                    return job.output_arguments
+
+            case UiPathResumeTriggerType.API:
+                if resume_trigger.api_resume and resume_trigger.api_resume.inbox_id:
+                    try:
+                        return await uipath.jobs.retrieve_api_payload_async(
+                            resume_trigger.api_resume.inbox_id
+                        )
+                    except Exception as e:
+                        raise UiPathRuntimeError(
+                            "API_CONNECTION_ERROR",
+                            "Failed to get trigger payload",
+                            f"Error fetching API trigger payload for inbox {resume_trigger.api_resume.inbox_id}: {str(e)}",
+                            UiPathErrorCategory.SYSTEM,
+                        ) from e
+            case _:
+                raise UiPathRuntimeError(
+                    "UNKNOWN_TRIGGER_TYPE",
+                    "Unexpected trigger type received",
+                    f"Trigger type :{type(resume_trigger.trigger_type)} is invalid",
+                    UiPathErrorCategory.USER,
+                )
+
+        raise UiPathRuntimeError(
+            "HITL_FEEDBACK_FAILURE",
+            "Failed to receive payload from HITL action",
+            detail="Failed to receive payload from HITL action",
+            category=UiPathErrorCategory.SYSTEM,
+        )
+
+
+@dataclass
+class HitlProcessor:
+    """Processes events in a Human-(Robot/Agent)-In-The-Loop scenario."""
+
+    value: Any
+
+    @cached_property
+    def type(self) -> UiPathResumeTriggerType:
+        """Returns the type of the interrupt value."""
+        if isinstance(self.value, CreateAction) or isinstance(self.value, WaitAction):
+            return UiPathResumeTriggerType.ACTION
+        if isinstance(self.value, InvokeProcess) or isinstance(self.value, WaitJob):
+            return UiPathResumeTriggerType.JOB
+        # default to API trigger
+        return UiPathResumeTriggerType.API
+
+    async def create_resume_trigger(self) -> UiPathResumeTrigger:
+        """Returns the resume trigger."""
+        uipath = UiPath()
+        try:
+            hitl_input = self.value
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=self.type, payload=serialize_object(hitl_input)
+            )
+
+            # check for default escalation config
+            if default_escalation.enabled and isinstance(hitl_input, str):
+                resume_trigger.trigger_type = UiPathResumeTriggerType.ACTION
+                action = await default_escalation.create(hitl_input)
+                if not action:
+                    raise Exception("Failed to create default escalation")
+                resume_trigger.item_key = action.key
+                return resume_trigger
+
+            match self.type:
+                case UiPathResumeTriggerType.ACTION:
+                    resume_trigger.folder_path = hitl_input.app_folder_path
+                    resume_trigger.folder_key = hitl_input.app_folder_key
+                    if isinstance(hitl_input, WaitAction):
+                        resume_trigger.item_key = hitl_input.action.key
+                    elif isinstance(hitl_input, CreateAction):
+                        action = await uipath.actions.create_async(
+                            title=hitl_input.title,
+                            app_name=hitl_input.app_name if hitl_input.app_name else "",
+                            app_folder_path=hitl_input.app_folder_path
+                            if hitl_input.app_folder_path
+                            else "",
+                            app_folder_key=hitl_input.app_folder_key
+                            if hitl_input.app_folder_key
+                            else "",
+                            app_key=hitl_input.app_key if hitl_input.app_key else "",
+                            app_version=hitl_input.app_version
+                            if hitl_input.app_version
+                            else 1,
+                            assignee=hitl_input.assignee if hitl_input.assignee else "",
+                            data=hitl_input.data,
+                        )
+                        if not action:
+                            raise Exception("Failed to create action")
+                        resume_trigger.item_key = action.key
+
+                case UiPathResumeTriggerType.JOB:
+                    resume_trigger.folder_path = hitl_input.process_folder_path
+                    resume_trigger.folder_key = hitl_input.process_folder_key
+                    if isinstance(hitl_input, WaitJob):
+                        resume_trigger.item_key = hitl_input.job.key
+                    elif isinstance(hitl_input, InvokeProcess):
+                        job = await uipath.processes.invoke_async(
+                            name=hitl_input.name,
+                            input_arguments=hitl_input.input_arguments,
+                            folder_path=hitl_input.process_folder_path,
+                            folder_key=hitl_input.process_folder_key,
+                        )
+                        if not job:
+                            raise Exception("Failed to invoke process")
+                        resume_trigger.item_key = job.key
+
+                case UiPathResumeTriggerType.API:
+                    resume_trigger.api_resume = UiPathApiTrigger(
+                        inbox_id=str(uuid.uuid4()), request=serialize_object(hitl_input)
+                    )
+                case _:
+                    raise UiPathRuntimeError(
+                        "UNKNOWN_HITL_MODEL",
+                        "Unexpected model received",
+                        f"{type(hitl_input)} is not a valid Human(Robot/Agent)-In-The-Loop model",
+                        UiPathErrorCategory.USER,
+                    )
+        except Exception as e:
+            raise UiPathRuntimeError(
+                "HITL_ACTION_CREATION_FAILED",
+                "Failed to create HITL action",
+                f"{str(e)}",
+                UiPathErrorCategory.SYSTEM,
+            ) from e
+
+        return resume_trigger

{uipath-2.0.63 → uipath-2.0.64}/src/uipath/_cli/_utils/_common.py

@@ -43,3 +43,29 @@ def get_env_vars(spinner: Optional[Spinner] = None) -> list[str | None]:
         click.get_current_context().exit(1)
 
     return [base_url, token]
+
+
+def serialize_object(obj):
+    """Recursively serializes an object and all its nested components."""
+    # Handle Pydantic models
+    if hasattr(obj, "model_dump"):
+        return serialize_object(obj.model_dump(by_alias=True))
+    elif hasattr(obj, "dict"):
+        return serialize_object(obj.dict())
+    elif hasattr(obj, "to_dict"):
+        return serialize_object(obj.to_dict())
+    # Handle dictionaries
+    elif isinstance(obj, dict):
+        return {k: serialize_object(v) for k, v in obj.items()}
+    # Handle lists
+    elif isinstance(obj, list):
+        return [serialize_object(item) for item in obj]
+    # Handle other iterable objects (convert to dict first)
+    elif hasattr(obj, "__iter__") and not isinstance(obj, (str, bytes)):
+        try:
+            return serialize_object(dict(obj))
+        except (TypeError, ValueError):
+            return obj
+    # Return primitive types as is
+    else:
+        return obj

uipath-2.0.64/src/uipath/_cli/_utils/_tracing.py

@@ -0,0 +1,52 @@
+import datetime
+import logging
+from zoneinfo import ZoneInfo
+
+
+class IgnoreSpecificUrl(logging.Filter):
+    def __init__(self, url_to_ignore):
+        super().__init__()
+        self.url_to_ignore = url_to_ignore
+
+    def filter(self, record):
+        try:
+            if record.msg == 'HTTP Request: %s %s "%s %d %s"':
+                # Ignore the log if the URL matches the one we want to ignore
+                method = record.args[0]
+                url = record.args[1]
+
+                if method == "POST" and url.path.endswith(self.url_to_ignore):
+                    # Check if the URL contains the specific path we want to ignore
+                    return True
+                return False
+
+        except Exception:
+            return False
+
+
+def setup_tracer_httpx_logging(url: str):
+    # Create a custom logger for httpx
+    # Add the custom filter to the root logger
+    logging.getLogger("httpx").addFilter(IgnoreSpecificUrl(url))
+
+
+def simple_serialize_defaults(obj):
+    if hasattr(obj, "model_dump"):
+        return obj.model_dump(exclude_none=True, mode="json")
+    if hasattr(obj, "dict"):
+        return obj.dict()
+    if hasattr(obj, "to_dict"):
+        return obj.to_dict()
+
+    if isinstance(obj, (set, tuple)):
+        if hasattr(obj, "_asdict") and callable(obj._asdict):
+            return obj._asdict()
+        return list(obj)
+
+    if isinstance(obj, datetime.datetime):
+        return obj.isoformat()
+
+    if isinstance(obj, (datetime.timezone, ZoneInfo)):
+        return obj.tzname(None)
+
+    return str(obj)

{uipath-2.0.63 → uipath-2.0.64}/src/uipath/_services/jobs_service.py

@@ -272,6 +272,59 @@ class JobsService(FolderContext, BaseService):
         response = response.json()
         return self._extract_first_inbox_id(response)
 
+    def retrieve_api_payload(self, inbox_id: str) -> Any:
+        """Fetch payload data for API triggers.
+
+        Args:
+            inbox_id: The Id of the inbox to fetch the payload for.
+
+        Returns:
+            The value field from the API response payload.
+        """
+        spec = self._retrieve_api_payload_spec(inbox_id=inbox_id)
+
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            headers=spec.headers,
+        )
+
+        data = response.json()
+        return data.get("payload")
+
+    async def retrieve_api_payload_async(self, inbox_id: str) -> Any:
+        """Asynchronously fetch payload data for API triggers.
+
+        Args:
+            inbox_id: The Id of the inbox to fetch the payload for.
+
+        Returns:
+            The value field from the API response payload.
+        """
+        spec = self._retrieve_api_payload_spec(inbox_id=inbox_id)
+
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            headers=spec.headers,
+        )
+
+        data = response.json()
+        return data.get("payload")
+
+    def _retrieve_api_payload_spec(
+        self,
+        *,
+        inbox_id: str,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"/orchestrator_/api/JobTriggers/GetPayload/{inbox_id}"),
+            headers={
+                **self.folder_headers,
+            },
+        )
+
     def _extract_first_inbox_id(self, response: Any) -> str:
         if len(response["value"]) > 0:
             return response["value"][0]["ItemKey"]