uipath-langchain 0.0.133__py3-none-any.whl → 0.1.28__py3-none-any.whl

uipath_langchain/_cli/_runtime/_runtime.py

@@ -1,379 +0,0 @@
-import json
-import logging
-import os
-from typing import Any, Dict, List, Optional, Tuple, Union
-
-from langchain_core.callbacks.base import BaseCallbackHandler
-from langchain_core.messages import BaseMessage
-from langchain_core.runnables.config import RunnableConfig
-from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
-from langgraph.errors import EmptyInputError, GraphRecursionError, InvalidUpdateError
-from langgraph.graph.state import CompiledStateGraph
-from uipath._cli._runtime._contracts import (
-    UiPathBaseRuntime,
-    UiPathErrorCategory,
-    UiPathRuntimeResult,
-)
-
-from .._utils._graph import LangGraphConfig
-from ._context import LangGraphRuntimeContext
-from ._conversation import map_message
-from ._exception import LangGraphRuntimeError
-from ._input import LangGraphInputProcessor
-from ._output import LangGraphOutputProcessor
-
-logger = logging.getLogger(__name__)
-
-
-class LangGraphRuntime(UiPathBaseRuntime):
-    """
-    A runtime class implementing the async context manager protocol.
-    This allows using the class with 'async with' statements.
-    """
-
-    def __init__(self, context: LangGraphRuntimeContext):
-        super().__init__(context)
-        self.context: LangGraphRuntimeContext = context
-
-    async def execute(self) -> Optional[UiPathRuntimeResult]:
-        """
-        Execute the graph with the provided input and configuration.
-
-        Returns:
-            Dictionary with execution results
-
-        Raises:
-            LangGraphRuntimeError: If execution fails
-        """
-
-        if self.context.state_graph is None:
-            return None
-
-        try:
-            async with AsyncSqliteSaver.from_conn_string(
-                self.state_file_path
-            ) as memory:
-                self.context.memory = memory
-
-                # Compile the graph with the checkpointer
-                graph = self.context.state_graph.compile(
-                    checkpointer=self.context.memory
-                )
-
-                # Process input, handling resume if needed
-                input_processor = LangGraphInputProcessor(context=self.context)
-
-                processed_input = await input_processor.process()
-
-                callbacks: List[BaseCallbackHandler] = []
-
-                graph_config: RunnableConfig = {
-                    "configurable": {
-                        "thread_id": (
-                            self.context.execution_id
-                            or self.context.job_id
-                            or "default"
-                        )
-                    },
-                    "callbacks": callbacks,
-                }
-
-                recursion_limit = os.environ.get("LANGCHAIN_RECURSION_LIMIT", None)
-                max_concurrency = os.environ.get("LANGCHAIN_MAX_CONCURRENCY", None)
-
-                if recursion_limit is not None:
-                    graph_config["recursion_limit"] = int(recursion_limit)
-                if max_concurrency is not None:
-                    graph_config["max_concurrency"] = int(max_concurrency)
-
-                if self.context.chat_handler:
-                    async for stream_chunk in graph.astream(
-                        processed_input,
-                        graph_config,
-                        stream_mode="messages",
-                        subgraphs=True,
-                    ):
-                        if not isinstance(stream_chunk, tuple) or len(stream_chunk) < 2:
-                            continue
-
-                        _, (message, _) = stream_chunk
-                        event = map_message(
-                            message=message,
-                            conversation_id=self.context.execution_id,
-                            exchange_id=self.context.execution_id,
-                        )
-                        if event:
-                            self.context.chat_handler.on_event(event)
-
-                # Stream the output at debug time
-                elif self.is_debug_run():
-                    # Get final chunk while streaming
-                    final_chunk = None
-                    async for stream_chunk in graph.astream(
-                        processed_input,
-                        graph_config,
-                        stream_mode="updates",
-                        subgraphs=True,
-                    ):
-                        self._pretty_print(stream_chunk)
-                        final_chunk = stream_chunk
-
-                    self.context.output = self._extract_graph_result(final_chunk, graph)
-                else:
-                    # Execute the graph normally at runtime or eval
-                    self.context.output = await graph.ainvoke(
-                        processed_input, graph_config
-                    )
-
-                # Get the state if available
-                try:
-                    self.context.state = await graph.aget_state(graph_config)
-                except Exception:
-                    pass
-
-                output_processor = await LangGraphOutputProcessor.create(self.context)
-
-                self.context.result = await output_processor.process()
-
-                return self.context.result
-
-        except Exception as e:
-            if isinstance(e, LangGraphRuntimeError):
-                raise
-
-            detail = f"Error: {str(e)}"
-
-            if isinstance(e, GraphRecursionError):
-                raise LangGraphRuntimeError(
-                    "GRAPH_RECURSION_ERROR",
-                    "Graph recursion limit exceeded",
-                    detail,
-                    UiPathErrorCategory.USER,
-                ) from e
-
-            if isinstance(e, InvalidUpdateError):
-                raise LangGraphRuntimeError(
-                    "GRAPH_INVALID_UPDATE",
-                    str(e),
-                    detail,
-                    UiPathErrorCategory.USER,
-                ) from e
-
-            if isinstance(e, EmptyInputError):
-                raise LangGraphRuntimeError(
-                    "GRAPH_EMPTY_INPUT",
-                    "The input data is empty",
-                    detail,
-                    UiPathErrorCategory.USER,
-                ) from e
-
-            raise LangGraphRuntimeError(
-                "EXECUTION_ERROR",
-                "Graph execution failed",
-                detail,
-                UiPathErrorCategory.USER,
-            ) from e
-        finally:
-            pass
-
-    async def validate(self) -> None:
-        """Validate runtime inputs."""
-        """Load and validate the graph configuration ."""
-        if self.context.langgraph_config is None:
-            self.context.langgraph_config = LangGraphConfig()
-            if not self.context.langgraph_config.exists:
-                raise LangGraphRuntimeError(
-                    "CONFIG_MISSING",
-                    "Invalid configuration",
-                    "Failed to load configuration",
-                    UiPathErrorCategory.DEPLOYMENT,
-                )
-
-        try:
-            self.context.langgraph_config.load_config()
-        except Exception as e:
-            raise LangGraphRuntimeError(
-                "CONFIG_INVALID",
-                "Invalid configuration",
-                f"Failed to load configuration: {str(e)}",
-                UiPathErrorCategory.DEPLOYMENT,
-            ) from e
-
-        # Determine entrypoint if not provided
-        graphs = self.context.langgraph_config.graphs
-        if not self.context.entrypoint and len(graphs) == 1:
-            self.context.entrypoint = graphs[0].name
-        elif not self.context.entrypoint:
-            graph_names = ", ".join(g.name for g in graphs)
-            raise LangGraphRuntimeError(
-                "ENTRYPOINT_MISSING",
-                "Entrypoint required",
-                f"Multiple graphs available. Please specify one of: {graph_names}.",
-                UiPathErrorCategory.DEPLOYMENT,
-            )
-
-        # Get the specified graph
-        self.graph_config = self.context.langgraph_config.get_graph(
-            self.context.entrypoint
-        )
-        if not self.graph_config:
-            raise LangGraphRuntimeError(
-                "GRAPH_NOT_FOUND",
-                "Graph not found",
-                f"Graph '{self.context.entrypoint}' not found.",
-                UiPathErrorCategory.DEPLOYMENT,
-            )
-        try:
-            loaded_graph = await self.graph_config.load_graph()
-            self.context.state_graph = (
-                loaded_graph.builder
-                if isinstance(loaded_graph, CompiledStateGraph)
-                else loaded_graph
-            )
-        except ImportError as e:
-            raise LangGraphRuntimeError(
-                "GRAPH_IMPORT_ERROR",
-                "Graph import failed",
-                f"Failed to import graph '{self.context.entrypoint}': {str(e)}",
-                UiPathErrorCategory.USER,
-            ) from e
-        except TypeError as e:
-            raise LangGraphRuntimeError(
-                "GRAPH_TYPE_ERROR",
-                "Invalid graph type",
-                f"Graph '{self.context.entrypoint}' is not a valid StateGraph or CompiledStateGraph: {str(e)}",
-                UiPathErrorCategory.USER,
-            ) from e
-        except ValueError as e:
-            raise LangGraphRuntimeError(
-                "GRAPH_VALUE_ERROR",
-                "Invalid graph value",
-                f"Invalid value in graph '{self.context.entrypoint}': {str(e)}",
-                UiPathErrorCategory.USER,
-            ) from e
-        except Exception as e:
-            raise LangGraphRuntimeError(
-                "GRAPH_LOAD_ERROR",
-                "Failed to load graph",
-                f"Unexpected error loading graph '{self.context.entrypoint}': {str(e)}",
-                UiPathErrorCategory.USER,
-            ) from e
-
-    async def cleanup(self):
-        if hasattr(self, "graph_config") and self.graph_config:
-            await self.graph_config.cleanup()
-
-    def _extract_graph_result(
-        self, final_chunk, graph: CompiledStateGraph[Any, Any, Any]
-    ):
-        """
-        Extract the result from a LangGraph output chunk according to the graph's output channels.
-
-        Args:
-            final_chunk: The final chunk from graph.astream()
-            graph: The LangGraph instance
-
-        Returns:
-            The extracted result according to the graph's output_channels configuration
-        """
-        # Unwrap from subgraph tuple format if needed
-        if isinstance(final_chunk, tuple) and len(final_chunk) == 2:
-            final_chunk = final_chunk[
-                1
-            ]  # Extract data part from (namespace, data) tuple
-
-        # If the result isn't a dict or graph doesn't define output channels, return as is
-        if not isinstance(final_chunk, dict) or not hasattr(graph, "output_channels"):
-            return final_chunk
-
-        output_channels = graph.output_channels
-
-        # Case 1: Single output channel as string
-        if isinstance(output_channels, str):
-            if output_channels in final_chunk:
-                return final_chunk[output_channels]
-            else:
-                return final_chunk
-
-        # Case 2: Multiple output channels as sequence
-        elif hasattr(output_channels, "__iter__") and not isinstance(
-            output_channels, str
-        ):
-            # Check which channels are present
-            available_channels = [ch for ch in output_channels if ch in final_chunk]
-
-            # if no available channels, output may contain the last_node name as key
-            unwrapped_final_chunk = {}
-            if not available_channels:
-                if len(final_chunk) == 1 and isinstance(
-                    unwrapped_final_chunk := next(iter(final_chunk.values())), dict
-                ):
-                    available_channels = [
-                        ch for ch in output_channels if ch in unwrapped_final_chunk
-                    ]
-
-            if available_channels:
-                # Create a dict with the available channels
-                return {
-                    channel: final_chunk.get(channel, None)
-                    or unwrapped_final_chunk[channel]
-                    for channel in available_channels
-                }
-
-        # Fallback for any other case
-        return final_chunk
-
-    def _pretty_print(self, stream_chunk: Union[Tuple[Any, Any], Dict[str, Any], Any]):
-        """
-        Pretty print a chunk from a LangGraph stream with stream_mode="updates" and subgraphs=True.
-
-        Args:
-            stream_chunk: A tuple of (namespace, updates) from graph.astream()
-        """
-        if not isinstance(stream_chunk, tuple) or len(stream_chunk) < 2:
-            return
-
-        node_namespace = ""
-        chunk_namespace = stream_chunk[0]
-        node_updates = stream_chunk[1]
-
-        # Extract namespace if available
-        if chunk_namespace and len(chunk_namespace) > 0:
-            node_namespace = chunk_namespace[0]
-
-        if not isinstance(node_updates, dict):
-            logger.info("Raw update: %s", node_updates)
-            return
-
-        # Process each node's updates
-        for node_name, node_result in node_updates.items():
-            # Log node identifier with appropriate namespace context
-            if node_namespace:
-                logger.info("[%s][%s]", node_namespace, node_name)
-            else:
-                logger.info("[%s]", node_name)
-
-            # Handle non-dict results
-            if not isinstance(node_result, dict):
-                logger.info("%s", node_result)
-                continue
-
-            # Process messages specially
-            messages = node_result.get("messages", [])
-            if isinstance(messages, list):
-                for message in messages:
-                    if isinstance(message, BaseMessage):
-                        message.pretty_print()
-
-            # Exclude "messages" from node_result and pretty-print the rest
-            metadata = {k: v for k, v in node_result.items() if k != "messages"}
-            if metadata:
-                try:
-                    formatted_metadata = json.dumps(
-                        metadata,
-                        indent=2,
-                        ensure_ascii=False,
-                    )
-                    logger.info("%s", formatted_metadata)
-                except (TypeError, ValueError):
-                    pass

uipath_langchain/_cli/_utils/_graph.py

@@ -1,199 +0,0 @@
-import importlib.util
-import inspect
-import json
-import logging
-import os
-import sys
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Union, cast
-
-from langgraph.graph import StateGraph
-from langgraph.graph.state import CompiledStateGraph
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class GraphConfig:
-    name: str
-    path: str
-    file_path: str
-    graph_var: str
-    _graph: Optional[Union[StateGraph[Any, Any], CompiledStateGraph[Any, Any, Any]]] = (
-        None
-    )
-
-    @classmethod
-    def from_config(cls, name: str, path: str) -> "GraphConfig":
-        file_path, graph_var = path.split(":")
-        return cls(name=name, path=path, file_path=file_path, graph_var=graph_var)
-
-    async def load_graph(
-        self,
-    ) -> Union[StateGraph[Any, Any], CompiledStateGraph[Any, Any, Any]]:
-        """Load graph from the specified path"""
-        try:
-            cwd = os.path.abspath(os.getcwd())
-            abs_file_path = os.path.abspath(os.path.normpath(self.file_path))
-
-            if not abs_file_path.startswith(cwd):
-                raise ValueError(
-                    f"Script path must be within the current directory. Found: {self.file_path}"
-                )
-
-            if not os.path.exists(abs_file_path):
-                raise FileNotFoundError(f"Script not found: {abs_file_path}")
-
-            if cwd not in sys.path:
-                sys.path.insert(0, cwd)
-
-            # For src-layout projects, add src directory to sys.path
-            # This mimics an editable/dev install
-            src_dir = os.path.join(cwd, "src")
-            if os.path.isdir(src_dir) and src_dir not in sys.path:
-                sys.path.insert(0, src_dir)
-
-            module_name = Path(abs_file_path).stem
-            spec = importlib.util.spec_from_file_location(module_name, abs_file_path)
-
-            if not spec or not spec.loader:
-                raise ImportError(f"Could not load module from: {abs_file_path}")
-
-            module = importlib.util.module_from_spec(spec)
-            sys.modules[module_name] = module
-            spec.loader.exec_module(module)
-
-            graph = getattr(module, self.graph_var, None)
-
-            # Get the graph object or function
-            graph_obj = getattr(module, self.graph_var, None)
-
-            # Handle callable graph factory
-            if callable(graph_obj):
-                if inspect.iscoroutinefunction(graph_obj):
-                    # Handle async function
-                    try:
-                        graph_obj = await graph_obj()
-                    except RuntimeError as e:
-                        raise e
-                else:
-                    # Call regular function
-                    graph_obj = graph_obj()
-
-            # Handle async context manager
-            if (
-                graph_obj is not None
-                and hasattr(graph_obj, "__aenter__")
-                and callable(graph_obj.__aenter__)
-            ):
-                self._context_manager = graph_obj
-                graph = await graph_obj.__aenter__()
-
-                # No need for atexit registration - the calling code should
-                # maintain a reference to this object and call cleanup explicitly
-
-            else:
-                # Not a context manager, use directly
-                graph = graph_obj
-
-            if not isinstance(graph, (StateGraph, CompiledStateGraph)):
-                raise TypeError(
-                    f"Expected StateGraph, CompiledStateGraph, or a callable returning one of these, got {type(graph)}"
-                )
-
-            self._graph = graph
-            return graph
-
-        except Exception as e:
-            logger.error(f"Failed to load graph {self.name}: {str(e)}")
-            raise
-
-    async def get_input_schema(self) -> Dict[str, Any]:
-        """Extract input schema from graph"""
-        if not self._graph:
-            self._graph = await self.load_graph()
-
-        if hasattr(self._graph, "input_schema"):
-            return cast(dict[str, Any], self._graph.input_schema)
-        return {}
-
-    async def cleanup(self):
-        """
-        Clean up resources when done with the graph.
-        This should be called when the graph is no longer needed.
-        """
-        if hasattr(self, "_context_manager") and self._context_manager:
-            try:
-                await self._context_manager.__aexit__(None, None, None)
-            except Exception as e:
-                logger.warning(f"Error during context cleanup: {str(e)}")
-            finally:
-                self._context_manager = None
-                self._graph = None
-
-
-class LangGraphConfig:
-    def __init__(self, config_path: str = "langgraph.json"):
-        self.config_path = config_path
-        self._config: Optional[Dict[str, Any]] = None
-        self._graphs: List[GraphConfig] = []
-
-    @property
-    def exists(self) -> bool:
-        """Check if langgraph.json exists"""
-        return os.path.exists(self.config_path)
-
-    def load_config(self) -> Dict[str, Any]:
-        """Load and validate langgraph configuration"""
-        if not self.exists:
-            raise FileNotFoundError(f"Config file not found: {self.config_path}")
-
-        try:
-            with open(self.config_path, "r") as f:
-                config = json.load(f)
-
-            required_fields = ["graphs"]
-            missing_fields = [field for field in required_fields if field not in config]
-            if missing_fields:
-                raise ValueError(
-                    f"Missing required fields in langgraph.json: {missing_fields}"
-                )
-
-            self._config = config
-            self._load_graphs()
-            return config
-        except Exception as e:
-            logger.error(f"Failed to load langgraph.json: {str(e)}")
-            raise
-
-    def _load_graphs(self):
-        """Load all graph configurations"""
-        if not self._config:
-            return
-
-        self._graphs = [
-            GraphConfig.from_config(name, path)
-            for name, path in self._config["graphs"].items()
-        ]
-
-    @property
-    def graphs(self) -> List[GraphConfig]:
-        """Get all graph configurations"""
-        if not self._graphs:
-            self.load_config()
-        return self._graphs
-
-    def get_graph(self, name: str) -> Optional[GraphConfig]:
-        """Get a specific graph configuration by name"""
-        return next((g for g in self.graphs if g.name == name), None)
-
-    @property
-    def dependencies(self) -> List[str]:
-        """Get project dependencies"""
-        return self._config.get("dependencies", []) if self._config else []
-
-    @property
-    def env_file(self) -> Optional[str]:
-        """Get environment file path"""
-        return self._config.get("env") if self._config else None

