x4d-devkit 0.5.1__tar.gz → 0.7.0__tar.gz

{x4d_devkit-0.5.1/x4d_devkit.egg-info → x4d_devkit-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: x4d-devkit
-Version: 0.5.1
+Version: 0.7.0
 Summary: X-4D dataset format SDK — load, validate, evaluate, and convert autonomous driving datasets
 Author: windzu
 License-Expression: Apache-2.0

{x4d_devkit-0.5.1 → x4d_devkit-0.7.0}/pyproject.toml

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

{x4d_devkit-0.5.1 → x4d_devkit-0.7.0}/tests/test_coordinate_frames.py

@@ -38,11 +38,14 @@ def _make_synthetic_clip(tmp_path: Path) -> Path:
         "sensors": {
             "LIDAR_TOP": {
                 "modality": "lidar",
-                "point_format": {"fields": ["x", "y", "z", "intensity"]}
+                "point_format": {
+                    "fields": ["x", "y", "z", "intensity"],
+                    "types": ["float32"] * 4,
+                    "bytes_per_point": 16,
+                },
             },
             "CAM_FRONT": {
                 "modality": "camera",
-                "point_format": None
             }
         }
     }))

{x4d_devkit-0.5.1 → x4d_devkit-0.7.0}/tests/test_models.py

@@ -9,6 +9,8 @@ from x4d_devkit.core.models import (
     SampleData,
     Annotation,
     Instance,
+    PointFormat,
+    SensorInfo,
 )
 
 
@@ -16,17 +18,21 @@ class TestClipMeta:
     def test_construction(self):
         meta = ClipMeta(
             clip_id="20180724_n015_scene-0061_000",
-            schema_version="0.1",
+            schema_version="0.5",
             session_id="n015-2018-07-24-11-22-45+0800",
             vehicle_id="n015",
             capture_time_utc="2018-07-24T00:00:00Z",
             duration_s=19.5,
             num_keyframes=39,
             num_sweeps=305,
-            sensors={"CAM_FRONT": {"modality": "camera", "resolution": [1600, 900]}},
+            sensors={
+                "CAM_FRONT": SensorInfo(modality="camera", resolution=(1600, 900)),
+            },
         )
         assert meta.clip_id == "20180724_n015_scene-0061_000"
         assert meta.num_keyframes == 39
+        assert meta.sensors["CAM_FRONT"].modality == "camera"
+        assert meta.sensors["CAM_FRONT"].resolution == (1600, 900)
 
     def test_frozen(self):
         meta = ClipMeta(
@@ -153,3 +159,74 @@ class TestInstance:
             first_annotation_token="a1", last_annotation_token="a5",
         )
         assert inst.num_annotations == 5
+
+
+class TestPointFormat:
+    def test_construction_normalises_to_tuples(self):
+        pf = PointFormat(
+            fields=["x", "y", "z", "intensity", "time"],
+            types=["float32"] * 5,
+            bytes_per_point=20,
+        )
+        assert isinstance(pf.fields, tuple)
+        assert isinstance(pf.types, tuple)
+        assert pf.num_fields == 5
+
+    def test_mismatched_lengths_rejected(self):
+        with pytest.raises(ValueError, match="must have equal length"):
+            PointFormat(fields=["x", "y", "z"], types=["float32", "float32"], bytes_per_point=12)
+
+    def test_round_trip_via_dict(self):
+        d = {
+            "fields": ["x", "y", "z", "intensity", "time"],
+            "types": ["float32"] * 5,
+            "bytes_per_point": 20,
+        }
+        pf = PointFormat.from_dict(d)
+        assert pf.to_dict() == d
+
+
+class TestSensorInfo:
+    def test_lidar_with_point_format(self):
+        d = {
+            "modality": "lidar",
+            "point_format": {
+                "fields": ["x", "y", "z", "intensity", "time"],
+                "types": ["float32"] * 5,
+                "bytes_per_point": 20,
+            },
+        }
+        si = SensorInfo.from_dict(d)
+        assert si.modality == "lidar"
+        assert si.point_format is not None
+        assert si.point_format.num_fields == 5
+        assert si.resolution is None
+        assert si.to_dict() == d
+
+    def test_camera_with_resolution(self):
+        d = {"modality": "camera", "resolution": [1600, 900]}
+        si = SensorInfo.from_dict(d)
+        assert si.modality == "camera"
+        assert si.point_format is None
+        assert si.resolution == (1600, 900)
+        assert si.to_dict() == d
+
+    def test_extras_round_trip(self):
+        """Unknown keys (e.g. producer-specific extras) survive a round-trip."""
+        d = {
+            "modality": "lidar",
+            "point_format": {
+                "fields": ["x", "y", "z"],
+                "types": ["float32", "float32", "float32"],
+                "bytes_per_point": 12,
+            },
+            "fused_from": ["lidar_top", "lidar_left"],
+        }
+        si = SensorInfo.from_dict(d)
+        assert si.extras == {"fused_from": ["lidar_top", "lidar_left"]}
+        out = si.to_dict()
+        assert out["fused_from"] == ["lidar_top", "lidar_left"]
+
+    def test_camera_no_point_format_in_dict(self):
+        si = SensorInfo.from_dict({"modality": "camera"})
+        assert si.point_format is None

