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

langchain/chains/elasticsearch_database/base.py

@@ -60,9 +60,8 @@ class ElasticsearchDatabaseChain(Chain):
     @model_validator(mode="after")
     def validate_indices(self) -> Self:
         if self.include_indices and self.ignore_indices:
-            raise ValueError(
-                "Cannot specify both 'include_indices' and 'ignore_indices'."
-            )
+            msg = "Cannot specify both 'include_indices' and 'ignore_indices'."
+            raise ValueError(msg)
         return self
 
     @property
@@ -81,8 +80,7 @@ class ElasticsearchDatabaseChain(Chain):
         """
         if not self.return_intermediate_steps:
             return [self.output_key]
-        else:
-            return [self.output_key, INTERMEDIATE_STEPS_KEY]
+        return [self.output_key, INTERMEDIATE_STEPS_KEY]
 
     def _list_indices(self) -> list[str]:
         all_indices = [
@@ -111,7 +109,7 @@ class ElasticsearchDatabaseChain(Chain):
             [
                 "Mapping for index {}:\n{}".format(index, mappings[index]["mappings"])
                 for index in mappings
-            ]
+            ],
         )
 
     def _search(self, indices: list[str], query: str) -> str:
@@ -144,7 +142,7 @@ class ElasticsearchDatabaseChain(Chain):
 
             _run_manager.on_text(es_cmd, color="green", verbose=self.verbose)
             intermediate_steps.append(
-                es_cmd
+                es_cmd,
             )  # output: elasticsearch dsl generation (no checker)
             intermediate_steps.append({"es_cmd": es_cmd})  # input: ES search
             result = self._search(indices=indices, query=es_cmd)
@@ -166,12 +164,13 @@ class ElasticsearchDatabaseChain(Chain):
             chain_result: dict[str, Any] = {self.output_key: final_result}
             if self.return_intermediate_steps:
                 chain_result[INTERMEDIATE_STEPS_KEY] = intermediate_steps
-            return chain_result
         except Exception as exc:
             # Append intermediate steps to exception, to aid in logging and later
             # improvement of few shot prompt seeds
             exc.intermediate_steps = intermediate_steps  # type: ignore[attr-defined]
-            raise exc
+            raise
+
+        return chain_result
 
     @property
     def _chain_type(self) -> str:

langchain/chains/elasticsearch_database/prompts.py

@@ -1,4 +1,3 @@
-# flake8: noqa
 from langchain_core.prompts.prompt import PromptTemplate
 
 PROMPT_SUFFIX = """Only use the following Elasticsearch indices:
@@ -17,7 +16,7 @@ Use the following format:
 
 Question: Question here
 ESQuery: Elasticsearch Query formatted as json
-"""
+"""  # noqa: E501
 
 DSL_PROMPT = PromptTemplate.from_template(DEFAULT_DSL_TEMPLATE + PROMPT_SUFFIX)
 
@@ -31,6 +30,6 @@ Answer: Final answer here
 
 Question: {input}
 Data: {data}
-Answer:"""
+Answer:"""  # noqa: E501
 
 ANSWER_PROMPT = PromptTemplate.from_template(DEFAULT_ANSWER_TEMPLATE)

langchain/chains/ernie_functions/__init__.py

@@ -36,9 +36,9 @@ def __getattr__(name: str) -> Any:
 
 __all__ = [
     "convert_to_ernie_function",
-    "create_structured_output_chain",
     "create_ernie_fn_chain",
-    "create_structured_output_runnable",
     "create_ernie_fn_runnable",
+    "create_structured_output_chain",
+    "create_structured_output_runnable",
     "get_ernie_output_parser",
 ]

langchain/chains/example_generator.py

@@ -7,7 +7,9 @@ TEST_GEN_TEMPLATE_SUFFIX = "Add another example."
 
 
 def generate_example(
-    examples: list[dict], llm: BaseLanguageModel, prompt_template: PromptTemplate
+    examples: list[dict],
+    llm: BaseLanguageModel,
+    prompt_template: PromptTemplate,
 ) -> str:
     """Return another example given a list of examples for a prompt."""
     prompt = FewShotPromptTemplate(

langchain/chains/flare/base.py

@@ -69,7 +69,8 @@ def _low_confidence_spans(
             "NumPy not found in the current Python environment. FlareChain will use a "
             "pure Python implementation for internal calculations, which may "
             "significantly impact performance, especially for large datasets. For "
-            "optimal speed and efficiency, consider installing NumPy: pip install numpy"
+            "optimal speed and efficiency, consider installing NumPy: pip install "
+            "numpy",
         )
         import math
 
@@ -171,7 +172,8 @@ class FlareChain(Chain):
         callbacks = _run_manager.get_child()
         if isinstance(self.question_generator_chain, LLMChain):
             question_gen_outputs = self.question_generator_chain.apply(
-                question_gen_inputs, callbacks=callbacks
+                question_gen_inputs,
+                callbacks=callbacks,
             )
             questions = [
                 output[self.question_generator_chain.output_keys[0]]
@@ -179,10 +181,13 @@ class FlareChain(Chain):
             ]
         else:
             questions = self.question_generator_chain.batch(
-                question_gen_inputs, config={"callbacks": callbacks}
+                question_gen_inputs,
+                config={"callbacks": callbacks},
             )
         _run_manager.on_text(
-            f"Generated Questions: {questions}", color="yellow", end="\n"
+            f"Generated Questions: {questions}",
+            color="yellow",
+            end="\n",
         )
         return self._do_generation(questions, user_input, response, _run_manager)
 
@@ -197,15 +202,18 @@ class FlareChain(Chain):
 
         response = ""
 
-        for i in range(self.max_iter):
+        for _i in range(self.max_iter):
             _run_manager.on_text(
-                f"Current Response: {response}", color="blue", end="\n"
+                f"Current Response: {response}",
+                color="blue",
+                end="\n",
             )
             _input = {"user_input": user_input, "context": "", "response": response}
             tokens, log_probs = _extract_tokens_and_log_probs(
                 self.response_chain.invoke(
-                    _input, {"callbacks": _run_manager.get_child()}
-                )
+                    _input,
+                    {"callbacks": _run_manager.get_child()},
+                ),
             )
             low_confidence_spans = _low_confidence_spans(
                 tokens,
@@ -236,7 +244,10 @@ class FlareChain(Chain):
 
     @classmethod
     def from_llm(
-        cls, llm: BaseLanguageModel, max_generation_len: int = 32, **kwargs: Any
+        cls,
+        llm: BaseLanguageModel,
+        max_generation_len: int = 32,
+        **kwargs: Any,
     ) -> FlareChain:
         """Creates a FlareChain from a language model.
 
@@ -250,14 +261,17 @@ class FlareChain(Chain):
         """
         try:
             from langchain_openai import ChatOpenAI
-        except ImportError:
-            raise ImportError(
+        except ImportError as e:
+            msg = (
                 "OpenAI is required for FlareChain. "
                 "Please install langchain-openai."
                 "pip install langchain-openai"
             )
+            raise ImportError(msg) from e
         llm = ChatOpenAI(
-            max_completion_tokens=max_generation_len, logprobs=True, temperature=0
+            max_completion_tokens=max_generation_len,
+            logprobs=True,
+            temperature=0,
         )
         response_chain = PROMPT | llm
         question_gen_chain = QUESTION_GENERATOR_PROMPT | llm | StrOutputParser()

langchain/chains/graph_qa/cypher.py

@@ -31,9 +31,9 @@ def __getattr__(name: str) -> Any:
 
 
 __all__ = [
-    "GraphCypherQAChain",
+    "CYPHER_GENERATION_PROMPT",
     "INTERMEDIATE_STEPS_KEY",
+    "GraphCypherQAChain",
     "construct_schema",
     "extract_cypher",
-    "CYPHER_GENERATION_PROMPT",
 ]

langchain/chains/graph_qa/falkordb.py

@@ -26,4 +26,4 @@ def __getattr__(name: str) -> Any:
     return _import_attribute(name)
 
 
-__all__ = ["FalkorDBQAChain", "INTERMEDIATE_STEPS_KEY", "extract_cypher"]
+__all__ = ["INTERMEDIATE_STEPS_KEY", "FalkorDBQAChain", "extract_cypher"]

langchain/chains/graph_qa/gremlin.py

@@ -30,7 +30,7 @@ def __getattr__(name: str) -> Any:
 
 __all__ = [
     "GRAPHDB_SPARQL_FIX_TEMPLATE",
-    "GremlinQAChain",
     "INTERMEDIATE_STEPS_KEY",
+    "GremlinQAChain",
     "extract_gremlin",
 ]

langchain/chains/graph_qa/neptune_sparql.py

@@ -30,7 +30,7 @@ def __getattr__(name: str) -> Any:
 
 __all__ = [
     "INTERMEDIATE_STEPS_KEY",
-    "NeptuneSparqlQAChain",
     "SPARQL_GENERATION_TEMPLATE",
+    "NeptuneSparqlQAChain",
     "extract_sparql",
 ]

langchain/chains/graph_qa/prompts.py

@@ -74,7 +74,9 @@ __all__ = [
     "AQL_FIX_TEMPLATE",
     "AQL_GENERATION_TEMPLATE",
     "AQL_QA_TEMPLATE",
+    "CYPHER_GENERATION_PROMPT",
     "CYPHER_GENERATION_TEMPLATE",
+    "CYPHER_QA_PROMPT",
     "CYPHER_QA_TEMPLATE",
     "GRAPHDB_QA_TEMPLATE",
     "GRAPHDB_SPARQL_FIX_TEMPLATE",
@@ -91,6 +93,4 @@ __all__ = [
     "SPARQL_GENERATION_UPDATE_TEMPLATE",
     "SPARQL_INTENT_TEMPLATE",
     "SPARQL_QA_TEMPLATE",
-    "CYPHER_QA_PROMPT",
-    "CYPHER_GENERATION_PROMPT",
 ]

langchain/chains/history_aware_retriever.py

@@ -49,10 +49,11 @@ def create_history_aware_retriever(
 
     """
     if "input" not in prompt.input_variables:
-        raise ValueError(
+        msg = (
             "Expected `input` to be a prompt variable, "
             f"but got {prompt.input_variables}"
         )
+        raise ValueError(msg)
 
     retrieve_documents: RetrieverOutputLike = RunnableBranch(
         (

langchain/chains/hyde/base.py

@@ -47,8 +47,7 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
         """Output keys for Hyde's LLM chain."""
         if isinstance(self.llm_chain, LLMChain):
             return self.llm_chain.output_keys
-        else:
-            return ["text"]
+        return ["text"]
 
     def embed_documents(self, texts: list[str]) -> list[list[float]]:
         """Call the base embeddings."""
@@ -66,7 +65,7 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
                 "HypotheticalDocumentEmbedder will use a pure Python implementation "
                 "for internal calculations, which may significantly impact "
                 "performance, especially for large datasets. For optimal speed and "
-                "efficiency, consider installing NumPy: pip install numpy"
+                "efficiency, consider installing NumPy: pip install numpy",
             )
             if not embeddings:
                 return []
@@ -92,7 +91,8 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
         """Call the internal llm chain."""
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
         return self.llm_chain.invoke(
-            inputs, config={"callbacks": _run_manager.get_child()}
+            inputs,
+            config={"callbacks": _run_manager.get_child()},
         )
 
     @classmethod
@@ -110,10 +110,11 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
         elif prompt_key is not None and prompt_key in PROMPT_MAP:
             prompt = PROMPT_MAP[prompt_key]
         else:
-            raise ValueError(
+            msg = (
                 f"Must specify prompt_key if custom_prompt not provided. Should be one "
                 f"of {list(PROMPT_MAP.keys())}."
             )
+            raise ValueError(msg)
 
         llm_chain = prompt | llm | StrOutputParser()
         return cls(base_embeddings=base_embeddings, llm_chain=llm_chain, **kwargs)

langchain/chains/hyde/prompts.py

@@ -1,15 +1,14 @@
-# flake8: noqa
 from langchain_core.prompts.prompt import PromptTemplate
 
-web_search_template = """Please write a passage to answer the question 
+web_search_template = """Please write a passage to answer the question
 Question: {QUESTION}
 Passage:"""
 web_search = PromptTemplate(template=web_search_template, input_variables=["QUESTION"])
-sci_fact_template = """Please write a scientific paper passage to support/refute the claim 
+sci_fact_template = """Please write a scientific paper passage to support/refute the claim
 Claim: {Claim}
-Passage:"""
+Passage:"""  # noqa: E501
 sci_fact = PromptTemplate(template=sci_fact_template, input_variables=["Claim"])
-arguana_template = """Please write a counter argument for the passage 
+arguana_template = """Please write a counter argument for the passage
 Passage: {PASSAGE}
 Counter Argument:"""
 arguana = PromptTemplate(template=arguana_template, input_variables=["PASSAGE"])
@@ -33,7 +32,7 @@ Passage:"""
 trec_news = PromptTemplate(template=trec_news_template, input_variables=["TOPIC"])
 mr_tydi_template = """Please write a passage in Swahili/Korean/Japanese/Bengali to answer the question in detail.
 Question: {QUESTION}
-Passage:"""
+Passage:"""  # noqa: E501
 mr_tydi = PromptTemplate(template=mr_tydi_template, input_variables=["QUESTION"])
 PROMPT_MAP = {
     "web_search": web_search,

langchain/chains/llm.py

@@ -82,13 +82,14 @@ class LLMChain(Chain):
     prompt: BasePromptTemplate
     """Prompt object to use."""
     llm: Union[
-        Runnable[LanguageModelInput, str], Runnable[LanguageModelInput, BaseMessage]
+        Runnable[LanguageModelInput, str],
+        Runnable[LanguageModelInput, BaseMessage],
     ]
     """Language model to call."""
     output_key: str = "text"  #: :meta private:
     output_parser: BaseLLMOutputParser = Field(default_factory=StrOutputParser)
     """Output parser to use.
-    Defaults to one that takes the most likely string but does not change it 
+    Defaults to one that takes the most likely string but does not change it
     otherwise."""
     return_final_only: bool = True
     """Whether to return only the final parsed result. Defaults to True.
@@ -116,8 +117,7 @@ class LLMChain(Chain):
         """
         if self.return_final_only:
             return [self.output_key]
-        else:
-            return [self.output_key, "full_generation"]
+        return [self.output_key, "full_generation"]
 
     def _call(
         self,
@@ -142,17 +142,17 @@ class LLMChain(Chain):
                 callbacks=callbacks,
                 **self.llm_kwargs,
             )
-        else:
-            results = self.llm.bind(stop=stop, **self.llm_kwargs).batch(
-                cast(list, prompts), {"callbacks": callbacks}
-            )
-            generations: list[list[Generation]] = []
-            for res in results:
-                if isinstance(res, BaseMessage):
-                    generations.append([ChatGeneration(message=res)])
-                else:
-                    generations.append([Generation(text=res)])
-            return LLMResult(generations=generations)
+        results = self.llm.bind(stop=stop, **self.llm_kwargs).batch(
+            cast(list, prompts),
+            {"callbacks": callbacks},
+        )
+        generations: list[list[Generation]] = []
+        for res in results:
+            if isinstance(res, BaseMessage):
+                generations.append([ChatGeneration(message=res)])
+            else:
+                generations.append([Generation(text=res)])
+        return LLMResult(generations=generations)
 
     async def agenerate(
         self,
@@ -169,17 +169,17 @@ class LLMChain(Chain):
                 callbacks=callbacks,
                 **self.llm_kwargs,
             )
-        else:
-            results = await self.llm.bind(stop=stop, **self.llm_kwargs).abatch(
-                cast(list, prompts), {"callbacks": callbacks}
-            )
-            generations: list[list[Generation]] = []
-            for res in results:
-                if isinstance(res, BaseMessage):
-                    generations.append([ChatGeneration(message=res)])
-                else:
-                    generations.append([Generation(text=res)])
-            return LLMResult(generations=generations)
+        results = await self.llm.bind(stop=stop, **self.llm_kwargs).abatch(
+            cast(list, prompts),
+            {"callbacks": callbacks},
+        )
+        generations: list[list[Generation]] = []
+        for res in results:
+            if isinstance(res, BaseMessage):
+                generations.append([ChatGeneration(message=res)])
+            else:
+                generations.append([Generation(text=res)])
+        return LLMResult(generations=generations)
 
     def prep_prompts(
         self,
@@ -201,9 +201,8 @@ class LLMChain(Chain):
             if run_manager:
                 run_manager.on_text(_text, end="\n", verbose=self.verbose)
             if "stop" in inputs and inputs["stop"] != stop:
-                raise ValueError(
-                    "If `stop` is present in any inputs, should be present in all."
-                )
+                msg = "If `stop` is present in any inputs, should be present in all."
+                raise ValueError(msg)
             prompts.append(prompt)
         return prompts, stop
 
@@ -227,18 +226,21 @@ class LLMChain(Chain):
             if run_manager:
                 await run_manager.on_text(_text, end="\n", verbose=self.verbose)
             if "stop" in inputs and inputs["stop"] != stop:
-                raise ValueError(
-                    "If `stop` is present in any inputs, should be present in all."
-                )
+                msg = "If `stop` is present in any inputs, should be present in all."
+                raise ValueError(msg)
             prompts.append(prompt)
         return prompts, stop
 
     def apply(
-        self, input_list: list[dict[str, Any]], callbacks: Callbacks = None
+        self,
+        input_list: list[dict[str, Any]],
+        callbacks: Callbacks = None,
     ) -> list[dict[str, str]]:
         """Utilize the LLM generate method for speed gains."""
         callback_manager = CallbackManager.configure(
-            callbacks, self.callbacks, self.verbose
+            callbacks,
+            self.callbacks,
+            self.verbose,
         )
         run_manager = callback_manager.on_chain_start(
             None,
@@ -249,17 +251,21 @@ class LLMChain(Chain):
             response = self.generate(input_list, run_manager=run_manager)
         except BaseException as e:
             run_manager.on_chain_error(e)
-            raise e
+            raise
         outputs = self.create_outputs(response)
         run_manager.on_chain_end({"outputs": outputs})
         return outputs
 
     async def aapply(
-        self, input_list: list[dict[str, Any]], callbacks: Callbacks = None
+        self,
+        input_list: list[dict[str, Any]],
+        callbacks: Callbacks = None,
     ) -> list[dict[str, str]]:
         """Utilize the LLM generate method for speed gains."""
         callback_manager = AsyncCallbackManager.configure(
-            callbacks, self.callbacks, self.verbose
+            callbacks,
+            self.callbacks,
+            self.verbose,
         )
         run_manager = await callback_manager.on_chain_start(
             None,
@@ -270,7 +276,7 @@ class LLMChain(Chain):
             response = await self.agenerate(input_list, run_manager=run_manager)
         except BaseException as e:
             await run_manager.on_chain_error(e)
-            raise e
+            raise
         outputs = self.create_outputs(response)
         await run_manager.on_chain_end({"outputs": outputs})
         return outputs
@@ -336,62 +342,72 @@ class LLMChain(Chain):
         return (await self.acall(kwargs, callbacks=callbacks))[self.output_key]
 
     def predict_and_parse(
-        self, callbacks: Callbacks = None, **kwargs: Any
+        self,
+        callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> Union[str, list[str], dict[str, Any]]:
         """Call predict and then parse the results."""
         warnings.warn(
             "The predict_and_parse method is deprecated, "
-            "instead pass an output parser directly to LLMChain."
+            "instead pass an output parser directly to LLMChain.",
+            stacklevel=2,
         )
         result = self.predict(callbacks=callbacks, **kwargs)
         if self.prompt.output_parser is not None:
             return self.prompt.output_parser.parse(result)
-        else:
-            return result
+        return result
 
     async def apredict_and_parse(
-        self, callbacks: Callbacks = None, **kwargs: Any
+        self,
+        callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> Union[str, list[str], dict[str, str]]:
         """Call apredict and then parse the results."""
         warnings.warn(
             "The apredict_and_parse method is deprecated, "
-            "instead pass an output parser directly to LLMChain."
+            "instead pass an output parser directly to LLMChain.",
+            stacklevel=2,
         )
         result = await self.apredict(callbacks=callbacks, **kwargs)
         if self.prompt.output_parser is not None:
             return self.prompt.output_parser.parse(result)
-        else:
-            return result
+        return result
 
     def apply_and_parse(
-        self, input_list: list[dict[str, Any]], callbacks: Callbacks = None
+        self,
+        input_list: list[dict[str, Any]],
+        callbacks: Callbacks = None,
     ) -> Sequence[Union[str, list[str], dict[str, str]]]:
         """Call apply and then parse the results."""
         warnings.warn(
             "The apply_and_parse method is deprecated, "
-            "instead pass an output parser directly to LLMChain."
+            "instead pass an output parser directly to LLMChain.",
+            stacklevel=2,
         )
         result = self.apply(input_list, callbacks=callbacks)
         return self._parse_generation(result)
 
     def _parse_generation(
-        self, generation: list[dict[str, str]]
+        self,
+        generation: list[dict[str, str]],
     ) -> Sequence[Union[str, list[str], dict[str, str]]]:
         if self.prompt.output_parser is not None:
             return [
                 self.prompt.output_parser.parse(res[self.output_key])
                 for res in generation
             ]
-        else:
-            return generation
+        return generation
 
     async def aapply_and_parse(
-        self, input_list: list[dict[str, Any]], callbacks: Callbacks = None
+        self,
+        input_list: list[dict[str, Any]],
+        callbacks: Callbacks = None,
     ) -> Sequence[Union[str, list[str], dict[str, str]]]:
         """Call apply and then parse the results."""
         warnings.warn(
             "The aapply_and_parse method is deprecated, "
-            "instead pass an output parser directly to LLMChain."
+            "instead pass an output parser directly to LLMChain.",
+            stacklevel=2,
         )
         result = await self.aapply(input_list, callbacks=callbacks)
         return self._parse_generation(result)
@@ -413,14 +429,14 @@ class LLMChain(Chain):
 def _get_language_model(llm_like: Runnable) -> BaseLanguageModel:
     if isinstance(llm_like, BaseLanguageModel):
         return llm_like
-    elif isinstance(llm_like, RunnableBinding):
+    if isinstance(llm_like, RunnableBinding):
         return _get_language_model(llm_like.bound)
-    elif isinstance(llm_like, RunnableWithFallbacks):
+    if isinstance(llm_like, RunnableWithFallbacks):
         return _get_language_model(llm_like.runnable)
-    elif isinstance(llm_like, (RunnableBranch, DynamicRunnable)):
+    if isinstance(llm_like, (RunnableBranch, DynamicRunnable)):
         return _get_language_model(llm_like.default)
-    else:
-        raise ValueError(
-            f"Unable to extract BaseLanguageModel from llm_like object of type "
-            f"{type(llm_like)}"
-        )
+    msg = (
+        f"Unable to extract BaseLanguageModel from llm_like object of type "
+        f"{type(llm_like)}"
+    )
+    raise ValueError(msg)

langchain/chains/llm_bash/__init__.py

@@ -1,9 +1,10 @@
 def __getattr__(name: str = "") -> None:
     """Raise an error on import since is deprecated."""
-    raise AttributeError(
+    msg = (
         "This module has been moved to langchain-experimental. "
         "For more details: https://github.com/langchain-ai/langchain/discussions/11352."
         "To access this code, install it with `pip install langchain-experimental`."
         "`from langchain_experimental.llm_bash.base "
         "import LLMBashChain`"
     )
+    raise AttributeError(msg)

langchain/chains/llm_checker/base.py

@@ -55,13 +55,12 @@ def _load_question_to_checked_assertions_chain(
         check_assertions_chain,
         revised_answer_chain,
     ]
-    question_to_checked_assertions_chain = SequentialChain(
+    return SequentialChain(
         chains=chains,  # type: ignore[arg-type]
         input_variables=["question"],
         output_variables=["revised_statement"],
         verbose=True,
     )
-    return question_to_checked_assertions_chain
 
 
 @deprecated(
@@ -112,7 +111,8 @@ class LLMCheckerChain(Chain):
             warnings.warn(
                 "Directly instantiating an LLMCheckerChain with an llm is deprecated. "
                 "Please instantiate with question_to_checked_assertions_chain "
-                "or using the from_llm class method."
+                "or using the from_llm class method.",
+                stacklevel=5,
             )
             if (
                 "question_to_checked_assertions_chain" not in values
@@ -122,7 +122,8 @@ class LLMCheckerChain(Chain):
                     _load_question_to_checked_assertions_chain(
                         values["llm"],
                         values.get(
-                            "create_draft_answer_prompt", CREATE_DRAFT_ANSWER_PROMPT
+                            "create_draft_answer_prompt",
+                            CREATE_DRAFT_ANSWER_PROMPT,
                         ),
                         values.get("list_assertions_prompt", LIST_ASSERTIONS_PROMPT),
                         values.get("check_assertions_prompt", CHECK_ASSERTIONS_PROMPT),
@@ -159,7 +160,8 @@ class LLMCheckerChain(Chain):
         question = inputs[self.input_key]
 
         output = self.question_to_checked_assertions_chain(
-            {"question": question}, callbacks=_run_manager.get_child()
+            {"question": question},
+            callbacks=_run_manager.get_child(),
         )
         return {self.output_key: output["revised_statement"]}