uipath 2.1.18__tar.gz → 2.1.20__tar.gz

{uipath-2.1.18 → uipath-2.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.18
+Version: 2.1.20
 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.1.18 → uipath-2.1.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.18"
+version = "2.1.20"
 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.1.20/samples/event-trigger/.python-version

@@ -0,0 +1 @@
+3.13

uipath-2.1.20/samples/event-trigger/README.md

@@ -0,0 +1,128 @@
+# UiPath Coded Agents with Event Triggers
+
+This guide explains how to create Python-based UiPath Coded Agents that respond to event triggers, enabling seamless event-driven agents.
+
+## Overview
+
+UiPath Coded Agents allow you to write automation logic directly in Python while leveraging UiPath's event trigger system. This project demonstrates how to create agents that handle external events from systems like Gmail, Slack, and other connectors.
+
+## How to Set Up UiPath Coded Agents with Event Triggers
+
+### Step 1: Install UiPath Python SDK
+
+1. Open it with your prefered editor
+2. In terminal run:
+```bash
+uv init
+uv add uipath
+uv run uipath new event-agent
+uv run uipath init
+```
+
+### Step 2: Create Your Coded Agent
+
+Create a Python file with your agent logic using the UiPath SDK:
+
+```python
+from dataclasses import dataclass
+from uipath.models import EventArguments
+from uipath import UiPath
+import logging
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class EchoOut:
+    message: dict
+
+# use EventArguments when called by UiPath EventTriggers
+def main(input: EventArguments) -> EchoOut:
+    sdk = UiPath()
+
+    # get the event payload, this will be different from event to event
+    payload = sdk.connections.retrieve_event_payload(input)
+
+    logger.info(f"Received payload: {payload}")
+
+    return EchoOut(payload)
+```
+
+Run `uipath init` again to update the input arguments.
+
+### Step 3: Understanding the Event Flow
+
+When an event trigger fires, UiPath will:
+1. Pass event data through `EventArguments`
+2. Your agent retrieves the full payload using `sdk.connections.retrieve_event_payload(input)`
+3. Process the payload based on your business logic
+4. Return structured output
+
+### Step 4: Publish Your Coded Agent and setup Event Trigger
+
+#### 4.1: Build and Publish
+1. Use `uipath pack` and `uipath publish` to create and publish the package
+2. Create an Orchestrator Automation from the published process
+
+#### 4.2: Access Event Triggers
+1. Log into UiPath Orchestrator
+2. Navigate to **Automations** → **Processes**
+3. Click on your coded workflow process
+
+#### 4.3: Create Event Trigger
+1. Go to the **Triggers** tab
+2. Click **Add Trigger** → **Event Trigger**
+
+#### 4.4: Configure Event Trigger Settings
+1. **Name**: Descriptive name (e.g., "Gmail Event Handler")
+2. **Event Source**: Select connector type:
+   - `uipath-google-gmailcustom` for Gmail
+   - `uipath-slack` for Slack
+   - `uipath-microsoft-outlookcustom` for Outlook
+   - Custom connectors
+3. **Event Type**: Choose specific event:
+   - `EMAIL_RECEIVED` for emails
+   - `MESSAGE_RECEIVED` for chat messages
+   - Custom event types
+4. **Filters**: Optional event filtering criteria
+
+#### 4.5: Map Event to Input Arguments
+The event data will automatically be passed to your `EventArguments` parameter.
+
+#### 4.6: Enable the Trigger
+1. Review configuration
+2. Click **Create** to save
+3. Ensure trigger status is **Enabled**
+
+### Step 5: Test Your Setup
+
+#### 5.1: Trigger Test Events
+- Send test email (Gmail triggers)
+- Post message in Slack (Slack triggers)
+- Perform action matching your event source
+
+#### 5.2: Monitor Execution
+1. Check **Monitoring** → **Jobs** in Orchestrator
+2. View job details and execution logs
+3. Verify your coded agent processed the event correctly
+
+#### 5.3: Debug with Logs
+
+```python
+import logging
+
+logger = logging.getLogger(__name__)
+
+def main(input: EventArguments) -> EchoOut:
+    sdk = UiPath()
+    
+    # payload will be a json (dict) specific to your event
+    payload = sdk.connections.retrieve_event_payload(input)
+    logger.info(f"Successfully retrieved payload: {type(payload)}")
+    logger.debug(f"Payload details: {payload}")
+    
+    # Your processing logic here
+    result = process_event(payload)
+    
+    logger.info(f"Event processed successfully: {result}")
+    return EchoOut(result)
+```

uipath-2.1.20/samples/event-trigger/main.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+from uipath.models import EventArguments
+from uipath import UiPath
+from uipath.tracing import traced
+import logging
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class EchoOut:
+    message: dict
+
+@traced()
+def handle_slack_event(payload: dict[str, any]) -> EchoOut:
+    """Handle Slack message events"""
+    message = payload['event']['text'] if 'event' in payload and 'text' in payload['event'] else "No message"
+    user = payload['event']['user'] if 'event' in payload and 'user' in payload['event'] else "Unknown user"
+
+    logger.info(f"Slack message from {user}: {message}")
+
+
+# use InputTriggerEventArgs when called by UiPath EventTriggers
+@traced()
+def main(input: EventArguments) -> EchoOut:
+    sdk = UiPath()
+
+    # get the event payload, this will be different from event to event
+    payload = sdk.connections.retrieve_event_payload(input)
+
+    handle_slack_event(payload)
+
+    logger.info(f"Received payload: {payload}")
+
+    return EchoOut(payload)

uipath-2.1.20/samples/event-trigger/pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "event-agent"
+version = "0.0.5"
+description = "event-agent"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath>=2.1.18",
+]
+requires-python = ">=3.10"

