"""Tests for inference/adapters.py -- inference backend registry and adapter dispatch.""" import numpy as np import pytest from inference import adapters def test_sam3_adapter_accepts_tracking_modes(): assert adapters.get_adapter("SAM3", tracking="tracking").tracking == "tracking" assert ( adapters.get_adapter("SAM3", tracking="no tracking").tracking == "no tracking" ) def test_metric_adapter_is_registered(): assert adapters._ADAPTERS["DA3NESTED-GIANT-LARGE-1.1"].depth_variant == "metric" def test_relative_adapter_is_registered(): assert adapters._ADAPTERS["DA3-LARGE-1.1"].depth_variant == "relative" @pytest.mark.parametrize("algorithm", ["1", "2", "3", "4", "5"]) def test_selector_algorithm_dispatch_is_registered(algorithm): assert algorithm in adapters._SELECTOR_ALGORITHMS assert callable(adapters._SELECTOR_ALGORITHMS[algorithm]) def test_selector_algorithm_defaults_to_five(monkeypatch): import importlib monkeypatch.delenv("VSI_SELECTOR_ALGORITHM", raising=False) reloaded = importlib.reload(adapters) try: assert reloaded.SELECTOR_ALGORITHM == "5" finally: importlib.reload(adapters) def test_select_video_frame_indices_rejects_unknown_algorithm(monkeypatch, tmp_path): monkeypatch.setattr(adapters, "SELECTOR_ALGORITHM", "99") monkeypatch.setattr(adapters, "SELECTED_FRAMES_CACHE", tmp_path) video = tmp_path / "scene.mp4" video.write_bytes(b"fake video bytes") with pytest.raises(ValueError, match="unknown selector algorithm"): adapters.select_video_frame_indices(str(video)) # Every constant that affects an algorithm's behavior must be part of # _selector_config()'s fingerprint, or a cache built before a constant change gets # silently served as "fresh" after the change -- this bit us twice while tuning # algorithm 3 (GLITCH_THUMBNAIL_WIDTH, then GLITCH_MINIMUM_OWN_KEYPOINTS were both # added to the algorithm without being added to the fingerprint). _ALGORITHM_TUNABLE_CONSTANTS = { "1": [ "REDUNDANCY_SSIM_THRESHOLD", "MINIMUM_ALIGNMENT_MATCHES", "MINIMUM_ALIGNMENT_INLIER_RATIO", "MINIMUM_VALID_OVERLAP_FRACTION", ], "2": [ "BLUR_RELATIVE_MEDIAN_FRACTION", "BLUR_ABSOLUTE_FLOOR", "BLUR_CANONICAL_WIDTH", "DARK_MEAN_THRESHOLD", "BRIGHT_MEAN_THRESHOLD", "LOW_CONTRAST_STD_THRESHOLD", ], "3": [ "BLACK_PIXEL_LUMINANCE_THRESHOLD", "BLACK_FRAME_PIXEL_RATIO_THRESHOLD", "GLITCH_MAX_NEIGHBOR_COVISIBILITY", "GLITCH_THUMBNAIL_WIDTH", "GLITCH_MINIMUM_OWN_KEYPOINTS", "MINIMUM_ALIGNMENT_MATCHES", ], "4": [ "COVISIBILITY_OVERLAP_THRESHOLD", "MINIMUM_ALIGNMENT_MATCHES", "REDUNDANCY_SSIM_THRESHOLD", ], "5": [ "BLUR_RELATIVE_MEDIAN_FRACTION", "BLUR_ABSOLUTE_FLOOR", "BLUR_CANONICAL_WIDTH", "DARK_MEAN_THRESHOLD", "BRIGHT_MEAN_THRESHOLD", "LOW_CONTRAST_STD_THRESHOLD", "COVISIBILITY_OVERLAP_THRESHOLD", "MINIMUM_ALIGNMENT_MATCHES", "REDUNDANCY_SSIM_THRESHOLD", ], } @pytest.mark.parametrize( ("algorithm", "constant_name"), [ (algorithm, name) for algorithm, names in _ALGORITHM_TUNABLE_CONSTANTS.items() for name in names ], ) def test_selector_config_reflects_every_tunable_constant( monkeypatch, algorithm, constant_name ): monkeypatch.setattr(adapters, "SELECTOR_ALGORITHM", algorithm) before = adapters._selector_config() original_value = getattr(adapters, constant_name) monkeypatch.setattr(adapters, constant_name, original_value * 2 + 1) after = adapters._selector_config() assert after != before def test_cache_is_invalidated_when_selector_config_changes(tmp_path, monkeypatch): monkeypatch.setattr(adapters, "SELECTED_FRAMES_CACHE", tmp_path) monkeypatch.setattr(adapters, "SELECTOR_ALGORITHM", "2") video = tmp_path / "scene.mp4" video.write_bytes(b"fake video bytes") adapters._cache_selected_frame_indices(str(video), [1, 2, 3]) assert adapters._load_selected_frame_indices(str(video)) == [1, 2, 3] monkeypatch.setattr( adapters, "BLUR_ABSOLUTE_FLOOR", adapters.BLUR_ABSOLUTE_FLOOR + 5 ) assert adapters._load_selected_frame_indices(str(video)) is None def _write_synthetic_video(path, frames, fps=10): cv2 = pytest.importorskip("cv2") height, width = frames[0].shape[:2] writer = cv2.VideoWriter( str(path), cv2.VideoWriter_fourcc(*"mp4v"), fps, (width, height) ) for frame in frames: writer.write(frame) writer.release() def _textured_frame(shape=(90, 160, 3), seed=0, circles=40): cv2 = pytest.importorskip("cv2") rng = np.random.default_rng(seed) frame = np.zeros(shape, np.uint8) for _ in range(circles): x, y = int(rng.integers(0, shape[1])), int(rng.integers(0, shape[0])) radius = int(rng.integers(3, 8)) color = tuple(int(value) for value in rng.integers(50, 255, 3)) cv2.circle(frame, (x, y), radius, color, -1) return frame def test_algorithm_3_catches_injected_corruption_without_false_positives(tmp_path): cv2 = pytest.importorskip("cv2") if not hasattr(cv2, "VideoWriter"): pytest.skip("real OpenCV video I/O is not installed") base = _textured_frame(seed=0) rng = np.random.default_rng(1) corrupt_frames = {20, 45} frames = [ ( rng.integers(0, 255, base.shape, dtype=np.uint8) if i in corrupt_frames else base ) for i in range(60) ] path = tmp_path / "synthetic_corrupt.mp4" _write_synthetic_video(path, frames) kept = set(adapters._select_indices_algorithm_3(str(path))) discarded = set(range(len(frames))) - kept assert corrupt_frames.issubset(discarded) assert discarded - corrupt_frames == set() def test_algorithm_4_compresses_static_redundancy_at_least_as_well_as_algorithm_1( tmp_path, ): cv2 = pytest.importorskip("cv2") if not hasattr(cv2, "VideoWriter"): pytest.skip("real OpenCV video I/O is not installed") base = _textured_frame(seed=2) rng = np.random.default_rng(3) # A static camera with tiny per-frame sensor noise -- exactly the appearance-level # jitter that fragmented algorithm 1's SSIM-based groups on real static footage. frames = [ np.clip(base.astype(np.int16) + rng.integers(-3, 3, base.shape), 0, 255).astype( np.uint8 ) for _ in range(80) ] path = tmp_path / "static_scene.mp4" _write_synthetic_video(path, frames) kept1 = adapters._select_indices_algorithm_1(str(path)) kept4 = adapters._select_indices_algorithm_4(str(path)) assert len(kept4) <= len(kept1) def test_algorithm_5_output_is_subset_of_algorithm_2_output(tmp_path): cv2 = pytest.importorskip("cv2") if not hasattr(cv2, "VideoWriter"): pytest.skip("real OpenCV video I/O is not installed") base = _textured_frame(seed=4) frames = [base for _ in range(60)] path = tmp_path / "scene.mp4" _write_synthetic_video(path, frames) kept2 = set(adapters._select_indices_algorithm_2(str(path))) kept5 = set(adapters._select_indices_algorithm_5(str(path))) assert kept5.issubset(kept2)