uipath-langchain 0.0.112__py3-none-any.whl → 0.1.24__py3-none-any.whl

uipath_langchain/tracers/_instrument_traceable.py

@@ -1,416 +0,0 @@
-import functools
-import importlib
-import inspect
-import logging
-import sys
-import uuid
-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
-
-# Original module and traceable function references
-original_langsmith: Any = None
-original_traceable: Any = None
-
-logger = logging.getLogger(__name__)
-
-
-def dispatch_trace_event(
-    func_name,
-    inputs: Dict[str, Any],
-    event_type="call",
-    call_uuid=None,
-    result=None,
-    exception=None,
-    run_type: Optional[
-        Literal["tool", "chain", "llm", "retriever", "embedding", "prompt", "parser"]
-    ] = None,
-    tags: Optional[List[str]] = None,
-    metadata: Optional[Dict[str, Any]] = None,
-):
-    """Dispatch trace event to our server."""
-    try:
-        event_data = FunctionCallEventData(
-            function_name=func_name,
-            event_type=event_type,
-            inputs=inputs,
-            call_uuid=call_uuid,
-            output=result,
-            error=str(exception) if exception else None,
-            run_type=run_type,
-            tags=tags,
-            metadata=metadata,
-        )
-
-        dispatch_custom_event(CustomTraceEvents.UIPATH_TRACE_FUNCTION_CALL, event_data)
-    except Exception as e:
-        logger.debug(
-            f"Error dispatching trace event: {e}. Function name: {func_name} Event type: {event_type}"
-        )
-
-
-def format_args_for_trace(
-    signature: inspect.Signature, *args: Any, **kwargs: Any
-) -> Dict[str, Any]:
-    try:
-        """Return a dictionary of inputs from the function signature."""
-        # Create a parameter mapping by partially binding the arguments
-        parameter_binding = signature.bind_partial(*args, **kwargs)
-
-        # Fill in default values for any unspecified parameters
-        parameter_binding.apply_defaults()
-
-        # Extract the input parameters, skipping special Python parameters
-        result = {}
-        for name, value in parameter_binding.arguments.items():
-            # Skip class and instance references
-            if name in ("self", "cls"):
-                continue
-
-            # Handle **kwargs parameters specially
-            param_info = signature.parameters.get(name)
-            if param_info and param_info.kind == inspect.Parameter.VAR_KEYWORD:
-                # Flatten nested kwargs directly into the result
-                if isinstance(value, dict):
-                    result.update(value)
-            else:
-                # Regular parameter
-                result[name] = value
-
-        return result
-    except Exception as e:
-        logger.warning(
-            f"Error formatting arguments for trace: {e}. Using args and kwargs directly."
-        )
-        return {"args": args, "kwargs": 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"
-                )
-
-            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"
-                )
-
-            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(
-    original_func: Any, wrapped_func: Any, decorator_kwargs: Dict[str, Any]
-):
-    """Create the appropriate wrapper based on function type."""
-
-    # Get the function name and tags from decorator arguments
-    func_name = decorator_kwargs.get("name", original_func.__name__)
-    tags = decorator_kwargs.get("tags", None)
-    metadata = decorator_kwargs.get("metadata", None)
-    run_type = decorator_kwargs.get("run_type", None)
-
-    return _create_traced_wrapper(
-        func=original_func,
-        wrapper_func=wrapped_func,
-        func_name=func_name,
-        run_type=run_type,
-        tags=tags,
-        metadata=metadata,
-    )
-
-
-def _uipath_traced(
-    name: Optional[str] = None,
-    run_type: Optional[str] = None,
-    span_type: Optional[str] = None,
-    input_processor: Optional[Callable[..., Any]] = None,
-    output_processor: Optional[Callable[..., Any]] = None,
-    *args: Any,
-    **kwargs: Any,
-):
-    """Decorator factory that creates traced functions using dispatch_trace_event."""
-
-    def decorator(func):
-        return _create_traced_wrapper(
-            func=func,
-            func_name=name,
-            run_type=run_type,
-            span_type=span_type,
-            input_processor=input_processor,
-            output_processor=output_processor,
-        )
-
-    return decorator
-
-
-# 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 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)
-
-    return uipath_trace_decorator
-
-
-# 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_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
-        if "langsmith" in sys.modules:
-            original_langsmith = sys.modules["langsmith"]
-            del sys.modules["langsmith"]
-
-        # Import the original module
-        original_langsmith = importlib.import_module("langsmith")
-
-        # Store the original traceable
-        original_traceable = original_langsmith.traceable
-
-        # Replace the traceable function with our patched version
-        original_langsmith.traceable = patched_traceable
-
-        # Put our modified module back
-        sys.modules["langsmith"] = original_langsmith
-
-    return original_langsmith

