feat(video): add intake quality gate

README.md

@@ -91,6 +91,23 @@ Each analysis run creates a folder under `runs/<run_id>/`:
 mock mode. JSON artifacts are validated before they are written, including required fields, supported
 enum values, score ranges, frame/timestamp ordering, and final report shape.
 
+`video_manifest.json` is produced from OpenCV metadata and sampled-frame quality checks. It includes
+FPS, duration, frame count, sampled frame count, resolution, codec/container when available,
+brightness, blur score, warning labels, and `analysis_allowed`.
+
+Video quality warning labels:
+
+- `too_short`
+- `too_long`
+- `too_dark`
+- `too_blurry`
+- `fps_too_low`
+- `resolution_too_low`
+- `video_decode_failed`
+
+Decode failures set `analysis_allowed=false`; the Gradio UI surfaces capture guidance instead of
+coach-style feedback when analysis is blocked.
+
 `annotated_video.mp4` is not implemented yet. The mocked renderer currently returns the original input video path and writes `annotated_video_placeholder.json`.
 
 ## Replacing Mock Steps

app.py

@@ -12,10 +12,40 @@ sys.path.insert(0, str(Path(__file__).parent / "src"))
 from pozify.pipeline import run_pipeline
 
 
+QUALITY_GUIDANCE = {
+    "too_short": "Record at least 10 seconds so the set contains enough movement context.",
+    "too_long": "Keep the clip under 60 seconds for the MVP analyzer.",
+    "too_dark": "Use brighter, even lighting and keep the body visible against the background.",
+    "too_blurry": "Stabilize the camera and avoid fast panning or heavy motion blur.",
+    "fps_too_low": "Use a camera mode with at least 15 FPS.",
+    "resolution_too_low": "Record at 480x360 or higher so joint positions are readable.",
+    "video_decode_failed": "Upload a playable video file; the current file could not be decoded.",
+}
+
+
 def _pretty_json(value: dict[str, Any]) -> str:
     return json.dumps(value, ensure_ascii=False, indent=2)
 
 
+def _quality_markdown(video_manifest: dict[str, Any]) -> str:
+    warnings = video_manifest["quality_warnings"]
+    if not warnings:
+        return "## Video Quality\n\nNo quality warnings detected."
+
+    warning_items = "\n".join(f"- `{warning}`: {QUALITY_GUIDANCE[warning]}" for warning in warnings)
+    status = (
+        "Analysis is blocked until the video can be decoded reliably."
+        if not video_manifest["analysis_allowed"]
+        else "Analysis completed, but capture quality may affect downstream feedback."
+    )
+    return f"""## Video Quality
+
+{status}
+
+{warning_items}
+"""
+
+
 def analyze_video(
     video_path: str | None,
     goal: str,
@@ -38,7 +68,24 @@ def analyze_video(
     )
 
     report = result["final_report"]
+    video_quality = _quality_markdown(report["video_manifest"])
     summary = report["coach_summary"]
+    if not report["video_manifest"]["analysis_allowed"]:
+        markdown = f"""{video_quality}
+
+## Run
+
+- **Run ID:** `{report["run_id"]}`
+- **Saved report:** `{Path(result["run_dir"]) / "final_report.json"}`
+"""
+        artifact_path = Path(result["run_dir"]) / "final_report.json"
+        return (
+            result["annotated_video_path"],
+            markdown,
+            _pretty_json(report),
+            str(artifact_path),
+        )
+
     markdown = f"""## Scan Summary
 
 - **Exercise:** {report["exercise"]["exercise"]} ({report["exercise"]["confidence"]:.0%} confidence)
@@ -59,6 +106,8 @@ def analyze_video(
 
 ### Next Session Plan
 {chr(10).join(f"- {item}" for item in summary["next_session_plan"])}
+
+{video_quality}
 """
 
     artifact_path = Path(result["run_dir"]) / "final_report.json"

pyproject.toml

@@ -6,6 +6,8 @@ readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
     "gradio>=4.44.0",
+    "numpy>=1.26.0",
+    "opencv-python-headless>=4.10.0",
 ]
 
 [project.optional-dependencies]

src/pozify/contracts.py

@@ -34,6 +34,12 @@ class VideoManifest:
     duration_sec: float
     total_frames: int
     sampled_frames: int
