kinemotion 0.38.1__tar.gz → 0.39.1__tar.gz

{kinemotion-0.38.1 → kinemotion-0.39.1}/.claude/settings.local.json

@@ -68,19 +68,5 @@
       "WebFetch(domain:www.sonarsource.com)"
     ]
   },
-  "enableAllProjectMcpServers": true,
-  "hooks": {
-    "UserPromptSubmit": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/fix-basic-memory-names.sh",
-            "timeout": 30000,
-            "statusMessage": "Normalizing basic-memory filenames to kebab-case..."
-          }
-        ]
-      }
-    ]
-  }
+  "enableAllProjectMcpServers": true
 }

{kinemotion-0.38.1 → kinemotion-0.39.1}/.cursor/mcp.json

@@ -21,8 +21,11 @@
       "args": [
         "basic-memory",
         "mcp",
-        "--project=dropjump"
-      ]
+        "--project=kinemotion"
+      ],
+      "env": {
+        "BASIC_MEMORY_KEBAB_FILENAMES": "true"
+      }
     },
     "sequential-thinking": {
       "command": "uvx",

{kinemotion-0.38.1 → kinemotion-0.39.1}/.github/workflows/deploy-backend.yml

@@ -134,7 +134,7 @@ jobs:
             --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
-            --set-secrets=SUPABASE_URL=SUPABASE_URL:latest,SUPABASE_ANON_KEY=SUPABASE_ANON_KEY:latest
+            --set-secrets=SUPABASE_URL=SUPABASE_URL:latest,SUPABASE_ANON_KEY=SUPABASE_ANON_KEY:latest,R2_ENDPOINT=R2_ENDPOINT:latest,R2_ACCESS_KEY=R2_ACCESS_KEY:latest,R2_SECRET_KEY=R2_SECRET_KEY:latest,R2_BUCKET_NAME=R2_BUCKET_NAME:latest
 
       - name: Verify deployment health
         run: |

{kinemotion-0.38.1 → kinemotion-0.39.1}/.mcp.json

@@ -21,8 +21,11 @@
       "args": [
         "basic-memory",
         "mcp",
-        "--project=dropjump"
-      ]
+        "--project=kinemotion"
+      ],
+      "env": {
+        "BASIC_MEMORY_KEBAB_FILENAMES": "true"
+      }
     },
     "sequential-thinking": {
       "command": "uvx",

{kinemotion-0.38.1 → kinemotion-0.39.1}/.serena/project.yml

@@ -80,5 +80,5 @@ excluded_tools: []
 # (contrary to the memories, which are loaded on demand).
 initial_prompt: ""
 
-project_name: "dropjump-claude"
+project_name: "kinemotion"
 included_optional_tools: []

{kinemotion-0.38.1 → kinemotion-0.39.1}/CHANGELOG.md

@@ -7,6 +7,55 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- version list -->
 
+## 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
+
+- Proxy the health endpoint to the backend
+  ([`f1d45d2`](https://github.com/feniix/kinemotion/commit/f1d45d2b194e39f96d43c0462960e80e236a8df9))
+
+- Use presigned URLs for R2 storage access
+  ([`ffd642e`](https://github.com/feniix/kinemotion/commit/ffd642e4c597447f8eee9d4275f48695a7862cf6))
+
+- **dropjump**: Use argmin for landing detection in finding acceleration spike
+  ([`1dd1e1a`](https://github.com/feniix/kinemotion/commit/1dd1e1abff7a3c4aae6675f8aa5f2ddf46de76f6))
+
+- **kinematics**: Correct scale and phase detection logic for CMJ/DJ
+  ([`283b560`](https://github.com/feniix/kinemotion/commit/283b560e69c5785a0d18c5b411e89fedc2a8a7bd))
+
+### Chores
+
+- Remove basic-memory naming hook and cleanup documentation
+  ([`b2f41ce`](https://github.com/feniix/kinemotion/commit/b2f41ce5d81a23090d2f60bd1a79451bd363bd77))
+
+### Features
+
+- Improve frontend
+  ([`241f2f5`](https://github.com/feniix/kinemotion/commit/241f2f58055c241f9919af70156f5ec586ed249f))
+
+- Improve frontend
+  ([`d6e69f3`](https://github.com/feniix/kinemotion/commit/d6e69f335cf6cee4da8affbab876b858aa04af12))
+
+- Integrate Cloudflare R2 storage and debug video overlay
+  ([`b7b05bd`](https://github.com/feniix/kinemotion/commit/b7b05bd500a26d742d78d1670079fb201af49140))
+
+### Testing
+
+- Update R2 integration tests
+  ([`955aa86`](https://github.com/feniix/kinemotion/commit/955aa8610040548635c0f34a931e402825740995))
+
+
 ## v0.38.1 (2025-12-09)
 
 ### Bug Fixes

{kinemotion-0.38.1 → kinemotion-0.39.1}/CLAUDE.md

@@ -393,78 +393,6 @@ This project integrates multiple MCP (Model Context Protocol) servers for enhanc
   - **Search knowledge**: `search_notes("CMJ triple extension")` to find relevant information
   - **Build conversations**: Call `build_context()` before complex tasks to enhance context
 
-#### **Basic Memory Naming Standards**
-
-**File Naming Convention: Lowercase Kebab-Case**
-
-All Markdown files in `.basic-memory/` must follow lowercase kebab-case naming:
-
-```
-✓ GOOD:
-- cmj-physiological-bounds-for-validation.md
-- api-reference-quick-commands.md
-- codebase-architecture-overview.md
-- cmj-phase-detection-testing-gap-analysis.md
-
-✗ BAD:
-- CMJ Physiological Bounds for Validation.md (Title Case with spaces)
-- cMJ_validation.md (inconsistent case)
-- API-REFERENCE.md (all caps)
-```
-
-**Frontmatter Format**
-
-Every note must have proper frontmatter with matching permalink:
-
-```markdown
----
-title: <Human-readable title (can use Title Case)>
-type: note
-permalink: <lowercase-kebab-case-matching-filename>
-tags:
-  - tag1
-  - tag2
----
-```
-
-**Example:**
-
-File: `.basic-memory/biomechanics/cmj-physiological-bounds-for-validation.md`
-
-```markdown
----
-title: CMJ Physiological Bounds for Validation
-type: note
-permalink: biomechanics/cmj-physiological-bounds-for-validation
-tags:
-  - cmj
-  - validation
-  - biomechanics
----
-
-# CMJ Physiological Bounds for Validation
-
-Content here...
-```
-
-**Folder Organization**
-
-- `api/` - API reference and quick commands
-- `biomechanics/` - Jump metrics, RSI, triple extension formulas
-- `codebase/` - Architecture overview, module relationships
-- `development/` - Quality gates, testing standards
-- `project-management/` - Subagent routing, task prioritization
-- `strategy/` - Roadmap and strategic priorities
-
-**Why This Matters**
-
-- **Consistency**: All files follow the same pattern for easier navigation
-- **URL-friendly**: Kebab-case works in memory:// URLs and permalinks
-- **Searchability**: Predictable naming makes notes easier to find
-- **Tools compatibility**: Works correctly with basic-memory CLI and MCP functions
-
-See [.basic-memory/README.md](.basic-memory/README.md) for detailed template and guidelines.
-
 #### **exa** - Web Search & Code Context
 - **Purpose**: Real-time web search and code example retrieval
 - **Use Cases**:

{kinemotion-0.38.1 → kinemotion-0.39.1}/GEMINI.md

@@ -52,32 +52,53 @@ docs/                   # Documentation (PARAMETERS.md is key)
 
 ### Analysis Pipeline
 
+#### Drop Jump Analysis
+
 1. **Pose Tracking** (`core/pose.py`): Extracts 13 body landmarks per frame using MediaPipe.
-1. **Center of Mass (CoM) Estimation** (`core/pose.py`): Optional, more accurate tracking using a biomechanical model.
-1. **Smoothing** (`core/smoothing.py`): A Savitzky-Golay filter reduces jitter.
-1. **Contact Detection** (`dropjump/analysis.py`): Analyzes vertical velocity to determine ground contact vs. flight.
-1. **Phase Identification**: Finds continuous ground contact and flight periods.
-1. **Sub-Frame Interpolation** (`dropjump/analysis.py`): Estimates exact transition times between frames using linear interpolation on the velocity curve, improving timing precision significantly.
-1. **Trajectory Curvature Analysis** (`dropjump/analysis.py`): Refines transition timing by detecting acceleration spikes (e.g., landing impact).
-1. **Metrics Calculation** (`dropjump/kinematics.py`): Calculates ground contact time, flight time, and jump height.
-1. **Output**: Provides metrics in JSON format and an optional debug video.
+1. **Smoothing** (`core/smoothing.py`): Savitzky-Golay filter for noise reduction.
+1. **Contact Detection** (`dropjump/analysis.py`): Velocity-based ground contact detection.
+1. **Sub-Frame Interpolation**: Linear interpolation for precise timing.
+1. **Trajectory Curvature**: Acceleration-based refinement.
+1. **Metrics**: RSI, contact time, jump height.
+
+#### CMJ Analysis (`cmj/analysis.py`)
+
+1. **Strategy**: Uses a **backward search** algorithm starting from the jump peak.
+1. **Signed Velocity**: Calculates signed velocity (negative=up, positive=down) to distinguish concentric/eccentric phases.
+1. **Phase Detection Sequence**:
+   - **Peak Height**: Global minimum y-position.
+   - **Takeoff**: Peak *negative* velocity (max upward speed) found by searching backward from peak.
+   - **Lowest Point**: Maximum y-position found by searching backward from takeoff.
+   - **Landing**: Maximum *positive* acceleration (impact) found by searching forward from peak.
+   - **Standing End**: Detected via acceleration thresholds searching backward from lowest point.
 
 ## Critical Implementation Details
 
-### 1. Aspect Ratio Preservation & SAR Handling (`core/video_io.py`)
+### 1. Aspect Ratio, Rotation & SAR Handling (`core/video_io.py`)
+
+- **CRITICAL**: The tool must preserve the source video's exact aspect ratio and orientation.
+- **FFmpeg/FFprobe**: The `VideoProcessor` class relies on `ffprobe` to extract:
+  - **Rotation**: Metadata often ignored by OpenCV (common in mobile videos).
+  - **SAR (Sample Aspect Ratio)**: Non-square pixel data.
+- **Fallback**: If `ffprobe` is missing, a warning is issued, and defaults are used.
+- **DO**: Always use `frame.shape[:2]` from an actual read frame for dimensions, not `cv2.CAP_PROP_*`.
+
+### 2. Internal Physics Validation (`scripts/validate_known_heights.py`)
 
-- **CRITICAL**: The tool must preserve the source video's exact aspect ratio, including Sample Aspect Ratio (SAR) from mobile videos.
-- **DO**: Get frame dimensions from the first actual frame read from the video (`frame.shape[:2]`), not from `cv2.CAP_PROP_*` properties, which can be wrong for rotated videos.
-- **DO**: Use `ffprobe` to extract SAR and calculate correct display dimensions.
-- The `DebugOverlayRenderer` uses these display dimensions for the output video.
+- **Context**: While clinical validation is pending, the tool undergoes rigorous **internal physics validation**.
+- **Methodology**: Objects are dropped from known heights (0.5m, 1.0m, 1.5m). Measured flight times are compared against theoretical physics predictions ($t = \\sqrt{2h/g}$).
+- **Passing Criteria**:
+  - **MAE**: \< 20ms
+  - **RMSE**: \< 30ms
+  - **Correlation**: > 0.99
 
-### 2. Sub-Frame Interpolation (`dropjump/analysis.py`)
+### 3. Sub-Frame Interpolation & Robust Derivatives (`dropjump/analysis.py`, `core/smoothing.py`)
 
 - **CRITICAL**: Timing precision is achieved by interpolating between frames.
-- **Velocity Calculation**: Velocity is computed as the **first derivative of the smoothed position trajectory** using a Savitzky-Golay filter (`savgol_filter(..., deriv=1)`). This is much smoother and more accurate than simple frame-to-frame differences.
+- **Velocity/Acceleration Calculation**: Velocity is computed as the **first derivative** and acceleration as the **second derivative** of the smoothed position trajectory using a Savitzky-Golay filter (`savgol_filter(..., deriv=1)` and `deriv=2`). This approach is highly robust and accurate, minimizing noise amplification compared to simple finite-difference methods.
 - **Interpolation**: When velocity crosses the contact threshold between two frames, linear interpolation is used to find the fractional frame index of the crossing. This improves timing accuracy from ~33ms to ~10ms at 30fps.
 
-### 3. Trajectory Curvature Analysis (`dropjump/analysis.py`)
+### 4. Trajectory Curvature Analysis (`dropjump/analysis.py`)
 
 - **CRITICAL**: Event timing is further refined using acceleration patterns.
 - **Acceleration Calculation**: Acceleration is the **second derivative of the smoothed position** (`savgol_filter(..., deriv=2)`).
@@ -86,12 +107,18 @@ docs/                   # Documentation (PARAMETERS.md is key)
   - **Takeoff**: A sharp change in acceleration.
 - **Blending**: The final transition time is a weighted blend: 70% from the curvature-based estimate and 30% from the velocity-based estimate. This is enabled by default via `--use-curvature`.
 
-### 4. JSON Serialization of NumPy Types (`dropjump/kinematics.py`)
+### 5. Adaptive Velocity Threshold (`dropjump/analysis.py`)
+
+- **INSIGHT**: The `calculate_adaptive_threshold` function is implemented but currently *not integrated* into the main analysis pipeline.
+- **PURPOSE**: This feature dynamically adjusts the `velocity_threshold` based on baseline noise characteristics of the video. This can significantly improve robustness across varying camera distances, lighting conditions, and video quality by making contact detection less sensitive to noise and more resilient to false positives/negatives.
+- **STATUS**: Awaiting CLI integration. Its inclusion would enhance the tool's adaptability without manual parameter tuning.
+
+### 6. JSON Serialization of NumPy Types (`dropjump/kinematics.py`)
 
 - **CRITICAL**: Standard `json.dump` cannot serialize NumPy integer types (e.g., `np.int64`).
 - **DO**: Explicitly cast all NumPy numbers to standard Python types (`int()`, `float()`) within the `to_dict()` methods of data classes before serialization.
 
-### 5. OpenCV Frame Dimensions
+### 7. OpenCV Frame Dimensions
 
 - **CRITICAL**: Be aware of dimension ordering differences.
 - **NumPy `frame.shape`**: `(height, width, channels)`

{kinemotion-0.38.1 → kinemotion-0.39.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.38.1
+Version: 0.39.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.38.1 → kinemotion-0.39.1}/backend/src/kinemotion_backend/app.py

@@ -52,6 +52,7 @@ class AnalysisResponse:
         message: str,
         metrics: dict[str, Any] | None = None,
         results_url: str | None = None,
+        debug_video_url: str | None = None,
         error: str | None = None,
         processing_time_s: float = 0.0,
     ):
@@ -59,6 +60,7 @@ class AnalysisResponse:
         self.message = message
         self.metrics = metrics
         self.results_url = results_url
+        self.debug_video_url = debug_video_url
         self.error = error
         self.processing_time_s = processing_time_s
 
@@ -76,6 +78,9 @@ class AnalysisResponse:
         if self.results_url is not None:
             result["results_url"] = self.results_url
 
+        if self.debug_video_url is not None:
+            result["debug_video_url"] = self.debug_video_url
+
         if self.error is not None:
             result["error"] = self.error
 
@@ -110,6 +115,29 @@ class R2StorageClient:
             region_name="auto",
         )
 
+    def generate_presigned_url(self, key: str, expiration: int = 3600) -> str:
+        """Generate presigned URL for object.
+
+        Args:
+            key: Object key
+            expiration: Expiration in seconds (default 1 hour)
+
+        Returns:
+            Presigned URL string
+
+        Raises:
+            OSError: If generation fails
+        """
+        try:
+            url = self.client.generate_presigned_url(
+                "get_object",
+                Params={"Bucket": self.bucket_name, "Key": key},
+                ExpiresIn=expiration,
+            )
+            return cast(str, url)
+        except Exception as e:
+            raise OSError(f"Failed to generate presigned URL: {str(e)}") from e
+
     def upload_file(self, local_path: str, remote_key: str) -> str:
         """Upload file to R2 storage.
 
@@ -118,14 +146,14 @@ class R2StorageClient:
             remote_key: S3 object key in R2 bucket
 
         Returns:
-            S3 URL of uploaded file
+            Presigned URL of uploaded file
 
         Raises:
-            IOError: If upload fails
+            OSError: If upload fails
         """
         try:
             self.client.upload_file(local_path, self.bucket_name, remote_key)
-            return f"{self.endpoint}/{self.bucket_name}/{remote_key}"
+            return self.generate_presigned_url(remote_key)
         except Exception as e:
             raise OSError(f"Failed to upload to R2: {str(e)}") from e
 
@@ -137,7 +165,7 @@ class R2StorageClient:
             local_path: Local path to save downloaded file
 
         Raises:
-            IOError: If download fails
+            OSError: If download fails
         """
         try:
             self.client.download_file(self.bucket_name, remote_key, local_path)
@@ -151,7 +179,7 @@ class R2StorageClient:
             remote_key: S3 object key in R2 bucket
 
         Raises:
-            IOError: If deletion fails
+            OSError: If deletion fails
         """
         try:
             self.client.delete_object(Bucket=self.bucket_name, Key=remote_key)
@@ -166,14 +194,14 @@ class R2StorageClient:
             body: Binary content to store
 
         Returns:
-            S3 URL of uploaded object
+            Presigned URL of uploaded object
 
         Raises:
-            IOError: If upload fails
+            OSError: If upload fails
         """
         try:
             self.client.put_object(Bucket=self.bucket_name, Key=key, Body=body)
-            return f"{self.endpoint}/{self.bucket_name}/{key}"
+            return self.generate_presigned_url(key)
         except Exception as e:
             raise OSError(f"Failed to put object to R2: {str(e)}") from e
 
@@ -366,6 +394,7 @@ async def _process_video_async(
     video_path: str,
     jump_type: JumpType,
     quality: str = "balanced",
+    output_video: str | None = None,
 ) -> dict[str, Any]:
     """Process video and return metrics.
 
@@ -373,6 +402,7 @@ async def _process_video_async(
         video_path: Path to video file
         jump_type: Type of jump analysis
         quality: Analysis quality preset
+        output_video: Optional path for debug video output
 
     Returns:
         Dictionary with metrics
@@ -381,9 +411,13 @@ async def _process_video_async(
         ValueError: If video processing fails
     """
     if jump_type == "drop_jump":
-        metrics = process_dropjump_video(video_path, quality=quality)
+        metrics = process_dropjump_video(
+            video_path, quality=quality, output_video=output_video
+        )
     else:  # cmj
-        metrics = process_cmj_video(video_path, quality=quality)
+        metrics = process_cmj_video(
+            video_path, quality=quality, output_video=output_video
+        )
 
     return cast(dict[str, Any], metrics.to_dict())
 
@@ -446,8 +480,10 @@ async def analyze_video(
 
     start_time = time.time()
     temp_video_path = None
+    temp_debug_video_path = None
     r2_video_key = None
     r2_results_key = None
+    r2_debug_video_key = None
 
     try:
         # Validate referer (prevent direct API access)
@@ -460,7 +496,8 @@ async def analyze_video(
             filename=file.filename,
             file_size=file.size,
         )
-        jump_type = _validate_jump_type(jump_type)  # Normalize to lowercase
+        # Normalize to lowercase
+        jump_type = cast(JumpType, _validate_jump_type(jump_type))
         await file.seek(0)
         _validate_video_file(file)
 
@@ -472,10 +509,13 @@ async def analyze_video(
             content = await file.read()
             temp_file.write(content)
 
+        # Create temporary path for debug video output
+        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as temp_debug:
+            temp_debug_video_path = temp_debug.name
+
         # Upload to R2 if client available
         if r2_client:
-            timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
-            r2_video_key = f"videos/{jump_type}/{timestamp}_{file.filename}"
+            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)
@@ -487,18 +527,30 @@ async def analyze_video(
                 ) from e
 
         # Process video with real kinemotion analysis
-        metrics = await _process_video_async(temp_video_path, jump_type, quality)  # type: ignore[arg-type]
+        metrics = await _process_video_async(
+            temp_video_path,
+            jump_type,
+            quality,
+            output_video=temp_debug_video_path,
+        )  # type: ignore[arg-type]
+
         logger.info(
             "video_analysis_completed",
             jump_type=jump_type,
             metrics_count=len(metrics),
         )
 
-        # Upload results to R2 if client available
+        # Upload results and debug video to R2 if client available
         results_url = None
+        debug_video_url = None
+
         if r2_client:
-            timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
-            r2_results_key = f"results/{jump_type}/{timestamp}_results.json"
+            # Use filename stem for derived files to keep them associated
+            # e.g. video.mp4 -> video_results.json, video_debug.mp4
+            file_stem = Path(file.filename or "video").stem
+
+            # Upload Metrics JSON
+            r2_results_key = f"results/{jump_type}/{file_stem}_results.json"
             try:
                 results_json = json.dumps(metrics, indent=2)
                 results_url = r2_client.put_object(
@@ -513,6 +565,28 @@ async def analyze_video(
                     "r2_results_upload_failed", error=str(e), key=r2_results_key
                 )
 
+            # Upload Debug Video if it was created
+            if (
+                temp_debug_video_path
+                and os.path.exists(temp_debug_video_path)
+                and os.path.getsize(temp_debug_video_path) > 0
+            ):
+                r2_debug_video_key = f"debug_videos/{jump_type}/{file_stem}_debug.mp4"
+                try:
+                    debug_video_url = r2_client.upload_file(
+                        temp_debug_video_path, r2_debug_video_key
+                    )
+                    logger.info(
+                        "debug_video_uploaded_to_r2",
+                        key=r2_debug_video_key,
+                        url=debug_video_url,
+                    )
+                except OSError as e:
+                    logger.warning(
+                        "r2_debug_video_upload_failed",
+                        error=str(e),
+                        key=r2_debug_video_key,
+                    )
         processing_time = time.time() - start_time
 
         # Build successful response
@@ -522,6 +596,7 @@ async def analyze_video(
             message=f"Successfully analyzed {jump_type_display} video",
             metrics=metrics,
             results_url=results_url,
+            debug_video_url=debug_video_url,
             processing_time_s=processing_time,
         )
 
@@ -581,6 +656,18 @@ async def analyze_video(
                     "temp_file_cleanup_failed", path=temp_video_path, error=str(e)
                 )
 
+        # Clean up temporary debug video file
+        if temp_debug_video_path and Path(temp_debug_video_path).exists():
+            try:
+                Path(temp_debug_video_path).unlink()
+                logger.debug("temp_debug_file_cleaned", path=temp_debug_video_path)
+            except OSError as e:
+                logger.warning(
+                    "temp_debug_file_cleanup_failed",
+                    path=temp_debug_video_path,
+                    error=str(e),
+                )
+
         # Clean up R2 video if results failed (optional - adjust based on policy)
         # if r2_client and r2_video_key and not results_url:
         #     try:

{kinemotion-0.38.1 → kinemotion-0.39.1}/backend/tests/test_r2_integration.py

@@ -88,13 +88,22 @@ def test_r2_upload_file_success() -> None:
         with patch("kinemotion_backend.app.boto3.client") as mock_boto3:
             mock_s3 = MagicMock()
             mock_boto3.return_value = mock_s3
+            mock_s3.generate_presigned_url.return_value = (
+                "https://r2.example.com/presigned-url"
+            )
 
             client = R2StorageClient()
-            client.upload_file("/tmp/test.mp4", "videos/test.mp4")
+            url = client.upload_file("/tmp/test.mp4", "videos/test.mp4")
 
             mock_s3.upload_file.assert_called_once_with(
                 "/tmp/test.mp4", "kinemotion", "videos/test.mp4"
             )
+            mock_s3.generate_presigned_url.assert_called_once_with(
+                "get_object",
+                Params={"Bucket": "kinemotion", "Key": "videos/test.mp4"},
+                ExpiresIn=3600,
+            )
+            assert url == "https://r2.example.com/presigned-url"
 
 
 def test_r2_upload_file_returns_url() -> None:
@@ -107,11 +116,16 @@ def test_r2_upload_file_returns_url() -> None:
             "R2_SECRET_KEY": "test_secret",
         },
     ):
-        with patch("kinemotion_backend.app.boto3.client"):
+        with patch("kinemotion_backend.app.boto3.client") as mock_boto3:
+            mock_s3 = MagicMock()
+            mock_boto3.return_value = mock_s3
+            presigned_url = "https://r2.example.com/presigned-url"
+            mock_s3.generate_presigned_url.return_value = presigned_url
+
             client = R2StorageClient()
             url = client.upload_file("/tmp/test.mp4", "videos/test.mp4")
 
-            assert url == "https://r2.example.com/kinemotion/videos/test.mp4"
+            assert url == presigned_url
 
 
 def test_r2_upload_file_error_handling() -> None:
@@ -240,12 +254,20 @@ def test_r2_put_object_success() -> None:
         with patch("kinemotion_backend.app.boto3.client") as mock_boto3:
             mock_s3 = MagicMock()
             mock_boto3.return_value = mock_s3
+            mock_s3.generate_presigned_url.return_value = (
+                "https://r2.example.com/presigned-url"
+            )
 
             client = R2StorageClient()
             url = client.put_object("results/test.json", b'{"status": "ok"}')
 
             mock_s3.put_object.assert_called_once()
-            assert url == "https://r2.example.com/kinemotion/results/test.json"
+            mock_s3.generate_presigned_url.assert_called_once_with(
+                "get_object",
+                Params={"Bucket": "kinemotion", "Key": "results/test.json"},
+                ExpiresIn=3600,
+            )
+            assert url == "https://r2.example.com/presigned-url"
 
 
 def test_r2_put_object_error_handling() -> None:

{kinemotion-0.38.1 → kinemotion-0.39.1}/frontend/src/App.tsx

@@ -80,7 +80,7 @@ function App() {
         {loading && <LoadingSpinner uploadProgress={uploadProgress} />}
         {loading && uploadProgress >= 100 && <ResultsSkeleton />}
         {error && <ErrorDisplay error={error} onRetry={handleRetry} />}
-        {metrics && !loading && <ResultsDisplay metrics={metrics} />}
+        {metrics && !loading && <ResultsDisplay metrics={metrics} videoFile={file} />}
       </main>
 
       <footer className="footer">