uipath_langchain/tracers/_utils.py

@@ -1,52 +0,0 @@
-import datetime
-import logging
-from zoneinfo import ZoneInfo
-
-
-class IgnoreSpecificUrl(logging.Filter):
-    def __init__(self, url_to_ignore):
-        super().__init__()
-        self.url_to_ignore = url_to_ignore
-
-    def filter(self, record):
-        try:
-            if record.msg == 'HTTP Request: %s %s "%s %d %s"':
-                # Ignore the log if the URL matches the one we want to ignore
-                method = record.args[0]
-                url = record.args[1]
-
-                if method == "POST" and url.path.endswith(self.url_to_ignore):
-                    # Check if the URL contains the specific path we want to ignore
-                    return True
-                return False
-
-        except Exception:
-            return False
-
-
-def _setup_tracer_httpx_logging(url: str):
-    # Create a custom logger for httpx
-    # Add the custom filter to the root logger
-    logging.getLogger("httpx").addFilter(IgnoreSpecificUrl(url))
-
-
-def _simple_serialize_defaults(obj):
-    if hasattr(obj, "model_dump"):
-        return obj.model_dump(exclude_none=True, mode="json")
-    if hasattr(obj, "dict"):
-        return obj.dict()
-    if hasattr(obj, "to_dict"):
-        return obj.to_dict()
-
-    if isinstance(obj, (set, tuple)):
-        if hasattr(obj, "_asdict") and callable(obj._asdict):
-            return obj._asdict()
-        return list(obj)
-
-    if isinstance(obj, datetime.datetime):
-        return obj.isoformat()
-
-    if isinstance(obj, (datetime.timezone, ZoneInfo)):
-        return obj.tzname(None)
-
-    return str(obj)

uipath_langchain-0.0.112.dist-info/RECORD

