fix: use run_in_executor instead of raising error

Author: BobMerkus

libs/weaviate/langchain_weaviate/vectorstores.py

@@ -23,6 +23,7 @@
 import weaviate  # type: ignore
 from langchain_core.documents import Document
 from langchain_core.embeddings import Embeddings
+from langchain_core.runnables.config import run_in_executor
 from langchain_core.vectorstores import VectorStore
 
 from langchain_weaviate.utils import maximal_marginal_relevance
@@ -570,7 +571,10 @@ async def aadd_texts(
     ) -> List[str]:
         """Add texts to Weaviate asynchronously."""
         if self._client_async is None:
-            raise ValueError("client_async must be an instance of WeaviateAsyncClient")
+            logger.warning("client_async is None, using synchronous client instead")
+            return await run_in_executor(
+                None, self.add_texts, texts, metadatas, tenant, **kwargs
+            )
         from weaviate.util import get_valid_uuid  # type: ignore
 
         if tenant and not await self._adoes_tenant_exist(tenant):
@@ -678,7 +682,7 @@ async def _perform_asearch(
         ValueError: If _embedding is None or an invalid search method is provided.
         """
         if self._client_async is None:
-            raise ValueError("client_async must be an instance of WeaviateAsyncClient")
+            raise ValueError("cannot perform asearch with synchronous client")
         if self._embedding is None:
             raise ValueError("_embedding cannot be None for similarity_search")
 
@@ -739,8 +743,9 @@ async def _perform_asearch(
 
     async def _adoes_tenant_exist(self, tenant: str) -> bool:
         """Check if tenant exists in Weaviate asynchronously."""
-        if self._client_async is None:
-            raise ValueError("client_async must be an instance of WeaviateAsyncClient")
+        assert (
+            self._client_async is not None
+        ), "client_async must be an instance of WeaviateAsyncClient"
         assert (
             self._multi_tenancy_enabled
         ), "Cannot check for tenant existence when multi-tenancy is not enabled"
@@ -763,6 +768,10 @@ async def asimilarity_search(
         Returns:
             List of Documents most similar to the query.
         """
+        if self._client_async is None:
+            return await run_in_executor(
+                None, self.similarity_search, query, k, **kwargs
+            )
         result = await self._perform_asearch(query, k, **kwargs)
         return result
 
@@ -791,6 +800,16 @@ async def amax_marginal_relevance_search(
         Returns:
             List of Documents selected by maximal marginal relevance.
         """
+        if self._client_async is None:
+            return await run_in_executor(
+                None,
+                self.max_marginal_relevance_search,
+                query,
+                k,
+                fetch_k,
+                lambda_mult,
+                **kwargs,
+            )
         if self._embedding is not None:
             embedding = await self._embedding.aembed_query(query)
         else:
@@ -827,6 +846,16 @@ async def amax_marginal_relevance_search_by_vector(
         Returns:
             List of Documents selected by maximal marginal relevance.
         """
+        if self._client_async is None:
+            return await run_in_executor(
+                None,
+                self.max_marginal_relevance_search_by_vector,
+                embedding,
+                k,
+                fetch_k,
+                lambda_mult,
+                **kwargs,
+            )
         results = await self._perform_asearch(
             query=None,
             k=fetch_k,
@@ -857,9 +886,36 @@ async def asimilarity_search_with_score(
         text and cosine distance in float for each.
         Lower score represents more similarity.
         """
+        if self._client_async is None:
+            return await run_in_executor(
+                None, self.similarity_search_with_score, query, k, **kwargs
+            )
         results = await self._perform_asearch(query, k, return_score=True, **kwargs)
         return results
 
+    async def asimilarity_search_by_vector(
+        self, embedding: List[float], k: int = 4, **kwargs: Any
+    ) -> List[Document]:
+        """Return docs most similar to embedding vector asynchronously.
+
+        Args:
+            embedding: Embedding vector to look up documents similar to.
+            k: Number of Documents to return. Defaults to 4.
+            **kwargs: Additional keyword arguments will be passed to the `hybrid()`
+                function of the weaviate client.
+
+        Returns:
+            List of Documents most similar to the embedding.
+        """
+        if self._client_async is None:
+            return await run_in_executor(
+                None, self.similarity_search_by_vector, embedding, k, **kwargs
+            )
+        result = await self._perform_asearch(
+            query=None, k=k, vector=embedding, **kwargs
+        )
+        return result
+
     @classmethod
     async def afrom_texts(
         cls,
@@ -917,8 +973,6 @@ async def afrom_texts(
 
         if client is None:
             raise ValueError("client must be an instance of WeaviateClient")
-        if client_async is None:
-            raise ValueError("client_async must be an instance of WeaviateAsyncClient")
 
         weaviate_vector_store = cls(
             client,
@@ -962,22 +1016,3 @@ async def _atenant_context(
             yield collection
         finally:
             pass
-
-    async def asimilarity_search_by_vector(
-        self, embedding: List[float], k: int = 4, **kwargs: Any
-    ) -> List[Document]:
-        """Return docs most similar to embedding vector asynchronously.
-
-        Args:
-            embedding: Embedding vector to look up documents similar to.
-            k: Number of Documents to return. Defaults to 4.
-            **kwargs: Additional keyword arguments will be passed to the `hybrid()`
-                function of the weaviate client.
-
-        Returns:
-            List of Documents most similar to the embedding.
-        """
-        result = await self._perform_asearch(
-            query=None, k=k, vector=embedding, **kwargs
-        )
-        return result

libs/weaviate/tests/unit_tests/test_vectorstores_additional.py

@@ -1035,19 +1035,9 @@ async def test_atenant_context_missing_tenant(
         async with docsearch._atenant_context(tenant=None):
             pass
 
-
-@pytest.mark.asyncio
-async def test_warning_when_client_async_not_provided(
-    embedding: Any, mock_weaviate_client: MagicMock
-) -> None:
-    """Test that a warning is logged when client_async is not provided."""
-    # Create store with client_async not provided
+    # Test that _perform_asearch raises ValueError when client_async is None
+    docsearch._client_async = None
     with pytest.raises(
-        ValueError, match="client_async must be an instance of WeaviateAsyncClient"
+        ValueError, match="cannot perform asearch with synchronous client"
     ):
-        await WeaviateVectorStore.afrom_texts(
-            client=mock_weaviate_client,
-            texts=["test"],
-            embedding=embedding,
-            client_async=None,
-        )
+        await docsearch._perform_asearch(query="test", k=5)

libs/weaviate/tests/unit_tests/test_vectorstores_integration_async.py

@@ -932,6 +932,31 @@ async def test_invalid_search_param(
     await weaviate_vector_store._perform_asearch(query=None, vector=[1, 2, 3], k=5)
 
 
+@pytest.mark.asyncio
+async def test_async_function_without_async_client(
+    weaviate_client: weaviate.WeaviateClient,
+    consistent_embedding: ConsistentFakeEmbeddings,
+) -> None:
+    index_name = f"TestIndex_{uuid.uuid4().hex}"
+    docsearch = WeaviateVectorStore(
+        client=weaviate_client,
+        client_async=None,
+        index_name=index_name,
+        text_key="text",
+        embedding=consistent_embedding,
+    )
+
+    # test all async functions without raising errors
+    # these should be run in the executor, this is identical to how the
+    # BaseVectorStore class runs the functions without the async method override
+    await docsearch.asimilarity_search("foo", k=1)
+    await docsearch.asimilarity_search_with_score("foo", k=1)
+    await docsearch.asimilarity_search_by_vector([1, 2, 3], k=1)
+    await docsearch.amax_marginal_relevance_search("foo", k=1)
+    await docsearch.amax_marginal_relevance_search_by_vector([1, 2, 3], k=1)
+    await docsearch.aadd_texts(["foo"])
+
+
 @pytest.mark.asyncio
 async def test_missing_coverage_edge_cases(
     weaviate_client: weaviate.WeaviateClient,
@@ -954,9 +979,10 @@ async def test_missing_coverage_edge_cases(
         text_key="text",
         embedding=embedding,
     )
-
-    with pytest.raises(ValueError, match="client_async must be an instance"):
+    # check if warning is logged
+    with caplog.at_level(logging.WARNING, logger="langchain_weaviate.vectorstores"):
         await docsearch_no_async.aadd_texts(["test"])
+        assert "client_async is None, using synchronous client instead" in caplog.text
 
     # Test line 355: Test max_marginal_relevance_search without embedding
     docsearch_no_embedding = WeaviateVectorStore(
@@ -970,10 +996,6 @@ async def test_missing_coverage_edge_cases(
     with pytest.raises(ValueError, match="max_marginal_relevance_search requires"):
         await docsearch_no_embedding.amax_marginal_relevance_search("test")
 
-    # Test lines 706-707: Test _perform_asearch without client_async or embedding
-    with pytest.raises(ValueError, match="client_async must be an instance"):
-        await docsearch_no_async._perform_asearch(query="test", k=1)
-
     docsearch = WeaviateVectorStore(
         client=weaviate_client,
         client_async=weaviate_client_async,
@@ -1003,15 +1025,6 @@ async def patched_perform_asearch(
     with pytest.raises(ValueError, match="Either query or vector must be provided"):
         await docsearch._perform_asearch(query=None, vector=None, k=1)
 
-    # Test line 735: Test _adoes_tenant_exist with no client_async
-    with pytest.raises(ValueError, match="client_async must be an instance"):
-        await docsearch_no_async._adoes_tenant_exist("test_tenant")
-
-    # Test lines 938, 946: Test _atenant_context with errors
-    with pytest.raises(ValueError, match="client_async must be an instance"):
-        async with docsearch_no_async._atenant_context("test_tenant"):
-            pass
-
     # Create a docsearch with client_async but without multi-tenancy
     docsearch_no_mt = WeaviateVectorStore(
         client=weaviate_client,
@@ -1043,3 +1056,10 @@ async def patched_perform_asearch(
     with pytest.raises(ValueError, match=msg):
         async with docsearch_with_mt._atenant_context(tenant=None):
             pass
+
+    # Test that an error is raised without the async client
+    with pytest.raises(
+        ValueError, match="client_async must be an instance of WeaviateAsyncClient"
+    ):
+        async with docsearch_no_async._atenant_context(tenant="test_tenant"):
+            pass