uipath 2.1.126__tar.gz → 2.1.128__tar.gz

{uipath-2.1.126 → uipath-2.1.128}/.pipelines/security-scans.yml

@@ -35,8 +35,8 @@ stages:
             parameters:
               OS: linux
               azureSubscription: $(azureInternalProductionEaConnectionName)
-              FOSSAFlags: '--project "Coded Agents" --branch "$(Build.SourceBranch)" --revision "$(Build.SourceVersion)-$(Build.BuildId)"'
-              FOSSATestFlags: '--project "Coded Agents" --revision "$(Build.SourceVersion)-$(Build.BuildId)"'
+              FOSSAFlags: '--project "UiPath Python SDK" --branch "$(Build.SourceBranch)" --revision "$(Build.SourceVersion)-$(Build.BuildId)"'
+              FOSSATestFlags: '--project "UiPath Python SDK" --revision "$(Build.SourceVersion)-$(Build.BuildId)"'
               ${{ if contains(variables['Build.SourceBranch'], 'main') }}:
                 publishSecurityReports: true
 
@@ -50,4 +50,4 @@ stages:
             parameters:
               os: 'linux64'
               language: 'python'
-              azureSubscription: $(azureInternalProductionEaConnectionName)
+              azureSubscription: $(azureInternalProductionEaConnectionName)

{uipath-2.1.126 → uipath-2.1.128}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.126"
+version = "2.1.128"
 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.126 → uipath-2.1.128}/src/uipath/_resources/SDK_REFERENCE.md

@@ -168,10 +168,10 @@ sdk.connections.list(name: Optional[str]=None, folder_path: Optional[str]=None,
 sdk.connections.list_async(name: Optional[str]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None, connector_key: Optional[str]=None, skip: Optional[int]=None, top: Optional[int]=None) -> typing.List[uipath.models.connections.Connection]
 
 # Synchronously retrieve connection API metadata.
-sdk.connections.metadata(element_instance_id: int, tool_path: str, schema_mode: bool=True) -> uipath.models.connections.ConnectionMetadata
+sdk.connections.metadata(element_instance_id: int, connector_key: str, tool_path: str, parameters: Optional[Dict[str, str]]=None, schema_mode: bool=True, max_jit_depth: int=5) -> uipath.models.connections.ConnectionMetadata
 
 # Asynchronously retrieve connection API metadata.
-sdk.connections.metadata_async(element_instance_id: int, tool_path: str, schema_mode: bool=True) -> uipath.models.connections.ConnectionMetadata
+sdk.connections.metadata_async(element_instance_id: int, connector_key: str, tool_path: str, parameters: Optional[Dict[str, str]]=None, schema_mode: bool=True, max_jit_depth: int=5) -> uipath.models.connections.ConnectionMetadata
 
 # Retrieve connection details by its key.
 sdk.connections.retrieve(key: str) -> uipath.models.connections.Connection

{uipath-2.1.126 → uipath-2.1.128}/src/uipath/_services/connections_service.py

@@ -1,6 +1,7 @@
 import json
 import logging
 from typing import Any, Dict, List, Optional
+from urllib.parse import parse_qsl, quote, urlsplit
 
 from httpx import Response
 
@@ -60,24 +61,77 @@ class ConnectionsService(BaseService):
         hide_output=True,
     )
     def metadata(
-        self, element_instance_id: int, tool_path: str, schema_mode: bool = True
+        self,
+        element_instance_id: int,
+        connector_key: str,
+        tool_path: str,
+        parameters: Optional[Dict[str, str]] = None,
+        schema_mode: bool = True,
+        max_jit_depth: int = 5,
     ) -> 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.
+        This method fetches the metadata for a connection. When parameters are provided,
+        it automatically fetches JIT (Just-In-Time) metadata for cascading fields in a loop,
+        following action URLs up to a maximum depth.
 
         Args:
             element_instance_id (int): The element instance ID of the connection.
+            connector_key (str): The connector key (e.g., 'uipath-atlassian-jira', 'uipath-slack').
             tool_path (str): The tool path to retrieve metadata for.
