feat(rep_counter): implement exercise-specific rep counters for push-ups, shoulder presses, and squats; add dependency on fastapi

pyproject.toml

@@ -5,6 +5,7 @@ description = "Gradio base app for Pozify with mocked pipeline steps and explici
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
+    "fastapi>=0.136.3",
     "gradio>=4.44.0",
     "mediapipe>=0.10.35",
     "numpy>=1.26.0",

requirements.txt

@@ -38,7 +38,9 @@ contourpy==1.3.3
 cycler==0.12.1
     # via matplotlib
 fastapi==0.136.3
-    # via gradio
+    # via
+    #   gradio
+    #   pozify
 filelock==3.29.1
     # via huggingface-hub
 flatbuffers==25.12.19

src/pozify/steps/rep_counter.py

@@ -1,223 +1,10 @@
 from __future__ import annotations
 
-from dataclasses import asdict
 from typing import Any
 
-from pozify.contracts import ExerciseClassification, PoseSequence, Rep, Reps
-from pozify.steps.rep_signals import (
-    SignalSample,
-    angle_deg,
-    average_axis,
-    body_line_score,
-    normalize_optional,
-    samples_from_values,
-    smooth_signal,
-)
-from pozify.steps.rep_state_machine import RepSegment, find_local_extrema, segment_low_high_low
-
-
-MIN_CYCLE_FRAMES = 12
-MIN_PHASE_FRAMES = 4
-MIN_USABLE_SIGNAL_SAMPLES = 9
-MIN_SIGNAL_RANGE = 0.22
-
-
-def _mean_optional(values: list[float | None]) -> float | None:
-    usable = [value for value in values if value is not None]
-    if not usable:
-        return None
-    return sum(usable) / len(usable)
-
-
-def _combine(primary: list[float | None], secondary: list[float | None], *, weight: float) -> list[float | None]:
-    normalized_secondary = normalize_optional(secondary)
-    combined: list[float | None] = []
-    for primary_value, secondary_value in zip(primary, normalized_secondary, strict=False):
-        if primary_value is None:
-            combined.append(None)
-            continue
-        if secondary_value is None:
-            combined.append(primary_value)
-            continue
-        combined.append(primary_value + secondary_value * weight)
-    return combined
-
-
-def _primary_signal_for_exercise(sequence: PoseSequence, exercise: str) -> tuple[list[SignalSample], dict[str, Any]]:
-    hip_y = [average_axis(frame, ("left_hip", "right_hip"), "y") for frame in sequence.frames]
-    shoulder_y = [average_axis(frame, ("left_shoulder", "right_shoulder"), "y") for frame in sequence.frames]
-    wrist_y = [average_axis(frame, ("left_wrist", "right_wrist"), "y") for frame in sequence.frames]
-    knee_bend = [
-        _mean_optional(
-            [
-                None if angle is None else max(0.0, 180.0 - angle)
-                for angle in (
-                    angle_deg(frame, "left_hip", "left_knee", "left_ankle"),
-                    angle_deg(frame, "right_hip", "right_knee", "right_ankle"),
-                )
-            ]
-        )
-        for frame in sequence.frames
-    ]
-    elbow_bend = [
-        _mean_optional(
-            [
-                None if angle is None else max(0.0, 180.0 - angle)
-                for angle in (
-                    angle_deg(frame, "left_shoulder", "left_elbow", "left_wrist"),
-                    angle_deg(frame, "right_shoulder", "right_elbow", "right_wrist"),
-                )
-            ]
-        )
-        for frame in sequence.frames
-    ]
-    body_line = [body_line_score(frame) for frame in sequence.frames]
-
-    if exercise == "squat":
-        raw_signal = _combine(hip_y, knee_bend, weight=0.35)
-        selected_signal = "hip_y_plus_knee_bend"
-    elif exercise == "shoulder_press":
-        inverted_wrist = [None if value is None else -value for value in wrist_y]
-        raw_signal = _combine(inverted_wrist, [None if value is None else -value for value in elbow_bend], weight=0.2)
-        selected_signal = "negative_wrist_y_plus_elbow_extension_proxy"
-    else:
-        chest_proxy = [
-            _mean_optional([shoulder_value, hip_value])
-            for shoulder_value, hip_value in zip(shoulder_y, hip_y, strict=False)
-        ]
-        raw_signal = _combine(chest_proxy, elbow_bend, weight=0.25)
-        selected_signal = "chest_y_plus_elbow_bend"
-
-    smoothed_signal = smooth_signal(raw_signal)
-    normalized_signal = normalize_optional(smoothed_signal)
-    samples = samples_from_values(sequence, normalized_signal)
-    return samples, {
-        "selected_signal": selected_signal,
-        "raw_signal_range": (
-            round(max((value for value in normalized_signal if value is not None), default=0.0)
-            - min((value for value in normalized_signal if value is not None), default=0.0), 4)
-        ),
-        "usable_signal_samples": len(samples),
-        "body_line_mean": round(_mean_optional(body_line) or 0.0, 4),
-    }
-
-
-def _segments_to_reps(segments: list[RepSegment]) -> list[Rep]:
-    return [
-        Rep(
-            rep_id=index + 1,
-            start_frame=segment.start.frame_index,
-            mid_frame=segment.middle.frame_index,
-            end_frame=segment.end.frame_index,
-            start_sec=round(segment.start.timestamp_sec, 3),
-            mid_sec=round(segment.middle.timestamp_sec, 3),
-            end_sec=round(segment.end.timestamp_sec, 3),
-        )
-        for index, segment in enumerate(segments)
-    ]
-
-
-def _partial_reps(
-    sequence: PoseSequence,
-    segments: list[RepSegment],
-    samples: list[SignalSample],
-    *,
-    signal_range: float,
-) -> list[dict[str, Any]]:
-    if not samples:
-        return [{"reason": "low_signal_quality"}]
-
-    partials: list[dict[str, Any]] = []
-    if not segments:
-        if signal_range >= MIN_SIGNAL_RANGE * 0.7:
-            partials.append(
-                {
-                    "reason": "insufficient_rom",
-                    "start_frame": samples[0].frame_index,
-                    "end_frame": samples[-1].frame_index,
-                    "start_sec": round(samples[0].timestamp_sec, 3),
-                    "end_sec": round(samples[-1].timestamp_sec, 3),
-                }
-            )
-        return partials
-
-    first_segment = segments[0]
-    if first_segment.start.frame_index - samples[0].frame_index >= MIN_PHASE_FRAMES:
-        partials.append(
-            {
-                "reason": "starts_mid_rep",
-                "start_frame": samples[0].frame_index,
-                "end_frame": first_segment.start.frame_index,
-                "start_sec": round(samples[0].timestamp_sec, 3),
-                "end_sec": round(first_segment.start.timestamp_sec, 3),
-            }
-        )
-
-    last_segment = segments[-1]
-    if samples[-1].frame_index - last_segment.end.frame_index >= MIN_PHASE_FRAMES:
-        partials.append(
-            {
-                "reason": "ends_mid_rep",
-                "start_frame": last_segment.end.frame_index,
-                "end_frame": samples[-1].frame_index,
-                "start_sec": round(last_segment.end.timestamp_sec, 3),
-                "end_sec": round(samples[-1].timestamp_sec, 3),
-            }
-        )
-    return partials
+from pozify.contracts import ExerciseClassification, PoseSequence, Reps
+from pozify.steps.rep_counters import get_rep_counter
 
 
 def run(classification: ExerciseClassification, sequence: PoseSequence) -> tuple[Reps, dict[str, Any]]:
