Skip to content

The agent engineering platform.

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.py
index 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 BaseOutputParser
from 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.py
index 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, Type
from langchain_core.exceptions import OutputParserException
from langchain_core.output_parsers import BaseOutputParser
from 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.enum
diff --git a/libs/langchain/langchain/output_parsers/fix.py b/libs/langchain/langchain/output_parsers/fix.py
index 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, Union
from langchain_core.exceptions import OutputParserException
from langchain_core.language_models import BaseLanguageModel
from langchain_core.output_parsers import BaseOutputParser
from langchain_core.prompts import BasePromptTemplate
+from langchain_core.runnables import RunnableSerializable
from 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."""
@classmethod
def 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 | llm
return 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 e
else:
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 e
else:
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]):
@property
def _type(self) -> str:
return "output_fixing"
+
+ @property
+ def OutputType(self) -> type[T]:
+ return self.parser.OutputType
diff --git a/libs/langchain/langchain/output_parsers/pandas_dataframe.py b/libs/langchain/langchain/output_parsers/pandas_dataframe.py
index 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.py
index 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, Optional
from 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."""
@classmethod
diff --git a/libs/langchain/langchain/output_parsers/regex_dict.py b/libs/langchain/langchain/output_parsers/regex_dict.py
index 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, Optional
from 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.py
index 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, Union
from langchain_core.exceptions import OutputParserException
from langchain_core.language_models import BaseLanguageModel
from langchain_core.output_parsers import BaseOutputParser
from langchain_core.prompt_values import PromptValue
from langchain_core.prompts import BasePromptTemplate, PromptTemplate
+from langchain_core.runnables import RunnableSerializable
NAIVE_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."""
@classmethod
def 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 | llm
return 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 e
else:
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 e
else:
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."""
@classmethod
def 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 | llm
return 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: E501
retries = 0
while retries <= self.max_retries:
@@ -190,11 +215,20 @@ class RetryWithErrorOutputParser(BaseOutputParser[T]):
raise e
else:
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 e
else:
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]):
@property
def _type(self) -> str:
return "retry_with_error"
+
+ @property
+ def OutputType(self) -> type[T]:
+ return self.parser.OutputType
diff --git a/libs/langchain/langchain/output_parsers/structured.py b/libs/langchain/langchain/output_parsers/structured.py
index 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, List
from langchain_core.output_parsers import BaseOutputParser
from 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.py
index 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]):
@property
def _type(self) -> str:
return "yaml"
+
+ @property
+ def OutputType(self) -> Type[T]:
+ return self.pydantic_object
diff --git a/libs/langchain/tests/unit_tests/output_parsers/test_boolean_parser.py b/libs/langchain/tests/unit_tests/output_parsers/test_boolean_parser.py
index 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 input
with 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 == bool
diff --git a/libs/langchain/tests/unit_tests/output_parsers/test_combining_parser.py b/libs/langchain/tests/unit_tests/output_parsers/test_combining_parser.py
index 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 CombiningOutputParser
from langchain.output_parsers.regex import RegexParser
from 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.py
index 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 Colors
diff --git a/libs/langchain/tests/unit_tests/output_parsers/test_fix.py b/libs/langchain/tests/unit_tests/output_parsers/test_fix.py
new file mode 100644
index 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.OutputType
diff --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.py
index 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 pd
from 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.py
index 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: T201
assert DEF_EXPECTED_RESULT == result
+ assert pydantic_parser.OutputType is TestModel
def 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.py
new file mode 100644
index 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.py
index 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 RegexDictParser
DEF_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: T201
assert 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.py
new file mode 100644
index 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.py
index 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 OutputParserException
from langchain.output_parsers import ResponseSchema, StructuredOutputParser
def 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 raised
else:
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.py
index 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