From 89fb8d506ff33b441f90972d127746d15da6192e Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Sat, 21 Sep 2024 17:21:18 -0700 Subject: [PATCH 01/14] Add more comments and docstrings --- libs/langgraph/langgraph/constants.py | 167 ++++++++---------- libs/langgraph/langgraph/errors.py | 25 +-- libs/langgraph/langgraph/pregel/algo.py | 25 ++- libs/langgraph/langgraph/pregel/debug.py | 4 + libs/langgraph/langgraph/pregel/executor.py | 17 +- libs/langgraph/langgraph/pregel/io.py | 5 +- libs/langgraph/langgraph/pregel/loop.py | 6 +- libs/langgraph/langgraph/pregel/messages.py | 3 + libs/langgraph/langgraph/pregel/metadata.py | 0 libs/langgraph/langgraph/pregel/read.py | 24 ++- libs/langgraph/langgraph/pregel/runner.py | 8 + libs/langgraph/langgraph/pregel/types.py | 112 ++++++++++-- libs/langgraph/langgraph/pregel/utils.py | 2 +- libs/langgraph/langgraph/pregel/validate.py | 2 +- libs/langgraph/langgraph/pregel/write.py | 29 ++- libs/langgraph/langgraph/version.py | 2 +- libs/langgraph/tests/test_tracing_interops.py | 7 +- 17 files changed, 274 insertions(+), 164 deletions(-) delete mode 100644 libs/langgraph/langgraph/pregel/metadata.py diff --git a/libs/langgraph/langgraph/constants.py b/libs/langgraph/langgraph/constants.py index e8719e664..eb0f703be 100644 --- a/libs/langgraph/langgraph/constants.py +++ b/libs/langgraph/langgraph/constants.py @@ -1,133 +1,106 @@ -from dataclasses import dataclass from types import MappingProxyType -from typing import Any, Literal, Mapping +from typing import Any, Mapping +from langgraph.pregel.types import Interrupt, Send # noqa: F401 + +# Interrupt, Send re-exported for backwards compatibility + +# --- Empty read-only containers --- +EMPTY_MAP: Mapping[str, Any] = MappingProxyType({}) +EMPTY_SEQ: tuple[str, ...] = tuple() + +# --- Reserved write keys --- INPUT = "__input__" +# for values passed as input to the graph +INTERRUPT = "__interrupt__" +# for dynamic interrupts raised by nodes +ERROR = "__error__" +# for errors raised by nodes +NO_WRITES = "__no_writes__" +# marker to signal node didn't write anything +SCHEDULED = "__scheduled__" +# marker to signal node was scheduled (in distributed mode) +TASKS = "__pregel_tasks" +# for Send objects returned by nodes/edges, corresponds to PUSH below +START = "__start__" +# marker for the first (maybe virtual) node in graph-style Pregel +END = "__end__" +# marker for the last (maybe virtual) node in graph-style Pregel + +# --- Reserved config.configurable keys --- CONFIG_KEY_SEND = "__pregel_send" +# holds the `write` function that accepts writes to state/edges/reserved keys CONFIG_KEY_READ = "__pregel_read" +# holds the `read` function that returns a copy of the current state CONFIG_KEY_CHECKPOINTER = "__pregel_checkpointer" +# holds a `BaseCheckpointSaver` passed from parent graph to child graphs CONFIG_KEY_STREAM = "__pregel_stream" +# holds a `StreamProtocol` passed from parent graph to child graphs CONFIG_KEY_STREAM_WRITER = "__pregel_stream_writer" +# holds a `StreamWriter` for stream_mode=custom CONFIG_KEY_STORE = "__pregel_store" +# holds a `BaseStore` made available to managed values CONFIG_KEY_RESUMING = "__pregel_resuming" +# holds a boolean indicating if subgraphs should resume from a previous checkpoint CONFIG_KEY_TASK_ID = "__pregel_task_id" +# holds the task ID for the current task CONFIG_KEY_DEDUPE_TASKS = "__pregel_dedupe_tasks" +# holds a boolean indicating if tasks should be deduplicated (for distributed mode) CONFIG_KEY_ENSURE_LATEST = "__pregel_ensure_latest" +# holds a boolean indicating whether to assert the requested checkpoint is the latest +# (for distributed mode) CONFIG_KEY_DELEGATE = "__pregel_delegate" -# this one part of public API so more readable +# holds a boolean indicating whether to delegate subgraphs (for distributed mode) CONFIG_KEY_CHECKPOINT_MAP = "checkpoint_map" -INTERRUPT = "__interrupt__" -ERROR = "__error__" -NO_WRITES = "__no_writes__" -SCHEDULED = "__scheduled__" -TASKS = "__pregel_tasks" # for backwards compat, this is the original name of PUSH +# holds a mapping of checkpoint_ns -> checkpoint_id for parent graphs +CONFIG_KEY_CHECKPOINT_ID = "checkpoint_id" +# holds the current checkpoint_id, if any +CONFIG_KEY_CHECKPOINT_NS = "checkpoint_ns" +# holds the current checkpoint_ns, "" for root graph + +# --- Other constants --- PUSH = "__pregel_push" +# denotes push-style tasks, ie. those created by Send objects PULL = "__pregel_pull" +# denotes pull-style tasks, ie. those triggered by edges RUNTIME_PLACEHOLDER = "__pregel_runtime_placeholder__" +# placeholder for managed values replaced at runtime +TAG_HIDDEN = "langsmith:hidden" +# tag to hide a node/edge from certain tracing/streaming environments +NS_SEP = "|" +# for checkpoint_ns, separates each level (ie. graph|subgraph|subsubgraph) +NS_END = ":" +# for checkpoint_ns, for each level, separates the namespace from the task_id + RESERVED = { - SCHEDULED, + # reserved write keys + INPUT, INTERRUPT, ERROR, NO_WRITES, + SCHEDULED, TASKS, - PUSH, - PULL, + # reserved config.configurable keys CONFIG_KEY_SEND, CONFIG_KEY_READ, CONFIG_KEY_CHECKPOINTER, - CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_STREAM, CONFIG_KEY_STREAM_WRITER, CONFIG_KEY_STORE, + CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_RESUMING, CONFIG_KEY_TASK_ID, CONFIG_KEY_DEDUPE_TASKS, CONFIG_KEY_ENSURE_LATEST, CONFIG_KEY_DELEGATE, - INPUT, + CONFIG_KEY_CHECKPOINT_MAP, + CONFIG_KEY_CHECKPOINT_ID, + CONFIG_KEY_CHECKPOINT_NS, + # other constants + PUSH, + PULL, RUNTIME_PLACEHOLDER, + TAG_HIDDEN, + NS_SEP, + NS_END, } -TAG_HIDDEN = "langsmith:hidden" - -START = "__start__" -END = "__end__" - -NS_SEP = "|" -NS_END = ":" - -EMPTY_MAP: Mapping[str, Any] = MappingProxyType({}) - - -class Send: - """A message or packet to send to a specific node in the graph. - - The `Send` class is used within a `StateGraph`'s conditional edges to - dynamically invoke a node with a custom state at the next step. - - Importantly, the sent state can differ from the core graph's state, - allowing for flexible and dynamic workflow management. - - One such example is a "map-reduce" workflow where your graph invokes - the same node multiple times in parallel with different states, - before aggregating the results back into the main graph's state. - - Attributes: - node (str): The name of the target node to send the message to. - arg (Any): The state or message to send to the target node. - - Examples: - >>> from typing import Annotated - >>> import operator - >>> class OverallState(TypedDict): - ... subjects: list[str] - ... jokes: Annotated[list[str], operator.add] - ... - >>> from langgraph.constants import Send - >>> from langgraph.graph import END, START - >>> def continue_to_jokes(state: OverallState): - ... return [Send("generate_joke", {"subject": s}) for s in state['subjects']] - ... - >>> from langgraph.graph import StateGraph - >>> builder = StateGraph(OverallState) - >>> builder.add_node("generate_joke", lambda state: {"jokes": [f"Joke about {state['subject']}"]}) - >>> builder.add_conditional_edges(START, continue_to_jokes) - >>> builder.add_edge("generate_joke", END) - >>> graph = builder.compile() - >>> - >>> # Invoking with two subjects results in a generated joke for each - >>> graph.invoke({"subjects": ["cats", "dogs"]}) - {'subjects': ['cats', 'dogs'], 'jokes': ['Joke about cats', 'Joke about dogs']} - """ - - node: str - arg: Any - - def __init__(self, /, node: str, arg: Any) -> None: - """ - Initialize a new instance of the Send class. - - Args: - node (str): The name of the target node to send the message to. - arg (Any): The state or message to send to the target node. - """ - self.node = node - self.arg = arg - - def __hash__(self) -> int: - return hash((self.node, self.arg)) - - def __repr__(self) -> str: - return f"Send(node={self.node!r}, arg={self.arg!r})" - - def __eq__(self, value: object) -> bool: - return ( - isinstance(value, Send) - and self.node == value.node - and self.arg == value.arg - ) - - -@dataclass -class Interrupt: - value: Any - when: Literal["during"] = "during" diff --git a/libs/langgraph/langgraph/errors.py b/libs/langgraph/langgraph/errors.py index ec84e0b28..ad3150942 100644 --- a/libs/langgraph/langgraph/errors.py +++ b/libs/langgraph/langgraph/errors.py @@ -1,8 +1,10 @@ from typing import Any, Sequence -from langgraph.checkpoint.base import EmptyChannelError +from langgraph.checkpoint.base import EmptyChannelError # noqa: F401 from langgraph.constants import Interrupt +# EmptyChannelError re-exported for backwards compatibility + class GraphRecursionError(RecursionError): """Raised when the graph has exhausted the maximum number of steps. @@ -24,13 +26,14 @@ class GraphRecursionError(RecursionError): class InvalidUpdateError(Exception): - """Raised when attempting to update a channel with an invalid sequence of updates.""" + """Raised when attempting to update a channel with an invalid set of updates.""" pass class GraphInterrupt(Exception): - """Raised when a subgraph is interrupted.""" + """Raised when a subgraph is interrupted, supressed by the root graph. + Never raised directly, or surfaced to the user.""" def __init__(self, interrupts: Sequence[Interrupt] = ()) -> None: super().__init__(interrupts) @@ -44,7 +47,7 @@ def __init__(self, value: Any) -> None: class GraphDelegate(Exception): - """Raised when a graph is delegated.""" + """Raised when a graph is delegated (for distributed mode).""" def __init__(self, *args: dict[str, Any]) -> None: super().__init__(*args) @@ -57,22 +60,12 @@ class EmptyInputError(Exception): class TaskNotFound(Exception): - """Raised when the executor is unable to find a task.""" + """Raised when the executor is unable to find a task (for distributed mode).""" pass class CheckpointNotLatest(Exception): - """Raised when the checkpoint is not the latest version.""" + """Raised when the checkpoint is not the latest version (for distributed mode).""" pass - - -__all__ = [ - "GraphRecursionError", - "InvalidUpdateError", - "GraphInterrupt", - "NodeInterrupt", - "EmptyInputError", - "EmptyChannelError", -] diff --git a/libs/langgraph/langgraph/pregel/algo.py b/libs/langgraph/langgraph/pregel/algo.py index 8a63d4cc6..44da0bbd5 100644 --- a/libs/langgraph/langgraph/pregel/algo.py +++ b/libs/langgraph/langgraph/pregel/algo.py @@ -33,6 +33,7 @@ CONFIG_KEY_READ, CONFIG_KEY_SEND, CONFIG_KEY_TASK_ID, + EMPTY_SEQ, INTERRUPT, NO_WRITES, NS_END, @@ -55,10 +56,11 @@ GetNextVersion = Callable[[Optional[V], BaseChannel], V] -EMPTY_SEQ: tuple[str, ...] = tuple() - class WritesProtocol(Protocol): + """Protocol for objects containing writes to be applied to checkpoint. + Implemented by PregelTaskWrites and PregelExecutableTask.""" + @property def name(self) -> str: ... @@ -70,6 +72,9 @@ def triggers(self) -> Sequence[str]: ... class PregelTaskWrites(NamedTuple): + """Simplest implementation of WritesProtocol, for usage with writes that + don't originate from a runnable task, eg. graph input, update_state, etc.""" + name: str writes: Sequence[tuple[str, Any]] triggers: Sequence[str] @@ -80,6 +85,7 @@ def should_interrupt( interrupt_nodes: Union[All, Sequence[str]], tasks: Iterable[PregelExecutableTask], ) -> list[PregelExecutableTask]: + """Check if the graph should be interrupted based on current state.""" version_type = type(next(iter(checkpoint["channel_versions"].values()), None)) null_version = version_type() # type: ignore[misc] seen = checkpoint["versions_seen"].get(INTERRUPT, {}) @@ -117,6 +123,9 @@ def local_read( select: Union[list[str], str], fresh: bool = False, ) -> Union[dict[str, Any], Any]: + """Function injected under CONFIG_KEY_READ in task config, to read current state. + Used by conditional edges to read a copy of the state with reflecting the writes + from that node only.""" if isinstance(select, str): managed_keys = [] for c, _ in task.writes: @@ -153,6 +162,8 @@ def local_write( managed: ManagedValueMapping, writes: Sequence[tuple[str, Any]], ) -> None: + """Function injected under CONFIG_KEY_SEND in task config, to write to channels. + Validates writes and forwards them to `commit` function.""" for chan, value in writes: if chan == TASKS: if not isinstance(value, Send): @@ -169,6 +180,7 @@ def local_write( def increment(current: Optional[int], channel: BaseChannel) -> int: + """Default channel versioning function, increments the current int version.""" return current + 1 if current is not None else 1 @@ -178,6 +190,9 @@ def apply_writes( tasks: Iterable[WritesProtocol], get_next_version: Optional[GetNextVersion], ) -> dict[str, list[Any]]: + """Apply writes from a set of tasks (usually the tasks from a Pregel step) + to the checkpoint and channels, and return managed values writes to be applied + externally.""" # update seen versions for task in tasks: checkpoint["versions_seen"].setdefault(task.name, {}).update( @@ -297,6 +312,9 @@ def prepare_next_tasks( checkpointer: Optional[BaseCheckpointSaver] = None, manager: Union[None, ParentRunManager, AsyncParentRunManager] = None, ) -> Union[dict[str, PregelTask], dict[str, PregelExecutableTask]]: + """Prepare the set of tasks that will make up the next Pregel step. + This is the union of all PUSH tasks (Sends) and PULL tasks (nodes triggered + by edges).""" tasks: dict[str, Union[PregelTask, PregelExecutableTask]] = {} # Consume pending packets for idx, _ in enumerate(checkpoint["pending_sends"]): @@ -348,6 +366,8 @@ def prepare_single_task( checkpointer: Optional[BaseCheckpointSaver] = None, manager: Union[None, ParentRunManager, AsyncParentRunManager] = None, ) -> Union[None, PregelTask, PregelExecutableTask]: + """Prepares a single task for the next Pregel step, given a task path, which + uniquely identifies a PUSH or PULL task within the graph.""" checkpoint_id = UUID(checkpoint["id"]).bytes configurable = config.get("configurable", {}) parent_ns = configurable.get("checkpoint_ns", "") @@ -568,6 +588,7 @@ def _proc_input( *, for_execution: bool, ) -> Iterator[Any]: + """Prepare input for a PULL task, based on the process's channels and triggers.""" # If all trigger channels subscribed by this process are not empty # then invoke the process with the values of all non-empty channels if isinstance(proc.channels, dict): diff --git a/libs/langgraph/langgraph/pregel/debug.py b/libs/langgraph/langgraph/pregel/debug.py index 56f1eb9c6..9c4661c0c 100644 --- a/libs/langgraph/langgraph/pregel/debug.py +++ b/libs/langgraph/langgraph/pregel/debug.py @@ -84,6 +84,7 @@ class DebugOutputCheckpoint(DebugOutputBase): def map_debug_tasks( step: int, tasks: Iterable[PregelExecutableTask] ) -> Iterator[DebugOutputTask]: + """Produce "task" events for stream_mode=debug.""" ts = datetime.now(timezone.utc).isoformat() for task in tasks: if task.config is not None and TAG_HIDDEN in task.config.get("tags", []): @@ -107,6 +108,7 @@ def map_debug_task_results( task_tup: tuple[PregelExecutableTask, Sequence[tuple[str, Any]]], stream_keys: Union[str, Sequence[str]], ) -> Iterator[DebugOutputTaskResult]: + """Produce "task_result" events for stream_mode=debug.""" stream_channels_list = ( [stream_keys] if isinstance(stream_keys, str) else stream_keys ) @@ -135,6 +137,7 @@ def map_debug_checkpoint( tasks: Iterable[PregelExecutableTask], pending_writes: list[PendingWrite], ) -> Iterator[DebugOutputCheckpoint]: + """Produce "checkpoint" events for stream_mode=debug.""" yield { "type": "checkpoint", "timestamp": checkpoint["ts"], @@ -213,6 +216,7 @@ def tasks_w_writes( pending_writes: Optional[list[PendingWrite]], states: Optional[dict[str, Union[RunnableConfig, StateSnapshot]]], ) -> tuple[PregelTask, ...]: + """Apply writes / subgraph states to tasks to be returned in a StateSnapshot.""" pending_writes = pending_writes or [] return tuple( PregelTask( diff --git a/libs/langgraph/langgraph/pregel/executor.py b/libs/langgraph/langgraph/pregel/executor.py index 46f1c3f64..691098b7a 100644 --- a/libs/langgraph/langgraph/pregel/executor.py +++ b/libs/langgraph/langgraph/pregel/executor.py @@ -39,6 +39,13 @@ def __call__( class BackgroundExecutor(ContextManager): + """A context manager that runs sync tasks in the background. + Uses a thread pool executor to delegate tasks to separate threads. + On exit, + - cancels any (not yet started) tasks with `__cancel_on_exit__=True` + - waits for all tasks to finish + - re-raises the first exception from tasks with `__reraise_on_exit__=True`""" + def __init__(self, config: RunnableConfig) -> None: self.stack = ExitStack() self.executor = self.stack.enter_context(get_executor_for_config(config)) @@ -49,7 +56,7 @@ def submit( # type: ignore[valid-type] fn: Callable[P, T], *args: P.args, __name__: Optional[str] = None, # currently not used in sync version - __cancel_on_exit__: bool = False, + __cancel_on_exit__: bool = False, # for sync, can cancel only if not started __reraise_on_exit__: bool = True, **kwargs: P.kwargs, ) -> concurrent.futures.Future[T]: @@ -101,6 +108,14 @@ def __exit__( class AsyncBackgroundExecutor(AsyncContextManager): + """A context manager that runs async tasks in the background. + Uses the current event loop to delegate tasks to asyncio tasks. + On exit, + - cancels any tasks with `__cancel_on_exit__=True` + - waits for all tasks to finish + - re-raises the first exception from tasks with `__reraise_on_exit__=True` + ignoring CancelledError""" + def __init__(self) -> None: self.context_not_supported = sys.version_info < (3, 11) self.tasks: dict[asyncio.Task, tuple[bool, bool]] = {} diff --git a/libs/langgraph/langgraph/pregel/io.py b/libs/langgraph/langgraph/pregel/io.py index ad2252c9d..6542b1d91 100644 --- a/libs/langgraph/langgraph/pregel/io.py +++ b/libs/langgraph/langgraph/pregel/io.py @@ -3,7 +3,7 @@ from langchain_core.runnables.utils import AddableDict from langgraph.channels.base import BaseChannel, EmptyChannelError -from langgraph.constants import ERROR, INTERRUPT, TAG_HIDDEN +from langgraph.constants import EMPTY_SEQ, ERROR, INTERRUPT, TAG_HIDDEN from langgraph.pregel.log import logger from langgraph.pregel.types import PregelExecutableTask @@ -97,9 +97,6 @@ def __radd__(self, other: dict[str, Any]) -> "AddableUpdatesDict": raise TypeError("AddableUpdatesDict does not support right-side addition") -EMPTY_SEQ: tuple[str, ...] = tuple() - - def map_output_updates( output_channels: Union[str, Sequence[str]], tasks: list[tuple[PregelExecutableTask, Sequence[tuple[str, Any]]]], diff --git a/libs/langgraph/langgraph/pregel/loop.py b/libs/langgraph/langgraph/pregel/loop.py index 49baa1846..c97cc8a69 100644 --- a/libs/langgraph/langgraph/pregel/loop.py +++ b/libs/langgraph/langgraph/pregel/loop.py @@ -44,6 +44,7 @@ CONFIG_KEY_RESUMING, CONFIG_KEY_STREAM, CONFIG_KEY_TASK_ID, + EMPTY_SEQ, ERROR, INPUT, INTERRUPT, @@ -101,13 +102,12 @@ V = TypeVar("V") P = ParamSpec("P") +StreamChunk = tuple[tuple[str, ...], str, Any] + INPUT_DONE = object() INPUT_RESUMING = object() -EMPTY_SEQ = () SPECIAL_CHANNELS = (ERROR, INTERRUPT, SCHEDULED) -StreamChunk = tuple[tuple[str, ...], str, Any] - class StreamProtocol: __slots__ = ("modes", "__call__") diff --git a/libs/langgraph/langgraph/pregel/messages.py b/libs/langgraph/langgraph/pregel/messages.py index 7c3f90b10..d0ae539e2 100644 --- a/libs/langgraph/langgraph/pregel/messages.py +++ b/libs/langgraph/langgraph/pregel/messages.py @@ -24,6 +24,9 @@ class StreamMessagesHandler(BaseCallbackHandler, _StreamingCallbackHandler): + """A callback handler that implements stream_mode=messages. + Collects messages from (1) chat model stream events and (2) node outputs.""" + def __init__(self, stream: Callable[[StreamChunk], None]): self.stream = stream self.metadata: dict[UUID, Meta] = {} diff --git a/libs/langgraph/langgraph/pregel/metadata.py b/libs/langgraph/langgraph/pregel/metadata.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/libs/langgraph/langgraph/pregel/read.py b/libs/langgraph/langgraph/pregel/read.py index 3ad988b89..097e76fa2 100644 --- a/libs/langgraph/langgraph/pregel/read.py +++ b/libs/langgraph/langgraph/pregel/read.py @@ -31,6 +31,9 @@ class ChannelRead(RunnableCallable): + """Implements the logic for reading state from CONFIG_KEY_READ. + Usable both as a runnable as well as a static method to call imperatively.""" + channel: Union[str, list[str]] fresh: bool = False @@ -108,21 +111,39 @@ def do_read( class PregelNode(Runnable): + """A node in a Pregel graph. This won't be invoked as a runnable by the graph + itself, but instead acts as a container for the components necessary to make + a PregelExecutableTask for a node.""" + channels: Union[list[str], Mapping[str, str]] + """The channels that will be passed as input to `bound`. + If a list, the node will be invoked with the first of that isn't empty. + If a dict, the keys are the names of the channels, and the values are the keys + to use in the input to `bound`.""" triggers: list[str] + """If any of these channels is written to, this node will be triggered in + the next step.""" mapper: Optional[Callable[[Any], Any]] + """A function to transform the input before passing it to `bound`.""" writers: list[Runnable] + """A list of writers that will be executed after `bound`, responsible for + taking the output of `bound` and writing it to the appropriate channels.""" bound: Runnable[Any, Any] + """The main logic of the node. This will be invoked with the input from + `channels`.""" retry_policy: Optional[RetryPolicy] + """The retry policy to use when invoking the node.""" tags: Optional[Sequence[str]] + """Tags to attach to the node for tracing.""" metadata: Optional[Mapping[str, Any]] + """Metadata to attach to the node for tracing.""" def __init__( self, @@ -151,7 +172,7 @@ def copy(self, update: dict[str, Any]) -> PregelNode: @cached_property def flat_writers(self) -> list[Runnable]: - """Get writers with optimizations applied.""" + """Get writers with optimizations applied. Dedupes consecutive ChannelWrites.""" writers = self.writers.copy() while ( len(writers) > 1 @@ -170,6 +191,7 @@ def flat_writers(self) -> list[Runnable]: @cached_property def node(self) -> Optional[Runnable[Any, Any]]: + """Get a runnable that combines `bound` and `writers`.""" writers = self.flat_writers if self.bound is DEFAULT_BOUND and not writers: return None diff --git a/libs/langgraph/langgraph/pregel/runner.py b/libs/langgraph/langgraph/pregel/runner.py index 14e84352f..32bbf74bd 100644 --- a/libs/langgraph/langgraph/pregel/runner.py +++ b/libs/langgraph/langgraph/pregel/runner.py @@ -22,6 +22,10 @@ class PregelRunner: + """Responsible for executing a set of Pregel tasks concurrently, commiting + their writes, yielding control to caller when there is output to emit, and + interrupting other tasks if appropriate.""" + def __init__( self, *, @@ -215,6 +219,8 @@ def commit( def _should_stop_others( done: Union[set[concurrent.futures.Future[Any]], set[asyncio.Future[Any]]], ) -> bool: + """Check if any task failed, if so, cancel all other tasks. + GraphInterrupts are not considered failures.""" for fut in done: if fut.cancelled(): return True @@ -227,6 +233,7 @@ def _should_stop_others( def _exception( fut: Union[concurrent.futures.Future[Any], asyncio.Future[Any]], ) -> Optional[BaseException]: + """Return the exception from a future, without raising CancelledError.""" if fut.cancelled(): if isinstance(fut, asyncio.Future): return asyncio.CancelledError() @@ -245,6 +252,7 @@ def _panic_or_proceed( timeout_exc_cls: Type[Exception] = TimeoutError, panic: bool = True, ) -> None: + """Cancel remaining tasks if any failed, re-raise exception if panic is True.""" done: set[Union[concurrent.futures.Future[Any], asyncio.Future[Any]]] = set() inflight: set[Union[concurrent.futures.Future[Any], asyncio.Future[Any]]] = set() for fut, val in futs.items(): diff --git a/libs/langgraph/langgraph/pregel/types.py b/libs/langgraph/langgraph/pregel/types.py index d34845483..4cca9946c 100644 --- a/libs/langgraph/langgraph/pregel/types.py +++ b/libs/langgraph/langgraph/pregel/types.py @@ -1,10 +1,28 @@ from collections import deque +from dataclasses import dataclass from typing import Any, Callable, Literal, NamedTuple, Optional, Sequence, Type, Union from langchain_core.runnables import Runnable, RunnableConfig from langgraph.checkpoint.base import CheckpointMetadata -from langgraph.constants import Interrupt + +All = Literal["*"] + +StreamMode = Literal["values", "updates", "debug", "messages", "custom"] +"""How the stream method should emit outputs. + +- 'values': Emit all values of the state for each step. +- 'updates': Emit only the node name(s) and updates + that were returned by the node(s) **after** each step. +- 'debug': Emit debug events for each step. +- 'messages': Emit LLM messages token-by-token. +- 'custom': Emit custom output `write: StreamWriter` kwarg of each node. +""" + +StreamWriter = Callable[[Any], None] +"""Callable that accepts a single argument and writes it to the output stream. +Always injected into nodes if requested as a keyword argument, but it's a no-op +when not using stream_mode="custom".""" def default_retry_on(exc: Exception) -> bool: @@ -63,6 +81,12 @@ class CachePolicy(NamedTuple): pass +@dataclass +class Interrupt: + value: Any + when: Literal["during"] = "during" + + class PregelTask(NamedTuple): id: str name: str @@ -105,20 +129,72 @@ class StateSnapshot(NamedTuple): """Tasks to execute in this step. If already attempted, may contain an error.""" -All = Literal["*"] - -StreamMode = Literal["values", "updates", "debug", "messages", "custom"] -"""How the stream method should emit outputs. - -- 'values': Emit all values of the state for each step. -- 'updates': Emit only the node name(s) and updates - that were returned by the node(s) **after** each step. -- 'debug': Emit debug events for each step. -- 'messages': Emit LLM messages token-by-token. -- 'custom': Emit custom output `write: StreamWriter` kwarg of each node. -""" - -StreamWriter = Callable[[Any], None] -"""Callable that accepts a single argument and writes it to the output stream. -Always injected into nodes if requested, -but it's a no-op when not using stream_mode="custom".""" +class Send: + """A message or packet to send to a specific node in the graph. + + The `Send` class is used within a `StateGraph`'s conditional edges to + dynamically invoke a node with a custom state at the next step. + + Importantly, the sent state can differ from the core graph's state, + allowing for flexible and dynamic workflow management. + + One such example is a "map-reduce" workflow where your graph invokes + the same node multiple times in parallel with different states, + before aggregating the results back into the main graph's state. + + Attributes: + node (str): The name of the target node to send the message to. + arg (Any): The state or message to send to the target node. + + Examples: + >>> from typing import Annotated + >>> import operator + >>> class OverallState(TypedDict): + ... subjects: list[str] + ... jokes: Annotated[list[str], operator.add] + ... + >>> from langgraph.constants import Send + >>> from langgraph.graph import END, START + >>> def continue_to_jokes(state: OverallState): + ... return [Send("generate_joke", {"subject": s}) for s in state['subjects']] + ... + >>> from langgraph.graph import StateGraph + >>> builder = StateGraph(OverallState) + >>> builder.add_node("generate_joke", lambda state: {"jokes": [f"Joke about {state['subject']}"]}) + >>> builder.add_conditional_edges(START, continue_to_jokes) + >>> builder.add_edge("generate_joke", END) + >>> graph = builder.compile() + >>> + >>> # Invoking with two subjects results in a generated joke for each + >>> graph.invoke({"subjects": ["cats", "dogs"]}) + {'subjects': ['cats', 'dogs'], 'jokes': ['Joke about cats', 'Joke about dogs']} + """ + + __slots__ = ("node", "arg") + + node: str + arg: Any + + def __init__(self, /, node: str, arg: Any) -> None: + """ + Initialize a new instance of the Send class. + + Args: + node (str): The name of the target node to send the message to. + arg (Any): The state or message to send to the target node. + """ + self.node = node + self.arg = arg + + def __hash__(self) -> int: + return hash((self.node, self.arg)) + + def __repr__(self) -> str: + return f"Send(node={self.node!r}, arg={self.arg!r})" + + def __eq__(self, value: object) -> bool: + return ( + isinstance(value, Send) + and self.node == value.node + and self.arg == value.arg + ) diff --git a/libs/langgraph/langgraph/pregel/utils.py b/libs/langgraph/langgraph/pregel/utils.py index c6dc064d3..3a29e5ed1 100644 --- a/libs/langgraph/langgraph/pregel/utils.py +++ b/libs/langgraph/langgraph/pregel/utils.py @@ -4,7 +4,7 @@ def get_new_channel_versions( previous_versions: ChannelVersions, current_versions: ChannelVersions ) -> ChannelVersions: - """Get new channel versions.""" + """Get subset of current_versions that are newer than previous_versions.""" if previous_versions: version_type = type(next(iter(current_versions.values()), None)) null_version = version_type() # type: ignore[misc] diff --git a/libs/langgraph/langgraph/pregel/validate.py b/libs/langgraph/langgraph/pregel/validate.py index 232014240..965fab54e 100644 --- a/libs/langgraph/langgraph/pregel/validate.py +++ b/libs/langgraph/langgraph/pregel/validate.py @@ -17,7 +17,7 @@ def validate_graph( ) -> None: for chan in channels: if chan in RESERVED: - raise ValueError(f"Channel names {RESERVED} are reserved") + raise ValueError(f"Channel names {chan} are reserved") subscribed_channels = set[str]() for name, node in nodes.items(): diff --git a/libs/langgraph/langgraph/pregel/write.py b/libs/langgraph/langgraph/pregel/write.py index 2adcab757..c2795c67c 100644 --- a/libs/langgraph/langgraph/pregel/write.py +++ b/libs/langgraph/langgraph/pregel/write.py @@ -1,6 +1,5 @@ from __future__ import annotations -import asyncio from typing import ( Any, Callable, @@ -22,30 +21,29 @@ TYPE_SEND = Callable[[Sequence[tuple[str, Any]]], None] R = TypeVar("R", bound=Runnable) - SKIP_WRITE = object() PASSTHROUGH = object() class ChannelWriteEntry(NamedTuple): channel: str + """Channel name to write to.""" value: Any = PASSTHROUGH + """Value to write, or PASSTHROUGH to use the input.""" skip_none: bool = False + """Whether to skip writing if the value is None.""" mapper: Optional[Callable] = None + """Function to transform the value before writing.""" class ChannelWrite(RunnableCallable): + """Implements th logic for sending writes to CONFIG_KEY_SEND. + Can be used as a runnable or as a static method to call imperatively.""" + writes: list[Union[ChannelWriteEntry, Send]] - """ - Sequence of write entries, each of which is a tuple of: - - channel name - - runnable to map input, or None to use the input, or any other value to use instead - - whether to skip writing if the mapped value is None - """ + """Sequence of write entries or Send objects to write.""" require_at_least_one_of: Optional[Sequence[str]] - """ - If defined, at least one of these channels must be written to. - """ + """If defined, at least one of these channels must be written to.""" def __init__( self, @@ -145,6 +143,7 @@ def do_write( @staticmethod def is_writer(runnable: Runnable) -> bool: + """Used by PregelNode to distinguish between writers and other runnables.""" return ( isinstance(runnable, ChannelWrite) or getattr(runnable, "_is_channel_writer", False) is True @@ -152,13 +151,9 @@ def is_writer(runnable: Runnable) -> bool: @staticmethod def register_writer(runnable: R) -> R: + """Used to mark a runnable as a writer, so that it can be detected by is_writer. + Instances of ChannelWrite are automatically marked as writers.""" # using object.__setattr__ to work around objects that override __setattr__ # eg. pydantic models and dataclasses object.__setattr__(runnable, "_is_channel_writer", True) return runnable - - -def _mk_future(val: Any) -> asyncio.Future: - fut: asyncio.Future[Any] = asyncio.Future() - fut.set_result(val) - return fut diff --git a/libs/langgraph/langgraph/version.py b/libs/langgraph/langgraph/version.py index 3368893c0..f5cb757f5 100644 --- a/libs/langgraph/langgraph/version.py +++ b/libs/langgraph/langgraph/version.py @@ -1,4 +1,4 @@ -"""Main entrypoint into package.""" +"""Exports package version.""" from importlib import metadata diff --git a/libs/langgraph/tests/test_tracing_interops.py b/libs/langgraph/tests/test_tracing_interops.py index 9bc8750b5..f1f0ad7fb 100644 --- a/libs/langgraph/tests/test_tracing_interops.py +++ b/libs/langgraph/tests/test_tracing_interops.py @@ -5,11 +5,14 @@ from unittest.mock import MagicMock import langsmith as ls +import pytest from langchain_core.runnables import RunnableConfig from langchain_core.tracers import LangChainTracer from langgraph.graph import StateGraph +pytestmark = pytest.mark.anyio + def _get_mock_client(**kwargs: Any) -> ls.Client: mock_session = MagicMock() @@ -76,7 +79,7 @@ async def child_node(state: State) -> State: child_builder = StateGraph(State) child_builder.add_node(child_node) child_builder.add_edge("__start__", "child_node") - child_graph = child_builder.compile() + child_graph = child_builder.compile().with_config(run_name="child_graph") parent_builder = StateGraph(State) parent_builder.add_node(parent_node) @@ -101,7 +104,7 @@ def get_posts(): # If the callbacks weren't propagated correctly, we'd # end up with broken dotted_orders parent_run = next(data for data in posts if data["name"] == "parent_node") - child_run = next(data for data in posts if data["name"] == "child_node") + child_run = next(data for data in posts if data["name"] == "child_graph") traceable_run = next(data for data in posts if data["name"] == "some_traceable") assert child_run["dotted_order"].startswith(traceable_run["dotted_order"]) From 9f8d71c65bad907a9b23ad8a11c0580830305644 Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Sat, 21 Sep 2024 17:23:12 -0700 Subject: [PATCH 02/14] Lint --- libs/langgraph/langgraph/errors.py | 2 +- libs/langgraph/langgraph/pregel/runner.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/libs/langgraph/langgraph/errors.py b/libs/langgraph/langgraph/errors.py index ad3150942..08bed5927 100644 --- a/libs/langgraph/langgraph/errors.py +++ b/libs/langgraph/langgraph/errors.py @@ -32,7 +32,7 @@ class InvalidUpdateError(Exception): class GraphInterrupt(Exception): - """Raised when a subgraph is interrupted, supressed by the root graph. + """Raised when a subgraph is interrupted, suppressed by the root graph. Never raised directly, or surfaced to the user.""" def __init__(self, interrupts: Sequence[Interrupt] = ()) -> None: diff --git a/libs/langgraph/langgraph/pregel/runner.py b/libs/langgraph/langgraph/pregel/runner.py index 32bbf74bd..6ba72e6ad 100644 --- a/libs/langgraph/langgraph/pregel/runner.py +++ b/libs/langgraph/langgraph/pregel/runner.py @@ -22,7 +22,7 @@ class PregelRunner: - """Responsible for executing a set of Pregel tasks concurrently, commiting + """Responsible for executing a set of Pregel tasks concurrently, committing their writes, yielding control to caller when there is output to emit, and interrupting other tasks if appropriate.""" From 313e3eed3e499af811ec3ca9e0576dff4332ccd7 Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Sat, 21 Sep 2024 17:26:29 -0700 Subject: [PATCH 03/14] Fix circular import --- libs/langgraph/langgraph/constants.py | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/libs/langgraph/langgraph/constants.py b/libs/langgraph/langgraph/constants.py index eb0f703be..e17ce7de8 100644 --- a/libs/langgraph/langgraph/constants.py +++ b/libs/langgraph/langgraph/constants.py @@ -1,9 +1,21 @@ from types import MappingProxyType from typing import Any, Mapping -from langgraph.pregel.types import Interrupt, Send # noqa: F401 # Interrupt, Send re-exported for backwards compatibility +def __getattr__(name: str) -> Any: + if name in globals(): + return globals()[name] + elif name == "Interrupt": + from langgraph.pregel.types import Interrupt + + return Interrupt + elif name == "Send": + from langgraph.pregel.types import Send + + return Send + raise AttributeError(f"module {__name__} has no attribute {name}") + # --- Empty read-only containers --- EMPTY_MAP: Mapping[str, Any] = MappingProxyType({}) From 3cbd70ffc9b64200a2f877fdcf186076a46230fd Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Sat, 21 Sep 2024 17:30:04 -0700 Subject: [PATCH 04/14] Fix docs --- docs/docs/reference/graphs.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/docs/reference/graphs.md b/docs/docs/reference/graphs.md index b2f4acdf2..3c25180ca 100644 --- a/docs/docs/reference/graphs.md +++ b/docs/docs/reference/graphs.md @@ -29,7 +29,7 @@ handler: python ## StreamMode -::: langgraph.pregel.StreamMode +::: langgraph.pregel.types.StreamMode ## Constants @@ -69,7 +69,7 @@ builder.add_conditional_edges("my_node", my_condition) ## Send -::: langgraph.constants.Send +::: langgraph.pregel.types.Send ## RetryPolicy From d9854b36ebb6690a5106ad73a3099ef3ee386259 Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Sat, 21 Sep 2024 17:37:17 -0700 Subject: [PATCH 05/14] Move to langgraph.types --- docs/docs/reference/graphs.md | 8 +- libs/langgraph/langgraph/constants.py | 15 +- libs/langgraph/langgraph/errors.py | 2 +- libs/langgraph/langgraph/graph/graph.py | 2 +- libs/langgraph/langgraph/graph/state.py | 2 +- libs/langgraph/langgraph/pregel/__init__.py | 2 +- libs/langgraph/langgraph/pregel/algo.py | 2 +- libs/langgraph/langgraph/pregel/debug.py | 2 +- libs/langgraph/langgraph/pregel/io.py | 2 +- libs/langgraph/langgraph/pregel/loop.py | 2 +- libs/langgraph/langgraph/pregel/retry.py | 12 +- libs/langgraph/langgraph/pregel/runner.py | 2 +- libs/langgraph/langgraph/pregel/types.py | 225 ++---------------- libs/langgraph/langgraph/pregel/validate.py | 2 +- libs/langgraph/langgraph/types.py | 200 ++++++++++++++++ libs/langgraph/langgraph/utils/runnable.py | 2 +- libs/langgraph/tests/test_pregel.py | 2 +- libs/langgraph/tests/test_pregel_async.py | 2 +- .../langgraph/scheduler/kafka/executor.py | 2 +- .../langgraph/scheduler/kafka/orchestrator.py | 2 +- .../langgraph/scheduler/kafka/retry.py | 2 +- 21 files changed, 258 insertions(+), 234 deletions(-) create mode 100644 libs/langgraph/langgraph/types.py diff --git a/docs/docs/reference/graphs.md b/docs/docs/reference/graphs.md index 3c25180ca..779f95095 100644 --- a/docs/docs/reference/graphs.md +++ b/docs/docs/reference/graphs.md @@ -69,8 +69,12 @@ builder.add_conditional_edges("my_node", my_condition) ## Send -::: langgraph.pregel.types.Send +::: langgraph.types.Send + +## Interrupt + +::: langgraph.types.Interrupt ## RetryPolicy -::: langgraph.pregel.types.RetryPolicy +::: langgraph.types.RetryPolicy diff --git a/libs/langgraph/langgraph/constants.py b/libs/langgraph/langgraph/constants.py index e17ce7de8..ef4a8a486 100644 --- a/libs/langgraph/langgraph/constants.py +++ b/libs/langgraph/langgraph/constants.py @@ -1,20 +1,9 @@ from types import MappingProxyType from typing import Any, Mapping +from langgraph.types import Interrupt, Send # noqa: F401 # Interrupt, Send re-exported for backwards compatibility -def __getattr__(name: str) -> Any: - if name in globals(): - return globals()[name] - elif name == "Interrupt": - from langgraph.pregel.types import Interrupt - - return Interrupt - elif name == "Send": - from langgraph.pregel.types import Send - - return Send - raise AttributeError(f"module {__name__} has no attribute {name}") # --- Empty read-only containers --- @@ -54,6 +43,8 @@ def __getattr__(name: str) -> Any: # holds a `BaseStore` made available to managed values CONFIG_KEY_RESUMING = "__pregel_resuming" # holds a boolean indicating if subgraphs should resume from a previous checkpoint +CONFIG_KEY_GRAPH_COUNT = "__pregel_graph_count" +# holds the number of subgraphs executed in a given task, used to raise errors CONFIG_KEY_TASK_ID = "__pregel_task_id" # holds the task ID for the current task CONFIG_KEY_DEDUPE_TASKS = "__pregel_dedupe_tasks" diff --git a/libs/langgraph/langgraph/errors.py b/libs/langgraph/langgraph/errors.py index 08bed5927..c7c5a518a 100644 --- a/libs/langgraph/langgraph/errors.py +++ b/libs/langgraph/langgraph/errors.py @@ -1,7 +1,7 @@ from typing import Any, Sequence from langgraph.checkpoint.base import EmptyChannelError # noqa: F401 -from langgraph.constants import Interrupt +from langgraph.types import Interrupt # EmptyChannelError re-exported for backwards compatibility diff --git a/libs/langgraph/langgraph/graph/graph.py b/libs/langgraph/langgraph/graph/graph.py index c5a043ee7..a5a4db3ac 100644 --- a/libs/langgraph/langgraph/graph/graph.py +++ b/libs/langgraph/langgraph/graph/graph.py @@ -38,8 +38,8 @@ from langgraph.errors import InvalidUpdateError from langgraph.pregel import Channel, Pregel from langgraph.pregel.read import PregelNode -from langgraph.pregel.types import All from langgraph.pregel.write import ChannelWrite, ChannelWriteEntry +from langgraph.types import All from langgraph.utils.runnable import RunnableCallable, coerce_to_runnable logger = logging.getLogger(__name__) diff --git a/libs/langgraph/langgraph/graph/state.py b/libs/langgraph/langgraph/graph/state.py index cee0fb849..4fdff2a49 100644 --- a/libs/langgraph/langgraph/graph/state.py +++ b/libs/langgraph/langgraph/graph/state.py @@ -45,9 +45,9 @@ is_writable_managed_value, ) from langgraph.pregel.read import ChannelRead, PregelNode -from langgraph.pregel.types import All, RetryPolicy from langgraph.pregel.write import SKIP_WRITE, ChannelWrite, ChannelWriteEntry from langgraph.store.base import BaseStore +from langgraph.types import All, RetryPolicy from langgraph.utils.fields import get_field_default from langgraph.utils.pydantic import create_model from langgraph.utils.runnable import coerce_to_runnable diff --git a/libs/langgraph/langgraph/pregel/__init__.py b/libs/langgraph/langgraph/pregel/__init__.py index f1a9aa578..c9fec2e57 100644 --- a/libs/langgraph/langgraph/pregel/__init__.py +++ b/libs/langgraph/langgraph/pregel/__init__.py @@ -83,11 +83,11 @@ from langgraph.pregel.read import PregelNode from langgraph.pregel.retry import RetryPolicy from langgraph.pregel.runner import PregelRunner -from langgraph.pregel.types import All, StateSnapshot, StreamMode from langgraph.pregel.utils import get_new_channel_versions from langgraph.pregel.validate import validate_graph, validate_keys from langgraph.pregel.write import ChannelWrite, ChannelWriteEntry from langgraph.store.base import BaseStore +from langgraph.types import All, StateSnapshot, StreamMode from langgraph.utils.config import ( ensure_config, merge_configs, diff --git a/libs/langgraph/langgraph/pregel/algo.py b/libs/langgraph/langgraph/pregel/algo.py index 44da0bbd5..f9b0096c8 100644 --- a/libs/langgraph/langgraph/pregel/algo.py +++ b/libs/langgraph/langgraph/pregel/algo.py @@ -51,7 +51,7 @@ from langgraph.pregel.log import logger from langgraph.pregel.manager import ChannelsManager from langgraph.pregel.read import PregelNode -from langgraph.pregel.types import All, PregelExecutableTask, PregelTask +from langgraph.types import All, PregelExecutableTask, PregelTask from langgraph.utils.config import merge_configs, patch_config GetNextVersion = Callable[[Optional[V], BaseChannel], V] diff --git a/libs/langgraph/langgraph/pregel/debug.py b/libs/langgraph/langgraph/pregel/debug.py index 9c4661c0c..982182842 100644 --- a/libs/langgraph/langgraph/pregel/debug.py +++ b/libs/langgraph/langgraph/pregel/debug.py @@ -22,7 +22,7 @@ from langgraph.checkpoint.base import Checkpoint, CheckpointMetadata, PendingWrite from langgraph.constants import ERROR, INTERRUPT, TAG_HIDDEN from langgraph.pregel.io import read_channels -from langgraph.pregel.types import PregelExecutableTask, PregelTask, StateSnapshot +from langgraph.types import PregelExecutableTask, PregelTask, StateSnapshot class TaskPayload(TypedDict): diff --git a/libs/langgraph/langgraph/pregel/io.py b/libs/langgraph/langgraph/pregel/io.py index 6542b1d91..ef9822641 100644 --- a/libs/langgraph/langgraph/pregel/io.py +++ b/libs/langgraph/langgraph/pregel/io.py @@ -5,7 +5,7 @@ from langgraph.channels.base import BaseChannel, EmptyChannelError from langgraph.constants import EMPTY_SEQ, ERROR, INTERRUPT, TAG_HIDDEN from langgraph.pregel.log import logger -from langgraph.pregel.types import PregelExecutableTask +from langgraph.types import PregelExecutableTask def read_channel( diff --git a/libs/langgraph/langgraph/pregel/loop.py b/libs/langgraph/langgraph/pregel/loop.py index c97cc8a69..7eec59575 100644 --- a/libs/langgraph/langgraph/pregel/loop.py +++ b/libs/langgraph/langgraph/pregel/loop.py @@ -94,10 +94,10 @@ ) from langgraph.pregel.manager import AsyncChannelsManager, ChannelsManager from langgraph.pregel.read import PregelNode -from langgraph.pregel.types import All, PregelExecutableTask, StreamMode from langgraph.pregel.utils import get_new_channel_versions from langgraph.store.base import BaseStore from langgraph.store.batch import AsyncBatchedStore +from langgraph.types import All, PregelExecutableTask, StreamMode from langgraph.utils.config import patch_configurable V = TypeVar("V") diff --git a/libs/langgraph/langgraph/pregel/retry.py b/libs/langgraph/langgraph/pregel/retry.py index 90ccaa7d0..476b8ef32 100644 --- a/libs/langgraph/langgraph/pregel/retry.py +++ b/libs/langgraph/langgraph/pregel/retry.py @@ -4,9 +4,9 @@ import time from typing import Optional, Sequence -from langgraph.constants import CONFIG_KEY_RESUMING +from langgraph.constants import CONFIG_KEY_GRAPH_COUNT, CONFIG_KEY_RESUMING from langgraph.errors import GraphInterrupt -from langgraph.pregel.types import PregelExecutableTask, RetryPolicy +from langgraph.types import PregelExecutableTask, RetryPolicy from langgraph.utils.config import patch_configurable logger = logging.getLogger(__name__) @@ -70,7 +70,9 @@ def run_with_retry( exc_info=exc, ) # signal subgraphs to resume (if available) - config = patch_configurable(config, {CONFIG_KEY_RESUMING: True}) + config = patch_configurable( + config, {CONFIG_KEY_RESUMING: True, CONFIG_KEY_GRAPH_COUNT: 0} + ) async def arun_with_retry( @@ -136,4 +138,6 @@ async def arun_with_retry( exc_info=exc, ) # signal subgraphs to resume (if available) - config = patch_configurable(config, {CONFIG_KEY_RESUMING: True}) + config = patch_configurable( + config, {CONFIG_KEY_RESUMING: True, CONFIG_KEY_GRAPH_COUNT: 0} + ) diff --git a/libs/langgraph/langgraph/pregel/runner.py b/libs/langgraph/langgraph/pregel/runner.py index 6ba72e6ad..b8392b613 100644 --- a/libs/langgraph/langgraph/pregel/runner.py +++ b/libs/langgraph/langgraph/pregel/runner.py @@ -18,7 +18,7 @@ from langgraph.errors import GraphDelegate, GraphInterrupt from langgraph.pregel.executor import Submit from langgraph.pregel.retry import arun_with_retry, run_with_retry -from langgraph.pregel.types import PregelExecutableTask, RetryPolicy +from langgraph.types import PregelExecutableTask, RetryPolicy class PregelRunner: diff --git a/libs/langgraph/langgraph/pregel/types.py b/libs/langgraph/langgraph/pregel/types.py index 4cca9946c..7a72b88c9 100644 --- a/libs/langgraph/langgraph/pregel/types.py +++ b/libs/langgraph/langgraph/pregel/types.py @@ -1,200 +1,25 @@ -from collections import deque -from dataclasses import dataclass -from typing import Any, Callable, Literal, NamedTuple, Optional, Sequence, Type, Union - -from langchain_core.runnables import Runnable, RunnableConfig - -from langgraph.checkpoint.base import CheckpointMetadata - -All = Literal["*"] - -StreamMode = Literal["values", "updates", "debug", "messages", "custom"] -"""How the stream method should emit outputs. - -- 'values': Emit all values of the state for each step. -- 'updates': Emit only the node name(s) and updates - that were returned by the node(s) **after** each step. -- 'debug': Emit debug events for each step. -- 'messages': Emit LLM messages token-by-token. -- 'custom': Emit custom output `write: StreamWriter` kwarg of each node. -""" - -StreamWriter = Callable[[Any], None] -"""Callable that accepts a single argument and writes it to the output stream. -Always injected into nodes if requested as a keyword argument, but it's a no-op -when not using stream_mode="custom".""" - - -def default_retry_on(exc: Exception) -> bool: - import httpx - import requests - - if isinstance(exc, ConnectionError): - return True - if isinstance( - exc, - ( - ValueError, - TypeError, - ArithmeticError, - ImportError, - LookupError, - NameError, - SyntaxError, - RuntimeError, - ReferenceError, - StopIteration, - StopAsyncIteration, - OSError, - ), - ): - return False - if isinstance(exc, httpx.HTTPStatusError): - return 500 <= exc.response.status_code < 600 - if isinstance(exc, requests.HTTPError): - return 500 <= exc.response.status_code < 600 if exc.response else True - return True - - -class RetryPolicy(NamedTuple): - """Configuration for retrying nodes.""" - - initial_interval: float = 0.5 - """Amount of time that must elapse before the first retry occurs. In seconds.""" - backoff_factor: float = 2.0 - """Multiplier by which the interval increases after each retry.""" - max_interval: float = 128.0 - """Maximum amount of time that may elapse between retries. In seconds.""" - max_attempts: int = 3 - """Maximum number of attempts to make before giving up, including the first.""" - jitter: bool = True - """Whether to add random jitter to the interval between retries.""" - retry_on: Union[ - Type[Exception], Sequence[Type[Exception]], Callable[[Exception], bool] - ] = default_retry_on - """List of exception classes that should trigger a retry, or a callable that returns True for exceptions that should trigger a retry.""" - - -class CachePolicy(NamedTuple): - """Configuration for caching nodes.""" - - pass - - -@dataclass -class Interrupt: - value: Any - when: Literal["during"] = "during" - - -class PregelTask(NamedTuple): - id: str - name: str - path: tuple[Union[str, int], ...] - error: Optional[Exception] = None - interrupts: tuple[Interrupt, ...] = () - state: Union[None, RunnableConfig, "StateSnapshot"] = None - - -class PregelExecutableTask(NamedTuple): - name: str - input: Any - proc: Runnable - writes: deque[tuple[str, Any]] - config: RunnableConfig - triggers: list[str] - retry_policy: Optional[RetryPolicy] - cache_policy: Optional[CachePolicy] - id: str - path: tuple[Union[str, int], ...] - scheduled: bool = False - - -class StateSnapshot(NamedTuple): - """Snapshot of the state of the graph at the beginning of a step.""" - - values: Union[dict[str, Any], Any] - """Current values of channels""" - next: tuple[str, ...] - """The name of the node to execute in each task for this step.""" - config: RunnableConfig - """Config used to fetch this snapshot""" - metadata: Optional[CheckpointMetadata] - """Metadata associated with this snapshot""" - created_at: Optional[str] - """Timestamp of snapshot creation""" - parent_config: Optional[RunnableConfig] - """Config used to fetch the parent snapshot, if any""" - tasks: tuple[PregelTask, ...] - """Tasks to execute in this step. If already attempted, may contain an error.""" - - -class Send: - """A message or packet to send to a specific node in the graph. - - The `Send` class is used within a `StateGraph`'s conditional edges to - dynamically invoke a node with a custom state at the next step. - - Importantly, the sent state can differ from the core graph's state, - allowing for flexible and dynamic workflow management. - - One such example is a "map-reduce" workflow where your graph invokes - the same node multiple times in parallel with different states, - before aggregating the results back into the main graph's state. - - Attributes: - node (str): The name of the target node to send the message to. - arg (Any): The state or message to send to the target node. - - Examples: - >>> from typing import Annotated - >>> import operator - >>> class OverallState(TypedDict): - ... subjects: list[str] - ... jokes: Annotated[list[str], operator.add] - ... - >>> from langgraph.constants import Send - >>> from langgraph.graph import END, START - >>> def continue_to_jokes(state: OverallState): - ... return [Send("generate_joke", {"subject": s}) for s in state['subjects']] - ... - >>> from langgraph.graph import StateGraph - >>> builder = StateGraph(OverallState) - >>> builder.add_node("generate_joke", lambda state: {"jokes": [f"Joke about {state['subject']}"]}) - >>> builder.add_conditional_edges(START, continue_to_jokes) - >>> builder.add_edge("generate_joke", END) - >>> graph = builder.compile() - >>> - >>> # Invoking with two subjects results in a generated joke for each - >>> graph.invoke({"subjects": ["cats", "dogs"]}) - {'subjects': ['cats', 'dogs'], 'jokes': ['Joke about cats', 'Joke about dogs']} - """ - - __slots__ = ("node", "arg") - - node: str - arg: Any - - def __init__(self, /, node: str, arg: Any) -> None: - """ - Initialize a new instance of the Send class. - - Args: - node (str): The name of the target node to send the message to. - arg (Any): The state or message to send to the target node. - """ - self.node = node - self.arg = arg - - def __hash__(self) -> int: - return hash((self.node, self.arg)) - - def __repr__(self) -> str: - return f"Send(node={self.node!r}, arg={self.arg!r})" - - def __eq__(self, value: object) -> bool: - return ( - isinstance(value, Send) - and self.node == value.node - and self.arg == value.arg - ) +"""Re-export types moved to langgraph.types""" + +from langgraph.types import ( + All, + CachePolicy, + PregelExecutableTask, + PregelTask, + RetryPolicy, + StateSnapshot, + StreamMode, + StreamWriter, + default_retry_on, +) + +__all__ = [ + "All", + "CachePolicy", + "PregelExecutableTask", + "PregelTask", + "RetryPolicy", + "StateSnapshot", + "StreamMode", + "StreamWriter", + "default_retry_on", +] diff --git a/libs/langgraph/langgraph/pregel/validate.py b/libs/langgraph/langgraph/pregel/validate.py index 965fab54e..cf957dc07 100644 --- a/libs/langgraph/langgraph/pregel/validate.py +++ b/libs/langgraph/langgraph/pregel/validate.py @@ -3,7 +3,7 @@ from langgraph.channels.base import BaseChannel from langgraph.constants import RESERVED from langgraph.pregel.read import PregelNode -from langgraph.pregel.types import All +from langgraph.types import All def validate_graph( diff --git a/libs/langgraph/langgraph/types.py b/libs/langgraph/langgraph/types.py new file mode 100644 index 000000000..4cca9946c --- /dev/null +++ b/libs/langgraph/langgraph/types.py @@ -0,0 +1,200 @@ +from collections import deque +from dataclasses import dataclass +from typing import Any, Callable, Literal, NamedTuple, Optional, Sequence, Type, Union + +from langchain_core.runnables import Runnable, RunnableConfig + +from langgraph.checkpoint.base import CheckpointMetadata + +All = Literal["*"] + +StreamMode = Literal["values", "updates", "debug", "messages", "custom"] +"""How the stream method should emit outputs. + +- 'values': Emit all values of the state for each step. +- 'updates': Emit only the node name(s) and updates + that were returned by the node(s) **after** each step. +- 'debug': Emit debug events for each step. +- 'messages': Emit LLM messages token-by-token. +- 'custom': Emit custom output `write: StreamWriter` kwarg of each node. +""" + +StreamWriter = Callable[[Any], None] +"""Callable that accepts a single argument and writes it to the output stream. +Always injected into nodes if requested as a keyword argument, but it's a no-op +when not using stream_mode="custom".""" + + +def default_retry_on(exc: Exception) -> bool: + import httpx + import requests + + if isinstance(exc, ConnectionError): + return True + if isinstance( + exc, + ( + ValueError, + TypeError, + ArithmeticError, + ImportError, + LookupError, + NameError, + SyntaxError, + RuntimeError, + ReferenceError, + StopIteration, + StopAsyncIteration, + OSError, + ), + ): + return False + if isinstance(exc, httpx.HTTPStatusError): + return 500 <= exc.response.status_code < 600 + if isinstance(exc, requests.HTTPError): + return 500 <= exc.response.status_code < 600 if exc.response else True + return True + + +class RetryPolicy(NamedTuple): + """Configuration for retrying nodes.""" + + initial_interval: float = 0.5 + """Amount of time that must elapse before the first retry occurs. In seconds.""" + backoff_factor: float = 2.0 + """Multiplier by which the interval increases after each retry.""" + max_interval: float = 128.0 + """Maximum amount of time that may elapse between retries. In seconds.""" + max_attempts: int = 3 + """Maximum number of attempts to make before giving up, including the first.""" + jitter: bool = True + """Whether to add random jitter to the interval between retries.""" + retry_on: Union[ + Type[Exception], Sequence[Type[Exception]], Callable[[Exception], bool] + ] = default_retry_on + """List of exception classes that should trigger a retry, or a callable that returns True for exceptions that should trigger a retry.""" + + +class CachePolicy(NamedTuple): + """Configuration for caching nodes.""" + + pass + + +@dataclass +class Interrupt: + value: Any + when: Literal["during"] = "during" + + +class PregelTask(NamedTuple): + id: str + name: str + path: tuple[Union[str, int], ...] + error: Optional[Exception] = None + interrupts: tuple[Interrupt, ...] = () + state: Union[None, RunnableConfig, "StateSnapshot"] = None + + +class PregelExecutableTask(NamedTuple): + name: str + input: Any + proc: Runnable + writes: deque[tuple[str, Any]] + config: RunnableConfig + triggers: list[str] + retry_policy: Optional[RetryPolicy] + cache_policy: Optional[CachePolicy] + id: str + path: tuple[Union[str, int], ...] + scheduled: bool = False + + +class StateSnapshot(NamedTuple): + """Snapshot of the state of the graph at the beginning of a step.""" + + values: Union[dict[str, Any], Any] + """Current values of channels""" + next: tuple[str, ...] + """The name of the node to execute in each task for this step.""" + config: RunnableConfig + """Config used to fetch this snapshot""" + metadata: Optional[CheckpointMetadata] + """Metadata associated with this snapshot""" + created_at: Optional[str] + """Timestamp of snapshot creation""" + parent_config: Optional[RunnableConfig] + """Config used to fetch the parent snapshot, if any""" + tasks: tuple[PregelTask, ...] + """Tasks to execute in this step. If already attempted, may contain an error.""" + + +class Send: + """A message or packet to send to a specific node in the graph. + + The `Send` class is used within a `StateGraph`'s conditional edges to + dynamically invoke a node with a custom state at the next step. + + Importantly, the sent state can differ from the core graph's state, + allowing for flexible and dynamic workflow management. + + One such example is a "map-reduce" workflow where your graph invokes + the same node multiple times in parallel with different states, + before aggregating the results back into the main graph's state. + + Attributes: + node (str): The name of the target node to send the message to. + arg (Any): The state or message to send to the target node. + + Examples: + >>> from typing import Annotated + >>> import operator + >>> class OverallState(TypedDict): + ... subjects: list[str] + ... jokes: Annotated[list[str], operator.add] + ... + >>> from langgraph.constants import Send + >>> from langgraph.graph import END, START + >>> def continue_to_jokes(state: OverallState): + ... return [Send("generate_joke", {"subject": s}) for s in state['subjects']] + ... + >>> from langgraph.graph import StateGraph + >>> builder = StateGraph(OverallState) + >>> builder.add_node("generate_joke", lambda state: {"jokes": [f"Joke about {state['subject']}"]}) + >>> builder.add_conditional_edges(START, continue_to_jokes) + >>> builder.add_edge("generate_joke", END) + >>> graph = builder.compile() + >>> + >>> # Invoking with two subjects results in a generated joke for each + >>> graph.invoke({"subjects": ["cats", "dogs"]}) + {'subjects': ['cats', 'dogs'], 'jokes': ['Joke about cats', 'Joke about dogs']} + """ + + __slots__ = ("node", "arg") + + node: str + arg: Any + + def __init__(self, /, node: str, arg: Any) -> None: + """ + Initialize a new instance of the Send class. + + Args: + node (str): The name of the target node to send the message to. + arg (Any): The state or message to send to the target node. + """ + self.node = node + self.arg = arg + + def __hash__(self) -> int: + return hash((self.node, self.arg)) + + def __repr__(self) -> str: + return f"Send(node={self.node!r}, arg={self.arg!r})" + + def __eq__(self, value: object) -> bool: + return ( + isinstance(value, Send) + and self.node == value.node + and self.arg == value.arg + ) diff --git a/libs/langgraph/langgraph/utils/runnable.py b/libs/langgraph/langgraph/utils/runnable.py index bfc2a627b..d81f86e34 100644 --- a/libs/langgraph/langgraph/utils/runnable.py +++ b/libs/langgraph/langgraph/utils/runnable.py @@ -35,7 +35,7 @@ from typing_extensions import TypeGuard from langgraph.constants import CONFIG_KEY_STREAM_WRITER -from langgraph.pregel.types import StreamWriter +from langgraph.types import StreamWriter from langgraph.utils.config import ( ensure_config, get_async_callback_manager_for_config, diff --git a/libs/langgraph/tests/test_pregel.py b/libs/langgraph/tests/test_pregel.py index 3e43ef28f..eb88ab189 100644 --- a/libs/langgraph/tests/test_pregel.py +++ b/libs/langgraph/tests/test_pregel.py @@ -70,8 +70,8 @@ StateSnapshot, ) from langgraph.pregel.retry import RetryPolicy -from langgraph.pregel.types import PregelTask, StreamWriter from langgraph.store.memory import MemoryStore +from langgraph.types import PregelTask, StreamWriter from tests.any_str import AnyDict, AnyStr, AnyVersion, UnsortedSequence from tests.conftest import ALL_CHECKPOINTERS_SYNC, SHOULD_CHECK_SNAPSHOTS from tests.fake_chat import FakeChatModel diff --git a/libs/langgraph/tests/test_pregel_async.py b/libs/langgraph/tests/test_pregel_async.py index 640658399..cee63f469 100644 --- a/libs/langgraph/tests/test_pregel_async.py +++ b/libs/langgraph/tests/test_pregel_async.py @@ -68,8 +68,8 @@ StateSnapshot, ) from langgraph.pregel.retry import RetryPolicy -from langgraph.pregel.types import PregelTask, StreamWriter from langgraph.store.memory import MemoryStore +from langgraph.types import PregelTask, StreamWriter from tests.any_str import AnyDict, AnyStr, AnyVersion, UnsortedSequence from tests.conftest import ( ALL_CHECKPOINTERS_ASYNC, diff --git a/libs/scheduler-kafka/langgraph/scheduler/kafka/executor.py b/libs/scheduler-kafka/langgraph/scheduler/kafka/executor.py index 9cbb6bf83..c803239e8 100644 --- a/libs/scheduler-kafka/langgraph/scheduler/kafka/executor.py +++ b/libs/scheduler-kafka/langgraph/scheduler/kafka/executor.py @@ -25,7 +25,6 @@ ) from langgraph.pregel.manager import AsyncChannelsManager, ChannelsManager from langgraph.pregel.runner import PregelRunner -from langgraph.pregel.types import RetryPolicy from langgraph.scheduler.kafka.retry import aretry, retry from langgraph.scheduler.kafka.types import ( AsyncConsumer, @@ -38,6 +37,7 @@ Sendable, Topics, ) +from langgraph.types import RetryPolicy from langgraph.utils.config import patch_configurable diff --git a/libs/scheduler-kafka/langgraph/scheduler/kafka/orchestrator.py b/libs/scheduler-kafka/langgraph/scheduler/kafka/orchestrator.py index 1ad9c5c5b..097429bb6 100644 --- a/libs/scheduler-kafka/langgraph/scheduler/kafka/orchestrator.py +++ b/libs/scheduler-kafka/langgraph/scheduler/kafka/orchestrator.py @@ -24,7 +24,6 @@ from langgraph.pregel import Pregel from langgraph.pregel.executor import BackgroundExecutor, Submit from langgraph.pregel.loop import AsyncPregelLoop, SyncPregelLoop -from langgraph.pregel.types import RetryPolicy from langgraph.scheduler.kafka.retry import aretry, retry from langgraph.scheduler.kafka.types import ( AsyncConsumer, @@ -37,6 +36,7 @@ Producer, Topics, ) +from langgraph.types import RetryPolicy from langgraph.utils.config import patch_configurable diff --git a/libs/scheduler-kafka/langgraph/scheduler/kafka/retry.py b/libs/scheduler-kafka/langgraph/scheduler/kafka/retry.py index bb80047f8..74dbe3e27 100644 --- a/libs/scheduler-kafka/langgraph/scheduler/kafka/retry.py +++ b/libs/scheduler-kafka/langgraph/scheduler/kafka/retry.py @@ -6,7 +6,7 @@ from typing_extensions import ParamSpec -from langgraph.pregel.types import RetryPolicy +from langgraph.types import RetryPolicy logger = logging.getLogger(__name__) P = ParamSpec("P") From 30b631aaff2507a9a48fd663ac3f43c87be6416f Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Sat, 21 Sep 2024 17:41:05 -0700 Subject: [PATCH 06/14] Rewrite imports --- docs/docs/how-tos/map-reduce.ipynb | 558 +++++++++++----------- docs/docs/reference/graphs.md | 2 +- libs/langgraph/langgraph/types.py | 2 +- libs/langgraph/tests/test_pregel.py | 4 +- libs/langgraph/tests/test_pregel_async.py | 4 +- libs/scheduler-kafka/README.md | 2 +- 6 files changed, 286 insertions(+), 286 deletions(-) diff --git a/docs/docs/how-tos/map-reduce.ipynb b/docs/docs/how-tos/map-reduce.ipynb index 51a2eb14d..fb00f0bfb 100644 --- a/docs/docs/how-tos/map-reduce.ipynb +++ b/docs/docs/how-tos/map-reduce.ipynb @@ -1,286 +1,286 @@ { - "cells": [ - { - "attachments": { - "a108ffc8-6136-4cd7-a6f9-579e41a5a786.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "id": "95a87145-34d0-4f97-b45f-5c9fd8532c8a", - "metadata": {}, - "source": [ - "# How to create map-reduce branches for parallel execution\n", - "\n", - "[Map-reduce](https://en.wikipedia.org/wiki/MapReduce) operations are essential for efficient task decomposition and parallel processing. This approach involves breaking a task into smaller sub-tasks, processing each sub-task in parallel, and aggregating the results across all of the completed sub-tasks. \n", - "\n", - "Consider this example: given a general topic from the user, generate a list of related subjects, generate a joke for each subject, and select the best joke from the resulting list. In this design pattern, a first node may generate a list of objects (e.g., related subjects) and we want to apply some other node (e.g., generate a joke) to all those objects (e.g., subjects). However, two main challenges arise.\n", - " \n", - "(1) the number of objects (e.g., subjects) may be unknown ahead of time (meaning the number of edges may not be known) when we lay out the graph and (2) the input State to the downstream Node should be different (one for each generated object).\n", - " \n", - "LangGraph addresses these challenges [through its `Send` API](https://langchain-ai.github.io/langgraph/concepts/low_level/#send). By utilizing conditional edges, `Send` can distribute different states (e.g., subjects) to multiple instances of a node (e.g., joke generation). Importantly, the sent state can differ from the core graph's state, allowing for flexible and dynamic workflow management. \n", - "\n", - "![Screenshot 2024-07-12 at 9.45.40 AM.png](attachment:a108ffc8-6136-4cd7-a6f9-579e41a5a786.png)" - ] - }, - { - "cell_type": "markdown", - "id": "66c58b5f", - "metadata": {}, - "source": [ - "## Setup\n", - "\n", - "First, let's install the required packages and set our API keys" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "3eb04cd1", - "metadata": {}, - "outputs": [], - "source": [ - "%%capture --no-stderr\n", - "%pip install -U langchain-anthropic langgraph" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "dc292321", - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import getpass\n", - "\n", - "\n", - "def _set_env(name: str):\n", - " if not os.getenv(name):\n", - " os.environ[name] = getpass.getpass(f\"{name}: \")\n", - "\n", - "\n", - "_set_env(\"ANTHROPIC_API_KEY\")" - ] - }, - { - "cell_type": "markdown", - "id": "b87911bb", - "metadata": {}, - "source": [ - "
\n", - "

Set up LangSmith for LangGraph development

\n", - "

\n", - " Sign up for LangSmith to quickly spot issues and improve the performance of your LangGraph projects. LangSmith lets you use trace data to debug, test, and monitor your LLM apps built with LangGraph — read more about how to get started here. \n", - "

\n", - "
" - ] - }, - { - "cell_type": "markdown", - "id": "b4e782a0", - "metadata": {}, - "source": [ - "## Define the graph" - ] - }, - { - "cell_type": "markdown", - "id": "66803b55", - "metadata": {}, - "source": [ - "
\n", - "

Using Pydantic with LangChain

\n", - "

\n", - " This notebook uses Pydantic v2 BaseModel, which requires langchain-core >= 0.3. Using langchain-core < 0.3 will result in errors due to mixing of Pydantic v1 and v2 BaseModels.\n", - "

\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "0f0f78e4-423d-4e2d-aa1a-01efaec4715f", - "metadata": {}, - "outputs": [], - "source": [ - "import operator\n", - "from typing import Annotated, TypedDict\n", - "\n", - "from langchain_anthropic import ChatAnthropic\n", - "\n", - "from langgraph.constants import Send\n", - "from langgraph.graph import END, StateGraph, START\n", - "\n", - "from pydantic import BaseModel, Field\n", - "\n", - "# Model and prompts\n", - "# Define model and prompts we will use\n", - "subjects_prompt = \"\"\"Generate a comma separated list of between 2 and 5 examples related to: {topic}.\"\"\"\n", - "joke_prompt = \"\"\"Generate a joke about {subject}\"\"\"\n", - "best_joke_prompt = \"\"\"Below are a bunch of jokes about {topic}. Select the best one! Return the ID of the best one.\n", - "\n", - "{jokes}\"\"\"\n", - "\n", - "\n", - "class Subjects(BaseModel):\n", - " subjects: list[str]\n", - "\n", - "\n", - "class Joke(BaseModel):\n", - " joke: str\n", - "\n", - "\n", - "class BestJoke(BaseModel):\n", - " id: int = Field(description=\"Index of the best joke, starting with 0\", ge=0)\n", - "\n", - "\n", - "model = ChatAnthropic(model=\"claude-3-5-sonnet-20240620\")\n", - "\n", - "# Graph components: define the components that will make up the graph\n", - "\n", - "\n", - "# This will be the overall state of the main graph.\n", - "# It will contain a topic (which we expect the user to provide)\n", - "# and then will generate a list of subjects, and then a joke for\n", - "# each subject\n", - "class OverallState(TypedDict):\n", - " topic: str\n", - " subjects: list\n", - " # Notice here we use the operator.add\n", - " # This is because we want combine all the jokes we generate\n", - " # from individual nodes back into one list - this is essentially\n", - " # the \"reduce\" part\n", - " jokes: Annotated[list, operator.add]\n", - " best_selected_joke: str\n", - "\n", - "\n", - "# This will be the state of the node that we will \"map\" all\n", - "# subjects to in order to generate a joke\n", - "class JokeState(TypedDict):\n", - " subject: str\n", - "\n", - "\n", - "# This is the function we will use to generate the subjects of the jokes\n", - "def generate_topics(state: OverallState):\n", - " prompt = subjects_prompt.format(topic=state[\"topic\"])\n", - " response = model.with_structured_output(Subjects).invoke(prompt)\n", - " return {\"subjects\": response.subjects}\n", - "\n", - "\n", - "# Here we generate a joke, given a subject\n", - "def generate_joke(state: JokeState):\n", - " prompt = joke_prompt.format(subject=state[\"subject\"])\n", - " response = model.with_structured_output(Joke).invoke(prompt)\n", - " return {\"jokes\": [response.joke]}\n", - "\n", - "\n", - "# Here we define the logic to map out over the generated subjects\n", - "# We will use this an edge in the graph\n", - "def continue_to_jokes(state: OverallState):\n", - " # We will return a list of `Send` objects\n", - " # Each `Send` object consists of the name of a node in the graph\n", - " # as well as the state to send to that node\n", - " return [Send(\"generate_joke\", {\"subject\": s}) for s in state[\"subjects\"]]\n", - "\n", - "\n", - "# Here we will judge the best joke\n", - "def best_joke(state: OverallState):\n", - " jokes = \"\\n\\n\".join(state[\"jokes\"])\n", - " prompt = best_joke_prompt.format(topic=state[\"topic\"], jokes=jokes)\n", - " response = model.with_structured_output(BestJoke).invoke(prompt)\n", - " return {\"best_selected_joke\": state[\"jokes\"][response.id]}\n", - "\n", - "\n", - "# Construct the graph: here we put everything together to construct our graph\n", - "graph = StateGraph(OverallState)\n", - "graph.add_node(\"generate_topics\", generate_topics)\n", - "graph.add_node(\"generate_joke\", generate_joke)\n", - "graph.add_node(\"best_joke\", best_joke)\n", - "graph.add_edge(START, \"generate_topics\")\n", - "graph.add_conditional_edges(\"generate_topics\", continue_to_jokes, [\"generate_joke\"])\n", - "graph.add_edge(\"generate_joke\", \"best_joke\")\n", - "graph.add_edge(\"best_joke\", END)\n", - "app = graph.compile()" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "37ed1f71-63db-416f-b715-4617b33d4b7f", - "metadata": {}, - "outputs": [ + "cells": [ { - "data": { - "image/jpeg": "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", - "text/plain": [ - "" + "attachments": { + "a108ffc8-6136-4cd7-a6f9-579e41a5a786.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "95a87145-34d0-4f97-b45f-5c9fd8532c8a", + "metadata": {}, + "source": [ + "# How to create map-reduce branches for parallel execution\n", + "\n", + "[Map-reduce](https://en.wikipedia.org/wiki/MapReduce) operations are essential for efficient task decomposition and parallel processing. This approach involves breaking a task into smaller sub-tasks, processing each sub-task in parallel, and aggregating the results across all of the completed sub-tasks. \n", + "\n", + "Consider this example: given a general topic from the user, generate a list of related subjects, generate a joke for each subject, and select the best joke from the resulting list. In this design pattern, a first node may generate a list of objects (e.g., related subjects) and we want to apply some other node (e.g., generate a joke) to all those objects (e.g., subjects). However, two main challenges arise.\n", + " \n", + "(1) the number of objects (e.g., subjects) may be unknown ahead of time (meaning the number of edges may not be known) when we lay out the graph and (2) the input State to the downstream Node should be different (one for each generated object).\n", + " \n", + "LangGraph addresses these challenges [through its `Send` API](https://langchain-ai.github.io/langgraph/concepts/low_level/#send). By utilizing conditional edges, `Send` can distribute different states (e.g., subjects) to multiple instances of a node (e.g., joke generation). Importantly, the sent state can differ from the core graph's state, allowing for flexible and dynamic workflow management. \n", + "\n", + "![Screenshot 2024-07-12 at 9.45.40 AM.png](attachment:a108ffc8-6136-4cd7-a6f9-579e41a5a786.png)" ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from IPython.display import Image\n", - "\n", - "Image(app.get_graph().draw_mermaid_png())" - ] - }, - { - "cell_type": "markdown", - "id": "4a0026d8", - "metadata": {}, - "source": [ - "## Use the graph" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "fd90cace", - "metadata": {}, - "outputs": [ + }, + { + "cell_type": "markdown", + "id": "66c58b5f", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "First, let's install the required packages and set our API keys" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "3eb04cd1", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture --no-stderr\n", + "%pip install -U langchain-anthropic langgraph" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'generate_topics': {'subjects': ['Lions', 'Elephants', 'Penguins', 'Dolphins']}}\n", - "{'generate_joke': {'jokes': [\"Why don't elephants use computers? They're afraid of the mouse!\"]}}\n", - "{'generate_joke': {'jokes': [\"Why don't dolphins use smartphones? Because they're afraid of phishing!\"]}}\n", - "{'generate_joke': {'jokes': [\"Why don't you see penguins in Britain? Because they're afraid of Wales!\"]}}\n", - "{'generate_joke': {'jokes': [\"Why don't lions like fast food? Because they can't catch it!\"]}}\n", - "{'best_joke': {'best_selected_joke': \"Why don't dolphins use smartphones? Because they're afraid of phishing!\"}}\n" - ] + "cell_type": "code", + "execution_count": null, + "id": "dc292321", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import getpass\n", + "\n", + "\n", + "def _set_env(name: str):\n", + " if not os.getenv(name):\n", + " os.environ[name] = getpass.getpass(f\"{name}: \")\n", + "\n", + "\n", + "_set_env(\"ANTHROPIC_API_KEY\")" + ] + }, + { + "cell_type": "markdown", + "id": "b87911bb", + "metadata": {}, + "source": [ + "
\n", + "

Set up LangSmith for LangGraph development

\n", + "

\n", + " Sign up for LangSmith to quickly spot issues and improve the performance of your LangGraph projects. LangSmith lets you use trace data to debug, test, and monitor your LLM apps built with LangGraph — read more about how to get started here. \n", + "

\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "b4e782a0", + "metadata": {}, + "source": [ + "## Define the graph" + ] + }, + { + "cell_type": "markdown", + "id": "66803b55", + "metadata": {}, + "source": [ + "
\n", + "

Using Pydantic with LangChain

\n", + "

\n", + " This notebook uses Pydantic v2 BaseModel, which requires langchain-core >= 0.3. Using langchain-core < 0.3 will result in errors due to mixing of Pydantic v1 and v2 BaseModels.\n", + "

\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0f0f78e4-423d-4e2d-aa1a-01efaec4715f", + "metadata": {}, + "outputs": [], + "source": [ + "import operator\n", + "from typing import Annotated, TypedDict\n", + "\n", + "from langchain_anthropic import ChatAnthropic\n", + "\n", + "from langgraph.types import Send\n", + "from langgraph.graph import END, StateGraph, START\n", + "\n", + "from pydantic import BaseModel, Field\n", + "\n", + "# Model and prompts\n", + "# Define model and prompts we will use\n", + "subjects_prompt = \"\"\"Generate a comma separated list of between 2 and 5 examples related to: {topic}.\"\"\"\n", + "joke_prompt = \"\"\"Generate a joke about {subject}\"\"\"\n", + "best_joke_prompt = \"\"\"Below are a bunch of jokes about {topic}. Select the best one! Return the ID of the best one.\n", + "\n", + "{jokes}\"\"\"\n", + "\n", + "\n", + "class Subjects(BaseModel):\n", + " subjects: list[str]\n", + "\n", + "\n", + "class Joke(BaseModel):\n", + " joke: str\n", + "\n", + "\n", + "class BestJoke(BaseModel):\n", + " id: int = Field(description=\"Index of the best joke, starting with 0\", ge=0)\n", + "\n", + "\n", + "model = ChatAnthropic(model=\"claude-3-5-sonnet-20240620\")\n", + "\n", + "# Graph components: define the components that will make up the graph\n", + "\n", + "\n", + "# This will be the overall state of the main graph.\n", + "# It will contain a topic (which we expect the user to provide)\n", + "# and then will generate a list of subjects, and then a joke for\n", + "# each subject\n", + "class OverallState(TypedDict):\n", + " topic: str\n", + " subjects: list\n", + " # Notice here we use the operator.add\n", + " # This is because we want combine all the jokes we generate\n", + " # from individual nodes back into one list - this is essentially\n", + " # the \"reduce\" part\n", + " jokes: Annotated[list, operator.add]\n", + " best_selected_joke: str\n", + "\n", + "\n", + "# This will be the state of the node that we will \"map\" all\n", + "# subjects to in order to generate a joke\n", + "class JokeState(TypedDict):\n", + " subject: str\n", + "\n", + "\n", + "# This is the function we will use to generate the subjects of the jokes\n", + "def generate_topics(state: OverallState):\n", + " prompt = subjects_prompt.format(topic=state[\"topic\"])\n", + " response = model.with_structured_output(Subjects).invoke(prompt)\n", + " return {\"subjects\": response.subjects}\n", + "\n", + "\n", + "# Here we generate a joke, given a subject\n", + "def generate_joke(state: JokeState):\n", + " prompt = joke_prompt.format(subject=state[\"subject\"])\n", + " response = model.with_structured_output(Joke).invoke(prompt)\n", + " return {\"jokes\": [response.joke]}\n", + "\n", + "\n", + "# Here we define the logic to map out over the generated subjects\n", + "# We will use this an edge in the graph\n", + "def continue_to_jokes(state: OverallState):\n", + " # We will return a list of `Send` objects\n", + " # Each `Send` object consists of the name of a node in the graph\n", + " # as well as the state to send to that node\n", + " return [Send(\"generate_joke\", {\"subject\": s}) for s in state[\"subjects\"]]\n", + "\n", + "\n", + "# Here we will judge the best joke\n", + "def best_joke(state: OverallState):\n", + " jokes = \"\\n\\n\".join(state[\"jokes\"])\n", + " prompt = best_joke_prompt.format(topic=state[\"topic\"], jokes=jokes)\n", + " response = model.with_structured_output(BestJoke).invoke(prompt)\n", + " return {\"best_selected_joke\": state[\"jokes\"][response.id]}\n", + "\n", + "\n", + "# Construct the graph: here we put everything together to construct our graph\n", + "graph = StateGraph(OverallState)\n", + "graph.add_node(\"generate_topics\", generate_topics)\n", + "graph.add_node(\"generate_joke\", generate_joke)\n", + "graph.add_node(\"best_joke\", best_joke)\n", + "graph.add_edge(START, \"generate_topics\")\n", + "graph.add_conditional_edges(\"generate_topics\", continue_to_jokes, [\"generate_joke\"])\n", + "graph.add_edge(\"generate_joke\", \"best_joke\")\n", + "graph.add_edge(\"best_joke\", END)\n", + "app = graph.compile()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "37ed1f71-63db-416f-b715-4617b33d4b7f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image\n", + "\n", + "Image(app.get_graph().draw_mermaid_png())" + ] + }, + { + "cell_type": "markdown", + "id": "4a0026d8", + "metadata": {}, + "source": [ + "## Use the graph" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fd90cace", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'generate_topics': {'subjects': ['Lions', 'Elephants', 'Penguins', 'Dolphins']}}\n", + "{'generate_joke': {'jokes': [\"Why don't elephants use computers? They're afraid of the mouse!\"]}}\n", + "{'generate_joke': {'jokes': [\"Why don't dolphins use smartphones? Because they're afraid of phishing!\"]}}\n", + "{'generate_joke': {'jokes': [\"Why don't you see penguins in Britain? Because they're afraid of Wales!\"]}}\n", + "{'generate_joke': {'jokes': [\"Why don't lions like fast food? Because they can't catch it!\"]}}\n", + "{'best_joke': {'best_selected_joke': \"Why don't dolphins use smartphones? Because they're afraid of phishing!\"}}\n" + ] + } + ], + "source": [ + "# Call the graph: here we call it to generate a list of jokes\n", + "for s in app.stream({\"topic\": \"animals\"}):\n", + " print(s)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" } - ], - "source": [ - "# Call the graph: here we call it to generate a list of jokes\n", - "for s in app.stream({\"topic\": \"animals\"}):\n", - " print(s)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 + "nbformat": 4, + "nbformat_minor": 5 } diff --git a/docs/docs/reference/graphs.md b/docs/docs/reference/graphs.md index 779f95095..14392ba2c 100644 --- a/docs/docs/reference/graphs.md +++ b/docs/docs/reference/graphs.md @@ -29,7 +29,7 @@ handler: python ## StreamMode -::: langgraph.pregel.types.StreamMode +::: langgraph.types.StreamMode ## Constants diff --git a/libs/langgraph/langgraph/types.py b/libs/langgraph/langgraph/types.py index 4cca9946c..afbc98505 100644 --- a/libs/langgraph/langgraph/types.py +++ b/libs/langgraph/langgraph/types.py @@ -153,7 +153,7 @@ class Send: ... subjects: list[str] ... jokes: Annotated[list[str], operator.add] ... - >>> from langgraph.constants import Send + >>> from langgraph.types import Send >>> from langgraph.graph import END, START >>> def continue_to_jokes(state: OverallState): ... return [Send("generate_joke", {"subject": s}) for s in state['subjects']] diff --git a/libs/langgraph/tests/test_pregel.py b/libs/langgraph/tests/test_pregel.py index eb88ab189..1fa11ead2 100644 --- a/libs/langgraph/tests/test_pregel.py +++ b/libs/langgraph/tests/test_pregel.py @@ -52,7 +52,7 @@ CheckpointTuple, ) from langgraph.checkpoint.memory import MemorySaver -from langgraph.constants import ERROR, PULL, PUSH, Interrupt, Send +from langgraph.constants import ERROR, PULL, PUSH from langgraph.errors import InvalidUpdateError, NodeInterrupt from langgraph.graph import END, Graph from langgraph.graph.graph import START @@ -71,7 +71,7 @@ ) from langgraph.pregel.retry import RetryPolicy from langgraph.store.memory import MemoryStore -from langgraph.types import PregelTask, StreamWriter +from langgraph.types import Interrupt, PregelTask, Send, StreamWriter from tests.any_str import AnyDict, AnyStr, AnyVersion, UnsortedSequence from tests.conftest import ALL_CHECKPOINTERS_SYNC, SHOULD_CHECK_SNAPSHOTS from tests.fake_chat import FakeChatModel diff --git a/libs/langgraph/tests/test_pregel_async.py b/libs/langgraph/tests/test_pregel_async.py index cee63f469..416c9ffe2 100644 --- a/libs/langgraph/tests/test_pregel_async.py +++ b/libs/langgraph/tests/test_pregel_async.py @@ -51,7 +51,7 @@ CheckpointTuple, ) from langgraph.checkpoint.memory import MemorySaver -from langgraph.constants import ERROR, PULL, PUSH, Interrupt, Send +from langgraph.constants import ERROR, PULL, PUSH from langgraph.errors import InvalidUpdateError, NodeInterrupt from langgraph.graph import END, Graph, StateGraph from langgraph.graph.graph import START @@ -69,7 +69,7 @@ ) from langgraph.pregel.retry import RetryPolicy from langgraph.store.memory import MemoryStore -from langgraph.types import PregelTask, StreamWriter +from langgraph.types import Interrupt, PregelTask, Send, StreamWriter from tests.any_str import AnyDict, AnyStr, AnyVersion, UnsortedSequence from tests.conftest import ( ALL_CHECKPOINTERS_ASYNC, diff --git a/libs/scheduler-kafka/README.md b/libs/scheduler-kafka/README.md index 637a337dd..fd65d7f3c 100644 --- a/libs/scheduler-kafka/README.md +++ b/libs/scheduler-kafka/README.md @@ -95,7 +95,7 @@ You can pass any of the following values as `kwargs` to either `KafkaOrchestrato - batch_max_n (int): Maximum number of messages to include in a single batch. Default: 10. - batch_max_ms (int): Maximum time in milliseconds to wait for messages to include in a batch. Default: 1000. -- retry_policy (langgraph.pregel.types.RetryPolicy): Controls which graph-level errors will be retried when processing messages. A good use for this is to retry database errors thrown by the checkpointer. Defaults to None. +- retry_policy (langgraph.types.RetryPolicy): Controls which graph-level errors will be retried when processing messages. A good use for this is to retry database errors thrown by the checkpointer. Defaults to None. ### Connection settings From beeb2aa8ba80a8a896ab75cd5263644d0b64e5b2 Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Sat, 21 Sep 2024 17:44:11 -0700 Subject: [PATCH 07/14] Detect multiple subgraphs in single node --- libs/langgraph/langgraph/pregel/loop.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/libs/langgraph/langgraph/pregel/loop.py b/libs/langgraph/langgraph/pregel/loop.py index 7eec59575..f5dba4f9b 100644 --- a/libs/langgraph/langgraph/pregel/loop.py +++ b/libs/langgraph/langgraph/pregel/loop.py @@ -41,6 +41,7 @@ CONFIG_KEY_DEDUPE_TASKS, CONFIG_KEY_DELEGATE, CONFIG_KEY_ENSURE_LATEST, + CONFIG_KEY_GRAPH_COUNT, CONFIG_KEY_RESUMING, CONFIG_KEY_STREAM, CONFIG_KEY_TASK_ID, @@ -220,6 +221,11 @@ def __init__( self.config = patch_configurable( self.config, {"checkpoint_ns": "", "checkpoint_id": None} ) + if config["configurable"].get(CONFIG_KEY_GRAPH_COUNT, 0) > 0: + raise ValueError("Detected multiple subgraphs called in a single node.") + else: + # mutate config so that sibling subgraphs can be detected + self.config["configurable"][CONFIG_KEY_GRAPH_COUNT] = 1 if ( CONFIG_KEY_CHECKPOINT_MAP in self.config["configurable"] and self.config["configurable"].get("checkpoint_ns") From 89bb7fe178aef7ca98f452e9b2d1a94034667107 Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Sat, 21 Sep 2024 17:47:36 -0700 Subject: [PATCH 08/14] Skip test for now --- libs/langgraph/tests/test_tracing_interops.py | 1 + 1 file changed, 1 insertion(+) diff --git a/libs/langgraph/tests/test_tracing_interops.py b/libs/langgraph/tests/test_tracing_interops.py index f1f0ad7fb..a3dae6420 100644 --- a/libs/langgraph/tests/test_tracing_interops.py +++ b/libs/langgraph/tests/test_tracing_interops.py @@ -55,6 +55,7 @@ def wait_for( raise ValueError(f"Callable did not return within {total_time}") +@pytest.skip("This test times out in CI") async def test_nested_tracing(): lt_py_311 = sys.version_info < (3, 11) mock_client = _get_mock_client() From 2fccd0958534f6266c53a331b6717c73b62e83ab Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Sat, 21 Sep 2024 17:52:17 -0700 Subject: [PATCH 09/14] Fix --- libs/langgraph/langgraph/pregel/algo.py | 3 +++ libs/langgraph/langgraph/pregel/loop.py | 11 ++++++----- libs/langgraph/tests/test_tracing_interops.py | 2 +- 3 files changed, 10 insertions(+), 6 deletions(-) diff --git a/libs/langgraph/langgraph/pregel/algo.py b/libs/langgraph/langgraph/pregel/algo.py index f9b0096c8..3c98a248b 100644 --- a/libs/langgraph/langgraph/pregel/algo.py +++ b/libs/langgraph/langgraph/pregel/algo.py @@ -30,6 +30,7 @@ from langgraph.constants import ( CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_CHECKPOINTER, + CONFIG_KEY_GRAPH_COUNT, CONFIG_KEY_READ, CONFIG_KEY_SEND, CONFIG_KEY_TASK_ID, @@ -429,6 +430,7 @@ def prepare_single_task( manager.get_child(f"graph:step:{step}") if manager else None ), configurable={ + CONFIG_KEY_GRAPH_COUNT: 0, CONFIG_KEY_TASK_ID: task_id, # deque.extend is thread-safe CONFIG_KEY_SEND: partial( @@ -539,6 +541,7 @@ def prepare_single_task( else None ), configurable={ + CONFIG_KEY_GRAPH_COUNT: 0, CONFIG_KEY_TASK_ID: task_id, # deque.extend is thread-safe CONFIG_KEY_SEND: partial( diff --git a/libs/langgraph/langgraph/pregel/loop.py b/libs/langgraph/langgraph/pregel/loop.py index f5dba4f9b..a40b5f8f6 100644 --- a/libs/langgraph/langgraph/pregel/loop.py +++ b/libs/langgraph/langgraph/pregel/loop.py @@ -221,11 +221,12 @@ def __init__( self.config = patch_configurable( self.config, {"checkpoint_ns": "", "checkpoint_id": None} ) - if config["configurable"].get(CONFIG_KEY_GRAPH_COUNT, 0) > 0: - raise ValueError("Detected multiple subgraphs called in a single node.") - else: - # mutate config so that sibling subgraphs can be detected - self.config["configurable"][CONFIG_KEY_GRAPH_COUNT] = 1 + if self.is_nested: + if config["configurable"].get(CONFIG_KEY_GRAPH_COUNT, 0) > 0: + raise ValueError("Detected multiple subgraphs called in a single node.") + else: + # mutate config so that sibling subgraphs can be detected + self.config["configurable"][CONFIG_KEY_GRAPH_COUNT] = 1 if ( CONFIG_KEY_CHECKPOINT_MAP in self.config["configurable"] and self.config["configurable"].get("checkpoint_ns") diff --git a/libs/langgraph/tests/test_tracing_interops.py b/libs/langgraph/tests/test_tracing_interops.py index a3dae6420..5b458394b 100644 --- a/libs/langgraph/tests/test_tracing_interops.py +++ b/libs/langgraph/tests/test_tracing_interops.py @@ -55,7 +55,7 @@ def wait_for( raise ValueError(f"Callable did not return within {total_time}") -@pytest.skip("This test times out in CI") +@pytest.mark.skip("This test times out in CI") async def test_nested_tracing(): lt_py_311 = sys.version_info < (3, 11) mock_client = _get_mock_client() From 81a9a2f9038716b3be8a705f07a46c5b541e7918 Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Sat, 21 Sep 2024 18:48:23 -0700 Subject: [PATCH 10/14] Use a different strategy, add test --- libs/langgraph/langgraph/constants.py | 18 +++++------ libs/langgraph/langgraph/errors.py | 10 ++++++ libs/langgraph/langgraph/graph/graph.py | 5 ++- libs/langgraph/langgraph/graph/state.py | 7 ++-- .../langgraph/prebuilt/chat_agent_executor.py | 4 +-- libs/langgraph/langgraph/pregel/__init__.py | 32 ++++++++----------- libs/langgraph/langgraph/pregel/algo.py | 3 -- libs/langgraph/langgraph/pregel/loop.py | 12 +++---- libs/langgraph/langgraph/pregel/retry.py | 26 ++++++++++----- libs/langgraph/langgraph/types.py | 18 +++++++++-- libs/langgraph/tests/test_pregel.py | 20 ++++++++++-- libs/langgraph/tests/test_pregel_async.py | 19 +++++++++-- 12 files changed, 114 insertions(+), 60 deletions(-) diff --git a/libs/langgraph/langgraph/constants.py b/libs/langgraph/langgraph/constants.py index ef4a8a486..bde74c438 100644 --- a/libs/langgraph/langgraph/constants.py +++ b/libs/langgraph/langgraph/constants.py @@ -10,6 +10,14 @@ EMPTY_MAP: Mapping[str, Any] = MappingProxyType({}) EMPTY_SEQ: tuple[str, ...] = tuple() +# --- Public constants --- +TAG_HIDDEN = "langsmith:hidden" +# tag to hide a node/edge from certain tracing/streaming environments +START = "__start__" +# the first (maybe virtual) node in graph-style Pregel +END = "__end__" +# the last (maybe virtual) node in graph-style Pregel + # --- Reserved write keys --- INPUT = "__input__" # for values passed as input to the graph @@ -23,10 +31,6 @@ # marker to signal node was scheduled (in distributed mode) TASKS = "__pregel_tasks" # for Send objects returned by nodes/edges, corresponds to PUSH below -START = "__start__" -# marker for the first (maybe virtual) node in graph-style Pregel -END = "__end__" -# marker for the last (maybe virtual) node in graph-style Pregel # --- Reserved config.configurable keys --- CONFIG_KEY_SEND = "__pregel_send" @@ -43,8 +47,6 @@ # holds a `BaseStore` made available to managed values CONFIG_KEY_RESUMING = "__pregel_resuming" # holds a boolean indicating if subgraphs should resume from a previous checkpoint -CONFIG_KEY_GRAPH_COUNT = "__pregel_graph_count" -# holds the number of subgraphs executed in a given task, used to raise errors CONFIG_KEY_TASK_ID = "__pregel_task_id" # holds the task ID for the current task CONFIG_KEY_DEDUPE_TASKS = "__pregel_dedupe_tasks" @@ -68,14 +70,13 @@ # denotes pull-style tasks, ie. those triggered by edges RUNTIME_PLACEHOLDER = "__pregel_runtime_placeholder__" # placeholder for managed values replaced at runtime -TAG_HIDDEN = "langsmith:hidden" -# tag to hide a node/edge from certain tracing/streaming environments NS_SEP = "|" # for checkpoint_ns, separates each level (ie. graph|subgraph|subsubgraph) NS_END = ":" # for checkpoint_ns, for each level, separates the namespace from the task_id RESERVED = { + TAG_HIDDEN, # reserved write keys INPUT, INTERRUPT, @@ -103,7 +104,6 @@ PUSH, PULL, RUNTIME_PLACEHOLDER, - TAG_HIDDEN, NS_SEP, NS_END, } diff --git a/libs/langgraph/langgraph/errors.py b/libs/langgraph/langgraph/errors.py index c7c5a518a..63bc8aff6 100644 --- a/libs/langgraph/langgraph/errors.py +++ b/libs/langgraph/langgraph/errors.py @@ -69,3 +69,13 @@ class CheckpointNotLatest(Exception): """Raised when the checkpoint is not the latest version (for distributed mode).""" pass + + +class MultipleSubgraphsError(Exception): + """Raised when multiple subgraphs are called inside the same node.""" + + pass + + +_SEEN_CHECKPOINT_NS: set[str] = set() +"""Used for subgraph detection.""" diff --git a/libs/langgraph/langgraph/graph/graph.py b/libs/langgraph/langgraph/graph/graph.py index a5a4db3ac..e957a15b9 100644 --- a/libs/langgraph/langgraph/graph/graph.py +++ b/libs/langgraph/langgraph/graph/graph.py @@ -26,7 +26,6 @@ from typing_extensions import Self from langgraph.channels.ephemeral_value import EphemeralValue -from langgraph.checkpoint.base import BaseCheckpointSaver from langgraph.constants import ( END, NS_END, @@ -39,7 +38,7 @@ from langgraph.pregel import Channel, Pregel from langgraph.pregel.read import PregelNode from langgraph.pregel.write import ChannelWrite, ChannelWriteEntry -from langgraph.types import All +from langgraph.types import All, Checkpointer from langgraph.utils.runnable import RunnableCallable, coerce_to_runnable logger = logging.getLogger(__name__) @@ -406,7 +405,7 @@ def validate(self, interrupt: Optional[Sequence[str]] = None) -> Self: def compile( self, - checkpointer: Optional[BaseCheckpointSaver] = None, + checkpointer: Checkpointer = None, interrupt_before: Optional[Union[All, list[str]]] = None, interrupt_after: Optional[Union[All, list[str]]] = None, debug: bool = False, diff --git a/libs/langgraph/langgraph/graph/state.py b/libs/langgraph/langgraph/graph/state.py index 4fdff2a49..bc0762c80 100644 --- a/libs/langgraph/langgraph/graph/state.py +++ b/libs/langgraph/langgraph/graph/state.py @@ -32,7 +32,6 @@ from langgraph.channels.ephemeral_value import EphemeralValue from langgraph.channels.last_value import LastValue from langgraph.channels.named_barrier_value import NamedBarrierValue -from langgraph.checkpoint.base import BaseCheckpointSaver from langgraph.constants import NS_END, NS_SEP, TAG_HIDDEN from langgraph.errors import InvalidUpdateError from langgraph.graph.graph import END, START, Branch, CompiledGraph, Graph, Send @@ -47,7 +46,7 @@ from langgraph.pregel.read import ChannelRead, PregelNode from langgraph.pregel.write import SKIP_WRITE, ChannelWrite, ChannelWriteEntry from langgraph.store.base import BaseStore -from langgraph.types import All, RetryPolicy +from langgraph.types import All, Checkpointer, RetryPolicy from langgraph.utils.fields import get_field_default from langgraph.utils.pydantic import create_model from langgraph.utils.runnable import coerce_to_runnable @@ -400,7 +399,7 @@ def add_edge(self, start_key: Union[str, list[str]], end_key: str) -> Self: def compile( self, - checkpointer: Optional[BaseCheckpointSaver] = None, + checkpointer: Checkpointer = None, *, store: Optional[BaseStore] = None, interrupt_before: Optional[Union[All, list[str]]] = None, @@ -413,7 +412,7 @@ def compile( streamed, batched, and run asynchronously. Args: - checkpointer (Optional[BaseCheckpointSaver]): An optional checkpoint saver object. + checkpointer (Checkpointer): An optional checkpoint saver object. This serves as a fully versioned "memory" for the graph, allowing the graph to be paused and resumed, and replayed from any point. interrupt_before (Optional[Sequence[str]]): An optional list of node names to interrupt before. diff --git a/libs/langgraph/langgraph/prebuilt/chat_agent_executor.py b/libs/langgraph/langgraph/prebuilt/chat_agent_executor.py index 1e2209bd7..c5c64cd24 100644 --- a/libs/langgraph/langgraph/prebuilt/chat_agent_executor.py +++ b/libs/langgraph/langgraph/prebuilt/chat_agent_executor.py @@ -16,13 +16,13 @@ from langchain_core.tools import BaseTool from langgraph._api.deprecation import deprecated_parameter -from langgraph.checkpoint.base import BaseCheckpointSaver from langgraph.graph import StateGraph from langgraph.graph.graph import CompiledGraph from langgraph.graph.message import add_messages from langgraph.managed import IsLastStep from langgraph.prebuilt.tool_executor import ToolExecutor from langgraph.prebuilt.tool_node import ToolNode +from langgraph.types import Checkpointer # We create the AgentState that we will pass around @@ -132,7 +132,7 @@ def create_react_agent( state_schema: Optional[StateSchemaType] = None, messages_modifier: Optional[MessagesModifier] = None, state_modifier: Optional[StateModifier] = None, - checkpointer: Optional[BaseCheckpointSaver] = None, + checkpointer: Checkpointer = None, interrupt_before: Optional[list[str]] = None, interrupt_after: Optional[list[str]] = None, debug: bool = False, diff --git a/libs/langgraph/langgraph/pregel/__init__.py b/libs/langgraph/langgraph/pregel/__init__.py index c9fec2e57..f78d072d6 100644 --- a/libs/langgraph/langgraph/pregel/__init__.py +++ b/libs/langgraph/langgraph/pregel/__init__.py @@ -87,7 +87,7 @@ from langgraph.pregel.validate import validate_graph, validate_keys from langgraph.pregel.write import ChannelWrite, ChannelWriteEntry from langgraph.store.base import BaseStore -from langgraph.types import All, StateSnapshot, StreamMode +from langgraph.types import All, Checkpointer, StateSnapshot, StreamMode from langgraph.utils.config import ( ensure_config, merge_configs, @@ -197,7 +197,7 @@ class Pregel(Runnable[Union[dict[str, Any], Any], Union[dict[str, Any], Any]]): debug: bool """Whether to print debug information during execution. Defaults to False.""" - checkpointer: Optional[BaseCheckpointSaver] = None + checkpointer: Checkpointer = None """Checkpointer used to save and load graph state. Defaults to None.""" store: Optional[BaseStore] = None @@ -281,7 +281,7 @@ def config_specs(self) -> list[ConfigurableFieldSpec]: [spec for node in self.nodes.values() for spec in node.config_specs] + ( self.checkpointer.config_specs - if self.checkpointer is not None + if isinstance(self.checkpointer, BaseCheckpointSaver) else [] ) + ( @@ -1059,6 +1059,8 @@ def _defaults( Union[All, Sequence[str]], Optional[BaseCheckpointSaver], ]: + if config["recursion_limit"] < 1: + raise ValueError("recursion_limit must be at least 1") debug = debug if debug is not None else self.debug if output_keys is None: output_keys = self.stream_channels_asis @@ -1072,12 +1074,16 @@ def _defaults( if CONFIG_KEY_TASK_ID in config.get("configurable", {}): # if being called as a node in another graph, always use values mode stream_mode = ["values"] - if CONFIG_KEY_CHECKPOINTER in config.get("configurable", {}): - checkpointer: Optional[BaseCheckpointSaver] = config["configurable"][ - CONFIG_KEY_CHECKPOINTER - ] + if self.checkpointer is False: + checkpointer: Optional[BaseCheckpointSaver] = None + elif CONFIG_KEY_CHECKPOINTER in config.get("configurable", {}): + checkpointer = config["configurable"][CONFIG_KEY_CHECKPOINTER] else: checkpointer = self.checkpointer + if checkpointer and not config.get("configurable"): + raise ValueError( + f"Checkpointer requires one or more of the following 'configurable' keys: {[s.id for s in checkpointer.config_specs]}" + ) return ( debug, set(stream_mode), @@ -1193,12 +1199,6 @@ def output() -> Iterator: run_id=config.get("run_id"), ) try: - if config["recursion_limit"] < 1: - raise ValueError("recursion_limit must be at least 1") - if self.checkpointer and not config.get("configurable"): - raise ValueError( - f"Checkpointer requires one or more of the following 'configurable' keys: {[s.id for s in self.checkpointer.config_specs]}" - ) # assign defaults ( debug, @@ -1414,12 +1414,6 @@ def output() -> Iterator: None, ) try: - if config["recursion_limit"] < 1: - raise ValueError("recursion_limit must be at least 1") - if self.checkpointer and not config.get("configurable"): - raise ValueError( - f"Checkpointer requires one or more of the following 'configurable' keys: {[s.id for s in self.checkpointer.config_specs]}" - ) # assign defaults ( debug, diff --git a/libs/langgraph/langgraph/pregel/algo.py b/libs/langgraph/langgraph/pregel/algo.py index 3c98a248b..f9b0096c8 100644 --- a/libs/langgraph/langgraph/pregel/algo.py +++ b/libs/langgraph/langgraph/pregel/algo.py @@ -30,7 +30,6 @@ from langgraph.constants import ( CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_CHECKPOINTER, - CONFIG_KEY_GRAPH_COUNT, CONFIG_KEY_READ, CONFIG_KEY_SEND, CONFIG_KEY_TASK_ID, @@ -430,7 +429,6 @@ def prepare_single_task( manager.get_child(f"graph:step:{step}") if manager else None ), configurable={ - CONFIG_KEY_GRAPH_COUNT: 0, CONFIG_KEY_TASK_ID: task_id, # deque.extend is thread-safe CONFIG_KEY_SEND: partial( @@ -541,7 +539,6 @@ def prepare_single_task( else None ), configurable={ - CONFIG_KEY_GRAPH_COUNT: 0, CONFIG_KEY_TASK_ID: task_id, # deque.extend is thread-safe CONFIG_KEY_SEND: partial( diff --git a/libs/langgraph/langgraph/pregel/loop.py b/libs/langgraph/langgraph/pregel/loop.py index a40b5f8f6..452103c9e 100644 --- a/libs/langgraph/langgraph/pregel/loop.py +++ b/libs/langgraph/langgraph/pregel/loop.py @@ -41,7 +41,6 @@ CONFIG_KEY_DEDUPE_TASKS, CONFIG_KEY_DELEGATE, CONFIG_KEY_ENSURE_LATEST, - CONFIG_KEY_GRAPH_COUNT, CONFIG_KEY_RESUMING, CONFIG_KEY_STREAM, CONFIG_KEY_TASK_ID, @@ -55,10 +54,12 @@ TASKS, ) from langgraph.errors import ( + _SEEN_CHECKPOINT_NS, CheckpointNotLatest, EmptyInputError, GraphDelegate, GraphInterrupt, + MultipleSubgraphsError, ) from langgraph.managed.base import ( ManagedValueMapping, @@ -221,12 +222,11 @@ def __init__( self.config = patch_configurable( self.config, {"checkpoint_ns": "", "checkpoint_id": None} ) - if self.is_nested: - if config["configurable"].get(CONFIG_KEY_GRAPH_COUNT, 0) > 0: - raise ValueError("Detected multiple subgraphs called in a single node.") + if self.is_nested and self.checkpointer is not None: + if self.config["configurable"]["checkpoint_ns"] in _SEEN_CHECKPOINT_NS: + raise MultipleSubgraphsError else: - # mutate config so that sibling subgraphs can be detected - self.config["configurable"][CONFIG_KEY_GRAPH_COUNT] = 1 + _SEEN_CHECKPOINT_NS.add(self.config["configurable"]["checkpoint_ns"]) if ( CONFIG_KEY_CHECKPOINT_MAP in self.config["configurable"] and self.config["configurable"].get("checkpoint_ns") diff --git a/libs/langgraph/langgraph/pregel/retry.py b/libs/langgraph/langgraph/pregel/retry.py index 476b8ef32..33c60d875 100644 --- a/libs/langgraph/langgraph/pregel/retry.py +++ b/libs/langgraph/langgraph/pregel/retry.py @@ -4,8 +4,8 @@ import time from typing import Optional, Sequence -from langgraph.constants import CONFIG_KEY_GRAPH_COUNT, CONFIG_KEY_RESUMING -from langgraph.errors import GraphInterrupt +from langgraph.constants import CONFIG_KEY_RESUMING +from langgraph.errors import _SEEN_CHECKPOINT_NS, GraphInterrupt from langgraph.types import PregelExecutableTask, RetryPolicy from langgraph.utils.config import patch_configurable @@ -70,9 +70,14 @@ def run_with_retry( exc_info=exc, ) # signal subgraphs to resume (if available) - config = patch_configurable( - config, {CONFIG_KEY_RESUMING: True, CONFIG_KEY_GRAPH_COUNT: 0} - ) + config = patch_configurable(config, {CONFIG_KEY_RESUMING: True}) + # clear checkpoint_ns seen (for subgraph detection) + if checkpoint_ns := config["configurable"].get("checkpoint_ns"): + _SEEN_CHECKPOINT_NS.discard(checkpoint_ns) + finally: + # clear checkpoint_ns seen (for subgraph detection) + if checkpoint_ns := config["configurable"].get("checkpoint_ns"): + _SEEN_CHECKPOINT_NS.discard(checkpoint_ns) async def arun_with_retry( @@ -138,6 +143,11 @@ async def arun_with_retry( exc_info=exc, ) # signal subgraphs to resume (if available) - config = patch_configurable( - config, {CONFIG_KEY_RESUMING: True, CONFIG_KEY_GRAPH_COUNT: 0} - ) + config = patch_configurable(config, {CONFIG_KEY_RESUMING: True}) + # clear checkpoint_ns seen (for subgraph detection) + if checkpoint_ns := config["configurable"].get("checkpoint_ns"): + _SEEN_CHECKPOINT_NS.discard(checkpoint_ns) + finally: + # clear checkpoint_ns seen (for subgraph detection) + if checkpoint_ns := config["configurable"].get("checkpoint_ns"): + _SEEN_CHECKPOINT_NS.discard(checkpoint_ns) diff --git a/libs/langgraph/langgraph/types.py b/libs/langgraph/langgraph/types.py index afbc98505..f8a8a74c6 100644 --- a/libs/langgraph/langgraph/types.py +++ b/libs/langgraph/langgraph/types.py @@ -1,12 +1,26 @@ from collections import deque from dataclasses import dataclass -from typing import Any, Callable, Literal, NamedTuple, Optional, Sequence, Type, Union +from typing import ( + Any, + Callable, + Literal, + NamedTuple, + Optional, + Sequence, + Type, + Union, +) from langchain_core.runnables import Runnable, RunnableConfig -from langgraph.checkpoint.base import CheckpointMetadata +from langgraph.checkpoint.base import BaseCheckpointSaver, CheckpointMetadata All = Literal["*"] +"""Special value to indicate that graph should interrupt on all nodes.""" + +Checkpointer = Union[None, Literal[False], BaseCheckpointSaver] +"""Type of the checkpointer to use for a subgraph. False disables checkpointing, +even if the parent graph has a checkpointer. None inherits checkpointer.""" StreamMode = Literal["values", "updates", "debug", "messages", "custom"] """How the stream method should emit outputs. diff --git a/libs/langgraph/tests/test_pregel.py b/libs/langgraph/tests/test_pregel.py index 1fa11ead2..18bccbe75 100644 --- a/libs/langgraph/tests/test_pregel.py +++ b/libs/langgraph/tests/test_pregel.py @@ -53,7 +53,7 @@ ) from langgraph.checkpoint.memory import MemorySaver from langgraph.constants import ERROR, PULL, PUSH -from langgraph.errors import InvalidUpdateError, NodeInterrupt +from langgraph.errors import InvalidUpdateError, MultipleSubgraphsError, NodeInterrupt from langgraph.graph import END, Graph from langgraph.graph.graph import START from langgraph.graph.message import MessageGraph, add_messages @@ -1861,7 +1861,12 @@ def test_invoke_two_processes_two_in_join_two_out(mocker: MockerFixture) -> None assert [*executor.map(app.invoke, [2] * 100)] == [[13, 13]] * 100 -def test_invoke_join_then_call_other_pregel(mocker: MockerFixture) -> None: +@pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_SYNC) +def test_invoke_join_then_call_other_pregel( + mocker: MockerFixture, request: pytest.FixtureRequest, checkpointer_name: str +) -> None: + checkpointer = request.getfixturevalue(f"checkpointer_{checkpointer_name}") + add_one = mocker.Mock(side_effect=lambda x: x + 1) add_10_each = mocker.Mock(side_effect=lambda x: [y + 10 for y in x]) @@ -1912,6 +1917,17 @@ def test_invoke_join_then_call_other_pregel(mocker: MockerFixture) -> None: with ThreadPoolExecutor() as executor: assert [*executor.map(app.invoke, [[2, 3]] * 10)] == [27] * 10 + # add checkpointer + app.checkpointer = checkpointer + # subgraph is called twice in the same node, through .map(), so raises + with pytest.raises(MultipleSubgraphsError): + app.invoke([2, 3], {"configurable": {"thread_id": "1"}}) + + # set inner graph checkpointer NeverCheckpoint + inner_app.checkpointer = False + # subgraph still called twice, but checkpointing for inner graph is disabled + assert app.invoke([2, 3], {"configurable": {"thread_id": "1"}}) == 27 + def test_invoke_two_processes_one_in_two_out(mocker: MockerFixture) -> None: add_one = mocker.Mock(side_effect=lambda x: x + 1) diff --git a/libs/langgraph/tests/test_pregel_async.py b/libs/langgraph/tests/test_pregel_async.py index 416c9ffe2..0bd9ed1f9 100644 --- a/libs/langgraph/tests/test_pregel_async.py +++ b/libs/langgraph/tests/test_pregel_async.py @@ -52,7 +52,7 @@ ) from langgraph.checkpoint.memory import MemorySaver from langgraph.constants import ERROR, PULL, PUSH -from langgraph.errors import InvalidUpdateError, NodeInterrupt +from langgraph.errors import InvalidUpdateError, MultipleSubgraphsError, NodeInterrupt from langgraph.graph import END, Graph, StateGraph from langgraph.graph.graph import START from langgraph.graph.message import MessageGraph, add_messages @@ -2080,7 +2080,10 @@ async def test_invoke_two_processes_two_in_join_two_out(mocker: MockerFixture) - ] -async def test_invoke_join_then_call_other_pregel(mocker: MockerFixture) -> None: +@pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_ASYNC) +async def test_invoke_join_then_call_other_pregel( + mocker: MockerFixture, checkpointer_name: str +) -> None: add_one = mocker.Mock(side_effect=lambda x: x + 1) add_10_each = mocker.Mock(side_effect=lambda x: [y + 10 for y in x]) @@ -2133,6 +2136,18 @@ async def test_invoke_join_then_call_other_pregel(mocker: MockerFixture) -> None 27 for _ in range(10) ] + async with awith_checkpointer(checkpointer_name) as checkpointer: + # add checkpointer + app.checkpointer = checkpointer + # subgraph is called twice in the same node, through .map(), so raises + with pytest.raises(MultipleSubgraphsError): + await app.ainvoke([2, 3], {"configurable": {"thread_id": "1"}}) + + # set inner graph checkpointer NeverCheckpoint + inner_app.checkpointer = False + # subgraph still called twice, but checkpointing for inner graph is disabled + assert await app.ainvoke([2, 3], {"configurable": {"thread_id": "1"}}) == 27 + async def test_invoke_two_processes_one_in_two_out(mocker: MockerFixture) -> None: add_one = mocker.Mock(side_effect=lambda x: x + 1) From 644f14991e71ea0e5e8cf24155dd0dc6af41eb87 Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Sun, 22 Sep 2024 12:04:17 -0700 Subject: [PATCH 11/14] Fix kfka --- libs/langgraph/langgraph/pregel/loop.py | 7 ++++++- .../langgraph/scheduler/kafka/orchestrator.py | 1 + 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/libs/langgraph/langgraph/pregel/loop.py b/libs/langgraph/langgraph/pregel/loop.py index 452103c9e..45b8798af 100644 --- a/libs/langgraph/langgraph/pregel/loop.py +++ b/libs/langgraph/langgraph/pregel/loop.py @@ -197,6 +197,7 @@ def __init__( specs: Mapping[str, Union[BaseChannel, ManagedValueSpec]], output_keys: Union[str, Sequence[str]], stream_keys: Union[str, Sequence[str]], + check_subgraphs: bool = True, debug: bool = False, ) -> None: self.stream = stream @@ -222,7 +223,7 @@ def __init__( self.config = patch_configurable( self.config, {"checkpoint_ns": "", "checkpoint_id": None} ) - if self.is_nested and self.checkpointer is not None: + if check_subgraphs and self.is_nested and self.checkpointer is not None: if self.config["configurable"]["checkpoint_ns"] in _SEEN_CHECKPOINT_NS: raise MultipleSubgraphsError else: @@ -641,6 +642,7 @@ def __init__( specs: Mapping[str, Union[BaseChannel, ManagedValueSpec]], output_keys: Union[str, Sequence[str]] = EMPTY_SEQ, stream_keys: Union[str, Sequence[str]] = EMPTY_SEQ, + check_subgraphs: bool = True, debug: bool = False, ) -> None: super().__init__( @@ -653,6 +655,7 @@ def __init__( specs=specs, output_keys=output_keys, stream_keys=stream_keys, + check_subgraphs=check_subgraphs, debug=debug, ) self.stack = ExitStack() @@ -762,6 +765,7 @@ def __init__( specs: Mapping[str, Union[BaseChannel, ManagedValueSpec]], output_keys: Union[str, Sequence[str]] = EMPTY_SEQ, stream_keys: Union[str, Sequence[str]] = EMPTY_SEQ, + check_subgraphs: bool = True, debug: bool = False, ) -> None: super().__init__( @@ -774,6 +778,7 @@ def __init__( specs=specs, output_keys=output_keys, stream_keys=stream_keys, + check_subgraphs=check_subgraphs, debug=debug, ) self.store = AsyncBatchedStore(self.store) if self.store else None diff --git a/libs/scheduler-kafka/langgraph/scheduler/kafka/orchestrator.py b/libs/scheduler-kafka/langgraph/scheduler/kafka/orchestrator.py index 097429bb6..a94a3bd0a 100644 --- a/libs/scheduler-kafka/langgraph/scheduler/kafka/orchestrator.py +++ b/libs/scheduler-kafka/langgraph/scheduler/kafka/orchestrator.py @@ -158,6 +158,7 @@ async def attempt(self, msg: MessageToOrchestrator) -> None: specs=graph.channels, output_keys=graph.output_channels, stream_keys=graph.stream_channels, + check_subgraphs=False, ) as loop: if loop.tick( input_keys=graph.input_channels, From 74f34db9e453df4097280262e54c9eb992f2a1e0 Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Sun, 22 Sep 2024 12:04:43 -0700 Subject: [PATCH 12/14] Fix sync kafka --- libs/scheduler-kafka/langgraph/scheduler/kafka/orchestrator.py | 1 + 1 file changed, 1 insertion(+) diff --git a/libs/scheduler-kafka/langgraph/scheduler/kafka/orchestrator.py b/libs/scheduler-kafka/langgraph/scheduler/kafka/orchestrator.py index a94a3bd0a..39e7b755b 100644 --- a/libs/scheduler-kafka/langgraph/scheduler/kafka/orchestrator.py +++ b/libs/scheduler-kafka/langgraph/scheduler/kafka/orchestrator.py @@ -348,6 +348,7 @@ def attempt(self, msg: MessageToOrchestrator) -> None: specs=graph.channels, output_keys=graph.output_channels, stream_keys=graph.stream_channels, + check_subgraphs=False, ) as loop: if loop.tick( input_keys=graph.input_channels, From e76f49c7f0eb3b9cff9d5641384a441b5a121c67 Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Sun, 22 Sep 2024 12:37:24 -0700 Subject: [PATCH 13/14] Fix flaky test --- libs/langgraph/tests/any_str.py | 17 +++++++++++++++++ libs/langgraph/tests/test_pregel.py | 12 ++++++------ libs/langgraph/tests/test_pregel_async.py | 12 ++++++------ 3 files changed, 29 insertions(+), 12 deletions(-) diff --git a/libs/langgraph/tests/any_str.py b/libs/langgraph/tests/any_str.py index 9a1977a8c..5995d0e52 100644 --- a/libs/langgraph/tests/any_str.py +++ b/libs/langgraph/tests/any_str.py @@ -2,6 +2,23 @@ from typing import Any, Sequence, Union +class FloatBetween(float): + def __init__(self, min_value: float, max_value: float) -> None: + super().__init__() + self.min_value = min_value + self.max_value = max_value + + def __eq__(self, other: object) -> bool: + return ( + isinstance(other, float) + and other >= self.min_value + and other <= self.max_value + ) + + def __hash__(self) -> int: + return hash((float(self), self.min_value, self.max_value)) + + class AnyStr(str): def __init__(self, prefix: Union[str, re.Pattern] = "") -> None: super().__init__() diff --git a/libs/langgraph/tests/test_pregel.py b/libs/langgraph/tests/test_pregel.py index 18bccbe75..605f00747 100644 --- a/libs/langgraph/tests/test_pregel.py +++ b/libs/langgraph/tests/test_pregel.py @@ -72,7 +72,7 @@ from langgraph.pregel.retry import RetryPolicy from langgraph.store.memory import MemoryStore from langgraph.types import Interrupt, PregelTask, Send, StreamWriter -from tests.any_str import AnyDict, AnyStr, AnyVersion, UnsortedSequence +from tests.any_str import AnyDict, AnyStr, AnyVersion, FloatBetween, UnsortedSequence from tests.conftest import ALL_CHECKPOINTERS_SYNC, SHOULD_CHECK_SNAPSHOTS from tests.fake_chat import FakeChatModel from tests.fake_tracer import FakeTracer @@ -8596,22 +8596,22 @@ def outer_2(state: State): assert chunks == [ # arrives before "inner" finishes ( - 0.0, + FloatBetween(0.0, 0.1), ( (AnyStr("inner:"),), {"inner_1": {"my_key": "got here", "my_other_key": ""}}, ), ), - (0.2, ((), {"outer_1": {"my_key": " and parallel"}})), + (FloatBetween(0.2, 0.3), ((), {"outer_1": {"my_key": " and parallel"}})), ( - 0.5, + FloatBetween(0.5, 0.6), ( (AnyStr("inner:"),), {"inner_2": {"my_key": " and there", "my_other_key": "got here"}}, ), ), - (0.5, ((), {"inner": {"my_key": "got here and there"}})), - (0.5, ((), {"outer_2": {"my_key": " and back again"}})), + (FloatBetween(0.5, 0.6), ((), {"inner": {"my_key": "got here and there"}})), + (FloatBetween(0.5, 0.6), ((), {"outer_2": {"my_key": " and back again"}})), ] diff --git a/libs/langgraph/tests/test_pregel_async.py b/libs/langgraph/tests/test_pregel_async.py index 0bd9ed1f9..d17925aca 100644 --- a/libs/langgraph/tests/test_pregel_async.py +++ b/libs/langgraph/tests/test_pregel_async.py @@ -70,7 +70,7 @@ from langgraph.pregel.retry import RetryPolicy from langgraph.store.memory import MemoryStore from langgraph.types import Interrupt, PregelTask, Send, StreamWriter -from tests.any_str import AnyDict, AnyStr, AnyVersion, UnsortedSequence +from tests.any_str import AnyDict, AnyStr, AnyVersion, FloatBetween, UnsortedSequence from tests.conftest import ( ALL_CHECKPOINTERS_ASYNC, ALL_CHECKPOINTERS_ASYNC_PLUS_NONE, @@ -7202,22 +7202,22 @@ async def outer_2(state: State): assert chunks == [ # arrives before "inner" finishes ( - 0.0, + FloatBetween(0.0, 0.1), ( (AnyStr("inner:"),), {"inner_1": {"my_key": "got here", "my_other_key": ""}}, ), ), - (0.2, ((), {"outer_1": {"my_key": " and parallel"}})), + (FloatBetween(0.2, 0.3), ((), {"outer_1": {"my_key": " and parallel"}})), ( - 0.5, + FloatBetween(0.5, 0.6), ( (AnyStr("inner:"),), {"inner_2": {"my_key": " and there", "my_other_key": "got here"}}, ), ), - (0.5, ((), {"inner": {"my_key": "got here and there"}})), - (0.5, ((), {"outer_2": {"my_key": " and back again"}})), + (FloatBetween(0.5, 0.6), ((), {"inner": {"my_key": "got here and there"}})), + (FloatBetween(0.5, 0.6), ((), {"outer_2": {"my_key": " and back again"}})), ] From 84a45d186c22fa32fa4352a7317950406e1cb883 Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Sun, 22 Sep 2024 12:42:34 -0700 Subject: [PATCH 14/14] Fix --- libs/langgraph/tests/any_str.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/libs/langgraph/tests/any_str.py b/libs/langgraph/tests/any_str.py index 5995d0e52..5643a00fb 100644 --- a/libs/langgraph/tests/any_str.py +++ b/libs/langgraph/tests/any_str.py @@ -1,8 +1,13 @@ import re from typing import Any, Sequence, Union +from typing_extensions import Self + class FloatBetween(float): + def __new__(cls, min_value: float, max_value: float) -> Self: + return super().__new__(cls, min_value) + def __init__(self, min_value: float, max_value: float) -> None: super().__init__() self.min_value = min_value