uipath_langchain/_cli/cli_dev.py

@@ -1,44 +0,0 @@
-import asyncio
-from typing import Optional
-
-from openinference.instrumentation.langchain import (
-    LangChainInstrumentor,
-    get_current_span,
-)
-from uipath._cli._dev._terminal import UiPathDevTerminal
-from uipath._cli._runtime._contracts import UiPathRuntimeFactory
-from uipath._cli._utils._console import ConsoleLogger
-from uipath._cli.middlewares import MiddlewareResult
-
-from .._tracing import _instrument_traceable_attributes
-from ._runtime._context import LangGraphRuntimeContext
-from ._runtime._runtime import LangGraphRuntime
-
-console = ConsoleLogger()
-
-
-def langgraph_dev_middleware(interface: Optional[str]) -> MiddlewareResult:
-    """Middleware to launch the developer terminal"""
-
-    try:
-        if interface == "terminal":
-            runtime_factory = UiPathRuntimeFactory(
-                LangGraphRuntime, LangGraphRuntimeContext
-            )
-
-            _instrument_traceable_attributes()
-            runtime_factory.add_instrumentor(LangChainInstrumentor, get_current_span)
-            app = UiPathDevTerminal(runtime_factory)
-            asyncio.run(app.run_async())
-        else:
-            console.error(f"Unknown interface: {interface}")
-    except KeyboardInterrupt:
-        console.info("Debug session interrupted by user")
-    except Exception as e:
-        console.error(f"Error occurred: {e}")
-        return MiddlewareResult(
-            should_continue=False,
-            should_include_stacktrace=True,
-        )
-
-    return MiddlewareResult(should_continue=False)

uipath_langchain/_cli/cli_eval.py

@@ -1,78 +0,0 @@
-import asyncio
-from typing import List, Optional
-
-from openinference.instrumentation.langchain import (
-    LangChainInstrumentor,
-    get_current_span,
-)
-from uipath._cli._evals._runtime import UiPathEvalContext, UiPathEvalRuntime
-from uipath._cli._runtime._contracts import (
-    UiPathRuntimeFactory,
-)
-from uipath._cli._utils._eval_set import EvalHelpers
-from uipath._cli.middlewares import MiddlewareResult
-from uipath.eval._helpers import auto_discover_entrypoint
-
-from uipath_langchain._cli._runtime._context import LangGraphRuntimeContext
-from uipath_langchain._cli._runtime._runtime import LangGraphRuntime
-from uipath_langchain._cli._utils._graph import LangGraphConfig
-from uipath_langchain._tracing import (
-    LangChainExporter,
-    _instrument_traceable_attributes,
-)
-
-
-def langgraph_eval_middleware(
-    entrypoint: Optional[str], eval_set: Optional[str], eval_ids: List[str], **kwargs
-) -> MiddlewareResult:
-    config = LangGraphConfig()
-    if not config.exists:
-        return MiddlewareResult(
-            should_continue=True
-        )  # Continue with normal flow if no langgraph.json
-
-    eval_context = UiPathEvalContext.with_defaults(**kwargs)
-    eval_context.eval_set = eval_set or EvalHelpers.auto_discover_eval_set()
-    eval_context.eval_ids = eval_ids
-
-    try:
-        _instrument_traceable_attributes()
-
-        runtime_entrypoint = entrypoint or auto_discover_entrypoint()
-
-        def generate_runtime_context(
-            context_entrypoint: str, langgraph_config: LangGraphConfig, **context_kwargs
-        ) -> LangGraphRuntimeContext:
-            context = LangGraphRuntimeContext.with_defaults(**context_kwargs)
-            context.langgraph_config = langgraph_config
-            context.entrypoint = context_entrypoint
-            return context
-
-        runtime_factory = UiPathRuntimeFactory(
-            LangGraphRuntime,
-            LangGraphRuntimeContext,
-            context_generator=lambda **context_kwargs: generate_runtime_context(
-                context_entrypoint=runtime_entrypoint,
-                langgraph_config=config,
-                **context_kwargs,
-            ),
-        )
-
-        if eval_context.job_id:
-            runtime_factory.add_span_exporter(LangChainExporter())
-
-        runtime_factory.add_instrumentor(LangChainInstrumentor, get_current_span)
-
-        async def execute():
-            async with UiPathEvalRuntime.from_eval_context(
-                factory=runtime_factory, context=eval_context
-            ) as eval_runtime:
-                await eval_runtime.execute()
-
-        asyncio.run(execute())
-        return MiddlewareResult(should_continue=False)
-
-    except Exception as e:
-        return MiddlewareResult(
-            should_continue=False, error_message=f"Error running evaluation: {str(e)}"
-        )