uipath 2.0.13__tar.gz → 2.0.14__tar.gz

{uipath-2.0.13 → uipath-2.0.14}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.0.13"
+version = "2.0.14"
 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.13 → uipath-2.0.14}/src/uipath/_cli/cli_run.py

@@ -115,9 +115,9 @@ def run(entrypoint: Optional[str], input: Optional[str], resume: bool) -> None:
 
     # Handle result from middleware
     if result.error_message:
-        click.echo(result.error_message)
+        click.echo(result.error_message, err=True)
         if result.should_include_stacktrace:
-            click.echo(traceback.format_exc())
+            click.echo(traceback.format_exc(), err=True)
         click.get_current_context().exit(1)
 
     if result.info_message:

uipath-2.0.14/src/uipath/tracing/__init__.py

@@ -0,0 +1,3 @@
+from ._traced import TracingManager, traced, wait_for_tracers  # noqa: D104
+
+__all__ = ["TracingManager", "traced", "wait_for_tracers"]

{uipath-2.0.13 → uipath-2.0.14}/src/uipath/tracing/_traced.py

@@ -1,8 +1,9 @@
+import importlib
 import inspect
 import json
 import logging
 from functools import wraps
-from typing import Any, Callable, Optional
+from typing import Any, Callable, List, Optional, Tuple
 
 from opentelemetry import trace
 from opentelemetry.sdk.trace import TracerProvider