x4d_devkit-0.7.0/tests/test_v06_api_additions.py

@@ -0,0 +1,162 @@
+"""Unit tests for v0.6.0 API additions.
+
+Covers:
+    - x4d_devkit.__version__
+    - ClipLoader.schema_version property + require_schema_version + constructor kwarg
+    - SchemaVersionMismatch exception
+    - calc_ap / calc_tp public re-exports (and underscore aliases still work)
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+import x4d_devkit
+from x4d_devkit import (
+    ClipLoader,
+    SchemaVersionMismatch,
+    calc_ap,
+    calc_tp,
+)
+from x4d_devkit.eval.matching import MetricData
+
+
+def _write_minimal_clip(clip_dir: Path, schema_version: str) -> None:
+    """Write the minimum JSON files ClipLoader.__init__ needs to succeed."""
+    clip_dir.mkdir(parents=True, exist_ok=True)
+    meta = {
+        "clip_id": "20260504_test_001",
+        "schema_version": schema_version,
+        "session_id": "20260504_test",
+        "vehicle_id": "test",
+        "capture_time_utc": "2026-05-04T00:00:00Z",
+        "duration_s": 0.0,
+        "keyframe_count": 0,
+        "sweep_count": 0,
+        "sensors": [],
+    }
+    (clip_dir / "meta.json").write_text(json.dumps(meta))
+    for empty in (
+        "calibrated_sensor.json",
+        "ego_pose.json",
+        "sample.json",
+        "sample_data.json",
+        "annotation.json",
+        "instance.json",
+    ):
+        (clip_dir / empty).write_text("[]")
+
+
+def test_package_has_version_attribute():
+    """__version__ is a non-empty string matching expected shape."""
+    assert isinstance(x4d_devkit.__version__, str)
+    assert x4d_devkit.__version__  # non-empty
+    # Either a real version (e.g. "0.6.0", "0.6.0.post1") or the editable fallback.
+    assert "." in x4d_devkit.__version__ or x4d_devkit.__version__.startswith("0.0.0")
+
+
+def test_loader_schema_version_property(tmp_path):
+    _write_minimal_clip(tmp_path, "0.5")
+    loader = ClipLoader(tmp_path)
+    assert loader.schema_version == "0.5"
+    assert loader.schema_version == loader.meta.schema_version
+
+
+def test_loader_require_schema_version_match(tmp_path):
+    _write_minimal_clip(tmp_path, "0.5")
+    loader = ClipLoader(tmp_path)
+    loader.require_schema_version("0.5")  # no raise
+
+
+def test_loader_require_schema_version_mismatch(tmp_path):
+    _write_minimal_clip(tmp_path, "0.4")
+    loader = ClipLoader(tmp_path)
+    with pytest.raises(SchemaVersionMismatch) as exc:
+        loader.require_schema_version("0.5")
+    assert exc.value.actual == "0.4"
+    assert exc.value.expected == "0.5"
+    assert "0.4" in str(exc.value) and "0.5" in str(exc.value)
+
+
+def test_loader_require_schema_version_set(tmp_path):
+    _write_minimal_clip(tmp_path, "0.4")
+    loader = ClipLoader(tmp_path)
+    loader.require_schema_version({"0.4", "0.5"})  # no raise
+    with pytest.raises(SchemaVersionMismatch):
+        loader.require_schema_version({"0.5", "0.6"})
+
+
+def test_loader_constructor_strict_check_match(tmp_path):
+    _write_minimal_clip(tmp_path, "0.5")
+    ClipLoader(tmp_path, expected_schema_version="0.5")  # no raise
+
+
+def test_loader_constructor_strict_check_mismatch(tmp_path):
+    _write_minimal_clip(tmp_path, "0.4")
+    with pytest.raises(SchemaVersionMismatch):
+        ClipLoader(tmp_path, expected_schema_version="0.5")
+
+
+def test_loader_constructor_strict_check_set(tmp_path):
+    _write_minimal_clip(tmp_path, "0.5")
+    ClipLoader(tmp_path, expected_schema_version={"0.4", "0.5"})  # no raise
+    _write_minimal_clip(tmp_path, "0.3")
+    with pytest.raises(SchemaVersionMismatch):
+        ClipLoader(tmp_path, expected_schema_version={"0.4", "0.5"})
+
+
+def _md_with_precision(prec: np.ndarray) -> MetricData:
+    """Build a MetricData with just enough fields for calc_ap / calc_tp."""
+    n = len(prec)
+    md = MetricData(
+        recall=np.linspace(0, 1, n),
+        precision=prec,
+        confidence=np.linspace(1, 0, n),
+        trans_err=np.zeros(n),
+        vel_err=np.zeros(n),
+        scale_err=np.zeros(n),
+        orient_err=np.zeros(n),
+        attr_err=np.zeros(n),
+    )
+    return md
+
+
+def test_calc_ap_public_export():
+    """calc_ap is importable from x4d_devkit and x4d_devkit.eval, returns expected value."""
+    from x4d_devkit.eval import calc_ap as eval_calc_ap
+
+    assert eval_calc_ap is calc_ap
+
+    # Constant precision = 1.0 across recall, min_recall=0, min_precision=0 → AP=1.0
+    md = _md_with_precision(np.ones(101))
+    ap = calc_ap(md, min_recall=0.0, min_precision=0.0)
+    assert ap == pytest.approx(1.0)
+
+    # Constant 0 precision → AP=0.0
+    md = _md_with_precision(np.zeros(101))
+    ap = calc_ap(md, min_recall=0.0, min_precision=0.0)
+    assert ap == pytest.approx(0.0)
+
+
+def test_calc_tp_public_export():
+    """calc_tp is importable and returns mean of metric in valid recall range."""
+    from x4d_devkit.eval import calc_tp as eval_calc_tp
+
+    assert eval_calc_tp is calc_tp
+
+    md = _md_with_precision(np.ones(101))
+    md.trans_err[:] = 0.5
+    # min_recall=0 → first_ind=1; max_recall_ind defaults; mean over [1..max] of 0.5 = 0.5
+    tp = calc_tp(md, min_recall=0.0, metric_name="trans_err")
+    assert tp == pytest.approx(0.5)
+
+
+def test_underscore_aliases_still_work():
+    """Old _calc_ap / _calc_tp names remain importable (deprecated alias)."""
+    from x4d_devkit.eval.detection import _calc_ap, _calc_tp
+
+    assert _calc_ap is calc_ap
+    assert _calc_tp is calc_tp

{x4d_devkit-0.5.1 → x4d_devkit-0.7.0}/x4d_devkit/__init__.py

@@ -1,5 +1,12 @@
 """X-4D dataset format SDK."""
 
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+try:
+    __version__ = _pkg_version("x4d-devkit")
+except PackageNotFoundError:  # source checkout without installed metadata
+    __version__ = "0.0.0+unknown"
+
 from x4d_devkit.client import X4DClient
 from x4d_devkit.core import (
     Annotation,
@@ -8,8 +15,11 @@ from x4d_devkit.core import (
     ClipMeta,
     EgoPose,
     Instance,
+    PointFormat,
     Sample,
     SampleData,
+    SchemaVersionMismatch,
+    SensorInfo,
     Transform,
     TransformChain,
     generate_token,
@@ -18,12 +28,15 @@ from x4d_devkit.eval import (
     DetectionConfig,
     DetectionEval,
     DetectionResult,
+    calc_ap,
+    calc_tp,
     nusc_detection_config,
 )
 from x4d_devkit.validation import validate_clip, ValidationReport
 from x4d_devkit.fusion import LIDAR_FUSED_DTYPE, FusionSource, fuse_pointclouds  # noqa: E402,F401
 
 __all__ = [
+    "__version__",
     "Annotation",
     "CalibratedSensor",
     "LIDAR_FUSED_DTYPE",
@@ -36,12 +49,17 @@ __all__ = [
     "DetectionResult",
     "EgoPose",
     "Instance",
+    "PointFormat",
     "Sample",
     "SampleData",
+    "SchemaVersionMismatch",
+    "SensorInfo",
     "Transform",
     "TransformChain",
     "ValidationReport",
     "X4DClient",
+    "calc_ap",
+    "calc_tp",
     "generate_token",
     "nusc_detection_config",
     "validate_clip",

{x4d_devkit-0.5.1 → x4d_devkit-0.7.0}/x4d_devkit/core/__init__.py

@@ -1,14 +1,16 @@
 """Core layer: data models, clip loader, transforms."""
 
-from x4d_devkit.core.loader import ClipLoader
+from x4d_devkit.core.loader import ClipLoader, SchemaVersionMismatch
 from x4d_devkit.core.models import (
     Annotation,
     CalibratedSensor,
     ClipMeta,
     EgoPose,
     Instance,
+    PointFormat,
     Sample,
     SampleData,
+    SensorInfo,
 )
 from x4d_devkit.core.token import generate_token
 from x4d_devkit.core.transform import Transform, TransformChain
@@ -20,8 +22,11 @@ __all__ = [
     "ClipMeta",
     "EgoPose",
     "Instance",
+    "PointFormat",
     "Sample",
     "SampleData",
+    "SchemaVersionMismatch",
+    "SensorInfo",
     "Transform",
     "TransformChain",
     "generate_token",

{x4d_devkit-0.5.1 → x4d_devkit-0.7.0}/x4d_devkit/core/loader.py

@@ -17,6 +17,7 @@ from x4d_devkit.core.models import (
     SampleData,
     Annotation,
     Instance,
+    SensorInfo,
 )
 from x4d_devkit.core.transform import Transform, TransformChain, rotation_matrix_to_quat
 
@@ -24,6 +25,24 @@ FrameType = Literal["sensor", "ego", "world"]
 _VALID_FRAMES = {"sensor", "ego", "world"}
 
 
+class SchemaVersionMismatch(ValueError):
+    """Raised when a clip's ``meta.schema_version`` doesn't match the consumer's expectations.
+
+    Attributes:
+        actual: the version found in ``meta.json``.
+        expected: the version (or set of versions) the consumer required.
+    """
+
+    def __init__(self, actual: str, expected: "str | set[str]") -> None:
+        self.actual = actual
+        self.expected = expected
+        if isinstance(expected, str):
+            msg = f"clip schema_version is {actual!r}, expected {expected!r}"
+        else:
+            msg = f"clip schema_version is {actual!r}, expected one of {sorted(expected)!r}"
+        super().__init__(msg)
+
+
 class ClipLoader:
     """Load and index an X4D clip directory.
 
