uipath 2.0.24__tar.gz → 2.0.25__tar.gz

{uipath-2.0.24 → uipath-2.0.25}/.github/workflows/publish-dev.yml

@@ -66,6 +66,8 @@ jobs:
           Write-Output "Package version set to $DEV_VERSION"
 
           $dependencyMessage = @"
+          ## Development Package
+
           - Add this package as a dependency in your pyproject.toml:
 
           ``````toml
@@ -79,26 +81,40 @@ jobs:
           ]
           ``````
           "@
-          Write-Output $dependencyMessage
 
-          # Post comment to GitHub PR
+          # Get the owner and repo from the GitHub repository
           $owner = "${{ github.repository_owner }}"
           $repo = "${{ github.repository }}".Split('/')[1]
-          $issueNumber = $PR_NUM
-
-          $body = @{
-            body = $dependencyMessage
-          } | ConvertTo-Json
+          $prNumber = $PR_NUM
 
-          # Create the comment using GitHub REST API
-          $uri = "https://api.github.com/repos/$owner/$repo/issues/$issueNumber/comments"
+          # Get the current PR description
+          $prUri = "https://api.github.com/repos/$owner/$repo/pulls/$prNumber"
           $headers = @{
             Authorization = "token $env:GITHUB_TOKEN"
             Accept = "application/vnd.github.v3+json"
           }
+          
+          $pr = Invoke-RestMethod -Uri $prUri -Method Get -Headers $headers
+          $currentBody = $pr.body
+
+          # Check if there's already a development package section
+          if ($currentBody -match '## Development Package') {
+            # Replace the existing section with the new dependency message
+            $newBody = $currentBody -replace '## Development Package(\r?\n|.)*?(?=##|$)', $dependencyMessage
+          } else {
+            # Append the dependency message to the end of the description
+            $newBody = if ($currentBody) { "$currentBody`n`n$dependencyMessage" } else { $dependencyMessage }
+          }
 
-          Invoke-RestMethod -Uri $uri -Method Post -Body $body -Headers $headers -ContentType "application/json"
-      
+          # Update the PR description
+          $updateBody = @{
+            body = $newBody
+          } | ConvertTo-Json
+
+          Invoke-RestMethod -Uri $prUri -Method Patch -Headers $headers -Body $updateBody -ContentType "application/json"
+          
+          Write-Output "Updated PR description with development package information"
+          
       - name: Build package
         run: uv build
 

{uipath-2.0.24 → uipath-2.0.25}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.0.24"
+version = "2.0.25"
 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.0.24 → uipath-2.0.25}/src/uipath/tracing/_traced.py

@@ -51,8 +51,9 @@ class TracingManager:
 
         Args:
             tracer_implementation: A function that takes the same parameters as _opentelemetry_traced
-                                 and returns a decorator
+                                 and returns a decorator. If None, reverts to default implementation.
         """
+        tracer_implementation = tracer_implementation or _opentelemetry_traced
         cls._custom_tracer_implementation = tracer_implementation
 
         # Work with a copy of the registry to avoid modifying it during iteration
@@ -60,7 +61,10 @@ class TracingManager:
 
         for original_func, decorated_func, params in registry_copy:
             # Apply the new decorator with the same parameters
-            new_decorated_func = tracer_implementation(**params)(original_func)
+            supported_params = _get_supported_params(tracer_implementation, params)
+            new_decorated_func = tracer_implementation(**supported_params)(
+                original_func
+            )
 
             logger.debug(
                 f"Reapplying decorator to {original_func.__name__}, from {decorated_func.__name__}"
@@ -300,6 +304,36 @@ def _opentelemetry_traced(
     return decorator
 
 
+def _get_supported_params(tracer_impl, params):
+    """Extract the parameters supported by the tracer implementation.
+
+    Args:
+        tracer_impl: The tracer implementation function or callable
+        params: Dictionary of parameters to check
+
+    Returns:
+        Dictionary containing only parameters supported by the tracer implementation
+    """
+    supported_params = {}
+    if hasattr(tracer_impl, "__code__"):
+        # For regular functions
+        impl_signature = inspect.signature(tracer_impl)
+        for param_name, param_value in params.items():
+            if param_name in impl_signature.parameters and param_value is not None:
+                supported_params[param_name] = param_value
+    elif callable(tracer_impl):
+        # For callable objects
+        impl_signature = inspect.signature(tracer_impl.__call__)
+        for param_name, param_value in params.items():
+            if param_name in impl_signature.parameters and param_value is not None:
+                supported_params[param_name] = param_value
+    else:
+        # If we can't inspect, pass all parameters and let the function handle it
+        supported_params = params
+
+    return supported_params
+
+
 def traced(
     name: Optional[str] = None,
     run_type: Optional[str] = None,
@@ -343,8 +377,12 @@ def traced(
     )
 
     def decorator(func):
-        # Decorate the function
-        decorated_func = tracer_impl(**params)(func)
+        # Check which parameters are supported by the tracer_impl
+        supported_params = _get_supported_params(tracer_impl, params)
+
+        # Decorate the function with only supported parameters
+        decorated_func = tracer_impl(**supported_params)(func)
+
         # Register both original and decorated function with parameters
         TracingManager.register_traced_function(func, decorated_func, params)
         return decorated_func

{uipath-2.0.24 → uipath-2.0.25}/tests/tracing/test_tracing_manager.py

@@ -64,6 +64,30 @@ def custom_tracer_with_counter(call_counter, **kwargs):
     return decorator
 
 
+# Helper function for testing custom tracer without name parameter
+def custom_tracer_without_name_param(
+    run_type=None,
+    span_type=None,
+    input_processor=None,
+    output_processor=None,
+):
+    """Custom tracer implementation that doesn't accept the 'name' parameter."""
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            result = func(*args, **kwargs)
+            if isinstance(result, dict):
+                result["custom_tracer_without_name"] = True
+                if run_type:
+                    result["run_type"] = run_type
+            return result
+
+        return wrapper
+
+    return decorator
+
+
 # Define the test classes
 class TestClassForMethodTest:
     @traced()
@@ -163,3 +187,33 @@ def test_reapply_to_module_level_functions():
 
     # Verify both functions were processed
     assert call_counter["count"] == 2
+
+
+def test_custom_tracer_without_name_param():
+    """Test that a custom tracer without the 'name' parameter works correctly."""
+    TracingManager.reapply_traced_decorator(donothing_custom_tracer)
+
+    # Create a function with @traced
+    @traced(name="explicit_name")
+    def function_with_name():
+        return {"status": "original"}
+
+    # Initial call with default implementation
+    result1 = function_with_name()
+    assert result1 == {"status": "original"}
+
+    # Apply custom implementation that doesn't support 'name'
+    TracingManager.reapply_traced_decorator(custom_tracer_without_name_param)
+
+    # Create a new function with the same decorator
+    # This tests that new decorations use the custom implementation properly
+    @traced(name="this_will_be_ignored", run_type="special_run")
+    def another_function():
+        return {"status": "success"}
+
+    result3 = another_function()
+
+    # Verify parameters are correctly filtered
+    assert "custom_tracer_without_name" in result3
+    assert "run_type" in result3
+    assert result3["run_type"] == "special_run"

{uipath-2.0.24 → uipath-2.0.25}/uv.lock

@@ -2393,7 +2393,7 @@ wheels = [
 
 [[package]]
 name = "uipath"
-version = "2.0.24"
+version = "2.0.25"
 source = { editable = "." }
 dependencies = [
     { name = "click" },