| """Exercise the real HF loader and embedded media, without a Hub upload.""" |
| import unittest |
| import json |
| import subprocess |
| import tempfile |
| from pathlib import Path |
|
|
| import yaml |
| from datasets import Image, Video, load_dataset |
| from PIL import Image as PILImage |
|
|
|
|
| ROOT = Path(__file__).resolve().parents[1] |
|
|
|
|
| class ReleaseTest(unittest.TestCase): |
| @classmethod |
| def setUpClass(cls): |
| cls.cache = tempfile.TemporaryDirectory(prefix="sprite-release-test-") |
| cls.addClassCleanup(cls.cache.cleanup) |
|
|
| def test_playable_video_preserves_selected_source_timing(self): |
| for name in ("loops", "scene_boundaries"): |
| with self.subTest(config=name): |
| ds = load_dataset(str(ROOT), name, split="train", cache_dir=self.cache.name).cast_column("video", Video(decode=False)) |
| row = ds[0] |
| folder = "shots" if name == "loops" else "animations" |
| with PILImage.open(ROOT / "data" / folder / (row["id"] + ".webp")) as image: |
| start = row.get("start_frame", 0) |
| end = row.get("end_frame_exclusive", image.n_frames) |
| milliseconds = 0 |
| for index in range(start, end): |
| image.seek(index) |
| image.load() |
| milliseconds += image.info["duration"] |
| video = row["video"]["bytes"] |
| probe = subprocess.run( |
| ["ffprobe", "-v", "error", "-show_entries", "stream=codec_name,width,height,duration", |
| "-of", "json", "-i", "pipe:0"], input=video, capture_output=True, check=True, |
| ) |
| stream = json.loads(probe.stdout)["streams"][0] |
| self.assertEqual(stream["codec_name"], "h264") |
| self.assertLessEqual(max(stream["width"], stream["height"]), 320) |
| self.assertAlmostEqual(float(stream["duration"]), milliseconds / 1000, places=3) |
| subprocess.run( |
| ["ffmpeg", "-v", "error", "-xerror", "-i", "pipe:0", "-f", "null", "-"], |
| input=video, capture_output=True, check=True, |
| ) |
|
|
| def test_viewer_configs_load_with_images(self): |
| metadata = yaml.safe_load((ROOT / "README.md").read_text().split("---")[1]) |
| configs = metadata.get("configs", []) |
| self.assertEqual( |
| {c["config_name"] for c in configs}, |
| {"matting", "loops", "scene_boundaries"}, |
| ) |
| expected = {"matting": 1080, "loops": 248, "scene_boundaries": 257} |
| for config in configs: |
| name = config["config_name"] |
| with self.subTest(config=name): |
| |
| |
| ds = load_dataset(str(ROOT), name, split="train", cache_dir=self.cache.name) |
| self.assertEqual(len(ds), expected[name]) |
| if name != "matting": |
| self.assertIsInstance(ds.features.get("video"), Video) |
| ds = ds.cast_column("video", Video(decode=False)) |
| image_columns = [k for k, v in ds.features.items() if isinstance(v, Image)] |
| self.assertTrue(image_columns) |
| ids = set() |
| for row in ds: |
| self.assertNotIn(row["id"], ids) |
| ids.add(row["id"]) |
| if name != "matting": |
| self.assertEqual(row["video"]["bytes"][4:8], b"ftyp") |
| for key in image_columns: |
| row[key].load() |
| self.assertGreater(row[key].width, 0) |
| if name == "matting": |
| self.assertEqual(row["cutout"].mode, "RGBA") |
| self.assertEqual(row["image"].size, row["matte"].size) |
| elif name == "loops": |
| self.assertLess(row["start_frame"], row["end_frame_exclusive"]) |
| self.assertLessEqual(row["end_frame_exclusive"], row["num_frames"]) |
| stream = load_dataset(str(ROOT), name, split="train", streaming=True, cache_dir=self.cache.name) |
| if name != "matting": |
| stream = stream.cast_column("video", Video(decode=False)) |
| streamed = next(iter(stream)) |
| self.assertEqual(streamed["id"], ds[0]["id"]) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
