File size: 7,868 Bytes
db613b6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 | """Release gates reject corrupt targets and source references before packaging."""
from __future__ import annotations
import shutil
import pyarrow.parquet as pq
import pytest
from kitti_c2l import release
from kitti_c2l.generate import generate_sequence_rows
from kitti_c2l.sequence_mapping import SequenceInfo
from kitti_c2l.windows import generate_sequence_windows
from kitti_c2l.writer import rows_to_table, windows_to_table
@pytest.fixture
def small_release_table(fake_kitti_root, tmp_path, monkeypatch):
info = SequenceInfo("04", "2011_09_30", "0016", 0, 3, 4, "train")
monkeypatch.setattr(release, "load_sequence_mapping", lambda: {"04": info})
rows = list(generate_sequence_rows(info, fake_kitti_root))
path = tmp_path / "train.parquet"
pq.write_table(rows_to_table(rows), path)
return path, rows, info, fake_kitti_root
def test_release_table_checks_source_calibration(small_release_table):
path, rows, _, raw_root = small_release_table
result = release.validate_table(path, kitti_calib_root=raw_root)
assert result["rows"] == len(rows) == 20
assert result["sha256"] == release.sha256(path)
@pytest.mark.parametrize(
"field,value,reason",
[
("sample_seed", 1, "seed"),
("raw_frame_index", 99, "raw mapping"),
("sample_id", "bad_id", "invalid ID"),
("delta_cam_tx_cm", 999.0, "seeded perturbation"),
("miscal_t_cam_from_velo_cm", [999.0, 0.0, 0.0], "translation/units"),
("gt_R_cam_from_velo", [float("nan")] * 9, "non-finite"),
("miscal_R_cam_from_velo", [-1, 0, 0, 0, 1, 0, 0, 0, 1], "reflected"),
("stage", None, "null values"),
],
)
def test_release_rejects_corrupt_rows(small_release_table, field, value, reason):
path, rows, _, _ = small_release_table
rows[0] = rows[0]._replace(**{field: value})
pq.write_table(rows_to_table(rows), path)
with pytest.raises(release.ReleaseValidationError, match=reason):
release.validate_table(path)
@pytest.mark.parametrize("duplicate", [False, True])
def test_release_rejects_missing_or_duplicate_stages(small_release_table, duplicate):
path, rows, _, _ = small_release_table
rows = rows + [rows[0]] if duplicate else rows[:-1]
pq.write_table(rows_to_table(rows), path)
with pytest.raises(release.ReleaseValidationError, match="duplicate|coverage"):
release.validate_table(path)
def test_release_checks_short_final_window(small_release_table):
path, _, info, raw_root = small_release_table
path = path.with_name("windows_train.parquet")
rows = list(generate_sequence_windows(info, raw_root))
pq.write_table(windows_to_table(rows), path)
assert release.validate_table(path)["rows"] == 5
rows[0] = rows[0]._replace(window_length=30)
pq.write_table(windows_to_table(rows), path)
with pytest.raises(release.ReleaseValidationError, match="window coverage"):
release.validate_table(path)
def test_release_rejects_materialized_sensor_assets(tmp_path):
data = tmp_path / "data"
data.mkdir()
for name in (*release.DATA_FILES, "frames_train-00000-of-00001.parquet"):
(data / name).touch()
with pytest.raises(release.ReleaseValidationError, match="sensor assets are excluded"):
release.validate_release(tmp_path)
def test_staging_uses_allowlist_and_refuses_overwrite(tmp_path, monkeypatch):
import scripts.prepare_release as preparation
root = tmp_path / "source"
root.mkdir()
for relative in preparation.RELEASE_FILES:
destination = root / relative
destination.parent.mkdir(parents=True, exist_ok=True)
destination.write_bytes(b"fixture")
(root / "private-notes.txt").write_text("not for release")
monkeypatch.setattr(preparation, "validate_release", lambda *args, **kwargs: {})
output = tmp_path / "public"
archive = preparation.prepare(root, output)
assert archive.exists()
assert {str(p.relative_to(output)) for p in output.rglob("*") if p.is_file()} == set(
preparation.RELEASE_FILES
) | {"SHA256SUMS"}
with pytest.raises(FileExistsError):
preparation.prepare(root, output)
# Identical inputs produce an identical archive despite a different source path/mtime.
other_root = tmp_path / "other-source"
shutil.copytree(root, other_root)
other_output = tmp_path / "again" / "public"
other_archive = preparation.prepare(other_root, other_output)
assert release.sha256(archive) == release.sha256(other_archive)
@pytest.fixture
def recorded_hub_release(tmp_path):
import json
from pathlib import Path
source = Path(__file__).resolve().parents[1] / "release/v1"
destination = tmp_path / "release/v1"
destination.mkdir(parents=True)
for name in [
"hub_manifest.json",
"manifest.json",
"HF_DATASET_CARD.md",
"hub_payload_verification.json",
]:
shutil.copyfile(source / name, destination / name)
return tmp_path, json.loads((destination / "hub_manifest.json").read_text())
def test_recorded_full_hub_inventory(recorded_hub_release):
root, _ = recorded_hub_release
result = release.validate_hub_manifest(root)
assert len(result["shards"]) == 50
assert result["total_frames"] == 22400
@pytest.mark.parametrize(
"problem",
["missing_shard", "duplicate_shard", "wrong_frame_count", "changed_metadata", "empty_shard"],
)
def test_full_hub_inventory_rejects_invalid_snapshot(recorded_hub_release, problem):
import json
root, report = recorded_hub_release
if problem == "missing_shard":
report["shards"].pop()
elif problem == "duplicate_shard":
report["shards"][-1] = report["shards"][0]
elif problem == "wrong_frame_count":
report["shards"][0]["rows"] += 1
elif problem == "changed_metadata":
report["metadata_files"][0]["sha256"] = "0" * 64
else:
report["shards"][0]["bytes"] = 0
(root / "release/v1/hub_manifest.json").write_text(json.dumps(report))
with pytest.raises(release.ReleaseValidationError):
release.validate_hub_manifest(root)
def test_full_card_cannot_drop_existing_frames_configuration(recorded_hub_release):
import yaml
root, _ = recorded_hub_release
path = root / "release/v1/HF_DATASET_CARD.md"
_, header, body = path.read_text().split("---", 2)
metadata = yaml.safe_load(header)
metadata["configs"] = [
config for config in metadata["configs"] if config["config_name"] != "frames"
]
path.write_text("---\n" + yaml.safe_dump(metadata) + "---" + body)
with pytest.raises(release.ReleaseValidationError, match="all three configs"):
release.validate_hub_manifest(root)
def test_full_update_keeps_existing_payloads_and_uses_production_card(tmp_path, monkeypatch):
import json
import scripts.prepare_release as preparation
root = tmp_path / "source"
root.mkdir()
for relative in preparation.RELEASE_FILES:
target = root / relative
target.parent.mkdir(parents=True, exist_ok=True)
target.write_text("fixture")
card = root / "release/v1/HF_DATASET_CARD.md"
card.write_text("production card retaining frames")
monkeypatch.setattr(preparation, "validate_release", lambda *args, **kwargs: {})
monkeypatch.setattr(
preparation,
"validate_hub_manifest",
lambda *args: {"repo_id": "owner/dataset", "revision": "a" * 40},
)
output = tmp_path / "full-update"
preparation.prepare(root, output, profile="full-update")
assert (output / "README.md").read_text() == card.read_text()
profile = json.loads((output / "release-profile.json").read_text())
assert profile["requires_existing_frame_shards"] is True
assert profile["delete_remote_files"] is False
assert not list((output / "data").glob("frames_*.parquet"))
|