mkv-episode-matcher 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

mkv_episode_matcher/episode_identification.py

@@ -9,6 +9,10 @@ from loguru import logger
 import whisper
 import numpy as np
 import re
+from pathlib import Path
+import chardet
+from loguru import logger
+
 class EpisodeMatcher:
     def __init__(self, cache_dir, show_name, min_confidence=0.6):
         self.cache_dir = Path(cache_dir)
@@ -50,34 +54,32 @@ class EpisodeMatcher:
         return str(chunk_path)
 
     def load_reference_chunk(self, srt_file, chunk_idx):
-        """Load reference subtitles for a specific time chunk."""
+        """
+        Load reference subtitles for a specific time chunk with robust encoding handling.
+        
+        Args:
+            srt_file (str or Path): Path to the SRT file
+            chunk_idx (int): Index of the chunk to load
+            
+        Returns:
+            str: Combined text from the subtitle chunk
+        """
         chunk_start = chunk_idx * self.chunk_duration
         chunk_end = chunk_start + self.chunk_duration
-        text_lines = []
         
-        with open(srt_file, 'r', encoding='utf-8') as f:
-            content = f.read().strip()
+        try:
+            # Read the file content using our robust reader
+            reader = SubtitleReader()
+            content = reader.read_srt_file(srt_file)
             
-        for block in content.split('\n\n'):
-            lines = block.split('\n')
-            if len(lines) < 3 or '-->' not in lines[1]:  # Skip malformed blocks
-                continue
-                
-            try:
-                timestamp = lines[1]
-                text = ' '.join(lines[2:])
-                
-                end_time = timestamp.split(' --> ')[1].strip()
-                hours, minutes, seconds = map(float, end_time.replace(',','.').split(':'))
-                total_seconds = hours * 3600 + minutes * 60 + seconds
-                
-                if chunk_start <= total_seconds <= chunk_end:
-                    text_lines.append(text)
-                    
-            except (IndexError, ValueError):
-                continue
-                
-        return ' '.join(text_lines)
+            # Extract subtitles for the time chunk
+            text_lines = reader.extract_subtitle_chunk(content, chunk_start, chunk_end)
+            
+            return ' '.join(text_lines)
+            
+        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:
@@ -94,14 +96,27 @@ class EpisodeMatcher:
             # Load Whisper model
             model = whisper.load_model("base", device=self.device)
             
-            # Get season-specific reference files
+            # Get season-specific reference files using multiple patterns
             reference_dir = self.cache_dir / "data" / self.show_name
-            season_pattern = f"S{season_number:02d}E"
-            reference_files = [
-                f for f in reference_dir.glob("*.srt")
-                if season_pattern in f.name
+            
+            # Create season patterns for different formats
+            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
             ]
             
+            reference_files = []
+            for pattern in patterns:
+                files = [f for f in reference_dir.glob("*.srt") 
+                        if any(re.search(f"{p}\\d+", f.name, re.IGNORECASE) 
+                        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
@@ -147,4 +162,121 @@ class EpisodeMatcher:
         finally:
             # Cleanup temp files
             for file in self.temp_dir.glob("chunk_*.wav"):
-                file.unlink()
+                file.unlink()
+
+def detect_file_encoding(file_path):
+    """
+    Detect the encoding of a file using chardet.
+    
+    Args:
+        file_path (str or Path): Path to the file
+        
+    Returns:
+        str: Detected encoding, defaults to 'utf-8' if detection fails
+    """
+    try:
+        with open(file_path, 'rb') as f:
+            raw_data = f.read()
+        result = chardet.detect(raw_data)
+        encoding = result['encoding']
+        confidence = result['confidence']
+        
+        logger.debug(f"Detected encoding {encoding} with {confidence:.2%} confidence for {file_path}")
+        return encoding if encoding else 'utf-8'
+    except Exception as e:
+        logger.warning(f"Error detecting encoding for {file_path}: {e}")
+        return 'utf-8'
+
+def read_file_with_fallback(file_path, encodings=None):
+    """
+    Read a file trying multiple encodings in order of preference.
+    
+    Args:
+        file_path (str or Path): Path to the file
+        encodings (list): List of encodings to try, defaults to common subtitle encodings
+        
+    Returns:
+        str: File contents
+        
+    Raises:
+        ValueError: If file cannot be read with any encoding
+    """
+    if encodings is None:
+        # First try detected encoding, then fallback to common subtitle encodings
+        detected = detect_file_encoding(file_path)
+        encodings = [detected, 'utf-8', 'latin-1', 'cp1252', 'iso-8859-1']
+    
+    file_path = Path(file_path)
+    errors = []
+    
+    for encoding in encodings:
+        try:
+            with open(file_path, 'r', encoding=encoding) as f:
+                content = f.read()
+            logger.debug(f"Successfully read {file_path} using {encoding} encoding")
+            return content
+        except UnicodeDecodeError as e:
+            errors.append(f"{encoding}: {str(e)}")
+            continue
+            
+    error_msg = f"Failed to read {file_path} with any encoding. Errors:\n" + "\n".join(errors)
+    logger.error(error_msg)
+    raise ValueError(error_msg)
+
+class SubtitleReader:
+    """Helper class for reading and parsing subtitle files."""
+    
+    @staticmethod
+    def parse_timestamp(timestamp):
+        """Parse SRT timestamp into seconds."""
+        hours, minutes, seconds = timestamp.replace(',', '.').split(':')
+        return float(hours) * 3600 + float(minutes) * 60 + float(seconds)
+    
+    @staticmethod
+    def read_srt_file(file_path):
+        """
+        Read an SRT file and return its contents with robust encoding handling.
+        
+        Args:
+            file_path (str or Path): Path to the SRT file
+            
+        Returns:
+            str: Contents of the SRT file
+        """
+        return read_file_with_fallback(file_path)
+    
+    @staticmethod
+    def extract_subtitle_chunk(content, start_time, end_time):
+        """
+        Extract subtitle text for a specific time window.
+        
+        Args:
+            content (str): Full SRT file content
+            start_time (float): Chunk start time in seconds
+            end_time (float): Chunk end time in seconds
+            
+        Returns:
+            list: List of subtitle texts within the time window
+        """
+        text_lines = []
+        
+        for block in content.strip().split('\n\n'):
+            lines = block.split('\n')
+            if len(lines) < 3 or '-->' not in lines[1]:
+                continue
+                
+            try:
+                timestamp = lines[1]
+                text = ' '.join(lines[2:])
+                
+                end_stamp = timestamp.split(' --> ')[1].strip()
+                total_seconds = SubtitleReader.parse_timestamp(end_stamp)
+                
+                if start_time <= total_seconds <= end_time:
+                    text_lines.append(text)
+                    
+            except (IndexError, ValueError) as e:
+                logger.warning(f"Error parsing subtitle block: {e}")
+                continue
+                
+        return text_lines

mkv_episode_matcher/episode_matcher.py

@@ -29,6 +29,14 @@ def process_show(season=None, dry_run=False, get_subs=False):
     show_name = clean_text(os.path.basename(show_dir))
     matcher = EpisodeMatcher(CACHE_DIR, show_name)
     
+    # Early check for reference files
+    reference_dir = Path(CACHE_DIR) / "data" / show_name
+    reference_files = list(reference_dir.glob("*.srt"))
+    if not reference_files:
+        logger.error(f"No reference subtitle files found in {reference_dir}")
+        logger.info("Please download reference subtitles first")
+        return
+        
     season_paths = get_valid_seasons(show_dir)
     if not season_paths:
         logger.warning(f"No seasons with .mkv files found")

mkv_episode_matcher/utils.py

@@ -300,7 +300,7 @@ def extract_srt_text(filepath):
 
 def extract_season_episode(filename):
     """
-    Extract season and episode numbers from filename.
+    Extract season and episode numbers from filename with support for multiple formats.
     
     Args:
         filename (str): Filename to parse
@@ -308,10 +308,20 @@ def extract_season_episode(filename):
     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))
+    # List of patterns to try
+    patterns = [
+        r'S(\d+)E(\d+)',          # S01E01
+        r'(\d+)x(\d+)',           # 1x01 or 01x01
+        r'Season\s*(\d+).*?(\d+)' # Season 1 - 01
+    ]
+    
+    for pattern in patterns:
+        match = re.search(pattern, filename, re.IGNORECASE)
+        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.

{mkv_episode_matcher-0.3.4.dist-info → mkv_episode_matcher-0.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: mkv-episode-matcher
-Version: 0.3.4
+Version: 0.3.6
 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
@@ -51,46 +51,31 @@ Automatically match and rename your MKV TV episodes using The Movie Database (TM
 - ✨ **Bulk Processing**: Handle entire seasons at once
 - 🧪 **Dry Run Mode**: Test changes before applying
 
+## Prerequisites
+
+- Python 3.9 or higher
+- [FFmpeg](https://ffmpeg.org/download.html) installed and available in system PATH
+- [Tesseract OCR](https://github.com/UB-Mannheim/tesseract/wiki) installed (required for image-based subtitle processing)
+- TMDb API key
+- OpenSubtitles account (optional, for subtitle downloads)
+
 ## Quick Start
 
 1. Install the package:
 ```bash
 pip install mkv-episode-matcher
 ```
+2. Download .srt subtitles files to ~/.mkv-episode-matcher/cache/data/Show Name/
 
-2. Run on your show directory:
+3. Run on your show directory:
 ```bash
-mkv-match --show-dir "path/to/your/show" --season 1
+mkv-match --show-dir "path/to/your/show"
 ```
 
-## Requirements
-
-- Python 3.8 or higher
-- TMDb API key
-- OpenSubtitles account (optional, for subtitle downloads)
-
 ## Documentation
 
 Full documentation is available at [https://jsakkos.github.io/mkv-episode-matcher/](https://jsakkos.github.io/mkv-episode-matcher/)
 
-## Basic Usage
-
-```python
-from mkv_episode_matcher import process_show
-
-# Process all seasons
-process_show()
-
-# Process specific season
-process_show(season=1)
-
-# Test run without making changes
-process_show(season=1, dry_run=True)
-
-# Process and download subtitles
-process_show(get_subs=True)
-```
-
 ## Directory Structure
 
 MKV Episode Matcher expects your TV shows to be organized as follows:
@@ -105,6 +90,23 @@ Show Name/
 │   └── episode2.mkv
 ```
 
+## Reference Subtitle File Structure
+
+Subtitle files that are not automatically downloaded using the `--get-subs` flag should be named as follows:
+
+```
+
+~/.mkv-episode-matcher/cache/data/Show Name/
+├── Show Name - S01E01.srt
+├── Show Name - S01E02.srt
+└── ...
+```
+
+On Windows, the cache directory is located at `C:\Users\{username}\.mkv-episode-matcher\cache\data\`
+
+Reference subtitle files should follow this naming pattern:
+`{show_name} - S{season:02d}E{episode:02d}.srt`
+
 ## Contributing
 
 1. Fork the repository

{mkv_episode_matcher-0.3.4.dist-info → mkv_episode_matcher-0.3.6.dist-info}/RECORD

@@ -2,13 +2,13 @@ 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_identification.py,sha256=NopEkcBFFUjjrAujogeVcdISv8UZHFjYr5RJLM0j468,5875
-mkv_episode_matcher/episode_matcher.py,sha256=BJ76DPxsmZs-KfHZZ_0WvKSBZWXsUEO6lW34YdYEaxM,3979
+mkv_episode_matcher/episode_identification.py,sha256=_6M1UJkq1RGfmLI32u9dNOVvgp5Vf2MjqW2MTx0Gl8E,10329
+mkv_episode_matcher/episode_matcher.py,sha256=vunYpHQxyXo3l88BUScXa7_kMYMCV1pXpQxaLa-plZA,4325
 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/subtitle_utils.py,sha256=rYSbd393pKYQW0w4sXgals02WFGqMYYYkQHDbEkWF8c,2666
 mkv_episode_matcher/tmdb_client.py,sha256=LbMCgjmp7sCbrQo_CDlpcnryKPz5S7inE24YY9Pyjk4,4172
-mkv_episode_matcher/utils.py,sha256=Txnn24ou7Pg3iMq9WrT3nwBRlRP8JEuZQ2ZYW7uesp4,13972
+mkv_episode_matcher/utils.py,sha256=VASbougN3rb2iu40iZWkGjKIbahW713TOrFBo_TR9wo,14269
 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
@@ -19,8 +19,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.3.4.dist-info/METADATA,sha256=QPa0StsF0ADrzxSEswvQ4tTbBkztRjR82hNFsXnJwCc,4640
-mkv_episode_matcher-0.3.4.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-mkv_episode_matcher-0.3.4.dist-info/entry_points.txt,sha256=IglJ43SuCZq2eQ3shMFILCkmQASJHnDCI3ogohW2Hn4,64
-mkv_episode_matcher-0.3.4.dist-info/top_level.txt,sha256=XRLbd93HUaedeWLtkyTvQjFcE5QcBRYa3V-CfHrq-OI,20
-mkv_episode_matcher-0.3.4.dist-info/RECORD,,
+mkv_episode_matcher-0.3.6.dist-info/METADATA,sha256=gjlfeFtCjCCjf2qUWTGJ9zTvSSU_1KRhp1ZtIBISecI,5113
+mkv_episode_matcher-0.3.6.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mkv_episode_matcher-0.3.6.dist-info/entry_points.txt,sha256=IglJ43SuCZq2eQ3shMFILCkmQASJHnDCI3ogohW2Hn4,64
+mkv_episode_matcher-0.3.6.dist-info/top_level.txt,sha256=XRLbd93HUaedeWLtkyTvQjFcE5QcBRYa3V-CfHrq-OI,20
+mkv_episode_matcher-0.3.6.dist-info/RECORD,,

{mkv_episode_matcher-0.3.4.dist-info → mkv_episode_matcher-0.3.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any