kinemotion 0.47.2__py3-none-any.whl → 0.47.4__py3-none-any.whl

kinemotion/dropjump/api.py

@@ -0,0 +1,541 @@
+"""Public API for drop jump video analysis."""
+
+import json
+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 ..core.auto_tuning import (
+    AnalysisParameters,
+    QualityPreset,
+    analyze_video_sample,
+    auto_tune_parameters,
+)
+from ..core.filtering import reject_outliers
+from ..core.metadata import (
+    AlgorithmConfig,
+    DetectionConfig,
+    DropDetectionConfig,
+    ProcessingInfo,
+    ResultMetadata,
+    SmoothingConfig,
+    VideoInfo,
+    create_timestamp,
+    get_kinemotion_version,
+)
+from ..core.pipeline_utils import (
+    apply_expert_overrides,
+    apply_smoothing,
+    convert_timer_to_stage_names,
+    determine_confidence_levels,
+    extract_vertical_positions,
+    parse_quality_preset,
+    print_verbose_parameters,
+    process_all_frames,
+    process_videos_bulk_generic,
+)
+from ..core.pose import PoseTracker
+from ..core.quality import QualityAssessment, assess_jump_quality
+from ..core.timing import NULL_TIMER, PerformanceTimer, Timer
+from ..core.video_io import VideoProcessor
+from .analysis import (
+    detect_ground_contact,
+    find_contact_phases,
+)
+from .debug_overlay import DebugOverlayRenderer
+from .kinematics import DropJumpMetrics, calculate_drop_jump_metrics
+from .metrics_validator import DropJumpMetricsValidator
+
+
+@dataclass
+class DropJumpVideoResult:
+    """Result of processing a single drop jump video."""
+
+    video_path: str
+    success: bool
+    metrics: DropJumpMetrics | None = None
+    error: str | None = None
+    processing_time: float = 0.0
+
+
+@dataclass
+class DropJumpVideoConfig:
+    """Configuration for processing a single drop jump video."""
+
+    video_path: str
+    quality: str = "balanced"
+    output_video: str | None = None
+    json_output: str | None = None
+    drop_start_frame: int | None = None
+    smoothing_window: int | None = None
+    velocity_threshold: float | None = None
+    min_contact_frames: int | None = None
+    visibility_threshold: float | None = None
+    detection_confidence: float | None = None
+    tracking_confidence: float | None = None
+
+
+def _assess_dropjump_quality(
+    vertical_positions: "NDArray",
+    visibilities: "NDArray",
+    contact_states: list,
+    fps: float,
+) -> 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,
+    frame_indices: list[int],
+    video_fps: float,
+    smoothed_landmarks: list,
+    contact_states: list,
+    metrics: DropJumpMetrics,
+    timer: Timer | None,
+    verbose: bool,
+) -> None:
+    """Generate debug video with overlay."""
+    if verbose:
+        print(f"Generating debug video: {output_video}")
+
+    if not frames:
+        return
+
+    timer = timer or NULL_TIMER
+    debug_h, debug_w = frames[0].shape[:2]
+
+    if video_fps > 30:
+        debug_fps = video_fps / (video_fps / 30.0)
+    else:
+        debug_fps = video_fps
+
+    if len(frames) < len(smoothed_landmarks):
+        step = max(1, int(video_fps / 30.0))
+        debug_fps = video_fps / step
+
+    def _render_frames(renderer: DebugOverlayRenderer) -> None:
+        for frame, idx in zip(frames, frame_indices, strict=True):
+            annotated = renderer.render_frame(
+                frame,
+                smoothed_landmarks[idx],
+                contact_states[idx],
+                idx,
+                metrics,
+                use_com=False,
+            )
+            renderer.write_frame(annotated)
+
+    renderer_context = DebugOverlayRenderer(
+        output_video,
+        debug_w,
+        debug_h,
+        debug_w,
+        debug_h,
+        debug_fps,
+        timer=timer,
+    )
+
+    with timer.measure("debug_video_generation"):
+        with renderer_context as renderer:
+            _render_frames(renderer)
+
+    if verbose:
+        print(f"Debug video saved: {output_video}")
+
+
+def process_dropjump_video(
+    video_path: str,
+    quality: str = "balanced",
+    output_video: str | None = None,
+    json_output: str | None = None,
+    drop_start_frame: int | None = None,
+    smoothing_window: int | None = None,
+    velocity_threshold: float | None = None,
+    min_contact_frames: int | None = None,
+    visibility_threshold: float | None = None,
+    detection_confidence: float | None = None,
+    tracking_confidence: float | None = None,
+    verbose: bool = False,
+    timer: Timer | None = None,
+    pose_tracker: "PoseTracker | None" = None,
+) -> DropJumpMetrics:
+    """
+    Process a single drop jump video and return metrics.
+
+    Jump height is calculated from flight time using kinematic formula (h = g*t²/8).
+
+    Args:
+        video_path: Path to the input video file
+        quality: Analysis quality preset ("fast", "balanced", or "accurate")
+        output_video: Optional path for debug video output
+        json_output: Optional path for JSON metrics output
+        drop_start_frame: Optional manual drop start frame
+        smoothing_window: Optional override for smoothing window
+        velocity_threshold: Optional override for velocity threshold
+        min_contact_frames: Optional override for minimum contact frames
+        visibility_threshold: Optional override for visibility threshold
+        detection_confidence: Optional override for pose detection confidence
+        tracking_confidence: Optional override for pose tracking confidence
+        verbose: Print processing details
+        timer: Optional Timer for measuring operations
+        pose_tracker: Optional pre-initialized PoseTracker instance (reused if provided)
+
+    Returns:
+        DropJumpMetrics object containing analysis results
+
+    Raises:
+        ValueError: If video cannot be processed or parameters are invalid
+        FileNotFoundError: If video file does not exist
+    """
+    if not Path(video_path).exists():
+        raise FileNotFoundError(f"Video file not found: {video_path}")
+
+    from ..core.determinism import set_deterministic_mode
+
+    set_deterministic_mode(seed=42)
+
+    start_time = time.time()
+    if timer is None:
+        timer = PerformanceTimer()
+
+    quality_preset = parse_quality_preset(quality)
+
+    with timer.measure("video_initialization"):
+        with VideoProcessor(video_path, timer=timer) as video:
+            detection_conf, tracking_conf = determine_confidence_levels(
+                quality_preset, detection_confidence, tracking_confidence
+            )
+
+            if verbose:
+                print("Processing all frames with MediaPipe pose tracking...")
+
+            tracker = pose_tracker
+            should_close_tracker = False
+
+            if tracker is None:
+                tracker = PoseTracker(
+                    min_detection_confidence=detection_conf,
+                    min_tracking_confidence=tracking_conf,
+                    timer=timer,
+                )
+                should_close_tracker = True
+
+            frames, landmarks_sequence, frame_indices = process_all_frames(
+                video, tracker, verbose, timer, close_tracker=should_close_tracker
+            )
+
+            with timer.measure("parameter_auto_tuning"):
+                characteristics = analyze_video_sample(
+                    landmarks_sequence, video.fps, video.frame_count
+                )
+                params = auto_tune_parameters(characteristics, quality_preset)
+
+                params = apply_expert_overrides(
+                    params,
+                    smoothing_window,
+                    velocity_threshold,
+                    min_contact_frames,
+                    visibility_threshold,
+                )
+
+                if verbose:
+                    print_verbose_parameters(
+                        video, characteristics, quality_preset, params
+                    )
+
+            smoothed_landmarks = apply_smoothing(
+                landmarks_sequence, params, verbose, timer
+            )
+
+            if verbose:
+                print("Extracting foot positions...")
+            with timer.measure("vertical_position_extraction"):
+                vertical_positions, visibilities = extract_vertical_positions(
+                    smoothed_landmarks
+                )
+
+            if verbose:
+                print("Detecting ground contact...")
+            with timer.measure("ground_contact_detection"):
+                contact_states = detect_ground_contact(
+                    vertical_positions,
+                    velocity_threshold=params.velocity_threshold,
+                    min_contact_frames=params.min_contact_frames,
+                    visibility_threshold=params.visibility_threshold,
+                    visibilities=visibilities,
+                    window_length=params.smoothing_window,
+                    polyorder=params.polyorder,
+                    timer=timer,
+                )
+
+            if verbose:
+                print("Calculating metrics...")
+            with timer.measure("metrics_calculation"):
+                metrics = calculate_drop_jump_metrics(
+                    contact_states,
+                    vertical_positions,
+                    video.fps,
+                    drop_start_frame=drop_start_frame,
+                    velocity_threshold=params.velocity_threshold,
+                    smoothing_window=params.smoothing_window,
+                    polyorder=params.polyorder,
+                    use_curvature=params.use_curvature,
+                    timer=timer,
+                )
+
+            if verbose:
+                print("Assessing tracking quality...")
+            with timer.measure("quality_assessment"):
+                quality_result, _, _, _ = _assess_dropjump_quality(
+                    vertical_positions, visibilities, contact_states, video.fps
+                )
+
+            if verbose and quality_result.warnings:
+                print("\n⚠️  Quality Warnings:")
+                for warning in quality_result.warnings:
+                    print(f"  - {warning}")
+                print()
+
+            if output_video:
+                _generate_debug_video(
+                    output_video,
+                    frames,
+                    frame_indices,
+                    video.fps,
+                    smoothed_landmarks,
+                    contact_states,
+                    metrics,
+                    timer,
+                    verbose,
+                )
+
+            with timer.measure("metrics_validation"):
+                validator = DropJumpMetricsValidator()
+                validation_result = validator.validate(metrics.to_dict())  # type: ignore[arg-type]
+                metrics.validation_result = validation_result
+
+            if verbose and validation_result.issues:
+                print("\n⚠️  Validation Results:")
+                for issue in validation_result.issues:
+                    print(f"  [{issue.severity.value}] {issue.metric}: {issue.message}")
+
+            processing_time = time.time() - start_time
+            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:
+                _save_dropjump_json(json_output, metrics, timer, verbose)
+
+            if verbose:
+                _print_dropjump_summary(start_time, timer)
+
+            return metrics
+
+
+def process_dropjump_videos_bulk(
+    configs: list[DropJumpVideoConfig],
+    max_workers: int = 4,
+    progress_callback: Callable[[DropJumpVideoResult], None] | None = None,
+) -> list[DropJumpVideoResult]:
+    """
+    Process multiple drop jump videos in parallel.
+    """
+
+    def error_factory(video_path: str, error_msg: str) -> DropJumpVideoResult:
+        return DropJumpVideoResult(
+            video_path=video_path, success=False, error=error_msg
+        )
+
+    return process_videos_bulk_generic(
+        configs,
+        _process_dropjump_video_wrapper,
+        error_factory,
+        max_workers,
+        progress_callback,
+    )
+
+
+def _process_dropjump_video_wrapper(config: DropJumpVideoConfig) -> DropJumpVideoResult:
+    """Wrapper function for parallel processing."""
+    start_time = time.time()
+
+    try:
+        metrics = process_dropjump_video(
+            video_path=config.video_path,
+            quality=config.quality,
+            output_video=config.output_video,
+            json_output=config.json_output,
+            drop_start_frame=config.drop_start_frame,
+            smoothing_window=config.smoothing_window,
+            velocity_threshold=config.velocity_threshold,
+            min_contact_frames=config.min_contact_frames,
+            visibility_threshold=config.visibility_threshold,
+            detection_confidence=config.detection_confidence,
+            tracking_confidence=config.tracking_confidence,
+            verbose=False,
+        )
+
+        processing_time = time.time() - start_time
+
+        return DropJumpVideoResult(
+            video_path=config.video_path,
+            success=True,
+            metrics=metrics,
+            processing_time=processing_time,
+        )
+
+    except Exception as e:
+        processing_time = time.time() - start_time
+
+        return DropJumpVideoResult(
+            video_path=config.video_path,
+            success=False,
+            error=str(e),
+            processing_time=processing_time,
+        )

