anipy-cli 2.7.17__py3-none-any.whl → 3.8.2__py3-none-any.whl

anipy_cli/prompts.py

@@ -0,0 +1,387 @@
+import time
+from typing import TYPE_CHECKING, Optional, List, Tuple
+from InquirerPy import inquirer
+from InquirerPy.base.control import Choice
+from anipy_api.mal import MyAnimeListAdapter
+from anipy_api.provider import (
+    BaseProvider,
+    FilterCapabilities,
+    Filters,
+    LanguageTypeEnum,
+    Season,
+)
+from anipy_api.anime import Anime
+
+from anipy_cli.util import (
+    DotSpinner,
+    find_closest,
+    get_anime_season,
+    get_prefered_providers,
+    error,
+    parse_episode_ranges,
+    convert_letter_to_season,
+)
+from anipy_cli.colors import colors
+from anipy_cli.config import Config
+
+
+if TYPE_CHECKING:
+    from anipy_api.provider import Episode
+    from anipy_api.locallist import LocalList
+
+
+def search_show_prompt(
+    mode: str, skip_season_search: bool = False
+) -> Optional["Anime"]:
+    if not (Config().skip_season_search or skip_season_search):
+        anime = season_search_pre_prompt(mode)
+        if anime is not None:
+            return anime
+
+    query = inquirer.text(  # type: ignore
+        "Search Anime:",
+        long_instruction="To cancel this prompt press ctrl+z",
+        mandatory=False,
+    ).execute()
+
+    if not (query and query.strip()):
+        return None
+
+    with DotSpinner("Searching for ", colors.BLUE, query, "..."):
+        results: List[Anime] = []
+        for provider in get_prefered_providers(mode):
+            results.extend(
+                [
+                    Anime.from_search_result(provider, x)
+                    for x in provider.get_search(query)
+                ]
+            )
+
+    if len(results) == 0:
+        error("no search results")
+        # Do not prompt for season again
+        return search_show_prompt(mode, skip_season_search=True)
+
+    anime = inquirer.fuzzy(  # type: ignore
+        message="Select Show:",
+        choices=[
+            Choice(value=r, name=f"{n + 1}. {repr(r)}") for n, r in enumerate(results)
+        ],
+        long_instruction=(
+            "\nS = Anime is available in sub\n"
+            "D = Anime is available in dub\n"
+            "First two letters indicate the provider\n"
+            "To skip this prompt press ctrl+z"
+        ),
+        mandatory=False,
+    ).execute()
+
+    return anime
+
+
+def _get_season_provider(mode: str) -> Optional["BaseProvider"]:
+    season_provider = None
+    for p in get_prefered_providers(mode):
+        if p.FILTER_CAPS & (
+            FilterCapabilities.SEASON
+            | FilterCapabilities.YEAR
+            | FilterCapabilities.NO_QUERY
+        ):
+            season_provider = p
+    return season_provider
+
+
+def season_search_pre_prompt(
+    mode: str, year: Optional[int] = None, season: Optional[str] = None
+) -> Optional["Anime"]:
+    season_provider = _get_season_provider(mode)
+    assume_season_search = Config().assume_season_search
+
+    # If there is no proper season provider
+    if season_provider is None:
+        if not assume_season_search:
+            return
+        # If assume search was on, and there is no proper season provider
+        print(
+            f"`assume_season_search` was set to true, but the providers ({', '.join(Config().providers[mode])}) you have selected do not have seasonal capabilities"
+        )
+        return
+
+    if assume_season_search or (year and season):
+        return season_search_prompt(season_provider, year, season)
+
+    should_search = inquirer.confirm("Do you want to search in season?", default=False).execute()  # type: ignore
+
+    if should_search:
+        return season_search_prompt(season_provider)
+
+    print(
+        "Hint: you can set `skip_season_search` to `true` in the config to skip this prompt!"
+    )
+
+
+def season_search_prompt(
+    provider: "BaseProvider", year: Optional[int] = None, season: Optional[str] = None
+) -> Optional["Anime"]:
+    if year is None:
+        curr_year = time.localtime().tm_year
+        year = inquirer.number(  # type: ignore
+            message="Enter year:",
+            long_instruction="To skip this prompt press ctrl+z",
+            default=curr_year,
+            mandatory=False,
+        ).execute()
+
+    if not year or not str(year).strip():
+        return
+
+    if season is None:
+        season = inquirer.select(  # type: ignore
+            message="Select Season:",
+            choices=["Winter", "Spring", "Summer", "Fall"],
+            instruction="The season selected by default is the current season.",
+            long_instruction="To skip this prompt press ctrl+z",
+            default=get_anime_season(time.localtime().tm_mon),
+            mandatory=False,
+        ).execute()
+
+    if season is None:
+        return
+
+    discovered_anime = get_anime_by_season(provider, year, Season[season.upper()])
+
+    if not discovered_anime:
+        error(f"No anime found in {season} {year}")
+        return
+
+    anime = inquirer.fuzzy(  # type: ignore
+        message="Select Show:",
+        choices=[
+            Choice(value=r, name=f"{n + 1}. {repr(r)}")
+            for n, r in enumerate(discovered_anime)
+        ],
+        long_instruction=(
+            "\nS = Anime is available in sub\n"
+            "D = Anime is available in dub\n"
+            "First two letters indicate the provider\n"
+            "To skip this prompt press ctrl+z"
+        ),
+        mandatory=False,
+    ).execute()
+
+    return anime
+
+
+def get_anime_by_season(provider: "BaseProvider", year: int, season: Season):
+    with DotSpinner(
+        "Retrieving anime in ", colors.BLUE, f"{season.name} {year}", "..."
+    ):
+        filters = Filters(year=year, season=season)
+        return [
+            Anime.from_search_result(provider, r)
+            for r in provider.get_search(query="", filters=filters)
+        ]
+
+
+def pick_episode_prompt(
+    anime: "Anime", lang: LanguageTypeEnum, instruction: str = ""
+) -> Optional["Episode"]:
+    with DotSpinner("Fetching episode list for ", colors.BLUE, anime.name, "..."):
+        episodes = anime.get_episodes(lang)
+
+    if not episodes:
+        error(f"No episodes available for {anime.name}")
+        return None
+
+    return inquirer.fuzzy(  # type: ignore
+        message="Select Episode:",
+        instruction=instruction,
+        choices=episodes,
+        long_instruction="To skip this prompt press ctrl+z",
+        mandatory=False,
+    ).execute()
+
+
+def pick_episode_range_prompt(
+    anime: "Anime", lang: LanguageTypeEnum
+) -> List["Episode"]:
+    with DotSpinner("Fetching episode list for ", colors.BLUE, anime.name, "..."):
+        episodes = anime.get_episodes(lang)
+
+    if not episodes:
+        error(f"No episodes available for {anime.name}")
+        return []
+
+    res = inquirer.text(  # type: ignore
+        message=f"Input Episode Range(s) from episodes {episodes[0]} to {episodes[-1]}:",
+        long_instruction="Type e.g. `1-10 19-20` or `3-4` or `3`\nTo skip this prompt press ctrl+z",
+        mandatory=False,
+    ).execute()
+
+    if res is None:
+        return []
+
+    return parse_episode_ranges(res, episodes)
+
+
+def lang_prompt(anime: "Anime") -> LanguageTypeEnum:
+    config = Config()
+    preferred = (
+        LanguageTypeEnum[config.preferred_type.upper()]
+        if config.preferred_type is not None
+        else None
+    )
+
+    if preferred in anime.languages:
+        return preferred
+
+    if LanguageTypeEnum.DUB not in anime.languages:
+        return LanguageTypeEnum.SUB
+
+    if len(anime.languages) == 2:
+        res = inquirer.confirm("Want to watch in dub?").execute()  # type: ignore
+        print("Hint: you can set a default in the config with `preferred_type`!")
+
+        if res:
+            return LanguageTypeEnum.DUB
+        else:
+            return LanguageTypeEnum.SUB
+    else:
+        return next(iter(anime.languages))
+
+
+def parse_seasonal_search(mode: str, passed: str | bool) -> Optional["Anime"]:
+    """
+    Takes the mode we are in, as well as the search parameters.
+    Asks the user to choose an anime.
+
+    `Mode`: The provider to use.
+    `Passed`: The search terms passed (ex: `year:season`) or True,
+    if True we'll ask the user for this information
+    """
+    if isinstance(passed, bool):
+        if not passed:
+            return
+
+        provider = _get_season_provider(mode)
+
+        if not provider:
+            error(
+                "No valid provider was found for season search in the current mode",
+                fatal=True,
+            )
+
+        return season_search_prompt(provider)
+
+    options = iter(passed.split(":"))
+    year = next(options, None)
+    season = next(options, None)
+
+    if (not year) or not year.isnumeric():
+        error("A year was either not provided, or was not a number", fatal=True)
+
+    if not season:
+        error("A season was not provided", fatal=True)
+
+    season = convert_letter_to_season(season)
+
+    if not season:
+        error("The given season was not a valid season", fatal=True)
+
+    return season_search_pre_prompt(mode, int(year), season)
+
+
+def parse_auto_search(
+    mode: str, passed: str
+) -> Tuple["Anime", LanguageTypeEnum, List["Episode"]]:
+    options = iter(passed.split(":"))
+    query = next(options, None)
+    ranges = next(options, None)
+    ltype = next(options, None)
+
+    if not query:
+        error("you provided the search parameter but no query", fatal=True)
+
+    if not ranges:
+        error("you provided the search parameter but no episode ranges", fatal=True)
+
+    if not (ltype == "sub" or ltype == "dub"):
+        ltype = Config().preferred_type
+
+    with DotSpinner("Searching for ", colors.BLUE, query, "..."):
+        results: List[Anime] = []
+        for provider in get_prefered_providers(mode):
+            results.extend(
+                [
+                    Anime.from_search_result(provider, x)
+                    for x in provider.get_search(query)
+                ]
+            )
+    if len(results) == 0:
+        error(f"no anime found for query {query}", fatal=True)
+
+    result = results[0]
+    if ltype is None:
+        lang = lang_prompt(result)
+    else:
+        lang = LanguageTypeEnum[ltype.upper()]
+
+    if lang not in result.languages:
+        error(f"{lang} is not available for {result.name}", fatal=True)
+
+    episodes = result.get_episodes(lang)
+    chosen = parse_episode_ranges(ranges, episodes)
+    if not chosen:
+        error("could not determine any epiosdes from search parameter", fatal=True)
+
+    return result, lang, chosen
+
+
+def migrate_provider(mode: str, local_list: "LocalList"):
+    config = Config()
+    all_entries = local_list.get_all()
+    current_providers = list(get_prefered_providers(mode))
+    print(
+        f"Migrating to configured providers ({mode}):",
+        ", ".join([p.NAME for p in current_providers]),
+    )
+    for s in all_entries:
+        if s.provider in [p.NAME for p in current_providers]:
+            continue
+
+        print(f"Mapping: {s.name}")
+
+        search_results: List[Anime] = []
+        for p in current_providers:
+            search_results.extend(
+                [Anime.from_search_result(p, r) for r in p.get_search(s.name)]
+            )
+
+        best_anime = None
+        best_ratio = 0
+        for r in search_results:
+            titles = {r.name}
+            titles |= set(r.get_info().alternative_names or [])
+            ratio = MyAnimeListAdapter._find_best_ratio(titles, {s.name})
+
+            if ratio > best_ratio:
+                best_ratio = ratio
+                best_anime = r
+
+            if best_ratio == 1:
+                break
+
+        if best_anime is None:
+            continue
+
+        if best_ratio >= config.mal_mapping_min_similarity:
+            local_list.delete(s)
+        else:
+            print(f"Could not autmatically map {s.name}, you can map it manually.")
+            best_anime = search_show_prompt("seasonal", skip_season_search=True)
+            if best_anime is None:
+                continue
+            local_list.delete(s)
+
+        episode = find_closest(best_anime.get_episodes(s.language), s.episode)
+        local_list.update(best_anime, language=s.language, episode=episode)

anipy_cli/util.py

@@ -0,0 +1,268 @@
+import logging
+import os
+import sys
+import subprocess as sp
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Iterator,
+    List,
+    Literal,
+    NoReturn,
+    Optional,
+    Union,
+    overload,
+)
+
+import anipy_cli.logger as logger
+
+from anipy_api.anime import Anime
+from anipy_api.download import Downloader, PostDownloadCallback
+from anipy_api.locallist import LocalListData
+from anipy_api.player import get_player
+from anipy_api.provider import list_providers
+from InquirerPy import inquirer
+from yaspin.core import Yaspin
+from yaspin.spinners import Spinners
+
+from anipy_cli.colors import color, colors
+from anipy_cli.config import Config
+from anipy_cli.discord import DiscordPresence
+
+if TYPE_CHECKING:
+    from anipy_api.player import PlayerBase
+    from anipy_api.provider import BaseProvider, Episode, ProviderStream
+
+
+class DotSpinner(Yaspin):
+    def __init__(self, *text_and_colors: Any, **spinner_args: Any):
+        super().__init__(
+            text=color(*text_and_colors),
+            color="cyan",
+            spinner=Spinners.dots,
+            **spinner_args,
+        )
+
+    def __enter__(self) -> "DotSpinner":
+        self.start()
+        return self
+
+    def set_text(self, *text_and_colors: Any):
+        self.text = color(*text_and_colors)
+
+
+@overload
+def error(error: str, fatal: Literal[True]) -> NoReturn: ...
+@overload
+def error(
+    error: str, fatal: Literal[False] = ..., log_level: int = logging.INFO
+) -> None: ...
+
+
+def error(
+    error: str, fatal: bool = False, log_level: int = logging.INFO
+) -> Union[NoReturn, None]:
+    if not fatal:
+        sys.stderr.write(
+            color(colors.RED, "anipy-cli: error: ", colors.END, f"{error}\n")
+        )
+        logger.log(log_level, error)
+        return
+
+    sys.stderr.write(
+        color(
+            colors.RED,
+            "anipy-cli: fatal error: ",
+            colors.END,
+            f"{error}, exiting\n",
+        )
+    )
+    logger.warn(error)
+    sys.exit(1)
+
+
+def clear_screen():
+    if logger.get_console_log_level() < 60:
+        return
+    os.system("cls" if os.name == "nt" else "clear")
+
+
+def get_prefered_providers(mode: str) -> Iterator["BaseProvider"]:
+    config = Config()
+    preferred_providers = config.providers[mode]
+
+    if not preferred_providers:
+        error(
+            f"you have no providers set for '{mode}' mode, look into your config",
+            fatal=True,
+        )
+
+    providers = []
+    for i in list_providers():
+        if i.NAME in preferred_providers:
+            url_override = config.provider_urls.get(i.NAME, None)
+            providers.append(i(url_override))
+
+    if not providers:
+        error(
+            f"there are no working providers for '{mode}' mode, look into your config",
+            fatal=True,
+        )
+
+    for p in providers:
+        yield p
+
+
+def get_download_path(
+    anime: "Anime",
+    stream: "ProviderStream",
+    parent_directory: Optional[Path] = None,
+) -> Path:
+    config = Config()
+    download_folder = parent_directory or config.download_folder_path
+
+    anime_name = Downloader._get_valid_pathname(anime.name)
+    filename = config.download_name_format.format(
+        show_name=anime_name,
+        episode_number=str(stream.episode).zfill(2),
+        quality=stream.resolution,
+        provider=anime.provider.NAME,
+        type=stream.language,
+    )
+
+    filename = Downloader._get_valid_pathname(filename)
+
+    return download_folder / anime_name / filename
+
+
+def get_post_download_scripts_hook(
+    mode: str, anime: "Anime", spinner: DotSpinner
+) -> PostDownloadCallback:
+    config = Config()
+    scripts = config.post_download_scripts[mode]
+    timeout = config.post_download_scripts["timeout"]
+
+    def hook(path: Path, stream: "ProviderStream"):
+        spinner.hide()
+        arguments = [
+            str(path),
+            anime.name,
+            str(stream.episode),
+            anime.provider.NAME,
+            str(stream.resolution),
+            stream.language.name,
+        ]
+        for s in scripts:
+            sub_proc = sp.Popen([s, *arguments])
+            sub_proc.wait(timeout)  # type: ignore
+        spinner.show()
+
+    return hook
+
+
+def parse_episode_ranges(ranges: str, episodes: List["Episode"]) -> List["Episode"]:
+    picked = set()
+    for r in ranges.split():
+        numbers = [parsenum(n) for n in r.split("-")]
+        if numbers[0] > numbers[-1]:
+            error(f"invalid range: {r}")
+            continue
+        try:
+            picked = picked | set(
+                episodes[episodes.index(numbers[0]) : episodes.index(numbers[-1]) + 1]
+            )
+        except ValueError:
+            error(f"range `{r}` is not contained in episodes {episodes}")
+            continue
+
+    return sorted(picked)
+
+
+def parsenum(n: str):
+    try:
+        return int(n)
+    except ValueError:
+        return float(n)
+
+
+def find_closest(episodes: List["Episode"], target: "Episode") -> "Episode":
+    left, right = 0, len(episodes) - 1
+    while left < right:
+        if abs(episodes[left] - target) <= abs(episodes[right] - target):
+            right -= 1
+        else:
+            left += 1
+
+    return episodes[left]
+
+
+def get_configured_player(player_override: Optional[str] = None) -> "PlayerBase":
+    config = Config()
+    player = Path(player_override or config.player_path)
+    if config.dc_presence:
+        # If the cache size is 0, it means that DiscordPresence was
+        # not intialized once in the run_cli function and therefore we
+        # can assume that it failed to initialize beacuse of some error.
+        if DiscordPresence.cache_info().currsize > 0:
+            discord_cb = DiscordPresence().dc_presence_callback
+        else:
+            discord_cb = None
+    else:
+        discord_cb = None
+
+    if "mpv" in player.stem:
+        args = config.mpv_commandline_options
+    elif "vlc" in player.stem:
+        args = config.vlc_commandline_options
+    elif "iina" in player.stem:
+        args = config.iina_commandline_options
+    else:
+        args = []
+
+    return get_player(player, args, discord_cb)
+
+
+def get_anime_season(month: int):
+    if 1 <= month <= 3:
+        return "Winter"
+    elif 4 <= month <= 6:
+        return "Spring"
+    elif 7 <= month <= 9:
+        return "Summer"
+    else:
+        return "Fall"
+
+
+def convert_letter_to_season(letter: str) -> Optional[str]:
+    """
+    Converts the beginning of the name of a season to that season name.
+
+    Ex:
+    ```
+    win -> Winter
+    su -> Summer
+    sp -> Spring
+    ```
+
+    Returns None if the letter does not correspond to a season
+    """
+    for season in ["Spring", "Summer", "Fall", "Winter"]:
+        if season.startswith(letter.capitalize()):
+            return season
+    return
+
+
+def migrate_locallist(file: Path) -> LocalListData:
+    error(f"{file} is in an unsuported format...")
+
+    new_list = LocalListData({})
+    choice = inquirer.confirm(  # type: ignore
+        message="Should it be delted?",
+        default=False,
+    ).execute()
+    if choice:
+        file.unlink()
+        return new_list
+    else:
+        error("could not read {file}", fatal=True)