langchain-core 1.0.0a5__py3-none-any.whl → 1.0.3__py3-none-any.whl

langchain_core/prompts/dict.py

@@ -2,7 +2,7 @@
 
 import warnings
 from functools import cached_property
-from typing import Any, Literal, Optional
+from typing import Any, Literal
 
 from typing_extensions import override
 
@@ -48,7 +48,7 @@ class DictPromptTemplate(RunnableSerializable[dict, dict]):
 
     @override
     def invoke(
-        self, input: dict, config: Optional[RunnableConfig] = None, **kwargs: Any
+        self, input: dict, config: RunnableConfig | None = None, **kwargs: Any
     ) -> dict:
         return self._call_with_config(
             lambda x: self.format(**x),
@@ -74,10 +74,10 @@ class DictPromptTemplate(RunnableSerializable[dict, dict]):
 
     @classmethod
     def get_lc_namespace(cls) -> list[str]:
-        """Get the namespace of the langchain object.
+        """Get the namespace of the LangChain object.
 
         Returns:
-            ``["langchain_core", "prompts", "dict"]``
+            `["langchain_core", "prompts", "dict"]`
         """
         return ["langchain_core", "prompts", "dict"]
 
@@ -85,7 +85,7 @@ class DictPromptTemplate(RunnableSerializable[dict, dict]):
         """Human-readable representation.
 
         Args:
-            html: Whether to format as HTML. Defaults to False.
+            html: Whether to format as HTML.
 
         Returns:
             Human-readable representation.

langchain_core/prompts/few_shot.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Literal, Optional, Union
+from typing import TYPE_CHECKING, Any, Literal
 
 from pydantic import (
     BaseModel,
@@ -33,11 +33,11 @@ if TYPE_CHECKING:
 class _FewShotPromptTemplateMixin(BaseModel):
     """Prompt template that contains few shot examples."""
 
-    examples: Optional[list[dict]] = None
+    examples: list[dict] | None = None
     """Examples to format into the prompt.
     Either this or example_selector should be provided."""
 
-    example_selector: Optional[BaseExampleSelector] = None
+    example_selector: BaseExampleSelector | None = None
     """ExampleSelector to choose the examples to format into the prompt.
     Either this or examples should be provided."""
 
@@ -229,7 +229,7 @@ class FewShotPromptTemplate(_FewShotPromptTemplateMixin, StringPromptTemplate):
         """Return the prompt type key."""
         return "few_shot"
 
-    def save(self, file_path: Union[Path, str]) -> None:
+    def save(self, file_path: Path | str) -> None:
         """Save the prompt template to a file.
 
         Args:
@@ -268,104 +268,97 @@ class FewShotChatMessagePromptTemplate(
         Prompt template with a fixed list of examples (matching the sample
         conversation above):
 
-        .. code-block:: python
+        ```python
+        from langchain_core.prompts import (
+            FewShotChatMessagePromptTemplate,
+            ChatPromptTemplate,
+        )
 
-            from langchain_core.prompts import (
-                FewShotChatMessagePromptTemplate,
-                ChatPromptTemplate,
-            )
+        examples = [
+            {"input": "2+2", "output": "4"},
+            {"input": "2+3", "output": "5"},
+        ]
 
-            examples = [
-                {"input": "2+2", "output": "4"},
-                {"input": "2+3", "output": "5"},
+        example_prompt = ChatPromptTemplate.from_messages(
+            [
+                ("human", "What is {input}?"),
+                ("ai", "{output}"),
             ]
-
-            example_prompt = ChatPromptTemplate.from_messages(
-                [
-                    ("human", "What is {input}?"),
-                    ("ai", "{output}"),
-                ]
-            )
-
-            few_shot_prompt = FewShotChatMessagePromptTemplate(
-                examples=examples,
-                # This is a prompt template used to format each individual example.
-                example_prompt=example_prompt,
-            )
-
-            final_prompt = ChatPromptTemplate.from_messages(
-                [
-                    ("system", "You are a helpful AI Assistant"),
-                    few_shot_prompt,
-                    ("human", "{input}"),
-                ]
-            )
-            final_prompt.format(input="What is 4+4?")
-
-        Prompt template with dynamically selected examples:
-
-        .. code-block:: python
-
-            from langchain_core.prompts import SemanticSimilarityExampleSelector
-            from langchain_core.embeddings import OpenAIEmbeddings
-            from langchain_core.vectorstores import Chroma
-
-            examples = [
-                {"input": "2+2", "output": "4"},
-                {"input": "2+3", "output": "5"},
-                {"input": "2+4", "output": "6"},
-                # ...
+        )
+
+        few_shot_prompt = FewShotChatMessagePromptTemplate(
+            examples=examples,
+            # This is a prompt template used to format each individual example.
+            example_prompt=example_prompt,
+        )
+
+        final_prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", "You are a helpful AI Assistant"),
+                few_shot_prompt,
+                ("human", "{input}"),
             ]
+        )
+        final_prompt.format(input="What is 4+4?")
+        ```
 
-            to_vectorize = [" ".join(example.values()) for example in examples]
-            embeddings = OpenAIEmbeddings()
-            vectorstore = Chroma.from_texts(
-                to_vectorize, embeddings, metadatas=examples
-            )
-            example_selector = SemanticSimilarityExampleSelector(
-                vectorstore=vectorstore
-            )
-
-            from langchain_core import SystemMessage
-            from langchain_core.prompts import HumanMessagePromptTemplate
-            from langchain_core.prompts.few_shot import FewShotChatMessagePromptTemplate
-
-            few_shot_prompt = FewShotChatMessagePromptTemplate(
-                # Which variable(s) will be passed to the example selector.
-                input_variables=["input"],
-                example_selector=example_selector,
-                # Define how each example will be formatted.
-                # In this case, each example will become 2 messages:
-                # 1 human, and 1 AI
-                example_prompt=(
-                    HumanMessagePromptTemplate.from_template("{input}")
-                    + AIMessagePromptTemplate.from_template("{output}")
-                ),
-            )
-            # Define the overall prompt.
-            final_prompt = (
-                SystemMessagePromptTemplate.from_template(
-                    "You are a helpful AI Assistant"
-                )
-                + few_shot_prompt
-                + HumanMessagePromptTemplate.from_template("{input}")
-            )
-            # Show the prompt
-            print(final_prompt.format_messages(input="What's 3+3?"))  # noqa: T201
+        Prompt template with dynamically selected examples:
 
-            # Use within an LLM
-            from langchain_core.chat_models import ChatAnthropic
+        ```python
+        from langchain_core.prompts import SemanticSimilarityExampleSelector
+        from langchain_core.embeddings import OpenAIEmbeddings
+        from langchain_core.vectorstores import Chroma
 
-            chain = final_prompt | ChatAnthropic(model="claude-3-haiku-20240307")
-            chain.invoke({"input": "What's 3+3?"})
+        examples = [
+            {"input": "2+2", "output": "4"},
+            {"input": "2+3", "output": "5"},
+            {"input": "2+4", "output": "6"},
+            # ...
+        ]
 
+        to_vectorize = [" ".join(example.values()) for example in examples]
+        embeddings = OpenAIEmbeddings()
+        vectorstore = Chroma.from_texts(to_vectorize, embeddings, metadatas=examples)
+        example_selector = SemanticSimilarityExampleSelector(vectorstore=vectorstore)
+
+        from langchain_core import SystemMessage
+        from langchain_core.prompts import HumanMessagePromptTemplate
+        from langchain_core.prompts.few_shot import FewShotChatMessagePromptTemplate
+
+        few_shot_prompt = FewShotChatMessagePromptTemplate(
+            # Which variable(s) will be passed to the example selector.
+            input_variables=["input"],
+            example_selector=example_selector,
+            # Define how each example will be formatted.
+            # In this case, each example will become 2 messages:
+            # 1 human, and 1 AI
+            example_prompt=(
+                HumanMessagePromptTemplate.from_template("{input}")
+                + AIMessagePromptTemplate.from_template("{output}")
+            ),
+        )
+        # Define the overall prompt.
+        final_prompt = (
+            SystemMessagePromptTemplate.from_template("You are a helpful AI Assistant")
+            + few_shot_prompt
+            + HumanMessagePromptTemplate.from_template("{input}")
+        )
+        # Show the prompt
+        print(final_prompt.format_messages(input="What's 3+3?"))  # noqa: T201
+
+        # Use within an LLM
+        from langchain_core.chat_models import ChatAnthropic
+
+        chain = final_prompt | ChatAnthropic(model="claude-3-haiku-20240307")
+        chain.invoke({"input": "What's 3+3?"})
+        ```
     """
 
     input_variables: list[str] = Field(default_factory=list)
     """A list of the names of the variables the prompt template will use
     to pass to the example_selector, if provided."""
 
-    example_prompt: Union[BaseMessagePromptTemplate, BaseChatPromptTemplate]
+    example_prompt: BaseMessagePromptTemplate | BaseChatPromptTemplate
     """The class to format each example."""
 
     @classmethod

langchain_core/prompts/few_shot_with_templates.py

@@ -1,7 +1,7 @@
 """Prompt template that contains few shot examples."""
 
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Any
 
 from pydantic import ConfigDict, model_validator
 from typing_extensions import Self
@@ -17,7 +17,7 @@ from langchain_core.prompts.string import (
 class FewShotPromptWithTemplates(StringPromptTemplate):
     """Prompt template that contains few shot examples."""
 
-    examples: Optional[list[dict]] = None
+    examples: list[dict] | None = None
     """Examples to format into the prompt.
     Either this or example_selector should be provided."""
 
@@ -34,7 +34,7 @@ class FewShotPromptWithTemplates(StringPromptTemplate):
     example_separator: str = "\n\n"
     """String separator used to join the prefix, the examples, and suffix."""
 
-    prefix: Optional[StringPromptTemplate] = None
+    prefix: StringPromptTemplate | None = None
     """A PromptTemplate to put before the examples."""
 
     template_format: PromptTemplateFormat = "f-string"
@@ -46,10 +46,10 @@ class FewShotPromptWithTemplates(StringPromptTemplate):
 
     @classmethod
     def get_lc_namespace(cls) -> list[str]:
-        """Get the namespace of the langchain object.
+        """Get the namespace of the LangChain object.
 
         Returns:
-            ``["langchain", "prompts", "few_shot_with_templates"]``
+            `["langchain", "prompts", "few_shot_with_templates"]`
         """
         return ["langchain", "prompts", "few_shot_with_templates"]
 
@@ -116,17 +116,15 @@ class FewShotPromptWithTemplates(StringPromptTemplate):
         """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")
+        ```
         """
         kwargs = self._merge_partial_and_user_variables(**kwargs)
         # Get the examples to use.
@@ -165,7 +163,7 @@ class FewShotPromptWithTemplates(StringPromptTemplate):
         """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.
@@ -210,7 +208,7 @@ class FewShotPromptWithTemplates(StringPromptTemplate):
         """Return the prompt type key."""
         return "few_shot_with_templates"
 
-    def save(self, file_path: Union[Path, str]) -> None:
+    def save(self, file_path: Path | str) -> None:
         """Save the prompt to a file.
 
         Args:

langchain_core/prompts/image.py

@@ -26,8 +26,8 @@ class ImagePromptTemplate(BasePromptTemplate[ImageURL]):
         """Create an image prompt template.
 
         Raises:
-            ValueError: If the input variables contain ``'url'``, ``'path'``, or
-                ``'detail'``.
+            ValueError: If the input variables contain `'url'`, `'path'`, or
+                `'detail'`.
         """
         if "input_variables" not in kwargs:
             kwargs["input_variables"] = []
@@ -49,10 +49,10 @@ class ImagePromptTemplate(BasePromptTemplate[ImageURL]):
 
     @classmethod
     def get_lc_namespace(cls) -> list[str]:
-        """Get the namespace of the langchain object.
+        """Get the namespace of the LangChain object.
 
         Returns:
-            ``["langchain", "prompts", "image"]``
+            `["langchain", "prompts", "image"]`
         """
         return ["langchain", "prompts", "image"]
 
@@ -60,7 +60,7 @@ class ImagePromptTemplate(BasePromptTemplate[ImageURL]):
         """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.
@@ -71,7 +71,7 @@ class ImagePromptTemplate(BasePromptTemplate[ImageURL]):
         """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.
@@ -85,7 +85,7 @@ class ImagePromptTemplate(BasePromptTemplate[ImageURL]):
         """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.
@@ -93,14 +93,12 @@ class ImagePromptTemplate(BasePromptTemplate[ImageURL]):
         Raises:
             ValueError: If the url is not provided.
             ValueError: If the url is not a string.
-            ValueError: If ``'path'`` is provided in the template or kwargs.
+            ValueError: If `'path'` is provided in the template or kwargs.
 
         Example:
-
-            .. code-block:: python
-
-                prompt.format(variable1="foo")
-
+            ```python
+            prompt.format(variable1="foo")
+            ```
         """
         formatted = {}
         for k, v in self.template.items():
@@ -134,7 +132,7 @@ class ImagePromptTemplate(BasePromptTemplate[ImageURL]):
         """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.

langchain_core/prompts/loading.py

@@ -2,8 +2,8 @@
 
 import json
 import logging
+from collections.abc import Callable
 from pathlib import Path
-from typing import Callable, Optional, Union
 
 import yaml
 
@@ -134,14 +134,12 @@ def _load_prompt(config: dict) -> PromptTemplate:
     return PromptTemplate(**config)
 
 
-def load_prompt(
-    path: Union[str, Path], encoding: Optional[str] = None
-) -> BasePromptTemplate:
+def load_prompt(path: str | Path, encoding: str | None = None) -> BasePromptTemplate:
     """Unified method for loading a prompt from LangChainHub or local fs.
 
     Args:
         path: Path to the prompt file.
-        encoding: Encoding of the file. Defaults to None.
+        encoding: Encoding of the file.
 
     Returns:
         A PromptTemplate object.
@@ -160,7 +158,7 @@ def load_prompt(
 
 
 def _load_prompt_from_file(
-    file: Union[str, Path], encoding: Optional[str] = None
+    file: str | Path, encoding: str | None = None
 ) -> BasePromptTemplate:
     """Load prompt from file."""
     # Convert file to a Path object.

langchain_core/prompts/message.py

@@ -23,10 +23,10 @@ class BaseMessagePromptTemplate(Serializable, ABC):
 
     @classmethod
     def get_lc_namespace(cls) -> list[str]:
-        """Get the namespace of the langchain object.
+        """Get the namespace of the LangChain object.
 
         Returns:
-            ``["langchain", "prompts", "chat"]``
+            `["langchain", "prompts", "chat"]`
         """
         return ["langchain", "prompts", "chat"]
 
@@ -68,7 +68,7 @@ class BaseMessagePromptTemplate(Serializable, ABC):
         """Human-readable representation.
 
         Args:
-            html: Whether to format as HTML. Defaults to False.
+            html: Whether to format as HTML.
 
         Returns:
             Human-readable representation.

langchain_core/prompts/prompt.py

@@ -2,9 +2,8 @@
 
 from __future__ import annotations
 
-import warnings
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel, model_validator
 from typing_extensions import override
@@ -45,18 +44,16 @@ class PromptTemplate(StringPromptTemplate):
         from untrusted sources.
 
     Example:
+        ```python
+        from langchain_core.prompts import PromptTemplate
 
-        .. code-block:: python
-
-            from langchain_core.prompts import PromptTemplate
-
-            # Instantiation using from_template (recommended)
-            prompt = PromptTemplate.from_template("Say {foo}")
-            prompt.format(foo="bar")
-
-            # Instantiation using initializer
-            prompt = PromptTemplate(template="Say {foo}")
+        # Instantiation using from_template (recommended)
+        prompt = PromptTemplate.from_template("Say {foo}")
+        prompt.format(foo="bar")
 
+        # Instantiation using initializer
+        prompt = PromptTemplate(template="Say {foo}")
+        ```
     """
 
     @property
@@ -69,10 +66,10 @@ class PromptTemplate(StringPromptTemplate):
     @classmethod
     @override
     def get_lc_namespace(cls) -> list[str]:
-        """Get the namespace of the langchain object.
+        """Get the namespace of the LangChain object.
 
         Returns:
-            ``["langchain", "prompts", "prompt"]``
+            `["langchain", "prompts", "prompt"]`
         """
         return ["langchain", "prompts", "prompt"]
 
@@ -145,10 +142,10 @@ class PromptTemplate(StringPromptTemplate):
         Raises:
             ValueError: If the template formats are not f-string or if there are
                 conflicting partial variables.
-            NotImplementedError: If the other object is not a ``PromptTemplate`` or str.
+            NotImplementedError: If the other object is not a `PromptTemplate` or str.
 
         Returns:
-            A new ``PromptTemplate`` that is the combination of the two.
+            A new `PromptTemplate` that is the combination of the two.
         """
         # Allow for easy combining
         if isinstance(other, PromptTemplate):
@@ -192,7 +189,7 @@ class PromptTemplate(StringPromptTemplate):
         """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.
@@ -223,7 +220,7 @@ class PromptTemplate(StringPromptTemplate):
             example_separator: The separator to use in between examples. Defaults
                 to two new line characters.
             prefix: String that should go before any examples. Generally includes
-                examples. Default to an empty string.
+                examples.
 
         Returns:
             The final prompt generated.
@@ -234,32 +231,21 @@ class PromptTemplate(StringPromptTemplate):
     @classmethod
     def from_file(
         cls,
-        template_file: Union[str, Path],
-        input_variables: Optional[list[str]] = None,
-        encoding: Optional[str] = None,
+        template_file: str | Path,
+        encoding: str | None = None,
         **kwargs: Any,
     ) -> PromptTemplate:
         """Load a prompt from a file.
 
         Args:
             template_file: The path to the file containing the prompt template.
-            input_variables: [DEPRECATED] A list of variable names the final prompt
-                template will expect. Defaults to None.
             encoding: The encoding system for opening the template file.
                 If not provided, will use the OS default.
 
-        input_variables is ignored as from_file now delegates to from_template().
-
         Returns:
             The prompt loaded from the file.
         """
         template = Path(template_file).read_text(encoding=encoding)
-        if input_variables:
-            warnings.warn(
-                "`input_variables' is deprecated and ignored.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
         return cls.from_template(template=template, **kwargs)
 
     @classmethod
@@ -268,7 +254,7 @@ class PromptTemplate(StringPromptTemplate):
         template: str,
         *,
         template_format: PromptTemplateFormat = "f-string",
-        partial_variables: Optional[dict[str, Any]] = None,
+        partial_variables: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> PromptTemplate:
         """Load a prompt template from a template.
@@ -289,14 +275,13 @@ class PromptTemplate(StringPromptTemplate):
         Args:
             template: The template to load.
             template_format: The format of the template. Use `jinja2` for jinja2,
-                             `mustache` for mustache, and `f-string` for f-strings.
-                             Defaults to `f-string`.
+                `mustache` for mustache, and `f-string` for f-strings.
             partial_variables: A dictionary of variables that can be used to partially
-                               fill in the template. For example, if the template is
-                              `"{variable1} {variable2}"`, and `partial_variables` is
-                              `{"variable1": "foo"}`, then the final prompt will be
-                              `"foo {variable2}"`. Defaults to None.
-            kwargs: Any other arguments to pass to the prompt template.
+                fill in the template. For example, if the template is
+                `"{variable1} {variable2}"`, and `partial_variables` is
+                `{"variable1": "foo"}`, then the final prompt will be
+                `"foo {variable2}"`.
+            **kwargs: Any other arguments to pass to the prompt template.
 
         Returns:
             The prompt template loaded from the template.