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

langchain/chains/combine_documents/map_reduce.py

@@ -10,6 +10,7 @@ from langchain_core.documents import Document
 from langchain_core.runnables.config import RunnableConfig
 from langchain_core.utils.pydantic import create_model
 from pydantic import BaseModel, ConfigDict, model_validator
+from typing_extensions import override
 
 from langchain.chains.combine_documents.base import BaseCombineDocumentsChain
 from langchain.chains.combine_documents.reduce import ReduceDocumentsChain
@@ -98,6 +99,7 @@ class MapReduceDocumentsChain(BaseCombineDocumentsChain):
                 llm_chain=llm_chain,
                 reduce_documents_chain=reduce_documents_chain,
             )
+
     """
 
     llm_chain: LLMChain
@@ -111,8 +113,10 @@ class MapReduceDocumentsChain(BaseCombineDocumentsChain):
     return_intermediate_steps: bool = False
     """Return the results of the map steps in the output."""
 
+    @override
     def get_output_schema(
-        self, config: Optional[RunnableConfig] = None
+        self,
+        config: Optional[RunnableConfig] = None,
     ) -> type[BaseModel]:
         if self.return_intermediate_steps:
             return create_model(
@@ -133,7 +137,7 @@ class MapReduceDocumentsChain(BaseCombineDocumentsChain):
         """
         _output_keys = super().output_keys
         if self.return_intermediate_steps:
