uipath 2.1.53__tar.gz → 2.1.55__tar.gz

uipath-2.1.55/.github/workflows/integration_tests.yml

@@ -0,0 +1,72 @@
+name: Integration testing
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main ]
+
+permissions:
+  contents: read
+  pull-requests: write
+  actions: read
+
+jobs:
+  discover-testcases:
+    runs-on: ubuntu-latest
+    outputs:
+      testcases: ${{ steps.discover.outputs.testcases }}
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    
+    - name: Discover testcases
+      id: discover
+      run: |
+        # Find all testcase folders (excluding common folders like README, etc.)
+        testcase_dirs=$(find testcases -maxdepth 1 -type d -name "*-*" | sed 's|testcases/||' | sort)
+        
+        echo "Found testcase directories:"
+        echo "$testcase_dirs"
+        
+        # Convert to JSON array for matrix
+        testcases_json=$(echo "$testcase_dirs" | jq -R -s -c 'split("\n")[:-1]')
+        echo "testcases=$testcases_json" >> $GITHUB_OUTPUT
+
+  integration-tests:
+    needs: [discover-testcases]
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/astral-sh/uv:python3.12-bookworm
+      env:
+        UIPATH_JOB_KEY: "3a03d5cb-fa21-4021-894d-a8e2eda0afe0"
+    strategy:
+      fail-fast: false
+      matrix:
+        testcase: ${{ fromJson(needs.discover-testcases.outputs.testcases) }}
+        environment: [alpha, cloud]
+    
+    name: "${{ matrix.testcase }} / ${{ matrix.environment }}"
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Install dependencies
+      run: uv sync
+
+    - name: Run testcase
+      env:
+        CLIENT_ID:      ${{ matrix.environment == 'alpha' && secrets.ALPHA_TEST_CLIENT_ID || secrets.CLOUD_TEST_CLIENT_ID }}
+        CLIENT_SECRET:  ${{ matrix.environment == 'alpha' && secrets.ALPHA_TEST_CLIENT_SECRET || secrets.CLOUD_TEST_CLIENT_SECRET }}
+        BASE_URL:       ${{ matrix.environment == 'alpha' && secrets.ALPHA_BASE_URL || secrets.CLOUD_BASE_URL }}
+        USE_AZURE_CHAT: ${{ matrix.use_azure_chat }}
+      working-directory: testcases/${{ matrix.testcase }}
+      run: |
+        echo "Running testcase: ${{ matrix.testcase }}"
+        echo "Environment: ${{ matrix.environment }}"
+        echo "Working directory: $(pwd)"
+        
+        # Execute the testcase run script directly
+        bash run.sh
+        bash ../common/validate_output.sh

{uipath-2.1.53 → uipath-2.1.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.53
+Version: 2.1.55
 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.53 → uipath-2.1.55}/docs/core/getting_started.md

@@ -239,9 +239,9 @@ Selected feed: Orchestrator Tenant Processes Feed
 
 After selecting your publishing destination (tenant or personal workspace), you'll see details about your package and a confirmation message.
 
-## Getting Started with the SDK
+## Integrating with the UiPath Platform
 
-Create a new project following the same steps as above.
+Create a **new project** (separate from the one you just packaged and published) following the same steps as above. This new project will invoke your previous process using the UiPath SDK.
 
 Open `main.py` in your code editor and add the following code:
 
