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

langchain_core/prompt_values.py

@@ -8,85 +8,39 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
-from typing import Literal, Union, cast
+from typing import Literal, cast
 
-from typing_extensions import TypedDict, overload
+from typing_extensions import TypedDict
 
 from langchain_core.load.serializable import Serializable
 from langchain_core.messages import (
-    AIMessage,
     AnyMessage,
     BaseMessage,
     HumanMessage,
-    SystemMessage,
-    ToolMessage,
     get_buffer_string,
 )
-from langchain_core.messages import content_blocks as types
-from langchain_core.v1.messages import AIMessage as AIMessageV1
-from langchain_core.v1.messages import HumanMessage as HumanMessageV1
-from langchain_core.v1.messages import MessageV1, ResponseMetadata
-from langchain_core.v1.messages import SystemMessage as SystemMessageV1
-from langchain_core.v1.messages import ToolMessage as ToolMessageV1
-
-
-def _convert_to_v1(message: BaseMessage) -> MessageV1:
-    """Best-effort conversion of a V0 AIMessage to V1."""
-    if isinstance(message.content, str):
-        content: list[types.ContentBlock] = []
-        if message.content:
-            content = [{"type": "text", "text": message.content}]
-    else:
-        content = []
-        for block in message.content:
-            if isinstance(block, str):
-                content.append({"type": "text", "text": block})
-            elif isinstance(block, dict):
-                content.append(cast("types.ContentBlock", block))
-            else:
-                pass
-
-    if isinstance(message, HumanMessage):
-        return HumanMessageV1(content=content)
-    if isinstance(message, AIMessage):
-        for tool_call in message.tool_calls:
-            content.append(tool_call)
-        return AIMessageV1(
-            content=content,
-            usage_metadata=message.usage_metadata,
-            response_metadata=cast("ResponseMetadata", message.response_metadata),
-            tool_calls=message.tool_calls,
-        )
-    if isinstance(message, SystemMessage):
-        return SystemMessageV1(content=content)
-    if isinstance(message, ToolMessage):
-        return ToolMessageV1(
-            tool_call_id=message.tool_call_id,
-            content=content,
-            artifact=message.artifact,
-        )
-    error_message = f"Unsupported message type: {type(message)}"
-    raise TypeError(error_message)
 
 
 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 whether this class is serializable. Defaults to 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.
 
         This is used to determine the namespace of the object when serializing.
-        Defaults to ["langchain", "schema", "prompt"].
+
+        Returns:
+            `["langchain", "schema", "prompt"]`
         """
         return ["langchain", "schema", "prompt"]
 
@@ -94,18 +48,8 @@ class PromptValue(Serializable, ABC):
     def to_string(self) -> str:
         """Return prompt value as string."""
 
-    @overload
-    def to_messages(
-        self, message_version: Literal["v0"] = "v0"
-    ) -> list[BaseMessage]: ...
-
-    @overload
-    def to_messages(self, message_version: Literal["v1"]) -> list[MessageV1]: ...
-
     @abstractmethod
-    def to_messages(
-        self, message_version: Literal["v0", "v1"] = "v0"
-    ) -> Union[Sequence[BaseMessage], Sequence[MessageV1]]:
+    def to_messages(self) -> list[BaseMessage]:
         """Return prompt as a list of Messages."""
 
 
@@ -118,10 +62,12 @@ class StringPromptValue(PromptValue):
 
     @classmethod
     def get_lc_namespace(cls) -> list[str]:
-        """Get the namespace of the langchain object.
+        """Get the namespace of the LangChain object.
 
         This is used to determine the namespace of the object when serializing.
-        Defaults to ["langchain", "prompts", "base"].
+
+        Returns:
+            `["langchain", "prompts", "base"]`
         """
         return ["langchain", "prompts", "base"]
 
@@ -129,20 +75,8 @@ class StringPromptValue(PromptValue):
         """Return prompt as string."""
         return self.text
 
-    @overload
-    def to_messages(
-        self, message_version: Literal["v0"] = "v0"
-    ) -> list[BaseMessage]: ...
-
-    @overload
-    def to_messages(self, message_version: Literal["v1"]) -> list[MessageV1]: ...
-
-    def to_messages(
-        self, message_version: Literal["v0", "v1"] = "v0"
-    ) -> Union[Sequence[BaseMessage], Sequence[MessageV1]]:
+    def to_messages(self) -> list[BaseMessage]:
         """Return prompt as messages."""
-        if message_version == "v1":
-            return [HumanMessageV1(content=self.text)]
         return [HumanMessage(content=self.text)]
 
 
@@ -159,32 +93,18 @@ class ChatPromptValue(PromptValue):
         """Return prompt as string."""
         return get_buffer_string(self.messages)
 
-    @overload
-    def to_messages(
-        self, message_version: Literal["v0"] = "v0"
-    ) -> list[BaseMessage]: ...
-
-    @overload
-    def to_messages(self, message_version: Literal["v1"]) -> list[MessageV1]: ...
-
-    def to_messages(
-        self, message_version: Literal["v0", "v1"] = "v0"
-    ) -> Union[Sequence[BaseMessage], Sequence[MessageV1]]:
-        """Return prompt as a list of messages.
-
-        Args:
-            message_version: The output version, either "v0" (default) or "v1".
-        """
-        if message_version == "v1":
-            return [_convert_to_v1(m) for m in self.messages]
+    def to_messages(self) -> list[BaseMessage]:
+        """Return prompt as a list of messages."""
         return list(self.messages)
 
     @classmethod
     def get_lc_namespace(cls) -> list[str]:
-        """Get the namespace of the langchain object.
+        """Get the namespace of the LangChain object.
 
         This is used to determine the namespace of the object when serializing.
-        Defaults to ["langchain", "prompts", "chat"].
+
+        Returns:
+            `["langchain", "prompts", "chat"]`
         """
         return ["langchain", "prompts", "chat"]
 
@@ -193,8 +113,12 @@ 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.
+
+    Can be `'auto'`, `'low'`, or `'high'`.
+
+    This follows OpenAI's Chat Completion API's image URL format.
+    """
 
     url: str
     """Either a URL of the image or the base64 encoded image data."""
@@ -209,28 +133,10 @@ class ImagePromptValue(PromptValue):
 
     def to_string(self) -> str:
         """Return prompt (image URL) as string."""
-        return self.image_url["url"]
-
-    @overload
-    def to_messages(
-        self, message_version: Literal["v0"] = "v0"
-    ) -> list[BaseMessage]: ...
-
-    @overload
-    def to_messages(self, message_version: Literal["v1"]) -> list[MessageV1]: ...
+        return self.image_url.get("url", "")
 
-    def to_messages(
-        self, message_version: Literal["v0", "v1"] = "v0"
-    ) -> Union[Sequence[BaseMessage], Sequence[MessageV1]]:
+    def to_messages(self) -> list[BaseMessage]:
         """Return prompt (image URL) as messages."""
-        if message_version == "v1":
-            block: types.ImageContentBlock = {
-                "type": "image",
-                "url": self.image_url["url"],
-            }
-            if "detail" in self.image_url:
-                block["detail"] = self.image_url["detail"]
-            return [HumanMessageV1(content=[block])]
         return [HumanMessage(content=[cast("dict", self.image_url)])]
 
 

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",

langchain_core/prompts/base.py

@@ -6,17 +6,14 @@ import contextlib
 import json
 import typing
 from abc import ABC, abstractmethod
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from functools import cached_property
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     Generic,
-    Optional,
     TypeVar,
-    Union,
 )
 
 import yaml
@@ -57,16 +54,16 @@ class BasePromptTemplate(
     input_types: typing.Dict[str, Any] = Field(default_factory=dict, exclude=True)  # noqa: UP006
     """A dictionary of the types of the variables the prompt template expects.
     If not provided, all variables are assumed to be strings."""
-    output_parser: Optional[BaseOutputParser] = None
+    output_parser: BaseOutputParser | None = None
     """How to parse the output of calling an LLM on this formatted prompt."""
     partial_variables: Mapping[str, Any] = Field(default_factory=dict)
     """A dictionary of the partial variables the prompt template carries.
 
     Partial variables populate the template so that you don't need to
     pass them in every time you call the prompt."""
-    metadata: Optional[typing.Dict[str, Any]] = None  # noqa: UP006
+    metadata: typing.Dict[str, Any] | None = None  # noqa: UP006
     """Metadata to be used for tracing."""
-    tags: Optional[list[str]] = None
+    tags: list[str] | None = None
     """Tags to be used for tracing."""
 
     @model_validator(mode="after")
@@ -99,18 +96,16 @@ class BasePromptTemplate(
 
     @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", "prompt_template"].
+        Returns:
+            `["langchain", "schema", "prompt_template"]`
         """
         return ["langchain", "schema", "prompt_template"]
 
     @classmethod
     def is_lc_serializable(cls) -> bool:
-        """Return whether this class is serializable.
-
-        Returns True.
-        """
+        """Return True as this class is serializable."""
         return True
 
     model_config = ConfigDict(
@@ -125,19 +120,17 @@ class BasePromptTemplate(
     @override
     def OutputType(self) -> Any:
         """Return the output type of the prompt."""
-        return Union[StringPromptValue, ChatPromptValueConcrete]
+        return StringPromptValue | ChatPromptValueConcrete
 
     @override
-    def get_input_schema(
-        self, config: Optional[RunnableConfig] = None
-    ) -> type[BaseModel]:
+    def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
         """Get the input schema for the prompt.
 
         Args:
-            config: RunnableConfig, configuration for the prompt.
+            config: configuration for the prompt.
 
         Returns:
-            Type[BaseModel]: The input schema for the prompt.
+            The input schema for the prompt.
         """
         # This is correct, but pydantic typings/mypy don't think so.
         required_input_variables = {
@@ -197,7 +190,7 @@ class BasePromptTemplate(
 
     @override
     def invoke(
-        self, input: dict, config: Optional[RunnableConfig] = None, **kwargs: Any
+        self, input: dict, config: RunnableConfig | None = None, **kwargs: Any
     ) -> PromptValue:
         """Invoke the prompt.
 
@@ -206,13 +199,13 @@ class BasePromptTemplate(
             config: RunnableConfig, configuration for the prompt.
 
         Returns:
-            PromptValue: The output of the prompt.
+            The output of the prompt.
         """
         config = ensure_config(config)
         if self.metadata:
             config["metadata"] = {**config["metadata"], **self.metadata}
         if self.tags:
-            config["tags"] = config["tags"] + self.tags
+            config["tags"] += self.tags
         return self._call_with_config(
             self._format_prompt_with_error_handling,
             input,
@@ -223,7 +216,7 @@ class BasePromptTemplate(
 
     @override
     async def ainvoke(
-        self, input: dict, config: Optional[RunnableConfig] = None, **kwargs: Any
+        self, input: dict, config: RunnableConfig | None = None, **kwargs: Any
     ) -> PromptValue:
         """Async invoke the prompt.
 
@@ -232,7 +225,7 @@ class BasePromptTemplate(
             config: RunnableConfig, configuration for the prompt.
 
         Returns:
-            PromptValue: The output of the prompt.
+            The output of the prompt.
         """
         config = ensure_config(config)
         if self.metadata:
@@ -252,31 +245,31 @@ class BasePromptTemplate(
         """Create Prompt Value.
 
         Args:
-            kwargs: Any arguments to be passed to the prompt template.
+            **kwargs: Any arguments to be passed to the prompt template.
 
         Returns:
-            PromptValue: The output of the prompt.
+            The output of the prompt.
         """
 
     async def aformat_prompt(self, **kwargs: Any) -> PromptValue:
         """Async create Prompt Value.
 
         Args:
-            kwargs: Any arguments to be passed to the prompt template.
+            **kwargs: Any arguments to be passed to the prompt template.
 
         Returns:
-            PromptValue: The output of the prompt.
+            The output of the prompt.
         """
         return self.format_prompt(**kwargs)
 
-    def partial(self, **kwargs: Union[str, Callable[[], str]]) -> BasePromptTemplate:
+    def partial(self, **kwargs: str | Callable[[], str]) -> BasePromptTemplate:
         """Return a partial of the prompt template.
 
         Args:
-            kwargs: Union[str, Callable[[], str]], partial variables to set.
+            **kwargs: partial variables to set.
 
         Returns:
-            BasePromptTemplate: A partial of the prompt template.
+            A partial of the prompt template.
         """
         prompt_dict = self.__dict__.copy()
         prompt_dict["input_variables"] = list(
@@ -297,34 +290,30 @@ class BasePromptTemplate(
         """Format the prompt with the inputs.
 
         Args:
-            kwargs: Any arguments to be passed to the prompt template.
+            **kwargs: Any arguments to be passed to the prompt template.
 
         Returns:
             A formatted string.
 
         Example:
-
-        .. code-block:: python
-
-            prompt.format(variable1="foo")
-
+        ```python
+        prompt.format(variable1="foo")
+        ```
         """
 
     async def aformat(self, **kwargs: Any) -> FormatOutputType:
         """Async format the prompt with the inputs.
 
         Args:
-            kwargs: Any arguments to be passed to the prompt template.
+            **kwargs: Any arguments to be passed to the prompt template.
 
         Returns:
             A formatted string.
 
         Example:
-
-        .. code-block:: python
-
-            await prompt.aformat(variable1="foo")
-
+        ```python
+        await prompt.aformat(variable1="foo")
+        ```
         """
         return self.format(**kwargs)
 
@@ -337,20 +326,17 @@ class BasePromptTemplate(
         """Return dictionary representation of prompt.
 
         Args:
-            kwargs: Any additional arguments to pass to the dictionary.
+            **kwargs: Any additional arguments to pass to the dictionary.
 
         Returns:
-            Dict: Dictionary representation of the prompt.
-
-        Raises:
-            NotImplementedError: If the prompt type is not implemented.
+            Dictionary representation of the prompt.
         """
         prompt_dict = super().model_dump(**kwargs)
         with contextlib.suppress(NotImplementedError):
             prompt_dict["_type"] = self._prompt_type
         return prompt_dict
 
-    def save(self, file_path: Union[Path, str]) -> None:
+    def save(self, file_path: Path | str) -> None:
         """Save the prompt.
 
         Args:
@@ -362,10 +348,9 @@ class BasePromptTemplate(
             NotImplementedError: If the prompt type is not implemented.
 
         Example:
-        .. code-block:: python
-
-            prompt.save(file_path="path/prompt.yaml")
-
+        ```python
+        prompt.save(file_path="path/prompt.yaml")
+        ```
         """
         if self.partial_variables:
             msg = "Cannot save prompt with partial variables."
@@ -384,10 +369,10 @@ class BasePromptTemplate(
         directory_path.mkdir(parents=True, exist_ok=True)
 
         if save_path.suffix == ".json":
-            with save_path.open("w") as f:
+            with save_path.open("w", encoding="utf-8") as f:
                 json.dump(prompt_dict, f, indent=4)
         elif save_path.suffix.endswith((".yaml", ".yml")):
-            with save_path.open("w") as f:
+            with save_path.open("w", encoding="utf-8") as f:
                 yaml.dump(prompt_dict, f, default_flow_style=False)
         else:
             msg = f"{save_path} must be json or yaml"
@@ -436,16 +421,16 @@ def format_document(doc: Document, prompt: BasePromptTemplate[str]) -> str:
         string of the document formatted.
 
     Example:
-        .. code-block:: python
-
-            from langchain_core.documents import Document
-            from langchain_core.prompts import PromptTemplate
+        ```python
+        from langchain_core.documents import Document
+        from langchain_core.prompts import PromptTemplate
 
-            doc = Document(page_content="This is a joke", metadata={"page": "1"})
-            prompt = PromptTemplate.from_template("Page {page}: {page_content}")
-            format_document(doc, prompt)
-            >>> "Page 1: This is a joke"
+        doc = Document(page_content="This is a joke", metadata={"page": "1"})
+        prompt = PromptTemplate.from_template("Page {page}: {page_content}")
+        format_document(doc, prompt)
+        >>> "Page 1: This is a joke"
 
+        ```
     """
     return prompt.format(**_get_document_info(doc, prompt))