feat(grpc): add GrpcIndex.list_namespaces_paginated

Exposes the ListNamespaces gRPC RPC on GrpcIndex by:
- Adding list_namespaces() to GrpcChannelProtocol in _protocol.py
- Implementing list_namespaces_paginated() on GrpcIndex, converting the
  Rust channel dict response into a ListNamespacesResponse
- Importing ListNamespacesResponse in grpc/__init__.py
- Adding 6 unit tests covering response parsing, param forwarding, and
  pagination token handling

Author: jhamon

pinecone/grpc/__init__.py

@@ -28,6 +28,7 @@
 from pinecone.grpc.future import PineconeFuture
 from pinecone.models.namespaces.models import (
     IndexedFields,
+    ListNamespacesResponse,
     NamespaceDescription,
     NamespaceFieldConfig,
     NamespaceSchema,
@@ -1322,6 +1323,69 @@ def search_records(
             timeout=timeout,
         )
 
+    def list_namespaces_paginated(
+        self,
+        *,
+        prefix: str | None = None,
+        limit: int | None = None,
+        pagination_token: str | None = None,
+        timeout: float | None = None,
+    ) -> ListNamespacesResponse:
+        """Fetch a single page of namespace descriptions via gRPC.
+
+        Args:
+            prefix (str | None): Return only namespaces whose names start with this prefix.
+            limit (int | None): Maximum number of namespaces to return in this page.
+            pagination_token (str | None): Token from a previous response to fetch the next page.
+            timeout (float | None): Per-call timeout in seconds.
+
+        Returns:
+            :class:`ListNamespacesResponse` with namespace descriptions, pagination info,
+            and total count.
+        """
+        logger.info("Listing namespaces (paginated) via gRPC")
+        result = self._channel.list_namespaces(
+            prefix=prefix,
+            limit=limit,
+            pagination_token=pagination_token,
+            timeout_s=timeout,
+        )
+
+        namespaces: list[NamespaceDescription] = []
+        for ns_data in result.get("namespaces", []):
+            schema: NamespaceSchema | None = None
+            raw_schema = ns_data.get("schema")
+            if raw_schema is not None:
+                schema = NamespaceSchema(
+                    fields={
+                        k: NamespaceFieldConfig(filterable=v["filterable"])
+                        for k, v in raw_schema.get("fields", {}).items()
+                    }
+                )
+            indexed_fields: IndexedFields | None = None
+            raw_indexed = ns_data.get("indexed_fields")
+            if raw_indexed is not None:
+                indexed_fields = IndexedFields(fields=list(raw_indexed))
+            namespaces.append(
+                NamespaceDescription(
+                    name=ns_data.get("name", ""),
+                    record_count=ns_data.get("record_count", 0),
+                    schema=schema,
+                    indexed_fields=indexed_fields,
+                )
+            )
+
+        pagination: Pagination | None = None
+        raw_pag = result.get("pagination")
+        if raw_pag is not None:
+            pagination = Pagination(next=raw_pag.get("next"))
+
+        return ListNamespacesResponse(
+            namespaces=namespaces,
+            pagination=pagination,
+            total_count=result.get("total_count", 0),
+        )
+
     def describe_namespace(
         self,
         *,

pinecone/grpc/_protocol.py

@@ -110,6 +110,17 @@ def describe_namespace(
         """Describe a namespace."""
         ...
 
+    def list_namespaces(
+        self,
+        *,
+        pagination_token: str | None = None,
+        limit: int | None = None,
+        prefix: str | None = None,
+        timeout_s: float | None = None,
+    ) -> dict[str, Any]:
+        """List namespaces (single page)."""
+        ...
+
     def delete_namespace(
         self,
         namespace: str,

tests/unit/grpc/test_grpc_index.py

@@ -8,7 +8,7 @@
 
 import pinecone.grpc
 from pinecone.grpc import GRPCIndex, GrpcIndex
-from pinecone.models.namespaces.models import NamespaceDescription
+from pinecone.models.namespaces.models import ListNamespacesResponse, NamespaceDescription
 
 _MOCK_GRPC_MODULE_PATH = "pinecone._grpc"
 
@@ -190,3 +190,94 @@ def test_grpc_delete_namespace_passes_timeout(self) -> None:
         idx.delete_namespace(name="ns1", timeout=3.0)
 
         mock_channel.delete_namespace.assert_called_once_with("ns1", timeout_s=3.0)
+
+
+class TestGrpcListNamespacesPaginated:
+    def test_grpc_list_namespaces_paginated_routes_to_channel(self) -> None:
+        mock_channel = MagicMock()
+        mock_channel.list_namespaces.return_value = {
+            "namespaces": [{"name": "ns1", "record_count": 5}],
+            "total_count": 1,
+        }
+        idx = _make_grpc_index(mock_channel)
+
+        result = idx.list_namespaces_paginated()
+
+        assert isinstance(result, ListNamespacesResponse)
+        assert len(result.namespaces) == 1
+        assert isinstance(result.namespaces[0], NamespaceDescription)
+        assert result.namespaces[0].name == "ns1"
+        assert result.namespaces[0].record_count == 5
+        assert result.total_count == 1
+        assert result.pagination is None
+
+    def test_grpc_list_namespaces_paginated_prefix_forwarded(self) -> None:
+        mock_channel = MagicMock()
+        mock_channel.list_namespaces.return_value = {"namespaces": [], "total_count": 0}
+        idx = _make_grpc_index(mock_channel)
+
+        idx.list_namespaces_paginated(prefix="prod-")
+
+        mock_channel.list_namespaces.assert_called_once_with(
+            prefix="prod-",
+            limit=None,
+            pagination_token=None,
+            timeout_s=None,
+        )
+
+    def test_grpc_list_namespaces_paginated_pagination_token_forwarded(self) -> None:
+        mock_channel = MagicMock()
+        mock_channel.list_namespaces.return_value = {"namespaces": [], "total_count": 0}
+        idx = _make_grpc_index(mock_channel)
+
+        idx.list_namespaces_paginated(pagination_token="tok123")
+
+        mock_channel.list_namespaces.assert_called_once_with(
+            prefix=None,
+            limit=None,
+            pagination_token="tok123",
+            timeout_s=None,
+        )
+
+    def test_grpc_list_namespaces_paginated_limit_forwarded(self) -> None:
+        mock_channel = MagicMock()
+        mock_channel.list_namespaces.return_value = {"namespaces": [], "total_count": 0}
+        idx = _make_grpc_index(mock_channel)
+
+        idx.list_namespaces_paginated(limit=10)
+
+        mock_channel.list_namespaces.assert_called_once_with(
+            prefix=None,
+            limit=10,
+            pagination_token=None,
+            timeout_s=None,
+        )
+
+    def test_grpc_list_namespaces_paginated_pagination_next_parsed(self) -> None:
+        mock_channel = MagicMock()
+        mock_channel.list_namespaces.return_value = {
+            "namespaces": [{"name": "a", "record_count": 1}],
+            "pagination": {"next": "nexttoken"},
+            "total_count": 5,
+        }
+        idx = _make_grpc_index(mock_channel)
+
+        result = idx.list_namespaces_paginated()
+
+        assert result.pagination is not None
+        assert result.pagination.next == "nexttoken"
+        assert result.total_count == 5
+
+    def test_grpc_list_namespaces_paginated_timeout_forwarded(self) -> None:
+        mock_channel = MagicMock()
+        mock_channel.list_namespaces.return_value = {"namespaces": [], "total_count": 0}
+        idx = _make_grpc_index(mock_channel)
+
+        idx.list_namespaces_paginated(timeout=2.5)
+
+        mock_channel.list_namespaces.assert_called_once_with(
+            prefix=None,
+            limit=None,
+            pagination_token=None,
+            timeout_s=2.5,
+        )