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

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

@@ -32,6 +32,7 @@ from langchain_core.runnables import (
 from langchain_core.runnables.configurable import DynamicRunnable
 from langchain_core.utils.input import get_colored_text
 from pydantic import ConfigDict, Field
+from typing_extensions import override
 
 from langchain.chains.base import Chain
 
@@ -73,22 +74,25 @@ class LLMChain(Chain):
                 input_variables=["adjective"], template=prompt_template
             )
             llm = LLMChain(llm=OpenAI(), prompt=prompt)
+
     """
 
     @classmethod
+    @override
     def is_lc_serializable(self) -> bool:
         return True
 
     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 +120,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 +145,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 +172,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 +204,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 +229,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 +254,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 +279,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
@@ -315,6 +324,7 @@ class LLMChain(Chain):
             .. code-block:: python
 
                 completion = llm.predict(adjective="funny")
+
         """
         return self(kwargs, callbacks=callbacks)[self.output_key]
 
@@ -332,66 +342,77 @@ class LLMChain(Chain):
             .. code-block:: python
 
                 completion = llm.predict(adjective="funny")
+
         """
         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 +434,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:
+def __getattr__(_: 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(
@@ -83,6 +82,7 @@ class LLMCheckerChain(Chain):
             from langchain.chains import LLMCheckerChain
             llm = OpenAI(temperature=0.7)
             checker_chain = LLMCheckerChain.from_llm(llm)
+
     """
 
     question_to_checked_assertions_chain: SequentialChain
@@ -107,12 +107,13 @@ class LLMCheckerChain(Chain):
 
     @model_validator(mode="before")
     @classmethod
-    def raise_deprecation(cls, values: dict) -> Any:
+    def _raise_deprecation(cls, values: dict) -> Any:
         if "llm" in values:
             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 +123,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 +161,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"]}
 
@@ -177,6 +180,16 @@ class LLMCheckerChain(Chain):
         revised_answer_prompt: PromptTemplate = REVISED_ANSWER_PROMPT,
         **kwargs: Any,
     ) -> LLMCheckerChain:
+        """Create an LLMCheckerChain from a language model.
+
+        Args:
+            llm: a language model
+            create_draft_answer_prompt: prompt to create a draft answer
+            list_assertions_prompt: prompt to list assertions
+            check_assertions_prompt: prompt to check assertions
+            revised_answer_prompt: prompt to revise the answer
+            **kwargs: additional arguments
+        """
         question_to_checked_assertions_chain = (
             _load_question_to_checked_assertions_chain(
                 llm,

langchain/chains/llm_checker/prompt.py

@@ -1,4 +1,3 @@
-# flake8: noqa
 from langchain_core.prompts.prompt import PromptTemplate
 
 _CREATE_DRAFT_ANSWER_TEMPLATE = """{question}\n\n"""
@@ -8,14 +7,14 @@ CREATE_DRAFT_ANSWER_PROMPT = PromptTemplate(
 
 _LIST_ASSERTIONS_TEMPLATE = """Here is a statement:
 {statement}
-Make a bullet point list of the assumptions you made when producing the above statement.\n\n"""
+Make a bullet point list of the assumptions you made when producing the above statement.\n\n"""  # noqa: E501
 LIST_ASSERTIONS_PROMPT = PromptTemplate(
     input_variables=["statement"], template=_LIST_ASSERTIONS_TEMPLATE
 )
 
 _CHECK_ASSERTIONS_TEMPLATE = """Here is a bullet point list of assertions:
 {assertions}
-For each assertion, determine whether it is true or false. If it is false, explain why.\n\n"""
+For each assertion, determine whether it is true or false. If it is false, explain why.\n\n"""  # noqa: E501
 CHECK_ASSERTIONS_PROMPT = PromptTemplate(
     input_variables=["assertions"], template=_CHECK_ASSERTIONS_TEMPLATE
 )
@@ -24,7 +23,7 @@ _REVISED_ANSWER_TEMPLATE = """{checked_assertions}
 
 Question: In light of the above assertions and checks, how would you answer the question '{question}'?
 
-Answer:"""
+Answer:"""  # noqa: E501
 REVISED_ANSWER_PROMPT = PromptTemplate(
     input_variables=["checked_assertions", "question"],
     template=_REVISED_ANSWER_TEMPLATE,

langchain/chains/llm_math/base.py

@@ -26,7 +26,7 @@ from langchain.chains.llm_math.prompt import PROMPT
     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.llm_math.base.LLMMathChain.html"  # noqa: E501
+        "https://api.python.langchain.com/en/latest/chains/langchain.chains.llm_math.base.LLMMathChain.html"
     ),
     removal="1.0",
 )
@@ -146,6 +146,7 @@ class LLMMathChain(Chain):
             from langchain.chains import LLMMathChain
             from langchain_community.llms import OpenAI
             llm_math = LLMMathChain.from_llm(OpenAI())
+
     """  # noqa: E501
 
     llm_chain: LLMChain
@@ -163,19 +164,21 @@ class LLMMathChain(Chain):
 
     @model_validator(mode="before")
     @classmethod
-    def raise_deprecation(cls, values: dict) -> Any:
+    def _raise_deprecation(cls, values: dict) -> Any:
         try:
             import numexpr  # noqa: F401
-        except ImportError:
-            raise ImportError(
+        except ImportError as e:
+            msg = (
                 "LLMMathChain requires the numexpr package. "
                 "Please install it with `pip install numexpr`."
             )
+            raise ImportError(msg) from e
         if "llm" in values:
             warnings.warn(
                 "Directly instantiating an LLMMathChain with an llm is deprecated. "
                 "Please instantiate with llm_chain argument or using the from_llm "
-                "class method."
+                "class method.",
+                stacklevel=5,
             )
             if "llm_chain" not in values and values["llm"] is not None:
                 prompt = values.get("prompt", PROMPT)
@@ -208,19 +211,22 @@ class LLMMathChain(Chain):
                     expression.strip(),
                     global_dict={},  # restrict access to globals
                     local_dict=local_dict,  # add common mathematical functions
-                )
+                ),
             )
         except Exception as e:
-            raise ValueError(
+            msg = (
                 f'LLMMathChain._evaluate("{expression}") raised error: {e}.'
                 " Please try again with a valid numerical expression"
             )
+            raise ValueError(msg) from e
 
         # Remove any leading and trailing brackets from the output
         return re.sub(r"^\[|\]$", "", output)
 
     def _process_llm_result(
-        self, llm_output: str, run_manager: CallbackManagerForChainRun
+        self,
+        llm_output: str,
+        run_manager: CallbackManagerForChainRun,
     ) -> dict[str, str]:
         run_manager.on_text(llm_output, color="green", verbose=self.verbose)
         llm_output = llm_output.strip()
@@ -236,7 +242,8 @@ class LLMMathChain(Chain):
         elif "Answer:" in llm_output:
             answer = "Answer: " + llm_output.split("Answer:")[-1]
         else:
-            raise ValueError(f"unknown format from LLM: {llm_output}")
+            msg = f"unknown format from LLM: {llm_output}"
+            raise ValueError(msg)
         return {self.output_key: answer}
 
     async def _aprocess_llm_result(
@@ -258,7 +265,8 @@ class LLMMathChain(Chain):
         elif "Answer:" in llm_output:
             answer = "Answer: " + llm_output.split("Answer:")[-1]
         else:
-            raise ValueError(f"unknown format from LLM: {llm_output}")
+            msg = f"unknown format from LLM: {llm_output}"
+            raise ValueError(msg)
         return {self.output_key: answer}
 
     def _call(
@@ -300,5 +308,12 @@ class LLMMathChain(Chain):
         prompt: BasePromptTemplate = PROMPT,
         **kwargs: Any,
     ) -> LLMMathChain:
+        """Create a LLMMathChain from a language model.
+
+        Args:
+            llm: a language model
+            prompt: a prompt template
+            **kwargs: additional arguments
+        """
         llm_chain = LLMChain(llm=llm, prompt=prompt)
         return cls(llm_chain=llm_chain, **kwargs)

langchain/chains/llm_math/prompt.py

@@ -1,4 +1,3 @@
-# flake8: noqa
 from langchain_core.prompts.prompt import PromptTemplate
 
 _PROMPT_TEMPLATE = """Translate a math problem into a expression that can be executed using Python's numexpr library. Use the output of running this code to answer the question.
@@ -36,7 +35,7 @@ Question: 37593^(1/5)
 Answer: 8.222831614237718
 
 Question: {question}
-"""
+"""  # noqa: E501
 
 PROMPT = PromptTemplate(
     input_variables=["question"],