kinemotion 0.47.1__tar.gz → 0.47.2__tar.gz

{kinemotion-0.47.1 → kinemotion-0.47.2}/.claude/settings.local.json

@@ -65,7 +65,9 @@
       "WebFetch(domain:realpython.com)",
       "WebFetch(domain:sonarcloud.io)",
       "WebFetch(domain:www.pyopensci.org)",
-      "WebFetch(domain:www.sonarsource.com)"
+      "WebFetch(domain:www.sonarsource.com)",
+      "mcp__sonarqube__search_sonar_issues_in_projects",
+      "mcp__sonarqube__show_rule"
     ]
   },
   "enableAllProjectMcpServers": true

{kinemotion-0.47.1 → kinemotion-0.47.2}/.mcp.json

@@ -27,6 +27,19 @@
         "BASIC_MEMORY_KEBAB_FILENAMES": "true"
       }
     },
+    "sonarqube": {
+      "command": "direnv",
+      "args": [
+        "exec",
+        "/Users/feniix/src/personal/cursor/kinemotion",
+        "java",
+        "-jar",
+        "/tmp/sonarqube-mcp-server-1.4.0.1666.jar"
+      ],
+      "env": {
+        "STORAGE_PATH": "/tmp/sonarqube"
+      }
+    },
     "sequential-thinking": {
       "command": "uvx",
       "args": [

{kinemotion-0.47.1 → kinemotion-0.47.2}/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- version list -->
 
+## v0.47.2 (2025-12-12)
+
+### Bug Fixes
+
+- **telemetry**: Use structlog for robust error handling
+  ([`0c66c5f`](https://github.com/feniix/kinemotion/commit/0c66c5f486c4f034e5833ee0016d37fc31e9240d))
+
+### Documentation
+
+- Update CLAUDE.md with test count and coverage improvements
+  ([`1132324`](https://github.com/feniix/kinemotion/commit/1132324fe9bfe907bc6850397fd5370668b1bfa6))
+
+### Refactoring
+
+- Reduce cognitive complexity across validation, kinematics, and API
+  ([`04a88cb`](https://github.com/feniix/kinemotion/commit/04a88cbcec3b52bf1767e9647627b839ca842ecf))
+
+
 ## v0.47.1 (2025-12-12)
 
 ### Bug Fixes

{kinemotion-0.47.1 → kinemotion-0.47.2}/CLAUDE.md

@@ -45,7 +45,7 @@ uv run pytest --cov-report=html         # Generate HTML coverage report
 uv run ruff check --fix && uv run pyright  # Lint + type check
 ```
 
-**Note**: Test count reflects 207 test functions across 24 test files. Parameterized tests generate additional test instances at runtime. Total coverage: 78.67%.
+**Note**: Test count reflects 620 passing tests across 24 test files. Parameterized tests generate additional test instances at runtime. Total coverage: 80.86%.
 
 **Coverage Reports:**
 
@@ -98,7 +98,7 @@ src/kinemotion/
 │   └── validation_bounds.py    # Drop jump bounds (DropJumpBounds)
 └── [other modules]
 
-tests/                      # 519 tests (comprehensive coverage across all modules)
+tests/                      # 620 tests (comprehensive coverage across all modules)
 ├── conftest.py             # Shared fixtures (cli_runner, minimal_video, sample_video_path)
 ├── core/                   # Core module tests (9 files)
 ├── dropjump/               # Drop jump tests (6 files)
@@ -128,7 +128,7 @@ The project has evolved into a complete platform with three main components:
 │   ├── cli.py           # Main CLI commands
 │   ├── api.py           # Python API (used by backend)
 │   └── [modules]        # Core, dropjump, cmj
-└── tests/               # 519 comprehensive tests (78.67% coverage)
+└── tests/               # 620 comprehensive tests (80.86% coverage)
 ```
 
 **Data Flow:**
@@ -186,27 +186,29 @@ uv run pytest             # All tests (207 test functions)
 - Ruff (88 char lines, both linting and formatting)
 - Conventional Commits (see below)
 - **Code duplication target: < 3%**
-- **Test coverage: ≥ 50% (current: 78.67% with branch coverage)**
-- **Test count: 207 test functions across 24 test files**
+- **Test coverage: ≥ 50% (current: 80.86% with branch coverage)**
+- **Test count: 620 tests across 24 test files**
+- **SonarQube maintainability: 86% of issues resolved (6/7)**
 
 ### Coverage Summary
 
-**Current:** 78.67% (207 test functions, 2966 statements, 1056 branches)
+**Current:** 80.86% (620 tests, 3296 statements, 1088 branches)
 
 **Coverage by tier:**
 
 - Core algorithms: 89-100% ✅ (smoothing: 100%, filtering: 89%, analysis: 88-94%)
-- API/Integration: 72% ✅ (api.py)
-- CLI modules: 76-87% ✅ (dropjump: 87.17%, cmj: 76.12%)
+- API/Integration: 66% ✅ (api.py - improved with helper extraction)
+- CLI modules: 90-91% ✅ (dropjump: 90.24%, cmj: 91.26%)
 - Validation: 80-100% ✅ (validators, bounds)
-- Visualization: 10-36% ✅ (debug overlays - appropriate)
+- Kinematics: 92-93% ✅ (cmj: 92.25%, dropjump: 93.03%)
+- Visualization: 10-40% ✅ (debug overlays - appropriate)
 
 **Key metrics:**
 
-- All 519 tests pass
-- 0 type errors (pyright strict)
-- 0 linting errors (ruff)
-- 100% coverage on critical modules (smoothing, formatting, validation_bounds)
+- All 620 tests pass ✅
+- 0 type errors (pyright strict) ✅
+- 0 linting errors (ruff) ✅
+- 100% coverage on critical modules (smoothing, formatting, validation_bounds) ✅
 
 **Test Organization:**
 
@@ -227,6 +229,8 @@ View HTML report: `uv run pytest --cov-report=html && open htmlcov/index.html`
 ### Code Quality
 
 - **Duplication target:** < 3% (current: 2.96%)
+- **SonarQube maintainability:** 86% issues resolved
+- **Cognitive complexity:** Target ≤15 per function
 - **Check:** `npx jscpd src/kinemotion`
 
 **Principles:**
@@ -235,6 +239,13 @@ View HTML report: `uv run pytest --cov-report=html && open htmlcov/index.html`
 2. Use inheritance for shared behavior
 3. Create helper functions (testable, reusable)
 4. Use function composition (pass functions as parameters)
+5. Apply Extract Method pattern for complex functions (see recent refactoring)
+
+**Maintainability Patterns:**
+- Extract Method: Break down functions with complexity >15
+- Parameter Object: Bundle related parameters into dataclasses
+- Early Return: Reduce nesting by handling edge cases first
+- Helper Functions: Single Responsibility Principle for all helpers
 
 See [Testing Guide](docs/development/testing.md) for detailed duplication avoidance strategies.
 

{kinemotion-0.47.1 → kinemotion-0.47.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.47.1
+Version: 0.47.2
 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.47.1 → kinemotion-0.47.2}/backend/src/kinemotion_backend/telemetry.py

@@ -3,12 +3,13 @@
 Enables OpenTelemetry tracing and logging if OTEL_EXPORTER_OTLP_ENDPOINT is set.
 """
 
-import logging
 import os
 
 from fastapi import FastAPI
 
-logger = logging.getLogger(__name__)
+from kinemotion_backend.logging_config import get_logger
+
+logger = get_logger(__name__)
 
 
 def setup_telemetry(app: FastAPI) -> bool:

{kinemotion-0.47.1 → kinemotion-0.47.2}/pyproject.toml

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

{kinemotion-0.47.1 → kinemotion-0.47.2}/src/kinemotion/api.py

@@ -5,12 +5,18 @@ import time
 from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
 
 from .cmj.analysis import detect_cmj_phases
 from .cmj.debug_overlay import CMJDebugOverlayRenderer
 from .cmj.kinematics import CMJMetrics, calculate_cmj_metrics
 from .cmj.metrics_validator import CMJMetricsValidator
 from .core.auto_tuning import (
+    AnalysisParameters,
+    QualityPreset,
     analyze_video_sample,
     auto_tune_parameters,
 )
@@ -38,7 +44,7 @@ from .core.pipeline_utils import (
     process_videos_bulk_generic,
 )
 from .core.pose import PoseTracker
-from .core.quality import assess_jump_quality
+from .core.quality import QualityAssessment, assess_jump_quality
 from .core.timing import NULL_TIMER, PerformanceTimer, Timer
 from .core.video_io import VideoProcessor
 from .dropjump.analysis import (
@@ -78,6 +84,146 @@ class DropJumpVideoConfig:
     tracking_confidence: float | None = None
 
 
+def _assess_dropjump_quality(
+    vertical_positions: "NDArray",
+    visibilities: "NDArray",
+    contact_states: list,
+    fps: float,
+    timer: Timer,
+) -> tuple:
+    """Assess tracking quality and detect phases.
+
+    Returns:
+        Tuple of (quality_result, outlier_mask, phases_detected, phase_count)
+    """
+    _, outlier_mask = reject_outliers(
+        vertical_positions,
+        use_ransac=True,
+        use_median=True,
+        interpolate=False,
+    )
+
+    phases = find_contact_phases(contact_states)
+    phases_detected = len(phases) > 0
+    phase_count = len(phases)
+
+    quality_result = assess_jump_quality(
+        visibilities=visibilities,
+        positions=vertical_positions,
+        outlier_mask=outlier_mask,
+        fps=fps,
+        phases_detected=phases_detected,
+        phase_count=phase_count,
+    )
+
+    return quality_result, outlier_mask, phases_detected, phase_count
+
+
+def _build_dropjump_metadata(
+    video_path: str,
+    video: "VideoProcessor",
+    params: "AnalysisParameters",
+    quality_result: QualityAssessment,
+    drop_start_frame: int | None,
+    metrics: DropJumpMetrics,
+    processing_time: float,
+    quality_preset: "QualityPreset",
+    timer: Timer,
+) -> ResultMetadata:
+    """Build complete result metadata."""
+    drop_frame = None
+    if drop_start_frame is None and metrics.drop_start_frame is not None:
+        drop_frame = metrics.drop_start_frame
+    elif drop_start_frame is not None:
+        drop_frame = drop_start_frame
+
+    algorithm_config = AlgorithmConfig(
+        detection_method="forward_search",
+        tracking_method="mediapipe_pose",
+        model_complexity=1,
+        smoothing=SmoothingConfig(
+            window_size=params.smoothing_window,
+            polynomial_order=params.polyorder,
+            use_bilateral_filter=params.bilateral_filter,
+            use_outlier_rejection=params.outlier_rejection,
+        ),
+        detection=DetectionConfig(
+            velocity_threshold=params.velocity_threshold,
+            min_contact_frames=params.min_contact_frames,
+            visibility_threshold=params.visibility_threshold,
+            use_curvature_refinement=params.use_curvature,
+        ),
+        drop_detection=DropDetectionConfig(
+            auto_detect_drop_start=(drop_start_frame is None),
+            detected_drop_frame=drop_frame,
+            min_stationary_duration_s=0.5,
+        ),
+    )
+
+    video_info = VideoInfo(
+        source_path=video_path,
+        fps=video.fps,
+        width=video.width,
+        height=video.height,
+        duration_s=video.frame_count / video.fps,
+        frame_count=video.frame_count,
+        codec=video.codec,
+    )
+
+    stage_times = convert_timer_to_stage_names(timer.get_metrics())
+
+    processing_info = ProcessingInfo(
+        version=get_kinemotion_version(),
+        timestamp=create_timestamp(),
+        quality_preset=quality_preset.value,
+        processing_time_s=processing_time,
+        timing_breakdown=stage_times,
+    )
+
+    return ResultMetadata(
+        quality=quality_result,
+        video=video_info,
+        processing=processing_info,
+        algorithm=algorithm_config,
+    )
+
+
+def _save_dropjump_json(
+    json_output: str,
+    metrics: DropJumpMetrics,
+    timer: Timer,
+    verbose: bool,
+) -> None:
+    """Save metrics to JSON file."""
+    with timer.measure("json_serialization"):
+        output_path = Path(json_output)
+        metrics_dict = metrics.to_dict()
+        json_str = json.dumps(metrics_dict, indent=2)
+        output_path.write_text(json_str)
+
+    if verbose:
+        print(f"Metrics written to: {json_output}")
+
+
+def _print_dropjump_summary(
+    start_time: float,
+    timer: Timer,
+) -> None:
+    """Print verbose timing summary."""
+    total_time = time.time() - start_time
+    stage_times = convert_timer_to_stage_names(timer.get_metrics())
+
+    print("\n=== Timing Summary ===")
+    for stage, duration in stage_times.items():
+        percentage = (duration / total_time) * 100
+        dur_ms = duration * 1000
+        print(f"{stage:.<40} {dur_ms:>6.0f}ms ({percentage:>5.1f}%)")
+    total_ms = total_time * 1000
+    print(f"{('Total'):.>40} {total_ms:>6.0f}ms (100.0%)")
+    print()
+    print("Analysis complete!")
+
+
 def _generate_debug_video(
     output_video: str,
     frames: list,
@@ -281,65 +427,10 @@ def process_dropjump_video(
             if verbose:
                 print("Assessing tracking quality...")
             with timer.measure("quality_assessment"):
-                _, outlier_mask = reject_outliers(
-                    vertical_positions,
-                    use_ransac=True,
-                    use_median=True,
-                    interpolate=False,
-                )
-
-                phases = find_contact_phases(contact_states)
-                phases_detected = len(phases) > 0
-                phase_count = len(phases)
-
-                quality_result = assess_jump_quality(
-                    visibilities=visibilities,
-                    positions=vertical_positions,
-                    outlier_mask=outlier_mask,
-                    fps=video.fps,
-                    phases_detected=phases_detected,
-                    phase_count=phase_count,
+                quality_result, _, _, _ = _assess_dropjump_quality(
+                    vertical_positions, visibilities, contact_states, video.fps, timer
                 )
 
-            drop_frame = None
-            if drop_start_frame is None and metrics.drop_start_frame is not None:
-                drop_frame = metrics.drop_start_frame
-            elif drop_start_frame is not None:
-                drop_frame = drop_start_frame
-
-            algorithm_config = AlgorithmConfig(
-                detection_method="forward_search",
-                tracking_method="mediapipe_pose",
-                model_complexity=1,
-                smoothing=SmoothingConfig(
-                    window_size=params.smoothing_window,
-                    polynomial_order=params.polyorder,
-                    use_bilateral_filter=params.bilateral_filter,
-                    use_outlier_rejection=params.outlier_rejection,
-                ),
-                detection=DetectionConfig(
-                    velocity_threshold=params.velocity_threshold,
-                    min_contact_frames=params.min_contact_frames,
-                    visibility_threshold=params.visibility_threshold,
-                    use_curvature_refinement=params.use_curvature,
-                ),
-                drop_detection=DropDetectionConfig(
-                    auto_detect_drop_start=(drop_start_frame is None),
-                    detected_drop_frame=drop_frame,
-                    min_stationary_duration_s=0.5,
-                ),
-            )
-
-            video_info = VideoInfo(
-                source_path=video_path,
-                fps=video.fps,
-                width=video.width,
-                height=video.height,
-                duration_s=video.frame_count / video.fps,
-                frame_count=video.frame_count,
-                codec=video.codec,
-            )
-
             if verbose and quality_result.warnings:
                 print("\n⚠️  Quality Warnings:")
                 for warning in quality_result.warnings:
@@ -370,48 +461,24 @@ def process_dropjump_video(
                     print(f"  [{issue.severity.value}] {issue.metric}: {issue.message}")
 
             processing_time = time.time() - start_time
-            stage_times = convert_timer_to_stage_names(timer.get_metrics())
-
-            processing_info = ProcessingInfo(
-                version=get_kinemotion_version(),
-                timestamp=create_timestamp(),
-                quality_preset=quality_preset.value,
-                processing_time_s=processing_time,
-                timing_breakdown=stage_times,
-            )
-
-            result_metadata = ResultMetadata(
-                quality=quality_result,
-                video=video_info,
-                processing=processing_info,
-                algorithm=algorithm_config,
+            result_metadata = _build_dropjump_metadata(
+                video_path,
+                video,
+                params,
+                quality_result,
+                drop_start_frame,
+                metrics,
+                processing_time,
+                quality_preset,
+                timer,
             )
-
             metrics.result_metadata = result_metadata
 
             if json_output:
-                with timer.measure("json_serialization"):
-                    output_path = Path(json_output)
-                    metrics_dict = metrics.to_dict()
-                    json_str = json.dumps(metrics_dict, indent=2)
-                    output_path.write_text(json_str)
-
-                if verbose:
-                    print(f"Metrics written to: {json_output}")
+                _save_dropjump_json(json_output, metrics, timer, verbose)
 
             if verbose:
-                total_time = time.time() - start_time
-                stage_times_verbose = convert_timer_to_stage_names(timer.get_metrics())
-
-                print("\n=== Timing Summary ===")
-                for stage, duration in stage_times_verbose.items():
-                    percentage = (duration / total_time) * 100
-                    dur_ms = duration * 1000
-                    print(f"{stage:.<40} {dur_ms:>6.0f}ms ({percentage:>5.1f}%)")
-                total_ms = total_time * 1000
-                print(f"{('Total'):.>40} {total_ms:>6.0f}ms (100.0%)")
-                print()
-                print("Analysis complete!")
+                _print_dropjump_summary(start_time, timer)
 
             return metrics
 

{kinemotion-0.47.1 → kinemotion-0.47.2}/src/kinemotion/cmj/analysis.py

@@ -480,7 +480,7 @@ def compute_average_hip_position(
 def find_standing_end(
     velocities: np.ndarray,
     lowest_point: float,
-    positions: np.ndarray | None = None,
+    _positions: np.ndarray | None = None,
     accelerations: np.ndarray | None = None,
 ) -> float | None:
     """
@@ -493,7 +493,7 @@ def find_standing_end(
     Args:
         velocities: Signed velocity array (for backward compatibility)
         lowest_point: Frame index of lowest point
-        positions: Position array (unused, kept for backward compatibility)
+        _positions: Intentionally unused - kept for backward compatibility
         accelerations: Acceleration array (if provided, uses
             acceleration-based detection)