langchain-core 1.0.0a8__py3-none-any.whl → 1.0.0rc1__py3-none-any.whl

langchain_core/prompts/few_shot.py

@@ -268,97 +268,90 @@ 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)

langchain_core/prompts/few_shot_with_templates.py

@@ -49,7 +49,7 @@ class FewShotPromptWithTemplates(StringPromptTemplate):
         """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.

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"] = []
@@ -52,7 +52,7 @@ class ImagePromptTemplate(BasePromptTemplate[ImageURL]):
         """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

@@ -139,7 +139,7 @@ def load_prompt(path: str | Path, encoding: str | None = None) -> BasePromptTemp
 
     Args:
         path: Path to the prompt file.
-        encoding: Encoding of the file. Defaults to None.
+        encoding: Encoding of the file.
 
     Returns:
         A PromptTemplate object.

langchain_core/prompts/message.py

@@ -26,7 +26,7 @@ class BaseMessagePromptTemplate(Serializable, ABC):
         """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. Defaults to `False`.
 
         Returns:
             Human-readable representation.

langchain_core/prompts/prompt.py

@@ -44,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
@@ -71,7 +69,7 @@ class PromptTemplate(StringPromptTemplate):
         """Get the namespace of the langchain object.
 
         Returns:
-            ``["langchain", "prompts", "prompt"]``
+            `["langchain", "prompts", "prompt"]`
         """
         return ["langchain", "prompts", "prompt"]
 
@@ -144,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):
@@ -191,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.
@@ -283,8 +281,8 @@ class PromptTemplate(StringPromptTemplate):
                                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.
+                              `"foo {variable2}"`.
+            **kwargs: Any other arguments to pass to the prompt template.
 
         Returns:
             The prompt template loaded from the template.

langchain_core/prompts/string.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import warnings
 from abc import ABC
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from string import Formatter
 from typing import Any, Literal
 
@@ -149,9 +149,7 @@ def mustache_template_vars(
 Defs = dict[str, "Defs"]
 
 
-def mustache_schema(
-    template: str,
-) -> type[BaseModel]:
+def mustache_schema(template: str) -> type[BaseModel]:
     """Get the variables from a mustache template.
 
     Args:
