feat(grpc): add GrpcIndex.delete_namespace (LSB-0051)

## Purpose

`GrpcIndex` was missing `delete_namespace`, blocking backcompat parity
with the legacy `GRPCIndex`. Users need to delete namespaces via the
gRPC path without falling back to REST.

## Solution

- Added `delete_namespace` to `GrpcChannelProtocol` in `_protocol.py`
  so mypy can verify all call sites.
- Added `GrpcIndex.delete_namespace` in `grpc/__init__.py` mirroring
  the signature and validation logic of `Index.delete_namespace`:
  keyword-only `name=`, legacy `namespace=` alias via `**kwargs`,
  `TypeError` on unexpected kwargs, `ValidationError` on both-provided
  or empty/whitespace name.
- Delegates to `self._channel.delete_namespace(effective, timeout_s=timeout)`;
  returns `None` (Rust side returns an empty dict which is discarded).
- 6 unit tests covering success, legacy alias, both-kwargs error,
  positional TypeError, empty name, and timeout forwarding.
- Integration test `test_namespace_crud_lifecycle_grpc` covering the
  full create/describe/list/delete round-trip via `grpc=True`.

Author: jhamon

pinecone/grpc/__init__.py

@@ -1381,6 +1381,42 @@ def describe_namespace(
             indexed_fields=indexed_fields,
         )
 
+    def delete_namespace(
+        self,
+        *,
+        name: str | None = None,
+        timeout: float | None = None,
+        **kwargs: str,
+    ) -> None:
+        """Delete a namespace by name, removing all its vectors.
+
+        Args:
+            name (str): Name of the namespace to delete.
+            timeout (float | None): Per-call timeout in seconds.
+
+        Returns:
+            None — a successful delete returns no payload.
+
+        Raises:
+            :exc:`ValidationError`: If the name is not a string or is empty/whitespace.
+            :exc:`TypeError`: If unexpected keyword arguments are passed.
+        """
+        legacy_namespace: str | None = kwargs.pop("namespace", None)
+        if kwargs:
+            raise TypeError(
+                f"delete_namespace() got unexpected keyword arguments: {sorted(kwargs)!r}"
+            )
+        if name is not None and legacy_namespace is not None:
+            raise ValidationError("Provide either name= or namespace=, not both")
+        effective: str = name if name is not None else (legacy_namespace or "")
+        if not isinstance(effective, str):
+            raise ValidationError("namespace name must be a string")
+        if not effective or not effective.strip():
+            raise ValidationError("namespace name must be a non-empty string")
+
+        logger.info("Deleting namespace %r via gRPC", effective)
+        self._channel.delete_namespace(effective, timeout_s=timeout)
+
     def close(self) -> None:
         """Close the underlying gRPC channel, REST client, and release resources."""
         self._executor.shutdown(wait=True)

pinecone/grpc/_protocol.py