+            parameters (Optional[Dict[str, str]]): Parameter values. When provided, triggers
+                automatic JIT fetching for cascading fields.
             schema_mode (bool): Whether or not to represent the output schema in the response fields.
+            max_jit_depth (int): The maximum depth of the JIT resolution loop.
 
         Returns:
             ConnectionMetadata: The connection metadata.
+
+        Examples:
+            >>> metadata = sdk.connections.metadata(
+            ...     element_instance_id=123,
+            ...     connector_key="uipath-atlassian-jira",
+            ...     tool_path="Issue",
+            ...     parameters={"projectId": "PROJ-123"}  # Optional
+            ... )
         """
-        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())
+        spec = self._metadata_spec(
+            element_instance_id, connector_key, tool_path, schema_mode
+        )
+        response = self.request(
+            spec.method, url=spec.endpoint, params=spec.params, headers=spec.headers
+        )
+        data = response.json()
+        metadata = ConnectionMetadata.model_validate(data)
+
+        last_action_url = None
+        depth = 0
+
+        while (
+            parameters
+            and (action_url := self._get_jit_action_url(metadata))
+            and depth < max_jit_depth
+        ):
+            # Stop if we're about to call the same URL template again
+            if action_url == last_action_url:
+                break
+
+            last_action_url = action_url
+            depth += 1
+
+            jit_spec = self._metadata_jit_spec(
+                element_instance_id, action_url, parameters, schema_mode
+            )
+            jit_response = self.request(
+                jit_spec.method,
+                url=jit_spec.endpoint,
+                params=jit_spec.params,
+                headers=jit_spec.headers,
+            )
+            data = jit_response.json()
+            metadata = ConnectionMetadata.model_validate(data)
+
+        return metadata
 
     @traced(name="connections_list", run_type="uipath")
     def list(
@@ -217,26 +271,77 @@ class ConnectionsService(BaseService):
         hide_output=True,
     )
     async def metadata_async(
-        self, element_instance_id: int, tool_path: str, schema_mode: bool = True
+        self,
+        element_instance_id: int,
+        connector_key: str,
+        tool_path: str,
+        parameters: Optional[Dict[str, str]] = None,
+        schema_mode: bool = True,
+        max_jit_depth: int = 5,
     ) -> 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.
+        This method fetches the metadata for a connection. When parameters are provided,
+        it automatically fetches JIT (Just-In-Time) metadata for cascading fields in a loop,
+        following action URLs up to a maximum depth.
 
         Args:
             element_instance_id (int): The element instance ID of the connection.
+            connector_key (str): The connector key (e.g., 'uipath-atlassian-jira', 'uipath-slack').
             tool_path (str): The tool path to retrieve metadata for.
+            parameters (Optional[Dict[str, str]]): Parameter values. When provided, triggers
+                automatic JIT fetching for cascading fields.
             schema_mode (bool): Whether or not to represent the output schema in the response fields.
+            max_jit_depth (int): The maximum depth of the JIT resolution loop.
 
         Returns:
             ConnectionMetadata: The connection metadata.
+
+        Examples:
+            >>> metadata = await sdk.connections.metadata_async(
+            ...     element_instance_id=123,
+            ...     connector_key="uipath-atlassian-jira",
+            ...     tool_path="Issue",
+            ...     parameters={"projectId": "PROJ-123"}  # Optional
+            ... )
         """
-        spec = self._metadata_spec(element_instance_id, tool_path, schema_mode)
+        spec = self._metadata_spec(
+            element_instance_id, connector_key, tool_path, schema_mode
+        )
         response = await self.request_async(
-            spec.method, url=spec.endpoint, headers=spec.headers
+            spec.method, url=spec.endpoint, params=spec.params, headers=spec.headers
         )