+    width: int
+    height: int
+    codec: str | None
+    container: str | None
+    brightness_mean: float | None
+    blur_laplacian_var: float | None
     quality_warnings: list[str]
     analysis_allowed: bool
 
@@ -273,6 +279,12 @@ def _validate_video_manifest(value: Any, path: str) -> None:
             "duration_sec",
             "total_frames",
             "sampled_frames",
+            "width",
+            "height",
+            "codec",
+            "container",
+            "brightness_mean",
+            "blur_laplacian_var",
             "quality_warnings",
             "analysis_allowed",
         },
@@ -286,6 +298,16 @@ def _validate_video_manifest(value: Any, path: str) -> None:
     _require_int(payload["sampled_frames"], f"{path}.sampled_frames", minimum=0)
     if payload["sampled_frames"] > payload["total_frames"]:
         raise ContractValidationError(f"{path}.sampled_frames must be <= total_frames")
+    _require_int(payload["width"], f"{path}.width", minimum=0)
+    _require_int(payload["height"], f"{path}.height", minimum=0)
+    if payload["codec"] is not None:
+        _require_type(payload["codec"], str, f"{path}.codec")
+    if payload["container"] is not None:
+        _require_type(payload["container"], str, f"{path}.container")
+    if payload["brightness_mean"] is not None:
+        _require_number(payload["brightness_mean"], f"{path}.brightness_mean", minimum=0)
+    if payload["blur_laplacian_var"] is not None:
+        _require_number(payload["blur_laplacian_var"], f"{path}.blur_laplacian_var", minimum=0)
     _require_string_list(payload["quality_warnings"], f"{path}.quality_warnings")
     _require_bool(payload["analysis_allowed"], f"{path}.analysis_allowed")
 

