fix: address review findings for property reindex API (#2097)

g-despot · g-despot · commit 6bcb4c5ebbc0 · 2026-07-19T22:19:14.000+02:00
- accept a bare string for the tenants argument of update_property_index
  and rebuild_property_index, normalizing it to a single-element list so
  it cannot be exploded into a per-character csv (export API precedent)
- override to_dict on _PropertyIndexes/_CollectionPropertyIndexes so the
  nested dataclass lists serialize to JSON-compatible dicts
  (_CollectionConfig precedent)
- drop the dead list branch for dataType in the index status parser
- cover the ReindexFailedError/ReindexCanceledError wait paths of both
  update and rebuild, pin the empty request body of the rebuild/cancel
  mocks, and prove json.dumps(...to_dict()) round-trips
diff --git a/mock_tests/test_property_reindex.py b/mock_tests/test_property_reindex.py
@@ -13,7 +13,11 @@
     PropertyIndexTaskStatus,
     Tokenization,
 )
-from weaviate.exceptions import WeaviateUnsupportedFeatureError
+from weaviate.exceptions import (
+    ReindexCanceledError,
+    ReindexFailedError,
+    WeaviateUnsupportedFeatureError,
+)
 
 COLLECTION = "TestCollection"
 SCHEMA_PATH = f"/v1/schema/{COLLECTION}"
@@ -128,12 +132,117 @@ def test_update_property_index_wait_for_completion(
     weaviate_139_mock.check_assertions()
 
 
+def test_update_property_index_bare_str_tenant(
+    weaviate_139_mock: HTTPServer, client_139: weaviate.WeaviateClient
+) -> None:
+    """A bare string tenant is normalized to a single csv value, not exploded into characters."""
+    weaviate_139_mock.expect_request(
+        f"{SCHEMA_PATH}/properties/age/index/rangeFilters",
+        method="PUT",
+        query_string={"tenants": "tenant1"},
+        json={},
+    ).respond_with_json({"taskId": TASK_ID, "status": "STARTED"}, status=202)
+
+    task = client_139.collections.use(COLLECTION).config.update_property_index(
+        "age", "rangeFilters", tenants="tenant1"
+    )
+    assert task.status == PropertyIndexTaskStatus.STARTED
+    weaviate_139_mock.check_assertions()
+
+
+@pytest.mark.parametrize(
+    "index_status,exception",
+    [("failed", ReindexFailedError), ("cancelled", ReindexCanceledError)],
+)
+def test_update_property_index_wait_raises(
+    weaviate_139_mock: HTTPServer,
+    client_139: weaviate.WeaviateClient,
+    index_status: str,
+    exception: type,
+) -> None:
+    weaviate_139_mock.expect_request(
+        f"{SCHEMA_PATH}/properties/name/index/searchable",
+        method="PUT",
+        json={"tokenization": "word"},
+    ).respond_with_json({"taskId": TASK_ID, "status": "STARTED"}, status=202)
+    weaviate_139_mock.expect_request(f"{SCHEMA_PATH}/indexes", method="GET").respond_with_json(
+        {
+            "collection": COLLECTION,
+            "properties": [
+                {
+                    "name": "name",
+                    "dataType": "text",
+                    "indexes": [
+                        {
+                            "type": "searchable",
+                            "status": index_status,
+                            "progress": 0.42,
+                            "taskId": TASK_ID,
+                            "tokenization": "word",
+                        }
+                    ],
+                }
+            ],
+        }
+    )
+
+    with pytest.raises(exception):
+        client_139.collections.use(COLLECTION).config.update_property_index(
+            "name", "searchable", tokenization=Tokenization.WORD, wait_for_completion=True
+        )
+    weaviate_139_mock.check_assertions()
+
+
+@pytest.mark.parametrize(
+    "index_status,exception",
+    [("failed", ReindexFailedError), ("cancelled", ReindexCanceledError)],
+)
+def test_rebuild_property_index_wait_raises(
+    weaviate_139_mock: HTTPServer,
+    client_139: weaviate.WeaviateClient,
+    index_status: str,
+    exception: type,
+) -> None:
+    weaviate_139_mock.expect_request(
+        f"{SCHEMA_PATH}/properties/name/index/searchable/rebuild",
+        method="POST",
+        json={},
+    ).respond_with_json({"taskId": TASK_ID, "status": "STARTED"}, status=202)
+    weaviate_139_mock.expect_request(f"{SCHEMA_PATH}/indexes", method="GET").respond_with_json(
+        {
+            "collection": COLLECTION,
+            "properties": [
+                {
+                    "name": "name",
+                    "dataType": "text",
+                    "indexes": [
+                        {
+                            "type": "searchable",
+                            "status": index_status,
+                            "progress": 0.42,
+                            "taskId": TASK_ID,
+                            "tokenization": "word",
+                        }
+                    ],
+                }
+            ],
+        }
+    )
+
+    with pytest.raises(exception):
+        client_139.collections.use(COLLECTION).config.rebuild_property_index(
+            "name", "searchable", wait_for_completion=True
+        )
+    weaviate_139_mock.check_assertions()
+
+
 def test_rebuild_property_index(
     weaviate_139_mock: HTTPServer, client_139: weaviate.WeaviateClient
 ) -> None:
     weaviate_139_mock.expect_request(
         f"{SCHEMA_PATH}/properties/name/index/searchable/rebuild",
         method="POST",
+        json={},
     ).respond_with_json({"taskId": TASK_ID, "status": "STARTED"}, status=202)
 
     task = client_139.collections.use(COLLECTION).config.rebuild_property_index(
@@ -151,6 +260,7 @@ def test_rebuild_property_index_with_tenants(
         f"{SCHEMA_PATH}/properties/age/index/rangeFilters/rebuild",
         method="POST",
         query_string={"tenants": "tenant1,tenant2"},
+        json={},
     ).respond_with_json({"taskId": TASK_ID, "status": "STARTED"}, status=202)
 
     task = client_139.collections.use(COLLECTION).config.rebuild_property_index(
@@ -167,6 +277,7 @@ def test_cancel_property_index_task_cancelled(
     weaviate_139_mock.expect_request(
         f"{SCHEMA_PATH}/properties/name/index/searchable/cancel",
         method="POST",
+        json={},
     ).respond_with_json({"taskId": TASK_ID, "status": "CANCELLED"}, status=202)
 
     task = client_139.collections.use(COLLECTION).config.cancel_property_index_task(
@@ -183,6 +294,7 @@ def test_cancel_property_index_task_no_op(
     weaviate_139_mock.expect_request(
         f"{SCHEMA_PATH}/properties/name/index/searchable/cancel",
         method="POST",
+        json={},
     ).respond_with_json({"status": "NO_OP"}, status=202)
 
     task = client_139.collections.use(COLLECTION).config.cancel_property_index_task(
@@ -270,6 +382,14 @@ def test_get_property_indexes(
     assert age.indexes[0].task_id is None
     assert age.indexes[0].tokenization is None
 
+    # the nested dataclasses serialize all the way down to a JSON-compatible dict
+    out = json.loads(json.dumps(indexes.to_dict()))
+    assert out["collection"] == COLLECTION
+    assert out["properties"][0]["indexes"][0]["taskId"] == TASK_ID
+    assert out["properties"][0]["indexes"][0]["targetTokenization"] == "field"
+    assert out["properties"][1]["dataType"] == "int"
+    assert out["properties"][1]["indexes"][0]["status"] == "ready"
+
     weaviate_139_mock.check_assertions()
 
 
diff --git a/weaviate/collections/classes/config.py b/weaviate/collections/classes/config.py
@@ -2271,6 +2271,11 @@ class _PropertyIndexes(_ConfigBase):
     description: Optional[str]
     indexes: List[PropertyIndexStatus]
 
+    def to_dict(self) -> Dict[str, Any]:
+        out = super().to_dict()
+        out["indexes"] = [index.to_dict() for index in self.indexes]
+        return out
+
 
 PropertyIndexes = _PropertyIndexes
 
@@ -2280,6 +2285,11 @@ class _CollectionPropertyIndexes(_ConfigBase):
     collection: str
     properties: List[PropertyIndexes]
 
+    def to_dict(self) -> Dict[str, Any]:
+        out = super().to_dict()
+        out["properties"] = [prop.to_dict() for prop in self.properties]
+        return out
+
 
 CollectionPropertyIndexes = _CollectionPropertyIndexes
 
diff --git a/weaviate/collections/classes/config_methods.py b/weaviate/collections/classes/config_methods.py
@@ -592,22 +592,17 @@ def _property_index_status_from_json(index: Dict[str, Any]) -> _PropertyIndexSta
 
 
 def _collection_property_indexes_from_json(response: Dict[str, Any]) -> _CollectionPropertyIndexes:
-    properties: List[_PropertyIndexes] = []
-    for prop in response.get("properties") or []:
-        data_type = prop.get("dataType")
-        if isinstance(data_type, list):
-            data_type = data_type[0] if len(data_type) > 0 else ""
-        properties.append(
+    return _CollectionPropertyIndexes(
+        collection=response["collection"],
+        properties=[
             _PropertyIndexes(
                 name=prop["name"],
-                data_type=cast(str, data_type),
+                data_type=prop["dataType"],
                 description=prop.get("description"),
                 indexes=[
                     _property_index_status_from_json(index) for index in prop.get("indexes") or []
                 ],
             )
-        )
-    return _CollectionPropertyIndexes(
-        collection=response["collection"],
-        properties=properties,
+            for prop in response.get("properties") or []
+        ],
     )
diff --git a/weaviate/collections/config/async_.pyi b/weaviate/collections/config/async_.pyi
@@ -1,4 +1,4 @@
-from typing import Dict, List, Literal, Optional, Sequence, Union, overload
+from typing import Dict, List, Literal, Optional, Union, overload
 
 from typing_extensions import deprecated
 
@@ -102,7 +102,7 @@ class _ConfigCollectionAsync(_ConfigCollectionExecutor[ConnectionAsync]):
         *,
         tokenization: Optional[Tokenization] = None,
         algorithm: Optional[Literal["blockmax"]] = None,
-        tenants: Optional[Sequence[str]] = None,
+        tenants: Union[List[str], str, None] = None,
         wait_for_completion: Literal[True],
     ) -> PropertyIndexStatus: ...
     @overload
@@ -113,7 +113,7 @@ class _ConfigCollectionAsync(_ConfigCollectionExecutor[ConnectionAsync]):
         *,
         tokenization: Optional[Tokenization] = None,
         algorithm: Optional[Literal["blockmax"]] = None,
-        tenants: Optional[Sequence[str]] = None,
+        tenants: Union[List[str], str, None] = None,
         wait_for_completion: Literal[False] = False,
     ) -> PropertyIndexTask: ...
     @overload
@@ -122,7 +122,7 @@ class _ConfigCollectionAsync(_ConfigCollectionExecutor[ConnectionAsync]):
         property_name: str,
         index_name: IndexName,
         *,
-        tenants: Optional[Sequence[str]] = None,
+        tenants: Union[List[str], str, None] = None,
         wait_for_completion: Literal[True],
     ) -> PropertyIndexStatus: ...
     @overload
@@ -131,7 +131,7 @@ class _ConfigCollectionAsync(_ConfigCollectionExecutor[ConnectionAsync]):
         property_name: str,
         index_name: IndexName,
         *,
-        tenants: Optional[Sequence[str]] = None,
+        tenants: Union[List[str], str, None] = None,
         wait_for_completion: Literal[False] = False,
     ) -> PropertyIndexTask: ...
     async def cancel_property_index_task(
diff --git a/weaviate/collections/config/executor.py b/weaviate/collections/config/executor.py
@@ -754,7 +754,7 @@ def update_property_index(
         *,
         tokenization: Optional[Tokenization] = None,
         algorithm: Optional[Literal["blockmax"]] = None,
-        tenants: Optional[Sequence[str]] = None,
+        tenants: Union[List[str], str, None] = None,
         wait_for_completion: Literal[True],
     ) -> executor.Result[PropertyIndexStatus]: ...
 
@@ -766,7 +766,7 @@ def update_property_index(
         *,
         tokenization: Optional[Tokenization] = None,
         algorithm: Optional[Literal["blockmax"]] = None,
-        tenants: Optional[Sequence[str]] = None,
+        tenants: Union[List[str], str, None] = None,
         wait_for_completion: Literal[False] = False,
     ) -> executor.Result[PropertyIndexTask]: ...
 
@@ -777,7 +777,7 @@ def update_property_index(
         *,
         tokenization: Optional[Tokenization] = None,
         algorithm: Optional[Literal["blockmax"]] = None,
-        tenants: Optional[Sequence[str]] = None,
+        tenants: Union[List[str], str, None] = None,
         wait_for_completion: bool = False,
     ) -> executor.Result[Union[PropertyIndexTask, PropertyIndexStatus]]:
         """Create or migrate a property index in this collection.
@@ -794,9 +794,9 @@ def update_property_index(
                 optional as a change on an existing `searchable` or `filterable` index. Not valid for
                 `rangeFilters`.
             algorithm: The search algorithm of a `searchable` index. Only `blockmax` may be requested.
-            tenants: The tenants for which to create the index. Only valid when creating a
-                `rangeFilters` index on a multi-tenant collection. If not provided, all tenants are
-                affected.
+            tenants: The tenant/list of tenants for which to create the index. Only valid when
+                creating a `rangeFilters` index on a multi-tenant collection. If not provided, all
+                tenants are affected.
             wait_for_completion: Whether to wait until the index reports `ready`. By default False.
 
         Returns:
@@ -823,6 +823,8 @@ def update_property_index(
             )
         if algorithm is not None:
             body["algorithm"] = algorithm
+        if isinstance(tenants, str):
+            tenants = [tenants]
         params: Optional[Dict[str, Any]] = (
             {"tenants": ",".join(tenants)} if tenants is not None else None
         )
@@ -874,7 +876,7 @@ def rebuild_property_index(
         property_name: str,
         index_name: IndexName,
         *,
-        tenants: Optional[Sequence[str]] = None,
+        tenants: Union[List[str], str, None] = None,
         wait_for_completion: Literal[True],
     ) -> executor.Result[PropertyIndexStatus]: ...
 
@@ -884,7 +886,7 @@ def rebuild_property_index(
         property_name: str,
         index_name: IndexName,
         *,
-        tenants: Optional[Sequence[str]] = None,
+        tenants: Union[List[str], str, None] = None,
         wait_for_completion: Literal[False] = False,
     ) -> executor.Result[PropertyIndexTask]: ...
 
@@ -893,16 +895,16 @@ def rebuild_property_index(
         property_name: str,
         index_name: IndexName,
         *,
-        tenants: Optional[Sequence[str]] = None,
+        tenants: Union[List[str], str, None] = None,
         wait_for_completion: bool = False,
     ) -> executor.Result[Union[PropertyIndexTask, PropertyIndexStatus]]:
         """Rebuild an existing property index from scratch with its current configuration.
 
         Args:
             property_name: The property whose index to rebuild.
             index_name: The type of the index, one of `searchable`, `filterable` or `rangeFilters`.
-            tenants: The tenants for which to rebuild the index on a multi-tenant collection.
-                If not provided, all tenants are affected.
+            tenants: The tenant/list of tenants for which to rebuild the index on a multi-tenant
+                collection. If not provided, all tenants are affected.
             wait_for_completion: Whether to wait until the index reports `ready`. By default False.
 
         Returns:
@@ -922,6 +924,8 @@ def rebuild_property_index(
         _validate_input([_ValidateArgument(expected=[str], name="index_name", value=index_name)])
 
         path = self.__property_index_path(property_name, index_name) + "/rebuild"
+        if isinstance(tenants, str):
+            tenants = [tenants]
         params: Optional[Dict[str, Any]] = (
             {"tenants": ",".join(tenants)} if tenants is not None else None
         )
diff --git a/weaviate/collections/config/sync.pyi b/weaviate/collections/config/sync.pyi
