langchain-core 1.0.0a1__py3-none-any.whl → 1.0.0a3__py3-none-any.whl

langchain_core/prompts/few_shot.py

@@ -117,7 +117,7 @@ class FewShotPromptTemplate(_FewShotPromptTemplateMixin, StringPromptTemplate):
 
     @classmethod
     def is_lc_serializable(cls) -> bool:
-        """Return whether or not the class is serializable."""
+        """Return False as this class is not serializable."""
         return False
 
     validate_template: bool = False
@@ -153,7 +153,7 @@ class FewShotPromptTemplate(_FewShotPromptTemplateMixin, StringPromptTemplate):
                 self.template_format,
                 self.input_variables + list(self.partial_variables),
             )
-        elif self.template_format or None:
+        elif self.template_format:
             self.input_variables = [
                 var
                 for var in get_template_variables(
@@ -272,7 +272,7 @@ class FewShotChatMessagePromptTemplate(
 
             from langchain_core.prompts import (
                 FewShotChatMessagePromptTemplate,
-                ChatPromptTemplate
+                ChatPromptTemplate,
             )
 
             examples = [
@@ -281,7 +281,7 @@ class FewShotChatMessagePromptTemplate(
             ]
 
             example_prompt = ChatPromptTemplate.from_messages(
-            [('human', 'What is {input}?'), ('ai', '{output}')]
+                [("human", "What is {input}?"), ("ai", "{output}")]
             )
 
             few_shot_prompt = FewShotChatMessagePromptTemplate(
@@ -292,9 +292,9 @@ class FewShotChatMessagePromptTemplate(
 
             final_prompt = ChatPromptTemplate.from_messages(
                 [
-                    ('system', 'You are a helpful AI Assistant'),
+                    ("system", "You are a helpful AI Assistant"),
                     few_shot_prompt,
-                    ('human', '{input}'),
+                    ("human", "{input}"),
                 ]
             )
             final_prompt.format(input="What is 4+4?")
@@ -314,10 +314,7 @@ class FewShotChatMessagePromptTemplate(
                 # ...
             ]
 
-            to_vectorize = [
-                " ".join(example.values())
-                for example in examples
-            ]
+            to_vectorize = [" ".join(example.values()) for example in examples]
             embeddings = OpenAIEmbeddings()
             vectorstore = Chroma.from_texts(
                 to_vectorize, embeddings, metadatas=examples
@@ -355,6 +352,7 @@ class FewShotChatMessagePromptTemplate(
 
             # 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?"})
 
@@ -369,7 +367,7 @@ class FewShotChatMessagePromptTemplate(
 
     @classmethod
     def is_lc_serializable(cls) -> bool:
-        """Return whether or not the class is serializable."""
+        """Return False as this class is not serializable."""
         return False
 
     model_config = ConfigDict(

langchain_core/prompts/few_shot_with_templates.py

@@ -46,7 +46,11 @@ 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"]``
+        """
         return ["langchain", "prompts", "few_shot_with_templates"]
 
     @model_validator(mode="before")

langchain_core/prompts/image.py

@@ -23,7 +23,12 @@ class ImagePromptTemplate(BasePromptTemplate[ImageURL]):
     Options are: 'f-string', 'mustache', 'jinja2'."""
 
     def __init__(self, **kwargs: Any) -> None:
-        """Create an image prompt template."""
+        """Create an image prompt template.
+
+        Raises:
+            ValueError: If the input variables contain ``'url'``, ``'path'``, or
+                ``'detail'``.
+        """
         if "input_variables" not in kwargs:
             kwargs["input_variables"] = []
 
@@ -44,7 +49,11 @@ 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"]``
+        """
         return ["langchain", "prompts", "image"]
 
     def format_prompt(self, **kwargs: Any) -> PromptValue:
@@ -84,6 +93,7 @@ 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.
 
         Example:
 
@@ -128,9 +138,6 @@ class ImagePromptTemplate(BasePromptTemplate[ImageURL]):
 
         Returns:
             A formatted string.
-
-        Raises:
-            ValueError: If the path or url is not a string.
         """
         return await run_in_executor(None, self.format, **kwargs)
 

langchain_core/prompts/loading.py

@@ -53,7 +53,7 @@ def _load_template(var_name: str, config: dict) -> dict:
         template_path = Path(config.pop(f"{var_name}_path"))
         # Load the template.
         if template_path.suffix == ".txt":
-            template = template_path.read_text()
+            template = template_path.read_text(encoding="utf-8")
         else:
             raise ValueError
         # Set the template variable to the extracted variable.
@@ -67,7 +67,7 @@ def _load_examples(config: dict) -> dict:
         pass
     elif isinstance(config["examples"], str):
         path = Path(config["examples"])
-        with path.open() as f:
+        with path.open(encoding="utf-8") as f:
             if path.suffix == ".json":
                 examples = json.load(f)
             elif path.suffix in {".yaml", ".yml"}:

langchain_core/prompts/message.py

@@ -18,17 +18,15 @@ class BaseMessagePromptTemplate(Serializable, ABC):
 
     @classmethod
     def is_lc_serializable(cls) -> bool:
-        """Return whether or not the class is serializable.
-
-        Returns: 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.
 
-        Default namespace is ["langchain", "prompts", "chat"].
+        Returns:
+            ``["langchain", "prompts", "chat"]``
         """
         return ["langchain", "prompts", "chat"]
 
@@ -90,7 +88,8 @@ class BaseMessagePromptTemplate(Serializable, ABC):
         Returns:
             Combined prompt template.
         """
-        from langchain_core.prompts.chat import ChatPromptTemplate
+        # Import locally to avoid circular import.
+        from langchain_core.prompts.chat import ChatPromptTemplate  # noqa: PLC0415
 
         prompt = ChatPromptTemplate(messages=[self])
         return prompt + other

langchain_core/prompts/pipeline.py

@@ -39,23 +39,28 @@ class PipelinePromptTemplate(BasePromptTemplate):
     This can be useful when you want to reuse parts of prompts.
 
     A PipelinePrompt consists of two main parts:
-        - final_prompt: This is the final prompt that is returned
-        - pipeline_prompts: This is a list of tuples, consisting
-          of a string (`name`) and a Prompt Template.
-          Each PromptTemplate will be formatted and then passed
-          to future prompt templates as a variable with
-          the same name as `name`
+
+    - final_prompt: This is the final prompt that is returned
+    - pipeline_prompts: This is a list of tuples, consisting
+      of a string (``name``) and a Prompt Template.
+      Each PromptTemplate will be formatted and then passed
+      to future prompt templates as a variable with
+      the same name as ``name``
 
     """
 
     final_prompt: BasePromptTemplate
     """The final prompt that is returned."""
     pipeline_prompts: list[tuple[str, BasePromptTemplate]]
-    """A list of tuples, consisting of a string (`name`) and a Prompt Template."""
+    """A list of tuples, consisting of a string (``name``) and a Prompt Template."""
 
     @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", "pipeline"]``
+        """
         return ["langchain", "prompts", "pipeline"]
 
     @model_validator(mode="before")

langchain_core/prompts/prompt.py

@@ -69,6 +69,11 @@ class PromptTemplate(StringPromptTemplate):
     @classmethod
     @override
     def get_lc_namespace(cls) -> list[str]:
+        """Get the namespace of the langchain object.
+
+        Returns:
+            ``["langchain", "prompts", "prompt"]``
+        """
         return ["langchain", "prompts", "prompt"]
 
     template: str
@@ -135,14 +140,20 @@ class PromptTemplate(StringPromptTemplate):
         return mustache_schema(self.template)
 
     def __add__(self, other: Any) -> PromptTemplate:
-        """Override the + operator to allow for combining prompt templates."""
+        """Override the + operator to allow for combining prompt templates.
+
+        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.
+
+        Returns:
+            A new ``PromptTemplate`` that is the combination of the two.
+        """
         # Allow for easy combining
         if isinstance(other, PromptTemplate):
-            if self.template_format != "f-string":
-                msg = "Adding prompt templates only supported for f-strings."
-                raise ValueError(msg)
-            if other.template_format != "f-string":
-                msg = "Adding prompt templates only supported for f-strings."
+            if self.template_format != other.template_format:
+                msg = "Cannot add templates of different formats"
                 raise ValueError(msg)
             input_variables = list(
                 set(self.input_variables) | set(other.input_variables)
@@ -160,11 +171,14 @@ class PromptTemplate(StringPromptTemplate):
                 template=template,
                 input_variables=input_variables,
                 partial_variables=partial_variables,
-                template_format="f-string",
+                template_format=self.template_format,
                 validate_template=validate_template,
             )
         if isinstance(other, str):
-            prompt = PromptTemplate.from_template(other)
+            prompt = PromptTemplate.from_template(
+                other,
+                template_format=self.template_format,
+            )
             return self + prompt
         msg = f"Unsupported operand type for +: {type(other)}"
         raise NotImplementedError(msg)

langchain_core/prompts/string.py

@@ -15,6 +15,14 @@ from langchain_core.utils import get_colored_text, mustache
 from langchain_core.utils.formatting import formatter
 from langchain_core.utils.interactive_env import is_interactive_env
 
+try:
+    from jinja2 import Environment, meta
+    from jinja2.sandbox import SandboxedEnvironment
+
+    _HAS_JINJA2 = True
+except ImportError:
+    _HAS_JINJA2 = False
+
 PromptTemplateFormat = Literal["f-string", "mustache", "jinja2"]
 
 
@@ -40,9 +48,7 @@ def jinja2_formatter(template: str, /, **kwargs: Any) -> str:
     Raises:
         ImportError: If jinja2 is not installed.
     """
-    try:
-        from jinja2.sandbox import SandboxedEnvironment
-    except ImportError as e:
+    if not _HAS_JINJA2:
         msg = (
             "jinja2 not installed, which is needed to use the jinja2_formatter. "
             "Please install it with `pip install jinja2`."
@@ -50,7 +56,7 @@ def jinja2_formatter(template: str, /, **kwargs: Any) -> str:
             "Do not expand jinja2 templates using unverified or user-controlled "
             "inputs as that can result in arbitrary Python code execution."
         )
-        raise ImportError(msg) from e
+        raise ImportError(msg)
 
     # This uses a sandboxed environment to prevent arbitrary code execution.
     # Jinja2 uses an opt-out rather than opt-in approach for sand-boxing.
@@ -88,14 +94,12 @@ def validate_jinja2(template: str, input_variables: list[str]) -> None:
 
 
 def _get_jinja2_variables_from_template(template: str) -> set[str]:
-    try:
-        from jinja2 import Environment, meta
-    except ImportError as e:
+    if not _HAS_JINJA2:
         msg = (
             "jinja2 not installed, which is needed to use the jinja2_formatter. "
             "Please install it with `pip install jinja2`."
         )
-        raise ImportError(msg) from e
+        raise ImportError(msg)
     env = Environment()  # noqa: S701
     ast = env.parse(template)
     return meta.find_undeclared_variables(ast)
@@ -166,7 +170,7 @@ def mustache_schema(
                 prefix = section_stack.pop()
         elif type_ in {"section", "inverted section"}:
             section_stack.append(prefix)
-            prefix = prefix + tuple(key.split("."))
+            prefix += tuple(key.split("."))
             fields[prefix] = False
         elif type_ in {"variable", "no escape"}:
             fields[prefix + tuple(key.split("."))] = True
@@ -268,7 +272,11 @@ class StringPromptTemplate(BasePromptTemplate, 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", "base"]``
+        """
         return ["langchain", "prompts", "base"]
 
     def format_prompt(self, **kwargs: Any) -> PromptValue:

langchain_core/prompts/structured.py

@@ -68,8 +68,11 @@ 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.
         """
         return cls.__module__.split(".")
 
@@ -89,10 +92,12 @@ class StructuredPrompt(ChatPromptTemplate):
 
                 from langchain_core.prompts import StructuredPrompt
 
+
                 class OutputSchema(BaseModel):
                     name: str
                     value: int
 
+
                 template = StructuredPrompt(
                     [
                         ("human", "Hello, how are you?"),

langchain_core/rate_limiters.py

@@ -110,9 +110,9 @@ class InMemoryRateLimiter(BaseRateLimiter):
             )
 
             from langchain_anthropic import ChatAnthropic
+
             model = ChatAnthropic(
-                model_name="claude-3-opus-20240229",
-                rate_limiter=rate_limiter
+                model_name="claude-3-opus-20240229", rate_limiter=rate_limiter
             )
 
             for _ in range(5):

langchain_core/retrievers.py

@@ -31,6 +31,7 @@ from typing_extensions import Self, TypedDict, override
 
 from langchain_core._api import deprecated
 from langchain_core.callbacks import Callbacks
+from langchain_core.callbacks.manager import AsyncCallbackManager, CallbackManager
 from langchain_core.documents import Document
 from langchain_core.runnables import (
     Runnable,
@@ -109,6 +110,7 @@ class BaseRetriever(RunnableSerializable[RetrieverInput, RetrieverOutput], ABC):
 
             from sklearn.metrics.pairwise import cosine_similarity
 
+
             class TFIDFRetriever(BaseRetriever, BaseModel):
                 vectorizer: Any
                 docs: list[Document]
@@ -122,10 +124,12 @@ class BaseRetriever(RunnableSerializable[RetrieverInput, RetrieverOutput], ABC):
                     # Ip -- (n_docs,x), Op -- (n_docs,n_Feats)
                     query_vec = self.vectorizer.transform([query])
                     # Op -- (n_docs,1) -- Cosine Sim with each doc
-                    results = cosine_similarity(self.tfidf_array, query_vec).reshape((-1,))
+                    results = cosine_similarity(self.tfidf_array, query_vec).reshape(
+                        (-1,)
+                    )
                     return [self.docs[i] for i in results.argsort()[-self.k :][::-1]]
 
-    """  # noqa: E501
+    """
 
     model_config = ConfigDict(
         arbitrary_types_allowed=True,
@@ -233,8 +237,6 @@ class BaseRetriever(RunnableSerializable[RetrieverInput, RetrieverOutput], ABC):
             retriever.invoke("query")
 
         """
-        from langchain_core.callbacks.manager import CallbackManager
-
         config = ensure_config(config)
         inheritable_metadata = {
             **(config.get("metadata") or {}),
@@ -298,8 +300,6 @@ class BaseRetriever(RunnableSerializable[RetrieverInput, RetrieverOutput], ABC):
             await retriever.ainvoke("query")
 
         """
-        from langchain_core.callbacks.manager import AsyncCallbackManager
-
         config = ensure_config(config)
         inheritable_metadata = {
             **(config.get("metadata") or {}),
@@ -359,6 +359,7 @@ class BaseRetriever(RunnableSerializable[RetrieverInput, RetrieverOutput], ABC):
         Args:
             query: String to find relevant documents for
             run_manager: The callback handler to use
+
         Returns:
             List of relevant documents
         """