uipath 2.1.126__tar.gz → 2.1.127__tar.gz

{uipath-2.1.126 → uipath-2.1.127}/.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.127}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.126"
+version = "2.1.127"
 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.127}/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.127}/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.127}/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.126 → uipath-2.1.127}/tests/sdk/services/test_connections_service.py

@@ -98,6 +98,7 @@ class TestConnectionsService:
         version: str,
     ) -> None:
         element_instance_id = 123
+        connector_key = "test-connector"
         tool_path = "test-tool"
         valid_choice = {
             "index": 0,
@@ -188,14 +189,14 @@ class TestConnectionsService:
             },
         }
         httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/{tool_path}/metadata",
+            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/{connector_key}/objects/{tool_path}/metadata",
             status_code=200,
             json={
                 "fields": json_schema,
             },
         )
 
-        metadata = service.metadata(element_instance_id, tool_path)
+        metadata = service.metadata(element_instance_id, connector_key, tool_path)
 
         assert isinstance(metadata, ConnectionMetadata)
         dynamic_type = jsonschema_to_pydantic(metadata.fields)
@@ -263,6 +264,7 @@ class TestConnectionsService:
         version: str,
     ) -> None:
         element_instance_id = 123
+        connector_key = "test-connector"
         tool_path = "test-tool"
         valid_choice = {
             "index": 0,
@@ -353,14 +355,16 @@ class TestConnectionsService:
             },
         }
         httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/{tool_path}/metadata",
+            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/{connector_key}/objects/{tool_path}/metadata",
             status_code=200,
             json={
                 "fields": json_schema,
             },
         )
 
-        metadata = await service.metadata_async(element_instance_id, tool_path)
+        metadata = await service.metadata_async(
+            element_instance_id, connector_key, tool_path
+        )
 
         assert isinstance(metadata, ConnectionMetadata)
         dynamic_type = jsonschema_to_pydantic(metadata.fields)
@@ -1001,3 +1005,256 @@ class TestConnectionsService:
             exc_info.value
         )
         assert "cannot be provided together" in str(exc_info.value)
