anipy-cli 2.7.31__py3-none-any.whl → 3.0.0__py3-none-any.whl

anipy_cli/menus/menu.py

@@ -0,0 +1,194 @@
+import sys
+from typing import TYPE_CHECKING, List
+
+from anipy_api.download import Downloader
+from anipy_api.provider import LanguageTypeEnum
+from anipy_api.locallist import LocalList
+
+from anipy_cli.colors import colors, cprint
+from anipy_cli.config import Config
+from anipy_cli.menus.base_menu import MenuBase, MenuOption
+from anipy_cli.util import DotSpinner, error, get_download_path, migrate_locallist
+from anipy_cli.prompts import pick_episode_prompt, search_show_prompt
+
+
+if TYPE_CHECKING:
+    from anipy_api.anime import Anime
+    from anipy_api.player import PlayerBase
+    from anipy_api.provider import Episode, ProviderStream
+
+    from anipy_cli.arg_parser import CliArgs
+
+
+class Menu(MenuBase):
+    def __init__(
+        self,
+        options: "CliArgs",
+        anime: "Anime",
+        stream: "ProviderStream",
+        player: "PlayerBase",
+    ):
+        self.options = options
+        self.anime = anime
+        self.stream = stream
+        self.player = player
+        self.lang = stream.language
+        self.history_list = LocalList(
+            Config()._history_file_path, migrate_cb=migrate_locallist
+        )
+
+    @property
+    def menu_options(self) -> List["MenuOption"]:
+        return [
+            MenuOption("Next Episode", self.next_ep, "n"),
+            MenuOption("Previous Episode", self.prev_ep, "p"),
+            MenuOption("Replay Episode", self.repl_ep, "r"),
+            MenuOption(
+                f"Change to {'sub' if self.lang == LanguageTypeEnum.DUB else 'dub'}",
+                self.change_type,
+                "c",
+            ),
+            MenuOption("Select episode", self.selec_ep, "s"),
+            MenuOption("Search for Anime", self.search, "a"),
+            MenuOption("Print Video Info", self.video_info, "i"),
+            MenuOption("Download Episode", self.download_video, "d"),
+            MenuOption("Quit", self.quit, "q"),
+        ]
+
+    def print_header(self):
+        cprint(
+            colors.GREEN,
+            "Playing: ",
+            colors.BLUE,
+            f"{self.anime.name} ({self.lang})",
+            colors.GREEN,
+            f" | {self.stream.resolution}p | ",
+            colors.RED,
+            f"{self.stream.episode}/{self.anime.get_episodes(self.lang)[-1]}",
+        )
+
+    def _start_episode(self, episode: "Episode"):
+        with DotSpinner(
+            "Extracting streams for ",
+            colors.BLUE,
+            f"{self.anime.name} ({self.lang})",
+            " Episode ",
+            episode,
+            "...",
+        ):
+            self.stream = self.anime.get_video(
+                episode, self.lang, preferred_quality=self.options.quality
+            )
+
+        self.history_list.update(self.anime, episode=episode, language=self.lang)
+        self.player.play_title(self.anime, self.stream)
+
+    def next_ep(self):
+        episodes = self.anime.get_episodes(self.lang)
+        current_episode = episodes.index(self.stream.episode)
+        if len(episodes) <= current_episode + 1:
+            error("no episodes after this")
+        else:
+            next_episode = episodes[current_episode + 1]
+            self._start_episode(next_episode)
+
+        self.print_options()
+
+    def prev_ep(self):
+        episodes = self.anime.get_episodes(self.lang)
+        current_episode = episodes.index(self.stream.episode)
+        if current_episode - 1 < 0:
+            error("no episodes before this")
+        else:
+            prev_episode = episodes[current_episode - 1]
+            self._start_episode(prev_episode)
+
+        self.print_options()
+
+    def repl_ep(self):
+        self._start_episode(self.stream.episode)
+
+    def change_type(self):
+        to_change = (
+            LanguageTypeEnum.DUB
+            if self.lang == LanguageTypeEnum.SUB
+            else LanguageTypeEnum.SUB
+        )
+
+        if to_change not in self.anime.languages:
+            error(f"this anime does not have a {to_change} version")
+            return
+
+        if self.stream.episode not in self.anime.get_episodes(to_change):
+            error(
+                f"the current episode ({self.stream.episode}) is not available in {to_change}, not switching..."
+            )
+            return
+
+        self.lang = to_change
+        self.repl_ep()
+        self.print_options()
+
+    def selec_ep(self):
+        episode = pick_episode_prompt(self.anime, self.lang)
+        if episode is None:
+            return
+        self._start_episode(episode)
+        self.print_options()
+
+    def search(self):
+        search_result = search_show_prompt("default")
+        if search_result is None:
+            return
+        self.anime = search_result
+        episode = pick_episode_prompt(self.anime, self.lang)
+        if episode is None:
+            return
+        self._start_episode(episode)
+        self.print_options()
+
+    def video_info(self):
+        print(f"Show Name: {self.anime.name}")
+        print(f"Provider: {self.anime.provider.NAME}")
+        print(f"Stream Url: {self.stream.url}")
+        print(f"Quality: {self.stream.resolution}p")
+
+    def download_video(self):
+        config = Config()
+        with DotSpinner("Starting Download...") as s:
+
+            def progress_indicator(percentage: float):
+                s.set_text(f"Downloading ({percentage:.1f}%)")
+
+            def info_display(message: str):
+                s.write(f"> {message}")
+
+            downloader = Downloader(progress_indicator, info_display)
+
+            s.set_text(
+                "Extracting streams for ",
+                colors.BLUE,
+                f"{self.anime.name} ({self.lang})",
+                colors.END,
+                " Episode ",
+                self.stream.episode,
+                "...",
+            )
+
+            s.set_text("Downloading...")
+
+            path = downloader.download(
+                self.stream,
+                get_download_path(self.anime, self.stream),
+                container=config.remux_to,
+                ffmpeg=self.options.ffmpeg or config.ffmpeg_hls,
+            )
+
+        if Config().auto_open_dl_defaultcli:
+            self.player.play_file(str(path))
+
+        self.print_options()
+
+    def quit(self):
+        self.player.kill_player()
+        sys.exit(0)

anipy_cli/menus/seasonal_menu.py

@@ -0,0 +1,263 @@
+import sys
+from typing import TYPE_CHECKING, List, Tuple
+
+from anipy_api.anime import Anime
+from anipy_api.download import Downloader
+from anipy_api.provider import LanguageTypeEnum
+from anipy_api.provider.base import Episode
+from anipy_api.locallist import LocalList, LocalListEntry
+from InquirerPy import inquirer
+from InquirerPy.base.control import Choice
+from InquirerPy.utils import get_style
+
+from anipy_cli.colors import colors
+from anipy_cli.config import Config
+from anipy_cli.menus.base_menu import MenuBase, MenuOption
+from anipy_cli.util import (
+    DotSpinner,
+    error,
+    get_configured_player,
+    get_download_path,
+    migrate_locallist,
+)
+from anipy_cli.prompts import pick_episode_prompt, search_show_prompt, lang_prompt
+
+if TYPE_CHECKING:
+    from anipy_cli.arg_parser import CliArgs
+
+
+class SeasonalMenu(MenuBase):
+    def __init__(self, options: "CliArgs"):
+        self.options = options
+        self.player = get_configured_player(self.options.optional_player)
+
+        config = Config()
+        self.dl_path = config.seasonals_dl_path
+        self.seasonal_list = LocalList(config._seasonal_file_path, migrate_locallist)
+        if options.location:
+            self.dl_path = options.location
+
+    @property
+    def menu_options(self) -> List[MenuOption]:
+        return [
+            MenuOption("Add Anime", self.add_anime, "a"),
+            MenuOption("Delete one anime from seasonals", self.del_anime, "e"),
+            MenuOption("List anime in seasonals", self.list_animes, "l"),
+            MenuOption("Change dub/sub of anime in seasonals", self.change_lang, "c"),
+            MenuOption("Download newest episodes", self.download_latest, "d"),
+            MenuOption("Binge watch newest episodes", self.binge_latest, "w"),
+            MenuOption("Quit", self.quit, "q"),
+        ]
+
+    def print_header(self):
+        pass
+
+    def _choose_latest(self) -> List[Tuple["Anime", LanguageTypeEnum, List["Episode"]]]:
+        with DotSpinner("Fetching status of shows in seasonals..."):
+            choices = []
+            for s in self.seasonal_list.get_all():
+                anime = Anime.from_local_list_entry(s)
+                lang = s.language
+                episodes = anime.get_episodes(lang)
+                to_watch = episodes[episodes.index(s.episode) + 1 :]
+                if len(to_watch) > 0:
+                    ch = Choice(
+                        value=(anime, lang, to_watch),
+                        name=f"{anime.name} (to watch: {len(to_watch)})",
+                    )
+                    choices.append(ch)
+
+        if self.options.auto_update:
+            return [ch.value for ch in choices]
+
+        choices = inquirer.fuzzy(  # type: ignore
+            message="Select Seasonals to catch up to:",
+            choices=choices,
+            multiselect=True,
+            long_instruction="| skip prompt: ctrl+z | toggle: ctrl+space | toggle all: ctrl+a | continue: enter |",
+            mandatory=False,
+            keybindings={"toggle": [{"key": "c-space"}]},
+            style=get_style(
+                {"long_instruction": "fg:#5FAFFF bg:#222"}, style_override=False
+            ),
+        ).execute()
+        return choices or []
+
+    def add_anime(self):
+        anime = search_show_prompt("default")
+
+        if anime is None:
+            return
+
+        lang = lang_prompt(anime)
+
+        episode = pick_episode_prompt(
+            anime, lang, instruction="To start from the beginning skip this Prompt"
+        )
+
+        if episode is None:
+            episode = anime.get_episodes(lang)[0]
+
+        self.seasonal_list.update(anime, episode=episode, language=lang)
+
+        self.print_options()
+
+    def del_anime(self):
+        seasonals = self.seasonal_list.get_all()
+
+        if len(seasonals) == 0:
+            error("No seasonals configured.")
+            return
+
+        entries: List[LocalListEntry] = (
+            inquirer.fuzzy(  # type: ignore
+                message="Select Seasonals to delete:",
+                choices=seasonals,
+                multiselect=True,
+                long_instruction="| skip prompt: ctrl+z | toggle: ctrl+space | toggle all: ctrl+a | continue: enter |",
+                mandatory=False,
+                keybindings={"toggle": [{"key": "c-space"}]},
+                style=get_style(
+                    {"long_instruction": "fg:#5FAFFF bg:#222"}, style_override=False
+                ),
+            ).execute()
+            or []
+        )
+
+        for e in entries:
+            self.seasonal_list.delete(e)
+
+        self.print_options()
+
+    def change_lang(self):
+        seasonals = self.seasonal_list.get_all()
+
+        if len(seasonals) == 0:
+            error("No seasonals configured.")
+            return
+
+        entries: List[LocalListEntry] = (
+            inquirer.fuzzy(  # type: ignore
+                message="Select Seasonals to delete:",
+                choices=seasonals,
+                multiselect=True,
+                long_instruction="| skip prompt: ctrl+z | toggle: ctrl+space | toggle all: ctrl+a | continue: enter |",
+                mandatory=False,
+                keybindings={"toggle": [{"key": "c-space"}]},
+                style=get_style(
+                    {"long_instruction": "fg:#5FAFFF bg:#222"}, style_override=False
+                ),
+            ).execute()
+            or []
+        )
+
+        if not entries:
+            return
+
+        action: str = inquirer.select(  # type: ignore
+            message="Switch to:",
+            choices=["Sub", "Dub"],
+            long_instruction="To skip this prompt press ctrl+z",
+            mandatory=False,
+        ).execute()
+
+        if not action:
+            return
+
+        for e in entries:
+            if e.language == LanguageTypeEnum.DUB:
+                new_lang = LanguageTypeEnum.SUB
+            else:
+                new_lang = LanguageTypeEnum.DUB
+            if new_lang in e.languages:
+                self.seasonal_list.update(e, language=new_lang)
+            else:
+                print(f"> {new_lang} is for {e.name} not available")
+
+    def list_animes(self):
+        for i in self.seasonal_list.get_all():
+            print(i)
+
+    def download_latest(self):
+        picked = self._choose_latest()
+        config = Config()
+        total_eps = sum([len(e) for _a, _d, e in picked])
+        if total_eps == 0:
+            print("Nothing to download, returning...")
+            return
+        else:
+            print(f"Downloading a total of {total_eps} episode(s)")
+        with DotSpinner("Starting Download...") as s:
+
+            def progress_indicator(percentage: float):
+                s.set_text(f"Progress: {percentage:.1f}%")
+
+            def info_display(message: str):
+                s.write(f"> {message}")
+
+            downloader = Downloader(progress_indicator, info_display)
+
+            for anime, lang, eps in picked:
+                for ep in eps:
+                    s.set_text(
+                        "Extracting streams for ",
+                        colors.BLUE,
+                        f"{anime.name} ({lang})",
+                        colors.END,
+                        " Episode ",
+                        ep,
+                        "...",
+                    )
+
+                    stream = anime.get_video(
+                        ep, lang, preferred_quality=self.options.quality
+                    )
+
+                    info_display(
+                        f"Downloading Episode {stream.episode} of {anime.name}"
+                    )
+                    s.set_text("Downloading...")
+
+                    downloader.download(
+                        stream,
+                        get_download_path(anime, stream, parent_directory=self.dl_path),
+                        container=config.remux_to,
+                        ffmpeg=self.options.ffmpeg or config.ffmpeg_hls,
+                    )
+                    self.seasonal_list.update(anime, episode=ep, language=lang)
+
+        if not self.options.auto_update:
+            self.print_options(clear_screen=True)
+
+    def binge_latest(self):
+        picked = self._choose_latest()
+        total_eps = sum([len(e) for _a, _d, e in picked])
+        if total_eps == 0:
+            print("Nothing to watch, returning...")
+            return
+        else:
+            print(f"Playing a total of {total_eps} episode(s)")
+        for anime, lang, eps in picked:
+            for ep in eps:
+                with DotSpinner(
+                    "Extracting streams for ",
+                    colors.BLUE,
+                    f"{anime.name} ({lang})",
+                    colors.END,
+                    " Episode ",
+                    ep,
+                    "...",
+                ) as s:
+                    stream = anime.get_video(
+                        ep, lang, preferred_quality=self.options.quality
+                    )
+                    s.ok("✔")
+
+                self.player.play_title(anime, stream)
+                self.player.wait()
+                self.seasonal_list.update(anime, episode=ep, language=lang)
+
+        self.print_options()
+
+    def quit(self):
+        sys.exit(0)

