langchain-core 1.0.0a6__py3-none-any.whl → 1.0.0a8__py3-none-any.whl

langchain_core/runnables/fallbacks.py

@@ -5,7 +5,7 @@ import inspect
 import typing
 from collections.abc import AsyncIterator, Iterator, Sequence
 from functools import wraps
-from typing import TYPE_CHECKING, Any, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, cast
 
 from pydantic import BaseModel, ConfigDict
 from typing_extensions import override
@@ -51,41 +51,39 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
     more convenient to use the ``with_fallbacks`` method on a Runnable.
 
     Example:
+        ```python
+        from langchain_core.chat_models.openai import ChatOpenAI
+        from langchain_core.chat_models.anthropic import ChatAnthropic
 
-        .. code-block:: python
-
-            from langchain_core.chat_models.openai import ChatOpenAI
-            from langchain_core.chat_models.anthropic import ChatAnthropic
-
-            model = ChatAnthropic(model="claude-3-haiku-20240307").with_fallbacks(
-                [ChatOpenAI(model="gpt-3.5-turbo-0125")]
-            )
-            # Will usually use ChatAnthropic, but fallback to ChatOpenAI
-            # if ChatAnthropic fails.
-            model.invoke("hello")
-
-            # And you can also use fallbacks at the level of a chain.
-            # Here if both LLM providers fail, we'll fallback to a good hardcoded
-            # response.
+        model = ChatAnthropic(model="claude-3-haiku-20240307").with_fallbacks(
+            [ChatOpenAI(model="gpt-3.5-turbo-0125")]
+        )
+        # Will usually use ChatAnthropic, but fallback to ChatOpenAI
+        # if ChatAnthropic fails.
+        model.invoke("hello")
 
-            from langchain_core.prompts import PromptTemplate
-            from langchain_core.output_parser import StrOutputParser
-            from langchain_core.runnables import RunnableLambda
+        # And you can also use fallbacks at the level of a chain.
+        # Here if both LLM providers fail, we'll fallback to a good hardcoded
+        # response.
 
+        from langchain_core.prompts import PromptTemplate
+        from langchain_core.output_parser import StrOutputParser
+        from langchain_core.runnables import RunnableLambda
 
-            def when_all_is_lost(inputs):
-                return (
-                    "Looks like our LLM providers are down. "
-                    "Here's a nice 🦜️ emoji for you instead."
-                )
 
+        def when_all_is_lost(inputs):
+            return (
+                "Looks like our LLM providers are down. "
+                "Here's a nice 🦜️ emoji for you instead."
+            )
 
-            chain_with_fallback = (
-                PromptTemplate.from_template("Tell me a joke about {topic}")
-                | model
-                | StrOutputParser()
-            ).with_fallbacks([RunnableLambda(when_all_is_lost)])
 
+        chain_with_fallback = (
+            PromptTemplate.from_template("Tell me a joke about {topic}")
+            | model
+            | StrOutputParser()
+        ).with_fallbacks([RunnableLambda(when_all_is_lost)])
+        ```
     """
 
     runnable: Runnable[Input, Output]
@@ -97,7 +95,7 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
 
     Any exception that is not a subclass of these exceptions will be raised immediately.
     """