-    if classification.exercise == "unknown":
-        reps = Reps(exercise=classification.exercise, reps=[], partial_reps=[{"reason": "unknown_exercise"}])
-        return reps, {"selected_signal": "none", "thresholds": {}, "extrema": [], "accepted_reps": []}
-
-    samples, debug = _primary_signal_for_exercise(sequence, classification.exercise)
-    signal_range = debug["raw_signal_range"]
-    extrema = find_local_extrema(samples)
-    segments = (
-        segment_low_high_low(
-            extrema,
-            min_cycle_frames=MIN_CYCLE_FRAMES,
-            min_phase_frames=MIN_PHASE_FRAMES,
-            min_amplitude=max(MIN_SIGNAL_RANGE, signal_range * 0.35),
-        )
-        if len(samples) >= MIN_USABLE_SIGNAL_SAMPLES
-        else []
-    )
-    partial_reps = _partial_reps(sequence, segments, samples, signal_range=signal_range)
-    if sequence.pose_valid_ratio < 0.8:
-        partial_reps.append({"reason": "low_pose_valid_ratio"})
-
-    reps = Reps(
-        exercise=classification.exercise,
-        reps=_segments_to_reps(segments),
-        partial_reps=partial_reps,
-    )
-    debug_payload = {
-        **debug,
-        "thresholds": {
-            "min_cycle_frames": MIN_CYCLE_FRAMES,
-            "min_phase_frames": MIN_PHASE_FRAMES,
-            "min_amplitude": round(max(MIN_SIGNAL_RANGE, signal_range * 0.35), 4),
-        },
-        "extrema": [
-            {
-                "kind": extrema_item.kind,
-                "frame_index": extrema_item.sample.frame_index,
-                "timestamp_sec": round(extrema_item.sample.timestamp_sec, 3),
-                "value": round(extrema_item.sample.value, 4),
-            }
-            for extrema_item in extrema
-        ],
-        "accepted_reps": [
-            {
-                "start": asdict(segment.start),
-                "middle": asdict(segment.middle),
-                "end": asdict(segment.end),
-                "amplitude": round(segment.amplitude, 4),
-            }
-            for segment in segments
-        ],
-    }
-    return reps, debug_payload
+    return get_rep_counter(classification.exercise).count(sequence)

