mkv-episode-matcher 0.1.1__tar.gz → 0.1.3__tar.gz

mkv_episode_matcher-0.1.3/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

mkv_episode_matcher-0.1.3/.github/workflows/ci.yml

@@ -0,0 +1,29 @@
+name: ci 
+on:
+  push:
+    branches:
+      - master 
+      - main
+permissions:
+  contents: write
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Configure Git Credentials
+        run: |
+          git config user.name github-actions[bot]
+          git config user.email 41898282+github-actions[bot]@users.noreply.github.com
+      - uses: actions/setup-python@v5
+        with:
+          python-version: 3.x
+      - run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV 
+      - uses: actions/cache@v4
+        with:
+          key: mkdocs-material-${{ env.cache_id }}
+          path: .cache
+          restore-keys: |
+            mkdocs-material-
+      - run: pip install mkdocs-material 
+      - run: mkdocs gh-deploy --force

mkv_episode_matcher-0.1.3/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "mkv_episode_matcher/libraries/pgs2srt"]
+	path = mkv_episode_matcher/libraries/pgs2srt
+	url = https://github.com/Jsakkos/pgs2srt

mkv_episode_matcher-0.1.3/.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+    "python.testing.unittestArgs": [
+        "-v",
+        "-s",
+        "./tests",
+        "-p",
+        "*test*.py"
+    ],
+    "python.testing.pytestEnabled": false,
+    "python.testing.unittestEnabled": true
+}