{uipath-2.1.18 → uipath-2.1.20}/src/uipath/_cli/_runtime/_runtime.py

@@ -11,6 +11,7 @@ from typing import Any, Dict, Optional, Type, TypeVar, cast, get_type_hints
 from opentelemetry import trace
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from pydantic import BaseModel
 
 from uipath.tracing import LlmOpsHttpExporter
 
@@ -162,9 +163,11 @@ class UiPathRuntime(UiPathBaseRuntime):
                 input_param = params[0]
                 input_type = input_param.annotation
 
-                # Case 2: Class or dataclass parameter
+                # Case 2: Class, dataclass, or Pydantic model parameter
                 if input_type != inspect.Parameter.empty and (
-                    is_dataclass(input_type) or hasattr(input_type, "__annotations__")
+                    is_dataclass(input_type)
+                    or self._is_pydantic_model(input_type)
+                    or hasattr(input_type, "__annotations__")
                 ):
                     try:
                         valid_type = cast(Type[Any], input_type)
@@ -216,7 +219,16 @@ class UiPathRuntime(UiPathBaseRuntime):
         )
 
     def _convert_to_class(self, data: Dict[str, Any], cls: Type[T]) -> T:
-        """Convert a dictionary to either a dataclass or regular class instance."""
+        """Convert a dictionary to either a dataclass, Pydantic model, or regular class instance."""
+        # Handle Pydantic models
+        try:
+            if inspect.isclass(cls) and issubclass(cls, BaseModel):
+                return cast(T, cls.model_validate(data))
+        except TypeError:
+            # issubclass can raise TypeError if cls is not a class
+            pass
+
+        # Handle dataclasses
         if is_dataclass(cls):
             field_types = get_type_hints(cls)
             converted_data = {}
@@ -227,13 +239,17 @@ class UiPathRuntime(UiPathBaseRuntime):
 
                 value = data[field_name]
                 if (
-                    is_dataclass(field_type) or hasattr(field_type, "__annotations__")
+                    is_dataclass(field_type)
+                    or self._is_pydantic_model(field_type)
+                    or hasattr(field_type, "__annotations__")
                 ) and isinstance(value, dict):
                     typed_field = cast(Type[Any], field_type)
                     value = self._convert_to_class(value, typed_field)
                 converted_data[field_name] = value
 
             return cast(T, cls(**converted_data))