src/pozify/steps/rep_counters/__init__.py

@@ -0,0 +1,5 @@
+from pozify.steps.rep_counters.base import ExerciseRepCounter
+from pozify.steps.rep_counters.registry import get_rep_counter
+
+__all__ = ["ExerciseRepCounter", "get_rep_counter"]
+

src/pozify/steps/rep_counters/base.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import asdict
+from typing import Any
+
+from pozify.contracts import PoseSequence, Rep, Reps
+from pozify.steps.rep_signals import SignalSample, normalize_optional, samples_from_values, smooth_signal
+from pozify.steps.rep_state_machine import RepSegment, find_local_extrema, segment_low_high_low
+
+
+MIN_CYCLE_FRAMES = 12
+MIN_PHASE_FRAMES = 4
+MIN_USABLE_SIGNAL_SAMPLES = 9
+MIN_SIGNAL_RANGE = 0.22
+
+
+def mean_optional(values: list[float | None]) -> float | None:
+    usable = [value for value in values if value is not None]
+    if not usable:
+        return None
+    return sum(usable) / len(usable)
+
+
+def combine(primary: list[float | None], secondary: list[float | None], *, weight: float) -> list[float | None]:
+    normalized_secondary = normalize_optional(secondary)
+    combined: list[float | None] = []
+    for primary_value, secondary_value in zip(primary, normalized_secondary, strict=False):
+        if primary_value is None:
+            combined.append(None)
+            continue
+        if secondary_value is None:
+            combined.append(primary_value)
+            continue
+        combined.append(primary_value + secondary_value * weight)
+    return combined
+
+
+def normalized_samples(
+    sequence: PoseSequence,
+    raw_signal: list[float | None],
+) -> tuple[list[SignalSample], float]:
+    smoothed_signal = smooth_signal(raw_signal)
+    normalized_signal = normalize_optional(smoothed_signal)
+    samples = samples_from_values(sequence, normalized_signal)
+    signal_range = max((value for value in normalized_signal if value is not None), default=0.0) - min(
+        (value for value in normalized_signal if value is not None),
+        default=0.0,
+    )
+    return samples, round(signal_range, 4)
+
+
+def segments_to_reps(segments: list[RepSegment]) -> list[Rep]:
+    return [
+        Rep(
+            rep_id=index + 1,
+            start_frame=segment.start.frame_index,
+            mid_frame=segment.middle.frame_index,
+            end_frame=segment.end.frame_index,
+            start_sec=round(segment.start.timestamp_sec, 3),
+            mid_sec=round(segment.middle.timestamp_sec, 3),
+            end_sec=round(segment.end.timestamp_sec, 3),
+        )
+        for index, segment in enumerate(segments)
+    ]
+
+
+def partial_reps(
+    sequence: PoseSequence,
+    segments: list[RepSegment],
+    samples: list[SignalSample],
+    *,
+    signal_range: float,
+) -> list[dict[str, Any]]:
+    if not samples:
+        return [{"reason": "low_signal_quality"}]
+
+    partials: list[dict[str, Any]] = []
+    if not segments:
+        if signal_range >= MIN_SIGNAL_RANGE * 0.7:
+            partials.append(
+                {
+                    "reason": "insufficient_rom",
+                    "start_frame": samples[0].frame_index,
+                    "end_frame": samples[-1].frame_index,
+                    "start_sec": round(samples[0].timestamp_sec, 3),
+                    "end_sec": round(samples[-1].timestamp_sec, 3),
+                }
+            )
+        return partials
+
+    first_segment = segments[0]
+    if first_segment.start.frame_index - samples[0].frame_index >= MIN_PHASE_FRAMES:
+        partials.append(
+            {
+                "reason": "starts_mid_rep",
+                "start_frame": samples[0].frame_index,
+                "end_frame": first_segment.start.frame_index,
+                "start_sec": round(samples[0].timestamp_sec, 3),
+                "end_sec": round(first_segment.start.timestamp_sec, 3),
+            }
+        )
+
+    last_segment = segments[-1]
+    if samples[-1].frame_index - last_segment.end.frame_index >= MIN_PHASE_FRAMES:
+        partials.append(
+            {
+                "reason": "ends_mid_rep",
+                "start_frame": last_segment.end.frame_index,
+                "end_frame": samples[-1].frame_index,
+                "start_sec": round(last_segment.end.timestamp_sec, 3),
+                "end_sec": round(samples[-1].timestamp_sec, 3),
+            }
+        )
+    return partials
+
+
+class ExerciseRepCounter(ABC):
+    exercise: str
+    min_cycle_frames = MIN_CYCLE_FRAMES
+    min_phase_frames = MIN_PHASE_FRAMES
+    min_signal_range = MIN_SIGNAL_RANGE
+    min_usable_signal_samples = MIN_USABLE_SIGNAL_SAMPLES
+
+    @abstractmethod
+    def build_signal(self, sequence: PoseSequence) -> tuple[list[SignalSample], dict[str, Any]]:
+        """Build the exercise-specific normalized motion signal."""
+
+    def count(self, sequence: PoseSequence) -> tuple[Reps, dict[str, Any]]:
+        samples, debug = self.build_signal(sequence)
+        signal_range = debug["raw_signal_range"]
+        extrema = find_local_extrema(samples)
+        min_amplitude = max(self.min_signal_range, signal_range * 0.35)
+        segments = (
+            segment_low_high_low(
+                extrema,
+                min_cycle_frames=self.min_cycle_frames,
+                min_phase_frames=self.min_phase_frames,
+                min_amplitude=min_amplitude,
+            )
+            if len(samples) >= self.min_usable_signal_samples
+            else []
+        )
+        partials = partial_reps(sequence, segments, samples, signal_range=signal_range)
+        if sequence.pose_valid_ratio < 0.8:
+            partials.append({"reason": "low_pose_valid_ratio"})
+
+        reps = Reps(
+            exercise=self.exercise,
+            reps=segments_to_reps(segments),
+            partial_reps=partials,
+        )
+        debug_payload = {
+            **debug,
+            "thresholds": {
+                "min_cycle_frames": self.min_cycle_frames,
+                "min_phase_frames": self.min_phase_frames,
+                "min_amplitude": round(min_amplitude, 4),
+            },
+            "extrema": [
+                {
+                    "kind": extrema_item.kind,
+                    "frame_index": extrema_item.sample.frame_index,
+                    "timestamp_sec": round(extrema_item.sample.timestamp_sec, 3),
+                    "value": round(extrema_item.sample.value, 4),
+                }
+                for extrema_item in extrema
+            ],
+            "accepted_reps": [
+                {
+                    "start": asdict(segment.start),
+                    "middle": asdict(segment.middle),
+                    "end": asdict(segment.end),
+                    "amplitude": round(segment.amplitude, 4),
+                }
+                for segment in segments
+            ],
+        }
+        return reps, debug_payload
+