-    exception_key: Optional[str] = None
+    exception_key: str | None = None
     """If string is specified then handled exceptions will be passed to fallbacks as
         part of the input under the specified key. If None, exceptions
         will not be passed to fallbacks. If used, the base Runnable and its fallbacks
@@ -118,14 +116,12 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
         return self.runnable.OutputType
 
     @override
-    def get_input_schema(
-        self, config: Optional[RunnableConfig] = None
-    ) -> type[BaseModel]:
+    def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
         return self.runnable.get_input_schema(config)
 
     @override
     def get_output_schema(
-        self, config: Optional[RunnableConfig] = None
+        self, config: RunnableConfig | None = None
     ) -> type[BaseModel]:
         return self.runnable.get_output_schema(config)
 
@@ -166,7 +162,7 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
 
     @override
     def invoke(
-        self, input: Input, config: Optional[RunnableConfig] = None, **kwargs: Any
+        self, input: Input, config: RunnableConfig | None = None, **kwargs: Any
     ) -> Output:
         if self.exception_key is not None and not isinstance(input, dict):
             msg = (
@@ -218,8 +214,8 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
     async def ainvoke(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Output:
         if self.exception_key is not None and not isinstance(input, dict):
             msg = (
@@ -268,10 +264,10 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
     def batch(
         self,
         inputs: list[Input],
-        config: Optional[Union[RunnableConfig, list[RunnableConfig]]] = None,
+        config: RunnableConfig | list[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
-        **kwargs: Optional[Any],
+        **kwargs: Any | None,
     ) -> list[Output]:
         if self.exception_key is not None and not all(
             isinstance(input_, dict) for input_ in inputs
@@ -307,7 +303,9 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
                 name=config.get("run_name") or self.get_name(),
                 run_id=config.pop("run_id", None),
             )
-            for cm, input_, config in zip(callback_managers, inputs, configs)
+            for cm, input_, config in zip(
+                callback_managers, inputs, configs, strict=False
+            )
         ]
 
         to_return: dict[int, Any] = {}
@@ -325,7 +323,9 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
                 return_exceptions=True,
                 **kwargs,
             )
-            for (i, input_), output in zip(sorted(run_again.copy().items()), outputs):
+            for (i, input_), output in zip(
+                sorted(run_again.copy().items()), outputs, strict=False
+            ):
                 if isinstance(output, BaseException) and not isinstance(
                     output, self.exceptions_to_handle
                 ):
@@ -360,10 +360,10 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
     async def abatch(
         self,
         inputs: list[Input],
-        config: Optional[Union[RunnableConfig, list[RunnableConfig]]] = None,
+        config: RunnableConfig | list[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
-        **kwargs: Optional[Any],
+        **kwargs: Any | None,
     ) -> list[Output]:
         if self.exception_key is not None and not all(
             isinstance(input_, dict) for input_ in inputs
@@ -400,11 +400,13 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
                     name=config.get("run_name") or self.get_name(),
                     run_id=config.pop("run_id", None),
                 )
-                for cm, input_, config in zip(callback_managers, inputs, configs)
+                for cm, input_, config in zip(
+                    callback_managers, inputs, configs, strict=False
+                )
             )
         )
 
-        to_return: dict[int, Union[Output, BaseException]] = {}
+        to_return: dict[int, Output | BaseException] = {}
         run_again = dict(enumerate(inputs))
         handled_exceptions: dict[int, BaseException] = {}
         first_to_raise = None
@@ -420,7 +422,9 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
                 **kwargs,
             )
 
-            for (i, input_), output in zip(sorted(run_again.copy().items()), outputs):
+            for (i, input_), output in zip(
+                sorted(run_again.copy().items()), outputs, strict=False
+            ):
                 if isinstance(output, BaseException) and not isinstance(
                     output, self.exceptions_to_handle
                 ):
@@ -460,8 +464,8 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
     def stream(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Iterator[Output]:
         if self.exception_key is not None and not isinstance(input, dict):
             msg = (
@@ -507,7 +511,7 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
             raise first_error
 
         yield chunk
-        output: Optional[Output] = chunk
+        output: Output | None = chunk
         try:
             for chunk in stream:
                 yield chunk
@@ -524,8 +528,8 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
     async def astream(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> AsyncIterator[Output]:
         if self.exception_key is not None and not isinstance(input, dict):
             msg = (
@@ -571,7 +575,7 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
             raise first_error
 
         yield chunk
-        output: Optional[Output] = chunk
+        output: Output | None = chunk
         try:
             async for chunk in stream:
                 yield chunk
@@ -595,27 +599,27 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
             self.fallbacks is replaced with getattr(x, name).
 
         Example:
-            .. code-block:: python
-
-                from langchain_openai import ChatOpenAI
-                from langchain_anthropic import ChatAnthropic
-
-                gpt_4o = ChatOpenAI(model="gpt-4o")
-                claude_3_sonnet = ChatAnthropic(model="claude-3-7-sonnet-20250219")
-                llm = gpt_4o.with_fallbacks([claude_3_sonnet])
-
-                llm.model_name
-                # -> "gpt-4o"
-
-                # .bind_tools() is called on both ChatOpenAI and ChatAnthropic
-                # Equivalent to:
-                # gpt_4o.bind_tools([...]).with_fallbacks([claude_3_sonnet.bind_tools([...])])
-                llm.bind_tools([...])
-                # -> RunnableWithFallbacks(
-                    runnable=RunnableBinding(bound=ChatOpenAI(...), kwargs={"tools": [...]}),
-                    fallbacks=[RunnableBinding(bound=ChatAnthropic(...), kwargs={"tools": [...]})],
-                )
+            ```python
+            from langchain_openai import ChatOpenAI
+            from langchain_anthropic import ChatAnthropic
+
+            gpt_4o = ChatOpenAI(model="gpt-4o")
+            claude_3_sonnet = ChatAnthropic(model="claude-3-7-sonnet-20250219")
+            llm = gpt_4o.with_fallbacks([claude_3_sonnet])
+
+            llm.model_name
+            # -> "gpt-4o"
+
+            # .bind_tools() is called on both ChatOpenAI and ChatAnthropic
+            # Equivalent to:
+            # gpt_4o.bind_tools([...]).with_fallbacks([claude_3_sonnet.bind_tools([...])])
+            llm.bind_tools([...])
+            # -> RunnableWithFallbacks(
+                runnable=RunnableBinding(bound=ChatOpenAI(...), kwargs={"tools": [...]}),
+                fallbacks=[RunnableBinding(bound=ChatAnthropic(...), kwargs={"tools": [...]})],
+            )
 
+            ```
         """  # noqa: E501
         attr = getattr(self.runnable, name)
         if _returns_runnable(attr):