-        return ConnectionMetadata.model_validate(response.json())
+        data = response.json()
+        metadata = ConnectionMetadata.model_validate(data)
+
+        last_action_url = None
+        depth = 0
+
+        while (
+            parameters
+            and (action_url := self._get_jit_action_url(metadata))
+            and depth < max_jit_depth
+        ):
+            # Stop if we're about to call the same URL template again
+            if action_url == last_action_url:
+                break
+
+            last_action_url = action_url
+            depth += 1
+
+            jit_spec = self._metadata_jit_spec(
+                element_instance_id, action_url, parameters, schema_mode
+            )
+            jit_response = await self.request_async(
+                jit_spec.method,
+                url=jit_spec.endpoint,
+                params=jit_spec.params,
+                headers=jit_spec.headers,
+            )
+            data = jit_response.json()
+            metadata = ConnectionMetadata.model_validate(data)
+
+        return metadata
 
     @traced(
         name="connections_retrieve_token",
@@ -377,9 +482,13 @@ class ConnectionsService(BaseService):
         )
 
     def _metadata_spec(
-        self, element_instance_id: int, tool_path: str, schema_mode: bool
+        self,
+        element_instance_id: int,
+        connector_key: str,
+        tool_path: str,
+        schema_mode: bool,
     ) -> RequestSpec:
-        metadata_endpoint_url = f"/elements_/v3/element/instances/{element_instance_id}/elements/{tool_path}/metadata"
+        metadata_endpoint_url = f"/elements_/v3/element/instances/{element_instance_id}/elements/{connector_key}/objects/{tool_path}/metadata"
         return RequestSpec(
             method="GET",
             endpoint=Endpoint(metadata_endpoint_url),
@@ -390,6 +499,54 @@ class ConnectionsService(BaseService):
             },
         )
 
+    def _metadata_jit_spec(
+        self,
+        element_instance_id: int,
+        dynamic_path: str,
+        parameters: Dict[str, str],
+        schema_mode: bool,
+    ) -> RequestSpec:
+        """Build request spec for JIT metadata with dynamic path parameter substitution.
+
+        For example, if the dynamic path is "elements/jira/projects/{projectId}/issues", and the parameters
+        are {"projectId": "PROJ-123"}, the resolved path will be "elements/jira/projects/PROJ-123/issues".
+        """
+        for key, value in parameters.items():
+            dynamic_path = dynamic_path.replace(
+                f"{{{key}}}", quote(str(value), safe="")
+            )
+        split = urlsplit(dynamic_path.lstrip("/"))
+        query_params = dict(parse_qsl(split.query))
+
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(
+                f"/elements_/v3/element/instances/{element_instance_id}/{split.path}"
+            ),
+            params=query_params,
+            headers={
+                "accept": "application/schema+json"
+                if schema_mode
+                else "application/json"
+            },
+        )
+
+    def _get_jit_action_url(
+        self, connection_metadata: ConnectionMetadata
+    ) -> Optional[str]:
+        """Return the URL of the JIT action that should be triggered dynamically."""
+        if "method" not in connection_metadata.metadata:
+            return None
+
+        methods = connection_metadata.metadata["method"]
+        actions = [
+            action
+            for method_data in methods.values()
+            for action in method_data.get("design", {}).get("actions", [])
+            if action.get("actionType") == "api"
+        ]
+        return actions[0].get("apiConfiguration", {}).get("url") if actions else None
+
     def _retrieve_token_spec(
         self, key: str, token_type: ConnectionTokenType = ConnectionTokenType.DIRECT
     ) -> RequestSpec:

{uipath-2.1.126 → uipath-2.1.128}/src/uipath/models/connections.py

@@ -8,6 +8,7 @@ class ConnectionMetadata(BaseModel):
     """Metadata about a connection."""
 
     fields: dict[str, Any] = Field(default_factory=dict, alias="fields")
+    metadata: dict[str, Any] = Field(default_factory=dict, alias="metadata")
 
     model_config = ConfigDict(populate_by_name=True, extra="allow")
 

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