src/pozify/steps/rep_counters/push_up.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pozify.contracts import PoseSequence
+from pozify.steps.rep_counters.base import ExerciseRepCounter, combine, mean_optional, normalized_samples
+from pozify.steps.rep_signals import SignalSample, angle_deg, average_axis, body_line_score
+
+
+class PushUpRepCounter(ExerciseRepCounter):
+    exercise = "push_up"
+
+    def build_signal(self, sequence: PoseSequence) -> tuple[list[SignalSample], dict[str, Any]]:
+        hip_y = [average_axis(frame, ("left_hip", "right_hip"), "y") for frame in sequence.frames]
+        shoulder_y = [average_axis(frame, ("left_shoulder", "right_shoulder"), "y") for frame in sequence.frames]
+        elbow_bend = [
+            mean_optional(
+                [
+                    None if angle is None else max(0.0, 180.0 - angle)
+                    for angle in (
+                        angle_deg(frame, "left_shoulder", "left_elbow", "left_wrist"),
+                        angle_deg(frame, "right_shoulder", "right_elbow", "right_wrist"),
+                    )
+                ]
+            )
+            for frame in sequence.frames
+        ]
+        body_line = [body_line_score(frame) for frame in sequence.frames]
+        chest_proxy = [
+            mean_optional([shoulder_value, hip_value])
+            for shoulder_value, hip_value in zip(shoulder_y, hip_y, strict=False)
+        ]
+        samples, signal_range = normalized_samples(sequence, combine(chest_proxy, elbow_bend, weight=0.25))
+        return samples, {
+            "selected_signal": "chest_y_plus_elbow_bend",
+            "raw_signal_range": signal_range,
+            "usable_signal_samples": len(samples),
+            "body_line_mean": round(mean_optional(body_line) or 0.0, 4),
+        }
+