src/pozify/steps/pose_landmarker.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from pozify.contracts import PoseFrame, PoseSequence, VideoManifest
+from pozify.steps.video_qc import sample_frame_indices
 
 
 LANDMARK_NAMES = [
@@ -38,8 +39,7 @@ def _mock_landmarks(frame_index: int) -> dict[str, dict[str, float]]:
 
 def run(manifest: VideoManifest) -> PoseSequence:
     frames: list[PoseFrame] = []
-    step = max(1, int(manifest.total_frames / 12))
-    for frame_index in range(0, manifest.total_frames, step):
+    for frame_index in sample_frame_indices(manifest.total_frames):
         frames.append(
             PoseFrame(
                 frame_index=frame_index,
@@ -60,4 +60,3 @@ def run(manifest: VideoManifest) -> PoseSequence:
         smoothing_method="none",
         pose_valid_ratio=1.0,
     )
-

src/pozify/steps/video_qc.py

@@ -1,24 +1,156 @@
 from __future__ import annotations
 
 from pathlib import Path
+from typing import Iterator
+
+import cv2
 
 from pozify.contracts import VideoManifest
 
 
-def run(video_path: str | None) -> VideoManifest:
-    warnings: list[str] = []
+MIN_DURATION_SEC = 10.0
+MAX_DURATION_SEC = 60.0
+MIN_FPS = 15.0
+MIN_WIDTH = 480
+MIN_HEIGHT = 360
+MIN_BRIGHTNESS = 45.0
+MIN_BLUR_LAPLACIAN_VAR = 50.0
+DEFAULT_SAMPLE_COUNT = 12
+
+HARD_FAILURE_WARNINGS = {"video_decode_failed"}
+
+
+def _decode_fourcc(value: float) -> str | None:
+    code = int(value)
+    if code <= 0:
+        return None
+    chars = [chr((code >> 8 * index) & 0xFF) for index in range(4)]
+    decoded = "".join(chars).strip()
+    return decoded or None
+
+
+def _container_from_path(video_path: str | None) -> str | None:
     if video_path is None:
-        warnings.append("no_video_uploaded_mock_mode")
-    elif not Path(video_path).exists():
-        warnings.append("video_path_not_found_mock_mode")
+        return None
+    suffix = Path(video_path).suffix.lower().lstrip(".")
+    return suffix or None
+
+
+def sample_frame_indices(total_frames: int, sample_count: int = DEFAULT_SAMPLE_COUNT) -> list[int]:
+    if total_frames <= 0 or sample_count <= 0:
+        return []
+    if total_frames <= sample_count:
+        return list(range(total_frames))
+
+    last_index = total_frames - 1
+    return sorted(
+        {
+            round(index * last_index / (sample_count - 1))
+            for index in range(sample_count)
+        }
+    )
+
+
+def sample_video_frames(
+    video_path: str,
+    sample_count: int = DEFAULT_SAMPLE_COUNT,
+) -> Iterator[tuple[int, object]]:
+    capture = cv2.VideoCapture(video_path)
+    try:
+        if not capture.isOpened():
+            return
+
+        total_frames = int(capture.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
+        for frame_index in sample_frame_indices(total_frames, sample_count):
+            capture.set(cv2.CAP_PROP_POS_FRAMES, frame_index)
+            ok, frame = capture.read()
+            if ok and frame is not None:
+                yield frame_index, frame
+    finally:
+        capture.release()
+
 
+def _empty_manifest(video_path: str | None, warnings: list[str]) -> VideoManifest:
     return VideoManifest(
         video_path=video_path,
-        fps=30.0,
-        duration_sec=12.0,
-        total_frames=360,
-        sampled_frames=180,
+        fps=0.0,
+        duration_sec=0.0,
+        total_frames=0,
+        sampled_frames=0,
+        width=0,
+        height=0,
+        codec=None,
+        container=_container_from_path(video_path),
+        brightness_mean=None,
+        blur_laplacian_var=None,
         quality_warnings=warnings,
-        analysis_allowed=True,
+        analysis_allowed=False,
     )
 
+
+def _brightness_and_blur(frame: object) -> tuple[float, float]:
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    brightness = float(gray.mean())
+    blur = float(cv2.Laplacian(gray, cv2.CV_64F).var())
+    return brightness, blur
+
+
+def run(video_path: str | None) -> VideoManifest:
+    if video_path is None or not Path(video_path).exists():
+        return _empty_manifest(video_path, ["video_decode_failed"])
+
+    capture = cv2.VideoCapture(video_path)
+    try:
+        if not capture.isOpened():
+            return _empty_manifest(video_path, ["video_decode_failed"])
+
+        fps = float(capture.get(cv2.CAP_PROP_FPS) or 0.0)
+        total_frames = int(capture.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
+        width = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH) or 0)
+        height = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT) or 0)
+        codec = _decode_fourcc(capture.get(cv2.CAP_PROP_FOURCC) or 0.0)
+    finally:
+        capture.release()
+
+    if total_frames <= 0 or fps <= 0:
+        return _empty_manifest(video_path, ["video_decode_failed"])
+
+    sampled_metrics = [_brightness_and_blur(frame) for _, frame in sample_video_frames(video_path)]
+    if not sampled_metrics:
+        return _empty_manifest(video_path, ["video_decode_failed"])
+
+    brightness_values = [brightness for brightness, _ in sampled_metrics]
+    blur_values = [blur for _, blur in sampled_metrics]
+    brightness_mean = round(sum(brightness_values) / len(brightness_values), 2)
+    blur_laplacian_var = round(sum(blur_values) / len(blur_values), 2)
+    duration_sec = round(total_frames / fps, 3)
+
+    warnings: list[str] = []
+    if duration_sec < MIN_DURATION_SEC:
+        warnings.append("too_short")
+    if duration_sec > MAX_DURATION_SEC:
+        warnings.append("too_long")
+    if brightness_mean < MIN_BRIGHTNESS:
+        warnings.append("too_dark")
+    if blur_laplacian_var < MIN_BLUR_LAPLACIAN_VAR:
+        warnings.append("too_blurry")
+    if fps < MIN_FPS:
+        warnings.append("fps_too_low")
+    if width < MIN_WIDTH or height < MIN_HEIGHT:
+        warnings.append("resolution_too_low")
+
+    return VideoManifest(
+        video_path=video_path,
+        fps=round(fps, 3),
+        duration_sec=duration_sec,
+        total_frames=total_frames,
+        sampled_frames=len(sampled_metrics),
+        width=width,
+        height=height,
+        codec=codec,
+        container=_container_from_path(video_path),
+        brightness_mean=brightness_mean,
+        blur_laplacian_var=blur_laplacian_var,
+        quality_warnings=warnings,
+        analysis_allowed=not any(warning in HARD_FAILURE_WARNINGS for warning in warnings),
+    )

