mkv-episode-matcher 0.1.12__py3-none-any.whl → 0.2.0__py3-none-any.whl

mkv_episode_matcher/mkv_to_srt.py

@@ -9,15 +9,28 @@ sys.path.append(os.path.join(parent_dir, "libraries", "pgs2srt"))
 import re
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timedelta
-
+from pathlib import Path
 import pytesseract
 from imagemaker import make_image
 from loguru import logger
 from pgsreader import PGSReader
 from PIL import Image, ImageOps
-
+from typing import Optional
 from mkv_episode_matcher.__main__ import CONFIG_FILE
 from mkv_episode_matcher.config import get_config
+def check_if_processed(filename: str) -> bool:
+    """
+    Check if the file has already been processed (has SxxExx format)
+    
+    Args:
+        filename (str): Filename to check
+        
+    Returns:
+        bool: True if file is already processed
+    """
+    import re
+    match = re.search(r"S\d+E\d+", filename)
+    return bool(match)
 
 
 def convert_mkv_to_sup(mkv_file, output_dir):
@@ -51,21 +64,23 @@ def convert_mkv_to_sup(mkv_file, output_dir):
 
 
 @logger.catch
-def perform_ocr(sup_file_path):
+def perform_ocr(sup_file_path: str) -> Optional[str]:
     """
     Perform OCR on a .sup file and save the extracted text to a .srt file.
-
-    Args:
-        sup_file_path (str): Path to the .sup file.
+    Returns the path to the created SRT file.
     """
-
     # Get the base name of the .sup file without the extension
     base_name = os.path.splitext(os.path.basename(sup_file_path))[0]
     output_dir = os.path.dirname(sup_file_path)
     logger.info(f"Performing OCR on {sup_file_path}")
+    
     # Construct the output .srt file path
     srt_file = os.path.join(output_dir, f"{base_name}.srt")
 
+    if os.path.exists(srt_file):
+        logger.info(f"SRT file {srt_file} already exists, skipping OCR")
+        return srt_file
+
     # Load a PGS/SUP file.
     pgs = PGSReader(sup_file_path)
 
@@ -151,24 +166,137 @@ def perform_ocr(sup_file_path):
         logger.info(f"Saved to: {srt_file}")
 
 
-def convert_mkv_to_srt(season_path, mkv_files):
-    """
-    Converts MKV files to SRT format.
+# def convert_mkv_to_srt(season_path, mkv_files):
+#     """
+#     Converts MKV files to SRT format.
 
-    Args:
-        season_path (str): The path to the season directory.
-        mkv_files (list): List of MKV files to convert.
+#     Args:
+#         season_path (str): The path to the season directory.
+#         mkv_files (list): List of MKV files to convert.
 
-    Returns:
-        None
+#     Returns:
+#         None
+#     """
+#     logger.info(f"Converting {len(mkv_files)} files to SRT")
+#     output_dir = os.path.join(season_path, "ocr")
+#     os.makedirs(output_dir, exist_ok=True)
+#     sup_files = []
+#     for mkv_file in mkv_files:
+#         sup_file = convert_mkv_to_sup(mkv_file, output_dir)
+#         sup_files.append(sup_file)
+#     with ThreadPoolExecutor() as executor:
+#         for sup_file in sup_files:
+#             executor.submit(perform_ocr, sup_file)
+
+        
+
+def extract_subtitles(mkv_file: str, output_dir: str) -> Optional[str]:
+    """
+    Extract subtitles from MKV file based on detected subtitle type.
+    """
+    subtitle_type, stream_index = detect_subtitle_type(mkv_file)
+    if not subtitle_type:
+        logger.error(f"No supported subtitle streams found in {mkv_file}")
+        return None
+        
+    base_name = Path(mkv_file).stem
+    
+    if subtitle_type == 'subrip':
+        # For SRT subtitles, extract directly to .srt
+        output_file = os.path.join(output_dir, f"{base_name}.srt")
+        if not os.path.exists(output_file):
+            cmd = [
+                "ffmpeg", "-i", mkv_file,
+                "-map", f"0:{stream_index}",
+                output_file
+            ]
+    else:
+        # For DVD or PGS subtitles, extract to SUP format first
+        output_file = os.path.join(output_dir, f"{base_name}.sup")
+        if not os.path.exists(output_file):
+            cmd = [
+                "ffmpeg", "-i", mkv_file,
+                "-map", f"0:{stream_index}",
+                "-c", "copy",
+                output_file
+            ]
+    
+    if not os.path.exists(output_file):
+        try:
+            subprocess.run(cmd, check=True)
+            logger.info(f"Extracted subtitles from {mkv_file} to {output_file}")
+            return output_file
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Error extracting subtitles: {e}")
+            return None
+    else:
+        logger.info(f"Subtitle file {output_file} already exists, skipping extraction")
+        return output_file
+
+def convert_mkv_to_srt(season_path: str, mkv_files: list[str]) -> None:
+    """
+    Convert subtitles from MKV files to SRT format.
     """
     logger.info(f"Converting {len(mkv_files)} files to SRT")
