syncnet-python 0.2.1__tar.gz → 0.2.2__tar.gz

{syncnet_python-0.2.1 → syncnet_python-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncnet-python
-Version: 0.2.1
+Version: 0.2.2
 Summary: SyncNet: Audio-visual synchronization detection using deep learning. Updated version of https://github.com/joonson/syncnet_python for modern Python versions.
 Author: SyncNet Python Contributors
 Maintainer: SyncNet Python Contributors
@@ -49,7 +49,6 @@ Dynamic: license-file
 
 [![PyPI version](https://badge.fury.io/py/syncnet-python.svg)](https://badge.fury.io/py/syncnet-python)
 [![Python](https://img.shields.io/pypi/pyversions/syncnet-python.svg)](https://pypi.org/project/syncnet-python/)
-[![Downloads](https://pepy.tech/badge/syncnet-python)](https://pepy.tech/project/syncnet-python)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 Audio-visual synchronization detection using deep learning with modern Python architecture.

{syncnet_python-0.2.1 → syncnet_python-0.2.2}/README.md

@@ -2,7 +2,6 @@
 
 [![PyPI version](https://badge.fury.io/py/syncnet-python.svg)](https://badge.fury.io/py/syncnet-python)
 [![Python](https://img.shields.io/pypi/pyversions/syncnet-python.svg)](https://pypi.org/project/syncnet-python/)
-[![Downloads](https://pepy.tech/badge/syncnet-python)](https://pepy.tech/project/syncnet-python)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 Audio-visual synchronization detection using deep learning with modern Python architecture.
@@ -167,4 +166,4 @@ MIT License - see LICENSE file for details.
 
 - GitHub: https://github.com/yourusername/syncnet-python
 - Documentation: https://syncnet-python.readthedocs.io
-- Issues: https://github.com/yourusername/syncnet-python/issues
+- Issues: https://github.com/yourusername/syncnet-python/issues

{syncnet_python-0.2.1 → syncnet_python-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "syncnet-python"
-version = "0.2.1"
+version = "0.2.2"
 description = "SyncNet: Audio-visual synchronization detection using deep learning. Updated version of https://github.com/joonson/syncnet_python for modern Python versions."
 readme = "README.md"
 requires-python = ">=3.9"

{syncnet_python-0.2.1 → syncnet_python-0.2.2}/syncnet_python/__init__.py

@@ -4,23 +4,34 @@ This package provides a PyTorch implementation of SyncNet for detecting
 synchronization between audio and video in multimedia content.
 """
 
-__version__ = "0.1.1"
+__version__ = "0.2.2"
 
 # Import main components
 try:
     from .syncnet_pipeline import SyncNetPipeline
     from .SyncNetModel import S as SyncNetModel
     from .SyncNetInstance import SyncNetInstance
+    from .safe_syncnet_utils import (
+        safe_syncnet_inference,
+        extract_audio_from_video,
+        calculate_lse_metrics
+    )
 except ImportError:
     # Fallback for development
     SyncNetPipeline = None
     SyncNetModel = None
     SyncNetInstance = None
+    safe_syncnet_inference = None
+    extract_audio_from_video = None
+    calculate_lse_metrics = None
 
 __all__ = [
     "SyncNetPipeline",
     "SyncNetModel", 
     "SyncNetInstance",
+    "safe_syncnet_inference",
+    "extract_audio_from_video", 
+    "calculate_lse_metrics",
     "__version__"
 ]
 

syncnet_python-0.2.2/syncnet_python/safe_syncnet_utils.py

@@ -0,0 +1,154 @@
+"""Safe SyncNet utilities with comprehensive error handling."""
+
+import logging
+import tempfile
+import os
+from pathlib import Path
+from typing import Optional, Tuple, List
+try:
+    from .syncnet_pipeline import SyncNetPipeline
+except ImportError:
+    from syncnet_pipeline import SyncNetPipeline
+
+
+def safe_syncnet_inference(
+    pipeline: SyncNetPipeline,
+    video_path: str,
+    audio_path: Optional[str] = None,
+    cache_dir: Optional[str] = None
+) -> Tuple[List[int], List[float], List[float], float, float, str, bool]:
+    """
+    Safe SyncNet inference with automatic audio extraction if needed.
+    
+    This function provides a wrapper around SyncNetPipeline.inference() that:
+    1. Handles audio_path=None by automatically extracting audio from video
+    2. Provides comprehensive error handling and logging
+    3. Ensures proper cleanup of temporary files
+    
+    Args:
+        pipeline: Initialized SyncNetPipeline instance
+        video_path: Path to input video file
+        audio_path: Path to audio file (None for auto-extraction from video)
+        cache_dir: Directory for temporary files (None for auto-cleanup)
+        
+    Returns:
+        Tuple of (offsets, confidences, distances, max_conf, min_dist, s3fd_json, has_face)
+        
+    Raises:
+        RuntimeError: If processing fails at any stage
+        FileNotFoundError: If video file doesn't exist
+        ValueError: If video format is not supported
+    """
+    if not os.path.exists(video_path):
+        raise FileNotFoundError(f"Video file not found: {video_path}")
+    
+    if audio_path and not os.path.exists(audio_path):
+        raise FileNotFoundError(f"Audio file not found: {audio_path}")
+    
+    logging.info(f"Starting safe SyncNet inference for video: {video_path}")
+    
+    try:
+        # Use the updated inference method that handles audio_path=None
+        results = pipeline.inference(
+            video_path=video_path,
+            audio_path=audio_path,
+            cache_dir=cache_dir
+        )
+        
+        offsets, confs, dists, max_conf, min_dist, s3fd_json, has_face = results
+        
+        # Validate results
+        if not has_face:
+            logging.warning("No faces detected in the video")
+        elif not offsets:
+            logging.warning("No valid face tracks found")
+        else:
+            logging.info(f"Successfully processed {len(offsets)} face tracks")
+            logging.info(f"LSE-C (max confidence): {max_conf:.3f}")
+            logging.info(f"LSE-D (min distance): {min_dist:.3f}")
+        
+        return results
+        
+    except Exception as e:
+        logging.error(f"SyncNet inference failed: {str(e)}")
+        raise RuntimeError(f"SyncNet processing failed: {str(e)}") from e
+
+
+def extract_audio_from_video(video_path: str, audio_path: str) -> None:
+    """
+    Extract audio from video file using ffmpeg.
+    
+    Args:
+        video_path: Path to input video file
+        audio_path: Path for output audio file
+        
+    Raises:
+        RuntimeError: If audio extraction fails
+        FileNotFoundError: If video file doesn't exist
+    """
+    if not os.path.exists(video_path):
+        raise FileNotFoundError(f"Video file not found: {video_path}")
+    
+    # Create a temporary pipeline instance just for audio extraction
+    pipeline = SyncNetPipeline()
+    
+    try:
+        pipeline._extract_audio_from_video(video_path, audio_path)
+        logging.info(f"Successfully extracted audio from {video_path} to {audio_path}")
+    except Exception as e:
+        logging.error(f"Audio extraction failed: {str(e)}")
+        raise RuntimeError(f"Audio extraction failed: {str(e)}") from e
+
+
+def calculate_lse_metrics(
+    pipeline: SyncNetPipeline,
+    video_path: str,
+    audio_path: Optional[str] = None,
+    cache_dir: Optional[str] = None
+) -> Tuple[float, float, str]:
+    """
+    Calculate LSE-C and LSE-D metrics for a video.
+    
+    Args:
+        pipeline: Initialized SyncNetPipeline instance
+        video_path: Path to input video file
+        audio_path: Path to audio file (None for auto-extraction)
+        cache_dir: Directory for temporary files
+        
+    Returns:
+        Tuple of (lse_c, lse_d, quality_assessment)
+        
+    Raises:
+        RuntimeError: If metric calculation fails
+    """
+    try:
+        results = safe_syncnet_inference(pipeline, video_path, audio_path, cache_dir)
+        offsets, confs, dists, max_conf, min_dist, s3fd_json, has_face = results
+        
+        if not has_face:
+            return 0.0, float('inf'), "NO_FACE"
+        
+        if not confs or not dists:
+            return 0.0, float('inf'), "NO_TRACKS"
+        
+        # LSE-C is the maximum confidence across all tracks
+        lse_c = max_conf
+        
+        # LSE-D is the minimum distance across all tracks  
+        lse_d = min_dist
+        
+        # Quality assessment based on typical thresholds
+        if lse_c > 3.5 and lse_d < 7.0:
+            quality = "GOOD"
+        elif lse_c > 2.0 and lse_d < 10.0:
+            quality = "FAIR"
+        else:
+            quality = "POOR"
+        
+        logging.info(f"LSE Metrics - C: {lse_c:.3f}, D: {lse_d:.3f}, Quality: {quality}")
+        
+        return lse_c, lse_d, quality
+        
+    except Exception as e:
+        logging.error(f"LSE metric calculation failed: {str(e)}")
+        raise RuntimeError(f"LSE metric calculation failed: {str(e)}") from e

{syncnet_python-0.2.1 → syncnet_python-0.2.2}/syncnet_python/syncnet_pipeline.py

@@ -215,11 +215,34 @@ class SyncNetPipeline:
         os.remove(tmp_avi)
         return final_avi
 
+    # ---------------------------- audio extraction helper ----------------- #
+    def _extract_audio_from_video(self, video_path: str, output_path: str) -> None:
+        """Extract audio from video file using ffmpeg."""
+        cfg = self.cfg
+        ffmpeg_bin = cfg.ffmpeg_bin if cfg.ffmpeg_bin is not None else "ffmpeg"
+        
+        cmd = [
+            ffmpeg_bin, "-y", "-i", str(video_path),
+            "-ac", "1", "-ar", str(cfg.audio_sample_rate),
+            "-acodec", "pcm_s16le", "-f", "wav",
+            str(output_path)
+        ]
+        
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            logging.info(f"Successfully extracted audio from {video_path} to {output_path}")
+        except subprocess.CalledProcessError as e:
+            logging.error(f"FFmpeg audio extraction failed: {e.stderr}")
+            raise RuntimeError(f"FFmpeg audio extraction failed: {e.stderr}")
+        except FileNotFoundError:
+            logging.error(f"FFmpeg not found at: {ffmpeg_bin}")
+            raise RuntimeError(f"FFmpeg not found. Please ensure ffmpeg is installed and in PATH.")
+
     # ---------------------------- inference -------------------------------- #
     def inference(
         self,
-        video_path: str,  # We do not extract audio from video_path!
-        audio_path: str,
+        video_path: str,
+        audio_path: Optional[str] = None,  # Now supports None for auto-extraction
         *,
         cache_dir: Optional[str] = None,
     ) -> Tuple[List[int], List[float], List[float], float, float, str, bool]:
@@ -229,34 +252,59 @@ class SyncNetPipeline:
             work.mkdir(parents=True, exist_ok=True)
 
         try:
+            # Handle audio_path=None case - extract audio from video
+            if audio_path is None:
+                logging.info("audio_path is None, extracting audio from video")
+                extracted_audio_path = work / "extracted_audio.wav"
+                self._extract_audio_from_video(video_path, str(extracted_audio_path))
+                actual_audio_path = str(extracted_audio_path)
+            else:
+                actual_audio_path = audio_path
+                logging.info(f"Using provided audio path: {actual_audio_path}")
+
             # 1) Convert video to constant-fps AVI
             avi = work / "video.avi"
-            (
-                ffmpeg.input(video_path)
-                .output(str(avi), **{"q:v": 2}, r=cfg.frame_rate, **{"async": 1})
-                .overwrite_output()
-                .run()
-            )
+            try:
+                (
+                    ffmpeg.input(video_path)
+                    .output(str(avi), **{"q:v": 2}, r=cfg.frame_rate, **{"async": 1})
+                    .overwrite_output()
+                    .run()
+                )
+            except ffmpeg.Error as e:
+                logging.error(f"FFmpeg video conversion failed: {e}")
+                raise RuntimeError(f"FFmpeg video conversion failed: {e}")
 
             # 2) Extract frames
             frames_dir = work / "frames"
             frames_dir.mkdir(exist_ok=True)
-            (
-                ffmpeg.input(str(avi))
-                .output(str(frames_dir / "%06d.jpg"), **{"q:v": 2}, f="image2", threads=1)
-                .overwrite_output()
-                .run()
-            )
+            try:
+                (
+                    ffmpeg.input(str(avi))
+                    .output(str(frames_dir / "%06d.jpg"), **{"q:v": 2}, f="image2", threads=1)
+                    .overwrite_output()
+                    .run()
+                )
+            except ffmpeg.Error as e:
+                logging.error(f"FFmpeg frame extraction failed: {e}")
+                raise RuntimeError(f"FFmpeg frame extraction failed: {e}")
+            
             frames = sorted(glob(str(frames_dir / "*.jpg")))
+            if not frames:
+                raise RuntimeError("No frames were extracted from the video")
 
             # 3) Resample speech
             audio_wav = work / "speech.wav"
-            (
-                ffmpeg.input(audio_path)
-                .output(str(audio_wav), ac=1, ar=cfg.audio_sample_rate, format="wav")
-                .overwrite_output()
-                .run()
-            )
+            try:
+                (
+                    ffmpeg.input(actual_audio_path)
+                    .output(str(audio_wav), ac=1, ar=cfg.audio_sample_rate, format="wav")
+                    .overwrite_output()
+                    .run()
+                )
+            except ffmpeg.Error as e:
+                logging.error(f"FFmpeg audio resampling failed: {e}")
+                raise RuntimeError(f"FFmpeg audio resampling failed: {e}")
 
             # 4) Face detection
             detections = []

syncnet_python-0.2.2/syncnet_python/test_error_handling.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""Test script for comprehensive error handling in SyncNet v0.2.2."""
+
+import logging
+import tempfile
+from pathlib import Path
+import sys
+import os
+sys.path.insert(0, os.path.dirname(__file__))
+
+from syncnet_pipeline import SyncNetPipeline
+
+# Import safe utils with fallback
+try:
+    from safe_syncnet_utils import safe_syncnet_inference, calculate_lse_metrics
+except ImportError:
+    # Fallback implementation for testing
+    def safe_syncnet_inference(pipeline, video_path, audio_path=None, cache_dir=None):
+        return pipeline.inference(video_path=video_path, audio_path=audio_path, cache_dir=cache_dir)
+    
+    def calculate_lse_metrics(pipeline, video_path, audio_path=None, cache_dir=None):
+        results = pipeline.inference(video_path=video_path, audio_path=audio_path, cache_dir=cache_dir)
+        offsets, confs, dists, max_conf, min_dist, _, has_face = results
+        
+        if not has_face or not confs:
+            return 0.0, float('inf'), "NO_FACE"
+        
+        quality = "GOOD" if max_conf > 3.5 and min_dist < 7.0 else "FAIR" if max_conf > 2.0 else "POOR"
+        return max_conf, min_dist, quality
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s"
+)
+
+def test_audio_none_handling():
+    """Test automatic audio extraction when audio_path=None."""
+    print("\n=== Testing audio_path=None handling ===")
+    
+    # Initialize pipeline
+    pipeline = SyncNetPipeline(
+        {'s3fd_weights': '../weights/sfd_face.pth', 'syncnet_weights': '../weights/syncnet_v2.model'},
+        device='cuda'
+    )
+    
+    # Test with audio_path=None (should automatically extract audio)
+    video_path = '../example/pair_0000_lipsynced.mp4'
+    
+    try:
+        print(f"Testing inference with audio_path=None for: {video_path}")
+        results = pipeline.inference(
+            video_path=video_path,
+            audio_path=None,  # This should now work!
+            cache_dir='../example/cache_test_none'
+        )
+        
+        offsets, confs, dists, max_conf, min_dist, _, has_face = results
+        
+        if has_face:
+            print(f"✅ SUCCESS: Auto audio extraction worked!")
+            print(f"   LSE-C: {max_conf:.3f}")
+            print(f"   LSE-D: {min_dist:.3f}")
+        else:
+            print("⚠️  No face detected, but no error occurred")
+            
+    except Exception as e:
+        print(f"❌ FAILED: {str(e)}")
+
+def test_safe_wrapper_functions():
+    """Test the safe wrapper functions."""
+    print("\n=== Testing Safe Wrapper Functions ===")
+    
+    pipeline = SyncNetPipeline(
+        {'s3fd_weights': '../weights/sfd_face.pth', 'syncnet_weights': '../weights/syncnet_v2.model'},
+        device='cuda'
+    )
+    
+    video_path = '../example/pair_0000_lipsynced.mp4'
+    
+    try:
+        print("Testing safe_syncnet_inference...")
+        results = safe_syncnet_inference(
+            pipeline, 
+            video_path, 
+            audio_path=None,
+            cache_dir='../example/cache_test_safe'
+        )
+        print("✅ safe_syncnet_inference: SUCCESS")
+        
+        print("Testing calculate_lse_metrics...")
+        lse_c, lse_d, quality = calculate_lse_metrics(
+            pipeline,
+            video_path,
+            audio_path=None,
+            cache_dir='../example/cache_test_metrics'
+        )
+        print(f"✅ calculate_lse_metrics: SUCCESS")
+        print(f"   LSE-C: {lse_c:.3f}")
+        print(f"   LSE-D: {lse_d:.3f}")
+        print(f"   Quality: {quality}")
+        
+    except Exception as e:
+        print(f"❌ Safe wrapper test FAILED: {str(e)}")
+
+def test_error_cases():
+    """Test various error cases."""
+    print("\n=== Testing Error Cases ===")
+    
+    pipeline = SyncNetPipeline(
+        {'s3fd_weights': '../weights/sfd_face.pth', 'syncnet_weights': '../weights/syncnet_v2.model'},
+        device='cuda'
+    )
+    
+    # Test with non-existent file
+    try:
+        results = safe_syncnet_inference(
+            pipeline,
+            "non_existent_video.mp4",
+            audio_path=None
+        )
+        print("❌ Should have failed for non-existent file")
+    except FileNotFoundError:
+        print("✅ Correctly caught FileNotFoundError for non-existent video")
+    except Exception as e:
+        print(f"⚠️  Unexpected error: {str(e)}")
+
+def main():
+    """Run all tests."""
+    print("SyncNet v0.2.2 Error Handling Test Suite")
+    print("=" * 50)
+    
+    test_audio_none_handling()
+    test_safe_wrapper_functions() 
+    test_error_cases()
+    
+    print("\n" + "=" * 50)
+    print("Test suite completed!")
+
+if __name__ == "__main__":
+    main()

{syncnet_python-0.2.1 → syncnet_python-0.2.2}/syncnet_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncnet-python
-Version: 0.2.1
+Version: 0.2.2
 Summary: SyncNet: Audio-visual synchronization detection using deep learning. Updated version of https://github.com/joonson/syncnet_python for modern Python versions.
 Author: SyncNet Python Contributors
 Maintainer: SyncNet Python Contributors
@@ -49,7 +49,6 @@ Dynamic: license-file
 
 [![PyPI version](https://badge.fury.io/py/syncnet-python.svg)](https://badge.fury.io/py/syncnet-python)
 [![Python](https://img.shields.io/pypi/pyversions/syncnet-python.svg)](https://pypi.org/project/syncnet-python/)
-[![Downloads](https://pepy.tech/badge/syncnet-python)](https://pepy.tech/project/syncnet-python)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 Audio-visual synchronization detection using deep learning with modern Python architecture.

{syncnet_python-0.2.1 → syncnet_python-0.2.2}/syncnet_python.egg-info/SOURCES.txt

@@ -43,7 +43,9 @@ syncnet_python/cli.py
 syncnet_python/run_syncnet_pipeline_on_1example.py
 syncnet_python/run_syncnet_pipeline_on_mocha_generation_on_mocha_bench.py
 syncnet_python/run_syncnet_pipeline_on_your_own_model_results.py
+syncnet_python/safe_syncnet_utils.py
 syncnet_python/syncnet_pipeline.py
+syncnet_python/test_error_handling.py
 syncnet_python/test_lse_metrics.py
 syncnet_python.egg-info/PKG-INFO
 syncnet_python.egg-info/SOURCES.txt