fix(query_namespaces): preserve input order for deterministic tie-break

Sync Index.query_namespaces() fed per-namespace responses into
QueryResultsAggregator in completion order (as_completed), so tied
scores broke in a non-deterministic order across runs. The aggregator
contract is insertion-order tie-break, so callers must add results in
input namespace order. Submit all futures up front (preserving
parallelism) and consume them in input namespace order. Adds a unit
test that uses graduated sleeps to invert completion order vs input
order.

Author: jhamon

pinecone/index/__init__.py

@@ -5,7 +5,7 @@
 import logging
 import os
 from collections.abc import Iterator, Mapping, Sequence
-from concurrent.futures import ThreadPoolExecutor, as_completed
+from concurrent.futures import ThreadPoolExecutor
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
@@ -762,14 +762,13 @@ def query_namespaces(
         if vector is not None:
             query_kwargs["vector"] = vector
 
+        # Submit every query before iterating results so queries run concurrently;
+        # collect results in input namespace order so the aggregator's
+        # insertion-order tie-break stays deterministic across runs.
         with ThreadPoolExecutor(max_workers=min(len(namespaces), 32)) as pool:
-            future_to_ns = {
-                pool.submit(self.query, namespace=ns, **query_kwargs): ns for ns in namespaces
-            }
-            for future in as_completed(future_to_ns):
-                ns = future_to_ns[future]
-                response = future.result()
-                aggregator.add_results(ns, response)
+            futures = [pool.submit(self.query, namespace=ns, **query_kwargs) for ns in namespaces]
+            for ns, future in zip(namespaces, futures, strict=True):
+                aggregator.add_results(ns, future.result())
 
         return aggregator.get_results()
 

tests/unit/test_query_namespaces.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import time
 from unittest.mock import patch
 
 import pytest
@@ -56,6 +57,42 @@ def test_query_namespaces_fans_out(self) -> None:
             assert called_namespaces == ["ns1", "ns2", "ns3"]
 
 
+class TestQueryNamespacesTieBreaking:
+    def test_tie_breaking_follows_input_namespace_order(self) -> None:
+        """With tied scores, result order must match input namespace order
+        regardless of completion order. Earlier-listed namespaces are made
+        slowest so completion order is the reverse of input order; the
+        aggregator's insertion-order tie-break is only deterministic when
+        the caller adds results in input order."""
+        idx = _make_index()
+
+        delays = {"ns1": 0.03, "ns2": 0.02, "ns3": 0.01, "ns4": 0.0}
+
+        def query_side_effect(**kwargs: object) -> QueryResponse:
+            ns = str(kwargs["namespace"])
+            time.sleep(delays[ns])
+            return _make_query_response([_scored(f"{ns}-v0", 1.0), _scored(f"{ns}-v1", 1.0)])
+
+        with patch.object(idx, "query", side_effect=query_side_effect):
+            result = idx.query_namespaces(
+                vector=[0.1, 0.2],
+                namespaces=["ns1", "ns2", "ns3", "ns4"],
+                metric="cosine",
+                top_k=8,
+            )
+
+        assert [m.id for m in result.matches] == [
+            "ns1-v0",
+            "ns1-v1",
+            "ns2-v0",
+            "ns2-v1",
+            "ns3-v0",
+            "ns3-v1",
+            "ns4-v0",
+            "ns4-v1",
+        ]
+
+
 class TestQueryNamespacesMerge:
     def test_query_namespaces_merges_results(self) -> None:
         """Mock Index.query to return different scores per namespace, verify