langchain 0.3.26__py3-none-any.whl → 0.4.0.dev0__py3-none-any.whl

langchain/chains/base.py

@@ -1,6 +1,7 @@
 """Base interface that all chains should implement."""
 
 import builtins
+import contextlib
 import inspect
 import json
 import logging
@@ -35,6 +36,7 @@ from pydantic import (
     field_validator,
     model_validator,
 )
+from typing_extensions import override
 
 from langchain.schema import RUN_KEY
 
@@ -106,18 +108,26 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
         arbitrary_types_allowed=True,
     )
 
+    @override
     def get_input_schema(
-        self, config: Optional[RunnableConfig] = None
+        self,
+        config: Optional[RunnableConfig] = None,
     ) -> type[BaseModel]:
         # This is correct, but pydantic typings/mypy don't think so.
-        return create_model("ChainInput", **{k: (Any, None) for k in self.input_keys})
+        return create_model("ChainInput", **dict.fromkeys(self.input_keys, (Any, None)))
 
+    @override
     def get_output_schema(
-        self, config: Optional[RunnableConfig] = None
+        self,
+        config: Optional[RunnableConfig] = None,
     ) -> type[BaseModel]:
         # This is correct, but pydantic typings/mypy don't think so.
-        return create_model("ChainOutput", **{k: (Any, None) for k in self.output_keys})
+        return create_model(
+            "ChainOutput",
+            **dict.fromkeys(self.output_keys, (Any, None)),
+        )
 
+    @override
     def invoke(
         self,
         input: dict[str, Any],
@@ -160,17 +170,20 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
             )
 
             final_outputs: dict[str, Any] = self.prep_outputs(
-                inputs, outputs, return_only_outputs
+                inputs,
+                outputs,
+                return_only_outputs,
             )
         except BaseException as e:
             run_manager.on_chain_error(e)
-            raise e
+            raise
         run_manager.on_chain_end(outputs)
 
         if include_run_info:
             final_outputs[RUN_KEY] = RunInfo(run_id=run_manager.run_id)
         return final_outputs
 
+    @override
     async def ainvoke(
         self,
         input: dict[str, Any],
@@ -211,11 +224,13 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
                 else await self._acall(inputs)
             )
             final_outputs: dict[str, Any] = await self.aprep_outputs(
-                inputs, outputs, return_only_outputs
+                inputs,
+                outputs,
+                return_only_outputs,
             )
         except BaseException as e:
             await run_manager.on_chain_error(e)
-            raise e
+            raise
         await run_manager.on_chain_end(outputs)
 
         if include_run_info:
@@ -224,7 +239,8 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
 
     @property
     def _chain_type(self) -> str:
-        raise NotImplementedError("Saving not supported for this chain type.")
+        msg = "Saving not supported for this chain type."
+        raise NotImplementedError(msg)
 
     @model_validator(mode="before")
     @classmethod
@@ -232,29 +248,33 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
         """Raise deprecation warning if callback_manager is used."""
         if values.get("callback_manager") is not None:
             if values.get("callbacks") is not None:
-                raise ValueError(
+                msg = (
                     "Cannot specify both callback_manager and callbacks. "
                     "callback_manager is deprecated, callbacks is the preferred "
                     "parameter to pass in."
                 )
+                raise ValueError(msg)
             warnings.warn(
                 "callback_manager is deprecated. Please use callbacks instead.",
                 DeprecationWarning,
+                stacklevel=4,
             )
             values["callbacks"] = values.pop("callback_manager", None)
         return values
 
     @field_validator("verbose", mode="before")
     @classmethod
-    def set_verbose(cls, verbose: Optional[bool]) -> bool:
+    def set_verbose(
+        cls,
+        verbose: Optional[bool],  # noqa: FBT001
+    ) -> bool:
         """Set the chain verbosity.
 
         Defaults to the global setting if not specified by the user.
         """
         if verbose is None:
             return _get_verbosity()
-        else:
-            return verbose
+        return verbose
 
     @property
     @abstractmethod
@@ -275,21 +295,24 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
                 # only one is not set, we can still figure out which key it is.
                 _input_keys = _input_keys.difference(self.memory.memory_variables)
             if len(_input_keys) != 1:
-                raise ValueError(
+                msg = (
                     f"A single string input was passed in, but this chain expects "
                     f"multiple inputs ({_input_keys}). When a chain expects "
                     f"multiple inputs, please call it by passing in a dictionary, "
                     "eg `chain({'foo': 1, 'bar': 2})`"
                 )
+                raise ValueError(msg)
 
         missing_keys = set(self.input_keys).difference(inputs)
         if missing_keys:
-            raise ValueError(f"Missing some input keys: {missing_keys}")
+            msg = f"Missing some input keys: {missing_keys}"
+            raise ValueError(msg)
 
     def _validate_outputs(self, outputs: dict[str, Any]) -> None:
         missing_keys = set(self.output_keys).difference(outputs)
         if missing_keys:
-            raise ValueError(f"Missing some output keys: {missing_keys}")
+            msg = f"Missing some output keys: {missing_keys}"
+            raise ValueError(msg)
 
     @abstractmethod
     def _call(
@@ -336,14 +359,17 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
                 `Chain.output_keys`.
         """
         return await run_in_executor(
-            None, self._call, inputs, run_manager.get_sync() if run_manager else None
+            None,
+            self._call,
+            inputs,
+            run_manager.get_sync() if run_manager else None,
         )
 
     @deprecated("0.1.0", alternative="invoke", removal="1.0")
     def __call__(
         self,
         inputs: Union[dict[str, Any], Any],
-        return_only_outputs: bool = False,
+        return_only_outputs: bool = False,  # noqa: FBT001,FBT002
         callbacks: Callbacks = None,
         *,
         tags: Optional[list[str]] = None,
@@ -385,7 +411,7 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
 
         return self.invoke(
             inputs,
-            cast(RunnableConfig, {k: v for k, v in config.items() if v is not None}),
+            cast("RunnableConfig", {k: v for k, v in config.items() if v is not None}),
             return_only_outputs=return_only_outputs,
             include_run_info=include_run_info,
         )
@@ -394,7 +420,7 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
     async def acall(
         self,
         inputs: Union[dict[str, Any], Any],
-        return_only_outputs: bool = False,
+        return_only_outputs: bool = False,  # noqa: FBT001,FBT002
         callbacks: Callbacks = None,
         *,
         tags: Optional[list[str]] = None,
@@ -435,7 +461,7 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
         }
         return await self.ainvoke(
             inputs,
-            cast(RunnableConfig, {k: v for k, v in config.items() if k is not None}),
+            cast("RunnableConfig", {k: v for k, v in config.items() if k is not None}),
             return_only_outputs=return_only_outputs,
             include_run_info=include_run_info,
         )
@@ -444,7 +470,7 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
         self,
         inputs: dict[str, str],
         outputs: dict[str, str],
-        return_only_outputs: bool = False,
+        return_only_outputs: bool = False,  # noqa: FBT001,FBT002
     ) -> dict[str, str]:
         """Validate and prepare chain outputs, and save info about this run to memory.
 
@@ -463,14 +489,13 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
             self.memory.save_context(inputs, outputs)
         if return_only_outputs:
             return outputs
-        else:
-            return {**inputs, **outputs}
+        return {**inputs, **outputs}
 
     async def aprep_outputs(
         self,
         inputs: dict[str, str],
         outputs: dict[str, str],
-        return_only_outputs: bool = False,
+        return_only_outputs: bool = False,  # noqa: FBT001,FBT002
     ) -> dict[str, str]:
         """Validate and prepare chain outputs, and save info about this run to memory.
 
@@ -489,8 +514,7 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
             await self.memory.asave_context(inputs, outputs)
         if return_only_outputs:
             return outputs
-        else:
-            return {**inputs, **outputs}
+        return {**inputs, **outputs}
 
     def prep_inputs(self, inputs: Union[dict[str, Any], Any]) -> dict[str, str]:
         """Prepare chain inputs, including adding inputs from memory.
@@ -510,7 +534,7 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
                 # If there are multiple input keys, but some get set by memory so that
                 # only one is not set, we can still figure out which key it is.
                 _input_keys = _input_keys.difference(self.memory.memory_variables)
-            inputs = {list(_input_keys)[0]: inputs}
+            inputs = {next(iter(_input_keys)): inputs}
         if self.memory is not None:
             external_context = self.memory.load_memory_variables(inputs)
             inputs = dict(inputs, **external_context)
@@ -534,7 +558,7 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
                 # If there are multiple input keys, but some get set by memory so that
                 # only one is not set, we can still figure out which key it is.
                 _input_keys = _input_keys.difference(self.memory.memory_variables)
-            inputs = {list(_input_keys)[0]: inputs}
+            inputs = {next(iter(_input_keys)): inputs}
         if self.memory is not None:
             external_context = await self.memory.aload_memory_variables(inputs)
             inputs = dict(inputs, **external_context)
@@ -543,10 +567,11 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
     @property
     def _run_output_key(self) -> str:
         if len(self.output_keys) != 1:
-            raise ValueError(
+            msg = (
                 f"`run` not supported when there is not exactly "
                 f"one output key. Got {self.output_keys}."
             )
+            raise ValueError(msg)
         return self.output_keys[0]
 
     @deprecated("0.1.0", alternative="invoke", removal="1.0")
@@ -593,13 +618,15 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
                 context = "Weather report for Boise, Idaho on 07/03/23..."
                 chain.run(question=question, context=context)
                 # -> "The temperature in Boise is..."
+
         """
         # Run at start to make sure this is possible/defined
         _output_key = self._run_output_key
 
         if args and not kwargs:
             if len(args) != 1:
-                raise ValueError("`run` supports only one positional argument.")
+                msg = "`run` supports only one positional argument."
+                raise ValueError(msg)
             return self(args[0], callbacks=callbacks, tags=tags, metadata=metadata)[
                 _output_key
             ]
@@ -610,15 +637,16 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
             ]
 
         if not kwargs and not args:
-            raise ValueError(
+            msg = (
                 "`run` supported with either positional arguments or keyword arguments,"
                 " but none were provided."
             )
-        else:
-            raise ValueError(
-                f"`run` supported with either positional arguments or keyword arguments"
-                f" but not both. Got args: {args} and kwargs: {kwargs}."
-            )
+            raise ValueError(msg)
+        msg = (
+            f"`run` supported with either positional arguments or keyword arguments"
+            f" but not both. Got args: {args} and kwargs: {kwargs}."
+        )
+        raise ValueError(msg)
 
     @deprecated("0.1.0", alternative="ainvoke", removal="1.0")
     async def arun(
@@ -665,32 +693,42 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
                 context = "Weather report for Boise, Idaho on 07/03/23..."
                 await chain.arun(question=question, context=context)
                 # -> "The temperature in Boise is..."
+
         """
         if len(self.output_keys) != 1:
-            raise ValueError(
+            msg = (
                 f"`run` not supported when there is not exactly "
                 f"one output key. Got {self.output_keys}."
             )
-        elif args and not kwargs:
+            raise ValueError(msg)
+        if args and not kwargs:
             if len(args) != 1:
-                raise ValueError("`run` supports only one positional argument.")
+                msg = "`run` supports only one positional argument."
+                raise ValueError(msg)
             return (
                 await self.acall(
-                    args[0], callbacks=callbacks, tags=tags, metadata=metadata
+                    args[0],
+                    callbacks=callbacks,
+                    tags=tags,
+                    metadata=metadata,
                 )
             )[self.output_keys[0]]
 
         if kwargs and not args:
             return (
                 await self.acall(
-                    kwargs, callbacks=callbacks, tags=tags, metadata=metadata
+                    kwargs,
+                    callbacks=callbacks,
+                    tags=tags,
+                    metadata=metadata,
                 )
             )[self.output_keys[0]]
 
-        raise ValueError(
+        msg = (
             f"`run` supported with either positional arguments or keyword arguments"
             f" but not both. Got args: {args} and kwargs: {kwargs}."
         )
+        raise ValueError(msg)
 
     def dict(self, **kwargs: Any) -> dict:
         """Dictionary representation of chain.
@@ -710,12 +748,11 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
 
                 chain.dict(exclude_unset=True)
                 # -> {"_type": "foo", "verbose": False, ...}
+
         """
         _dict = super().dict(**kwargs)
-        try:
+        with contextlib.suppress(NotImplementedError):
             _dict["_type"] = self._chain_type
-        except NotImplementedError:
-            pass
         return _dict
 
     def save(self, file_path: Union[Path, str]) -> None:
@@ -731,36 +768,39 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
             .. code-block:: python
 
                 chain.save(file_path="path/chain.yaml")
+
         """
         if self.memory is not None:
-            raise ValueError("Saving of memory is not yet supported.")
+            msg = "Saving of memory is not yet supported."
+            raise ValueError(msg)
 
         # Fetch dictionary to save
         chain_dict = self.dict()
         if "_type" not in chain_dict:
-            raise NotImplementedError(f"Chain {self} does not support saving.")
+            msg = f"Chain {self} does not support saving."
+            raise NotImplementedError(msg)
 
         # Convert file to Path object.
-        if isinstance(file_path, str):
-            save_path = Path(file_path)
-        else:
-            save_path = file_path
+        save_path = Path(file_path) if isinstance(file_path, str) else file_path
 
         directory_path = save_path.parent
         directory_path.mkdir(parents=True, exist_ok=True)
 
         if save_path.suffix == ".json":
-            with open(file_path, "w") as f:
+            with save_path.open("w") as f:
                 json.dump(chain_dict, f, indent=4)
         elif save_path.suffix.endswith((".yaml", ".yml")):
-            with open(file_path, "w") as f:
+            with save_path.open("w") as f:
                 yaml.dump(chain_dict, f, default_flow_style=False)
         else:
-            raise ValueError(f"{save_path} must be json or yaml")
+            msg = f"{save_path} must be json or yaml"
+            raise ValueError(msg)
 
     @deprecated("0.1.0", alternative="batch", removal="1.0")
     def apply(
-        self, input_list: list[builtins.dict[str, Any]], callbacks: Callbacks = None
+        self,
+        input_list: list[builtins.dict[str, Any]],
+        callbacks: Callbacks = None,
     ) -> list[builtins.dict[str, str]]:
         """Call the chain on all inputs in the list."""
         return [self(inputs, callbacks=callbacks) for inputs in input_list]

langchain/chains/chat_vector_db/prompts.py

@@ -1,4 +1,3 @@
-# flake8: noqa
 from langchain_core.prompts.prompt import PromptTemplate
 
 _template = """Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question.
@@ -6,7 +5,7 @@ _template = """Given the following conversation and a follow up question, rephra
 Chat History:
 {chat_history}
 Follow Up Input: {question}
-Standalone question:"""
+Standalone question:"""  # noqa: E501
 CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template)
 
 prompt_template = """Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.
@@ -14,7 +13,7 @@ prompt_template = """Use the following pieces of context to answer the question
 {context}
 
 Question: {question}
-Helpful Answer:"""
+Helpful Answer:"""  # noqa: E501
 QA_PROMPT = PromptTemplate(
     template=prompt_template, input_variables=["context", "question"]
 )

langchain/chains/combine_documents/__init__.py

@@ -10,6 +10,6 @@ from langchain.chains.combine_documents.stuff import create_stuff_documents_chai
 __all__ = [
     "acollapse_docs",
     "collapse_docs",
-    "split_list_of_docs",
     "create_stuff_documents_chain",
+    "split_list_of_docs",
 ]

langchain/chains/combine_documents/base.py

@@ -14,6 +14,7 @@ from langchain_core.runnables.config import RunnableConfig
 from langchain_core.utils.pydantic import create_model
 from langchain_text_splitters import RecursiveCharacterTextSplitter, TextSplitter
 from pydantic import BaseModel, Field
+from typing_extensions import override
 
 from langchain.chains.base import Chain
 
@@ -24,10 +25,11 @@ DEFAULT_DOCUMENT_PROMPT = PromptTemplate.from_template("{page_content}")
 
 def _validate_prompt(prompt: BasePromptTemplate, document_variable_name: str) -> None:
     if document_variable_name not in prompt.input_variables:
-        raise ValueError(
+        msg = (
             f"Prompt must accept {document_variable_name} as an input variable. "
             f"Received prompt with input variables: {prompt.input_variables}"
         )
+        raise ValueError(msg)
 
 
 class BaseCombineDocumentsChain(Chain, ABC):
@@ -45,16 +47,20 @@ class BaseCombineDocumentsChain(Chain, ABC):
     input_key: str = "input_documents"  #: :meta private:
     output_key: str = "output_text"  #: :meta private:
 
+    @override
     def get_input_schema(
-        self, config: Optional[RunnableConfig] = None
+        self,
+        config: Optional[RunnableConfig] = None,
     ) -> type[BaseModel]:
         return create_model(
             "CombineDocumentsInput",
             **{self.input_key: (list[Document], None)},
         )
 
+    @override
     def get_output_schema(
-        self, config: Optional[RunnableConfig] = None
+        self,
+        config: Optional[RunnableConfig] = None,
     ) -> type[BaseModel]:
         return create_model(
             "CombineDocumentsOutput",
@@ -77,7 +83,7 @@ class BaseCombineDocumentsChain(Chain, ABC):
         """
         return [self.output_key]
 
-    def prompt_length(self, docs: list[Document], **kwargs: Any) -> Optional[int]:
+    def prompt_length(self, docs: list[Document], **kwargs: Any) -> Optional[int]:  # noqa: ARG002
         """Return the prompt length given the documents passed in.
 
         This can be used by a caller to determine whether passing in a list
@@ -111,7 +117,9 @@ class BaseCombineDocumentsChain(Chain, ABC):
 
     @abstractmethod
     async def acombine_docs(
-        self, docs: list[Document], **kwargs: Any
+        self,
+        docs: list[Document],
+        **kwargs: Any,
     ) -> tuple[str, dict]:
         """Combine documents into a single string.
 
@@ -136,7 +144,9 @@ class BaseCombineDocumentsChain(Chain, ABC):
         # Other keys are assumed to be needed for LLM prediction
         other_keys = {k: v for k, v in inputs.items() if k != self.input_key}
         output, extra_return_dict = self.combine_docs(
-            docs, callbacks=_run_manager.get_child(), **other_keys
+            docs,
+            callbacks=_run_manager.get_child(),
+            **other_keys,
         )
         extra_return_dict[self.output_key] = output
         return extra_return_dict
@@ -152,7 +162,9 @@ class BaseCombineDocumentsChain(Chain, ABC):
         # Other keys are assumed to be needed for LLM prediction
         other_keys = {k: v for k, v in inputs.items() if k != self.input_key}
         output, extra_return_dict = await self.acombine_docs(
-            docs, callbacks=_run_manager.get_child(), **other_keys
+            docs,
+            callbacks=_run_manager.get_child(),
+            **other_keys,
         )
         extra_return_dict[self.output_key] = output
         return extra_return_dict
@@ -162,7 +174,7 @@ class BaseCombineDocumentsChain(Chain, ABC):
     since="0.2.7",
     alternative=(
         "example in API reference with more detail: "
-        "https://api.python.langchain.com/en/latest/chains/langchain.chains.combine_documents.base.AnalyzeDocumentChain.html"  # noqa: E501
+        "https://api.python.langchain.com/en/latest/chains/langchain.chains.combine_documents.base.AnalyzeDocumentChain.html"
     ),
     removal="1.0",
 )
@@ -222,6 +234,7 @@ class AnalyzeDocumentChain(Chain):
                     input_documents=itemgetter("input_document") | split_text,
                 ) | chain.pick("output_text")
             )
+
     """
 
     input_key: str = "input_document"  #: :meta private:
@@ -244,16 +257,20 @@ class AnalyzeDocumentChain(Chain):
         """
         return self.combine_docs_chain.output_keys
 
+    @override
     def get_input_schema(
-        self, config: Optional[RunnableConfig] = None
+        self,
+        config: Optional[RunnableConfig] = None,
     ) -> type[BaseModel]:
         return create_model(
             "AnalyzeDocumentChain",
             **{self.input_key: (str, None)},
         )
 
+    @override
     def get_output_schema(
-        self, config: Optional[RunnableConfig] = None
+        self,
+        config: Optional[RunnableConfig] = None,
     ) -> type[BaseModel]:
         return self.combine_docs_chain.get_output_schema(config)
 
@@ -270,5 +287,7 @@ class AnalyzeDocumentChain(Chain):
         other_keys: dict = {k: v for k, v in inputs.items() if k != self.input_key}
         other_keys[self.combine_docs_chain.input_key] = docs
         return self.combine_docs_chain(
-            other_keys, return_only_outputs=True, callbacks=_run_manager.get_child()
+            other_keys,
+            return_only_outputs=True,
+            callbacks=_run_manager.get_child(),
         )