+
+        # Handle regular classes
         else:
             sig = inspect.signature(cls.__init__)
             params = sig.parameters
@@ -254,6 +270,7 @@ class UiPathRuntime(UiPathBaseRuntime):
 
                     if (
                         is_dataclass(param_type)
+                        or self._is_pydantic_model(param_type)
                         or hasattr(param_type, "__annotations__")
                     ) and isinstance(value, dict):
                         typed_param = cast(Type[Any], param_type)
@@ -265,22 +282,41 @@ class UiPathRuntime(UiPathBaseRuntime):
 
             return cls(**init_args)
 
+    def _is_pydantic_model(self, cls: Type[Any]) -> bool:
+        """Safely check if a class is a Pydantic model."""
+        try:
+            return inspect.isclass(cls) and issubclass(cls, BaseModel)
+        except TypeError:
+            # issubclass can raise TypeError if cls is not a class
+            return False
+
     def _convert_from_class(self, obj: Any) -> Dict[str, Any]:
-        """Convert a class instance (dataclass or regular) to a dictionary."""
+        """Convert a class instance (dataclass, Pydantic model, or regular) to a dictionary."""
         if obj is None:
             return {}
 
-        if is_dataclass(obj):
+        # Handle Pydantic models
+        if isinstance(obj, BaseModel):
+            return obj.model_dump()
+
+        # Handle dataclasses
+        elif is_dataclass(obj):
             # Make sure obj is an instance, not a class
             if isinstance(obj, type):
                 return {}
             return asdict(obj)
+
+        # Handle regular classes
         elif hasattr(obj, "__dict__"):
             result = {}
             for key, value in obj.__dict__.items():
                 # Skip private attributes
                 if not key.startswith("_"):
-                    if hasattr(value, "__dict__") or is_dataclass(value):
+                    if (
+                        isinstance(value, BaseModel)
+                        or hasattr(value, "__dict__")
+                        or is_dataclass(value)
+                    ):
                         result[key] = self._convert_from_class(value)
                     else:
                         result[key] = value

{uipath-2.1.18 → uipath-2.1.20}/src/uipath/_cli/_utils/_input_args.py

@@ -14,6 +14,8 @@ from typing import (
     get_type_hints,
 )
 
+from pydantic import BaseModel
+
 SchemaType = Literal["object", "integer", "double", "string", "boolean", "array"]
 
 TYPE_MAP: Dict[str, SchemaType] = {
@@ -50,7 +52,30 @@ def get_type_schema(type_hint: Any) -> Dict[str, Any]:
         return {"type": "object"}
 
     if inspect.isclass(type_hint):
-        if is_dataclass(type_hint):
+        # Handle Pydantic models
+        if issubclass(type_hint, BaseModel):
+            properties = {}
+            required = []
+
+            # Get the model fields
+            model_fields = type_hint.model_fields
+
+            for field_name, field_info in model_fields.items():
+                # Use alias if defined, otherwise use field name
+                schema_field_name = field_info.alias if field_info.alias else field_name
+
+                # Get the field type schema
+                field_schema = get_type_schema(field_info.annotation)
+                properties[schema_field_name] = field_schema
+
+                # Check if field is required using Pydantic's built-in method
+                if field_info.is_required():
+                    required.append(schema_field_name)
+
+            return {"type": "object", "properties": properties, "required": required}
+
+        # Handle dataclasses
+        elif is_dataclass(type_hint):
             properties = {}
             required = []
 
@@ -61,6 +86,8 @@ def get_type_schema(type_hint: Any) -> Dict[str, Any]:
                     required.append(field.name)
 
             return {"type": "object", "properties": properties, "required": required}
+
+        # Handle regular classes with annotations
         elif hasattr(type_hint, "__annotations__"):
             properties = {}
             required = []

{uipath-2.1.18 → uipath-2.1.20}/src/uipath/_cli/_utils/_parse_ast.py

@@ -8,6 +8,7 @@ from typing import Any, Dict, List, Optional, Tuple
 from ..._services import (
     AssetsService,
     BucketsService,
+    ConnectionsService,
     ContextGroundingService,
     ProcessesService,
 )
@@ -47,6 +48,7 @@ supported_bindings_by_service = {
     "processes": ProcessesService,
     "buckets": BucketsService,
     "context_grounding": ContextGroundingService,
+    "connections": ConnectionsService,
 }
 
 
@@ -103,7 +105,17 @@ class ServiceUsage:
 
         # custom logic for connections bindings
         elif self.service_name == "connections":
+            # First, try to get inferred bindings for connections if they exist
+            connections_service = supported_bindings_by_service.get("connections")
+            inferred_bindings = {}
+            if connections_service:
+                inferred_bindings = get_inferred_bindings_names(connections_service)
+
             for call in self.method_calls:
+                # Skip methods that are decorated with @infer_bindings(ignore=False)
+                if call.method_name in inferred_bindings:
+                    continue
+
                 if len(call.args) > 0:
                     connection_id = call.args[0]
                     if connection_id:

{uipath-2.1.18 → uipath-2.1.20}/src/uipath/_cli/_utils/_project_files.py

@@ -68,6 +68,7 @@ def get_project_config(directory: str) -> dict[str, str]:
         "version": toml_data["version"],
         "authors": toml_data["authors"],
         "dependencies": toml_data.get("dependencies", {}),
+        "requires-python": toml_data.get("requires-python", {}),
     }
 
 
@@ -97,6 +98,11 @@ def validate_config(config: dict[str, str]) -> None:
             'Project authors cannot be empty. Please specify authors in pyproject.toml:\n    authors = [{ name = "John Doe" }]'
         )
 
+    if not config["requires-python"] or config["requires-python"].strip() == "":
+        console.error(
+            "'requires-python' field cannot be empty. Please specify it in pyproject.toml:  requires-python = \">=3.10\""
+        )
+
     invalid_chars = ["&", "<", ">", '"', "'", ";"]
     for char in invalid_chars:
         if char in config["project_name"]:
@@ -296,6 +302,7 @@ def read_toml_project(file_path: str) -> dict:
         "version": project["version"].strip(),
         "authors": author_name.strip(),
         "dependencies": dependencies,
+        "requires-python": project.get("requires-python", "").strip(),
     }
 
 

{uipath-2.1.18 → uipath-2.1.20}/src/uipath/_services/connections_service.py

@@ -1,9 +1,11 @@
+import json
 import logging
+from typing import Any, Dict
 
 from .._config import Config
 from .._execution_context import ExecutionContext
-from .._utils import Endpoint, RequestSpec
-from ..models import Connection, ConnectionToken
+from .._utils import Endpoint, RequestSpec, infer_bindings
+from ..models import Connection, ConnectionToken, EventArguments
 from ..tracing._traced import traced
 from ._base_service import BaseService
 
@@ -112,6 +114,84 @@ class ConnectionsService(BaseService):
         )
         return ConnectionToken.model_validate(response.json())
 