tests/test_pipeline_contracts.py

@@ -6,6 +6,9 @@ import tempfile
 import unittest
 from pathlib import Path
 
+import cv2
+import numpy as np
+
 sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
 
 from pozify import pipeline
@@ -32,12 +35,18 @@ EXPECTED_ARTIFACT_KEYS = {
     ],
     "video_manifest.json": [
         "analysis_allowed",
+        "blur_laplacian_var",
+        "brightness_mean",
+        "codec",
+        "container",
         "duration_sec",
         "fps",
+        "height",
         "quality_warnings",
         "sampled_frames",
         "total_frames",
         "video_path",
+        "width",
     ],
     "pose_sequence.json": ["frames", "normalized", "pose_valid_ratio", "smoothing_method"],
     "exercise_classification.json": [
@@ -87,6 +96,32 @@ class PipelineContractTests(unittest.TestCase):
         pipeline.RUNS_DIR = self.original_runs_dir
         self.temp_dir.cleanup()
 
+    def _write_video(
+        self,
+        filename: str,
+        *,
+        fps: float = 30.0,
+        duration_sec: float = 10.0,
+        size: tuple[int, int] = (640, 480),
+    ) -> Path:
+        path = Path(self.temp_dir.name) / filename
+        writer = cv2.VideoWriter(
+            str(path),
+            cv2.VideoWriter_fourcc(*"mp4v"),
+            fps,
+            size,
+        )
+        self.assertTrue(writer.isOpened())
+        width, height = size
+        for frame_index in range(int(fps * duration_sec)):
+            frame = np.full((height, width, 3), 130, dtype=np.uint8)
+            offset = frame_index % 120
+            cv2.rectangle(frame, (40 + offset, 80), (260 + offset, 300), (245, 245, 245), -1)
+            cv2.line(frame, (0, frame_index % height), (width - 1, height - 1), (20, 20, 20), 3)
+            writer.write(frame)
+        writer.release()
+        return path
+
     def _assert_pipeline_artifacts(self, result: dict[str, object]) -> None:
         run_dir = Path(str(result["run_dir"]))
         manifest_path = run_dir / "manifest.json"
@@ -124,16 +159,20 @@ class PipelineContractTests(unittest.TestCase):
         self._assert_pipeline_artifacts(result)
         report = result["final_report"]
         self.assertEqual(report["exercise"]["exercise"], "push_up")
-        self.assertEqual(report["video_manifest"]["quality_warnings"], ["no_video_uploaded_mock_mode"])
+        self.assertEqual(report["video_manifest"]["quality_warnings"], ["video_decode_failed"])
+        self.assertFalse(report["video_manifest"]["analysis_allowed"])
 
     def test_pipeline_runs_end_to_end_with_fixture_video_path(self) -> None:
-        fixture = Path(__file__).parent / "fixtures" / "sample.mp4"
+        fixture = self._write_video("sample.mp4")
         result = pipeline.run_pipeline(video_path=str(fixture), profile_input=PROFILE_INPUT, mock=True)
 
         self._assert_pipeline_artifacts(result)
         report = result["final_report"]
         self.assertEqual(report["video_manifest"]["video_path"], str(fixture))
         self.assertEqual(report["video_manifest"]["quality_warnings"], [])
+        self.assertTrue(report["video_manifest"]["analysis_allowed"])
+        self.assertEqual(report["video_manifest"]["width"], 640)
+        self.assertEqual(report["video_manifest"]["height"], 480)
 
     def test_contract_validation_rejects_missing_required_field(self) -> None:
         payload = {

tests/test_video_qc.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+import sys
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from pozify.steps import video_qc
+
+
+class VideoQCTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.temp_dir = tempfile.TemporaryDirectory()
+
+    def tearDown(self) -> None:
+        self.temp_dir.cleanup()
+
+    def _write_video(
+        self,
+        filename: str,
+        *,
+        fps: float = 30.0,
+        duration_sec: float = 10.0,
+        size: tuple[int, int] = (640, 480),
+        mode: str = "valid",
+    ) -> Path:
+        path = Path(self.temp_dir.name) / filename
+        writer = cv2.VideoWriter(
+            str(path),
+            cv2.VideoWriter_fourcc(*"mp4v"),
+            fps,
+            size,
+        )
+        self.assertTrue(writer.isOpened())
+
+        width, height = size
+        for frame_index in range(max(1, int(fps * duration_sec))):
+            if mode == "dark":
+                frame = np.full((height, width, 3), 8, dtype=np.uint8)
+            elif mode == "blurry":
+                frame = np.full((height, width, 3), 150, dtype=np.uint8)
+            else:
+                frame = np.full((height, width, 3), 135, dtype=np.uint8)
+                offset = frame_index % max(1, width // 4)
+                cv2.rectangle(frame, (40 + offset, 80), (220 + offset, 300), (245, 245, 245), -1)
+                cv2.line(frame, (0, frame_index % height), (width - 1, height - 1), (10, 10, 10), 3)
+                cv2.putText(
+                    frame,
+                    str(frame_index),
+                    (30, 420),
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    2.0,
+                    (255, 255, 255),
+                    4,
+                )
+            writer.write(frame)
+
+        writer.release()
+        return path
+
+    def test_valid_video_produces_real_metadata(self) -> None:
+        path = self._write_video("valid.mp4")
+
+        manifest = video_qc.run(str(path))
+
+        self.assertTrue(manifest.analysis_allowed)
+        self.assertEqual(manifest.quality_warnings, [])
+        self.assertEqual(manifest.width, 640)
+        self.assertEqual(manifest.height, 480)
+        self.assertEqual(manifest.total_frames, 300)
+        self.assertAlmostEqual(manifest.fps, 30.0, places=1)
+        self.assertAlmostEqual(manifest.duration_sec, 10.0, places=1)
+        self.assertGreater(manifest.sampled_frames, 0)
+        self.assertEqual(manifest.container, "mp4")
+        self.assertIsNotNone(manifest.codec)
+        self.assertIsNotNone(manifest.brightness_mean)
+        self.assertIsNotNone(manifest.blur_laplacian_var)
+
+    def test_invalid_video_sets_decode_failure_and_blocks_analysis(self) -> None:
+        manifest = video_qc.run(str(Path(self.temp_dir.name) / "missing.mp4"))
+
+        self.assertFalse(manifest.analysis_allowed)
+        self.assertEqual(manifest.quality_warnings, ["video_decode_failed"])
+        self.assertEqual(manifest.total_frames, 0)
+        self.assertEqual(manifest.sampled_frames, 0)
+
+    def test_short_low_resolution_low_fps_video_reports_warnings(self) -> None:
+        path = self._write_video("short_low.mp4", fps=10.0, duration_sec=2.0, size=(320, 240))
+
+        manifest = video_qc.run(str(path))
+
+        self.assertTrue(manifest.analysis_allowed)
+        self.assertIn("too_short", manifest.quality_warnings)
+        self.assertIn("fps_too_low", manifest.quality_warnings)
+        self.assertIn("resolution_too_low", manifest.quality_warnings)
+
+    def test_long_video_reports_warning(self) -> None:
+        original_min_duration = video_qc.MIN_DURATION_SEC
+        original_max_duration = video_qc.MAX_DURATION_SEC
+        video_qc.MIN_DURATION_SEC = 0.0
+        video_qc.MAX_DURATION_SEC = 1.0
+        try:
+            path = self._write_video("long.mp4", duration_sec=2.0)
+
+            manifest = video_qc.run(str(path))
+        finally:
+            video_qc.MIN_DURATION_SEC = original_min_duration
+            video_qc.MAX_DURATION_SEC = original_max_duration
+
+        self.assertTrue(manifest.analysis_allowed)
+        self.assertIn("too_long", manifest.quality_warnings)
+
+    def test_dark_video_reports_warning(self) -> None:
+        path = self._write_video("dark.mp4", mode="dark")
+
+        manifest = video_qc.run(str(path))
+
+        self.assertTrue(manifest.analysis_allowed)
+        self.assertIn("too_dark", manifest.quality_warnings)
+
+    def test_blurry_video_reports_warning(self) -> None:
+        path = self._write_video("blurry.mp4", mode="blurry")
+
+        manifest = video_qc.run(str(path))
+
+        self.assertTrue(manifest.analysis_allowed)
+        self.assertIn("too_blurry", manifest.quality_warnings)
+
+    def test_sample_frame_indices_are_bounded_and_ordered(self) -> None:
+        indices = video_qc.sample_frame_indices(total_frames=100, sample_count=5)
+
+        self.assertEqual(indices, sorted(indices))
+        self.assertEqual(indices[0], 0)
+        self.assertEqual(indices[-1], 99)
+        self.assertEqual(len(indices), 5)
+
+
+if __name__ == "__main__":
+    unittest.main()

uv.lock

@@ -574,6 +574,24 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/15/ce/e5ec180bc41812edcd8daeb8639d205622c0e8c02259d8ab25a0201b3c2a/numpy-2.4.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73", size = 12504263, upload-time = "2026-05-18T23:37:09.715Z" },
 ]
 
+[[package]]
+name = "opencv-python-headless"
+version = "4.13.0.92"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/42/2310883be3b8826ac58c3f2787b9358a2d46923d61f88fedf930bc59c60c/opencv_python_headless-4.13.0.92-cp37-abi3-macosx_13_0_arm64.whl", hash = "sha256:1a7d040ac656c11b8c38677cc8cccdc149f98535089dbe5b081e80a4e5903209", size = 46247192, upload-time = "2026-02-05T07:01:35.187Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/1e/6f9e38005a6f7f22af785df42a43139d0e20f169eb5787ce8be37ee7fcc9/opencv_python_headless-4.13.0.92-cp37-abi3-macosx_14_0_x86_64.whl", hash = "sha256:3e0a6f0a37994ec6ce5f59e936be21d5d6384a4556f2d2da9c2f9c5dc948394c", size = 32568914, upload-time = "2026-02-05T07:01:51.989Z" },
+    { url = "https://files.pythonhosted.org/packages/21/76/9417a6aef9def70e467a5bf560579f816148a4c658b7d525581b356eda9e/opencv_python_headless-4.13.0.92-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c8cfc8e87ed452b5cecb9419473ee5560a989859fe1d10d1ce11ae87b09a2cb", size = 33703709, upload-time = "2026-02-05T10:24:46.469Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ce/bd17ff5772938267fd49716e94ca24f616ff4cb1ff4c6be13085108037be/opencv_python_headless-4.13.0.92-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0525a3d2c0b46c611e2130b5fdebc94cf404845d8fa64d2f3a3b679572a5bd22", size = 56016764, upload-time = "2026-02-05T10:26:48.904Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/b4/b7bcbf7c874665825a8c8e1097e93ea25d1f1d210a3e20d4451d01da30aa/opencv_python_headless-4.13.0.92-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:eb60e36b237b1ebd40a912da5384b348df8ed534f6f644d8e0b4f103e272ba7d", size = 35010236, upload-time = "2026-02-05T10:28:11.031Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/33/b5db29a6c00eb8f50708110d8d453747ca125c8b805bc437b289dbdcc057/opencv_python_headless-4.13.0.92-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:0bd48544f77c68b2941392fcdf9bcd2b9cdf00e98cb8c29b2455d194763cf99e", size = 60391106, upload-time = "2026-02-05T10:30:14.236Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/c3/52cfea47cd33e53e8c0fbd6e7c800b457245c1fda7d61660b4ffe9596a7f/opencv_python_headless-4.13.0.92-cp37-abi3-win32.whl", hash = "sha256:a7cf08e5b191f4ebb530791acc0825a7986e0d0dee2a3c491184bd8599848a4b", size = 30812232, upload-time = "2026-02-05T07:02:29.594Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/90/b338326131ccb2aaa3c2c85d00f41822c0050139a4bfe723cfd95455bd2d/opencv_python_headless-4.13.0.92-cp37-abi3-win_amd64.whl", hash = "sha256:77a82fe35ddcec0f62c15f2ba8a12ecc2ed4207c17b0902c7a3151ae29f37fb6", size = 40070414, upload-time = "2026-02-05T07:02:26.448Z" },
+]
+
 [[package]]
 name = "orjson"
 version = "3.11.9"
@@ -804,6 +822,8 @@ version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
     { name = "gradio" },
+    { name = "numpy" },
+    { name = "opencv-python-headless" },
 ]
 
 [package.optional-dependencies]
@@ -814,6 +834,8 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "gradio", specifier = ">=4.44.0" },
+    { name = "numpy", specifier = ">=1.26.0" },
+    { name = "opencv-python-headless", specifier = ">=4.10.0" },
     { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.5.0" },
 ]
 provides-extras = ["dev"]