kinemotion 0.35.2__tar.gz → 0.36.1__tar.gz

{kinemotion-0.35.2 → kinemotion-0.36.1}/.github/workflows/deploy-backend.yml

@@ -130,7 +130,7 @@ jobs:
           region: ${{ env.GCP_REGION }}
           image: ${{ env.REGISTRY }}/${{ env.GCP_PROJECT_ID }}/${{ env.SERVICE_NAME }}:${{ github.sha }}
           flags: |
-            --memory=2Gi
+            --memory=4Gi
             --allow-unauthenticated
             --service-account=kinemotion-backend-runtime@${{ env.GCP_PROJECT_ID }}.iam.gserviceaccount.com
             --set-env-vars=CORS_ORIGINS=https://kinemotion.vercel.app,JSON_LOGS=true,LOG_LEVEL=INFO

{kinemotion-0.35.2 → kinemotion-0.36.1}/CHANGELOG.md

@@ -7,6 +7,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- version list -->
 
+## v0.36.1 (2025-12-08)
+
+### Bug Fixes
+
+- **dropjump**: Improve analysis reproducibility with temporal averaging
+  ([`6f98b1f`](https://github.com/feniix/kinemotion/commit/6f98b1f918539e714b604ac1a0bf6187c6ff28a6))
+
+### Chores
+
+- Up the mem of the backend
+  ([`67133ca`](https://github.com/feniix/kinemotion/commit/67133ca2cded45df74ef5bfe3e9d9b7d85bde1a9))
+
+
+## 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

{kinemotion-0.35.2 → kinemotion-0.36.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.35.2
+Version: 0.36.1
 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.2 → kinemotion-0.36.1}/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.2 → kinemotion-0.36.1}/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.2 → kinemotion-0.36.1}/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.2 → kinemotion-0.36.1}/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.1/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.2 → kinemotion-0.36.1}/pyproject.toml

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

{kinemotion-0.35.2 → kinemotion-0.36.1}/src/kinemotion/api.py