{mkv_episode_matcher-0.1.1 → mkv_episode_matcher-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mkv-episode-matcher
-Version: 0.1.1
+Version: 0.1.3
 Summary: The MKV Episode Matcher is a tool for identifying TV series episodes from MKV files and renaming the files accordingly.
 Project-URL: Documentation, https://github.com/Jsakkos/mkv-episode-matcher#readme
 Project-URL: Issues, https://github.com/Jsakkos/mkv-episode-matcher/issues

mkv_episode_matcher-0.1.3/docs/index.md

@@ -0,0 +1,17 @@
+# Welcome to MkDocs
+
+For full documentation visit [mkdocs.org](https://www.mkdocs.org).
+
+## Commands
+
+* `mkdocs new [dir-name]` - Create a new project.
+* `mkdocs serve` - Start the live-reloading docs server.
+* `mkdocs build` - Build the documentation site.
+* `mkdocs -h` - Print help message and exit.
+
+## Project layout
+
+    mkdocs.yml    # The configuration file.
+    docs/
+        index.md  # The documentation homepage.
+        ...       # Other markdown pages, images and other files.

mkv_episode_matcher-0.1.3/mkdocs.yml

@@ -0,0 +1,6 @@
+site_name: MKV Episode Matcher Docs
+site_url: https://jsakkos.github.io/mkv-episode-matcher
+theme:
+  name: material
+repo_url: https://github.com/jsakkos/mkv-episode-matcher
+repo_name: jsakkos/mkv-episode-matcher

mkv_episode_matcher-0.1.3/mkv_episode_matcher/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

mkv_episode_matcher-0.1.3/mkv_episode_matcher/__init__.py

@@ -0,0 +1 @@
+version = "0.1.3"

mkv_episode_matcher-0.1.3/mkv_episode_matcher/__main__.py

@@ -0,0 +1,179 @@
+# __main__.py
+import argparse
+import os
+
+from loguru import logger
+
+from .config import get_config, set_config
+
+# Log the start of the application
+logger.info("Starting the application")
+
+# Check if logs directory exists, if not create it
+if not os.path.exists('./logs'):
+    os.mkdir('./logs')
+
+# Add a new handler for stdout logs
+logger.add("./logs/file_stdout.log", format="{time} {level} {message}", level="DEBUG", rotation="10 MB")
+
+# Add a new handler for error logs
+logger.add("./logs/file_errors.log", level="ERROR", rotation="10 MB")
+
+# Check if the configuration directory exists, if not create it
+if not os.path.exists(os.path.join(os.path.expanduser("~"), ".mkv-episode-matcher")):
+    os.makedirs(os.path.join(os.path.expanduser("~"), ".mkv-episode-matcher"))
+
+# Define the paths for the configuration file and cache directory
+CONFIG_FILE = os.path.join(
+    os.path.expanduser("~"), ".mkv-episode-matcher", "config.ini"
+)
+CACHE_DIR = os.path.join(os.path.expanduser("~"), ".mkv-episode-matcher", "cache")
+
+# Check if the cache directory exists, if not create it
+if not os.path.exists(CACHE_DIR):
+    os.makedirs(CACHE_DIR)
+
+
+@logger.catch
+def main():
+    """
+    Entry point of the application.
+
+    This function is responsible for starting the application, parsing command-line arguments,
+    setting the configuration, and processing the show.
+
+    Command-line arguments:
+    --tmdb-api-key: The API key for the TMDb API. If not provided, the function will try to get it from the cache or prompt the user to input it.
+    --show-dir: The main directory of the show. If not provided, the function will prompt the user to input it.
+    --season: The season number to be processed. If not provided, all seasons will be processed.
+    --dry-run: A boolean flag indicating whether to perform a dry run (i.e., not rename any files). If not provided, the function will rename files.
+    --get-subs: A boolean flag indicating whether to download subtitles for the show. If not provided, the function will not download subtitles.
+    --tesseract-path: The path to the tesseract executable. If not provided, the function will try to get it from the cache or prompt the user to input it.
+
+    The function logs its progress to two separate log files: one for standard output and one for errors.
+    """
+
+
+    # Parse command-line arguments
+    parser = argparse.ArgumentParser(description="Process shows with TMDb API")
+    parser.add_argument("--tmdb-api-key", help="TMDb API key")
+    parser.add_argument("--show-dir", help="Main directory of the show")
+    parser.add_argument(
+        "--season",
+        type=int,
+        default=None,
+        nargs="?",
+        help="Specify the season number to be processed (default: None)",
+    )
+    parser.add_argument(
+        "--dry-run",
+        type=bool,
+        default=None,
+        nargs="?",
+        help="Don't rename any files (default: None)",
+    )
+    parser.add_argument(
+        "--get-subs",
+        type=bool,
+        default=None,
+        nargs="?",
+        help="Download subtitles for the show (default: None)",
+    )
+    parser.add_argument(
+        "--tesseract-path",
+        type=str,
+        default=None,
+        nargs="?",
+        help="Path to the tesseract executable (default: None)",
+    )
+    args = parser.parse_args()
+    logger.debug(f"Command-line arguments: {args}")
+    open_subtitles_api_key = ""
+    open_subtitles_user_agent = ""
+    open_subtitles_username = ""
+    open_subtitles_password = ""
+    # Check if API key is provided via command-line argument
+    tmdb_api_key = args.tmdb_api_key
+
+    # If API key is not provided, try to get it from the cache
+    if not tmdb_api_key:
+        cached_config = get_config(CONFIG_FILE)
+        if cached_config:
+            tmdb_api_key = cached_config.get("tmdb_api_key")
+
+    # If API key is still not available, prompt the user to input it
+    if not tmdb_api_key:
+        tmdb_api_key = input("Enter your TMDb API key: ")
+        # Cache the API key
+
+    logger.debug(f"TMDb API Key: {tmdb_api_key}")
+    if args.get_subs:
+        logger.debug("Getting OpenSubtitles API key")
+        cached_config = get_config(CONFIG_FILE)
+        try:
+            open_subtitles_api_key = cached_config.get("open_subtitles_api_key")
+            open_subtitles_user_agent = cached_config.get("open_subtitles_user_agent")
+            open_subtitles_username = cached_config.get("open_subtitles_username")
+            open_subtitles_password = cached_config.get("open_subtitles_password")
+        except:
+            pass
+
+        if not open_subtitles_api_key:
+            open_subtitles_api_key = input("Enter your OpenSubtitles API key: ")
+
+        if not open_subtitles_user_agent:
+            open_subtitles_user_agent = input("Enter your OpenSubtitles User Agent: ")
+
+        if not open_subtitles_username:
+            open_subtitles_username = input("Enter your OpenSubtitles Username: ")
+
+        if not open_subtitles_password:
+            open_subtitles_password = input("Enter your OpenSubtitles Password: ")
+
+    # If show directory is provided via command-line argument, use it
+    show_dir = args.show_dir
+    if not show_dir:
+        show_dir = cached_config.get("show_dir")
+        if not show_dir:
+            # If show directory is not provided, prompt the user to input it
+            show_dir = input("Enter the main directory of the show:")
+        logger.info(f"Show Directory: {show_dir}")
+        # if the user does not provide a show directory, make the default show directory the current working directory
+        if not show_dir:
+            show_dir = os.getcwd()
+    if not args.tesseract_path:
+        tesseract_path = cached_config.get("tesseract_path")
+
+        if not tesseract_path:
+            tesseract_path = input(
+                r"Enter the path to the tesseract executable: ['C:\Program Files\Tesseract-OCR\tesseract.exe']"
+            )
+
+    else:
+        tesseract_path = args.tesseract_path
+    logger.debug(f"Teesseract Path: {tesseract_path}")
+    logger.debug(f"Show Directory: {show_dir}")
+
+    # Set the configuration
+    set_config(
+        tmdb_api_key,
+        open_subtitles_api_key,
+        open_subtitles_user_agent,
+        open_subtitles_username,
+        open_subtitles_password,
+        show_dir,
+        CONFIG_FILE,
+        tesseract_path=tesseract_path,
+    )
+    logger.info("Configuration set")
+
+    # Process the show
+    from .episode_matcher import process_show
+
+    process_show(args.season, dry_run=args.dry_run, get_subs=args.get_subs)
+    logger.info("Show processing completed")
+
+
+# Run the main function if the script is run directly
+if __name__ == "__main__":
+    main()

mkv_episode_matcher-0.1.3/mkv_episode_matcher/config.py

@@ -0,0 +1,82 @@
+# config.py
+import configparser
+import multiprocessing
+import os
+
+from loguru import logger
+
+MAX_THREADS = 4
+
+
+def get_total_threads():
+    return multiprocessing.cpu_count()
+
+
+total_threads = get_total_threads()
+
+if total_threads < MAX_THREADS:
+    MAX_THREADS = total_threads
+logger.info(f"Total available threads: {total_threads} -> Setting max to {MAX_THREADS}")
+
+
+def set_config(
+    tmdb_api_key,
+    open_subtitles_api_key,
+    open_subtitles_user_agent,
+    open_subtitles_username,
+    open_subtitles_password,
+    show_dir,
+    file,
+    tesseract_path=None,
+):
+    """
+    Sets the configuration values and writes them to a file.
+
+    Args:
+        tmdb_api_key (str): The API key for TMDB (The Movie Database).
+        open_subtitles_api_key (str): The API key for OpenSubtitles.
+        open_subtitles_user_agent (str): The user agent for OpenSubtitles.
+        open_subtitles_username (str): The username for OpenSubtitles.
+        open_subtitles_password (str): The password for OpenSubtitles.
+        show_dir (str): The directory where the TV show episodes are located.
+        file (str): The path to the configuration file.
+        tesseract_path (str, optional): The path to the Tesseract OCR executable.
+
+    Returns:
+        None
+    """
+    config = configparser.ConfigParser()
+    config["Config"] = {
+        "tmdb_api_key": str(tmdb_api_key),
+        "show_dir": show_dir,
+        "max_threads": int(MAX_THREADS),
+        "open_subtitles_api_key": str(open_subtitles_api_key),
+        "open_subtitles_user_agent": str(open_subtitles_user_agent),
+        "open_subtitles_username": str(open_subtitles_username),
+        "open_subtitles_password": str(open_subtitles_password),
+        "tesseract_path": str(tesseract_path),
+    }
+    logger.info(
+        f"Setting config with API:{tmdb_api_key}, show_dir: {show_dir}, and max_threads: {MAX_THREADS}"
+    )
+    with open(file, "w") as configfile:
+        config.write(configfile)
+
+
+def get_config(file):
+    """
+    Read and return the configuration from the specified file.
+
+    Args:
+        file (str): The path to the configuration file.
+
+    Returns:
+        dict: The configuration settings as a dictionary.
+
+    """
+    logger.info(f"Loading config from {file}")
+    config = configparser.ConfigParser()
+    if os.path.exists(file):
+        config.read(file)
+        return config["Config"] if "Config" in config else None
+    return {}

mkv_episode_matcher-0.1.3/mkv_episode_matcher/episode_matcher.py

@@ -0,0 +1,237 @@
+# episode_matcher.py
+import os
+import re
+
+from loguru import logger
+
+from mkv_episode_matcher.__main__ import CACHE_DIR, CONFIG_FILE
+from mkv_episode_matcher.config import get_config
+from mkv_episode_matcher.mkv_to_srt import convert_mkv_to_srt
+from mkv_episode_matcher.tmdb_client import fetch_show_id
+from mkv_episode_matcher.utils import check_filename, cleanup_ocr_files, get_subtitles
+
+
+# hash_data = {}
+@logger.catch
+def process_show(season=None, dry_run=False, get_subs=False):
+    """
+    Process the show by downloading episode images and finding matching episodes.
+
+    Args:
+        season (int, optional): The season number to process. If provided, only that season will be processed. Defaults to None.
+        force (bool, optional): Whether to force re-processing of episodes even if they already exist. Defaults to False.
+        dry_run (bool, optional): Whether to perform a dry run without actually processing the episodes. Defaults to False.
+        threshold (float, optional): The threshold value for matching episodes. Defaults to None.
+    """
+    config = get_config(CONFIG_FILE)
+    show_dir = config.get("show_dir")
+    show_name = os.path.basename(show_dir)
+    logger.info(f"Processing show '{show_name}'...")
+    show_id = fetch_show_id(show_name)
+
+    if show_id is None:
+        logger.error(f"Could not find show '{os.path.basename(show_dir)}' on TMDb.")
+        return
+    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))
+    ]
+    logger.info(
+        f"Found {len(season_paths)} seasons for show '{os.path.basename(show_dir)}'"
+    )
+    seasons_to_process = [
+        int(os.path.basename(season_path).split()[-1]) for season_path in season_paths
+    ]
+    if get_subs:
+        get_subtitles(show_id, seasons=set(seasons_to_process))
+    if season is not None:
+        mkv_files = [
+            os.path.join(show_dir, season)
+            for f in os.listdir(show_dir)
+            if f.endswith(".mkv")
+        ]
+
+        season_path = os.path.join(show_dir, f"Season {season}")
+    else:
+        for season_path in os.listdir(show_dir):
+            season_path = os.path.join(show_dir, season_path)
+            mkv_files = [
+                os.path.join(season_path, f)
+                for f in os.listdir(season_path)
+                if f.endswith(".mkv")
+            ]
+    # Filter out files that have already been processed
+    for f in mkv_files:
+        if check_filename(f):
+            logger.info(f"Skipping {f}, already processed")
+            mkv_files.remove(f)
+    if len(mkv_files) == 0:
+        logger.info("No new files to process")
+        return
+    convert_mkv_to_srt(season_path, mkv_files)
+    reference_text_dict = process_reference_srt_files(show_name)
+    srt_text_dict = process_srt_files(show_dir)
+    compare_and_rename_files(srt_text_dict, reference_text_dict, dry_run=dry_run)
+    cleanup_ocr_files(show_dir)
+
+def check_filename(filename):
+    """
+    Check if the filename is in the correct format.
+
+    Args:
+        filename (str): The filename to check.
+
+    Returns:
+        bool: True if the filename is in the correct format, False otherwise.
+    """
+    # Check if the filename matches the expected format
+    match = re.match(r".*S\d+E\d+", filename)
+    return bool(match)
+def extract_srt_text(filepath):
+    """
+    Extracts the text from an SRT file.
+
+    Args:
+        filepath (str): The path to the SRT file.
+
+    Returns:
+        list: A list of lists, where each inner list represents a block of text from the SRT file.
+              Each inner list contains the lines of text for that block.
+    """
+    # extract the text from the file
+    with open(filepath) as f:
+        filepath = f.read()
+    text_lines = [
+        filepath.split("\n\n")[i].split("\n")[2:]
+        for i in range(len(filepath.split("\n\n")))
+    ]
+    # remove empty lines
+    text_lines = [[line for line in lines if line] for lines in text_lines]
+    # remove <i> or </i> tags
+    text_lines = [
+        [re.sub(r"<i>|</i>|", "", line) for line in lines] for lines in text_lines
+    ]
+    # remove empty lists
+    text_lines = [lines for lines in text_lines if lines]
+    return text_lines
+
+
+def compare_text(text1, text2):
+    """
+    Compare two lists of text lines and return the number of matching lines.
+
+    Args:
+        text1 (list): List of text lines from the first source.
+        text2 (list): List of text lines from the second source.
+
+    Returns:
+        int: Number of matching lines between the two sources.
+    """
+    # Flatten the list of text lines
+    flat_text1 = [line for lines in text1 for line in lines]
+    flat_text2 = [line for lines in text2 for line in lines]
+
+    # Compare the two lists of text lines
+    matching_lines = set(flat_text1).intersection(flat_text2)
+    return len(matching_lines)
+
+
+def extract_season_episode(filename):
+    """
+    Extract the season and episode number from the filename.
+
+    Args:
+        filename (str): The filename to extract the season and episode from.
+
+    Returns:
+        tuple: A tuple containing the season and episode number.
+    """
+    # Extract the season and episode number from the filename
+    match = re.search(r"S(\d+)E(\d+)", filename)
+    if match:
+        season = int(match.group(1))
+        episode = int(match.group(2))
+        return season, episode
+    else:
+        return None, None
+
+
+def process_reference_srt_files(series_name):
+    """
+    Process reference SRT files for a given series.
+
+    Args:
+        series_name (str): The name of the series.
+
+    Returns:
+        dict: A dictionary containing the reference files where the keys are the MKV filenames
+              and the values are the corresponding SRT texts.
+    """
+    reference_files = {}
+    reference_dir = os.path.join(CACHE_DIR, "data", series_name)
+    for dirpath, _, filenames in os.walk(reference_dir):
+        for filename in filenames:
+            if filename.lower().endswith(".srt"):
+                srt_file = os.path.join(dirpath, filename)
+                logger.info(f"Processing {srt_file}")
+                srt_text = extract_srt_text(srt_file)
+                season, episode = extract_season_episode(filename)
+                mkv_filename = f"{series_name} - S{season:02}E{episode:02}.mkv"
+                reference_files[mkv_filename] = srt_text
+    return reference_files
+
+
+def process_srt_files(show_dir):
+    """
+    Process all SRT files in the given directory and its subdirectories.
+
+    Args:
+        show_dir (str): The directory path where the SRT files are located.
+
+    Returns:
+        dict: A dictionary containing the SRT file paths as keys and their corresponding text content as values.
+    """
+    srt_files = {}
+    for dirpath, _, filenames in os.walk(show_dir):
+        for filename in filenames:
+            if filename.lower().endswith(".srt"):
+                srt_file = os.path.join(dirpath, filename)
+                logger.info(f"Processing {srt_file}")
+                srt_text = extract_srt_text(srt_file)
+                srt_files[srt_file] = srt_text
+    return srt_files
+
+
+def compare_and_rename_files(srt_files, reference_files, dry_run=False):
+    """
+    Compare the srt files with the reference files and rename the matching mkv files.
+
+    Args:
+        srt_files (dict): A dictionary containing the srt files as keys and their contents as values.
+        reference_files (dict): A dictionary containing the reference files as keys and their contents as values.
+        dry_run (bool, optional): If True, the function will only log the renaming actions without actually renaming the files. Defaults to False.
+    """
+    logger.info(
+        f"Comparing {len(srt_files)} srt files with {len(reference_files)} reference files"
+    )
+    for srt_text in srt_files.keys():
+        parent_dir = os.path.dirname(os.path.dirname(srt_text))
+        for reference in reference_files.keys():
+            season, episode = extract_season_episode(reference)
+            mkv_file = os.path.join(
+                parent_dir, os.path.basename(srt_text).replace(".srt", ".mkv")
+            )
+            matching_lines = compare_text(
+                reference_files[reference], srt_files[srt_text]
+            )
+            if matching_lines >= int(len(reference_files[reference]) * 0.1):
+                logger.info(f"Matching lines: {matching_lines}")
+                logger.info(f"Found matching file: {mkv_file} ->{reference}")
+                new_filename = os.path.join(parent_dir, reference)
+                if not os.path.exists(new_filename):
+                    if os.path.exists(mkv_file) and not dry_run:
+                        logger.info(f"Renaming {mkv_file} to {new_filename}")
+                        os.rename(mkv_file, new_filename)
+                else:
+                    logger.info(f"File {new_filename} already exists, skipping")

mkv_episode_matcher-0.1.3/mkv_episode_matcher/libraries/pgs2srt/.git

@@ -0,0 +1 @@
+gitdir: ../../.git/modules/libraries/pgs2srt

mkv_episode_matcher-0.1.3/mkv_episode_matcher/libraries/pgs2srt/.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+.DS_Store