langchain 0.3.25__py3-none-any.whl → 0.3.27__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,108 +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_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):
@@ -230,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."""
@@ -254,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
 
@@ -264,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
@@ -277,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.
 
@@ -300,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.
 
@@ -320,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(
@@ -337,8 +356,8 @@ 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":
         if structured_query_translator is None:
@@ -367,7 +386,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

@@ -24,7 +24,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 +81,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 +97,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 +110,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 = [
@@ -126,7 +129,10 @@ class TimeWeightedVectorStoreRetriever(BaseRetriever):
         return result
 
     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)
@@ -137,7 +143,10 @@ class TimeWeightedVectorStoreRetriever(BaseRetriever):
         return self._get_rescored_docs(docs_and_scores)
 
     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 +173,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

@@ -1,6 +1,7 @@
 from typing import Any, Optional
 
-from langchain_core.runnables.base import Input, Output, RunnableBindingBase
+from langchain_core.runnables.base import RunnableBindingBase
+from langchain_core.runnables.utils import Input, Output
 
 
 class HubRunnable(RunnableBindingBase[Input, Output]):

langchain/runnables/openai_functions.py

@@ -37,8 +37,12 @@ class OpenAIFunctionsRouter(RunnableBindingBase[BaseMessage, Any]):
         functions: Optional[list[OpenAIFunction]] = None,
     ):
         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,3 +1,4 @@
-from langchain_core.tracers.base import BaseTracer, TracerException
+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"]

langchain/schema/callbacks/tracers/langchain.py

@@ -5,4 +5,4 @@ from langchain_core.tracers.langchain import (
     wait_for_all_tracers,
 )
 
-__all__ = ["log_error_once", "wait_for_all_tracers", "get_client", "LangChainTracer"]
+__all__ = ["LangChainTracer", "get_client", "log_error_once", "wait_for_all_tracers"]

langchain/schema/callbacks/tracers/langchain_v1.py

@@ -1,3 +1,3 @@
 from langchain_core.tracers.langchain_v1 import LangChainTracerV1, get_headers
 
-__all__ = ["get_headers", "LangChainTracerV1"]
+__all__ = ["LangChainTracerV1", "get_headers"]

langchain/schema/callbacks/tracers/log_stream.py

@@ -6,4 +6,4 @@ from langchain_core.tracers.log_stream import (
     RunState,
 )
 
-__all__ = ["LogEntry", "RunState", "RunLogPatch", "RunLog", "LogStreamCallbackHandler"]
+__all__ = ["LogEntry", "LogStreamCallbackHandler", "RunLog", "RunLogPatch", "RunState"]

langchain/schema/callbacks/tracers/schemas.py

@@ -13,15 +13,15 @@ from langchain_core.tracers.schemas import (
 )
 
 __all__ = [
-    "RunTypeEnum",
-    "TracerSessionV1Base",
-    "TracerSessionV1Create",
-    "TracerSessionV1",
-    "TracerSessionBase",
-    "TracerSession",
     "BaseRun",
-    "LLMRun",
     "ChainRun",
-    "ToolRun",
+    "LLMRun",
     "Run",
+    "RunTypeEnum",
+    "ToolRun",
+    "TracerSession",
+    "TracerSessionBase",
+    "TracerSessionV1",
+    "TracerSessionV1Base",
+    "TracerSessionV1Create",
 ]