langchain-core 0.4.0.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

langchain_core/output_parsers/__init__.py

@@ -1,17 +1,4 @@
-"""**OutputParser** classes parse the output of an LLM call.
-
-**Class hierarchy:**
-
-.. code-block::
-
-    BaseLLMOutputParser --> BaseOutputParser --> <name>OutputParser  # ListOutputParser, PydanticOutputParser
-
-**Main helpers:**
-
-.. code-block::
-
-    Serializable, Generation, PromptValue
-"""  # noqa: E501
+"""**OutputParser** classes parse the output of an LLM call."""
 
 from typing import TYPE_CHECKING
 

langchain_core/output_parsers/base.py

@@ -8,10 +8,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Generic,
-    Optional,
     TypeVar,
-    Union,
-    cast,
 )
 
 from typing_extensions import override
@@ -21,48 +18,45 @@ from langchain_core.messages import AnyMessage, BaseMessage
 from langchain_core.outputs import ChatGeneration, Generation
 from langchain_core.runnables import Runnable, RunnableConfig, RunnableSerializable
 from langchain_core.runnables.config import run_in_executor
-from langchain_core.v1.messages import AIMessage, MessageV1, MessageV1Types
 
 if TYPE_CHECKING:
     from langchain_core.prompt_values import PromptValue
 
 T = TypeVar("T")
-OutputParserLike = Runnable[Union[LanguageModelOutput, AIMessage], T]
+OutputParserLike = Runnable[LanguageModelOutput, T]
 
 
 class BaseLLMOutputParser(ABC, Generic[T]):
     """Abstract base class for parsing the outputs of a model."""
 
     @abstractmethod
-    def parse_result(
-        self, result: Union[list[Generation], AIMessage], *, partial: bool = False
-    ) -> T:
-        """Parse a list of candidate model Generations into a specific format.
+    def parse_result(self, result: list[Generation], *, partial: bool = False) -> T:
+        """Parse a list of candidate model `Generation` objects into a specific format.
 
         Args:
-            result: A list of Generations to be parsed. The Generations are assumed
-                to be different candidate outputs for a single model input.
+            result: A list of `Generation` to be parsed. The `Generation` objects are
+                assumed to be different candidate outputs for a single model input.
             partial: Whether to parse the output as a partial result. This is useful
-                for parsers that can parse partial results. Default is False.
+                for parsers that can parse partial results.
 
         Returns:
             Structured output.
         """
 
     async def aparse_result(
-        self, result: Union[list[Generation], AIMessage], *, partial: bool = False
+        self, result: list[Generation], *, partial: bool = False
     ) -> T:
-        """Async parse a list of candidate model Generations into a specific format.
+        """Async parse a list of candidate model `Generation` objects into a specific format.
 
         Args:
-            result: A list of Generations to be parsed. The Generations are assumed
+            result: A list of `Generation` to be parsed. The Generations are assumed
                 to be different candidate outputs for a single model input.
             partial: Whether to parse the output as a partial result. This is useful
-                for parsers that can parse partial results. Default is False.
+                for parsers that can parse partial results.
 
         Returns:
             Structured output.
-        """
+        """  # noqa: E501
         return await run_in_executor(None, self.parse_result, result, partial=partial)
 
 
@@ -75,7 +69,7 @@ class BaseGenerationOutputParser(
     @override
     def InputType(self) -> Any:
         """Return the input type for the parser."""
-        return Union[str, AnyMessage, MessageV1]
+        return str | AnyMessage
 
     @property
     @override
@@ -88,8 +82,8 @@ class BaseGenerationOutputParser(
     @override
     def invoke(
         self,
-        input: Union[str, BaseMessage, MessageV1],
-        config: Optional[RunnableConfig] = None,
+        input: str | BaseMessage,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> T:
         if isinstance(input, BaseMessage):
@@ -101,16 +95,9 @@ class BaseGenerationOutputParser(
                 config,
                 run_type="parser",
             )
-        if isinstance(input, MessageV1Types):
-            return self._call_with_config(
-                lambda inner_input: self.parse_result(inner_input),
-                input,
-                config,
-                run_type="parser",
-            )
         return self._call_with_config(
             lambda inner_input: self.parse_result([Generation(text=inner_input)]),
-            cast("str", input),
+            input,
             config,
             run_type="parser",
         )
@@ -118,9 +105,9 @@ class BaseGenerationOutputParser(
     @override
     async def ainvoke(
         self,
-        input: Union[str, BaseMessage],
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        input: str | BaseMessage,
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> T:
         if isinstance(input, BaseMessage):
             return await self._acall_with_config(
@@ -131,13 +118,6 @@ class BaseGenerationOutputParser(
                 config,
                 run_type="parser",
             )
-        if isinstance(input, MessageV1Types):
-            return await self._acall_with_config(
-                lambda inner_input: self.aparse_result(inner_input),
-                input,
-                config,
-                run_type="parser",
-            )
         return await self._acall_with_config(
             lambda inner_input: self.aparse_result([Generation(text=inner_input)]),
             input,
@@ -147,40 +127,42 @@ class BaseGenerationOutputParser(
 
 
 class BaseOutputParser(
-    BaseLLMOutputParser, RunnableSerializable[Union[LanguageModelOutput, AIMessage], T]
+    BaseLLMOutputParser, RunnableSerializable[LanguageModelOutput, T]
 ):
     """Base class to parse the output of an LLM call.
 
     Output parsers help structure language model responses.
 
     Example:
-        .. code-block:: python
-
-            class BooleanOutputParser(BaseOutputParser[bool]):
-                true_val: str = "YES"
-                false_val: str = "NO"
-
-                def parse(self, text: str) -> bool:
-                    cleaned_text = text.strip().upper()
-                    if cleaned_text not in (self.true_val.upper(), self.false_val.upper()):
-                        raise OutputParserException(
-                            f"BooleanOutputParser expected output value to either be "
-                            f"{self.true_val} or {self.false_val} (case-insensitive). "
-                            f"Received {cleaned_text}."
-                        )
-                    return cleaned_text == self.true_val.upper()
-
-                @property
-                def _type(self) -> str:
-                    return "boolean_output_parser"
-
-    """  # noqa: E501
+        ```python
+        class BooleanOutputParser(BaseOutputParser[bool]):
+            true_val: str = "YES"
+            false_val: str = "NO"
+
+            def parse(self, text: str) -> bool:
+                cleaned_text = text.strip().upper()
+                if cleaned_text not in (
+                    self.true_val.upper(),
+                    self.false_val.upper(),
+                ):
+                    raise OutputParserException(
+                        f"BooleanOutputParser expected output value to either be "
+                        f"{self.true_val} or {self.false_val} (case-insensitive). "
+                        f"Received {cleaned_text}."
+                    )
+                return cleaned_text == self.true_val.upper()
+
+            @property
+            def _type(self) -> str:
+                return "boolean_output_parser"
+        ```
+    """
 
     @property
     @override
     def InputType(self) -> Any:
         """Return the input type for the parser."""
-        return Union[str, AnyMessage, MessageV1]
+        return str | AnyMessage
 
     @property
     @override
