qdrant-haystack 9.1.1__py3-none-any.whl → 10.2.0__py3-none-any.whl

haystack_integrations/document_stores/qdrant/filters.py

@@ -1,198 +1,116 @@
+from collections.abc import Callable
 from datetime import datetime
-from typing import List, Optional, Union
+from typing import Any
 
 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: list[dict[str, Any]] | dict[str, Any] | models.Filter | None = None,
+) -> models.Filter | None:
     """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]) -> models.Condition | None:
+    """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,
-    should_clauses,
-    must_not_clauses,
-    qdrant_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]) -> models.Condition | None:
+    """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]) -> models.Filter | None:
+    """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 +121,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:
@@ -220,7 +135,7 @@ def _build_eq_condition(key: str, value: models.ValueVariants) -> models.Conditi
     return models.FieldCondition(key=key, match=models.MatchValue(value=value))
 
 
-def _build_in_condition(key: str, value: List[models.ValueVariants]) -> models.Condition:
+def _build_in_condition(key: str, value: list[models.ValueVariants]) -> models.Condition:
     if not isinstance(value, list):
         msg = f"Value {value} is not a list"
         raise FilterError(msg)
@@ -248,7 +163,7 @@ def _build_ne_condition(key: str, value: models.ValueVariants) -> models.Conditi
     )
 
 
-def _build_nin_condition(key: str, value: List[models.ValueVariants]) -> models.Condition:
+def _build_nin_condition(key: str, value: list[models.ValueVariants]) -> models.Condition:
     if not isinstance(value, list):
         msg = f"Value {value} is not a list"
         raise FilterError(msg)
@@ -264,9 +179,10 @@ def _build_nin_condition(key: str, value: List[models.ValueVariants]) -> models.
     )
 
 
-def _build_lt_condition(key: str, value: Union[str, float, int]) -> models.Condition:
+def _build_lt_condition(key: str, value: 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))
@@ -275,9 +191,10 @@ def _build_lt_condition(key: str, value: Union[str, float, int]) -> models.Condi
     raise FilterError(msg)
 
 
-def _build_lte_condition(key: str, value: Union[str, float, int]) -> models.Condition:
+def _build_lte_condition(key: str, value: 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))
@@ -286,9 +203,10 @@ def _build_lte_condition(key: str, value: Union[str, float, int]) -> models.Cond
     raise FilterError(msg)
 
 
-def _build_gt_condition(key: str, value: Union[str, float, int]) -> models.Condition:
+def _build_gt_condition(key: str, value: 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))
@@ -297,9 +215,10 @@ def _build_gt_condition(key: str, value: Union[str, float, int]) -> models.Condi
     raise FilterError(msg)
 
 
-def _build_gte_condition(key: str, value: Union[str, float, int]) -> models.Condition:
+def _build_gte_condition(key: str, value: 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):
+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.1.dist-info → qdrant_haystack-10.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qdrant-haystack
-Version: 9.1.1
+Version: 10.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
@@ -11,16 +11,15 @@ License-File: LICENSE.txt
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.9
-Requires-Dist: haystack-ai>=2.11.0
-Requires-Dist: qdrant-client>=1.10.0
+Requires-Python: >=3.10
+Requires-Dist: haystack-ai>=2.22.0
+Requires-Dist: qdrant-client>=1.12.0
 Description-Content-Type: text/markdown
 
 # qdrant-haystack
@@ -28,26 +27,11 @@ Description-Content-Type: text/markdown
 [![PyPI - Version](https://img.shields.io/pypi/v/qdrant-haystack.svg)](https://pypi.org/project/qdrant-haystack)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/qdrant-haystack.svg)](https://pypi.org/project/qdrant-haystack)
 
------
+- [Integration page](https://haystack.deepset.ai/integrations/qdrant-document-store)
+- [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/qdrant/CHANGELOG.md)
 
-**Table of Contents**
+---
 
-- [Installation](#installation)
-- [License](#license)
+## Contributing
 
-## Installation
-
-```console
-pip install qdrant-haystack
-```
-
-## Testing
-The test suites use Qdrant's in-memory instance. No additional steps required.
-
-```console
-hatch run test
-```
-
-## License
-
-`qdrant-haystack` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.
+Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).

qdrant_haystack-10.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=UFloH86KQGuLPu3dAVf7bS6EgTVX0FzjdxEqaSMvu4k,32593
+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=Rm5LI3Aw5gBuXwpZzvaECvpLhgSEI3zp9Va97-SfipU,2605
+haystack_integrations/document_stores/qdrant/document_store.py,sha256=XYKLXzhHdnzK6q4LFbAAxF3IBPVXnjkTMaIdC1hl9Iw,103894
+haystack_integrations/document_stores/qdrant/filters.py,sha256=uiac8igBikWb6hWpiS6SaE9N1GX52II2tOEGLC4izb0,8319
+haystack_integrations/document_stores/qdrant/migrate_to_sparse.py,sha256=DcQ9_Ilx1fgXOzjsUDpuaM9TKh2utmVm2hYFn-V2CkQ,5129
+qdrant_haystack-10.2.0.dist-info/METADATA,sha256=YfmwvqF3VOLrFWDS2znUhVUFnLmRBO59TPtra_M2XZs,1829
+qdrant_haystack-10.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+qdrant_haystack-10.2.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
+qdrant_haystack-10.2.0.dist-info/RECORD,,

{qdrant_haystack-9.1.1.dist-info → qdrant_haystack-10.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

qdrant_haystack-9.1.1.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=IKl3gHaOhDiwIgPsQm1fTBkgSPPd5OIl3XXFevnVJvk,29100
-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=a56IX_7mfESF8T4tj4Ew9aripvTkui-sl9FXCl3E1jc,70046
-haystack_integrations/document_stores/qdrant/filters.py,sha256=Nv_eKIYKwUWvldJfa0omfFQ0kgqi6L3DUFeMuIWziOY,11751
-haystack_integrations/document_stores/qdrant/migrate_to_sparse.py,sha256=2xyet1fhy2lpVTs3E75f7oR521zcjT6U2jHd4pLLgKM,4971
-qdrant_haystack-9.1.1.dist-info/METADATA,sha256=6zapHfuuI12SdXaFjpW5atJ8GKfZ6EXo_AVLGT5GT7s,1923
-qdrant_haystack-9.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-qdrant_haystack-9.1.1.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
-qdrant_haystack-9.1.1.dist-info/RECORD,,