langchain_core/runnables/graph.py

@@ -4,17 +4,15 @@ from __future__ import annotations
 
 import inspect
 from collections import defaultdict
+from collections.abc import Callable
 from dataclasses import dataclass, field
 from enum import Enum
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     NamedTuple,
-    Optional,
     Protocol,
     TypedDict,
-    Union,
     overload,
 )
 from uuid import UUID, uuid4
@@ -70,14 +68,12 @@ class Edge(NamedTuple):
     """The source node id."""
     target: str
     """The target node id."""
-    data: Optional[Stringifiable] = None
+    data: Stringifiable | None = None
     """Optional data associated with the edge. Defaults to None."""
     conditional: bool = False
     """Whether the edge is conditional. Defaults to False."""
 
-    def copy(
-        self, *, source: Optional[str] = None, target: Optional[str] = None
-    ) -> Edge:
+    def copy(self, *, source: str | None = None, target: str | None = None) -> Edge:
         """Return a copy of the edge with optional new source and target nodes.
 
         Args:
@@ -102,16 +98,16 @@ class Node(NamedTuple):
     """The unique identifier of the node."""
     name: str
     """The name of the node."""
-    data: Union[type[BaseModel], RunnableType, None]
+    data: type[BaseModel] | RunnableType | None
     """The data of the node."""
-    metadata: Optional[dict[str, Any]]
+    metadata: dict[str, Any] | None
     """Optional metadata for the node. Defaults to None."""
 
     def copy(
         self,
         *,
-        id: Optional[str] = None,
-        name: Optional[str] = None,
+        id: str | None = None,
+        name: str | None = None,
     ) -> Node:
         """Return a copy of the node with optional new id and name.
 
@@ -135,7 +131,7 @@ class Branch(NamedTuple):
 
     condition: Callable[..., str]
     """A callable that returns a string representation of the condition."""
-    ends: Optional[dict[str, str]]
+    ends: dict[str, str] | None
     """Optional dictionary of end node ids for the branches. Defaults to None."""
 
 
@@ -182,7 +178,7 @@ class MermaidDrawMethod(Enum):
 
 def node_data_str(
     id: str,
-    data: Union[type[BaseModel], RunnableType, None],
+    data: type[BaseModel] | RunnableType | None,
 ) -> str:
     """Convert the data of a node to a string.
 
@@ -201,7 +197,7 @@ def node_data_str(
 
 def node_data_json(
     node: Node, *, with_schemas: bool = False
-) -> dict[str, Union[str, dict[str, Any]]]:
+) -> dict[str, str | dict[str, Any]]:
     """Convert the data of a node to a JSON-serializable format.
 
     Args:
@@ -316,10 +312,10 @@ class Graph:
 
     def add_node(
         self,
-        data: Union[type[BaseModel], RunnableType, None],
-        id: Optional[str] = None,
+        data: type[BaseModel] | RunnableType | None,
+        id: str | None = None,
         *,
-        metadata: Optional[dict[str, Any]] = None,
+        metadata: dict[str, Any] | None = None,
     ) -> Node:
         """Add a node to the graph and return it.
 
@@ -357,7 +353,7 @@ class Graph:
         self,
         source: Node,
         target: Node,
-        data: Optional[Stringifiable] = None,
+        data: Stringifiable | None = None,
         conditional: bool = False,  # noqa: FBT001,FBT002
     ) -> Edge:
         """Add an edge to the graph and return it.
@@ -388,7 +384,7 @@ class Graph:
 
     def extend(
         self, graph: Graph, *, prefix: str = ""
-    ) -> tuple[Optional[Node], Optional[Node]]:
+    ) -> tuple[Node | None, Node | None]:
         """Add all nodes and edges from another graph.
 
         Note this doesn't check for duplicates, nor does it connect the graphs.
@@ -459,7 +455,7 @@ class Graph:
             ],
         )
 
-    def first_node(self) -> Optional[Node]:
+    def first_node(self) -> Node | None:
         """Find the single node that is not a target of any edge.
 
         If there is no such node, or there are multiple, return None.
@@ -471,7 +467,7 @@ class Graph:
         """
         return _first_node(self)
 
-    def last_node(self) -> Optional[Node]:
+    def last_node(self) -> Node | None:
         """Find the single node that is not a source of any edge.
 
         If there is no such node, or there are multiple, return None.
@@ -531,24 +527,24 @@ class Graph:
     def draw_png(
         self,
         output_file_path: str,
-        fontname: Optional[str] = None,
-        labels: Optional[LabelsDict] = None,
+        fontname: str | None = None,
+        labels: LabelsDict | None = None,
     ) -> None: ...
 
     @overload
     def draw_png(
         self,
         output_file_path: None,
-        fontname: Optional[str] = None,
-        labels: Optional[LabelsDict] = None,
+        fontname: str | None = None,
+        labels: LabelsDict | None = None,
     ) -> bytes: ...
 
     def draw_png(
         self,
-        output_file_path: Optional[str] = None,
-        fontname: Optional[str] = None,
-        labels: Optional[LabelsDict] = None,
-    ) -> Union[bytes, None]:
+        output_file_path: str | None = None,
+        fontname: str | None = None,
+        labels: LabelsDict | None = None,
+    ) -> bytes | None:
         """Draw the graph as a PNG image.
 
         Args:
@@ -581,9 +577,9 @@ class Graph:
         *,
         with_styles: bool = True,
         curve_style: CurveStyle = CurveStyle.LINEAR,
-        node_colors: Optional[NodeStyles] = None,
+        node_colors: NodeStyles | None = None,
         wrap_label_n_words: int = 9,
-        frontmatter_config: Optional[dict[str, Any]] = None,
+        frontmatter_config: dict[str, Any] | None = None,
     ) -> str:
         """Draw the graph as a Mermaid syntax string.
 
