The agent engineering platform.
Python agentsaiai-agentsanthropicchatgptdeepagentsenterpriseframeworkgeminigenerative-ailangchainlanggraphllmmultiagentopen-sourceopenaipydanticpythonragtypescript
langchain[patch]: fix `OutputType` of OutputParsers and fix legacy API in OutputParsers (#19792)
hmasdevff0c06b1e50f
diff --git a/libs/langchain/langchain/output_parsers/combining.py b/libs/langchain/langchain/output_parsers/combining.pyindex 1222c2208d..3159a014e8 100644--- a/libs/langchain/langchain/output_parsers/combining.py+++ b/libs/langchain/langchain/output_parsers/combining.py@@ -6,7 +6,7 @@ from langchain_core.output_parsers import BaseOutputParserfrom langchain_core.pydantic_v1 import root_validator-class CombiningOutputParser(BaseOutputParser):+class CombiningOutputParser(BaseOutputParser[Dict[str, Any]]):"""Combine multiple output parsers into one."""parsers: List[BaseOutputParser]diff --git a/libs/langchain/langchain/output_parsers/enum.py b/libs/langchain/langchain/output_parsers/enum.pyindex 4396a5291b..b21d80834b 100644--- a/libs/langchain/langchain/output_parsers/enum.py+++ b/libs/langchain/langchain/output_parsers/enum.py@@ -1,12 +1,12 @@from enum import Enum-from typing import Any, Dict, List, Type+from typing import Dict, List, Typefrom langchain_core.exceptions import OutputParserExceptionfrom langchain_core.output_parsers import BaseOutputParserfrom langchain_core.pydantic_v1 import root_validator-class EnumOutputParser(BaseOutputParser):+class EnumOutputParser(BaseOutputParser[Enum]):"""Parse an output that is one of a set of values."""enum: Type[Enum]@@ -23,7 +23,7 @@ class EnumOutputParser(BaseOutputParser):def _valid_values(self) -> List[str]:return [e.value for e in self.enum]- def parse(self, response: str) -> Any:+ def parse(self, response: str) -> Enum:try:return self.enum(response.strip())except ValueError:@@ -34,3 +34,7 @@ class EnumOutputParser(BaseOutputParser):def get_format_instructions(self) -> str:return f"Select one of the following options: {', '.join(self._valid_values)}"++ @property+ def OutputType(self) -> Type[Enum]:+ return self.enumdiff --git a/libs/langchain/langchain/output_parsers/fix.py b/libs/langchain/langchain/output_parsers/fix.pyindex 7b6e5a3442..849200105d 100644--- a/libs/langchain/langchain/output_parsers/fix.py+++ b/libs/langchain/langchain/output_parsers/fix.py@@ -1,11 +1,12 @@from __future__ import annotations-from typing import Any, TypeVar+from typing import Any, TypeVar, Unionfrom langchain_core.exceptions import OutputParserExceptionfrom langchain_core.language_models import BaseLanguageModelfrom langchain_core.output_parsers import BaseOutputParserfrom langchain_core.prompts import BasePromptTemplate+from langchain_core.runnables import RunnableSerializablefrom langchain.output_parsers.prompts import NAIVE_FIX_PROMPT@@ -22,10 +23,12 @@ class OutputFixingParser(BaseOutputParser[T]):parser: BaseOutputParser[T]"""The parser to use to parse the output."""# Should be an LLMChain but we want to avoid top-level imports from langchain.chains- retry_chain: Any- """The LLMChain to use to retry the completion."""+ retry_chain: Union[RunnableSerializable, Any]+ """The RunnableSerializable to use to retry the completion (Legacy: LLMChain)."""max_retries: int = 1"""The maximum number of times to retry the parse."""+ legacy: bool = True+ """Whether to use the run or arun method of the retry_chain."""@classmethoddef from_llm(@@ -46,9 +49,7 @@ class OutputFixingParser(BaseOutputParser[T]):Returns:OutputFixingParser"""- from langchain.chains.llm import LLMChain-- chain = LLMChain(llm=llm, prompt=prompt)+ chain = prompt | llmreturn cls(parser=parser, retry_chain=chain, max_retries=max_retries)def parse(self, completion: str) -> T:@@ -62,11 +63,29 @@ class OutputFixingParser(BaseOutputParser[T]):raise eelse:retries += 1- completion = self.retry_chain.run(- instructions=self.parser.get_format_instructions(),- completion=completion,- error=repr(e),- )+ if self.legacy and hasattr(self.retry_chain, "run"):+ completion = self.retry_chain.run(+ instructions=self.parser.get_format_instructions(),+ completion=completion,+ error=repr(e),+ )+ else:+ try:+ completion = self.retry_chain.invoke(+ dict(+ instructions=self.parser.get_format_instructions(), # noqa: E501+ input=completion,+ error=repr(e),+ )+ )+ except (NotImplementedError, AttributeError):+ # Case: self.parser does not have get_format_instructions # noqa: E501+ completion = self.retry_chain.invoke(+ dict(+ input=completion,+ error=repr(e),+ )+ )raise OutputParserException("Failed to parse")@@ -81,11 +100,29 @@ class OutputFixingParser(BaseOutputParser[T]):raise eelse:retries += 1- completion = await self.retry_chain.arun(- instructions=self.parser.get_format_instructions(),- completion=completion,- error=repr(e),- )+ if self.legacy and hasattr(self.retry_chain, "arun"):+ completion = await self.retry_chain.arun(+ instructions=self.parser.get_format_instructions(), # noqa: E501+ completion=completion,+ error=repr(e),+ )+ else:+ try:+ completion = await self.retry_chain.ainvoke(+ dict(+ instructions=self.parser.get_format_instructions(), # noqa: E501+ input=completion,+ error=repr(e),+ )+ )+ except (NotImplementedError, AttributeError):+ # Case: self.parser does not have get_format_instructions # noqa: E501+ completion = await self.retry_chain.ainvoke(+ dict(+ input=completion,+ error=repr(e),+ )+ )raise OutputParserException("Failed to parse")@@ -95,3 +132,7 @@ class OutputFixingParser(BaseOutputParser[T]):@propertydef _type(self) -> str:return "output_fixing"++ @property+ def OutputType(self) -> type[T]:+ return self.parser.OutputTypediff --git a/libs/langchain/langchain/output_parsers/pandas_dataframe.py b/libs/langchain/langchain/output_parsers/pandas_dataframe.pyindex 4c0cb177d0..3447767c08 100644--- a/libs/langchain/langchain/output_parsers/pandas_dataframe.py+++ b/libs/langchain/langchain/output_parsers/pandas_dataframe.py@@ -10,7 +10,7 @@ from langchain.output_parsers.format_instructions import ()-class PandasDataFrameOutputParser(BaseOutputParser):+class PandasDataFrameOutputParser(BaseOutputParser[Dict[str, Any]]):"""Parse an output using Pandas DataFrame format.""""""The Pandas DataFrame to parse."""diff --git a/libs/langchain/langchain/output_parsers/regex.py b/libs/langchain/langchain/output_parsers/regex.pyindex ea8b053e15..5add60b1b2 100644--- a/libs/langchain/langchain/output_parsers/regex.py+++ b/libs/langchain/langchain/output_parsers/regex.py@@ -6,7 +6,7 @@ from typing import Dict, List, Optionalfrom langchain_core.output_parsers import BaseOutputParser-class RegexParser(BaseOutputParser):+class RegexParser(BaseOutputParser[Dict[str, str]]):"""Parse the output of an LLM call using a regex."""@classmethoddiff --git a/libs/langchain/langchain/output_parsers/regex_dict.py b/libs/langchain/langchain/output_parsers/regex_dict.pyindex 1b390485da..df40c7683f 100644--- a/libs/langchain/langchain/output_parsers/regex_dict.py+++ b/libs/langchain/langchain/output_parsers/regex_dict.py@@ -6,7 +6,7 @@ from typing import Dict, Optionalfrom langchain_core.output_parsers import BaseOutputParser-class RegexDictParser(BaseOutputParser):+class RegexDictParser(BaseOutputParser[Dict[str, str]]):"""Parse the output of an LLM call into a Dictionary using a regex."""regex_pattern: str = r"{}:\s?([^.'\n']*)\.?" # : :meta private:diff --git a/libs/langchain/langchain/output_parsers/retry.py b/libs/langchain/langchain/output_parsers/retry.pyindex 571362f012..b82f179657 100644--- a/libs/langchain/langchain/output_parsers/retry.py+++ b/libs/langchain/langchain/output_parsers/retry.py@@ -1,12 +1,13 @@from __future__ import annotations-from typing import Any, TypeVar+from typing import Any, TypeVar, Unionfrom langchain_core.exceptions import OutputParserExceptionfrom langchain_core.language_models import BaseLanguageModelfrom langchain_core.output_parsers import BaseOutputParserfrom langchain_core.prompt_values import PromptValuefrom langchain_core.prompts import BasePromptTemplate, PromptTemplate+from langchain_core.runnables import RunnableSerializableNAIVE_COMPLETION_RETRY = """Prompt:{prompt}@@ -43,10 +44,12 @@ class RetryOutputParser(BaseOutputParser[T]):parser: BaseOutputParser[T]"""The parser to use to parse the output."""# Should be an LLMChain but we want to avoid top-level imports from langchain.chains- retry_chain: Any- """The LLMChain to use to retry the completion."""+ retry_chain: Union[RunnableSerializable, Any]+ """The RunnableSerializable to use to retry the completion (Legacy: LLMChain)."""max_retries: int = 1"""The maximum number of times to retry the parse."""+ legacy: bool = True+ """Whether to use the run or arun method of the retry_chain."""@classmethoddef from_llm(@@ -67,9 +70,7 @@ class RetryOutputParser(BaseOutputParser[T]):Returns:RetryOutputParser"""- from langchain.chains.llm import LLMChain-- chain = LLMChain(llm=llm, prompt=prompt)+ chain = prompt | llmreturn cls(parser=parser, retry_chain=chain, max_retries=max_retries)def parse_with_prompt(self, completion: str, prompt_value: PromptValue) -> T:@@ -92,9 +93,19 @@ class RetryOutputParser(BaseOutputParser[T]):raise eelse:retries += 1- completion = self.retry_chain.run(- prompt=prompt_value.to_string(), completion=completion- )+ if self.legacy and hasattr(self.retry_chain, "run"):+ completion = self.retry_chain.run(+ prompt=prompt_value.to_string(),+ completion=completion,+ error=repr(e),+ )+ else:+ completion = self.retry_chain.invoke(+ dict(+ prompt=prompt_value.to_string(),+ input=completion,+ )+ )raise OutputParserException("Failed to parse")@@ -118,9 +129,19 @@ class RetryOutputParser(BaseOutputParser[T]):raise eelse:retries += 1- completion = await self.retry_chain.arun(- prompt=prompt_value.to_string(), completion=completion- )+ if self.legacy and hasattr(self.retry_chain, "arun"):+ completion = await self.retry_chain.arun(+ prompt=prompt_value.to_string(),+ completion=completion,+ error=repr(e),+ )+ else:+ completion = await self.retry_chain.ainvoke(+ dict(+ prompt=prompt_value.to_string(),+ input=completion,+ )+ )raise OutputParserException("Failed to parse")@@ -136,6 +157,10 @@ class RetryOutputParser(BaseOutputParser[T]):def _type(self) -> str:return "retry"+ @property+ def OutputType(self) -> type[T]:+ return self.parser.OutputType+class RetryWithErrorOutputParser(BaseOutputParser[T]):"""Wrap a parser and try to fix parsing errors.@@ -149,11 +174,13 @@ class RetryWithErrorOutputParser(BaseOutputParser[T]):parser: BaseOutputParser[T]"""The parser to use to parse the output."""- # Should be an LLMChain but we want to avoid top-level imports from langchain.chains- retry_chain: Any- """The LLMChain to use to retry the completion."""+ # Should be an LLMChain but we want to avoid top-level imports from langchain.chains # noqa: E501+ retry_chain: Union[RunnableSerializable, Any]+ """The RunnableSerializable to use to retry the completion (Legacy: LLMChain)."""max_retries: int = 1"""The maximum number of times to retry the parse."""+ legacy: bool = True+ """Whether to use the run or arun method of the retry_chain."""@classmethoddef from_llm(@@ -174,12 +201,10 @@ class RetryWithErrorOutputParser(BaseOutputParser[T]):Returns:A RetryWithErrorOutputParser."""- from langchain.chains.llm import LLMChain-- chain = LLMChain(llm=llm, prompt=prompt)+ chain = prompt | llmreturn cls(parser=parser, retry_chain=chain, max_retries=max_retries)- def parse_with_prompt(self, completion: str, prompt_value: PromptValue) -> T:+ def parse_with_prompt(self, completion: str, prompt_value: PromptValue) -> T: # noqa: E501retries = 0while retries <= self.max_retries:@@ -190,11 +215,20 @@ class RetryWithErrorOutputParser(BaseOutputParser[T]):raise eelse:retries += 1- completion = self.retry_chain.run(- prompt=prompt_value.to_string(),- completion=completion,- error=repr(e),- )+ if self.legacy and hasattr(self.retry_chain, "run"):+ completion = self.retry_chain.run(+ prompt=prompt_value.to_string(),+ completion=completion,+ error=repr(e),+ )+ else:+ completion = self.retry_chain.invoke(+ dict(+ input=completion,+ prompt=prompt_value.to_string(),+ error=repr(e),+ )+ )raise OutputParserException("Failed to parse")@@ -209,11 +243,20 @@ class RetryWithErrorOutputParser(BaseOutputParser[T]):raise eelse:retries += 1- completion = await self.retry_chain.arun(- prompt=prompt_value.to_string(),- completion=completion,- error=repr(e),- )+ if self.legacy and hasattr(self.retry_chain, "arun"):+ completion = await self.retry_chain.arun(+ prompt=prompt_value.to_string(),+ completion=completion,+ error=repr(e),+ )+ else:+ completion = await self.retry_chain.ainvoke(+ dict(+ prompt=prompt_value.to_string(),+ input=completion,+ error=repr(e),+ )+ )raise OutputParserException("Failed to parse")@@ -228,3 +271,7 @@ class RetryWithErrorOutputParser(BaseOutputParser[T]):@propertydef _type(self) -> str:return "retry_with_error"++ @property+ def OutputType(self) -> type[T]:+ return self.parser.OutputTypediff --git a/libs/langchain/langchain/output_parsers/structured.py b/libs/langchain/langchain/output_parsers/structured.pyindex 57abb7f2c8..097e1a7170 100644--- a/libs/langchain/langchain/output_parsers/structured.py+++ b/libs/langchain/langchain/output_parsers/structured.py@@ -1,6 +1,6 @@from __future__ import annotations-from typing import Any, List+from typing import Any, Dict, Listfrom langchain_core.output_parsers import BaseOutputParserfrom langchain_core.output_parsers.json import parse_and_check_json_markdown@@ -31,7 +31,7 @@ def _get_sub_string(schema: ResponseSchema) -> str:)-class StructuredOutputParser(BaseOutputParser):+class StructuredOutputParser(BaseOutputParser[Dict[str, Any]]):"""Parse the output of an LLM call to a structured output."""response_schemas: List[ResponseSchema]@@ -92,7 +92,7 @@ class StructuredOutputParser(BaseOutputParser):else:return STRUCTURED_FORMAT_INSTRUCTIONS.format(format=schema_str)- def parse(self, text: str) -> Any:+ def parse(self, text: str) -> Dict[str, Any]:expected_keys = [rs.name for rs in self.response_schemas]return parse_and_check_json_markdown(text, expected_keys)diff --git a/libs/langchain/langchain/output_parsers/yaml.py b/libs/langchain/langchain/output_parsers/yaml.pyindex 21bcf359a2..e7c071eb40 100644--- a/libs/langchain/langchain/output_parsers/yaml.py+++ b/libs/langchain/langchain/output_parsers/yaml.py@@ -60,3 +60,7 @@ class YamlOutputParser(BaseOutputParser[T]):@propertydef _type(self) -> str:return "yaml"++ @property+ def OutputType(self) -> Type[T]:+ return self.pydantic_objectdiff --git a/libs/langchain/tests/unit_tests/output_parsers/test_boolean_parser.py b/libs/langchain/tests/unit_tests/output_parsers/test_boolean_parser.pyindex bae5992875..2ccfc2f1b2 100644--- a/libs/langchain/tests/unit_tests/output_parsers/test_boolean_parser.py+++ b/libs/langchain/tests/unit_tests/output_parsers/test_boolean_parser.py@@ -39,3 +39,8 @@ def test_boolean_output_parser_parse() -> None:# Bad inputwith pytest.raises(ValueError):parser.parse("BOOM")+++def test_boolean_output_parser_output_type() -> None:+ """Test the output type of the boolean output parser is a boolean."""+ assert BooleanOutputParser().OutputType == booldiff --git a/libs/langchain/tests/unit_tests/output_parsers/test_combining_parser.py b/libs/langchain/tests/unit_tests/output_parsers/test_combining_parser.pyindex 21a3ab6a92..a2d757e886 100644--- a/libs/langchain/tests/unit_tests/output_parsers/test_combining_parser.py+++ b/libs/langchain/tests/unit_tests/output_parsers/test_combining_parser.py@@ -1,4 +1,6 @@"""Test in memory docstore."""+from typing import Any, Dict+from langchain.output_parsers.combining import CombiningOutputParserfrom langchain.output_parsers.regex import RegexParserfrom langchain.output_parsers.structured import ResponseSchema, StructuredOutputParser@@ -43,3 +45,27 @@ def test_combining_dict_result() -> None:combining_parser = CombiningOutputParser(parsers=parsers)result_dict = combining_parser.parse(DEF_README)assert DEF_EXPECTED_RESULT == result_dict+++def test_combining_output_parser_output_type() -> None:+ """Test combining output parser output type is Dict[str, Any]."""+ parsers = [+ StructuredOutputParser(+ response_schemas=[+ ResponseSchema(+ name="answer", description="answer to the user's question"+ ),+ ResponseSchema(+ name="source",+ description="source used to answer the user's question",+ ),+ ]+ ),+ RegexParser(+ regex=r"Confidence: (A|B|C), Explanation: (.*)",+ output_keys=["confidence", "explanation"],+ default_output_key="noConfidence",+ ),+ ]+ combining_parser = CombiningOutputParser(parsers=parsers)+ assert combining_parser.OutputType is Dict[str, Any]diff --git a/libs/langchain/tests/unit_tests/output_parsers/test_enum_parser.py b/libs/langchain/tests/unit_tests/output_parsers/test_enum_parser.pyindex 57fe3e0717..b385b65b53 100644--- a/libs/langchain/tests/unit_tests/output_parsers/test_enum_parser.py+++ b/libs/langchain/tests/unit_tests/output_parsers/test_enum_parser.py@@ -30,3 +30,8 @@ def test_enum_output_parser_parse() -> None:assert False, "Should have raised OutputParserException"except OutputParserException:pass+++def test_enum_output_parser_output_type() -> None:+ """Test the output type of the enum output parser is the expected enum."""+ assert EnumOutputParser(enum=Colors).OutputType is Colorsdiff --git a/libs/langchain/tests/unit_tests/output_parsers/test_fix.py b/libs/langchain/tests/unit_tests/output_parsers/test_fix.pynew file mode 100644index 0000000000..0f1eaf9413--- /dev/null+++ b/libs/langchain/tests/unit_tests/output_parsers/test_fix.py@@ -0,0 +1,121 @@+from typing import Any++import pytest+from langchain_core.exceptions import OutputParserException+from langchain_core.runnables import RunnablePassthrough++from langchain.output_parsers.boolean import BooleanOutputParser+from langchain.output_parsers.datetime import DatetimeOutputParser+from langchain.output_parsers.fix import BaseOutputParser, OutputFixingParser+++class SuccessfulParseAfterRetries(BaseOutputParser[str]):+ parse_count: int = 0 # Number of times parse has been called+ attemp_count_before_success: int # Number of times to fail before succeeding # noqa++ def parse(self, *args: Any, **kwargs: Any) -> str:+ self.parse_count += 1+ if self.parse_count <= self.attemp_count_before_success:+ raise OutputParserException("error")+ return "parsed"+++class SuccessfulParseAfterRetriesWithGetFormatInstructions(SuccessfulParseAfterRetries): # noqa+ def get_format_instructions(self) -> str:+ return "instructions"+++ "base_parser",+ [+ SuccessfulParseAfterRetries(attemp_count_before_success=5),+ SuccessfulParseAfterRetriesWithGetFormatInstructions(+ attemp_count_before_success=5+ ), # noqa: E501+ ],+)+def test_output_fixing_parser_parse(+ base_parser: SuccessfulParseAfterRetries,+) -> None:+ # preparation+ n: int = (+ base_parser.attemp_count_before_success+ ) # Success on the (n+1)-th attempt # noqa+ base_parser = SuccessfulParseAfterRetries(attemp_count_before_success=n)+ parser = OutputFixingParser(+ parser=base_parser,+ max_retries=n, # n times to retry, that is, (n+1) times call+ retry_chain=RunnablePassthrough(),+ legacy=False,+ )+ # test+ assert parser.parse("completion") == "parsed"+ assert base_parser.parse_count == n + 1+ # TODO: test whether "instructions" is passed to the retry_chain+++ "base_parser",+ [+ SuccessfulParseAfterRetries(attemp_count_before_success=5),+ SuccessfulParseAfterRetriesWithGetFormatInstructions(+ attemp_count_before_success=5+ ), # noqa: E501+ ],+)+async def test_output_fixing_parser_aparse(+ base_parser: SuccessfulParseAfterRetries,+) -> None:+ n: int = (+ base_parser.attemp_count_before_success+ ) # Success on the (n+1)-th attempt # noqa+ base_parser = SuccessfulParseAfterRetries(attemp_count_before_success=n)+ parser = OutputFixingParser(+ parser=base_parser,+ max_retries=n, # n times to retry, that is, (n+1) times call+ retry_chain=RunnablePassthrough(),+ legacy=False,+ )+ assert (await parser.aparse("completion")) == "parsed"+ assert base_parser.parse_count == n + 1+ # TODO: test whether "instructions" is passed to the retry_chain+++def test_output_fixing_parser_parse_fail() -> None:+ n: int = 5 # Success on the (n+1)-th attempt+ base_parser = SuccessfulParseAfterRetries(attemp_count_before_success=n)+ parser = OutputFixingParser(+ parser=base_parser,+ max_retries=n - 1, # n-1 times to retry, that is, n times call+ retry_chain=RunnablePassthrough(),+ legacy=False,+ )+ with pytest.raises(OutputParserException):+ parser.parse("completion")+ assert base_parser.parse_count == n+++async def test_output_fixing_parser_aparse_fail() -> None:+ n: int = 5 # Success on the (n+1)-th attempt+ base_parser = SuccessfulParseAfterRetries(attemp_count_before_success=n)+ parser = OutputFixingParser(+ parser=base_parser,+ max_retries=n - 1, # n-1 times to retry, that is, n times call+ retry_chain=RunnablePassthrough(),+ legacy=False,+ )+ with pytest.raises(OutputParserException):+ await parser.aparse("completion")+ assert base_parser.parse_count == n+++ "base_parser",+ [+ BooleanOutputParser(),+ DatetimeOutputParser(),+ ],+)+def test_output_fixing_parser_output_type(base_parser: BaseOutputParser) -> None: # noqa: E501+ parser = OutputFixingParser(parser=base_parser, retry_chain=RunnablePassthrough()) # noqa: E501+ assert parser.OutputType is base_parser.OutputTypediff --git a/libs/langchain/tests/unit_tests/output_parsers/test_pandas_dataframe_parser.py b/libs/langchain/tests/unit_tests/output_parsers/test_pandas_dataframe_parser.pyindex 1a61ba2c49..6b20614dd8 100644--- a/libs/langchain/tests/unit_tests/output_parsers/test_pandas_dataframe_parser.py+++ b/libs/langchain/tests/unit_tests/output_parsers/test_pandas_dataframe_parser.py@@ -1,4 +1,6 @@"""Test PandasDataframeParser"""+from typing import Any, Dict+import pandas as pdfrom langchain_core.exceptions import OutputParserException@@ -108,3 +110,8 @@ def test_pandas_output_parser_invalid_special_op() -> None:assert False, "Should have raised OutputParserException"except OutputParserException:assert True+++def test_pandas_output_parser_output_type() -> None:+ """Test the output type of the pandas dataframe output parser is a pandas dataframe.""" # noqa: E501+ assert parser.OutputType is Dict[str, Any]diff --git a/libs/langchain/tests/unit_tests/output_parsers/test_pydantic_parser.py b/libs/langchain/tests/unit_tests/output_parsers/test_pydantic_parser.pyindex ee08ce2616..f8c7d42c70 100644--- a/libs/langchain/tests/unit_tests/output_parsers/test_pydantic_parser.py+++ b/libs/langchain/tests/unit_tests/output_parsers/test_pydantic_parser.py@@ -60,6 +60,7 @@ def test_pydantic_output_parser() -> None:result = pydantic_parser.parse(DEF_RESULT)print("parse_result:", result) # noqa: T201assert DEF_EXPECTED_RESULT == result+ assert pydantic_parser.OutputType is TestModeldef test_pydantic_output_parser_fail() -> None:diff --git a/libs/langchain/tests/unit_tests/output_parsers/test_regex.py b/libs/langchain/tests/unit_tests/output_parsers/test_regex.pynew file mode 100644index 0000000000..ef434b4ba7--- /dev/null+++ b/libs/langchain/tests/unit_tests/output_parsers/test_regex.py@@ -0,0 +1,38 @@+from typing import Dict++from langchain.output_parsers.regex import RegexParser++# NOTE: The almost same constant variables in ./test_combining_parser.py+DEF_EXPECTED_RESULT = {+ "confidence": "A",+ "explanation": "Paris is the capital of France according to Wikipedia.",+}++DEF_README = """```json+{+ "answer": "Paris",+ "source": "https://en.wikipedia.org/wiki/France"+}+```++//Confidence: A, Explanation: Paris is the capital of France according to Wikipedia."""+++def test_regex_parser_parse() -> None:+ """Test regex parser parse."""+ parser = RegexParser(+ regex=r"Confidence: (A|B|C), Explanation: (.*)",+ output_keys=["confidence", "explanation"],+ default_output_key="noConfidence",+ )+ assert DEF_EXPECTED_RESULT == parser.parse(DEF_README)+++def test_regex_parser_output_type() -> None:+ """Test regex parser output type is Dict[str, str]."""+ parser = RegexParser(+ regex=r"Confidence: (A|B|C), Explanation: (.*)",+ output_keys=["confidence", "explanation"],+ default_output_key="noConfidence",+ )+ assert parser.OutputType is Dict[str, str]diff --git a/libs/langchain/tests/unit_tests/output_parsers/test_regex_dict.py b/libs/langchain/tests/unit_tests/output_parsers/test_regex_dict.pyindex c07d0c8567..b9cc1f38a3 100644--- a/libs/langchain/tests/unit_tests/output_parsers/test_regex_dict.py+++ b/libs/langchain/tests/unit_tests/output_parsers/test_regex_dict.py@@ -1,5 +1,7 @@"""Test in memory docstore."""+from typing import Dict+from langchain.output_parsers.regex_dict import RegexDictParserDEF_EXPECTED_RESULT = {"action": "Search", "action_input": "How to use this class?"}@@ -36,3 +38,11 @@ def test_regex_dict_result() -> None:result_dict = regex_dict_parser.parse(DEF_README)print("parse_result:", result_dict) # noqa: T201assert DEF_EXPECTED_RESULT == result_dict+++def test_regex_dict_output_type() -> None:+ """Test regex dict output type."""+ regex_dict_parser = RegexDictParser(+ output_key_to_format=DEF_OUTPUT_KEY_TO_FORMAT, no_update_value="N/A"+ )+ assert regex_dict_parser.OutputType is Dict[str, str]diff --git a/libs/langchain/tests/unit_tests/output_parsers/test_retry.py b/libs/langchain/tests/unit_tests/output_parsers/test_retry.pynew file mode 100644index 0000000000..161ba32a98--- /dev/null+++ b/libs/langchain/tests/unit_tests/output_parsers/test_retry.py@@ -0,0 +1,196 @@+from typing import Any++import pytest+from langchain_core.prompt_values import StringPromptValue+from langchain_core.runnables import RunnablePassthrough++from langchain.output_parsers.boolean import BooleanOutputParser+from langchain.output_parsers.datetime import DatetimeOutputParser+from langchain.output_parsers.retry import (+ BaseOutputParser,+ OutputParserException,+ RetryOutputParser,+ RetryWithErrorOutputParser,+)+++class SuccessfulParseAfterRetries(BaseOutputParser[str]):+ parse_count: int = 0 # Number of times parse has been called+ attemp_count_before_success: int # Number of times to fail before succeeding # noqa+ error_msg: str = "error"++ def parse(self, *args: Any, **kwargs: Any) -> str:+ self.parse_count += 1+ if self.parse_count <= self.attemp_count_before_success:+ raise OutputParserException(self.error_msg)+ return "parsed"+++def test_retry_output_parser_parse_with_prompt() -> None:+ n: int = 5 # Success on the (n+1)-th attempt+ base_parser = SuccessfulParseAfterRetries(attemp_count_before_success=n)+ parser = RetryOutputParser(+ parser=base_parser,+ retry_chain=RunnablePassthrough(),+ max_retries=n, # n times to retry, that is, (n+1) times call+ legacy=False,+ )+ actual = parser.parse_with_prompt("completion", StringPromptValue(text="dummy")) # noqa: E501+ assert actual == "parsed"+ assert base_parser.parse_count == n + 1+++def test_retry_output_parser_parse_with_prompt_fail() -> None:+ n: int = 5 # Success on the (n+1)-th attempt+ base_parser = SuccessfulParseAfterRetries(attemp_count_before_success=n)+ parser = RetryOutputParser(+ parser=base_parser,+ retry_chain=RunnablePassthrough(),+ max_retries=n - 1, # n-1 times to retry, that is, n times call+ legacy=False,+ )+ with pytest.raises(OutputParserException):+ parser.parse_with_prompt("completion", StringPromptValue(text="dummy"))+ assert base_parser.parse_count == n+++async def test_retry_output_parser_aparse_with_prompt() -> None:+ n: int = 5 # Success on the (n+1)-th attempt+ base_parser = SuccessfulParseAfterRetries(attemp_count_before_success=n)+ parser = RetryOutputParser(+ parser=base_parser,+ retry_chain=RunnablePassthrough(),+ max_retries=n, # n times to retry, that is, (n+1) times call+ legacy=False,+ )+ actual = await parser.aparse_with_prompt(+ "completion", StringPromptValue(text="dummy")+ )+ assert actual == "parsed"+ assert base_parser.parse_count == n + 1+++async def test_retry_output_parser_aparse_with_prompt_fail() -> None:+ n: int = 5 # Success on the (n+1)-th attempt+ base_parser = SuccessfulParseAfterRetries(attemp_count_before_success=n)+ parser = RetryOutputParser(+ parser=base_parser,+ retry_chain=RunnablePassthrough(),+ max_retries=n - 1, # n-1 times to retry, that is, n times call+ legacy=False,+ )+ with pytest.raises(OutputParserException):+ await parser.aparse_with_prompt("completion", StringPromptValue(text="dummy")) # noqa: E501+ assert base_parser.parse_count == n+++ "base_parser",+ [+ BooleanOutputParser(),+ DatetimeOutputParser(),+ ],+)+def test_retry_output_parser_output_type(base_parser: BaseOutputParser) -> None:+ parser = RetryOutputParser(+ parser=base_parser,+ retry_chain=RunnablePassthrough(),+ legacy=False,+ )+ assert parser.OutputType is base_parser.OutputType+++def test_retry_output_parser_parse_is_not_implemented() -> None:+ parser = RetryOutputParser(+ parser=BooleanOutputParser(),+ retry_chain=RunnablePassthrough(),+ legacy=False,+ )+ with pytest.raises(NotImplementedError):+ parser.parse("completion")+++def test_retry_with_error_output_parser_parse_with_prompt() -> None:+ n: int = 5 # Success on the (n+1)-th attempt+ base_parser = SuccessfulParseAfterRetries(attemp_count_before_success=n)+ parser = RetryWithErrorOutputParser(+ parser=base_parser,+ retry_chain=RunnablePassthrough(),+ max_retries=n, # n times to retry, that is, (n+1) times call+ legacy=False,+ )+ actual = parser.parse_with_prompt("completion", StringPromptValue(text="dummy")) # noqa: E501+ assert actual == "parsed"+ assert base_parser.parse_count == n + 1+++def test_retry_with_error_output_parser_parse_with_prompt_fail() -> None:+ n: int = 5 # Success on the (n+1)-th attempt+ base_parser = SuccessfulParseAfterRetries(attemp_count_before_success=n)+ parser = RetryWithErrorOutputParser(+ parser=base_parser,+ retry_chain=RunnablePassthrough(),+ max_retries=n - 1, # n-1 times to retry, that is, n times call+ legacy=False,+ )+ with pytest.raises(OutputParserException):+ parser.parse_with_prompt("completion", StringPromptValue(text="dummy"))+ assert base_parser.parse_count == n+++async def test_retry_with_error_output_parser_aparse_with_prompt() -> None:+ n: int = 5 # Success on the (n+1)-th attempt+ base_parser = SuccessfulParseAfterRetries(attemp_count_before_success=n)+ parser = RetryWithErrorOutputParser(+ parser=base_parser,+ retry_chain=RunnablePassthrough(),+ max_retries=n, # n times to retry, that is, (n+1) times call+ legacy=False,+ )+ actual = await parser.aparse_with_prompt(+ "completion", StringPromptValue(text="dummy")+ )+ assert actual == "parsed"+ assert base_parser.parse_count == n + 1+++async def test_retry_with_error_output_parser_aparse_with_prompt_fail() -> None: # noqa: E501+ n: int = 5 # Success on the (n+1)-th attempt+ base_parser = SuccessfulParseAfterRetries(attemp_count_before_success=n)+ parser = RetryWithErrorOutputParser(+ parser=base_parser,+ retry_chain=RunnablePassthrough(),+ max_retries=n - 1, # n-1 times to retry, that is, n times call+ legacy=False,+ )+ with pytest.raises(OutputParserException):+ await parser.aparse_with_prompt("completion", StringPromptValue(text="dummy")) # noqa: E501+ assert base_parser.parse_count == n+++ "base_parser",+ [+ BooleanOutputParser(),+ DatetimeOutputParser(),+ ],+)+def test_retry_with_error_output_parser_output_type(+ base_parser: BaseOutputParser,+) -> None:+ parser = RetryWithErrorOutputParser(+ parser=base_parser,+ retry_chain=RunnablePassthrough(),+ legacy=False,+ )+ assert parser.OutputType is base_parser.OutputType+++def test_retry_with_error_output_parser_parse_is_not_implemented() -> None:+ parser = RetryWithErrorOutputParser(+ parser=BooleanOutputParser(),+ retry_chain=RunnablePassthrough(),+ legacy=False,+ )+ with pytest.raises(NotImplementedError):+ parser.parse("completion")diff --git a/libs/langchain/tests/unit_tests/output_parsers/test_structured_parser.py b/libs/langchain/tests/unit_tests/output_parsers/test_structured_parser.pyindex 8fec872eb2..857b427a41 100644--- a/libs/langchain/tests/unit_tests/output_parsers/test_structured_parser.py+++ b/libs/langchain/tests/unit_tests/output_parsers/test_structured_parser.py@@ -1,9 +1,12 @@+from typing import Any, Dict+from langchain_core.exceptions import OutputParserExceptionfrom langchain.output_parsers import ResponseSchema, StructuredOutputParserdef test_parse() -> None:+ """Test parsing structured output."""response_schemas = [ResponseSchema(name="name", description="desc"),ResponseSchema(name="age", description="desc"),@@ -24,3 +27,13 @@ def test_parse() -> None:pass # Test passes if OutputParserException is raisedelse:assert False, f"Expected OutputParserException, but got {parser.parse(text)}"+++def test_output_type() -> None:+ """Test the output type of the structured output parser is Dict[str, Any]."""+ response_schemas = [+ ResponseSchema(name="name", description="desc"),+ ResponseSchema(name="age", description="desc"),+ ]+ parser = StructuredOutputParser.from_response_schemas(response_schemas)+ assert parser.OutputType == Dict[str, Any]diff --git a/libs/langchain/tests/unit_tests/output_parsers/test_yaml_parser.py b/libs/langchain/tests/unit_tests/output_parsers/test_yaml_parser.pyindex b48a353d8d..065ca4aa96 100644--- a/libs/langchain/tests/unit_tests/output_parsers/test_yaml_parser.py+++ b/libs/langchain/tests/unit_tests/output_parsers/test_yaml_parser.py@@ -93,3 +93,9 @@ def test_yaml_output_parser_fail() -> None:assert "Failed to parse TestModel from completion" in str(e)else:assert False, "Expected OutputParserException"+++def test_yaml_output_parser_output_type() -> None:+ """Test YamlOutputParser OutputType."""+ yaml_parser = YamlOutputParser(pydantic_object=TestModel)+ assert yaml_parser.OutputType is TestModel