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

langchain/retrievers/self_query/base.py

@@ -27,11 +27,12 @@ def _get_builtin_translator(vectorstore: VectorStore) -> Visitor:
     """Get the translator class corresponding to the vector store class."""
     try:
         import langchain_community  # noqa: F401
-    except ImportError:
-        raise ImportError(
+    except ImportError as err:
+        msg = (
             "The langchain-community package must be installed to use this feature."
             " Please install it using `pip install langchain-community`."
         )
+        raise ImportError(msg) from err
 
     from langchain_community.query_constructors.astradb import AstraDBTranslator
     from langchain_community.query_constructors.chroma import ChromaTranslator
@@ -118,116 +119,116 @@ def _get_builtin_translator(vectorstore: VectorStore) -> Visitor:
     }
     if isinstance(vectorstore, DatabricksVectorSearch):
         return DatabricksVectorSearchTranslator()
-    elif isinstance(vectorstore, MyScale):
+    if isinstance(vectorstore, MyScale):
         return MyScaleTranslator(metadata_key=vectorstore.metadata_column)
-    elif isinstance(vectorstore, Redis):
+    if isinstance(vectorstore, Redis):
         return RedisTranslator.from_vectorstore(vectorstore)
-    elif isinstance(vectorstore, TencentVectorDB):
+    if isinstance(vectorstore, TencentVectorDB):
         fields = [
             field.name for field in (vectorstore.meta_fields or []) if field.index
         ]
         return TencentVectorDBTranslator(fields)
-    elif vectorstore.__class__ in BUILTIN_TRANSLATORS:
+    if vectorstore.__class__ in BUILTIN_TRANSLATORS:
         return BUILTIN_TRANSLATORS[vectorstore.__class__]()
+    try:
+        from langchain_astradb.vectorstores import AstraDBVectorStore
+    except ImportError:
+        pass
     else:
-        try:
-            from langchain_astradb.vectorstores import AstraDBVectorStore
-        except ImportError:
-            pass
-        else:
-            if isinstance(vectorstore, AstraDBVectorStore):
-                return AstraDBTranslator()
-
-        try:
-            from langchain_elasticsearch.vectorstores import ElasticsearchStore
-        except ImportError:
-            pass
-        else:
-            if isinstance(vectorstore, ElasticsearchStore):
-                return ElasticsearchTranslator()
-
-        try:
-            from langchain_pinecone import PineconeVectorStore
-        except ImportError:
-            pass
-        else:
-            if isinstance(vectorstore, PineconeVectorStore):
-                return PineconeTranslator()
-
-        try:
-            from langchain_milvus import Milvus
-        except ImportError:
-            pass
-        else:
-            if isinstance(vectorstore, Milvus):
-                return MilvusTranslator()
-
-        try:
-            from langchain_mongodb import MongoDBAtlasVectorSearch
-        except ImportError:
-            pass
-        else:
-            if isinstance(vectorstore, MongoDBAtlasVectorSearch):
-                return MongoDBAtlasTranslator()
-
-        try:
-            from langchain_neo4j import Neo4jVector
-        except ImportError:
-            pass
-        else:
-            if isinstance(vectorstore, Neo4jVector):
-                return Neo4jTranslator()
-
-        try:
-            # Trying langchain_chroma import if exists
-            from langchain_chroma import Chroma
-        except ImportError:
-            pass
-        else:
-            if isinstance(vectorstore, Chroma):
-                return ChromaTranslator()
-
-        try:
-            from langchain_postgres import PGVector
-            from langchain_postgres import PGVectorTranslator as NewPGVectorTranslator
-        except ImportError:
-            pass
-        else:
-            if isinstance(vectorstore, PGVector):
-                return NewPGVectorTranslator()
-
-        try:
-            from langchain_qdrant import QdrantVectorStore
-        except ImportError:
-            pass
-        else:
-            if isinstance(vectorstore, QdrantVectorStore):
-                return QdrantTranslator(metadata_key=vectorstore.metadata_payload_key)
-
-        try:
-            # Added in langchain-community==0.2.11
-            from langchain_community.query_constructors.hanavector import HanaTranslator
-            from langchain_community.vectorstores import HanaDB
-        except ImportError:
-            pass
-        else:
-            if isinstance(vectorstore, HanaDB):
-                return HanaTranslator()
-
-        try:
-            # Trying langchain_weaviate (weaviate v4) import if exists
-            from langchain_weaviate.vectorstores import WeaviateVectorStore
-
-        except ImportError:
-            pass
-        else:
-            if isinstance(vectorstore, WeaviateVectorStore):
-                return WeaviateTranslator()
-
-        raise ValueError(
-            f"Self query retriever with Vector Store type {vectorstore.__class__}"
-            f" not supported."
-        )
+        if isinstance(vectorstore, AstraDBVectorStore):
+            return AstraDBTranslator()
+
+    try:
+        from langchain_elasticsearch.vectorstores import ElasticsearchStore
+    except ImportError:
+        pass
+    else:
+        if isinstance(vectorstore, ElasticsearchStore):
+            return ElasticsearchTranslator()
+
+    try:
+        from langchain_pinecone import PineconeVectorStore
+    except ImportError:
+        pass
+    else:
+        if isinstance(vectorstore, PineconeVectorStore):
+            return PineconeTranslator()
+
+    try:
+        from langchain_milvus import Milvus
+    except ImportError:
+        pass
+    else:
+        if isinstance(vectorstore, Milvus):
+            return MilvusTranslator()
+
+    try:
+        from langchain_mongodb import MongoDBAtlasVectorSearch
+    except ImportError:
+        pass
+    else:
+        if isinstance(vectorstore, MongoDBAtlasVectorSearch):
+            return MongoDBAtlasTranslator()
+
+    try:
+        from langchain_neo4j import Neo4jVector
+    except ImportError:
+        pass
+    else:
+        if isinstance(vectorstore, Neo4jVector):
+            return Neo4jTranslator()
+
+    try:
+        # Trying langchain_chroma import if exists
+        from langchain_chroma import Chroma
+    except ImportError:
+        pass
+    else:
+        if isinstance(vectorstore, Chroma):
+            return ChromaTranslator()
+
+    try:
+        from langchain_postgres import PGVector
+        from langchain_postgres import PGVectorTranslator as NewPGVectorTranslator
+    except ImportError:
+        pass
+    else:
+        if isinstance(vectorstore, PGVector):
+            return NewPGVectorTranslator()
+
+    try:
+        from langchain_qdrant import QdrantVectorStore
+    except ImportError:
+        pass
+    else:
+        if isinstance(vectorstore, QdrantVectorStore):
+            return QdrantTranslator(metadata_key=vectorstore.metadata_payload_key)
+
+    try:
+        # Added in langchain-community==0.2.11
+        from langchain_community.query_constructors.hanavector import HanaTranslator
+        from langchain_community.vectorstores import HanaDB
+    except ImportError:
+        pass
+    else:
+        if isinstance(vectorstore, HanaDB):
+            return HanaTranslator()
+
+    try:
+        # Trying langchain_weaviate (weaviate v4) import if exists
+        from langchain_weaviate.vectorstores import WeaviateVectorStore
+
+    except ImportError:
+        pass
+    else:
+        if isinstance(vectorstore, WeaviateVectorStore):
+            return WeaviateTranslator()
+
+    msg = (
+        f"Self query retriever with Vector Store type {vectorstore.__class__}"
+        f" not supported."
+    )
+    raise ValueError(msg)
 
 
 class SelfQueryRetriever(BaseRetriever):
@@ -238,7 +239,7 @@ class SelfQueryRetriever(BaseRetriever):
     """The underlying vector store from which documents will be retrieved."""
     query_constructor: Runnable[dict, StructuredQuery] = Field(alias="llm_chain")
     """The query constructor chain for generating the vector store queries.
-    
+
     llm_chain is legacy name kept for backwards compatibility."""
     search_type: str = "similarity"
     """The search type to perform on the vector store."""
@@ -262,7 +263,7 @@ class SelfQueryRetriever(BaseRetriever):
         """Validate translator."""
         if "structured_query_translator" not in values:
             values["structured_query_translator"] = _get_builtin_translator(
-                values["vectorstore"]
+                values["vectorstore"],
             )
         return values
 
@@ -272,10 +273,12 @@ class SelfQueryRetriever(BaseRetriever):
         return self.query_constructor
 
     def _prepare_query(
-        self, query: str, structured_query: StructuredQuery
+        self,
+        query: str,
+        structured_query: StructuredQuery,
     ) -> tuple[str, dict[str, Any]]:
         new_query, new_kwargs = self.structured_query_translator.visit_structured_query(
-            structured_query
+            structured_query,
         )
         if structured_query.limit is not None:
             new_kwargs["k"] = structured_query.limit
@@ -285,19 +288,24 @@ class SelfQueryRetriever(BaseRetriever):
         return new_query, search_kwargs
 
     def _get_docs_with_query(
-        self, query: str, search_kwargs: dict[str, Any]
+        self,
+        query: str,
+        search_kwargs: dict[str, Any],
     ) -> list[Document]:
-        docs = self.vectorstore.search(query, self.search_type, **search_kwargs)
-        return docs
+        return self.vectorstore.search(query, self.search_type, **search_kwargs)
 
     async def _aget_docs_with_query(
-        self, query: str, search_kwargs: dict[str, Any]
+        self,
+        query: str,
+        search_kwargs: dict[str, Any],
     ) -> list[Document]:
-        docs = await self.vectorstore.asearch(query, self.search_type, **search_kwargs)
-        return docs
+        return await self.vectorstore.asearch(query, self.search_type, **search_kwargs)
 
     def _get_relevant_documents(
-        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
+        self,
+        query: str,
+        *,
+        run_manager: CallbackManagerForRetrieverRun,
     ) -> list[Document]:
         """Get documents relevant for a query.
 
@@ -308,16 +316,19 @@ class SelfQueryRetriever(BaseRetriever):
             List of relevant documents
         """
         structured_query = self.query_constructor.invoke(
-            {"query": query}, config={"callbacks": run_manager.get_child()}
+            {"query": query},
+            config={"callbacks": run_manager.get_child()},
         )
         if self.verbose:
-            logger.info(f"Generated Query: {structured_query}")
+            logger.info("Generated Query: %s", structured_query)
         new_query, search_kwargs = self._prepare_query(query, structured_query)
-        docs = self._get_docs_with_query(new_query, search_kwargs)
-        return docs
+        return self._get_docs_with_query(new_query, search_kwargs)
 
     async def _aget_relevant_documents(
-        self, query: str, *, run_manager: AsyncCallbackManagerForRetrieverRun
+        self,
+        query: str,
+        *,
+        run_manager: AsyncCallbackManagerForRetrieverRun,
     ) -> list[Document]:
         """Get documents relevant for a query.
 
@@ -328,13 +339,13 @@ class SelfQueryRetriever(BaseRetriever):
             List of relevant documents
         """
         structured_query = await self.query_constructor.ainvoke(
-            {"query": query}, config={"callbacks": run_manager.get_child()}
+            {"query": query},
+            config={"callbacks": run_manager.get_child()},
         )
         if self.verbose:
-            logger.info(f"Generated Query: {structured_query}")
+            logger.info("Generated Query: %s", structured_query)
         new_query, search_kwargs = self._prepare_query(query, structured_query)
-        docs = await self._aget_docs_with_query(new_query, search_kwargs)
-        return docs
+        return await self._aget_docs_with_query(new_query, search_kwargs)
 
     @classmethod
     def from_llm(
@@ -345,10 +356,29 @@ class SelfQueryRetriever(BaseRetriever):
         metadata_field_info: Sequence[Union[AttributeInfo, dict]],
         structured_query_translator: Optional[Visitor] = None,
         chain_kwargs: Optional[dict] = None,
-        enable_limit: bool = False,
-        use_original_query: bool = False,
+        enable_limit: bool = False,  # noqa: FBT001,FBT002
+        use_original_query: bool = False,  # noqa: FBT001,FBT002
         **kwargs: Any,
     ) -> "SelfQueryRetriever":
+        """Create a SelfQueryRetriever from an LLM and a vector store.
+
+        Args:
+            llm: The language model to use for generating queries.
+            vectorstore: The vector store to use for retrieving documents.
+            document_contents: Description of the page contents of the document to be
+                queried.
+            metadata_field_info: Metadata field information for the documents.
+            structured_query_translator: Optional translator for turning internal query
+                language into vectorstore search params.
+            chain_kwargs: Additional keyword arguments for the query constructor.
+            enable_limit: Whether to enable the limit operator.
+            use_original_query: Whether to use the original query instead of the revised
+                query from the LLM.
+            **kwargs: Additional keyword arguments for the SelfQueryRetriever.
+
+        Returns:
+            An instance of SelfQueryRetriever.
+        """
         if structured_query_translator is None:
             structured_query_translator = _get_builtin_translator(vectorstore)
         chain_kwargs = chain_kwargs or {}
@@ -375,7 +405,7 @@ class SelfQueryRetriever(BaseRetriever):
             **chain_kwargs,
         )
         query_constructor = query_constructor.with_config(
-            run_name=QUERY_CONSTRUCTOR_RUN_NAME
+            run_name=QUERY_CONSTRUCTOR_RUN_NAME,
         )
         return cls(  # type: ignore[call-arg]
             query_constructor=query_constructor,

langchain/retrievers/time_weighted_retriever.py

@@ -10,6 +10,7 @@ from langchain_core.documents import Document
 from langchain_core.retrievers import BaseRetriever
 from langchain_core.vectorstores import VectorStore
 from pydantic import ConfigDict, Field
+from typing_extensions import override
 
 
 def _get_hours_passed(time: datetime.datetime, ref_time: datetime.datetime) -> float:
@@ -24,7 +25,7 @@ class TimeWeightedVectorStoreRetriever(BaseRetriever):
     vectorstore: VectorStore
     """The vectorstore to store documents and determine salience."""
 
-    search_kwargs: dict = Field(default_factory=lambda: dict(k=100))
+    search_kwargs: dict = Field(default_factory=lambda: {"k": 100})
     """Keyword arguments to pass to the vectorstore similarity search."""
 
     # TODO: abstract as a queue
@@ -81,7 +82,8 @@ class TimeWeightedVectorStoreRetriever(BaseRetriever):
         """Return documents that are salient to the query."""
         docs_and_scores: list[tuple[Document, float]]
         docs_and_scores = self.vectorstore.similarity_search_with_relevance_scores(
-            query, **self.search_kwargs
+            query,
+            **self.search_kwargs,
         )
         results = {}
         for fetched_doc, relevance in docs_and_scores:
@@ -96,7 +98,8 @@ class TimeWeightedVectorStoreRetriever(BaseRetriever):
         docs_and_scores: list[tuple[Document, float]]
         docs_and_scores = (
             await self.vectorstore.asimilarity_search_with_relevance_scores(
-                query, **self.search_kwargs
+                query,
+                **self.search_kwargs,
             )
         )
         results = {}
@@ -108,7 +111,8 @@ class TimeWeightedVectorStoreRetriever(BaseRetriever):
         return results
 
     def _get_rescored_docs(
-        self, docs_and_scores: dict[Any, tuple[Document, Optional[float]]]
+        self,
+        docs_and_scores: dict[Any, tuple[Document, Optional[float]]],
     ) -> list[Document]:
         current_time = datetime.datetime.now()
         rescored_docs = [
@@ -125,8 +129,12 @@ class TimeWeightedVectorStoreRetriever(BaseRetriever):
             result.append(buffered_doc)
         return result
 
+    @override
     def _get_relevant_documents(
-        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
+        self,
+        query: str,
+        *,
+        run_manager: CallbackManagerForRetrieverRun,
     ) -> list[Document]:
         docs_and_scores = {
             doc.metadata["buffer_idx"]: (doc, self.default_salience)
@@ -136,8 +144,12 @@ class TimeWeightedVectorStoreRetriever(BaseRetriever):
         docs_and_scores.update(self.get_salient_docs(query))
         return self._get_rescored_docs(docs_and_scores)
 
+    @override
     async def _aget_relevant_documents(
-        self, query: str, *, run_manager: AsyncCallbackManagerForRetrieverRun
+        self,
+        query: str,
+        *,
+        run_manager: AsyncCallbackManagerForRetrieverRun,
     ) -> list[Document]:
         docs_and_scores = {
             doc.metadata["buffer_idx"]: (doc, self.default_salience)
@@ -164,7 +176,9 @@ class TimeWeightedVectorStoreRetriever(BaseRetriever):
         return self.vectorstore.add_documents(dup_docs, **kwargs)
 
     async def aadd_documents(
-        self, documents: list[Document], **kwargs: Any
+        self,
+        documents: list[Document],
+        **kwargs: Any,
     ) -> list[str]:
         """Add documents to vectorstore."""
         current_time = kwargs.get("current_time")

langchain/retrievers/zilliz.py

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

langchain/runnables/hub.py

@@ -19,6 +19,18 @@ class HubRunnable(RunnableBindingBase[Input, Output]):
         api_key: Optional[str] = None,
         **kwargs: Any,
     ) -> None:
+        """Initialize the HubRunnable.
+
+        Args:
+            owner_repo_commit: The full name of the prompt to pull from in the format of
+                `owner/prompt_name:commit_hash` or `owner/prompt_name`
+                or just `prompt_name` if it's your own prompt.
+            api_url: The URL of the LangChain Hub API.
+                Defaults to the hosted API service if you have an api key set,
+                or a localhost instance if not.
+            api_key: The API key to use to authenticate with the LangChain Hub API.
+            **kwargs: Additional keyword arguments to pass to the parent class.
+        """
         from langchain.hub import pull
 
         pulled = pull(owner_repo_commit, api_url=api_url, api_key=api_key)

langchain/runnables/openai_functions.py

@@ -36,9 +36,19 @@ class OpenAIFunctionsRouter(RunnableBindingBase[BaseMessage, Any]):
         ],
         functions: Optional[list[OpenAIFunction]] = None,
     ):
+        """Initialize the OpenAIFunctionsRouter.
+
+        Args:
+            runnables: A mapping of function names to runnables.
+            functions: Optional list of functions to check against the runnables.
+        """
         if functions is not None:
-            assert len(functions) == len(runnables)
-            assert all(func["name"] in runnables for func in functions)
+            if len(functions) != len(runnables):
+                msg = "The number of functions does not match the number of runnables."
+                raise ValueError(msg)
+            if not all(func["name"] in runnables for func in functions):
+                msg = "One or more function names are not found in runnables."
+                raise ValueError(msg)
         router = (
             JsonOutputFunctionsParser(args_only=False)
             | {"key": itemgetter("name"), "input": itemgetter("arguments")}

langchain/schema/__init__.py

@@ -43,40 +43,40 @@ Memory = BaseMemory
 _message_to_dict = message_to_dict
 
 __all__ = [
-    "BaseCache",
-    "BaseMemory",
-    "BaseStore",
-    "AgentFinish",
+    "RUN_KEY",
+    "AIMessage",
     "AgentAction",
-    "Document",
+    "AgentFinish",
+    "BaseCache",
     "BaseChatMessageHistory",
     "BaseDocumentTransformer",
+    "BaseLLMOutputParser",
+    "BaseMemory",
     "BaseMessage",
+    "BaseOutputParser",
+    "BasePromptTemplate",
+    "BaseRetriever",
+    "BaseStore",
+    "ChatGeneration",
     "ChatMessage",
+    "ChatResult",
+    "Document",
     "FunctionMessage",
+    "Generation",
     "HumanMessage",
-    "AIMessage",
-    "SystemMessage",
-    "messages_from_dict",
-    "messages_to_dict",
-    "message_to_dict",
-    "_message_to_dict",
-    "_message_from_dict",
-    "get_buffer_string",
-    "RunInfo",
     "LLMResult",
-    "ChatResult",
-    "ChatGeneration",
-    "Generation",
-    "PromptValue",
     "LangChainException",
-    "BaseRetriever",
-    "RUN_KEY",
     "Memory",
     "OutputParserException",
+    "PromptValue",
+    "RunInfo",
     "StrOutputParser",
-    "BaseOutputParser",
-    "BaseLLMOutputParser",
-    "BasePromptTemplate",
+    "SystemMessage",
+    "_message_from_dict",
+    "_message_to_dict",
     "format_document",
+    "get_buffer_string",
+    "message_to_dict",
+    "messages_from_dict",
+    "messages_to_dict",
 ]

langchain/schema/cache.py

@@ -1,3 +1,3 @@
 from langchain_core.caches import RETURN_VAL_TYPE, BaseCache
 
-__all__ = ["BaseCache", "RETURN_VAL_TYPE"]
+__all__ = ["RETURN_VAL_TYPE", "BaseCache"]

langchain/schema/callbacks/base.py

@@ -11,13 +11,13 @@ from langchain_core.callbacks.base import (
 )
 
 __all__ = [
-    "RetrieverManagerMixin",
-    "LLMManagerMixin",
-    "ChainManagerMixin",
-    "ToolManagerMixin",
-    "CallbackManagerMixin",
-    "RunManagerMixin",
-    "BaseCallbackHandler",
     "AsyncCallbackHandler",
+    "BaseCallbackHandler",
     "BaseCallbackManager",
+    "CallbackManagerMixin",
+    "ChainManagerMixin",
+    "LLMManagerMixin",
+    "RetrieverManagerMixin",
+    "RunManagerMixin",
+    "ToolManagerMixin",
 ]

langchain/schema/callbacks/manager.py

@@ -28,28 +28,28 @@ from langchain_core.tracers.context import (
 from langchain_core.utils.env import env_var_is_set
 
 __all__ = [
-    "tracing_enabled",
-    "tracing_v2_enabled",
-    "collect_runs",
-    "trace_as_chain_group",
-    "handle_event",
-    "BaseRunManager",
-    "RunManager",
-    "ParentRunManager",
-    "AsyncRunManager",
-    "AsyncParentRunManager",
-    "CallbackManagerForLLMRun",
-    "AsyncCallbackManagerForLLMRun",
-    "CallbackManagerForChainRun",
+    "AsyncCallbackManager",
+    "AsyncCallbackManagerForChainGroup",
     "AsyncCallbackManagerForChainRun",
-    "CallbackManagerForToolRun",
-    "AsyncCallbackManagerForToolRun",
-    "CallbackManagerForRetrieverRun",
+    "AsyncCallbackManagerForLLMRun",
     "AsyncCallbackManagerForRetrieverRun",
+    "AsyncCallbackManagerForToolRun",
+    "AsyncParentRunManager",
+    "AsyncRunManager",
+    "BaseRunManager",
     "CallbackManager",
     "CallbackManagerForChainGroup",
-    "AsyncCallbackManager",
-    "AsyncCallbackManagerForChainGroup",
-    "register_configure_hook",
+    "CallbackManagerForChainRun",
+    "CallbackManagerForLLMRun",
+    "CallbackManagerForRetrieverRun",
+    "CallbackManagerForToolRun",
+    "ParentRunManager",
+    "RunManager",
+    "collect_runs",
     "env_var_is_set",
+    "handle_event",
+    "register_configure_hook",
+    "trace_as_chain_group",
+    "tracing_enabled",
+    "tracing_v2_enabled",
 ]

langchain/schema/callbacks/tracers/base.py

@@ -1,4 +1,4 @@
 from langchain_core.exceptions import TracerException
 from langchain_core.tracers.base import BaseTracer
 
-__all__ = ["TracerException", "BaseTracer"]
+__all__ = ["BaseTracer", "TracerException"]

langchain/schema/callbacks/tracers/evaluation.py

@@ -3,4 +3,4 @@ from langchain_core.tracers.evaluation import (
     wait_for_all_evaluators,
 )
 
-__all__ = ["wait_for_all_evaluators", "EvaluatorCallbackHandler"]
+__all__ = ["EvaluatorCallbackHandler", "wait_for_all_evaluators"]