weaviate-haystack 1.0.2__tar.gz → 2.0.0__tar.gz

{weaviate_haystack-1.0.2 → weaviate_haystack-2.0.0}/.gitignore

@@ -134,3 +134,4 @@ dmypy.json
 
 # Docs generation artifacts
 _readme_*.md
+.idea

{weaviate_haystack-1.0.2 → weaviate_haystack-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: weaviate-haystack
-Version: 1.0.2
+Version: 2.0.0
 Summary: An integration of Weaviate vector database 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/weaviate/README.md
@@ -21,7 +21,7 @@ Requires-Python: >=3.8
 Requires-Dist: haystack-ai
 Requires-Dist: haystack-pydoc-tools
 Requires-Dist: python-dateutil
-Requires-Dist: weaviate-client==3.*
+Requires-Dist: weaviate-client
 Description-Content-Type: text/markdown
 
 # weaviate-haystack

{weaviate_haystack-1.0.2 → weaviate_haystack-2.0.0}/docker-compose.yml

@@ -8,7 +8,7 @@ services:
     - '8080'
     - --scheme
     - http
-    image: semitechnologies/weaviate:1.23.2
+    image: semitechnologies/weaviate:1.24.5
     ports:
     - 8080:8080
     - 50051:50051
@@ -19,4 +19,4 @@ services:
       PERSISTENCE_DATA_PATH: '/var/lib/weaviate'
       DEFAULT_VECTORIZER_MODULE: 'none'
       ENABLE_MODULES: ''
-      CLUSTER_HOSTNAME: 'node1'
+      CLUSTER_HOSTNAME: 'node1'

{weaviate_haystack-1.0.2 → weaviate_haystack-2.0.0}/pydoc/config.yml

@@ -26,6 +26,7 @@ renderer:
   order: 250
   markdown:
     descriptive_class_title: false
+    classdef_code_block: false
     descriptive_module_title: true
     add_method_class_prefix: true
     add_member_class_prefix: false

{weaviate_haystack-1.0.2 → weaviate_haystack-2.0.0}/pyproject.toml

@@ -24,7 +24,7 @@ classifiers = [
 ]
 dependencies = [
   "haystack-ai",
-  "weaviate-client==3.*",
+  "weaviate-client",
   "haystack-pydoc-tools",
   "python-dateutil",
 ]
@@ -67,12 +67,12 @@ fmt = ["black {args:.}", "ruff --fix {args:.}", "style"]
 all = ["style", "typing"]
 
 [tool.black]
-target-version = ["py37"]
+target-version = ["py38"]
 line-length = 120
 skip-string-normalization = true
 
 [tool.ruff]
-target-version = "py37"
+target-version = "py38"
 line-length = 120
 select = [
   "A",
@@ -133,17 +133,20 @@ ban-relative-imports = "parents"
 "tests/**/*" = ["PLR2004", "S101", "TID252"]
 
 [tool.coverage.run]
-source_pkgs = ["src", "tests"]
+source = ["haystack_integrations"]
 branch = true
-parallel = true
+parallel = false
 
 
-[tool.coverage.paths]
-weaviate_haystack = ["src/haystack_integrations", "*/weaviate-haystack/src"]
-tests = ["tests", "*/weaviate-haystack/tests"]
-
 [tool.coverage.report]
-exclude_lines = ["no cov", "if __name__ == .__main__.:", "if TYPE_CHECKING:"]
+omit = ["*/tests/*", "*/__init__.py"]
+show_missing=true
+exclude_lines = [
+  "no cov",
+  "if __name__ == .__main__.:",
+  "if TYPE_CHECKING:",
+]
+
 
 [[tool.mypy.overrides]]
 module = [

{weaviate_haystack-1.0.2 → weaviate_haystack-2.0.0}/src/haystack_integrations/components/retrievers/weaviate/bm25_retriever.py

@@ -7,7 +7,17 @@ from haystack_integrations.document_stores.weaviate import WeaviateDocumentStore
 @component
 class WeaviateBM25Retriever:
     """
-    Retriever that uses BM25 to find the most promising documents for a given query.
+    A component for retrieving documents from Weaviate using the BM25 algorithm.
+
+    Example usage:
+    ```python
+    from haystack_integrations.document_stores.weaviate.document_store import WeaviateDocumentStore
+    from haystack_integrations.components.retrievers.weaviate.bm25_retriever import WeaviateBM25Retriever
+
+    document_store = WeaviateDocumentStore(url="http://localhost:8080")
+    retriever = WeaviateBM25Retriever(document_store=document_store)
+    retriever.run(query="How to make a pizza", top_k=3)
+    ```
     """
 
     def __init__(
@@ -20,15 +30,24 @@ class WeaviateBM25Retriever:
         """
         Create a new instance of WeaviateBM25Retriever.
 
-        :param document_store: Instance of WeaviateDocumentStore that will be associated with this retriever.
-        :param filters: Custom filters applied when running the retriever, defaults to None
-        :param top_k: Maximum number of documents to return, defaults to 10
+        :param document_store:
+            Instance of WeaviateDocumentStore that will be used from this retriever.
+        :param filters:
+            Custom filters applied when running the retriever
+        :param top_k:
+            Maximum number of documents to return
         """
         self._document_store = document_store
         self._filters = filters or {}
         self._top_k = top_k
 
     def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
         return default_to_dict(
             self,
             filters=self._filters,
@@ -38,6 +57,14 @@ class WeaviateBM25Retriever:
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "WeaviateBM25Retriever":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+            Deserialized component.
+        """
         data["init_parameters"]["document_store"] = WeaviateDocumentStore.from_dict(
             data["init_parameters"]["document_store"]
         )
@@ -45,6 +72,16 @@ class WeaviateBM25Retriever:
 
     @component.output_types(documents=List[Document])
     def run(self, query: str, filters: Optional[Dict[str, Any]] = None, top_k: Optional[int] = None):
+        """
+        Retrieves documents from Weaviate using the BM25 algorithm.
+
+        :param query:
+            The query text.
+        :param filters:
+            Filters to use when running the retriever.
+        :param top_k:
+            The maximum number of documents to return.
+        """
         filters = filters or self._filters
         top_k = top_k or self._top_k
         documents = self._document_store._bm25_retrieval(query=query, filters=filters, top_k=top_k)

{weaviate_haystack-1.0.2 → weaviate_haystack-2.0.0}/src/haystack_integrations/components/retrievers/weaviate/embedding_retriever.py

@@ -20,16 +20,22 @@ class WeaviateEmbeddingRetriever:
         certainty: Optional[float] = None,
     ):
         """
-        Create a new instance of WeaviateEmbeddingRetriever.
-        Raises ValueError if both `distance` and `certainty` are provided.
-        See the official Weaviate documentation to learn more about the `distance` and `certainty` parameters:
-        https://weaviate.io/developers/weaviate/api/graphql/search-operators#variables
+        Creates a new instance of WeaviateEmbeddingRetriever.
 
-        :param document_store: Instance of WeaviateDocumentStore that will be associated with this retriever.
-        :param filters: Custom filters applied when running the retriever, defaults to None
-        :param top_k: Maximum number of documents to return, defaults to 10
-        :param distance: The maximum allowed distance between Documents' embeddings, defaults to None
-        :param certainty: Normalized distance between the result item and the search vector, defaults to None
+        :param document_store:
+            Instance of WeaviateDocumentStore that will be used from this retriever.
+        :param filters:
+            Custom filters applied when running the retriever.
+        :param top_k:
+            Maximum number of documents to return.
+        :param distance:
+            The maximum allowed distance between Documents' embeddings.
+        :param certainty:
+            Normalized distance between the result item and the search vector.
+        :raises ValueError:
+            If both `distance` and `certainty` are provided.
+            See https://weaviate.io/developers/weaviate/api/graphql/search-operators#variables to learn more about
+            `distance` and `certainty` parameters.
         """
         if distance is not None and certainty is not None:
             msg = "Can't use 'distance' and 'certainty' parameters together"
@@ -42,6 +48,12 @@ class WeaviateEmbeddingRetriever:
         self._certainty = certainty
 
     def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
         return default_to_dict(
             self,
             filters=self._filters,
@@ -53,6 +65,14 @@ class WeaviateEmbeddingRetriever:
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "WeaviateEmbeddingRetriever":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+            Deserialized component.
+        """
         data["init_parameters"]["document_store"] = WeaviateDocumentStore.from_dict(
             data["init_parameters"]["document_store"]
         )
@@ -67,10 +87,33 @@ class WeaviateEmbeddingRetriever:
         distance: Optional[float] = None,
         certainty: Optional[float] = None,
     ):
+        """
+        Retrieves documents from Weaviate using the vector search.
+
+        :param query_embedding:
+            Embedding of the query.
+        :param filters:
+            Filters to use when running the retriever.
+        :param top_k:
+            The maximum number of documents to return.
+        :param distance:
+            The maximum allowed distance between Documents' embeddings.
+        :param certainty:
+            Normalized distance between the result item and the search vector.
+        :raises ValueError:
+            If both `distance` and `certainty` are provided.
+            See https://weaviate.io/developers/weaviate/api/graphql/search-operators#variables to learn more about
+            `distance` and `certainty` parameters.
+        """
         filters = filters or self._filters
         top_k = top_k or self._top_k
+
         distance = distance or self._distance
         certainty = certainty or self._certainty
+        if distance is not None and certainty is not None:
+            msg = "Can't use 'distance' and 'certainty' parameters together"
+            raise ValueError(msg)
+
         documents = self._document_store._embedding_retrieval(
             query_embedding=query_embedding,
             filters=filters,

{weaviate_haystack-1.0.2 → weaviate_haystack-2.0.0}/src/haystack_integrations/document_stores/weaviate/_filters.py

@@ -4,8 +4,11 @@ from dateutil import parser
 from haystack.errors import FilterError
 from pandas import DataFrame
 
+import weaviate
+from weaviate.collections.classes.filters import Filter, FilterReturn
 
-def convert_filters(filters: Dict[str, Any]) -> Dict[str, Any]:
+
+def convert_filters(filters: Dict[str, Any]) -> FilterReturn:
     """
     Convert filters from Haystack format to Weaviate format.
     """
@@ -14,7 +17,7 @@ def convert_filters(filters: Dict[str, Any]) -> Dict[str, Any]:
         raise FilterError(msg)
 
     if "field" in filters:
-        return {"operator": "And", "operands": [_parse_comparison_condition(filters)]}
+        return Filter.all_of([_parse_comparison_condition(filters)])
     return _parse_logical_condition(filters)
 
 
@@ -29,7 +32,7 @@ OPERATOR_INVERSE = {
     "not in": "in",
     "AND": "OR",
     "OR": "AND",
-    "NOT": "AND",
+    "NOT": "OR",
 }
 
 
@@ -51,7 +54,13 @@ def _invert_condition(filters: Dict[str, Any]) -> Dict[str, Any]:
     return inverted_condition
 
 
-def _parse_logical_condition(condition: Dict[str, Any]) -> Dict[str, Any]:
+LOGICAL_OPERATORS = {
+    "AND": Filter.all_of,
+    "OR": Filter.any_of,
+}
+
+
+def _parse_logical_condition(condition: Dict[str, Any]) -> FilterReturn:
     if "operator" not in condition:
         msg = f"'operator' key missing in {condition}"
         raise FilterError(msg)
@@ -67,7 +76,7 @@ def _parse_logical_condition(condition: Dict[str, Any]) -> Dict[str, Any]:
                 operands.append(_parse_logical_condition(c))
             else:
                 operands.append(_parse_comparison_condition(c))
-        return {"operator": operator.lower().capitalize(), "operands": operands}
+        return LOGICAL_OPERATORS[operator](operands)
     elif operator == "NOT":
         inverted_conditions = _invert_condition(condition)
         return _parse_logical_condition(inverted_conditions)
@@ -76,28 +85,6 @@ def _parse_logical_condition(condition: Dict[str, Any]) -> Dict[str, Any]:
         raise FilterError(msg)
 
 
-def _infer_value_type(value: Any) -> str:
-    if value is None:
-        return "valueNull"
-
-    if isinstance(value, bool):
-        return "valueBoolean"
-    if isinstance(value, int):
-        return "valueInt"
-    if isinstance(value, float):
-        return "valueNumber"
-
-    if isinstance(value, str):
-        try:
-            parser.isoparse(value)
-            return "valueDate"
-        except ValueError:
-            return "valueText"
-
-    msg = f"Unknown value type {type(value)}"
-    raise FilterError(msg)
-
-
 def _handle_date(value: Any) -> str:
     if isinstance(value, str):
         try:
@@ -107,25 +94,22 @@ def _handle_date(value: Any) -> str:
     return value
 
 
-def _equal(field: str, value: Any) -> Dict[str, Any]:
+def _equal(field: str, value: Any) -> FilterReturn:
     if value is None:
-        return {"path": field, "operator": "IsNull", "valueBoolean": True}
-    return {"path": field, "operator": "Equal", _infer_value_type(value): _handle_date(value)}
+        return weaviate.classes.query.Filter.by_property(field).is_none(True)
+    return weaviate.classes.query.Filter.by_property(field).equal(_handle_date(value))
 
 
-def _not_equal(field: str, value: Any) -> Dict[str, Any]:
+def _not_equal(field: str, value: Any) -> FilterReturn:
     if value is None:
-        return {"path": field, "operator": "IsNull", "valueBoolean": False}
-    return {
-        "operator": "Or",
-        "operands": [
-            {"path": field, "operator": "NotEqual", _infer_value_type(value): _handle_date(value)},
-            {"path": field, "operator": "IsNull", "valueBoolean": True},
-        ],
-    }
+        return weaviate.classes.query.Filter.by_property(field).is_none(False)
 
+    return weaviate.classes.query.Filter.by_property(field).not_equal(
+        _handle_date(value)
+    ) | weaviate.classes.query.Filter.by_property(field).is_none(True)
 
-def _greater_than(field: str, value: Any) -> Dict[str, Any]:
+
+def _greater_than(field: str, value: Any) -> FilterReturn:
     if value is None:
         # When the value is None and '>' is used we create a filter that would return a Document
         # if it has a field set and not set at the same time.
@@ -144,10 +128,10 @@ def _greater_than(field: str, value: Any) -> Dict[str, Any]:
     if type(value) in [list, DataFrame]:
         msg = f"Filter value can't be of type {type(value)} using operators '>', '>=', '<', '<='"
         raise FilterError(msg)
-    return {"path": field, "operator": "GreaterThan", _infer_value_type(value): _handle_date(value)}
+    return weaviate.classes.query.Filter.by_property(field).greater_than(_handle_date(value))
 
 
-def _greater_than_equal(field: str, value: Any) -> Dict[str, Any]:
+def _greater_than_equal(field: str, value: Any) -> FilterReturn:
     if value is None:
         # When the value is None and '>=' is used we create a filter that would return a Document
         # if it has a field set and not set at the same time.
@@ -166,10 +150,10 @@ def _greater_than_equal(field: str, value: Any) -> Dict[str, Any]:
     if type(value) in [list, DataFrame]:
         msg = f"Filter value can't be of type {type(value)} using operators '>', '>=', '<', '<='"
         raise FilterError(msg)
-    return {"path": field, "operator": "GreaterThanEqual", _infer_value_type(value): _handle_date(value)}
+    return weaviate.classes.query.Filter.by_property(field).greater_or_equal(_handle_date(value))
 
 
-def _less_than(field: str, value: Any) -> Dict[str, Any]:
+def _less_than(field: str, value: Any) -> FilterReturn:
     if value is None:
         # When the value is None and '<' is used we create a filter that would return a Document
         # if it has a field set and not set at the same time.
@@ -188,10 +172,10 @@ def _less_than(field: str, value: Any) -> Dict[str, Any]:
     if type(value) in [list, DataFrame]:
         msg = f"Filter value can't be of type {type(value)} using operators '>', '>=', '<', '<='"
         raise FilterError(msg)
-    return {"path": field, "operator": "LessThan", _infer_value_type(value): _handle_date(value)}
+    return weaviate.classes.query.Filter.by_property(field).less_than(_handle_date(value))
 
 
-def _less_than_equal(field: str, value: Any) -> Dict[str, Any]:
+def _less_than_equal(field: str, value: Any) -> FilterReturn:
     if value is None:
         # When the value is None and '<=' is used we create a filter that would return a Document
         # if it has a field set and not set at the same time.
@@ -210,22 +194,23 @@ def _less_than_equal(field: str, value: Any) -> Dict[str, Any]:
     if type(value) in [list, DataFrame]:
         msg = f"Filter value can't be of type {type(value)} using operators '>', '>=', '<', '<='"
         raise FilterError(msg)
-    return {"path": field, "operator": "LessThanEqual", _infer_value_type(value): _handle_date(value)}
+    return weaviate.classes.query.Filter.by_property(field).less_or_equal(_handle_date(value))
 
 
-def _in(field: str, value: Any) -> Dict[str, Any]:
+def _in(field: str, value: Any) -> FilterReturn:
     if not isinstance(value, list):
         msg = f"{field}'s value must be a list when using 'in' or 'not in' comparators"
         raise FilterError(msg)
 
-    return {"operator": "And", "operands": [_equal(field, v) for v in value]}
+    return weaviate.classes.query.Filter.by_property(field).contains_any(value)
 
 
-def _not_in(field: str, value: Any) -> Dict[str, Any]:
+def _not_in(field: str, value: Any) -> FilterReturn:
     if not isinstance(value, list):
         msg = f"{field}'s value must be a list when using 'in' or 'not in' comparators"
         raise FilterError(msg)
-    return {"operator": "And", "operands": [_not_equal(field, v) for v in value]}
+    operands = [weaviate.classes.query.Filter.by_property(field).not_equal(v) for v in value]
+    return Filter.all_of(operands)
 
 
 COMPARISON_OPERATORS = {
@@ -240,7 +225,7 @@ COMPARISON_OPERATORS = {
 }
 
 
-def _parse_comparison_condition(condition: Dict[str, Any]) -> Dict[str, Any]:
+def _parse_comparison_condition(condition: Dict[str, Any]) -> FilterReturn:
     field: str = condition["field"]
 
     if field.startswith("meta."):
@@ -265,15 +250,11 @@ def _parse_comparison_condition(condition: Dict[str, Any]) -> Dict[str, Any]:
     return COMPARISON_OPERATORS[operator](field, value)
 
 
-def _match_no_document(field: str) -> Dict[str, Any]:
+def _match_no_document(field: str) -> FilterReturn:
     """
     Returns a filters that will match no Document, this is used to keep the behavior consistent
     between different Document Stores.
     """
-    return {
-        "operator": "And",
-        "operands": [
-            {"path": field, "operator": "IsNull", "valueBoolean": False},
-            {"path": field, "operator": "IsNull", "valueBoolean": True},
-        ],
-    }
+
+    operands = [weaviate.classes.query.Filter.by_property(field).is_none(val) for val in [False, True]]
+    return Filter.all_of(operands)