langchain-core 1.0.0a6__py3-none-any.whl → 1.0.4__py3-none-any.whl

langchain_core/output_parsers/xml.py

@@ -5,7 +5,7 @@ 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
@@ -43,19 +43,19 @@ class _StreamingParser:
     """Streaming parser for XML.
 
     This implementation is pulled into a class to avoid implementation
-    drift between transform and atransform of the XMLOutputParser.
+    drift between transform and atransform of the `XMLOutputParser`.
     """
 
     def __init__(self, parser: Literal["defusedxml", "xml"]) -> None:
         """Initialize the streaming parser.
 
         Args:
-            parser: Parser to use for XML parsing. Can be either 'defusedxml' or 'xml'.
-              See documentation in XMLOutputParser for more information.
+            parser: Parser to use for XML parsing. Can be either `'defusedxml'` or
+                `'xml'`. See documentation in `XMLOutputParser` for more information.
 
         Raises:
-            ImportError: If defusedxml is not installed and the defusedxml
-                parser is requested.
+            ImportError: If `defusedxml` is not installed and the `defusedxml` parser is
+                requested.
         """
         if parser == "defusedxml":
             if not _HAS_DEFUSEDXML:
@@ -75,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.
+            chunk: A chunk of text to parse. This can be a `str` or a `BaseMessage`.
 
         Yields:
-            AddableDict: A dictionary representing the parsed XML element.
+            A `dict` representing the parsed XML element.
 
         Raises:
             xml.etree.ElementTree.ParseError: If the XML is not well-formed.
@@ -147,65 +147,68 @@ class _StreamingParser:
 
 
 class XMLOutputParser(BaseTransformOutputParser):
-    """Parse an output using xml format."""
+    """Parse an output using xml format.
 
-    tags: Optional[list[str]] = None
+    Returns a dictionary of tags.
+    """
+
+    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"]:
+    For example, with `tags=["foo", "bar", "baz"]`:
 
     1. A well-formatted XML instance:
-       "<foo>\n   <bar>\n      <baz></baz>\n   </bar>\n</foo>"
+        `"<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>"
+        `"<foo>\n   <bar>\n   </foo>"`
 
     3. A badly-formatted XML instance (unexpected 'tag' element):
-       "<foo>\n   <tag>\n   </tag>\n</foo>"
+        `"<foo>\n   <tag>\n   </tag>\n</foo>"`
     """
     encoding_matcher: re.Pattern = re.compile(
         r"<([^>]*encoding[^>]*)>\n(.*)", re.MULTILINE | re.DOTALL
     )
     parser: Literal["defusedxml", "xml"] = "defusedxml"
-    """Parser to use for XML parsing. Can be either 'defusedxml' or 'xml'.
+    """Parser to use for XML parsing. Can be either `'defusedxml'` or `'xml'`.
 
-    * 'defusedxml' is the default parser and is used to prevent XML vulnerabilities
-       present in some distributions of Python's standard library xml.
-       `defusedxml` is a wrapper around the standard library parser that
-       sets up the parser with secure defaults.
-    * 'xml' is the standard library parser.
+    * `'defusedxml'` is the default parser and is used to prevent XML vulnerabilities
+        present in some distributions of Python's standard library xml.
+        `defusedxml` is a wrapper around the standard library parser that
+        sets up the parser with secure defaults.
+    * `'xml'` is the standard library parser.
 
-    Use `xml` only if you are sure that your distribution of the standard library
-    is not vulnerable to XML vulnerabilities.
+    Use `xml` only if you are sure that your distribution of the standard library is not
+    vulnerable to XML vulnerabilities.
 
     Please review the following resources for more information:
 
     * https://docs.python.org/3/library/xml.html#xml-vulnerabilities
     * https://github.com/tiran/defusedxml
 
-    The standard library relies on libexpat for parsing XML:
-    https://github.com/libexpat/libexpat
+    The standard library relies on [`libexpat`](https://github.com/libexpat/libexpat)
+    for parsing XML.
     """
 
     def get_format_instructions(self) -> str:
         """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:
             text: The output of an LLM call.
 
         Returns:
-            A dictionary representing the parsed XML.
+            A `dict` representing the parsed XML.
 
         Raises:
             OutputParserException: If the XML is not well-formed.
-            ImportError: If defusedxml is not installed and the defusedxml
-                parser is requested.
+            ImportError: If defus`edxml is not installed and the `defusedxml` parser is
+                requested.
         """
         # Try to find XML string within triple backticks
         # Imports are temporarily placed here to avoid issue with caching on CI
@@ -240,9 +243,7 @@ class XMLOutputParser(BaseTransformOutputParser):
             raise OutputParserException(msg, llm_output=text) from e
 
     @override
-    def _transform(
-        self, input: Iterator[Union[str, BaseMessage]]
-    ) -> Iterator[AddableDict]:
+    def _transform(self, input: Iterator[str | BaseMessage]) -> Iterator[AddableDict]:
         streaming_parser = _StreamingParser(self.parser)
         for chunk in input:
             yield from streaming_parser.parse(chunk)
@@ -250,7 +251,7 @@ class XMLOutputParser(BaseTransformOutputParser):
 
     @override
     async def _atransform(
-        self, input: AsyncIterator[Union[str, BaseMessage]]
+        self, input: AsyncIterator[str | BaseMessage]
     ) -> AsyncIterator[AddableDict]:
         streaming_parser = _StreamingParser(self.parser)
         async for chunk in input:
@@ -258,7 +259,7 @@ class XMLOutputParser(BaseTransformOutputParser):
                 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,21 +15,21 @@ 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.
-    Most of the time, the message will be of type ``AIMessage``.
+    The `message` attribute is a structured representation of the chat message.
+    Most of the time, the message will be of type `AIMessage`.
 
     Users working with chat models will usually access information via either
-    ``AIMessage`` (returned from runnable interfaces) or ``LLMResult`` (available
+    `AIMessage` (returned from runnable interfaces) or `LLMResult` (available
     via callbacks).
     """
 
     text: str = ""
     """The text contents of the output message.
 
-    .. warning::
+    !!! warning
         SHOULD NOT BE SET DIRECTLY!
 
     """
