kinemotion 0.35.1__py3-none-any.whl → 0.36.0__py3-none-any.whl

kinemotion/api.py

@@ -1060,7 +1060,7 @@ def process_cmj_video(
 
         # Validate metrics against physiological bounds
         validator = CMJMetricsValidator()
-        validation_result = validator.validate(metrics.to_dict()["data"])  # type: ignore[arg-type]
+        validation_result = validator.validate(metrics.to_dict())  # type: ignore[arg-type]
         metrics.validation_result = validation_result
 
         if verbose and validation_result.issues:

kinemotion/cmj/metrics_validator.py

@@ -68,6 +68,22 @@ class CMJValidationResult(ValidationResult):
 class CMJMetricsValidator(MetricsValidator):
     """Comprehensive CMJ metrics validator."""
 
+    @staticmethod
+    def _get_metric_value(
+        data: dict, key_with_suffix: str, key_without_suffix: str
+    ) -> float | None:
+        """Get metric value, supporting both suffixed and legacy key formats.
+
+        Args:
+            data: Dictionary containing metrics
+            key_with_suffix: Key with unit suffix (e.g., "flight_time_ms")
+            key_without_suffix: Legacy key without suffix (e.g., "flight_time")
+
+        Returns:
+            Metric value or None if not found
+        """
+        return data.get(key_with_suffix) or data.get(key_without_suffix)
+
     def validate(self, metrics: dict) -> CMJValidationResult:
         """Validate CMJ metrics comprehensively.
 
@@ -87,25 +103,28 @@ class CMJMetricsValidator(MetricsValidator):
 
         profile = result.athlete_profile
 
+        # Extract metric values (handle nested "data" structure)
+        data = metrics.get("data", metrics)  # Support both structures
+
         # PRIMARY BOUNDS CHECKS
-        self._check_flight_time(metrics, result, profile)
-        self._check_jump_height(metrics, result, profile)
-        self._check_countermovement_depth(metrics, result, profile)
-        self._check_concentric_duration(metrics, result, profile)
-        self._check_eccentric_duration(metrics, result, profile)
-        self._check_peak_velocities(metrics, result, profile)
+        self._check_flight_time(data, result, profile)
+        self._check_jump_height(data, result, profile)
+        self._check_countermovement_depth(data, result, profile)
+        self._check_concentric_duration(data, result, profile)
+        self._check_eccentric_duration(data, result, profile)
+        self._check_peak_velocities(data, result, profile)
 
         # CROSS-VALIDATION CHECKS
-        self._check_flight_time_height_consistency(metrics, result)
-        self._check_velocity_height_consistency(metrics, result)
-        self._check_rsi_validity(metrics, result, profile)
+        self._check_flight_time_height_consistency(data, result)
+        self._check_velocity_height_consistency(data, result)
+        self._check_rsi_validity(data, result, profile)
 
         # CONSISTENCY CHECKS
-        self._check_depth_height_ratio(metrics, result)
-        self._check_contact_depth_ratio(metrics, result)
+        self._check_depth_height_ratio(data, result)
+        self._check_contact_depth_ratio(data, result)
 
         # TRIPLE EXTENSION ANGLES
-        self._check_triple_extension(metrics, result, profile)
+        self._check_triple_extension(data, result, profile)
 
         # Finalize status
         result.finalize_status()
@@ -116,10 +135,18 @@ class CMJMetricsValidator(MetricsValidator):
         self, metrics: dict, result: CMJValidationResult, profile: AthleteProfile
     ) -> None:
         """Validate flight time."""
-        flight_time = metrics.get("flight_time")
-        if flight_time is None:
+        flight_time_raw = self._get_metric_value(
+            metrics, "flight_time_ms", "flight_time"
+        )
+        if flight_time_raw is None:
             return
 
+        # If value is in seconds (legacy), use as-is; if in ms, convert
+        if flight_time_raw < 10:  # Likely in seconds
+            flight_time = flight_time_raw
+        else:  # In milliseconds
+            flight_time = flight_time_raw / 1000.0
+
         bounds = CMJBounds.FLIGHT_TIME
 
         if not bounds.is_physically_possible(flight_time):
@@ -159,7 +186,7 @@ class CMJMetricsValidator(MetricsValidator):
         self, metrics: dict, result: CMJValidationResult, profile: AthleteProfile
     ) -> None:
         """Validate jump height."""
-        jump_height = metrics.get("jump_height")
+        jump_height = self._get_metric_value(metrics, "jump_height_m", "jump_height")
         if jump_height is None:
             return
 
@@ -201,7 +228,9 @@ class CMJMetricsValidator(MetricsValidator):
         self, metrics: dict, result: CMJValidationResult, profile: AthleteProfile
     ) -> None:
         """Validate countermovement depth."""
-        depth = metrics.get("countermovement_depth")
+        depth = self._get_metric_value(
+            metrics, "countermovement_depth_m", "countermovement_depth"
+        )
         if depth is None:
             return
 
@@ -243,10 +272,19 @@ class CMJMetricsValidator(MetricsValidator):
         self, metrics: dict, result: CMJValidationResult, profile: AthleteProfile
     ) -> None:
         """Validate concentric duration (contact time)."""
-        duration = metrics.get("concentric_duration")
-        if duration is None:
+        duration_raw = self._get_metric_value(
+            metrics, "concentric_duration_ms", "concentric_duration"
+        )
+        if duration_raw is None:
             return
 
+        # If value is in seconds (legacy), convert to ms first
+        # Values >10 are assumed to be in ms, <10 assumed to be in seconds
+        if duration_raw < 10:  # Likely in seconds
+            duration = duration_raw
+        else:  # In milliseconds
+            duration = duration_raw / 1000.0
+
         bounds = CMJBounds.CONCENTRIC_DURATION
 
         if not bounds.is_physically_possible(duration):
@@ -286,10 +324,18 @@ class CMJMetricsValidator(MetricsValidator):
         self, metrics: dict, result: CMJValidationResult, profile: AthleteProfile
     ) -> None:
         """Validate eccentric duration."""
-        duration = metrics.get("eccentric_duration")
-        if duration is None:
+        duration_raw = self._get_metric_value(
+            metrics, "eccentric_duration_ms", "eccentric_duration"
+        )
+        if duration_raw is None:
             return
 
+        # If value is in seconds (legacy), use as-is; if in ms, convert
+        if duration_raw < 10:  # Likely in seconds
+            duration = duration_raw
+        else:  # In milliseconds
+            duration = duration_raw / 1000.0
+
         bounds = CMJBounds.ECCENTRIC_DURATION
 
         if not bounds.is_physically_possible(duration):
@@ -321,7 +367,9 @@ class CMJMetricsValidator(MetricsValidator):
     ) -> None:
         """Validate peak eccentric and concentric velocities."""
         # Eccentric
-        ecc_vel = metrics.get("peak_eccentric_velocity")
+        ecc_vel = self._get_metric_value(
+            metrics, "peak_eccentric_velocity_m_s", "peak_eccentric_velocity"
+        )
         if ecc_vel is not None:
             bounds = CMJBounds.PEAK_ECCENTRIC_VELOCITY
             if not bounds.is_physically_possible(ecc_vel):
@@ -349,7 +397,9 @@ class CMJMetricsValidator(MetricsValidator):
                 )
 
         # Concentric
-        con_vel = metrics.get("peak_concentric_velocity")
+        con_vel = self._get_metric_value(
+            metrics, "peak_concentric_velocity_m_s", "peak_concentric_velocity"
+        )
         if con_vel is not None:
             bounds = CMJBounds.PEAK_CONCENTRIC_VELOCITY
             if not bounds.is_physically_possible(con_vel):
@@ -390,12 +440,15 @@ class CMJMetricsValidator(MetricsValidator):
         self, metrics: dict, result: CMJValidationResult
     ) -> None:
         """Verify jump height is consistent with flight time."""
-        flight_time = metrics.get("flight_time")
-        jump_height = metrics.get("jump_height")
+        flight_time_ms = metrics.get("flight_time_ms")
+        jump_height = metrics.get("jump_height_m")
 
-        if flight_time is None or jump_height is None:
+        if flight_time_ms is None or jump_height is None:
             return
 
+        # Convert ms to seconds
+        flight_time = flight_time_ms / 1000.0
+
         # h = g * t^2 / 8
         g = 9.81
         expected_height = (g * flight_time**2) / 8
@@ -424,8 +477,8 @@ class CMJMetricsValidator(MetricsValidator):
         self, metrics: dict, result: CMJValidationResult
     ) -> None:
         """Verify peak velocity is consistent with jump height."""
-        velocity = metrics.get("peak_concentric_velocity")
-        jump_height = metrics.get("jump_height")
+        velocity = metrics.get("peak_concentric_velocity_m_s")
+        jump_height = metrics.get("jump_height_m")
 
         if velocity is None or jump_height is None:
             return
@@ -461,16 +514,31 @@ class CMJMetricsValidator(MetricsValidator):
         self, metrics: dict, result: CMJValidationResult, profile: AthleteProfile
     ) -> None:
         """Validate Reactive Strength Index."""
-        flight_time = metrics.get("flight_time")
-        concentric_duration = metrics.get("concentric_duration")
+        flight_time_raw = self._get_metric_value(
+            metrics, "flight_time_ms", "flight_time"
+        )
+        concentric_duration_raw = self._get_metric_value(
+            metrics, "concentric_duration_ms", "concentric_duration"
+        )
 
         if (
-            flight_time is None
-            or concentric_duration is None
-            or concentric_duration == 0
+            flight_time_raw is None
+            or concentric_duration_raw is None
+            or concentric_duration_raw == 0
         ):
             return
 
+        # Convert to seconds if needed
+        if flight_time_raw < 10:  # Likely in seconds
+            flight_time = flight_time_raw
+        else:  # In milliseconds
+            flight_time = flight_time_raw / 1000.0
+
+        if concentric_duration_raw < 10:  # Likely in seconds
+            concentric_duration = concentric_duration_raw
+        else:  # In milliseconds
+            concentric_duration = concentric_duration_raw / 1000.0
+
         rsi = flight_time / concentric_duration
         result.rsi = rsi
 
@@ -513,8 +581,8 @@ class CMJMetricsValidator(MetricsValidator):
         self, metrics: dict, result: CMJValidationResult
     ) -> None:
         """Check countermovement depth to jump height ratio."""
-        depth = metrics.get("countermovement_depth")
-        jump_height = metrics.get("jump_height")
+        depth = metrics.get("countermovement_depth_m")
+        jump_height = metrics.get("jump_height_m")
 
         if (
             depth is None or jump_height is None or depth < 0.05
@@ -557,12 +625,14 @@ class CMJMetricsValidator(MetricsValidator):
         self, metrics: dict, result: CMJValidationResult
     ) -> None:
         """Check contact time to countermovement depth ratio."""
-        contact = metrics.get("concentric_duration")
-        depth = metrics.get("countermovement_depth")
+        contact_ms = metrics.get("concentric_duration_ms")
+        depth = metrics.get("countermovement_depth_m")
 
-        if contact is None or depth is None or depth < 0.05:
+        if contact_ms is None or depth is None or depth < 0.05:
             return
 
+        # Convert ms to seconds for ratio calculation
+        contact = contact_ms / 1000.0
         ratio = contact / depth
         result.contact_depth_ratio = ratio
 

kinemotion/cmj/validation_bounds.py

@@ -323,7 +323,10 @@ def estimate_athlete_profile(
     Returns:
         Estimated AthleteProfile
     """
-    jump_height = metrics_dict.get("jump_height", 0)
+    # Support both nested "data" structure and flat structure
+    # Extract with unit suffix as used in serialization, or without suffix (legacy)
+    data = metrics_dict.get("data", metrics_dict)
+    jump_height = data.get("jump_height_m") or data.get("jump_height", 0)
 
     if jump_height < 0.20:
         return AthleteProfile.ELDERLY

{kinemotion-0.35.1.dist-info → kinemotion-0.36.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.35.1
+Version: 0.36.0
 Summary: Video-based kinematic analysis for athletic performance
 Project-URL: Homepage, https://github.com/feniix/kinemotion
 Project-URL: Repository, https://github.com/feniix/kinemotion

{kinemotion-0.35.1.dist-info → kinemotion-0.36.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 kinemotion/__init__.py,sha256=sxdDOekOrIgjxm842gy-6zfq7OWmGl9ShJtXCm4JI7c,723
-kinemotion/api.py,sha256=oZB4Xk8KLqwOEYJCZnmEKPn_mAyQacw4s4QAhwTPH8I,39479
+kinemotion/api.py,sha256=nbDbyzhXIMA04tGqKPH8R0fR66zgtu14x6NgWroy_QU,39471
 kinemotion/cli.py,sha256=cqYV_7URH0JUDy1VQ_EDLv63FmNO4Ns20m6s1XAjiP4,464
 kinemotion/cmj/__init__.py,sha256=Ynv0-Oco4I3Y1Ubj25m3h9h2XFqeNwpAewXmAYOmwfU,127
 kinemotion/cmj/analysis.py,sha256=OfNTMLPwZIRYbX-Yd8jgZ-7pqnHRz7L2bWAHVYFsQ60,18955
@@ -7,8 +7,8 @@ kinemotion/cmj/cli.py,sha256=Mj2h9It1jVjAauvtCxfLWTRijj7zbYhxZuebhw2Zz6w,10828
 kinemotion/cmj/debug_overlay.py,sha256=fXmWoHhqMLGo4vTtB6Ezs3yLUDOLw63zLIgU2gFlJQU,15892
 kinemotion/cmj/joint_angles.py,sha256=HmheIEiKcQz39cRezk4h-htorOhGNPsqKIR9RsAEKts,9960
 kinemotion/cmj/kinematics.py,sha256=qRBe87NkX-7HQTQ8RoF-EpvfcffgP5vycJJRrxpHboc,10307
-kinemotion/cmj/metrics_validator.py,sha256=p_hgg0Q0UAiWGNXKSW4E9kPvyEgPNAujaxrk2XUmsBY,28619
-kinemotion/cmj/validation_bounds.py,sha256=yRhmpUzGJs0QYyL1o3mOkgUSTe4XTO2MONMITTjCv3c,11778
+kinemotion/cmj/metrics_validator.py,sha256=V_fmlczYH06SBtwqESv-IfGi3wDsIy3RQbd7VwOyNo0,31359
+kinemotion/cmj/validation_bounds.py,sha256=9ZTo68fl3ooyWjXXyTMRLpK9tFANa_rQf3oHhq7iQGE,11995
 kinemotion/core/__init__.py,sha256=HsqolRa60cW3vrG8F9Lvr9WvWcs5hCmsTzSgo7imi-4,1278
 kinemotion/core/auto_tuning.py,sha256=wtCUMOhBChVJNXfEeku3GCMW4qED6MF-O_mv2sPTiVQ,11324
 kinemotion/core/cli_utils.py,sha256=zbnifPhD-OYofJioeYfJtshuWcl8OAEWtqCGVF4ctAI,7966
@@ -30,8 +30,8 @@ kinemotion/dropjump/kinematics.py,sha256=yB4ws4VG59SUGcw1J-uXfDFfCMXBdzRh5C4jo0o
 kinemotion/dropjump/metrics_validator.py,sha256=sx4RodHpeiW8_PRB0GUJvkUWto1Ard1Dvrc9z8eKk7M,9351
 kinemotion/dropjump/validation_bounds.py,sha256=5b4I3CKPybuvrbn-nP5yCcGF_sH4Vtyw3a5AWWvWnBk,4645
 kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kinemotion-0.35.1.dist-info/METADATA,sha256=n93tZOI22N9m3SF1OHG2HImIGP7_fru3jN22Jr8xKrw,26020
-kinemotion-0.35.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-kinemotion-0.35.1.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.35.1.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.35.1.dist-info/RECORD,,
+kinemotion-0.36.0.dist-info/METADATA,sha256=oDRVIjwO8LiGTAOuFxGM5AVQAejcl5liHy3WM95eq3c,26020
+kinemotion-0.36.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kinemotion-0.36.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.36.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.36.0.dist-info/RECORD,,