anipy_cli/prompts.py

@@ -0,0 +1,231 @@
+import time
+from typing import TYPE_CHECKING, Optional, List, Tuple
+from InquirerPy import inquirer
+from anipy_api.provider import (
+    BaseProvider,
+    FilterCapabilities,
+    Filters,
+    LanguageTypeEnum,
+    Season,
+)
+from anipy_api.anime import Anime
+
+from anipy_cli.util import (
+    DotSpinner,
+    get_anime_season,
+    get_prefered_providers,
+    error,
+    parse_episode_ranges,
+)
+from anipy_cli.colors import colors
+from anipy_cli.config import Config
+
+
+if TYPE_CHECKING:
+    from anipy_api.provider import Episode
+
+
+def search_show_prompt(mode: str) -> Optional["Anime"]:
+    if not Config().skip_season_search:
+        season_provider = None
+        for p in get_prefered_providers(mode):
+            if p.FILTER_CAPS & (
+                FilterCapabilities.SEASON
+                | FilterCapabilities.YEAR
+                | FilterCapabilities.NO_QUERY
+            ):
+                season_provider = p
+        if season_provider is not None:
+            should_search = inquirer.confirm("Do you want to search in season?", default=False).execute()  # type: ignore
+            if not should_search:
+                print(
+                    "Hint: you can set `skip_season_search` to `true` in the config to skip this prompt!"
+                )
+            else:
+                return season_search_prompt(season_provider)
+
+    query = inquirer.text(  # type: ignore
+        "Search Anime:",
+        long_instruction="To cancel this prompt press ctrl+z",
+        mandatory=False,
+    ).execute()
+
+    if query is None:
+        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")
+        return search_show_prompt(mode)
+
+    anime = inquirer.fuzzy(  # type: ignore
+        message="Select Show:",
+        choices=results,
+        long_instruction="\nS = Anime is available in sub\nD = Anime is available in dub\nTo skip this prompt press ctrl+z",
+        mandatory=False,
+    ).execute()
+
+    return anime
+
+
+def season_search_prompt(provider: "BaseProvider") -> Optional["Anime"]:
+    year = inquirer.number(  # type: ignore
+        message="Enter year:",
+        long_instruction="To skip this prompt press ctrl+z",
+        default=time.localtime().tm_year,
+        mandatory=False,
+    ).execute()
+
+    if year is None:
+        return
+
+    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
+
+    season = Season[season.upper()]
+
+    filters = Filters(year=year, season=season)
+    results = [
+        Anime.from_search_result(provider, r)
+        for r in provider.get_search(query="", filters=filters)
+    ]
+
+    anime = inquirer.fuzzy(  # type: ignore
+        message="Select Show:",
+        choices=results,
+        long_instruction="\nS = Anime is available in sub\nD = Anime is available in dub\nTo skip this prompt press ctrl+z",
+        mandatory=False,
+    ).execute()
+
+    return anime
+
+
+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_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