@@ -110,6 +110,15 @@ def describe_namespace(
         """Describe a namespace."""
         ...
 
+    def delete_namespace(
+        self,
+        namespace: str,
+        *,
+        timeout_s: float | None = None,
+    ) -> None:
+        """Delete a namespace."""
+        ...
+
     def close(self) -> None:
         """Close the channel and release resources."""
         ...

tests/integration/test_data_plane.py

@@ -943,6 +943,56 @@ def test_namespace_crud_lifecycle_rest(client: Pinecone, shared_index_dim2: str)
     assert ns_name not in post_names
 
 
+# ---------------------------------------------------------------------------
+# namespace CRUD — gRPC
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.integration
+def test_namespace_crud_lifecycle_grpc(client: Pinecone, shared_index_dim2: str) -> None:
+    # shared_index_dim2
+    """GrpcIndex create_namespace / describe_namespace / list_namespaces_paginated / delete_namespace round-trip.
+
+    Verifies claims:
+    - unified-ns-0001: Can create a named namespace via gRPC.
+    - unified-ns-0002: Creation returns name and record_count == 0.
+    - unified-ns-0003: Can describe a namespace by name via gRPC.
+    - unified-ns-0004: Can delete a namespace by name via gRPC; returns None.
+    - unified-ns-0005: Can list namespaces via gRPC with optional prefix filtering.
+    """
+    ns = f"ns-{uuid.uuid4().hex[:8]}"
+    ns_name = f"{ns}-grpc"
+    index: GrpcIndex = client.index(name=shared_index_dim2, grpc=True)
+
+    # 1. Create namespace — returns NamespaceDescription with record_count == 0
+    created = index.create_namespace(name=ns_name)
+    assert isinstance(created, NamespaceDescription)
+    assert created.name == ns_name
+    assert created.record_count == 0  # unified-ns-0002
+
+    # 2. Describe namespace — returns same details
+    described = index.describe_namespace(name=ns_name)
+    assert isinstance(described, NamespaceDescription)
+    assert described.name == ns_name
+    assert isinstance(described.record_count, int)
+
+    # 3. Namespace appears in list_namespaces_paginated with prefix match
+    list_resp = index.list_namespaces_paginated(prefix=f"{ns}-", limit=100)
+    assert isinstance(list_resp, ListNamespacesResponse)
+    ns_names = [ns_item.name for ns_item in list_resp.namespaces]
+    assert ns_name in ns_names
+
+    # 4. Delete namespace — returns None on success (unified-ns-0004)
+    result = index.delete_namespace(name=ns_name)
+    assert result is None
+
+    # 5. After deletion, namespace no longer appears in listing
+    post_delete = index.list_namespaces_paginated(prefix=f"{ns}-", limit=100)
+    assert isinstance(post_delete, ListNamespacesResponse)
+    post_names = [ns_item.name for ns_item in post_delete.namespaces]
+    assert ns_name not in post_names
+
+
 # ---------------------------------------------------------------------------
 # list_namespaces generator — REST sync
 # ---------------------------------------------------------------------------

tests/unit/grpc/test_grpc_index.py

@@ -131,3 +131,62 @@ def test_grpc_describe_namespace_passes_timeout(self) -> None:
         idx.describe_namespace(name="ns1", timeout=5.0)
 
         mock_channel.describe_namespace.assert_called_once_with("ns1", timeout_s=5.0)
+
+
+class TestGrpcDeleteNamespace:
+    def test_grpc_delete_namespace_returns_none(self) -> None:
+        mock_channel = MagicMock()
+        mock_channel.delete_namespace.return_value = None
+        idx = _make_grpc_index(mock_channel)
+
+        result = idx.delete_namespace(name="movies")
+
+        mock_channel.delete_namespace.assert_called_once_with("movies", timeout_s=None)
+        assert result is None
+
+    def test_grpc_delete_namespace_accepts_legacy_namespace_kwarg(self) -> None:
+        mock_channel = MagicMock()
+        mock_channel.delete_namespace.return_value = None
+        idx = _make_grpc_index(mock_channel)
+
+        result = idx.delete_namespace(namespace="movies")  # type: ignore[call-arg]
+
+        mock_channel.delete_namespace.assert_called_once_with("movies", timeout_s=None)
+        assert result is None
+
+    def test_grpc_delete_namespace_both_kwargs_raise(self) -> None:
+        from pinecone.errors.exceptions import ValidationError
+
+        mock_channel = MagicMock()
+        idx = _make_grpc_index(mock_channel)
+
+        with pytest.raises(ValidationError, match=r"name=.*namespace="):
+            idx.delete_namespace(name="movies", namespace="movies")  # type: ignore[call-arg]
+
+    def test_grpc_delete_namespace_positional_name_raises(self) -> None:
+        mock_channel = MagicMock()
+        idx = _make_grpc_index(mock_channel)
+
+        with pytest.raises(TypeError):
+            idx.delete_namespace("my-ns")  # type: ignore[misc]
+
+    def test_grpc_delete_namespace_empty_name_raises(self) -> None:
+        from pinecone.errors.exceptions import ValidationError
+
+        mock_channel = MagicMock()
+        idx = _make_grpc_index(mock_channel)
+
+        with pytest.raises(ValidationError, match="non-empty"):
+            idx.delete_namespace(name="")
+
+        with pytest.raises(ValidationError, match="non-empty"):
+            idx.delete_namespace(name="   ")
+
+    def test_grpc_delete_namespace_passes_timeout(self) -> None:
+        mock_channel = MagicMock()
+        mock_channel.delete_namespace.return_value = None
+        idx = _make_grpc_index(mock_channel)
+
+        idx.delete_namespace(name="ns1", timeout=3.0)
+
+        mock_channel.delete_namespace.assert_called_once_with("ns1", timeout_s=3.0)