+
+    def test_get_jit_action_url_with_api_action(
+        self, service: ConnectionsService
+    ) -> None:
+        """Test _get_jit_action_url extracts URL from first API action."""
+        metadata = ConnectionMetadata(
+            fields={},
+            metadata={
+                "method": {
+                    "POST": {
+                        "design": {
+                            "actions": [
+                                {
+                                    "actionType": "reset",
+                                    "name": "Reset Form",
+                                },
+                                {
+                                    "actionType": "api",
+                                    "name": "Load Issue Types",
+                                    "apiConfiguration": {
+                                        "method": "GET",
+                                        "url": "elements/jira/projects/{project.id}/issuetypes",
+                                    },
+                                },
+                            ]
+                        }
+                    }
+                }
+            },
+        )
+
+        url = service._get_jit_action_url(metadata)
+
+        assert url == "elements/jira/projects/{project.id}/issuetypes"
+
+    def test_metadata_with_jit_parameters(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """Test metadata() triggers JIT fetch when parameters are provided."""
+        element_instance_id = 123
+        connector_key = "uipath-jira"
+        tool_path = "Issue"
+        parameters = {"project.id": "PROJ-123"}
+
+        # Mock initial metadata response
+        initial_response = {
+            "fields": {
+                "project.id": {"type": "string", "displayName": "Project ID"},
+                "summary": {"type": "string", "displayName": "Summary"},
+            },
+            "metadata": {
+                "method": {
+                    "POST": {
+                        "design": {
+                            "actions": [
+                                {
+                                    "actionType": "api",
+                                    "apiConfiguration": {
+                                        "url": "elements/jira/projects/{project.id}/issuetypes"
+                                    },
+                                }
+                            ]
+                        }
+                    }
+                }
+            },
+        }
+
+        # Mock JIT metadata response
+        jit_response = {
+            "fields": {
+                "CustomIssueType": {
+                    "type": "string",
+                    "displayName": "Custom Issue Type",
+                },
+            },
+        }
+
+        # Add mock responses
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/{connector_key}/objects/{tool_path}/metadata",
+            json=initial_response,
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/jira/projects/PROJ-123/issuetypes",
+            json=jit_response,
+        )
+
+        metadata = service.metadata(
+            element_instance_id, connector_key, tool_path, parameters
+        )
+
+        # Should return JIT metadata
+        assert isinstance(metadata, ConnectionMetadata)
+        assert "CustomIssueType" in metadata.fields
+
+        # Verify both requests were made
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 2
+
+    @pytest.mark.httpx_mock(assert_all_responses_were_requested=False)
+    async def test_metadata_with_max_jit_depth(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """Test metadata() stops at max JIT depth to prevent infinite loops."""
+        element_instance_id = 123
+        connector_key = "uipath-jira"
+        tool_path = "Issue"
+        parameters = {"param": "value"}
+        max_jit_depth = 5
+
+        # Create a response that always has another action (infinite chain)
+        def create_response_with_action(level: int):
+            return {
+                "fields": {
+                    f"field_level_{level}": {
+                        "type": "string",
+                        "displayName": f"Field Level {level}",
+                    },
+                },
+                "metadata": {
+                    "method": {
+                        "POST": {
+                            "design": {
+                                "actions": [
+                                    {
+                                        "actionType": "api",
+                                        "apiConfiguration": {
+                                            "url": f"elements/jira/level{level + 1}"
+                                        },
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                },
+            }
+
+        # Add initial response
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/{connector_key}/objects/{tool_path}/metadata",
+            json=create_response_with_action(0),
+        )
+
+        # Add 10 more levels (more than max JIT depth) to test limit
+        for level in range(1, 11):
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/jira/level{level}",
+                json=create_response_with_action(level),
+            )
+
+        metadata = service.metadata(
+            element_instance_id, connector_key, tool_path, parameters, max_jit_depth
+        )
+
+        # Should return metadata from level 5 (stopped at max JIT depth)
+        assert isinstance(metadata, ConnectionMetadata)
+        assert "field_level_5" in metadata.fields
+
+        # Verify exactly 6 requests were made (initial + 5 JIT levels)
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 6
+
+    def test_metadata_stops_on_repeated_url(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """Test metadata() stops early when action URL repeats."""
+        element_instance_id = 123
+        connector_key = "uipath-jira"
+        tool_path = "Issue"
+        parameters = {"project.id": "PROJ-123"}
+
+        # First response with action URL
+        level1_response = {
+            "fields": {
+                "field1": {"type": "string", "displayName": "Field 1"},
+            },
+            "metadata": {
+                "method": {
+                    "POST": {
+                        "design": {
+                            "actions": [
+                                {
+                                    "actionType": "api",
+                                    "apiConfiguration": {
+                                        "url": "elements/jira/projects/{project.id}/metadata"
+                                    },
+                                }
+                            ]
+                        }
+                    }
+                }
+            },
+        }
+
+        # Second response with the same action URL
+        level2_response = {
+            "fields": {
+                "field2": {"type": "string", "displayName": "Field 2"},
+            },
+            "metadata": {
+                "method": {
+                    "POST": {
+                        "design": {
+                            "actions": [
+                                {
+                                    "actionType": "api",
+                                    "apiConfiguration": {
+                                        "url": "elements/jira/projects/{project.id}/metadata"
+                                    },
+                                }
+                            ]
+                        }
+                    }
+                }
+            },
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/{connector_key}/objects/{tool_path}/metadata",
+            json=level1_response,
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/jira/projects/PROJ-123/metadata",
+            json=level2_response,
+        )
+
+        metadata = service.metadata(
+            element_instance_id, connector_key, tool_path, parameters
+        )
+
+        # Should return metadata from level 2 (stopped because next URL is same)
+        assert isinstance(metadata, ConnectionMetadata)
+        assert "field2" in metadata.fields
+
+        # Verify exactly 2 requests were made (initial + 1 JIT level, then stopped)
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 2

{uipath-2.1.126 → uipath-2.1.127}/uv.lock

@@ -3047,7 +3047,7 @@ wheels = [
 
 [[package]]
 name = "uipath"
-version = "2.1.126"
+version = "2.1.127"
 source = { editable = "." }
 dependencies = [
     { name = "azure-monitor-opentelemetry" },