@@ -262,6 +262,10 @@ def main():
     )
 ```
 
+/// warning
+An agent can invoke itself if needed, but this must be done with caution. Be mindful that using the same name for invocation may lead to unintentional loops. To prevent recursion issues, implement safeguards like exit conditions.
+///
+
 ### Verifying the Execution
 
 <!-- termynal -->

{uipath-2.1.53 → uipath-2.1.55}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.53"
+version = "2.1.55"
 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"
@@ -79,7 +79,7 @@ include = [
 [tool.ruff]
 line-length = 88
 indent-width = 4
-exclude = ["samples/**"]
+exclude = ["samples/**", "testcases/**"]
 
 [tool.ruff.lint]
 select = ["E", "F", "B", "I", "D"]
@@ -107,7 +107,7 @@ line-ending = "auto"
 
 [tool.mypy]
 plugins = ["pydantic.mypy"]
-exclude = ["samples/.*"]
+exclude = ["samples/.*", "testcases/.*"]
 
 follow_imports = "silent"
 warn_redundant_casts = true

{uipath-2.1.53 → uipath-2.1.55}/src/uipath/_cli/_runtime/_contracts.py

@@ -319,7 +319,7 @@ class UiPathRuntimeContext(BaseModel):
     chat_handler: Optional[UiPathConversationHandler] = None
     is_conversational: Optional[bool] = None
 
-    model_config = {"arbitrary_types_allowed": True}
+    model_config = {"arbitrary_types_allowed": True, "extra": "allow"}
 
     @classmethod
     def with_defaults(cls: type[C], config_path: Optional[str] = None, **kwargs) -> C:

{uipath-2.1.53 → uipath-2.1.55}/src/uipath/_cli/_utils/_studio_project.py

@@ -1,6 +1,7 @@
 import json
 import os
 from functools import wraps
+from pathlib import PurePath
 from typing import Any, Callable, List, Optional, Union
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator
@@ -103,7 +104,7 @@ class ProjectFolder(BaseModel):
         return v
 
 
-class ProjectStructure(BaseModel):
+class ProjectStructure(ProjectFolder):
     """Model representing the complete file structure of a UiPath project.
 
     Attributes:
@@ -114,34 +115,7 @@ class ProjectStructure(BaseModel):
         folder_type: The type of the root folder (optional)
     """
 
-    model_config = ConfigDict(
-        validate_by_name=True,
-        validate_by_alias=True,
-        use_enum_values=True,
-        arbitrary_types_allowed=True,
-        extra="allow",
-    )
-
-    id: Optional[str] = Field(default=None, alias="id")
-    name: Optional[str] = Field(default=None, alias="name")
-    folders: List[ProjectFolder] = Field(default_factory=list)
-    files: List[ProjectFile] = Field(default_factory=list)
-    folder_type: Optional[str] = Field(default=None, alias="folderType")
-
-    @field_validator("folder_type", mode="before")
-    @classmethod
-    def convert_folder_type(cls, v: Union[str, int, None]) -> Optional[str]:
-        """Convert numeric folder type to string.
-
-        Args:
-            v: The value to convert
-
-        Returns:
-            Optional[str]: The converted value or None
-        """
-        if isinstance(v, int):
-            return str(v)
-        return v
+    pass
 
 
 class LockInfo(BaseModel):
@@ -174,6 +148,33 @@ def get_folder_by_name(
     return None
 
 
+def resolve_path(
+    folder: ProjectFolder,
+    path: PurePath,
+) -> ProjectFile | ProjectFolder:
+    """Resolve a path relative to the folder.
+
+    Args:
+        folder: Project folder
+        path: Path relative to the folder
+
+    Returns: The resolved folder or file. If resolution fails, an assertion is raised.
+    """
+    root = path.parts
+    while len(root) > 1:
+        child = next(
+            (folder for folder in folder.folders if folder.name == root[0]), None
+        )
+        assert child, "Path not found."
+        folder = child
+        root = root[1:]
+    file = next((f for f in folder.files if f.name == root[0]), None)
+    child = next((folder for folder in folder.folders if folder.name == root[0]), None)
+    resolved = file or child
+    assert resolved, "Path not found."
+    return resolved
+
+
 class AddedResource(BaseModel):
     """Represents a new file to be added during a structural migration."""
 

{uipath-2.1.53 → uipath-2.1.55}/src/uipath/tracing/_traced.py

@@ -2,25 +2,28 @@ import importlib
 import inspect
 import json
 import logging
+from contextvars import ContextVar
 from functools import wraps
 from typing import Any, Callable, List, Optional, Tuple
 
-from opentelemetry import trace
+from opentelemetry import context, trace
+from opentelemetry.trace import set_span_in_context
 
 from ._utils import _SpanUtils
 
 logger = logging.getLogger(__name__)
 
 _tracer_instance: Optional[trace.Tracer] = None
+# ContextVar to track the currently active span for nesting
+_active_traced_span: ContextVar[Optional[trace.Span]] = ContextVar(
+    "_active_traced_span", default=None
+)
 
 
 def get_tracer() -> trace.Tracer:
     """Lazily initializes and returns the tracer instance."""
     global _tracer_instance
     if _tracer_instance is None:
-        logger.warning(
-            "Initializing tracer instance. This should only be done once per process."
-        )
         _tracer_instance = trace.get_tracer(__name__)
     return _tracer_instance
 
@@ -53,24 +56,24 @@ class TracingManager:
         """
         cls._current_span_provider = current_span_provider
 
-    @classmethod
-    def get_parent_context(cls):
-        """Get the parent context using the registered current span provider.
+    @staticmethod
+    def get_parent_context():
+        # Always use the currently active OTel span if valid (recursion / children)
+        current_span = trace.get_current_span()
+        if current_span is not None and current_span.get_span_context().is_valid:
+            return set_span_in_context(current_span)
 
-        Returns:
-            Context object with the current span set, or None if no provider is registered.
-        """
-        if cls._current_span_provider is not None:
+        # Only for the very top-level call, fallback to LangGraph span
+        if TracingManager._current_span_provider is not None:
             try:
-                current_span = cls._current_span_provider()
-                if current_span is not None:
-                    from opentelemetry.trace import set_span_in_context
-
-                    return set_span_in_context(current_span)
+                external_span = TracingManager._current_span_provider()
+                if external_span is not None:
+                    return set_span_in_context(external_span)
             except Exception as e:
                 logger.warning(f"Error getting current span from provider: {e}")
-                return None
-        return None
+
+        # Last fallback
+        return context.get_current()
 
     @classmethod
     def register_traced_function(cls, original_func, decorated_func, params):
@@ -176,176 +179,169 @@ def _opentelemetry_traced(
     """Default tracer implementation using OpenTelemetry."""
 
     def decorator(func):
-        trace_name = name if name is not None else func.__name__
+        trace_name = name or func.__name__
+
+        def get_parent_context():
+            """Return a context object for starting the new span."""
+            current_span = _active_traced_span.get()
+            if current_span is not None and current_span.get_span_context().is_valid:
+                return set_span_in_context(current_span)
 
+            if TracingManager._current_span_provider is not None:
+                try:
+                    external_span = TracingManager._current_span_provider()
+                    if external_span is not None:
+                        return set_span_in_context(external_span)
+                except Exception as e:
+                    logger.warning(f"Error getting current span from provider: {e}")
+
+            return context.get_current()
+
+        # --------- Sync wrapper ---------
         @wraps(func)
         def sync_wrapper(*args, **kwargs):
-            context = TracingManager.get_parent_context()
-
-            with get_tracer().start_as_current_span(
-                trace_name, context=context
-            ) as span:
-                default_span_type = "function_call_sync"
-                span.set_attribute(
-                    "span_type",
-                    span_type if span_type is not None else default_span_type,
-                )
+            ctx = get_parent_context()
+            span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
+            span = span_cm.__enter__()
+            token = _active_traced_span.set(span)
+            try:
+                span.set_attribute("span_type", span_type or "function_call_sync")
                 if run_type is not None:
                     span.set_attribute("run_type", run_type)
 
-                # Format arguments for tracing
                 inputs = _SpanUtils.format_args_for_trace_json(
                     inspect.signature(func), *args, **kwargs
                 )
-                # Apply input processor if provided
-                if input_processor is not None:
+                if input_processor:
                     processed_inputs = input_processor(json.loads(inputs))
                     inputs = json.dumps(processed_inputs, default=str)
                 span.set_attribute("inputs", inputs)
-                try:
-                    result = func(*args, **kwargs)
-                    # Process output if processor is provided
-                    output = result
-                    if output_processor is not None:
-                        output = output_processor(result)
-                    span.set_attribute("output", json.dumps(output, default=str))
-                    return result
-                except Exception as e:
-                    span.record_exception(e)
-                    span.set_status(
-                        trace.status.Status(trace.status.StatusCode.ERROR, str(e))
-                    )
-                    raise
 
+                result = func(*args, **kwargs)
+                output = output_processor(result) if output_processor else result
+                span.set_attribute("output", json.dumps(output, default=str))
+                return result
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(
+                    trace.status.Status(trace.status.StatusCode.ERROR, str(e))
+                )
+                raise
+            finally:
+                _active_traced_span.reset(token)
+                span_cm.__exit__(None, None, None)
+
+        # --------- Async wrapper ---------
         @wraps(func)
         async def async_wrapper(*args, **kwargs):
-            context = TracingManager.get_parent_context()
-
-            with get_tracer().start_as_current_span(
-                trace_name, context=context
-            ) as span:
-                default_span_type = "function_call_async"
-                span.set_attribute(
-                    "span_type",
-                    span_type if span_type is not None else default_span_type,
-                )
+            ctx = get_parent_context()
+            span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
+            span = span_cm.__enter__()
+            token = _active_traced_span.set(span)
+            try:
+                span.set_attribute("span_type", span_type or "function_call_async")
                 if run_type is not None:
                     span.set_attribute("run_type", run_type)
 
-                # Format arguments for tracing
                 inputs = _SpanUtils.format_args_for_trace_json(
                     inspect.signature(func), *args, **kwargs
                 )
-                # Apply input processor if provided
-                if input_processor is not None:
+                if input_processor:
                     processed_inputs = input_processor(json.loads(inputs))
                     inputs = json.dumps(processed_inputs, default=str)
                 span.set_attribute("inputs", inputs)
-                try:
-                    result = await func(*args, **kwargs)
-                    # Process output if processor is provided
-                    output = result
-                    if output_processor is not None:
-                        output = output_processor(result)
-                    span.set_attribute("output", json.dumps(output, default=str))
-                    return result
-                except Exception as e:
-                    span.record_exception(e)
-                    span.set_status(
-                        trace.status.Status(trace.status.StatusCode.ERROR, str(e))
-                    )
-                    raise
 
+                result = await func(*args, **kwargs)
+                output = output_processor(result) if output_processor else result
+                span.set_attribute("output", json.dumps(output, default=str))
+                return result
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(
+                    trace.status.Status(trace.status.StatusCode.ERROR, str(e))
+                )
+                raise
+            finally:
+                _active_traced_span.reset(token)
+                span_cm.__exit__(None, None, None)
+
+        # --------- Generator wrapper ---------
         @wraps(func)
         def generator_wrapper(*args, **kwargs):
-            context = TracingManager.get_parent_context()
-
-            with get_tracer().start_as_current_span(
-                trace_name, context=context
-            ) as span:
-                span.get_span_context()
-                default_span_type = "function_call_generator_sync"
+            ctx = get_parent_context()
+            span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
+            span = span_cm.__enter__()
+            token = _active_traced_span.set(span)
+            try:
                 span.set_attribute(
-                    "span_type",
-                    span_type if span_type is not None else default_span_type,
+                    "span_type", span_type or "function_call_generator_sync"
                 )
                 if run_type is not None:
                     span.set_attribute("run_type", run_type)
 
-                # Format arguments for tracing
                 inputs = _SpanUtils.format_args_for_trace_json(
                     inspect.signature(func), *args, **kwargs
                 )
-                # Apply input processor if provided
-                if input_processor is not None:
+                if input_processor:
                     processed_inputs = input_processor(json.loads(inputs))
                     inputs = json.dumps(processed_inputs, default=str)
                 span.set_attribute("inputs", inputs)
+
                 outputs = []
-                try:
-                    for item in func(*args, **kwargs):
-                        outputs.append(item)
-                        span.add_event(f"Yielded: {item}")  # Add event for each yield
-                        yield item
-
-                    # Process output if processor is provided
-                    output_to_record = outputs
-                    if output_processor is not None:
-                        output_to_record = output_processor(outputs)
-                    span.set_attribute(
-                        "output", json.dumps(output_to_record, default=str)
-                    )
-                except Exception as e:
-                    span.record_exception(e)
-                    span.set_status(
-                        trace.status.Status(trace.status.StatusCode.ERROR, str(e))
-                    )
-                    raise
+                for item in func(*args, **kwargs):
+                    outputs.append(item)
+                    span.add_event(f"Yielded: {item}")
+                    yield item
+                output = output_processor(outputs) if output_processor else outputs
+                span.set_attribute("output", json.dumps(output, default=str))
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(
+                    trace.status.Status(trace.status.StatusCode.ERROR, str(e))
+                )
+                raise
+            finally:
+                _active_traced_span.reset(token)
+                span_cm.__exit__(None, None, None)
 
+        # --------- Async generator wrapper ---------
         @wraps(func)
         async def async_generator_wrapper(*args, **kwargs):
-            context = TracingManager.get_parent_context()
-
-            with get_tracer().start_as_current_span(
-                trace_name, context=context
-            ) as span:
-                default_span_type = "function_call_generator_async"
+            ctx = get_parent_context()
+            span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
+            span = span_cm.__enter__()
+            token = _active_traced_span.set(span)
+            try:
                 span.set_attribute(
-                    "span_type",
-                    span_type if span_type is not None else default_span_type,
+                    "span_type", span_type or "function_call_generator_async"
                 )
                 if run_type is not None:
                     span.set_attribute("run_type", run_type)
 
-                # Format arguments for tracing
                 inputs = _SpanUtils.format_args_for_trace_json(
                     inspect.signature(func), *args, **kwargs
                 )
-                # Apply input processor if provided
-                if input_processor is not None:
+                if input_processor:
                     processed_inputs = input_processor(json.loads(inputs))
                     inputs = json.dumps(processed_inputs, default=str)
                 span.set_attribute("inputs", inputs)
+
                 outputs = []
-                try:
-                    async for item in func(*args, **kwargs):
-                        outputs.append(item)
-                        span.add_event(f"Yielded: {item}")  # Add event for each yield
-                        yield item
-
-                    # Process output if processor is provided
-                    output_to_record = outputs
-                    if output_processor is not None:
-                        output_to_record = output_processor(outputs)
-                    span.set_attribute(
-                        "output", json.dumps(output_to_record, default=str)
-                    )
-                except Exception as e:
-                    span.record_exception(e)
-                    span.set_status(
-                        trace.status.Status(trace.status.StatusCode.ERROR, str(e))
-                    )
-                    raise
+                async for item in func(*args, **kwargs):
+                    outputs.append(item)
+                    span.add_event(f"Yielded: {item}")
+                    yield item
+                output = output_processor(outputs) if output_processor else outputs
+                span.set_attribute("output", json.dumps(output, default=str))
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(
+                    trace.status.Status(trace.status.StatusCode.ERROR, str(e))
+                )
+                raise
+            finally:
+                _active_traced_span.reset(token)
+                span_cm.__exit__(None, None, None)
 
         if inspect.iscoroutinefunction(func):
             return async_wrapper

uipath-2.1.55/testcases/apicalls-testcase/main.py

@@ -0,0 +1,47 @@
+import logging
+from dataclasses import dataclass
+from typing import Optional
+
+from uipath import UiPath
+
+logger = logging.getLogger(__name__)
+
+sdk = None
+
+
+def test_assets(sdk: UiPath):
+    sdk.assets.retrieve(name="MyAsset")
+
+
+async def test_llm(sdk: UiPath):
+    messages = [
+        {"role": "system", "content": "You are a helpful programming assistant."},
+        {"role": "user", "content": "How do I read a file in Python?"},
+        {"role": "assistant", "content": "You can use the built-in open() function."},
+        {"role": "user", "content": "Can you show an example?"},
+    ]
+
+    result_openai = await sdk.llm_openai.chat_completions(messages)
+    logger.info("LLM OpenAI Response: %s", result_openai.choices[0].message.content)
+
+    result_normalized = await sdk.llm.chat_completions(messages)
+    logger.info(
+        "LLM Normalized Response: %s", result_normalized.choices[0].message.content
+    )
+
+
+@dataclass
+class EchoIn:
+    message: str
+
+
+@dataclass
+class EchoOut:
+    message: str
+
+
+async def main(input: EchoIn) -> EchoOut:
+    sdk = UiPath()
+
+    await test_llm(sdk)
+    return EchoOut(message=input.message)

uipath-2.1.55/testcases/apicalls-testcase/pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "agent"
+version = "0.0.1"
+description = "agent"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.10"
+
+[tool.uv.sources]
+uipath = { path = "../../", editable = true }

uipath-2.1.55/testcases/apicalls-testcase/run.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+echo "Syncing dependencies..."
+uv sync
+
+echo "Authenticating with UiPath..."
+uv run uipath auth --client-id="$CLIENT_ID" --client-secret="$CLIENT_SECRET" --base-url="$BASE_URL"
+
+echo "Run init..."
+uv run uipath init
+
+echo "Packing agent..."
+uv run uipath pack
+
+echo "Input from input.json file"
+uv run uipath run main.py '{"message": "abc" }'