@@ -175,6 +173,11 @@ def mustache_schema(
             fields[prefix] = False
         elif type_ in {"variable", "no escape"}:
             fields[prefix + tuple(key.split("."))] = True
+
+    for fkey, fval in fields.items():
+        fields[fkey] = fval and not any(
+            is_subsequence(fkey, k) for k in fields if k != fkey
+        )
     defs: Defs = {}  # None means leaf node
     while fields:
         field, is_leaf = fields.popitem()
@@ -276,7 +279,7 @@ class StringPromptTemplate(BasePromptTemplate, ABC):
         """Get the namespace of the langchain object.
 
         Returns:
-            ``["langchain", "prompts", "base"]``
+            `["langchain", "prompts", "base"]`
         """
         return ["langchain", "prompts", "base"]
 
@@ -284,7 +287,7 @@ class StringPromptTemplate(BasePromptTemplate, ABC):
         """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.
@@ -295,7 +298,7 @@ class StringPromptTemplate(BasePromptTemplate, ABC):
         """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.
@@ -327,3 +330,12 @@ class StringPromptTemplate(BasePromptTemplate, ABC):
     def pretty_print(self) -> None:
         """Print a pretty representation of the prompt."""
         print(self.pretty_repr(html=is_interactive_env()))  # noqa: T201
+
+
+def is_subsequence(child: Sequence, parent: Sequence) -> bool:
+    """Return True if child is subsequence of parent."""
+    if len(child) == 0 or len(parent) == 0:
+        return False
+    if len(parent) < len(child):
+        return False
+    return all(child[i] == parent[i] for i in range(len(child)))

langchain_core/prompts/structured.py

@@ -65,8 +65,8 @@ class StructuredPrompt(ChatPromptTemplate):
     def get_lc_namespace(cls) -> list[str]:
         """Get the namespace of the langchain object.
 
-        For example, if the class is ``langchain.llms.openai.OpenAI``, then the
-        namespace is ``["langchain", "llms", "openai"]``
+        For example, if the class is `langchain.llms.openai.OpenAI`, then the
+        namespace is `["langchain", "llms", "openai"]`
 
         Returns:
             The namespace of the langchain object.
@@ -85,35 +85,34 @@ class StructuredPrompt(ChatPromptTemplate):
         Examples:
             Instantiation from a list of message templates:
 
-            .. code-block:: python
+            ```python
+            from langchain_core.prompts import StructuredPrompt
 
-                from langchain_core.prompts import StructuredPrompt
 
+            class OutputSchema(BaseModel):
+                name: str
+                value: int
 
-                class OutputSchema(BaseModel):
-                    name: str
-                    value: int
-
-
-                template = StructuredPrompt(
-                    [
-                        ("human", "Hello, how are you?"),
-                        ("ai", "I'm doing well, thanks!"),
-                        ("human", "That's good to hear."),
-                    ],
-                    OutputSchema,
-                )
 
+            template = StructuredPrompt(
+                [
+                    ("human", "Hello, how are you?"),
+                    ("ai", "I'm doing well, thanks!"),
+                    ("human", "That's good to hear."),
+                ],
+                OutputSchema,
+            )
+            ```
         Args:
             messages: sequence of message representations.
-                  A message can be represented using the following formats:
-                  (1) BaseMessagePromptTemplate, (2) BaseMessage, (3) 2-tuple of
-                  (message type, template); e.g., ("human", "{user_input}"),
-                  (4) 2-tuple of (message class, template), (5) a string which is
-                  shorthand for ("human", template); e.g., "{user_input}"
+                A message can be represented using the following formats:
+                (1) BaseMessagePromptTemplate, (2) BaseMessage, (3) 2-tuple of
+                (message type, template); e.g., ("human", "{user_input}"),
+                (4) 2-tuple of (message class, template), (5) a string which is
+                shorthand for ("human", template); e.g., "{user_input}"
             schema: a dictionary representation of function call, or a Pydantic model.
-            kwargs: Any additional kwargs to pass through to
-                ``ChatModel.with_structured_output(schema, **kwargs)``.
+            **kwargs: Any additional kwargs to pass through to
+                `ChatModel.with_structured_output(schema, **kwargs)`.
 
         Returns:
             a structured prompt template
@@ -145,7 +144,7 @@ class StructuredPrompt(ChatPromptTemplate):
 
         Args:
             others: The language model to pipe the structured prompt to.
-            name: The name of the pipeline. Defaults to None.
+            name: The name of the pipeline.
 
         Returns:
             A RunnableSequence object.

langchain_core/rate_limiters.py

@@ -39,12 +39,12 @@ class BaseRateLimiter(abc.ABC):
         of the attempt to acquire the tokens.
 
         Args:
-            blocking: If True, the method will block until the tokens are available.
-                If False, the method will return immediately with the result of
-                the attempt. Defaults to True.
+            blocking: If `True`, the method will block until the tokens are available.
+                If `False`, the method will return immediately with the result of
+                the attempt. Defaults to `True`.
 
         Returns:
-           True if the tokens were successfully acquired, False otherwise.
+           `True` if the tokens were successfully acquired, `False` otherwise.
         """
 
     @abc.abstractmethod
@@ -58,12 +58,12 @@ class BaseRateLimiter(abc.ABC):
         of the attempt to acquire the tokens.
 
         Args:
-            blocking: If True, the method will block until the tokens are available.
-                If False, the method will return immediately with the result of
-                the attempt. Defaults to True.
+            blocking: If `True`, the method will block until the tokens are available.
+                If `False`, the method will return immediately with the result of
+                the attempt. Defaults to `True`.
 
         Returns:
-           True if the tokens were successfully acquired, False otherwise.
+           `True` if the tokens were successfully acquired, `False` otherwise.
         """
 
 
@@ -90,36 +90,34 @@ class InMemoryRateLimiter(BaseRateLimiter):
     Current limitations:
 
     - The rate limiter is not designed to work across different processes. It is
-      an in-memory rate limiter, but it is thread safe.
+        an in-memory rate limiter, but it is thread safe.
     - The rate limiter only supports time-based rate limiting. It does not take
-      into account the size of the request or any other factors.
+        into account the size of the request or any other factors.
 
     Example:
+        ```python
+        import time
 
-        .. code-block:: python
+        from langchain_core.rate_limiters import InMemoryRateLimiter
 
-            import time
+        rate_limiter = InMemoryRateLimiter(
+            requests_per_second=0.1,  # <-- Can only make a request once every 10 seconds!!
+            check_every_n_seconds=0.1,  # Wake up every 100 ms to check whether allowed to make a request,
+            max_bucket_size=10,  # Controls the maximum burst size.
+        )
 
-            from langchain_core.rate_limiters import InMemoryRateLimiter
+        from langchain_anthropic import ChatAnthropic
 
-            rate_limiter = InMemoryRateLimiter(
-                requests_per_second=0.1,  # <-- Can only make a request once every 10 seconds!!
-                check_every_n_seconds=0.1,  # Wake up every 100 ms to check whether allowed to make a request,
-                max_bucket_size=10,  # Controls the maximum burst size.
-            )
-
-            from langchain_anthropic import ChatAnthropic
-
-            model = ChatAnthropic(
-                model_name="claude-3-opus-20240229", rate_limiter=rate_limiter
-            )
-
-            for _ in range(5):
-                tic = time.time()
-                model.invoke("hello")
-                toc = time.time()
-                print(toc - tic)
+        model = ChatAnthropic(
+            model_name="claude-3-opus-20240229", rate_limiter=rate_limiter
+        )
 
+        for _ in range(5):
+            tic = time.time()
+            model.invoke("hello")
+            toc = time.time()
+            print(toc - tic)
+        ```
 
     !!! version-added "Added in version 0.2.24"
 
@@ -207,12 +205,12 @@ class InMemoryRateLimiter(BaseRateLimiter):
         of the attempt to acquire the tokens.
 
         Args:
-            blocking: If True, the method will block until the tokens are available.
-                If False, the method will return immediately with the result of
-                the attempt. Defaults to True.
+            blocking: If `True`, the method will block until the tokens are available.
+                If `False`, the method will return immediately with the result of
+                the attempt. Defaults to `True`.
 
         Returns:
-           True if the tokens were successfully acquired, False otherwise.
+           `True` if the tokens were successfully acquired, `False` otherwise.
         """
         if not blocking:
             return self._consume()
@@ -231,12 +229,12 @@ class InMemoryRateLimiter(BaseRateLimiter):
         of the attempt to acquire the tokens.
 
         Args:
-            blocking: If True, the method will block until the tokens are available.
-                If False, the method will return immediately with the result of
-                the attempt. Defaults to True.
+            blocking: If `True`, the method will block until the tokens are available.
+                If `False`, the method will return immediately with the result of
+                the attempt. Defaults to `True`.
 
         Returns:
-           True if the tokens were successfully acquired, False otherwise.
+           `True` if the tokens were successfully acquired, `False` otherwise.
         """
         if not blocking:
             return self._consume()