langchain-core 1.0.0a5__py3-none-any.whl → 1.0.0a7__py3-none-any.whl

langchain_core/tracers/langchain.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import logging
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 from uuid import UUID
 
 from langsmith import Client, get_tracing_context
@@ -30,7 +30,7 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 _LOGGED = set()
-_EXECUTOR: Optional[ThreadPoolExecutor] = None
+_EXECUTOR: ThreadPoolExecutor | None = None
 
 
 def log_error_once(method: str, exception: Exception) -> None:
@@ -76,10 +76,10 @@ class LangChainTracer(BaseTracer):
 
     def __init__(
         self,
-        example_id: Optional[Union[UUID, str]] = None,
-        project_name: Optional[str] = None,
-        client: Optional[Client] = None,
-        tags: Optional[list[str]] = None,
+        example_id: UUID | str | None = None,
+        project_name: str | None = None,
+        client: Client | None = None,
+        tags: list[str] | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize the LangChain tracer.
@@ -98,7 +98,7 @@ class LangChainTracer(BaseTracer):
         self.project_name = project_name or ls_utils.get_tracer_project()
         self.client = client or get_client()
         self.tags = tags or []
-        self.latest_run: Optional[Run] = None
+        self.latest_run: Run | None = None
         self.run_has_token_event_map: dict[str, bool] = {}
 
     def _start_trace(self, run: Run) -> None:
@@ -122,10 +122,10 @@ class LangChainTracer(BaseTracer):
         messages: list[list[BaseMessage]],
         *,
         run_id: UUID,
-        tags: Optional[list[str]] = None,
-        parent_run_id: Optional[UUID] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        name: Optional[str] = None,
+        tags: list[str] | None = None,
+        parent_run_id: UUID | None = None,
+        metadata: dict[str, Any] | None = None,
+        name: str | None = None,
         **kwargs: Any,
     ) -> Run:
         """Start a trace for an LLM run.
@@ -242,8 +242,8 @@ class LangChainTracer(BaseTracer):
         self,
         token: str,
         run_id: UUID,
-        chunk: Optional[Union[GenerationChunk, ChatGenerationChunk]] = None,
-        parent_run_id: Optional[UUID] = None,
+        chunk: GenerationChunk | ChatGenerationChunk | None = None,
+        parent_run_id: UUID | None = None,
     ) -> Run:
         run_id_str = str(run_id)
         if run_id_str not in self.run_has_token_event_map:

langchain_core/tracers/log_stream.py

@@ -12,9 +12,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Literal,
-    Optional,
     TypeVar,
-    Union,
     overload,
 )
 
@@ -59,13 +57,13 @@ class LogEntry(TypedDict):
     """List of LLM tokens streamed by this run, if applicable."""
     streamed_output: list[Any]
     """List of output chunks streamed by this run, if available."""
-    inputs: NotRequired[Optional[Any]]
+    inputs: NotRequired[Any | None]
     """Inputs to this run. Not available currently via astream_log."""
-    final_output: Optional[Any]
+    final_output: Any | None
     """Final output of this run.
 
     Only available after the run has finished successfully."""
-    end_time: Optional[str]
+    end_time: str | None
     """ISO-8601 timestamp of when the run ended.
     Only available after the run has finished."""
 
@@ -77,7 +75,7 @@ class RunState(TypedDict):
     """ID of the run."""
     streamed_output: list[Any]
     """List of output chunks streamed by Runnable.stream()"""
-    final_output: Optional[Any]
+    final_output: Any | None
     """Final output of the run, usually the result of aggregating (`+`) streamed_output.
     Updated throughout the run when supported by the Runnable."""
 
@@ -112,7 +110,7 @@ class RunLogPatch:
         """
         self.ops = list(ops)
 
-    def __add__(self, other: Union[RunLogPatch, Any]) -> RunLog:
+    def __add__(self, other: RunLogPatch | Any) -> RunLog:
         """Combine two ``RunLogPatch`` instances.
 
         Args:
@@ -160,7 +158,7 @@ class RunLog(RunLogPatch):
         super().__init__(*ops)
         self.state = state
 
-    def __add__(self, other: Union[RunLogPatch, Any]) -> RunLog:
+    def __add__(self, other: RunLogPatch | Any) -> RunLog:
         """Combine two ``RunLog``s.
 
         Args:
@@ -215,12 +213,12 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler):
         self,
         *,
         auto_close: bool = True,
-        include_names: Optional[Sequence[str]] = None,
-        include_types: Optional[Sequence[str]] = None,
-        include_tags: Optional[Sequence[str]] = None,
-        exclude_names: Optional[Sequence[str]] = None,
-        exclude_types: Optional[Sequence[str]] = None,
-        exclude_tags: Optional[Sequence[str]] = None,
+        include_names: Sequence[str] | None = None,
+        include_types: Sequence[str] | None = None,
+        include_tags: Sequence[str] | None = None,
+        exclude_names: Sequence[str] | None = None,
+        exclude_types: Sequence[str] | None = None,
+        exclude_tags: Sequence[str] | None = None,
         # Schema format is for internal use only.
         _schema_format: Literal["original", "streaming_events"] = "streaming_events",
     ) -> None:
@@ -273,7 +271,7 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler):
         self.receive_stream = memory_stream.get_receive_stream()
         self._key_map_by_run_id: dict[UUID, str] = {}
         self._counter_map_by_name: dict[str, int] = defaultdict(int)
-        self.root_id: Optional[UUID] = None
+        self.root_id: UUID | None = None
 
     def __aiter__(self) -> AsyncIterator[RunLogPatch]:
         """Iterate over the stream of run logs.
@@ -515,7 +513,7 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler):
         self,
         run: Run,
         token: str,
-        chunk: Optional[Union[GenerationChunk, ChatGenerationChunk]],
+        chunk: GenerationChunk | ChatGenerationChunk | None,
     ) -> None:
         """Process new LLM token."""
         index = self._key_map_by_run_id.get(run.id)
@@ -541,7 +539,7 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler):
 
 def _get_standardized_inputs(
     run: Run, schema_format: Literal["original", "streaming_events"]
-) -> Optional[dict[str, Any]]:
+) -> dict[str, Any] | None:
     """Extract standardized inputs from a run.
 
     Standardizes the inputs based on the type of the runnable used.
@@ -583,7 +581,7 @@ def _get_standardized_inputs(
 
 def _get_standardized_outputs(
     run: Run, schema_format: Literal["original", "streaming_events", "original+chat"]
-) -> Optional[Any]:
+) -> Any | None:
     """Extract standardized output from a run.
 
     Standardizes the outputs based on the type of the runnable used.
@@ -617,7 +615,7 @@ def _get_standardized_outputs(
 def _astream_log_implementation(
     runnable: Runnable[Input, Output],
     value: Any,
-    config: Optional[RunnableConfig] = None,
+    config: RunnableConfig | None = None,
     *,
     stream: LogStreamCallbackHandler,
     diff: Literal[True] = True,
@@ -630,7 +628,7 @@ def _astream_log_implementation(
 def _astream_log_implementation(
     runnable: Runnable[Input, Output],
     value: Any,
-    config: Optional[RunnableConfig] = None,
+    config: RunnableConfig | None = None,
     *,
     stream: LogStreamCallbackHandler,
     diff: Literal[False],
@@ -642,13 +640,13 @@ def _astream_log_implementation(
 async def _astream_log_implementation(
     runnable: Runnable[Input, Output],
     value: Any,
-    config: Optional[RunnableConfig] = None,
+    config: RunnableConfig | None = None,
     *,
     stream: LogStreamCallbackHandler,
     diff: bool = True,
     with_streamed_output_list: bool = True,
     **kwargs: Any,
-) -> Union[AsyncIterator[RunLogPatch], AsyncIterator[RunLog]]:
+) -> AsyncIterator[RunLogPatch] | AsyncIterator[RunLog]:
     """Implementation of astream_log for a given runnable.
 
     The implementation has been factored out (at least temporarily) as both
