langchain-core 0.4.0.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

langchain_core/tracers/schemas.py

@@ -2,138 +2,13 @@
 
 from __future__ import annotations
 
-import warnings
-from datetime import datetime, timezone
-from typing import Any, Optional
-from uuid import UUID
-
 from langsmith import RunTree
-from langsmith.schemas import RunTypeEnum as RunTypeEnumDep
-from pydantic import PydanticDeprecationWarning
-from pydantic.v1 import BaseModel as BaseModelV1
-from pydantic.v1 import Field as FieldV1
-
-from langchain_core._api import deprecated
-
-
-@deprecated("0.1.0", alternative="Use string instead.", removal="1.0")
-def RunTypeEnum() -> type[RunTypeEnumDep]:  # noqa: N802
-    """RunTypeEnum."""
-    warnings.warn(
-        "RunTypeEnum is deprecated. Please directly use a string instead"
-        " (e.g. 'llm', 'chain', 'tool').",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-    return RunTypeEnumDep
-
-
-@deprecated("0.1.0", removal="1.0")
-class TracerSessionV1Base(BaseModelV1):
-    """Base class for TracerSessionV1."""
-
-    start_time: datetime = FieldV1(default_factory=lambda: datetime.now(timezone.utc))
-    name: Optional[str] = None
-    extra: Optional[dict[str, Any]] = None
-
-
-@deprecated("0.1.0", removal="1.0")
-class TracerSessionV1Create(TracerSessionV1Base):
-    """Create class for TracerSessionV1."""
-
-
-@deprecated("0.1.0", removal="1.0")
-class TracerSessionV1(TracerSessionV1Base):
-    """TracerSessionV1 schema."""
-
-    id: int
-
-
-@deprecated("0.1.0", removal="1.0")
-class TracerSessionBase(TracerSessionV1Base):
-    """Base class for TracerSession."""
-
-    tenant_id: UUID
-
-
-@deprecated("0.1.0", removal="1.0")
-class TracerSession(TracerSessionBase):
-    """TracerSessionV1 schema for the V2 API."""
-
-    id: UUID
-
-
-@deprecated("0.1.0", alternative="Run", removal="1.0")
-class BaseRun(BaseModelV1):
-    """Base class for Run."""
-
-    uuid: str
-    parent_uuid: Optional[str] = None
-    start_time: datetime = FieldV1(default_factory=lambda: datetime.now(timezone.utc))
-    end_time: datetime = FieldV1(default_factory=lambda: datetime.now(timezone.utc))
-    extra: Optional[dict[str, Any]] = None
-    execution_order: int
-    child_execution_order: int
-    serialized: dict[str, Any]
-    session_id: int
-    error: Optional[str] = None
-
-
-@deprecated("0.1.0", alternative="Run", removal="1.0")
-class LLMRun(BaseRun):
-    """Class for LLMRun."""
-
-    prompts: list[str]
-    # Temporarily, remove but we will completely remove LLMRun
-    # response: Optional[LLMResult] = None
-
-
-@deprecated("0.1.0", alternative="Run", removal="1.0")
-class ChainRun(BaseRun):
-    """Class for ChainRun."""
-
-    inputs: dict[str, Any]
-    outputs: Optional[dict[str, Any]] = None
-    child_llm_runs: list[LLMRun] = FieldV1(default_factory=list)
-    child_chain_runs: list[ChainRun] = FieldV1(default_factory=list)
-    child_tool_runs: list[ToolRun] = FieldV1(default_factory=list)
-
-
-@deprecated("0.1.0", alternative="Run", removal="1.0")
-class ToolRun(BaseRun):
-    """Class for ToolRun."""
-
-    tool_input: str
-    output: Optional[str] = None
-    action: str
-    child_llm_runs: list[LLMRun] = FieldV1(default_factory=list)
-    child_chain_runs: list[ChainRun] = FieldV1(default_factory=list)
-    child_tool_runs: list[ToolRun] = FieldV1(default_factory=list)
-
 
 # Begin V2 API Schemas
 
 
 Run = RunTree  # For backwards compatibility
 
-# TODO: Update once langsmith moves to Pydantic V2 and we can swap Run.model_rebuild
-# for Run.update_forward_refs
-with warnings.catch_warnings():
-    warnings.simplefilter("ignore", category=PydanticDeprecationWarning)
-
-    ChainRun.update_forward_refs()
-    ToolRun.update_forward_refs()
-
 __all__ = [
-    "BaseRun",
-    "ChainRun",
-    "LLMRun",
     "Run",
-    "RunTypeEnum",
-    "ToolRun",
-    "TracerSession",
-    "TracerSessionBase",
-    "TracerSessionV1",
-    "TracerSessionV1Base",
-    "TracerSessionV1Create",
 ]

langchain_core/tracers/stdout.py

@@ -1,7 +1,8 @@
 """Tracers that print to the console."""
 
 import json
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 from langchain_core.tracers.base import BaseTracer
 from langchain_core.tracers.schemas import Run
@@ -48,8 +49,7 @@ class FunctionCallbackHandler(BaseTracer):
     """Tracer that calls a function with a single str parameter."""
 
     name: str = "function_callback_handler"
-    """The name of the tracer. This is used to identify the tracer in the logs.
-    Default is "function_callback_handler"."""
+    """The name of the tracer. This is used to identify the tracer in the logs."""
 
     def __init__(self, function: Callable[[str], None], **kwargs: Any) -> None:
         """Create a FunctionCallbackHandler.

langchain_core/utils/__init__.py

@@ -1,4 +1,4 @@
-"""**Utility functions** for LangChain.
+"""Utility functions for LangChain.
 
 These functions do not depend on any other LangChain module.
 """
@@ -21,7 +21,6 @@ if TYPE_CHECKING:
         print_text,
     )
     from langchain_core.utils.iter import batch_iterate
-    from langchain_core.utils.loading import try_load_from_hub
     from langchain_core.utils.pydantic import pre_init
     from langchain_core.utils.strings import (
         comma_list,
@@ -68,7 +67,6 @@ __all__ = (
     "secret_from_env",
     "stringify_dict",
     "stringify_value",
-    "try_load_from_hub",
     "xor_args",
 )
 
@@ -84,7 +82,6 @@ _dynamic_imports = {
     "get_colored_text": "input",
     "print_text": "input",
     "batch_iterate": "iter",
-    "try_load_from_hub": "loading",
     "pre_init": "pydantic",
     "comma_list": "strings",
     "sanitize_for_postgres": "strings",

langchain_core/utils/_merge.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Optional
+from typing import Any
 
 
 def merge_dicts(left: dict[str, Any], *others: dict[str, Any]) -> dict[str, Any]:
@@ -57,6 +57,11 @@ def merge_dicts(left: dict[str, Any], *others: dict[str, Any]) -> dict[str, Any]
                 #             "should either occur once or have the same value across "
                 #             "all dicts."
                 #         )
+                if (right_k == "index" and merged[right_k].startswith("lc_")) or (
+                    right_k in ("id", "output_version", "model_provider")
+                    and merged[right_k] == right_v
+                ):
+                    continue
                 merged[right_k] += right_v
             elif isinstance(merged[right_k], dict):
                 merged[right_k] = merge_dicts(merged[right_k], right_v)
@@ -75,7 +80,7 @@ def merge_dicts(left: dict[str, Any], *others: dict[str, Any]) -> dict[str, Any]
     return merged
 
 
-def merge_lists(left: Optional[list], *others: Optional[list]) -> Optional[list]:
+def merge_lists(left: list | None, *others: list | None) -> list | None:
     """Add many lists, handling None.
 
     Args:
@@ -93,20 +98,53 @@ def merge_lists(left: Optional[list], *others: Optional[list]) -> Optional[list]
             merged = other.copy()
         else:
             for e in other:
-                if isinstance(e, dict) and "index" in e and isinstance(e["index"], int):
+                if (
+                    isinstance(e, dict)
+                    and "index" in e
+                    and (
+                        isinstance(e["index"], int)
+                        or (
+                            isinstance(e["index"], str) and e["index"].startswith("lc_")
+                        )
+                    )
+                ):
                     to_merge = [
                         i
                         for i, e_left in enumerate(merged)
-                        if e_left["index"] == e["index"]
+                        if "index" in e_left and e_left["index"] == e["index"]
                     ]
                     if to_merge:
                         # TODO: Remove this once merge_dict is updated with special
                         # handling for 'type'.
-                        new_e = (
-                            {k: v for k, v in e.items() if k != "type"}
-                            if "type" in e
-                            else e
-                        )
+                        if (left_type := merged[to_merge[0]].get("type")) and (
+                            e.get("type") == "non_standard" and "value" in e
+                        ):
+                            if left_type != "non_standard":
+                                # standard + non_standard
+                                new_e: dict[str, Any] = {
+                                    "extras": {
+                                        k: v
+                                        for k, v in e["value"].items()
+                                        if k != "type"
+                                    }
+                                }
+                            else:
+                                # non_standard + non_standard
+                                new_e = {
+                                    "value": {
+                                        k: v
+                                        for k, v in e["value"].items()
+                                        if k != "type"
+                                    }
+                                }
+                                if "index" in e:
+                                    new_e["index"] = e["index"]
+                        else:
+                            new_e = (
+                                {k: v for k, v in e.items() if k != "type"}
+                                if "type" in e
+                                else e
+                            )
                         merged[to_merge[0]] = merge_dicts(merged[to_merge[0]], new_e)
                     else:
                         merged.append(e)

langchain_core/utils/aiter.py

@@ -11,17 +11,15 @@ from collections.abc import (
     AsyncIterable,
     AsyncIterator,
     Awaitable,
+    Callable,
     Iterator,
 )
 from contextlib import AbstractAsyncContextManager
 from types import TracebackType
 from typing import (
     Any,
-    Callable,
     Generic,
-    Optional,
     TypeVar,
-    Union,
     cast,
     overload,
 )
@@ -36,8 +34,8 @@ _no_default = object()
 # https://github.com/python/cpython/blob/main/Lib/test/test_asyncgen.py#L54
 # before 3.10, the builtin anext() was not available
 def py_anext(
-    iterator: AsyncIterator[T], default: Union[T, Any] = _no_default
-) -> Awaitable[Union[T, None, Any]]:
+    iterator: AsyncIterator[T], default: T | Any = _no_default
+) -> Awaitable[T | Any | None]:
     """Pure-Python implementation of anext() for testing purposes.
 
     Closely matches the builtin anext() C implementation.
@@ -52,7 +50,7 @@ def py_anext(
 
     Returns:
         The next value from the iterator, or the default value
-            if the iterator is exhausted.
+        if the iterator is exhausted.
 
     Raises:
         TypeError: If the iterator is not an async iterator.
@@ -68,7 +66,7 @@ def py_anext(
     if default is _no_default:
         return __anext__(iterator)
 
-    async def anext_impl() -> Union[T, Any]:
+    async def anext_impl() -> T | Any:
         try:
             # The C code is way more low-level than this, as it implements
             # all methods of the iterator protocol. In this implementation
@@ -90,11 +88,11 @@ class NoLock:
 
     async def __aexit__(
         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,
     ) -> bool:
-        """Exception not handled."""
+        """Return False, exception not suppressed."""
         return False
 
 
@@ -106,10 +104,10 @@ async def tee_peer(
     peers: list[deque[T]],
     lock: AbstractAsyncContextManager[Any],
 ) -> AsyncGenerator[T, 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:
@@ -155,39 +153,39 @@ async 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:: python3
-
-        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.
 
     """
@@ -197,15 +195,15 @@ class Tee(Generic[T]):
         iterable: AsyncIterator[T],
         n: int = 2,
         *,
-        lock: Optional[AbstractAsyncContextManager[Any]] = None,
+        lock: AbstractAsyncContextManager[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 = iterable.__aiter__()  # before 3.10 aiter() doesn't exist
         self._buffers: list[deque[T]] = [deque() for _ in range(n)]
@@ -230,13 +228,17 @@ class Tee(Generic[T]):
     def __getitem__(self, item: slice) -> tuple[AsyncIterator[T], ...]: ...
 
     def __getitem__(
-        self, item: Union[int, slice]
-    ) -> Union[AsyncIterator[T], tuple[AsyncIterator[T], ...]]:
+        self, item: int | slice
+    ) -> AsyncIterator[T] | tuple[AsyncIterator[T], ...]:
         """Return the child iterator(s) for the given index or slice."""
         return self._children[item]
 
     def __iter__(self) -> Iterator[AsyncIterator[T]]:
-        """Iterate over the child iterators."""
+        """Iterate over the child iterators.
+
+        Yields:
+            The child iterators.
+        """
         yield from self._children
 
     async def __aenter__(self) -> "Tee[T]":
@@ -245,11 +247,15 @@ class Tee(Generic[T]):
 
     async def __aexit__(
         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,
     ) -> bool:
-        """Close all child iterators."""
+        """Close all child iterators.
+
+        Returns:
+            False, exceptions not suppressed.
+        """
         await self.aclose()
         return False
 
@@ -263,30 +269,28 @@ atee = Tee
 
 
 class aclosing(AbstractAsyncContextManager):  # noqa: N801
-    """Async context manager to wrap an AsyncGenerator that has a ``aclose()`` method.
+    """Async context manager to wrap an AsyncGenerator that has a `aclose()` method.
 
     Code like this:
 
-    .. code-block:: python
-
-        async with aclosing(<module>.fetch(<arguments>)) as agen:
-            <block>
+    ```python
+    async with aclosing(<module>.fetch(<arguments>)) as agen:
+        <block>
+    ```
 
     is equivalent to this:
 
-    .. code-block:: python
-
-        agen = <module>.fetch(<arguments>)
-        try:
-            <block>
-        finally:
-            await agen.aclose()
+    ```python
+    agen = <module>.fetch(<arguments>)
+    try:
+        <block>
+    finally:
+        await agen.aclose()
 
+    ```
     """
 
-    def __init__(
-        self, thing: Union[AsyncGenerator[Any, Any], AsyncIterator[Any]]
-    ) -> None:
+    def __init__(self, thing: AsyncGenerator[Any, Any] | AsyncIterator[Any]) -> None:
         """Create the context manager.
 
         Args:
@@ -295,15 +299,15 @@ class aclosing(AbstractAsyncContextManager):  # noqa: N801
         self.thing = thing
 
     @override
-    async def __aenter__(self) -> Union[AsyncGenerator[Any, Any], AsyncIterator[Any]]:
+    async def __aenter__(self) -> AsyncGenerator[Any, Any] | AsyncIterator[Any]:
         return self.thing
 
     @override
     async def __aexit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
     ) -> None:
         if hasattr(self.thing, "aclose"):
             await self.thing.aclose()
@@ -318,8 +322,8 @@ async def abatch_iterate(
         size: The size of the batch.
         iterable: The async iterable to batch.
 
-    Returns:
-        An async iterator over the batches.
+    Yields:
+        The batches.
     """
     batch: list[T] = []
     async for element in iterable:

langchain_core/utils/env.py

@@ -3,17 +3,17 @@
 from __future__ import annotations
 
 import os
-from typing import Any, Optional, Union
+from typing import Any
 
 
 def env_var_is_set(env_var: str) -> bool:
     """Check if an environment variable is set.
 
     Args:
-        env_var (str): The name of the environment variable.
+        env_var: The name of the environment variable.
 
     Returns:
-        bool: True if the environment variable is set, False otherwise.
+        `True` if the environment variable is set, `False` otherwise.
     """
     return env_var in os.environ and os.environ[env_var] not in {
         "",
@@ -25,9 +25,9 @@ def env_var_is_set(env_var: str) -> bool:
 
 def get_from_dict_or_env(
     data: dict[str, Any],
-    key: Union[str, list[str]],
+    key: str | list[str],
     env_key: str,
-    default: Optional[str] = None,
+    default: str | None = None,
 ) -> str:
     """Get a value from a dictionary or an environment variable.
 
@@ -38,7 +38,10 @@ def get_from_dict_or_env(
         env_key: The environment variable to look up if the key is not
             in the dictionary.
         default: The default value to return if the key is not in the dictionary
-            or the environment. Defaults to None.
+            or the environment.
+
+    Returns:
+        The dict value or the environment variable value.
     """
     if isinstance(key, (list, tuple)):
         for k in key:
@@ -53,7 +56,7 @@ def get_from_dict_or_env(
     return get_from_env(key_for_err, env_key, default=default)
 
 
-def get_from_env(key: str, env_key: str, default: Optional[str] = None) -> str:
+def get_from_env(key: str, env_key: str, default: str | None = None) -> str:
     """Get a value from a dictionary or an environment variable.
 
     Args:
@@ -61,10 +64,10 @@ def get_from_env(key: str, env_key: str, default: Optional[str] = None) -> str:
         env_key: The environment variable to look up if the key is not
             in the dictionary.
         default: The default value to return if the key is not in the dictionary
-            or the environment. Defaults to None.
+            or the environment.
 
     Returns:
-        str: The value of the key.
+        The value of the key.
 
     Raises:
         ValueError: If the key is not in the dictionary and no default value is