mkv-episode-matcher 0.8.1__tar.gz → 0.9.0__tar.gz

{mkv_episode_matcher-0.8.1 → mkv_episode_matcher-0.9.0}/.github/workflows/tests.yml

@@ -1,37 +1,30 @@
 name: Tests
-
 on:
   push:
     branches: [main, master]
   pull_request:
     branches: [main, master]
-
 jobs:
   test:
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
         python-version: ["3.9", "3.10", "3.11", "3.12"]
       fail-fast: false
-
     steps:
       - uses: actions/checkout@v4
-
       - name: Install uv and set the python version
         uses: astral-sh/setup-uv@v5
         with:
           enable-cache: true
           cache-dependency-glob: "uv.lock"
           python-version: ${{ matrix.python-version }}
-
       - name: Install the project
         run: uv sync --all-extras --dev
-
       - 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:

mkv_episode_matcher-0.9.0/.python-version

@@ -0,0 +1 @@
+3.11

{mkv_episode_matcher-0.8.1 → mkv_episode_matcher-0.9.0}/CHANGELOG.md

@@ -5,6 +5,23 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.9.0] - 2025-06-01
+
+### Changed
+- Replaced all `os.path` calls with `pathlib.Path` for improved path handling
+- Fixed issues with trailing slashes in directory paths
+- Updated `check_filename` to handle both string paths and Path objects
+- Modernized file and directory operations to use pathlib API
+
+### Enhanced
+- Improved robustness of path manipulation operations
+- Better handling of different path formats across operating systems
+- More consistent behavior with paths containing trailing slashes
+
+### Fixed
+- Fixed bug where paths with trailing slashes would result in empty show names
+- Fixed incorrect handling of paths in subtitle downloads and match operations
+
 ## [0.7.0] - 2025-03-05
 
 ### Added

{mkv_episode_matcher-0.8.1 → mkv_episode_matcher-0.9.0}/PKG-INFO

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

{mkv_episode_matcher-0.8.1 → mkv_episode_matcher-0.9.0}/mkv_episode_matcher/__main__.py

@@ -1,7 +1,7 @@
 # __main__.py (enhanced version)
 import argparse
-import os
 import sys
+from pathlib import Path
 from typing import Optional
 
 from loguru import logger
@@ -20,33 +20,33 @@ console = Console()
 logger.info("Starting the application")
 
 # Check if the configuration directory exists, if not create it
-CONFIG_DIR = os.path.join(os.path.expanduser("~"), ".mkv-episode-matcher")
-if not os.path.exists(CONFIG_DIR):
-    os.makedirs(CONFIG_DIR)
+CONFIG_DIR = Path.home() / ".mkv-episode-matcher"
+if not CONFIG_DIR.exists():
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
 
 # Define the paths for the configuration file and cache directory
-CONFIG_FILE = os.path.join(CONFIG_DIR, "config.ini")
-CACHE_DIR = os.path.join(CONFIG_DIR, "cache")
+CONFIG_FILE = CONFIG_DIR / "config.ini"
+CACHE_DIR = CONFIG_DIR / "cache"
 
 # Check if the cache directory exists, if not create it
-if not os.path.exists(CACHE_DIR):
-    os.makedirs(CACHE_DIR)
+if not CACHE_DIR.exists():
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
 
 # Check if logs directory exists, if not create it
-log_dir = os.path.join(CONFIG_DIR, "logs")
-if not os.path.exists(log_dir):
-    os.mkdir(log_dir)
+log_dir = CONFIG_DIR / "logs"
+if not log_dir.exists():
+    log_dir.mkdir(exist_ok=True)
 logger.remove()
 # Add a new handler for stdout logs
 logger.add(
-    os.path.join(log_dir, "stdout.log"),
+    str(log_dir / "stdout.log"),
     format="{time} {level} {message}",
     level="INFO",
     rotation="10 MB",
 )
 
 # Add a new handler for error logs
-logger.add(os.path.join(log_dir, "stderr.log"), level="ERROR", rotation="10 MB")
+logger.add(str(log_dir / "stderr.log"), level="ERROR", rotation="10 MB")
 
 
 def print_welcome_message():
@@ -104,7 +104,7 @@ def select_season(seasons):
     """
     console.print("[bold cyan]Available Seasons:[/bold cyan]")
     for i, season in enumerate(seasons, 1):
-        season_num = os.path.basename(season).replace("Season ", "")
+        season_num = Path(season).name.replace("Season ", "")
         console.print(f"  {i}. Season {season_num}")
     
     console.print(f"  0. All Seasons")
@@ -119,7 +119,7 @@ def select_season(seasons):
         return None
     
     selected_season = seasons[int(choice) - 1]
-    return int(os.path.basename(selected_season).replace("Season ", ""))
+    return int(Path(selected_season).name.replace("Season ", ""))
 
 
 @logger.catch
@@ -239,7 +239,7 @@ def main():
         show_dir = Prompt.ask("Enter the main directory of the show")
     
     logger.info(f"Show Directory: {show_dir}")
-    if not os.path.exists(show_dir):
+    if not Path(show_dir).exists():
         console.print(f"[bold red]Error:[/bold red] Show directory '{show_dir}' does not exist.")
         return
     
@@ -286,7 +286,7 @@ def main():
         selected_season = select_season(seasons)
     
     # Show what's going to happen
-    show_name = os.path.basename(show_dir)
+    show_name = Path(show_dir).name
     season_text = f"Season {selected_season}" if selected_season else "all seasons"
     
     console.print(

{mkv_episode_matcher-0.8.1 → mkv_episode_matcher-0.9.0}/mkv_episode_matcher/config.py

@@ -1,7 +1,7 @@
 # config.py
 import configparser
 import multiprocessing
-import os
+from pathlib import Path
 
 from loguru import logger
 
@@ -73,7 +73,7 @@ def get_config(file):
     """
     logger.info(f"Loading config from {file}")
     config = configparser.ConfigParser()
-    if os.path.exists(file):
+    if Path(file).exists():
         config.read(file)
         return config["Config"] if "Config" in config else None
     return {}

{mkv_episode_matcher-0.8.1 → mkv_episode_matcher-0.9.0}/mkv_episode_matcher/episode_matcher.py

@@ -1,7 +1,5 @@
 # mkv_episode_matcher/episode_matcher.py
 
-import glob
-import os
 import re
 import shutil
 from pathlib import Path
@@ -19,6 +17,7 @@ from mkv_episode_matcher.utils import (
     clean_text,
     get_subtitles,
     get_valid_seasons,
+    normalize_path,
     rename_episode_file,
 )
 
