syncnet-python 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

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/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/syncnet_pipeline.py

@@ -18,10 +18,17 @@ from scipy.interpolate import interp1d
 from scenedetect import ContentDetector, SceneManager, StatsManager
 from scenedetect.video_manager import VideoManager
 
-from .detectors.s3fd import S3FD
-from .detectors.s3fd.nets import S3FDNet
-from .SyncNetInstance import SyncNetInstance
-from .SyncNetModel import S
+try:
+    from .detectors.s3fd import S3FD
+    from .detectors.s3fd.nets import S3FDNet
+    from .SyncNetInstance import SyncNetInstance
+    from .SyncNetModel import S
+except ImportError:
+    # Fallback for direct script execution
+    from detectors.s3fd import S3FD
+    from detectors.s3fd.nets import S3FDNet
+    from SyncNetInstance import SyncNetInstance
+    from SyncNetModel import S
 
 # ---------------------------------------------------------------------- #
 # Configuration                                                          #
@@ -47,6 +54,11 @@ class PipelineConfig:
     # Tools
     ffmpeg_bin: str = "ffmpeg"  # assumes ffmpeg in $PATH
     audio_sample_rate: int = 16000  # resample rate for speech
+    
+    def __post_init__(self):
+        """Validate configuration after initialization."""
+        if self.ffmpeg_bin is None:
+            self.ffmpeg_bin = "ffmpeg"
 
     @classmethod
     def from_dict(cls, d: Dict[str, Any]):
@@ -165,24 +177,72 @@ class SyncNetPipeline:
         slice_wav = f"{base}.wav"
         ss = track["frame"][0] / cfg.frame_rate
         to = (track["frame"][-1] + 1) / cfg.frame_rate
-        subprocess.call(
-            f'{cfg.ffmpeg_bin} -y -i "{audio_wav}" -ss {ss:.3f} -to {to:.3f} "{slice_wav}"',
-            shell=True,
-        )
+        
+        # Ensure ffmpeg_bin is not None
+        ffmpeg_bin = cfg.ffmpeg_bin if cfg.ffmpeg_bin is not None else "ffmpeg"
+        
+        cmd = [
+            ffmpeg_bin, "-y", "-i", str(audio_wav), 
+            "-ss", f"{ss:.3f}", "-to", f"{to:.3f}", 
+            str(slice_wav)
+        ]
+        
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        except subprocess.CalledProcessError as e:
+            logging.error(f"FFmpeg audio slicing failed: {e.stderr}")
+            raise RuntimeError(f"FFmpeg audio slicing 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.")
 
         final_avi = f"{base}.avi"
-        subprocess.call(
-            f'{cfg.ffmpeg_bin} -y -i "{tmp_avi}" -i "{slice_wav}" -c:v copy -c:a copy "{final_avi}"',
-            shell=True,
-        )
+        
+        cmd = [
+            ffmpeg_bin, "-y", "-i", str(tmp_avi), "-i", str(slice_wav),
+            "-c:v", "copy", "-c:a", "copy", str(final_avi)
+        ]
+        
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        except subprocess.CalledProcessError as e:
+            logging.error(f"FFmpeg video/audio merge failed: {e.stderr}")
+            raise RuntimeError(f"FFmpeg video/audio merge 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.")
+        
         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]:
@@ -192,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/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/test_lse_metrics.py

@@ -0,0 +1,95 @@
+import logging
+import sys
+from pathlib import Path
+from syncnet_pipeline import SyncNetPipeline
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s"
+)
+
+def calculate_lse_metrics(video_path):
+    """
+    Calculate LSE-C and LSE-D metrics for a video
+    
+    LSE-C (Lip Sync Error - Confidence): 
+    - Higher confidence values indicate better lip sync
+    - Threshold typically around 3.5-4.0 for good sync
+    
+    LSE-D (Lip Sync Error - Distance):
+    - Lower distance values indicate better lip sync  
+    - Threshold typically around 6.5-7.0 for good sync
+    """
+    # Initialize pipeline
+    pipe = SyncNetPipeline(
+        {
+            "s3fd_weights": "../weights/sfd_face.pth",
+            "syncnet_weights": "../weights/syncnet_v2.model",
+        },
+        device="cuda",  # or "cpu"
+    )
+    
+    # Run inference
+    print(f"\n=== Processing {video_path} ===")
+    
+    # For testing, we'll extract audio from the video itself
+    results = pipe.inference(
+        video_path=video_path,
+        audio_path=video_path,  # Extract audio from same video
+        cache_dir="../example/cache_lse",
+    )
+    
+    offsets, confs, dists, max_conf, min_dist, s3fd_json, has_face = results
+    
+    if not has_face:
+        print(f"No face detected in {video_path}")
+        return None, None
+    
+    # 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
+    
+    print(f"Number of face tracks: {len(offsets)}")
+    print(f"Track offsets: {offsets}")
+    print(f"Track confidences: {[f'{c:.3f}' for c in confs]}")
+    print(f"Track distances: {[f'{d:.3f}' for d in dists]}")
+    print(f"LSE-C (max confidence): {lse_c:.3f}")
+    print(f"LSE-D (min distance): {lse_d:.3f}")
+    
+    # Interpretation
+    sync_quality = "GOOD" if lse_c > 3.5 and lse_d < 7.0 else "POOR"
+    print(f"Sync Quality: {sync_quality}")
+    
+    return lse_c, lse_d
+
+def main():
+    # Test files
+    test_files = [
+        "../example/pair_0000_lipsynced.mp4",
+        "../example/pair_0001_lipsynced.mp4"
+    ]
+    
+    results = {}
+    
+    for video_path in test_files:
+        if Path(video_path).exists():
+            lse_c, lse_d = calculate_lse_metrics(video_path)
+            results[video_path] = (lse_c, lse_d)
+        else:
+            print(f"File not found: {video_path}")
+    
+    # Summary
+    print("\n=== SUMMARY ===")
+    print(f"{'Video':<40} {'LSE-C':<10} {'LSE-D':<10} {'Quality':<10}")
+    print("-" * 70)
+    
+    for video_path, (lse_c, lse_d) in results.items():
+        if lse_c is not None:
+            video_name = Path(video_path).name
+            quality = "GOOD" if lse_c > 3.5 and lse_d < 7.0 else "POOR"
+            print(f"{video_name:<40} {lse_c:<10.3f} {lse_d:<10.3f} {quality:<10}")
+
+if __name__ == "__main__":
+    main()

