qdrant-haystack 10.2.0__tar.gz → 10.3.0__tar.gz

{qdrant_haystack-10.2.0 → qdrant_haystack-10.3.0}/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [integrations/qdrant-v10.2.1] - 2026-02-02
+
+### 📚 Documentation
+
+- Fixing `QdrantDocumentStore` docstring parsing error (#2806)
+
+
+## [integrations/qdrant-v10.2.0] - 2026-02-02
+
+### 🌀 Miscellaneous
+
+- Feat: `QdrantDocumentStore` return number deleted docs on `delete_by_filter` (#2807)
+
 ## [integrations/qdrant-v9.6.0] - 2026-02-02
 
 ### 🚀 Features

{qdrant_haystack-10.2.0 → qdrant_haystack-10.3.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: qdrant-haystack
-Version: 10.2.0
+Version: 10.3.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
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
-Author-email: Kacper Łukawski <kacper.lukawski@qdrant.com>, Anush Shetty <anush.shetty@qdrant.com>
+Author-email: deepset GmbH <info@deepset.ai>, Kacper Łukawski <kacper.lukawski@qdrant.com>, Anush Shetty <anush.shetty@qdrant.com>
 License-Expression: Apache-2.0
 License-File: LICENSE.txt
 Classifier: Development Status :: 4 - Beta
@@ -15,10 +15,11 @@ 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 :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
-Requires-Dist: haystack-ai>=2.22.0
+Requires-Dist: haystack-ai>=2.26.1
 Requires-Dist: qdrant-client>=1.12.0
 Description-Content-Type: text/markdown
 

qdrant_haystack-10.3.0/pydoc/config_docusaurus.yml

@@ -0,0 +1,15 @@
+loaders:
+  - modules:
+      - haystack_integrations.components.retrievers.qdrant.retriever
+      - haystack_integrations.document_stores.qdrant.document_store
+      - haystack_integrations.document_stores.qdrant.migrate_to_sparse
+    search_path: [../src]
+processors:
+  - type: filter
+    documented_only: true
+    skip_empty_modules: true
+renderer:
+  description: Qdrant integration for Haystack
+  id: integrations-qdrant
+  filename: qdrant.md
+  title: Qdrant

{qdrant_haystack-10.2.0 → qdrant_haystack-10.3.0}/pyproject.toml

@@ -11,6 +11,7 @@ requires-python = ">=3.10"
 license = "Apache-2.0"
 keywords = []
 authors = [
+  { name = "deepset GmbH", email = "info@deepset.ai" },
   { name = "Kacper Łukawski", email = "kacper.lukawski@qdrant.com" },
   { name = "Anush Shetty", email = "anush.shetty@qdrant.com" },
 ]
@@ -22,10 +23,14 @@ classifiers = [
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai>=2.22.0", "qdrant-client>=1.12.0"]
+dependencies = [
+  "haystack-ai>=2.26.1",
+  "qdrant-client>=1.12.0"
+]
 
 [project.urls]
 Source = "https://github.com/deepset-ai/haystack-core-integrations"
@@ -48,7 +53,7 @@ installer = "uv"
 dependencies = ["haystack-pydoc-tools", "ruff"]
 
 [tool.hatch.envs.default.scripts]
-docs = ["pydoc-markdown pydoc/config_docusaurus.yml"]
+docs = ["haystack-pydoc pydoc/config_docusaurus.yml"]
 fmt = "ruff check --fix {args}; ruff format {args}"
 fmt-check = "ruff check {args} && ruff format --check {args}"
 
@@ -84,6 +89,7 @@ line-length = 120
 [tool.ruff.lint]
 select = [
   "A",
+  "ANN",
   "ARG",
   "B",
   "C",
@@ -112,6 +118,8 @@ select = [
 ignore = [
   # Allow non-abstract empty methods in abstract base classes
   "B027",
+  # Allow Any in type annotations at dynamic boundaries
+  "ANN401",
   # Allow boolean positional values in function calls, like `dict.get(... True)`
   "FBT003",
   # Allow boolean arguments in function definition
@@ -136,7 +144,7 @@ ban-relative-imports = "parents"
 
 [tool.ruff.lint.per-file-ignores]
 # Tests can use magic values, assertions, and relative imports
-"tests/**/*" = ["PLR2004", "S101", "TID252"]
+"tests/**/*" = ["PLR2004", "S101", "TID252", "ANN"]
 # examples can contain "print" commands
 "examples/**/*" = ["T201"]
 

{qdrant_haystack-10.2.0 → qdrant_haystack-10.3.0}/src/haystack_integrations/document_stores/qdrant/document_store.py

@@ -10,6 +10,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 haystack.utils.misc import _normalize_metadata_field_name
 from numpy import exp
 from qdrant_client.http import models as rest
 from qdrant_client.http.exceptions import UnexpectedResponse
@@ -603,14 +604,59 @@ class QdrantDocumentStore:
         )
 
     @staticmethod
-    def _metadata_fields_info_from_schema(payload_schema: dict[str, Any]) -> dict[str, str]:
-        """Build field name -> type dict from Qdrant payload_schema. Used by get_metadata_fields_info (sync/async)."""
-        fields_info: dict[str, str] = {}
+    def _infer_type_from_value(value: Any) -> str:
+        """
+        Infers the type from a metadata value for get_metadata_fields_info.
+
+        Returns types matching OpenSearch format for consistency:
+        - 'keyword' for strings
+        - 'long' for integers
+        - 'float' for floats
+        - 'boolean' for booleans
+        """
+        if isinstance(value, bool):
+            return "boolean"
+        elif isinstance(value, int):
+            return "long"
+        elif isinstance(value, float):
+            return "float"
+        elif isinstance(value, str):
+            return "keyword"
+        else:
+            return "keyword"
+
+    @staticmethod
+    def _process_records_fields_info(records: list[Any], field_info: dict[str, dict[str, str]]) -> None:
+        """
+        Update field_info from a batch of Qdrant records.
+
+        Used by get_metadata_fields_info (sync/async). Extracts metadata from
+        payload["meta"] and infers types for each field.
+        """
+        for record in records:
+            if record.payload and "meta" in record.payload:
+                meta = record.payload["meta"]
+                for field_name, value in meta.items():
+                    if value is not None and field_name not in field_info:
+                        field_info[field_name] = {"type": QdrantDocumentStore._infer_type_from_value(value)}
+
+    @staticmethod
+    def _metadata_fields_info_from_schema(payload_schema: dict[str, Any]) -> dict[str, dict[str, str]]:
+        """
+        Build field name -> {type: ...} dict from Qdrant payload_schema.
+
+        Used when payload_schema has indexed metadata fields (e.g. meta.category).
+        Returns empty dict when schema has no metadata field info.
+        """
+        fields_info: dict[str, dict[str, str]] = {}
         for field_name, field_config in payload_schema.items():
-            if hasattr(field_config, "data_type"):
-                fields_info[field_name] = str(field_config.data_type)
-            else:
-                fields_info[field_name] = "unknown"
+            if field_name.startswith("meta."):
+                meta_field = field_name[5:]
+                if hasattr(field_config, "data_type"):
+                    qdrant_type = str(field_config.data_type).lower()
+                    fields_info[meta_field] = {"type": qdrant_type}
+                else:
+                    fields_info[meta_field] = {"type": "unknown"}
         return fields_info
 
     @staticmethod
@@ -978,12 +1024,19 @@ class QdrantDocumentStore:
             logger.warning(f"Error {e} when calling QdrantDocumentStore.count_documents_by_filter_async()")
             return 0
 
-    def get_metadata_fields_info(self) -> dict[str, str]:
+    def get_metadata_fields_info(self) -> dict[str, dict[str, str]]:
         """
-        Returns the information about the fields from the collection.
+        Returns the information about the metadata fields in the collection.
+
+        Since Qdrant may not have a payload schema for unindexed metadata,
+        this method scrolls through documents to infer field types from
+        payload["meta"].
 
         :returns:
-            A dictionary mapping field names to their types (e.g., {"field_name": "integer"}).
+            A dictionary mapping field names to their type information e.g.:
+            ```python
+            {"category": {"type": "keyword"}, "priority": {"type": "long"}}
+            ```
         """
         self._initialize_client()
         assert self._client is not None
@@ -991,17 +1044,41 @@ class QdrantDocumentStore:
         try:
             collection_info = self._client.get_collection(self.index)
             payload_schema = collection_info.payload_schema or {}
-            return self._metadata_fields_info_from_schema(payload_schema)
+            fields_info = self._metadata_fields_info_from_schema(payload_schema)
+
+            if not fields_info:
+                next_offset = None
+                while True:
+                    records, next_offset = self._client.scroll(
+                        collection_name=self.index,
+                        scroll_filter=None,
+                        limit=self.scroll_size,
+                        offset=next_offset,
+                        with_payload=True,
+                        with_vectors=False,
+                    )
+                    self._process_records_fields_info(records, fields_info)
+                    if self._check_stop_scrolling(next_offset):
+                        break
+
+            return fields_info
         except (UnexpectedResponse, ValueError) as e:
             logger.warning(f"Error {e} when calling QdrantDocumentStore.get_metadata_fields_info()")
             return {}
 
-    async def get_metadata_fields_info_async(self) -> dict[str, str]:
+    async def get_metadata_fields_info_async(self) -> dict[str, dict[str, str]]:
         """
-        Asynchronously returns the information about the fields from the collection.
+        Asynchronously returns the information about the metadata fields in the collection.
+
+        Since Qdrant may not have a payload schema for unindexed metadata,
+        this method scrolls through documents to infer field types from
+        payload["meta"].
 
         :returns:
-            A dictionary mapping field names to their types (e.g., {"field_name": "integer"}).
+            A dictionary mapping field names to their type information e.g.:
+            ```python
+            {"category": {"type": "keyword"}, "priority": {"type": "long"}}
+            ```
         """
         await self._initialize_async_client()
         assert self._async_client is not None
@@ -1009,7 +1086,24 @@ class QdrantDocumentStore:
         try:
             collection_info = await self._async_client.get_collection(self.index)
             payload_schema = collection_info.payload_schema or {}
-            return self._metadata_fields_info_from_schema(payload_schema)
+            fields_info = self._metadata_fields_info_from_schema(payload_schema)
+
+            if not fields_info:
+                next_offset = None
+                while True:
+                    records, next_offset = await self._async_client.scroll(
+                        collection_name=self.index,
+                        scroll_filter=None,
+                        limit=self.scroll_size,
+                        offset=next_offset,
+                        with_payload=True,
+                        with_vectors=False,
+                    )
+                    self._process_records_fields_info(records, fields_info)
+                    if self._check_stop_scrolling(next_offset):
+                        break
+
+            return fields_info
         except (UnexpectedResponse, ValueError) as e:
             logger.warning(f"Error {e} when calling QdrantDocumentStore.get_metadata_fields_info_async()")
             return {}
@@ -1021,11 +1115,13 @@ class QdrantDocumentStore:
         :param metadata_field: The metadata field key (inside ``meta``) to get the minimum and maximum values for.
 
         :returns: A dictionary with the keys "min" and "max", where each value is the minimum or maximum value of the
-                  metadata field across all documents. Returns an empty dict if no documents have the field.
+                  metadata field across all documents. Returns ``{"min": None, "max": None}`` if no documents have
+                  the field.
         """
         self._initialize_client()
         assert self._client is not None
 
+        field_name = _normalize_metadata_field_name(metadata_field)
         try:
             min_value: Any = None
             max_value: Any = None
@@ -1040,13 +1136,11 @@ class QdrantDocumentStore:
                     with_payload=True,
                     with_vectors=False,
                 )
-                min_value, max_value = self._process_records_min_max(records, metadata_field, min_value, max_value)
+                min_value, max_value = self._process_records_min_max(records, field_name, min_value, max_value)
                 if self._check_stop_scrolling(next_offset):
                     break
 
-            if min_value is not None and max_value is not None:
-                return {"min": min_value, "max": max_value}
-            return {}
+            return {"min": min_value, "max": max_value}
         except Exception as e:
             logger.warning(f"Error {e} when calling QdrantDocumentStore.get_metadata_field_min_max()")
             return {}
@@ -1058,11 +1152,13 @@ class QdrantDocumentStore:
         :param metadata_field: The metadata field key (inside ``meta``) to get the minimum and maximum values for.
 
         :returns: A dictionary with the keys "min" and "max", where each value is the minimum or maximum value of the
-                  metadata field across all documents. Returns an empty dict if no documents have the field.
+                  metadata field across all documents. Returns ``{"min": None, "max": None}`` if no documents have
+                  the field.
         """
         await self._initialize_async_client()
         assert self._async_client is not None
 
+        field_name = _normalize_metadata_field_name(metadata_field)
         try:
             min_value: Any = None
             max_value: Any = None
@@ -1077,13 +1173,11 @@ class QdrantDocumentStore:
                     with_payload=True,
                     with_vectors=False,
                 )
-                min_value, max_value = self._process_records_min_max(records, metadata_field, min_value, max_value)
+                min_value, max_value = self._process_records_min_max(records, field_name, min_value, max_value)
                 if self._check_stop_scrolling(next_offset):
                     break
 
-            if min_value is not None and max_value is not None:
-                return {"min": min_value, "max": max_value}
-            return {}
+            return {"min": min_value, "max": max_value}
         except Exception as e:
             logger.warning(f"Error {e} when calling QdrantDocumentStore.get_metadata_field_min_max_async()")
             return {}

{qdrant_haystack-10.2.0 → qdrant_haystack-10.3.0}/tests/test_document_store.py

@@ -6,8 +6,17 @@ from haystack.dataclasses import SparseEmbedding
 from haystack.document_stores.errors import DuplicateDocumentError
 from haystack.document_stores.types import DuplicatePolicy
 from haystack.testing.document_store import (
+    CountDocumentsByFilterTest,
     CountDocumentsTest,
+    CountUniqueMetadataByFilterTest,
+    DeleteAllTest,
+    DeleteByFilterTest,
     DeleteDocumentsTest,
+    FilterableDocsFixtureMixin,
+    GetMetadataFieldMinMaxTest,
+    GetMetadataFieldsInfoTest,
+    GetMetadataFieldUniqueValuesTest,
+    UpdateByFilterTest,
     WriteDocumentsTest,
     _random_embeddings,
 )
@@ -22,7 +31,20 @@ from haystack_integrations.document_stores.qdrant.document_store import (
 )
 
 
-class TestQdrantDocumentStore(CountDocumentsTest, WriteDocumentsTest, DeleteDocumentsTest):
+class TestQdrantDocumentStore(
+    CountDocumentsByFilterTest,
+    CountDocumentsTest,
+    CountUniqueMetadataByFilterTest,
+    DeleteAllTest,
+    DeleteByFilterTest,
+    DeleteDocumentsTest,
+    FilterableDocsFixtureMixin,
+    GetMetadataFieldMinMaxTest,
+    GetMetadataFieldUniqueValuesTest,
+    GetMetadataFieldsInfoTest,
+    UpdateByFilterTest,
+    WriteDocumentsTest,
+):
     @pytest.fixture
     def document_store(self) -> QdrantDocumentStore:
         return QdrantDocumentStore(
@@ -302,21 +324,6 @@ class TestQdrantDocumentStore(CountDocumentsTest, WriteDocumentsTest, DeleteDocu
             with pytest.raises(ValueError, match="different vector size"):
                 document_store._set_up_collection("test_collection", 768, False, "cosine", False, False)
 
-    def test_delete_all_documents_no_index_recreation(self, document_store):
-        document_store._initialize_client()
-
-        # write some documents
-        docs = [Document(id=str(i)) for i in range(5)]
-        document_store.write_documents(docs)
-
-        # delete all documents without recreating the index
-        document_store.delete_all_documents(recreate_index=False)
-        assert document_store.count_documents() == 0
-
-        # ensure the collection still exists by writing documents again
-        document_store.write_documents(docs)
-        assert document_store.count_documents() == 5
-
     def test_delete_all_documents_index_recreation(self, document_store):
         document_store._initialize_client()
 
@@ -340,183 +347,6 @@ class TestQdrantDocumentStore(CountDocumentsTest, WriteDocumentsTest, DeleteDocu
         document_store.write_documents(docs)
         assert document_store.count_documents() == 5
 
-    def test_delete_by_filter(self, document_store: QdrantDocumentStore):
-        docs = [
-            Document(content="Doc 1", meta={"category": "A", "year": 2023}),
-            Document(content="Doc 2", meta={"category": "B", "year": 2023}),
-            Document(content="Doc 3", meta={"category": "A", "year": 2024}),
-        ]
-        document_store.write_documents(docs)
-        assert document_store.count_documents() == 3
-
-        deleted_count = document_store.delete_by_filter(
-            filters={"field": "meta.category", "operator": "==", "value": "A"}
-        )
-        assert deleted_count == 2
-
-        # Verify only category B remains
-        remaining_docs = document_store.filter_documents()
-        assert len(remaining_docs) == 1
-        assert remaining_docs[0].meta["category"] == "B"
-
-        # Delete remaining document by year
-        deleted_count = document_store.delete_by_filter(filters={"field": "meta.year", "operator": "==", "value": 2023})
-        assert deleted_count == 1
-        assert document_store.count_documents() == 0
-
-    def test_delete_by_filter_no_matches(self, document_store: QdrantDocumentStore):
-        docs = [
-            Document(content="Doc 1", meta={"category": "A"}),
-            Document(content="Doc 2", meta={"category": "B"}),
-        ]
-        document_store.write_documents(docs)
-        assert document_store.count_documents() == 2
-
-        # try to delete documents with category="C" (no matches)
-        deleted_count = document_store.delete_by_filter(
-            filters={"field": "meta.category", "operator": "==", "value": "C"}
-        )
-        assert deleted_count == 0
-        assert document_store.count_documents() == 2
-
-    def test_delete_by_filter_advanced_filters(self, document_store: QdrantDocumentStore):
-        docs = [
-            Document(content="Doc 1", meta={"category": "A", "year": 2023, "status": "draft"}),
-            Document(content="Doc 2", meta={"category": "A", "year": 2024, "status": "published"}),
-            Document(content="Doc 3", meta={"category": "B", "year": 2023, "status": "draft"}),
-        ]
-        document_store.write_documents(docs)
-        assert document_store.count_documents() == 3
-
-        # AND condition (matches only Doc 1)
-        deleted_count = document_store.delete_by_filter(
-            filters={
-                "operator": "AND",
-                "conditions": [
-                    {"field": "meta.category", "operator": "==", "value": "A"},
-                    {"field": "meta.year", "operator": "==", "value": 2023},
-                ],
-            }
-        )
-        assert deleted_count == 1
-        assert document_store.count_documents() == 2
-
-        # OR condition (matches Doc 2 and Doc 3)
-        deleted_count = document_store.delete_by_filter(
-            filters={
-                "operator": "OR",
-                "conditions": [
-                    {"field": "meta.category", "operator": "==", "value": "B"},
-                    {"field": "meta.status", "operator": "==", "value": "published"},
-                ],
-            }
-        )
-        assert deleted_count == 2
-        assert document_store.count_documents() == 0
-
-    def test_update_by_filter(self, document_store: QdrantDocumentStore):
-        docs = [
-            Document(content="Doc 1", meta={"category": "A", "status": "draft"}),
-            Document(content="Doc 2", meta={"category": "B", "status": "draft"}),
-            Document(content="Doc 3", meta={"category": "A", "status": "draft"}),
-        ]
-        document_store.write_documents(docs)
-        assert document_store.count_documents() == 3
-
-        # Update status for category="A" documents
-        updated_count = document_store.update_by_filter(
-            filters={"field": "meta.category", "operator": "==", "value": "A"}, meta={"status": "published"}
-        )
-        assert updated_count == 2
-
-        # Verify the updated documents have the new metadata
-        published_docs = document_store.filter_documents(
-            filters={"field": "meta.status", "operator": "==", "value": "published"}
-        )
-        assert len(published_docs) == 2
-        for doc in published_docs:
-            assert doc.meta["status"] == "published"
-            assert doc.meta["category"] == "A"
-
-        # Verify documents with category="B" were not updated
-        draft_docs = document_store.filter_documents(
-            filters={"field": "meta.status", "operator": "==", "value": "draft"}
-        )
-        assert len(draft_docs) == 1
-        assert draft_docs[0].meta["category"] == "B"
-
-    def test_update_by_filter_multiple_fields(self, document_store: QdrantDocumentStore):
-        docs = [
-            Document(content="Doc 1", meta={"category": "A", "year": 2023}),
-            Document(content="Doc 2", meta={"category": "A", "year": 2023}),
-            Document(content="Doc 3", meta={"category": "B", "year": 2024}),
-        ]
-        document_store.write_documents(docs)
-        assert document_store.count_documents() == 3
-
-        # Update multiple fields for category="A" documents
-        updated_count = document_store.update_by_filter(
-            filters={"field": "meta.category", "operator": "==", "value": "A"},
-            meta={"status": "published", "reviewed": True},
-        )
-        assert updated_count == 2
-
-        # Verify updates
-        published_docs = document_store.filter_documents(
-            filters={"field": "meta.status", "operator": "==", "value": "published"}
-        )
-        assert len(published_docs) == 2
-        for doc in published_docs:
-            assert doc.meta["status"] == "published"
-            assert doc.meta["reviewed"] is True
-            assert doc.meta["category"] == "A"
-            assert doc.meta["year"] == 2023  # Existing field preserved
-
-    def test_update_by_filter_no_matches(self, document_store: QdrantDocumentStore):
-        docs = [
-            Document(content="Doc 1", meta={"category": "A"}),
-            Document(content="Doc 2", meta={"category": "B"}),
-        ]
-        document_store.write_documents(docs)
-        assert document_store.count_documents() == 2
-
-        # Try to update documents with category="C" (no matches)
-        updated_count = document_store.update_by_filter(
-            filters={"field": "meta.category", "operator": "==", "value": "C"}, meta={"status": "published"}
-        )
-        assert updated_count == 0
-        assert document_store.count_documents() == 2
-
-    def test_update_by_filter_advanced_filters(self, document_store: QdrantDocumentStore):
-        docs = [
-            Document(content="Doc 1", meta={"category": "A", "year": 2023, "status": "draft"}),
-            Document(content="Doc 2", meta={"category": "A", "year": 2024, "status": "draft"}),
-            Document(content="Doc 3", meta={"category": "B", "year": 2023, "status": "draft"}),
-        ]
-        document_store.write_documents(docs)
-        assert document_store.count_documents() == 3
-
-        # Update with AND condition
-        updated_count = document_store.update_by_filter(
-            filters={
-                "operator": "AND",
-                "conditions": [
-                    {"field": "meta.category", "operator": "==", "value": "A"},
-                    {"field": "meta.year", "operator": "==", "value": 2023},
-                ],
-            },
-            meta={"status": "published"},
-        )
-        assert updated_count == 1
-
-        # Verify only one document was updated
-        published_docs = document_store.filter_documents(
-            filters={"field": "meta.status", "operator": "==", "value": "published"}
-        )
-        assert len(published_docs) == 1
-        assert published_docs[0].meta["category"] == "A"
-        assert published_docs[0].meta["year"] == 2023
-
     def test_update_by_filter_preserves_vectors(self, document_store: QdrantDocumentStore):
         """Test that update_by_filter preserves document embeddings."""
         docs = [
@@ -539,116 +369,6 @@ class TestQdrantDocumentStore(CountDocumentsTest, WriteDocumentsTest, DeleteDocu
         assert updated_docs[0].embedding is not None
         assert len(updated_docs[0].embedding) == 768
 
-    def test_count_documents_by_filter(self, document_store: QdrantDocumentStore):
-        """Test counting documents with filters."""
-        docs = [
-            Document(content="Doc 1", meta={"category": "A", "year": 2023}),
-            Document(content="Doc 2", meta={"category": "A", "year": 2024}),
-            Document(content="Doc 3", meta={"category": "B", "year": 2023}),
-            Document(content="Doc 4", meta={"category": "B", "year": 2024}),
-        ]
-        document_store.write_documents(docs)
-
-        # Test counting all documents
-        assert document_store.count_documents() == 4
-
-        # Test counting with single filter
-        count = document_store.count_documents_by_filter(
-            filters={"field": "meta.category", "operator": "==", "value": "A"}
-        )
-        assert count == 2
-
-        # Test counting with multiple filters
-        count = document_store.count_documents_by_filter(
-            filters={
-                "operator": "AND",
-                "conditions": [
-                    {"field": "meta.category", "operator": "==", "value": "B"},
-                    {"field": "meta.year", "operator": "==", "value": 2023},
-                ],
-            }
-        )
-        assert count == 1
-
-    def test_get_metadata_fields_info(self, document_store: QdrantDocumentStore):
-        """Test getting metadata field information."""
-        docs = [
-            Document(content="Doc 1", meta={"category": "A", "score": 0.9, "tags": ["tag1", "tag2"]}),
-            Document(content="Doc 2", meta={"category": "B", "score": 0.8, "tags": ["tag2"]}),
-        ]
-        document_store.write_documents(docs)
-
-        fields_info = document_store.get_metadata_fields_info()
-        # Should return empty dict or field info depending on Qdrant collection setup
-        assert isinstance(fields_info, dict)
-
-    def test_get_metadata_field_min_max(self, document_store: QdrantDocumentStore):
-        """Test getting min/max values for a metadata field."""
-        docs = [
-            Document(content="Doc 1", meta={"score": 0.5}),
-            Document(content="Doc 2", meta={"score": 0.8}),
-            Document(content="Doc 3", meta={"score": 0.3}),
-        ]
-        document_store.write_documents(docs)
-
-        result = document_store.get_metadata_field_min_max("score")
-        assert result.get("min") == 0.3
-        assert result.get("max") == 0.8
-
-    def test_count_unique_metadata_by_filter(self, document_store: QdrantDocumentStore):
-        """Test counting unique metadata field values."""
-        docs = [
-            Document(content="Doc 1", meta={"category": "A"}),
-            Document(content="Doc 2", meta={"category": "B"}),
-            Document(content="Doc 3", meta={"category": "A"}),
-            Document(content="Doc 4", meta={"category": "C"}),
-        ]
-        document_store.write_documents(docs)
-
-        result = document_store.count_unique_metadata_by_filter(filters={}, metadata_fields=["category"])
-        assert result == {"category": 3}
-
-    def test_count_unique_metadata_by_filter_multiple_fields(self, document_store: QdrantDocumentStore):
-        """Test counting unique values for multiple metadata fields."""
-        docs = [
-            Document(content="Doc 1", meta={"category": "A", "status": "active"}),
-            Document(content="Doc 2", meta={"category": "B", "status": "active"}),
-            Document(content="Doc 3", meta={"category": "A", "status": "inactive"}),
-        ]
-        document_store.write_documents(docs)
-
-        result = document_store.count_unique_metadata_by_filter(filters={}, metadata_fields=["category", "status"])
-        assert result == {"category": 2, "status": 2}
-
-    def test_count_unique_metadata_by_filter_with_filter(self, document_store: QdrantDocumentStore):
-        """Test counting unique metadata field values with filtering."""
-        docs = [
-            Document(content="Doc 1", meta={"category": "A", "status": "active"}),
-            Document(content="Doc 2", meta={"category": "B", "status": "active"}),
-            Document(content="Doc 3", meta={"category": "A", "status": "inactive"}),
-        ]
-        document_store.write_documents(docs)
-
-        result = document_store.count_unique_metadata_by_filter(
-            filters={"field": "meta.status", "operator": "==", "value": "active"},
-            metadata_fields=["category"],
-        )
-        assert result == {"category": 2}
-
-    def test_get_metadata_field_unique_values(self, document_store: QdrantDocumentStore):
-        """Test getting unique metadata field values."""
-        docs = [
-            Document(content="Doc 1", meta={"category": "A"}),
-            Document(content="Doc 2", meta={"category": "B"}),
-            Document(content="Doc 3", meta={"category": "A"}),
-            Document(content="Doc 4", meta={"category": "C"}),
-        ]
-        document_store.write_documents(docs)
-
-        values = document_store.get_metadata_field_unique_values("category")
-        assert len(values) == 3
-        assert set(values) == {"A", "B", "C"}
-
     def test_get_metadata_field_unique_values_pagination(self, document_store: QdrantDocumentStore):
         """Test getting unique metadata field values with pagination."""
         docs = [Document(content=f"Doc {i}", meta={"value": i % 5}) for i in range(10)]

qdrant_haystack-10.2.0/pydoc/config_docusaurus.yml

@@ -1,30 +0,0 @@
-loaders:
-- ignore_when_discovered:
-  - __init__
-  modules:
-  - haystack_integrations.components.retrievers.qdrant.retriever
-  - haystack_integrations.document_stores.qdrant.document_store
-  - haystack_integrations.document_stores.qdrant.migrate_to_sparse
-  search_path:
-  - ../src
-  type: haystack_pydoc_tools.loaders.CustomPythonLoader
-processors:
-- do_not_filter_modules: false
-  documented_only: true
-  expression: null
-  skip_empty_modules: true
-  type: filter
-- type: smart
-- type: crossref
-renderer:
-  description: Qdrant integration for Haystack
-  id: integrations-qdrant
-  markdown:
-    add_member_class_prefix: false
-    add_method_class_prefix: true
-    classdef_code_block: false
-    descriptive_class_title: false
-    descriptive_module_title: true
-    filename: qdrant.md
-  title: Qdrant
-  type: haystack_pydoc_tools.renderers.DocusaurusRenderer