mkv-episode-matcher 0.4.5__tar.gz → 0.5.0__tar.gz

{mkv_episode_matcher-0.4.5 → mkv_episode_matcher-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mkv-episode-matcher
-Version: 0.4.5
+Version: 0.5.0
 Summary: The MKV Episode Matcher is a tool for identifying TV series episodes from MKV files and renaming the files accordingly.
 Home-page: https://github.com/Jsakkos/mkv-episode-matcher
 Author: Jonathan Sakkos

{mkv_episode_matcher-0.4.5 → mkv_episode_matcher-0.5.0}/mkv_episode_matcher/__main__.py

@@ -108,7 +108,7 @@ def main():
     )
     args = parser.parse_args()
     if args.check_gpu:
-        from mkv_episode_matcher.speech_to_text import check_gpu_support
+        from mkv_episode_matcher.utils import check_gpu_support
         check_gpu_support()
         return
     logger.debug(f"Command-line arguments: {args}")

{mkv_episode_matcher-0.4.5 → mkv_episode_matcher-0.5.0}/mkv_episode_matcher/episode_identification.py

@@ -18,7 +18,7 @@ class EpisodeMatcher:
         self.cache_dir = Path(cache_dir)
         self.min_confidence = min_confidence
         self.show_name = show_name
-        self.chunk_duration = 300  # 5 minutes
+        self.chunk_duration = 30
         self.device = "cuda" if torch.cuda.is_available() else "cpu"
         self.temp_dir = Path(tempfile.gettempdir()) / "whisper_chunks"
         self.temp_dir.mkdir(exist_ok=True)
@@ -44,7 +44,9 @@ class EpisodeMatcher:
                 '-ss', str(start_time),
                 '-t', str(self.chunk_duration),
                 '-i', mkv_file,
-                '-vn',
+                '-vn',  # Disable video
+                '-sn',  # Disable subtitles
+                '-dn',  # Disable data streams
                 '-acodec', 'pcm_s16le',
                 '-ar', '16000',
                 '-ac', '1',
@@ -80,31 +82,73 @@ class EpisodeMatcher:
         except Exception as e:
             logger.error(f"Error loading reference chunk from {srt_file}: {e}")
             return ''
-
-    def identify_episode(self, video_file, temp_dir, season_number):
-        try:
-            # Get video duration
-            duration = float(subprocess.check_output([
-                'ffprobe', '-v', 'error',
-                '-show_entries', 'format=duration',
-                '-of', 'default=noprint_wrappers=1:nokey=1',
-                video_file
-            ]).decode())
+    def _try_match_with_model(self, video_file, model_name, max_duration, reference_files):
+        """
+        Attempt to match using specified model, checking multiple 30-second chunks up to max_duration.
+        
+        Args:
+            video_file: Path to the video file
+            model_name: Name of the Whisper model to use
+            max_duration: Maximum duration in seconds to check
+            reference_files: List of reference subtitle files
+        """
+        # Use cached model
+        model = get_whisper_model(model_name, self.device)
+        
+        # Calculate number of chunks to check (30 seconds each)
+        num_chunks = max_duration // self.chunk_duration
+        
+        for chunk_idx in range(num_chunks):
+            start_time = chunk_idx * self.chunk_duration
+            logger.debug(f"Trying {model_name} model at {start_time} seconds")
             
-            total_chunks = int(np.ceil(duration / self.chunk_duration))
+            audio_path = self.extract_audio_chunk(video_file, start_time)
             
-            # Load Whisper model
-            model = whisper.load_model("base", device=self.device)
+            result = model.transcribe(
+                audio_path,
+                task="transcribe",
+                language="en"
+            )
             
-            # Get season-specific reference files using multiple patterns
-            reference_dir = self.cache_dir / "data" / self.show_name
+            chunk_text = result["text"]
+            best_confidence = 0
+            best_match = None
             
-            # Create season patterns for different formats
+            # Compare with reference chunks
+            for ref_file in reference_files:
+                ref_text = self.load_reference_chunk(ref_file, chunk_idx)
+                confidence = self.chunk_score(chunk_text, ref_text)
+                
+                if confidence > best_confidence:
+                    best_confidence = confidence
+                    best_match = ref_file
+                    
+                if confidence > self.min_confidence:
+                    season_ep = re.search(r'S(\d+)E(\d+)', best_match.stem)
+                    if season_ep:
+                        season, episode = map(int, season_ep.groups())
+                        return {
+                            'season': season,
+                            'episode': episode,
+                            'confidence': best_confidence,
+                            'reference_file': str(best_match),
+                            'matched_at': start_time
+                        }
+            
+            logger.debug(f"No match found at {start_time} seconds (best confidence: {best_confidence:.2f})")
+        
+        return None
+
+    def identify_episode(self, video_file, temp_dir, season_number):
+        """Progressive episode identification with faster initial attempt."""
+        try:
+            # Get reference files first
+            reference_dir = self.cache_dir / "data" / self.show_name
             patterns = [
-                f"S{season_number:02d}E",  # S01E01
-                f"S{season_number}E",      # S1E01
-                f"{season_number:02d}x",   # 01x01
-                f"{season_number}x",       # 1x01
+                f"S{season_number:02d}E",
+                f"S{season_number}E",
+                f"{season_number:02d}x",
+                f"{season_number}x",
             ]
             
             reference_files = []
@@ -114,55 +158,43 @@ class EpisodeMatcher:
                         for p in patterns)]
                 reference_files.extend(files)
             
-            # Remove duplicates while preserving order
             reference_files = list(dict.fromkeys(reference_files))
             
             if not reference_files:
                 logger.error(f"No reference files found for season {season_number}")
                 return None
-                
-            # Process chunks until match found
-            for chunk_idx in range(min(3, total_chunks)):  # Only try first 3 chunks
-                start_time = chunk_idx * self.chunk_duration
-                audio_path = self.extract_audio_chunk(video_file, start_time)
-                
-                # Transcribe chunk
-                result = model.transcribe(
-                    audio_path,
-                    task="transcribe",
-                    language="en"
-                )
-                
-                chunk_text = result["text"]
-                best_confidence = 0
-                best_match = None
-                
-                # Compare with reference chunks
-                for ref_file in reference_files:
-                    ref_text = self.load_reference_chunk(ref_file, chunk_idx)
-                    confidence = self.chunk_score(chunk_text, ref_text)
-                    
-                    if confidence > best_confidence:
-                        best_confidence = confidence
-                        best_match = ref_file
-                        
-                    if confidence > self.min_confidence:
-                        season_ep = re.search(r'S(\d+)E(\d+)', best_match.stem)
-                        if season_ep:
-                            season, episode = map(int, season_ep.groups())
-                            return {
-                                'season': season,
-                                'episode': episode,
-                                'confidence': best_confidence,
-                                'reference_file': str(best_match),
-                            }
+
+            # Try with tiny model first (fastest) - check first 2 minutes
+            logger.info("Attempting match with tiny model (first 2 minutes)...")
+            match = self._try_match_with_model(video_file, "tiny", 120, reference_files)
+            if match and match['confidence'] > 0.65:  # Slightly lower threshold for tiny
+                logger.info(f"Successfully matched with tiny model at {match['matched_at']}s (confidence: {match['confidence']:.2f})")
+                return match
+            
+            # If unsuccessful with tiny, try base model on first 3 minutes
+            logger.info("Tiny model match failed, trying base model (first 3 minutes)...")
+            match = self._try_match_with_model(video_file, "base", 180, reference_files)
+            if match and match['confidence'] > self.min_confidence:
+                logger.info(f"Successfully matched with base model at {match['matched_at']}s (confidence: {match['confidence']:.2f})")
+                return match
             
