langchain 0.3.26__py3-none-any.whl → 0.4.0.dev0__py3-none-any.whl

langchain/output_parsers/retry.py

@@ -9,7 +9,7 @@ from langchain_core.prompt_values import PromptValue
 from langchain_core.prompts import BasePromptTemplate, PromptTemplate
 from langchain_core.runnables import RunnableSerializable
 from pydantic import SkipValidation
-from typing_extensions import TypedDict
+from typing_extensions import TypedDict, override
 
 NAIVE_COMPLETION_RETRY = """Prompt:
 {prompt}
@@ -30,18 +30,22 @@ Please try again:"""
 
 NAIVE_RETRY_PROMPT = PromptTemplate.from_template(NAIVE_COMPLETION_RETRY)
 NAIVE_RETRY_WITH_ERROR_PROMPT = PromptTemplate.from_template(
-    NAIVE_COMPLETION_RETRY_WITH_ERROR
+    NAIVE_COMPLETION_RETRY_WITH_ERROR,
 )
 
 T = TypeVar("T")
 
 
 class RetryOutputParserRetryChainInput(TypedDict):
+    """Retry chain input for RetryOutputParser."""
+
     prompt: str
     completion: str
 
 
 class RetryWithErrorOutputParserRetryChainInput(TypedDict):
+    """Retry chain input for RetryWithErrorOutputParser."""
+
     prompt: str
     completion: str
     error: str
@@ -104,25 +108,25 @@ class RetryOutputParser(BaseOutputParser[T]):
         while retries <= self.max_retries:
             try:
                 return self.parser.parse(completion)
-            except OutputParserException as e:
+            except OutputParserException:
                 if retries == self.max_retries:
-                    raise e
+                    raise
+                retries += 1
+                if self.legacy and hasattr(self.retry_chain, "run"):
+                    completion = self.retry_chain.run(
+                        prompt=prompt_value.to_string(),
+                        completion=completion,
+                    )
                 else:
-                    retries += 1
-                    if self.legacy and hasattr(self.retry_chain, "run"):
-                        completion = self.retry_chain.run(
-                            prompt=prompt_value.to_string(),
-                            completion=completion,
-                        )
-                    else:
-                        completion = self.retry_chain.invoke(
-                            dict(
-                                prompt=prompt_value.to_string(),
-                                completion=completion,
-                            )
-                        )
-
-        raise OutputParserException("Failed to parse")
+                    completion = self.retry_chain.invoke(
+                        {
+                            "prompt": prompt_value.to_string(),
+                            "completion": completion,
+                        },
+                    )
+
+        msg = "Failed to parse"
+        raise OutputParserException(msg)
 
     async def aparse_with_prompt(self, completion: str, prompt_value: PromptValue) -> T:
         """Parse the output of an LLM call using a wrapped parser.
@@ -141,30 +145,31 @@ class RetryOutputParser(BaseOutputParser[T]):
                 return await self.parser.aparse(completion)
             except OutputParserException as e:
                 if retries == self.max_retries:
-                    raise e
+                    raise
+                retries += 1
+                if self.legacy and hasattr(self.retry_chain, "arun"):
+                    completion = await self.retry_chain.arun(
+                        prompt=prompt_value.to_string(),
+                        completion=completion,
+                        error=repr(e),
+                    )
                 else:
-                    retries += 1
-                    if self.legacy and hasattr(self.retry_chain, "arun"):
-                        completion = await self.retry_chain.arun(
-                            prompt=prompt_value.to_string(),
-                            completion=completion,
-                            error=repr(e),
-                        )
-                    else:
-                        completion = await self.retry_chain.ainvoke(
-                            dict(
-                                prompt=prompt_value.to_string(),
-                                completion=completion,
-                            )
-                        )
-
-        raise OutputParserException("Failed to parse")
+                    completion = await self.retry_chain.ainvoke(
+                        {
+                            "prompt": prompt_value.to_string(),
+                            "completion": completion,
+                        },
+                    )
 
+        msg = "Failed to parse"
+        raise OutputParserException(msg)
+
+    @override
     def parse(self, completion: str) -> T:
-        raise NotImplementedError(
-            "This OutputParser can only be called by the `parse_with_prompt` method."
-        )
+        msg = "This OutputParser can only be called by the `parse_with_prompt` method."
+        raise NotImplementedError(msg)
 
+    @override
     def get_format_instructions(self) -> str:
         return self.parser.get_format_instructions()
 
@@ -173,6 +178,7 @@ class RetryOutputParser(BaseOutputParser[T]):
         return "retry"
 
     @property
+    @override
     def OutputType(self) -> type[T]:
         return self.parser.OutputType
 
@@ -192,7 +198,8 @@ class RetryWithErrorOutputParser(BaseOutputParser[T]):
     # Should be an LLMChain but we want to avoid top-level imports from langchain.chains
     retry_chain: Annotated[
         Union[
-            RunnableSerializable[RetryWithErrorOutputParserRetryChainInput, str], Any
+            RunnableSerializable[RetryWithErrorOutputParserRetryChainInput, str],
+            Any,
         ],
         SkipValidation(),
     ]
@@ -224,6 +231,7 @@ class RetryWithErrorOutputParser(BaseOutputParser[T]):
         chain = prompt | llm | StrOutputParser()
         return cls(parser=parser, retry_chain=chain, max_retries=max_retries)
 
+    @override
     def parse_with_prompt(self, completion: str, prompt_value: PromptValue) -> T:
         retries = 0
 
@@ -232,27 +240,36 @@ class RetryWithErrorOutputParser(BaseOutputParser[T]):
                 return self.parser.parse(completion)
             except OutputParserException as e:
                 if retries == self.max_retries:
-                    raise e
+                    raise
+                retries += 1
+                if self.legacy and hasattr(self.retry_chain, "run"):
+                    completion = self.retry_chain.run(
+                        prompt=prompt_value.to_string(),
+                        completion=completion,
+                        error=repr(e),
+                    )
                 else:
-                    retries += 1
-                    if self.legacy and hasattr(self.retry_chain, "run"):
-                        completion = self.retry_chain.run(
-                            prompt=prompt_value.to_string(),
-                            completion=completion,
-                            error=repr(e),
-                        )
-                    else:
-                        completion = self.retry_chain.invoke(
-                            dict(
-                                completion=completion,
-                                prompt=prompt_value.to_string(),
-                                error=repr(e),
-                            )
-                        )
-
-        raise OutputParserException("Failed to parse")
+                    completion = self.retry_chain.invoke(
+                        {
+                            "completion": completion,
+                            "prompt": prompt_value.to_string(),
+                            "error": repr(e),
+                        },
+                    )
+
+        msg = "Failed to parse"
+        raise OutputParserException(msg)
 
     async def aparse_with_prompt(self, completion: str, prompt_value: PromptValue) -> T:
+        """Parse the output of an LLM call using a wrapped parser.
+
+        Args:
+            completion: The chain completion to parse.
+            prompt_value: The prompt to use to parse the completion.
+
+        Returns:
+            The parsed completion.
+        """
         retries = 0
 
         while retries <= self.max_retries:
@@ -260,31 +277,32 @@ class RetryWithErrorOutputParser(BaseOutputParser[T]):
                 return await self.parser.aparse(completion)
             except OutputParserException as e:
                 if retries == self.max_retries:
-                    raise e
+                    raise
+                retries += 1
+                if self.legacy and hasattr(self.retry_chain, "arun"):
+                    completion = await self.retry_chain.arun(
+                        prompt=prompt_value.to_string(),
+                        completion=completion,
+                        error=repr(e),
+                    )
                 else:
-                    retries += 1
-                    if self.legacy and hasattr(self.retry_chain, "arun"):
-                        completion = await self.retry_chain.arun(
-                            prompt=prompt_value.to_string(),
-                            completion=completion,
-                            error=repr(e),
-                        )
-                    else:
-                        completion = await self.retry_chain.ainvoke(
-                            dict(
-                                prompt=prompt_value.to_string(),
-                                completion=completion,
-                                error=repr(e),
-                            )
-                        )
-
-        raise OutputParserException("Failed to parse")
-
+                    completion = await self.retry_chain.ainvoke(
+                        {
+                            "prompt": prompt_value.to_string(),
+                            "completion": completion,
+                            "error": repr(e),
+                        },
+                    )
+
+        msg = "Failed to parse"
+        raise OutputParserException(msg)
+
+    @override
     def parse(self, completion: str) -> T:
-        raise NotImplementedError(
-            "This OutputParser can only be called by the `parse_with_prompt` method."
-        )
+        msg = "This OutputParser can only be called by the `parse_with_prompt` method."
+        raise NotImplementedError(msg)
 
+    @override
     def get_format_instructions(self) -> str:
         return self.parser.get_format_instructions()
 
@@ -293,5 +311,6 @@ class RetryWithErrorOutputParser(BaseOutputParser[T]):
         return "retry_with_error"
 
     @property
+    @override
     def OutputType(self) -> type[T]:
         return self.parser.OutputType

langchain/output_parsers/structured.py

@@ -5,6 +5,7 @@ from typing import Any
 from langchain_core.output_parsers import BaseOutputParser
 from langchain_core.output_parsers.json import parse_and_check_json_markdown
 from pydantic import BaseModel
+from typing_extensions import override
 
 from langchain.output_parsers.format_instructions import (
     STRUCTURED_FORMAT_INSTRUCTIONS,
@@ -27,7 +28,9 @@ class ResponseSchema(BaseModel):
 
 def _get_sub_string(schema: ResponseSchema) -> str:
     return line_template.format(
-        name=schema.name, description=schema.description, type=schema.type
+        name=schema.name,
+        description=schema.description,
+        type=schema.type,
     )
 
 
@@ -39,11 +42,23 @@ class StructuredOutputParser(BaseOutputParser[dict[str, Any]]):
 
     @classmethod
     def from_response_schemas(
-        cls, response_schemas: list[ResponseSchema]
+        cls,
+        response_schemas: list[ResponseSchema],
     ) -> StructuredOutputParser:
+        """Create a StructuredOutputParser from a list of ResponseSchema.
+
+        Args:
+            response_schemas: The schemas for the response.
+
+        Returns:
+            An instance of StructuredOutputParser.
+        """
         return cls(response_schemas=response_schemas)
 
-    def get_format_instructions(self, only_json: bool = False) -> str:
+    def get_format_instructions(
+        self,
+        only_json: bool = False,  # noqa: FBT001,FBT002
+    ) -> str:
         """Get format instructions for the output parser.
 
         example:
@@ -85,13 +100,13 @@ class StructuredOutputParser(BaseOutputParser[dict[str, Any]]):
                 will be returned, without the introducing text. Defaults to False.
         """
         schema_str = "\n".join(
-            [_get_sub_string(schema) for schema in self.response_schemas]
+            [_get_sub_string(schema) for schema in self.response_schemas],
         )
         if only_json:
             return STRUCTURED_FORMAT_SIMPLE_INSTRUCTIONS.format(format=schema_str)
-        else:
-            return STRUCTURED_FORMAT_INSTRUCTIONS.format(format=schema_str)
+        return STRUCTURED_FORMAT_INSTRUCTIONS.format(format=schema_str)
 
+    @override
     def parse(self, text: str) -> dict[str, Any]:
         expected_keys = [rs.name for rs in self.response_schemas]
         return parse_and_check_json_markdown(text, expected_keys)

langchain/output_parsers/yaml.py

@@ -6,6 +6,7 @@ import yaml
 from langchain_core.exceptions import OutputParserException
 from langchain_core.output_parsers import BaseOutputParser
 from pydantic import BaseModel, ValidationError
+from typing_extensions import override
 
 from langchain.output_parsers.format_instructions import YAML_FORMAT_INSTRUCTIONS
 
@@ -18,36 +19,42 @@ class YamlOutputParser(BaseOutputParser[T]):
     pydantic_object: type[T]
     """The pydantic model to parse."""
     pattern: re.Pattern = re.compile(
-        r"^```(?:ya?ml)?(?P<yaml>[^`]*)", re.MULTILINE | re.DOTALL
+        r"^```(?:ya?ml)?(?P<yaml>[^`]*)",
+        re.MULTILINE | re.DOTALL,
     )
-    """Regex pattern to match yaml code blocks 
+    """Regex pattern to match yaml code blocks
     within triple backticks with optional yaml or yml prefix."""
 
+    @override
     def parse(self, text: str) -> T:
         try:
             # Greedy search for 1st yaml candidate.
             match = re.search(self.pattern, text.strip())
-            yaml_str = ""
-            if match:
-                yaml_str = match.group("yaml")
-            else:
-                # If no backticks were present, try to parse the entire output as yaml.
-                yaml_str = text
+            # If no backticks were present, try to parse the entire output as yaml.
+            yaml_str = match.group("yaml") if match else text
 
             json_object = yaml.safe_load(yaml_str)
             if hasattr(self.pydantic_object, "model_validate"):
                 return self.pydantic_object.model_validate(json_object)
-            else:
-                return self.pydantic_object.parse_obj(json_object)
+            return self.pydantic_object.parse_obj(json_object)
 
         except (yaml.YAMLError, ValidationError) as e:
             name = self.pydantic_object.__name__
             msg = f"Failed to parse {name} from completion {text}. Got: {e}"
             raise OutputParserException(msg, llm_output=text) from e
 
+    @override
     def get_format_instructions(self) -> str:
         # Copy schema to avoid altering original Pydantic schema.
-        schema = {k: v for k, v in self.pydantic_object.schema().items()}
+        if hasattr(self.pydantic_object, "model_json_schema"):
+            # Pydantic v2
+            schema = dict(self.pydantic_object.model_json_schema().items())
+        elif hasattr(self.pydantic_object, "schema"):
+            # Pydantic v1
+            schema = dict(self.pydantic_object.schema().items())
+        else:
+            msg = "Pydantic object must have either model_json_schema or schema method"
+            raise ValueError(msg)
 
         # Remove extraneous fields.
         reduced_schema = schema
@@ -65,5 +72,6 @@ class YamlOutputParser(BaseOutputParser[T]):
         return "yaml"
 
     @property
+    @override
     def OutputType(self) -> type[T]:
         return self.pydantic_object

langchain/prompts/__init__.py

@@ -65,7 +65,9 @@ if TYPE_CHECKING:
 # Used to consolidate logic for raising deprecation warnings and
 # handling optional imports.
 MODULE_LOOKUP = {
-    "NGramOverlapExampleSelector": "langchain_community.example_selectors.ngram_overlap"
+    "NGramOverlapExampleSelector": (
+        "langchain_community.example_selectors.ngram_overlap"
+    ),
 }
 
 _import_attribute = create_importer(__file__, module_lookup=MODULE_LOOKUP)
@@ -82,6 +84,7 @@ __all__ = [
     "BasePromptTemplate",
     "ChatMessagePromptTemplate",
     "ChatPromptTemplate",
+    "FewShotChatMessagePromptTemplate",
     "FewShotPromptTemplate",
     "FewShotPromptWithTemplates",
     "HumanMessagePromptTemplate",
@@ -90,11 +93,10 @@ __all__ = [
     "MessagesPlaceholder",
     "NGramOverlapExampleSelector",
     "PipelinePromptTemplate",
+    "Prompt",
     "PromptTemplate",
     "SemanticSimilarityExampleSelector",
     "StringPromptTemplate",
     "SystemMessagePromptTemplate",
     "load_prompt",
-    "FewShotChatMessagePromptTemplate",
-    "Prompt",
 ]

langchain/prompts/base.py

@@ -10,12 +10,12 @@ from langchain_core.prompts import (
 from langchain_core.prompts.string import _get_jinja2_variables_from_template
 
 __all__ = [
-    "jinja2_formatter",
-    "validate_jinja2",
-    "check_valid_template",
-    "get_template_variables",
-    "StringPromptTemplate",
     "BasePromptTemplate",
+    "StringPromptTemplate",
     "StringPromptValue",
     "_get_jinja2_variables_from_template",
+    "check_valid_template",
+    "get_template_variables",
+    "jinja2_formatter",
+    "validate_jinja2",
 ]

langchain/prompts/chat.py

@@ -16,22 +16,22 @@ from langchain_core.prompts.chat import (
 )
 
 __all__ = [
+    "AIMessagePromptTemplate",
+    "BaseChatPromptTemplate",
     "BaseMessagePromptTemplate",
-    "MessagesPlaceholder",
     "BaseStringMessagePromptTemplate",
     "ChatMessagePromptTemplate",
-    "HumanMessagePromptTemplate",
-    "AIMessagePromptTemplate",
-    "SystemMessagePromptTemplate",
-    "BaseChatPromptTemplate",
     "ChatPromptTemplate",
     "ChatPromptValue",
     "ChatPromptValueConcrete",
-    "_convert_to_message",
-    "_create_template_from_message_type",
-    "MessagePromptTemplateT",
+    "HumanMessagePromptTemplate",
     "MessageLike",
     "MessageLikeRepresentation",
+    "MessagePromptTemplateT",
+    "MessagesPlaceholder",
+    "SystemMessagePromptTemplate",
+    "_convert_to_message",
+    "_create_template_from_message_type",
 ]
 
 from langchain_core.prompts.message import BaseMessagePromptTemplate

langchain/prompts/example_selector/__init__.py

@@ -21,7 +21,9 @@ if TYPE_CHECKING:
 # Used to consolidate logic for raising deprecation warnings and
 # handling optional imports.
 DEPRECATED_LOOKUPS = {
-    "NGramOverlapExampleSelector": "langchain_community.example_selectors.ngram_overlap"
+    "NGramOverlapExampleSelector": (
+        "langchain_community.example_selectors.ngram_overlap"
+    ),
 }
 
 _import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUPS)

langchain/prompts/example_selector/semantic_similarity.py

@@ -5,7 +5,7 @@ from langchain_core.example_selectors.semantic_similarity import (
 )
 
 __all__ = [
-    "sorted_values",
-    "SemanticSimilarityExampleSelector",
     "MaxMarginalRelevanceExampleSelector",
+    "SemanticSimilarityExampleSelector",
+    "sorted_values",
 ]

langchain/prompts/few_shot.py

@@ -5,7 +5,7 @@ from langchain_core.prompts.few_shot import (
 )
 
 __all__ = [
-    "FewShotPromptTemplate",
     "FewShotChatMessagePromptTemplate",
+    "FewShotPromptTemplate",
     "_FewShotPromptTemplateMixin",
 ]

langchain/prompts/loading.py

@@ -11,13 +11,13 @@ from langchain_core.prompts.loading import (
 from langchain_core.utils.loading import try_load_from_hub
 
 __all__ = [
-    "load_prompt_from_config",
-    "load_prompt",
-    "try_load_from_hub",
     "_load_examples",
     "_load_few_shot_prompt",
     "_load_output_parser",
     "_load_prompt",
     "_load_prompt_from_file",
     "_load_template",
+    "load_prompt",
+    "load_prompt_from_config",
+    "try_load_from_hub",
 ]

langchain/prompts/prompt.py

@@ -3,4 +3,4 @@ from langchain_core.prompts.prompt import PromptTemplate
 # For backwards compatibility.
 Prompt = PromptTemplate
 
-__all__ = ["PromptTemplate", "Prompt"]
+__all__ = ["Prompt", "PromptTemplate"]

langchain/pydantic_v1/__init__.py

@@ -7,7 +7,7 @@ from langchain_core._api import warn_deprecated
 # attempt to import pydantic since it adds pydantic_v1 and pydantic_v2 to sys.modules.
 #
 # This hack is done for the following reasons:
-# * Langchain will attempt to remain compatible with both pydantic v1 and v2 since
+# * LangChain will attempt to remain compatible with both pydantic v1 and v2 since
 #   both dependencies and dependents may be stuck on either version of v1 or v2.
 # * Creating namespaces for pydantic v1 and v2 should allow us to write code that
 #   unambiguously uses either v1 or v2 API.

langchain/retrievers/__init__.py

@@ -148,8 +148,8 @@ __all__ = [
     "GoogleDocumentAIWarehouseRetriever",
     "GoogleVertexAIMultiTurnSearchRetriever",
     "GoogleVertexAISearchRetriever",
-    "KayAiRetriever",
     "KNNRetriever",
+    "KayAiRetriever",
     "LlamaIndexGraphRetriever",
     "LlamaIndexRetriever",
     "MergerRetriever",
@@ -157,22 +157,22 @@ __all__ = [
     "MilvusRetriever",
     "MultiQueryRetriever",
     "MultiVectorRetriever",
+    "NeuralDBRetriever",
     "OutlineRetriever",
     "ParentDocumentRetriever",
     "PineconeHybridSearchRetriever",
     "PubMedRetriever",
-    "RemoteLangChainRetriever",
     "RePhraseQueryRetriever",
-    "SelfQueryRetriever",
+    "RemoteLangChainRetriever",
     "SVMRetriever",
-    "TavilySearchAPIRetriever",
+    "SelfQueryRetriever",
     "TFIDFRetriever",
+    "TavilySearchAPIRetriever",
     "TimeWeightedVectorStoreRetriever",
     "VespaRetriever",
     "WeaviateHybridSearchRetriever",
     "WebResearchRetriever",
     "WikipediaRetriever",
     "ZepRetriever",
-    "NeuralDBRetriever",
     "ZillizRetriever",
 ]

langchain/retrievers/bedrock.py

@@ -27,7 +27,7 @@ def __getattr__(name: str) -> Any:
 
 
 __all__ = [
-    "VectorSearchConfig",
-    "RetrievalConfig",
     "AmazonKnowledgeBasesRetriever",
+    "RetrievalConfig",
+    "VectorSearchConfig",
 ]

langchain/retrievers/bm25.py

@@ -23,6 +23,6 @@ def __getattr__(name: str) -> Any:
 
 
 __all__ = [
-    "default_preprocessing_func",
     "BM25Retriever",
+    "default_preprocessing_func",
 ]

langchain/retrievers/contextual_compression.py

@@ -38,15 +38,18 @@ class ContextualCompressionRetriever(BaseRetriever):
             Sequence of relevant documents
         """
         docs = self.base_retriever.invoke(
-            query, config={"callbacks": run_manager.get_child()}, **kwargs
+            query,
+            config={"callbacks": run_manager.get_child()},
+            **kwargs,
         )
         if docs:
             compressed_docs = self.base_compressor.compress_documents(
-                docs, query, callbacks=run_manager.get_child()
+                docs,
+                query,
+                callbacks=run_manager.get_child(),
             )
             return list(compressed_docs)
-        else:
-            return []
+        return []
 
     async def _aget_relevant_documents(
         self,
@@ -64,12 +67,15 @@ class ContextualCompressionRetriever(BaseRetriever):
             List of relevant documents
         """
         docs = await self.base_retriever.ainvoke(
-            query, config={"callbacks": run_manager.get_child()}, **kwargs
+            query,
+            config={"callbacks": run_manager.get_child()},
+            **kwargs,
         )
         if docs:
             compressed_docs = await self.base_compressor.acompress_documents(
-                docs, query, callbacks=run_manager.get_child()
+                docs,
+                query,
+                callbacks=run_manager.get_child(),
             )
             return list(compressed_docs)
-        else:
-            return []
+        return []

langchain/retrievers/docarray.py

@@ -23,6 +23,6 @@ def __getattr__(name: str) -> Any:
 
 
 __all__ = [
-    "SearchType",
     "DocArrayRetriever",
+    "SearchType",
 ]