x4d-devkit 0.14.2__tar.gz → 0.14.3__tar.gz

{x4d_devkit-0.14.2 → x4d_devkit-0.14.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: x4d-devkit
-Version: 0.14.2
+Version: 0.14.3
 Summary: X-4D dataset format SDK — load, validate, evaluate, and convert autonomous driving datasets
 Author: windzu
 License-Expression: Apache-2.0
@@ -50,6 +50,34 @@ pip install x4d-devkit[client]
 
 ## Quick Start
 
+### Connect to an X-4D platform
+
+The CLI can authenticate with a bearer token passed explicitly, through
+environment variables, or from the user config written by `x4d login`.
+
+```bash
+x4d --base-url http://host:8000 --api-key <token> projects list
+x4d --base-url http://host:8000 --api-key <token> clips list --project-id 1
+x4d --base-url http://host:8000 --api-key <token> clips download --clip-ids clip_a,clip_b --output /data/x4d/clips
+```
+
+```bash
+export X4D_BASE_URL=http://host:8000
+export X4D_API_KEY=<token>
+x4d projects list
+x4d clips list --project-name nuscenes-mini --has-archive true --format json
+x4d clips download --project-name nuscenes-mini --output /data/x4d/nuscenes-mini/clips --workers 8
+```
+
+```bash
+x4d --base-url http://host:8000 login --username <user> --password <password>
+```
+
+`login` stores `base_url` and the returned access token in
+`~/.config/x4d/config.toml`. Archive downloads go through the platform file
+proxy and extract standard X4D clip directories; training containers do not
+need database or MinIO access.
+
 ### Load a clip
 
 ```python

{x4d_devkit-0.14.2 → x4d_devkit-0.14.3}/README.md

@@ -20,6 +20,34 @@ pip install x4d-devkit[client]
 
 ## Quick Start
 
+### Connect to an X-4D platform
+
+The CLI can authenticate with a bearer token passed explicitly, through
+environment variables, or from the user config written by `x4d login`.
+
+```bash
+x4d --base-url http://host:8000 --api-key <token> projects list
+x4d --base-url http://host:8000 --api-key <token> clips list --project-id 1
+x4d --base-url http://host:8000 --api-key <token> clips download --clip-ids clip_a,clip_b --output /data/x4d/clips
+```
+
+```bash
+export X4D_BASE_URL=http://host:8000
+export X4D_API_KEY=<token>
+x4d projects list
+x4d clips list --project-name nuscenes-mini --has-archive true --format json
+x4d clips download --project-name nuscenes-mini --output /data/x4d/nuscenes-mini/clips --workers 8
+```
+
+```bash
+x4d --base-url http://host:8000 login --username <user> --password <password>
+```
+
+`login` stores `base_url` and the returned access token in
+`~/.config/x4d/config.toml`. Archive downloads go through the platform file
+proxy and extract standard X4D clip directories; training containers do not
+need database or MinIO access.
+
 ### Load a clip
 
 ```python

{x4d_devkit-0.14.2 → x4d_devkit-0.14.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "x4d-devkit"
-version = "0.14.2"
+version = "0.14.3"
 description = "X-4D dataset format SDK — load, validate, evaluate, and convert autonomous driving datasets"
 readme = "README.md"
 license = "Apache-2.0"

x4d_devkit-0.14.3/tests/test_cli_auth.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import argparse
+
+from x4d_devkit import cli
+
+
+def test_config_round_trip(tmp_path):
+    path = tmp_path / "config.toml"
+    cli.save_config(
+        {"base_url": "http://host:8000", "api_key": 'tok"en\\value'},
+        path=path,
+    )
+
+    assert cli.load_config(path) == {
+        "base_url": "http://host:8000",
+        "api_key": 'tok"en\\value',
+    }
+
+
+def test_resolve_prefers_explicit_over_env_and_config(tmp_path, monkeypatch):
+    path = tmp_path / "config.toml"
+    cli.save_config({"base_url": "http://config", "api_key": "config-token"}, path)
+    monkeypatch.setenv(cli.CONFIG_ENV, str(path))
+    monkeypatch.setenv(cli.BASE_URL_ENV, "http://env")
+    monkeypatch.setenv(cli.API_KEY_ENV, "env-token")
+
+    args = argparse.Namespace(base_url="http://explicit", api_key="explicit-token", token=None)
+
+    assert cli.resolve_base_url(args) == "http://explicit"
+    assert cli.resolve_api_key(args) == "explicit-token"
+
+
+def test_resolve_prefers_env_over_config(tmp_path, monkeypatch):
+    path = tmp_path / "config.toml"
+    cli.save_config({"base_url": "http://config", "api_key": "config-token"}, path)
+    monkeypatch.setenv(cli.CONFIG_ENV, str(path))
+    monkeypatch.setenv(cli.BASE_URL_ENV, "http://env")
+    monkeypatch.setenv(cli.API_KEY_ENV, "env-token")
+
+    args = argparse.Namespace(base_url=None, api_key=None, token=None)
+
+    assert cli.resolve_base_url(args) == "http://env"
+    assert cli.resolve_api_key(args) == "env-token"
+
+
+def test_resolve_reads_config_when_env_absent(tmp_path, monkeypatch):
+    path = tmp_path / "config.toml"
+    cli.save_config({"base_url": "http://config", "api_key": "config-token"}, path)
+    monkeypatch.setenv(cli.CONFIG_ENV, str(path))
+    monkeypatch.delenv(cli.BASE_URL_ENV, raising=False)
+    monkeypatch.delenv(cli.API_KEY_ENV, raising=False)
+
+    args = argparse.Namespace(base_url=None, api_key=None, token=None)
+
+    assert cli.resolve_base_url(args) == "http://config"
+    assert cli.resolve_api_key(args) == "config-token"
+
+
+def test_parse_bool():
+    assert cli.parse_bool("true") is True
+    assert cli.parse_bool("0") is False

x4d_devkit-0.14.3/tests/test_client_projects.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import pytest
+
+from x4d_devkit.client.projects import ProjectsAPI
+
+
+class FakeClient:
+    def __init__(self, pages):
+        self.pages = pages
+        self.calls = []
+
+    def get(self, path, params=None):
+        assert path == "/projects"
+        self.calls.append(params)
+        return self.pages[params["page"] - 1]
+
+
+def test_get_project_by_exact_name():
+    api = ProjectsAPI(
+        FakeClient(
+            [
+                {
+                    "items": [{"id": 1, "name": "nuscenes"}, {"id": 2, "name": "nuscenes-mini"}],
+                    "total": 2,
+                    "page": 1,
+                    "page_size": 100,
+                }
+            ]
+        )
+    )
+
+    assert api.get_by_name("nuscenes-mini")["id"] == 2
+
+
+def test_get_project_by_name_requires_match():
+    api = ProjectsAPI(
+        FakeClient([{"items": [], "total": 0, "page": 1, "page_size": 100}])
+    )
+
+    with pytest.raises(ValueError, match="Project not found"):
+        api.get_by_name("missing")

{x4d_devkit-0.14.2 → x4d_devkit-0.14.3}/tests/test_coordinate_frames.py

@@ -42,7 +42,7 @@ def _make_synthetic_clip(tmp_path: Path) -> Path:
         "keyframe_count": 2,
         "sweep_count": 0,
         "sensors": {
-            "LIDAR_TOP": {
+            "lidar_top": {
                 "modality": "lidar",
                 "point_format": {
                     "fields": ["x", "y", "z", "intensity"],
@@ -50,7 +50,7 @@ def _make_synthetic_clip(tmp_path: Path) -> Path:
                     "bytes_per_point": 16,
                 },
             },
-            "CAM_FRONT": {
+            "cam_front": {
                 "modality": "camera",
             }
         }
@@ -62,7 +62,7 @@ def _make_synthetic_clip(tmp_path: Path) -> Path:
     (clip_dir / "calibrated_sensor.json").write_text(json.dumps([
         {
             "calibrated_sensor_token": "cs-lidar",
-            "channel": "LIDAR_TOP",
+            "channel": "lidar_top",
             "translation": {"x": 0.0, "y": 0.0, "z": 1.0},
             "rotation": {"qx": 0.0, "qy": 0.0, "qz": 0.0, "qw": 1.0},
             "intrinsics": None,
@@ -70,7 +70,7 @@ def _make_synthetic_clip(tmp_path: Path) -> Path:
         },
         {
             "calibrated_sensor_token": "cs-cam",
-            "channel": "CAM_FRONT",
+            "channel": "cam_front",
             "translation": {"x": 0.5, "y": 0.0, "z": 0.8},
             "rotation": {"qx": 0.0, "qy": 0.0, "qz": 0.0, "qw": 1.0},
             "intrinsics": {"camera_model": "pinhole",
@@ -117,16 +117,16 @@ def _make_synthetic_clip(tmp_path: Path) -> Path:
     ]))
 
     # -- sample_data.json --
-    lidar_dir = clip_dir / "LIDAR_TOP"
+    lidar_dir = clip_dir / "lidar_top"
     lidar_dir.mkdir()
 
     (clip_dir / "sample_data.json").write_text(json.dumps([
         {
             "sample_data_token": "sd-lidar-0",
             "sample_token": "s-0",
-            "channel": "LIDAR_TOP",
+            "channel": "lidar_top",
             "timestamp_us": 1000000,
-            "file_path": "LIDAR_TOP/frame0.bin",
+            "file_path": "lidar_top/frame0.bin",
             "ego_pose_token": "ep-0",
             "calibrated_sensor_token": "cs-lidar",
             "is_keyframe": True,
@@ -138,9 +138,9 @@ def _make_synthetic_clip(tmp_path: Path) -> Path:
         {
             "sample_data_token": "sd-lidar-1",
             "sample_token": "s-1",
-            "channel": "LIDAR_TOP",
+            "channel": "lidar_top",
             "timestamp_us": 1500000,
-            "file_path": "LIDAR_TOP/frame1.bin",
+            "file_path": "lidar_top/frame1.bin",
             "ego_pose_token": "ep-1",
             "calibrated_sensor_token": "cs-lidar",
             "is_keyframe": True,
@@ -242,9 +242,9 @@ class TestFrameIdHelpers:
         assert loader.annotation_frame_id == "base_link"
 
     def test_sensor_frame_id_returns_channel_frame(self, loader):
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
+        sd = loader.sample_data_for_channel("lidar_top")[0]
         # v0.2 has no per-sensor frame_id, falls back to channel name.
-        assert loader.sensor_frame_id(sd) == "LIDAR_TOP"
+        assert loader.sensor_frame_id(sd) == "lidar_top"
 
     def test_clip_world_constant_is_string_literal(self):
         # The spec pins this name. Any consumer can pass it as a regular frame.
@@ -259,62 +259,62 @@ class TestFrameIdHelpers:
 class TestLoadPointCloudFrames:
     def test_no_frame_returns_raw_sensor(self, loader):
         """Default (no frame=) returns the raw sensor data unchanged."""
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
+        sd = loader.sample_data_for_channel("lidar_top")[0]
         pts = loader.load_point_cloud(sd)
         assert pts.shape == (4, 4)
         np.testing.assert_allclose(pts[0, :3], [1.0, 0.0, 0.0], atol=1e-6)
 
     def test_frame_equal_to_sensor_frame_is_noop(self, loader):
         """Passing the sensor's own frame_id matches the no-frame default."""
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
+        sd = loader.sample_data_for_channel("lidar_top")[0]
         pts_default = loader.load_point_cloud(sd)
         pts_explicit = loader.load_point_cloud(sd, frame=loader.sensor_frame_id(sd))
         np.testing.assert_array_equal(pts_default, pts_explicit)
 
     def test_frame_equal_to_ego_applies_calibration(self, loader):
-        """frame=ego_pose_frame_id applies sensor-to-ego (z+1 for LIDAR_TOP)."""
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
+        """frame=ego_pose_frame_id applies sensor-to-ego (z+1 for lidar_top)."""
+        sd = loader.sample_data_for_channel("lidar_top")[0]
         pts = loader.load_point_cloud(sd, frame=loader.ego_pose_frame_id)
         np.testing.assert_allclose(pts[0, :3], [1.0, 0.0, 1.0], atol=1e-5)
         np.testing.assert_allclose(pts[2, :3], [0.0, 0.0, 2.0], atol=1e-5)
 
     def test_frame_clip_world_first_ego(self, loader):
         """frame='clip_world' for the first ego pose (at origin) ≡ ego frame."""
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]  # ep-0 at origin
+        sd = loader.sample_data_for_channel("lidar_top")[0]  # ep-0 at origin
         pts_ego = loader.load_point_cloud(sd, frame=loader.ego_pose_frame_id)
         pts_world = loader.load_point_cloud(sd, frame=CLIP_WORLD)
         np.testing.assert_allclose(pts_world[:, :3], pts_ego[:, :3], atol=1e-5)
 
     def test_frame_clip_world_second_ego(self, loader):
         """frame='clip_world' for the second ego pose adds the ego offset."""
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[1]  # ep-1 at x=10
+        sd = loader.sample_data_for_channel("lidar_top")[1]  # ep-1 at x=10
         pts = loader.load_point_cloud(sd, frame=CLIP_WORLD)
         np.testing.assert_allclose(pts[0, :3], [11.0, 0.0, 1.0], atol=1e-5)
 
     def test_intensity_preserved(self, loader):
         """Non-xyz columns are passed through unchanged."""
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
+        sd = loader.sample_data_for_channel("lidar_top")[0]
         pts = loader.load_point_cloud(sd, frame=CLIP_WORLD)
         np.testing.assert_allclose(pts[:, 3], 0.5, atol=1e-6)
 
     def test_magic_string_world_rejected(self, loader):
         """The legacy magic string 'world' must be rejected with a hint."""
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
+        sd = loader.sample_data_for_channel("lidar_top")[0]
         with pytest.raises(ValueError, match=r"clip_world"):
             loader.load_point_cloud(sd, frame="world")
 
     def test_magic_string_ego_rejected(self, loader):
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
+        sd = loader.sample_data_for_channel("lidar_top")[0]
         with pytest.raises(ValueError, match=r"ego_pose_frame_id"):
             loader.load_point_cloud(sd, frame="ego")
 
     def test_magic_string_sensor_rejected(self, loader):
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
+        sd = loader.sample_data_for_channel("lidar_top")[0]
         with pytest.raises(ValueError, match=r"sensor_frame_id"):
             loader.load_point_cloud(sd, frame="sensor")
 
     def test_unknown_frame_id_raises_keyerror(self, loader):
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
+        sd = loader.sample_data_for_channel("lidar_top")[0]
         with pytest.raises(KeyError, match=r"not_a_real_frame"):
             loader.load_point_cloud(sd, frame="not_a_real_frame")
 
@@ -367,9 +367,9 @@ class TestAnnotationsForSampleFrames:
 
     def test_frame_sensor_id_transforms_to_that_sensor(self, loader):
         """Passing a sensor's frame_id transforms annotations into that sensor's frame."""
-        # LIDAR_TOP is at (0,0,1) in ego frame. Annotation at ego (5,3,0) →
-        # LIDAR_TOP frame: subtract z=1 → (5,3,-1).
-        anns = loader.annotations_for_sample("s-0", frame="LIDAR_TOP")
+        # lidar_top is at (0,0,1) in ego frame. Annotation at ego (5,3,0) →
+        # lidar_top frame: subtract z=1 → (5,3,-1).
+        anns = loader.annotations_for_sample("s-0", frame="lidar_top")
         np.testing.assert_allclose(anns[0].translation, [5.0, 3.0, -1.0], atol=1e-5)
 
     def test_magic_string_sensor_rejected(self, loader):
@@ -399,51 +399,51 @@ class TestAnnotationsForSampleFrames:
 
 class TestGetTransform:
     def test_identity_same_frame(self, loader):
-        T = loader.get_transform("LIDAR_TOP", "LIDAR_TOP")
+        T = loader.get_transform("lidar_top", "lidar_top")
         np.testing.assert_allclose(T.as_matrix, np.eye(4), atol=1e-10)
 
     def test_static_sensor_to_ego(self, loader):
         # Static-only: no sd needed.
-        T = loader.get_transform("LIDAR_TOP", loader.ego_pose_frame_id)
+        T = loader.get_transform("lidar_top", loader.ego_pose_frame_id)
         np.testing.assert_allclose(T.translation, [0.0, 0.0, 1.0], atol=1e-10)
 
     def test_static_sensor_to_sensor(self, loader):
-        # LIDAR_TOP at (0,0,1) and CAM_FRONT at (0.5,0,0.8) in ego frame.
+        # lidar_top at (0,0,1) and cam_front at (0.5,0,0.8) in ego frame.
         # T_CAM_from_LIDAR = T_CAM_from_ego @ T_ego_from_LIDAR
         #   = (-0.5, 0, -0.8) ∘ (0, 0, +1) = (-0.5, 0, +0.2)
-        T = loader.get_transform("LIDAR_TOP", "CAM_FRONT")
+        T = loader.get_transform("lidar_top", "cam_front")
         np.testing.assert_allclose(T.translation, [-0.5, 0.0, 0.2], atol=1e-10)
 
     def test_dynamic_sensor_to_clip_world_requires_sd(self, loader):
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[1]  # ego at x=10
-        T = loader.get_transform("LIDAR_TOP", CLIP_WORLD, sd=sd)
+        sd = loader.sample_data_for_channel("lidar_top")[1]  # ego at x=10
+        T = loader.get_transform("lidar_top", CLIP_WORLD, sd=sd)
         # sensor → ego (z+1) → world (x+10)  →  (10, 0, 1)
         np.testing.assert_allclose(T.translation, [10.0, 0.0, 1.0], atol=1e-10)
 
     def test_clip_world_without_sd_raises(self, loader):
         with pytest.raises(ValueError, match=r"clip_world"):
-            loader.get_transform("LIDAR_TOP", CLIP_WORLD)
+            loader.get_transform("lidar_top", CLIP_WORLD)
 
     def test_round_trip_through_clip_world(self, loader):
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[1]
-        T_fwd = loader.get_transform("LIDAR_TOP", CLIP_WORLD, sd=sd)
-        T_rev = loader.get_transform(CLIP_WORLD, "LIDAR_TOP", sd=sd)
+        sd = loader.sample_data_for_channel("lidar_top")[1]
+        T_fwd = loader.get_transform("lidar_top", CLIP_WORLD, sd=sd)
+        T_rev = loader.get_transform(CLIP_WORLD, "lidar_top", sd=sd)
         np.testing.assert_allclose((T_fwd @ T_rev).as_matrix, np.eye(4), atol=1e-10)
 
     def test_magic_string_rejected(self, loader):
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
+        sd = loader.sample_data_for_channel("lidar_top")[0]
         with pytest.raises(ValueError, match=r"clip_world"):
             loader.get_transform("sensor", "world", sd=sd)
 
     def test_unknown_frame_id_raises_keyerror(self, loader):
         with pytest.raises(KeyError, match=r"not_a_real_frame"):
-            loader.get_transform("LIDAR_TOP", "not_a_real_frame")
+            loader.get_transform("lidar_top", "not_a_real_frame")
 
     def test_consistency_with_load_point_cloud(self, loader):
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[1]
+        sd = loader.sample_data_for_channel("lidar_top")[1]
         pts_sensor = loader.load_point_cloud(sd)
         pts_world = loader.load_point_cloud(sd, frame=CLIP_WORLD)
-        T = loader.get_transform("LIDAR_TOP", CLIP_WORLD, sd=sd)
+        T = loader.get_transform("lidar_top", CLIP_WORLD, sd=sd)
         pts_manual = T.apply(pts_sensor[:, :3].astype(np.float64)).astype(np.float32)
         np.testing.assert_allclose(pts_world[:, :3], pts_manual, atol=1e-5)
 
@@ -476,11 +476,11 @@ class TestCoordinateFramesIntegration:
     def test_point_cloud_round_trip(self, nuscenes_loader):
         """sensor → clip_world → sensor recovers original points."""
         sd = next(
-            s for s in nuscenes_loader.sample_data_for_channel("LIDAR_TOP") if s.is_keyframe
+            s for s in nuscenes_loader.sample_data_for_channel("lidar_top") if s.is_keyframe
         )
         pts_sensor = nuscenes_loader.load_point_cloud(sd)
         pts_world = nuscenes_loader.load_point_cloud(sd, frame=CLIP_WORLD)
-        T_back = nuscenes_loader.get_transform(CLIP_WORLD, "LIDAR_TOP", sd=sd)
+        T_back = nuscenes_loader.get_transform(CLIP_WORLD, "lidar_top", sd=sd)
         recovered = T_back.apply(pts_world[:, :3].astype(np.float64)).astype(np.float32)
         np.testing.assert_allclose(recovered, pts_sensor[:, :3], atol=1e-4)
 

{x4d_devkit-0.14.2 → x4d_devkit-0.14.3}/tests/test_loader.py

@@ -53,10 +53,11 @@ class TestClipLoader:
 
     def test_calibrated_sensors(self, clip_dir):
         loader = ClipLoader(clip_dir)
-        assert len(loader.calibrated_sensors) == 7
+        assert len(loader.calibrated_sensors) == 8
         channels = {cs.channel for cs in loader.calibrated_sensors}
-        assert "CAM_FRONT" in channels
-        assert "LIDAR_TOP" in channels
+        assert "base_link" in channels
+        assert "cam_front" in channels
+        assert "lidar_top" in channels
 
     def test_annotations_and_instances(self, clip_dir):
         loader = ClipLoader(clip_dir)
@@ -78,9 +79,9 @@ class TestClipLoader:
 
     def test_sample_data_for_channel(self, clip_dir):
         loader = ClipLoader(clip_dir)
-        cam_data = loader.sample_data_for_channel("CAM_FRONT")
+        cam_data = loader.sample_data_for_channel("cam_front")
         assert len(cam_data) > 0
-        assert all(sd.channel == "CAM_FRONT" for sd in cam_data)
+        assert all(sd.channel == "cam_front" for sd in cam_data)
         timestamps = [sd.timestamp_us for sd in cam_data]
         assert timestamps == sorted(timestamps)
 
@@ -101,7 +102,7 @@ class TestClipLoader:
 
     def test_load_point_cloud(self, clip_dir):
         loader = ClipLoader(clip_dir)
-        lidar_data = loader.sample_data_for_channel("LIDAR_TOP")
+        lidar_data = loader.sample_data_for_channel("lidar_top")
         kf = next(sd for sd in lidar_data if sd.is_keyframe)
         pc = loader.load_point_cloud(kf)
         assert isinstance(pc, np.ndarray)
@@ -111,7 +112,7 @@ class TestClipLoader:
 
     def test_load_image_path(self, clip_dir):
         loader = ClipLoader(clip_dir)
-        cam_data = loader.sample_data_for_channel("CAM_FRONT")
+        cam_data = loader.sample_data_for_channel("cam_front")
         kf = next(sd for sd in cam_data if sd.is_keyframe)
         path = loader.load_image_path(kf)
         assert path.is_file()

{x4d_devkit-0.14.2 → x4d_devkit-0.14.3}/tests/test_nuscenes_converter.py

@@ -160,26 +160,27 @@ class TestNuScenesConverterExtraction:
         assert clip_id == "20180724_n015_scene-0061_000"
         assert meta["clip_id"] == clip_id
         assert meta["vehicle_id"] == "n015"
-        assert "LIDAR_TOP" in meta["sensors"]
-        assert "CAM_FRONT" in meta["sensors"]
-        assert "RADAR_FRONT" not in meta["sensors"]
+        assert "lidar_top" in meta["sensors"]
+        assert "cam_front" in meta["sensors"]
+        assert "radar_front" not in meta["sensors"]
         assert len(meta["sensors"]) == 7  # 6 cam + 1 lidar
-        assert meta["sensors"]["LIDAR_TOP"]["modality"] == "lidar"
-        assert meta["sensors"]["CAM_FRONT"]["modality"] == "camera"
-        assert meta["schema_version"] == "0.1"
+        assert meta["sensors"]["lidar_top"]["modality"] == "lidar"
+        assert meta["sensors"]["cam_front"]["modality"] == "camera"
+        assert meta["schema_version"] == "0.10"
 
     def test_extract_calibrated_sensors(self, converter):
         scene = converter.nusc.scene[0]
         clip_id, _ = converter._extract_metadata(scene)
         cs_records = converter._extract_calibrated_sensors(scene, clip_id)
-        assert len(cs_records) == 7
+        assert len(cs_records) == 8  # base_link root + 6 cameras + 1 lidar
         channels = {r["channel"] for r in cs_records}
-        assert "CAM_FRONT" in channels
-        assert "LIDAR_TOP" in channels
-        assert "RADAR_FRONT" not in channels
+        assert "base_link" in channels
+        assert "cam_front" in channels
+        assert "lidar_top" in channels
+        assert "radar_front" not in channels
         # Check token is deterministic
-        cam_front = next(r for r in cs_records if r["channel"] == "CAM_FRONT")
-        expected_token = generate_token(clip_id, "cs:CAM_FRONT")
+        cam_front = next(r for r in cs_records if r["channel"] == "cam_front")
+        expected_token = generate_token(clip_id, "cs:cam_front")
         assert cam_front["calibrated_sensor_token"] == expected_token
         # Check named fields
         assert "x" in cam_front["translation"]
@@ -281,9 +282,9 @@ class TestNuScenesConverterSamples:
 
         # Check channels — only target channels
         channels = {sd["channel"] for sd in sample_data_records}
-        assert "CAM_FRONT" in channels
-        assert "LIDAR_TOP" in channels
-        assert "RADAR_FRONT" not in channels
+        assert "cam_front" in channels
+        assert "lidar_top" in channels
+        assert "radar_front" not in channels
 
         # Check file_path format
         for sd in sample_data_records:
@@ -303,7 +304,7 @@ class TestNuScenesConverterSamples:
         sample_data_records = converter._extract_sample_data(scene, clip_id, ep_old_to_new)
 
         sd_by_token = {sd["sample_data_token"]: sd for sd in sample_data_records}
-        cam_front_sds = [sd for sd in sample_data_records if sd["channel"] == "CAM_FRONT"]
+        cam_front_sds = [sd for sd in sample_data_records if sd["channel"] == "cam_front"]
         cam_front_sds.sort(key=lambda sd: sd["timestamp_us"])
         # First should have prev=None, last next=None
         assert cam_front_sds[0]["prev"] is None
@@ -354,21 +355,21 @@ class TestNuScenesConverterFullScene:
                 assert len(data) > 0, f"{name} is empty"
 
         # Check sensor data directories
-        assert (clip_dir / "samples" / "LIDAR_TOP").is_dir()
-        assert (clip_dir / "samples" / "CAM_FRONT").is_dir()
-        assert not (clip_dir / "samples" / "RADAR_FRONT").exists()
+        assert (clip_dir / "samples" / "lidar_top").is_dir()
+        assert (clip_dir / "samples" / "cam_front").is_dir()
+        assert not (clip_dir / "samples" / "radar_front").exists()
 
         # Check sensor files exist and are non-empty
-        lidar_files = list((clip_dir / "samples" / "LIDAR_TOP").glob("*.bin"))
+        lidar_files = list((clip_dir / "samples" / "lidar_top").glob("*.bin"))
         assert len(lidar_files) > 0
         assert lidar_files[0].stat().st_size > 0
 
-        cam_files = list((clip_dir / "samples" / "CAM_FRONT").glob("*.jpg"))
+        cam_files = list((clip_dir / "samples" / "cam_front").glob("*.jpg"))
         assert len(cam_files) > 0
 
         # Check sweeps exist
-        assert (clip_dir / "sweeps" / "LIDAR_TOP").is_dir()
-        sweep_files = list((clip_dir / "sweeps" / "LIDAR_TOP").glob("*.bin"))
+        assert (clip_dir / "sweeps" / "lidar_top").is_dir()
+        sweep_files = list((clip_dir / "sweeps" / "lidar_top").glob("*.bin"))
         assert len(sweep_files) > 0
 
     def test_sample_data_files_all_exist(self, converter):

{x4d_devkit-0.14.2 → x4d_devkit-0.14.3}/tests/test_transform_chain.py

@@ -31,14 +31,14 @@ def loader(tmp_path_factory):
 class TestTransformChain:
     def test_ego_from_sensor_lidar(self, loader):
         chain = TransformChain(loader)
-        T = chain.get_ego_from_sensor("LIDAR_TOP")
+        T = chain.get_ego_from_sensor("lidar_top")
         assert isinstance(T, Transform)
-        # LIDAR_TOP has extrinsic offset from base_link, should not be identity
+        # lidar_top has extrinsic offset from base_link, should not be identity
         assert not np.allclose(T.translation, [0, 0, 0], atol=1e-3)
 
     def test_ego_from_sensor_camera(self, loader):
         chain = TransformChain(loader)
-        T = chain.get_ego_from_sensor("CAM_FRONT")
+        T = chain.get_ego_from_sensor("cam_front")
         assert isinstance(T, Transform)
 
     def test_world_from_ego_first_frame_near_identity(self, loader):
@@ -52,7 +52,7 @@ class TestTransformChain:
     def test_world_from_sensor_composition(self, loader):
         """world_from_sensor == world_from_ego @ ego_from_sensor."""
         chain = TransformChain(loader)
-        lidar_data = loader.sample_data_for_channel("LIDAR_TOP")
+        lidar_data = loader.sample_data_for_channel("lidar_top")
         sd = next(s for s in lidar_data if s.is_keyframe)
 
         T_direct = chain.get_world_from_sensor(sd)
@@ -66,7 +66,7 @@ class TestTransformChain:
     def test_point_cloud_round_trip(self, loader):
         """sensor -> world -> sensor round-trip should recover original points."""
         chain = TransformChain(loader)
-        lidar_data = loader.sample_data_for_channel("LIDAR_TOP")
+        lidar_data = loader.sample_data_for_channel("lidar_top")
         sd = next(s for s in lidar_data if s.is_keyframe)
         pc = loader.load_point_cloud(sd)
         xyz = pc[:, :3]
@@ -78,11 +78,11 @@ class TestTransformChain:
     def test_transform_points_to_world_changes_coords(self, loader):
         """Points in world coords should differ from sensor coords."""
         chain = TransformChain(loader)
-        lidar_data = loader.sample_data_for_channel("LIDAR_TOP")
+        lidar_data = loader.sample_data_for_channel("lidar_top")
         sd = next(s for s in lidar_data if s.is_keyframe)
         pc = loader.load_point_cloud(sd)
         xyz = pc[:10, :3]
 
         world_pts = chain.transform_points_to_world(xyz, sd)
-        # Not identical (LIDAR_TOP has extrinsic offset)
+        # Not identical (lidar_top has extrinsic offset)
         assert not np.allclose(world_pts, xyz, atol=1e-3)