+            # If still no match, try base model on up to 10 minutes
+            logger.info("No match in first 3 minutes, extending base model search to 10 minutes...")
+            match = self._try_match_with_model(video_file, "base", 600, reference_files)
+            if match:
+                logger.info(f"Successfully matched with base model at {match['matched_at']}s (confidence: {match['confidence']:.2f})")
+                return match
+            
+            logger.info("Speech recognition match failed")
             return None
             
         finally:
             # Cleanup temp files
             for file in self.temp_dir.glob("chunk_*.wav"):
-                file.unlink()
+                try:
+                    file.unlink()
+                except Exception as e:
+                    logger.warning(f"Failed to delete temp file {file}: {e}")
 
 def detect_file_encoding(file_path):
     """
@@ -279,4 +311,19 @@ class SubtitleReader:
                 logger.warning(f"Error parsing subtitle block: {e}")
                 continue
                 
-        return text_lines
+        return text_lines
+    
+_whisper_models = {}
+
+def get_whisper_model(model_name="tiny", device=None):
+    """Cache whisper models to avoid reloading."""
+    global _whisper_models
+    if device is None:
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        
+    key = f"{model_name}_{device}"
+    if key not in _whisper_models:
+        _whisper_models[key] = whisper.load_model(model_name, device=device)
+        logger.info(f"Loaded {model_name} model on {device}")
+    
+    return _whisper_models[key]

{mkv_episode_matcher-0.4.5 → mkv_episode_matcher-0.5.0}/mkv_episode_matcher/episode_matcher.py

@@ -19,7 +19,6 @@ from mkv_episode_matcher.utils import (
     process_srt_files,
     compare_and_rename_files,get_valid_seasons,rename_episode_file
 )
-from mkv_episode_matcher.speech_to_text import process_speech_to_text
 from mkv_episode_matcher.episode_identification import EpisodeMatcher
 
 def process_show(season=None, dry_run=False, get_subs=False):
@@ -76,8 +75,6 @@ def process_show(season=None, dry_run=False, get_subs=False):
                 
                 if match:
                     new_name = f"{matcher.show_name} - S{match['season']:02d}E{match['episode']:02d}.mkv"
-                    new_path = os.path.join(season_path, new_name)
-                    
                     logger.info(f"Speech matched {os.path.basename(mkv_file)} to {new_name} "
                               f"(confidence: {match['confidence']:.2f})")
                     

{mkv_episode_matcher-0.4.5 → mkv_episode_matcher-0.5.0}/mkv_episode_matcher/utils.py

@@ -2,7 +2,7 @@
 import os
 import re
 import shutil
-
+import torch
 import requests
 from loguru import logger
 from opensubtitlescom import OpenSubtitles
@@ -389,4 +389,11 @@ def compare_text(text1, text2):
 
     # Compare the two lists of text lines
     matching_lines = set(flat_text1).intersection(flat_text2)
-    return len(matching_lines)
+    return len(matching_lines)
+
+def check_gpu_support():
+    logger.info('Checking GPU support...')
+    if torch.cuda.is_available():
+        logger.info(f"CUDA is available. Using GPU: {torch.cuda.get_device_name(0)}")
+    else:
+        logger.warning("CUDA not available. Using CPU. Refer to https://pytorch.org/get-started/locally/ for GPU support.")

{mkv_episode_matcher-0.4.5 → mkv_episode_matcher-0.5.0}/mkv_episode_matcher.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mkv-episode-matcher
-Version: 0.4.5
+Version: 0.5.0
 Summary: The MKV Episode Matcher is a tool for identifying TV series episodes from MKV files and renaming the files accordingly.
 Home-page: https://github.com/Jsakkos/mkv-episode-matcher
 Author: Jonathan Sakkos

{mkv_episode_matcher-0.4.5 → mkv_episode_matcher-0.5.0}/mkv_episode_matcher.egg-info/SOURCES.txt

@@ -27,7 +27,6 @@ mkv_episode_matcher/config.py
 mkv_episode_matcher/episode_identification.py
 mkv_episode_matcher/episode_matcher.py
 mkv_episode_matcher/mkv_to_srt.py
-mkv_episode_matcher/speech_to_text.py
 mkv_episode_matcher/subtitle_utils.py
 mkv_episode_matcher/tmdb_client.py
 mkv_episode_matcher/utils.py

{mkv_episode_matcher-0.4.5 → mkv_episode_matcher-0.5.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = mkv_episode_matcher
-version = 0.4.5
+version = 0.5.0
 author = Jonathan Sakkos
 author_email = jonathansakkos@gmail.com
 description = The MKV Episode Matcher is a tool for identifying TV series episodes from MKV files and renaming the files accordingly.

mkv_episode_matcher-0.4.5/mkv_episode_matcher/speech_to_text.py

@@ -1,96 +0,0 @@
-# mkv_episode_matcher/speech_to_text.py
-
-import os
-import subprocess
-from pathlib import Path
-import whisper
-import torch
-from loguru import logger
-
-def process_speech_to_text(mkv_file, output_dir):
-    """
-    Convert MKV file to transcript using Whisper.
-    
-    Args:
-        mkv_file (str): Path to MKV file
-        output_dir (str): Directory to save transcript files
-    """
-    # Extract audio if not already done
-    wav_file = extract_audio(mkv_file, output_dir)
-    if not wav_file:
-        return None
-
-    # Load model
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    if device == "cuda":
-        logger.info(f"CUDA is available. Using GPU: {torch.cuda.get_device_name(0)}")
-    else:
-        logger.info("CUDA not available. Using CPU.")
-    
-    model = whisper.load_model("base", device=device)
-    
-    # Generate transcript
-    segments_file = os.path.join(output_dir, f"{Path(mkv_file).stem}.segments.json")
-    if not os.path.exists(segments_file):
-        try:
-            result = model.transcribe(
-                wav_file,
-                task="transcribe",
-                language="en",
-            )
-            
-            # Save segments
-            import json
-            with open(segments_file, 'w', encoding='utf-8') as f:
-                json.dump(result["segments"], f, indent=2)
-                
-            logger.info(f"Transcript saved to {segments_file}")
-            
-        except Exception as e:
-            logger.error(f"Error during transcription: {e}")
-            return None
-    else:
-        logger.info(f"Using existing transcript: {segments_file}")
-    
-    return segments_file
-
-def extract_audio(mkv_file, output_dir):
-    """
-    Extract audio from MKV file using FFmpeg.
-    
-    Args:
-        mkv_file (str): Path to MKV file
-        output_dir (str): Directory to save WAV file
-        
-    Returns:
-        str: Path to extracted WAV file
-    """
-    wav_file = os.path.join(output_dir, f"{Path(mkv_file).stem}.wav")
-    
-    if not os.path.exists(wav_file):
-        logger.info(f"Extracting audio from {mkv_file}")
-        try:
-            cmd = [
-                'ffmpeg',
-                '-i', mkv_file,
-                '-vn',  # Disable video
-                '-acodec', 'pcm_s16le',  # Convert to PCM format
-                '-ar', '16000',  # Set sample rate to 16kHz
-                '-ac', '1',  # Convert to mono
-                wav_file
-            ]
-            subprocess.run(cmd, check=True, capture_output=True)
-            logger.info(f"Audio extracted to {wav_file}")
-        except subprocess.CalledProcessError as e:
-            logger.error(f"Error extracting audio: {e}")
-            return None
-    else:
-        logger.info(f"Audio file {wav_file} already exists, skipping extraction")
-    
-    return wav_file
-def check_gpu_support():
-    logger.info('Checking GPU support...')
-    if torch.cuda.is_available():
-        logger.info(f"CUDA is available. Using GPU: {torch.cuda.get_device_name(0)}")
-    else:
-        logger.warning("CUDA not available. Using CPU. Refer to https://pytorch.org/get-started/locally/ for GPU support.")