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

langchain_core/utils/function_calling.py

@@ -8,13 +8,12 @@ import logging
 import types
 import typing
 import uuid
+from collections.abc import Callable
 from typing import (
     TYPE_CHECKING,
     Annotated,
     Any,
-    Callable,
     Literal,
-    Optional,
     Union,
     cast,
     get_args,
@@ -103,8 +102,8 @@ def _rm_titles(kv: dict, prev_key: str = "") -> dict:
 def _convert_json_schema_to_openai_function(
     schema: dict,
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
     rm_titles: bool = True,
 ) -> FunctionDescription:
     """Converts a Pydantic model to a function description for the OpenAI API.
@@ -137,8 +136,8 @@ def _convert_json_schema_to_openai_function(
 def _convert_pydantic_to_openai_function(
     model: type,
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
     rm_titles: bool = True,
 ) -> FunctionDescription:
     """Converts a Pydantic model to a function description for the OpenAI API.
@@ -184,8 +183,8 @@ convert_pydantic_to_openai_function = deprecated(
 def convert_pydantic_to_openai_tool(
     model: type[BaseModel],
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
 ) -> ToolDescription:
     """Converts a Pydantic model to a function description for the OpenAI API.
 
@@ -285,7 +284,9 @@ def _convert_any_typed_dicts_to_pydantic(
                 new_arg_type = _convert_any_typed_dicts_to_pydantic(
                     annotated_args[0], depth=depth + 1, visited=visited
                 )
-                field_kwargs = dict(zip(("default", "description"), annotated_args[1:]))
+                field_kwargs = dict(
+                    zip(("default", "description"), annotated_args[1:], strict=False)
+                )
                 if (field_desc := field_kwargs.get("description")) and not isinstance(
                     field_desc, str
                 ):
@@ -393,9 +394,9 @@ def format_tool_to_openai_tool(tool: BaseTool) -> ToolDescription:
 
 
 def convert_to_openai_function(
-    function: Union[dict[str, Any], type, Callable, BaseTool],
+    function: dict[str, Any] | type | Callable | BaseTool,
     *,
-    strict: Optional[bool] = None,
+    strict: bool | None = None,
 ) -> dict[str, Any]:
     """Convert a raw function/class to an OpenAI function.
 
@@ -418,20 +419,16 @@ def convert_to_openai_function(
     Raises:
         ValueError: If function is not in a supported format.
 
-    .. versionchanged:: 0.2.29
-
+    !!! warning "Behavior changed in 0.2.29"
         ``strict`` arg added.
 
-    .. versionchanged:: 0.3.13
-
+    !!! warning "Behavior changed in 0.3.13"
         Support for Anthropic format tools added.
 
-    .. versionchanged:: 0.3.14
-
+    !!! warning "Behavior changed in 0.3.14"
         Support for Amazon Bedrock Converse format tools added.
 
-    .. versionchanged:: 0.3.16
-
+    !!! warning "Behavior changed in 0.3.16"
         'description' and 'parameters' keys are now optional. Only 'name' is
         required and guaranteed to be part of the output.
     """
@@ -524,9 +521,9 @@ _WellKnownOpenAITools = (
 
 
 def convert_to_openai_tool(
-    tool: Union[dict[str, Any], type[BaseModel], Callable, BaseTool],
+    tool: dict[str, Any] | type[BaseModel] | Callable | BaseTool,
     *,
-    strict: Optional[bool] = None,
+    strict: bool | None = None,
 ) -> dict[str, Any]:
     """Convert a tool-like object to an OpenAI tool schema.
 
@@ -549,35 +546,28 @@ def convert_to_openai_tool(
         A dict version of the passed in tool which is compatible with the
         OpenAI tool-calling API.
 
-    .. versionchanged:: 0.2.29
-
+    !!! warning "Behavior changed in 0.2.29"
         ``strict`` arg added.
 
-    .. versionchanged:: 0.3.13
-
+    !!! warning "Behavior changed in 0.3.13"
         Support for Anthropic format tools added.
 
-    .. versionchanged:: 0.3.14
-
+    !!! warning "Behavior changed in 0.3.14"
         Support for Amazon Bedrock Converse format tools added.
 
-    .. versionchanged:: 0.3.16
-
+    !!! warning "Behavior changed in 0.3.16"
         'description' and 'parameters' keys are now optional. Only 'name' is
         required and guaranteed to be part of the output.
 
-    .. versionchanged:: 0.3.44
-
+    !!! warning "Behavior changed in 0.3.44"
         Return OpenAI Responses API-style tools unchanged. This includes
         any dict with "type" in "file_search", "function", "computer_use_preview",
         "web_search_preview".
 
-    .. versionchanged:: 0.3.61
-
+    !!! warning "Behavior changed in 0.3.61"
         Added support for OpenAI's built-in code interpreter and remote MCP tools.
 
-    .. versionchanged:: 0.3.63
-
+    !!! warning "Behavior changed in 0.3.63"
         Added support for OpenAI's image generation built-in tool.
     """
     # Import locally to prevent circular import
@@ -603,9 +593,9 @@ def convert_to_openai_tool(
 
 
 def convert_to_json_schema(
-    schema: Union[dict[str, Any], type[BaseModel], Callable, BaseTool],
+    schema: dict[str, Any] | type[BaseModel] | Callable | BaseTool,
     *,
-    strict: Optional[bool] = None,
+    strict: bool | None = None,
 ) -> dict[str, Any]:
     """Convert a schema representation to a JSON schema.
 
@@ -648,9 +638,9 @@ def convert_to_json_schema(
 def tool_example_to_messages(
     input: str,
     tool_calls: list[BaseModel],
-    tool_outputs: Optional[list[str]] = None,
+    tool_outputs: list[str] | None = None,
     *,
-    ai_response: Optional[str] = None,
+    ai_response: str | None = None,
 ) -> list[BaseMessage]:
     """Convert an example into a list of messages that can be fed into an LLM.
 
@@ -742,7 +732,7 @@ def tool_example_to_messages(
     tool_outputs = tool_outputs or ["You have correctly called this tool."] * len(
         openai_tool_calls
     )
-    for output, tool_call_dict in zip(tool_outputs, openai_tool_calls):
+    for output, tool_call_dict in zip(tool_outputs, openai_tool_calls, strict=False):
         messages.append(ToolMessage(content=output, tool_call_id=tool_call_dict["id"]))
 
     if ai_response:
@@ -751,7 +741,7 @@ def tool_example_to_messages(
 
 
 def _parse_google_docstring(
-    docstring: Optional[str],
+    docstring: str | None,
     args: list[str],
     *,
     error_on_invalid_docstring: bool = False,

langchain_core/utils/html.py

@@ -3,7 +3,6 @@
 import logging
 import re
 from collections.abc import Sequence
-from typing import Optional, Union
 from urllib.parse import urljoin, urlparse
 
 logger = logging.getLogger(__name__)
@@ -35,7 +34,7 @@ DEFAULT_LINK_REGEX = (
 
 
 def find_all_links(
-    raw_html: str, *, pattern: Union[str, re.Pattern, None] = None
+    raw_html: str, *, pattern: str | re.Pattern | None = None
 ) -> list[str]:
     """Extract all links from a raw HTML string.
 
@@ -54,8 +53,8 @@ def extract_sub_links(
     raw_html: str,
     url: str,
     *,
-    base_url: Optional[str] = None,
-    pattern: Union[str, re.Pattern, None] = None,
+    base_url: str | None = None,
+    pattern: str | re.Pattern | None = None,
     prevent_outside: bool = True,
     exclude_prefixes: Sequence[str] = (),
     continue_on_failure: bool = False,

langchain_core/utils/input.py

@@ -1,6 +1,6 @@
 """Handle chained inputs."""
 
-from typing import Optional, TextIO
+from typing import TextIO
 
 _TEXT_COLOR_MAPPING = {
     "blue": "36;1",
@@ -12,7 +12,7 @@ _TEXT_COLOR_MAPPING = {
 
 
 def get_color_mapping(
-    items: list[str], excluded_colors: Optional[list] = None
+    items: list[str], excluded_colors: list | None = None
 ) -> dict[str, str]:
     """Get mapping for items to a support color.
 
@@ -56,7 +56,7 @@ def get_bolded_text(text: str) -> str:
 
 
 def print_text(
-    text: str, color: Optional[str] = None, end: str = "", file: Optional[TextIO] = None
+    text: str, color: str | None = None, end: str = "", file: TextIO | None = None
 ) -> None:
     """Print text with highlighting and no end characters.
 

langchain_core/utils/iter.py

@@ -9,9 +9,7 @@ from typing import (
     Any,
     Generic,
     Literal,
-    Optional,
     TypeVar,
-    Union,
     overload,
 )
 
@@ -26,9 +24,9 @@ class NoLock:
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> Literal[False]:
         """Return False (exception not suppressed)."""
         return False
@@ -42,7 +40,7 @@ def tee_peer(
     peers: list[deque[T]],
     lock: AbstractContextManager[Any],
 ) -> Generator[T, None, None]:
-    """An individual iterator of a :py:func:`~.tee`.
+    """An individual iterator of a `.tee`.
 
     This function is a generator that yields items from the shared iterator
     ``iterator``. It buffers items until the least advanced iterator has
@@ -108,22 +106,22 @@ class Tee(Generic[T]):
             await a.anext(previous)  # advance one iterator
             return a.map(operator.sub, previous, current)
 
-    Unlike :py:func:`itertools.tee`, :py:func:`~.tee` returns a custom type instead
-    of a :py:class:`tuple`. Like a tuple, it can be indexed, iterated and unpacked
-    to get the child iterators. In addition, its :py:meth:`~.tee.aclose` method
+    Unlike `itertools.tee`, `.tee` returns a custom type instead
+    of a :py`tuple`. Like a tuple, it can be indexed, iterated and unpacked
+    to get the child iterators. In addition, its `.tee.aclose` method
     immediately closes all children, and it can be used in an ``async with`` context
     for the same effect.
 
     If ``iterable`` is an iterator and read elsewhere, ``tee`` will *not*
     provide these items. Also, ``tee`` must internally buffer each item until the
     last iterator has yielded it; if the most and least advanced iterator differ
-    by most data, using a :py:class:`list` is more efficient (but not lazy).
+    by most data, using a :py`list` is more efficient (but not lazy).
 
     If the underlying iterable is concurrency safe (``anext`` may be awaited
     concurrently) the resulting iterators are concurrency safe as well. Otherwise,
     the iterators are safe if there is only ever one single "most advanced" iterator.
     To enforce sequential use of ``anext``, provide a ``lock``
-    - e.g. an :py:class:`asyncio.Lock` instance in an :py:mod:`asyncio` application -
+    - e.g. an :py`asyncio.Lock` instance in an :py:mod:`asyncio` application -
     and access is automatically synchronised.
 
     """
@@ -133,7 +131,7 @@ class Tee(Generic[T]):
         iterable: Iterator[T],
         n: int = 2,
         *,
-        lock: Optional[AbstractContextManager[Any]] = None,
+        lock: AbstractContextManager[Any] | None = None,
     ):
         """Create a ``tee``.
 
@@ -165,9 +163,7 @@ class Tee(Generic[T]):
     @overload
     def __getitem__(self, item: slice) -> tuple[Iterator[T], ...]: ...
 
-    def __getitem__(
-        self, item: Union[int, slice]
-    ) -> Union[Iterator[T], tuple[Iterator[T], ...]]:
+    def __getitem__(self, item: int | slice) -> Iterator[T] | tuple[Iterator[T], ...]:
         """Return the child iterator(s) at the given index or slice."""
         return self._children[item]
 
@@ -185,9 +181,9 @@ class Tee(Generic[T]):
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> Literal[False]:
         """Close all child iterators.
 
@@ -207,7 +203,7 @@ class Tee(Generic[T]):
 safetee = Tee
 
 
-def batch_iterate(size: Optional[int], iterable: Iterable[T]) -> Iterator[list[T]]:
+def batch_iterate(size: int | None, iterable: Iterable[T]) -> Iterator[list[T]]:
     """Utility batching function.
 
     Args:

langchain_core/utils/json.py

@@ -4,7 +4,8 @@ from __future__ import annotations
 
 import json
 import re
-from typing import Any, Callable, Union
+from collections.abc import Callable
+from typing import Any
 
 from langchain_core.exceptions import OutputParserException
 
@@ -19,7 +20,7 @@ def _replace_new_line(match: re.Match[str]) -> str:
     return match.group(1) + value + match.group(3)
 
 
-def _custom_parser(multiline_string: Union[str, bytes, bytearray]) -> str:
+def _custom_parser(multiline_string: str | bytes | bytearray) -> str:
     r"""Custom parser for multiline strings.
 
     The LLM response for `action_input` may be a multiline

langchain_core/utils/json_schema.py

@@ -3,13 +3,13 @@
 from __future__ import annotations
 
 from copy import deepcopy
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
 
-def _retrieve_ref(path: str, schema: dict) -> Union[list, dict]:
+def _retrieve_ref(path: str, schema: dict) -> list | dict:
     components = path.split("/")
     if components[0] != "#":
         msg = (
@@ -17,7 +17,7 @@ def _retrieve_ref(path: str, schema: dict) -> Union[list, dict]:
             "with #."
         )
         raise ValueError(msg)
-    out: Union[list, dict] = schema
+    out: list | dict = schema
     for component in components[1:]:
         if component in out:
             if isinstance(out, list):
@@ -67,7 +67,7 @@ def _process_dict_properties(
 def _dereference_refs_helper(
     obj: Any,
     full_schema: dict[str, Any],
-    processed_refs: Optional[set[str]],
+    processed_refs: set[str] | None,
     skip_keys: Sequence[str],
     shallow_refs: bool,  # noqa: FBT001
 ) -> Any:
@@ -167,8 +167,8 @@ def _dereference_refs_helper(
 def dereference_refs(
     schema_obj: dict,
     *,
-    full_schema: Optional[dict] = None,
-    skip_keys: Optional[Sequence[str]] = None,
+    full_schema: dict | None = None,
+    skip_keys: Sequence[str] | None = None,
 ) -> dict:
     """Resolve and inline JSON Schema $ref references in a schema object.
 

langchain_core/utils/mustache.py

@@ -12,8 +12,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Literal,
-    Optional,
-    Union,
     cast,
 )
 
@@ -23,7 +21,7 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-Scopes: TypeAlias = list[Union[Literal[False, 0], Mapping[str, Any]]]
+Scopes: TypeAlias = list[Literal[False, 0] | Mapping[str, Any]]
 
 
 # Globals
@@ -433,13 +431,13 @@ EMPTY_DICT: MappingProxyType[str, str] = MappingProxyType({})
 
 
 def render(
-    template: Union[str, list[tuple[str, str]]] = "",
+    template: str | list[tuple[str, str]] = "",
     data: Mapping[str, Any] = EMPTY_DICT,
     partials_dict: Mapping[str, str] = EMPTY_DICT,
     padding: str = "",
     def_ldel: str = "{{",
     def_rdel: str = "}}",
-    scopes: Optional[Scopes] = None,
+    scopes: Scopes | None = None,
     warn: bool = False,  # noqa: FBT001,FBT002
     keep: bool = False,  # noqa: FBT001,FBT002
 ) -> str:

langchain_core/utils/pydantic.py

@@ -5,16 +5,14 @@ from __future__ import annotations
 import inspect
 import textwrap
 import warnings
+from collections.abc import Callable
 from contextlib import nullcontext
 from functools import lru_cache, wraps
 from types import GenericAlias
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Optional,
     TypeVar,
-    Union,
     cast,
     overload,
 )
@@ -205,8 +203,8 @@ def _create_subset_model_v1(
     model: type[BaseModelV1],
     field_names: list,
     *,
-    descriptions: Optional[dict] = None,
-    fn_description: Optional[str] = None,
+    descriptions: dict | None = None,
+    fn_description: str | None = None,
 ) -> type[BaseModel]:
     """Create a pydantic model with only a subset of model's fields."""
     fields = {}
@@ -218,7 +216,7 @@ def _create_subset_model_v1(
             # this isn't perfect but should work for most functions
             field.outer_type_
             if field.required and not field.allow_none
-            else Optional[field.outer_type_]
+            else field.outer_type_ | None
         )
         if descriptions and field_name in descriptions:
             field.field_info.description = descriptions[field_name]
@@ -234,8 +232,8 @@ def _create_subset_model_v2(
     model: type[BaseModel],
     field_names: list[str],
     *,
-    descriptions: Optional[dict] = None,
-    fn_description: Optional[str] = None,
+    descriptions: dict | None = None,
+    fn_description: str | None = None,
 ) -> type[BaseModel]:
     """Create a pydantic model with a subset of the model fields."""
     descriptions_ = descriptions or {}
@@ -276,8 +274,8 @@ def _create_subset_model(
     model: TypeBaseModel,
     field_names: list[str],
     *,
-    descriptions: Optional[dict] = None,
-    fn_description: Optional[str] = None,
+    descriptions: dict | None = None,
+    fn_description: str | None = None,
 ) -> type[BaseModel]:
     """Create subset model using the same pydantic version as the input model.
 
@@ -318,8 +316,8 @@ def get_fields(model: BaseModelV1) -> dict[str, ModelField]: ...
 
 
 def get_fields(
-    model: Union[type[Union[BaseModel, BaseModelV1]], BaseModel, BaseModelV1],
-) -> Union[dict[str, FieldInfoV2], dict[str, ModelField]]:
+    model: type[BaseModel | BaseModelV1] | BaseModel | BaseModelV1,
+) -> dict[str, FieldInfoV2] | dict[str, ModelField]:
     """Return the field names of a Pydantic model.
 
     Args:
@@ -348,7 +346,7 @@ NO_DEFAULT = object()
 def _create_root_model(
     name: str,
     type_: Any,
-    module_name: Optional[str] = None,
+    module_name: str | None = None,
     default_: object = NO_DEFAULT,
 ) -> type[BaseModel]:
     """Create a base class."""
@@ -413,7 +411,7 @@ def _create_root_model_cached(
     model_name: str,
     type_: Any,
     *,
-    module_name: Optional[str] = None,
+    module_name: str | None = None,
     default_: object = NO_DEFAULT,
 ) -> type[BaseModel]:
     return _create_root_model(
@@ -436,7 +434,7 @@ def _create_model_cached(
 
 def create_model(
     model_name: str,
-    module_name: Optional[str] = None,
+    module_name: str | None = None,
     /,
     **field_definitions: Any,
 ) -> type[BaseModel]:
@@ -509,9 +507,9 @@ def _remap_field_definitions(field_definitions: dict[str, Any]) -> dict[str, Any
 def create_model_v2(
     model_name: str,
     *,
-    module_name: Optional[str] = None,
-    field_definitions: Optional[dict[str, Any]] = None,
-    root: Optional[Any] = None,
+    module_name: str | None = None,
+    field_definitions: dict[str, Any] | None = None,
+    root: Any | None = None,
 ) -> type[BaseModel]:
     """Create a pydantic model with the given field definitions.
 

langchain_core/utils/usage.py

@@ -1,6 +1,6 @@
 """Usage utilities."""
 
-from typing import Callable
+from collections.abc import Callable
 
 
 def _dict_int_op(