mkv-episode-matcher 0.9.2__py3-none-any.whl → 0.9.3__py3-none-any.whl

mkv_episode_matcher/__main__.py

@@ -7,7 +7,6 @@ from typing import Optional
 from loguru import logger
 from rich.console import Console
 from rich.panel import Panel
-from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.prompt import Confirm, Prompt
 
 from mkv_episode_matcher import __version__
@@ -62,15 +61,17 @@ def print_welcome_message():
     console.print()
 
 
-def confirm_api_key(config_value: Optional[str], key_name: str, description: str) -> str:
+def confirm_api_key(
+    config_value: Optional[str], key_name: str, description: str
+) -> str:
     """
     Confirm if the user wants to use an existing API key or enter a new one.
-    
+
     Args:
         config_value: The current value from the config
         key_name: The name of the key
         description: Description of the key for user information
-        
+
     Returns:
         The API key to use
     """
@@ -79,7 +80,7 @@ def confirm_api_key(config_value: Optional[str], key_name: str, description: str
         console.print(f"Current value: [green]{mask_api_key(config_value)}[/green]")
         if Confirm.ask("Use existing key?", default=True):
             return config_value
-    
+
     return Prompt.ask(f"Enter your {key_name}")
 
 
@@ -95,10 +96,10 @@ def mask_api_key(key: str) -> str:
 def select_season(seasons):
     """
     Allow user to select a season from a list.
-    
+
     Args:
         seasons: List of available seasons
-        
+
     Returns:
         Selected season number or None for all seasons
     """
@@ -106,21 +107,51 @@ def select_season(seasons):
     for i, season in enumerate(seasons, 1):
         season_num = Path(season).name.replace("Season ", "")
         console.print(f"  {i}. Season {season_num}")
-    
-    console.print(f"  0. All Seasons")
-    
+
+    console.print("  0. All Seasons")
+
     choice = Prompt.ask(
         "Select a season number (0 for all)",
         choices=[str(i) for i in range(len(seasons) + 1)],
-        default="0"
+        default="0",
     )
-    
+
     if int(choice) == 0:
         return None
-    
+
     selected_season = seasons[int(choice) - 1]
     return int(Path(selected_season).name.replace("Season ", ""))
 
+def onboarding(config_path):
+    """Prompt user for all required config values, showing existing as defaults."""
+    config = get_config(config_path) if config_path.exists() else {}
+
+    def ask_with_default(prompt_text, key, description, secret=False):
+        current = config.get(key)
+        if current:
+            console.print(f"[cyan]{key}:[/cyan] {description}")
+            console.print(f"Current value: [green]{mask_api_key(current) if secret else current}[/green]")
+            if Confirm.ask("Use existing value?", default=True):
+                return current
+        return Prompt.ask(f"Enter your {key}", default=current or "")
+
+    tmdb_api_key = ask_with_default("TMDb API key", "tmdb_api_key", "Used to lookup show and episode information. To get your API key, create an account at https://www.themoviedb.org/ and follow the instructions at https://developer.themoviedb.org/docs/getting-started", secret=True)
+    open_subtitles_username = ask_with_default("OpenSubtitles Username", "open_subtitles_username", "Account username for OpenSubtitles. To create an account, visit https://www.opensubtitles.com/ then click 'Register'")
+    open_subtitles_password = ask_with_default("OpenSubtitles Password", "open_subtitles_password", "Account password for OpenSubtitles", secret=True)
+    open_subtitles_user_agent = ask_with_default("OpenSubtitles Consumer Name", "open_subtitles_user_agent", "Required for subtitle downloads. Go to https://www.opensubtitles.com/en/consumers, click 'New Consumer', give it a name, then click 'Save'")
+    open_subtitles_api_key = ask_with_default("OpenSubtitles API key", "open_subtitles_api_key", "Required for subtitle downloads. Enter the API key linked with the OpenSubtitles Consumer that you created in the previous step.", secret=True)
+    show_dir = ask_with_default("Show Directory", "show_dir", "Main directory of the show")
+
+    set_config(
+        tmdb_api_key,
+        open_subtitles_api_key,
+        open_subtitles_user_agent,
+        open_subtitles_username,
+        open_subtitles_password,
+        show_dir,
+        config_path,
+    )
+    console.print("[bold green]Onboarding complete! Configuration saved.[/bold green]")
 
 @logger.catch
 def main():
@@ -165,7 +196,8 @@ def main():
         help="Check if GPU is available for faster processing",
     )
     parser.add_argument(
-        "--verbose", "-v",
+        "--verbose",
+        "-v",
         action="store_true",
         help="Enable verbose output",
     )
@@ -175,22 +207,30 @@ def main():
         default=0.7,
         help="Set confidence threshold for episode matching (0.0-1.0)",
     )
-    
+    parser.add_argument(
+        "--onboard",
+        action="store_true",
+        help="Run onboarding to set up configuration",
+    )
     args = parser.parse_args()
     if args.verbose:
         console.print("[bold cyan]Command-line Arguments[/bold cyan]")
         console.print(args)
     if args.check_gpu:
         from mkv_episode_matcher.utils import check_gpu_support
+
         with console.status("[bold green]Checking GPU support..."):
             check_gpu_support()
         return
 
-    
     logger.debug(f"Command-line arguments: {args}")
-
-    # Load configuration once
-    config = get_config(CONFIG_FILE)
+    # Onboarding: run if --onboard or config file missing
+    if args.onboard or not CONFIG_FILE.exists():
+        onboarding(CONFIG_FILE)
+        # Reload config after onboarding
+        config = get_config(CONFIG_FILE)
+    else:
+        config = get_config(CONFIG_FILE)
 
     # Get TMDb API key
     tmdb_api_key = args.tmdb_api_key or config.get("tmdb_api_key")
@@ -202,49 +242,49 @@ def main():
 
     if args.get_subs:
         console.print("[bold cyan]Subtitle Download Configuration[/bold cyan]")
-        
+
         tmdb_api_key = confirm_api_key(
-            tmdb_api_key, 
-            "TMDb API key", 
-            "Used to lookup show and episode information"
+            tmdb_api_key, "TMDb API key", "Used to lookup show and episode information"
         )
-        
+
         open_subtitles_api_key = confirm_api_key(
             open_subtitles_api_key,
             "OpenSubtitles API key",
-            "Required for subtitle downloads"
+            "Required for subtitle downloads",
         )
-        
+
         open_subtitles_user_agent = confirm_api_key(
             open_subtitles_user_agent,
             "OpenSubtitles User Agent",
-            "Required for subtitle downloads"
+            "Required for subtitle downloads",
         )
-        
+
         open_subtitles_username = confirm_api_key(
             open_subtitles_username,
             "OpenSubtitles Username",
-            "Account username for OpenSubtitles"
+            "Account username for OpenSubtitles",
         )
-        
+
         open_subtitles_password = confirm_api_key(
             open_subtitles_password,
             "OpenSubtitles Password",
-            "Account password for OpenSubtitles"
+            "Account password for OpenSubtitles",
         )
 
     # Use config for show directory
     show_dir = args.show_dir or config.get("show_dir")
     if not show_dir:
         show_dir = Prompt.ask("Enter the main directory of the show")
-    
+
     logger.info(f"Show Directory: {show_dir}")
     if not Path(show_dir).exists():
-        console.print(f"[bold red]Error:[/bold red] Show directory '{show_dir}' does not exist.")
+        console.print(
+            f"[bold red]Error:[/bold red] Show directory '{show_dir}' does not exist."
+        )
         return
-    
+
     if not show_dir:
-        show_dir = os.getcwd()
+        show_dir = Path.cwd()
         console.print(f"Using current directory: [cyan]{show_dir}[/cyan]")
 
     logger.debug(f"Show Directory: {show_dir}")
@@ -274,25 +314,27 @@ def main():
                 border_style="yellow",
             )
         )
-    
+
     seasons = get_valid_seasons(show_dir)
     if not seasons:
-        console.print("[bold red]Error:[/bold red] No seasons with .mkv files found in the show directory.")
+        console.print(
+            "[bold red]Error:[/bold red] No seasons with .mkv files found in the show directory."
+        )
         return
-    
+
     # If season wasn't specified and there are multiple seasons, let user choose
     selected_season = args.season
     if selected_season is None and len(seasons) > 1:
         selected_season = select_season(seasons)
-    
+
     # Show what's going to happen
     show_name = Path(show_dir).name
     season_text = f"Season {selected_season}" if selected_season else "all seasons"
-    
+
     console.print(
         f"[bold green]Processing[/bold green] [cyan]{show_name}[/cyan], {season_text}"
     )
-    
+
     # # Setup progress spinner
     # with Progress(
     #     TextColumn("[bold green]Processing...[/bold green]"),
@@ -300,15 +342,15 @@ def main():
     # ) as progress:
     #     task = progress.add_task("", total=None)
     process_show(
-        selected_season, 
-        dry_run=args.dry_run, 
-        get_subs=args.get_subs, 
+        selected_season,
+        dry_run=args.dry_run,
+        get_subs=args.get_subs,
         verbose=args.verbose,
-        confidence=args.confidence
+        confidence=args.confidence,
     )
-    
+
     console.print("[bold green]✓[/bold green] Processing completed successfully!")
-    
+
     # Show where logs are stored
     console.print(f"\n[dim]Logs available at: {log_dir}[/dim]")
 
@@ -323,4 +365,4 @@ if __name__ == "__main__":
     except Exception as e:
         console.print(f"\n[bold red]Error:[/bold red] {str(e)}")
         logger.exception("Unhandled exception")
-        sys.exit(1)
+        sys.exit(1)

mkv_episode_matcher/episode_identification.py

@@ -1,27 +1,30 @@
 import re
 import subprocess
 import tempfile
+from functools import lru_cache
 from pathlib import Path
-from rich import print
-from rich.console import Console
+
 import chardet
 import numpy as np
 import torch
 import whisper
 from loguru import logger
 from rapidfuzz import fuzz
+from rich import print
+from rich.console import Console
+
 from mkv_episode_matcher.utils import extract_season_episode
-from functools import lru_cache
 
 console = Console()
 
+
 class SubtitleCache:
     """Cache for storing parsed subtitle data to avoid repeated loading and parsing."""
-    
+
     def __init__(self):
         self.subtitles = {}  # {file_path: parsed_content}
         self.chunk_cache = {}  # {(file_path, chunk_idx): text}
-    
+
     def get_subtitle_content(self, srt_file):
         """Get the full content of a subtitle file, loading it only once."""
         srt_file = str(srt_file)
@@ -29,18 +32,18 @@ class SubtitleCache:
             reader = SubtitleReader()
             self.subtitles[srt_file] = reader.read_srt_file(srt_file)
         return self.subtitles[srt_file]
-    
+
     def get_chunk(self, srt_file, chunk_idx, chunk_start, chunk_end):
         """Get a specific time chunk from a subtitle file, with caching."""
         srt_file = str(srt_file)
         cache_key = (srt_file, chunk_idx)
-        
+
         if cache_key not in self.chunk_cache:
             content = self.get_subtitle_content(srt_file)
             reader = SubtitleReader()
             text_lines = reader.extract_subtitle_chunk(content, chunk_start, chunk_end)
             self.chunk_cache[cache_key] = " ".join(text_lines)
-            
+
         return self.chunk_cache[cache_key]
 
 
@@ -78,10 +81,10 @@ class EpisodeMatcher:
     def extract_audio_chunk(self, mkv_file, start_time):
         """Extract a chunk of audio from MKV file with caching."""
         cache_key = (str(mkv_file), start_time)
-        
+
         if cache_key in self.audio_chunks:
             return self.audio_chunks[cache_key]
-            
+
         chunk_path = self.temp_dir / f"chunk_{start_time}.wav"
         if not chunk_path.exists():
             cmd = [
@@ -105,7 +108,7 @@ class EpisodeMatcher:
                 str(chunk_path),
             ]
             subprocess.run(cmd, capture_output=True)
-        
+
         chunk_path_str = str(chunk_path)
         self.audio_chunks[cache_key] = chunk_path_str
         return chunk_path_str
@@ -125,9 +128,11 @@ class EpisodeMatcher:
             # Apply the same offset as in _try_match_with_model
             chunk_start = self.skip_initial_duration + (chunk_idx * self.chunk_duration)
             chunk_end = chunk_start + self.chunk_duration
-            
-            return self.subtitle_cache.get_chunk(srt_file, chunk_idx, chunk_start, chunk_end)
-            
+
+            return self.subtitle_cache.get_chunk(
+                srt_file, chunk_idx, chunk_start, chunk_end
+            )
+
         except Exception as e:
             logger.error(f"Error loading reference chunk from {srt_file}: {e}")
             return ""
@@ -136,11 +141,11 @@ class EpisodeMatcher:
         """Get reference subtitle files with caching."""
         cache_key = (self.show_name, season_number)
         logger.debug(f"Reference cache key: {cache_key}")
-        
+
         if cache_key in self.reference_files_cache:
             logger.debug("Returning cached reference files")
             return self.reference_files_cache[cache_key]
-            
+
         reference_dir = self.cache_dir / "data" / self.show_name
         patterns = [
             f"S{season_number:02d}E",
@@ -154,15 +159,15 @@ class EpisodeMatcher:
             files = [
                 f
                 for f in reference_dir.glob("*.srt")
-                if any(
-                    re.search(f"{p}\\d+", f.name, re.IGNORECASE) for p in patterns
-                )
+                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))
-        logger.debug(f"Found {len(reference_files)} reference files for season {season_number}")
+        logger.debug(
+            f"Found {len(reference_files)} reference files for season {season_number}"
+        )
         self.reference_files_cache[cache_key] = reference_files
         return reference_files
 
@@ -183,7 +188,9 @@ class EpisodeMatcher:
         model = get_whisper_model(model_name, self.device)
 
         # Calculate number of chunks to check
-        num_chunks = min(max_duration // self.chunk_duration, 10)  # Limit to 10 chunks for initial check
+        num_chunks = min(
+            max_duration // self.chunk_duration, 10
+        )  # Limit to 10 chunks for initial check
 
         # Pre-load all reference chunks for the chunks we'll check
         for chunk_idx in range(num_chunks):
@@ -200,11 +207,14 @@ class EpisodeMatcher:
 
             result = model.transcribe(audio_path, task="transcribe", language="en")
 
-
             chunk_text = result["text"]
-            logger.debug(f"Transcription result: {chunk_text} ({len(chunk_text)} characters)")
+            logger.debug(
+                f"Transcription result: {chunk_text} ({len(chunk_text)} characters)"
+            )
             if len(chunk_text) < 10:
-                logger.debug(f"Transcription result too short: {chunk_text} ({len(chunk_text)} characters)")
+                logger.debug(
+                    f"Transcription result too short: {chunk_text} ({len(chunk_text)} characters)"
+                )
                 continue
             best_confidence = 0
             best_match = None
@@ -220,13 +230,17 @@ class EpisodeMatcher:
                     best_match = Path(ref_file)
 
                 if confidence > self.min_confidence:
-                    print(f"Matched with {best_match} (confidence: {best_confidence:.2f})")
+                    print(
+                        f"Matched with {best_match} (confidence: {best_confidence:.2f})"
+                    )
                     try:
                         season, episode = extract_season_episode(best_match.stem)
                     except Exception as e:
                         print(f"Error extracting season/episode: {e}")
                         continue
-                    print(f"Season: {season}, Episode: {episode} (confidence: {best_confidence:.2f})")
+                    print(
+                        f"Season: {season}, Episode: {episode} (confidence: {best_confidence:.2f})"
+                    )
                     if season and episode:
                         return {
                             "season": season,
@@ -250,16 +264,21 @@ class EpisodeMatcher:
             if not reference_files:
                 logger.error(f"No reference files found for season {season_number}")
                 return None
-                
+
             # Cache video duration
             duration = get_video_duration(video_file)
 
             # Try with tiny model first (fastest)
             logger.info("Attempting match with tiny model...")
             match = self._try_match_with_model(
-                video_file, "tiny.en", min(duration, 300), reference_files  # Limit to first 5 minutes
+                video_file,
+                "tiny.en",
+                min(duration, 300),
+                reference_files,  # Limit to first 5 minutes
             )
-            if match and match["confidence"] > 0.65:  # Slightly lower threshold for tiny
+            if (
+                match and match["confidence"] > 0.65
+            ):  # Slightly lower threshold for tiny
                 logger.info(
                     f"Successfully matched with tiny model at {match['matched_at']}s (confidence: {match['confidence']:.2f})"
                 )
@@ -270,7 +289,10 @@ class EpisodeMatcher:
                 "No match with tiny model, extending base model search to 5 minutes..."
             )
             match = self._try_match_with_model(
-                video_file, "base.en", min(duration, 300), reference_files  # Limit to first 5 minutes
+                video_file,
+                "base.en",
+                min(duration, 300),
+                reference_files,  # Limit to first 5 minutes
             )
             if match:
                 logger.info(
@@ -320,7 +342,9 @@ def detect_file_encoding(file_path):
     """
     try:
         with open(file_path, "rb") as f:
-            raw_data = f.read(min(1024 * 1024, Path(file_path).stat().st_size))  # Read up to 1MB
+            raw_data = f.read(
+                min(1024 * 1024, Path(file_path).stat().st_size)
+            )  # Read up to 1MB
         result = chardet.detect(raw_data)
         encoding = result["encoding"]
         confidence = result["confidence"]
@@ -421,10 +445,10 @@ class SubtitleReader:
                 time_parts = timestamp.split(" --> ")
                 start_stamp = time_parts[0].strip()
                 end_stamp = time_parts[1].strip()
-                
+
                 subtitle_start = SubtitleReader.parse_timestamp(start_stamp)
                 subtitle_end = SubtitleReader.parse_timestamp(end_stamp)
-                
+
                 # Check if this subtitle overlaps with our chunk
                 if subtitle_end >= start_time and subtitle_start <= end_time:
                     text = " ".join(lines[2:])
@@ -440,6 +464,7 @@ class SubtitleReader:
 # Global whisper model cache with better cache key
 _whisper_models = {}
 
+
 def get_whisper_model(model_name="tiny", device=None):
     """Cache whisper models to avoid reloading."""
     global _whisper_models
@@ -451,4 +476,4 @@ def get_whisper_model(model_name="tiny", device=None):
         _whisper_models[key] = whisper.load_model(model_name, device=device)
         logger.info(f"Loaded {model_name} model on {device}")
 
-    return _whisper_models[key]
+    return _whisper_models[key]

mkv_episode_matcher/episode_matcher.py

@@ -4,9 +4,8 @@ import re
 import shutil
 from pathlib import Path
 
-from loguru import logger
 from rich.console import Console
-from rich.progress import Progress, BarColumn, TextColumn, TimeElapsedColumn
+from rich.progress import BarColumn, Progress, TextColumn, TimeElapsedColumn
 
 from mkv_episode_matcher.__main__ import CACHE_DIR, CONFIG_FILE
 from mkv_episode_matcher.config import get_config
@@ -25,10 +24,12 @@ from mkv_episode_matcher.utils import (
 console = Console()
 
 
-def process_show(season=None, dry_run=False, get_subs=False, verbose=False, confidence=0.6):
+def process_show(
+    season=None, dry_run=False, get_subs=False, verbose=False, confidence=0.6
+):
     """
     Process the show using streaming speech recognition with improved UI feedback.
-    
+
     Args:
         season (int, optional): Season number to process. Defaults to None (all seasons).
         dry_run (bool): If True, only simulate actions without making changes.
@@ -48,7 +49,9 @@ def process_show(season=None, dry_run=False, get_subs=False, verbose=False, conf
         console.print(
             f"[bold yellow]Warning:[/bold yellow] No reference subtitle files found in {reference_dir}"
         )
-        console.print("[cyan]Tip:[/cyan] Use --get-subs to download reference subtitles")
+        console.print(
+            "[cyan]Tip:[/cyan] Use --get-subs to download reference subtitles"
+        )
         return
 
     season_paths = get_valid_seasons(show_dir)
@@ -59,7 +62,9 @@ def process_show(season=None, dry_run=False, get_subs=False, verbose=False, conf
     if season is not None:
         season_path = str(Path(show_dir) / f"Season {season}")
         if season_path not in season_paths:
-            console.print(f"[bold red]Error:[/bold red] Season {season} has no .mkv files to process")
+            console.print(
+                f"[bold red]Error:[/bold red] Season {season} has no .mkv files to process"
+            )
             return
         season_paths = [season_path]
 
@@ -68,8 +73,7 @@ def process_show(season=None, dry_run=False, get_subs=False, verbose=False, conf
 
     for season_path in season_paths:
         mkv_files = [
-            f for f in Path(season_path).glob("*.mkv")
-            if not check_filename(f)
+            f for f in Path(season_path).glob("*.mkv") if not check_filename(f)
         ]
 
         if not mkv_files:
@@ -77,7 +81,7 @@ def process_show(season=None, dry_run=False, get_subs=False, verbose=False, conf
             console.print(f"[dim]No new files to process in Season {season_num}[/dim]")
             continue
 
-        season_num = int(re.search(r'Season (\d+)', season_path).group(1))
+        season_num = int(re.search(r"Season (\d+)", season_path).group(1))
         temp_dir = Path(season_path) / "temp"
         temp_dir.mkdir(exist_ok=True)
 
@@ -85,13 +89,19 @@ def process_show(season=None, dry_run=False, get_subs=False, verbose=False, conf
             if get_subs:
                 show_id = fetch_show_id(matcher.show_name)
                 if show_id:
-                    console.print(f"[bold cyan]Downloading subtitles for Season {season_num}...[/bold cyan]")
+                    console.print(
+                        f"[bold cyan]Downloading subtitles for Season {season_num}...[/bold cyan]"
+                    )
                     get_subtitles(show_id, seasons={season_num}, config=config)
                 else:
-                    console.print("[bold red]Error:[/bold red] Could not find show ID. Skipping subtitle download.")
+                    console.print(
+                        "[bold red]Error:[/bold red] Could not find show ID. Skipping subtitle download."
+                    )
+
+            console.print(
+                f"[bold cyan]Processing {len(mkv_files)} files in Season {season_num}...[/bold cyan]"
+            )
 
-            console.print(f"[bold cyan]Processing {len(mkv_files)} files in Season {season_num}...[/bold cyan]")
-            
             # Process files with a progress bar
             with Progress(
                 TextColumn("[progress.description]{task.description}"),
@@ -100,24 +110,30 @@ def process_show(season=None, dry_run=False, get_subs=False, verbose=False, conf
                 TimeElapsedColumn(),
                 console=console,
             ) as progress:
-                task = progress.add_task(f"[cyan]Matching Season {season_num}[/cyan]", total=len(mkv_files))
-                
+                task = progress.add_task(
+                    f"[cyan]Matching Season {season_num}[/cyan]", total=len(mkv_files)
+                )
+
                 for mkv_file in mkv_files:
                     file_basename = Path(mkv_file).name
-                    progress.update(task, description=f"[cyan]Processing[/cyan] {file_basename}")
-                    
+                    progress.update(
+                        task, description=f"[cyan]Processing[/cyan] {file_basename}"
+                    )
+
                     if verbose:
                         console.print(f"  Analyzing {file_basename}...")
-                    
+
                     total_processed += 1
                     match = matcher.identify_episode(mkv_file, temp_dir, season_num)
 
                     if match:
                         total_matched += 1
                         new_name = f"{matcher.show_name} - S{match['season']:02d}E{match['episode']:02d}.mkv"
-                        
-                        confidence_color = "green" if match['confidence'] > 0.8 else "yellow"
-                        
+
+                        confidence_color = (
+                            "green" if match["confidence"] > 0.8 else "yellow"
+                        )
+
                         if verbose or dry_run:
                             console.print(
                                 f"  Match: [bold]{file_basename}[/bold] → [bold cyan]{new_name}[/bold cyan] "
@@ -128,24 +144,30 @@ def process_show(season=None, dry_run=False, get_subs=False, verbose=False, conf
                             rename_episode_file(mkv_file, new_name)
                     else:
                         if verbose:
-                            console.print(f"  [yellow]No match found for {file_basename}[/yellow]")
-                    
+                            console.print(
+                                f"  [yellow]No match found for {file_basename}[/yellow]"
+                            )
+
                     progress.advance(task)
         finally:
             if not dry_run and temp_dir.exists():
                 shutil.rmtree(temp_dir)
-    
+
     # Summary
     console.print()
     if total_processed == 0:
         console.print("[yellow]No files needed processing[/yellow]")
     else:
         console.print(f"[bold]Summary:[/bold] Processed {total_processed} files")
-        console.print(f"[bold green]Successfully matched:[/bold green] {total_matched} files")
-        
+        console.print(
+            f"[bold green]Successfully matched:[/bold green] {total_matched} files"
+        )
+
         if total_matched < total_processed:
-            console.print(f"[bold yellow]Unmatched:[/bold yellow] {total_processed - total_matched} files")
+            console.print(
+                f"[bold yellow]Unmatched:[/bold yellow] {total_processed - total_matched} files"
+            )
             console.print(
                 "[cyan]Tip:[/cyan] Try downloading subtitles with --get-subs or "
                 "check that your files are named consistently"
-            )
+            )

mkv_episode_matcher/utils.py

@@ -1,7 +1,7 @@
 # utils.py
+import os
 import re
 import shutil
-import os
 from pathlib import Path
 
 import requests
@@ -11,7 +11,7 @@ from opensubtitlescom import OpenSubtitles
 from opensubtitlescom.exceptions import OpenSubtitlesException
 from rich.console import Console
 from rich.panel import Panel
-from rich.progress import Progress, SpinnerColumn, TextColumn
+
 from mkv_episode_matcher.__main__ import CACHE_DIR, CONFIG_FILE
 from mkv_episode_matcher.config import get_config
 from mkv_episode_matcher.subtitle_utils import find_existing_subtitle, sanitize_filename
@@ -24,29 +24,30 @@ def normalize_path(path_str):
     """
     Normalize a path string to handle cross-platform path issues.
     Properly handles trailing slashes and backslashes in both Windows and Unix paths.
-    
+
     Args:
         path_str (str): The path string to normalize
-        
+
     Returns:
         pathlib.Path: A normalized Path object
     """
     # Convert to string if it's a Path object
     if isinstance(path_str, Path):
         path_str = str(path_str)
-        
+
     # Remove trailing slashes or backslashes
-    path_str = path_str.rstrip('/').rstrip('\\')
-    
+    path_str = path_str.rstrip("/").rstrip("\\")
+
     # Handle Windows paths on non-Windows platforms
-    if os.name != 'nt' and '\\' in path_str and ':' in path_str[:2]:
+    if os.name != "nt" and "\\" in path_str and ":" in path_str[:2]:
         # This looks like a Windows path on a non-Windows system
         # Extract the last component which should be the directory/file name
-        components = path_str.split('\\')
+        components = path_str.split("\\")
         return Path(components[-1])
-    
+
     return Path(path_str)
 
+
 def get_valid_seasons(show_dir):
     """
     Get all season directories that contain MKV files.
@@ -59,11 +60,7 @@ def get_valid_seasons(show_dir):
     """
     # Get all season directories
     show_path = normalize_path(show_dir)
-    season_paths = [
-        str(show_path / d.name)
-        for d in show_path.iterdir()
-        if d.is_dir()
-    ]
+    season_paths = [str(show_path / d.name) for d in show_path.iterdir() if d.is_dir()]
 
     # Filter seasons to only include those with .mkv files
     valid_season_paths = []
@@ -219,13 +216,13 @@ def get_subtitles(show_id, seasons: set[int], config=None, max_retries=3):
             )
 
             if existing_subtitle:
-                logger.info(
-                    f"Subtitle already exists: {Path(existing_subtitle).name}"
-                )
+                logger.info(f"Subtitle already exists: {Path(existing_subtitle).name}")
                 continue
 
             # Default to standard format for new downloads
-            srt_filepath = str(series_cache_dir / f"{series_name} - S{season:02d}E{episode:02d}.srt")
+            srt_filepath = str(
+                series_cache_dir / f"{series_name} - S{season:02d}E{episode:02d}.srt"
+            )
 
             # get the episode info from TMDB
             url = f"https://api.themoviedb.org/3/tv/{show_id}/season/{season}/episode/{episode}?api_key={tmdb_api_key}"
@@ -245,7 +242,9 @@ def get_subtitles(show_id, seasons: set[int], config=None, max_retries=3):
             for subtitle in response.data:
                 subtitle_dict = subtitle.to_dict()
                 # Remove special characters and convert to uppercase
-                filename_clean = re.sub(r"\\W+", " ", subtitle_dict["file_name"]).upper()
+                filename_clean = re.sub(
+                    r"\\W+", " ", subtitle_dict["file_name"]
+                ).upper()
                 if f"E{episode:02d}" in filename_clean:
                     logger.info(f"Original filename: {subtitle_dict['file_name']}")
                     retry_count = 0
@@ -257,25 +256,43 @@ def get_subtitles(show_id, seasons: set[int], config=None, max_retries=3):
                             break
                         except OpenSubtitlesException as e:
                             retry_count += 1
-                            logger.error(f"OpenSubtitlesException (attempt {retry_count}): {e}")
-                            console.print(f"[red]OpenSubtitlesException (attempt {retry_count}): {e}[/red]")
+                            logger.error(
+                                f"OpenSubtitlesException (attempt {retry_count}): {e}"
+                            )
+                            console.print(
+                                f"[red]OpenSubtitlesException (attempt {retry_count}): {e}[/red]"
+                            )
                             if retry_count >= max_retries:
-                                user_input = input("Would you like to continue matching? (y/n): ")
-                                if user_input.strip().lower() != 'y':
-                                    logger.info("User chose to stop matching due to the error.")
+                                user_input = input(
+                                    "Would you like to continue matching? (y/n): "
+                                )
+                                if user_input.strip().lower() != "y":
+                                    logger.info(
+                                        "User chose to stop matching due to the error."
+                                    )
                                     return
                                 else:
-                                    logger.info("User chose to continue matching despite the error.")
+                                    logger.info(
+                                        "User chose to continue matching despite the error."
+                                    )
                                     break
                         except Exception as e:
                             logger.error(f"Failed to download and save subtitle: {e}")
-                            console.print(f"[red]Failed to download and save subtitle: {e}[/red]")
-                            user_input = input("Would you like to continue matching despite the error? (y/n): ")
-                            if user_input.strip().lower() != 'y':
-                                logger.info("User chose to stop matching due to the error.")
+                            console.print(
+                                f"[red]Failed to download and save subtitle: {e}[/red]"
+                            )
+                            user_input = input(
+                                "Would you like to continue matching despite the error? (y/n): "
+                            )
+                            if user_input.strip().lower() != "y":
+                                logger.info(
+                                    "User chose to stop matching due to the error."
+                                )
                                 return
                             else:
-                                logger.info("User chose to continue matching despite the error.")
+                                logger.info(
+                                    "User chose to continue matching despite the error."
+                                )
                                 break
                     else:
                         continue
@@ -453,7 +470,7 @@ def check_gpu_support():
     if torch.cuda.is_available():
         logger.info(f"CUDA is available. Using GPU: {torch.cuda.get_device_name(0)}")
         console.print(
-        Panel.fit(
+            Panel.fit(
                 f"CUDA is available. Using GPU: {torch.cuda.get_device_name(0)}",
                 title="GPU Support",
                 border_style="magenta",
@@ -464,9 +481,9 @@ def check_gpu_support():
             "CUDA not available. Using CPU. Refer to https://pytorch.org/get-started/locally/ for GPU support."
         )
         console.print(
-        Panel.fit(
-            "CUDA not available. Using CPU. Refer to https://pytorch.org/get-started/locally/ for GPU support.",
-            title="GPU Support",
-            border_style="red",
+            Panel.fit(
+                "CUDA not available. Using CPU. Refer to https://pytorch.org/get-started/locally/ for GPU support.",
+                title="GPU Support",
+                border_style="red",
+            )
         )
-        )

{mkv_episode_matcher-0.9.2.dist-info → mkv_episode_matcher-0.9.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkv-episode-matcher
-Version: 0.9.2
+Version: 0.9.3
 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
@@ -45,15 +45,11 @@ Automatically match and rename your MKV TV episodes using The Movie Database (TM
 
 ## Features
 
-- 🎯 **Automatic Episode Matching**: Uses TMDb to accurately identify episodes
-- 🎨 **Rich User Interface**: Color-coded output and progress indicators
-- 📝 **Subtitle Extraction**: Extracts subtitles from MKV files
-- 🔊 **Speech Recognition**: Uses Whisper for accurate episode identification
-- 🚀 **Multi-threaded**: Fast processing of multiple files
+- 🎯 **Automatic Episode Matching**: Uses TMDb and OpenSubtitles to accurately identify episodes
+- 🔊 **Speech Recognition**: Uses OpenAI Whisper for accurate episode identification
 - ⬇️ **Subtitle Downloads**: Integration with OpenSubtitles
 - ✨ **Bulk Processing**: Handle entire seasons at once
 - 🧪 **Dry Run Mode**: Test changes before applying
-- 🎮 **Interactive Mode**: User-friendly season selection and configuration
 
 ## Prerequisites
 
@@ -66,15 +62,41 @@ Automatically match and rename your MKV TV episodes using The Movie Database (TM
 
 1. Install the package:
 ```bash
-pip install mkv-episode-matcher
+pip install -U mkv-episode-matcher
 ```
-2. Download .srt subtitles files to ~/.mkv-episode-matcher/cache/data/Show Name/
+2. Run onboarding to set up your configuration (first-time users or to update credentials):
+```bash
+mkv-match --onboard
+```
+   - You will be prompted for:
+     - TMDb API key (for episode matching)
+     - OpenSubtitles API key, Consumer Name, Username, and Password (for subtitle downloads)
+     - Show Directory (main directory of your show)
+   - If a config value already exists, you can accept the default or enter a new value.
 
-3. Run on your show directory:
+3. 
+   a. If you setup the TMDb and Opensubtitles credentials above, automatically fetch subtitles with the `--get-subs` flag. 
+   b. Alternatively, manually download .srt subtitles files to ~/.mkv-episode-matcher/cache/data/Show Name/
+
+4. Run on your show directory:
 ```bash
 mkv-match --show-dir "path/to/your/show"
 ```
 
+## Onboarding & Configuration
+
+The onboarding process will prompt you for all required configuration values if you run with `--onboard` or if no config file exists. You can re-run onboarding at any time to update your credentials or show directory.
+
+**Required information:**
+- TMDb API key (for episode matching)
+- OpenSubtitles API key (for subtitle downloads)
+- OpenSubtitles Consumer Name (for subtitle downloads)
+- OpenSubtitles Username (for subtitle downloads)
+- OpenSubtitles Password (for subtitle downloads)
+- Show Directory (main directory of your show)
+
+If a value already exists, it will be shown as the default and you can accept it or enter a new value.
+
 ## Directory Structure
 
 MKV Episode Matcher expects your TV shows to be organized as follows:

mkv_episode_matcher-0.9.3.dist-info/RECORD

@@ -0,0 +1,14 @@
+mkv_episode_matcher/.gitattributes,sha256=Gh2-F2vCM7SZ01pX23UT8pQcmauXWfF3gwyRSb6ZAFs,66
+mkv_episode_matcher/__init__.py,sha256=u3yZcpuK0ICeUjxYKePvW-zS61E5ss5q2AvqnSHuz9E,240
+mkv_episode_matcher/__main__.py,sha256=iYuO2xWt1Xf_MXxJd_XKCrEgpicawE8LlZWtIq9dk90,12380
+mkv_episode_matcher/config.py,sha256=KuKxvKuOrmpCZ80mjykT6oZeD3uArsq6XPioMBrAxuU,2279
+mkv_episode_matcher/episode_identification.py,sha256=YwkH3cmd79I6zFh4nIuv19Kh4N9vXcP8HnZlmUQTA7c,16953
+mkv_episode_matcher/episode_matcher.py,sha256=r6A9K4g4a8yU5aJ42n2yWuVgu5azBRE9FY3kDcdfe3w,6545
+mkv_episode_matcher/subtitle_utils.py,sha256=z4eYTMAoI8BVzdCNeqHu-9mkhwG8RzxE5BbNjWUJwCg,2552
+mkv_episode_matcher/tmdb_client.py,sha256=LbMCgjmp7sCbrQo_CDlpcnryKPz5S7inE24YY9Pyjk4,4172
+mkv_episode_matcher/utils.py,sha256=Q9XFA-EIbMAsUKRtK5z23G1zgJKtxTcD-TkaHQKYIK8,17956
+mkv_episode_matcher-0.9.3.dist-info/METADATA,sha256=lF6Y5I3N17CWo2KkfJelo2cF7syZWtJGwm0_aQ_ZFk0,6362
+mkv_episode_matcher-0.9.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mkv_episode_matcher-0.9.3.dist-info/entry_points.txt,sha256=IglJ43SuCZq2eQ3shMFILCkmQASJHnDCI3ogohW2Hn4,64
+mkv_episode_matcher-0.9.3.dist-info/top_level.txt,sha256=XRLbd93HUaedeWLtkyTvQjFcE5QcBRYa3V-CfHrq-OI,20
+mkv_episode_matcher-0.9.3.dist-info/RECORD,,

mkv_episode_matcher-0.9.2.dist-info/RECORD

@@ -1,14 +0,0 @@
-mkv_episode_matcher/.gitattributes,sha256=Gh2-F2vCM7SZ01pX23UT8pQcmauXWfF3gwyRSb6ZAFs,66
-mkv_episode_matcher/__init__.py,sha256=u3yZcpuK0ICeUjxYKePvW-zS61E5ss5q2AvqnSHuz9E,240
-mkv_episode_matcher/__main__.py,sha256=tIx_lahBMvwIGC_LHYHvCP7ILNIFGyyn0Go2gyaVA-0,10006
-mkv_episode_matcher/config.py,sha256=KuKxvKuOrmpCZ80mjykT6oZeD3uArsq6XPioMBrAxuU,2279
-mkv_episode_matcher/episode_identification.py,sha256=xH5HIa6oC4nXhlqzdqQn1XYQFNUrnbUVlW-R9RsBHq4,16745
-mkv_episode_matcher/episode_matcher.py,sha256=OHtBZd3HnLpANe7HgSvcAQIZjilWgKHVOqfju557NyA,6300
-mkv_episode_matcher/subtitle_utils.py,sha256=z4eYTMAoI8BVzdCNeqHu-9mkhwG8RzxE5BbNjWUJwCg,2552
-mkv_episode_matcher/tmdb_client.py,sha256=LbMCgjmp7sCbrQo_CDlpcnryKPz5S7inE24YY9Pyjk4,4172
-mkv_episode_matcher/utils.py,sha256=N2je7Pc1EaTYHL-lwTPjCThUzpvKfo62QesBJwGaKx8,17405
-mkv_episode_matcher-0.9.2.dist-info/METADATA,sha256=uHnJI9fMFFNDxeKp35E8TPtkmfrrckbuf4Dt17mdnSA,5357
-mkv_episode_matcher-0.9.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mkv_episode_matcher-0.9.2.dist-info/entry_points.txt,sha256=IglJ43SuCZq2eQ3shMFILCkmQASJHnDCI3ogohW2Hn4,64
-mkv_episode_matcher-0.9.2.dist-info/top_level.txt,sha256=XRLbd93HUaedeWLtkyTvQjFcE5QcBRYa3V-CfHrq-OI,20
-mkv_episode_matcher-0.9.2.dist-info/RECORD,,