grid-cortex-client 0.5.1__tar.gz → 0.6.1__tar.gz

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/CLAUDE.md

@@ -5,7 +5,7 @@ Python client for the Cortex ML inference API. Published to **public PyPI**.
 ## Build & Test
 
 ```bash
-uv run --package grid-cortex-client pytest
+BUILD_VERSION=0.0.0.dev0 uv run --project cortex --package grid-cortex-client pytest
 ```
 
 - Build tool: hatchling + hatch-vcs
@@ -27,7 +27,7 @@ uv run --package grid-cortex-client pytest
 | Stage | `https://cortex-stage.generalrobotics.dev/cortex` | `wss://cortex-stage.generalrobotics.dev/cortex/ws/ws` |
 | Prod | `https://cortex-prod.generalrobotics.dev/cortex` | `wss://cortex-prod.generalrobotics.dev/cortex/ws/ws` |
 
-Override via `GRID_CORTEX_BASE_URL` (REST) and `GRID_CORTEX_WS_URL` (WebSocket). Default is prod.
+Override the REST/WebSocket base via `GRID_CORTEX_BASE_URL`. Default is prod.
 
 ## Publishing
 

grid_cortex_client-0.6.1/MIGRATION.md

@@ -0,0 +1,19 @@
+# grid-cortex-client migration notes
+
+## `CORTEX_API_KEY` → `GRID_CORTEX_API_KEY` (breaking)
+
+The client now resolves the API key from **`GRID_CORTEX_API_KEY`** only. The
+legacy `CORTEX_API_KEY` environment-variable fallback in `CortexHubClient` has
+been removed.
+
+**Action required:** set `GRID_CORTEX_API_KEY` instead of `CORTEX_API_KEY`, or
+pass `api_key=` explicitly to the client. Code that still relies on
+`CORTEX_API_KEY` will construct the client with no key and get a `401` on the
+first call.
+
+This is a breaking change to the published package and must ship under a MAJOR
+bump (`cortex-client/vX.0.0`) — see `client-versioning.md` (the squash subject
+needs `feat(cortex-client)!:` or a `BREAKING CHANGE:` footer, or cut the MAJOR
+manually). `GRID_CORTEX_API_KEY` is the single canonical name repo-wide: the
+legacy `CORTEX_API_KEY` is no longer injected into the session pod either, so
+customer skills that read `CORTEX_API_KEY` directly must migrate too.

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grid-cortex-client
-Version: 0.5.1
+Version: 0.6.1
 Summary: Python client for Grid Cortex
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/pyproject.toml

@@ -53,4 +53,5 @@ markers = [
 [dependency-groups]
 dev = [
     "pytest>=8.3.5",
+    "pytest-asyncio>=0.24",
 ]

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/src/grid_cortex_client/client.py

@@ -4,7 +4,7 @@ import httpx
 import logging
 from . import utils as _u
 
-BASE_URL = os.getenv("GRID_CORTEX_BASE_URL", "https://cortex-prod.generalrobotics.dev/cortex")
+DEFAULT_BASE_URL = "https://cortex-prod.generalrobotics.dev/cortex"
 
 # Remove basicConfig, as library logging should not configure root logger
 # logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
@@ -51,7 +51,7 @@ class HTTPClient:
             headers["x-api-key"] = api_key
 
         # Determine the final base URL
-        final_base_url = base_url or os.getenv("GRID_CORTEX_BASE_URL", "https://cortex-prod.generalrobotics.dev/cortex")
+        final_base_url = base_url or os.getenv("GRID_CORTEX_BASE_URL", DEFAULT_BASE_URL)
         logger.info(f"HTTPClient initialized for base URL: {final_base_url}")
 
         self._client = httpx.Client(base_url=final_base_url, timeout=timeout, headers=headers)
@@ -75,7 +75,6 @@ class HTTPClient:
                 headers.setdefault("Content-Type", "application/msgpack")
                 resp = self._client.post(path, content=data, headers=headers, timeout=timeout)
             else:
-                # JSON fall-back (legacy)
                 headers = headers or {"Content-Type": "application/json"}
                 resp = self._client.post(path, json=json, data=data, headers=headers, timeout=timeout)
             resp.raise_for_status()
@@ -170,7 +169,7 @@ class AsyncHTTPClient:
         else:
             headers["x-api-key"] = api_key
 
-        final_base_url = base_url or os.getenv("GRID_CORTEX_BASE_URL", "https://cortex-prod.generalrobotics.dev/cortex")
+        final_base_url = base_url or os.getenv("GRID_CORTEX_BASE_URL", DEFAULT_BASE_URL)
         logger.info(f"AsyncHTTPClient initialized for base URL: {final_base_url}")
 
         self._client = httpx.AsyncClient(base_url=final_base_url, timeout=timeout, headers=headers)

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/src/grid_cortex_client/cortex_hub_client.py

@@ -84,7 +84,7 @@ class CortexHubClient:
 
     Args:
         api_key: API key (defaults to GRID_CORTEX_API_KEY env var)
-        base_url: Base URL (defaults to GRID_CORTEX_BASE_URL env var or production).
+        base_url: Base URL (defaults to the GRID_CORTEX_BASE_URL env var, or production if unset).
                   The WebSocket endpoint is derived from the `/ws` route prefix (ends up as `/ws/ws`).
         timeout: Socket timeout in seconds
 
@@ -108,9 +108,9 @@ class CortexHubClient:
         base_url: Optional[str] = None,
         timeout: float = 60.0,
     ):