+    
+    # Filter out already processed files
+    unprocessed_files = []
+    for mkv_file in mkv_files:
+        if check_if_processed(os.path.basename(mkv_file)):
+            logger.info(f"Skipping {mkv_file} - already processed")
+            continue
+        unprocessed_files.append(mkv_file)
+    
+    if not unprocessed_files:
+        logger.info("No new files to process")
+        return
+        
+    # Create OCR directory
     output_dir = os.path.join(season_path, "ocr")
     os.makedirs(output_dir, exist_ok=True)
-    sup_files = []
-    for mkv_file in mkv_files:
-        sup_file = convert_mkv_to_sup(mkv_file, output_dir)
-        sup_files.append(sup_file)
-    with ThreadPoolExecutor() as executor:
-        for sup_file in sup_files:
-            executor.submit(perform_ocr, sup_file)
+    
+    for mkv_file in unprocessed_files:
+        subtitle_file = extract_subtitles(mkv_file, output_dir)
+        if not subtitle_file:
+            continue
+            
+        if subtitle_file.endswith('.srt'):
+            # Already have SRT, keep it in OCR directory
+            logger.info(f"Extracted SRT subtitle to {subtitle_file}")
+        else:
+            # For SUP files (DVD or PGS), perform OCR
+            srt_file = perform_ocr(subtitle_file)
+            if srt_file:
+                logger.info(f"Created SRT from OCR: {srt_file}")
+            
+def detect_subtitle_type(mkv_file: str) -> tuple[Optional[str], Optional[int]]:
+    """
+    Detect the type and index of subtitle streams in an MKV file.
+    """
+    cmd = ["ffmpeg", "-i", mkv_file]
+    
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        
+        subtitle_streams = []
+        for line in result.stderr.split('\n'):
+            if 'Subtitle' in line:
+                stream_index = int(line.split('#0:')[1].split('(')[0])
+                if 'subrip' in line:
+                    subtitle_streams.append(('subrip', stream_index))
+                elif 'dvd_subtitle' in line:
+                    subtitle_streams.append(('dvd_subtitle', stream_index))
+                elif 'hdmv_pgs_subtitle' in line:
+                    subtitle_streams.append(('hdmv_pgs_subtitle', stream_index))
+        
+        # Prioritize subtitle formats: SRT > DVD > PGS
+        for format_priority in ['subrip', 'dvd_subtitle', 'hdmv_pgs_subtitle']:
+            for format_type, index in subtitle_streams:
+                if format_type == format_priority:
+                    return format_type, index
+                    
+        return None, None
+        
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Error detecting subtitle type: {e}")
+        return None, None

mkv_episode_matcher/utils.py

@@ -2,7 +2,6 @@
 import os
 import re
 import shutil
-from typing import Set
 
 import requests
 from loguru import logger
@@ -117,7 +116,7 @@ def rename_episode_file(original_file_path, season_number, episode_number):
         os.rename(original_file_path, new_file_path)
 
 
