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

langchain/chains/sequential.py

@@ -48,17 +48,18 @@ class SequentialChain(Chain):
         """Validate that the correct inputs exist for all chains."""
         chains = values["chains"]
         input_variables = values["input_variables"]
-        memory_keys = list()
+        memory_keys = []
         if "memory" in values and values["memory"] is not None:
             """Validate that prompt input variables are consistent."""
             memory_keys = values["memory"].memory_variables
             if set(input_variables).intersection(set(memory_keys)):
                 overlapping_keys = set(input_variables) & set(memory_keys)
-                raise ValueError(
+                msg = (
                     f"The input key(s) {''.join(overlapping_keys)} are found "
                     f"in the Memory keys ({memory_keys}) - please use input and "
                     f"memory keys that don't overlap."
                 )
+                raise ValueError(msg)
 
         known_variables = set(input_variables + memory_keys)
 
@@ -68,15 +69,15 @@ class SequentialChain(Chain):
                 missing_vars = missing_vars.difference(chain.memory.memory_variables)
 
             if missing_vars:
-                raise ValueError(
+                msg = (
                     f"Missing required input keys: {missing_vars}, "
                     f"only had {known_variables}"
                 )
+                raise ValueError(msg)
             overlapping_keys = known_variables.intersection(chain.output_keys)
             if overlapping_keys:
-                raise ValueError(
-                    f"Chain returned keys that already exist: {overlapping_keys}"
-                )
+                msg = f"Chain returned keys that already exist: {overlapping_keys}"
+                raise ValueError(msg)
 
             known_variables |= set(chain.output_keys)
 
@@ -89,9 +90,8 @@ class SequentialChain(Chain):
         else:
             missing_vars = set(values["output_variables"]).difference(known_variables)
             if missing_vars:
-                raise ValueError(
-                    f"Expected output variables that were not found: {missing_vars}."
-                )
+                msg = f"Expected output variables that were not found: {missing_vars}."
+                raise ValueError(msg)
 
         return values
 
@@ -102,7 +102,7 @@ class SequentialChain(Chain):
     ) -> dict[str, str]:
         known_values = inputs.copy()
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
-        for i, chain in enumerate(self.chains):
+        for _i, chain in enumerate(self.chains):
             callbacks = _run_manager.get_child()
             outputs = chain(known_values, return_only_outputs=True, callbacks=callbacks)
             known_values.update(outputs)
@@ -116,9 +116,11 @@ class SequentialChain(Chain):
         known_values = inputs.copy()
         _run_manager = run_manager or AsyncCallbackManagerForChainRun.get_noop_manager()
         callbacks = _run_manager.get_child()
-        for i, chain in enumerate(self.chains):
+        for _i, chain in enumerate(self.chains):
             outputs = await chain.acall(
-                known_values, return_only_outputs=True, callbacks=callbacks
+                known_values,
+                return_only_outputs=True,
+                callbacks=callbacks,
             )
             known_values.update(outputs)
         return {k: known_values[k] for k in self.output_variables}
@@ -158,15 +160,17 @@ class SimpleSequentialChain(Chain):
         """Validate that chains are all single input/output."""
         for chain in self.chains:
             if len(chain.input_keys) != 1:
-                raise ValueError(
+                msg = (
                     "Chains used in SimplePipeline should all have one input, got "
                     f"{chain} with {len(chain.input_keys)} inputs."
                 )
+                raise ValueError(msg)
             if len(chain.output_keys) != 1:
-                raise ValueError(
+                msg = (
                     "Chains used in SimplePipeline should all have one output, got "
                     f"{chain} with {len(chain.output_keys)} outputs."
                 )
+                raise ValueError(msg)
         return self
 
     def _call(
@@ -179,12 +183,16 @@ class SimpleSequentialChain(Chain):
         color_mapping = get_color_mapping([str(i) for i in range(len(self.chains))])
         for i, chain in enumerate(self.chains):
             _input = chain.run(
-                _input, callbacks=_run_manager.get_child(f"step_{i + 1}")
+                _input,
+                callbacks=_run_manager.get_child(f"step_{i + 1}"),
             )
             if self.strip_outputs:
                 _input = _input.strip()
             _run_manager.on_text(
-                _input, color=color_mapping[str(i)], end="\n", verbose=self.verbose
+                _input,
+                color=color_mapping[str(i)],
+                end="\n",
+                verbose=self.verbose,
             )
         return {self.output_key: _input}
 
@@ -198,11 +206,15 @@ class SimpleSequentialChain(Chain):
         color_mapping = get_color_mapping([str(i) for i in range(len(self.chains))])
         for i, chain in enumerate(self.chains):
             _input = await chain.arun(
-                _input, callbacks=_run_manager.get_child(f"step_{i + 1}")
+                _input,
+                callbacks=_run_manager.get_child(f"step_{i + 1}"),
             )
             if self.strip_outputs:
                 _input = _input.strip()
             await _run_manager.on_text(
-                _input, color=color_mapping[str(i)], end="\n", verbose=self.verbose
+                _input,
+                color=color_mapping[str(i)],
+                end="\n",
+                verbose=self.verbose,
             )
         return {self.output_key: _input}

langchain/chains/sql_database/prompt.py

@@ -1,8 +1,6 @@
-# flake8: noqa
 from langchain_core.output_parsers.list import CommaSeparatedListOutputParser
 from langchain_core.prompts.prompt import PromptTemplate
 
-
 PROMPT_SUFFIX = """Only use the following tables:
 {table_info}
 
@@ -21,7 +19,7 @@ SQLQuery: SQL Query to run
 SQLResult: Result of the SQLQuery
 Answer: Final answer here
 
-"""
+"""  # noqa: E501
 
 PROMPT = PromptTemplate(
     input_variables=["input", "table_info", "dialect", "top_k"],
@@ -35,7 +33,7 @@ Question: {query}
 
 Table Names: {table_names}
 
-Relevant Table Names:"""
+Relevant Table Names:"""  # noqa: E501
 DECIDER_PROMPT = PromptTemplate(
     input_variables=["query", "table_names"],
     template=_DECIDER_TEMPLATE,
@@ -46,7 +44,7 @@ _cratedb_prompt = """You are a CrateDB expert. Given an input question, first cr
 Unless the user specifies in the question a specific number of examples to obtain, query for at most {top_k} results using the LIMIT clause as per CrateDB. You can order the results to return the most informative data in the database.
 Never query for all columns from a table. You must query only the columns that are needed to answer the question. Wrap each column name in double quotes (") to denote them as delimited identifiers.
 Pay attention to use only the column names you can see in the tables below. Be careful to not query for columns that do not exist. Also, pay attention to which column is in which table.
-Pay attention to use CURRENT_DATE function to get the current date, if the question involves "today". 
+Pay attention to use CURRENT_DATE function to get the current date, if the question involves "today".
 
 Use the following format:
 
@@ -55,7 +53,7 @@ SQLQuery: SQL Query to run
 SQLResult: Result of the SQLQuery
 Answer: Final answer here
 
-"""
+"""  # noqa: E501
 
 CRATEDB_PROMPT = PromptTemplate(
     input_variables=["input", "table_info", "top_k"],
@@ -75,7 +73,7 @@ SQLQuery: SQL Query to run
 SQLResult: Result of the SQLQuery
 Answer: Final answer here
 
-"""
+"""  # noqa: E501
 
 DUCKDB_PROMPT = PromptTemplate(
     input_variables=["input", "table_info", "top_k"],
@@ -95,7 +93,7 @@ SQLQuery: SQL Query to run
 SQLResult: Result of the SQLQuery
 Answer: Final answer here
 
-"""
+"""  # noqa: E501
 
 GOOGLESQL_PROMPT = PromptTemplate(
     input_variables=["input", "table_info", "top_k"],
@@ -116,7 +114,7 @@ SQLQuery: SQL Query to run
 SQLResult: Result of the SQLQuery
 Answer: Final answer here
 
-"""
+"""  # noqa: E501
 
 MSSQL_PROMPT = PromptTemplate(
     input_variables=["input", "table_info", "top_k"],
@@ -137,7 +135,7 @@ SQLQuery: SQL Query to run
 SQLResult: Result of the SQLQuery
 Answer: Final answer here
 
-"""
+"""  # noqa: E501
 
 MYSQL_PROMPT = PromptTemplate(
     input_variables=["input", "table_info", "top_k"],
@@ -158,7 +156,7 @@ SQLQuery: SQL Query to run
 SQLResult: Result of the SQLQuery
 Answer: Final answer here
 
-"""
+"""  # noqa: E501
 
 MARIADB_PROMPT = PromptTemplate(
     input_variables=["input", "table_info", "top_k"],
@@ -179,7 +177,7 @@ SQLQuery: SQL Query to run
 SQLResult: Result of the SQLQuery
 Answer: Final answer here
 
-"""
+"""  # noqa: E501
 
 ORACLE_PROMPT = PromptTemplate(
     input_variables=["input", "table_info", "top_k"],
@@ -200,7 +198,7 @@ SQLQuery: SQL Query to run
 SQLResult: Result of the SQLQuery
 Answer: Final answer here
 
-"""
+"""  # noqa: E501
 
 POSTGRES_PROMPT = PromptTemplate(
     input_variables=["input", "table_info", "top_k"],
@@ -221,7 +219,7 @@ SQLQuery: SQL Query to run
 SQLResult: Result of the SQLQuery
 Answer: Final answer here
 
-"""
+"""  # noqa: E501
 
 SQLITE_PROMPT = PromptTemplate(
     input_variables=["input", "table_info", "top_k"],
@@ -241,7 +239,7 @@ SQLQuery: "SQL Query to run"
 SQLResult: "Result of the SQLQuery"
 Answer: "Final answer here"
 
-"""
+"""  # noqa: E501
 
 CLICKHOUSE_PROMPT = PromptTemplate(
     input_variables=["input", "table_info", "top_k"],
@@ -261,7 +259,7 @@ SQLQuery: "SQL Query to run"
 SQLResult: "Result of the SQLQuery"
 Answer: "Final answer here"
 
-"""
+"""  # noqa: E501
 
 PRESTODB_PROMPT = PromptTemplate(
     input_variables=["input", "table_info", "top_k"],

langchain/chains/sql_database/query.py

@@ -113,6 +113,7 @@ def create_sql_query_chain(
 
             Question: {input}'''
             prompt = PromptTemplate.from_template(template)
+
     """  # noqa: E501
     if prompt is not None:
         prompt_to_use = prompt
@@ -121,26 +122,27 @@ def create_sql_query_chain(
     else:
         prompt_to_use = PROMPT
     if {"input", "top_k", "table_info"}.difference(
-        prompt_to_use.input_variables + list(prompt_to_use.partial_variables)
+        prompt_to_use.input_variables + list(prompt_to_use.partial_variables),
     ):
-        raise ValueError(
+        msg = (
             f"Prompt must have input variables: 'input', 'top_k', "
             f"'table_info'. Received prompt with input variables: "
             f"{prompt_to_use.input_variables}. Full prompt:\n\n{prompt_to_use}"
         )
+        raise ValueError(msg)
     if "dialect" in prompt_to_use.input_variables:
         prompt_to_use = prompt_to_use.partial(dialect=db.dialect)
 
     table_info_kwargs = {}
     if get_col_comments:
         if db.dialect not in ("postgresql", "mysql", "oracle"):
-            raise ValueError(
+            msg = (
                 f"get_col_comments=True is only supported for dialects "
                 f"'postgresql', 'mysql', and 'oracle'. Received dialect: "
                 f"{db.dialect}"
             )
-        else:
-            table_info_kwargs["get_col_comments"] = True
+            raise ValueError(msg)
+        table_info_kwargs["get_col_comments"] = True
 
     inputs = {
         "input": lambda x: x["question"] + "\nSQLQuery: ",

langchain/chains/structured_output/__init__.py

@@ -3,4 +3,4 @@ from langchain.chains.structured_output.base import (
     create_structured_output_runnable,
 )
 
-__all__ = ["create_structured_output_runnable", "create_openai_fn_runnable"]
+__all__ = ["create_openai_fn_runnable", "create_structured_output_runnable"]

langchain/chains/structured_output/base.py

@@ -47,18 +47,18 @@ from pydantic import BaseModel
         """
             from pydantic import BaseModel, Field
             from langchain_anthropic import ChatAnthropic
-    
+
             class Joke(BaseModel):
                 setup: str = Field(description="The setup of the joke")
-                punchline: str = Field(description="The punchline to the joke") 
-    
+                punchline: str = Field(description="The punchline to the joke")
+
             # Or any other chat model that supports tools.
             # Please reference to to the documentation of structured_output
-            # to see an up to date list of which models support 
+            # to see an up to date list of which models support
             # with_structured_output.
             model = ChatAnthropic(model="claude-3-opus-20240229", temperature=0)
             structured_llm = model.with_structured_output(Joke)
-            structured_llm.invoke("Tell me a joke about cats. 
+            structured_llm.invoke("Tell me a joke about cats.
                 Make sure to call the Joke function.")
             """
     ),
@@ -132,9 +132,11 @@ def create_openai_fn_runnable(
                 structured_llm = create_openai_fn_runnable([RecordPerson, RecordDog], llm)
                 structured_llm.invoke("Harry was a chubby brown beagle who loved chicken)
                 # -> RecordDog(name="Harry", color="brown", fav_food="chicken")
+
     """  # noqa: E501
     if not functions:
-        raise ValueError("Need to pass in at least one function. Received zero.")
+        msg = "Need to pass in at least one function. Received zero."
+        raise ValueError(msg)
     openai_functions = [convert_to_openai_function(f) for f in functions]
     llm_kwargs_: dict[str, Any] = {"functions": openai_functions, **llm_kwargs}
     if len(openai_functions) == 1 and enforce_single_function_usage:
@@ -142,8 +144,7 @@ def create_openai_fn_runnable(
     output_parser = output_parser or get_openai_output_parser(functions)
     if prompt:
         return prompt | llm.bind(**llm_kwargs_) | output_parser
-    else:
-        return llm.bind(**llm_kwargs_) | output_parser
+    return llm.bind(**llm_kwargs_) | output_parser
 
 
 @deprecated(
@@ -168,15 +169,15 @@ def create_openai_fn_runnable(
 
             class Joke(BaseModel):
                 setup: str = Field(description="The setup of the joke")
-                punchline: str = Field(description="The punchline to the joke") 
+                punchline: str = Field(description="The punchline to the joke")
 
             # Or any other chat model that supports tools.
             # Please reference to to the documentation of structured_output
-            # to see an up to date list of which models support 
+            # to see an up to date list of which models support
             # with_structured_output.
             model = ChatAnthropic(model="claude-3-opus-20240229", temperature=0)
             structured_llm = model.with_structured_output(Joke)
-            structured_llm.invoke("Tell me a joke about cats. 
+            structured_llm.invoke("Tell me a joke about cats.
                 Make sure to call the Joke function.")
             """
     ),
@@ -190,7 +191,9 @@ def create_structured_output_runnable(
     enforce_function_usage: bool = True,
     return_single: bool = True,
     mode: Literal[
-        "openai-functions", "openai-tools", "openai-json"
+        "openai-functions",
+        "openai-tools",
+        "openai-json",
     ] = "openai-functions",
     **kwargs: Any,
 ) -> Runnable:
@@ -201,39 +204,39 @@ def create_structured_output_runnable(
             is passed in, it's assumed to already be a valid JsonSchema.
             For best results, pydantic.BaseModels should have docstrings describing what
             the schema represents and descriptions for the parameters.
-        llm: Language model to use. Assumed to support the OpenAI function-calling API 
-            if mode is 'openai-function'. Assumed to support OpenAI response_format 
+        llm: Language model to use. Assumed to support the OpenAI function-calling API
+            if mode is 'openai-function'. Assumed to support OpenAI response_format
             parameter if mode is 'openai-json'.
-        prompt: BasePromptTemplate to pass to the model. If mode is 'openai-json' and 
-            prompt has input variable 'output_schema' then the given output_schema 
+        prompt: BasePromptTemplate to pass to the model. If mode is 'openai-json' and
+            prompt has input variable 'output_schema' then the given output_schema
             will be converted to a JsonSchema and inserted in the prompt.
         output_parser: Output parser to use for parsing model outputs. By default
             will be inferred from the function types. If pydantic.BaseModel is passed
-            in, then the OutputParser will try to parse outputs using the pydantic 
+            in, then the OutputParser will try to parse outputs using the pydantic
             class. Otherwise model outputs will be parsed as JSON.
-        mode: How structured outputs are extracted from the model. If 'openai-functions' 
-            then OpenAI function calling is used with the deprecated 'functions', 
-            'function_call' schema. If 'openai-tools' then OpenAI function 
-            calling with the latest 'tools', 'tool_choice' schema is used. This is 
-            recommended over 'openai-functions'. If 'openai-json' then OpenAI model 
+        mode: How structured outputs are extracted from the model. If 'openai-functions'
+            then OpenAI function calling is used with the deprecated 'functions',
+            'function_call' schema. If 'openai-tools' then OpenAI function
+            calling with the latest 'tools', 'tool_choice' schema is used. This is
+            recommended over 'openai-functions'. If 'openai-json' then OpenAI model
             with response_format set to JSON is used.
-        enforce_function_usage: Only applies when mode is 'openai-tools' or 
-            'openai-functions'. If True, then the model will be forced to use the given 
-            output schema. If False, then the model can elect whether to use the output 
+        enforce_function_usage: Only applies when mode is 'openai-tools' or
+            'openai-functions'. If True, then the model will be forced to use the given
+            output schema. If False, then the model can elect whether to use the output
             schema.
-        return_single: Only applies when mode is 'openai-tools'. Whether to a list of 
-            structured outputs or a single one. If True and model does not return any 
-            structured outputs then chain output is None. If False and model does not 
+        return_single: Only applies when mode is 'openai-tools'. Whether to a list of
+            structured outputs or a single one. If True and model does not return any
+            structured outputs then chain output is None. If False and model does not
             return any structured outputs then chain output is an empty list.
         kwargs: Additional named arguments.
 
     Returns:
-        A runnable sequence that will return a structured output(s) matching the given 
+        A runnable sequence that will return a structured output(s) matching the given
             output_schema.
-    
+
     OpenAI tools example with Pydantic schema (mode='openai-tools'):
         .. code-block:: python
-        
+
                 from typing import Optional
 
                 from langchain.chains import create_structured_output_runnable
@@ -251,23 +254,23 @@ def create_structured_output_runnable(
                 llm = ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0)
                 prompt = ChatPromptTemplate.from_messages(
                     [
-                        ("system", "You are an extraction algorithm. Please extract every possible instance"), 
+                        ("system", "You are an extraction algorithm. Please extract every possible instance"),
                         ('human', '{input}')
                     ]
                 )
                 structured_llm = create_structured_output_runnable(
-                    RecordDog, 
-                    llm, 
-                    mode="openai-tools", 
-                    enforce_function_usage=True, 
+                    RecordDog,
+                    llm,
+                    mode="openai-tools",
+                    enforce_function_usage=True,
                     return_single=True
                 )
                 structured_llm.invoke({"input": "Harry was a chubby brown beagle who loved chicken"})
                 # -> RecordDog(name="Harry", color="brown", fav_food="chicken")
-                
+
     OpenAI tools example with dict schema (mode="openai-tools"):
         .. code-block:: python
-        
+
                 from typing import Optional
 
                 from langchain.chains import create_structured_output_runnable
@@ -303,15 +306,15 @@ def create_structured_output_runnable(
 
                 llm = ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0)
                 structured_llm = create_structured_output_runnable(
-                    dog_schema, 
-                    llm, 
-                    mode="openai-tools", 
-                    enforce_function_usage=True, 
+                    dog_schema,
+                    llm,
+                    mode="openai-tools",
+                    enforce_function_usage=True,
                     return_single=True
                 )
                 structured_llm.invoke("Harry was a chubby brown beagle who loved chicken")
                 # -> {'name': 'Harry', 'color': 'brown', 'fav_food': 'chicken'}
-    
+
     OpenAI functions example (mode="openai-functions"):
         .. code-block:: python
 
@@ -332,7 +335,7 @@ def create_structured_output_runnable(
                 structured_llm = create_structured_output_runnable(Dog, llm, mode="openai-functions")
                 structured_llm.invoke("Harry was a chubby brown beagle who loved chicken")
                 # -> Dog(name="Harry", color="brown", fav_food="chicken")
-                
+
     OpenAI functions with prompt example:
         .. code-block:: python
 
@@ -361,7 +364,7 @@ def create_structured_output_runnable(
                 # -> Dog(name="Harry", color="brown", fav_food="chicken")
     OpenAI json response format example (mode="openai-json"):
         .. code-block:: python
-        
+
                 from typing import Optional
 
                 from langchain.chains import create_structured_output_runnable
@@ -379,19 +382,21 @@ def create_structured_output_runnable(
                 llm = ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0)
                 structured_llm = create_structured_output_runnable(Dog, llm, mode="openai-json")
                 system = '''You are a world class assistant for extracting information in structured JSON formats. \
-                
+
                 Extract a valid JSON blob from the user input that matches the following JSON Schema:
-                
+
                 {output_schema}'''
                 prompt = ChatPromptTemplate.from_messages(
                     [("system", system), ("human", "{input}"),]
                 )
                 chain = prompt | structured_llm
                 chain.invoke({"input": "Harry was a chubby brown beagle who loved chicken"})
+
     """  # noqa: E501
     # for backwards compatibility
     force_function_usage = kwargs.get(
-        "enforce_single_function_usage", enforce_function_usage
+        "enforce_single_function_usage",
+        enforce_function_usage,
     )
 
     if mode == "openai-tools":
@@ -400,9 +405,8 @@ def create_structured_output_runnable(
         # Backwards compatibility keys
         unrecognized_keys = keys_in_kwargs - {"enforce_single_function_usage"}
         if unrecognized_keys:
-            raise TypeError(
-                f"Got an unexpected keyword argument(s): {unrecognized_keys}."
-            )
+            msg = f"Got an unexpected keyword argument(s): {unrecognized_keys}."
+            raise TypeError(msg)
 
         return _create_openai_tools_runnable(
             output_schema,
@@ -413,7 +417,7 @@ def create_structured_output_runnable(
             first_tool_only=return_single,
         )
 
-    elif mode == "openai-functions":
+    if mode == "openai-functions":
         return _create_openai_functions_structured_output_runnable(
             output_schema,
             llm,
@@ -422,19 +426,24 @@ def create_structured_output_runnable(
             enforce_single_function_usage=force_function_usage,
             **kwargs,  # llm-specific kwargs
         )
-    elif mode == "openai-json":
+    if mode == "openai-json":
         if force_function_usage:
-            raise ValueError(
+            msg = (
                 "enforce_single_function_usage is not supported for mode='openai-json'."
             )
+            raise ValueError(msg)
         return _create_openai_json_runnable(
-            output_schema, llm, prompt=prompt, output_parser=output_parser, **kwargs
-        )
-    else:
-        raise ValueError(
-            f"Invalid mode {mode}. Expected one of 'openai-tools', 'openai-functions', "
-            f"'openai-json'."
+            output_schema,
+            llm,
+            prompt=prompt,
+            output_parser=output_parser,
+            **kwargs,
         )
+    msg = (
+        f"Invalid mode {mode}. Expected one of 'openai-tools', 'openai-functions', "
+        f"'openai-json'."
+    )
+    raise ValueError(msg)
 
 
 def _create_openai_tools_runnable(
@@ -454,12 +463,12 @@ def _create_openai_tools_runnable(
             "function": {"name": oai_tool["function"]["name"]},
         }
     output_parser = output_parser or _get_openai_tool_output_parser(
-        tool, first_tool_only=first_tool_only
+        tool,
+        first_tool_only=first_tool_only,
     )
     if prompt:
         return prompt | llm.bind(**llm_kwargs) | output_parser
-    else:
-        return llm.bind(**llm_kwargs) | output_parser
+    return llm.bind(**llm_kwargs) | output_parser
 
 
 def _get_openai_tool_output_parser(
@@ -474,7 +483,8 @@ def _get_openai_tool_output_parser(
     else:
         key_name = convert_to_openai_tool(tool)["function"]["name"]
         output_parser = JsonOutputKeyToolsParser(
-            first_tool_only=first_tool_only, key_name=key_name
+            first_tool_only=first_tool_only,
+            key_name=key_name,
         )
     return output_parser
 
@@ -533,8 +543,7 @@ def _create_openai_json_runnable(
             prompt = prompt.partial(output_schema=json.dumps(schema_as_dict, indent=2))
 
         return prompt | llm | output_parser
-    else:
-        return llm | output_parser
+    return llm | output_parser
 
 
 def _create_openai_functions_structured_output_runnable(
@@ -563,7 +572,8 @@ def _create_openai_functions_structured_output_runnable(
 
         function = _OutputFormatter
         output_parser = output_parser or PydanticAttrOutputFunctionsParser(
-            pydantic_schema=_OutputFormatter, attr_name="output"
+            pydantic_schema=_OutputFormatter,
+            attr_name="output",
         )
     return create_openai_fn_runnable(
         [function],