@@ -190,7 +172,7 @@ class BaseOutputParser(
         This property is inferred from the first type argument of the class.
 
         Raises:
-            TypeError: If the class doesn't have an inferable OutputType.
+            TypeError: If the class doesn't have an inferable `OutputType`.
         """
         for base in self.__class__.mro():
             if hasattr(base, "__pydantic_generic_metadata__"):
@@ -207,8 +189,8 @@ class BaseOutputParser(
     @override
     def invoke(
         self,
-        input: Union[str, BaseMessage, MessageV1],
-        config: Optional[RunnableConfig] = None,
+        input: str | BaseMessage,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> T:
         if isinstance(input, BaseMessage):
@@ -220,16 +202,9 @@ class BaseOutputParser(
                 config,
                 run_type="parser",
             )
-        if isinstance(input, MessageV1Types):
-            return self._call_with_config(
-                lambda inner_input: self.parse_result(inner_input),
-                input,
-                config,
-                run_type="parser",
-            )
         return self._call_with_config(
             lambda inner_input: self.parse_result([Generation(text=inner_input)]),
-            cast("str", input),
+            input,
             config,
             run_type="parser",
         )
@@ -237,9 +212,9 @@ class BaseOutputParser(
     @override
     async def ainvoke(
         self,
-        input: Union[str, BaseMessage, MessageV1],
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        input: str | BaseMessage,
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> T:
         if isinstance(input, BaseMessage):
             return await self._acall_with_config(
@@ -250,40 +225,29 @@ class BaseOutputParser(
                 config,
                 run_type="parser",
             )
-        if isinstance(input, MessageV1Types):
-            return await self._acall_with_config(
-                lambda inner_input: self.aparse_result(inner_input),
-                input,
-                config,
-                run_type="parser",
-            )
         return await self._acall_with_config(
             lambda inner_input: self.aparse_result([Generation(text=inner_input)]),
-            cast("str", input),
+            input,
             config,
             run_type="parser",
         )
 
     @override
-    def parse_result(
-        self, result: Union[list[Generation], AIMessage], *, partial: bool = False
-    ) -> T:
-        """Parse a list of candidate model Generations into a specific format.
+    def parse_result(self, result: list[Generation], *, partial: bool = False) -> T:
+        """Parse a list of candidate model `Generation` objects into a specific format.
 
-        The return value is parsed from only the first Generation in the result, which
-            is assumed to be the highest-likelihood Generation.
+        The return value is parsed from only the first `Generation` in the result, which
+            is assumed to be the highest-likelihood `Generation`.
 
         Args:
-            result: A list of Generations to be parsed. The Generations are assumed
-                to be different candidate outputs for a single model input.
+            result: A list of `Generation` to be parsed. The `Generation` objects are
+                assumed to be different candidate outputs for a single model input.
             partial: Whether to parse the output as a partial result. This is useful
-                for parsers that can parse partial results. Default is False.
+                for parsers that can parse partial results.
 
         Returns:
             Structured output.
         """
-        if isinstance(result, AIMessage):
-            return self.parse(result.text)
         return self.parse(result[0].text)
 
     @abstractmethod
@@ -298,22 +262,22 @@ class BaseOutputParser(
         """
 
     async def aparse_result(
-        self, result: Union[list[Generation], AIMessage], *, partial: bool = False
+        self, result: list[Generation], *, partial: bool = False
     ) -> T:
-        """Async parse a list of candidate model Generations into a specific format.
+        """Async parse a list of candidate model `Generation` objects into a specific format.
 
-        The return value is parsed from only the first Generation in the result, which
-            is assumed to be the highest-likelihood Generation.
+        The return value is parsed from only the first `Generation` in the result, which
+            is assumed to be the highest-likelihood `Generation`.
 
         Args:
-            result: A list of Generations to be parsed. The Generations are assumed
-                to be different candidate outputs for a single model input.
+            result: A list of `Generation` to be parsed. The `Generation` objects are
+                assumed to be different candidate outputs for a single model input.
             partial: Whether to parse the output as a partial result. This is useful
-                for parsers that can parse partial results. Default is False.
+                for parsers that can parse partial results.
 
         Returns:
             Structured output.
-        """
+        """  # noqa: E501
         return await run_in_executor(None, self.parse_result, result, partial=partial)
 
     async def aparse(self, text: str) -> T:
@@ -335,13 +299,13 @@ class BaseOutputParser(
     ) -> Any:
         """Parse the output of an LLM call with the input prompt for context.
 
-        The prompt is largely provided in the event the OutputParser wants
+        The prompt is largely provided in the event the `OutputParser` wants
         to retry or fix the output in some way, and needs information from
         the prompt to do so.
 
         Args:
             completion: String output of a language model.
-            prompt: Input PromptValue.
+            prompt: Input `PromptValue`.
 
         Returns:
             Structured output.

langchain_core/output_parsers/json.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import json
 from json import JSONDecodeError
-from typing import Annotated, Any, Optional, TypeVar, Union
+from typing import Annotated, Any, TypeVar
 
 import jsonpatch  # type: ignore[import-untyped]
 import pydantic
@@ -21,10 +21,9 @@ from langchain_core.utils.json import (
     parse_json_markdown,
     parse_partial_json,
 )
-from langchain_core.v1.messages import AIMessage
 
 # Union type needs to be last assignment to PydanticBaseModel to make mypy happy.
-PydanticBaseModel = Union[BaseModel, pydantic.BaseModel]
+PydanticBaseModel = BaseModel | pydantic.BaseModel
 
 TBaseModel = TypeVar("TBaseModel", bound=PydanticBaseModel)
 
@@ -39,33 +38,30 @@ class JsonOutputParser(BaseCumulativeTransformOutputParser[Any]):
     describing the difference between the previous and the current object.
     """
 
-    pydantic_object: Annotated[Optional[type[TBaseModel]], SkipValidation()] = None  # type: ignore[valid-type]
+    pydantic_object: Annotated[type[TBaseModel] | None, SkipValidation()] = None  # type: ignore[valid-type]
     """The Pydantic object to use for validation.
-    If None, no validation is performed."""
+    If `None`, no validation is performed."""
 
     @override
-    def _diff(self, prev: Optional[Any], next: Any) -> Any:
+    def _diff(self, prev: Any | None, next: Any) -> Any:
         return jsonpatch.make_patch(prev, next).patch
 
-    def _get_schema(self, pydantic_object: type[TBaseModel]) -> dict[str, Any]:
+    @staticmethod
+    def _get_schema(pydantic_object: type[TBaseModel]) -> dict[str, Any]:
         if issubclass(pydantic_object, pydantic.BaseModel):
             return pydantic_object.model_json_schema()
-        if issubclass(pydantic_object, pydantic.v1.BaseModel):
-            return pydantic_object.schema()
-        return None
+        return pydantic_object.schema()
 
-    def parse_result(
-        self, result: Union[list[Generation], AIMessage], *, partial: bool = False
-    ) -> Any:
+    @override
+    def parse_result(self, result: list[Generation], *, partial: bool = False) -> Any:
         """Parse the result of an LLM call to a JSON object.
 
         Args:
             result: The result of the LLM call.
             partial: Whether to parse partial JSON objects.
-                If True, the output will be a JSON object containing
+                If `True`, the output will be a JSON object containing
                 all the keys that have been returned so far.
-                If False, the output will be the full JSON object.
-                Default is False.
+                If `False`, the output will be the full JSON object.
 
         Returns:
             The parsed JSON object.
@@ -73,7 +69,7 @@ class JsonOutputParser(BaseCumulativeTransformOutputParser[Any]):
         Raises:
             OutputParserException: If the output is not valid JSON.
         """
-        text = result.text if isinstance(result, AIMessage) else result[0].text
+        text = result[0].text
         text = text.strip()
         if partial:
             try:

langchain_core/output_parsers/list.py

@@ -7,13 +7,12 @@ import re
 from abc import abstractmethod
 from collections import deque
 from io import StringIO
-from typing import TYPE_CHECKING, TypeVar, Union
+from typing import TYPE_CHECKING, TypeVar
 
 from typing_extensions import override
 
 from langchain_core.messages import BaseMessage
 from langchain_core.output_parsers.transform import BaseTransformOutputParser
-from langchain_core.v1.messages import AIMessage
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Iterator
@@ -71,9 +70,7 @@ class ListOutputParser(BaseTransformOutputParser[list[str]]):
         raise NotImplementedError
 
     @override
-    def _transform(
-        self, input: Iterator[Union[str, BaseMessage, AIMessage]]
-    ) -> Iterator[list[str]]:
+    def _transform(self, input: Iterator[str | BaseMessage]) -> Iterator[list[str]]:
         buffer = ""
         for chunk in input:
             if isinstance(chunk, BaseMessage):
@@ -82,8 +79,6 @@ class ListOutputParser(BaseTransformOutputParser[list[str]]):
                 if not isinstance(chunk_content, str):
                     continue
                 buffer += chunk_content
-            elif isinstance(chunk, AIMessage):
-                buffer += chunk.text
             else:
                 # add current chunk to buffer
                 buffer += chunk
@@ -108,7 +103,7 @@ class ListOutputParser(BaseTransformOutputParser[list[str]]):
 
     @override
     async def _atransform(
-        self, input: AsyncIterator[Union[str, BaseMessage, AIMessage]]
+        self, input: AsyncIterator[str | BaseMessage]
     ) -> AsyncIterator[list[str]]:
         buffer = ""
         async for chunk in input:
@@ -118,8 +113,6 @@ class ListOutputParser(BaseTransformOutputParser[list[str]]):
                 if not isinstance(chunk_content, str):
                     continue
                 buffer += chunk_content
-            elif isinstance(chunk, AIMessage):
-                buffer += chunk.text
             else:
                 # add current chunk to buffer
                 buffer += chunk
@@ -148,22 +141,19 @@ class CommaSeparatedListOutputParser(ListOutputParser):
 
     @classmethod
     def is_lc_serializable(cls) -> bool:
-        """Check if the langchain object is serializable.
-
-        Returns True.
-        """
+        """Return True as this class is serializable."""
         return True
 
     @classmethod
     def get_lc_namespace(cls) -> list[str]:
-        """Get the namespace of the langchain object.
+        """Get the namespace of the LangChain object.
 
         Returns:
-            A list of strings.
-            Default is ["langchain", "output_parsers", "list"].
+            `["langchain", "output_parsers", "list"]`
         """
         return ["langchain", "output_parsers", "list"]
 
+    @override
     def get_format_instructions(self) -> str:
         """Return the format instructions for the comma-separated list output."""
         return (
@@ -171,6 +161,7 @@ class CommaSeparatedListOutputParser(ListOutputParser):
             "eg: `foo, bar, baz` or `foo,bar,baz`"
         )
 
+    @override
     def parse(self, text: str) -> list[str]:
         """Parse the output of an LLM call.
 
@@ -218,15 +209,8 @@ class NumberedListOutputParser(ListOutputParser):
         """
         return re.findall(self.pattern, text)
 
+    @override
     def parse_iter(self, text: str) -> Iterator[re.Match]:
-        """Parse the output of an LLM call.
-
-        Args:
-            text: The output of an LLM call.
-
-        Yields:
-            A match object for each part of the output.
-        """
         return re.finditer(self.pattern, text)
 
     @property
@@ -240,6 +224,7 @@ class MarkdownListOutputParser(ListOutputParser):
     pattern: str = r"^\s*[-*]\s([^\n]+)$"
     """The pattern to match a Markdown list item."""
 
+    @override
     def get_format_instructions(self) -> str:
         """Return the format instructions for the Markdown list output."""
         return "Your response should be a markdown list, eg: `- foo\n- bar\n- baz`"
@@ -255,15 +240,8 @@ class MarkdownListOutputParser(ListOutputParser):
         """
         return re.findall(self.pattern, text, re.MULTILINE)
 
+    @override
     def parse_iter(self, text: str) -> Iterator[re.Match]:
-        """Parse the output of an LLM call.
-
-        Args:
-            text: The output of an LLM call.
-
-        Yields:
-            A match object for each part of the output.
-        """
         return re.finditer(self.pattern, text, re.MULTILINE)
 
     @property