@@ -0,0 +1,128 @@
+"""Json schema to dynamic pydantic model."""
+
+from enum import Enum
+from typing import Any, Dict, List, Type, Union
+
+from pydantic import BaseModel, Field, create_model
+
+
+def jsonschema_to_pydantic(
+    schema: dict[str, Any],
+) -> Type[BaseModel]:
+    """Convert a schema dict to a pydantic model.
+
+    Modified version of https://github.com/kreneskyp/jsonschema-pydantic to account for three unresolved issues.
+      1. Support for title
+      2. Better representation of optionals.
+      3. Support for optional
+
+    Args:
+        schema: JSON schema.
+        definitions: Definitions dict. Defaults to `$def`.
+
+    Returns: Pydantic model.
+    """
+    dynamic_type_counter = 0
+    combined_model_counter = 0
+
+    def convert_type(prop: dict[str, Any]) -> Any:
+        nonlocal dynamic_type_counter, combined_model_counter
+        if "$ref" in prop:
+            # This is the full path. It will be updated in update_forward_refs.
+            return prop["$ref"].split("/")[-1].capitalize()
+
+        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 "enum" in prop:
+                dynamic_members = {
+                    f"KEY_{i}": value for i, value in enumerate(prop["enum"])
+                }
+
+                base_type: Any = type_mapping.get(type_, Any)
+
+                class DynamicEnum(base_type, Enum):
+                    pass
+
+                type_ = DynamicEnum(prop.get("title", "DynamicEnum"), dynamic_members)  # type: ignore[call-arg]
+                return type_
+            elif type_ == "array":
+                item_type: Any = convert_type(prop.get("items", {}))
+                return List[item_type]  # noqa F821
+            elif type_ == "object":
+                if "properties" in prop:
+                    if "title" in prop and prop["title"]:
+                        title = prop["title"]
+                    else:
+                        title = f"DynamicType_{dynamic_type_counter}"
+                        dynamic_type_counter += 1
+
+                    fields: dict[str, Any] = {}
+                    required_fields = prop.get("required", [])
+
+                    for name, property in prop.get("properties", {}).items():
+                        pydantic_type = convert_type(property)
+                        field_kwargs = {}
+                        if "default" in property:
+                            field_kwargs["default"] = property["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 property:
+                            field_kwargs["description"] = property["description"]
+                        if "title" in property:
+                            field_kwargs["title"] = property["title"]
+
+                        fields[name] = (pydantic_type, Field(**field_kwargs))
+
+                    object_model = create_model(title, **fields)
+                    if "description" in prop:
+                        object_model.__doc__ = prop["description"]
+                    return object_model
+                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 = convert_type(sub_schema)
+                combined_fields.update(model.__annotations__)
+            combined_model = create_model(
+                f"CombinedModel_{combined_model_counter}", **combined_fields
+            )
+            combined_model_counter += 1
+            return combined_model
+
+        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}")
+
+    namespace: dict[str, Any] = {}
+    for name, definition in schema.get("$defs", schema.get("definitions", {})).items():
+        model = convert_type(definition)
+        namespace[name.capitalize()] = model
+    model = convert_type(schema)
+    model.model_rebuild(force=True, _types_namespace=namespace)
+    return model

{uipath-2.1.126 → uipath-2.1.128}/tests/cli/utils/test_dynamic_schema.py

@@ -1,3 +1,4 @@
+from enum import Enum
 from typing import List, Optional
 
 from pydantic import BaseModel, Field
@@ -5,12 +6,16 @@ from pydantic import BaseModel, Field
 from uipath.utils.dynamic_schema import jsonschema_to_pydantic
 
 
-def test_dynamic_schema():
+def atest_dynamic_schema():
     # Arrange
     class InnerSchema(BaseModel):
-        """Inner schema description."""
+        """Inner schema description including a self-reference."""
 
-        pass
+        self_reference: Optional["InnerSchema"] = None
+
+    class CustomEnum(str, Enum):
+        KEY_1 = "VALUE_1"
+        KEY_2 = "VALUE_2"
 
     class Schema(BaseModel):
         """Schema description."""
@@ -70,7 +75,7 @@ def test_dynamic_schema():
         )
 
         nested_object: InnerSchema = Field(
-            default=InnerSchema(),
+            default=InnerSchema(self_reference=None),
             title="Nested Object Title",
             description="Nested Object Description",
         )
@@ -85,6 +90,12 @@ def test_dynamic_schema():
             description="List Nested Object Description",
         )
 
+        enum: CustomEnum = Field(
+            default=CustomEnum.KEY_1,
+            title="Enum Title",
+            description="Enum Description",
+        )
+
     schema_json = Schema.model_json_schema()
 
     # Act