qdrant-haystack 9.1.3__py3-none-any.whl → 9.2.0__py3-none-any.whl

haystack_integrations/components/retrievers/qdrant/retriever.py

@@ -8,6 +8,11 @@ from qdrant_client.http import models
 
 from haystack_integrations.document_stores.qdrant import QdrantDocumentStore
 
+FILTER_POLICY_MERGE_ERROR_MESSAGE = (
+    "Native Qdrant filters cannot be used with filter_policy set to MERGE. "
+    "Set filter_policy to REPLACE or use Haystack filters instead."
+)
+
 
 @component
 class QdrantEmbeddingRetriever:
@@ -153,8 +158,19 @@ class QdrantEmbeddingRetriever:
         :returns:
             The retrieved documents.
 
+        :raises ValueError: If 'filter_policy' is set to 'MERGE' and 'filters' is a native Qdrant filter.
         """
-        filters = apply_filter_policy(self._filter_policy, self._filters, filters)
+        if self._filter_policy == FilterPolicy.MERGE and (
+            isinstance(self._filters, models.Filter) or isinstance(filters, models.Filter)
+        ):
+            raise ValueError(FILTER_POLICY_MERGE_ERROR_MESSAGE)
+
+        # Replacing filters works with native Qdrant filters even if the type is wrong
+        filters = apply_filter_policy(
+            filter_policy=self._filter_policy,
+            init_filters=self._filters,  # type: ignore[arg-type]
+            runtime_filters=filters,  # type: ignore[arg-type]
+        )
 
         docs = self._document_store._query_by_embedding(
             query_embedding=query_embedding,
@@ -197,8 +213,19 @@ class QdrantEmbeddingRetriever:
         :returns:
             The retrieved documents.
 
+        :raises ValueError: If 'filter_policy' is set to 'MERGE' and 'filters' is a native Qdrant filter.
         """
-        filters = apply_filter_policy(self._filter_policy, self._filters, filters)
+        if self._filter_policy == FilterPolicy.MERGE and (
+            isinstance(self._filters, models.Filter) or isinstance(filters, models.Filter)
+        ):
+            raise ValueError(FILTER_POLICY_MERGE_ERROR_MESSAGE)
+
+        # Replacing filters works with native Qdrant filters even if the type is wrong
+        filters = apply_filter_policy(
+            filter_policy=self._filter_policy,
+            init_filters=self._filters,  # type: ignore[arg-type]
+            runtime_filters=filters,  # type: ignore[arg-type]
+        )
 
         docs = await self._document_store._query_by_embedding_async(
             query_embedding=query_embedding,
@@ -364,8 +391,19 @@ class QdrantSparseEmbeddingRetriever:
         :returns:
             The retrieved documents.
 
+        :raises ValueError: If 'filter_policy' is set to 'MERGE' and 'filters' is a native Qdrant filter.
         """
-        filters = apply_filter_policy(self._filter_policy, self._filters, filters)
+        if self._filter_policy == FilterPolicy.MERGE and (
+            isinstance(self._filters, models.Filter) or isinstance(filters, models.Filter)
+        ):
+            raise ValueError(FILTER_POLICY_MERGE_ERROR_MESSAGE)
+
+        # Replacing filters works with native Qdrant filters even if the type is wrong
+        filters = apply_filter_policy(
+            filter_policy=self._filter_policy,
+            init_filters=self._filters,  # type: ignore[arg-type]
+            runtime_filters=filters,  # type: ignore[arg-type]
+        )
 
         docs = self._document_store._query_by_sparse(
             query_sparse_embedding=query_sparse_embedding,
@@ -413,8 +451,19 @@ class QdrantSparseEmbeddingRetriever:
         :returns:
             The retrieved documents.
 
+        :raises ValueError: If 'filter_policy' is set to 'MERGE' and 'filters' is a native Qdrant filter.
         """
-        filters = apply_filter_policy(self._filter_policy, self._filters, filters)
+        if self._filter_policy == FilterPolicy.MERGE and (
+            isinstance(self._filters, models.Filter) or isinstance(filters, models.Filter)
+        ):
+            raise ValueError(FILTER_POLICY_MERGE_ERROR_MESSAGE)
+
+        # Replacing filters works with native Qdrant filters even if the type is wrong
+        filters = apply_filter_policy(
+            filter_policy=self._filter_policy,
+            init_filters=self._filters,  # type: ignore[arg-type]
+            runtime_filters=filters,  # type: ignore[arg-type]
+        )
 
         docs = await self._document_store._query_by_sparse_async(
             query_sparse_embedding=query_sparse_embedding,
@@ -579,8 +628,19 @@ class QdrantHybridRetriever:
         :returns:
             The retrieved documents.
 
+        :raises ValueError: If 'filter_policy' is set to 'MERGE' and 'filters' is a native Qdrant filter.
         """
-        filters = apply_filter_policy(self._filter_policy, self._filters, filters)
+        if self._filter_policy == FilterPolicy.MERGE and (
+            isinstance(self._filters, models.Filter) or isinstance(filters, models.Filter)
+        ):
+            raise ValueError(FILTER_POLICY_MERGE_ERROR_MESSAGE)
+
+        # Replacing filters works with native Qdrant filters even if the type is wrong
+        filters = apply_filter_policy(
+            filter_policy=self._filter_policy,
+            init_filters=self._filters,  # type: ignore[arg-type]
+            runtime_filters=filters,  # type: ignore[arg-type]
+        )
 
         docs = self._document_store._query_hybrid(
             query_embedding=query_embedding,
@@ -628,8 +688,19 @@ class QdrantHybridRetriever:
         :returns:
             The retrieved documents.
 
+        :raises ValueError: If 'filter_policy' is set to 'MERGE' and 'filters' is a native Qdrant filter.
         """
-        filters = apply_filter_policy(self._filter_policy, self._filters, filters)
+        if self._filter_policy == FilterPolicy.MERGE and (
+            isinstance(self._filters, models.Filter) or isinstance(filters, models.Filter)
+        ):
+            raise ValueError(FILTER_POLICY_MERGE_ERROR_MESSAGE)
+
+        # Replacing filters works with native Qdrant filters even if the type is wrong
+        filters = apply_filter_policy(
+            filter_policy=self._filter_policy,
+            init_filters=self._filters,  # type: ignore[arg-type]
+            runtime_filters=filters,  # type: ignore[arg-type]
+        )
 
         docs = await self._document_store._query_hybrid_async(
             query_embedding=query_embedding,

haystack_integrations/document_stores/qdrant/converters.py

@@ -37,7 +37,7 @@ def convert_haystack_documents_to_qdrant_points(
 
         else:
             vector = payload.pop("embedding") or {}
-        _id = convert_id(payload.get("id"))
+        _id = convert_id(document.id)
 
         point = rest.PointStruct(
             payload=payload,
@@ -62,19 +62,21 @@ QdrantPoint = Union[rest.ScoredPoint, rest.Record]
 
 
 def convert_qdrant_point_to_haystack_document(point: QdrantPoint, use_sparse_embeddings: bool) -> Document:
-    payload = {**point.payload}
+    payload = point.payload or {}
     payload["score"] = point.score if hasattr(point, "score") else None
 
     if not use_sparse_embeddings:
         payload["embedding"] = point.vector if hasattr(point, "vector") else None
-    elif hasattr(point, "vector") and point.vector is not None:
+    elif hasattr(point, "vector") and point.vector is not None and isinstance(point.vector, dict):
         payload["embedding"] = point.vector.get(DENSE_VECTORS_NAME)
 
         if SPARSE_VECTORS_NAME in point.vector:
-            parse_vector_dict = {
-                "indices": point.vector[SPARSE_VECTORS_NAME].indices,
-                "values": point.vector[SPARSE_VECTORS_NAME].values,
-            }
-            payload["sparse_embedding"] = parse_vector_dict
+            sparse_vector = point.vector[SPARSE_VECTORS_NAME]
+            if isinstance(sparse_vector, rest.SparseVector):
+                sparse_vector_dict = {
+                    "indices": sparse_vector.indices,
+                    "values": sparse_vector.values,
+                }
+                payload["sparse_embedding"] = sparse_vector_dict
 
     return Document.from_dict(payload)

haystack_integrations/document_stores/qdrant/document_store.py

@@ -2,7 +2,6 @@ import inspect
 from itertools import islice
 from typing import Any, AsyncGenerator, ClassVar, Dict, Generator, List, Optional, Set, Tuple, Union
 
-import numpy as np
 import qdrant_client
 from haystack import default_from_dict, default_to_dict, logging
 from haystack.dataclasses import Document
@@ -10,6 +9,7 @@ from haystack.dataclasses.sparse_embedding import SparseEmbedding
 from haystack.document_stores.errors import DocumentStoreError, DuplicateDocumentError
 from haystack.document_stores.types import DuplicatePolicy
 from haystack.utils import Secret, deserialize_secrets_inplace
+from numpy import exp
 from qdrant_client import grpc
 from qdrant_client.http import models as rest
 from qdrant_client.http.exceptions import UnexpectedResponse
@@ -18,7 +18,6 @@ from tqdm import tqdm
 from .converters import (
     DENSE_VECTORS_NAME,
     SPARSE_VECTORS_NAME,
-    QdrantPoint,
     convert_haystack_documents_to_qdrant_points,
     convert_id,
     convert_qdrant_point_to_haystack_document,
@@ -27,6 +26,12 @@ from .filters import convert_filters_to_qdrant
 
 logger = logging.getLogger(__name__)
 
+# Default group size to apply when using group_by
+# - Our methods use None as the default for optional group_size parameter.
+# - Qdrant expects an integer and internally defaults to 3 when performing grouped queries.
+# - When group_by is specified but group_size is None, we use this value instead of passing None.
+DEFAULT_GROUP_SIZE = 3
+
 
 class QdrantStoreError(DocumentStoreError):
     pass
@@ -85,7 +90,7 @@ class QdrantDocumentStore:
     ```
     """
 
-    SIMILARITY: ClassVar[Dict[str, str]] = {
+    SIMILARITY: ClassVar[Dict[str, rest.Distance]] = {
         "cosine": rest.Distance.COSINE,
         "dot_product": rest.Distance.DOT,
         "l2": rest.Distance.EUCLID,
@@ -216,8 +221,8 @@ class QdrantDocumentStore:
             List of payload fields to index.
         """
 
-        self._client = None
-        self._async_client = None
+        self._client: Optional[qdrant_client.QdrantClient] = None
+        self._async_client: Optional[qdrant_client.AsyncQdrantClient] = None
 
         # Store the Qdrant client specific attributes
         self.location = location
@@ -575,8 +580,8 @@ class QdrantDocumentStore:
                 with_vectors=True,
             )
             stop_scrolling = next_offset is None or (
-                isinstance(next_offset, grpc.PointId) and next_offset.num == 0 and next_offset.uuid == ""
-            )
+                isinstance(next_offset, grpc.PointId) and next_offset.num == 0 and next_offset.uuid == ""  # type: ignore[union-attr]
+            )  # grpc.PointId always has num and uuid
 
             for record in records:
                 yield convert_qdrant_point_to_haystack_document(
@@ -612,8 +617,8 @@ class QdrantDocumentStore:
                 with_vectors=True,
             )
             stop_scrolling = next_offset is None or (
-                isinstance(next_offset, grpc.PointId) and next_offset.num == 0 and next_offset.uuid == ""
-            )
+                isinstance(next_offset, grpc.PointId) and next_offset.num == 0 and next_offset.uuid == ""  # type: ignore[union-attr]
+            )  # grpc.PointId always has num and uuid
 
             for record in records:
                 yield convert_qdrant_point_to_haystack_document(
@@ -739,7 +744,7 @@ class QdrantDocumentStore:
                 query_filter=qdrant_filters,
                 limit=top_k,
                 group_by=group_by,
-                group_size=group_size,
+                group_size=group_size or DEFAULT_GROUP_SIZE,
                 with_vectors=return_embedding,
                 score_threshold=score_threshold,
             ).groups
@@ -801,7 +806,7 @@ class QdrantDocumentStore:
                 query_filter=qdrant_filters,
                 limit=top_k,
                 group_by=group_by,
-                group_size=group_size,
+                group_size=group_size or DEFAULT_GROUP_SIZE,
                 with_vectors=return_embedding,
                 score_threshold=score_threshold,
             ).groups
@@ -893,7 +898,7 @@ class QdrantDocumentStore:
                     query=rest.FusionQuery(fusion=rest.Fusion.RRF),
                     limit=top_k,
                     group_by=group_by,
-                    group_size=group_size,
+                    group_size=group_size or DEFAULT_GROUP_SIZE,
                     score_threshold=score_threshold,
                     with_payload=True,
                     with_vectors=return_embedding,
@@ -990,14 +995,14 @@ class QdrantDocumentStore:
                 query_filter=qdrant_filters,
                 limit=top_k,
                 group_by=group_by,
-                group_size=group_size,
+                group_size=group_size or DEFAULT_GROUP_SIZE,
                 with_vectors=return_embedding,
                 score_threshold=score_threshold,
             )
             groups = response.groups
             return self._process_group_results(groups)
         else:
-            response = await self._async_client.query_points(
+            query_response = await self._async_client.query_points(
                 collection_name=self.index,
                 query=rest.SparseVector(
                     indices=query_indices,
@@ -1009,7 +1014,7 @@ class QdrantDocumentStore:
                 with_vectors=return_embedding,
                 score_threshold=score_threshold,
             )
-            points = response.points
+            points = query_response.points
             return self._process_query_point_results(points, scale_score=scale_score)
 
     async def _query_by_embedding_async(
@@ -1054,14 +1059,14 @@ class QdrantDocumentStore:
                 query_filter=qdrant_filters,
                 limit=top_k,
                 group_by=group_by,
-                group_size=group_size,
+                group_size=group_size or DEFAULT_GROUP_SIZE,
                 with_vectors=return_embedding,
                 score_threshold=score_threshold,
             )
             groups = response.groups
             return self._process_group_results(groups)
         else:
-            response = await self._async_client.query_points(
+            query_response = await self._async_client.query_points(
                 collection_name=self.index,
                 query=query_embedding,
                 using=DENSE_VECTORS_NAME if self.use_sparse_embeddings else None,
@@ -1070,7 +1075,7 @@ class QdrantDocumentStore:
                 with_vectors=return_embedding,
                 score_threshold=score_threshold,
             )
-            points = response.points
+            points = query_response.points
             return self._process_query_point_results(points, scale_score=scale_score)
 
     async def _query_hybrid_async(
@@ -1145,14 +1150,14 @@ class QdrantDocumentStore:
                     query=rest.FusionQuery(fusion=rest.Fusion.RRF),
                     limit=top_k,
                     group_by=group_by,
-                    group_size=group_size,
+                    group_size=group_size or DEFAULT_GROUP_SIZE,
                     score_threshold=score_threshold,
                     with_payload=True,
                     with_vectors=return_embedding,
                 )
                 groups = response.groups
             else:
-                response = await self._async_client.query_points(
+                query_response = await self._async_client.query_points(
                     collection_name=self.index,
                     prefetch=[
                         rest.Prefetch(
@@ -1175,7 +1180,7 @@ class QdrantDocumentStore:
                     with_payload=True,
                     with_vectors=return_embedding,
                 )
-                points = response.points
+                points = query_response.points
 
         except Exception as e:
             msg = "Error during hybrid search"
@@ -1233,7 +1238,6 @@ class QdrantDocumentStore:
         """
         if payload_fields_to_index is not None:
             for payload_index in payload_fields_to_index:
-
                 # self._async_client is initialized at this point
                 # since _initialize_async_client() is called before this method is executed
                 assert self._async_client is not None
@@ -1359,7 +1363,7 @@ class QdrantDocumentStore:
     def recreate_collection(
         self,
         collection_name: str,
-        distance,
+        distance: rest.Distance,
         embedding_dim: int,
         on_disk: Optional[bool] = None,
         use_sparse_embeddings: Optional[bool] = None,
@@ -1402,7 +1406,7 @@ class QdrantDocumentStore:
     async def recreate_collection_async(
         self,
         collection_name: str,
-        distance,
+        distance: rest.Distance,
         embedding_dim: int,
         on_disk: Optional[bool] = None,
         use_sparse_embeddings: Optional[bool] = None,
@@ -1445,7 +1449,7 @@ class QdrantDocumentStore:
     def _handle_duplicate_documents(
         self,
         documents: List[Document],
-        policy: DuplicatePolicy = None,
+        policy: Optional[DuplicatePolicy] = None,
     ) -> List[Document]:
         """
         Checks whether any of the passed documents is already existing in the chosen index and returns a list of
@@ -1472,7 +1476,7 @@ class QdrantDocumentStore:
     async def _handle_duplicate_documents_async(
         self,
         documents: List[Document],
-        policy: DuplicatePolicy = None,
+        policy: Optional[DuplicatePolicy] = None,
     ) -> List[Document]:
         """
         Asynchronously checks whether any of the passed documents is already existing
@@ -1561,11 +1565,11 @@ class QdrantDocumentStore:
     def _prepare_collection_config(
         self,
         embedding_dim: int,
-        distance,
+        distance: rest.Distance,
         on_disk: Optional[bool] = None,
         use_sparse_embeddings: Optional[bool] = None,
         sparse_idf: bool = False,
-    ) -> Tuple[Dict[str, rest.VectorParams], Optional[Dict[str, rest.SparseVectorParams]]]:
+    ) -> Tuple[Union[Dict[str, rest.VectorParams], rest.VectorParams], Optional[Dict[str, rest.SparseVectorParams]]]:
         """
         Prepares the configuration for creating or recreating a Qdrant collection.
 
@@ -1577,12 +1581,14 @@ class QdrantDocumentStore:
             use_sparse_embeddings = self.use_sparse_embeddings
 
         # dense vectors configuration
-        vectors_config = rest.VectorParams(size=embedding_dim, on_disk=on_disk, distance=distance)
-        sparse_vectors_config = None
+        base_vectors_config = rest.VectorParams(size=embedding_dim, on_disk=on_disk, distance=distance)
+        vectors_config: Union[rest.VectorParams, Dict[str, rest.VectorParams]] = base_vectors_config
+
+        sparse_vectors_config: Optional[Dict[str, rest.SparseVectorParams]] = None
 
         if use_sparse_embeddings:
             # in this case, we need to define named vectors
-            vectors_config = {DENSE_VECTORS_NAME: vectors_config}
+            vectors_config = {DENSE_VECTORS_NAME: base_vectors_config}
 
             sparse_vectors_config = {
                 SPARSE_VECTORS_NAME: rest.SparseVectorParams(
@@ -1610,7 +1616,9 @@ class QdrantDocumentStore:
             msg = "Invalid filter syntax. See https://docs.haystack.deepset.ai/docs/metadata-filtering for details."
             raise ValueError(msg)
 
-    def _process_query_point_results(self, results: List[QdrantPoint], scale_score: bool = False) -> List[Document]:
+    def _process_query_point_results(
+        self, results: List[rest.ScoredPoint], scale_score: bool = False
+    ) -> List[Document]:
         """
         Processes query results from Qdrant.
         """
@@ -1622,10 +1630,12 @@ class QdrantDocumentStore:
         if scale_score:
             for document in documents:
                 score = document.score
+                if score is None:
+                    continue
                 if self.similarity == "cosine":
                     score = (score + 1) / 2
                 else:
-                    score = float(1 / (1 + np.exp(-score / 100)))
+                    score = float(1 / (1 + exp(-score / 100)))
                 document.score = score
 
         return documents
@@ -1647,16 +1657,22 @@ class QdrantDocumentStore:
     def _validate_collection_compatibility(
         self,
         collection_name: str,
-        collection_info,
-        distance,
+        collection_info: rest.CollectionInfo,
+        distance: rest.Distance,
         embedding_dim: int,
     ) -> None:
         """
         Validates that an existing collection is compatible with the current configuration.
         """
-        has_named_vectors = isinstance(collection_info.config.params.vectors, dict)
+        vectors_config = collection_info.config.params.vectors
 
-        if has_named_vectors and DENSE_VECTORS_NAME not in collection_info.config.params.vectors:
+        if vectors_config is None:
+            msg = f"Collection '{collection_name}' has no vector configuration."
+            raise QdrantStoreError(msg)
+
+        has_named_vectors = isinstance(vectors_config, dict)
+
+        if has_named_vectors and DENSE_VECTORS_NAME not in vectors_config:
             msg = (
                 f"Collection '{collection_name}' already exists in Qdrant, "
                 f"but it has been originally created outside of Haystack and is not supported. "
@@ -1688,11 +1704,20 @@ class QdrantDocumentStore:
 
         # Get current distance and vector size based on collection configuration
         if self.use_sparse_embeddings:
-            current_distance = collection_info.config.params.vectors[DENSE_VECTORS_NAME].distance
-            current_vector_size = collection_info.config.params.vectors[DENSE_VECTORS_NAME].size
+            if not isinstance(vectors_config, dict):
+                msg = f"Collection '{collection_name}' has invalid vector configuration for sparse embeddings."
+                raise QdrantStoreError(msg)
+
+            dense_vector_config = vectors_config[DENSE_VECTORS_NAME]
+            current_distance = dense_vector_config.distance
+            current_vector_size = dense_vector_config.size
         else:
-            current_distance = collection_info.config.params.vectors.distance
-            current_vector_size = collection_info.config.params.vectors.size
+            if isinstance(vectors_config, dict):
+                msg = f"Collection '{collection_name}' has invalid vector configuration for dense embeddings only."
+                raise QdrantStoreError(msg)
+
+            current_distance = vectors_config.distance
+            current_vector_size = vectors_config.size
 
         # Validate distance metric
         if current_distance != distance:

haystack_integrations/document_stores/qdrant/filters.py

@@ -1,198 +1,115 @@
 from datetime import datetime
-from typing import List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union
 
 from haystack.utils.filters import COMPARISON_OPERATORS, LOGICAL_OPERATORS, FilterError
 from qdrant_client.http import models
 
-COMPARISON_OPERATORS = COMPARISON_OPERATORS.keys()
-LOGICAL_OPERATORS = LOGICAL_OPERATORS.keys()
-
 
 def convert_filters_to_qdrant(
-    filter_term: Optional[Union[List[dict], dict, models.Filter]] = None, is_parent_call: bool = True
-) -> Optional[Union[models.Filter, List[models.Filter], List[models.Condition]]]:
+    filter_term: Optional[Union[List[Dict[str, Any]], Dict[str, Any], models.Filter]] = None,
+) -> Optional[models.Filter]:
     """Converts Haystack filters to the format used by Qdrant.
 
     :param filter_term: the haystack filter to be converted to qdrant.
-    :param is_parent_call: indicates if this is the top-level call to the function. If True, the function returns
-      a single models.Filter object; if False, it may return a list of filters or conditions for further processing.
-
-    :returns: a single Qdrant Filter in the parent call or a list of such Filters in recursive calls.
-
-    :raises FilterError: If the invalid filter criteria is provided or if an unknown operator is encountered.
-
+    :returns: a single Qdrant Filter or None.
+    :raises FilterError: If invalid filter criteria is provided.
     """
-
     if isinstance(filter_term, models.Filter):
         return filter_term
     if not filter_term:
         return None
 
-    must_clauses: List[models.Filter] = []
-    should_clauses: List[models.Filter] = []
-    must_not_clauses: List[models.Filter] = []
-    # Indicates if there are multiple same LOGICAL OPERATORS on each level
-    # and prevents them from being combined
-    same_operator_flag = False
-    conditions, qdrant_filter, current_level_operators = (
-        [],
-        [],
-        [],
-    )
-
     if isinstance(filter_term, dict):
         filter_term = [filter_term]
 
-    # ======== IDENTIFY FILTER ITEMS ON EACH LEVEL ========
+    conditions = _process_filter_items(filter_term)
+
+    return _build_final_filter(conditions)
 
-    for item in filter_term:
-        operator = item.get("operator")
 
-        # Check for repeated similar operators on each level
-        same_operator_flag = operator in current_level_operators and operator in LOGICAL_OPERATORS
-        if not same_operator_flag:
-            current_level_operators.append(operator)
+def _process_filter_items(filter_items: List[Dict[str, Any]]) -> List[models.Condition]:
+    """Process a list of filter items and return all conditions."""
+    all_conditions: List[models.Condition] = []
 
+    for item in filter_items:
+        operator = item.get("operator")
         if operator is None:
             msg = "Operator not found in filters"
             raise FilterError(msg)
 
-        if operator in LOGICAL_OPERATORS and "conditions" not in item:
-            msg = f"'conditions' not found for '{operator}'"
+        if operator in LOGICAL_OPERATORS:
+            condition = _process_logical_operator(item)
+            if condition:
+                all_conditions.append(condition)
+        elif operator in COMPARISON_OPERATORS:
+            condition = _process_comparison_operator(item)
+            if condition:
+                all_conditions.append(condition)
+        else:
+            msg = f"Unknown operator {operator} used in filters"
             raise FilterError(msg)
 
-        if operator in LOGICAL_OPERATORS:
-            # Recursively process nested conditions
-            current_filter = convert_filters_to_qdrant(item.get("conditions", []), is_parent_call=False) or []
-
-            # When same_operator_flag is set to True,
-            # ensure each clause is appended as an independent list to avoid merging distinct clauses.
-            if operator == "AND":
-                must_clauses = [must_clauses, current_filter] if same_operator_flag else must_clauses + current_filter
-            elif operator == "OR":
-                should_clauses = (
-                    [should_clauses, current_filter] if same_operator_flag else should_clauses + current_filter
-                )
-            elif operator == "NOT":
-                must_not_clauses = (
-                    [must_not_clauses, current_filter] if same_operator_flag else must_not_clauses + current_filter
-                )
+    return all_conditions
 
-        elif operator in COMPARISON_OPERATORS:
-            field = item.get("field")
-            value = item.get("value")
-            if field is None or value is None:
-                msg = f"'field' or 'value' not found for '{operator}'"
-                raise FilterError(msg)
 
-            parsed_conditions = _parse_comparison_operation(comparison_operation=operator, key=field, value=value)
+def _process_logical_operator(item: Dict[str, Any]) -> Optional[models.Condition]:
+    """Process a logical operator (AND, OR, NOT) and return the corresponding condition."""
+    operator = item["operator"]
+    conditions = item.get("conditions")
 
-            # check if the parsed_conditions are models.Filter or models.Condition
-            for condition in parsed_conditions:
-                if isinstance(condition, models.Filter):
-                    qdrant_filter.append(condition)
-                else:
-                    conditions.append(condition)
+    if not conditions:
+        msg = f"'conditions' not found for '{operator}'"
+        raise FilterError(msg)
 
-        else:
-            msg = f"Unknown operator {operator} used in filters"
-            raise FilterError(msg)
+    # Recursively process nested conditions
+    nested_conditions = _process_filter_items(conditions)
 
-    # ======== PROCESS FILTER ITEMS ON EACH LEVEL ========
-
-    # If same logical operators have separate clauses, create separate filters
-    if same_operator_flag:
-        qdrant_filter = build_filters_for_repeated_operators(
-            must_clauses, should_clauses, must_not_clauses, qdrant_filter
-        )
-
-    # else append a single Filter for existing clauses
-    elif must_clauses or should_clauses or must_not_clauses:
-        qdrant_filter.append(
-            models.Filter(
-                must=must_clauses or None,
-                should=should_clauses or None,
-                must_not=must_not_clauses or None,
-            )
-        )
-
-    # In case of parent call, a single Filter is returned
-    if is_parent_call:
-        # If qdrant_filter has just a single Filter in parent call,
-        # then it might be returned instead.
-        if len(qdrant_filter) == 1 and isinstance(qdrant_filter[0], models.Filter):
-            return qdrant_filter[0]
-        else:
-            must_clauses.extend(conditions)
-            return models.Filter(
-                must=must_clauses or None,
-                should=should_clauses or None,
-                must_not=must_not_clauses or None,
-            )
+    if not nested_conditions:
+        return None
 
-    # Store conditions of each level in output of the loop
-    elif conditions:
-        qdrant_filter.extend(conditions)
+    # Build the appropriate filter based on operator
+    if operator == "AND":
+        return models.Filter(must=nested_conditions)
+    elif operator == "OR":
+        return models.Filter(should=nested_conditions)
+    elif operator == "NOT":
+        return models.Filter(must_not=nested_conditions)
 
-    return qdrant_filter
+    return None
 
 
-def build_filters_for_repeated_operators(
-    must_clauses: List,
-    should_clauses: List,
-    must_not_clauses: List,
-    qdrant_filter: List[models.Filter],
-) -> List[models.Filter]:
-    """
-    Flattens the nested lists of clauses by creating separate Filters for each clause of a logical operator.
+def _process_comparison_operator(item: Dict[str, Any]) -> Optional[models.Condition]:
+    """Process a comparison operator and return the corresponding condition."""
+    operator = item["operator"]
+    field = item.get("field")
+    value = item.get("value")
 
-    :param must_clauses: a nested list of must clauses or an empty list.
-    :param should_clauses: a nested list of should clauses or an empty list.
-    :param must_not_clauses: a nested list of must_not clauses or an empty list.
-    :param qdrant_filter: a list where the generated Filter objects will be appended.
-      This list will be modified in-place.
+    if field is None or value is None:
+        msg = f"'field' or 'value' not found for '{operator}'"
+        raise FilterError(msg)
 
+    return _build_comparison_condition(operator, field, value)
 
-    :returns: the modified `qdrant_filter` list with appended generated Filter objects.
-    """
 
-    if any(isinstance(i, list) for i in must_clauses):
-        for i in must_clauses:
-            qdrant_filter.append(
-                models.Filter(
-                    must=i or None,
-                    should=should_clauses or None,
-                    must_not=must_not_clauses or None,
-                )
-            )
-    if any(isinstance(i, list) for i in should_clauses):
-        for i in should_clauses:
-            qdrant_filter.append(
-                models.Filter(
-                    must=must_clauses or None,
-                    should=i or None,
-                    must_not=must_not_clauses or None,
-                )
-            )
-    if any(isinstance(i, list) for i in must_not_clauses):
-        for i in must_clauses:
-            qdrant_filter.append(
-                models.Filter(
-                    must=must_clauses or None,
-                    should=should_clauses or None,
-                    must_not=i or None,
-                )
-            )
+def _build_final_filter(conditions: List[models.Condition]) -> Optional[models.Filter]:
+    """Build the final filter from a list of conditions."""
+    if not conditions:
+        return None
 
-    return qdrant_filter
+    if len(conditions) == 1:
+        # If single condition and it's already a Filter, return it
+        if isinstance(conditions[0], models.Filter):
+            return conditions[0]
+        # Otherwise wrap it in a Filter
+        return models.Filter(must=[conditions[0]])
 
+    # Multiple conditions - combine with AND logic
+    return models.Filter(must=conditions)
 
-def _parse_comparison_operation(
-    comparison_operation: str, key: str, value: Union[dict, List, str, float]
-) -> List[models.Condition]:
-    conditions: List[models.Condition] = []
 
-    condition_builder_mapping = {
+def _build_comparison_condition(operator: str, key: str, value: Any) -> models.Condition:
+    """Build a comparison condition based on operator, key, and value."""
+    condition_builders: Dict[str, Callable[[str, Any], models.Condition]] = {
         "==": _build_eq_condition,
         "in": _build_in_condition,
         "!=": _build_ne_condition,
@@ -203,15 +120,12 @@ def _parse_comparison_operation(
         "<=": _build_lte_condition,
     }
 
-    condition_builder = condition_builder_mapping.get(comparison_operation)
-
-    if condition_builder is None:
-        msg = f"Unknown operator {comparison_operation} used in filters"
-        raise ValueError(msg)
-
-    conditions.append(condition_builder(key, value))
+    builder = condition_builders.get(operator)
+    if builder is None:
+        msg = f"Unknown operator {operator} used in filters"
+        raise FilterError(msg)
 
-    return conditions
+    return builder(key, value)
 
 
 def _build_eq_condition(key: str, value: models.ValueVariants) -> models.Condition:
@@ -266,7 +180,8 @@ def _build_nin_condition(key: str, value: List[models.ValueVariants]) -> models.
 
 def _build_lt_condition(key: str, value: Union[str, float, int]) -> models.Condition:
     if isinstance(value, str) and is_datetime_string(value):
-        return models.FieldCondition(key=key, range=models.DatetimeRange(lt=value))
+        dt_value = datetime.fromisoformat(value)
+        return models.FieldCondition(key=key, range=models.DatetimeRange(lt=dt_value))
 
     if isinstance(value, (int, float)):
         return models.FieldCondition(key=key, range=models.Range(lt=value))
@@ -277,7 +192,8 @@ def _build_lt_condition(key: str, value: Union[str, float, int]) -> models.Condi
 
 def _build_lte_condition(key: str, value: Union[str, float, int]) -> models.Condition:
     if isinstance(value, str) and is_datetime_string(value):
-        return models.FieldCondition(key=key, range=models.DatetimeRange(lte=value))
+        dt_value = datetime.fromisoformat(value)
+        return models.FieldCondition(key=key, range=models.DatetimeRange(lte=dt_value))
 
     if isinstance(value, (int, float)):
         return models.FieldCondition(key=key, range=models.Range(lte=value))
@@ -288,7 +204,8 @@ def _build_lte_condition(key: str, value: Union[str, float, int]) -> models.Cond
 
 def _build_gt_condition(key: str, value: Union[str, float, int]) -> models.Condition:
     if isinstance(value, str) and is_datetime_string(value):
-        return models.FieldCondition(key=key, range=models.DatetimeRange(gt=value))
+        dt_value = datetime.fromisoformat(value)
+        return models.FieldCondition(key=key, range=models.DatetimeRange(gt=dt_value))
 
     if isinstance(value, (int, float)):
         return models.FieldCondition(key=key, range=models.Range(gt=value))
@@ -299,7 +216,8 @@ def _build_gt_condition(key: str, value: Union[str, float, int]) -> models.Condi
 
 def _build_gte_condition(key: str, value: Union[str, float, int]) -> models.Condition:
     if isinstance(value, str) and is_datetime_string(value):
-        return models.FieldCondition(key=key, range=models.DatetimeRange(gte=value))
+        dt_value = datetime.fromisoformat(value)
+        return models.FieldCondition(key=key, range=models.DatetimeRange(gte=dt_value))
 
     if isinstance(value, (int, float)):
         return models.FieldCondition(key=key, range=models.Range(gte=value))

haystack_integrations/document_stores/qdrant/migrate_to_sparse.py

@@ -1,17 +1,19 @@
-import logging as python_logging
+# mypy: disable-error-code="assignment, arg-type"
+
+import logging
 import time
 
-from haystack import logging
 from qdrant_client.http import models
 
 from haystack_integrations.document_stores.qdrant import QdrantDocumentStore
 
+# using Haystack logging is problematic here
 logger = logging.getLogger(__name__)
-logger.addHandler(python_logging.StreamHandler())
-logger.setLevel(python_logging.INFO)
+logger.addHandler(logging.StreamHandler())
+logger.setLevel(logging.INFO)
 
 
-def migrate_to_sparse_embeddings_support(old_document_store: QdrantDocumentStore, new_index: str) -> None:
+def migrate_to_sparse_embeddings_support(old_document_store: QdrantDocumentStore, new_index: str) -> None:  # type: ignore
     """
     Utility function to migrate an existing `QdrantDocumentStore` to a new one with support for sparse embeddings.
 
@@ -61,8 +63,10 @@ def migrate_to_sparse_embeddings_support(old_document_store: QdrantDocumentStore
     init_parameters["recreate_index"] = True
 
     new_document_store = QdrantDocumentStore(**init_parameters)
+    new_document_store._initialize_client()
+    assert new_document_store._client is not None
 
-    client = new_document_store.client
+    client = new_document_store._client
 
     original_indexing_threshold = client.get_collection(
         collection_name=new_index
@@ -115,7 +119,7 @@ def migrate_to_sparse_embeddings_support(old_document_store: QdrantDocumentStore
 
         message = (
             f"Points transmitted: {points_transmitted}/{total_points}\n"
-            f"Percent done {points_transmitted/total_points*100:.2f}%\n"
+            f"Percent done {points_transmitted / total_points * 100:.2f}%\n"
             f"Time elapsed: {time.time() - start:.2f} seconds\n"
             f"Time remaining: {(((time.time() - start) / points_transmitted) * points_remaining) / 60:.2f} minutes\n"
             f"Current offset: {next_page_offset}\n"

{qdrant_haystack-9.1.3.dist-info → qdrant_haystack-9.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qdrant-haystack
-Version: 9.1.3
+Version: 9.2.0
 Summary: An integration of Qdrant ANN vector database backend with Haystack
 Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/qdrant/README.md
@@ -45,7 +45,7 @@ pip install qdrant-haystack
 The test suites use Qdrant's in-memory instance. No additional steps required.
 
 ```console
-hatch run test
+hatch run test:all
 ```
 
 ## License

qdrant_haystack-9.2.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+haystack_integrations/components/retrievers/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haystack_integrations/components/retrievers/qdrant/__init__.py,sha256=AE1hdw4sqb0rTSqfAxKCRUOZVE8gbHdQ1wDccdN86hc,313
+haystack_integrations/components/retrievers/qdrant/retriever.py,sha256=2NcFyZQrM7USrdclYqwhFjc6xOxpxlGWrDECrQapUf4,32850
+haystack_integrations/document_stores/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haystack_integrations/document_stores/qdrant/__init__.py,sha256=kUGc5uewqArhmVR-JqB_NmJ4kNkTIQIvYDNSoO2ELn0,302
+haystack_integrations/document_stores/qdrant/converters.py,sha256=oAgBXAjIrcjWRr8SlhcNZwUeF34cviKeJnUFqhFBNBo,2642
+haystack_integrations/document_stores/qdrant/document_store.py,sha256=jOFDwEVvUFBmSdwVDhYNCq3uwVXjP9ERemWFr32OuKQ,72454
+haystack_integrations/document_stores/qdrant/filters.py,sha256=s5Y3ISe2yGfKijiiPMYA51-R54HMz2YWHXXJgQ-TL8c,8361
+haystack_integrations/document_stores/qdrant/migrate_to_sparse.py,sha256=DcQ9_Ilx1fgXOzjsUDpuaM9TKh2utmVm2hYFn-V2CkQ,5129
+qdrant_haystack-9.2.0.dist-info/METADATA,sha256=iTc-OW227ceEtgKyP9Z9UBUf5NA4y4wTi1DzYJcSAw0,1927
+qdrant_haystack-9.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+qdrant_haystack-9.2.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
+qdrant_haystack-9.2.0.dist-info/RECORD,,

qdrant_haystack-9.1.3.dist-info/RECORD

@@ -1,11 +0,0 @@
-haystack_integrations/components/retrievers/qdrant/__init__.py,sha256=AE1hdw4sqb0rTSqfAxKCRUOZVE8gbHdQ1wDccdN86hc,313
-haystack_integrations/components/retrievers/qdrant/retriever.py,sha256=Ni_aWM_JslmrWdfUl0TenOOxT15YJmMpSSSRAP3qPYs,29298
-haystack_integrations/document_stores/qdrant/__init__.py,sha256=kUGc5uewqArhmVR-JqB_NmJ4kNkTIQIvYDNSoO2ELn0,302
-haystack_integrations/document_stores/qdrant/converters.py,sha256=iVhAZ7wdRxRjfLVMHB1JdAhn7LpU5bwza1obGmEePWU,2506
-haystack_integrations/document_stores/qdrant/document_store.py,sha256=PVvWBKJZXQRG2-TiFp0lZLd7nOChVh0gIipRXoaVYaM,70829
-haystack_integrations/document_stores/qdrant/filters.py,sha256=e7y-Pqf6S2v1jd-1jCNdzD4sVGGI4x7f3Q16lP21NrQ,11790
-haystack_integrations/document_stores/qdrant/migrate_to_sparse.py,sha256=o66D6VaDEtz_zFYmZw_jsbBTXb9MGX15JnfAzyo7Wq0,4979
-qdrant_haystack-9.1.3.dist-info/METADATA,sha256=IWKyGxGKrMNSBGMUttB-28RaO_dLExuhAxn0LMJHnOc,1923
-qdrant_haystack-9.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-qdrant_haystack-9.1.3.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
-qdrant_haystack-9.1.3.dist-info/RECORD,,