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

langchain_core/output_parsers/transform.py

@@ -5,8 +5,6 @@ from __future__ import annotations
 from typing import (
     TYPE_CHECKING,
     Any,
-    Optional,
-    Union,
 )
 
 from typing_extensions import override
@@ -20,7 +18,6 @@ from langchain_core.outputs import (
     GenerationChunk,
 )
 from langchain_core.runnables.config import run_in_executor
-from langchain_core.v1.messages import AIMessage, AIMessageChunk
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Iterator
@@ -33,27 +30,23 @@ class BaseTransformOutputParser(BaseOutputParser[T]):
 
     def _transform(
         self,
-        input: Iterator[Union[str, BaseMessage, AIMessage]],
+        input: Iterator[str | BaseMessage],
     ) -> Iterator[T]:
         for chunk in input:
             if isinstance(chunk, BaseMessage):
                 yield self.parse_result([ChatGeneration(message=chunk)])
-            elif isinstance(chunk, AIMessage):
-                yield self.parse_result(chunk)
             else:
                 yield self.parse_result([Generation(text=chunk)])
 
     async def _atransform(
         self,
-        input: AsyncIterator[Union[str, BaseMessage, AIMessage]],
+        input: AsyncIterator[str | BaseMessage],
     ) -> AsyncIterator[T]:
         async for chunk in input:
             if isinstance(chunk, BaseMessage):
                 yield await run_in_executor(
                     None, self.parse_result, [ChatGeneration(message=chunk)]
                 )
-            elif isinstance(chunk, AIMessage):
-                yield await run_in_executor(None, self.parse_result, chunk)
             else:
                 yield await run_in_executor(
                     None, self.parse_result, [Generation(text=chunk)]
@@ -62,8 +55,8 @@ class BaseTransformOutputParser(BaseOutputParser[T]):
     @override
     def transform(
         self,
-        input: Iterator[Union[str, BaseMessage, AIMessage]],
-        config: Optional[RunnableConfig] = None,
+        input: Iterator[str | BaseMessage],
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> Iterator[T]:
         """Transform the input into the output format.
@@ -71,7 +64,7 @@ class BaseTransformOutputParser(BaseOutputParser[T]):
         Args:
             input: The input to transform.
             config: The configuration to use for the transformation.
-            kwargs: Additional keyword arguments.
+            **kwargs: Additional keyword arguments.
 
         Yields:
             The transformed output.
@@ -83,8 +76,8 @@ class BaseTransformOutputParser(BaseOutputParser[T]):
     @override
     async def atransform(
         self,
-        input: AsyncIterator[Union[str, BaseMessage, AIMessage]],
-        config: Optional[RunnableConfig] = None,
+        input: AsyncIterator[str | BaseMessage],
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[T]:
         """Async transform the input into the output format.
@@ -92,7 +85,7 @@ class BaseTransformOutputParser(BaseOutputParser[T]):
         Args:
             input: The input to transform.
             config: The configuration to use for the transformation.
-            kwargs: Additional keyword arguments.
+            **kwargs: Additional keyword arguments.
 
         Yields:
             The transformed output.
@@ -113,7 +106,7 @@ class BaseCumulativeTransformOutputParser(BaseTransformOutputParser[T]):
 
     def _diff(
         self,
-        prev: Optional[T],
+        prev: T | None,
         next: T,  # noqa: A002
     ) -> T:
         """Convert parsed outputs into a diff format.
@@ -130,42 +123,23 @@ class BaseCumulativeTransformOutputParser(BaseTransformOutputParser[T]):
         raise NotImplementedError
 
     @override
-    def _transform(
-        self, input: Iterator[Union[str, BaseMessage, AIMessage]]
-    ) -> Iterator[Any]:
+    def _transform(self, input: Iterator[str | BaseMessage]) -> Iterator[Any]:
         prev_parsed = None
-        acc_gen: Union[GenerationChunk, ChatGenerationChunk, AIMessageChunk, None] = (
-            None
-        )
+        acc_gen: GenerationChunk | ChatGenerationChunk | None = None
         for chunk in input:
-            chunk_gen: Union[GenerationChunk, ChatGenerationChunk, AIMessageChunk]
+            chunk_gen: GenerationChunk | ChatGenerationChunk
             if isinstance(chunk, BaseMessageChunk):
                 chunk_gen = ChatGenerationChunk(message=chunk)
             elif isinstance(chunk, BaseMessage):
                 chunk_gen = ChatGenerationChunk(
                     message=BaseMessageChunk(**chunk.model_dump())
                 )
-            elif isinstance(chunk, AIMessageChunk):
-                chunk_gen = chunk
-            elif isinstance(chunk, AIMessage):
-                chunk_gen = AIMessageChunk(
-                    content=chunk.content,
-                    id=chunk.id,
-                    name=chunk.name,
-                    lc_version=chunk.lc_version,
-                    response_metadata=chunk.response_metadata,
-                    usage_metadata=chunk.usage_metadata,
-                    parsed=chunk.parsed,
-                )
             else:
                 chunk_gen = GenerationChunk(text=chunk)
 
             acc_gen = chunk_gen if acc_gen is None else acc_gen + chunk_gen  # type: ignore[operator]
 
-            if isinstance(acc_gen, AIMessageChunk):
-                parsed = self.parse_result(acc_gen, partial=True)
-            else:
-                parsed = self.parse_result([acc_gen], partial=True)
+            parsed = self.parse_result([acc_gen], partial=True)
             if parsed is not None and parsed != prev_parsed:
                 if self.diff:
                     yield self._diff(prev_parsed, parsed)
@@ -175,41 +149,24 @@ class BaseCumulativeTransformOutputParser(BaseTransformOutputParser[T]):
 
     @override
     async def _atransform(
-        self, input: AsyncIterator[Union[str, BaseMessage, AIMessage]]
+        self, input: AsyncIterator[str | BaseMessage]
     ) -> AsyncIterator[T]:
         prev_parsed = None
-        acc_gen: Union[GenerationChunk, ChatGenerationChunk, AIMessageChunk, None] = (
-            None
-        )
+        acc_gen: GenerationChunk | ChatGenerationChunk | None = None
         async for chunk in input:
-            chunk_gen: Union[GenerationChunk, ChatGenerationChunk, AIMessageChunk]
+            chunk_gen: GenerationChunk | ChatGenerationChunk
             if isinstance(chunk, BaseMessageChunk):
                 chunk_gen = ChatGenerationChunk(message=chunk)
             elif isinstance(chunk, BaseMessage):
                 chunk_gen = ChatGenerationChunk(
                     message=BaseMessageChunk(**chunk.model_dump())
                 )
-            elif isinstance(chunk, AIMessageChunk):
-                chunk_gen = chunk
-            elif isinstance(chunk, AIMessage):
-                chunk_gen = AIMessageChunk(
-                    content=chunk.content,
-                    id=chunk.id,
-                    name=chunk.name,
-                    lc_version=chunk.lc_version,
-                    response_metadata=chunk.response_metadata,
-                    usage_metadata=chunk.usage_metadata,
-                    parsed=chunk.parsed,
-                )
             else:
                 chunk_gen = GenerationChunk(text=chunk)
 
             acc_gen = chunk_gen if acc_gen is None else acc_gen + chunk_gen  # type: ignore[operator]
 
-            if isinstance(acc_gen, AIMessageChunk):
-                parsed = await self.aparse_result(acc_gen, partial=True)
-            else:
-                parsed = await self.aparse_result([acc_gen], partial=True)
+            parsed = await self.aparse_result([acc_gen], partial=True)
             if parsed is not None and parsed != prev_parsed:
                 if self.diff:
                     yield await run_in_executor(None, self._diff, prev_parsed, parsed)

langchain_core/output_parsers/xml.py

@@ -5,17 +5,23 @@ import re
 import xml
 import xml.etree.ElementTree as ET
 from collections.abc import AsyncIterator, Iterator
-from typing import Any, Literal, Optional, Union
+from typing import Any, Literal
 from xml.etree.ElementTree import TreeBuilder
 
 from typing_extensions import override
 
 from langchain_core.exceptions import OutputParserException
 from langchain_core.messages import BaseMessage
-from langchain_core.messages.utils import convert_from_v1_message
 from langchain_core.output_parsers.transform import BaseTransformOutputParser
 from langchain_core.runnables.utils import AddableDict
-from langchain_core.v1.messages import AIMessage
+
+try:
+    from defusedxml import ElementTree  # type: ignore[import-untyped]
+    from defusedxml.ElementTree import XMLParser  # type: ignore[import-untyped]
+
+    _HAS_DEFUSEDXML = True
+except ImportError:
+    _HAS_DEFUSEDXML = False
 
 XML_FORMAT_INSTRUCTIONS = """The output should be formatted as a XML file.
 1. Output should conform to the tags below.
@@ -52,17 +58,13 @@ class _StreamingParser:
                 parser is requested.
         """
         if parser == "defusedxml":
-            try:
-                from defusedxml.ElementTree import (  # type: ignore[import-untyped]
-                    XMLParser,
-                )
-            except ImportError as e:
+            if not _HAS_DEFUSEDXML:
                 msg = (
                     "defusedxml is not installed. "
                     "Please install it to use the defusedxml parser."
                     "You can install it with `pip install defusedxml` "
                 )
-                raise ImportError(msg) from e
+                raise ImportError(msg)
             parser_ = XMLParser(target=TreeBuilder())
         else:
             parser_ = None
@@ -73,14 +75,14 @@ class _StreamingParser:
         self.buffer = ""
         self.xml_started = False
 
-    def parse(self, chunk: Union[str, BaseMessage]) -> Iterator[AddableDict]:
+    def parse(self, chunk: str | BaseMessage) -> Iterator[AddableDict]:
         """Parse a chunk of text.
 
         Args:
             chunk: A chunk of text to parse. This can be a string or a BaseMessage.
 
         Yields:
-            AddableDict: A dictionary representing the parsed XML element.
+            A dictionary representing the parsed XML element.
 
         Raises:
             xml.etree.ElementTree.ParseError: If the XML is not well-formed.
@@ -107,10 +109,11 @@ class _StreamingParser:
         self.buffer = ""
         # yield all events
         try:
-            for event, elem in self.pull_parser.read_events():
+            events = self.pull_parser.read_events()
+            for event, elem in events:  # type: ignore[misc]
                 if event == "start":
                     # update current path
-                    self.current_path.append(elem.tag)
+                    self.current_path.append(elem.tag)  # type: ignore[union-attr]
                     self.current_path_has_children = False
                 elif event == "end":
                     # remove last element from current path
@@ -118,7 +121,7 @@ class _StreamingParser:
                     self.current_path.pop()
                     # yield element
                     if not self.current_path_has_children:
-                        yield nested_element(self.current_path, elem)
+                        yield nested_element(self.current_path, elem)  # type: ignore[arg-type]
                     # prevent yielding of parent element
                     if self.current_path:
                         self.current_path_has_children = True
@@ -137,9 +140,6 @@ class _StreamingParser:
         """Close the parser.
 
         This should be called after all chunks have been parsed.
-
-        Raises:
-            xml.etree.ElementTree.ParseError: If the XML is not well-formed.
         """
         # Ignore ParseError. This will ignore any incomplete XML at the end of the input
         with contextlib.suppress(xml.etree.ElementTree.ParseError):
@@ -149,20 +149,21 @@ class _StreamingParser:
 class XMLOutputParser(BaseTransformOutputParser):
     """Parse an output using xml format."""
 
-    tags: Optional[list[str]] = None
+    tags: list[str] | None = None
     """Tags to tell the LLM to expect in the XML output.
 
     Note this may not be perfect depending on the LLM implementation.
 
     For example, with tags=["foo", "bar", "baz"]:
-            1. A well-formatted XML instance:
-                "<foo>\n   <bar>\n      <baz></baz>\n   </bar>\n</foo>"
 
-            2. A badly-formatted XML instance (missing closing tag for 'bar'):
-                "<foo>\n   <bar>\n   </foo>"
+    1. A well-formatted XML instance:
+       "<foo>\n   <bar>\n      <baz></baz>\n   </bar>\n</foo>"
+
+    2. A badly-formatted XML instance (missing closing tag for 'bar'):
+       "<foo>\n   <bar>\n   </foo>"
 
-            3. A badly-formatted XML instance (unexpected 'tag' element):
-                "<foo>\n   <tag>\n   </tag>\n</foo>"
+    3. A badly-formatted XML instance (unexpected 'tag' element):
+       "<foo>\n   <tag>\n   </tag>\n</foo>"
     """
     encoding_matcher: re.Pattern = re.compile(
         r"<([^>]*encoding[^>]*)>\n(.*)", re.MULTILINE | re.DOTALL
@@ -192,7 +193,7 @@ class XMLOutputParser(BaseTransformOutputParser):
         """Return the format instructions for the XML output."""
         return XML_FORMAT_INSTRUCTIONS.format(tags=self.tags)
 
-    def parse(self, text: str) -> dict[str, Union[str, list[Any]]]:
+    def parse(self, text: str) -> dict[str, str | list[Any]]:
         """Parse the output of an LLM call.
 
         Args:
@@ -210,16 +211,14 @@ class XMLOutputParser(BaseTransformOutputParser):
         # Imports are temporarily placed here to avoid issue with caching on CI
         # likely if you're reading this you can move them to the top of the file
         if self.parser == "defusedxml":
-            try:
-                from defusedxml import ElementTree  # type: ignore[import-untyped]
-            except ImportError as e:
+            if not _HAS_DEFUSEDXML:
                 msg = (
                     "defusedxml is not installed. "
                     "Please install it to use the defusedxml parser."
                     "You can install it with `pip install defusedxml`"
                     "See https://github.com/tiran/defusedxml for more details"
                 )
-                raise ImportError(msg) from e
+                raise ImportError(msg)
             et = ElementTree  # Use the defusedxml parser
         else:
             et = ET  # Use the standard library parser
@@ -241,32 +240,23 @@ class XMLOutputParser(BaseTransformOutputParser):
             raise OutputParserException(msg, llm_output=text) from e
 
     @override
-    def _transform(
-        self, input: Iterator[Union[str, BaseMessage, AIMessage]]
-    ) -> Iterator[AddableDict]:
+    def _transform(self, input: Iterator[str | BaseMessage]) -> Iterator[AddableDict]:
         streaming_parser = _StreamingParser(self.parser)
         for chunk in input:
-            if isinstance(chunk, AIMessage):
-                yield from streaming_parser.parse(convert_from_v1_message(chunk))
-            else:
-                yield from streaming_parser.parse(chunk)
+            yield from streaming_parser.parse(chunk)
         streaming_parser.close()
 
     @override
     async def _atransform(
-        self, input: AsyncIterator[Union[str, BaseMessage, AIMessage]]
+        self, input: AsyncIterator[str | BaseMessage]
     ) -> AsyncIterator[AddableDict]:
         streaming_parser = _StreamingParser(self.parser)
         async for chunk in input:
-            if isinstance(chunk, AIMessage):
-                for output in streaming_parser.parse(convert_from_v1_message(chunk)):
-                    yield output
-            else:
-                for output in streaming_parser.parse(chunk):
-                    yield output
+            for output in streaming_parser.parse(chunk):
+                yield output
         streaming_parser.close()
 
-    def _root_to_dict(self, root: ET.Element) -> dict[str, Union[str, list[Any]]]:
+    def _root_to_dict(self, root: ET.Element) -> dict[str, str | list[Any]]:
         """Converts xml tree to python dictionary."""
         if root.text and bool(re.search(r"\S", root.text)):
             # If root text contains any non-whitespace character it

langchain_core/outputs/__init__.py

@@ -12,7 +12,7 @@ When invoking models via the standard runnable methods (e.g. invoke, batch, etc.
 - LLMs will return regular text strings.
 
 In addition, users can access the raw output of either LLMs or chat models via
-callbacks. The ``on_chat_model_end`` and ``on_llm_end`` callbacks will return an
+callbacks. The `on_chat_model_end` and `on_llm_end` callbacks will return an
 LLMResult object containing the generated outputs and any additional information
 returned by the model provider.
 

langchain_core/outputs/chat_generation.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Literal, Union
+from typing import Literal
 
 from pydantic import model_validator
 from typing_extensions import Self
@@ -15,7 +15,7 @@ from langchain_core.utils._merge import merge_dicts
 class ChatGeneration(Generation):
     """A single chat generation output.
 
-    A subclass of Generation that represents the response from a chat model
+    A subclass of `Generation` that represents the response from a chat model
     that generates chat messages.
 
     The `message` attribute is a structured representation of the chat message.
@@ -29,8 +29,9 @@ class ChatGeneration(Generation):
     text: str = ""
     """The text contents of the output message.
 
-    .. warning::
+    !!! warning
         SHOULD NOT BE SET DIRECTLY!
+
     """
     message: BaseMessage
     """The message output by the chat model."""
@@ -69,9 +70,9 @@ class ChatGeneration(Generation):
 
 
 class ChatGenerationChunk(ChatGeneration):
-    """ChatGeneration chunk.
+    """`ChatGeneration` chunk.
 
-    ChatGeneration chunks can be concatenated with other ChatGeneration chunks.
+    `ChatGeneration` chunks can be concatenated with other `ChatGeneration` chunks.
     """
 
     message: BaseMessageChunk
@@ -81,13 +82,20 @@ class ChatGenerationChunk(ChatGeneration):
     """Type is used exclusively for serialization purposes."""
 
     def __add__(
-        self, other: Union[ChatGenerationChunk, list[ChatGenerationChunk]]
+        self, other: ChatGenerationChunk | list[ChatGenerationChunk]
     ) -> ChatGenerationChunk:
-        """Concatenate two ChatGenerationChunks.
+        """Concatenate two `ChatGenerationChunk`s.
 
         Args:
-            other: The other ChatGenerationChunk or list of ChatGenerationChunks to
-                concatenate.
+            other: The other `ChatGenerationChunk` or list of `ChatGenerationChunk`
+                to concatenate.
+
+        Raises:
+            TypeError: If other is not a `ChatGenerationChunk` or list of
+                `ChatGenerationChunk`.
+
+        Returns:
+            A new `ChatGenerationChunk` concatenated from self and other.
         """
         if isinstance(other, ChatGenerationChunk):
             generation_info = merge_dicts(
@@ -115,8 +123,15 @@ class ChatGenerationChunk(ChatGeneration):
 
 def merge_chat_generation_chunks(
     chunks: list[ChatGenerationChunk],
-) -> Union[ChatGenerationChunk, None]:
-    """Merge a list of ChatGenerationChunks into a single ChatGenerationChunk."""
+) -> ChatGenerationChunk | None:
+    """Merge a list of `ChatGenerationChunk`s into a single `ChatGenerationChunk`.
+
+    Args:
+        chunks: A list of `ChatGenerationChunk` to merge.
+
+    Returns:
+        A merged `ChatGenerationChunk`, or None if the input list is empty.
+    """
     if not chunks:
         return None
 

langchain_core/outputs/chat_result.py

@@ -1,7 +1,5 @@
 """Chat result schema."""
 
-from typing import Optional
-
 from pydantic import BaseModel
 
 from langchain_core.outputs.chat_generation import ChatGeneration
@@ -26,7 +24,7 @@ class ChatResult(BaseModel):
     Generations is a list to allow for multiple candidate generations for a single
     input prompt.
     """
-    llm_output: Optional[dict] = None
+    llm_output: dict | None = None
     """For arbitrary LLM provider specific output.
 
     This dictionary is a free-form dictionary that can contain any information that the

langchain_core/outputs/generation.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Literal, Optional
+from typing import Any, Literal
 
 from langchain_core.load import Serializable
 from langchain_core.utils._merge import merge_dicts
@@ -28,7 +28,7 @@ class Generation(Serializable):
     text: str
     """Generated text output."""
 
-    generation_info: Optional[dict[str, Any]] = None
+    generation_info: dict[str, Any] | None = None
     """Raw response from the provider.
 
     May include things like the reason for finishing or token log probabilities.
@@ -39,14 +39,15 @@ class Generation(Serializable):
 
     @classmethod
     def is_lc_serializable(cls) -> bool:
-        """Return whether this class is serializable."""
+        """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.
 
-        Default namespace is ["langchain", "schema", "output"].
+        Returns:
+            `["langchain", "schema", "output"]`
         """
         return ["langchain", "schema", "output"]
 
@@ -55,7 +56,17 @@ class GenerationChunk(Generation):
     """Generation chunk, which can be concatenated with other Generation chunks."""
 
     def __add__(self, other: GenerationChunk) -> GenerationChunk:
-        """Concatenate two GenerationChunks."""
+        """Concatenate two `GenerationChunk`s.
+
+        Args:
+            other: Another `GenerationChunk` to concatenate with.
+
+        Raises:
+            TypeError: If other is not a `GenerationChunk`.
+
+        Returns:
+            A new `GenerationChunk` concatenated from self and other.
+        """
         if isinstance(other, GenerationChunk):
             generation_info = merge_dicts(
                 self.generation_info or {},

langchain_core/outputs/llm_result.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from copy import deepcopy
-from typing import Literal, Optional, Union
+from typing import Literal
 
 from pydantic import BaseModel
 
@@ -21,7 +21,7 @@ class LLMResult(BaseModel):
     """
 
     generations: list[
-        list[Union[Generation, ChatGeneration, GenerationChunk, ChatGenerationChunk]]
+        list[Generation | ChatGeneration | GenerationChunk | ChatGenerationChunk]
     ]
     """Generated outputs.
 
@@ -30,13 +30,13 @@ class LLMResult(BaseModel):
     The second dimension of the list represents different candidate generations for a
     given prompt.
 
-    - When returned from **an LLM**, the type is ``list[list[Generation]]``.
-    - When returned from a **chat model**, the type is ``list[list[ChatGeneration]]``.
+    - When returned from **an LLM**, the type is `list[list[Generation]]`.
+    - When returned from a **chat model**, the type is `list[list[ChatGeneration]]`.
 
     ChatGeneration is a subclass of Generation that has a field for a structured chat
     message.
     """
-    llm_output: Optional[dict] = None
+    llm_output: dict | None = None
     """For arbitrary LLM provider specific output.
 
     This dictionary is a free-form dictionary that can contain any information that the
@@ -45,10 +45,10 @@ class LLMResult(BaseModel):
     Users should generally avoid relying on this field and instead rely on accessing
     relevant information from standardized fields present in AIMessage.
     """
-    run: Optional[list[RunInfo]] = None
+    run: list[RunInfo] | None = None
     """List of metadata info for model call for each input.
 
-    See :class:`~langchain_core.outputs.run_info.RunInfo` for details.
+    See `langchain_core.outputs.run_info.RunInfo` for details.
     """
 
     type: Literal["LLMResult"] = "LLMResult"
@@ -91,7 +91,14 @@ class LLMResult(BaseModel):
         return llm_results
 
     def __eq__(self, other: object) -> bool:
-        """Check for LLMResult equality by ignoring any metadata related to runs."""
+        """Check for `LLMResult` equality by ignoring any metadata related to runs.
+
+        Args:
+            other: Another `LLMResult` object to compare against.
+
+        Returns:
+            `True` if the generations and `llm_output` are equal, `False` otherwise.
+        """
         if not isinstance(other, LLMResult):
             return NotImplemented
         return (