@@ -693,8 +691,8 @@ async def _astream_log_implementation(
     # add each chunk to the output stream
     async def consume_astream() -> None:
         try:
-            prev_final_output: Optional[Output] = None
-            final_output: Optional[Output] = None
+            prev_final_output: Output | None = None
+            final_output: Output | None = None
 
             async for chunk in runnable.astream(value, config, **kwargs):
                 prev_final_output = final_output

langchain_core/tracers/root_listeners.py

@@ -1,7 +1,7 @@
 """Tracers that call listeners."""
 
-from collections.abc import Awaitable
-from typing import TYPE_CHECKING, Callable, Optional, Union
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING
 
 from langchain_core.runnables.config import (
     RunnableConfig,
@@ -14,10 +14,10 @@ from langchain_core.tracers.schemas import Run
 if TYPE_CHECKING:
     from uuid import UUID
 
-Listener = Union[Callable[[Run], None], Callable[[Run, RunnableConfig], None]]
-AsyncListener = Union[
-    Callable[[Run], Awaitable[None]], Callable[[Run, RunnableConfig], Awaitable[None]]
-]
+Listener = Callable[[Run], None] | Callable[[Run, RunnableConfig], None]
+AsyncListener = (
+    Callable[[Run], Awaitable[None]] | Callable[[Run, RunnableConfig], Awaitable[None]]
+)
 
 
 class RootListenersTracer(BaseTracer):
@@ -30,9 +30,9 @@ class RootListenersTracer(BaseTracer):
         self,
         *,
         config: RunnableConfig,
-        on_start: Optional[Listener],
-        on_end: Optional[Listener],
-        on_error: Optional[Listener],
+        on_start: Listener | None,
+        on_end: Listener | None,
+        on_error: Listener | None,
     ) -> None:
         """Initialize the tracer.
 
@@ -48,7 +48,7 @@ class RootListenersTracer(BaseTracer):
         self._arg_on_start = on_start
         self._arg_on_end = on_end
         self._arg_on_error = on_error
-        self.root_id: Optional[UUID] = None
+        self.root_id: UUID | None = None
 
     def _persist_run(self, run: Run) -> None:
         # This is a legacy method only called once for an entire run tree
@@ -85,9 +85,9 @@ class AsyncRootListenersTracer(AsyncBaseTracer):
         self,
         *,
         config: RunnableConfig,
-        on_start: Optional[AsyncListener],
-        on_end: Optional[AsyncListener],
-        on_error: Optional[AsyncListener],
+        on_start: AsyncListener | None,
+        on_end: AsyncListener | None,
+        on_error: AsyncListener | None,
     ) -> None:
         """Initialize the tracer.
 
@@ -103,7 +103,7 @@ class AsyncRootListenersTracer(AsyncBaseTracer):
         self._arg_on_start = on_start
         self._arg_on_end = on_end
         self._arg_on_error = on_error
-        self.root_id: Optional[UUID] = None
+        self.root_id: UUID | None = None
 
     async def _persist_run(self, run: Run) -> None:
         # This is a legacy method only called once for an entire run tree

langchain_core/tracers/run_collector.py

@@ -1,6 +1,6 @@
 """A tracer that collects all nested runs in a list."""
 
-from typing import Any, Optional, Union
+from typing import Any
 from uuid import UUID
 
 from langchain_core.tracers.base import BaseTracer
@@ -15,9 +15,7 @@ class RunCollectorCallbackHandler(BaseTracer):
 
     name: str = "run-collector_callback_handler"
 
-    def __init__(
-        self, example_id: Optional[Union[UUID, str]] = None, **kwargs: Any
-    ) -> None:
+    def __init__(self, example_id: UUID | str | None = None, **kwargs: Any) -> None:
         """Initialize the RunCollectorCallbackHandler.
 
         Args:

langchain_core/tracers/schemas.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import warnings
 from datetime import datetime, timezone
-from typing import Any, Optional
+from typing import Any
 from uuid import UUID
 
 from langsmith import RunTree
@@ -37,8 +37,8 @@ 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
+    name: str | None = None
+    extra: dict[str, Any] | None = None
 
 
 @deprecated("0.1.0", removal="1.0")
@@ -72,15 +72,15 @@ class BaseRun(BaseModelV1):
     """Base class for Run."""
 
     uuid: str
-    parent_uuid: Optional[str] = None
+    parent_uuid: str | None = 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
+    extra: dict[str, Any] | None = None
     execution_order: int
     child_execution_order: int
     serialized: dict[str, Any]
     session_id: int
-    error: Optional[str] = None
+    error: str | None = None
 
 
 @deprecated("0.1.0", alternative="Run", removal="1.0")
@@ -97,7 +97,7 @@ class ChainRun(BaseRun):
     """Class for ChainRun."""
 
     inputs: dict[str, Any]
-    outputs: Optional[dict[str, Any]] = None
+    outputs: dict[str, Any] | None = 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)
@@ -108,7 +108,7 @@ class ToolRun(BaseRun):
     """Class for ToolRun."""
 
     tool_input: str
-    output: Optional[str] = None
+    output: str | None = None
     action: str
     child_llm_runs: list[LLMRun] = FieldV1(default_factory=list)
     child_chain_runs: list[ChainRun] = FieldV1(default_factory=list)

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

langchain_core/utils/__init__.py

@@ -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]:
@@ -80,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:

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, Any, None]]:
+    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.
@@ -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,9 +88,9 @@ 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:
         """Return False, exception not suppressed."""
         return False
@@ -106,7 +104,7 @@ 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
@@ -172,22 +170,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.
 
     """
@@ -197,7 +195,7 @@ class Tee(Generic[T]):
         iterable: AsyncIterator[T],
         n: int = 2,
         *,
-        lock: Optional[AbstractAsyncContextManager[Any]] = None,
+        lock: AbstractAsyncContextManager[Any] | None = None,
     ):
         """Create a ``tee``.
 
@@ -230,8 +228,8 @@ 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]
 
@@ -249,9 +247,9 @@ 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.
 
@@ -292,9 +290,7 @@ class aclosing(AbstractAsyncContextManager):  # noqa: N801
 
     """
 
-    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:
@@ -303,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()

langchain_core/utils/env.py

@@ -3,7 +3,7 @@
 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:
@@ -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.
 
@@ -56,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: