weaviate-haystack 7.7.0__tar.gz → 7.9.0__tar.gz

{weaviate_haystack-7.7.0 → weaviate_haystack-7.9.0}/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [integrations/weaviate-v7.8.0] - 2026-09-01
+
+### 🐛 Bug Fixes
+
+- `Weaviate` match `search_term` against metadata field value, not content + default size value set to 10 (#3643)
+- Fix new issues raised by ruff 0.16.0 (#3670)
+- `WeaviateDocumentStore` get_metadata_field_unique_values setting list of values to return to `Any` (#3708)
+- Weaviate adding optional parameter `filters` to `get_metadata_field_unique_values()` (#3741)
+- Standardize license files (#3771)
+
+### 🧪 Testing
+
+- `WeaviateDocumentStore` removing duplicated tests already covered by haystack Mixin tests (#3787)
+
+
+## [integrations/weaviate-v7.7.0] - 2026-07-22
+
+### 🚜 Refactor
+
+- Align Weaviate closing methods to standard (#3630)
+
+
 ## [integrations/weaviate-v7.6.0] - 2026-06-22
 
 ### 🐛 Bug Fixes
@@ -200,21 +222,20 @@
 
 ### 🧹 Chores
 
-- Weaviate - remove legacy filter support (#1070)
 - Update changelog after removing legacy filters (#1083)
 - Update ruff linting scripts and settings (#1105)
 
+## [integrations/weaviate-v3.0.0] - 2024-09-12
 
-## [integrations/weaviate-v2.2.1] - 2024-09-07
+### 🧹 Chores
 
-### 🚀 Features
+- Weaviate - remove legacy filter support (#1070)
 
-- Add filter_policy to weaviate integration (#824)
+
+## [integrations/weaviate-v2.2.1] - 2024-09-07
 
 ### 🐛 Bug Fixes
 
-- Weaviate filter error (#811)
-- Fix connection to Weaviate Cloud Service (#624)
 - Pin weaviate-client (#1046)
 - Weaviate - fix connection issues with some WCS URLs (#1058)
 
@@ -222,9 +243,27 @@
 
 - Do not retry tests in `hatch run test` command (#954)
 
-### ⚙️ CI
+### 🌀 Miscellaneous
 
-- Retry tests to reduce flakyness (#836)
+- Chore: weaviate - ruff update, don't ruff tests (#986)
+
+## [integrations/weaviate-v2.2.0] - 2024-08-02
+
+### 🌀 Miscellaneous
+
+- Fix: Weaviate: Use collections.list_all instead of collections._get_all (#921)
+
+## [integrations/weaviate-v2.1.3] - 2024-07-17
+
+### 🌀 Miscellaneous
+
+- Fix: `weaviate` - Fallback to default filter policy when deserializing retrievers without the init parameter  (#903)
+
+## [integrations/weaviate-v2.1.2] - 2024-07-15
+
+### 🚀 Features
+
+- Add filter_policy to weaviate integration (#824)
 
 ### 🧹 Chores
 
@@ -232,15 +271,24 @@
 
 ### 🌀 Miscellaneous
 
+- Chore: Minor retriever pydoc fix (#884)
+
+## [integrations/weaviate-v2.1.1] - 2024-06-25
+
+### 🐛 Bug Fixes
+
+- Weaviate filter error (#811)
+- Fix connection to Weaviate Cloud Service (#624)
+
+### ⚙️ CI
+
+- Retry tests to reduce flakyness (#836)
+
+### 🌀 Miscellaneous
+
 - Handle connection to WCS and add tests
 - Revert "Handle connection to WCS and add tests"
-
-This reverts commit f48802b2ce612896fd06a13cf33dffd9f77a8859.
 - Ci: install `pytest-rerunfailures` where needed; add retry config to `test-cov` script (#845)
-- Chore: Minor retriever pydoc fix (#884)
-- Fix: `weaviate` - Fallback to default filter policy when deserializing retrievers without the init parameter  (#903)
-- Fix: Weaviate: Use collections.list_all instead of collections._get_all (#921)
-- Chore: weaviate - ruff update, don't ruff tests (#986)
 
 ## [integrations/weaviate-v2.1.0] - 2024-06-10
 

{weaviate_haystack-7.7.0 → weaviate_haystack-7.9.0}/LICENSE.txt

@@ -58,7 +58,7 @@ APPENDIX: How to apply the Apache License to your work.
 
 To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.
 
-Copyright [yyyy] [name of copyright owner]
+Copyright 2023-present deepset GmbH
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

{weaviate_haystack-7.7.0 → weaviate_haystack-7.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: weaviate-haystack
-Version: 7.7.0
+Version: 7.9.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 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
 Requires-Dist: haystack-ai>=2.28.0
 Requires-Dist: python-dateutil>=2.7.0
-Requires-Dist: weaviate-client>=4.20
+Requires-Dist: weaviate-client>=4.23.0
 Description-Content-Type: text/markdown
 
 # weaviate-haystack

{weaviate_haystack-7.7.0 → weaviate_haystack-7.9.0}/docker-compose.yml

@@ -7,7 +7,7 @@ services:
     - '8080'
     - --scheme
     - http
-    image: semitechnologies/weaviate:1.36.2
+    image: cr.weaviate.io/semitechnologies/weaviate:1.39.4
     ports:
     - 8080:8080
     - 50051:50051
@@ -18,4 +18,16 @@ services:
       PERSISTENCE_DATA_PATH: '/var/lib/weaviate'
       DEFAULT_VECTORIZER_MODULE: 'none'
       ENABLE_MODULES: ''
-      CLUSTER_HOSTNAME: 'node1'
+      CLUSTER_HOSTNAME: 'node1'
+    healthcheck:
+      test:
+      - CMD
+      - busybox
+      - wget
+      - -q
+      - -O
+      - '-'
+      - http://127.0.0.1:8080/v1/.well-known/ready
+      interval: 5s
+      timeout: 3s
+      retries: 20

{weaviate_haystack-7.7.0 → weaviate_haystack-7.9.0}/pyproject.toml

@@ -25,7 +25,7 @@ classifiers = [
 ]
 dependencies = [
   "haystack-ai>=2.28.0",
-  "weaviate-client>=4.20",
+  "weaviate-client>=4.23.0",
   "python-dateutil>=2.7.0",
 ]
 
@@ -136,6 +136,7 @@ ignore = [
   "PLR0912",
   "PLR0913",
   "PLR0915",
+  "PLR0917",
 ]
 
 [tool.ruff.lint.isort]

{weaviate_haystack-7.7.0 → weaviate_haystack-7.9.0}/src/haystack_integrations/document_stores/weaviate/document_store.py

@@ -4,6 +4,7 @@
 
 import base64
 import datetime
+import importlib.metadata
 import json
 from contextlib import suppress
 from dataclasses import asdict
@@ -38,6 +39,27 @@ from .auth import AuthCredentials
 
 logger = logging.getLogger(__name__)
 
+# Weaviate tracks which framework integrations talk to it through this header, so that adoption of
+# weaviate-haystack shows up in Weaviate's own telemetry. See https://github.com/weaviate/weaviate/pull/10535.
+_INTEGRATION_HEADER = "X-Weaviate-Client-Integration"
+_INTEGRATION_NAME = "haystack-python"
+_PACKAGE_NAME = "weaviate-haystack"
+
+
+def _integration_header_value() -> str:
+    """
+    Builds the value of the Weaviate client integration header.
+
+    :returns:
+        A `<name>/<version>` string. The version falls back to `unknown` when the package metadata is
+        unavailable, for example when running from a source checkout that was never installed.
+    """
+    try:
+        version = importlib.metadata.version(_PACKAGE_NAME)
+    except importlib.metadata.PackageNotFoundError:
+        version = "unknown"
+    return f"{_INTEGRATION_NAME}/{version}"
+
 
 # This is the default collection properties for Weaviate.
 # It's a list of properties that will be created on the collection.
@@ -144,6 +166,9 @@ class WeaviateDocumentStore:
             ```
             {"X-OpenAI-Api-Key": "<THE-KEY>"}, {"X-HuggingFace-Api-Key": "<THE-KEY>"}
             ```
+            Every connection also carries `X-Weaviate-Client-Integration: haystack-python/<version>`, which
+            identifies this integration in Weaviate's telemetry. Supplying that header here, in any casing,
+            overrides it.
         :param embedded_options:
             If set, create an embedded Weaviate cluster inside the client. For a full list of options see
             `weaviate.embedded.EmbeddedOptions`.
@@ -183,6 +208,26 @@ class WeaviateDocumentStore:
             "properties", DOCUMENT_COLLECTION_PROPERTIES
         )
 
+    def _connection_headers(self) -> dict[str, Any]:
+        """
+        Builds the headers passed to the Weaviate client.
+
+        Merges the integration identification header into the user supplied `additional_headers`. A user
+        supplied value for the same header wins, so the header can be overridden or suppressed. The merged
+        headers are deliberately not stored on the instance: `to_dict()` must keep serializing only the
+        headers the user actually passed, so that a serialized pipeline does not bake in the version of
+        `weaviate-haystack` that happened to write it.
+
+        :returns:
+            The headers to pass to the Weaviate client.
+        """
+        headers: dict[str, Any] = dict(self._additional_headers) if self._additional_headers else {}
+        # The comparison is case insensitive because gRPC metadata keys are case sensitive: a user supplied
+        # "x-weaviate-client-integration" would otherwise end up alongside our own spelling of the header.
+        if not any(key.lower() == _INTEGRATION_HEADER.lower() for key in headers):
+            headers[_INTEGRATION_HEADER] = _integration_header_value()
+        return headers
+
     @property
     def client(self) -> weaviate.WeaviateClient:
         """Return the synchronous Weaviate client, creating and connecting it if necessary."""
@@ -199,7 +244,7 @@ class WeaviateDocumentStore:
             self._client = weaviate.connect_to_weaviate_cloud(
                 self._url,
                 auth_credentials=self._auth_client_secret.resolve_value(),
-                headers=self._additional_headers,
+                headers=self._connection_headers(),
                 additional_config=self._additional_config,
             )
         else:
@@ -216,7 +261,7 @@ class WeaviateDocumentStore:
                 ),
                 auth_client_secret=self._auth_client_secret.resolve_value() if self._auth_client_secret else None,
                 additional_config=self._additional_config,
-                additional_headers=self._additional_headers,
+                additional_headers=self._connection_headers(),
                 embedded_options=self._embedded_options,
                 skip_init_checks=False,
             )
@@ -244,7 +289,7 @@ class WeaviateDocumentStore:
             self._async_client = weaviate.use_async_with_weaviate_cloud(
                 self._url,
                 auth_credentials=self._auth_client_secret.resolve_value(),
-                headers=self._additional_headers,
+                headers=self._connection_headers(),
                 additional_config=self._additional_config,
             )
         else:
@@ -261,7 +306,7 @@ class WeaviateDocumentStore:
                 ),
                 auth_client_secret=self._auth_client_secret.resolve_value() if self._auth_client_secret else None,
                 additional_config=self._additional_config,
-                additional_headers=self._additional_headers,
+                additional_headers=self._connection_headers(),
                 embedded_options=self._embedded_options,
                 skip_init_checks=False,
             )
@@ -632,76 +677,121 @@ class WeaviateDocumentStore:
 
         return result
 
+    @staticmethod
+    def _compute_field_unique_values(
+        agg_result: Any, search_term: str | None, from_: int, size: int
+    ) -> tuple[list[Any], int]:
+        """
+        Computes paginated unique values from a Weaviate group-by aggregation result.
+
+        Weaviate's `like` filter only supports case-sensitive substring matching, so instead of
+        filtering server-side (which would be case-sensitive), all groups are fetched unconditionally
+        and `search_term` is applied here as a case-insensitive substring match in Python.
+
+        :param agg_result: The group-by aggregation result, with one group per unique field value.
+        :param search_term: Optional term to filter the values by, matched as a case-insensitive
+            substring against each value.
+        :param from_: The starting offset for pagination (0-indexed).
+        :param size: The maximum number of unique values to return.
+        :returns: A tuple of (paginated list of unique values in their original type, total count of
+            unique values). See `get_metadata_field_unique_values`'s docstring for a caveat on scalar
+            int fields - `agg_result`'s numeric group keys always decode as `float`.
+        """
+        all_values = [g.grouped_by.value for g in agg_result.groups] if agg_result.groups else []
+        if search_term:
+            search_term_lower = search_term.lower()
+            all_values = [value for value in all_values if search_term_lower in str(value).lower()]
+        all_values.sort(key=str)  # Sort for consistent pagination
+        total_count = len(all_values)
+
+        paginated_values = all_values[from_ : from_ + size]
+
+        return paginated_values, total_count
+
     def get_metadata_field_unique_values(
         self,
         metadata_field: str,
         search_term: str | None = None,
         from_: int = 0,
-        size: int = 10000,
-    ) -> tuple[list[str], int]:
+        size: int = 10,
+        filters: dict[str, Any] | None = None,
+    ) -> tuple[list[Any], int]:
         """
         Returns unique values for a metadata field with pagination support.
 
         :param metadata_field: The metadata field name to get unique values for.
             Can be prefixed with 'meta.' (e.g., 'meta.category' or 'category').
-        :param search_term: Optional term to filter documents by content before
-            extracting unique values. If provided, only documents whose content
-            contains this term will be considered.
-            Note: Uses substring matching (case-sensitive, no stemming).
+        :param search_term: Optional term to filter the metadata field's values by
+            before returning them. If provided, only values of `metadata_field` that
+            contain this term will be considered.
+            Note: Uses case-insensitive substring matching (no stemming).
         :param from_: The starting offset for pagination (0-indexed). Defaults to 0.
-        :param size: The maximum number of unique values to return. Defaults to 10000.
-        :returns: A tuple of (list of unique values, total count of unique values).
-        :raises ValueError: If the field is not found in the collection schema.
+        :param size: The maximum number of unique values to return. Defaults to 10.
+        :param filters: Optional filters to restrict the documents considered.
+        :returns: A tuple of (list of unique values in their original type, total count of unique values).
+
+        **Note**: a scalar `int` metadata value comes back as `float`, not `int`. weaviate-client has no
+        wire-protocol field for a scalar int - non-list properties are packed into a
+        `google.protobuf.Struct`, whose `Value` type only has `number_value` (a double), so the int/float
+        distinction is lost before the value reaches Weaviate. `GroupByAggregate` decodes numeric group
+        keys the same way, so this holds even when the field's schema type is explicitly `DataType.INT`.
+        List-valued int fields (e.g. `meta={"tags": [1, 2]}`) are unaffected - those go through a
+        dedicated `IntArrayProperties` wire type instead.
         """
         field_name = _normalize_metadata_field_name(metadata_field)
 
         config = self.collection.config.get()
         schema_fields = {prop.name for prop in config.properties}
         if field_name not in schema_fields:
-            msg = f"Field '{field_name}' not found in collection schema"
-            raise ValueError(msg)
+            # No document has ever written this field, so Weaviate's auto-schema never created a
+            # property for it - there are no values to aggregate.
+            return [], 0
 
         weaviate_filter = None
-        if search_term:
-            weaviate_filter = convert_filters({"field": "content", "operator": "contains", "value": search_term})
+        if filters:
+            validate_filters(filters)
+            weaviate_filter = convert_filters(filters)
 
         # Weaviate's GroupByAggregate has a default limit of 100 groups.
         # We use the document count as the limit to ensure all unique values are retrieved,
         # since the number of unique values cannot exceed the number of documents.
-        doc_count = self.collection.aggregate.over_all(total_count=True).total_count or 0
+        doc_count = self.collection.aggregate.over_all(filters=weaviate_filter, total_count=True).total_count or 0
 
         agg_result = self.collection.aggregate.over_all(
             filters=weaviate_filter, group_by=GroupByAggregate(prop=field_name, limit=doc_count)
         )
 
-        all_values = [str(g.grouped_by.value) for g in agg_result.groups] if agg_result.groups else []
-        all_values.sort()  # Sort for consistent pagination
-        total_count = len(all_values)
-
-        paginated_values = all_values[from_ : from_ + size]
-
-        return paginated_values, total_count
+        return self._compute_field_unique_values(agg_result, search_term, from_, size)
 
     async def get_metadata_field_unique_values_async(
         self,
         metadata_field: str,
         search_term: str | None = None,
         from_: int = 0,
-        size: int = 10000,
-    ) -> tuple[list[str], int]:
+        size: int = 10,
+        filters: dict[str, Any] | None = None,
+    ) -> tuple[list[Any], int]:
         """
         Asynchronously returns unique values for a metadata field with pagination support.
 
         :param metadata_field: The metadata field name to get unique values for.
             Can be prefixed with 'meta.' (e.g., 'meta.category' or 'category').
-        :param search_term: Optional term to filter documents by content before
-            extracting unique values. If provided, only documents whose content
-            contains this term will be considered.
-            Note: Uses substring matching (case-sensitive, no stemming).
+        :param search_term: Optional term to filter the metadata field's values by
+            before returning them. If provided, only values of `metadata_field` that
+            contain this term will be considered.
+            Note: Uses case-insensitive substring matching (no stemming).
         :param from_: The starting offset for pagination (0-indexed). Defaults to 0.
-        :param size: The maximum number of unique values to return. Defaults to 10000.
-        :returns: A tuple of (list of unique values, total count of unique values).
-        :raises ValueError: If the field is not found in the collection schema.
+        :param size: The maximum number of unique values to return. Defaults to 10.
+        :param filters: Optional filters to restrict the documents considered.
+        :returns: A tuple of (list of unique values in their original type, total count of unique values).
+
+        **Note**: a scalar `int` metadata value comes back as `float`, not `int`. weaviate-client has no
+        wire-protocol field for a scalar int - non-list properties are packed into a
+        `google.protobuf.Struct`, whose `Value` type only has `number_value` (a double), so the int/float
+        distinction is lost before the value reaches Weaviate. `GroupByAggregate` decodes numeric group
+        keys the same way, so this holds even when the field's schema type is explicitly `DataType.INT`.
+        List-valued int fields (e.g. `meta={"tags": [1, 2]}`) are unaffected - those go through a
+        dedicated `IntArrayProperties` wire type instead.
         """
         field_name = _normalize_metadata_field_name(metadata_field)
 
@@ -709,30 +799,26 @@ class WeaviateDocumentStore:
         config = await collection.config.get()
         schema_fields = {prop.name for prop in config.properties}
         if field_name not in schema_fields:
-            msg = f"Field '{field_name}' not found in collection schema"
-            raise ValueError(msg)
+            # No document has ever written this field, so Weaviate's auto-schema never created a
+            # property for it - there are no values to aggregate.
+            return [], 0
 
         weaviate_filter = None
-        if search_term:
-            weaviate_filter = convert_filters({"field": "content", "operator": "contains", "value": search_term})
+        if filters:
+            validate_filters(filters)
+            weaviate_filter = convert_filters(filters)
 
         # Weaviate's GroupByAggregate has a default limit of 100 groups.
         # We use the document count as the limit to ensure all unique values are retrieved,
         # since the number of unique values cannot exceed the number of documents.
-        doc_count_result = await collection.aggregate.over_all(total_count=True)
+        doc_count_result = await collection.aggregate.over_all(filters=weaviate_filter, total_count=True)
         doc_count = doc_count_result.total_count or 0
 
         agg_result = await collection.aggregate.over_all(
             filters=weaviate_filter, group_by=GroupByAggregate(prop=field_name, limit=doc_count)
         )
 
-        all_values = [str(g.grouped_by.value) for g in agg_result.groups] if agg_result.groups else []
-        all_values.sort()  # Sort for consistent pagination
-        total_count = len(all_values)
-
-        paginated_values = all_values[from_ : from_ + size]
-
-        return paginated_values, total_count
+        return self._compute_field_unique_values(agg_result, search_term, from_, size)
 
     @staticmethod
     def _to_data_object(document: Document) -> dict[str, Any]:

{weaviate_haystack-7.7.0 → weaviate_haystack-7.9.0}/tests/test_document_store.py

@@ -3,6 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import base64
+import importlib.metadata
 import logging
 import os
 from collections.abc import Generator
@@ -43,6 +44,7 @@ from haystack_integrations.document_stores.weaviate.auth import AuthApiKey
 from haystack_integrations.document_stores.weaviate.document_store import (
     DOCUMENT_COLLECTION_PROPERTIES,
     WeaviateDocumentStore,
+    _integration_header_value,
 )
 
 
@@ -81,7 +83,10 @@ def test_client_connects_to_weaviate_cloud(mock_connect, monkeypatch):
 
     mock_connect.assert_called_once()
     _args, kwargs = mock_connect.call_args
-    assert kwargs["headers"] == {"X-HuggingFace-Api-Key": "k"}
+    assert kwargs["headers"] == {
+        "X-HuggingFace-Api-Key": "k",
+        "X-Weaviate-Client-Integration": _integration_header_value(),
+    }
 
 
 @pytest.mark.asyncio
@@ -100,9 +105,84 @@ async def test_async_client_connects_to_weaviate_cloud(mock_connect, monkeypatch
     mock_client.collections.exists = exists
     mock_connect.return_value = mock_client
 
-    ds = WeaviateDocumentStore(url="rAnD0m.something.weaviate.cloud", auth_client_secret=AuthApiKey())
+    ds = WeaviateDocumentStore(
+        url="rAnD0m.something.weaviate.cloud",
+        auth_client_secret=AuthApiKey(),
+        additional_headers={"X-HuggingFace-Api-Key": "k"},
+    )
     assert await ds.async_client is mock_client
+
     mock_connect.assert_called_once()
+    _args, kwargs = mock_connect.call_args
+    assert kwargs["headers"] == {
+        "X-HuggingFace-Api-Key": "k",
+        "X-Weaviate-Client-Integration": _integration_header_value(),
+    }
+
+
+@patch("haystack_integrations.document_stores.weaviate.document_store.weaviate.WeaviateClient")
+def test_client_sends_integration_header(mock_weaviate_client_class):
+    mock_client = MagicMock()
+    mock_client.collections.exists.return_value = True
+    mock_weaviate_client_class.return_value = mock_client
+
+    ds = WeaviateDocumentStore(url="http://localhost:8080")
+    ds.client  # noqa: B018
+
+    headers = mock_weaviate_client_class.call_args.kwargs["additional_headers"]
+    assert headers["X-Weaviate-Client-Integration"].startswith("haystack-python/")
+
+
+@pytest.mark.asyncio
+@patch("haystack_integrations.document_stores.weaviate.document_store.weaviate.WeaviateAsyncClient")
+async def test_async_client_sends_integration_header(mock_weaviate_async_client_class):
+    mock_client = MagicMock()
+
+    async def connect() -> None:
+        return None
+
+    async def exists(_name: str) -> bool:
+        return True
+
+    mock_client.connect = connect
+    mock_client.collections.exists = exists
+    mock_weaviate_async_client_class.return_value = mock_client
+
+    ds = WeaviateDocumentStore(url="http://localhost:8080")
+    await ds.async_client
+
+    headers = mock_weaviate_async_client_class.call_args.kwargs["additional_headers"]
+    assert headers["X-Weaviate-Client-Integration"].startswith("haystack-python/")
+
+
+@pytest.mark.parametrize("header_name", ["X-Weaviate-Client-Integration", "x-weaviate-client-integration"])
+@patch("haystack_integrations.document_stores.weaviate.document_store.weaviate.WeaviateClient")
+def test_user_supplied_integration_header_wins(mock_weaviate_client_class, header_name):
+    mock_client = MagicMock()
+    mock_client.collections.exists.return_value = True
+    mock_weaviate_client_class.return_value = mock_client
+
+    ds = WeaviateDocumentStore(url="http://localhost:8080", additional_headers={header_name: "custom/1.0"})
+    ds.client  # noqa: B018
+
+    headers = mock_weaviate_client_class.call_args.kwargs["additional_headers"]
+    assert headers == {header_name: "custom/1.0"}
+
+
+def test_integration_header_value_falls_back_to_unknown_version(monkeypatch):
+    def raise_package_not_found(_package_name: str) -> str:
+        raise importlib.metadata.PackageNotFoundError
+
+    monkeypatch.setattr(importlib.metadata, "version", raise_package_not_found)
+
+    assert _integration_header_value() == "haystack-python/unknown"
+
+
+def test_integration_header_is_not_serialized():
+    assert WeaviateDocumentStore().to_dict()["init_parameters"]["additional_headers"] is None
+
+    ds = WeaviateDocumentStore(additional_headers={"X-HuggingFace-Api-Key": "k"})
+    assert ds.to_dict()["init_parameters"]["additional_headers"] == {"X-HuggingFace-Api-Key": "k"}
 
 
 def test_to_data_object_with_sparse_embedding_logs_warning(caplog):
@@ -325,7 +405,10 @@ class TestWeaviateDocumentStore(
         mock_weaviate_client_class.assert_called_once_with(
             auth_client_secret=AuthApiKey().resolve_value(),
             connection_params=None,
-            additional_headers={"X-HuggingFace-Api-Key": "MY_HUGGINGFACE_KEY"},
+            additional_headers={
+                "X-HuggingFace-Api-Key": "MY_HUGGINGFACE_KEY",
+                "X-Weaviate-Client-Integration": _integration_header_value(),
+            },
             embedded_options=EmbeddedOptions(
                 persistence_data_path=DEFAULT_PERSISTENCE_DATA_PATH,
                 binary_path=DEFAULT_BINARY_PATH,
@@ -1144,60 +1227,59 @@ class TestWeaviateDocumentStore(
                 metadata_fields=["nonexistent_field"],
             )
 
-    def test_get_metadata_field_unique_values_with_meta_prefix(self, document_store):
-        docs = [
-            Document(content="Doc 1", meta={"category": "TypeA"}),
-            Document(content="Doc 2", meta={"category": "TypeB"}),
-        ]
-        document_store.write_documents(docs)
-
-        values, total_count = document_store.get_metadata_field_unique_values("meta.category")
-        assert total_count == 2
-        assert set(values) == {"TypeA", "TypeB"}
+    # --- Overrides of mixin tests to account for Weaviate-specific behaviour ---
 
-    def test_get_metadata_field_unique_values_with_search_term(self, document_store):
+    def test_get_metadata_field_unique_values_preserves_type(self, document_store):
+        """
+        Override: weaviate-client has no wire-protocol field for a scalar int - google.protobuf.Struct's
+        Value type only has `number_value` (a double), so a metadata int is indistinguishable from a
+        float by the time it reaches Weaviate. GroupByAggregate consequently always returns numeric
+        group keys as float, regardless of the field's declared schema type.
+        """
         docs = [
-            Document(content="Python programming language", meta={"category": "TypeA"}),
-            Document(content="Java programming language", meta={"category": "TypeB"}),
-            Document(content="Python is great", meta={"category": "TypeC"}),
-            Document(content="JavaScript tutorial", meta={"category": "TypeD"}),
+            Document(content="Doc 1", meta={"priority": 1}),
+            Document(content="Doc 2", meta={"priority": 2}),
+            Document(content="Doc 3", meta={"priority": 1}),
         ]
         document_store.write_documents(docs)
 
-        values, total_count = document_store.get_metadata_field_unique_values("category", search_term="Python")
+        values, total_count = document_store.get_metadata_field_unique_values(metadata_field="priority")
+
+        assert set(values) == {1, 2}
+        assert all(isinstance(value, float) for value in values)  # not int - see docstring
         assert total_count == 2
-        assert set(values) == {"TypeA", "TypeC"}
 
-    def test_get_metadata_field_unique_values_with_pagination(self, document_store):
+    def test_get_metadata_field_unique_values_distinct_types(self, document_store):
+        """
+        Override: the base mixin test stores int, float, str and bool under the *same* metadata field
+        name and expects all four back as distinct values. Weaviate's collection schema fields are
+        strongly single-typed, so a field can't simultaneously hold int/str/float/bool values.
+
+        This adapts the same intent - int, float, str and bool must come back as distinct, unmangled
+        types via get_metadata_field_unique_values() - using one field per type instead of one shared
+        field, which is what Weaviate can actually support.
+        """
         docs = [
-            Document(content="Doc 1", meta={"category": "TypeA"}),
-            Document(content="Doc 2", meta={"category": "TypeB"}),
-            Document(content="Doc 3", meta={"category": "TypeC"}),
-            Document(content="Doc 4", meta={"category": "TypeD"}),
-            Document(content="Doc 5", meta={"category": "TypeE"}),
+            Document(content="Doc 1", meta={"priority_int": 1}),
+            Document(content="Doc 2", meta={"priority_str": "1"}),
+            Document(content="Doc 3", meta={"priority_float": 1.5}),
+            Document(content="Doc 4", meta={"priority_bool": True}),
         ]
         document_store.write_documents(docs)
 
-        values, total_count = document_store.get_metadata_field_unique_values("category", from_=0, size=2)
-        assert total_count == 5
-        assert len(values) == 2
-
-        values2, total_count2 = document_store.get_metadata_field_unique_values("category", from_=2, size=2)
-        assert total_count2 == 5
-        assert len(values2) == 2
-
-        assert set(values).isdisjoint(set(values2))
-
-    def test_get_metadata_field_unique_values_field_not_found(self, document_store):
-        with pytest.raises(ValueError, match="not found in collection schema"):
-            document_store.get_metadata_field_unique_values("nonexistent_field")
-
-    def test_get_metadata_field_unique_values_empty_result(self, document_store):
-        values, total_count = document_store.get_metadata_field_unique_values("category")
-        assert total_count == 0
-        assert values == []
-
-    # --- Overrides of mixin tests to account for Weaviate-specific behaviour ---
+        int_values, int_count = document_store.get_metadata_field_unique_values(metadata_field="priority_int")
+        str_values, str_count = document_store.get_metadata_field_unique_values(metadata_field="priority_str")
+        float_values, float_count = document_store.get_metadata_field_unique_values(metadata_field="priority_float")
+        bool_values, bool_count = document_store.get_metadata_field_unique_values(metadata_field="priority_bool")
+
+        assert (int_count, str_count, float_count, bool_count) == (1, 1, 1, 1)
+        # int type fidelity isn't asserted here: GroupByAggregate returns numeric group keys as float
+        # regardless of the field's declared schema type, the same known gap covered by
+        # test_get_metadata_field_unique_values_preserves_type - not specific to field-sharing.
+        assert int_values == [1]
+        assert str_values == ["1"] and type(str_values[0]) is str
+        assert float_values == [1.5] and type(float_values[0]) is float
+        assert bool_values == [True] and type(bool_values[0]) is bool
 
     def test_count_documents_by_filter_simple(self, document_store):
         docs = [

{weaviate_haystack-7.7.0 → weaviate_haystack-7.9.0}/tests/test_document_store_async.py

@@ -440,65 +440,69 @@ class TestWeaviateDocumentStoreAsync(
                 metadata_fields=["nonexistent_field"],
             )
 
-    @pytest.mark.asyncio
-    async def test_get_metadata_field_unique_values_async_with_meta_prefix(self, document_store):
-        docs = [
-            Document(content="Doc 1", meta={"category": "TypeA"}),
-            Document(content="Doc 2", meta={"category": "TypeB"}),
-        ]
-        await document_store.write_documents_async(docs)
-
-        values, total_count = await document_store.get_metadata_field_unique_values_async("meta.category")
-        assert total_count == 2
-        assert set(values) == {"TypeA", "TypeB"}
+    # --- Overrides of mixin tests to account for Weaviate-specific behaviour ---
 
     @pytest.mark.asyncio
-    async def test_get_metadata_field_unique_values_async_with_search_term(self, document_store):
+    async def test_get_metadata_field_unique_values_preserves_type_async(self, document_store):
+        """
+        Override: weaviate-client has no wire-protocol field for a scalar int - google.protobuf.Struct's
+        Value type only has `number_value` (a double), so a metadata int is indistinguishable from a
+        float by the time it reaches Weaviate. GroupByAggregate consequently always returns numeric
+        group keys as float, regardless of the field's declared schema type.
+        """
         docs = [
-            Document(content="Python programming language", meta={"category": "TypeA"}),
-            Document(content="Java programming language", meta={"category": "TypeB"}),
-            Document(content="Python is great", meta={"category": "TypeC"}),
-            Document(content="JavaScript tutorial", meta={"category": "TypeD"}),
+            Document(content="Doc 1", meta={"priority": 1}),
+            Document(content="Doc 2", meta={"priority": 2}),
+            Document(content="Doc 3", meta={"priority": 1}),
         ]
         await document_store.write_documents_async(docs)
 
-        values, total_count = await document_store.get_metadata_field_unique_values_async(
-            "category", search_term="Python"
-        )
+        values, total_count = await document_store.get_metadata_field_unique_values_async(metadata_field="priority")
+
+        assert set(values) == {1, 2}
+        assert all(isinstance(value, float) for value in values)  # not int - see docstring
         assert total_count == 2
-        assert set(values) == {"TypeA", "TypeC"}
 
     @pytest.mark.asyncio
-    async def test_get_metadata_field_unique_values_async_with_pagination(self, document_store):
+    async def test_get_metadata_field_unique_values_distinct_types_async(self, document_store):
+        """
+        Override: the base mixin test stores int, float, str and bool under the *same* metadata field
+        name and expects all four back as distinct values. Weaviate's collection schema fields are
+        strongly single-typed, so a field can't simultaneously hold int/str/float/bool values.
+
+        This adapts the same intent - int, float, str and bool must come back as distinct, unmangled
+        types via get_metadata_field_unique_values_async() - using one field per type instead of one
+        shared field, which is what Weaviate can actually support.
+        """
         docs = [
-            Document(content="Doc 1", meta={"category": "TypeA"}),
-            Document(content="Doc 2", meta={"category": "TypeB"}),
-            Document(content="Doc 3", meta={"category": "TypeC"}),
-            Document(content="Doc 4", meta={"category": "TypeD"}),
-            Document(content="Doc 5", meta={"category": "TypeE"}),
+            Document(content="Doc 1", meta={"priority_int": 1}),
+            Document(content="Doc 2", meta={"priority_str": "1"}),
+            Document(content="Doc 3", meta={"priority_float": 1.5}),
+            Document(content="Doc 4", meta={"priority_bool": True}),
         ]
         await document_store.write_documents_async(docs)
 
-        values, total_count = await document_store.get_metadata_field_unique_values_async("category", from_=0, size=2)
-        assert total_count == 5
-        assert len(values) == 2
-
-        values2, total_count2 = await document_store.get_metadata_field_unique_values_async("category", from_=2, size=2)
-        assert total_count2 == 5
-        assert len(values2) == 2
-
-        assert set(values).isdisjoint(set(values2))
-
-    @pytest.mark.asyncio
-    async def test_get_metadata_field_unique_values_async_field_not_found(self, document_store):
-        with pytest.raises(ValueError, match="not found in collection schema"):
-            await document_store.get_metadata_field_unique_values_async("nonexistent_field")
+        int_values, int_count = await document_store.get_metadata_field_unique_values_async(
+            metadata_field="priority_int"
+        )
+        str_values, str_count = await document_store.get_metadata_field_unique_values_async(
+            metadata_field="priority_str"
+        )
+        float_values, float_count = await document_store.get_metadata_field_unique_values_async(
+            metadata_field="priority_float"
+        )
+        bool_values, bool_count = await document_store.get_metadata_field_unique_values_async(
+            metadata_field="priority_bool"
+        )
 
-    @pytest.mark.asyncio
-    async def test_get_metadata_field_unique_values_async_empty_result(self, document_store):
-        values, total_count = await document_store.get_metadata_field_unique_values_async("category")
-        assert total_count == 0
-        assert values == []
+        assert (int_count, str_count, float_count, bool_count) == (1, 1, 1, 1)
+        # int type fidelity isn't asserted here: GroupByAggregate returns numeric group keys as float
+        # regardless of the field's declared schema type, the same known gap covered by
+        # test_get_metadata_field_unique_values_preserves_type_async - not specific to field-sharing.
+        assert int_values == [1]
+        assert str_values == ["1"] and type(str_values[0]) is str
+        assert float_values == [1.5] and type(float_values[0]) is float
+        assert bool_values == [True] and type(bool_values[0]) is bool
 
     @pytest.mark.asyncio
     async def test_delete_all_documents_excessive_batch_size_async(