uipath 2.1.84__tar.gz → 2.1.85__tar.gz

{uipath-2.1.84 → uipath-2.1.85}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.84"
+version = "2.1.85"
 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.84 → uipath-2.1.85}/src/uipath/_cli/_evals/_runtime.py

@@ -432,12 +432,12 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
     async def execute_runtime(
         self, eval_item: EvaluationItem
     ) -> UiPathEvalRunExecutionOutput:
-        eval_item_id = eval_item.id
+        execution_id = str(uuid.uuid4())
         runtime_context: C = self.factory.new_context(
-            execution_id=eval_item_id,
+            execution_id=execution_id,
             input_json=eval_item.inputs,
             is_eval_run=True,
-            log_handler=self._setup_execution_logging(eval_item_id),
+            log_handler=self._setup_execution_logging(execution_id),
         )
         if runtime_context.execution_id is None:
             raise ValueError("execution_id must be set for eval runs")
@@ -445,9 +445,8 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         attributes = {
             "evalId": eval_item.id,
             "span_type": "eval",
+            "execution.id": runtime_context.execution_id,
         }
-        if runtime_context.execution_id:
-            attributes["execution.id"] = runtime_context.execution_id
 
         start_time = time()
         try:

{uipath-2.1.84 → uipath-2.1.85}/src/uipath/_services/connections_service.py

@@ -7,7 +7,7 @@ from httpx import Response
 from .._config import Config
 from .._execution_context import ExecutionContext
 from .._utils import Endpoint, RequestSpec, header_folder, infer_bindings
-from ..models import Connection, ConnectionToken, EventArguments
+from ..models import Connection, ConnectionMetadata, ConnectionToken, EventArguments
 from ..models.connections import ConnectionTokenType
 from ..tracing._traced import traced
 from ._base_service import BaseService
@@ -54,6 +54,31 @@ class ConnectionsService(BaseService):
         response = self.request(spec.method, url=spec.endpoint)
         return Connection.model_validate(response.json())
 
+    @traced(
+        name="connections_metadata",
+        run_type="uipath",
+        hide_output=True,
+    )
+    def metadata(
+        self, element_instance_id: int, tool_path: str, schema_mode: bool = True
+    ) -> ConnectionMetadata:
+        """Synchronously retrieve connection API metadata.
+
+        This method fetches the metadata for a connection,
+        which can be used to establish communication with an external service.
+
+        Args:
+            element_instance_id (int): The element instance ID of the connection.
+            tool_path (str): The tool path to retrieve metadata for.
+            schema_mode (bool): Whether or not to represent the output schema in the response fields.
+
+        Returns:
+            ConnectionMetadata: The connection metadata.
+        """
+        spec = self._metadata_spec(element_instance_id, tool_path, schema_mode)
+        response = self.request(spec.method, url=spec.endpoint, headers=spec.headers)
+        return ConnectionMetadata.model_validate(response.json())
+
     @traced(name="connections_list", run_type="uipath")
     def list(
         self,
@@ -186,6 +211,33 @@ class ConnectionsService(BaseService):
         response = await self.request_async(spec.method, url=spec.endpoint)
         return Connection.model_validate(response.json())
 
+    @traced(
+        name="connections_metadata",
+        run_type="uipath",
+        hide_output=True,
+    )
+    async def metadata_async(
+        self, element_instance_id: int, tool_path: str, schema_mode: bool = True
+    ) -> ConnectionMetadata:
+        """Asynchronously retrieve connection API metadata.
+
+        This method fetches the metadata for a connection,
+        which can be used to establish communication with an external service.
+
+        Args:
+            element_instance_id (int): The element instance ID of the connection.
+            tool_path (str): The tool path to retrieve metadata for.
+            schema_mode (bool): Whether or not to represent the output schema in the response fields.
+
+        Returns:
+            ConnectionMetadata: The connection metadata.
+        """
+        spec = self._metadata_spec(element_instance_id, tool_path, schema_mode)
+        response = await self.request_async(
+            spec.method, url=spec.endpoint, headers=spec.headers
+        )
+        return ConnectionMetadata.model_validate(response.json())
+
     @traced(
         name="connections_retrieve_token",
         run_type="uipath",
@@ -324,6 +376,20 @@ class ConnectionsService(BaseService):
             endpoint=Endpoint(f"/connections_/api/v1/Connections/{key}"),
         )
 
+    def _metadata_spec(
+        self, element_instance_id: int, tool_path: str, schema_mode: bool
+    ) -> RequestSpec:
+        metadata_endpoint_url = f"/elements_/v3/element/instances/{element_instance_id}/elements/{tool_path}/metadata"
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(metadata_endpoint_url),
+            headers={
+                "accept": "application/schema+json"
+                if schema_mode
+                else "application/json"
+            },
+        )
+
     def _retrieve_token_spec(
         self, key: str, token_type: ConnectionTokenType = ConnectionTokenType.DIRECT
     ) -> RequestSpec:

{uipath-2.1.84 → uipath-2.1.85}/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, EventArguments
+from .connections import Connection, ConnectionMetadata, ConnectionToken, EventArguments
 from .context_grounding import ContextGroundingQueryResponse
 from .context_grounding_index import ContextGroundingIndex
 from .errors import BaseUrlMissingError, SecretMissingError
@@ -38,6 +38,7 @@ __all__ = [
     "QueueItemPriority",
     "TransactionItemResult",
     "Connection",
+    "ConnectionMetadata",
     "ConnectionToken",
     "EventArguments",
     "Job",

{uipath-2.1.84 → uipath-2.1.85}/src/uipath/models/connections.py

@@ -4,6 +4,14 @@ from typing import Any, Optional
 from pydantic import BaseModel, ConfigDict, Field
 
 
+class ConnectionMetadata(BaseModel):
+    """Metadata about a connection."""
+
+    fields: dict[str, Any] = Field(default_factory=dict, alias="fields")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
 class Connection(BaseModel):
     model_config = ConfigDict(
         validate_by_name=True,

uipath-2.1.85/src/uipath/utils/dynamic_schema.py

@@ -0,0 +1,111 @@
+"""Json schema to dynamic pydantic model."""
+
+from typing import Any, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel, Field, create_model
+
+
+def jsonschema_to_pydantic(
+    schema: dict[str, Any],
+    definitions: Optional[dict[str, Any]] = None,
+) -> Type[BaseModel]:
+    """Convert a schema dict to a pydantic model.
+
+    Modified version of https://github.com/kreneskyp/jsonschema-pydantic to account for two unresolved issues.
+
+    Args:
+        schema: JSON schema.
+        definitions: Definitions dict. Defaults to `$def`.
+
+    Returns: Pydantic model.
+    """
+    title = schema.get("title", "DynamicModel")
+    assert isinstance(title, str), "Title of a model must be a string."
+
+    description = schema.get("description", None)
+
+    # top level schema provides definitions
+    if definitions is None:
+        if "$defs" in schema:
+            definitions = schema["$defs"]
+        elif "definitions" in schema:
+            definitions = schema["definitions"]
+        else:
+            definitions = {}
+
+    def convert_type(prop: dict[str, Any]) -> Any:
+        if "$ref" in prop:
+            ref_path = prop["$ref"].split("/")
+            ref = definitions[ref_path[-1]]
+            return jsonschema_to_pydantic(ref, definitions)
+
+        if "type" in prop:
+            type_mapping = {
+                "string": str,
+                "number": float,
+                "integer": int,
+                "boolean": bool,
+                "array": List,
+                "object": Dict[str, Any],
+                "null": None,
+            }
+
+            type_ = prop["type"]
+
+            if type_ == "array":
+                item_type: Any = convert_type(prop.get("items", {}))
+                assert isinstance(item_type, type)
+                return List[item_type]  # noqa F821
+            elif type_ == "object":
+                if "properties" in prop:
+                    return jsonschema_to_pydantic(prop, definitions)
+                else:
+                    return Dict[str, Any]
+            else:
+                return type_mapping.get(type_, Any)
+
+        elif "allOf" in prop:
+            combined_fields = {}
+            for sub_schema in prop["allOf"]:
+                model = jsonschema_to_pydantic(sub_schema, definitions)
+                combined_fields.update(model.__annotations__)
+            return create_model("CombinedModel", **combined_fields)
+
+        elif "anyOf" in prop:
+            unioned_types = tuple(
+                convert_type(sub_schema) for sub_schema in prop["anyOf"]
+            )
+            return Union[unioned_types]
+        elif prop == {} or "type" not in prop:
+            return Any
+        else:
+            raise ValueError(f"Unsupported schema: {prop}")
+
+    fields: dict[str, Any] = {}
+    required_fields = schema.get("required", [])
+
+    for name, prop in schema.get("properties", {}).items():
+        pydantic_type = convert_type(prop)
+        field_kwargs = {}
+        if "default" in prop:
+            field_kwargs["default"] = prop["default"]
+        if name not in required_fields:
+            # Note that we do not make this optional. This is due to a limitation in Pydantic/Python.
+            # If we convert the Optional type back to json schema, it is represented as type | None.
+            # pydantic_type = Optional[pydantic_type]
+
+            if "default" not in field_kwargs:
+                field_kwargs["default"] = None
+        if "description" in prop:
+            field_kwargs["description"] = prop["description"]
+        if "title" in prop:
+            field_kwargs["title"] = prop["title"]
+
+        fields[name] = (pydantic_type, Field(**field_kwargs))
+
+    convert_type(schema.get("properties", {}).get("choices", {}))
+
+    model = create_model(title, **fields)
+    if description:
+        model.__doc__ = description
+    return model

uipath-2.1.85/tests/cli/utils/test_dynamic_schema.py

@@ -0,0 +1,95 @@
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+from uipath.utils.dynamic_schema import jsonschema_to_pydantic
+
+
+def test_dynamic_schema():
+    # Arrange
+    class InnerSchema(BaseModel):
+        """Inner schema description."""
+
+        pass
+
+    class Schema(BaseModel):
+        """Schema description."""
+
+        string: str = Field(
+            default="", title="String Title", description="String Description"
+        )
+        optional_string: Optional[str] = Field(
+            default=None,
+            title="Optional String Title",
+            description="Optional String Description",
+        )
+        list_str: List[str] = Field(
+            default=[], title="List String", description="List String Description"
+        )
+
+        integer: int = Field(
+            default=0, title="Integer Title", description="Integer Description"
+        )
+        optional_integer: Optional[int] = Field(
+            default=None,
+            title="Option Integer Title",
+            description="Option Integer Description",
+        )
+        list_integer: List[int] = Field(
+            default=[],
+            title="List Integer Title",
+            description="List Integer Description",
+        )
+
+        floating: float = Field(
+            default=0.0, title="Floating Title", description="Floating Description"
+        )
+        optional_floating: Optional[float] = Field(
+            default=None,
+            title="Option Floating Title",
+            description="Option Floating Description",
+        )
+        list_floating: List[float] = Field(
+            default=[],
+            title="List Floating Title",
+            description="List Floating Description",
+        )
+
+        boolean: bool = Field(
+            default=False, title="Boolean Title", description="Boolean Description"
+        )
+        optional_boolean: Optional[bool] = Field(
+            default=None,
+            title="Option Boolean Title",
+            description="Option Boolean Description",
+        )
+        list_boolean: List[bool] = Field(
+            default=[],
+            title="List Boolean Title",
+            description="List Boolean Description",
+        )
+
+        nested_object: InnerSchema = Field(
+            default=InnerSchema(),
+            title="Nested Object Title",
+            description="Nested Object Description",
+        )
+        optional_nested_object: Optional[InnerSchema] = Field(
+            default=None,
+            title="Optional Nested Object Title",
+            description="Optional Nested Object Description",
+        )
+        list_nested_object: List[InnerSchema] = Field(
+            default=[],
+            title="List Nested Object Title",
+            description="List Nested Object Description",
+        )
+
+    schema_json = Schema.model_json_schema()
+
+    # Act
+    dynamic_schema = jsonschema_to_pydantic(schema_json)
+    dynamic_schema_json = dynamic_schema.model_json_schema()
+
+    # Assert
+    assert dynamic_schema_json == schema_json

{uipath-2.1.84 → uipath-2.1.85}/tests/sdk/services/test_connections_service.py

@@ -2,6 +2,7 @@ from unittest.mock import MagicMock
 from urllib.parse import unquote_plus
 
 import pytest
+from pydantic import ValidationError
 from pytest_httpx import HTTPXMock
 
 from uipath._config import Config
@@ -9,7 +10,13 @@ from uipath._execution_context import ExecutionContext
 from uipath._services.connections_service import ConnectionsService
 from uipath._services.folder_service import FolderService
 from uipath._utils.constants import HEADER_FOLDER_KEY, HEADER_USER_AGENT
-from uipath.models import Connection, ConnectionToken, EventArguments
+from uipath.models import (
+    Connection,
+    ConnectionMetadata,
+    ConnectionToken,
+    EventArguments,
+)
+from uipath.utils.dynamic_schema import jsonschema_to_pydantic
 
 
 @pytest.fixture
@@ -81,6 +88,125 @@ class TestConnectionsService:
             == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ConnectionsService.retrieve/{version}"
         )
 
+    def test_metadata(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        element_instance_id = 123
+        tool_path = "test-tool"
+        valid_choice = {
+            "index": 0,
+            "finishReason": "done",
+            "message": {"content": "foo", "role": "user"},
+        }
+        invalid_choice = {
+            "index": 0,
+            "finishReason": "done",
+            "message": {"content": 123, "role": "user"},
+        }
+        valid_object = {
+            "choices": [valid_choice],
+            "usage": {"totalTokens": 100},
+            "created": 1000,
+        }
+        invalid_object_1 = {
+            "choices": [valid_choice],
+            "usage": {"totalTokens": 100},
+            "created": "string",
+        }
+        invalid_object_2 = {
+            "choices": [invalid_choice],
+            "usage": {"totalTokens": 100},
+            "created": 1000,
+        }
+        json_schema = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "properties": {
+                "choices": {
+                    "title": "Choices",
+                    "type": "array",
+                    "items": {"$ref": "#/definitions/choices"},
+                },
+                "usage": {"title": "Usage", "$ref": "#/definitions/usage"},
+                "created": {
+                    "title": "Creation timestamp",
+                    "type": "integer",
+                    "format": "int64",
+                },
+            },
+            "definitions": {
+                "message": {
+                    "type": "object",
+                    "title": "Message",
+                    "properties": {
+                        "content": {
+                            "title": "Translated message content",
+                            "type": "string",
+                        },
+                        "role": {
+                            "title": "Role of the message sender",
+                            "type": "string",
+                        },
+                    },
+                },
+                "choices": {
+                    "type": "object",
+                    "title": "Choices",
+                    "properties": {
+                        "index": {
+                            "title": "Choice index",
+                            "type": "integer",
+                            "format": "int64",
+                        },
+                        "finish_reason": {
+                            "title": "Completion reason",
+                            "type": "string",
+                        },
+                        "message": {
+                            "title": "Message",
+                            "$ref": "#/definitions/message",
+                        },
+                    },
+                },
+                "usage": {
+                    "type": "object",
+                    "title": "Usage",
+                    "properties": {
+                        "total_tokens": {
+                            "title": "Total tokens used",
+                            "type": "integer",
+                            "format": "int64",
+                        }
+                    },
+                },
+            },
+        }
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/{tool_path}/metadata",
+            status_code=200,
+            json={
+                "fields": json_schema,
+            },
+        )
+
+        metadata = service.metadata(element_instance_id, tool_path)
+
+        assert isinstance(metadata, ConnectionMetadata)
+        dynamic_type = jsonschema_to_pydantic(metadata.fields)
+
+        dynamic_type.model_validate(valid_object)
+        with pytest.raises(ValidationError):
+            assert dynamic_type.model_validate(invalid_object_1)
+        with pytest.raises(ValidationError):
+            assert dynamic_type.model_validate(invalid_object_2)
+        dynamic_type.model_json_schema()
+
     @pytest.mark.anyio
     async def test_retrieve_async(
         self,
@@ -127,6 +253,125 @@ class TestConnectionsService:
             == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ConnectionsService.retrieve_async/{version}"
         )
 
+    async def test_metadata_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        element_instance_id = 123
+        tool_path = "test-tool"
+        valid_choice = {
+            "index": 0,
+            "finishReason": "done",
+            "message": {"content": "foo", "role": "user"},
+        }
+        invalid_choice = {
+            "index": 0,
+            "finishReason": "done",
+            "message": {"content": 123, "role": "user"},
+        }
+        valid_object = {
+            "choices": [valid_choice],
+            "usage": {"totalTokens": 100},
+            "created": 1000,
+        }
+        invalid_object_1 = {
+            "choices": [valid_choice],
+            "usage": {"totalTokens": 100},
+            "created": "string",
+        }
+        invalid_object_2 = {
+            "choices": [invalid_choice],
+            "usage": {"totalTokens": 100},
+            "created": 1000,
+        }
+        json_schema = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "properties": {
+                "choices": {
+                    "title": "Choices",
+                    "type": "array",
+                    "items": {"$ref": "#/definitions/choices"},
+                },
+                "usage": {"title": "Usage", "$ref": "#/definitions/usage"},
+                "created": {
+                    "title": "Creation timestamp",
+                    "type": "integer",
+                    "format": "int64",
+                },
+            },
+            "definitions": {
+                "message": {
+                    "type": "object",
+                    "title": "Message",
+                    "properties": {
+                        "content": {
+                            "title": "Translated message content",
+                            "type": "string",
+                        },
+                        "role": {
+                            "title": "Role of the message sender",
+                            "type": "string",
+                        },
+                    },
+                },
+                "choices": {
+                    "type": "object",
+                    "title": "Choices",
+                    "properties": {
+                        "index": {
+                            "title": "Choice index",
+                            "type": "integer",
+                            "format": "int64",
+                        },
+                        "finish_reason": {
+                            "title": "Completion reason",
+                            "type": "string",
+                        },
+                        "message": {
+                            "title": "Message",
+                            "$ref": "#/definitions/message",
+                        },
+                    },
+                },
+                "usage": {
+                    "type": "object",
+                    "title": "Usage",
+                    "properties": {
+                        "total_tokens": {
+                            "title": "Total tokens used",
+                            "type": "integer",
+                            "format": "int64",
+                        }
+                    },
+                },
+            },
+        }
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/{tool_path}/metadata",
+            status_code=200,
+            json={
+                "fields": json_schema,
+            },
+        )
+
+        metadata = await service.metadata_async(element_instance_id, tool_path)
+
+        assert isinstance(metadata, ConnectionMetadata)
+        dynamic_type = jsonschema_to_pydantic(metadata.fields)
+
+        dynamic_type.model_validate(valid_object)
+        with pytest.raises(ValidationError):
+            assert dynamic_type.model_validate(invalid_object_1)
+        with pytest.raises(ValidationError):
+            assert dynamic_type.model_validate(invalid_object_2)
+        dynamic_type.model_json_schema()
+
     def test_retrieve_token(
         self,
         httpx_mock: HTTPXMock,

{uipath-2.1.84 → uipath-2.1.85}/uv.lock

@@ -2146,7 +2146,7 @@ wheels = [
 
 [[package]]
 name = "uipath"
-version = "2.1.84"
+version = "2.1.85"
 source = { editable = "." }
 dependencies = [
     { name = "azure-monitor-opentelemetry" },