@@ -49,11 +68,18 @@ class ClipLoader:
         anns = loader.annotations_for_sample(sample.token, frame="ego")
     """
 
-    def __init__(self, clip_dir: str | Path) -> None:
+    def __init__(
+        self,
+        clip_dir: str | Path,
+        *,
+        expected_schema_version: "str | set[str] | None" = None,
+    ) -> None:
         self._clip_dir = Path(clip_dir)
 
         # Load and parse all JSON
         self._meta = self._load_meta()
+        if expected_schema_version is not None:
+            self.require_schema_version(expected_schema_version)
         self._calibrated_sensors = self._load_calibrated_sensors()
         self._ego_poses = self._load_ego_poses()
         self._samples = self._load_samples()
@@ -97,6 +123,10 @@ class ClipLoader:
 
     def _load_meta(self) -> ClipMeta:
         d = self._read_json("meta.json")
+        sensors = {
+            channel: SensorInfo.from_dict(raw)
+            for channel, raw in (d.get("sensors") or {}).items()
+        }
         return ClipMeta(
             clip_id=d["clip_id"],
             schema_version=d["schema_version"],
@@ -106,7 +136,7 @@ class ClipLoader:
             duration_s=d["duration_s"],
             num_keyframes=d["keyframe_count"],
             num_sweeps=d["sweep_count"],
-            sensors=d["sensors"],
+            sensors=sensors,
         )
 
     def _load_calibrated_sensors(self) -> list[CalibratedSensor]:
@@ -228,6 +258,31 @@ class ClipLoader:
         """Clip metadata (from meta.json)."""
         return self._meta
 
+    @property
+    def schema_version(self) -> str:
+        """Shortcut for ``self.meta.schema_version`` — the X-4D format version this clip was written in."""
+        return self._meta.schema_version
+
+    def require_schema_version(self, expected: "str | set[str]") -> None:
+        """Raise ``SchemaVersionMismatch`` if the clip's schema_version isn't in ``expected``.
+
+        Args:
+            expected: a single version string (e.g. ``"0.5"``) or a set of accepted
+                versions (e.g. ``{"0.4", "0.5"}``).
+
+        Example::
+
+            loader = ClipLoader(path)
+            loader.require_schema_version("0.5")  # raises if not 0.5
+        """
+        actual = self._meta.schema_version
+        if isinstance(expected, str):
+            if actual != expected:
+                raise SchemaVersionMismatch(actual, expected)
+        else:
+            if actual not in expected:
+                raise SchemaVersionMismatch(actual, set(expected))
+
     @property
     def samples(self) -> list[Sample]:
         """All samples, sorted by timestamp."""
@@ -350,8 +405,12 @@ class ClipLoader:
             raise ValueError(f"Invalid frame '{frame}', must be one of {_VALID_FRAMES}")
 
         sensor_info = self._meta.sensors[sd.channel]
-        pf = sensor_info["point_format"]
-        num_fields = len(pf["fields"])
+        if sensor_info.point_format is None:
+            raise ValueError(
+                f"channel '{sd.channel}' has no point_format in meta.json — "
+                f"cannot load as a point cloud (modality={sensor_info.modality})"
+            )
+        num_fields = sensor_info.point_format.num_fields
 
         path = self._clip_dir / sd.file_path
         raw = np.fromfile(str(path), dtype=np.float32)

{x4d_devkit-0.5.1 → x4d_devkit-0.7.0}/x4d_devkit/core/models.py

@@ -12,28 +12,119 @@ Coordinate conventions:
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 
 import numpy as np
 
 
+@dataclass(frozen=True)
+class PointFormat:
+    """Binary layout of a LiDAR point cloud .bin file.
+
+    Each point is laid out as ``len(fields)`` consecutive scalars of the
+    matching numpy dtype (``types[i]`` for ``fields[i]``). ``bytes_per_point``
+    is the on-disk stride in bytes.
+
+    Attributes:
+        fields: Per-component field names, e.g. ``["x", "y", "z", "intensity", "time"]``.
+        types: Per-component numpy dtype names, e.g. ``["float32", ...]``.
+        bytes_per_point: Total bytes per point on disk (== sum of dtype sizes).
+    """
+
+    fields: tuple[str, ...]
+    types: tuple[str, ...]
+    bytes_per_point: int
+
+    def __post_init__(self) -> None:
+        # Normalise sequences → immutable tuples for free hashability.
+        object.__setattr__(self, "fields", tuple(self.fields))
+        object.__setattr__(self, "types", tuple(self.types))
+        if len(self.fields) != len(self.types):
+            raise ValueError(
+                f"PointFormat: fields ({len(self.fields)}) and types "
+                f"({len(self.types)}) must have equal length"
+            )
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> PointFormat:
+        return cls(
+            fields=tuple(d["fields"]),
+            types=tuple(d["types"]),
+            bytes_per_point=int(d["bytes_per_point"]),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "fields": list(self.fields),
+            "types": list(self.types),
+            "bytes_per_point": self.bytes_per_point,
+        }
+
+    @property
+    def num_fields(self) -> int:
+        return len(self.fields)
+
+
+@dataclass(frozen=True)
+class SensorInfo:
+    """Per-channel sensor metadata embedded in ``meta.json``.
+
+    Attributes:
+        modality: ``"lidar"`` or ``"camera"``.
+        point_format: Binary point layout (LiDAR only; ``None`` for cameras).
+        resolution: ``(width, height)`` in pixels (cameras only; ``None`` for LiDAR).
+        extras: Any additional fields the producer wrote into the sensor dict.
+            Preserved verbatim so ``to_dict()`` round-trips unknown keys.
+    """
+
+    modality: str
+    point_format: PointFormat | None = None
+    resolution: tuple[int, int] | None = None
+    extras: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> SensorInfo:
+        modality = d["modality"]
+        pf_raw = d.get("point_format")
+        point_format = PointFormat.from_dict(pf_raw) if pf_raw is not None else None
+        res_raw = d.get("resolution")
+        resolution = (int(res_raw[0]), int(res_raw[1])) if res_raw is not None else None
+        known = {"modality", "point_format", "resolution"}
+        extras = {k: v for k, v in d.items() if k not in known}
+        return cls(
+            modality=modality,
+            point_format=point_format,
+            resolution=resolution,
+            extras=extras,
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        out: dict[str, Any] = {"modality": self.modality}
+        if self.point_format is not None:
+            out["point_format"] = self.point_format.to_dict()
+        if self.resolution is not None:
+            out["resolution"] = list(self.resolution)
+        out.update(self.extras)
+        return out
+
+
 @dataclass(frozen=True)
 class ClipMeta:
     """Metadata for an X4D clip (from meta.json).
 
     Attributes:
         clip_id: Unique clip identifier (e.g. "20180724_n015_scene-0061_000").
-        schema_version: X4D format version (e.g. "0.2").
+        schema_version: X4D format version (e.g. "0.5").
         session_id: Recording session identifier.
         vehicle_id: Vehicle identifier.
         capture_time_utc: Capture timestamp in ISO 8601 format.
         duration_s: Clip duration in seconds.
         num_keyframes: Number of keyframes (annotated frames).
         num_sweeps: Number of sweep frames (non-annotated intermediate frames).
-        sensors: Sensor metadata dict, keyed by channel name. Each value
-            contains ``modality`` ("lidar"/"camera") and ``point_format``
-            (for LiDAR channels, describes binary file field layout).
+        sensors: Per-channel sensor metadata, keyed by channel name. Each
+            value is a ``SensorInfo`` carrying modality + (for LiDAR) the
+            binary ``PointFormat`` describing the .bin file layout.
     """
 
     clip_id: str
@@ -44,7 +135,7 @@ class ClipMeta:
     duration_s: float
     num_keyframes: int
     num_sweeps: int
-    sensors: dict[str, dict[str, Any]]
+    sensors: dict[str, SensorInfo]
 
 
 @dataclass(frozen=True)

{x4d_devkit-0.5.1 → x4d_devkit-0.7.0}/x4d_devkit/eval/__init__.py

@@ -4,6 +4,8 @@ from x4d_devkit.eval.detection import (
     DetectionConfig,
     DetectionEval,
     DetectionResult,
+    calc_ap,
+    calc_tp,
     detzero_detection_config,
     nusc_detection_config,
 )
@@ -12,6 +14,8 @@ __all__ = [
     "DetectionConfig",
     "DetectionEval",
     "DetectionResult",
+    "calc_ap",
+    "calc_tp",
     "detzero_detection_config",
     "nusc_detection_config",
 ]

{x4d_devkit-0.5.1 → x4d_devkit-0.7.0}/x4d_devkit/eval/detection.py

@@ -197,7 +197,7 @@ class DetectionResult:
     tp_scores: dict[str, float]
 
 
-def _calc_ap(md: MetricData, min_recall: float, min_precision: float) -> float:
+def calc_ap(md: MetricData, min_recall: float, min_precision: float) -> float:
     """Calculate Average Precision from MetricData."""
     prec = np.copy(md.precision)
     prec = prec[round(100 * min_recall) + 1:]
@@ -208,7 +208,7 @@ def _calc_ap(md: MetricData, min_recall: float, min_precision: float) -> float:
     return float(np.mean(prec) / (1.0 - min_precision))
 
 
-def _calc_tp(md: MetricData, min_recall: float, metric_name: str) -> float:
+def calc_tp(md: MetricData, min_recall: float, metric_name: str) -> float:
     """Calculate mean TP metric between min_recall and max_recall."""
     first_ind = round(100 * min_recall) + 1
     last_ind = md.max_recall_ind
@@ -218,6 +218,11 @@ def _calc_tp(md: MetricData, min_recall: float, metric_name: str) -> float:
     return float(np.nanmean(metric_arr[first_ind:last_ind + 1]))
 
 
+# Deprecated aliases — removed in 0.7.0. Use calc_ap / calc_tp.
+_calc_ap = calc_ap
+_calc_tp = calc_tp
+
+
 def _extract_boxes(
     clip: ClipLoader,
     config: DetectionConfig,
@@ -339,7 +344,7 @@ class DetectionEval:
             label_aps[class_name] = {}
             for dist_th in cfg.dist_thresholds:
                 md = metric_data[class_name][str(dist_th)]
-                label_aps[class_name][str(dist_th)] = _calc_ap(md, cfg.min_recall, cfg.min_precision)
+                label_aps[class_name][str(dist_th)] = calc_ap(md, cfg.min_recall, cfg.min_precision)
 
         mean_dist_aps = {
             cn: float(np.mean(list(label_aps[cn].values())))
@@ -360,7 +365,7 @@ class DetectionEval:
                 elif class_name == "barrier" and metric_name in ("attr_err", "vel_err"):
                     label_tp_errors[class_name][metric_name] = float("nan")
                 else:
-                    label_tp_errors[class_name][metric_name] = _calc_tp(md, cfg.min_recall, metric_name)
+                    label_tp_errors[class_name][metric_name] = calc_tp(md, cfg.min_recall, metric_name)
 
         tp_errors = {}
         for metric_name in TP_METRICS:

{x4d_devkit-0.5.1 → x4d_devkit-0.7.0/x4d_devkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: x4d-devkit
-Version: 0.5.1
+Version: 0.7.0
 Summary: X-4D dataset format SDK — load, validate, evaluate, and convert autonomous driving datasets
 Author: windzu
 License-Expression: Apache-2.0

{x4d_devkit-0.5.1 → x4d_devkit-0.7.0}/x4d_devkit.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ tests/test_nuscenes_converter.py
 tests/test_token.py
 tests/test_transform.py
 tests/test_transform_chain.py
+tests/test_v06_api_additions.py
 tests/test_validation.py
 x4d_devkit/__init__.py
 x4d_devkit/cli.py