@@ -1,36 +0,0 @@
-uipath_langchain/__init__.py,sha256=VBrvQn7d3nuOdN7zEnV2_S-uhmkjgEIlXiFVeZxZakQ,80
-uipath_langchain/middlewares.py,sha256=tre7o9DFMgWk1DJiEEUmT6_wiP-PPkWtKmG0iOyvr9c,509
-uipath_langchain/_cli/__init__.py,sha256=juqd9PbXs4yg45zMJ7BHAOPQjb7sgEbWE9InBtGZhfo,24
-uipath_langchain/_cli/cli_init.py,sha256=B5BVUA7pDvKyRRGEx5mgmeE5SJvLPM3cnLGt6a9iixY,7417
-uipath_langchain/_cli/cli_new.py,sha256=dL8-Rri6u67ZZdbb4nT38A5xD_Q3fVnG0UK9VSeKaqg,2563
-uipath_langchain/_cli/cli_run.py,sha256=rGuYp9AEJdhHclOCFPX100Mo0kaDYt6e6pIKBgbS6ek,3023
-uipath_langchain/_cli/_runtime/_context.py,sha256=wr4aNn06ReIXmetEZ6b6AnpAt64p13anQ2trZ5Bzgio,807
-uipath_langchain/_cli/_runtime/_exception.py,sha256=USKkLYkG-dzjX3fEiMMOHnVUpiXJs_xF0OQXCCOvbYM,546
-uipath_langchain/_cli/_runtime/_input.py,sha256=vZ8vfVxvPSaPWmIPghvNx1VRKzbalHsKUMBPiKDvJWM,5492
-uipath_langchain/_cli/_runtime/_output.py,sha256=yJOZPWv2FRUJWv1NRs9JmpB4QMTDXu8jrxoaKrfJvzw,9078
-uipath_langchain/_cli/_runtime/_runtime.py,sha256=SjOZkal6c1ZeZNFzW23DoAnF6LNQ2nN0dISSu2cSFhQ,13881
-uipath_langchain/_cli/_templates/langgraph.json.template,sha256=eeh391Gta_hoRgaNaZ58nW1LNvCVXA7hlAH6l7Veous,107
-uipath_langchain/_cli/_templates/main.py.template,sha256=9JEyPxwc4Ce8Dfd2UAgHgpwkkjuXwWXOQZ-65P53QuM,1195
-uipath_langchain/_cli/_utils/_graph.py,sha256=P7m03i6kcLda8XVpVtppcM8GOrSW62zWcv3rCR1H5zs,7086
-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=mCJ2-XXfpedjxT7DSXINPITHrXzQJCESgNo-nz3irDk,3450
-uipath_langchain/_utils/_sleep_policy.py,sha256=e9pHdjmcCj4CVoFM1jMyZFelH11YatsgWfpyrfXzKBQ,1251
-uipath_langchain/chat/__init__.py,sha256=WDcvy91ixvZ3Mq7Ae94g5CjyQwXovDBnEv1NlD5SXBE,116
-uipath_langchain/chat/models.py,sha256=sLz8yzEMUMSNsCFyywRxFwe2JisR3TP-n1vbeRKl9H8,10225
-uipath_langchain/embeddings/__init__.py,sha256=QICtYB58ZyqFfDQrEaO8lTEgAU5NuEKlR7iIrS0OBtc,156
-uipath_langchain/embeddings/embeddings.py,sha256=gntzTfwO1pHbgnXiPdfETJaaurvQWqxVUCH75VMah54,4274
-uipath_langchain/retrievers/__init__.py,sha256=rOn7PyyHgZ4pMnXWPkGqmuBmx8eGuo-Oyndo7Wm9IUU,108
-uipath_langchain/retrievers/context_grounding_retriever.py,sha256=YLCIwy89LhLnNqcM0YJ5mZoeNyCs5UiKD3Wly8gnW1E,2239
-uipath_langchain/tracers/AsyncUiPathTracer.py,sha256=SgFLVU8ZtRaUjIiiM5jjYqlKc-4ec3tAXwZVceDM2ng,9147
-uipath_langchain/tracers/__init__.py,sha256=bMmqGCC4DsuLUdDVM4zvmVbRLPeULZ8K9ity0GAfy_4,197
-uipath_langchain/tracers/_events.py,sha256=CJri76SSdu7rGJIkXurJ2C5sQahfSK4E5UWwWYdEAtE,922
-uipath_langchain/tracers/_instrument_traceable.py,sha256=0e841zVzcPWjOGtmBx0GeHbq3JoqsmWv6gVPzDOKNTM,13496
-uipath_langchain/tracers/_utils.py,sha256=JOT1tKMdvqjMDtj2WbmbOWMeMlTXBWavxWpogX7KlRA,1543
-uipath_langchain/vectorstores/__init__.py,sha256=w8qs1P548ud1aIcVA_QhBgf_jZDrRMK5Lono78yA8cs,114
-uipath_langchain/vectorstores/context_grounding_vectorstore.py,sha256=TncIXG-YsUlO0R5ZYzWsM-Dj1SVCZbzmo2LraVxXelc,9559
-uipath_langchain-0.0.112.dist-info/METADATA,sha256=MSb7h7hBN5BjhDchfFQYu2X4_OTt2hki8Zr5a-t0TDg,4166
-uipath_langchain-0.0.112.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath_langchain-0.0.112.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
-uipath_langchain-0.0.112.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
-uipath_langchain-0.0.112.dist-info/RECORD,,

uipath_langchain-0.0.112.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[uipath.middlewares]
-register = uipath_langchain.middlewares:register_middleware