-            _output_keys = _output_keys + ["intermediate_steps"]
+            _output_keys = [*_output_keys, "intermediate_steps"]
         return _output_keys
 
     model_config = ConfigDict(
@@ -147,11 +151,12 @@ class MapReduceDocumentsChain(BaseCombineDocumentsChain):
         """For backwards compatibility."""
         if "combine_document_chain" in values:
             if "reduce_documents_chain" in values:
-                raise ValueError(
+                msg = (
                     "Both `reduce_documents_chain` and `combine_document_chain` "
                     "cannot be provided at the same time. `combine_document_chain` "
                     "is deprecated, please only provide `reduce_documents_chain`"
                 )
+                raise ValueError(msg)
             combine_chain = values["combine_document_chain"]
             collapse_chain = values.get("collapse_document_chain")
             reduce_chain = ReduceDocumentsChain(
@@ -160,8 +165,7 @@ class MapReduceDocumentsChain(BaseCombineDocumentsChain):
             )
             values["reduce_documents_chain"] = reduce_chain
             del values["combine_document_chain"]
-            if "collapse_document_chain" in values:
-                del values["collapse_document_chain"]
+            values.pop("collapse_document_chain", None)
 
         return values
 
@@ -179,23 +183,25 @@ class MapReduceDocumentsChain(BaseCombineDocumentsChain):
     def get_default_document_variable_name(cls, values: dict) -> Any:
         """Get default document variable name, if not provided."""
         if "llm_chain" not in values:
-            raise ValueError("llm_chain must be provided")
+            msg = "llm_chain must be provided"
+            raise ValueError(msg)
 
         llm_chain_variables = values["llm_chain"].prompt.input_variables
         if "document_variable_name" not in values:
             if len(llm_chain_variables) == 1:
                 values["document_variable_name"] = llm_chain_variables[0]
             else:
-                raise ValueError(
+                msg = (
                     "document_variable_name must be provided if there are "
                     "multiple llm_chain input_variables"
                 )
-        else:
-            if values["document_variable_name"] not in llm_chain_variables:
-                raise ValueError(
-                    f"document_variable_name {values['document_variable_name']} was "
-                    f"not found in llm_chain input_variables: {llm_chain_variables}"
-                )
+                raise ValueError(msg)
+        elif values["document_variable_name"] not in llm_chain_variables:
+            msg = (
+                f"document_variable_name {values['document_variable_name']} was "
+                f"not found in llm_chain input_variables: {llm_chain_variables}"
+            )
+            raise ValueError(msg)
         return values
 
     @property
@@ -204,26 +210,25 @@ class MapReduceDocumentsChain(BaseCombineDocumentsChain):
         if isinstance(self.reduce_documents_chain, ReduceDocumentsChain):
             if self.reduce_documents_chain.collapse_documents_chain:
                 return self.reduce_documents_chain.collapse_documents_chain
-            else:
-                return self.reduce_documents_chain.combine_documents_chain
-        else:
-            raise ValueError(
-                f"`reduce_documents_chain` is of type "
-                f"{type(self.reduce_documents_chain)} so it does not have "
-                f"this attribute."
-            )
+            return self.reduce_documents_chain.combine_documents_chain
+        msg = (
+            f"`reduce_documents_chain` is of type "
+            f"{type(self.reduce_documents_chain)} so it does not have "
+            f"this attribute."
+        )
+        raise ValueError(msg)
 
     @property
     def combine_document_chain(self) -> BaseCombineDocumentsChain:
         """Kept for backward compatibility."""
         if isinstance(self.reduce_documents_chain, ReduceDocumentsChain):
             return self.reduce_documents_chain.combine_documents_chain
-        else:
-            raise ValueError(
-                f"`reduce_documents_chain` is of type "
-                f"{type(self.reduce_documents_chain)} so it does not have "
-                f"this attribute."
-            )
+        msg = (
+            f"`reduce_documents_chain` is of type "
+            f"{type(self.reduce_documents_chain)} so it does not have "
+            f"this attribute."
+        )
+        raise ValueError(msg)
 
     def combine_docs(
         self,
@@ -249,7 +254,10 @@ class MapReduceDocumentsChain(BaseCombineDocumentsChain):
             for i, r in enumerate(map_results)
         ]
         result, extra_return_dict = self.reduce_documents_chain.combine_docs(
-            result_docs, token_max=token_max, callbacks=callbacks, **kwargs
+            result_docs,
+            token_max=token_max,
+            callbacks=callbacks,
+            **kwargs,
         )
         if self.return_intermediate_steps:
             intermediate_steps = [r[question_result_key] for r in map_results]
@@ -270,7 +278,7 @@ class MapReduceDocumentsChain(BaseCombineDocumentsChain):
         """
         map_results = await self.llm_chain.aapply(
             # FYI - this is parallelized and so it is fast.
-            [{**{self.document_variable_name: d.page_content}, **kwargs} for d in docs],
+            [{self.document_variable_name: d.page_content, **kwargs} for d in docs],
             callbacks=callbacks,
         )
         question_result_key = self.llm_chain.output_key
@@ -280,7 +288,10 @@ class MapReduceDocumentsChain(BaseCombineDocumentsChain):
             for i, r in enumerate(map_results)
         ]
         result, extra_return_dict = await self.reduce_documents_chain.acombine_docs(
-            result_docs, token_max=token_max, callbacks=callbacks, **kwargs
+            result_docs,
+            token_max=token_max,
+            callbacks=callbacks,
+            **kwargs,
         )
         if self.return_intermediate_steps:
             intermediate_steps = [r[question_result_key] for r in map_results]

langchain/chains/combine_documents/map_rerank.py

@@ -11,7 +11,7 @@ from langchain_core.documents import Document
 from langchain_core.runnables.config import RunnableConfig
 from langchain_core.utils.pydantic import create_model
 from pydantic import BaseModel, ConfigDict, model_validator
-from typing_extensions import Self
+from typing_extensions import Self, override
 
 from langchain.chains.combine_documents.base import BaseCombineDocumentsChain
 from langchain.chains.llm import LLMChain
@@ -24,15 +24,15 @@ from langchain.output_parsers.regex import RegexParser
     message=(
         "This class is deprecated. Please see the migration guide here for "
         "a recommended replacement: "
-        "https://python.langchain.com/docs/versions/migrating_chains/map_rerank_docs_chain/"  # noqa: E501
+        "https://python.langchain.com/docs/versions/migrating_chains/map_rerank_docs_chain/"
     ),
 )
 class MapRerankDocumentsChain(BaseCombineDocumentsChain):
     """Combining documents by mapping a chain over them, then reranking results.
 
     This algorithm calls an LLMChain on each input document. The LLMChain is expected
-    to have an OutputParser that parses the result into both an answer (`answer_key`)
-    and a score (`rank_key`). The answer with the highest score is then returned.
+    to have an OutputParser that parses the result into both an answer (``answer_key``)
+    and a score (``rank_key``). The answer with the highest score is then returned.
 
     Example:
         .. code-block:: python
@@ -69,6 +69,7 @@ class MapRerankDocumentsChain(BaseCombineDocumentsChain):
                 rank_key="score",
                 answer_key="answer",
             )
+
     """
 
     llm_chain: LLMChain
@@ -91,8 +92,10 @@ class MapRerankDocumentsChain(BaseCombineDocumentsChain):
         extra="forbid",
     )
 
+    @override
     def get_output_schema(
-        self, config: Optional[RunnableConfig] = None
+        self,
+        config: Optional[RunnableConfig] = None,
     ) -> type[BaseModel]:
         schema: dict[str, Any] = {
             self.output_key: (str, None),
@@ -100,7 +103,7 @@ class MapRerankDocumentsChain(BaseCombineDocumentsChain):
         if self.return_intermediate_steps:
             schema["intermediate_steps"] = (list[str], None)
         if self.metadata_keys:
-            schema.update({key: (Any, None) for key in self.metadata_keys})
+            schema.update(dict.fromkeys(self.metadata_keys, (Any, None)))
 
         return create_model("MapRerankOutput", **schema)
 
@@ -112,7 +115,7 @@ class MapRerankDocumentsChain(BaseCombineDocumentsChain):
         """
         _output_keys = super().output_keys
         if self.return_intermediate_steps:
-            _output_keys = _output_keys + ["intermediate_steps"]
+            _output_keys = [*_output_keys, "intermediate_steps"]
         if self.metadata_keys is not None:
             _output_keys += self.metadata_keys
         return _output_keys
@@ -122,21 +125,24 @@ class MapRerankDocumentsChain(BaseCombineDocumentsChain):
         """Validate that the combine chain outputs a dictionary."""
         output_parser = self.llm_chain.prompt.output_parser
         if not isinstance(output_parser, RegexParser):
-            raise ValueError(
+            msg = (
                 "Output parser of llm_chain should be a RegexParser,"
                 f" got {output_parser}"
             )
+            raise ValueError(msg)  # noqa: TRY004
         output_keys = output_parser.output_keys
         if self.rank_key not in output_keys:
-            raise ValueError(
+            msg = (
                 f"Got {self.rank_key} as key to rank on, but did not find "
                 f"it in the llm_chain output keys ({output_keys})"
             )
+            raise ValueError(msg)
         if self.answer_key not in output_keys:
-            raise ValueError(
+            msg = (
                 f"Got {self.answer_key} as key to return, but did not find "
                 f"it in the llm_chain output keys ({output_keys})"
             )
+            raise ValueError(msg)
         return self
 
     @model_validator(mode="before")
@@ -144,27 +150,32 @@ class MapRerankDocumentsChain(BaseCombineDocumentsChain):
     def get_default_document_variable_name(cls, values: dict) -> Any:
         """Get default document variable name, if not provided."""
         if "llm_chain" not in values:
-            raise ValueError("llm_chain must be provided")
+            msg = "llm_chain must be provided"
+            raise ValueError(msg)
 
         llm_chain_variables = values["llm_chain"].prompt.input_variables
         if "document_variable_name" not in values:
             if len(llm_chain_variables) == 1:
                 values["document_variable_name"] = llm_chain_variables[0]
             else:
-                raise ValueError(
+                msg = (
                     "document_variable_name must be provided if there are "
                     "multiple llm_chain input_variables"
                 )
-        else:
-            if values["document_variable_name"] not in llm_chain_variables:
-                raise ValueError(
-                    f"document_variable_name {values['document_variable_name']} was "
-                    f"not found in llm_chain input_variables: {llm_chain_variables}"
-                )
+                raise ValueError(msg)
+        elif values["document_variable_name"] not in llm_chain_variables:
+            msg = (
+                f"document_variable_name {values['document_variable_name']} was "
+                f"not found in llm_chain input_variables: {llm_chain_variables}"
+            )
+            raise ValueError(msg)
         return values
 
     def combine_docs(
-        self, docs: list[Document], callbacks: Callbacks = None, **kwargs: Any
+        self,
+        docs: list[Document],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> tuple[str, dict]:
         """Combine documents in a map rerank manner.
 
@@ -182,13 +193,16 @@ class MapRerankDocumentsChain(BaseCombineDocumentsChain):
         """
         results = self.llm_chain.apply_and_parse(
             # FYI - this is parallelized and so it is fast.
-            [{**{self.document_variable_name: d.page_content}, **kwargs} for d in docs],
+            [{self.document_variable_name: d.page_content, **kwargs} for d in docs],
             callbacks=callbacks,
         )
         return self._process_results(docs, results)
 
     async def acombine_docs(
-        self, docs: list[Document], callbacks: Callbacks = None, **kwargs: Any
+        self,
+        docs: list[Document],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> tuple[str, dict]:
         """Combine documents in a map rerank manner.
 
@@ -206,7 +220,7 @@ class MapRerankDocumentsChain(BaseCombineDocumentsChain):
         """
         results = await self.llm_chain.aapply_and_parse(
             # FYI - this is parallelized and so it is fast.
-            [{**{self.document_variable_name: d.page_content}, **kwargs} for d in docs],
+            [{self.document_variable_name: d.page_content, **kwargs} for d in docs],
             callbacks=callbacks,
         )
         return self._process_results(docs, results)
@@ -216,9 +230,10 @@ class MapRerankDocumentsChain(BaseCombineDocumentsChain):
         docs: list[Document],
         results: Sequence[Union[str, list[str], dict[str, str]]],
     ) -> tuple[str, dict]:
-        typed_results = cast(list[dict], results)
+        typed_results = cast("list[dict]", results)
         sorted_res = sorted(
-            zip(typed_results, docs), key=lambda x: -int(x[0][self.rank_key])
+            zip(typed_results, docs),
+            key=lambda x: -int(x[0][self.rank_key]),
         )
         output, document = sorted_res[0]
         extra_info = {}

langchain/chains/combine_documents/reduce.py

@@ -27,7 +27,10 @@ class AsyncCombineDocsProtocol(Protocol):
 
 
 def split_list_of_docs(
-    docs: list[Document], length_func: Callable, token_max: int, **kwargs: Any
+    docs: list[Document],
+    length_func: Callable,
+    token_max: int,
+    **kwargs: Any,
 ) -> list[list[Document]]:
     """Split Documents into subsets that each meet a cumulative length constraint.
 
@@ -48,10 +51,11 @@ def split_list_of_docs(
         _num_tokens = length_func(_sub_result_docs, **kwargs)
         if _num_tokens > token_max:
             if len(_sub_result_docs) == 1:
-                raise ValueError(
+                msg = (
                     "A single document was longer than the context length,"
                     " we cannot handle this."
                 )
+                raise ValueError(msg)
             new_result_doc_list.append(_sub_result_docs[:-1])
             _sub_result_docs = _sub_result_docs[-1:]
     new_result_doc_list.append(_sub_result_docs)
@@ -197,6 +201,7 @@ class ReduceDocumentsChain(BaseCombineDocumentsChain):
                 combine_documents_chain=combine_documents_chain,
                 collapse_documents_chain=collapse_documents_chain,
             )
+
     """
 
     combine_documents_chain: BaseCombineDocumentsChain
@@ -224,8 +229,7 @@ class ReduceDocumentsChain(BaseCombineDocumentsChain):
     def _collapse_chain(self) -> BaseCombineDocumentsChain:
         if self.collapse_documents_chain is not None:
             return self.collapse_documents_chain
-        else:
-            return self.combine_documents_chain
+        return self.combine_documents_chain
 
     def combine_docs(
         self,
@@ -250,10 +254,15 @@ class ReduceDocumentsChain(BaseCombineDocumentsChain):
             element returned is a dictionary of other keys to return.
         """
         result_docs, extra_return_dict = self._collapse(
-            docs, token_max=token_max, callbacks=callbacks, **kwargs
+            docs,
+            token_max=token_max,
+            callbacks=callbacks,
+            **kwargs,
         )
         return self.combine_documents_chain.combine_docs(
-            docs=result_docs, callbacks=callbacks, **kwargs
+            docs=result_docs,
+            callbacks=callbacks,
+            **kwargs,
         )
 
     async def acombine_docs(
@@ -279,10 +288,15 @@ class ReduceDocumentsChain(BaseCombineDocumentsChain):
             element returned is a dictionary of other keys to return.
         """
         result_docs, extra_return_dict = await self._acollapse(
-            docs, token_max=token_max, callbacks=callbacks, **kwargs
+            docs,
+            token_max=token_max,
+            callbacks=callbacks,
+            **kwargs,
         )
         return await self.combine_documents_chain.acombine_docs(
-            docs=result_docs, callbacks=callbacks, **kwargs
+            docs=result_docs,
+            callbacks=callbacks,
+            **kwargs,
         )
 
     def _collapse(
@@ -298,26 +312,30 @@ class ReduceDocumentsChain(BaseCombineDocumentsChain):
 
         def _collapse_docs_func(docs: list[Document], **kwargs: Any) -> str:
             return self._collapse_chain.run(
-                input_documents=docs, callbacks=callbacks, **kwargs
+                input_documents=docs,
+                callbacks=callbacks,
+                **kwargs,
             )
 
         _token_max = token_max or self.token_max
         retries: int = 0
         while num_tokens is not None and num_tokens > _token_max:
             new_result_doc_list = split_list_of_docs(
-                result_docs, length_func, _token_max, **kwargs
+                result_docs,
+                length_func,
+                _token_max,
+                **kwargs,
             )
-            result_docs = []
-            for docs in new_result_doc_list:
-                new_doc = collapse_docs(docs, _collapse_docs_func, **kwargs)
-                result_docs.append(new_doc)
+            result_docs = [
+                collapse_docs(docs_, _collapse_docs_func, **kwargs)
+                for docs_ in new_result_doc_list
+            ]
             num_tokens = length_func(result_docs, **kwargs)
             retries += 1
             if self.collapse_max_retries and retries == self.collapse_max_retries:
-                raise ValueError(
-                    f"Exceed {self.collapse_max_retries} tries to \
+                msg = f"Exceed {self.collapse_max_retries} tries to \
                         collapse document to {_token_max} tokens."
-                )
+                raise ValueError(msg)
         return result_docs, {}
 
     async def _acollapse(
@@ -333,26 +351,30 @@ class ReduceDocumentsChain(BaseCombineDocumentsChain):
 
         async def _collapse_docs_func(docs: list[Document], **kwargs: Any) -> str:
             return await self._collapse_chain.arun(
-                input_documents=docs, callbacks=callbacks, **kwargs
+                input_documents=docs,
+                callbacks=callbacks,
+                **kwargs,
             )
 
         _token_max = token_max or self.token_max
         retries: int = 0
         while num_tokens is not None and num_tokens > _token_max:
             new_result_doc_list = split_list_of_docs(
-                result_docs, length_func, _token_max, **kwargs
+                result_docs,
+                length_func,
+                _token_max,
+                **kwargs,
             )
-            result_docs = []
-            for docs in new_result_doc_list:
-                new_doc = await acollapse_docs(docs, _collapse_docs_func, **kwargs)
-                result_docs.append(new_doc)
+            result_docs = [
+                await acollapse_docs(docs_, _collapse_docs_func, **kwargs)
+                for docs_ in new_result_doc_list
+            ]
             num_tokens = length_func(result_docs, **kwargs)
             retries += 1
             if self.collapse_max_retries and retries == self.collapse_max_retries:
-                raise ValueError(
-                    f"Exceed {self.collapse_max_retries} tries to \
+                msg = f"Exceed {self.collapse_max_retries} tries to \
                         collapse document to {_token_max} tokens."
-                )
+                raise ValueError(msg)
         return result_docs, {}
 
     @property

langchain/chains/combine_documents/refine.py

@@ -27,7 +27,7 @@ def _get_default_document_prompt() -> PromptTemplate:
     message=(
         "This class is deprecated. Please see the migration guide here for "
         "a recommended replacement: "
-        "https://python.langchain.com/docs/versions/migrating_chains/refine_docs_chain/"  # noqa: E501
+        "https://python.langchain.com/docs/versions/migrating_chains/refine_docs_chain/"
     ),
 )
 class RefineDocumentsChain(BaseCombineDocumentsChain):
@@ -79,6 +79,7 @@ class RefineDocumentsChain(BaseCombineDocumentsChain):
                 document_variable_name=document_variable_name,
                 initial_response_name=initial_response_name,
             )
+
     """
 
     initial_llm_chain: LLMChain
@@ -91,7 +92,7 @@ class RefineDocumentsChain(BaseCombineDocumentsChain):
     initial_response_name: str
     """The variable name to format the initial response in when refining."""
     document_prompt: BasePromptTemplate = Field(
-        default_factory=_get_default_document_prompt
+        default_factory=_get_default_document_prompt,
     )
     """Prompt to use to format each document, gets passed to `format_document`."""
     return_intermediate_steps: bool = False
@@ -105,7 +106,7 @@ class RefineDocumentsChain(BaseCombineDocumentsChain):
         """
         _output_keys = super().output_keys
         if self.return_intermediate_steps:
-            _output_keys = _output_keys + ["intermediate_steps"]
+            _output_keys = [*_output_keys, "intermediate_steps"]
         return _output_keys
 
     model_config = ConfigDict(
@@ -127,27 +128,32 @@ class RefineDocumentsChain(BaseCombineDocumentsChain):
     def get_default_document_variable_name(cls, values: dict) -> Any:
         """Get default document variable name, if not provided."""
         if "initial_llm_chain" not in values:
-            raise ValueError("initial_llm_chain must be provided")
+            msg = "initial_llm_chain must be provided"
+            raise ValueError(msg)
 
         llm_chain_variables = values["initial_llm_chain"].prompt.input_variables
         if "document_variable_name" not in values:
             if len(llm_chain_variables) == 1:
                 values["document_variable_name"] = llm_chain_variables[0]
             else:
-                raise ValueError(
+                msg = (
                     "document_variable_name must be provided if there are "
                     "multiple llm_chain input_variables"
                 )
-        else:
-            if values["document_variable_name"] not in llm_chain_variables:
-                raise ValueError(
-                    f"document_variable_name {values['document_variable_name']} was "
-                    f"not found in llm_chain input_variables: {llm_chain_variables}"
-                )
+                raise ValueError(msg)
+        elif values["document_variable_name"] not in llm_chain_variables:
+            msg = (
+                f"document_variable_name {values['document_variable_name']} was "
+                f"not found in llm_chain input_variables: {llm_chain_variables}"
+            )
+            raise ValueError(msg)
         return values
 
     def combine_docs(
-        self, docs: list[Document], callbacks: Callbacks = None, **kwargs: Any
+        self,
+        docs: list[Document],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> tuple[str, dict]:
         """Combine by mapping first chain over all, then stuffing into final chain.
 
@@ -172,7 +178,10 @@ class RefineDocumentsChain(BaseCombineDocumentsChain):
         return self._construct_result(refine_steps, res)
 
     async def acombine_docs(
-        self, docs: list[Document], callbacks: Callbacks = None, **kwargs: Any
+        self,
+        docs: list[Document],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> tuple[str, dict]:
         """Async combine by mapping a first chain over all, then stuffing
          into a final chain.
@@ -211,16 +220,17 @@ class RefineDocumentsChain(BaseCombineDocumentsChain):
         }
 
     def _construct_initial_inputs(
-        self, docs: list[Document], **kwargs: Any
+        self,
+        docs: list[Document],
+        **kwargs: Any,
     ) -> dict[str, Any]:
         base_info = {"page_content": docs[0].page_content}
         base_info.update(docs[0].metadata)
         document_info = {k: base_info[k] for k in self.document_prompt.input_variables}
         base_inputs: dict = {
-            self.document_variable_name: self.document_prompt.format(**document_info)
+            self.document_variable_name: self.document_prompt.format(**document_info),
         }
-        inputs = {**base_inputs, **kwargs}
-        return inputs
+        return {**base_inputs, **kwargs}
 
     @property
     def _chain_type(self) -> str: