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

langchain_core/language_models/llms.py

@@ -7,21 +7,17 @@ import functools
 import inspect
 import json
 import logging
-import warnings
 from abc import ABC, abstractmethod
-from collections.abc import AsyncIterator, Iterator, Sequence
+from collections.abc import AsyncIterator, Callable, Iterator, Sequence
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Optional,
-    Union,
     cast,
 )
 
 import yaml
-from pydantic import ConfigDict, Field, model_validator
+from pydantic import ConfigDict
 from tenacity import (
     RetryCallState,
     before_sleep_log,
@@ -33,7 +29,6 @@ from tenacity import (
 )
 from typing_extensions import override
 
-from langchain_core._api import deprecated
 from langchain_core.caches import BaseCache
 from langchain_core.callbacks import (
     AsyncCallbackManager,
@@ -51,10 +46,7 @@ from langchain_core.language_models.base import (
 )
 from langchain_core.load import dumpd
 from langchain_core.messages import (
-    AIMessage,
-    BaseMessage,
     convert_to_messages,
-    get_buffer_string,
 )
 from langchain_core.outputs import Generation, GenerationChunk, LLMResult, RunInfo
 from langchain_core.prompt_values import ChatPromptValue, PromptValue, StringPromptValue
@@ -76,9 +68,7 @@ def _log_error_once(msg: str) -> None:
 def create_base_retry_decorator(
     error_types: list[type[BaseException]],
     max_retries: int = 1,
-    run_manager: Optional[
-        Union[AsyncCallbackManagerForLLMRun, CallbackManagerForLLMRun]
-    ] = None,
+    run_manager: AsyncCallbackManagerForLLMRun | CallbackManagerForLLMRun | None = None,
 ) -> Callable[[Any], Any]:
     """Create a retry decorator for a given LLM and provided a list of error types.
 
@@ -129,9 +119,9 @@ def create_base_retry_decorator(
     )
 
 
-def _resolve_cache(*, cache: Union[BaseCache, bool, None]) -> Optional[BaseCache]:
+def _resolve_cache(*, cache: BaseCache | bool | None) -> BaseCache | None:
     """Resolve the cache."""
-    llm_cache: Optional[BaseCache]
+    llm_cache: BaseCache | None
     if isinstance(cache, BaseCache):
         llm_cache = cache
     elif cache is None:
@@ -156,7 +146,7 @@ def _resolve_cache(*, cache: Union[BaseCache, bool, None]) -> Optional[BaseCache
 def get_prompts(
     params: dict[str, Any],
     prompts: list[str],
-    cache: Union[BaseCache, bool, None] = None,  # noqa: FBT001
+    cache: BaseCache | bool | None = None,  # noqa: FBT001
 ) -> tuple[dict[int, list], str, list[int], list[str]]:
     """Get prompts that are already cached.
 
@@ -192,7 +182,7 @@ def get_prompts(
 async def aget_prompts(
     params: dict[str, Any],
     prompts: list[str],
-    cache: Union[BaseCache, bool, None] = None,  # noqa: FBT001
+    cache: BaseCache | bool | None = None,  # noqa: FBT001
 ) -> tuple[dict[int, list], str, list[int], list[str]]:
     """Get prompts that are already cached. Async version.
 
@@ -225,13 +215,13 @@ async def aget_prompts(
 
 
 def update_cache(
-    cache: Union[BaseCache, bool, None],  # noqa: FBT001
+    cache: BaseCache | bool | None,  # noqa: FBT001
     existing_prompts: dict[int, list],
     llm_string: str,
     missing_prompt_idxs: list[int],
     new_results: LLMResult,
     prompts: list[str],
-) -> Optional[dict]:
+) -> dict | None:
     """Update the cache and get the LLM output.
 
     Args:
@@ -258,13 +248,13 @@ def update_cache(
 
 
 async def aupdate_cache(
-    cache: Union[BaseCache, bool, None],  # noqa: FBT001
+    cache: BaseCache | bool | None,  # noqa: FBT001
     existing_prompts: dict[int, list],
     llm_string: str,
     missing_prompt_idxs: list[int],
     new_results: LLMResult,
     prompts: list[str],
-) -> Optional[dict]:
+) -> dict | None:
     """Update the cache and get the LLM output. Async version.
 
     Args:
@@ -296,26 +286,10 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     It should take in a prompt and return a string.
     """
 
-    callback_manager: Optional[BaseCallbackManager] = Field(default=None, exclude=True)
-    """[DEPRECATED]"""
-
     model_config = ConfigDict(
         arbitrary_types_allowed=True,
     )
 
-    @model_validator(mode="before")
-    @classmethod
-    def raise_deprecation(cls, values: dict) -> Any:
-        """Raise deprecation warning if callback_manager is used."""
-        if values.get("callback_manager") is not None:
-            warnings.warn(
-                "callback_manager is deprecated. Please use callbacks instead.",
-                DeprecationWarning,
-                stacklevel=5,
-            )
-            values["callbacks"] = values.pop("callback_manager", None)
-        return values
-
     @functools.cached_property
     def _serialized(self) -> dict[str, Any]:
         return dumpd(self)
@@ -343,7 +317,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
 
     def _get_ls_params(
         self,
-        stop: Optional[list[str]] = None,
+        stop: list[str] | None = None,
         **kwargs: Any,
     ) -> LangSmithParams:
         """Get standard params for tracing."""
@@ -382,9 +356,9 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     def invoke(
         self,
         input: LanguageModelInput,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         *,
-        stop: Optional[list[str]] = None,
+        stop: list[str] | None = None,
         **kwargs: Any,
     ) -> str:
         config = ensure_config(config)
@@ -407,9 +381,9 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     async def ainvoke(
         self,
         input: LanguageModelInput,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         *,
-        stop: Optional[list[str]] = None,
+        stop: list[str] | None = None,
         **kwargs: Any,
     ) -> str:
         config = ensure_config(config)
@@ -429,7 +403,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     def batch(
         self,
         inputs: list[LanguageModelInput],
-        config: Optional[Union[RunnableConfig, list[RunnableConfig]]] = None,
+        config: RunnableConfig | list[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
         **kwargs: Any,
@@ -476,7 +450,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     async def abatch(
         self,
         inputs: list[LanguageModelInput],
-        config: Optional[Union[RunnableConfig, list[RunnableConfig]]] = None,
+        config: RunnableConfig | list[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
         **kwargs: Any,
@@ -522,9 +496,9 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     def stream(
         self,
         input: LanguageModelInput,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         *,
-        stop: Optional[list[str]] = None,
+        stop: list[str] | None = None,
         **kwargs: Any,
     ) -> Iterator[str]:
         if type(self)._stream == BaseLLM._stream:  # noqa: SLF001
@@ -559,7 +533,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                 run_id=config.pop("run_id", None),
                 batch_size=1,
             )
-            generation: Optional[GenerationChunk] = None
+            generation: GenerationChunk | None = None
             try:
                 for chunk in self._stream(
                     prompt, stop=stop, run_manager=run_manager, **kwargs
@@ -589,9 +563,9 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     async def astream(
         self,
         input: LanguageModelInput,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         *,
-        stop: Optional[list[str]] = None,
+        stop: list[str] | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[str]:
         if (
@@ -629,7 +603,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
             run_id=config.pop("run_id", None),
             batch_size=1,
         )
-        generation: Optional[GenerationChunk] = None
+        generation: GenerationChunk | None = None
         try:
             async for chunk in self._astream(
                 prompt,
@@ -662,8 +636,8 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     def _generate(
         self,
         prompts: list[str],
-        stop: Optional[list[str]] = None,
-        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        stop: list[str] | None = None,
+        run_manager: CallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> LLMResult:
         """Run the LLM on the given prompts.
@@ -682,8 +656,8 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     async def _agenerate(
         self,
         prompts: list[str],
-        stop: Optional[list[str]] = None,
-        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        stop: list[str] | None = None,
+        run_manager: AsyncCallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> LLMResult:
         """Run the LLM on the given prompts.
@@ -710,8 +684,8 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     def _stream(
         self,
         prompt: str,
-        stop: Optional[list[str]] = None,
-        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        stop: list[str] | None = None,
+        run_manager: CallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> Iterator[GenerationChunk]:
         """Stream the LLM on the given prompt.
@@ -738,8 +712,8 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     async def _astream(
         self,
         prompt: str,
-        stop: Optional[list[str]] = None,
-        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        stop: list[str] | None = None,
+        run_manager: AsyncCallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[GenerationChunk]:
         """An async version of the _stream method.
@@ -783,8 +757,8 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     def generate_prompt(
         self,
         prompts: list[PromptValue],
-        stop: Optional[list[str]] = None,
-        callbacks: Optional[Union[Callbacks, list[Callbacks]]] = None,
+        stop: list[str] | None = None,
+        callbacks: Callbacks | list[Callbacks] | None = None,
         **kwargs: Any,
     ) -> LLMResult:
         prompt_strings = [p.to_string() for p in prompts]
@@ -794,8 +768,8 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     async def agenerate_prompt(
         self,
         prompts: list[PromptValue],
-        stop: Optional[list[str]] = None,
-        callbacks: Optional[Union[Callbacks, list[Callbacks]]] = None,
+        stop: list[str] | None = None,
+        callbacks: Callbacks | list[Callbacks] | None = None,
         **kwargs: Any,
     ) -> LLMResult:
         prompt_strings = [p.to_string() for p in prompts]
@@ -806,7 +780,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     def _generate_helper(
         self,
         prompts: list[str],
-        stop: Optional[list[str]],
+        stop: list[str] | None,
         run_managers: list[CallbackManagerForLLMRun],
         *,
         new_arg_supported: bool,
@@ -829,7 +803,9 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                 run_manager.on_llm_error(e, response=LLMResult(generations=[]))
             raise
         flattened_outputs = output.flatten()
-        for manager, flattened_output in zip(run_managers, flattened_outputs):
+        for manager, flattened_output in zip(
+            run_managers, flattened_outputs, strict=False
+        ):
             manager.on_llm_end(flattened_output)
         if run_managers:
             output.run = [
@@ -840,13 +816,13 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     def generate(
         self,
         prompts: list[str],
-        stop: Optional[list[str]] = None,
-        callbacks: Optional[Union[Callbacks, list[Callbacks]]] = None,
+        stop: list[str] | None = None,
+        callbacks: Callbacks | list[Callbacks] | None = None,
         *,
-        tags: Optional[Union[list[str], list[list[str]]]] = None,
-        metadata: Optional[Union[dict[str, Any], list[dict[str, Any]]]] = None,
-        run_name: Optional[Union[str, list[str]]] = None,
-        run_id: Optional[Union[uuid.UUID, list[Optional[uuid.UUID]]]] = None,
+        tags: list[str] | list[list[str]] | None = None,
+        metadata: dict[str, Any] | list[dict[str, Any]] | None = None,
+        run_name: str | list[str] | None = None,
+        run_id: uuid.UUID | list[uuid.UUID | None] | None = None,
         **kwargs: Any,
     ) -> LLMResult:
         """Pass a sequence of prompts to a model and return generations.
@@ -936,14 +912,12 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                 msg = "run_name must be a list of the same length as prompts"
                 raise ValueError(msg)
             callbacks = cast("list[Callbacks]", callbacks)
-            tags_list = cast(
-                "list[Optional[list[str]]]", tags or ([None] * len(prompts))
-            )
+            tags_list = cast("list[list[str] | None]", tags or ([None] * len(prompts)))
             metadata_list = cast(
-                "list[Optional[dict[str, Any]]]", metadata or ([{}] * len(prompts))
+                "list[dict[str, Any] | None]", metadata or ([{}] * len(prompts))
             )
             run_name_list = run_name or cast(
-                "list[Optional[str]]", ([None] * len(prompts))
+                "list[str | None]", ([None] * len(prompts))
             )
             callback_managers = [
                 CallbackManager.configure(
@@ -955,7 +929,9 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                     meta,
                     self.metadata,
                 )
-                for callback, tag, meta in zip(callbacks, tags_list, metadata_list)
+                for callback, tag, meta in zip(
+                    callbacks, tags_list, metadata_list, strict=False
+                )
             ]
         else:
             # We've received a single callbacks arg to apply to all inputs
@@ -970,7 +946,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                     self.metadata,
                 )
             ] * len(prompts)
-            run_name_list = [cast("Optional[str]", run_name)] * len(prompts)
+            run_name_list = [cast("str | None", run_name)] * len(prompts)
         run_ids_list = self._get_run_ids_list(run_id, prompts)
         params = self.dict()
         params["stop"] = stop
@@ -996,7 +972,11 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                     run_id=run_id_,
                 )[0]
                 for callback_manager, prompt, run_name, run_id_ in zip(
-                    callback_managers, prompts, run_name_list, run_ids_list
+                    callback_managers,
+                    prompts,
+                    run_name_list,
+                    run_ids_list,
+                    strict=False,
                 )
             ]
             return self._generate_helper(
@@ -1046,7 +1026,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
 
     @staticmethod
     def _get_run_ids_list(
-        run_id: Optional[Union[uuid.UUID, list[Optional[uuid.UUID]]]], prompts: list
+        run_id: uuid.UUID | list[uuid.UUID | None] | None, prompts: list
     ) -> list:
         if run_id is None:
             return [None] * len(prompts)
@@ -1063,7 +1043,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     async def _agenerate_helper(
         self,
         prompts: list[str],
-        stop: Optional[list[str]],
+        stop: list[str] | None,
         run_managers: list[AsyncCallbackManagerForLLMRun],
         *,
         new_arg_supported: bool,
@@ -1093,7 +1073,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
             *[
                 run_manager.on_llm_end(flattened_output)
                 for run_manager, flattened_output in zip(
-                    run_managers, flattened_outputs
+                    run_managers, flattened_outputs, strict=False
                 )
             ]
         )
@@ -1106,13 +1086,13 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     async def agenerate(
         self,
         prompts: list[str],
-        stop: Optional[list[str]] = None,
-        callbacks: Optional[Union[Callbacks, list[Callbacks]]] = None,
+        stop: list[str] | None = None,
+        callbacks: Callbacks | list[Callbacks] | None = None,
         *,
-        tags: Optional[Union[list[str], list[list[str]]]] = None,
-        metadata: Optional[Union[dict[str, Any], list[dict[str, Any]]]] = None,
-        run_name: Optional[Union[str, list[str]]] = None,
-        run_id: Optional[Union[uuid.UUID, list[Optional[uuid.UUID]]]] = None,
+        tags: list[str] | list[list[str]] | None = None,
+        metadata: dict[str, Any] | list[dict[str, Any]] | None = None,
+        run_name: str | list[str] | None = None,
+        run_id: uuid.UUID | list[uuid.UUID | None] | None = None,
         **kwargs: Any,
     ) -> LLMResult:
         """Asynchronously pass a sequence of prompts to a model and return generations.
@@ -1191,14 +1171,12 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                 msg = "run_name must be a list of the same length as prompts"
                 raise ValueError(msg)
             callbacks = cast("list[Callbacks]", callbacks)
-            tags_list = cast(
-                "list[Optional[list[str]]]", tags or ([None] * len(prompts))
-            )
+            tags_list = cast("list[list[str] | None]", tags or ([None] * len(prompts)))
             metadata_list = cast(
-                "list[Optional[dict[str, Any]]]", metadata or ([{}] * len(prompts))
+                "list[dict[str, Any] | None]", metadata or ([{}] * len(prompts))
             )
             run_name_list = run_name or cast(
-                "list[Optional[str]]", ([None] * len(prompts))
+                "list[str | None]", ([None] * len(prompts))
             )
             callback_managers = [
                 AsyncCallbackManager.configure(
@@ -1210,7 +1188,9 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                     meta,
                     self.metadata,
                 )
-                for callback, tag, meta in zip(callbacks, tags_list, metadata_list)
+                for callback, tag, meta in zip(
+                    callbacks, tags_list, metadata_list, strict=False
+                )
             ]
         else:
             # We've received a single callbacks arg to apply to all inputs
@@ -1225,7 +1205,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                     self.metadata,
                 )
             ] * len(prompts)
-            run_name_list = [cast("Optional[str]", run_name)] * len(prompts)
+            run_name_list = [cast("str | None", run_name)] * len(prompts)
         run_ids_list = self._get_run_ids_list(run_id, prompts)
         params = self.dict()
         params["stop"] = stop
@@ -1255,7 +1235,11 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                         run_id=run_id_,
                     )
                     for callback_manager, prompt, run_name, run_id_ in zip(
-                        callback_managers, prompts, run_name_list, run_ids_list
+                        callback_managers,
+                        prompts,
+                        run_name_list,
+                        run_ids_list,
+                        strict=False,
                     )
                 ]
             )
@@ -1308,64 +1292,14 @@ class BaseLLM(BaseLanguageModel[str], ABC):
         generations = [existing_prompts[i] for i in range(len(prompts))]
         return LLMResult(generations=generations, llm_output=llm_output, run=run_info)
 
-    @deprecated("0.1.7", alternative="invoke", removal="1.0")
-    def __call__(
-        self,
-        prompt: str,
-        stop: Optional[list[str]] = None,
-        callbacks: Callbacks = None,
-        *,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        **kwargs: Any,
-    ) -> str:
-        """Check Cache and run the LLM on the given prompt and input.
-
-        Args:
-            prompt: The prompt to generate from.
-            stop: Stop words to use when generating. Model output is cut off at the
-                first occurrence of any of these substrings.
-            callbacks: Callbacks to pass through. Used for executing additional
-                functionality, such as logging or streaming, throughout generation.
-            tags: List of tags to associate with the prompt.
-            metadata: Metadata to associate with the prompt.
-            **kwargs: Arbitrary additional keyword arguments. These are usually passed
-                to the model provider API call.
-
-        Returns:
-            The generated text.
-
-        Raises:
-            ValueError: If the prompt is not a string.
-        """
-        if not isinstance(prompt, str):
-            msg = (
-                "Argument `prompt` is expected to be a string. Instead found "
-                f"{type(prompt)}. If you want to run the LLM on multiple prompts, use "
-                "`generate` instead."
-            )
-            raise ValueError(msg)  # noqa: TRY004
-        return (
-            self.generate(
-                [prompt],
-                stop=stop,
-                callbacks=callbacks,
-                tags=tags,
-                metadata=metadata,
-                **kwargs,
-            )
-            .generations[0][0]
-            .text
-        )
-
     async def _call_async(
         self,
         prompt: str,
-        stop: Optional[list[str]] = None,
+        stop: list[str] | None = None,
         callbacks: Callbacks = None,
         *,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
+        tags: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> str:
         """Check Cache and run the LLM on the given prompt and input."""
@@ -1379,50 +1313,6 @@ class BaseLLM(BaseLanguageModel[str], ABC):
         )
         return result.generations[0][0].text
 
-    @deprecated("0.1.7", alternative="invoke", removal="1.0")
-    @override
-    def predict(
-        self, text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any
-    ) -> str:
-        stop_ = None if stop is None else list(stop)
-        return self(text, stop=stop_, **kwargs)
-
-    @deprecated("0.1.7", alternative="invoke", removal="1.0")
-    @override
-    def predict_messages(
-        self,
-        messages: list[BaseMessage],
-        *,
-        stop: Optional[Sequence[str]] = None,
-        **kwargs: Any,
-    ) -> BaseMessage:
-        text = get_buffer_string(messages)
-        stop_ = None if stop is None else list(stop)
-        content = self(text, stop=stop_, **kwargs)
-        return AIMessage(content=content)
-
-    @deprecated("0.1.7", alternative="ainvoke", removal="1.0")
-    @override
-    async def apredict(
-        self, text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any
-    ) -> str:
-        stop_ = None if stop is None else list(stop)
-        return await self._call_async(text, stop=stop_, **kwargs)
-
-    @deprecated("0.1.7", alternative="ainvoke", removal="1.0")
-    @override
-    async def apredict_messages(
-        self,
-        messages: list[BaseMessage],
-        *,
-        stop: Optional[Sequence[str]] = None,
-        **kwargs: Any,
-    ) -> BaseMessage:
-        text = get_buffer_string(messages)
-        stop_ = None if stop is None else list(stop)
-        content = await self._call_async(text, stop=stop_, **kwargs)
-        return AIMessage(content=content)
-
     def __str__(self) -> str:
         """Return a string representation of the object for printing."""
         cls_name = f"\033[1m{self.__class__.__name__}\033[0m"
@@ -1440,7 +1330,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
         starter_dict["_type"] = self._llm_type
         return starter_dict
 
-    def save(self, file_path: Union[Path, str]) -> None:
+    def save(self, file_path: Path | str) -> None:
         """Save the LLM.
 
         Args:
@@ -1510,8 +1400,8 @@ class LLM(BaseLLM):
     def _call(
         self,
         prompt: str,
-        stop: Optional[list[str]] = None,
-        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        stop: list[str] | None = None,
+        run_manager: CallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> str:
         """Run the LLM on the given input.
@@ -1534,8 +1424,8 @@ class LLM(BaseLLM):
     async def _acall(
         self,
         prompt: str,
-        stop: Optional[list[str]] = None,
-        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        stop: list[str] | None = None,
+        run_manager: AsyncCallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> str:
         """Async version of the _call method.
@@ -1568,8 +1458,8 @@ class LLM(BaseLLM):
     def _generate(
         self,
         prompts: list[str],
-        stop: Optional[list[str]] = None,
-        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        stop: list[str] | None = None,
+        run_manager: CallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> LLMResult:
         # TODO: add caching here.
@@ -1587,8 +1477,8 @@ class LLM(BaseLLM):
     async def _agenerate(
         self,
         prompts: list[str],
-        stop: Optional[list[str]] = None,
-        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        stop: list[str] | None = None,
+        run_manager: AsyncCallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> LLMResult:
         generations = []

langchain_core/load/dump.py

@@ -72,7 +72,7 @@ def dumps(obj: Any, *, pretty: bool = False, **kwargs: Any) -> str:
 def dumpd(obj: Any) -> Any:
     """Return a dict representation of an object.
 
-    .. note::
+    !!! note
         Unfortunately this function is not as efficient as it could be because it first
         dumps the object to a json string and then loads it back into a dictionary.