@@ -39,7 +38,7 @@ def process_show(season=None, dry_run=False, get_subs=False, verbose=False, conf
     """
     config = get_config(CONFIG_FILE)
     show_dir = config.get("show_dir")
-    show_name = clean_text(os.path.basename(show_dir))
+    show_name = clean_text(normalize_path(show_dir).name)
     matcher = EpisodeMatcher(CACHE_DIR, show_name, min_confidence=confidence)
 
     # Early check for reference files
@@ -58,7 +57,7 @@ def process_show(season=None, dry_run=False, get_subs=False, verbose=False, conf
         return
 
     if season is not None:
-        season_path = os.path.join(show_dir, f"Season {season}")
+        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")
             return
@@ -69,12 +68,12 @@ 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 glob.glob(os.path.join(season_path, "*.mkv"))
+            f for f in Path(season_path).glob("*.mkv")
             if not check_filename(f)
         ]
 
         if not mkv_files:
-            season_num = os.path.basename(season_path).replace("Season ", "")
+            season_num = Path(season_path).name.replace("Season ", "")
             console.print(f"[dim]No new files to process in Season {season_num}[/dim]")
             continue
 
@@ -104,7 +103,7 @@ def process_show(season=None, dry_run=False, get_subs=False, verbose=False, conf
                 task = progress.add_task(f"[cyan]Matching Season {season_num}[/cyan]", total=len(mkv_files))
                 
                 for mkv_file in mkv_files:
-                    file_basename = os.path.basename(mkv_file)
+                    file_basename = Path(mkv_file).name
                     progress.update(task, description=f"[cyan]Processing[/cyan] {file_basename}")
                     
                     if verbose:

{mkv_episode_matcher-0.8.1 → mkv_episode_matcher-0.9.0}/mkv_episode_matcher/subtitle_utils.py

@@ -1,5 +1,5 @@
-import os
 import re
+from pathlib import Path
 from typing import Optional
 
 
@@ -55,8 +55,8 @@ def find_existing_subtitle(
     patterns = generate_subtitle_patterns(series_name, season, episode)
 
     for pattern in patterns:
-        filepath = os.path.join(series_cache_dir, pattern)
-        if os.path.exists(filepath):
+        filepath = Path(series_cache_dir) / pattern
+        if filepath.exists():
             return filepath
 
     return None

{mkv_episode_matcher-0.8.1 → mkv_episode_matcher-0.9.0}/mkv_episode_matcher/utils.py

@@ -1,7 +1,8 @@
 # utils.py
-import os
 import re
 import shutil
+import os
+from pathlib import Path
 
 import requests
 import torch
@@ -16,6 +17,35 @@ from mkv_episode_matcher.subtitle_utils import find_existing_subtitle, sanitize_
 from mkv_episode_matcher.tmdb_client import fetch_season_details
 
 console = Console()
+
+
+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('\\')
+    
+    # Handle Windows paths on non-Windows platforms
+    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('\\')
+        return Path(components[-1])
+    
+    return Path(path_str)
+
 def get_valid_seasons(show_dir):
     """
     Get all season directories that contain MKV files.
@@ -27,26 +57,28 @@ def get_valid_seasons(show_dir):
         list: List of paths to valid season directories
     """
     # Get all season directories
+    show_path = normalize_path(show_dir)
     season_paths = [
-        os.path.join(show_dir, d)
-        for d in os.listdir(show_dir)
-        if os.path.isdir(os.path.join(show_dir, d))
+        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 = []
     for season_path in season_paths:
-        mkv_files = [f for f in os.listdir(season_path) if f.endswith(".mkv")]
+        season_path_obj = Path(season_path)
+        mkv_files = [f for f in season_path_obj.iterdir() if f.name.endswith(".mkv")]
         if mkv_files:
             valid_season_paths.append(season_path)
 
     if not valid_season_paths:
         logger.warning(
-            f"No seasons with .mkv files found in show '{os.path.basename(show_dir)}'"
+            f"No seasons with .mkv files found in show '{normalize_path(show_dir).name}'"
         )
     else:
         logger.info(
-            f"Found {len(valid_season_paths)} seasons with .mkv files in '{os.path.basename(show_dir)}'"
+            f"Found {len(valid_season_paths)} seasons with .mkv files in '{normalize_path(show_dir).name}'"
         )
 
     return valid_season_paths
@@ -57,11 +89,14 @@ def check_filename(filename):
     Check if the filename is in the correct format (S01E02).
 
     Args:
-        filename (str): The filename to check.
+        filename (str or Path): The filename to check.
 
     Returns:
         bool: True if the filename matches the expected pattern.
     """
+    # Convert Path object to string if needed
+    if isinstance(filename, Path):
+        filename = str(filename)
     # Check if the filename matches the expected format
     match = re.search(r".*S\d+E\d+", filename)
     return bool(match)
@@ -79,16 +114,14 @@ def scramble_filename(original_file_path, file_number):
         None
     """
     logger.info(f"Scrambling {original_file_path}")
-    series_title = os.path.basename(
-        os.path.dirname(os.path.dirname(original_file_path))
-    )
-    original_file_name = os.path.basename(original_file_path)
-    extension = os.path.splitext(original_file_path)[-1]
+    series_title = normalize_path(original_file_path).parent.parent.name
+    original_file_name = Path(original_file_path).name
+    extension = Path(original_file_path).suffix
     new_file_name = f"{series_title} - {file_number:03d}{extension}"
-    new_file_path = os.path.join(os.path.dirname(original_file_path), new_file_name)
-    if not os.path.exists(new_file_path):
+    new_file_path = Path(original_file_path).parent / new_file_name
+    if not new_file_path.exists():
         logger.info(f"Renaming {original_file_name} -> {new_file_name}")
-        os.rename(original_file_path, new_file_path)
+        Path(original_file_path).rename(new_file_path)
 
 
 def rename_episode_file(original_file_path, new_filename):
@@ -96,32 +129,32 @@ def rename_episode_file(original_file_path, new_filename):
     Rename an episode file with a standardized naming convention.
 
     Args:
-        original_file_path (str): The original file path of the episode.
-        new_filename (str): The new filename including season/episode info.
+        original_file_path (str or Path): The original file path of the episode.
+        new_filename (str or Path): The new filename including season/episode info.
 
     Returns:
-        str: Path to the renamed file, or None if rename failed.
+        Path: Path to the renamed file, or None if rename failed.
     """
-    original_dir = os.path.dirname(original_file_path)
-    new_file_path = os.path.join(original_dir, new_filename)
+    original_dir = Path(original_file_path).parent
+    new_file_path = original_dir / new_filename
 
     # Check if new filepath already exists
-    if os.path.exists(new_file_path):
+    if new_file_path.exists():
         logger.warning(f"File already exists: {new_filename}")
 
         # Add numeric suffix if file exists
-        base, ext = os.path.splitext(new_filename)
+        base, ext = Path(new_filename).stem, Path(new_filename).suffix
         suffix = 2
         while True:
             new_filename = f"{base}_{suffix}{ext}"
-            new_file_path = os.path.join(original_dir, new_filename)
-            if not os.path.exists(new_file_path):
+            new_file_path = original_dir / new_filename
+            if not new_file_path.exists():
                 break
             suffix += 1
 
     try:
-        os.rename(original_file_path, new_file_path)
-        logger.info(f"Renamed {os.path.basename(original_file_path)} -> {new_filename}")
+        Path(original_file_path).rename(new_file_path)
+        logger.info(f"Renamed {Path(original_file_path).name} -> {new_filename}")
         return new_file_path
     except OSError as e:
         logger.error(f"Failed to rename file: {e}")
@@ -143,7 +176,7 @@ def get_subtitles(show_id, seasons: set[int], config=None):
     if config is None:
         config = get_config(CONFIG_FILE)
     show_dir = config.get("show_dir")
-    series_name = sanitize_filename(os.path.basename(show_dir))
+    series_name = sanitize_filename(normalize_path(show_dir).name)
     tmdb_api_key = config.get("tmdb_api_key")
     open_subtitles_api_key = config.get("open_subtitles_api_key")
     open_subtitles_user_agent = config.get("open_subtitles_user_agent")
@@ -175,7 +208,7 @@ def get_subtitles(show_id, seasons: set[int], config=None):
         for episode in range(1, episodes + 1):
             logger.info(f"Processing Season {season}, Episode {episode}...")
 
-            series_cache_dir = os.path.join(CACHE_DIR, "data", series_name)
+            series_cache_dir = Path(CACHE_DIR) / "data" / series_name
             os.makedirs(series_cache_dir, exist_ok=True)
 
             # Check for existing subtitle in any supported format
@@ -185,15 +218,12 @@ def get_subtitles(show_id, seasons: set[int], config=None):
 
             if existing_subtitle:
                 logger.info(
-                    f"Subtitle already exists: {os.path.basename(existing_subtitle)}"
+                    f"Subtitle already exists: {Path(existing_subtitle).name}"
                 )
                 continue
 
             # Default to standard format for new downloads
-            srt_filepath = os.path.join(
-                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}"
@@ -241,17 +271,15 @@ def process_reference_srt_files(series_name):
         dict: A dictionary containing the reference files where the keys are the MKV filenames
               and the values are the corresponding SRT texts.
     """
-    import os
-
     from mkv_episode_matcher.__main__ import CACHE_DIR
 
     reference_files = {}
-    reference_dir = os.path.join(CACHE_DIR, "data", series_name)
+    reference_dir = Path(CACHE_DIR) / "data" / series_name
 
     for dirpath, _, filenames in os.walk(reference_dir):
         for filename in filenames:
             if filename.lower().endswith(".srt"):
-                srt_file = os.path.join(dirpath, filename)
+                srt_file = Path(dirpath) / filename
                 logger.info(f"Processing {srt_file}")
                 srt_text = extract_srt_text(srt_file)
                 season, episode = extract_season_episode(filename)
@@ -333,7 +361,7 @@ def process_srt_files(show_dir):
     for dirpath, _, filenames in os.walk(show_dir):
         for filename in filenames:
             if filename.lower().endswith(".srt"):
-                srt_file = os.path.join(dirpath, filename)
+                srt_file = Path(dirpath) / filename
                 logger.info(f"Processing {srt_file}")
                 srt_text = extract_srt_text(srt_file)
                 srt_files[srt_file] = srt_text
@@ -353,22 +381,20 @@ def compare_and_rename_files(srt_files, reference_files, dry_run=False):
         f"Comparing {len(srt_files)} srt files with {len(reference_files)} reference files"
     )
     for srt_text in srt_files.keys():
-        parent_dir = os.path.dirname(os.path.dirname(srt_text))
+        parent_dir = Path(srt_text).parent.parent
         for reference in reference_files.keys():
             _season, _episode = extract_season_episode(reference)
-            mkv_file = os.path.join(
-                parent_dir, os.path.basename(srt_text).replace(".srt", ".mkv")
-            )
+            mkv_file = str(parent_dir / Path(srt_text).name.replace(".srt", ".mkv"))
             matching_lines = compare_text(
                 reference_files[reference], srt_files[srt_text]
             )
             if matching_lines >= int(len(reference_files[reference]) * 0.1):
                 logger.info(f"Matching lines: {matching_lines}")
                 logger.info(f"Found matching file: {mkv_file} ->{reference}")
-                new_filename = os.path.join(parent_dir, reference)
+                new_filename = parent_dir / reference
                 if not dry_run:
-                    logger.info(f"Renaming {mkv_file} to {new_filename}")
-                    rename_episode_file(mkv_file, new_filename)
+                    logger.info(f"Renaming {mkv_file} to {str(new_filename)}")
+                    rename_episode_file(mkv_file, reference)
 
 
 def compare_text(text1, text2):

{mkv_episode_matcher-0.8.1 → mkv_episode_matcher-0.9.0}/mkv_episode_matcher.egg-info/PKG-INFO

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

{mkv_episode_matcher-0.8.1 → mkv_episode_matcher-0.9.0}/mkv_episode_matcher.egg-info/SOURCES.txt

@@ -38,4 +38,6 @@ mkv_episode_matcher.egg-info/entry_points.txt
 mkv_episode_matcher.egg-info/requires.txt
 mkv_episode_matcher.egg-info/top_level.txt
 tests/__init__.py
-tests/test_main.py
+tests/test_main.py
+tests/test_path_handling.py
+tests/test_trailing_slash.py

{mkv_episode_matcher-0.8.1 → mkv_episode_matcher-0.9.0}/setup.cfg

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

mkv_episode_matcher-0.9.0/tests/test_path_handling.py

@@ -0,0 +1,103 @@
+# test_path_handling.py
+import sys
+import pytest
+from pathlib import Path
+import importlib
+import unittest
+from unittest import mock
+
+# Add the parent directory to the path so we can import the project modules
+sys.path.append(str(Path(__file__).parent.parent.absolute()))
+
+# Import the modules we want to test
+from mkv_episode_matcher.__main__ import main as main_module
+from mkv_episode_matcher.episode_matcher import process_show
+from mkv_episode_matcher.utils import check_filename, rename_episode_file, normalize_path
+
+# Test paths to use in tests
+TEST_PATHS = [
+    ("/mnt/c/Shows/Breaking Bad", "Breaking Bad"),  # Normal path
+    ("/mnt/c/Shows/Breaking Bad/", "Breaking Bad"),  # Linux trailing slash
+    ("/mnt/c/Shows/Breaking Bad\\", "Breaking Bad"),  # Windows trailing backslash
+    ("/mnt/c/Shows/Breaking Bad//", "Breaking Bad"),  # Double trailing slash
+    ("C:\\Shows\\The Office\\", "The Office"),  # Windows path with trailing slash
+    ("/home/user/Shows/Game of Thrones/", "Game of Thrones"),  # Another Linux path
+]
+
+class TestPathLibImplementation(unittest.TestCase):
+    """Test the pathlib implementation used throughout the codebase"""
+    
+    def test_show_name_extraction_with_pathlib(self):
+        """Test that normalize_path.name correctly extracts the show name even with trailing slash"""
+        # Path with trailing slash that previously caused bugs with os.path.basename
+        path_with_trailing_slash = "/mnt/c/Shows/Breaking Bad/"
+        
+        # Expected correct show name
+        expected_show_name = "Breaking Bad"
+        
+        # Our new implementation using normalize_path
+        extracted_name = normalize_path(path_with_trailing_slash).name
+        
+        # This should succeed with our normalized path
+        self.assertEqual(extracted_name, expected_show_name, 
+                        "normalize_path.name should correctly extract the show name with trailing slash")
+    
+    def test_check_filename_with_path_objects(self):
+        """Test that check_filename works with both Path objects and strings"""
+        # Test with string path
+        string_path = "/path/to/Show.S01E01.mkv"
+        self.assertTrue(check_filename(string_path), "check_filename should work with string paths")
+        
+        # Test with Path object
+        path_object = Path("/path/to/Show.S01E01.mkv")
+        self.assertTrue(check_filename(path_object), "check_filename should work with Path objects")
+    
+    def test_path_operations(self):
+        """Test various Path operations used in the codebase"""
+        base_path = Path("/mnt/c/Shows/Breaking Bad")
+        
+        # Test Path joining with / operator
+        episode_path = base_path / "Season 1" / "Episode 1.mkv"
+        expected_path = Path("/mnt/c/Shows/Breaking Bad/Season 1/Episode 1.mkv")
+        self.assertEqual(episode_path, expected_path, "Path joining with / operator should work correctly")
+        
+        # Test parent directory
+        self.assertEqual(episode_path.parent, Path("/mnt/c/Shows/Breaking Bad/Season 1"), 
+                         "Parent directory should be correctly identified")
+        
+        # Test name extraction
+        self.assertEqual(episode_path.name, "Episode 1.mkv", "Filename should be correctly extracted")
+        
+        # Test stem and suffix
+        self.assertEqual(episode_path.stem, "Episode 1", "File stem should be correctly extracted")
+        self.assertEqual(episode_path.suffix, ".mkv", "File extension should be correctly extracted")
+
+
+class TestEpisodeMatcherShowNameExtraction(unittest.TestCase):
+    """Test the show name extraction in episode_matcher.py"""
+    
+    @mock.patch('mkv_episode_matcher.config.get_config')
+    def test_episode_matcher_show_name_with_trailing_slash(self, mock_get_config):
+        """Test that process_show extracts show_name incorrectly with trailing slash"""
+        # Create a mock config that returns a path with trailing slash
+        mock_config = mock.MagicMock()
+        mock_config.get.return_value = "/mnt/c/Shows/Breaking Bad/"
+        mock_get_config.return_value = mock_config
+        
+        # Import the module under test
+        import mkv_episode_matcher.episode_matcher as episode_matcher
+        
+        # Access the function that should be affected by the bug
+        # This line simulates what happens in process_show() but we're just testing the show_name extraction
+        show_dir = mock_config.get("show_dir")
+        
+        # How the code would extract show_name with normalize_path - this would work
+        fixed_show_name = normalize_path(show_dir).name
+        self.assertEqual(fixed_show_name, "Breaking Bad",
+                         "normalize_path.name should extract correct show name even with trailing slash")
+
+def test_pathlib_works_with_trailing_slashes():
+    """Test that normalize_path.name works correctly with trailing slashes"""
+    for path, expected in TEST_PATHS:
+        result = normalize_path(path).name
+        assert result == expected, f"Normalized path should extract correct name for: {path}"

mkv_episode_matcher-0.9.0/tests/test_trailing_slash.py

@@ -0,0 +1,64 @@
+# tests/test_trailing_slash.py
+
+"""
+This test verifies that pathlib.Path.name correctly handles paths with trailing slashes.
+"""
+
+from pathlib import Path
+import sys
+import os
+
+# Add the parent directory to the path so we can import the project modules
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from mkv_episode_matcher.utils import normalize_path
+
+# Test paths with their expected basename
+TEST_PATHS = [
+    ("/mnt/c/Shows/Breaking Bad", "Breaking Bad"),  # Unix normal path
+    ("/mnt/c/Shows/Breaking Bad/", "Breaking Bad"),  # Unix trailing slash
+    ("X:\\Shows\\Breaking Bad", "Breaking Bad"),  # Windows normal path
+    ("X:\\Shows\\Breaking Bad\\", "Breaking Bad"),  # Windows trailing backslash
+]
+
+def test_pathlib_works_with_trailing_slash():
+    """Verify that pathlib.Path.name correctly handles paths with trailing slash."""
+    path_with_slash = "/mnt/c/Shows/Breaking Bad/"
+    result = normalize_path(path_with_slash).name
+    assert result == "Breaking Bad", "Path.name should extract correct name even with trailing slash"
+
+def test_pathlib_works_with_trailing_backslash():
+    """Verify that pathlib.Path.name correctly handles paths with trailing backslash."""
+    path_with_backslash = "X:\\Shows\\Breaking Bad\\"
+    result = normalize_path(path_with_backslash).name
+    assert result == "Breaking Bad", "Path.name should extract correct name even with trailing backslash"
+
+def test_pathlib_works_without_trailing_slash():
+    """Verify pathlib works correctly for paths without trailing slash."""
+    normal_path = "/mnt/c/Shows/Breaking Bad"
+    result = normalize_path(normal_path).name
+    assert result == "Breaking Bad", "Path.name should work for paths without trailing slash"
+
+def test_path_parent_behavior():
+    """Test that Path.parent correctly handles paths with trailing slashes."""
+    path_with_slash = "/mnt/c/Shows/Breaking Bad/"
+    path_without_slash = "/mnt/c/Shows/Breaking Bad"
+    
+    assert normalize_path(path_with_slash).parent == Path("/mnt/c/Shows"), "Parent should be correctly extracted"
+    assert normalize_path(path_without_slash).parent == Path("/mnt/c/Shows"), "Parent should be correctly extracted"
+
+def test_path_stem_suffix():
+    """Test Path.stem and Path.suffix functionality."""
+    path = "/mnt/c/Shows/Breaking Bad/episode.mkv"
+    path_obj = Path(path)
+    
+    assert path_obj.stem == "episode", "Stem should be correctly extracted"
+    assert path_obj.suffix == ".mkv", "Suffix should be correctly extracted"
+
+def test_all_paths_with_pathlib():
+    """Test all the path formats with pathlib."""
+    for path, expected in TEST_PATHS:
+        # Check normalize_path.name always works
+        pathlib_result = normalize_path(path).name
+        assert pathlib_result == expected, f"Expected '{expected}' for normalize_path('{path}').name but got '{pathlib_result}'"
+        rstrip_result = normalize_path(path).name
+        assert rstrip_result == expected, f"Expected '{expected}' for normalize_path approach on '{path}' but got '{rstrip_result}'"

mkv_episode_matcher-0.8.1/.python-version

@@ -1 +0,0 @@
-3.9