pinecone-haystack 6.2.0__py3-none-any.whl

haystack_integrations/document_stores/pinecone/filters.py

@@ -0,0 +1,191 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+from typing import Any
+
+from haystack.errors import FilterError
+
+
+def _normalize_filters(filters: dict[str, Any]) -> dict[str, Any]:
+    """
+    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"
+        raise FilterError(msg)
+
+    if "field" in filters:
+        return _parse_comparison_condition(filters)
+    return _parse_logical_condition(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]:
+    if "field" not in condition:
+        # 'field' key is only found in comparison dictionaries.
+        # We assume this is a logic dictionary since it's not present.
+        return _parse_logical_condition(condition)
+
+    field: str = condition["field"]
+    if "operator" not in condition:
+        msg = f"'operator' key missing in {condition}"
+        raise FilterError(msg)
+    if "value" not in condition:
+        msg = f"'value' key missing in {condition}"
+        raise FilterError(msg)
+    operator: str = condition["operator"]
+    if field.startswith("meta."):
+        # Remove the "meta." prefix if present.
+        # Documents are flattened when using the PineconeDocumentStore
+        # so we don't need to specify the "meta." prefix.
+        # Instead of raising an error we handle it gracefully.
+        field = field[5:]
+
+    value: Any = condition["value"]
+
+    return COMPARISON_OPERATORS[operator](field, value)
+
+
+def _equal(field: str, value: Any) -> dict[str, Any]:
+    supported_types = (str, int, float, bool)
+    if not isinstance(value, supported_types):
+        msg = (
+            f"Unsupported type for 'equal' comparison: {type(value)}. "
+            f"Types supported by Pinecone are: {supported_types}"
+        )
+        raise FilterError(msg)
+
+    return {field: {"$eq": value}}
+
+
+def _not_equal(field: str, value: Any) -> dict[str, Any]:
+    supported_types = (str, int, float, bool)
+    if not isinstance(value, supported_types):
+        msg = (
+            f"Unsupported type for 'not equal' comparison: {type(value)}. "
+            f"Types supported by Pinecone are: {supported_types}"
+        )
+        raise FilterError(msg)
+
+    return {field: {"$ne": value}}
+
+
+def _greater_than(field: str, value: Any) -> dict[str, Any]:
+    supported_types = (int, float)
+    if not isinstance(value, supported_types):
+        msg = (
+            f"Unsupported type for 'greater than' comparison: {type(value)}. "
+            f"Types supported by Pinecone are: {supported_types}"
+        )
+        raise FilterError(msg)
+
+    return {field: {"$gt": value}}
+
+
+def _greater_than_equal(field: str, value: Any) -> dict[str, Any]:
+    supported_types = (int, float)
+    if not isinstance(value, supported_types):
+        msg = (
+            f"Unsupported type for 'greater than equal' comparison: {type(value)}. "
+            f"Types supported by Pinecone are: {supported_types}"
+        )
+        raise FilterError(msg)
+
+    return {field: {"$gte": value}}
+
+
+def _less_than(field: str, value: Any) -> dict[str, Any]:
+    supported_types = (int, float)
+    if not isinstance(value, supported_types):
+        msg = (
+            f"Unsupported type for 'less than' comparison: {type(value)}. "
+            f"Types supported by Pinecone are: {supported_types}"
+        )
+        raise FilterError(msg)
+
+    return {field: {"$lt": value}}
+
+
+def _less_than_equal(field: str, value: Any) -> dict[str, Any]:
+    supported_types = (int, float)
+    if not isinstance(value, supported_types):
+        msg = (
+            f"Unsupported type for 'less than equal' comparison: {type(value)}. "
+            f"Types supported by Pinecone are: {supported_types}"
+        )
+        raise FilterError(msg)
+
+    return {field: {"$lte": value}}
+
+
+def _not_in(field: str, value: Any) -> dict[str, Any]:
+    if not isinstance(value, list):
+        msg = f"{field}'s value must be a list when using 'not in' comparator in Pinecone"
+        raise FilterError(msg)
+
+    supported_types = (int, float, str)
+    for v in value:
+        if not isinstance(v, supported_types):
+            msg = (
+                f"Unsupported type for 'not in' comparison: {type(v)}. "
+                f"Types supported by Pinecone are: {supported_types}"
+            )
+            raise FilterError(msg)
+
+    return {field: {"$nin": value}}
+
+
+def _in(field: str, value: Any) -> dict[str, Any]:
+    if not isinstance(value, list):
+        msg = f"{field}'s value must be a list when using 'in' comparator in Pinecone"
+        raise FilterError(msg)
+
+    supported_types = (int, float, str)
+    for v in value:
+        if not isinstance(v, supported_types):
+            msg = f"Unsupported type for 'in' comparison: {type(v)}. Types supported by Pinecone are: {supported_types}"
+            raise FilterError(msg)
+
+    return {field: {"$in": value}}
+
+
+COMPARISON_OPERATORS = {
+    "==": _equal,
+    "!=": _not_equal,
+    ">": _greater_than,
+    ">=": _greater_than_equal,
+    "<": _less_than,
+    "<=": _less_than_equal,
+    "in": _in,
+    "not in": _not_in,
+}
+
+LOGICAL_OPERATORS = {"AND": "$and", "OR": "$or"}
+
+
+def _validate_filters(filters: dict[str, Any] | None) -> None:
+    """
+    Helper method to validate filter syntax.
+    """
+    if filters and "operator" not in filters and "conditions" not in filters:
+        msg = "Invalid filter syntax. See https://docs.haystack.deepset.ai/docs/metadata-filtering for details."
+        raise ValueError(msg)

pinecone_haystack-6.2.0.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: pinecone_haystack
+Version: 6.2.0
+Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/pinecone#readme
+Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
+Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/pinecone
+Author-email: deepset GmbH <info@deepset.ai>
+License-Expression: Apache-2.0
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+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.28.0
+Requires-Dist: pinecone[asyncio]>=7.0.0
+Description-Content-Type: text/markdown
+
+# pinecone-haystack
+
+[![PyPI - Version](https://img.shields.io/pypi/v/pinecone-haystack.svg)](https://pypi.org/project/pinecone-haystack)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pinecone-haystack.svg)](https://pypi.org/project/pinecone-haystack)
+
+- [Integration page](https://haystack.deepset.ai/integrations/pinecone-document-store)
+- [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/pinecone/CHANGELOG.md)
+
+---
+
+## Contributing
+
+Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).
+
+To run integration tests locally, you need to export the `PINECONE_API_KEY` environment variable.

pinecone_haystack-6.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+haystack_integrations/components/retrievers/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haystack_integrations/components/retrievers/pinecone/__init__.py,sha256=45Ny1bezIdZ_nBB6PJce-ekkeSAP_8eYZb7mUS8KtS4,102
+haystack_integrations/components/retrievers/pinecone/embedding_retriever.py,sha256=UvSfOHyXxdmlLPmttuy8cU_Mw9w3xUU3-TyyuDI_Dx0,6983
+haystack_integrations/document_stores/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haystack_integrations/document_stores/pinecone/__init__.py,sha256=Fj-FzfUJFIlH6eOsB4XYVmw26U-Qg1gfONvsCFoKMRU,197
+haystack_integrations/document_stores/pinecone/document_store.py,sha256=WEuEItbAF2SRfkL0BVmqNJZNoIt_hiKzz6OBGEkJmzQ,46917
+haystack_integrations/document_stores/pinecone/filters.py,sha256=kBaWgFWeo6E819XJLzDj0bCIEpEbRO-jUAQue7-zkvo,6257
+pinecone_haystack-6.2.0.dist-info/METADATA,sha256=bvtSrZjOz-t1U178vfw5UkGLLjtCfFLvZC6mx9HBzR0,1870
+pinecone_haystack-6.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+pinecone_haystack-6.2.0.dist-info/RECORD,,

pinecone_haystack-6.2.0.dist-info/WHEEL

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