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

uipath_langchain/_cli/_runtime/_runtime.py

@@ -1,371 +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 langchain_core.tracers.langchain import wait_for_all_tracers
-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 import _instrument_traceable_attributes
-from ...tracers import AsyncUiPathTracer
-from ._context import LangGraphRuntimeContext
-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
-        """
-        _instrument_traceable_attributes()
-
-        await self.validate()
-
-        if self.context.state_graph is None:
-            return None
-
-        tracer = None
-
-        try:
-            if self.context.resume is False and self.context.job_id is None:
-                # Delete the previous graph state file at debug time
-                if os.path.exists(self.state_file_path):
-                    os.remove(self.state_file_path)
-
-            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()
-
-                # Set up tracing if available
-                callbacks: List[BaseCallbackHandler] = []
-
-                if self.context.job_id and self.context.tracing_enabled:
-                    tracer = AsyncUiPathTracer(context=self.context.trace_context)
-                    callbacks = [tracer]
-
-                graph_config: RunnableConfig = {
-                    "configurable": {
-                        "thread_id": self.context.job_id
-                        if self.context.job_id
-                        else "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)
-
-                # Stream the output at debug time
-                if self.context.job_id is None:
-                    # 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
-                    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:
-            if tracer is not None:
-                await tracer.wait_for_all_tracers()
-
-            if self.context.langsmith_tracing_enabled:
-                wait_for_all_tracers()
-
-    async def validate(self) -> None:
-        """Validate runtime inputs."""
-        """Load and validate the graph configuration ."""
-        try:
-            if self.context.input:
-                self.context.input_json = json.loads(self.context.input)
-        except json.JSONDecodeError as e:
-            raise LangGraphRuntimeError(
-                "INPUT_INVALID_JSON",
-                "Invalid JSON input",
-                "The input data is not valid JSON.",
-                UiPathErrorCategory.USER,
-            ) from e
-
-        if self.context.langgraph_config is None:
-            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):
-        """
-        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 available_channels:
-                # Create a dict with the available channels
-                return {channel: 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,202 +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 dotenv import load_dotenv
-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, CompiledStateGraph]] = 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, CompiledStateGraph]:
-        """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)
-
-            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}"
-                )
-
-            if env_file := config.get("env"):
-                env_path = os.path.abspath(os.path.normpath(env_file))
-                if os.path.exists(env_path):
-                    if not load_dotenv(env_path):
-                        # log warning only if dotenv is not empty
-                        if os.path.getsize(env_path) > 0:
-                            logger.warning(
-                                f"Could not load environment variables from {env_path}"
-                            )
-                    else:
-                        logger.debug(f"Loaded environment variables from {env_path}")
-
-            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_run.py

@@ -1,80 +0,0 @@
-import asyncio
-from os import environ as env
-from typing import Optional
-
-from dotenv import load_dotenv
-from uipath._cli._runtime._contracts import UiPathTraceContext
-from uipath._cli.middlewares import MiddlewareResult
-
-from ._runtime._context import LangGraphRuntimeContext
-from ._runtime._exception import LangGraphRuntimeError
-from ._runtime._runtime import LangGraphRuntime
-from ._utils._graph import LangGraphConfig
-
-load_dotenv()
-
-
-def langgraph_run_middleware(
-    entrypoint: Optional[str], input: Optional[str], resume: bool
-) -> MiddlewareResult:
-    """Middleware to handle langgraph execution"""
-    config = LangGraphConfig()
-    if not config.exists:
-        return MiddlewareResult(
-            should_continue=True
-        )  # Continue with normal flow if no langgraph.json
-
-    try:
-        bool_map = {"true": True, "false": False}
-        tracing = env.get("UIPATH_TRACING_ENABLED", True)
-        if isinstance(tracing, str) and tracing.lower() in bool_map:
-            tracing = bool_map[tracing.lower()]
-
-        async def execute():
-            context = LangGraphRuntimeContext.from_config(
-                env.get("UIPATH_CONFIG_PATH", "uipath.json")
-            )
-            context.entrypoint = entrypoint
-            context.input = input
-            context.resume = resume
-            context.langgraph_config = config
-            context.logs_min_level = env.get("LOG_LEVEL", "INFO")
-            context.job_id = env.get("UIPATH_JOB_KEY")
-            context.trace_id = env.get("UIPATH_TRACE_ID")
-            context.tracing_enabled = tracing
-            context.trace_context = UiPathTraceContext(
-                enabled=tracing,
-                trace_id=env.get("UIPATH_TRACE_ID"),
-                parent_span_id=env.get("UIPATH_PARENT_SPAN_ID"),
-                root_span_id=env.get("UIPATH_ROOT_SPAN_ID"),
-                job_id=env.get("UIPATH_JOB_KEY"),
-                org_id=env.get("UIPATH_ORGANIZATION_ID"),
-                tenant_id=env.get("UIPATH_TENANT_ID"),
-                process_key=env.get("UIPATH_PROCESS_UUID"),
-                folder_key=env.get("UIPATH_FOLDER_KEY"),
-            )
-            context.langsmith_tracing_enabled = env.get("LANGSMITH_TRACING", False)
-
-            # Add default env variables
-            env["UIPATH_REQUESTING_PRODUCT"] = "uipath-python-sdk"
-            env["UIPATH_REQUESTING_FEATURE"] = "langgraph-agent"
-
-            async with LangGraphRuntime.from_context(context) as runtime:
-                await runtime.execute()
-
-        asyncio.run(execute())
-
-        return MiddlewareResult(should_continue=False, error_message=None)
-
-    except LangGraphRuntimeError as e:
-        return MiddlewareResult(
-            should_continue=False,
-            error_message=e.error_info.detail,
-            should_include_stacktrace=True,
-        )
-    except Exception as e:
-        return MiddlewareResult(
-            should_continue=False,
-            error_message=f"Error: {str(e)}",
-            should_include_stacktrace=True,
-        )