some logical filters

integrations/pinecone/src/pinecone_haystack/filters.py

@@ -9,7 +9,8 @@
 
 def _normalize_filters(filters: Dict[str, Any]) -> Dict[str, Any]:
     """
-    Converts Haystack filters in ElasticSearch compatible filters.
+    Converts Haystack filters in Pinecone compatible filters.
+    Reference: https://docs.pinecone.io/docs/metadata-filtering
     """
     if not isinstance(filters, dict):
         msg = "Filters must be a dictionary"
@@ -20,8 +21,22 @@ def _normalize_filters(filters: Dict[str, Any]) -> Dict[str, Any]:
     return _parse_logical_condition(filters)
 
 
-def _parse_logical_condition(filters: Dict[str, Any]) -> Dict[str, Any]:
-    return filters
+def _parse_logical_condition(condition: Dict[str, Any]) -> Dict[str, Any]:
+    if "operator" not in condition:
+        msg = f"'operator' key missing in {condition}"
+        raise FilterError(msg)
+    if "conditions" not in condition:
+        msg = f"'conditions' key missing in {condition}"
+        raise FilterError(msg)
+
+    operator = condition["operator"]
+    conditions = [_parse_comparison_condition(c) for c in condition["conditions"]]
+
+    if operator in LOGICAL_OPERATORS:
+        return {LOGICAL_OPERATORS[operator]: conditions}
+
+    msg = f"Unknown logical operator '{operator}'"
+    raise FilterError(msg)
 
 
 def _parse_comparison_condition(condition: Dict[str, Any]) -> Dict[str, Any]:
@@ -55,7 +70,7 @@ def _parse_comparison_condition(condition: Dict[str, Any]) -> Dict[str, Any]:
     if isinstance(value, DataFrame):
         value = value.to_json()
 
-    return {"$and": [COMPARISON_OPERATORS[operator](field, value)]}
+    return COMPARISON_OPERATORS[operator](field, value)
 
 
 def _equal(field: str, value: Any) -> Dict[str, Any]:
@@ -174,3 +189,5 @@ def _in(field: str, value: Any) -> Dict[str, Any]:
     "in": _in,
     "not in": _not_in,
 }
+
+LOGICAL_OPERATORS = {"AND": "$and", "OR": "$or"}

integrations/pinecone/tests/test_filters.py

@@ -13,24 +13,23 @@ def assert_documents_are_equal(self, received: List[Document], expected: List[Do
         The PineconeDocumentStore.filter_documents() method returns a Documents with their score set.
         We don't want to compare the score, so we set it to None before comparing the documents.
         """
+
         for doc in received:
             doc.score = None
             # Pinecone seems to convert strings to datetime objects (undocumented behavior)
             # We convert them back to strings to compare them
             if "date" in doc.meta:
                 doc.meta["date"] = doc.meta["date"].isoformat()
-
             # Pinecone seems to convert integers to floats (undocumented behavior)
             # We convert them back to integers to compare them
             if "number" in doc.meta:
                 doc.meta["number"] = int(doc.meta["number"])
 
-        # let's compare the documents
+        # Lists comparison
         assert len(received) == len(expected)
-        for received_doc in received:
-            id_ = received_doc.id
-            expected_doc = next(filter(lambda x: x.id == id_, expected))
-
+        received.sort(key=lambda x: x.id)
+        expected.sort(key=lambda x: x.id)
+        for received_doc, expected_doc in zip(received, expected):
             assert received_doc.meta == expected_doc.meta
             assert received_doc.content == expected_doc.content
             if received_doc.dataframe is None: