Allow empty strings for reranking query and improve test cases

Author: VarinThakur01

examples/sap_hanavector.ipynb

@@ -164,7 +164,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -944,20 +944,26 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Reranked documents:\n",
+      "Compressed documents:\n",
+      "--------------------------------------------------------------------------------\n",
+      "Content: Deep learning applications\n",
+      "Relevance score: 0.2188\n",
       "--------------------------------------------------------------------------------\n",
       "Content: Advanced machine learning techniques\n",
-      "Relevance score: 0.0748353898525238\n",
+      "Relevance score: 0.0748\n",
       "--------------------------------------------------------------------------------\n",
       "Content: Introduction to neural networks\n",
-      "Relevance score: 0.007919907569885254\n",
+      "Relevance score: 0.0079\n",
+      "--------------------------------------------------------------------------------\n",
+      "Content: Natural language processing techniques\n",
+      "Relevance score: 0.0040\n",
       "--------------------------------------------------------------------------------\n",
-      "Content: Python programming basics\n",
-      "Relevance score: 0.002642408013343811\n",
+      "Content: Reinforcement learning strategies\n",
+      "Relevance score: 0.0036\n",
       "\n",
       "Top 2 reranked results:\n",
       "  [1] Score: 0.4351 - Advanced machine learning techniques\n",
-      "  [2] Score: 0.0262 - Introduction to neural networks\n"
+      "  [3] Score: 0.0342 - Deep learning applications\n"
      ]
     }
    ],
@@ -975,17 +981,20 @@
     "    Document(page_content=\"Python programming basics\"),\n",
     "    Document(page_content=\"Advanced machine learning techniques\"),\n",
     "    Document(page_content=\"Introduction to neural networks\"),\n",
+    "    Document(page_content=\"Deep learning applications\"),\n",
+    "    Document(page_content=\"Reinforcement learning strategies\"),\n",
+    "    Document(page_content=\"Natural language processing techniques\"),\n",
     "]\n",
     "\n",
-    "# Rerank documents based on a query using compress_documents (returns top 5)\n",
+    "# Rerank documents based on a query using compress_documents (returns top min(5, len(documents)))\n",
     "# Reranking scores will be added to the metadata of each document under the key \"relevance_score\"\n",
     "reranked_docs = reranker.compress_documents(documents, query=\"AI and deep learning\")\n",
     "\n",
-    "print(\"Reranked documents:\")\n",
+    "print(\"Compressed documents:\")\n",
     "for doc in reranked_docs:\n",
     "    print(\"-\" * 80)\n",
     "    print(f\"Content: {doc.page_content}\")\n",
-    "    print(f\"Relevance score: {doc.metadata.get('relevance_score')}\")\n",
+    "    print(f\"Relevance score: {doc.metadata.get('relevance_score'):.4f}\")\n",
     "\n",
     "# Or use the rerank method for more control over top_n\n",
     "results = reranker.rerank(documents, query=\"machine learning\", top_n=2)\n",

langchain_hana/vectorstores/hana_db.py

@@ -840,8 +840,8 @@ def from_texts(  # type: ignore[no-untyped-def, override]
     def _validate_rerank_config(rerank_config: dict) -> None:
         if not isinstance(rerank_config, dict):
             raise ValueError("rerank_config must be a dictionary")
-        if "query" not in rerank_config or not isinstance(rerank_config["query"], str) or not rerank_config["query"]:
-            raise ValueError("rerank_config must contain 'query' and it must be a non-empty string")
+        if "query" not in rerank_config or not isinstance(rerank_config["query"], str):
+            raise ValueError("rerank_config must contain 'query' and it must be a string")
         if "top_n" in rerank_config and (not isinstance(rerank_config["top_n"], int) or rerank_config["top_n"] <= 0):
             raise ValueError("rerank_config 'top_n' must be a positive integer")
         if "rank_fields" in rerank_config:
@@ -924,7 +924,7 @@ def similarity_search_with_score(
         else:
             if rerank_config:
                 rerank_config_copy = {**rerank_config}
-                if not rerank_config.get("query"):
+                if rerank_config.get("query") is None:
                         rerank_config_copy["query"] = query  # Use the original query if no specific rerank query is provided
             else:
                 rerank_config_copy = None
@@ -1007,7 +1007,7 @@ def similarity_search_with_score_and_vector_by_query(
 
         if rerank_config:
             rerank_config_copy = {**rerank_config}
-            if not rerank_config.get("query"):
+            if rerank_config.get("query") is None:
                 rerank_config_copy["query"] = query  # Use the original query if no specific rerank query is provided
         else:
             rerank_config_copy = None

tests/integration_tests/test_hana_db.py

@@ -129,16 +129,22 @@ def build_rerank_config(base_config: dict[str, Any] | None, top_n: int, query: s
 
 
 @pytest.fixture(params=[
-    ({"query": 5}, "rerank_config must contain 'query' and it must be a non-empty string"),
+    ({"query": 5}, "rerank_config must contain 'query' and it must be a string"),
     ({"top_n": "not_an_int"}, "rerank_config 'top_n' must be a positive integer"),
     ({"model_id": 5}, "rerank_config 'model_id' must be a non-empty string"),
+    ({"model_id": ""}, "rerank_config 'model_id' must be a non-empty string"),
     ({"rank_fields": "not_a_list"}, "rerank_config 'rank_fields' must be a list of strings"),
     ({"rank_fields": [1, 2, 3]}, "rerank_config 'rank_fields' must be a list of strings")
-], ids=["query_not_str", "top_n_not_int", "model_id_not_str", "rank_fields_not_list", "rank_fields_not_str"])
+], ids=["query_not_str", "top_n_not_int", "model_id_not_str", "model_id_empty_str", "rank_fields_not_list", "rank_fields_not_str"])
 def invalid_rerank_config_with_error_message(request):
     return request.param
 
 
+@pytest.fixture
+def invalid_rerank_config_non_existent_model_id():
+    return {"query": "test_query", "model_id": "non_existing_model"}
+
+
 @pytest.mark.skipif(not hanadb_installed, reason="hanadb not installed")
 def test_hanavector_non_existing_table(table_name_with_cleanup) -> None:
     """Test end to end construction and search."""
@@ -365,9 +371,9 @@ def test_hanavector_similarity_search_simple_invalid_rerank_config(vectorDB, inv
 
 
 @pytest.mark.skipif(not hanadb_installed, reason="hanadb not installed")
-def test_hanavector_similarity_search_simple_invalid_rerank_model_id(vectorDB) -> None:
+def test_hanavector_similarity_search_simple_invalid_rerank_model_id(vectorDB, invalid_rerank_config_non_existent_model_id) -> None:
     with pytest.raises(dbapi.Error):
-        vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 1, rerank_config={"model_id": "non_existing_model"})
+        vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 1, rerank_config=invalid_rerank_config_non_existent_model_id)
 
 
 @pytest.mark.skipif(not hanadb_installed, reason="hanadb not installed")
@@ -408,9 +414,9 @@ def test_hanavector_similarity_search_by_vector_simple_invalid_rerank_config(vec
 
 
 @pytest.mark.skipif(not hanadb_installed, reason="hanadb not installed")
-def test_hanavector_similarity_search_by_vector_simple_invalid_rerank_model_id(vectorDB) -> None:
+def test_hanavector_similarity_search_by_vector_simple_invalid_rerank_model_id(vectorDB, invalid_rerank_config_non_existent_model_id) -> None:
     with pytest.raises(dbapi.Error):
-        vectorDB.similarity_search_by_vector(embedding.embed_query(HanaTestConstants.TEXTS[0]), 1, rerank_config={"query": HanaTestConstants.TEXTS[0], "model_id": "non_existing_model"})
+        vectorDB.similarity_search_by_vector(embedding.embed_query(HanaTestConstants.TEXTS[0]), 1, rerank_config=invalid_rerank_config_non_existent_model_id)
 
 
 @pytest.mark.skipif(not hanadb_installed, reason="hanadb not installed")
@@ -456,7 +462,7 @@ def test_hanavector_similarity_search_simple_euclidean_distance_invalid_rerank_c
 
 
 @pytest.mark.skipif(not hanadb_installed, reason="hanadb not installed")
-def test_hanavector_similarity_search_simple_euclidean_distance_invalid_rerank_model_id(table_name_with_cleanup) -> None:
+def test_hanavector_similarity_search_simple_euclidean_distance_invalid_rerank_model_id(table_name_with_cleanup, invalid_rerank_config_non_existent_model_id) -> None:
     table_name = table_name_with_cleanup
 
     # Check if table is created
@@ -469,7 +475,7 @@ def test_hanavector_similarity_search_simple_euclidean_distance_invalid_rerank_m
     )
 
     with pytest.raises(dbapi.Error):
-        vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 1, rerank_config={"model_id": "non_existing_model"})
+        vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 1, rerank_config=invalid_rerank_config_non_existent_model_id)
 
 
 @pytest.mark.skipif(not hanadb_installed, reason="hanadb not installed")
@@ -502,9 +508,9 @@ def test_hanavector_similarity_search_with_metadata_invalid_rerank_config(
 
 
 @pytest.mark.skipif(not hanadb_installed, reason="hanadb not installed")
-def test_hanavector_similarity_search_with_metadata_invalid_rerank_model_id(vectorDB) -> None:
+def test_hanavector_similarity_search_with_metadata_invalid_rerank_model_id(vectorDB, invalid_rerank_config_non_existent_model_id) -> None:
     with pytest.raises(dbapi.Error):
-        vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 3, rerank_config={"model_id": "non_existing_model"})
+        vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 3, rerank_config=invalid_rerank_config_non_existent_model_id)
 
 
 @pytest.mark.skipif(not hanadb_installed, reason="hanadb not installed")
@@ -550,9 +556,9 @@ def test_hanavector_similarity_search_with_metadata_filter_invalid_rerank_config
 
 
 @pytest.mark.skipif(not hanadb_installed, reason="hanadb not installed")
-def test_hanavector_similarity_search_with_metadata_filter_invalid_rerank_model_id(vectorDB) -> None:
+def test_hanavector_similarity_search_with_metadata_filter_invalid_rerank_model_id(vectorDB, invalid_rerank_config_non_existent_model_id) -> None:
     with pytest.raises(dbapi.Error):
-        vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 3, filter={"start": 100}, rerank_config={"model_id": "non_existing_model"})
+        vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 3, filter={"start": 100}, rerank_config=invalid_rerank_config_non_existent_model_id)
 
 
 @pytest.mark.skipif(not hanadb_installed, reason="hanadb not installed")
@@ -583,9 +589,9 @@ def test_hanavector_similarity_search_with_metadata_filter_string_invalid_rerank
 
 
 @pytest.mark.skipif(not hanadb_installed, reason="hanadb not installed")
-def test_hanavector_similarity_search_with_metadata_filter_string_invalid_rerank_model_id(vectorDB) -> None:
+def test_hanavector_similarity_search_with_metadata_filter_string_invalid_rerank_model_id(vectorDB, invalid_rerank_config_non_existent_model_id) -> None:
     with pytest.raises(dbapi.Error):
-        vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 3, filter={"quality": "bad"}, rerank_config={"model_id": "non_existing_model"})
+        vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 3, filter={"quality": "bad"}, rerank_config=invalid_rerank_config_non_existent_model_id)
 
 
 @pytest.mark.skipif(not hanadb_installed, reason="hanadb not installed")
@@ -616,9 +622,9 @@ def test_hanavector_similarity_search_with_metadata_filter_bool_invalid_rerank_c
 
 
 @pytest.mark.skipif(not hanadb_installed, reason="hanadb not installed")
-def test_hanavector_similarity_search_with_metadata_filter_bool_invalid_rerank_model_id(vectorDB) -> None:
+def test_hanavector_similarity_search_with_metadata_filter_bool_invalid_rerank_model_id(vectorDB, invalid_rerank_config_non_existent_model_id) -> None:
     with pytest.raises(dbapi.Error):
-        vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 3, filter={"ready": False}, rerank_config={"model_id": "non_existing_model"})
+        vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 3, filter={"ready": False}, rerank_config=invalid_rerank_config_non_existent_model_id)
 
 
 @pytest.mark.skipif(not hanadb_installed, reason="hanadb not installed")
@@ -667,9 +673,9 @@ def test_hanavector_similarity_search_with_score_invalid_rerank_config(vectorDB,
 
 
 @pytest.mark.skipif(not hanadb_installed, reason="hanadb not installed")
-def test_hanavector_similarity_search_with_score_invalid_rerank_model_id(vectorDB) -> None:
+def test_hanavector_similarity_search_with_score_invalid_rerank_model_id(vectorDB, invalid_rerank_config_non_existent_model_id) -> None:
     with pytest.raises(dbapi.Error):
-        vectorDB.similarity_search_with_score(HanaTestConstants.TEXTS[0], 3, rerank_config={"model_id": "non_existing_model"})
+        vectorDB.similarity_search_with_score(HanaTestConstants.TEXTS[0], 3, rerank_config=invalid_rerank_config_non_existent_model_id)
 
 
 @pytest.mark.skipif(not hanadb_installed, reason="hanadb not installed")

tests/integration_tests/test_hana_db_internal_embeddings.py

@@ -84,16 +84,22 @@ def build_rerank_config(base_config: dict[str, Any] | None, top_n: int, query: s
 
 
 @pytest.fixture(params=[
-    ({"query": 5}, "rerank_config must contain 'query' and it must be a non-empty string"),
+    ({"query": 5}, "rerank_config must contain 'query' and it must be a string"),
     ({"top_n": "not_an_int"}, "rerank_config 'top_n' must be a positive integer"),
     ({"model_id": 5}, "rerank_config 'model_id' must be a non-empty string"),
+    ({"model_id": ""}, "rerank_config 'model_id' must be a non-empty string"),
     ({"rank_fields": "not_a_list"}, "rerank_config 'rank_fields' must be a list of strings"),
     ({"rank_fields": [1, 2, 3]}, "rerank_config 'rank_fields' must be a list of strings")
-], ids=["query_not_str", "top_n_not_int", "model_id_not_str", "rank_fields_not_list", "rank_fields_not_str"])
+], ids=["query_not_str", "top_n_not_int", "model_id_not_str", "model_id_empty_str", "rank_fields_not_list", "rank_fields_not_str"])
 def invalid_rerank_config_with_error_message(request):
     return request.param
 
 
+@pytest.fixture
+def invalid_rerank_config_non_existent_model_id():
+    return {"query": "test_query", "model_id": "non_existing_model"}
+
+
 @pytest.fixture(scope="module", params=[{
     "internal_embedding_model_id": os.environ["HANA_DB_EMBEDDING_MODEL_ID"],
 }, {
@@ -247,9 +253,9 @@ def test_hanavector_similarity_search_with_metadata_filter_invalid_rerank_config
         vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 3, filter={"start": 100}, rerank_config=invalid_rerank_config)
 
 
-def test_hanavector_similarity_search_with_metadata_filter_invalid_rerank_model_id(vectorDB) -> None:
+def test_hanavector_similarity_search_with_metadata_filter_invalid_rerank_model_id(vectorDB, invalid_rerank_config_non_existent_model_id) -> None:
     with pytest.raises(dbapi.Error):
-        vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 1, filter={"start": 100}, rerank_config={"model_id": "non_existing_model"})
+        vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 1, filter={"start": 100}, rerank_config=invalid_rerank_config_non_existent_model_id)
 
 
 def test_hanavector_similarity_search_simple(vectorDB, rerank_config_param) -> None:
@@ -281,9 +287,9 @@ def test_hanavector_similarity_search_simple_invalid_rerank_config(vectorDB, inv
         vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 1, rerank_config=invalid_rerank_config)
 
 
-def test_hanavector_similarity_search_simple_invalid_rerank_model_id(vectorDB) -> None:
+def test_hanavector_similarity_search_simple_invalid_rerank_model_id(vectorDB, invalid_rerank_config_non_existent_model_id) -> None:
     with pytest.raises(dbapi.Error):
-        vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 1, rerank_config={"model_id": "non_existing_model"})
+        vectorDB.similarity_search(HanaTestConstants.TEXTS[0], 1, rerank_config=invalid_rerank_config_non_existent_model_id)
 
 
 def test_hanavector_max_marginal_relevance_search(vectorDB) -> None: