mkv-episode-matcher 0.3.4__tar.gz → 0.3.6__tar.gz

mkv_episode_matcher-0.3.6/.github/workflows/tests.yml

@@ -0,0 +1,40 @@
+name: Tests
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.9"
+          - "3.10"
+          - "3.11"
+          - "3.12"
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv and set the python version
+        uses: astral-sh/setup-uv@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          uv venv
+          uv pip install -e .
+
+      - name: Run tests with pytest and coverage
+        run: |
+          uv run --dev pytest --cov-branch --cov-report=xml
+
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}

{mkv_episode_matcher-0.3.4 → mkv_episode_matcher-0.3.6}/PKG-INFO

@@ -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 → mkv_episode_matcher-0.3.6}/README.md

@@ -22,46 +22,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:
@@ -76,6 +61,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 → mkv_episode_matcher-0.3.6}/docs/cli.md

@@ -16,14 +16,14 @@ mkv-match --show-dir "/path/to/show" --season 1
 
 ## Command Options
 
-| Option | Description | Default |
-|--------|-------------|---------|
-| `--show-dir` | Show directory path | None |
-| `--season` | Season number to process | None (all) |
-| `--dry-run` | Test without making changes | False |
-| `--get-subs` | Download subtitles | False |
-| `--tmdb-api-key` | TMDb API key | None |
-| `--tesseract-path` | Path to Tesseract | None |
+| Option             | Description                 | Default    |
+| ------------------ | --------------------------- | ---------- |
+| `--show-dir`       | Show directory path         | None       |
+| `--season`         | Season number to process    | None (all) |
+| `--dry-run`        | Test without making changes | False      |
+| `--get-subs`       | Download subtitles          | False      |
+| `--tmdb-api-key`   | TMDb API key                | None       |
+| `--tesseract-path` | Path to Tesseract           | None       |
 
 ## Examples
 
@@ -55,25 +55,6 @@ mkv-match \
   --dry-run true
 ```
 
-## Environment Variables
-
-Alternative to command line options:
-
-```bash
-export TMDB_API_KEY="your_key"
-export SHOW_DIR="/path/to/shows"
-mkv-match
-```
-
-## Exit Codes
-
-| Code | Meaning |
-|------|---------|
-| 0 | Success |
-| 1 | General error |
-| 2 | Configuration error |
-| 3 | API error |
-
 ## Logging
 
 Logs are stored in:
@@ -89,3 +70,4 @@ Logs are stored in:
 2. Use dry-run first to test
 3. Check logs for details
 4. Use full paths for reliability
+5. Avoid using a trailing slash in paths

{mkv_episode_matcher-0.3.4 → mkv_episode_matcher-0.3.6}/docs/quickstart.md

@@ -42,34 +42,31 @@ Show Name/
 │   └── episode2.mkv
 ```
 
-## Python API Usage
+## Reference Subtitle File Structure
 
-```python
-from mkv_episode_matcher import process_show
+Subtitle files that are not automatically downloaded using the `--get-subs` flag should be named as follows:
 
-# Process all seasons
-process_show()
-
-# Process specific season
-process_show(season=1)
-
-# Test run
-process_show(season=1, dry_run=True)
-
-# With subtitles
-process_show(season=1, get_subs=True)
+```plaintext
+~/.mkv-episode-matcher/cache/data/Show Name/
+├── Show Name - S01E01.srt
+├── Show Name - S01E02.srt
+└── ...
 ```
 
 ## Configuration
 
-Create a configuration file at `~/.mkv-episode-matcher/config.ini`:
+The configuration file is automatically generated at `~/.mkv-episode-matcher/config.ini`:
 
 ```ini
 [Config]
-tmdb_api_key = your_api_key
-open_subtitles_api_key = your_opensubs_key
-show_dir = /path/to/shows
+tmdb_api_key = your_tmdb_api_key
+show_dir = /path/to/show
 max_threads = 4
+open_subtitles_api_key = your_opensubs_key
+open_subtitles_user_agent = your_user_agent
+open_subtitles_username = your_username
+open_subtitles_password = your_password
+tesseract_path = C:\Program Files\Tesseract-OCR\tesseract.exe
 ```
 
 ## Next Steps

mkv_episode_matcher-0.3.6/mkv_episode_matcher/episode_identification.py

@@ -0,0 +1,282 @@
+import json
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+import torch
+from rapidfuzz import fuzz
+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)
+        self.min_confidence = min_confidence
+        self.show_name = show_name
+        self.chunk_duration = 300  # 5 minutes
+        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)
+        
+    def clean_text(self, text):
+        text = text.lower().strip()
+        text = re.sub(r'\[.*?\]|\<.*?\>', '', text)
+        text = re.sub(r'([A-Za-z])-\1+', r'\1', text)
+        return ' '.join(text.split())
+
+    def chunk_score(self, whisper_chunk, ref_chunk):
+        whisper_clean = self.clean_text(whisper_chunk)
+        ref_clean = self.clean_text(ref_chunk)
+        return (fuzz.token_sort_ratio(whisper_clean, ref_clean) * 0.7 + 
+                fuzz.partial_ratio(whisper_clean, ref_clean) * 0.3) / 100.0
+
+    def extract_audio_chunk(self, mkv_file, start_time):
+        """Extract a chunk of audio from MKV file."""
+        chunk_path = self.temp_dir / f"chunk_{start_time}.wav"
+        if not chunk_path.exists():
+            cmd = [
+                'ffmpeg',
+                '-ss', str(start_time),
+                '-t', str(self.chunk_duration),
+                '-i', mkv_file,
+                '-vn',
+                '-acodec', 'pcm_s16le',
+                '-ar', '16000',
+                '-ac', '1',
+                str(chunk_path)
+            ]
+            subprocess.run(cmd, capture_output=True)
+        return str(chunk_path)
+
+    def load_reference_chunk(self, srt_file, chunk_idx):
+        """
+        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
+        
+        try:
+            # Read the file content using our robust reader
+            reader = SubtitleReader()
+            content = reader.read_srt_file(srt_file)
+            
+            # 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:
+            # 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())
+            
+            total_chunks = int(np.ceil(duration / self.chunk_duration))
+            
+            # Load Whisper model
+            model = whisper.load_model("base", device=self.device)
+            
+            # Get season-specific reference files using multiple patterns
+            reference_dir = self.cache_dir / "data" / self.show_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
+                
+            # 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),
+                            }
+            
+            return None
+            
+        finally:
+            # Cleanup temp files
+            for file in self.temp_dir.glob("chunk_*.wav"):
+                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-0.3.4 → mkv_episode_matcher-0.3.6}/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-0.3.4 → mkv_episode_matcher-0.3.6}/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 → mkv_episode_matcher-0.3.6}/mkv_episode_matcher.egg-info/PKG-INFO

@@ -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 → mkv_episode_matcher-0.3.6}/mkv_episode_matcher.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+.coverage
 .gitattributes
 .gitignore
 .gitmodules
@@ -11,6 +12,7 @@ uv.lock
 .github/funding.yml
 .github/workflows/documentation.yml
 .github/workflows/python-publish.yml
+.github/workflows/tests.yml
 .vscode/settings.json
 docs/cli.md
 docs/configuration.md
@@ -46,5 +48,4 @@ mkv_episode_matcher/libraries/pgs2srt/Libraries/SubZero/SubZero.py
 mkv_episode_matcher/libraries/pgs2srt/Libraries/SubZero/post_processing.py
 mkv_episode_matcher/libraries/pgs2srt/Libraries/SubZero/dictionaries/data.py
 tests/__init__.py
-tests/test_improvements.py
 tests/test_main.py

{mkv_episode_matcher-0.3.4 → mkv_episode_matcher-0.3.6}/pyproject.toml

@@ -47,6 +47,7 @@ dev = [
     "pytest-cov>=6.0.0",
     "pytest>=8.3.3",
     "ruff>=0.8.0",
+    "chardet>=5.2.0",
 ]
 
 

{mkv_episode_matcher-0.3.4 → mkv_episode_matcher-0.3.6}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = mkv_episode_matcher
-version = 0.3.4
+version = 0.3.6
 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.3.4 → mkv_episode_matcher-0.3.6}/tests/test_main.py

@@ -13,6 +13,31 @@ from mkv_episode_matcher.utils import (
 )
 from mkv_episode_matcher.episode_identification import EpisodeMatcher
 from mkv_episode_matcher.config import get_config, set_config
+from unittest.mock import Mock, patch
+
+
+# @pytest.fixture
+# def mock_config():
+#     return {
+#         "tmdb_api_key": "test_key",
+#         "show_dir": "/test/path",
+#         "max_threads": 4,
+#         "tesseract_path": "/usr/bin/tesseract",
+#     }
+
+
+@pytest.fixture
+def mock_episode_data():
+    return {
+        "name": "Test Episode",
+        "season_number": 1,
+        "episode_number": 1,
+        "overview": "Test overview",
+    }
+
+@pytest.fixture
+def mock_seasons():
+    return ["/test/path/Season 1"]
 
 @pytest.fixture
 def temp_show_dir(tmp_path):
@@ -101,8 +126,8 @@ class TestEpisodeMatcher:
         return EpisodeMatcher(tmp_path, "Test Show")
 
     def test_clean_text(self, matcher):
-        text = "Test [action] <tag> T-t-test"
-        assert matcher.clean_text(text) == "test action tag test"
+        text = "Test [action] T-t-test"
+        assert matcher.clean_text(text) == "test action test"
 
     def test_chunk_score(self, matcher):
         score = matcher.chunk_score("Test dialogue", "test dialog")
@@ -116,22 +141,27 @@ class TestEpisodeMatcher:
         assert isinstance(chunk, str)
         assert mock_run.called
 
-class TestProcessShow:
-    @patch('mkv_episode_matcher.episode_matcher.get_valid_seasons')
-    @patch('mkv_episode_matcher.episode_matcher.get_config')
-    def test_process_show_no_seasons(self, mock_config, mock_seasons, mock_config_data):
-        mock_seasons.return_value = []
-        mock_config.return_value = mock_config_data
-        process_show()
-        mock_seasons.assert_called_once()
-
-    @patch('mkv_episode_matcher.episode_matcher.get_valid_seasons')
-    @patch('mkv_episode_matcher.episode_matcher.get_config')
-    def test_process_show_with_season(self, mock_config, mock_seasons, temp_show_dir, mock_config_data):
-        mock_seasons.return_value = [str(temp_show_dir / "Season 1")]
-        mock_config.return_value = mock_config_data
-        process_show(season=1)
-        mock_seasons.assert_called_once()
+class TestEpisodeMatcher:
+    def test_extract_season_episode(self):
+        from mkv_episode_matcher.utils import extract_season_episode
+
+        # Test valid filename
+        assert extract_season_episode("Show - S01E02.mkv") == (1, 2)
+
+        # Test invalid filename
+        assert extract_season_episode("invalid.mkv") == (None, None)
+
+    @patch("mkv_episode_matcher.tmdb_client.requests.get")
+    def test_fetch_show_id(self, mock_get):
+        from mkv_episode_matcher.tmdb_client import fetch_show_id
+
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"results": [{"id": 12345}]}
+        mock_get.return_value = mock_response
+
+        assert fetch_show_id("Test Show") == "12345"
+
 
 if __name__ == '__main__':
     pytest.main(['-v'])

{mkv_episode_matcher-0.3.4 → mkv_episode_matcher-0.3.6}/uv.lock

@@ -24,6 +24,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/12/90/3c9ff0512038035f59d279fddeb79f5f1eccd8859f06d6163c58798b9487/certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8", size = 167321 },
 ]
 
+[[package]]
+name = "chardet"
+version = "5.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/0d/f7b6ab21ec75897ed80c17d79b15951a719226b9fababf1e40ea74d69079/chardet-5.2.0.tar.gz", hash = "sha256:1b3b6ff479a8c414bc3fa2c0852995695c4a026dcd6d0633b2dd092ca39c1cf7", size = 2069618 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/6f/f5fbc992a329ee4e0f288c1fe0e2ad9485ed064cac731ed2fe47dcc38cbf/chardet-5.2.0-py3-none-any.whl", hash = "sha256:e1cf59446890a00105fe7b7912492ea04b6e6f06d4b742b2c788469e34c82970", size = 199385 },
+]
+
 [[package]]
 name = "charset-normalizer"
 version = "3.4.0"
@@ -374,7 +383,7 @@ wheels = [
 
 [[package]]
 name = "mkv-episode-matcher"
-version = "0.3.3.post1.dev0+g40bb202.d20241207"
+version = "0.3.5.post1.dev0+g1beb2cf.d20250112"
 source = { editable = "." }
 dependencies = [
     { name = "configparser" },
@@ -391,6 +400,7 @@ dependencies = [
 
 [package.dev-dependencies]
 dev = [
+    { name = "chardet" },
     { name = "pytest" },
     { name = "pytest-cov" },
     { name = "ruff" },
@@ -412,6 +422,7 @@ requires-dist = [
 
 [package.metadata.requires-dev]
 dev = [
+    { name = "chardet", specifier = ">=5.2.0" },
     { name = "pytest", specifier = ">=8.3.3" },
     { name = "pytest-cov", specifier = ">=6.0.0" },
     { name = "ruff", specifier = ">=0.8.0" },

mkv_episode_matcher-0.3.4/mkv_episode_matcher/episode_identification.py

@@ -1,150 +0,0 @@
-import json
-import os
-import subprocess
-import tempfile
-from pathlib import Path
-import torch
-from rapidfuzz import fuzz
-from loguru import logger
-import whisper
-import numpy as np
-import re
-class EpisodeMatcher:
-    def __init__(self, cache_dir, show_name, min_confidence=0.6):
-        self.cache_dir = Path(cache_dir)
-        self.min_confidence = min_confidence
-        self.show_name = show_name
-        self.chunk_duration = 300  # 5 minutes
-        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)
-        
-    def clean_text(self, text):
-        text = text.lower().strip()
-        text = re.sub(r'\[.*?\]|\<.*?\>', '', text)
-        text = re.sub(r'([A-Za-z])-\1+', r'\1', text)
-        return ' '.join(text.split())
-
-    def chunk_score(self, whisper_chunk, ref_chunk):
-        whisper_clean = self.clean_text(whisper_chunk)
-        ref_clean = self.clean_text(ref_chunk)
-        return (fuzz.token_sort_ratio(whisper_clean, ref_clean) * 0.7 + 
-                fuzz.partial_ratio(whisper_clean, ref_clean) * 0.3) / 100.0
-
-    def extract_audio_chunk(self, mkv_file, start_time):
-        """Extract a chunk of audio from MKV file."""
-        chunk_path = self.temp_dir / f"chunk_{start_time}.wav"
-        if not chunk_path.exists():
-            cmd = [
-                'ffmpeg',
-                '-ss', str(start_time),
-                '-t', str(self.chunk_duration),
-                '-i', mkv_file,
-                '-vn',
-                '-acodec', 'pcm_s16le',
-                '-ar', '16000',
-                '-ac', '1',
-                str(chunk_path)
-            ]
-            subprocess.run(cmd, capture_output=True)
-        return str(chunk_path)
-
-    def load_reference_chunk(self, srt_file, chunk_idx):
-        """Load reference subtitles for a specific time 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()
-            
-        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)
-
-    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())
-            
-            total_chunks = int(np.ceil(duration / self.chunk_duration))
-            
-            # Load Whisper model
-            model = whisper.load_model("base", device=self.device)
-            
-            # Get season-specific reference files
-            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
-            ]
-            
-            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),
-                            }
-            
-            return None
-            
-        finally:
-            # Cleanup temp files
-            for file in self.temp_dir.glob("chunk_*.wav"):
-                file.unlink()

mkv_episode_matcher-0.3.4/tests/test_improvements.py

@@ -1,59 +0,0 @@
-from unittest.mock import Mock, patch
-
-import pytest
-
-
-@pytest.fixture
-def mock_config():
-    return {
-        "tmdb_api_key": "test_key",
-        "show_dir": "/test/path",
-        "max_threads": 4,
-        "tesseract_path": "/usr/bin/tesseract",
-    }
-
-
-@pytest.fixture
-def mock_episode_data():
-    return {
-        "name": "Test Episode",
-        "season_number": 1,
-        "episode_number": 1,
-        "overview": "Test overview",
-    }
-
-
-class TestEpisodeMatcher:
-    def test_extract_season_episode(self):
-        from mkv_episode_matcher.episode_matcher import extract_season_episode
-
-        # Test valid filename
-        assert extract_season_episode("Show - S01E02.mkv") == (1, 2)
-
-        # Test invalid filename
-        assert extract_season_episode("invalid.mkv") == (None, None)
-
-    @patch("mkv_episode_matcher.tmdb_client.requests.get")
-    def test_fetch_show_id(self, mock_get):
-        from mkv_episode_matcher.tmdb_client import fetch_show_id
-
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.json.return_value = {"results": [{"id": 12345}]}
-        mock_get.return_value = mock_response
-
-        assert fetch_show_id("Test Show") == "12345"
-
-    @patch("mkv_episode_matcher.utils.OpenSubtitles")
-    def test_get_subtitles(self, mock_subtitles):
-        from mkv_episode_matcher.utils import get_subtitles
-
-        # Test subtitle download
-        mock_subtitles.return_value.search.return_value.data = [
-            {"file_name": "Test.Show.S01E01.srt"}
-        ]
-
-        with patch("pathlib.Path.exists", return_value=False):
-            get_subtitles(12345, {1})
-
-            mock_subtitles.return_value.download_and_save.assert_called_once()