langchain-core 1.0.0a8__py3-none-any.whl → 1.0.0rc1__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

@@ -134,29 +134,28 @@ class BaseOutputParser(
     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"
-
+        ```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

langchain_core/output_parsers/json.py

@@ -40,7 +40,7 @@ class JsonOutputParser(BaseCumulativeTransformOutputParser[Any]):
 
     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: Any | None, next: Any) -> Any:
@@ -59,9 +59,9 @@ class JsonOutputParser(BaseCumulativeTransformOutputParser[Any]):
         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.
+                If `False`, the output will be the full JSON object.
                 Default is False.
 
         Returns:

langchain_core/output_parsers/list.py

@@ -149,7 +149,7 @@ class CommaSeparatedListOutputParser(ListOutputParser):
         """Get the namespace of the langchain object.
 
         Returns:
-            ``["langchain", "output_parsers", "list"]``
+            `["langchain", "output_parsers", "list"]`
         """
         return ["langchain", "output_parsers", "list"]
 

langchain_core/output_parsers/openai_functions.py

@@ -31,13 +31,13 @@ class OutputFunctionsParser(BaseGenerationOutputParser[Any]):
 
         Args:
             result: The result of the LLM call.
-            partial: Whether to parse partial JSON objects. Default is False.
+            partial: Whether to parse partial JSON objects.
 
         Returns:
             The parsed JSON object.
 
         Raises:
-            OutputParserException: If the output is not valid JSON.
+            `OutputParserException`: If the output is not valid JSON.
         """
         generation = result[0]
         if not isinstance(generation, ChatGeneration):
@@ -56,7 +56,7 @@ class OutputFunctionsParser(BaseGenerationOutputParser[Any]):
 
 
 class JsonOutputFunctionsParser(BaseCumulativeTransformOutputParser[Any]):
-    """Parse an output as the Json object."""
+    """Parse an output as the JSON object."""
 
     strict: bool = False
     """Whether to allow non-JSON-compliant strings.
@@ -82,13 +82,13 @@ class JsonOutputFunctionsParser(BaseCumulativeTransformOutputParser[Any]):
 
         Args:
             result: The result of the LLM call.
-            partial: Whether to parse partial JSON objects. Default is False.
+            partial: Whether to parse partial JSON objects.
 
         Returns:
             The parsed JSON object.
 
         Raises:
-            OutputParserException: If the output is not valid JSON.
+            OutputParserExcept`ion: If the output is not valid JSON.
         """
         if len(result) != 1:
             msg = f"Expected exactly one result, but got {len(result)}"
@@ -155,7 +155,7 @@ class JsonOutputFunctionsParser(BaseCumulativeTransformOutputParser[Any]):
 
 
 class JsonKeyOutputFunctionsParser(JsonOutputFunctionsParser):
-    """Parse an output as the element of the Json object."""
+    """Parse an output as the element of the JSON object."""
 
     key_name: str
     """The name of the key to return."""
@@ -165,7 +165,7 @@ class JsonKeyOutputFunctionsParser(JsonOutputFunctionsParser):
 
         Args:
             result: The result of the LLM call.
-            partial: Whether to parse partial JSON objects. Default is False.
+            partial: Whether to parse partial JSON objects.
 
         Returns:
             The parsed JSON object.
@@ -177,48 +177,50 @@ class JsonKeyOutputFunctionsParser(JsonOutputFunctionsParser):
 
 
 class PydanticOutputFunctionsParser(OutputFunctionsParser):
-    """Parse an output as a pydantic object.
+    """Parse an output as a Pydantic object.
 
-    This parser is used to parse the output of a ChatModel that uses
-    OpenAI function format to invoke functions.
+    This parser is used to parse the output of a chat model that uses OpenAI function
+    format to invoke functions.
 
-    The parser extracts the function call invocation and matches
-    them to the pydantic schema provided.
+    The parser extracts the function call invocation and matches them to the Pydantic
+    schema provided.
 
-    An exception will be raised if the function call does not match
-    the provided schema.
+    An exception will be raised if the function call does not match the provided schema.
 
     Example:
-        ... code-block:: python
-
-            message = AIMessage(
-                content="This is a test message",
-                additional_kwargs={
-                    "function_call": {
-                        "name": "cookie",
-                        "arguments": json.dumps({"name": "value", "age": 10}),
-                    }
-                },
-            )
-            chat_generation = ChatGeneration(message=message)
+        ```python
+        message = AIMessage(
+            content="This is a test message",
+            additional_kwargs={
+                "function_call": {
+                    "name": "cookie",
+                    "arguments": json.dumps({"name": "value", "age": 10}),
+                }
+            },
+        )
+        chat_generation = ChatGeneration(message=message)
 
-            class Cookie(BaseModel):
-                name: str
-                age: int
 
-            class Dog(BaseModel):
-                species: str
+        class Cookie(BaseModel):
+            name: str
+            age: int
 
-            # Full output
-            parser = PydanticOutputFunctionsParser(
-                pydantic_schema={"cookie": Cookie, "dog": Dog}
-            )
-            result = parser.parse_result([chat_generation])
+
+        class Dog(BaseModel):
+            species: str
+
+
+        # Full output
+        parser = PydanticOutputFunctionsParser(
+            pydantic_schema={"cookie": Cookie, "dog": Dog}
+        )
+        result = parser.parse_result([chat_generation])
+        ```
 
     """
 
     pydantic_schema: type[BaseModel] | dict[str, type[BaseModel]]
-    """The pydantic schema to parse the output with.
+    """The Pydantic schema to parse the output with.
 
     If multiple schemas are provided, then the function name will be used to
     determine which schema to use.
@@ -227,7 +229,7 @@ class PydanticOutputFunctionsParser(OutputFunctionsParser):
     @model_validator(mode="before")
     @classmethod
     def validate_schema(cls, values: dict) -> Any:
-        """Validate the pydantic schema.
+        """Validate the Pydantic schema.
 
         Args:
             values: The values to validate.
@@ -236,7 +238,7 @@ class PydanticOutputFunctionsParser(OutputFunctionsParser):
             The validated values.
 
         Raises:
-            ValueError: If the schema is not a pydantic schema.
+            `ValueError`: If the schema is not a Pydantic schema.
         """
         schema = values["pydantic_schema"]
         if "args_only" not in values:
@@ -259,10 +261,10 @@ class PydanticOutputFunctionsParser(OutputFunctionsParser):
 
         Args:
             result: The result of the LLM call.
-            partial: Whether to parse partial JSON objects. Default is False.
+            partial: Whether to parse partial JSON objects.
 
         Raises:
-            ValueError: If the pydantic schema is not valid.
+            `ValueError`: If the Pydantic schema is not valid.
 
         Returns:
             The parsed JSON object.
@@ -285,13 +287,13 @@ class PydanticOutputFunctionsParser(OutputFunctionsParser):
             elif issubclass(pydantic_schema, BaseModelV1):
                 pydantic_args = pydantic_schema.parse_raw(args)
             else:
-                msg = f"Unsupported pydantic schema: {pydantic_schema}"
+                msg = f"Unsupported Pydantic schema: {pydantic_schema}"
                 raise ValueError(msg)
         return pydantic_args
 
 
 class PydanticAttrOutputFunctionsParser(PydanticOutputFunctionsParser):
-    """Parse an output as an attribute of a pydantic object."""
+    """Parse an output as an attribute of a Pydantic object."""
 
     attr_name: str
     """The name of the attribute to return."""
@@ -302,7 +304,7 @@ class PydanticAttrOutputFunctionsParser(PydanticOutputFunctionsParser):
 
         Args:
             result: The result of the LLM call.
-            partial: Whether to parse partial JSON objects. Default is False.
+            partial: Whether to parse partial JSON objects.
 
         Returns:
             The parsed JSON object.

langchain_core/output_parsers/openai_tools.py

@@ -148,7 +148,7 @@ class JsonOutputToolsParser(BaseCumulativeTransformOutputParser[Any]):
     first_tool_only: bool = False
     """Whether to return only the first tool call.
 
-    If False, the result will be a list of tool calls, or an empty list
+    If `False`, the result will be a list of tool calls, or an empty list
     if no tool calls are found.
 
     If true, and multiple tool calls are found, only the first one will be returned,
@@ -162,9 +162,9 @@ class JsonOutputToolsParser(BaseCumulativeTransformOutputParser[Any]):
         Args:
             result: The result of the LLM call.
             partial: Whether to parse partial JSON.
-                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.
+                If `False`, the output will be the full JSON object.
                 Default is False.
 
         Returns:
@@ -226,9 +226,9 @@ class JsonOutputKeyToolsParser(JsonOutputToolsParser):
         Args:
             result: The result of the LLM call.
             partial: Whether to parse partial JSON.
-                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.
+                If `False`, the output will be the full JSON object.
                 Default is False.
 
         Raises:
@@ -310,9 +310,9 @@ class PydanticToolsParser(JsonOutputToolsParser):
         Args:
             result: The result of the LLM call.
             partial: Whether to parse partial JSON.
-                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.
+                If `False`, the output will be the full JSON object.
                 Default is False.
 
         Returns:

langchain_core/output_parsers/pydantic.py

@@ -17,10 +17,10 @@ from langchain_core.utils.pydantic import (
 
 
 class PydanticOutputParser(JsonOutputParser, Generic[TBaseModel]):
-    """Parse an output using a pydantic model."""
+    """Parse an output using a Pydantic model."""
 
     pydantic_object: Annotated[type[TBaseModel], SkipValidation()]
-    """The pydantic model to parse."""
+    """The Pydantic model to parse."""
 
     def _parse_obj(self, obj: dict) -> TBaseModel:
         try:
@@ -45,21 +45,20 @@ class PydanticOutputParser(JsonOutputParser, Generic[TBaseModel]):
     def parse_result(
         self, result: list[Generation], *, partial: bool = False
     ) -> TBaseModel | None:
-        """Parse the result of an LLM call to a pydantic object.
+        """Parse the result of an LLM call to a Pydantic 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.
-                Defaults to False.
 
         Raises:
-            OutputParserException: If the result is not valid JSON
-                or does not conform to the pydantic model.
+            `OutputParserException`: If the result is not valid JSON
+                or does not conform to the Pydantic model.
 
         Returns:
-            The parsed pydantic object.
+            The parsed Pydantic object.
         """
         try:
             json_object = super().parse_result(result)
@@ -70,13 +69,13 @@ class PydanticOutputParser(JsonOutputParser, Generic[TBaseModel]):
             raise
 
     def parse(self, text: str) -> TBaseModel:
-        """Parse the output of an LLM call to a pydantic object.
+        """Parse the output of an LLM call to a Pydantic object.
 
         Args:
             text: The output of the LLM call.
 
         Returns:
-            The parsed pydantic object.
+            The parsed Pydantic object.
         """
         return super().parse(text)
 
@@ -107,7 +106,7 @@ class PydanticOutputParser(JsonOutputParser, Generic[TBaseModel]):
     @property
     @override
     def OutputType(self) -> type[TBaseModel]:
-        """Return the pydantic model."""
+        """Return the Pydantic model."""
         return self.pydantic_object
 
 

langchain_core/output_parsers/string.py

@@ -22,7 +22,7 @@ class StrOutputParser(BaseTransformOutputParser[str]):
         """Get the namespace of the langchain object.
 
         Returns:
-            ``["langchain", "schema", "output_parser"]``
+            `["langchain", "schema", "output_parser"]`
         """
         return ["langchain", "schema", "output_parser"]
 

langchain_core/output_parsers/transform.py

@@ -64,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.
@@ -85,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.

langchain_core/output_parsers/xml.py

@@ -82,7 +82,7 @@ class _StreamingParser:
             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.

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

@@ -15,14 +15,14 @@ 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).
     """
 
@@ -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
@@ -84,18 +84,18 @@ class ChatGenerationChunk(ChatGeneration):
     def __add__(
         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(
@@ -124,13 +124,13 @@ class ChatGenerationChunk(ChatGeneration):
 def merge_chat_generation_chunks(
     chunks: list[ChatGenerationChunk],
 ) -> ChatGenerationChunk | None:
-    """Merge a list of ``ChatGenerationChunk``s into a single ``ChatGenerationChunk``.
+    """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/generation.py

@@ -47,7 +47,7 @@ class Generation(Serializable):
         """Get the namespace of the langchain object.
 
         Returns:
-            ``["langchain", "schema", "output"]``
+            `["langchain", "schema", "output"]`
         """
         return ["langchain", "schema", "output"]
 
@@ -56,16 +56,16 @@ class GenerationChunk(Generation):
     """Generation chunk, 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

@@ -30,8 +30,8 @@ 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.
@@ -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

@@ -40,7 +40,7 @@ class PromptValue(Serializable, ABC):
         This is used to determine the namespace of the object when serializing.
 
         Returns:
-            ``["langchain", "schema", "prompt"]``
+            `["langchain", "schema", "prompt"]`
         """
         return ["langchain", "schema", "prompt"]
 
@@ -67,7 +67,7 @@ class StringPromptValue(PromptValue):
         This is used to determine the namespace of the object when serializing.
 
         Returns:
-            ``["langchain", "prompts", "base"]``
+            `["langchain", "prompts", "base"]`
         """
         return ["langchain", "prompts", "base"]
 
@@ -104,7 +104,7 @@ class ChatPromptValue(PromptValue):
         This is used to determine the namespace of the object when serializing.
 
         Returns:
-            ``["langchain", "prompts", "chat"]``
+            `["langchain", "prompts", "chat"]`
         """
         return ["langchain", "prompts", "chat"]
 
@@ -113,8 +113,8 @@ 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. Defaults to `'auto'`.
+    Can be `'auto'`, `'low'`, or `'high'`.
 
     This follows OpenAI's Chat Completion API's image URL format.
 

langchain_core/prompts/__init__.py

@@ -1,28 +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 --> 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