-        self._api_key = api_key or os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        self._api_key = api_key or os.getenv("GRID_CORTEX_API_KEY")
         if not self._api_key:
-            logger.warning("API key not set. Set GRID_CORTEX_API_KEY or CORTEX_API_KEY.")
+            logger.warning("API key not set. Set GRID_CORTEX_API_KEY.")
         self._base_url = base_url
         self._url = self._resolve_ws_url(base_url)
         self._timeout = timeout

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/src/grid_cortex_client/model_type.py

@@ -13,36 +13,54 @@ from enum import Enum
 
 
 class ModelType(Enum):
-    CONTACT_GRASPNET = "contact-graspnet"
+    C_RADIO = "c-radio"
     """
-    Generate 6-DoF grasp poses from a depth image + camera intrinsics
-    (+ optional segmentation mask) using Contact-GraspNet (PyTorch port).
+    Compute an L2-normalized embedding for a single RGB image.
 
     Args:
-        depth_image (Union[str, Image.Image, np.ndarray]): Depth image (path/URL/PIL/ndarray; float32 H×W).
-        camera_intrinsics (Union[str, np.ndarray]): 3×3 intrinsics matrix.
-        seg_image (Union[str, Image.Image, np.ndarray, None]): Optional segmentation mask (uint8 H×W).
-            When supplied + aux_args["filter_grasps"] = True, grasps are restricted to the masked region.
-        aux_args (Dict[str, Any]): Optional dict. Keys:
-            - "top_k" (int, default 64): cap on returned grasps after score-sort.
-            - "z_range" ([float, float], default [0.2, 1.8]): z-axis crop in metres.
-            - "local_regions" (bool, default False): crop 3D regions around segments.
-            - "filter_grasps" (bool, default False): restrict grasps to segmap; requires seg_image.
-            - "forward_passes" (int, default 1): how many forward passes to ensemble.
-        timeout (float | None): Optional HTTP timeout.
+        image_input (Union[str, Image.Image, np.ndarray]): RGB image as file path, URL, PIL Image, or numpy array.
+        timeout (float | None): Optional timeout in seconds for the HTTP request.
 
     Returns:
-        Dict with:
-            - grasps: Array of 4×4 grasp poses in camera frame, shape (N, 4, 4), N <= top_k.
-            - confidence: Array of confidence scores in [0, 1], shape (N,).
-            - latency_ms: Optional server-reported latency in milliseconds.
+        np.ndarray: Embedding as numpy array of shape ``(D,)``, dtype ``float32``,
+            L2-normalized so dot products give cosine similarity directly.
 
     Raises:
-        ValueError: If depth or intrinsics cannot be loaded.
+        ValueError: If image cannot be loaded.
         RuntimeError: If no HTTP transport is configured.
         Exception: If the HTTP request fails.
 
     Example:
+        >>> from grid_cortex_client import CortexClient, ModelType
+        >>> import numpy as np
+        >>> from PIL import Image
+        >>> client = CortexClient()
+        >>> image = np.array(Image.open("cat.jpg"))
+        >>> emb = client.run(ModelType.C_RADIO, image_input=image)
+        >>> print(emb.shape, float(np.linalg.norm(emb)))  # (D,) 1.0
+    """
+    CONTACT_GRASPNET = "contact-graspnet"
+    """
+    Generate grasps using ContactGraspNet.
+
+    Args:
+        depth_image (Union[str, Image.Image, np.ndarray, None]): Depth image (required).
+        camera_intrinsics (Union[str, np.ndarray, None]): 3×3 intrinsics matrix (required).
+        seg_image (Union[str, Image.Image, np.ndarray, None]): Optional segmentation mask (uint8 H×W).
+        aux_args (Dict[str, Any] | None): Optional dict. Keys: ``top_k`` (int, default 64),
+            ``z_range`` ([float, float], default [0.2, 1.8]),
+            ``local_regions`` (bool, default False),
+            ``filter_grasps`` (bool, default False; requires ``seg_image``),
+            ``forward_passes`` (int, default 1).
+        timeout (float | None): Optional HTTP timeout.
+
+    Returns:
+        Dict with:
+            - ``grasps``: (N, 4, 4) array of grasp poses in camera frame
+            - ``confidence``: (N,) array of confidence scores in [0, 1]
+            - ``latency_ms``: server-reported latency
+
+    Examples:
         >>> from grid_cortex_client import CortexClient, ModelType
         >>> import numpy as np
         >>> client = CortexClient()
@@ -302,14 +320,18 @@ class ModelType(Enum):
     """
     METRIC3D = "metric3d"
     """
-    Estimate metric depth and surface normals from a single RGB image.
+    Estimate metric depth and/or surface normals from a single RGB image.
 
     Args:
         image_input (Union[str, Image.Image, np.ndarray]): RGB image as file path, URL, PIL Image, or numpy array.
         timeout (float | None): Optional timeout in seconds for the HTTP request.
+        outputs (Optional[Union[str, Sequence[str]]]): Keyword-only. Optional selection of maps to return —
+            ``"depth"``, ``"normals"``, or a non-empty subset of both.
+            ``None`` (default) returns both. Requesting only what you need
+            shrinks the response payload (normals are 3x the size of depth).
 
     Returns:
-        Dict with keys:
+        Dict with the requested subset of:
             - ``"depth"``: (H, W) float32 array, metric depth in metres.
             - ``"normals"``: (H, W, 3) float32 array, unit surface normals.
 

grid_cortex_client-0.6.1/src/grid_cortex_client/models/c_radio.py

@@ -0,0 +1,129 @@
+"""C-RADIO wrapper.
+
+Client-side helper for the dense visual embedding endpoint powered by
+NVIDIA C-RADIOv4-SO400M.
+"""
+
+from __future__ import annotations
+
+from io import BytesIO
+from typing import Any, Dict, Union
+
+import numpy as np
+from PIL import Image
+
+from ..preprocessing import load_image, image_to_bytes
+from .base_model import BaseModel
+
+
+class CRadio(BaseModel):
+    """Dense visual embedding (C-RADIOv4-SO400M).
+
+    Preferred usage (through :class:`CortexClient`)
+    ---------------------------------------------
+    ```pycon
+    >>> emb = CortexClient().run(ModelType.C_RADIO, image_input=img)
+    >>> emb.shape
+    (2304,)
+    >>> float(np.linalg.norm(emb))
+    1.0
+    ```
+
+    Args (for :py:meth:`run`)
+    ------------------------
+    image_input: RGB image (path, URL, ``PIL.Image`` or ``np.ndarray``).
+
+    Returns
+    -------
+    np.ndarray
+        L2-normalized embedding vector (``float32``, 1-D). Cosine similarity
+        between two outputs is a plain ``a @ b``.
+    """
+
+    name: str = "c-radio"
+    model_id: str = "c-radio"
+
+    def __init__(self, *, transport=None) -> None:
+        """Create a C-RADIO wrapper.
+
+        Args:
+            transport: Optional shared HTTP transport injected by
+                :class:`~grid_cortex_client.CortexClient`.
+        """
+        super().__init__(transport=transport)
+
+    # ------------------------------------------------------------------
+    # BaseModel interface
+    # ------------------------------------------------------------------
+
+    def preprocess(
+        self,
+        *,
+        image_input: Union[str, Image.Image, np.ndarray],
+    ) -> Dict[str, Any]:
+        """Return msgpack-ready payload with raw JPEG image bytes."""
+        pil_img = load_image(image_input)
+        return {"image_input": image_to_bytes(pil_img, encoding_format="JPEG")}
+
+    def postprocess(
+        self,
+        response_data: Dict[str, Any],
+        **_: Any,
+    ) -> np.ndarray:
+        """Decode backend response into an L2-normalized embedding array.
+
+        Args:
+            response_data: Backend dict (or list-wrapped dict) containing an
+                ``"output"`` key holding ``.npy`` bytes for a 1-D float vector.
+
+        Returns:
+            np.ndarray of shape ``(D,)``, dtype ``float32``, L2-normalized.
+
+        Raises:
+            ValueError: If the payload is missing or cannot be decoded.
+        """
+        if isinstance(response_data, list):
+            response_dict = response_data[0]
+        else:
+            response_dict = response_data
+
+        emb_bytes = response_dict.get("output")
+        if not isinstance(emb_bytes, (bytes, bytearray, memoryview)):
+            raise ValueError("'output' field missing or not bytes")
+
+        arr = np.load(BytesIO(emb_bytes), allow_pickle=False)
+        return arr.astype(np.float32)
+
+    def run(
+        self,
+        image_input: Union[str, Image.Image, np.ndarray],
+        timeout: float | None = None,
+    ) -> np.ndarray:
+        """Compute an L2-normalized embedding for a single RGB image.
+
+        Args:
+            image_input: RGB image as file path, URL, PIL Image, or numpy array.
+            timeout: Optional timeout in seconds for the HTTP request.
+
+        Returns:
+            Embedding as numpy array of shape ``(D,)``, dtype ``float32``,
+            L2-normalized so dot products give cosine similarity directly.
+
+        Raises:
+            ValueError: If image cannot be loaded.
+            RuntimeError: If no HTTP transport is configured.
+            Exception: If the HTTP request fails.
+
+        Example:
+            >>> from grid_cortex_client import CortexClient, ModelType
+            >>> import numpy as np
+            >>> from PIL import Image
+            >>> client = CortexClient()
+            >>> image = np.array(Image.open("cat.jpg"))
+            >>> emb = client.run(ModelType.C_RADIO, image_input=image)
+            >>> print(emb.shape, float(np.linalg.norm(emb)))  # (D,) 1.0
+        """
+        return super().run(
+            image_input=image_input,
+            timeout=timeout,
+        )

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/src/grid_cortex_client/models/pi05.py

@@ -135,6 +135,8 @@ class PI05(BaseModel):
         gripper: Union[np.ndarray, list],
         state: Union[np.ndarray, list],
         prompt: Optional[str] = None,
+        rtc_kwargs: Optional[Dict[str, Any]] = None,
+        prev_chunk: Optional[Union[np.ndarray, list]] = None,
     ) -> Dict[str, Any]:
         """Convert inputs to the payload expected by the server.
 
@@ -145,6 +147,13 @@ class PI05(BaseModel):
             gripper: Gripper position.
             state: Robot state (concatenation of joints and gripper).
             prompt: Optional task prompt.
+            rtc_kwargs: Optional real-time-chunking params. When set, the server
+                routes through the RTC path (model.realtime_action). Expected
+                keys: ``rtc_current_index`` (steps of the previous chunk already
+                executed), ``rtc_frozen_until``, ``rtc_thaw_until``.
+            prev_chunk: Previous predicted action chunk, fed back as RTC guidance.
+                None on the first call; on later calls pass the ``prev_chunk``
+                returned by the previous inference.
 
         Returns:
             Dictionary that will be msgpack-encoded and sent to the server.
@@ -180,6 +189,13 @@ class PI05(BaseModel):
             "gripper": gripper_arr,
             "state": state_arr,
         }
+        # Real-time chunking (optional). Presence of rtc_kwargs is what makes the
+        # server take the RTC path; prev_chunk is the guidance chunk (None → the
+        # server bootstraps one on the first call).
+        if rtc_kwargs is not None:
+            obs["rtc_kwargs"] = rtc_kwargs
+        if prev_chunk is not None:
+            obs["prev_chunk"] = np.asarray(prev_chunk, dtype=np.float32)
 
         payload = {"obs": obs}
         if prompt is not None:
@@ -235,6 +251,8 @@ class PI05(BaseModel):
         gripper: Union[np.ndarray, list],
         state: Union[np.ndarray, list],
         prompt: Optional[str] = None,
+        rtc_kwargs: Optional[Dict[str, Any]] = None,
+        prev_chunk: Optional[Union[np.ndarray, list]] = None,
         timeout: float | None = None,
     ) -> Dict[str, Any]:
         """Run PI05 policy inference on robot observations.
@@ -246,11 +264,17 @@ class PI05(BaseModel):
             gripper: Gripper position as numpy array or list.
             state: Robot state as numpy array or list (concatenation of joints and gripper).
             prompt: Optional task prompt string.
+            rtc_kwargs: Optional real-time-chunking params (see :py:meth:`preprocess`).
+                When set, the server runs the RTC path and returns a ``prev_chunk``
+                field to feed back on the next call.
+            prev_chunk: Previous predicted chunk fed back as RTC guidance (None on
+                the first call).
             timeout: Optional timeout in seconds for the HTTP request.
 
         Returns:
             Action dictionary containing:
             - "actions": numpy array of shape (horizon, action_dim) with predicted actions
+            - "prev_chunk": (RTC only) chunk to feed back on the next call
             - Other fields from policy.infer() (e.g., "state", "policy_timing", etc.)
 
         Raises:
@@ -284,5 +308,7 @@ class PI05(BaseModel):
             gripper=gripper,
             state=state,
             prompt=prompt,
+            rtc_kwargs=rtc_kwargs,
+            prev_chunk=prev_chunk,
             timeout=timeout,
         )

grid_cortex_client-0.6.1/tests/test_c_radio.py

@@ -0,0 +1,124 @@
+"""Test C-RADIO model."""
+
+import os
+import time
+
+import numpy as np
+import pytest
+
+from grid_cortex_client import AsyncCortexClient, CortexClient, CortexHubClient, ModelType
+from grid_cortex_client.client import CortexAPIError
+
+from .conftest import BaseModelTestHTTP, run_concurrent_requests, is_gpu_mem_close
+
+
+class TestCRadioHTTP(BaseModelTestHTTP):
+    """HTTP-based tests for C-RADIO dense visual embedding model."""
+
+    @property
+    def batch_size(self) -> int:
+        """C-RADIO model batch size (matches `max_ongoing_requests` in config.yaml)."""
+        return 8
+
+    @property
+    def gpu_mem(self) -> float:
+        """C-RADIO model GPU memory budget (MB, matches config.yaml `gpu_mem`)."""
+        return 2000.0
+
+    @property
+    def max_input_size(self) -> tuple:
+        """C-RADIO model maximum input size (width, height)."""
+        return (720, 1280)
+
+    def test_basic_inference(self, client: CortexClient, rgb_image_np: np.ndarray):
+        """Test basic embedding extraction with valid input."""
+        emb = client.run(ModelType.C_RADIO, image_input=rgb_image_np)
+
+        assert emb is not None
+        assert isinstance(emb, np.ndarray)
+        assert emb.ndim == 1, f"emb.ndim {emb.ndim} != 1"
+        assert emb.shape[0] == 2304, f"emb dim {emb.shape[0]} != 2304 (C-RADIOv4-SO400M summary)"
+        assert emb.dtype == np.float32, f"emb.dtype {emb.dtype} != float32"
+        assert np.isfinite(emb).all(), "embedding contains NaN/Inf"
+        # L2-normalized → magnitude should be 1.0 within float32 tolerance.
+        norm = float(np.linalg.norm(emb))
+        assert abs(norm - 1.0) < 1e-3, f"embedding not L2-normalized (||emb|| = {norm})"
+
+    def test_image_input_list_rejected(self, client: CortexClient, rgb_image_np: np.ndarray):
+        """List image_input is rejected — at the client (TypeError) or server (422)."""
+        with pytest.raises((TypeError, CortexAPIError)):
+            client.run(ModelType.C_RADIO, image_input=[rgb_image_np, rgb_image_np])
+
+    def test_maximum_payload_size(self, client: CortexClient):
+        """Test that inference works with maximum allowed payload size."""
+        large_image = np.random.randint(0, 255, (*self.max_input_size, 3), dtype=np.uint8)
+        emb = client.run(ModelType.C_RADIO, image_input=large_image)
+
+        assert emb is not None
+        assert isinstance(emb, np.ndarray)
+        assert emb.ndim == 1
+
+        oversized_image = np.random.randint(0, 255, (4096, 4096, 3), dtype=np.uint8)
+        with pytest.raises(CortexAPIError) as exc_info:
+            client.run(ModelType.C_RADIO, image_input=oversized_image)
+        assert exc_info.value.status_code == 413
+
+        large_image = np.random.randint(0, 255, (*self.max_input_size, 3), dtype=np.uint8)
+        emb = client.run(ModelType.C_RADIO, image_input=large_image)
+
+        assert emb is not None
+        assert isinstance(emb, np.ndarray)
+        assert emb.ndim == 1
+
+    def test_inference_latency(self, client: CortexClient, rgb_image_np: np.ndarray):
+        """Test that inference latency is within acceptable range."""
+        start_time = time.time()
+        emb = client.run(ModelType.C_RADIO, image_input=rgb_image_np)
+        elapsed_time = time.time() - start_time
+
+        assert emb is not None
+        assert elapsed_time < 10.0, f"Inference took {elapsed_time:.2f}s, expected < 10s"
+
+    @pytest.mark.asyncio
+    async def test_concurrent_requests(self, async_client: AsyncCortexClient, rgb_image_np: np.ndarray):
+        """Test that multiple concurrent requests are handled correctly."""
+
+        async def make_request():
+            return await async_client.run(ModelType.C_RADIO, image_input=rgb_image_np)
+
+        results = await run_concurrent_requests(make_request, num_requests=self.batch_size)
+
+        assert len(results) == self.batch_size
+        assert all(not isinstance(r, Exception) for r in results)
+        assert all(isinstance(r, np.ndarray) for r in results)
+        assert all(r.ndim == 1 for r in results)
+
+    @pytest.mark.asyncio
+    async def test_gpu_memory_usage(self, async_client: AsyncCortexClient, rgb_image_np: np.ndarray):
+        """Test that GPU memory usage is within expected limits during inference."""
+        large_image = np.random.randint(0, 255, (*self.max_input_size, 3), dtype=np.uint8)
+
+        async def make_request():
+            return await async_client.run(ModelType.C_RADIO, image_input=large_image, raw_response=True)
+
+        results = await run_concurrent_requests(make_request, num_requests=self.batch_size)
+
+        assert len(results) == self.batch_size
+        assert all(not isinstance(r, Exception) for r in results)
+        assert all(is_gpu_mem_close(self.gpu_mem, result["gpu_stats"]["mem_usage_mb"]) for result in results), (
+            f"GPU memory peak too high: {[result['gpu_stats']['mem_usage_mb'] for result in results]} MB"
+        )
+
+    @pytest.mark.asyncio
+    async def test_cortex_hub(self, rgb_image_np: np.ndarray):
+        """Test C-RADIO inference via CortexHubClient (WebSocket)."""
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
+        if not api_key:
+            pytest.skip("GRID_CORTEX_API_KEY not set")
+
+        async with CortexHubClient(api_key=api_key) as hub:
+            emb = await hub.run(ModelType.C_RADIO, image_input=rgb_image_np)
+
+        assert emb is not None
+        assert isinstance(emb, np.ndarray)
+        assert emb.ndim == 1

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_contact_graspnet.py

@@ -268,9 +268,9 @@ class TestContactGraspNetHTTP(BaseModelTestHTTP):
         camera_intrinsics: np.ndarray,
         aux_args: dict,
     ):
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         async with CortexHubClient(api_key=api_key) as hub:
             result = await hub.run(

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_cortex_hub_client.py

@@ -21,9 +21,9 @@ class TestCortexHubClient:
     @pytest_asyncio.fixture
     async def hub(self):
         """Create connected CortexHubClient instance."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         hub = CortexHubClient(api_key=api_key)
         await hub.connect()
@@ -33,9 +33,9 @@ class TestCortexHubClient:
     @pytest.mark.asyncio
     async def test_connect_disconnect(self):
         """Test connection lifecycle."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         hub = CortexHubClient(api_key=api_key)
         assert not hub.is_connected
@@ -49,9 +49,9 @@ class TestCortexHubClient:
     @pytest.mark.asyncio
     async def test_context_manager(self, rgb_image_np: np.ndarray):
         """Test async context manager usage."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         async with CortexHubClient(api_key=api_key) as hub:
             assert hub.is_connected
@@ -290,9 +290,9 @@ class TestCortexHubClient:
     @pytest.mark.asyncio
     async def test_not_connected_error(self, rgb_image_np: np.ndarray):
         """Test error when calling run without connecting."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         hub = CortexHubClient(api_key=api_key)
         # Don't connect
@@ -307,9 +307,9 @@ class TestCortexHubClientPubSub:
     @pytest_asyncio.fixture
     async def hub(self):
         """Create connected CortexHubClient instance."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         hub = CortexHubClient(api_key=api_key)
         await hub.connect()
@@ -416,8 +416,10 @@ class TestCortexHubClientPubSub:
 class TestCortexHubClientURLResolution:
     """Tests for URL resolution (no network needed)."""
 