@@ -601,17 +597,15 @@ class Graph:
 
                 Example config:
 
-                .. code-block:: python
-
+                ```python
                 {
                     "config": {
                         "theme": "neutral",
                         "look": "handDrawn",
-                        "themeVariables": { "primaryColor": "#e2e2e2"},
+                        "themeVariables": {"primaryColor": "#e2e2e2"},
                     }
                 }
-
-
+                ```
         Returns:
             The Mermaid syntax string.
         """
@@ -638,16 +632,16 @@ class Graph:
         self,
         *,
         curve_style: CurveStyle = CurveStyle.LINEAR,
-        node_colors: Optional[NodeStyles] = None,
+        node_colors: NodeStyles | None = None,
         wrap_label_n_words: int = 9,
-        output_file_path: Optional[str] = None,
+        output_file_path: str | None = None,
         draw_method: MermaidDrawMethod = MermaidDrawMethod.API,
         background_color: str = "white",
         padding: int = 10,
         max_retries: int = 1,
         retry_delay: float = 1.0,
-        frontmatter_config: Optional[dict[str, Any]] = None,
-        base_url: Optional[str] = None,
+        frontmatter_config: dict[str, Any] | None = None,
+        base_url: str | None = None,
     ) -> bytes:
         """Draw the graph as a PNG image using Mermaid.
 
@@ -674,15 +668,15 @@ class Graph:
 
                 Example config:
 
-                .. code-block:: python
-
+                ```python
                 {
                     "config": {
                         "theme": "neutral",
                         "look": "handDrawn",
-                        "themeVariables": { "primaryColor": "#e2e2e2"},
+                        "themeVariables": {"primaryColor": "#e2e2e2"},
                     }
                 }
+                ```
             base_url: The base URL of the Mermaid server for rendering via API.
                 Defaults to None.
 
@@ -713,7 +707,7 @@ class Graph:
         )
 
 
-def _first_node(graph: Graph, exclude: Sequence[str] = ()) -> Optional[Node]:
+def _first_node(graph: Graph, exclude: Sequence[str] = ()) -> Node | None:
     """Find the single node that is not a target of any edge.
 
     Exclude nodes/sources with ids in the exclude list.
@@ -729,7 +723,7 @@ def _first_node(graph: Graph, exclude: Sequence[str] = ()) -> Optional[Node]:
     return found[0] if len(found) == 1 else None
 
 
-def _last_node(graph: Graph, exclude: Sequence[str] = ()) -> Optional[Node]:
+def _last_node(graph: Graph, exclude: Sequence[str] = ()) -> Node | None:
     """Find the single node that is not a source of any edge.
 
     Exclude nodes/targets with ids in the exclude list.

langchain_core/runnables/graph_ascii.py

@@ -255,20 +255,18 @@ def draw_ascii(vertices: Mapping[str, str], edges: Sequence[LangEdge]) -> str:
         ASCII representation
 
     Example:
+        ```python
+        from langchain_core.runnables.graph_ascii import draw_ascii
 
-        .. code-block:: python
+        vertices = {1: "1", 2: "2", 3: "3", 4: "4"}
+        edges = [
+            (source, target, None, None)
+            for source, target in [(1, 2), (2, 3), (2, 4), (1, 4)]
+        ]
 
-            from langchain_core.runnables.graph_ascii import draw_ascii
-
-            vertices = {1: "1", 2: "2", 3: "3", 4: "4"}
-            edges = [
-                (source, target, None, None)
-                for source, target in [(1, 2), (2, 3), (2, 4), (1, 4)]
-            ]
-
-
-            print(draw_ascii(vertices, edges))
 
+        print(draw_ascii(vertices, edges))
+        ```
         .. code-block::
 
                  +---+

