langchain 0.3.25__py3-none-any.whl → 0.3.27__py3-none-any.whl

langchain/chains/api/base.py

@@ -47,8 +47,8 @@ def _check_in_allowed_domain(url: str, limit_to_domains: Sequence[str]) -> bool:
     scheme, domain = _extract_scheme_and_domain(url)
 
     for allowed_domain in limit_to_domains:
-        allowed_scheme, allowed_domain = _extract_scheme_and_domain(allowed_domain)
-        if scheme == allowed_scheme and domain == allowed_domain:
+        allowed_scheme, allowed_domain_ = _extract_scheme_and_domain(allowed_domain)
+        if scheme == allowed_scheme and domain == allowed_domain_:
             return True
     return False
 
@@ -61,7 +61,7 @@ try:
         message=(
             "This class is deprecated and will be removed in langchain 1.0. "
             "See API reference for replacement: "
-            "https://api.python.langchain.com/en/latest/chains/langchain.chains.api.base.APIChain.html"  # noqa: E501
+            "https://api.python.langchain.com/en/latest/chains/langchain.chains.api.base.APIChain.html"
         ),
         removal="1.0",
     )
@@ -201,10 +201,10 @@ try:
         output_key: str = "output"  #: :meta private:
         limit_to_domains: Optional[Sequence[str]] = Field(default_factory=list)  # type: ignore[arg-type]
         """Use to limit the domains that can be accessed by the API chain.
-        
+
         * For example, to limit to just the domain `https://www.example.com`, set
             `limit_to_domains=["https://www.example.com"]`.
-            
+
         * The default value is an empty tuple, which means that no domains are
           allowed by default. By design this will raise an error on instantiation.
         * Use a None if you want to allow all domains by default -- this is not
@@ -235,9 +235,8 @@ try:
             input_vars = self.api_request_chain.prompt.input_variables
             expected_vars = {"question", "api_docs"}
             if set(input_vars) != expected_vars:
-                raise ValueError(
-                    f"Input variables should be {expected_vars}, got {input_vars}"
-                )
+                msg = f"Input variables should be {expected_vars}, got {input_vars}"
+                raise ValueError(msg)
             return self
 
         @model_validator(mode="before")
@@ -247,18 +246,20 @@ try:
             # This check must be a pre=True check, so that a default of None
             # won't be set to limit_to_domains if it's not provided.
             if "limit_to_domains" not in values:
-                raise ValueError(
+                msg = (
                     "You must specify a list of domains to limit access using "
                     "`limit_to_domains`"
                 )
+                raise ValueError(msg)
             if (
                 not values["limit_to_domains"]
                 and values["limit_to_domains"] is not None
             ):
-                raise ValueError(
+                msg = (
                     "Please provide a list of domains to limit access using "
                     "`limit_to_domains`."
                 )
+                raise ValueError(msg)
             return values
 
         @model_validator(mode="after")
@@ -267,9 +268,8 @@ try:
             input_vars = self.api_answer_chain.prompt.input_variables
             expected_vars = {"question", "api_docs", "api_url", "api_response"}
             if set(input_vars) != expected_vars:
-                raise ValueError(
-                    f"Input variables should be {expected_vars}, got {input_vars}"
-                )
+                msg = f"Input variables should be {expected_vars}, got {input_vars}"
+                raise ValueError(msg)
             return self
 
         def _call(
@@ -287,14 +287,19 @@ try:
             _run_manager.on_text(api_url, color="green", end="\n", verbose=self.verbose)
             api_url = api_url.strip()
             if self.limit_to_domains and not _check_in_allowed_domain(
-                api_url, self.limit_to_domains
+                api_url,
+                self.limit_to_domains,
             ):
-                raise ValueError(
+                msg = (
                     f"{api_url} is not in the allowed domains: {self.limit_to_domains}"
                 )
+                raise ValueError(msg)
             api_response = self.requests_wrapper.get(api_url)
             _run_manager.on_text(
-                str(api_response), color="yellow", end="\n", verbose=self.verbose
+                str(api_response),
+                color="yellow",
+                end="\n",
+                verbose=self.verbose,
             )
             answer = self.api_answer_chain.predict(
                 question=question,
@@ -320,18 +325,26 @@ try:
                 callbacks=_run_manager.get_child(),
             )
             await _run_manager.on_text(
-                api_url, color="green", end="\n", verbose=self.verbose
+                api_url,
+                color="green",
+                end="\n",
+                verbose=self.verbose,
             )
             api_url = api_url.strip()
             if self.limit_to_domains and not _check_in_allowed_domain(
-                api_url, self.limit_to_domains
+                api_url,
+                self.limit_to_domains,
             ):
-                raise ValueError(
+                msg = (
                     f"{api_url} is not in the allowed domains: {self.limit_to_domains}"
                 )
+                raise ValueError(msg)
             api_response = await self.requests_wrapper.aget(api_url)
             await _run_manager.on_text(
-                str(api_response), color="yellow", end="\n", verbose=self.verbose
+                str(api_response),
+                color="yellow",
+                end="\n",
+                verbose=self.verbose,
             )
             answer = await self.api_answer_chain.apredict(
                 question=question,
@@ -350,7 +363,7 @@ try:
             headers: Optional[dict] = None,
             api_url_prompt: BasePromptTemplate = API_URL_PROMPT,
             api_response_prompt: BasePromptTemplate = API_RESPONSE_PROMPT,
-            limit_to_domains: Optional[Sequence[str]] = tuple(),
+            limit_to_domains: Optional[Sequence[str]] = (),
             **kwargs: Any,
         ) -> APIChain:
             """Load chain from just an LLM and the api docs."""
@@ -374,7 +387,8 @@ except ImportError:
 
     class APIChain:  # type: ignore[no-redef]
         def __init__(self, *args: Any, **kwargs: Any) -> None:
-            raise ImportError(
+            msg = (
                 "To use the APIChain, you must install the langchain_community package."
                 "pip install langchain_community"
             )
+            raise ImportError(msg)

langchain/chains/api/news_docs.py

@@ -1,4 +1,3 @@
-# flake8: noqa
 NEWS_DOCS = """API documentation:
 Endpoint: https://newsapi.org
 Top headlines /v2/top-headlines
