langchain-core 1.0.0a6__py3-none-any.whl → 1.0.4__py3-none-any.whl

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,10 +40,10 @@ 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
+    `iterator`. It buffers items until the least advanced iterator has
     yielded them as well. The buffer is shared with all other peers.
 
     Args:
@@ -91,39 +89,39 @@ def tee_peer(
 
 
 class Tee(Generic[T]):
-    """Create ``n`` separate asynchronous iterators over ``iterable``.
+    """Create `n` separate asynchronous iterators over `iterable`.
 
-    This splits a single ``iterable`` into multiple iterators, each providing
+    This splits a single `iterable` into multiple iterators, each providing
     the same items in the same order.
     All child iterators may advance separately but share the same items
-    from ``iterable`` -- when the most advanced iterator retrieves an item,
+    from `iterable` -- when the most advanced iterator retrieves an item,
     it is buffered until the least advanced iterator has yielded it as well.
-    A ``tee`` works lazily and can handle an infinite ``iterable``, provided
+    A `tee` works lazily and can handle an infinite `iterable`, provided
     that all iterators advance.
 
-    .. code-block:: python
-
-        async def derivative(sensor_data):
-            previous, current = a.tee(sensor_data, n=2)
-            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
-    immediately closes all children, and it can be used in an ``async with`` context
+    ```python
+    async def derivative(sensor_data):
+        previous, current = a.tee(sensor_data, n=2)
+        await a.anext(previous)  # advance one iterator
+        return a.map(operator.sub, previous, current)
+    ```
+
+    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
+    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
+    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 -
+    To enforce sequential use of `anext`, provide a `lock`
+    - e.g. an :py`asyncio.Lock` instance in an :py:mod:`asyncio` application -
     and access is automatically synchronised.
 
     """
@@ -133,15 +131,15 @@ class Tee(Generic[T]):
         iterable: Iterator[T],
         n: int = 2,
         *,
-        lock: Optional[AbstractContextManager[Any]] = None,
+        lock: AbstractContextManager[Any] | None = None,
     ):
-        """Create a ``tee``.
+        """Create a `tee`.
 
         Args:
             iterable: The iterable to split.
-            n: The number of iterators to create. Defaults to 2.
+            n: The number of iterators to create.
             lock: The lock to synchronise access to the shared buffers.
-                Defaults to None.
+
         """
         self._iterator = iter(iterable)
         self._buffers: list[deque[T]] = [deque() for _ in range(n)]
@@ -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,11 +203,11 @@ 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:
-        size: The size of the batch. If None, returns a single batch.
+        size: The size of the batch. If `None`, returns a single batch.
         iterable: The iterable to batch.
 
     Yields:

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
@@ -50,7 +51,7 @@ def parse_partial_json(s: str, *, strict: bool = False) -> Any:
 
     Args:
         s: The JSON string to parse.
-        strict: Whether to use strict parsing. Defaults to False.
+        strict: Whether to use strict parsing.
 
     Returns:
         The parsed JSON object as a Python dictionary.

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:
@@ -85,7 +85,7 @@ def _dereference_refs_helper(
         full_schema: The complete schema containing all definitions
         processed_refs: Set tracking currently processing refs (for cycle detection)
         skip_keys: Keys under which to skip recursion
-        shallow_refs: If True, only break cycles; if False, deep-inline all refs
+        shallow_refs: If `True`, only break cycles; if False, deep-inline all refs
 
     Returns:
         The object with $ref properties resolved and merged with other properties.
@@ -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.
 
@@ -184,7 +184,7 @@ def dereference_refs(
             point to. If not provided, defaults to schema_obj (useful when the
             schema is self-contained).
         skip_keys: Controls recursion behavior and reference resolution depth:
-            - If None (default): Only recurse under '$defs' and use shallow reference
+            - If `None` (Default): Only recurse under '$defs' and use shallow reference
               resolution (break cycles but don't deep-inline nested refs)
             - If provided (even as []): Recurse under all keys and use deep reference
               resolution (fully inline all nested references)
@@ -226,7 +226,7 @@ def dereference_refs(
         ... }
         >>> result = dereference_refs(schema)  # Won't cause infinite recursion
 
-    Note:
+    !!! note
         - Circular references are handled gracefully by breaking cycles
         - Mixed $ref objects (with both $ref and other properties) are supported
         - Additional properties in mixed $refs override resolved properties

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
@@ -48,7 +46,7 @@ def grab_literal(template: str, l_del: str) -> tuple[str, str]:
         l_del: The left delimiter.
 
     Returns:
-        tuple[str, str]: The literal and the template.
+        The literal and the template.
     """
     global _CURRENT_LINE
 
@@ -78,7 +76,7 @@ def l_sa_check(
         is_standalone: Whether the tag is standalone.
 
     Returns:
-        bool: Whether the tag could be a standalone.
+        Whether the tag could be a standalone.
     """
     # If there is a newline, or the previous tag was a standalone
     if literal.find("\n") != -1 or is_standalone:
@@ -104,7 +102,7 @@ def r_sa_check(
         is_standalone: Whether the tag is standalone.
 
     Returns:
-        bool: Whether the tag could be a standalone.
+        Whether the tag could be a standalone.
     """
     # Check right side if we might be a standalone
     if is_standalone and tag_type not in {"variable", "no escape"}:
@@ -126,7 +124,7 @@ def parse_tag(template: str, l_del: str, r_del: str) -> tuple[tuple[str, str], s
         r_del: The right delimiter.
 
     Returns:
-        tuple[tuple[str, str], str]: The tag and the template.
+        The tag and the template.
 
     Raises:
         ChevronError: If the tag is unclosed.
@@ -331,7 +329,7 @@ def tokenize(
 
 
 def _html_escape(string: str) -> str:
-    """Return the HTML-escaped string with these characters escaped: ``" & < >``."""
+    """Return the HTML-escaped string with these characters escaped: `" & < >`."""
     html_codes = {
         '"': "&quot;",
         "<": "&lt;",
@@ -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,
 )
@@ -67,8 +65,8 @@ def get_pydantic_major_version() -> int:
 PYDANTIC_MAJOR_VERSION = PYDANTIC_VERSION.major
 PYDANTIC_MINOR_VERSION = PYDANTIC_VERSION.minor
 
-IS_PYDANTIC_V1 = PYDANTIC_VERSION.major == 1
-IS_PYDANTIC_V2 = PYDANTIC_VERSION.major == 2
+IS_PYDANTIC_V1 = False
+IS_PYDANTIC_V2 = True
 
 PydanticBaseModel = BaseModel
 TypeBaseModel = type[BaseModel]
@@ -80,7 +78,7 @@ def is_pydantic_v1_subclass(cls: type) -> bool:
     """Check if the given class is Pydantic v1-like.
 
     Returns:
-        True if the given class is a subclass of Pydantic ``BaseModel`` 1.x.
+        `True` if the given class is a subclass of Pydantic `BaseModel` 1.x.
     """
     return issubclass(cls, BaseModelV1)
 
@@ -89,7 +87,7 @@ def is_pydantic_v2_subclass(cls: type) -> bool:
     """Check if the given class is Pydantic v2-like.
 
     Returns:
-        True if the given class is a subclass of Pydantic BaseModel 2.x.
+        `True` if the given class is a subclass of Pydantic BaseModel 2.x.
     """
     return issubclass(cls, BaseModel)
 
@@ -103,7 +101,7 @@ def is_basemodel_subclass(cls: type) -> bool:
     * pydantic.v1.BaseModel in Pydantic 2.x
 
     Returns:
-        True if the given class is a subclass of Pydantic ``BaseModel``.
+        `True` if the given class is a subclass of Pydantic `BaseModel`.
     """
     # Before we can use issubclass on the cls we need to check if it is a class
     if not inspect.isclass(cls) or isinstance(cls, GenericAlias):
@@ -121,7 +119,7 @@ def is_basemodel_instance(obj: Any) -> bool:
     * pydantic.v1.BaseModel in Pydantic 2.x
 
     Returns:
-        True if the given class is an instance of Pydantic ``BaseModel``.
+        `True` if the given class is an instance of Pydantic `BaseModel`.
     """
     return isinstance(obj, (BaseModel, BaseModelV1))
 
@@ -131,10 +129,10 @@ def pre_init(func: Callable) -> Any:
     """Decorator to run a function before model initialization.
 
     Args:
-        func (Callable): The function to run before model initialization.
+        func: The function to run before model initialization.
 
     Returns:
-        Any: The decorated function.
+        The decorated function.
     """
     with warnings.catch_warnings():
         warnings.filterwarnings(action="ignore", category=PydanticDeprecationWarning)
@@ -148,11 +146,11 @@ def pre_init(func: Callable) -> Any:
             """Decorator to run a function before model initialization.
 
             Args:
-                cls (Type[BaseModel]): The model class.
-                values (dict[str, Any]): The values to initialize the model with.
+                cls: The model class.
+                values: The values to initialize the model with.
 
             Returns:
-                dict[str, Any]: The values to initialize the model with.
+                The values to initialize the model with.
             """
             # Insert default values
             fields = cls.model_fields
@@ -205,10 +203,10 @@ 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."""
+    """Create a Pydantic model with only a subset of model's fields."""
     fields = {}
 
     for field_name in field_names:
@@ -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,10 +232,10 @@ 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."""
+    """Create a Pydantic model with a subset of the model fields."""
     descriptions_ = descriptions or {}
     fields = {}
     for field_name in field_names:
@@ -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,13 +434,13 @@ 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]:
-    """Create a pydantic model with the given field definitions.
+    """Create a Pydantic model with the given field definitions.
 
-    Please use create_model_v2 instead of this function.
+    Please use `create_model_v2` instead of this function.
 
     Args:
         model_name: The name of the model.
@@ -451,7 +449,7 @@ def create_model(
         **field_definitions: The field definitions for the model.
 
     Returns:
-        Type[BaseModel]: The created model.
+        The created model.
     """
     kwargs = {}
     if "__root__" in field_definitions:
@@ -509,11 +507,11 @@ 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.
+    """Create a Pydantic model with the given field definitions.
 
     Attention:
         Please do not use outside of langchain packages. This API
@@ -524,10 +522,10 @@ def create_model_v2(
         module_name: The name of the module where the model is defined.
             This is used by Pydantic to resolve any forward references.
         field_definitions: The field definitions for the model.
-        root: Type for a root model (RootModel)
+        root: Type for a root model (`RootModel`)
 
     Returns:
-        Type[BaseModel]: The created model.
+        The created model.
     """
     field_definitions = field_definitions or {}
 

langchain_core/utils/strings.py

@@ -10,7 +10,7 @@ def stringify_value(val: Any) -> str:
         val: The value to stringify.
 
     Returns:
-        str: The stringified value.
+        The stringified value.
     """
     if isinstance(val, str):
         return val
@@ -28,12 +28,9 @@ def stringify_dict(data: dict) -> str:
         data: The dictionary to stringify.
 
     Returns:
-        str: The stringified dictionary.
+        The stringified dictionary.
     """
-    text = ""
-    for key, value in data.items():
-        text += key + ": " + stringify_value(value) + "\n"
-    return text
+    return "".join(f"{key}: {stringify_value(value)}\n" for key, value in data.items())
 
 
 def comma_list(items: list[Any]) -> str:
@@ -43,7 +40,7 @@ def comma_list(items: list[Any]) -> str:
         items: The list to convert.
 
     Returns:
-        str: The comma-separated string.
+        The comma-separated string.
     """
     return ", ".join(str(item) for item in items)
 
@@ -57,10 +54,10 @@ def sanitize_for_postgres(text: str, replacement: str = "") -> str:
 
     Args:
         text: The text to sanitize.
-        replacement: String to replace NUL bytes with. Defaults to empty string.
+        replacement: String to replace NUL bytes with.
 
     Returns:
-        str: The sanitized text with NUL bytes removed or replaced.
+        The sanitized text with NUL bytes removed or replaced.
 
     Example:
         >>> sanitize_for_postgres("Hello\\x00world")

langchain_core/utils/usage.py

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