kinemotion 0.39.0__tar.gz → 0.40.0__tar.gz

{kinemotion-0.39.0 → kinemotion-0.40.0}/CHANGELOG.md

@@ -7,6 +7,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- version list -->
 
+## v0.40.0 (2025-12-10)
+
+### Documentation
+
+- Switch formatting tool from black to ruff in GEMINI.md
+  ([`7bf2e3e`](https://github.com/feniix/kinemotion/commit/7bf2e3e073fea368470359a0bdff65b8568e48e1))
+
+### Features
+
+- Add detailed timing logs to analysis pipeline
+  ([`4c75820`](https://github.com/feniix/kinemotion/commit/4c758201be03dbd06f463e2434ca287bb123bfd5))
+
+### Testing
+
+- Relax flight time assertion in kinematics test
+  ([`b360c4d`](https://github.com/feniix/kinemotion/commit/b360c4de88c92e365657775041fe7eea04892a27))
+
+
+## v0.39.1 (2025-12-10)
+
+### Bug Fixes
+
+- Prioritize browser-compatible video codecs
+  ([`76ea08f`](https://github.com/feniix/kinemotion/commit/76ea08fd6edb3d0e0269b2e05db90a98e99777c1))
+
+- Use ffmpeg re-encoding only as a fallback
+  ([`d55923f`](https://github.com/feniix/kinemotion/commit/d55923f9c09d0d8507519c140b58485eaabb4f86))
+
+
 ## v0.39.0 (2025-12-10)
 
 ### Bug Fixes

{kinemotion-0.39.0 → kinemotion-0.40.0}/GEMINI.md

@@ -20,18 +20,18 @@ The project uses `uv` for dependency management and `asdf` for Python version ma
 **Key Libraries:**
 
 - **Production**: `click`, `opencv-python`, `mediapipe`, `numpy`, `scipy`.
-- **Development**: `pytest`, `black`, `ruff`, `mypy`.
+- **Development**: `pytest`, `ruff`, `pyright`.
 
 ### Development Commands
 
 - **Run CLI**: `uv run kinemotion dropjump-analyze <video_path>`
 - **Install/Sync Dependencies**: `uv sync`
 - **Run Tests**: `uv run pytest`
-- **Format Code**: `uv run black src/`
+- **Format Code**: `uv run ruff format .`
 - **Lint Code**: `uv run ruff check`
 - **Auto-fix Linting**: `uv run ruff check --fix`
-- **Type Check**: `uv run mypy src/kinemotion`
-- **Run All Checks**: `uv run ruff check && uv run mypy src/kinemotion && uv run pytest`
+- **Type Check**: `uv run pyright`
+- **Run All Checks**: `uv run ruff check && uv run pyright && uv run pytest`
 
 ## Architecture
 
@@ -127,18 +127,20 @@ docs/                   # Documentation (PARAMETERS.md is key)
 
 ## Code Quality & Workflow
 
+**CRITICAL**: Never commit code that fails sanity checks. Always run `ruff`, `pyright`, and `pytest` locally before committing.
+
 When contributing code, strictly adhere to the project's quality standards.
 
-1. **Format Code**: `uv run black src/`
+1. **Format Code**: `uv run ruff format .`
 1. **Lint and Fix**: `uv run ruff check --fix`
-1. **Type Check**: `uv run mypy src/kinemotion`
+1. **Type Check**: `uv run pyright`
 1. **Run Tests**: `uv run pytest`
 
-**Run all checks before committing**: `uv run ruff check && uv run mypy src/kinemotion && uv run pytest`
+**Run all checks before committing**: `uv run ruff check && uv run pyright && uv run pytest`
 
-- **Type Safety**: The project uses `mypy` in strict mode. All functions must have full type annotations.
+- **Type Safety**: The project uses `pyright` in strict mode. All functions must have full type annotations.
 - **Linting**: `ruff` is used for linting. Configuration is in `pyproject.toml`.
-- **Formatting**: `black` is used for code formatting.
+- **Formatting**: `ruff` is used for code formatting.
 
 ## Common Development Tasks
 

{kinemotion-0.39.0 → kinemotion-0.40.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.39.0
+Version: 0.40.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.39.0 → kinemotion-0.40.0}/backend/src/kinemotion_backend/app.py

@@ -515,10 +515,16 @@ async def analyze_video(
 
         # Upload to R2 if client available
         if r2_client:
+            upload_start = time.time()
             r2_video_key = f"videos/{jump_type}/{file.filename}"
             try:
                 r2_client.upload_file(temp_video_path, r2_video_key)
-                logger.info("video_uploaded_to_r2", key=r2_video_key)
+                upload_duration = time.time() - upload_start
+                logger.info(
+                    "video_uploaded_to_r2",
+                    key=r2_video_key,
+                    duration_ms=round(upload_duration * 1000),
+                )
             except OSError as e:
                 logger.error("r2_upload_failed", error=str(e), key=r2_video_key)
                 raise HTTPException(
@@ -527,17 +533,20 @@ async def analyze_video(
                 ) from e
 
         # Process video with real kinemotion analysis
+        analysis_start = time.time()
         metrics = await _process_video_async(
             temp_video_path,
             jump_type,
             quality,
             output_video=temp_debug_video_path,
         )  # type: ignore[arg-type]
+        analysis_duration = time.time() - analysis_start
 
         logger.info(
             "video_analysis_completed",
             jump_type=jump_type,
             metrics_count=len(metrics),
+            duration_ms=round(analysis_duration * 1000),
         )
 
         # Upload results and debug video to R2 if client available
@@ -552,12 +561,17 @@ async def analyze_video(
             # Upload Metrics JSON
             r2_results_key = f"results/{jump_type}/{file_stem}_results.json"
             try:
+                results_upload_start = time.time()
                 results_json = json.dumps(metrics, indent=2)
                 results_url = r2_client.put_object(
                     r2_results_key, results_json.encode()
                 )
+                results_upload_duration = time.time() - results_upload_start
                 logger.info(
-                    "results_uploaded_to_r2", key=r2_results_key, url=results_url
+                    "results_uploaded_to_r2",
+                    key=r2_results_key,
+                    url=results_url,
+                    duration_ms=round(results_upload_duration * 1000),
                 )
             except OSError as e:
                 # Log error but don't fail - results still available in response
@@ -573,13 +587,16 @@ async def analyze_video(
             ):
                 r2_debug_video_key = f"debug_videos/{jump_type}/{file_stem}_debug.mp4"
                 try:
+                    debug_upload_start = time.time()
                     debug_video_url = r2_client.upload_file(
                         temp_debug_video_path, r2_debug_video_key
                     )
+                    debug_upload_duration = time.time() - debug_upload_start
                     logger.info(
                         "debug_video_uploaded_to_r2",
                         key=r2_debug_video_key,
                         url=debug_video_url,
+                        duration_ms=round(debug_upload_duration * 1000),
                     )
                 except OSError as e:
                     logger.warning(

{kinemotion-0.39.0 → kinemotion-0.40.0}/pyproject.toml

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

{kinemotion-0.39.0 → kinemotion-0.40.0}/src/kinemotion/core/debug_overlay_utils.py

@@ -1,5 +1,11 @@
 """Shared debug overlay utilities for video rendering."""
 
+import os
+import shutil
+import subprocess
+import time
+from pathlib import Path
+
 import cv2
 import numpy as np
 
@@ -11,7 +17,7 @@ def create_video_writer(
     display_width: int,
     display_height: int,
     fps: float,
-) -> tuple[cv2.VideoWriter, bool]:
+) -> tuple[cv2.VideoWriter, bool, str]:
     """
     Create a video writer with fallback codec support.
 
@@ -24,28 +30,43 @@ def create_video_writer(
         fps: Frames per second
 
     Returns:
-        Tuple of (video_writer, needs_resize)
+        Tuple of (video_writer, needs_resize, used_codec)
     """
     needs_resize = (display_width != width) or (display_height != height)
 
-    # Try H.264 codec first (better quality/compatibility), fallback to mp4v
-    fourcc = cv2.VideoWriter_fourcc(*"avc1")
-    writer = cv2.VideoWriter(output_path, fourcc, fps, (display_width, display_height))
+    # Try browser-compatible codecs first
+    # avc1/h264: H.264 (Most compatible)
+    # vp09: VP9 (Good compatibility)
+    # mp4v: MPEG-4 (Poor browser support, last resort)
+    codecs_to_try = ["avc1", "h264", "vp09", "mp4v"]
 
-    # Check if writer opened successfully, fallback to mp4v if not
-    if not writer.isOpened():
-        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
-        writer = cv2.VideoWriter(
-            output_path, fourcc, fps, (display_width, display_height)
-        )
+    writer = None
+    used_codec = "mp4v"  # Default fallback
 
-    if not writer.isOpened():
+    for codec in codecs_to_try:
+        try:
+            fourcc = cv2.VideoWriter_fourcc(*codec)
+            writer = cv2.VideoWriter(
+                output_path, fourcc, fps, (display_width, display_height)
+            )
+            if writer.isOpened():
+                used_codec = codec
+                if codec == "mp4v":
+                    print(
+                        f"Warning: Fallback to {codec} codec. "
+                        "Video may not play in browsers."
+                    )
+                break
+        except Exception:
+            continue
+
+    if writer is None or not writer.isOpened():
         raise ValueError(
             f"Failed to create video writer for {output_path} with dimensions "
             f"{display_width}x{display_height}"
         )
 
-    return writer, needs_resize
+    return writer, needs_resize, used_codec
 
 
 def write_overlay_frame(
@@ -95,11 +116,12 @@ class BaseDebugOverlayRenderer:
             display_height: Display height (considering SAR)
             fps: Frames per second
         """
+        self.output_path = output_path
         self.width = width
         self.height = height
         self.display_width = display_width
         self.display_height = display_height
-        self.writer, self.needs_resize = create_video_writer(
+        self.writer, self.needs_resize, self.used_codec = create_video_writer(
             output_path, width, height, display_width, display_height, fps
         )
 
@@ -133,9 +155,67 @@ class BaseDebugOverlayRenderer:
         write_overlay_frame(self.writer, frame, self.display_width, self.display_height)
 
     def close(self) -> None:
-        """Release video writer."""
+        """Release video writer and re-encode if possible."""
         self.writer.release()
 
+        # Post-process with ffmpeg ONLY if we fell back to the incompatible mp4v codec
+        if self.used_codec == "mp4v" and shutil.which("ffmpeg"):
+            temp_path = None
+            try:
+                temp_path = str(
+                    Path(self.output_path).with_suffix(
+                        ".temp" + Path(self.output_path).suffix
+                    )
+                )
+
+                # Convert to H.264 with yuv420p pixel format for browser compatibility
+                # -y: Overwrite output file
+                # -vcodec libx264: Use H.264 codec
+                # -pix_fmt yuv420p: Required for wide browser support (Chrome,
+                #                   Safari, Firefox)
+                # -preset fast: Reasonable speed/compression tradeoff
+                # -crf 23: Standard quality
+                # -an: Remove audio (debug video has no audio)
+                cmd = [
+                    "ffmpeg",
+                    "-y",
+                    "-i",
+                    self.output_path,
+                    "-vcodec",
+                    "libx264",
+                    "-pix_fmt",
+                    "yuv420p",
+                    "-preset",
+                    "fast",
+                    "-crf",
+                    "23",
+                    "-an",
+                    temp_path,
+                ]
+
+                # Suppress output unless error
+                reencode_start = time.time()
+                subprocess.run(
+                    cmd,
+                    check=True,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.PIPE,
+                )
+                reencode_duration = time.time() - reencode_start
+                print(f"Debug video re-encoded in {reencode_duration:.2f}s")
+
+                # Overwrite original file
+                os.replace(temp_path, self.output_path)
+
+            except subprocess.CalledProcessError as e:
+                print(f"Warning: Failed to re-encode debug video with ffmpeg: {e}")
+                if temp_path and os.path.exists(temp_path):
+                    os.remove(temp_path)
+            except Exception as e:
+                print(f"Warning: Error during video post-processing: {e}")
+                if temp_path and os.path.exists(temp_path):
+                    os.remove(temp_path)
+
     def __enter__(self) -> "BaseDebugOverlayRenderer":
         return self
 

{kinemotion-0.39.0 → kinemotion-0.40.0}/tests/dropjump/test_kinematics.py

@@ -34,9 +34,11 @@ def test_calculate_metrics_basic():
     assert 0.25 < metrics.ground_contact_time < 0.40  # Approximately 8-12 frames
 
     # Flight time: acceleration-based landing detection finds impact earlier
-    # than simple phase boundary, typically 13-17 frames instead of 20
+    # than simple phase boundary, typically 13-17 frames instead of 20.
+    # Relaxed upper bound to 0.70 to account for cases where refinement
+    # might not trigger on synthetic linear data (20 frames = 0.66s).
     assert metrics.flight_time is not None
-    assert 0.34 < metrics.flight_time < 0.65  # Approximately 10-20 frames
+    assert 0.34 < metrics.flight_time < 0.70
 
     # Jump height should be calculated from flight time
     assert metrics.jump_height is not None

{kinemotion-0.39.0 → kinemotion-0.40.0}/uv.lock

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