+    @traced(
+        name="connections_retrieve_event_payload",
+        run_type="uipath",
+    )
+    @infer_bindings(resource_type="ignored", ignore=True)
+    def retrieve_event_payload(self, event_args: EventArguments) -> Dict[str, Any]:
+        """Retrieve event payload from UiPath Integration Service.
+
+        Args:
+            event_args (EventArguments): The event arguments. Should be passed along from the job's input.
+
+        Returns:
+            Dict[str, Any]: The event payload data
+        """
+        if not event_args.additional_event_data:
+            raise ValueError("additional_event_data is required")
+
+        # Parse additional event data to get event id
+        event_data = json.loads(event_args.additional_event_data)
+
+        event_id = None
+        if "processedEventId" in event_data:
+            event_id = event_data["processedEventId"]
+        elif "rawEventId" in event_data:
+            event_id = event_data["rawEventId"]
+        else:
+            raise ValueError("Event Id not found in additional event data")
+
+        # Build request URL using connection token's API base URI
+        spec = self._retrieve_event_payload_spec("v1", event_id)
+
+        response = self.request(spec.method, url=spec.endpoint)
+
+        return response.json()
+
+    @traced(
+        name="connections_retrieve_event_payload",
+        run_type="uipath",
+    )
+    @infer_bindings(resource_type="ignored", ignore=True)
+    async def retrieve_event_payload_async(
+        self, event_args: EventArguments
+    ) -> Dict[str, Any]:
+        """Retrieve event payload from UiPath Integration Service.
+
+        Args:
+            event_args (EventArguments): The event arguments. Should be passed along from the job's input.
+
+        Returns:
+            Dict[str, Any]: The event payload data
+        """
+        if not event_args.additional_event_data:
+            raise ValueError("additional_event_data is required")
+
+        # Parse additional event data to get event id
+        event_data = json.loads(event_args.additional_event_data)
+
+        event_id = None
+        if "processedEventId" in event_data:
+            event_id = event_data["processedEventId"]
+        elif "rawEventId" in event_data:
+            event_id = event_data["rawEventId"]
+        else:
+            raise ValueError("Event Id not found in additional event data")
+
+        # Build request URL using connection token's API base URI
+        spec = self._retrieve_event_payload_spec("v1", event_id)
+
+        response = await self.request_async(spec.method, url=spec.endpoint)
+
+        return response.json()
+
+    def _retrieve_event_payload_spec(self, version: str, event_id: str) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"/elements_/{version}/events/{event_id}"),
+        )
+
     def _retrieve_spec(self, key: str) -> RequestSpec:
         return RequestSpec(
             method="GET",

{uipath-2.1.18 → uipath-2.1.20}/src/uipath/_utils/_infer_bindings.py

@@ -8,7 +8,10 @@ T = TypeVar("T")
 
 
 def infer_bindings(
-    resource_type: str, name: str = "name", folder_path: str = "folder_path"
+    resource_type: str,
+    name: str = "name",
+    folder_path: str = "folder_path",
+    ignore: bool = False,
 ) -> Callable[..., Any]:
     def decorator(func: Callable[..., Any]):
         @functools.wraps(func)
@@ -30,7 +33,7 @@ def infer_bindings(
 
             return func(**all_args)
 
-        wrapper._should_infer_bindings = True  # type: ignore
+        wrapper._should_infer_bindings = not ignore  # type: ignore
         wrapper._infer_bindings_mappings = {"name": name, "folder_path": folder_path}  # type: ignore
         return wrapper
 

{uipath-2.1.18 → uipath-2.1.20}/src/uipath/models/__init__.py

@@ -3,7 +3,7 @@ from .actions import Action
 from .assets import Asset, UserAsset
 from .attachment import Attachment
 from .buckets import Bucket
-from .connections import Connection, ConnectionToken
+from .connections import Connection, ConnectionToken, EventArguments
 from .context_grounding import ContextGroundingQueryResponse
 from .context_grounding_index import ContextGroundingIndex
 from .errors import BaseUrlMissingError, SecretMissingError
@@ -39,6 +39,7 @@ __all__ = [
     "TransactionItemResult",
     "Connection",
     "ConnectionToken",
+    "EventArguments",
     "Job",
     "InvokeProcess",
     "ActionSchema",

{uipath-2.1.18 → uipath-2.1.20}/src/uipath/models/connections.py

@@ -49,3 +49,20 @@ class ConnectionToken(BaseModel):
     expires_in: Optional[int] = Field(default=None, alias="expiresIn")
     api_base_uri: Optional[str] = Field(default=None, alias="apiBaseUri")
     element_instance_id: Optional[int] = Field(default=None, alias="elementInstanceId")
+
+
+class EventArguments(BaseModel):
+    event_connector: Optional[str] = Field(default=None, alias="UiPathEventConnector")
+    event: Optional[str] = Field(default=None, alias="UiPathEvent")
+    event_object_type: Optional[str] = Field(
+        default=None, alias="UiPathEventObjectType"
+    )
+    event_object_id: Optional[str] = Field(default=None, alias="UiPathEventObjectId")
+    additional_event_data: Optional[str] = Field(
+        default=None, alias="UiPathAdditionalEventData"
+    )
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        extra="allow",
+    )