-def get_subtitles(show_id, seasons: Set[int]):
+def get_subtitles(show_id, seasons: set[int]):
     """
     Retrieves and saves subtitles for a given TV show and seasons.
 
@@ -138,16 +137,14 @@ def get_subtitles(show_id, seasons: Set[int]):
     open_subtitles_user_agent = config.get("open_subtitles_user_agent")
     open_subtitles_username = config.get("open_subtitles_username")
     open_subtitles_password = config.get("open_subtitles_password")
-    if not all(
-        [
-            show_dir,
-            tmdb_api_key,
-            open_subtitles_api_key,
-            open_subtitles_user_agent,
-            open_subtitles_username,
-            open_subtitles_password,
-        ]
-    ):
+    if not all([
+        show_dir,
+        tmdb_api_key,
+        open_subtitles_api_key,
+        open_subtitles_user_agent,
+        open_subtitles_username,
+        open_subtitles_password,
+    ]):
         logger.error("Missing configuration settings. Please run the setup script.")
     try:
         # Initialize the OpenSubtitles client
@@ -164,11 +161,8 @@ def get_subtitles(show_id, seasons: Set[int]):
 
         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)
-            os.makedirs(series_cache_dir,exist_ok=True)
+            series_cache_dir = os.path.join(CACHE_DIR, "data", series_name)
+            os.makedirs(series_cache_dir, exist_ok=True)
             srt_filepath = os.path.join(
                 series_cache_dir,
                 f"{series_name} - S{season:02d}E{episode:02d}.srt",
@@ -179,7 +173,7 @@ def get_subtitles(show_id, seasons: Set[int]):
                 response = requests.get(url)
                 response.raise_for_status()
                 episode_data = response.json()
-                episode_name = episode_data["name"]
+                episode_data["name"]
                 episode_id = episode_data["id"]
                 # search for the subtitle
                 response = subtitles.search(tmdb_id=episode_id, languages="en")
@@ -229,3 +223,10 @@ def cleanup_ocr_files(show_dir):
         if os.path.exists(ocr_dir_path):
             logger.info(f"Cleaning up OCR files in {ocr_dir_path}")
             shutil.rmtree(ocr_dir_path)
+
+
+def clean_text(text):
+    # Remove brackets, parentheses, and their content
+    cleaned_text = re.sub(r"\[.*?\]|\(.*?\)|\{.*?\}", "", text)
+    # Strip leading/trailing whitespace
+    return cleaned_text.strip()

mkv_episode_matcher-0.2.0.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.1
+Name: mkv-episode-matcher
+Version: 0.2.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
+Author-email: Jsakkos <jonathansakkos@gmail.com>
+License: MIT
+Project-URL: Documentation, https://github.com/Jsakkos/mkv-episode-matcher#readme
+Project-URL: Issues, https://github.com/Jsakkos/mkv-episode-matcher/issues
+Project-URL: Source, https://github.com/Jsakkos/mkv-episode-matcher
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: configparser>=7.1.0
+Requires-Dist: ffmpeg>=1.4
+Requires-Dist: loguru>=0.7.2
+Requires-Dist: numpy>=2.1.3
+Requires-Dist: opensubtitlescom>=0.1.5
+Requires-Dist: pytesseract>=0.3.13
+Requires-Dist: requests>=2.32.3
+Requires-Dist: tmdb-client>=0.0.1
+
+# MKV Episode Matcher
+
+[![Documentation Status](https://img.shields.io/github/actions/workflow/status/Jsakkos/mkv-episode-matcher/documentation.yml?label=docs)](https://jsakkos.github.io/mkv-episode-matcher/)
+[![PyPI version](https://badge.fury.io/py/mkv-episode-matcher.svg)](https://badge.fury.io/py/mkv-episode-matcher)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Automatically match and rename your MKV TV episodes using The Movie Database (TMDb).
+
+## Features
+
+- 🎯 **Automatic Episode Matching**: Uses TMDb to accurately identify episodes
+- 📝 **Subtitle Extraction**: Extracts subtitles from MKV files
+- 🔍 **OCR Support**: Handles image-based subtitles
+- 🚀 **Multi-threaded**: Fast processing of multiple files
+- ⬇️ **Subtitle Downloads**: Integration with OpenSubtitles
+- ✨ **Bulk Processing**: Handle entire seasons at once
+- 🧪 **Dry Run Mode**: Test changes before applying
+
+## Quick Start
+
+1. Install the package:
+```bash
+pip install mkv-episode-matcher
+```
+
+2. Run on your show directory:
+```bash
+mkv-match --show-dir "path/to/your/show" --season 1
+```
+
+## Requirements
+
+- Python 3.8 or higher
+- TMDb API key
+- OpenSubtitles account (optional, for subtitle downloads)
+
+## Documentation
+
+Full documentation is available at [https://jsakkos.github.io/mkv-episode-matcher/](https://jsakkos.github.io/mkv-episode-matcher/)
+
+## Basic Usage
+
+```python
+from mkv_episode_matcher import process_show
+
+# Process all seasons
+process_show()
+
+# Process specific season
+process_show(season=1)
+
+# Test run without making changes
+process_show(season=1, dry_run=True)
+
+# Process and download subtitles
+process_show(get_subs=True)
+```
+
+## Directory Structure
+
+MKV Episode Matcher expects your TV shows to be organized as follows:
+
+```
+Show Name/
+├── Season 1/
+│   ├── episode1.mkv
+│   ├── episode2.mkv
+├── Season 2/
+│   ├── episode1.mkv
+│   └── episode2.mkv
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+Distributed under the MIT License. See `LICENSE` for more information.
+
+## Acknowledgments
+
+- [TMDb](https://www.themoviedb.org/) for their excellent API
+- [OpenSubtitles](https://www.opensubtitles.com/) for subtitle integration
+- All contributors who have helped improve this project
+

mkv_episode_matcher-0.2.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+mkv_episode_matcher/.gitattributes,sha256=Gh2-F2vCM7SZ01pX23UT8pQcmauXWfF3gwyRSb6ZAFs,66
+mkv_episode_matcher/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+mkv_episode_matcher/__main__.py,sha256=3ZcCUxeI7rUA-4oiCD2WXBiOFJAqLsVVWfZKN446FwQ,6792
+mkv_episode_matcher/config.py,sha256=zDDKBcsDt5fME9BRqiTi7yWKeast1pZh36BNYMvIBYM,2419
+mkv_episode_matcher/episode_matcher.py,sha256=YBbRL-NIIvBwKojQOHoDsE3EQYy9_hn1j-4CAuLwM78,9854
+mkv_episode_matcher/mkv_to_srt.py,sha256=4yxBHRVhgVby0UtQ2aTXGuoQpid8pkgjMIaHU6GCdzc,10857
+mkv_episode_matcher/tmdb_client.py,sha256=LbMCgjmp7sCbrQo_CDlpcnryKPz5S7inE24YY9Pyjk4,4172
+mkv_episode_matcher/utils.py,sha256=5YWpRbciIAlmhBxa-etGtMA6IabswE3CuefRVQDROz4,9526
+mkv_episode_matcher/libraries/pgs2srt/.gitignore,sha256=mt3uxWYZaFurMw_yGE258gWhtGKPVR7e3Ll4ALJpyj4,23
+mkv_episode_matcher/libraries/pgs2srt/README.md,sha256=olb25G17tj0kxPgp_LcH5I2QWXjgP1m8JFyjYRGz4UU,1374
+mkv_episode_matcher/libraries/pgs2srt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mkv_episode_matcher/libraries/pgs2srt/imagemaker.py,sha256=mOlUt8eJ4LOqMYerOuWmQPPWcB-Umup2lBJlqzy_pPg,2736
+mkv_episode_matcher/libraries/pgs2srt/pgs2srt.py,sha256=UdCCUUWxKXCxBebiNBsrM95R6-zmJhSUAHcEPxUmbNU,4416
+mkv_episode_matcher/libraries/pgs2srt/pgsreader.py,sha256=h5vZSLPVHir-epuNa-L5MpJYpyyUk0h_13DtmrNG9Xc,7001
+mkv_episode_matcher/libraries/pgs2srt/requirements.txt,sha256=sg87dqWw_qpbwciw-Mc5mRJnV9LaCni2cybnT5ANqnA,59
+mkv_episode_matcher/libraries/pgs2srt/Libraries/SubZero/SubZero.py,sha256=geT1LXdVd8yED9zoJ9K1XfP2JzGcM7u1SslHYrJI09o,10061
+mkv_episode_matcher/libraries/pgs2srt/Libraries/SubZero/post_processing.py,sha256=GKtVy_Lxv-z27mkRG8pJF2znKWXwZTot7jL6kN-zIxM,10503
+mkv_episode_matcher/libraries/pgs2srt/Libraries/SubZero/dictionaries/data.py,sha256=AlJHUYXl85J95OzGRik-AHVfzDd7Q8BJCvD4Nr8kRIk,938598
+mkv_episode_matcher-0.2.0.dist-info/METADATA,sha256=aocARhBMBFQ5HRTgCCKa5p9pm-4Kw6SJxoxz31sg7HY,3710
+mkv_episode_matcher-0.2.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+mkv_episode_matcher-0.2.0.dist-info/entry_points.txt,sha256=IglJ43SuCZq2eQ3shMFILCkmQASJHnDCI3ogohW2Hn4,64
+mkv_episode_matcher-0.2.0.dist-info/top_level.txt,sha256=XRLbd93HUaedeWLtkyTvQjFcE5QcBRYa3V-CfHrq-OI,20
+mkv_episode_matcher-0.2.0.dist-info/RECORD,,

{mkv_episode_matcher-0.1.12.dist-info → mkv_episode_matcher-0.2.0.dist-info}/WHEEL

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

mkv_episode_matcher/notebooks/get_subtitles_test.ipynb

@@ -1,252 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Load imports and create config directory"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# __main__.py\n",
-    "import argparse\n",
-    "import os\n",
-    "\n",
-    "from loguru import logger\n",
-    "\n",
-    "from mkv_episode_matcher.config import get_config, set_config\n",
-    "from mkv_episode_matcher.utils import check_filename, cleanup_ocr_files, get_subtitles\n",
-    "from mkv_episode_matcher.tmdb_client import fetch_show_id,fetch_season_details\n",
-    "import os\n",
-    "import re\n",
-    "import shutil\n",
-    "from typing import Set\n",
-    "\n",
-    "import requests\n",
-    "from loguru import logger\n",
-    "from opensubtitlescom import OpenSubtitles\n",
-    "# Log the start of the application\n",
-    "logger.info(\"Starting the application\")\n",
-    "\n",
-    "\n",
-    "\n",
-    "# Check if the configuration directory exists, if not create it\n",
-    "if not os.path.exists(os.path.join(os.path.expanduser(\"~\"), \".mkv-episode-matcher\")):\n",
-    "    os.makedirs(os.path.join(os.path.expanduser(\"~\"), \".mkv-episode-matcher\"))\n",
-    "\n",
-    "# Define the paths for the configuration file and cache directory\n",
-    "CONFIG_FILE = os.path.join(\n",
-    "    os.path.expanduser(\"~\"), \".mkv-episode-matcher\", \"config.ini\"\n",
-    ")\n",
-    "CACHE_DIR = os.path.join(os.path.expanduser(\"~\"), \".mkv-episode-matcher\", \"cache\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Load configuration settings from config.ini"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "config = get_config(CONFIG_FILE)\n",
-    "show_dir = config.get(\"show_dir\")\n",
-    "show_name = os.path.basename(show_dir)\n",
-    "series_name = os.path.basename(show_dir)\n",
-    "tmdb_api_key = config.get(\"tmdb_api_key\")\n",
-    "open_subtitles_api_key = config.get(\"open_subtitles_api_key\")\n",
-    "open_subtitles_user_agent = config.get(\"open_subtitles_user_agent\")\n",
-    "open_subtitles_username = config.get(\"open_subtitles_username\")\n",
-    "open_subtitles_password = config.get(\"open_subtitles_password\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Make sure all required info exists in config.ini"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for x in     [\n",
-    "        show_dir,\n",
-    "        tmdb_api_key,\n",
-    "        open_subtitles_api_key,\n",
-    "        open_subtitles_user_agent,\n",
-    "        open_subtitles_username,\n",
-    "        open_subtitles_password,\n",
-    "    ]:\n",
-    "    try:\n",
-    "        print(x)\n",
-    "    except:\n",
-    "        print('failed')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "if not all(\n",
-    "    [\n",
-    "        show_dir,\n",
-    "        tmdb_api_key,\n",
-    "        open_subtitles_api_key,\n",
-    "        open_subtitles_user_agent,\n",
-    "        open_subtitles_username,\n",
-    "        open_subtitles_password,\n",
-    "    ]\n",
-    "):\n",
-    "    logger.error(\"Missing configuration settings. Please run the setup script.\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Make sure show can be found on TMDb\n",
-    "The show id is used to search on opensubtitles"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "show_id = fetch_show_id(show_name)\n",
-    "if show_id is None:\n",
-    "    logger.error(f\"Could not find show '{os.path.basename(show_name)}' on TMDb.\")\n",
-    "else:\n",
-    "    print(show_id)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Try getting the first season automatically"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "get_subtitles(show_id, seasons=set([1]))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Check if there's an issue in the get_subtitles function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "try:\n",
-    "    # Initialize the OpenSubtitles client\n",
-    "    subtitles = OpenSubtitles(open_subtitles_user_agent, open_subtitles_api_key)\n",
-    "\n",
-    "    # Log in (retrieve auth token)\n",
-    "    subtitles.login(open_subtitles_username, open_subtitles_password)\n",
-    "except Exception as e:\n",
-    "    logger.error(f\"Failed to log in to OpenSubtitles: {e}\")\n",
-    "\n",
-    "for season in [1]:\n",
-    "    episodes = fetch_season_details(show_id, season)\n",
-    "    logger.info(f\"Found {episodes} episodes in Season {season}\")\n",
-    "\n",
-    "    for episode in range(1, episodes + 1):\n",
-    "        logger.info(f\"Processing Season {season}, Episode {episode}...\")\n",
-    "        series_cache_dir =os.path.join(\n",
-    "            CACHE_DIR,\n",
-    "            \"data\",\n",
-    "            series_name)\n",
-    "        os.makedirs(series_cache_dir,exist_ok=True)\n",
-    "        srt_filepath = os.path.join(\n",
-    "            series_cache_dir,\n",
-    "            f\"{series_name} - S{season:02d}E{episode:02d}.srt\",\n",
-    "        )\n",
-    "        if not os.path.exists(srt_filepath):\n",
-    "            # get the episode info from TMDB\n",
-    "            url = f\"https://api.themoviedb.org/3/tv/{show_id}/season/{season}/episode/{episode}?api_key={tmdb_api_key}\"\n",
-    "            response = requests.get(url)\n",
-    "            response.raise_for_status()\n",
-    "            episode_data = response.json()\n",
-    "            episode_name = episode_data[\"name\"]\n",
-    "            episode_id = episode_data[\"id\"]\n",
-    "            # search for the subtitle\n",
-    "            response = subtitles.search(tmdb_id=episode_id, languages=\"en\")\n",
-    "            if len(response.data) == 0:\n",
-    "                logger.warning(\n",
-    "                    f\"No subtitles found for {series_name} - S{season:02d}E{episode:02d}\"\n",
-    "                )\n",
-    "\n",
-    "            for subtitle in response.data:\n",
-    "                subtitle_dict = subtitle.to_dict()\n",
-    "                # Remove special characters and convert to uppercase\n",
-    "                filename_clean = re.sub(\n",
-    "                    r\"\\W+\", \" \", subtitle_dict[\"file_name\"]\n",
-    "                ).upper()\n",
-    "                if f\"E{episode:02d}\" in filename_clean:\n",
-    "                    logger.info(f\"Original filename: {subtitle_dict['file_name']}\")\n",
-    "                    srt_file = subtitles.download_and_save(subtitle)\n",
-    "                    series_name = series_name.replace(\":\", \" -\")\n",
-    "                    shutil.move(os.path.join(os.getcwd(),srt_file), srt_filepath)\n",
-    "                    logger.info(f\"Subtitle saved to {srt_filepath}\")\n",
-    "                    break\n",
-    "                else:\n",
-    "                    continue\n",
-    "        else:\n",
-    "            logger.info(\n",
-    "                f\"Subtitle already exists for {series_name} - S{season:02d}E{episode:02d}\"\n",
-    "            )\n",
-    "            continue"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "mkv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}