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

anipy_cli/menus/menu.py

@@ -0,0 +1,265 @@
+import sys
+from typing import TYPE_CHECKING, List
+
+from InquirerPy import inquirer
+from InquirerPy.base.control import Choice
+from anipy_api.download import Downloader
+from anipy_api.provider import LanguageTypeEnum, ProviderStream
+from anipy_api.locallist import LocalList
+import anipy_cli.logger as logger
+
+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,
+    get_post_download_scripts_hook,
+    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
+
+    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
+        )
+        self.seasonal_list = LocalList(Config()._seasonal_file_path, 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("Select from history", self.selec_hist, "h"),
+            MenuOption("Search for Anime", self.search, "a"),
+            MenuOption("Add to seasonals", self.add_seasonal, "t"),
+            MenuOption("Change video quality", self.change_quality, "v"),
+            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
+            )
+            if self.stream is None:
+                error("Could not find stream for requested Episode!")
+                return
+
+        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 selec_hist(self):
+        from anipy_cli.clis.history_cli import HistoryCli
+
+        hist_cli = HistoryCli(self.options)
+        hist_cli.run()
+
+    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")
+        if self.stream.referrer:
+            print(f"Referer: {self.stream.referrer}")
+
+        if self.stream.subtitle:
+            print("Subtitles:")
+            for name, sub in self.stream.subtitle.items():
+                print(f" {name} - {sub.url}")
+
+    def add_seasonal(self):
+        self.seasonal_list.update(
+            self.anime, episode=self.stream.episode, language=self.stream.language
+        )
+        cprint(colors.GREEN, "Anime added to seasonals!")
+
+    def change_quality(self):
+        with DotSpinner(
+            "Extracting streams for ",
+            colors.BLUE,
+            f"{self.anime.name} ({self.lang})",
+            " Episode ",
+            self.stream.episode,
+            "...",
+        ):
+            streams = self.anime.get_videos(self.stream.episode, self.lang)
+            streams.reverse()
+
+        stream = inquirer.select(  # type: ignore
+            message="Select Stream:",
+            choices=[
+                Choice(value=s, name=f"{s.resolution}p - {s.url}") for s in streams
+            ],
+            long_instruction="To skip this prompt press ctrl+z",
+            mandatory=False,
+        ).execute()
+
+        if stream is None:
+            return
+
+        stream = next(filter(lambda x: x.url == stream["url"], streams))
+        self.options.quality = stream.resolution
+        self.stream = stream
+        self.player.play_title(self.anime, self.stream)
+        self.print_options()
+
+    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, exc_info: BaseException | None = None):
+                logger.info(message, exc_info, exc_info is not None)
+                s.write(f"> {message}")
+
+            def error_display(message: str, exc_info: BaseException | None = None):
+                logger.error(message, exc_info)
+                s.write(f"{colors.RED}! {message}{colors.END}")
+
+            downloader = Downloader(progress_indicator, info_display, error_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,
+                post_dl_cb=get_post_download_scripts_hook("default", self.anime, s),
+            )
+
+        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,270 @@
+import sys
+from typing import TYPE_CHECKING, List, Tuple
+
+
+from anipy_cli.download_component import DownloadComponent
+
+from anipy_api.anime import Anime
+from anipy_api.provider import LanguageTypeEnum
+from anipy_api.provider.base import Episode
+from anipy_api.locallist import LocalList, LocalListEntry
+from anipy_api.error import ProviderNotAvailableError
+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,
+    migrate_locallist,
+)
+from anipy_cli.prompts import (
+    pick_episode_prompt,
+    search_show_prompt,
+    lang_prompt,
+    migrate_provider,
+)
+
+
+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("Migrate to current provider", self.migrate_provider, "m"),
+            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():
+                try:
+                    anime = Anime.from_local_list_entry(s)
+                except ProviderNotAvailableError:
+                    error(
+                        f"Can not load '{s.name}' because the configured provider"
+                        f" '{s.provider}' was not found, maybe try to migrate"
+                        " providers with 'm'."
+                    )
+                    continue
+
+                lang = s.language
+                episodes = anime.get_episodes(lang)
+
+                if s.episode == -1:
+                    to_watch = episodes
+                else:
+                    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]
+
+        if not choices:
+            return []
+
+        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("seasonal")
+
+        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 = -1
+
+        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):
+        all_seasonals = self.seasonal_list.get_all()
+        if not all_seasonals:
+            error("No seasonals configured.")
+            return
+
+        for i in all_seasonals:
+            print(i)
+
+    def migrate_provider(self):
+        migrate_provider("seasonal", self.seasonal_list)
+        self.print_options(should_clear_screen=True)
+
+    def download_latest(self):
+        picked = self._choose_latest()
+        total_eps = sum([len(e) for _a, _d, e in picked])
+        if total_eps == 0:
+            print("All up to date on downloads.")
+            return
+        else:
+            print(f"Downloading a total of {total_eps} episode(s)")
+
+        def on_successful_download(anime: Anime, ep: Episode, lang: LanguageTypeEnum):
+            self.seasonal_list.update(anime, episode=ep, language=lang)
+
+        failed_series = DownloadComponent(
+            self.options, self.dl_path, "seasonal"
+        ).download_anime(picked, on_successful_download)
+
+        if not self.options.auto_update:
+            # Clear screen only if there were no issues
+            self.print_options(should_clear_screen=len(failed_series) == 0)
+
+    def binge_latest(self):
+        picked = self._choose_latest()
+        total_eps = sum([len(e) for _a, _d, e in picked])
+        if total_eps == 0:
+            print("Up to date on binge.")
+            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
+                    )
+                    if stream is None:
+                        error("Could not find stream for requested episode, skipping")
+                    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)