-    def test_default_url_is_production(self):
-        """Test default URL points to production with /ws/ws suffix."""
+    def test_default_url_is_prod(self, monkeypatch):
+        """Test default URL points to prod with /ws/ws suffix."""
+        monkeypatch.delenv("GRID_TARGET_ENV", raising=False)
+        monkeypatch.delenv("GRID_CORTEX_BASE_URL", raising=False)
         hub = CortexHubClient(api_key="test")
         assert "cortex-prod" in hub.url
         assert hub.url.endswith("/ws/ws")

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_da3metric.py

@@ -108,9 +108,9 @@ class TestDA3MetricHTTP(BaseModelTestHTTP):
     @pytest.mark.asyncio
     async def test_cortex_hub(self, rgb_image_np: np.ndarray):
         """Test DA3Metric inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         async with CortexHubClient(api_key=api_key) as hub:
             depth = await hub.run(ModelType.DA3METRIC, image_input=rgb_image_np)

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_fast_foundation_stereo.py

@@ -275,9 +275,9 @@ class TestFastFoundationStereoHTTP(BaseModelTestHTTP):
     @pytest.mark.asyncio
     async def test_cortex_hub(self, stereo_pair: tuple, aux_args: dict):
         """Test Fast-FoundationStereo inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         left, right = stereo_pair
         async with CortexHubClient(api_key=api_key) as hub:

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_foundation_stereo.py

