kinemotion 0.10.1__tar.gz → 0.10.2__tar.gz

{kinemotion-0.10.1 → kinemotion-0.10.2}/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- version list -->
 
+## v0.10.2 (2025-11-03)
+
+### Bug Fixes
+
+- Replace legacy numpy random functions with Generator API
+  ([`5cfa31b`](https://github.com/feniix/kinemotion/commit/5cfa31bce040eadfc53d52654c2e75087ef087a5))
+
+
 ## v0.10.1 (2025-11-03)
 
 ### Bug Fixes

{kinemotion-0.10.1 → kinemotion-0.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.10.1
+Version: 0.10.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.10.1 → kinemotion-0.10.2}/pyproject.toml

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

{kinemotion-0.10.1 → kinemotion-0.10.2}/tests/test_adaptive_threshold.py

@@ -14,8 +14,8 @@ def test_adaptive_threshold_basic() -> None:
     baseline_frames = int(3 * fps)  # 90 frames
 
     # Baseline: small random noise around position 0.5
-    np.random.seed(42)
-    baseline_positions = 0.5 + np.random.normal(0, 0.005, baseline_frames)
+    rng = np.random.default_rng(42)
+    baseline_positions = 0.5 + rng.normal(0, 0.005, baseline_frames)
 
     # Movement: larger position changes
     movement_positions = np.linspace(0.5, 0.7, 60)
@@ -36,8 +36,8 @@ def test_adaptive_threshold_high_noise() -> None:
     baseline_frames = int(3 * fps)
 
     # High noise baseline
-    np.random.seed(42)
-    baseline_positions = 0.5 + np.random.normal(0, 0.015, baseline_frames)
+    rng = np.random.default_rng(42)
+    baseline_positions = 0.5 + rng.normal(0, 0.015, baseline_frames)
     movement_positions = np.linspace(0.5, 0.8, 60)
     positions = np.concatenate([baseline_positions, movement_positions])
 
@@ -56,8 +56,8 @@ def test_adaptive_threshold_low_noise() -> None:
     baseline_frames = int(3 * fps)
 
     # Very low noise baseline
-    np.random.seed(42)
-    baseline_positions = 0.5 + np.random.normal(0, 0.002, baseline_frames)
+    rng = np.random.default_rng(42)
+    baseline_positions = 0.5 + rng.normal(0, 0.002, baseline_frames)
     movement_positions = np.linspace(0.5, 0.7, 60)
     positions = np.concatenate([baseline_positions, movement_positions])
 
@@ -90,8 +90,8 @@ def test_adaptive_threshold_maximum_bound() -> None:
     baseline_frames = int(3 * fps)
 
     # Extreme noise baseline
-    np.random.seed(42)
-    baseline_positions = 0.5 + np.random.normal(0, 0.05, baseline_frames)
+    rng = np.random.default_rng(42)
+    baseline_positions = 0.5 + rng.normal(0, 0.05, baseline_frames)
     movement_positions = np.linspace(0.5, 0.8, 60)
     positions = np.concatenate([baseline_positions, movement_positions])
 
@@ -106,7 +106,8 @@ def test_adaptive_threshold_short_video() -> None:
     fps = 30.0
 
     # Only 60 frames (2 seconds) - less than 3 second baseline
-    positions = 0.5 + np.random.normal(0, 0.01, 60)
+    rng = np.random.default_rng(42)
+    positions = 0.5 + rng.normal(0, 0.01, 60)
 
     threshold = calculate_adaptive_threshold(positions, fps, baseline_duration=3.0)
 
@@ -137,8 +138,8 @@ def test_adaptive_threshold_different_fps() -> None:
     fps = 60.0
     baseline_frames = int(3 * fps)  # 180 frames
 
-    np.random.seed(42)
-    baseline_positions = 0.5 + np.random.normal(0, 0.008, baseline_frames)
+    rng = np.random.default_rng(42)
+    baseline_positions = 0.5 + rng.normal(0, 0.008, baseline_frames)
     movement_positions = np.linspace(0.5, 0.7, 120)
     positions = np.concatenate([baseline_positions, movement_positions])
 
@@ -153,8 +154,8 @@ def test_adaptive_threshold_custom_multiplier() -> None:
     fps = 30.0
     baseline_frames = int(3 * fps)
 
-    np.random.seed(42)
-    baseline_positions = 0.5 + np.random.normal(0, 0.005, baseline_frames)
+    rng = np.random.default_rng(42)
+    baseline_positions = 0.5 + rng.normal(0, 0.008, baseline_frames)
     movement_positions = np.linspace(0.5, 0.7, 60)
     positions = np.concatenate([baseline_positions, movement_positions])
 
@@ -181,9 +182,9 @@ def test_adaptive_threshold_baseline_duration() -> None:
     fps = 30.0
 
     # Long video with different noise in different sections
-    np.random.seed(42)
-    first_3s = 0.5 + np.random.normal(0, 0.005, int(3 * fps))  # Low noise
-    next_2s = 0.5 + np.random.normal(0, 0.015, int(2 * fps))  # High noise
+    rng = np.random.default_rng(42)
+    first_3s = 0.5 + rng.normal(0, 0.005, int(3 * fps))  # Low noise
+    next_2s = 0.5 + rng.normal(0, 0.015, int(2 * fps))  # High noise
     movement = np.linspace(0.5, 0.7, 60)
 
     positions = np.concatenate([first_3s, next_2s, movement])

{kinemotion-0.10.1 → kinemotion-0.10.2}/tests/test_aspect_ratio.py

@@ -21,9 +21,10 @@ def create_test_video(
     fourcc = cv2.VideoWriter_fourcc(*"mp4v")
     writer = cv2.VideoWriter(temp_path, fourcc, fps, (width, height))
 
+    rng = np.random.default_rng(42)
     for _ in range(num_frames):
         # Create a random frame
-        frame = np.random.randint(0, 255, (height, width, 3), dtype=np.uint8)
+        frame = rng.integers(0, 255, (height, width, 3), dtype=np.uint8)
         writer.write(frame)
 
     writer.release()

{kinemotion-0.10.1 → kinemotion-0.10.2}/tests/test_filtering.py

@@ -35,8 +35,9 @@ def test_detect_outliers_ransac_finds_glitches() -> None:
 def test_detect_outliers_ransac_handles_clean_data() -> None:
     """Test that RANSAC does not flag valid points as outliers."""
     # Create smooth motion with small noise
+    rng = np.random.default_rng(42)
     positions = np.array([0.5 + 0.001 * i**2 for i in range(30)])
-    positions += np.random.normal(0, 0.001, 30)  # Small noise
+    positions += rng.normal(0, 0.001, 30)  # Small noise
 
     outliers = detect_outliers_ransac(
         positions, window_size=15, threshold=0.02, min_inliers=0.7
@@ -220,8 +221,9 @@ def test_bilateral_temporal_filter_preserves_edges() -> None:
 def test_bilateral_temporal_filter_smooths_noise() -> None:
     """Test that bilateral filter smooths noise within smooth regions."""
     # Noisy flat region
+    rng = np.random.default_rng(42)
     positions = np.array([0.5] * 30)
-    positions += np.random.normal(0, 0.01, 30)
+    positions += rng.normal(0, 0.01, 30)
 
     filtered = bilateral_temporal_filter(
         positions, window_size=9, sigma_spatial=3.0, sigma_intensity=0.02
@@ -233,7 +235,8 @@ def test_bilateral_temporal_filter_smooths_noise() -> None:
 
 def test_bilateral_temporal_filter_window_size() -> None:
     """Test that bilateral filter handles even window sizes."""
-    positions = np.random.rand(50)
+    rng = np.random.default_rng(42)
+    positions = rng.random(50)
 
     # Even window size should be adjusted to odd
     filtered_even = bilateral_temporal_filter(
@@ -284,10 +287,11 @@ def test_smooth_landmarks_advanced_with_bilateral() -> None:
     # Create landmark sequence with sharp transition (landing)
     n_frames = 40
     landmark_sequence = []
+    rng = np.random.default_rng(42)
 
     for i in range(n_frames):
         y = 0.8 if i < 20 else 0.5  # Sharp drop at frame 20
-        y += np.random.normal(0, 0.005)  # Add noise
+        y += rng.normal(0, 0.005)  # Add noise
 
         landmark_sequence.append(
             {
@@ -322,10 +326,11 @@ def test_smooth_landmarks_advanced_combined() -> None:
     n_frames = 50
     landmark_sequence = []
 
+    rng = np.random.default_rng(42)
     for i in range(n_frames):
         # Parabolic motion
         y = 0.5 + 0.001 * (i - 25) ** 2
-        y += np.random.normal(0, 0.005)  # Noise
+        y += rng.normal(0, 0.005)  # Noise
 
         # Add tracking glitch
         if i == 25:

{kinemotion-0.10.1 → kinemotion-0.10.2}/tests/test_polyorder.py

@@ -15,10 +15,11 @@ def test_smooth_landmarks_polyorder2_vs_polyorder3() -> None:
     n_frames = 30
     landmark_sequence = []
 
+    rng = np.random.default_rng(42)
     for i in range(n_frames):
         # Smooth parabolic motion with noise
         base_y = 0.5 + 0.01 * (i - 15) ** 2 / 225  # Parabola
-        noisy_y = base_y + np.random.normal(0, 0.01)
+        noisy_y = base_y + rng.normal(0, 0.01)
 
         landmark_sequence.append(
             {
@@ -49,9 +50,10 @@ def test_smooth_landmarks_polyorder2_vs_polyorder3() -> None:
 def test_velocity_from_derivative_polyorder() -> None:
     """Test velocity computation with different polynomial orders."""
     # Create synthetic position data with quadratic motion
+    rng = np.random.default_rng(42)
     t = np.linspace(0, 2, 60)
     positions = 0.5 + 0.1 * t**2  # Parabolic trajectory
-    positions += np.random.normal(0, 0.005, len(positions))  # Add noise
+    positions += rng.normal(0, 0.005, len(positions))  # Add noise
 
     # Compute velocity with different polynomial orders
     velocity_2 = compute_velocity_from_derivative(
@@ -79,9 +81,10 @@ def test_velocity_from_derivative_polyorder() -> None:
 def test_acceleration_from_derivative_polyorder() -> None:
     """Test acceleration computation with different polynomial orders."""
     # Create synthetic position data with cubic motion (non-zero third derivative)
+    rng = np.random.default_rng(42)
     t = np.linspace(0, 2, 60)
     positions = 0.5 + 0.05 * t**3  # Cubic trajectory
-    positions += np.random.normal(0, 0.003, len(positions))  # Add noise
+    positions += rng.normal(0, 0.003, len(positions))  # Add noise
 
     # Compute acceleration with different polynomial orders
     accel_2 = compute_acceleration_from_derivative(
@@ -111,7 +114,8 @@ def test_acceleration_from_derivative_polyorder() -> None:
 
 def test_polyorder_validation() -> None:
     """Test that polyorder must be less than window_length."""
-    positions = np.random.rand(50)
+    rng = np.random.default_rng(42)
+    positions = rng.random(50)
 
     # polyorder=2 with window=5 should work (2 < 5)
     velocity_valid = compute_velocity_from_derivative(

{kinemotion-0.10.1 → kinemotion-0.10.2}/uv.lock

@@ -603,7 +603,7 @@ wheels = [
 
 [[package]]
 name = "kinemotion"
-version = "0.10.0"
+version = "0.10.1"
 source = { editable = "." }
 dependencies = [
     { name = "click" },

{kinemotion-0.10.1 → kinemotion-0.10.2}/Dockerfile

@@ -53,10 +53,10 @@ LABEL org.opencontainers.image.title="kinemotion" \
 # - ffmpeg: Video codec support for OpenCV
 # hadolint ignore=DL3008
 RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg \
     libgl1 \
     libglib2.0-0 \
     libgomp1 \
-    ffmpeg \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*