kinemotion/dropjump/cli.py

@@ -8,16 +8,16 @@ from pathlib import Path
 
 import click
 
-from ..api import (
+from ..core.cli_utils import (
+    collect_video_files,
+    generate_batch_output_paths,
+)
+from .api import (
     DropJumpVideoConfig,
     DropJumpVideoResult,
     process_dropjump_video,
     process_dropjump_videos_bulk,
 )
-from ..core.cli_utils import (
-    collect_video_files,
-    generate_batch_output_paths,
-)
 
 
 @dataclass

{kinemotion-0.47.2.dist-info → kinemotion-0.47.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.47.2
+Version: 0.47.4
 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.2.dist-info → kinemotion-0.47.4.dist-info}/RECORD

@@ -1,15 +1,16 @@
 kinemotion/__init__.py,sha256=wPItmyGJUOFM6GPRVhAEvRz0-ErI7e2qiUREYJ9EfPQ,943
-kinemotion/api.py,sha256=vqr3IZPQhvAMgNI0WbU295ufXRJ8-tu638KojF_upaI,32153
+kinemotion/api.py,sha256=uj3py8jXuG3mYnmsZQnzuCQtWrO4O6gvZzGAMfZne4o,891
 kinemotion/cli.py,sha256=cqYV_7URH0JUDy1VQ_EDLv63FmNO4Ns20m6s1XAjiP4,464
-kinemotion/cmj/__init__.py,sha256=Ynv0-Oco4I3Y1Ubj25m3h9h2XFqeNwpAewXmAYOmwfU,127
+kinemotion/cmj/__init__.py,sha256=SkAw9ka8Yd1Qfv9hcvk22m3EfucROzYrSNGNF5kDzho,113
 kinemotion/cmj/analysis.py,sha256=3l0vYQB9tN4HtEO2MPFHVtrdzSmXgwpCm03qzYLCF0c,22196
-kinemotion/cmj/cli.py,sha256=HpZgLWoLjcgsfOZu6EQ_26tg6QwTgFjR-Ly8WCBg24c,9904
+kinemotion/cmj/api.py,sha256=MLyc4pkzK8wdSI5-pZ5ekfcI9MDwySknAqOUWxWCT9s,16895
+kinemotion/cmj/cli.py,sha256=S4-3YmaCjtGutDwjG475h8nIiw5utiLg5L6hCGfLOHY,9926
 kinemotion/cmj/debug_overlay.py,sha256=fXmWoHhqMLGo4vTtB6Ezs3yLUDOLw63zLIgU2gFlJQU,15892
 kinemotion/cmj/joint_angles.py,sha256=HmheIEiKcQz39cRezk4h-htorOhGNPsqKIR9RsAEKts,9960
 kinemotion/cmj/kinematics.py,sha256=Q-L8M7wG-MJ6EJTq6GO17c8sD5cb0Jg6Hc5vUZr14bA,13673
 kinemotion/cmj/metrics_validator.py,sha256=JAakR4RgNvUc7GM9Aj2TQrtatYpCCCGSzkBMXOldKjw,31455
 kinemotion/cmj/validation_bounds.py,sha256=9ZTo68fl3ooyWjXXyTMRLpK9tFANa_rQf3oHhq7iQGE,11995
-kinemotion/core/__init__.py,sha256=rBIEx9sW6E-nyVdWmoVGJYhfPikLukoDp7lxKri7RTQ,1543
+kinemotion/core/__init__.py,sha256=U2fnLUGXQ0jbwpXhdksYKDXbeQndEHjn9gwTAEJ9Av0,1451
 kinemotion/core/auto_tuning.py,sha256=wtCUMOhBChVJNXfEeku3GCMW4qED6MF-O_mv2sPTiVQ,11324
 kinemotion/core/cli_utils.py,sha256=sQPbT6XWWau-sm9yuN5c3eS5xNzoQGGXwSz6hQXtRvM,1859
 kinemotion/core/debug_overlay_utils.py,sha256=-goE3w4gBij99y1U4ckU5iaQPS0SupcHplT04DDWzUo,8579
@@ -22,19 +23,20 @@ kinemotion/core/pipeline_utils.py,sha256=0u7o-UFZX6cOu3NaWpFmEy5ejS0WUKggZ1HSdeZ
 kinemotion/core/pose.py,sha256=z1OGuwnc-NdK6Aoc9UYCyPBzomw4eInexOWonZbsEoA,9057
 kinemotion/core/quality.py,sha256=dPGQp08y8DdEUbUdjTThnUOUsALgF0D2sdz50cm6wLI,13098
 kinemotion/core/smoothing.py,sha256=FZmv3rumn0mYKU2y3JPKz46EvD8TVmQ6_GsN_Vp3BdU,15650
-kinemotion/core/timing.py,sha256=8DJLtyQIGA0BKT07A2b32OHi1cdGQAoX5ahjGt17vlI,12113
+kinemotion/core/timing.py,sha256=d1rjZc07Nbi5Jrio9AC-zeS0dNAlbPyNIydLz7X75Pk,7804
 kinemotion/core/validation.py,sha256=LmKfSl4Ayw3DgwKD9IrhsPdzp5ia4drLsHA2UuU1SCM,6310
 kinemotion/core/video_io.py,sha256=vCwpWnlW2y29l48dFXokdehQn42w_IQvayxbVTjpXqQ,7863
 kinemotion/dropjump/__init__.py,sha256=tC3H3BrCg8Oj-db-Vrtx4PH_llR1Ppkd5jwaOjhQcLg,862
 kinemotion/dropjump/analysis.py,sha256=p7nnCe7V6vnhQKZVYk--_nhsTvVa_WY-A3zXmyplsew,28211
-kinemotion/dropjump/cli.py,sha256=eLIA0rnx60vqD__PinB1-5nQ8_xQUhCGplwsB0u9MgU,15824
+kinemotion/dropjump/api.py,sha256=9tetwjoFdY7Z8PqXpNfaS96L9YVqEkJl7jejGnewhbE,17517
+kinemotion/dropjump/cli.py,sha256=pPQkjpuPUUefGcsRuMvRTtjsxpPSqSgQ9K49rsN_X_o,15823
 kinemotion/dropjump/debug_overlay.py,sha256=8XVuDyZ3nuNoCYkxcUWC7wyEoHyBxx77Sb--B1KiYWw,5974
 kinemotion/dropjump/kinematics.py,sha256=PATlGaClutGKJslL-LRIXHmTsvb-xEB8PUIMScU_K4c,19849
 kinemotion/dropjump/metrics_validator.py,sha256=CrTlGup8q2kyPXtA6HNwm7_yq0AsBaDllG7RVZdXmYA,9342
 kinemotion/dropjump/validation_bounds.py,sha256=fyl04ZV7nfvHkL5eob6oEpV9Hxce6aiOWQ9pclLp7AQ,5077
 kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kinemotion-0.47.2.dist-info/METADATA,sha256=j1rpZaKZM8ANWsND2jaj7JrDSvDfdHUiFJnn6EfqpoY,26020
-kinemotion-0.47.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-kinemotion-0.47.2.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.47.2.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.47.2.dist-info/RECORD,,
+kinemotion-0.47.4.dist-info/METADATA,sha256=-N2sOXvyGeykCej_Uq07hmu51025vrRF8EUFEiO5kVI,26020
+kinemotion-0.47.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kinemotion-0.47.4.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.47.4.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.47.4.dist-info/RECORD,,