mkv-episode-matcher 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

mkv_episode_matcher/episode_identification.py

@@ -0,0 +1,208 @@
+# mkv_episode_matcher/episode_identification.py
+
+import os
+import glob
+from pathlib import Path
+from rapidfuzz import fuzz
+from collections import defaultdict
+import re
+from loguru import logger
+import json
+import shutil
+
+class EpisodeMatcher:
+    def __init__(self, cache_dir, min_confidence=0.6):
+        self.cache_dir = Path(cache_dir)
+        self.min_confidence = min_confidence
+        self.whisper_segments = None
+        self.series_name = None
+        
+    def clean_text(self, text):
+        """Clean text by removing stage directions and normalizing repeated words."""
+        # Remove stage directions like [groans] and <i>SHIP:</i>
+        text = re.sub(r'\[.*?\]|\<.*?\>', '', text)
+        # Remove repeated words with dashes (e.g., "Y-y-you" -> "you")
+        text = re.sub(r'([A-Za-z])-\1+', r'\1', text)
+        # Remove multiple spaces
+        text = ' '.join(text.split())
+        return text.lower()
+
+    def chunk_score(self, whisper_chunk, ref_chunk):
+        """Calculate fuzzy match score between two chunks of text."""
+        whisper_clean = self.clean_text(whisper_chunk)
+        ref_clean = self.clean_text(ref_chunk)
+        
+        # Use token sort ratio to handle word order differences
+        token_sort = fuzz.token_sort_ratio(whisper_clean, ref_clean)
+        # Use partial ratio to catch substring matches
+        partial = fuzz.partial_ratio(whisper_clean, ref_clean)
+        
+        # Weight token sort more heavily but consider partial matches
+        return (token_sort * 0.7 + partial * 0.3) / 100.0
+
+    def identify_episode(self, video_file, temp_dir):
+        """Identify which episode matches this video file."""
+        
+        # Get series name from parent directory
+        self.series_name = Path(video_file).parent.parent.name
+        
+        # Load whisper transcript if not already processed
+        segments_file = Path(temp_dir) / f"{Path(video_file).stem}.segments.json"
+        if not segments_file.exists():
+            logger.error(f"No transcript found for {video_file}. Run speech recognition first.")
+            return None
+            
+        with open(segments_file) as f:
+            self.whisper_segments = json.load(f)
+
+        # Get reference directory for this series
+        reference_dir = self.cache_dir / "data" / self.series_name
+        if not reference_dir.exists():
+            logger.error(f"No reference files found for {self.series_name}")
+            return None
+
+        # Match against reference files
+        match = self.match_all_references(reference_dir)
+        
+        if match and match['confidence'] >= self.min_confidence:
+            # Extract season and episode from filename
+            match_file = Path(match['file'])
+            season_ep = re.search(r'S(\d+)E(\d+)', match_file.stem)
+            if season_ep:
+                season, episode = map(int, season_ep.groups())
+                return {
+                    'season': season,
+                    'episode': episode,
+                    'confidence': match['confidence'],
+                    'reference_file': str(match_file),
+                    'chunk_scores': match['chunk_scores']
+                }
+        
+        return None
+
+    def match_all_references(self, reference_dir):
+        """Process all reference files and track matching scores."""
+        results = defaultdict(list)
+        best_match = None
+        best_confidence = 0
+        
+        def process_chunks(ref_segments, filename):
+            nonlocal best_match, best_confidence
+            
+            chunk_size = 300  # 5 minute chunks
+            whisper_chunks = defaultdict(list)
+            ref_chunks = defaultdict(list)
+            
+            # Group segments into time chunks
+            for seg in self.whisper_segments:
+                chunk_idx = int(float(seg['start']) // chunk_size)
+                whisper_chunks[chunk_idx].append(seg['text'])
+                
+            for seg in ref_segments:
+                chunk_idx = int(seg['start'] // chunk_size)
+                ref_chunks[chunk_idx].append(seg['text'])
+            
+            # Score each chunk
+            for chunk_idx in whisper_chunks:
+                whisper_text = ' '.join(whisper_chunks[chunk_idx])
+                
+                # Look for matching reference chunk and adjacent chunks
+                scores = []
+                for ref_idx in range(max(0, chunk_idx-1), chunk_idx+2):
+                    if ref_idx in ref_chunks:
+                        ref_text = ' '.join(ref_chunks[ref_idx])
+                        score = self.chunk_score(whisper_text, ref_text)
+                        scores.append(score)
+                
+                if scores:
+                    chunk_confidence = max(scores)
+                    logger.info(f"File: {filename}, "
+                              f"Time: {chunk_idx*chunk_size}-{(chunk_idx+1)*chunk_size}s, "
+                              f"Confidence: {chunk_confidence:.2f}")
+                    
+                    results[filename].append({
+                        'chunk_idx': chunk_idx,
+                        'confidence': chunk_confidence
+                    })
+                    
+                    # Early exit if we find a very good match
+                    if chunk_confidence > self.min_confidence:
+                        chunk_scores = results[filename]
+                        confidence = sum(c['confidence'] * (0.9 ** c['chunk_idx']) 
+                                      for c in chunk_scores) / len(chunk_scores)
+                        
+                        if confidence > best_confidence:
+                            best_confidence = confidence
+                            best_match = {
+                                'file': filename,
+                                'confidence': confidence,
+                                'chunk_scores': chunk_scores
+                            }
+                        return True
+                        
+            return False
+
+        # Process each reference file
+        for ref_file in glob.glob(os.path.join(reference_dir, "*.srt")):
+            ref_segments = self.parse_srt_to_segments(ref_file)
+            filename = os.path.basename(ref_file)
+            
+            if process_chunks(ref_segments, filename):
+                break
+
+        # If no early match found, find best overall match
+        if not best_match:
+            for filename, chunks in results.items():
+                # Weight earlier chunks more heavily
+                confidence = sum(c['confidence'] * (0.9 ** c['chunk_idx']) 
+                               for c in chunks) / len(chunks)
+                
+                if confidence > best_confidence:
+                    best_confidence = confidence
+                    best_match = {
+                        'file': filename,
+                        'confidence': confidence,
+                        'chunk_scores': chunks
+                    }
+        
+        return best_match
+
+    def parse_srt_to_segments(self, srt_file):
+        """Parse SRT file into list of segments with start/end times and text."""
+        segments = []
+        current_segment = {}
+        
+        with open(srt_file, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+            
+        i = 0
+        while i < len(lines):
+            line = lines[i].strip()
+            
+            if line.isdigit():  # Index
+                if current_segment:
+                    segments.append(current_segment)
+                current_segment = {}
+                
+            elif '-->' in line:  # Timestamp
+                start, end = line.split(' --> ')
+                current_segment['start'] = self.timestr_to_seconds(start)
+                current_segment['end'] = self.timestr_to_seconds(end)
+                
+            elif line:  # Text
+                if 'text' in current_segment:
+                    current_segment['text'] += ' ' + line
+                else:
+                    current_segment['text'] = line
+                    
+            i += 1
+            
+        if current_segment:
+            segments.append(current_segment)
+            
+        return segments
+
+    def timestr_to_seconds(self, timestr):
+        """Convert SRT timestamp to seconds."""
+        h, m, s = timestr.replace(',','.').split(':')
+        return float(h) * 3600 + float(m) * 60 + float(s)

mkv_episode_matcher/episode_matcher.py

@@ -1,10 +1,12 @@
-# episode_matcher.py
-import os
-import re
+# mkv_episode_matcher/episode_matcher.py
 
+from pathlib import Path
+import shutil
+import glob
+import os
 from loguru import logger
 
-from mkv_episode_matcher.__main__ import CACHE_DIR, CONFIG_FILE
+from mkv_episode_matcher.__main__ import CONFIG_FILE, CACHE_DIR
 from mkv_episode_matcher.config import get_config
 from mkv_episode_matcher.mkv_to_srt import convert_mkv_to_srt
 from mkv_episode_matcher.tmdb_client import fetch_show_id
@@ -13,262 +15,103 @@ from mkv_episode_matcher.utils import (
     clean_text,
     cleanup_ocr_files,
     get_subtitles,
+    process_reference_srt_files,
+    process_srt_files,
+    compare_and_rename_files,get_valid_seasons
 )
+from mkv_episode_matcher.speech_to_text import process_speech_to_text
+from mkv_episode_matcher.episode_identification import EpisodeMatcher
 
-
-# hash_data = {}
-@logger.catch
 def process_show(season=None, dry_run=False, get_subs=False):
-    """
-    Process the show by downloading episode images and finding matching episodes.
-    Args:
-        season (int, optional): The season number to process. If provided, only that season will be processed. Defaults to None.
-        dry_run (bool, optional): Whether to perform a dry run without actually processing the episodes. Defaults to False.
-        get_subs (bool, optional): Whether to download subtitles for the episodes. Defaults to False.
-    """
+    """Process the show using both speech recognition and OCR fallback."""
     config = get_config(CONFIG_FILE)
     show_dir = config.get("show_dir")
-    show_name = clean_text(os.path.basename(show_dir))
-    logger.info(f"Processing show '{show_name}'...")
-
-    show_id = fetch_show_id(show_name)
-    if show_id is None:
-        logger.error(f"Could not find show '{os.path.basename(show_dir)}' on TMDb.")
+    
+    # Initialize episode matcher
+    matcher = EpisodeMatcher(CACHE_DIR)
+    
+    # Get valid season directories
+    season_paths = get_valid_seasons(show_dir)
+    if not season_paths:
+        logger.warning(f"No seasons with .mkv files found")
         return
 
-    # Get all season directories
-    season_paths = [
-        os.path.join(show_dir, d)
-        for d in os.listdir(show_dir)
-        if os.path.isdir(os.path.join(show_dir, d))
-    ]
-
-    # Filter seasons to only include those with .mkv files
-    valid_season_paths = []
-    for season_path in season_paths:
-        mkv_files = [f for f in os.listdir(season_path) if f.endswith(".mkv")]
-        if mkv_files:
-            valid_season_paths.append(season_path)
-
-    if not valid_season_paths:
-        logger.warning(f"No seasons with .mkv files found in show '{show_name}'")
-        return
-
-    logger.info(
-        f"Found {len(valid_season_paths)} seasons with .mkv files for show '{show_name}'"
-    )
-
-    # Extract season numbers from valid paths
-    seasons_to_process = [
-        int(os.path.basename(season_path).split()[-1])
-        for season_path in valid_season_paths
-    ]
-
-    if get_subs:
-        get_subtitles(show_id, seasons=set(seasons_to_process))
-
     if season is not None:
-        # If specific season requested, check if it has .mkv files
         season_path = os.path.join(show_dir, f"Season {season}")
-        if season_path not in valid_season_paths:
+        if season_path not in season_paths:
             logger.warning(f"Season {season} has no .mkv files to process")
             return
-
-        season_paths_to_process = [season_path]
-    else:
-        # Process all valid seasons
-        season_paths_to_process = valid_season_paths
+        season_paths = [season_path]
 
     # Process each season
-    for season_path in season_paths_to_process:
-        logger.info(f"Processing season path: {season_path}")
-        mkv_files = [
-            os.path.join(season_path, f)
-            for f in os.listdir(season_path)
-            if f.endswith(".mkv")
-        ]
+    for season_path in season_paths:
+        # Get MKV files that haven't been processed
+        mkv_files = [f for f in glob.glob(os.path.join(season_path, "*.mkv"))
+                    if not check_filename(f)]
         
-        # Filter out files that have already been processed
-        unprocessed_files = []
-        for f in mkv_files:
-            if check_filename(f):
-                logger.info(f"Skipping {f}, already processed")
-            else:
-                unprocessed_files.append(f)
-
-        if not unprocessed_files:
+        if not mkv_files:
             logger.info(f"No new files to process in {season_path}")
             continue
 
-        logger.info(f"Processing {len(unprocessed_files)} files in {season_path}")
-        convert_mkv_to_srt(season_path, unprocessed_files)
-        
-    # Process reference and SRT files after all seasons are converted
-    reference_text_dict = process_reference_srt_files(show_name)
-    srt_text_dict = process_srt_files(show_dir)
-    compare_and_rename_files(srt_text_dict, reference_text_dict, dry_run=dry_run)
-    cleanup_ocr_files(show_dir)
-
-
-def check_filename(filename):
-    """
-    Check if the filename is in the correct format.
-
-    Args:
-        filename (str): The filename to check.
-
-    Returns:
-        bool: True if the filename is in the correct format, False otherwise.
-    """
-    # Check if the filename matches the expected format
-    match = re.match(r".*S\d+E\d+", filename)
-    return bool(match)
-
-
-def extract_srt_text(filepath):
-    """
-    Extracts the text from an SRT file.
-
-    Args:
-        filepath (str): The path to the SRT file.
-
-    Returns:
-        list: A list of lists, where each inner list represents a block of text from the SRT file.
-              Each inner list contains the lines of text for that block.
-    """
-    # extract the text from the file
-    with open(filepath) as f:
-        filepath = f.read()
-    text_lines = [
-        filepath.split("\n\n")[i].split("\n")[2:]
-        for i in range(len(filepath.split("\n\n")))
-    ]
-    # remove empty lines
-    text_lines = [[line for line in lines if line] for lines in text_lines]
-    # remove <i> or </i> tags
-    text_lines = [
-        [re.sub(r"<i>|</i>|", "", line) for line in lines] for lines in text_lines
-    ]
-    # remove empty lists
-    text_lines = [lines for lines in text_lines if lines]
-    return text_lines
-
-
-def compare_text(text1, text2):
-    """
-    Compare two lists of text lines and return the number of matching lines.
-
-    Args:
-        text1 (list): List of text lines from the first source.
-        text2 (list): List of text lines from the second source.
-
-    Returns:
-        int: Number of matching lines between the two sources.
-    """
-    # Flatten the list of text lines
-    flat_text1 = [line for lines in text1 for line in lines]
-    flat_text2 = [line for lines in text2 for line in lines]
-
-    # Compare the two lists of text lines
-    matching_lines = set(flat_text1).intersection(flat_text2)
-    return len(matching_lines)
-
-
-def extract_season_episode(filename):
-    """
-    Extract the season and episode number from the filename.
-
-    Args:
-        filename (str): The filename to extract the season and episode from.
-
-    Returns:
-        tuple: A tuple containing the season and episode number.
-    """
-    # Extract the season and episode number from the filename
-    match = re.search(r"S(\d+)E(\d+)", filename)
-    if match:
-        season = int(match.group(1))
-        episode = int(match.group(2))
-        return season, episode
-    else:
-        return None, None
-
-
-def process_reference_srt_files(series_name):
-    """
-    Process reference SRT files for a given series.
-
-    Args:
-        series_name (str): The name of the series.
-
-    Returns:
-        dict: A dictionary containing the reference files where the keys are the MKV filenames
-              and the values are the corresponding SRT texts.
-    """
-    reference_files = {}
-    reference_dir = os.path.join(CACHE_DIR, "data", series_name)
-    for dirpath, _, filenames in os.walk(reference_dir):
-        for filename in filenames:
-            if filename.lower().endswith(".srt"):
-                srt_file = os.path.join(dirpath, filename)
-                logger.info(f"Processing {srt_file}")
-                srt_text = extract_srt_text(srt_file)
-                season, episode = extract_season_episode(filename)
-                mkv_filename = f"{series_name} - S{season:02}E{episode:02}.mkv"
-                reference_files[mkv_filename] = srt_text
-    return reference_files
-
-
-def process_srt_files(show_dir):
-    """
-    Process all SRT files in the given directory and its subdirectories.
-
-    Args:
-        show_dir (str): The directory path where the SRT files are located.
-
-    Returns:
-        dict: A dictionary containing the SRT file paths as keys and their corresponding text content as values.
-    """
-    srt_files = {}
-    for dirpath, _, filenames in os.walk(show_dir):
-        for filename in filenames:
-            if filename.lower().endswith(".srt"):
-                srt_file = os.path.join(dirpath, filename)
-                logger.info(f"Processing {srt_file}")
-                srt_text = extract_srt_text(srt_file)
-                srt_files[srt_file] = srt_text
-    return srt_files
-
-
-def compare_and_rename_files(srt_files, reference_files, dry_run=False):
-    """
-    Compare the srt files with the reference files and rename the matching mkv files.
-
-    Args:
-        srt_files (dict): A dictionary containing the srt files as keys and their contents as values.
-        reference_files (dict): A dictionary containing the reference files as keys and their contents as values.
-        dry_run (bool, optional): If True, the function will only log the renaming actions without actually renaming the files. Defaults to False.
-    """
-    logger.info(
-        f"Comparing {len(srt_files)} srt files with {len(reference_files)} reference files"
-    )
-    for srt_text in srt_files.keys():
-        parent_dir = os.path.dirname(os.path.dirname(srt_text))
-        for reference in reference_files.keys():
-            _season, _episode = extract_season_episode(reference)
-            mkv_file = os.path.join(
-                parent_dir, os.path.basename(srt_text).replace(".srt", ".mkv")
-            )
-            matching_lines = compare_text(
-                reference_files[reference], srt_files[srt_text]
-            )
-            if matching_lines >= int(len(reference_files[reference]) * 0.1):
-                logger.info(f"Matching lines: {matching_lines}")
-                logger.info(f"Found matching file: {mkv_file} ->{reference}")
-                new_filename = os.path.join(parent_dir, reference)
-                if not os.path.exists(new_filename):
-                    if os.path.exists(mkv_file) and not dry_run:
-                        logger.info(f"Renaming {mkv_file} to {new_filename}")
-                        os.rename(mkv_file, new_filename)
+        # Create temp directories
+        temp_dir = Path(season_path) / "temp"
+        ocr_dir = Path(season_path) / "ocr"
+        temp_dir.mkdir(exist_ok=True)
+        ocr_dir.mkdir(exist_ok=True)
+
+        try:
+            unmatched_files = []
+            
+            # First pass: Try speech recognition matching
+            for mkv_file in mkv_files:
+                logger.info(f"Attempting speech recognition match for {mkv_file}")
+                
+                # Extract audio and run speech recognition
+                process_speech_to_text(mkv_file, str(temp_dir))
+                match = matcher.identify_episode(mkv_file, temp_dir)
+                
+                if match and match['confidence'] >= matcher.min_confidence:
+                    # Rename the file
+                    new_name = f"{matcher.series_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})")
+                    
+                    if not dry_run:
+                        os.rename(mkv_file, new_path)
                 else:
-                    logger.info(f"File {new_filename} already exists, skipping")
+                    logger.info(f"Speech recognition match failed for {mkv_file}, will try OCR")
+                    unmatched_files.append(mkv_file)
+
+            # Second pass: Try OCR for unmatched files
+            if unmatched_files:
+                logger.info(f"Attempting OCR matching for {len(unmatched_files)} unmatched files")
+                
+                # Convert files to SRT using OCR
+                convert_mkv_to_srt(season_path, unmatched_files)
+                
+                # Process OCR results
+                reference_text_dict = process_reference_srt_files(matcher.series_name)
+                srt_text_dict = process_srt_files(str(ocr_dir))
+                
+                # Compare and rename
+                compare_and_rename_files(
+                    srt_text_dict, 
+                    reference_text_dict, 
+                    dry_run=dry_run,
+                    min_confidence=0.1  # Lower threshold for OCR
+                )
+            
+            # Download subtitles if requested
+            if get_subs:
+                show_id = fetch_show_id(matcher.series_name)
+                if show_id:
+                    seasons = {int(os.path.basename(p).split()[-1]) for p in season_paths}
+                    get_subtitles(show_id, seasons=seasons)
+
+        finally:
+            # Cleanup
+            if not dry_run:
+                shutil.rmtree(temp_dir)
+                cleanup_ocr_files(show_dir)

mkv_episode_matcher/speech_to_text.py

@@ -0,0 +1,90 @@
+# 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

mkv_episode_matcher/utils.py

@@ -11,32 +11,51 @@ from mkv_episode_matcher.__main__ import CACHE_DIR, CONFIG_FILE
 from mkv_episode_matcher.config import get_config
 from mkv_episode_matcher.tmdb_client import fetch_season_details
 
-
-def check_filename(filename, series_title, season_number, episode_number):
+def get_valid_seasons(show_dir):
     """
-    Check if a filename matches the expected naming convention for a series episode.
+    Get all season directories that contain MKV files.
 
     Args:
-        filename (str): The filename to be checked.
-        series_title (str): The title of the series.
-        season_number (int): The season number of the episode.
-        episode_number (int): The episode number of the episode.
+        show_dir (str): Base directory for the TV show
 
     Returns:
-        bool: True if the filename matches the expected naming convention, False otherwise.
+        list: List of paths to valid season directories
+    """
+    # Get all season directories
+    season_paths = [
+        os.path.join(show_dir, d)
+        for d in os.listdir(show_dir)
+        if os.path.isdir(os.path.join(show_dir, d))
+    ]
+
+    # Filter seasons to only include those with .mkv files
+    valid_season_paths = []
+    for season_path in season_paths:
+        mkv_files = [f for f in os.listdir(season_path) if f.endswith(".mkv")]
+        if mkv_files:
+            valid_season_paths.append(season_path)
+
+    if not valid_season_paths:
+        logger.warning(f"No seasons with .mkv files found in show '{os.path.basename(show_dir)}'")
+    else:
+        logger.info(
+            f"Found {len(valid_season_paths)} seasons with .mkv files in '{os.path.basename(show_dir)}'"
+        )
 
-    This function checks if the given filename matches the expected naming convention for a series episode.
-    The expected naming convention is '{series_title} - S{season_number:02d}E{episode_number:02d}.mkv'.
-    If the filename matches the expected pattern, it returns True; otherwise, it returns False.
+    return valid_season_paths
+def check_filename(filename):
+    """
+    Check if the filename is in the correct format (S01E02).
 
-    Example:
-        If filename = 'Example - S01E03.mkv', series_title = 'Example', season_number = 1, and episode_number = 3,
-        the function will return True because the filename matches the expected pattern.
+    Args:
+        filename (str): The filename to check.
+
+    Returns:
+        bool: True if the filename matches the expected pattern.
     """
-    pattern = re.compile(
-        f"{re.escape(series_title)} - S{season_number:02d}E{episode_number:02d}.mkv"
-    )
-    return bool(pattern.match(filename))
+    # Check if the filename matches the expected format
+    match = re.search(r'.*S\d+E\d+', filename)
+    return bool(match)
 
 
 def scramble_filename(original_file_path, file_number):
@@ -63,57 +82,41 @@ def scramble_filename(original_file_path, file_number):
         os.rename(original_file_path, new_file_path)
 
 
-def rename_episode_file(original_file_path, season_number, episode_number):
+def rename_episode_file(original_file_path, new_filename):
     """
     Rename an episode file with a standardized naming convention.
 
     Args:
         original_file_path (str): The original file path of the episode.
-        season_number (int): The season number of the episode.
-        episode_number (int): The episode number of the episode.
+        new_filename (str): The new filename including season/episode info.
 
     Returns:
-        None
-
-    This function renames an episode file with a standardized naming convention based on the series title, season number,
-    and episode number. If a file with the intended new name already exists, it appends a numerical suffix to the filename
-    until it finds a unique name.
-
-    Example:
-        If original_file_path = '/path/to/episode.mkv', season_number = 1, and episode_number = 3, and the series title is 'Example',
-        the function will rename the file to 'Example - S01E03.mkv' if no file with that name already exists. If a file with that
-        name already exists, it will be renamed to 'Example - S01E03_2.mkv', and so on.
+        str: Path to the renamed file, or None if rename failed.
     """
-    series_title = os.path.basename(
-        os.path.dirname(os.path.dirname(original_file_path))
-    )
-    original_file_name = os.path.basename(original_file_path)
-    extension = os.path.splitext(original_file_path)[-1]
-    new_file_name = (
-        f"{series_title} - S{season_number:02d}E{episode_number:02d}{extension}"
-    )
-    new_file_path = os.path.join(os.path.dirname(original_file_path), new_file_name)
-
-    # Check if the new file path already exists
+    original_dir = os.path.dirname(original_file_path)
+    new_file_path = os.path.join(original_dir, new_filename)
+    
+    # Check if new filepath already exists
     if os.path.exists(new_file_path):
-        logger.warning(f"Filename already exists: {new_file_name}.")
-
-        # If the file already exists, find a unique name by appending a numerical suffix
+        logger.warning(f"File already exists: {new_filename}")
+        
+        # Add numeric suffix if file exists
+        base, ext = os.path.splitext(new_filename)
         suffix = 2
         while True:
-            new_file_name = f"{series_title} - S{season_number:02d}E{episode_number:02d}_{suffix}{extension}"
-            new_file_path = os.path.join(
-                os.path.dirname(original_file_path), new_file_name
-            )
+            new_filename = f"{base}_{suffix}{ext}"
+            new_file_path = os.path.join(original_dir, new_filename)
             if not os.path.exists(new_file_path):
                 break
             suffix += 1
-
-        logger.info(f"Renaming {original_file_name} -> {new_file_name}")
-        os.rename(original_file_path, new_file_path)
-    else:
-        logger.info(f"Renaming {original_file_name} -> {new_file_name}")
+    
+    try:
         os.rename(original_file_path, new_file_path)
+        logger.info(f"Renamed {os.path.basename(original_file_path)} -> {new_filename}")
+        return new_file_path
+    except OSError as e:
+        logger.error(f"Failed to rename file: {e}")
+        return None
 
 
 def get_subtitles(show_id, seasons: set[int]):
@@ -230,3 +233,152 @@ def clean_text(text):
     cleaned_text = re.sub(r"\[.*?\]|\(.*?\)|\{.*?\}", "", text)
     # Strip leading/trailing whitespace
     return cleaned_text.strip()
+# mkv_episode_matcher/utils.py
+
+# Add this to your existing utils.py, keeping all other functions
+
+def process_reference_srt_files(series_name):
+    """
+    Process reference SRT files for a given series.
+
+    Args:
+        series_name (str): The name of the series.
+
+    Returns:
+        dict: A dictionary containing the reference files where the keys are the MKV filenames
+              and the values are the corresponding SRT texts.
+    """
+    from mkv_episode_matcher.__main__ import CACHE_DIR
+    import os
+    
+    reference_files = {}
+    reference_dir = os.path.join(CACHE_DIR, "data", series_name)
+    
+    for dirpath, _, filenames in os.walk(reference_dir):
+        for filename in filenames:
+            if filename.lower().endswith(".srt"):
+                srt_file = os.path.join(dirpath, filename)
+                logger.info(f"Processing {srt_file}")
+                srt_text = extract_srt_text(srt_file)
+                season, episode = extract_season_episode(filename)
+                mkv_filename = f"{series_name} - S{season:02}E{episode:02}.mkv"
+                reference_files[mkv_filename] = srt_text
+                
+    return reference_files
+
+def extract_srt_text(filepath):
+    """
+    Extracts text content from an SRT file.
+
+    Args:
+        filepath (str): Path to the SRT file.
+
+    Returns:
+        list: List of text lines from the SRT file.
+    """
+    # Read the file content
+    with open(filepath) as f:
+        content = f.read()
+        
+    # Split into subtitle blocks
+    blocks = content.strip().split('\n\n')
+    
+    text_lines = []
+    for block in blocks:
+        lines = block.split('\n')
+        if len(lines) < 3:
+            continue
+            
+        # Skip index and timestamp, get all remaining lines as text
+        text = ' '.join(lines[2:])
+        # Remove stage directions and tags
+        text = re.sub(r'\[.*?\]|\<.*?\>', '', text)
+        if text:
+            text_lines.append(text)
+            
+    return text_lines
+
+def extract_season_episode(filename):
+    """
+    Extract season and episode numbers from filename.
+    
+    Args:
+        filename (str): Filename to parse
+        
+    Returns:
+        tuple: (season_number, episode_number)
+    """
+    match = re.search(r'S(\d+)E(\d+)', filename)
+    if match:
+        return int(match.group(1)), int(match.group(2))
+    return None, None
+def process_srt_files(show_dir):
+    """
+    Process all SRT files in the given directory and its subdirectories.
+
+    Args:
+        show_dir (str): The directory path where the SRT files are located.
+
+    Returns:
+        dict: A dictionary containing the SRT file paths as keys and their corresponding text content as values.
+    """
+    srt_files = {}
+    for dirpath, _, filenames in os.walk(show_dir):
+        for filename in filenames:
+            if filename.lower().endswith(".srt"):
+                srt_file = os.path.join(dirpath, filename)
+                logger.info(f"Processing {srt_file}")
+                srt_text = extract_srt_text(srt_file)
+                srt_files[srt_file] = srt_text
+    return srt_files
+def compare_and_rename_files(srt_files, reference_files, dry_run=False):
+    """
+    Compare the srt files with the reference files and rename the matching mkv files.
+
+    Args:
+        srt_files (dict): A dictionary containing the srt files as keys and their contents as values.
+        reference_files (dict): A dictionary containing the reference files as keys and their contents as values.
+        dry_run (bool, optional): If True, the function will only log the renaming actions without actually renaming the files. Defaults to False.
+    """
+    logger.info(
+        f"Comparing {len(srt_files)} srt files with {len(reference_files)} reference files"
+    )
+    for srt_text in srt_files.keys():
+        parent_dir = os.path.dirname(os.path.dirname(srt_text))
+        for reference in reference_files.keys():
+            _season, _episode = extract_season_episode(reference)
+            mkv_file = os.path.join(
+                parent_dir, os.path.basename(srt_text).replace(".srt", ".mkv")
+            )
+            matching_lines = compare_text(
+                reference_files[reference], srt_files[srt_text]
+            )
+            if matching_lines >= int(len(reference_files[reference]) * 0.1):
+                logger.info(f"Matching lines: {matching_lines}")
+                logger.info(f"Found matching file: {mkv_file} ->{reference}")
+                new_filename = os.path.join(parent_dir, reference)
+                if not os.path.exists(new_filename):
+                    if os.path.exists(mkv_file) and not dry_run:
+                        logger.info(f"Renaming {mkv_file} to {new_filename}")
+                        os.rename(mkv_file, new_filename)
+                else:
+                    logger.info(f"File {new_filename} already exists, skipping")
+
+def compare_text(text1, text2):
+    """
+    Compare two lists of text lines and return the number of matching lines.
+
+    Args:
+        text1 (list): List of text lines from the first source.
+        text2 (list): List of text lines from the second source.
+
+    Returns:
+        int: Number of matching lines between the two sources.
+    """
+    # Flatten the list of text lines
+    flat_text1 = [line for lines in text1 for line in lines]
+    flat_text2 = [line for lines in text2 for line in lines]
+
+    # Compare the two lists of text lines
+    matching_lines = set(flat_text1).intersection(flat_text2)
+    return len(matching_lines)

{mkv_episode_matcher-0.2.0.dist-info → mkv_episode_matcher-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mkv-episode-matcher
-Version: 0.2.0
+Version: 0.3.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
@@ -14,16 +14,18 @@ Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.10
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: configparser>=7.1.0
 Requires-Dist: ffmpeg>=1.4
 Requires-Dist: loguru>=0.7.2
-Requires-Dist: numpy>=2.1.3
+Requires-Dist: openai-whisper>=20240930
 Requires-Dist: opensubtitlescom>=0.1.5
 Requires-Dist: pytesseract>=0.3.13
+Requires-Dist: rapidfuzz>=3.10.1
 Requires-Dist: requests>=2.32.3
 Requires-Dist: tmdb-client>=0.0.1
+Requires-Dist: wave>=0.0.2
 
 # MKV Episode Matcher
 

{mkv_episode_matcher-0.2.0.dist-info → mkv_episode_matcher-0.3.0.dist-info}/RECORD

@@ -2,10 +2,12 @@ mkv_episode_matcher/.gitattributes,sha256=Gh2-F2vCM7SZ01pX23UT8pQcmauXWfF3gwyRSb
 mkv_episode_matcher/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 mkv_episode_matcher/__main__.py,sha256=3ZcCUxeI7rUA-4oiCD2WXBiOFJAqLsVVWfZKN446FwQ,6792
 mkv_episode_matcher/config.py,sha256=zDDKBcsDt5fME9BRqiTi7yWKeast1pZh36BNYMvIBYM,2419
-mkv_episode_matcher/episode_matcher.py,sha256=YBbRL-NIIvBwKojQOHoDsE3EQYy9_hn1j-4CAuLwM78,9854
+mkv_episode_matcher/episode_identification.py,sha256=nXv9giH7xHysxnfczpsDefb7DmRXzuz8pgmfBemqwBs,8381
+mkv_episode_matcher/episode_matcher.py,sha256=tffbLz35Mpah0yQ6ASz1dg8tz27s8UrdSZunZ-GQLtY,4560
 mkv_episode_matcher/mkv_to_srt.py,sha256=4yxBHRVhgVby0UtQ2aTXGuoQpid8pkgjMIaHU6GCdzc,10857
+mkv_episode_matcher/speech_to_text.py,sha256=-bnGvmtPCKyHFPEaXwIcEYTf_P13rNpAJA-2UFeRFrs,2806
 mkv_episode_matcher/tmdb_client.py,sha256=LbMCgjmp7sCbrQo_CDlpcnryKPz5S7inE24YY9Pyjk4,4172
-mkv_episode_matcher/utils.py,sha256=5YWpRbciIAlmhBxa-etGtMA6IabswE3CuefRVQDROz4,9526
+mkv_episode_matcher/utils.py,sha256=hQmJNdTogGnN3qbN6sN1JUPvIe6RHU6ml3B41yZB8DQ,14147
 mkv_episode_matcher/libraries/pgs2srt/.gitignore,sha256=mt3uxWYZaFurMw_yGE258gWhtGKPVR7e3Ll4ALJpyj4,23
 mkv_episode_matcher/libraries/pgs2srt/README.md,sha256=olb25G17tj0kxPgp_LcH5I2QWXjgP1m8JFyjYRGz4UU,1374
 mkv_episode_matcher/libraries/pgs2srt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -16,8 +18,8 @@ mkv_episode_matcher/libraries/pgs2srt/requirements.txt,sha256=sg87dqWw_qpbwciw-M
 mkv_episode_matcher/libraries/pgs2srt/Libraries/SubZero/SubZero.py,sha256=geT1LXdVd8yED9zoJ9K1XfP2JzGcM7u1SslHYrJI09o,10061
 mkv_episode_matcher/libraries/pgs2srt/Libraries/SubZero/post_processing.py,sha256=GKtVy_Lxv-z27mkRG8pJF2znKWXwZTot7jL6kN-zIxM,10503
 mkv_episode_matcher/libraries/pgs2srt/Libraries/SubZero/dictionaries/data.py,sha256=AlJHUYXl85J95OzGRik-AHVfzDd7Q8BJCvD4Nr8kRIk,938598
-mkv_episode_matcher-0.2.0.dist-info/METADATA,sha256=aocARhBMBFQ5HRTgCCKa5p9pm-4Kw6SJxoxz31sg7HY,3710
-mkv_episode_matcher-0.2.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-mkv_episode_matcher-0.2.0.dist-info/entry_points.txt,sha256=IglJ43SuCZq2eQ3shMFILCkmQASJHnDCI3ogohW2Hn4,64
-mkv_episode_matcher-0.2.0.dist-info/top_level.txt,sha256=XRLbd93HUaedeWLtkyTvQjFcE5QcBRYa3V-CfHrq-OI,20
-mkv_episode_matcher-0.2.0.dist-info/RECORD,,
+mkv_episode_matcher-0.3.0.dist-info/METADATA,sha256=XAnfyhD0sBKRJqR_LwUdLD30wNNijVRj44girWFrl1w,3781
+mkv_episode_matcher-0.3.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+mkv_episode_matcher-0.3.0.dist-info/entry_points.txt,sha256=IglJ43SuCZq2eQ3shMFILCkmQASJHnDCI3ogohW2Hn4,64
+mkv_episode_matcher-0.3.0.dist-info/top_level.txt,sha256=XRLbd93HUaedeWLtkyTvQjFcE5QcBRYa3V-CfHrq-OI,20
+mkv_episode_matcher-0.3.0.dist-info/RECORD,,