{syncnet_python-0.2.0.dist-info → syncnet_python-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncnet-python
-Version: 0.2.0
+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
@@ -47,6 +47,10 @@ Dynamic: license-file
 
 # SyncNet Python
 
+[![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/)
+[![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.
 
 This is a **refactored and enhanced version** of the original [SyncNet implementation](https://github.com/joonson/syncnet_python) by Joon Son Chung, updated for Python 3.9+ with clean architecture, comprehensive error handling, and performance optimizations.

{syncnet_python-0.2.0.dist-info → syncnet_python-0.2.2.dist-info}/RECORD

@@ -1,18 +1,21 @@
 syncnet_python/SyncNetInstance.py,sha256=V-RtWL4nN2CW5n56DkE0d6hcnet4hAs_OVMaMS1ih20,6227
 syncnet_python/SyncNetModel.py,sha256=6qk27paoyV39MTsVyu6K2sbbM-1SLU_2N1zbqm1eeYs,3575
-syncnet_python/__init__.py,sha256=BAgXJdworzKFgKVrUD7cncAhhKlrqF5nMSnOcpTUvjM,702
+syncnet_python/__init__.py,sha256=qpGU322MOioCGVW_CqFSN7WsGsRO__GEtNjHCzD7ce4,1037
 syncnet_python/cli.py,sha256=YSQVVDChLkQ96gFRFqD7laQXqbrLC2b8SKaF-vc8FuA,3256
 syncnet_python/run_syncnet_pipeline_on_1example.py,sha256=7I8_jEgIFw-RUqCHU29LrIWIRP77lTUiH6MePOxsuWQ,1008
 syncnet_python/run_syncnet_pipeline_on_mocha_generation_on_mocha_bench.py,sha256=HJHGLgKpf21bG27_x1QD3MAhqtHey26Ujxb8s2aK-tA,5928
 syncnet_python/run_syncnet_pipeline_on_your_own_model_results.py,sha256=m-kz_DHhka_DywpBRWdxk-S0hrwqvCR16RiVQ7HUqDk,6003
-syncnet_python/syncnet_pipeline.py,sha256=KEVp1B1zRL4Jqbcq2FS4GgpJFh-Kw4Rz97tgmahi9O4,11683
+syncnet_python/safe_syncnet_utils.py,sha256=viucLggg13AW5xAjns_s-jlqv4rzvuRED0Ydo99_RbY,5381
+syncnet_python/syncnet_pipeline.py,sha256=KiLcxsp2-TNKXUxHoFASOwpOizXPwkMmvS42wFHSmes,15770
+syncnet_python/test_error_handling.py,sha256=i5ib1qEjbMUQg913r9plAdXYciQx2jmUjzuoXPvc5f4,4658
+syncnet_python/test_lse_metrics.py,sha256=H_4U2LN-Wussx_KABX5y5EO3QGnaVhKNMuTjLH0zNrE,2884
 syncnet_python/detectors/__init__.py,sha256=WLone-DTbvQUFleY93pmq7xomPDVjda9ATpZYcS6_sA,23
 syncnet_python/detectors/s3fd/__init__.py,sha256=MIJfIEsKFTGh8brmD3fBQg8JZAp57NtaTkY6_I5QZP0,2322
 syncnet_python/detectors/s3fd/box_utils.py,sha256=CWn46LMJKO1cdenI_IWxBbDriO2ueWTCl14Xp28fr-U,7235
 syncnet_python/detectors/s3fd/nets.py,sha256=BYPJq9UJ5bq5Q5RgP1j-NsFzO1gP3N0PYE1X19-4PZw,5891
-syncnet_python-0.2.0.dist-info/licenses/LICENSE,sha256=qwJOQjZqnGgzcgwg3VUkT2pGKwLyZr5nUOm0Gv7Zfog,1088
-syncnet_python-0.2.0.dist-info/METADATA,sha256=h7sqEFPpvFhBpW5ZrBiVtGDnXGmj49-t2ovzJQ7WnzU,7324
-syncnet_python-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-syncnet_python-0.2.0.dist-info/entry_points.txt,sha256=zPJrIl_ekAa31dHZNCoTHiII2k_m5GyMD5BEkMR6Ytk,59
-syncnet_python-0.2.0.dist-info/top_level.txt,sha256=OkvKpxwq9NzQSjjdD571umGrI3meW9kVleOV2N5Ua04,15
-syncnet_python-0.2.0.dist-info/RECORD,,
+syncnet_python-0.2.2.dist-info/licenses/LICENSE,sha256=qwJOQjZqnGgzcgwg3VUkT2pGKwLyZr5nUOm0Gv7Zfog,1088
+syncnet_python-0.2.2.dist-info/METADATA,sha256=y58FslZFThl3p0xv_415IKKW-qjbTHWzBfc6aN1kbrY,7650
+syncnet_python-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+syncnet_python-0.2.2.dist-info/entry_points.txt,sha256=zPJrIl_ekAa31dHZNCoTHiII2k_m5GyMD5BEkMR6Ytk,59
+syncnet_python-0.2.2.dist-info/top_level.txt,sha256=OkvKpxwq9NzQSjjdD571umGrI3meW9kVleOV2N5Ua04,15
+syncnet_python-0.2.2.dist-info/RECORD,,