@@ -417,6 +417,13 @@ def process_dropjump_video(
     if not Path(video_path).exists():
         raise FileNotFoundError(f"Video file not found: {video_path}")
 
+    # Set deterministic mode for drop jump reproducibility
+    # Note: MediaPipe has inherent non-determinism (Google issue #3945)
+    # This improves consistency but cannot eliminate all variation
+    from .core.determinism import set_deterministic_mode
+
+    set_deterministic_mode(seed=42)
+
     # Start timing
     start_time = time.time()
 

kinemotion-0.36.1/src/kinemotion/core/determinism.py

@@ -0,0 +1,85 @@
+"""Determinism utilities for reproducible analysis.
+
+Provides functions to set random seeds for NumPy, Python's random module,
+and TensorFlow (used by MediaPipe) to ensure deterministic behavior.
+"""
+
+import hashlib
+import os
+import random
+from pathlib import Path
+
+import numpy as np
+
+
+def get_video_hash_seed(video_path: str) -> int:
+    """Generate deterministic seed from video file path.
+
+    Uses video filename (not contents) to generate a consistent seed
+    for the same video across multiple runs.
+
+    Args:
+        video_path: Path to video file
+
+    Returns:
+        Integer seed value derived from filename
+    """
+    # Use filename only (not full path) for consistency
+    filename = Path(video_path).name
+    # Hash filename to get deterministic seed
+    hash_value = hashlib.md5(filename.encode()).hexdigest()
+    # Convert first 8 hex chars to integer
+    return int(hash_value[:8], 16)
+
+
+def set_deterministic_mode(
+    seed: int | None = None, video_path: str | None = None
+) -> None:
+    """Set random seeds for reproducible analysis.
+
+    Sets seeds for:
+    - Python's random module
+    - NumPy random number generator
+    - TensorFlow (via environment variable for TFLite)
+
+    Args:
+        seed: Random seed value. If None and video_path provided,
+              generates seed from video filename.
+        video_path: Optional video path to generate deterministic seed
+
+    Note:
+        This should be called before any MediaPipe or analysis operations
+        to ensure deterministic pose detection and metric calculation.
+    """
+    # Generate seed from video if not provided
+    if seed is None and video_path is not None:
+        seed = get_video_hash_seed(video_path)
+    elif seed is None:
+        seed = 42  # Default
+
+    # Python random
+    random.seed(seed)
+
+    # NumPy random
+    np.random.seed(seed)
+
+    # TensorFlow/TFLite (used by MediaPipe)
+    # Set via environment variable before TF is initialized
+    os.environ["PYTHONHASHSEED"] = str(seed)
+    os.environ["TF_DETERMINISTIC_OPS"] = "1"
+
+    # Try to set TensorFlow seed if available
+    try:
+        import tensorflow as tf
+
+        tf.random.set_seed(seed)
+
+        # Disable GPU non-determinism if CUDA is available
+        try:
+            tf.config.experimental.enable_op_determinism()
+        except AttributeError:
+            # Older TensorFlow versions don't have this
+            pass
+    except ImportError:
+        # TensorFlow not directly available (only via MediaPipe's bundled version)
+        pass

{kinemotion-0.35.2 → kinemotion-0.36.1}/src/kinemotion/core/pose.py

@@ -22,6 +22,7 @@ class PoseTracker:
         """
         self.mp_pose = mp.solutions.pose
         self.pose = self.mp_pose.Pose(
+            static_image_mode=False,  # Use tracking mode for better performance
             min_detection_confidence=min_detection_confidence,
             min_tracking_confidence=min_tracking_confidence,
             model_complexity=1,

{kinemotion-0.35.2 → kinemotion-0.36.1}/src/kinemotion/dropjump/kinematics.py

@@ -202,6 +202,36 @@ def _filter_phases_after_drop(
     return filtered_phases, filtered_interpolated
 
 
+def _compute_robust_phase_position(
+    foot_y_positions: NDArray[np.float64],
+    phase_start: int,
+    phase_end: int,
+    temporal_window: int = 11,
+) -> float:
+    """Compute robust position estimate using temporal averaging.
+
+    Uses median over a fixed temporal window to reduce sensitivity to
+    MediaPipe landmark noise, improving reproducibility.
+
+    Args:
+        foot_y_positions: Vertical position array
+        phase_start: Start frame of phase
+        phase_end: End frame of phase
+        temporal_window: Number of frames to average (default: 11)
+
+    Returns:
+        Robust position estimate using median
+    """
+    # Center the temporal window on the phase midpoint
+    phase_mid = (phase_start + phase_end) // 2
+    window_start = max(0, phase_mid - temporal_window // 2)
+    window_end = min(len(foot_y_positions), phase_mid + temporal_window // 2 + 1)
+
+    # Use median for robustness to outliers
+    window_positions = foot_y_positions[window_start:window_end]
+    return float(np.median(window_positions))
+
+
 def _identify_main_contact_phase(
     phases: list[tuple[int, int, ContactState]],
     ground_phases: list[tuple[int, int, int]],
@@ -237,17 +267,20 @@ def _identify_main_contact_phase(
 
         if ground_after_air and first_ground_idx < first_air_idx:
             # Check if first ground is at higher elevation (lower y) than
-            # ground after air
-            first_ground_y = float(
-                np.mean(foot_y_positions[first_ground_start : first_ground_end + 1])
+            # ground after air using robust temporal averaging
+            first_ground_y = _compute_robust_phase_position(
+                foot_y_positions, first_ground_start, first_ground_end
             )
             second_ground_start, second_ground_end, _ = ground_after_air[0]
-            second_ground_y = float(
-                np.mean(foot_y_positions[second_ground_start : second_ground_end + 1])
+            second_ground_y = _compute_robust_phase_position(
+                foot_y_positions, second_ground_start, second_ground_end
             )
 
-            # If first ground is significantly higher (>5% of frame), it's a drop jump
-            if second_ground_y - first_ground_y > 0.05:
+            # If first ground is significantly higher (>7% of frame), it's a drop jump
+            # Increased from 0.05 to 0.07 with 11-frame temporal averaging
+            # for reproducibility (balances detection sensitivity with noise robustness)
+            # Note: MediaPipe has inherent non-determinism (Google issue #3945)
+            if second_ground_y - first_ground_y > 0.07:
                 is_drop_jump = True
                 contact_start, contact_end = second_ground_start, second_ground_end
 

{kinemotion-0.35.2 → kinemotion-0.36.1}/uv.lock

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