@@ -29,4 +28,4 @@ Response object
     content | string | The unformatted content of the article, where available. This is truncated to 200 chars.
 
 Use page size: 2
-"""
+"""  # noqa: E501

langchain/chains/api/open_meteo_docs.py

@@ -1,4 +1,3 @@
-# flake8: noqa
 OPEN_METEO_DOCS = """BASE URL: https://api.open-meteo.com/
 
 API Documentation
@@ -30,4 +29,4 @@ showers	Preceding hour sum	mm (inch)	Showers from convective precipitation in mi
 weathercode	Instant	WMO code	Weather condition as a numeric code. Follow WMO weather interpretation codes. See table below for details.
 snow_depth	Instant	meters	Snow depth on the ground
 freezinglevel_height	Instant	meters	Altitude above sea level of the 0°C level
-visibility	Instant	meters	Viewing distance in meters. Influenced by low clouds, humidity and aerosols. Maximum visibility is approximately 24 km."""
+visibility	Instant	meters	Viewing distance in meters. Influenced by low clouds, humidity and aerosols. Maximum visibility is approximately 24 km."""  # noqa: E501

langchain/chains/api/openapi/requests_chain.py

@@ -26,4 +26,4 @@ def __getattr__(name: str) -> Any:
     return _import_attribute(name)
 
 
-__all__ = ["APIRequesterChain", "APIRequesterOutputParser", "REQUEST_TEMPLATE"]
+__all__ = ["REQUEST_TEMPLATE", "APIRequesterChain", "APIRequesterOutputParser"]

langchain/chains/api/openapi/response_chain.py

@@ -26,4 +26,4 @@ def __getattr__(name: str) -> Any:
     return _import_attribute(name)
 
 
-__all__ = ["APIResponderChain", "APIResponderOutputParser", "RESPONSE_TEMPLATE"]
+__all__ = ["RESPONSE_TEMPLATE", "APIResponderChain", "APIResponderOutputParser"]

langchain/chains/api/podcast_docs.py

@@ -1,4 +1,3 @@
-# flake8: noqa
 PODCAST_DOCS = """API documentation:
 Endpoint: https://listen-api.listennotes.com/api/v2
 GET /search
@@ -25,4 +24,4 @@ id | integer | optional
 title_highlighted | string | optional
 
 Use page_size: 3
-"""
+"""  # noqa: E501

langchain/chains/api/prompt.py

@@ -1,4 +1,3 @@
-# flake8: noqa
 from langchain_core.prompts.prompt import PromptTemplate
 
 API_URL_PROMPT_TEMPLATE = """You are given the below API Documentation:
@@ -7,7 +6,7 @@ Using this documentation, generate the full API url to call for answering the us
 You should build the API url in order to get a response that is as short as possible, while still getting the necessary information to answer the question. Pay attention to deliberately exclude any unnecessary pieces of data in the API call.
 
 Question:{question}
-API url:"""
+API url:"""  # noqa: E501
 
 API_URL_PROMPT = PromptTemplate(
     input_variables=[

langchain/chains/api/tmdb_docs.py

@@ -1,4 +1,3 @@
-# flake8: noqa
 TMDB_DOCS = """API documentation:
 Endpoint: https://api.themoviedb.org/3
 GET /search/movie
@@ -34,4 +33,4 @@ backdrop_path | string or null | optional
 popularity | number | optional
 vote_count | integer | optional
 video | boolean | optional
-vote_average | number | optional"""
+vote_average | number | optional"""  # noqa: E501

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
@@ -27,7 +28,7 @@ from langchain_core.runnables import (
     ensure_config,
     run_in_executor,
 )
-from langchain_core.runnables.utils import create_model
+from langchain_core.utils.pydantic import create_model
 from pydantic import (
     BaseModel,
     ConfigDict,
@@ -35,6 +36,7 @@ from pydantic import (
     field_validator,
     model_validator,
 )
+from typing_extensions import override
 
 from langchain.schema import RUN_KEY
 
@@ -107,17 +109,23 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
     )
 
     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)))
 
     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 +168,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 +222,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 +237,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 +246,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 +293,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 +357,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,
@@ -394,7 +418,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,
@@ -444,7 +468,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 +487,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 +512,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 +532,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 +556,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 +565,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")
@@ -599,7 +622,8 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
 
         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 +634,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(
@@ -667,30 +692,39 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
                 # -> "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.
@@ -712,10 +746,8 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
                 # -> {"_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:
@@ -733,34 +765,36 @@ class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
                 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",
 ]