langchain_core/runnables/graph_mermaid.py

@@ -10,7 +10,7 @@ import string
 import time
 from dataclasses import asdict
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, Optional
+from typing import TYPE_CHECKING, Any, Literal
 
 import yaml
 
@@ -45,13 +45,13 @@ def draw_mermaid(
     nodes: dict[str, Node],
     edges: list[Edge],
     *,
-    first_node: Optional[str] = None,
-    last_node: Optional[str] = None,
+    first_node: str | None = None,
+    last_node: str | None = None,
     with_styles: bool = True,
     curve_style: CurveStyle = CurveStyle.LINEAR,
-    node_styles: Optional[NodeStyles] = None,
+    node_styles: NodeStyles | None = None,
     wrap_label_n_words: int = 9,
-    frontmatter_config: Optional[dict[str, Any]] = None,
+    frontmatter_config: dict[str, Any] | None = None,
 ) -> str:
     """Draws a Mermaid graph using the provided graph data.
 
@@ -77,16 +77,15 @@ def draw_mermaid(
 
             Example config:
 
-            .. code-block:: python
-
+            ```python
             {
                 "config": {
                     "theme": "neutral",
                     "look": "handDrawn",
-                    "themeVariables": { "primaryColor": "#e2e2e2"},
+                    "themeVariables": {"primaryColor": "#e2e2e2"},
                 }
             }
-
+            ```
     Returns:
         str: Mermaid graph syntax.
 
@@ -164,7 +163,7 @@ def draw_mermaid(
         src_parts = edge.source.split(":")
         tgt_parts = edge.target.split(":")
         common_prefix = ":".join(
-            src for src, tgt in zip(src_parts, tgt_parts) if src == tgt
+            src for src, tgt in zip(src_parts, tgt_parts, strict=False) if src == tgt
         )
         edge_groups.setdefault(common_prefix, []).append(edge)
 
@@ -280,13 +279,13 @@ def _generate_mermaid_graph_styles(node_colors: NodeStyles) -> str:
 
 def draw_mermaid_png(
     mermaid_syntax: str,
-    output_file_path: Optional[str] = None,
+    output_file_path: str | None = None,
     draw_method: MermaidDrawMethod = MermaidDrawMethod.API,
-    background_color: Optional[str] = "white",
+    background_color: str | None = "white",
     padding: int = 10,
     max_retries: int = 1,
     retry_delay: float = 1.0,
-    base_url: Optional[str] = None,
+    base_url: str | None = None,
 ) -> bytes:
     """Draws a Mermaid graph as PNG using provided syntax.
 
@@ -340,8 +339,8 @@ def draw_mermaid_png(
 
 async def _render_mermaid_using_pyppeteer(
     mermaid_syntax: str,
-    output_file_path: Optional[str] = None,
-    background_color: Optional[str] = "white",
+    output_file_path: str | None = None,
+    background_color: str | None = "white",
     padding: int = 10,
     device_scale_factor: int = 3,
 ) -> bytes:
@@ -412,12 +411,12 @@ async def _render_mermaid_using_pyppeteer(
 def _render_mermaid_using_api(
     mermaid_syntax: str,
     *,
-    output_file_path: Optional[str] = None,
-    background_color: Optional[str] = "white",
-    file_type: Optional[Literal["jpeg", "png", "webp"]] = "png",
+    output_file_path: str | None = None,
+    background_color: str | None = "white",
+    file_type: Literal["jpeg", "png", "webp"] | None = "png",
     max_retries: int = 1,
     retry_delay: float = 1.0,
-    base_url: Optional[str] = None,
+    base_url: str | None = None,
 ) -> bytes:
     """Renders Mermaid graph using the Mermaid.INK API."""
     # Defaults to using the public mermaid.ink server.