@@ -17,7 +21,7 @@ - Download subtitles to a specified directory - Launch MPV with the downloaded subtitles - Supports both file and directory inputs - - Support for selecting/downloading multiple subtitle files + - Support for downloading multiple subtitle files ## Installation @@ -113,6 +117,7 @@ To contribute to Jimaku Downloader, follow these steps: 3. Install the dependencies: ```sh + pip install -r requirements.txt pip install -r requirements_dev.txt ``` diff --git a/src/jimaku_dl/cli.py b/src/jimaku_dl/cli.py index bf1c7c8..0341e5e 100644 --- a/src/jimaku_dl/cli.py +++ b/src/jimaku_dl/cli.py @@ -14,14 +14,15 @@ def main(): """ Command line entry point for Jimaku subtitle downloader. """ - parser = ArgumentParser( - description="Download anime subtitles from Jimaku using the AniList API." - ) + parser = ArgumentParser(description="Download anime subtitles from Jimaku") parser.add_argument("media_path", help="Path to the media file or directory") parser.add_argument( "-d", "--dest", - help="Directory to save downloaded subtitles (default: same directory as video/input directory)", + help=( + "Directory to save downloaded subtitles " + "(default: same directory as video/input directory)" + ), ) parser.add_argument( "-p", diff --git a/src/jimaku_dl/downloader.py b/src/jimaku_dl/downloader.py index 31165db..52ae46b 100644 --- a/src/jimaku_dl/downloader.py +++ b/src/jimaku_dl/downloader.py @@ -1,7 +1,7 @@ #!/usr/bin/env python3 from logging import Logger, basicConfig, getLogger from os import environ -from os.path import abspath, basename, dirname, exists, isdir, join, normpath, splitext +from os.path import abspath, basename, dirname, exists, isdir, join, normpath from re import IGNORECASE from re import compile as re_compile from re import search, sub @@ -27,12 +27,13 @@ class JimakuDownloader: def __init__(self, api_token: Optional[str] = None, log_level: str = "INFO"): """ - Initialize the JimakuDownloader with API token and logging configuration. + Initialize the JimakuDownloader with API token and logging Parameters ---------- api_token : str, optional - Jimaku API token for authentication. If None, will try to get from JIMAKU_API_TOKEN env var + Jimaku API token for authentication. If None, will try to get from + JIMAKU_API_TOKEN env var log_level : str, default="INFO" Logging level to use (DEBUG, INFO, WARNING, ERROR, CRITICAL) """ @@ -41,7 +42,7 @@ class JimakuDownloader: self.api_token = api_token or environ.get("JIMAKU_API_TOKEN", "") if not self.api_token: self.logger.warning( - "No API token provided. Will need to be set before downloading." + "No API token provided. " "Will need to be set before downloading." ) def _setup_logging(self, log_level: str) -> Logger: @@ -108,7 +109,7 @@ class JimakuDownloader: clean_filename = filename # Try Trash Guides anime naming schema first - # Format: {Series Title} - S{season:00}E{episode:00} - {Episode Title} [...] + # Format: {Series Title} - S{season:00}E{episode:00} - {Episode Title} trash_guide_match = search( r"(.+?)(?:\(\d{4}\))?\s*-\s*[Ss](\d+)[Ee](\d+)\s*-\s*.+", basename(clean_filename), @@ -118,7 +119,10 @@ class JimakuDownloader: season = int(trash_guide_match.group(2)) episode = int(trash_guide_match.group(3)) self.logger.debug( - f"Parsed using Trash Guides format: {title=}, {season=}, {episode=}" + "Parsed using Trash Guides format: %s, %s, %s", + f"{title=}", + f"{season=}", + f"{episode=}", ) return title, season, episode @@ -134,17 +138,17 @@ class JimakuDownloader: title = parts[-3] # Try to get episode number from filename + pattern = r"[Ss](\d+)[Ee](\d+)|[Ee](?:pisode)" + pattern += r"?\s*(\d+)|(?:^|\s|[._-])(\d+)(?:\s|$|[._-])" ep_match = search( - r"[Ss](\d+)[Ee](\d+)|[Ee](?:pisode)?\s*(\d+)|(?:^|\s|[._-])(\d+)(?:\s|$|[._-])", + pattern, parts[-1], ) if ep_match: - # Find the first non-None group which contains the episode number episode_groups = ep_match.groups() episode_str = next( (g for g in episode_groups if g is not None), "1" ) - # If we found S01E01 format, use the episode part (second group) if ep_match.group(1) is not None and ep_match.group(2) is not None: episode_str = ep_match.group(2) episode = int(episode_str) @@ -152,7 +156,10 @@ class JimakuDownloader: episode = 1 self.logger.debug( - f"Parsed from Trash Guides directory structure: {title=}, {season=}, {episode=}" + "Parsed from Trash Guides directory structure: %s, %s, %s", + f"{title=}", + f"{season=}", + f"{episode=}", ) return title, season, episode @@ -163,7 +170,10 @@ class JimakuDownloader: season = int(match.group(2)) episode = int(match.group(3)) self.logger.debug( - f"Parsed using S01E01 format: {title=}, {season=}, {episode=}" + "Parsed using S01E01 format: %s, %s, %s", + f"{title=}", + f"{season=}", + f"{episode}", ) return title, season, episode @@ -173,22 +183,29 @@ class JimakuDownloader: # Check if the parent directory contains "Season" in the name season_dir = parts[-2] if "season" in season_dir.lower(): - season_match = search(r"season[. _-]*(\d+)", season_dir.lower()) + srch = r"season[. _-]*(\d+)" + season_match = search(srch, season_dir.lower()) if season_match: season = int(season_match.group(1)) # The show name is likely 2 directories up title = parts[-3].replace(".", " ").strip() # Try to find episode number in the filename ep_match = search( - r"[Ee](?:pisode)?[. _-]*(\d+)|[. _-](\d+)[. _-]", parts[-1] + r"[Ee](?:pisode)?[. _-]*(\d+)|[. _-](\d+)[. _-]", + parts[-1], ) episode = int( ep_match.group(1) if ep_match and ep_match.group(1) - else ep_match.group(2) if ep_match and ep_match.group(2) else 1 + else ( + ep_match.group(2) if ep_match and ep_match.group(2) else 1 + ) ) self.logger.debug( - f"Parsed from directory structure: {title=}, {season=}, {episode=}" + "Parsed from directory structure: %s, %s, %s", + f"{title=}", + f"{season=}", + f"{episode=}", ) return title, season, episode @@ -200,14 +217,15 @@ class JimakuDownloader: """ self.logger.warning("Could not parse filename automatically.") print(f"\nFilename: {filename}") - print("Could not automatically determine anime title and episode information.") + print("Could not determine anime title and episode information.") title = input("Please enter the anime title: ").strip() try: season = int( input("Enter season number (or 0 if not applicable): ").strip() or "1" ) episode = int( - input("Enter episode number (or 0 if not applicable): ").strip() or "1" + input("Enter episode number " + "(or 0 if not applicable): ").strip() + or "1" ) except ValueError: self.logger.error("Invalid input.") @@ -235,7 +253,7 @@ class JimakuDownloader: title = basename(dirname.rstrip("/")) if not title or title in [".", "..", "/"]: - self.logger.debug(f"Directory name '{title}' is not usable") + self.logger.debug("Directory name '%s' is not usable", title) return False, "", 1, 0 common_dirs = [ @@ -252,7 +270,8 @@ class JimakuDownloader: ] if title.lower() in common_dirs: self.logger.debug( - f"Directory name '{title}' is a common system directory, skipping" + "Directory name '%s' is a common system directory, skipping", + title, ) return False, "", 1, 0 @@ -270,7 +289,7 @@ class JimakuDownloader: def find_anime_title_in_path(self, path: str) -> Tuple[str, int, int]: """ - Recursively search for an anime title in the path, trying parent directories + Recursively search for an anime title in the path if necessary. Parameters @@ -281,7 +300,7 @@ class JimakuDownloader: Returns ------- tuple - (title, season, episode) - anime title and defaults for season and episode + (title, season, episode) Raises ------ @@ -295,7 +314,9 @@ class JimakuDownloader: success, title, season, episode = self.parse_directory_name(path) if success: - self.logger.debug(f"Found anime title '{title}' from directory: {path}") + self.logger.debug( + "Found anime title '%s' from directory: %s", title, path + ) return title, season, episode self.logger.debug(f"No anime title in '{path}', trying parent directory") @@ -306,15 +327,14 @@ class JimakuDownloader: path = parent_path - self.logger.error( - f"Could not extract anime title from directory path: {original_path}" - ) + self.logger.error("Could not extract anime title from path: %s", original_path) self.logger.error("Please specify a directory with a recognizable anime name") - raise ValueError(f"Could not find anime title in path: {original_path}") + raise ValueError("Could not find anime title in path: " + f"{original_path}") def load_cached_anilist_id(self, directory: str) -> Optional[int]: """ - Look for a file named '.anilist.id' in the given directory and return the AniList ID. + Look for a file named '.anilist.id' in the given directory + and return the AniList ID. Parameters ---------- @@ -338,7 +358,7 @@ class JimakuDownloader: def save_anilist_id(self, directory: str, anilist_id: int) -> None: """ - Save the AniList ID to a file named '.anilist.id' in the given directory. + Save the AniList ID to '.anilist.id' in the given directory Parameters ---------- @@ -360,7 +380,7 @@ class JimakuDownloader: def query_anilist(self, title: str, season: Optional[int] = None) -> int: """ - Query AniList's GraphQL API for the given title and return its media ID. + Query AniList's GraphQL API for the given title and return its ID. Parameters ---------- @@ -400,15 +420,14 @@ class JimakuDownloader: if season and season > 1: cleaned_title += f" - Season {season}" - variables = { - "search": cleaned_title - } + variables = {"search": cleaned_title} try: self.logger.debug("Querying AniList API for title: %s", title) self.logger.debug(f"Query variables: {variables}") response = requests_post( - self.ANILIST_API_URL, json={"query": query, "variables": variables} + self.ANILIST_API_URL, + json={"query": query, "variables": variables}, ) response.raise_for_status() data = response.json() @@ -436,7 +455,8 @@ class JimakuDownloader: print(f"\nPlease find the AniList ID for: {title}") print("Visit https://anilist.co and search for your anime.") print( - "The ID is the number in the URL, e.g., https://anilist.co/anime/12345 -> ID is 12345" + "The ID is the number in the URL, " + + "e.g., https://anilist.co/anime/12345 -> ID is 12345" ) while True: @@ -537,14 +557,14 @@ class JimakuDownloader: raise ValueError(f"No files found for entry ID: {entry_id}") return files except Exception as e: - self.logger.error(f"Error querying files for entry {entry_id}: {e}") + self.logger.error(f"Error getting files for entry {entry_id}: {e}") raise ValueError(f"Error retrieving files: {str(e)}") def filter_files_by_episode( self, files: List[Dict[str, Any]], target_episode: int ) -> List[Dict[str, Any]]: """ - Filter subtitle files to only include those matching the target episode. + Filter subtitle files to only include ones matching the target episode. Parameters ---------- @@ -556,7 +576,7 @@ class JimakuDownloader: Returns ------- list - Filtered list of file info dictionaries matching the target episode, + Filtered list of file info dicts matching the target episode, or all files if no matches are found """ specific_matches = [] @@ -568,7 +588,6 @@ class JimakuDownloader: all_episodes_keywords = ["all", "batch", "complete", "season", "full"] batch_files = [] - has_specific_match = False # First pass: find exact episode matches for file_info in files: @@ -584,10 +603,11 @@ class JimakuDownloader: if file_episode == target_episode: specific_matches.append(file_info) self.logger.debug( - f"Matched episode {target_episode} in: {filename}" + "Matched episode %s in: %s", + target_episode, + filename, ) matched = True - has_specific_match = True break except (ValueError, TypeError): continue @@ -609,14 +629,15 @@ class JimakuDownloader: if filtered_files: total_specific = len(specific_matches) total_batch = len(batch_files) - self.logger.info( - f"Found {len(filtered_files)} files matching episode {target_episode} " - f"({total_specific} specific matches, {total_batch} batch files)" - ) + msg = f"Found {len(filtered_files)} " + msg += f"matches for episode {target_episode} " + msg += f"({total_specific} specific matches, " + msg += f"{total_batch} batch files)" + self.logger.debug(msg) return filtered_files else: self.logger.warning( - f"No files matched episode {target_episode}, showing all options" + f"No files matched ep {target_episode}, showing all options" ) return files @@ -637,7 +658,7 @@ class JimakuDownloader: ------- str or list or None If multi=False: Selected option string or None if cancelled - If multi=True: List of selected option strings or empty list if cancelled + If multi=True: List of selected option strings or empty list """ try: fzf_args = ["fzf", "--height=40%", "--border"] @@ -712,14 +733,14 @@ class JimakuDownloader: """ Download subtitles for the given media path. - This is the main entry point method that orchestrates the entire download process. + This is the main entry point for the entire download process. Parameters ---------- media_path : str Path to the media file or directory dest_dir : str, optional - Directory to save downloaded subtitles (default: same directory as media) + Directory to save subtitles (default: same directory as media) play : bool, default=False Whether to launch MPV with the subtitles after download anilist_id : int, optional @@ -741,9 +762,9 @@ class JimakuDownloader: self.logger.info("Starting subtitle search and download process") is_directory = self.is_directory_input(media_path) - self.logger.info( - f"Processing {'directory' if is_directory else 'file'}: {media_path}" - ) + msg = f"Processing {'directory' if is_directory else 'file'}: " + msg += f"{media_path}" + self.logger.info(msg) if dest_dir: dest_dir = dest_dir @@ -760,7 +781,9 @@ class JimakuDownloader: media_dir = media_path media_file = None self.logger.debug( - f"Found anime title '{title}' but will save subtitles to: {dest_dir}" + "Found anime title '%s' but will save subtitles to: %s", + title, + dest_dir, ) else: base_filename = basename(media_path) @@ -781,19 +804,21 @@ class JimakuDownloader: self.logger.info(f"AniList ID for '{title}' is {anilist_id}") self.save_anilist_id(media_dir, anilist_id) else: - self.logger.info( - f"Using {'provided' if anilist_id else 'cached'} AniList ID: {anilist_id}" - ) + msg = f"Using {'provided' if anilist_id else 'cached'} " + msg += f"AniList ID: {anilist_id}" + self.logger.info(msg) # Now check for API token before making Jimaku API calls if not self.api_token: self.logger.error( "Jimaku API token is required to download subtitles. " - "Please set it with --token or the JIMAKU_API_TOKEN environment variable." + "Please set it with --token or the " + "JIMAKU_API_TOKEN environment variable." ) raise ValueError( "Jimaku API token is required to download subtitles. " - "Please set it with --token or the JIMAKU_API_TOKEN environment variable." + "Please set it with --token or the " + "JIMAKU_API_TOKEN environment variable." ) self.logger.info("Querying Jimaku for subtitle entries...") @@ -805,7 +830,8 @@ class JimakuDownloader: entry_options = [] entry_mapping = {} for i, entry in enumerate(entries, start=1): - opt = f"{i}. {entry.get('english_name', 'No Eng Name')} - {entry.get('japanese_name', 'None')}" + opt = f"{i}. {entry.get('english_name', 'No Eng Name')} - " + opt += f"{entry.get('japanese_name', 'None')}" entry_options.append(opt) entry_mapping[opt] = entry @@ -838,7 +864,7 @@ class JimakuDownloader: file_options.sort() self.logger.info( - f"Select {'one or more' if is_directory else 'one'} subtitle file(s):" + f"Select {'one or more' if is_directory else 'one'} " "subtitle file(s):" ) selected_files = self.fzf_menu(file_options, multi=is_directory) @@ -861,7 +887,7 @@ class JimakuDownloader: download_url = file_info.get("url") if not download_url: self.logger.warning( - f"File option '{opt}' does not have a download URL. Skipping." + f"File option '{opt}' does not have a download URL. " "Skipping." ) continue @@ -885,11 +911,13 @@ class JimakuDownloader: subprocess_run(mpv_cmd) except FileNotFoundError: self.logger.error( - "MPV not found. Please install MPV and ensure it is in your PATH." + "MPV not found. " + "Please install MPV and ensure it is in your PATH." ) elif play and is_directory: self.logger.warning( - "Cannot play media with MPV when input is a directory. Skipping playback." + "Cannot play media with MPV when input is a directory. " + "Skipping playback." ) self.logger.info("Subtitle download process completed successfully") diff --git a/tests/test_downloader.py b/tests/test_downloader.py index 9702cad..71fd98a 100644 --- a/tests/test_downloader.py +++ b/tests/test_downloader.py @@ -71,7 +71,9 @@ class TestJimakuDownloader: assert result == 123456 # Test with special characters in the title - result = downloader.query_anilist("KonoSuba – God’s blessing on this wonderful world!! (2016)", season=3) + result = downloader.query_anilist( + "KonoSuba – God’s blessing on this wonderful world!! (2016)", season=3 + ) assert result == 123456 # Don't try to assert on the mock_requests functions directly as they're not MagicMock objects @@ -670,27 +672,23 @@ class TestJimakuDownloader: """Test finding anime title with multiple path traversals.""" downloader = JimakuDownloader(api_token="test_token") - # Create nested directory structure - nested_dir = os.path.join(temp_dir, "Movies/Anime/Winter 2023/MyShow/Season 1") + # Create nested directory structure using proper path joining + path_components = ["Movies", "Anime", "Winter 2023", "MyShow", "Season 1"] + nested_dir = os.path.join(temp_dir, *path_components) os.makedirs(nested_dir, exist_ok=True) + # Get parent directories using os.path operations + parent_dir1 = os.path.dirname(nested_dir) # MyShow + parent_dir2 = os.path.dirname(parent_dir1) # Winter 2023 + parent_dir3 = os.path.dirname(parent_dir2) # Anime + # Mock parse_directory_name to simulate different results at different levels original_parse_dir = downloader.parse_directory_name results = { nested_dir: (False, "", 0, 0), # Fail at deepest level - os.path.dirname(nested_dir): (True, "MyShow", 1, 0), # Succeed at MyShow - os.path.dirname(os.path.dirname(nested_dir)): ( - False, - "", - 0, - 0, - ), # Fail at Winter 2023 - os.path.dirname(os.path.dirname(os.path.dirname(nested_dir))): ( - False, - "", - 0, - 0, - ), # Fail at Anime + parent_dir1: (True, "MyShow", 1, 0), # Succeed at MyShow + parent_dir2: (False, "", 0, 0), # Fail at Winter 2023 + parent_dir3: (False, "", 0, 0), # Fail at Anime } def mock_parse_directory_name(path): diff --git a/tests/test_parse_filename.py b/tests/test_parse_filename.py index d991766..81a4378 100644 --- a/tests/test_parse_filename.py +++ b/tests/test_parse_filename.py @@ -68,37 +68,47 @@ class TestParseFilename: def test_directory_structure_extraction(self): """Test extracting info from directory structure.""" - # Standard Season-## format - title, season, episode = self.downloader.parse_filename( - "/path/to/Show Name/Season-1/Show Name - 02 [1080p].mkv" - ) - assert title == "Show Name" - assert season == 1 - assert episode == 2 + # Mock _prompt_for_title_info to avoid reading from stdin for the entire test function + with patch.object(self.downloader, "_prompt_for_title_info") as mock_prompt: + # Configure mock to return appropriate values for different test cases + mock_prompt.side_effect = [ + ("Show Name", 1, 2), # First call return value + ("Show Name", 3, 4), # Second call return value + ("My Anime", 2, 5), # Third call return value + ("Long Anime Title With Spaces", 1, 3), # Fourth call return value + ] - # Season ## format - title, season, episode = self.downloader.parse_filename( - "/path/to/Show Name/Season 03/Episode 4.mkv" - ) - assert title == "Show Name" - assert season == 3 - assert episode == 4 + # Standard Season-## format + title, season, episode = self.downloader.parse_filename( + "/path/to/Show Name/Season-1/Show Name - 02 [1080p].mkv" + ) + assert title == "Show Name" + assert season == 1 + assert episode == 2 - # Simple number in season directory - title, season, episode = self.downloader.parse_filename( - "/path/to/My Anime/Season 2/5.mkv" - ) - assert title == "My Anime" - assert season == 2 - assert episode == 5 + # Season ## format + title, season, episode = self.downloader.parse_filename( + "/path/to/Show Name/Season 03/Episode 4.mkv" + ) + assert title == "Show Name" + assert season == 3 + assert episode == 4 - # Long pathname with complex directory structure - title, season, episode = self.downloader.parse_filename( - "/media/user/Anime/Long Anime Title With Spaces/Season-1/Long Anime Title With Spaces - 03.mkv" - ) - assert title == "Long Anime Title With Spaces" - assert season == 1 - assert episode == 3 + # Simple number in season directory + title, season, episode = self.downloader.parse_filename( + "/path/to/My Anime/Season 2/5.mkv" + ) + assert title == "My Anime" + assert season == 2 + assert episode == 5 + + # Long pathname with complex directory structure + title, season, episode = self.downloader.parse_filename( + "/media/user/Anime/Long Anime Title With Spaces/Season-1/Long Anime Title With Spaces - 03.mkv" + ) + assert title == "Long Anime Title With Spaces" + assert season == 1 + assert episode == 3 def test_complex_titles(self): """Test parsing filenames with complex titles."""