@@ -18,9 +19,94 @@ trace.get_tracer_provider().add_span_processor(BatchSpanProcessor(LlmOpsHttpExpo
 tracer = trace.get_tracer(__name__)
 
 
-def wait_for_tracers():
-    """Wait for all tracers to finish."""
-    trace.get_tracer_provider().shutdown()  # type: ignore
+class TracingManager:
+    """Static utility class to manage tracing implementations and decorated functions."""
+
+    # Registry to track original functions, decorated functions, and their parameters
+    # Each entry is (original_func, decorated_func, params)
+    _traced_registry: List[Tuple[Callable[..., Any], Callable[..., Any], Any]] = []
+
+    # Custom tracer implementation
+    _custom_tracer_implementation = None
+
+    @classmethod
+    def get_custom_tracer_implementation(cls):
+        """Get the currently set custom tracer implementation."""
+        return cls._custom_tracer_implementation
+
+    @classmethod
+    def register_traced_function(cls, original_func, decorated_func, params):
+        """Register a function decorated with @traced and its parameters.
+
+        Args:
+            original_func: The original function before decoration
+            decorated_func: The function after decoration
+            params: The parameters used for tracing
+        """
+        cls._traced_registry.append((original_func, decorated_func, params))
+
+    @classmethod
+    def reapply_traced_decorator(cls, tracer_implementation):
+        """Reapply a different tracer implementation to all functions previously decorated with @traced.
+
+        Args:
+            tracer_implementation: A function that takes the same parameters as _opentelemetry_traced
+                                 and returns a decorator
+        """
+        cls._custom_tracer_implementation = tracer_implementation
+
+        # Work with a copy of the registry to avoid modifying it during iteration
+        registry_copy = cls._traced_registry.copy()
+
+        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)
+
+            logger.debug(
+                f"Reapplying decorator to {original_func.__name__}, from {decorated_func.__name__}"
+            )
+
+            # If this is a method on a class, we need to update the class
+            if hasattr(original_func, "__self__") and hasattr(
+                original_func, "__func__"
+            ):
+                setattr(
+                    original_func.__self__.__class__,
+                    original_func.__name__,
+                    new_decorated_func.__get__(
+                        original_func.__self__, original_func.__self__.__class__
+                    ),
+                )
+            else:
+                # Replace the function in its module
+                if hasattr(original_func, "__module__") and hasattr(
+                    original_func, "__qualname__"
+                ):
+                    try:
+                        module = importlib.import_module(original_func.__module__)
+                        parts = original_func.__qualname__.split(".")
+
+                        # Handle nested objects
+                        obj = module
+                        for part in parts[:-1]:
+                            obj = getattr(obj, part)
+
+                        setattr(obj, parts[-1], new_decorated_func)
+
+                        # Update the registry entry for this function
+                        # Find the index and replace with updated entry
+                        for i, (orig, _dec, _p) in enumerate(cls._traced_registry):
+                            if orig is original_func:
+                                cls._traced_registry[i] = (
+                                    original_func,
+                                    new_decorated_func,
+                                    params,
+                                )
+                                break
+                    except (ImportError, AttributeError) as e:
+                        # Log the error but continue processing other functions
+                        logger.warning(f"Error reapplying decorator: {e}")
+                        continue
 
 
 def _default_input_processor(inputs):
@@ -33,23 +119,9 @@ def _default_output_processor(outputs):
     return {"redacted": "Output data not logged for privacy/security"}
 
 
-class TracedDecoratorRegistry:
-    """Registry for tracing decorators."""
-
-    _decorators: dict[str, Any] = {}
-    _active_decorator = "opentelemetry"
-
-    @classmethod
-    def register_decorator(cls, name, decorator_factory):
-        """Register a decorator factory function with a name."""
-        cls._decorators[name] = decorator_factory
-        cls._active_decorator = name
-        return cls
-
-    @classmethod
-    def get_decorator(cls):
-        """Get the currently active decorator factory."""
-        return cls._decorators.get(cls._active_decorator)
+def wait_for_tracers():
+    """Wait for all tracers to finish."""
+    trace.get_tracer_provider().shutdown()  # type: ignore
 
 
 def _opentelemetry_traced(
@@ -58,6 +130,8 @@ def _opentelemetry_traced(
     input_processor: Optional[Callable[..., Any]] = None,
     output_processor: Optional[Callable[..., Any]] = None,
 ):
+    """Default tracer implementation using OpenTelemetry."""
+
     def decorator(func):
         @wraps(func)
         def sync_wrapper(*args, **kwargs):
@@ -78,9 +152,7 @@ def _opentelemetry_traced(
                 if input_processor is not None:
                     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
@@ -115,9 +187,7 @@ def _opentelemetry_traced(
                 if input_processor is not None:
                     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
@@ -152,9 +222,7 @@ def _opentelemetry_traced(
                 if input_processor is not None:
                     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):
@@ -195,9 +263,7 @@ def _opentelemetry_traced(
                 if input_processor is not None:
                     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):
@@ -254,16 +320,28 @@ def traced(
     # Apply default processors selectively based on hide flags
     if hide_input:
         input_processor = _default_input_processor
-
     if hide_output:
         output_processor = _default_output_processor
 
-    decorator_factory = TracedDecoratorRegistry.get_decorator()
+    # Store the parameters for later reapplication
+    params = {
+        "run_type": run_type,
+        "span_type": span_type,
+        "input_processor": input_processor,
+        "output_processor": output_processor,
+    }
 
-    if decorator_factory:
-        return decorator_factory(run_type, span_type, input_processor, output_processor)
-    else:
-        # Fallback to original implementation if no active decorator
-        return _opentelemetry_traced(
-            run_type, span_type, input_processor, output_processor
-        )
+    # Check for custom implementation first
+    custom_implementation = TracingManager.get_custom_tracer_implementation()
+    tracer_impl: Any = (
+        custom_implementation if custom_implementation else _opentelemetry_traced
+    )
+
+    def decorator(func):
+        # Decorate the function
+        decorated_func = tracer_impl(**params)(func)
+        # Register both original and decorated function with parameters
+        TracingManager.register_traced_function(func, decorated_func, params)
+        return decorated_func
+
+    return decorator

uipath-2.0.14/tests/tracing/test_tracing_manager.py

@@ -0,0 +1,165 @@
+from functools import wraps
+
+from uipath.tracing._traced import TracingManager, traced
+
+
+# Custom wrapper that does nothing
+def donothing_custom_tracer(**kwargs):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            # Simple implementation that just adds a marker to the result
+            result = func(*args, **kwargs)
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+# Helper function for testing custom tracer
+def simple_custom_tracer(**kwargs):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            # Simple implementation that just adds a marker to the result
+            result = func(*args, **kwargs)
+            if isinstance(result, dict):
+                result["custom_tracer_used"] = True
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+# Helper function for testing custom tracer with method
+def custom_method_tracer(**kwargs):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            result = func(*args, **kwargs)
+            if isinstance(result, dict):
+                result["custom_method_tracer_used"] = True
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+# Helper function for testing with counter
+def custom_tracer_with_counter(call_counter, **kwargs):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            call_counter["count"] += 1
+            result = func(*args, **kwargs)
+            if isinstance(result, dict):
+                result["custom_tracer_id"] = call_counter["count"]
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+# Define the test classes
+class TestClassForMethodTest:
+    @traced()
+    def sample_method(self, x, y):
+        return {"product": x * y}
+
+
+# Module level functions for function test
+@traced()
+def func1_for_test(x):
+    return {"result": x * 2}
+
+
+@traced()
+def func2_for_test(x):
+    return {"result": x * 3}
+
+
+# Define a function with @traced
+@traced()
+def sample_function():
+    return {"status": "success"}
+
+
+def test_tracing_manager_custom_implementation():
+    """Test setting and getting a custom tracer implementation."""
+    # Set the custom implementation
+    TracingManager.reapply_traced_decorator(simple_custom_tracer)
+
+    # Get the implementation and verify it's the same one
+    impl = TracingManager.get_custom_tracer_implementation()
+    assert impl is simple_custom_tracer
+
+
+def test_traced_with_custom_implementation():
+    """Test that @traced uses a custom implementation when provided."""
+    # Set the custom implementation
+    TracingManager.reapply_traced_decorator(simple_custom_tracer)
+
+    # Call the function and verify the custom implementation was used
+    result = sample_function()
+    assert "custom_tracer_used" in result
+    assert result["custom_tracer_used"] is True
+
+
+def test_reapply_traced_decorator_to_class_method():
+    """Test reapply_traced_decorator with class methods."""
+    TracingManager.reapply_traced_decorator(donothing_custom_tracer)
+
+    # Create instance and call with default implementation
+    instance = TestClassForMethodTest()
+    result1 = instance.sample_method(2, 3)
+    assert result1 == {"product": 6}
+
+    # Apply our custom implementation
+    TracingManager.reapply_traced_decorator(custom_method_tracer)
+
+    # Create a NEW instance which will use the updated class method
+    new_instance = TestClassForMethodTest()
+    result2 = new_instance.sample_method(2, 3)
+
+    # Verify the result
+    assert "product" in result2
+    assert result2["product"] == 6
+    assert "custom_method_tracer_used" in result2
+
+
+def test_reapply_to_module_level_functions():
+    """Test reapply_traced_decorator with module level functions."""
+
+    TracingManager.reapply_traced_decorator(donothing_custom_tracer)
+
+    # First call with default implementation
+    assert func1_for_test(5) == {"result": 10}
+    assert func2_for_test(5) == {"result": 15}
+
+    # Counter to track custom tracer calls
+    call_counter = {"count": 0}
+
+    # Reapply with the custom implementation
+    TracingManager.reapply_traced_decorator(
+        lambda **kwargs: custom_tracer_with_counter(call_counter, **kwargs)
+    )
+
+    # Call the functions directly - they should now use the updated implementation
+    result1 = func1_for_test(5)
+    result2 = func2_for_test(5)
+
+    # Verify the custom implementation was applied
+    assert "result" in result1
+    assert result1["result"] == 10
+    assert "custom_tracer_id" in result1
+
+    assert "result" in result2
+    assert result2["result"] == 15
+    assert "custom_tracer_id" in result2
+
+    # Verify both functions were processed
+    assert call_counter["count"] == 2