src/pozify/steps/rep_counters/registry.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pozify.contracts import PoseSequence, Reps
+from pozify.steps.rep_counters.base import ExerciseRepCounter
+from pozify.steps.rep_counters.push_up import PushUpRepCounter
+from pozify.steps.rep_counters.shoulder_press import ShoulderPressRepCounter
+from pozify.steps.rep_counters.squat import SquatRepCounter
+from pozify.steps.rep_signals import SignalSample
+
+
+class UnknownRepCounter(ExerciseRepCounter):
+    exercise = "unknown"
+
+    def build_signal(self, sequence: PoseSequence) -> tuple[list[SignalSample], dict[str, Any]]:
+        return [], {"selected_signal": "none", "thresholds": {}, "extrema": [], "accepted_reps": []}
+
+    def count(self, sequence: PoseSequence) -> tuple[Reps, dict[str, Any]]:
+        reps = Reps(exercise=self.exercise, reps=[], partial_reps=[{"reason": "unknown_exercise"}])
+        return reps, {"selected_signal": "none", "thresholds": {}, "extrema": [], "accepted_reps": []}
+
+
+REP_COUNTERS: dict[str, ExerciseRepCounter] = {
+    "push_up": PushUpRepCounter(),
+    "shoulder_press": ShoulderPressRepCounter(),
+    "squat": SquatRepCounter(),
+    "unknown": UnknownRepCounter(),
+}
+
+
+def get_rep_counter(exercise: str) -> ExerciseRepCounter:
+    return REP_COUNTERS.get(exercise, REP_COUNTERS["unknown"])
+