@@ -268,9 +268,9 @@ class TestFoundationStereoHTTP(BaseModelTestHTTP):
     @pytest.mark.asyncio
     async def test_cortex_hub(self, stereo_pair: tuple, aux_args: dict):
         """Test FoundationStereo inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         left, right = stereo_pair
         async with CortexHubClient(api_key=api_key) as hub:

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_graspgen.py

@@ -363,9 +363,9 @@ class TestGraspGenHTTP(BaseModelTestHTTP):
         aux_args: dict,
     ):
         """Test GraspGen inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         async with CortexHubClient(api_key=api_key) as hub:
             result = await hub.run(

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_graspgenx.py

@@ -135,9 +135,9 @@ class TestGraspGenXHTTP(BaseModelTestHTTP):
     @pytest.mark.asyncio
     async def test_cortex_hub(self, point_cloud: np.ndarray, aux_args: dict):
         """Inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
         async with CortexHubClient(api_key=api_key) as hub:
             result = await hub.run(ModelType.GRASPGENX, point_cloud=point_cloud, aux_args=aux_args)
         assert result is not None

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_gsam2.py

@@ -191,9 +191,9 @@ class TestGSAM2HTTP(BaseModelTestHTTP):
     @pytest.mark.asyncio
     async def test_cortex_hub(self, rgb_image_np: np.ndarray):
         """Test GSAM2 inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         async with CortexHubClient(api_key=api_key) as hub:
             result = await hub.run(ModelType.GSAM2, image_input=rgb_image_np, prompt="object")

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_locate_anything.py

@@ -189,9 +189,9 @@ class TestLocateAnythingHTTP(BaseModelTestHTTP):
     @pytest.mark.asyncio
     async def test_cortex_hub(self, rgb_image_np: np.ndarray):
         """Test LocateAnything inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         async with CortexHubClient(api_key=api_key) as hub:
             result = await hub.run(ModelType.LOCATE_ANYTHING, image_input=rgb_image_np, task="detect", prompt="cat")

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_metric3d.py

@@ -134,9 +134,9 @@ class TestMetric3DHTTP(BaseModelTestHTTP):
     @pytest.mark.asyncio
     async def test_cortex_hub(self, rgb_image_np: np.ndarray):
         """Test Metric3D inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         async with CortexHubClient(api_key=api_key) as hub:
             result = await hub.run(ModelType.METRIC3D, image_input=rgb_image_np)

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_moondream.py

@@ -228,9 +228,9 @@ class TestMoondreamHTTP(BaseModelTestHTTP):
     @pytest.mark.asyncio
     async def test_cortex_hub(self, rgb_image_np: np.ndarray):
         """Test Moondream inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         async with CortexHubClient(api_key=api_key) as hub:
             result = await hub.run(ModelType.MOONDREAM, image_input=rgb_image_np, task="caption", length="short")

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_oneformer.py

@@ -193,9 +193,9 @@ class TestOneFormerHTTP(BaseModelTestHTTP):
     @pytest.mark.asyncio
     async def test_cortex_hub(self, rgb_image_np: np.ndarray):
         """Test OneFormer inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         async with CortexHubClient(api_key=api_key) as hub:
             result = await hub.run(ModelType.ONEFORMER, image_input=rgb_image_np, mode="panoptic")

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_owlv2.py

@@ -224,9 +224,9 @@ class TestOWLv2HTTP(BaseModelTestHTTP):
     @pytest.mark.asyncio
     async def test_cortex_hub(self, rgb_image_np: np.ndarray):
         """Test OWLv2 inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         async with CortexHubClient(api_key=api_key) as hub:
             result = await hub.run(ModelType.OWLV2, image_input=rgb_image_np, prompt="cat . dog")

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_pi05.py

@@ -194,9 +194,9 @@ class TestPI05HTTP(BaseModelTestHTTP):
     @pytest.mark.asyncio
     async def test_cortex_hub(self):
         """Test PI05 inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         inputs = self._create_test_inputs()
         async with CortexHubClient(api_key=api_key) as hub:

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_qwen_vl.py

@@ -170,9 +170,9 @@ class TestQwenVLHTTP(BaseModelTestHTTP):
     @pytest.mark.asyncio
     async def test_cortex_hub(self, rgb_image_np: np.ndarray):
         """Test Qwen VL inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         async with CortexHubClient(api_key=api_key) as hub:
             result = await hub.run(ModelType.QWEN_VL, image_input=rgb_image_np, prompt="Describe this image.")

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_sam2.py

@@ -215,9 +215,9 @@ class TestSAM2HTTP(BaseModelTestHTTP):
     @pytest.mark.asyncio
     async def test_cortex_hub(self, rgb_image_np: np.ndarray):
         """Test SAM2 inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         async with CortexHubClient(api_key=api_key) as hub:
             result = await hub.run(ModelType.SAM2, image_input=rgb_image_np, prompts=[[320, 240]], labels=[1])

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_sam3.py

@@ -303,9 +303,9 @@ class TestSAM3HTTP(BaseModelTestHTTP):
     @pytest.mark.asyncio
     async def test_cortex_hub(self, rgb_image_np: np.ndarray):
         """Test SAM3 inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         async with CortexHubClient(api_key=api_key) as hub:
             result = await hub.run(ModelType.SAM3, image_input=rgb_image_np, text="object")

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_ur5e_pyroki_collision_batch.py

@@ -185,9 +185,9 @@ class TestUR5ePyrokiCollisionBatchHTTP(BaseModelTestHTTP):
     @pytest.mark.asyncio
     async def test_cortex_hub(self, collision_batch_payload: dict):
         """Test UR5e PyRoKi Collision Batch inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         async with CortexHubClient(api_key=api_key) as hub:
             result = await hub.run(ModelType.UR5E_PYROKI_COLLISION_BATCH, **collision_batch_payload)

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_ur5e_pyroki_fk.py

@@ -244,9 +244,9 @@ class TestUR5ePyrokiFkHTTP(BaseModelTestHTTP):
     @pytest.mark.asyncio
     async def test_cortex_hub(self, batch_joint_states_np: np.ndarray):
         """Test UR5e PyRoKi FK inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         async with CortexHubClient(api_key=api_key) as hub:
             result = await hub.run(ModelType.UR5E_PYROKI_FK, batch_joint_states=batch_joint_states_np)

{grid_cortex_client-0.5.1 → grid_cortex_client-0.6.1}/tests/test_zoedepth.py

@@ -113,9 +113,9 @@ class TestZoeDepthHTTP(BaseModelTestHTTP):
     @pytest.mark.asyncio
     async def test_cortex_hub(self, rgb_image_np: np.ndarray):
         """Test ZoeDepth inference via CortexHubClient (WebSocket)."""
-        api_key = os.getenv("GRID_CORTEX_API_KEY") or os.getenv("CORTEX_API_KEY")
+        api_key = os.getenv("GRID_CORTEX_API_KEY")
         if not api_key:
-            pytest.skip("GRID_CORTEX_API_KEY or CORTEX_API_KEY not set")
+            pytest.skip("GRID_CORTEX_API_KEY not set")
 
         async with CortexHubClient(api_key=api_key) as hub:
             depth = await hub.run(ModelType.ZOEDEPTH, image_input=rgb_image_np)