@@ -70,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
@@ -82,20 +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 ``ChatGenerationChunk``s.
+        """Concatenate two `ChatGenerationChunk`s.
 
         Args:
-            other: The other ``ChatGenerationChunk`` or list of ``ChatGenerationChunk``
+            other: The other `ChatGenerationChunk` or list of `ChatGenerationChunk`
                 to concatenate.
 
         Raises:
-            TypeError: If other is not a ``ChatGenerationChunk`` or list of
-                ``ChatGenerationChunk``.
+            TypeError: If other is not a `ChatGenerationChunk` or list of
+                `ChatGenerationChunk`.
 
         Returns:
-            A new ``ChatGenerationChunk`` concatenated from self and other.
+            A new `ChatGenerationChunk` concatenated from self and other.
         """
         if isinstance(other, ChatGenerationChunk):
             generation_info = merge_dicts(
@@ -123,14 +123,14 @@ class ChatGenerationChunk(ChatGeneration):
 
 def merge_chat_generation_chunks(
     chunks: list[ChatGenerationChunk],
-) -> Union[ChatGenerationChunk, None]:
-    """Merge a list of ``ChatGenerationChunk``s into a single ``ChatGenerationChunk``.
+) -> ChatGenerationChunk | None:
+    """Merge a list of `ChatGenerationChunk`s into a single `ChatGenerationChunk`.
 
     Args:
-        chunks: A list of ``ChatGenerationChunk`` to merge.
+        chunks: A list of `ChatGenerationChunk` to merge.
 
     Returns:
-        A merged ``ChatGenerationChunk``, or None if the input list is empty.
+        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
@@ -11,9 +11,8 @@ from langchain_core.utils._merge import merge_dicts
 class Generation(Serializable):
     """A single text generation output.
 
-    Generation represents the response from an
-    `"old-fashioned" LLM <https://python.langchain.com/docs/concepts/text_llms/>__` that
-    generates regular text (not chat messages).
+    Generation represents the response from an "old-fashioned" LLM (string-in,
+    string-out) that generates regular text (not chat messages).
 
     This model is used internally by chat model and will eventually
     be mapped to a more general `LLMResult` object, and then projected into
@@ -21,51 +20,52 @@ class Generation(Serializable):
 
     LangChain users working with chat models will usually access information via
     `AIMessage` (returned from runnable interfaces) or `LLMResult` (available
-    via callbacks). Please refer the `AIMessage` and `LLMResult` schema documentation
-    for more information.
+    via callbacks). Please refer to `AIMessage` and `LLMResult` for more information.
     """
 
     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.
     """
     type: Literal["Generation"] = "Generation"
     """Type is used exclusively for serialization purposes.
-    Set to "Generation" for this class."""
+
+    Set to "Generation" for this class.
+    """
 
     @classmethod
     def is_lc_serializable(cls) -> bool:
-        """Return True as 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.
 
         Returns:
-            ``["langchain", "schema", "output"]``
+            `["langchain", "schema", "output"]`
         """
         return ["langchain", "schema", "output"]
 
 
 class GenerationChunk(Generation):
-    """Generation chunk, which can be concatenated with other Generation chunks."""
+    """`GenerationChunk`, which can be concatenated with other Generation chunks."""
 
     def __add__(self, other: GenerationChunk) -> GenerationChunk:
-        """Concatenate two ``GenerationChunk``s.
+        """Concatenate two `GenerationChunk`s.
 
         Args:
-            other: Another ``GenerationChunk`` to concatenate with.
+            other: Another `GenerationChunk` to concatenate with.
 
         Raises:
-            TypeError: If other is not a ``GenerationChunk``.
+            TypeError: If other is not a `GenerationChunk`.
 
         Returns:
-            A new ``GenerationChunk`` concatenated from self and other.
+            A new `GenerationChunk` concatenated from self and other.
         """
         if isinstance(other, GenerationChunk):
             generation_info = merge_dicts(

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,13 +91,13 @@ 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.
+            other: Another `LLMResult` object to compare against.
 
         Returns:
-            True if the generations and ``llm_output`` are equal, False otherwise.
+            `True` if the generations and `llm_output` are equal, `False` otherwise.
         """
         if not isinstance(other, LLMResult):
             return NotImplemented

langchain_core/prompt_values.py

@@ -24,23 +24,21 @@ from langchain_core.messages import (
 class PromptValue(Serializable, ABC):
     """Base abstract class for inputs to any language model.
 
-    PromptValues can be converted to both LLM (pure text-generation) inputs and
-    ChatModel inputs.
+    `PromptValues` can be converted to both LLM (pure text-generation) inputs and
+    chat model inputs.
     """
 
     @classmethod
     def is_lc_serializable(cls) -> bool:
-        """Return True as 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.
-
-        This is used to determine the namespace of the object when serializing.
+        """Get the namespace of the LangChain object.
 
         Returns:
-            ``["langchain", "schema", "prompt"]``
+            `["langchain", "schema", "prompt"]`
         """
         return ["langchain", "schema", "prompt"]
 
@@ -50,7 +48,7 @@ class PromptValue(Serializable, ABC):
 
     @abstractmethod
     def to_messages(self) -> list[BaseMessage]:
-        """Return prompt as a list of Messages."""
+        """Return prompt as a list of messages."""
 
 
 class StringPromptValue(PromptValue):
@@ -62,12 +60,10 @@ class StringPromptValue(PromptValue):
 
     @classmethod
     def get_lc_namespace(cls) -> list[str]:
-        """Get the namespace of the langchain object.
-
-        This is used to determine the namespace of the object when serializing.
+        """Get the namespace of the LangChain object.
 
         Returns:
-            ``["langchain", "prompts", "base"]``
+            `["langchain", "prompts", "base"]`
         """
         return ["langchain", "prompts", "base"]
 
@@ -99,12 +95,10 @@ class ChatPromptValue(PromptValue):
 
     @classmethod
     def get_lc_namespace(cls) -> list[str]:
-        """Get the namespace of the langchain object.
-
-        This is used to determine the namespace of the object when serializing.
+        """Get the namespace of the LangChain object.
 
         Returns:
-            ``["langchain", "prompts", "chat"]``
+            `["langchain", "prompts", "chat"]`
         """
         return ["langchain", "prompts", "chat"]
 
@@ -113,11 +107,11 @@ class ImageURL(TypedDict, total=False):
     """Image URL."""
 
     detail: Literal["auto", "low", "high"]
-    """Specifies the detail level of the image. Defaults to ``'auto'``.
-    Can be ``'auto'``, ``'low'``, or ``'high'``.
+    """Specifies the detail level of the image.
 
-    This follows OpenAI's Chat Completion API's image URL format.
+    Can be `'auto'`, `'low'`, or `'high'`.
 
+    This follows OpenAI's Chat Completion API's image URL format.
     """
 
     url: str

langchain_core/prompts/__init__.py

@@ -1,29 +1,8 @@
 """**Prompt** is the input to the model.
 
-Prompt is often constructed
-from multiple components and prompt values. Prompt classes and functions make constructing
- and working with prompts easy.
-
-**Class hierarchy:**
-
-.. code-block::
-
-    BasePromptTemplate --> PipelinePromptTemplate
-                           StringPromptTemplate --> PromptTemplate
-                                                    FewShotPromptTemplate
-                                                    FewShotPromptWithTemplates
-                           BaseChatPromptTemplate --> AutoGPTPrompt
-                                                      ChatPromptTemplate --> AgentScratchPadChatPromptTemplate
-
-
-
-    BaseMessagePromptTemplate --> MessagesPlaceholder
-                                  BaseStringMessagePromptTemplate --> ChatMessagePromptTemplate
-                                                                      HumanMessagePromptTemplate
-                                                                      AIMessagePromptTemplate
-                                                                      SystemMessagePromptTemplate
-
-"""  # noqa: E501
+Prompt is often constructed from multiple components and prompt values. Prompt classes
+and functions make constructing and working with prompts easy.
+"""
 
 from typing import TYPE_CHECKING
 
@@ -53,7 +32,6 @@ if TYPE_CHECKING:
         FewShotPromptWithTemplates,
     )
     from langchain_core.prompts.loading import load_prompt
-    from langchain_core.prompts.pipeline import PipelinePromptTemplate
     from langchain_core.prompts.prompt import PromptTemplate
     from langchain_core.prompts.string import (
         StringPromptTemplate,
@@ -75,7 +53,6 @@ __all__ = (
     "FewShotPromptWithTemplates",
     "HumanMessagePromptTemplate",
     "MessagesPlaceholder",
-    "PipelinePromptTemplate",
     "PromptTemplate",
     "StringPromptTemplate",
     "SystemMessagePromptTemplate",
@@ -104,7 +81,6 @@ _dynamic_imports = {
     "FewShotPromptTemplate": "few_shot",
     "FewShotPromptWithTemplates": "few_shot_with_templates",
     "load_prompt": "loading",
-    "PipelinePromptTemplate": "pipeline",
     "PromptTemplate": "prompt",
     "StringPromptTemplate": "string",
     "check_valid_template": "string",