src/pozify/steps/rep_counters/shoulder_press.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pozify.contracts import PoseSequence
+from pozify.steps.rep_counters.base import ExerciseRepCounter, combine, mean_optional, normalized_samples
+from pozify.steps.rep_signals import SignalSample, angle_deg, average_axis, body_line_score
+
+
+class ShoulderPressRepCounter(ExerciseRepCounter):
+    exercise = "shoulder_press"
+
+    def build_signal(self, sequence: PoseSequence) -> tuple[list[SignalSample], dict[str, Any]]:
+        wrist_y = [average_axis(frame, ("left_wrist", "right_wrist"), "y") for frame in sequence.frames]
+        elbow_bend = [
+            mean_optional(
+                [
+                    None if angle is None else max(0.0, 180.0 - angle)
+                    for angle in (
+                        angle_deg(frame, "left_shoulder", "left_elbow", "left_wrist"),
+                        angle_deg(frame, "right_shoulder", "right_elbow", "right_wrist"),
+                    )
+                ]
+            )
+            for frame in sequence.frames
+        ]
+        body_line = [body_line_score(frame) for frame in sequence.frames]
+        inverted_wrist = [None if value is None else -value for value in wrist_y]
+        inverted_elbow_bend = [None if value is None else -value for value in elbow_bend]
+        raw_signal = combine(inverted_wrist, inverted_elbow_bend, weight=0.2)
+        samples, signal_range = normalized_samples(sequence, raw_signal)
+        return samples, {
+            "selected_signal": "negative_wrist_y_plus_elbow_extension_proxy",
+            "raw_signal_range": signal_range,
+            "usable_signal_samples": len(samples),
+            "body_line_mean": round(mean_optional(body_line) or 0.0, 4),
+        }
+

src/pozify/steps/rep_counters/squat.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pozify.contracts import PoseSequence
+from pozify.steps.rep_counters.base import ExerciseRepCounter, combine, mean_optional, normalized_samples
+from pozify.steps.rep_signals import SignalSample, angle_deg, average_axis, body_line_score
+
+
+class SquatRepCounter(ExerciseRepCounter):
+    exercise = "squat"
+
+    def build_signal(self, sequence: PoseSequence) -> tuple[list[SignalSample], dict[str, Any]]:
+        hip_y = [average_axis(frame, ("left_hip", "right_hip"), "y") for frame in sequence.frames]
+        knee_bend = [
+            mean_optional(
+                [
+                    None if angle is None else max(0.0, 180.0 - angle)
+                    for angle in (
+                        angle_deg(frame, "left_hip", "left_knee", "left_ankle"),
+                        angle_deg(frame, "right_hip", "right_knee", "right_ankle"),
+                    )
+                ]
+            )
+            for frame in sequence.frames
+        ]
+        body_line = [body_line_score(frame) for frame in sequence.frames]
+        samples, signal_range = normalized_samples(sequence, combine(hip_y, knee_bend, weight=0.35))
+        return samples, {
+            "selected_signal": "hip_y_plus_knee_bend",
+            "raw_signal_range": signal_range,
+            "usable_signal_samples": len(samples),
+            "body_line_mean": round(mean_optional(body_line) or 0.0, 4),
+        }
+

tests/test_rep_counter.py

@@ -9,6 +9,10 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
 
 from pozify.contracts import ExerciseClassification, PoseFrame, PoseSequence
 from pozify.steps import rep_counter
+from pozify.steps.rep_counters import get_rep_counter
+from pozify.steps.rep_counters.push_up import PushUpRepCounter
+from pozify.steps.rep_counters.shoulder_press import ShoulderPressRepCounter
+from pozify.steps.rep_counters.squat import SquatRepCounter
 
 
 def _frame(frame_index: int, landmarks: dict[str, dict[str, float]]) -> PoseFrame:
@@ -145,6 +149,11 @@ class RepCounterTests(unittest.TestCase):
         self.assertEqual(reps.partial_reps, [{"reason": "unknown_exercise"}])
         self.assertEqual(debug["selected_signal"], "none")
 
+    def test_exercises_resolve_to_specific_rep_counter_strategies(self) -> None:
+        self.assertIsInstance(get_rep_counter("push_up"), PushUpRepCounter)
+        self.assertIsInstance(get_rep_counter("shoulder_press"), ShoulderPressRepCounter)
+        self.assertIsInstance(get_rep_counter("squat"), SquatRepCounter)
+
 
 if __name__ == "__main__":
     unittest.main()

uv.lock

@@ -1289,6 +1289,7 @@ name = "pozify"
 version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
+    { name = "fastapi" },
     { name = "gradio" },
     { name = "mediapipe" },
     { name = "numpy" },
@@ -1303,6 +1304,7 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "fastapi", specifier = ">=0.136.3" },
     { name = "gradio", specifier = ">=4.44.0" },
     { name = "mediapipe", specifier = ">=0.10.35" },
     { name = "numpy", specifier = ">=1.26.0" },