qdrant-haystack 5.1.0__tar.gz → 7.0.0__tar.gz

{qdrant_haystack-5.1.0 → qdrant_haystack-7.0.0}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [integrations/qdrant-v6.0.0] - 2024-09-13
+
+## [integrations/qdrant-v5.1.0] - 2024-09-12
+
+### 🚀 Features
+
+- Qdrant - Add group_by and group_size optional parameters to Retrievers (#1054)
+
 ## [integrations/qdrant-v5.0.0] - 2024-09-02
 
 ## [integrations/qdrant-v4.2.0] - 2024-08-27

{qdrant_haystack-5.1.0 → qdrant_haystack-7.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qdrant-haystack
-Version: 5.1.0
+Version: 7.0.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

{qdrant_haystack-5.1.0 → qdrant_haystack-7.0.0}/pyproject.toml

@@ -44,6 +44,7 @@ root = "../.."
 git_describe_command = 'git describe --tags --match="integrations/qdrant-v[0-9]*"'
 
 [tool.hatch.envs.default]
+installer = "uv"
 dependencies = ["coverage[toml]>=6.5", "pytest", "pytest-rerunfailures", "haystack-pydoc-tools"]
 [tool.hatch.envs.default.scripts]
 test = "pytest {args:tests}"
@@ -58,12 +59,13 @@ docs = ["pydoc-markdown pydoc/config.yml"]
 python = ["3.8", "3.9", "3.10", "3.11"]
 
 [tool.hatch.envs.lint]
+installer = "uv"
 detached = true
-dependencies = ["black>=23.1.0", "mypy>=1.0.0", "ruff>=0.0.243"]
+dependencies = ["pip", "black>=23.1.0", "mypy>=1.0.0", "ruff>=0.0.243"]
 [tool.hatch.envs.lint.scripts]
 typing = "mypy --install-types --non-interactive --explicit-package-bases {args:src/ tests}"
-style = ["ruff check {args:. --exclude tests/, examples/}", "black --check --diff {args:.}"]
-fmt = ["black {args:.}", "ruff --fix {args:. --exclude tests/, examples/}", "style"]
+style = ["ruff check {args:.}", "black --check --diff {args:.}"]
+fmt = ["black {args:.}", "ruff check --fix {args:.}", "style"]
 all = ["style", "typing"]
 
 [tool.black]
@@ -74,6 +76,8 @@ skip-string-normalization = true
 [tool.ruff]
 target-version = "py38"
 line-length = 120
+
+[tool.ruff.lint]
 select = [
   "A",
   "ARG",
@@ -125,10 +129,10 @@ unfixable = [
   "F401",
 ]
 
-[tool.ruff.flake8-tidy-imports]
+[tool.ruff.lint.flake8-tidy-imports]
 ban-relative-imports = "parents"
 
-[tool.ruff.per-file-ignores]
+[tool.ruff.lint.per-file-ignores]
 # Tests can use magic values, assertions, and relative imports
 "tests/**/*" = ["PLR2004", "S101", "TID252"]
 # examples can contain "print" commands

{qdrant_haystack-5.1.0 → qdrant_haystack-7.0.0}/src/haystack_integrations/document_stores/qdrant/document_store.py

@@ -11,7 +11,6 @@ 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.filters import convert as convert_legacy_filters
 from qdrant_client import grpc
 from qdrant_client.http import models as rest
 from qdrant_client.http.exceptions import UnexpectedResponse
@@ -323,7 +322,8 @@ class QdrantDocumentStore:
             raise ValueError(msg)
 
         if filters and not isinstance(filters, rest.Filter) and "operator" not in filters:
-            filters = convert_legacy_filters(filters)
+            msg = "Invalid filter syntax. See https://docs.haystack.deepset.ai/docs/metadata-filtering for details."
+            raise ValueError(msg)
         return list(
             self.get_documents_generator(
                 filters,
@@ -362,7 +362,6 @@ class QdrantDocumentStore:
 
         document_objects = self._handle_duplicate_documents(
             documents=documents,
-            index=self.index,
             policy=policy,
         )
 
@@ -468,7 +467,6 @@ class QdrantDocumentStore:
     def get_documents_by_id(
         self,
         ids: List[str],
-        index: Optional[str] = None,
     ) -> List[Document]:
         """
         Retrieves documents from Qdrant by their IDs.
@@ -480,13 +478,11 @@ class QdrantDocumentStore:
         :returns:
             A list of documents.
         """
-        index = index or self.index
-
         documents: List[Document] = []
 
         ids = [convert_id(_id) for _id in ids]
         records = self.client.retrieve(
-            collection_name=index,
+            collection_name=self.index,
             ids=ids,
             with_payload=True,
             with_vectors=True,
@@ -987,7 +983,6 @@ class QdrantDocumentStore:
     def _handle_duplicate_documents(
         self,
         documents: List[Document],
-        index: Optional[str] = None,
         policy: DuplicatePolicy = None,
     ):
         """
@@ -995,31 +990,28 @@ class QdrantDocumentStore:
         documents that are not in the index yet.
 
         :param documents: A list of Haystack Document objects.
-        :param index: name of the index
         :param policy: The duplicate policy to use when writing documents.
         :returns: A list of Haystack Document objects.
         """
 
-        index = index or self.index
         if policy in (DuplicatePolicy.SKIP, DuplicatePolicy.FAIL):
-            documents = self._drop_duplicate_documents(documents, index)
-            documents_found = self.get_documents_by_id(ids=[doc.id for doc in documents], index=index)
+            documents = self._drop_duplicate_documents(documents)
+            documents_found = self.get_documents_by_id(ids=[doc.id for doc in documents])
             ids_exist_in_db: List[str] = [doc.id for doc in documents_found]
 
             if len(ids_exist_in_db) > 0 and policy == DuplicatePolicy.FAIL:
-                msg = f"Document with ids '{', '.join(ids_exist_in_db)} already exists in index = '{index}'."
+                msg = f"Document with ids '{', '.join(ids_exist_in_db)} already exists in index = '{self.index}'."
                 raise DuplicateDocumentError(msg)
 
             documents = list(filter(lambda doc: doc.id not in ids_exist_in_db, documents))
 
         return documents
 
-    def _drop_duplicate_documents(self, documents: List[Document], index: Optional[str] = None) -> List[Document]:
+    def _drop_duplicate_documents(self, documents: List[Document]) -> List[Document]:
         """
         Drop duplicate documents based on same hash ID.
 
         :param documents: A list of Haystack Document objects.
-        :param index: Name of the index.
         :returns: A list of Haystack Document objects.
         """
         _hash_ids: Set = set()
@@ -1030,7 +1022,7 @@ class QdrantDocumentStore:
                 logger.info(
                     "Duplicate Documents: Document with id '%s' already exists in index '%s'",
                     document.id,
-                    index or self.index,
+                    self.index,
                 )
                 continue
             _documents.append(document)

qdrant_haystack-5.1.0/tests/test_legacy_filters.py

@@ -1,442 +0,0 @@
-from typing import List
-
-import pytest
-from haystack import Document
-from haystack.document_stores.types import DocumentStore
-from haystack.testing.document_store import LegacyFilterDocumentsTest
-from haystack.utils.filters import FilterError
-
-from haystack_integrations.document_stores.qdrant import QdrantDocumentStore
-
-# The tests below are from haystack.testing.document_store.LegacyFilterDocumentsTest
-# Updated to include `meta` prefix for filter keys wherever necessary
-# And skip tests that are not supported in Qdrant(Dataframes, embeddings)
-
-
-class TestQdrantLegacyFilterDocuments(LegacyFilterDocumentsTest):
-    """
-    Utility class to test a Document Store `filter_documents` method using different types of legacy filters
-    """
-
-    @pytest.fixture
-    def document_store(self) -> QdrantDocumentStore:
-        return QdrantDocumentStore(
-            ":memory:",
-            recreate_index=True,
-            return_embedding=True,
-            wait_result_from_api=True,
-        )
-
-    def assert_documents_are_equal(self, received: List[Document], expected: List[Document]):
-        """
-        Assert that two lists of Documents are equal.
-        This is used in every test.
-        """
-
-        # Check that the lengths of the lists are the same
-        assert len(received) == len(expected)
-
-        # Check that the sets are equal, meaning the content and IDs match regardless of order
-        assert {doc.id for doc in received} == {doc.id for doc in expected}
-
-    def test_filter_simple_metadata_value(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.page": "100"})
-        self.assert_documents_are_equal(result, [doc for doc in filterable_docs if doc.meta.get("page") == "100"])
-
-    @pytest.mark.skip(reason="Dataframe filtering is not supported in Qdrant")
-    def test_filter_document_dataframe(self, document_store: DocumentStore, filterable_docs: List[Document]): ...
-
-    def test_eq_filter_explicit(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.page": {"$eq": "100"}})
-        self.assert_documents_are_equal(result, [doc for doc in filterable_docs if doc.meta.get("page") == "100"])
-
-    def test_eq_filter_implicit(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.page": "100"})
-        self.assert_documents_are_equal(result, [doc for doc in filterable_docs if doc.meta.get("page") == "100"])
-
-    @pytest.mark.skip(reason="Dataframe filtering is not supported in Qdrant")
-    def test_eq_filter_table(self, document_store: DocumentStore, filterable_docs: List[Document]): ...
-
-    @pytest.mark.skip(reason="Embedding filtering is not supported in Qdrant")
-    def test_eq_filter_embedding(self, document_store: DocumentStore, filterable_docs: List[Document]): ...
-
-    # LegacyFilterDocumentsNotEqualTest
-
-    def test_ne_filter(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.page": {"$ne": "100"}})
-        self.assert_documents_are_equal(result, [doc for doc in filterable_docs if doc.meta.get("page") != "100"])
-
-    @pytest.mark.skip(reason="Dataframe filtering is not supported in Qdrant")
-    def test_ne_filter_table(self, document_store: DocumentStore, filterable_docs: List[Document]): ...
-
-    @pytest.mark.skip(reason="Embedding filtering is not supported in Qdrant")
-    def test_ne_filter_embedding(self, document_store: DocumentStore, filterable_docs: List[Document]): ...
-
-    # LegacyFilterDocumentsInTest
-
-    def test_filter_simple_list_single_element(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.page": ["100"]})
-        self.assert_documents_are_equal(result, [doc for doc in filterable_docs if doc.meta.get("page") == "100"])
-
-    def test_filter_simple_list_one_value(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.page": ["100"]})
-        self.assert_documents_are_equal(result, [doc for doc in filterable_docs if doc.meta.get("page") in ["100"]])
-
-    def test_filter_simple_list(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.page": ["100", "123"]})
-        self.assert_documents_are_equal(
-            result,
-            [doc for doc in filterable_docs if doc.meta.get("page") in ["100", "123"]],
-        )
-
-    def test_incorrect_filter_value(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.page": ["nope"]})
-        self.assert_documents_are_equal(result, [])
-
-    def test_in_filter_explicit(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.page": {"$in": ["100", "123", "n.a."]}})
-        self.assert_documents_are_equal(
-            result,
-            [doc for doc in filterable_docs if doc.meta.get("page") in ["100", "123"]],
-        )
-
-    def test_in_filter_implicit(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.page": ["100", "123", "n.a."]})
-        self.assert_documents_are_equal(
-            result,
-            [doc for doc in filterable_docs if doc.meta.get("page") in ["100", "123"]],
-        )
-
-    @pytest.mark.skip(reason="Dataframe filtering is not supported in Qdrant")
-    def test_in_filter_table(self, document_store: DocumentStore, filterable_docs: List[Document]): ...
-
-    @pytest.mark.skip(reason="Embedding filtering is not supported in Qdrant")
-    def test_in_filter_embedding(self, document_store: DocumentStore, filterable_docs: List[Document]): ...
-
-    # LegacyFilterDocumentsNotInTest
-
-    @pytest.mark.skip(reason="Dataframe filtering is not supported in Qdrant")
-    def test_nin_filter_table(self, document_store: DocumentStore, filterable_docs: List[Document]): ...
-
-    @pytest.mark.skip(reason="Embedding filtering is not supported in Qdrant")
-    def test_nin_filter_embedding(self, document_store: DocumentStore, filterable_docs: List[Document]): ...
-
-    def test_nin_filter(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.page": {"$nin": ["100", "123", "n.a."]}})
-        self.assert_documents_are_equal(
-            result,
-            [doc for doc in filterable_docs if doc.meta.get("page") not in ["100", "123"]],
-        )
-
-    # LegacyFilterDocumentsGreaterThanTest
-
-    def test_gt_filter(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.number": {"$gt": 0.0}})
-        self.assert_documents_are_equal(
-            result,
-            [doc for doc in filterable_docs if "number" in doc.meta and doc.meta["number"] > 0],
-        )
-
-    def test_gt_filter_non_numeric(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        with pytest.raises(FilterError):
-            document_store.filter_documents(filters={"meta.page": {"$gt": "100"}})
-
-    @pytest.mark.skip(reason="Dataframe filtering is not supported in Qdrant")
-    def test_gt_filter_table(self, document_store: DocumentStore, filterable_docs: List[Document]): ...
-
-    @pytest.mark.skip(reason="Embedding filtering is not supported in Qdrant")
-    def test_gt_filter_embedding(self, document_store: DocumentStore, filterable_docs: List[Document]): ...
-
-    # LegacyFilterDocumentsGreaterThanEqualTest
-
-    def test_gte_filter(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.number": {"$gte": -2}})
-        self.assert_documents_are_equal(
-            result,
-            [doc for doc in filterable_docs if "number" in doc.meta and doc.meta["number"] >= -2],
-        )
-
-    def test_gte_filter_non_numeric(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        with pytest.raises(FilterError):
-            document_store.filter_documents(filters={"meta.page": {"$gte": "100"}})
-
-    @pytest.mark.skip(reason="Dataframe filtering is not supported in Qdrant")
-    def test_gte_filter_table(self, document_store: DocumentStore, filterable_docs: List[Document]): ...
-
-    @pytest.mark.skip(reason="Embedding filtering is not supported in Qdrant")
-    def test_gte_filter_embedding(self, document_store: DocumentStore, filterable_docs: List[Document]): ...
-
-    # LegacyFilterDocumentsLessThanTest
-
-    def test_lt_filter(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.number": {"$lt": 0.0}})
-        self.assert_documents_are_equal(
-            result,
-            [doc for doc in filterable_docs if doc.meta.get("number") is not None and doc.meta["number"] < 0],
-        )
-
-    def test_lt_filter_non_numeric(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        with pytest.raises(FilterError):
-            document_store.filter_documents(filters={"meta.page": {"$lt": "100"}})
-
-    @pytest.mark.skip(reason="Dataframe filtering is not supported in Qdrant")
-    def test_lt_filter_table(self, document_store: DocumentStore, filterable_docs: List[Document]): ...
-
-    @pytest.mark.skip(reason="Embedding filtering is not supported in Qdrant")
-    def test_lt_filter_embedding(self, document_store: DocumentStore, filterable_docs: List[Document]): ...
-
-    # LegacyFilterDocumentsLessThanEqualTest
-
-    def test_lte_filter(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.number": {"$lte": 2.0}})
-        self.assert_documents_are_equal(
-            result,
-            [doc for doc in filterable_docs if doc.meta.get("number") is not None and doc.meta["number"] <= 2.0],
-        )
-
-    def test_lte_filter_non_numeric(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        with pytest.raises(FilterError):
-            document_store.filter_documents(filters={"meta.page": {"$lte": "100"}})
-
-    @pytest.mark.skip(reason="Dataframe filtering is not supported in Qdrant")
-    def test_lte_filter_table(self, document_store: DocumentStore, filterable_docs: List[Document]): ...
-
-    @pytest.mark.skip(reason="Embedding filtering is not supported in Qdrant")
-    def test_lte_filter_embedding(self, document_store: DocumentStore, filterable_docs: List[Document]): ...
-
-    # LegacyFilterDocumentsSimpleLogicalTest
-
-    def test_filter_simple_or(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        filters = {
-            "$or": {
-                "meta.name": {"$in": ["name_0", "name_1"]},
-                "meta.number": {"$lt": 1.0},
-            }
-        }
-        result = document_store.filter_documents(filters=filters)
-        self.assert_documents_are_equal(
-            result,
-            [
-                doc
-                for doc in filterable_docs
-                if (doc.meta.get("number") is not None and doc.meta["number"] < 1)
-                or doc.meta.get("name") in ["name_0", "name_1"]
-            ],
-        )
-
-    def test_filter_simple_implicit_and_with_multi_key_dict(
-        self, document_store: DocumentStore, filterable_docs: List[Document]
-    ):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.number": {"$lte": 2.0, "$gte": 0.0}})
-        self.assert_documents_are_equal(
-            result,
-            [
-                doc
-                for doc in filterable_docs
-                if "number" in doc.meta and doc.meta["number"] >= 0.0 and doc.meta["number"] <= 2.0
-            ],
-        )
-
-    def test_filter_simple_explicit_and_with_list(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.number": {"$and": [{"$lte": 2}, {"$gte": 0}]}})
-        self.assert_documents_are_equal(
-            result,
-            [
-                doc
-                for doc in filterable_docs
-                if "number" in doc.meta and doc.meta["number"] <= 2.0 and doc.meta["number"] >= 0.0
-            ],
-        )
-
-    def test_filter_simple_implicit_and(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(filters={"meta.number": {"$lte": 2.0, "$gte": 0}})
-        self.assert_documents_are_equal(
-            result,
-            [
-                doc
-                for doc in filterable_docs
-                if "number" in doc.meta and doc.meta["number"] <= 2.0 and doc.meta["number"] >= 0.0
-            ],
-        )
-
-    # LegacyFilterDocumentsNestedLogicalTest(
-
-    def test_filter_nested_implicit_and(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        filters_simplified = {
-            "meta.number": {"$lte": 2, "$gte": 0},
-            "meta.name": ["name_0", "name_1"],
-        }
-        result = document_store.filter_documents(filters=filters_simplified)
-        self.assert_documents_are_equal(
-            result,
-            [
-                doc
-                for doc in filterable_docs
-                if (
-                    "number" in doc.meta
-                    and doc.meta["number"] <= 2
-                    and doc.meta["number"] >= 0
-                    and doc.meta.get("name") in ["name_0", "name_1"]
-                )
-            ],
-        )
-
-    def test_filter_nested_or(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        filters = {
-            "$or": {
-                "meta.name": {"$in": ["name_0", "name_1"]},
-                "meta.number": {"$lt": 1.0},
-            }
-        }
-        result = document_store.filter_documents(filters=filters)
-        self.assert_documents_are_equal(
-            result,
-            [
-                doc
-                for doc in filterable_docs
-                if (
-                    doc.meta.get("name") in ["name_0", "name_1"]
-                    or (doc.meta.get("number") is not None and doc.meta["number"] < 1)
-                )
-            ],
-        )
-
-    def test_filter_nested_and_or_explicit(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        filters_simplified = {
-            "$and": {
-                "meta.page": {"$eq": "123"},
-                "$or": {
-                    "meta.name": {"$in": ["name_0", "name_1"]},
-                    "meta.number": {"$lt": 1.0},
-                },
-            }
-        }
-        result = document_store.filter_documents(filters=filters_simplified)
-        self.assert_documents_are_equal(
-            result,
-            [
-                doc
-                for doc in filterable_docs
-                if (
-                    doc.meta.get("page") in ["123"]
-                    and (
-                        doc.meta.get("name") in ["name_0", "name_1"]
-                        or ("number" in doc.meta and doc.meta["number"] < 1)
-                    )
-                )
-            ],
-        )
-
-    def test_filter_nested_and_or_implicit(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        filters_simplified = {
-            "meta.page": {"$eq": "123"},
-            "$or": {
-                "meta.name": {"$in": ["name_0", "name_1"]},
-                "meta.number": {"$lt": 1.0},
-            },
-        }
-        result = document_store.filter_documents(filters=filters_simplified)
-        self.assert_documents_are_equal(
-            result,
-            [
-                doc
-                for doc in filterable_docs
-                if (
-                    doc.meta.get("page") in ["123"]
-                    and (
-                        doc.meta.get("name") in ["name_0", "name_1"]
-                        or ("number" in doc.meta and doc.meta["number"] < 1)
-                    )
-                )
-            ],
-        )
-
-    def test_filter_nested_or_and(self, document_store: DocumentStore, filterable_docs: List[Document]):
-        document_store.write_documents(filterable_docs)
-        filters_simplified = {
-            "$or": {
-                "meta.number": {"$lt": 1},
-                "$and": {
-                    "meta.name": {"$in": ["name_0", "name_1"]},
-                    "$not": {"meta.chapter": {"$eq": "intro"}},
-                },
-            }
-        }
-        result = document_store.filter_documents(filters=filters_simplified)
-        self.assert_documents_are_equal(
-            result,
-            [
-                doc
-                for doc in filterable_docs
-                if (
-                    (doc.meta.get("number") is not None and doc.meta["number"] < 1)
-                    or (doc.meta.get("name") in ["name_0", "name_1"] and (doc.meta.get("chapter") != "intro"))
-                )
-            ],
-        )
-
-    def test_filter_nested_multiple_identical_operators_same_level(
-        self, document_store: DocumentStore, filterable_docs: List[Document]
-    ):
-        document_store.write_documents(filterable_docs)
-        filters = {
-            "$or": [
-                {
-                    "$and": {
-                        "meta.name": {"$in": ["name_0", "name_1"]},
-                        "meta.page": "100",
-                    }
-                },
-                {
-                    "$and": {
-                        "meta.chapter": {"$in": ["intro", "abstract"]},
-                        "meta.page": "123",
-                    }
-                },
-            ]
-        }
-        result = document_store.filter_documents(filters=filters)
-        self.assert_documents_are_equal(
-            result,
-            [
-                doc
-                for doc in filterable_docs
-                if (
-                    (doc.meta.get("name") in ["name_0", "name_1"] and doc.meta.get("page") == "100")
-                    or (doc.meta.get("chapter") in ["intro", "abstract"] and doc.meta.get("page") == "123")
-                )
-            ],
-        )
-
-    def test_no_filter_not_empty(self, document_store: DocumentStore):
-        docs = [Document(content="test doc")]
-        document_store.write_documents(docs)
-        self.assert_documents_are_equal(document_store.filter_documents(), docs)
-        self.assert_documents_are_equal(document_store.filter_documents(filters={}), docs)