uipath-langchain 0.0.90__py3-none-any.whl → 0.0.92__py3-none-any.whl

uipath_langchain/_cli/_runtime/_runtime.py

@@ -15,7 +15,7 @@ from uipath._cli._runtime._contracts import (
     UiPathRuntimeResult,
 )
 
-from ..._utils import _instrument_traceable
+from ..._utils import _instrument_traceable_attributes
 from ...tracers import AsyncUiPathTracer
 from ._context import LangGraphRuntimeContext
 from ._exception import LangGraphRuntimeError
@@ -45,7 +45,7 @@ class LangGraphRuntime(UiPathBaseRuntime):
         Raises:
             LangGraphRuntimeError: If execution fails
         """
-        _instrument_traceable()
+        _instrument_traceable_attributes()
 
         await self.validate()
 

uipath_langchain/_utils/__init__.py

@@ -1,4 +1,4 @@
-from ..tracers._instrument_traceable import _instrument_traceable
+from ..tracers._instrument_traceable import _instrument_traceable_attributes
 from ._request_mixin import UiPathRequestMixin
 
-__all__ = ["UiPathRequestMixin", "_instrument_traceable"]
+__all__ = ["UiPathRequestMixin", "_instrument_traceable_attributes"]

uipath_langchain/tracers/__init__.py

@@ -1,5 +1,9 @@
-from ._instrument_traceable import _instrument_traceable
+from ._instrument_traceable import _instrument_traceable_attributes
 from .AsyncUiPathTracer import AsyncUiPathTracer
 from .UiPathTracer import UiPathTracer
 
-__all__ = ["AsyncUiPathTracer", "UiPathTracer", "_instrument_traceable"]
+__all__ = [
+    "AsyncUiPathTracer",
+    "UiPathTracer",
+    "_instrument_traceable_attributes",
+]

uipath_langchain/tracers/_instrument_traceable.py

@@ -4,9 +4,10 @@ import inspect
 import logging
 import sys
 import uuid
-from typing import Any, Dict, List, Literal, Optional
+from typing import Any, Callable, Dict, List, Literal, Optional
 
 from langchain_core.callbacks import dispatch_custom_event
+from uipath.tracing import TracingManager
 
 from ._events import CustomTraceEvents, FunctionCallEventData
 
@@ -82,26 +83,228 @@ def format_args_for_trace(
         return {"args": args, "kwargs": kwargs}
 
 
-# Create patched version of traceable
-def patched_traceable(*decorator_args, **decorator_kwargs):
-    # Handle the case when @traceable is used directly as decorator without arguments
-    if (
-        len(decorator_args) == 1
-        and callable(decorator_args[0])
-        and not decorator_kwargs
-    ):
-        func = decorator_args[0]
-        return _create_appropriate_wrapper(func, original_traceable(func), {})
-
-    # Handle the case when @traceable(args) is used with parameters
-    original_decorated = original_traceable(*decorator_args, **decorator_kwargs)
+def _create_traced_wrapper(
+    func: Callable[..., Any],
+    wrapper_func: Optional[Callable[..., Any]] = None,
+    func_name: Optional[str] = None,
+    run_type: Optional[str] = None,
+    span_type: Optional[str] = None,
+    tags: Optional[List[str]] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    input_processor: Optional[Callable[..., Any]] = None,
+    output_processor: Optional[Callable[..., Any]] = None,
+):
+    """Create a traced wrapper based on function type."""
+    # Use function name if not provided
+    actual_func_name = func_name or func.__name__
+    # Function to actually call (the wrapped function or original)
+    target_func = wrapper_func or func
+    # Ensure we have metadata
+    actual_metadata = metadata or {}
+
+    # Define all wrapper functions
+
+    @functools.wraps(target_func)
+    async def async_gen_wrapper(*args, **kwargs):
+        try:
+            call_uuid = str(uuid.uuid4())
+
+            # Get inputs and process them if needed
+            inputs = format_args_for_trace(inspect.signature(func), *args, **kwargs)
+            if input_processor is not None:
+                inputs = input_processor(inputs)
+
+            # Add span_type to metadata if provided
+            if span_type:
+                actual_metadata["span_type"] = (
+                    span_type or "function_call_generator_async"
+                )
 
-    def uipath_trace_decorator(func):
-        # Apply the original decorator with its arguments
-        wrapped_func = original_decorated(func)
-        return _create_appropriate_wrapper(func, wrapped_func, decorator_kwargs)
+            dispatch_trace_event(
+                actual_func_name,
+                inputs,
+                "call",
+                call_uuid,
+                run_type=run_type,  # type: ignore
+                tags=tags,
+                metadata=actual_metadata,
+            )
+
+            outputs = []
+            async_gen = target_func(*args, **kwargs)
+            async for item in async_gen:
+                outputs.append(item)
+                yield item
+
+            # Process output if needed
+            output_to_record = outputs
+            if output_processor is not None:
+                output_to_record = output_processor(outputs)
+
+            dispatch_trace_event(
+                actual_func_name,
+                inputs,
+                "completion",
+                call_uuid,
+                result=output_to_record,
+            )
+        except Exception as e:
+            dispatch_trace_event(
+                actual_func_name, inputs, "completion", call_uuid, exception=e
+            )
+            raise
+
+    @functools.wraps(target_func)
+    def gen_wrapper(*args, **kwargs):
+        try:
+            call_uuid = str(uuid.uuid4())
+
+            # Get inputs and process them if needed
+            inputs = format_args_for_trace(inspect.signature(func), *args, **kwargs)
+            if input_processor is not None:
+                inputs = input_processor(inputs)
+
+            # Add span_type to metadata if provided
+            if span_type:
+                actual_metadata["span_type"] = (
+                    span_type or "function_call_generator_sync"
+                )
 
-    return uipath_trace_decorator
+            dispatch_trace_event(
+                actual_func_name,
+                inputs,
+                "call",
+                call_uuid,
+                run_type=run_type,  # type: ignore
+                tags=tags,
+                metadata=actual_metadata,
+            )
+
+            outputs = []
+            gen = target_func(*args, **kwargs)
+            for item in gen:
+                outputs.append(item)
+                yield item
+
+            # Process output if needed
+            output_to_record = outputs
+            if output_processor is not None:
+                output_to_record = output_processor(outputs)
+
+            dispatch_trace_event(
+                actual_func_name,
+                inputs,
+                "completion",
+                call_uuid,
+                result=output_to_record,
+            )
+        except Exception as e:
+            dispatch_trace_event(
+                actual_func_name, inputs, "completion", call_uuid, exception=e
+            )
+            raise
+
+    @functools.wraps(target_func)
+    async def async_wrapper(*args, **kwargs):
+        try:
+            call_uuid = str(uuid.uuid4())
+
+            # Get inputs and process them if needed
+            inputs = format_args_for_trace(inspect.signature(func), *args, **kwargs)
+            if input_processor is not None:
+                inputs = input_processor(inputs)
+
+            # Add span_type to metadata if provided
+            if span_type:
+                actual_metadata["span_type"] = span_type or "function_call_async"
+
+            dispatch_trace_event(
+                actual_func_name,
+                inputs,
+                "call",
+                call_uuid,
+                run_type=run_type,  # type: ignore
+                tags=tags,
+                metadata=actual_metadata,
+            )
+
+            result = await target_func(*args, **kwargs)
+
+            # Process output if needed
+            output_to_record = result
+            if output_processor is not None:
+                output_to_record = output_processor(result)
+
+            dispatch_trace_event(
+                actual_func_name,
+                inputs,
+                "completion",
+                call_uuid,
+                result=output_to_record,
+            )
+
+            return result
+        except Exception as e:
+            dispatch_trace_event(
+                actual_func_name, inputs, "completion", call_uuid, exception=e
+            )
+            raise
+
+    @functools.wraps(target_func)
+    def sync_wrapper(*args, **kwargs):
+        try:
+            call_uuid = str(uuid.uuid4())
+
+            # Get inputs and process them if needed
+            inputs = format_args_for_trace(inspect.signature(func), *args, **kwargs)
+            if input_processor is not None:
+                inputs = input_processor(inputs)
+
+            # Add span_type to metadata if provided
+            if span_type:
+                actual_metadata["span_type"] = span_type or "function_call_sync"
+
+            dispatch_trace_event(
+                actual_func_name,
+                inputs,
+                "call",
+                call_uuid,
+                run_type=run_type,  # type: ignore
+                tags=tags,
+                metadata=actual_metadata,
+            )
+
+            result = target_func(*args, **kwargs)
+
+            # Process output if needed
+            output_to_record = result
+            if output_processor is not None:
+                output_to_record = output_processor(result)
+
+            dispatch_trace_event(
+                actual_func_name,
+                inputs,
+                "completion",
+                call_uuid,
+                result=output_to_record,
+            )
+
+            return result
+        except Exception as e:
+            dispatch_trace_event(
+                actual_func_name, inputs, "completion", call_uuid, exception=e
+            )
+            raise
+
+    # Return the appropriate wrapper based on the function type
+    if inspect.isasyncgenfunction(target_func):
+        return async_gen_wrapper
+    elif inspect.isgeneratorfunction(target_func):
+        return gen_wrapper
+    elif inspect.iscoroutinefunction(target_func):
+        return async_wrapper
+    else:
+        return sync_wrapper
 
 
 def _create_appropriate_wrapper(
@@ -115,154 +318,73 @@ def _create_appropriate_wrapper(
     metadata = decorator_kwargs.get("metadata", None)
     run_type = decorator_kwargs.get("run_type", None)
 
-    # Async generator function
-    if inspect.isasyncgenfunction(wrapped_func):
-
-        @functools.wraps(wrapped_func)
-        async def async_gen_wrapper(*args, **kwargs):
-            try:
-                call_uuid = str(uuid.uuid4())
-
-                inputs = format_args_for_trace(
-                    inspect.signature(original_func), *args, **kwargs
-                )
-
-                dispatch_trace_event(
-                    func_name,
-                    inputs,
-                    "call",
-                    call_uuid,
-                    run_type=run_type,
-                    tags=tags,
-                    metadata=metadata,
-                )
-                async_gen = wrapped_func(*args, **kwargs)
-
-                results = []
-
-                async for item in async_gen:
-                    results.append(item)
-                    yield item
-
-                dispatch_trace_event(
-                    func_name, inputs, "completion", call_uuid, results
-                )
-            except Exception as e:
-                dispatch_trace_event(
-                    func_name, inputs, "completion", call_uuid, exception=e
-                )
-                raise
-
-        return async_gen_wrapper
-
-    # Sync generator function
-    elif inspect.isgeneratorfunction(wrapped_func):
-
-        @functools.wraps(wrapped_func)
-        def gen_wrapper(*args, **kwargs):
-            try:
-                call_uuid = str(uuid.uuid4())
-
-                inputs = format_args_for_trace(
-                    inspect.signature(original_func), *args, **kwargs
-                )
-
-                results = []
-
-                dispatch_trace_event(
-                    func_name,
-                    inputs,
-                    "call",
-                    call_uuid,
-                    run_type=run_type,
-                    tags=tags,
-                    metadata=metadata,
-                )
-                gen = wrapped_func(*args, **kwargs)
-                for item in gen:
-                    results.append(item)
-                    yield item
-                dispatch_trace_event(
-                    func_name, inputs, "completion", call_uuid, results
-                )
-            except Exception as e:
-                dispatch_trace_event(
-                    func_name, inputs, "completion", call_uuid, exception=e
-                )
-                raise
-
-        return gen_wrapper
+    return _create_traced_wrapper(
+        func=original_func,
+        wrapper_func=wrapped_func,
+        func_name=func_name,
+        run_type=run_type,
+        tags=tags,
+        metadata=metadata,
+    )
 
-    # Async function
-    elif inspect.iscoroutinefunction(wrapped_func):
 
-        @functools.wraps(wrapped_func)
-        async def async_wrapper(*args, **kwargs):
-            try:
-                call_uuid = str(uuid.uuid4())
+def _uipath_traced(
+    run_type: Optional[str] = None,
+    span_type: Optional[str] = None,
+    input_processor: Optional[Callable[..., Any]] = None,
+    output_processor: Optional[Callable[..., Any]] = None,
+):
+    """Decorator factory that creates traced functions using dispatch_trace_event."""
+
+    def decorator(func):
+        return _create_traced_wrapper(
+            func=func,
+            run_type=run_type,
+            span_type=span_type,
+            input_processor=input_processor,
+            output_processor=output_processor,
+        )
 
-                inputs = format_args_for_trace(
-                    inspect.signature(original_func), *args, **kwargs
-                )
+    return decorator
 
-                dispatch_trace_event(
-                    func_name,
-                    inputs,
-                    "call",
-                    call_uuid,
-                    run_type=run_type,
-                    tags=tags,
-                    metadata=metadata,
-                )
-                result = await wrapped_func(*args, **kwargs)
-                dispatch_trace_event(func_name, inputs, "completion", call_uuid, result)
-                return result
-            except Exception as e:
-                dispatch_trace_event(
-                    func_name, inputs, "completion", call_uuid, exception=e
-                )
-                raise
 
-        return async_wrapper
+# Create patched version of traceable
+def patched_traceable(*decorator_args, **decorator_kwargs):
+    # Handle the case when @traceable is used directly as decorator without arguments
+    if (
+        len(decorator_args) == 1
+        and callable(decorator_args[0])
+        and not decorator_kwargs
+    ):
+        func = decorator_args[0]
+        return _create_appropriate_wrapper(func, original_traceable(func), {})
 
-    # Regular sync function (default case)
-    else:
+    # Handle the case when @traceable(args) is used with parameters
+    original_decorated = original_traceable(*decorator_args, **decorator_kwargs)
 
-        @functools.wraps(wrapped_func)
-        def sync_wrapper(*args, **kwargs):
-            try:
-                call_uuid = str(uuid.uuid4())
+    def uipath_trace_decorator(func):
+        # Apply the original decorator with its arguments
+        wrapped_func = original_decorated(func)
+        return _create_appropriate_wrapper(func, wrapped_func, decorator_kwargs)
 
-                inputs = format_args_for_trace(
-                    inspect.signature(original_func), *args, **kwargs
-                )
+    return uipath_trace_decorator
 
-                dispatch_trace_event(
-                    func_name,
-                    inputs,
-                    "call",
-                    call_uuid,
-                    run_type=run_type,
-                    tags=tags,
-                    metadata=metadata,
-                )
-                result = wrapped_func(*args, **kwargs)
-                dispatch_trace_event(func_name, inputs, "completion", call_uuid, result)
-                return result
-            except Exception as e:
-                dispatch_trace_event(
-                    func_name, inputs, "completion", call_uuid, exception=e
-                )
-                raise
 
-        return sync_wrapper
+# Register the UIPath traced decorator
+def register_uipath_tracing():
+    """Register the UIPath tracing decorator with TracedDecoratorRegistry."""
+    # Reapply to all previously decorated functions
+    TracingManager.reapply_traced_decorator(_uipath_traced)
 
 
 # Apply the patch
-def _instrument_traceable():
+def _instrument_traceable_attributes():
     """Apply the patch to langsmith module at import time."""
     global original_langsmith, original_traceable
 
+    # Register our custom tracing decorator
+    register_uipath_tracing()
+
     # Import the original module if not already done
     if original_langsmith is None:
         # Temporarily remove our custom module from sys.modules

{uipath_langchain-0.0.90.dist-info → uipath_langchain-0.0.92.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.90
+Version: 0.0.92
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python
@@ -25,7 +25,7 @@ Requires-Dist: pydantic-settings>=2.6.0
 Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: requests>=2.23.3
 Requires-Dist: types-requests>=2.32.0.20241016
-Requires-Dist: uipath<2.1.0,>=2.0.9
+Requires-Dist: uipath<2.1.0,>=2.0.14
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 

{uipath_langchain-0.0.90.dist-info → uipath_langchain-0.0.92.dist-info}/RECORD

@@ -8,9 +8,9 @@ uipath_langchain/_cli/_runtime/_escalation.py,sha256=oA5NvZvCo8ngELFJRyhZNM69DxV
 uipath_langchain/_cli/_runtime/_exception.py,sha256=USKkLYkG-dzjX3fEiMMOHnVUpiXJs_xF0OQXCCOvbYM,546
 uipath_langchain/_cli/_runtime/_input.py,sha256=gKzPaGW-EzgeAskWJjbCWnfZRLu_BM7lCXkq0XkVGLU,5614
 uipath_langchain/_cli/_runtime/_output.py,sha256=WQSrsvGaaclZ6GLWEh6Nk1Mz1iGaIB45PgIX3DS3AN4,16130
-uipath_langchain/_cli/_runtime/_runtime.py,sha256=M82qhxU6OVrobiaqoktPYEN9HQyK4NjuW9VgrTAxfWs,11803
+uipath_langchain/_cli/_runtime/_runtime.py,sha256=wj6e6tQdP2GjuSM-6G6Ug-FMqwOHwfUq-DGbd1gMfIg,11825
 uipath_langchain/_cli/_utils/_graph.py,sha256=WLBSJfPc3_C07SqJhePRe17JIc5wcBvEqLviMcNOdTA,6950
-uipath_langchain/_utils/__init__.py,sha256=Sp2qnEXLAp9ftQ09x7CZMenYnpXIIGFJNv8zNN7vAsw,172
+uipath_langchain/_utils/__init__.py,sha256=WoY66enCygRXTh6v5B1UrRcFCnQYuPJ8oqDkwomXzLc,194
 uipath_langchain/_utils/_request_mixin.py,sha256=t_1HWBxqEl-wsSk9ubmIM-8vs9BlNy4ZVBxtDxktn6U,18489
 uipath_langchain/_utils/_settings.py,sha256=MhwEVj4gVRSar0RBf2w2hTjO-5Qm-HpCuufqN3gSWjA,3390
 uipath_langchain/_utils/_sleep_policy.py,sha256=e9pHdjmcCj4CVoFM1jMyZFelH11YatsgWfpyrfXzKBQ,1251
@@ -24,17 +24,17 @@ uipath_langchain/retrievers/__init__.py,sha256=rOn7PyyHgZ4pMnXWPkGqmuBmx8eGuo-Oy
 uipath_langchain/retrievers/context_grounding_retriever.py,sha256=CeVSMEz5xTQIladkzDLeQXGC1_ycW72gb0RB41JZeYA,2000
 uipath_langchain/tracers/AsyncUiPathTracer.py,sha256=8eGWZ56iJcmhtRQU4cHuZYt6aJXqc8RB2OL_BCMp-Ow,10463
 uipath_langchain/tracers/UiPathTracer.py,sha256=V5g1nlB0TI1wYvUIkfCEcAdhy4thqeMBmjflWtxc-_M,5601
-uipath_langchain/tracers/__init__.py,sha256=8DeXfBFhu6IaqDRj_ffjRV01I8q5i_8wXbnhBZTwXnc,219
+uipath_langchain/tracers/__init__.py,sha256=MwrQh6iuPXMS72S5EX0JdCAX0TKe-l7fIPGV3EG0Ssk,256
 uipath_langchain/tracers/_events.py,sha256=CJri76SSdu7rGJIkXurJ2C5sQahfSK4E5UWwWYdEAtE,922
-uipath_langchain/tracers/_instrument_traceable.py,sha256=csPMKd-dk4jrnrxWyS177mLxUBKs-xZyj1tfRQgWrYE,9244
+uipath_langchain/tracers/_instrument_traceable.py,sha256=MP1xmSRpuzsGePoioiHUU0R7gT-BW6eA-25qKZpLyOk,13182
 uipath_langchain/tracers/_utils.py,sha256=JOT1tKMdvqjMDtj2WbmbOWMeMlTXBWavxWpogX7KlRA,1543
 uipath_langchain/utils/__init__.py,sha256=-w-4TD9ZnJDCpj4VIPXhJciukrmDJJbmnOFnhAkAaEU,81
 uipath_langchain/utils/_request_mixin.py,sha256=WFyTDyAthSci1DRwUwS21I3hLntD7HdVzYc0ZPoi3ys,18296
 uipath_langchain/utils/_settings.py,sha256=MhwEVj4gVRSar0RBf2w2hTjO-5Qm-HpCuufqN3gSWjA,3390
 uipath_langchain/utils/_sleep_policy.py,sha256=e9pHdjmcCj4CVoFM1jMyZFelH11YatsgWfpyrfXzKBQ,1251
 uipath_langchain/vectorstores/context_grounding_vectorstore.py,sha256=eTa5sX43-ydB1pj9VNHUPbB-hC36fZK_CGrNe5U2Nrw,9393
-uipath_langchain-0.0.90.dist-info/METADATA,sha256=BVn0Hp0FpVC3BrXtGBfMNwixP9VapW8dxRyWCJvnutI,3818
-uipath_langchain-0.0.90.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath_langchain-0.0.90.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
-uipath_langchain-0.0.90.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
-uipath_langchain-0.0.90.dist-info/RECORD,,
+uipath_langchain-0.0.92.dist-info/METADATA,sha256=gQX7bMt93pOFiHdTXAMZ1J3pBr6-sJuBP1BnybEtNAE,3819
+uipath_langchain-0.0.92.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath_langchain-0.0.92.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
+uipath_langchain-0.0.92.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
+uipath_langchain-0.0.92.dist-info/RECORD,,