kinemotion 0.35.1__tar.gz → 0.36.0__tar.gz

{kinemotion-0.35.1 → kinemotion-0.36.0}/CHANGELOG.md

@@ -7,6 +7,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- version list -->
 
+## v0.36.0 (2025-12-07)
+
+### Bug Fixes
+
+- **backend**: Upgrade kinemotion to v0.35.1 to fix negative metrics bug
+  ([`492dfaa`](https://github.com/feniix/kinemotion/commit/492dfaa87251e527bef0c85822314b7d57ecd48c))
+
+### Documentation
+
+- Fix broken links in agents-guide
+  ([`1daaffb`](https://github.com/feniix/kinemotion/commit/1daaffb43de1db48c0decba66f1f73a28b56c124))
+
+### Features
+
+- Add version display in frontend footer
+  ([`cb4ed66`](https://github.com/feniix/kinemotion/commit/cb4ed669f642430f5bad4b900489d6858235eb43))
+
+
+## v0.35.2 (2025-12-07)
+
+### Bug Fixes
+
+- **validation**: Resolve CMJ athlete profile misclassification
+  ([`1565514`](https://github.com/feniix/kinemotion/commit/156551412c50090c589bda9cacc8e62a542db19f))
+
+
 ## v0.35.1 (2025-12-07)
 
 ### Bug Fixes

{kinemotion-0.35.1 → kinemotion-0.36.0}/PKG-INFO

@@ -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 → kinemotion-0.36.0}/backend/pyproject.toml

@@ -32,7 +32,7 @@ dependencies = [
     "httpx>=0.27.0",
     # Local development: use editable install via `uv sync`
     # Production deployment: use released package from PyPI
-    "kinemotion>=0.30.0",
+    "kinemotion>=0.35.1",
     "pre-commit==4.4.0",
 ]
 

{kinemotion-0.35.1 → kinemotion-0.36.0}/backend/src/kinemotion_backend/app.py

@@ -6,6 +6,7 @@ Real metrics integration with Cloudflare R2 storage for video and results manage
 import os
 import tempfile
 from datetime import datetime, timezone
+from importlib.metadata import version
 from pathlib import Path
 from typing import Any, Literal, cast
 
@@ -397,10 +398,17 @@ async def health_check() -> dict[str, Any]:
     Returns:
         Status dictionary with service health information
     """
+    # Get kinemotion version safely
+    try:
+        kinemotion_version = version("kinemotion")
+    except Exception:
+        kinemotion_version = "unknown"
+
     return {
         "status": "ok",
         "service": "kinemotion-backend",
         "version": "0.1.0",
+        "kinemotion_version": kinemotion_version,
         "timestamp": datetime.now(timezone.utc).isoformat(),
         "r2_configured": r2_client is not None,
     }

{kinemotion-0.35.1 → kinemotion-0.36.0}/docs/development/agents-guide.md

@@ -391,6 +391,6 @@ When creating new agents:
 ## Resources
 
 - **Agent Configuration Files**: `.claude/agents/*.md`
-- **Project Instructions**: [CLAUDE.md](../../CLAUDE.md)
-- **Development Guides**: [Development Documentation](README.md)
+- **Project Instructions**: [CLAUDE.md](https://github.com/feniix/kinemotion/blob/main/CLAUDE.md)
+- **Development Guides**: [Testing Guide](testing.md), [Type Hints Guide](type-hints.md)
 - **Official Docs**: [Claude Code Subagents Documentation](https://docs.claude.com/en/docs/claude-code/sub-agents)

{kinemotion-0.35.1 → kinemotion-0.36.0}/frontend/src/App.tsx

@@ -7,11 +7,13 @@ import Auth from './components/Auth'
 import { useRecentUploads } from './hooks/useRecentUploads'
 import { useAnalysis } from './hooks/useAnalysis'
 import { useAuth } from './hooks/useAuth'
+import { useBackendVersion } from './hooks/useBackendVersion'
 
 function App() {
   const { user, loading: authLoading, signOut } = useAuth()
   const { file, jumpType, loading, uploadProgress, metrics, error, setFile, setJumpType, analyze, retry } = useAnalysis()
   const { recentUploads, addRecentUpload, clearRecentUploads } = useRecentUploads()
+  const { backendVersion, kinemotionVersion } = useBackendVersion()
 
   const handleAnalyze = async () => {
     await analyze()
@@ -87,6 +89,10 @@ function App() {
           <a href="https://github.com/feniix/kinemotion" target="_blank" rel="noopener noreferrer">
             GitHub
           </a>
+          {' | '}
+          <span style={{ fontSize: '0.85em', opacity: 0.8 }}>
+            Backend v{backendVersion} | Analysis v{kinemotionVersion}
+          </span>
         </p>
       </footer>
     </div>

kinemotion-0.36.0/frontend/src/hooks/useBackendVersion.ts

@@ -0,0 +1,40 @@
+import { useState, useEffect } from 'react'
+
+interface HealthResponse {
+  status: string
+  service: string
+  version: string
+  kinemotion_version: string
+  timestamp: string
+  r2_configured: boolean
+}
+
+export function useBackendVersion() {
+  const [backendVersion, setBackendVersion] = useState<string>('...')
+  const [kinemotionVersion, setKinemotionVersion] = useState<string>('...')
+  const [loading, setLoading] = useState(true)
+
+  useEffect(() => {
+    const fetchVersion = async () => {
+      try {
+        const baseApiUrl = import.meta.env.VITE_API_URL || ''
+        const response = await fetch(`${baseApiUrl}/health`)
+
+        if (response.ok) {
+          const data: HealthResponse = await response.json()
+          setBackendVersion(data.version)
+          setKinemotionVersion(data.kinemotion_version)
+        }
+      } catch (error) {
+        console.error('Failed to fetch backend version:', error)
+        // Keep default '...' values on error
+      } finally {
+        setLoading(false)
+      }
+    }
+
+    fetchVersion()
+  }, [])
+
+  return { backendVersion, kinemotionVersion, loading }
+}

{kinemotion-0.35.1 → kinemotion-0.36.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kinemotion"
-version = "0.35.1"
+version = "0.36.0"
 description = "Video-based kinematic analysis for athletic performance"
 readme = "README.md"
 requires-python = ">=3.10,<3.13"

{kinemotion-0.35.1 → kinemotion-0.36.0}/src/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-0.35.1 → kinemotion-0.36.0}/src/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-0.35.1 → kinemotion-0.36.0}/src/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 → kinemotion-0.36.0}/uv.lock

@@ -894,7 +894,7 @@ wheels = [
 
 [[package]]
 name = "kinemotion"
-version = "0.35.1"
+version = "0.36.0"
 source = { editable = "." }
 dependencies = [
     { name = "click" },