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

anipy_cli/clis/binge_cli.py

@@ -0,0 +1,96 @@
+import sys
+from typing import TYPE_CHECKING
+
+from anipy_api.locallist import LocalList
+
+from anipy_cli.clis.base_cli import CliBase
+from anipy_cli.colors import colors, cprint
+from anipy_cli.config import Config
+from anipy_cli.prompts import (
+    parse_seasonal_search,
+    pick_episode_range_prompt,
+    search_show_prompt,
+    lang_prompt,
+    parse_auto_search,
+)
+from anipy_cli.util import DotSpinner, get_configured_player, migrate_locallist, error
+
+if TYPE_CHECKING:
+    from anipy_cli.arg_parser import CliArgs
+
+
+class BingeCli(CliBase):
+    def __init__(self, options: "CliArgs"):
+        super().__init__(options)
+
+        self.player = get_configured_player(self.options.optional_player)
+        self.history_list = LocalList(
+            Config()._history_file_path, migrate_cb=migrate_locallist
+        )
+
+        self.anime = None
+        self.episodes = None
+        self.lang = None
+
+    def print_header(self):
+        cprint(colors.GREEN, "***Binge Mode***")
+
+    def _get_anime_from_user(self):
+        if (ss := self.options.seasonal_search) is not None:
+            return parse_seasonal_search(
+                "binge",
+                ss,
+            )
+
+        return search_show_prompt("binge")
+
+    def take_input(self):
+        if self.options.search is not None:
+            self.anime, self.lang, self.episodes = parse_auto_search(
+                "binge", self.options.search
+            )
+            return
+
+        anime = self._get_anime_from_user()
+
+        if anime is None:
+            sys.exit(0)
+
+        self.lang = lang_prompt(anime)
+
+        episodes = pick_episode_range_prompt(anime, self.lang)
+
+        self.anime = anime
+        self.episodes = episodes
+
+    def process(self): ...
+
+    def show(self):
+        assert self.episodes is not None
+        assert self.anime is not None
+        assert self.lang is not None
+
+        for e in self.episodes:
+            with DotSpinner(
+                "Extracting streams for ",
+                colors.BLUE,
+                f"{self.anime.name} ({self.lang})",
+                colors.END,
+                " Episode ",
+                e,
+                "...",
+            ) as s:
+                stream = self.anime.get_video(
+                    e, self.lang, preferred_quality=self.options.quality
+                )
+                if stream is None:
+                    error("Could not find stream for requested episode, skipping")
+                    continue
+                s.ok("✔")
+
+            self.history_list.update(self.anime, episode=e, language=self.lang)
+            self.player.play_title(self.anime, stream)
+            self.player.wait()
+
+    def post(self):
+        self.player.kill_player()

anipy_cli/clis/default_cli.py

@@ -0,0 +1,115 @@
+from typing import TYPE_CHECKING, Optional
+
+from anipy_api.locallist import LocalList
+
+from anipy_cli.clis.base_cli import CliBase
+from anipy_cli.colors import colors
+from anipy_cli.config import Config
+from anipy_cli.menus import Menu
+from anipy_cli.prompts import (
+    lang_prompt,
+    parse_auto_search,
+    parse_seasonal_search,
+    pick_episode_prompt,
+    search_show_prompt,
+)
+from anipy_cli.util import DotSpinner, error, get_configured_player, migrate_locallist
+
+if TYPE_CHECKING:
+    from anipy_api.anime import Anime
+    from anipy_api.provider import Episode, LanguageTypeEnum, ProviderStream
+
+    from anipy_cli.arg_parser import CliArgs
+
+
+# TODO: Add Resume feature
+class DefaultCli(CliBase):
+    def __init__(self, options: "CliArgs"):
+        super().__init__(options)
+
+        self.player = get_configured_player(self.options.optional_player)
+        self.history_list = LocalList(
+            Config()._history_file_path, migrate_cb=migrate_locallist
+        )
+
+        self.anime: Optional["Anime"] = None
+        self.epsiode: Optional["Episode"] = None
+        self.stream: Optional["ProviderStream"] = None
+        self.lang: Optional["LanguageTypeEnum"] = None
+
+    def print_header(self):
+        pass
+
+    def _get_anime_from_user(self):
+        if (ss := self.options.seasonal_search) is not None:
+            return parse_seasonal_search(
+                "default",
+                ss,
+            )
+
+        return search_show_prompt("default")
+
+    def take_input(self):
+        if self.options.search is not None:
+            self.anime, self.lang, episodes = parse_auto_search(
+                "default", self.options.search
+            )
+            self.epsiode = episodes[0]
+            return
+
+        anime = self._get_anime_from_user()
+
+        if anime is None:
+            return False
+
+        self.lang = lang_prompt(anime)
+
+        episode = pick_episode_prompt(anime, self.lang)
+
+        if episode is None:
+            return False
+
+        self.anime = anime
+        self.epsiode = episode
+
+    def process(self):
+        assert self.anime is not None
+        assert self.epsiode is not None
+        assert self.lang is not None
+
+        with DotSpinner(
+            "Extracting streams for ",
+            colors.BLUE,
+            f"{self.anime.name} ({self.lang})",
+            " Episode ",
+            self.epsiode,
+            "...",
+        ):
+            self.stream = self.anime.get_video(
+                self.epsiode, self.lang, preferred_quality=self.options.quality
+            )
+            if not self.stream:
+                error(
+                    f"Could not find any streams for {self.anime.name} ({self.lang}) Episode {self.epsiode}",
+                    fatal=True,
+                )
+
+    def show(self):
+        assert self.anime is not None
+        assert self.stream is not None
+
+        self.history_list.update(
+            self.anime, episode=self.epsiode, language=self.stream.language
+        )
+        self.player.play_title(self.anime, self.stream)
+
+    def post(self):
+        assert self.anime is not None
+        assert self.stream is not None
+
+        Menu(
+            options=self.options,
+            anime=self.anime,
+            stream=self.stream,
+            player=self.player,
+        ).run()

anipy_cli/clis/download_cli.py

@@ -0,0 +1,85 @@
+from typing import TYPE_CHECKING, Optional, List
+
+from anipy_cli.download_component import DownloadComponent
+
+from anipy_cli.clis.base_cli import CliBase
+from anipy_cli.colors import colors, cprint
+from anipy_cli.config import Config
+from anipy_cli.prompts import (
+    parse_seasonal_search,
+    pick_episode_range_prompt,
+    search_show_prompt,
+    lang_prompt,
+    parse_auto_search,
+)
+
+if TYPE_CHECKING:
+    from anipy_api.anime import Anime
+    from anipy_api.provider import Episode, LanguageTypeEnum
+
+    from anipy_cli.arg_parser import CliArgs
+
+
+class DownloadCli(CliBase):
+    def __init__(self, options: "CliArgs"):
+        super().__init__(options)
+
+        self.anime: Optional["Anime"] = None
+        self.episodes: Optional[List["Episode"]] = None
+        self.lang: Optional["LanguageTypeEnum"] = None
+
+        self.dl_path = Config().download_folder_path
+        if options.location:
+            self.dl_path = options.location
+
+    def print_header(self):
+        cprint(colors.GREEN, "***Download Mode***")
+        cprint(colors.GREEN, "Downloads are stored in: ", colors.END, str(self.dl_path))
+
+    def _get_anime_from_user(self):
+        if (ss := self.options.seasonal_search) is not None:
+            return parse_seasonal_search(
+                "download",
+                ss,
+            )
+
+        return search_show_prompt("download")
+
+    def take_input(self):
+        if self.options.search is not None:
+            self.anime, self.lang, self.episodes = parse_auto_search(
+                "download", self.options.search
+            )
+            return
+
+        anime = self._get_anime_from_user()
+
+        if anime is None:
+            return False
+
+        self.lang = lang_prompt(anime)
+
+        episodes = pick_episode_range_prompt(anime, self.lang)
+
+        self.anime = anime
+        self.episodes = episodes
+
+    def process(self):
+        assert self.episodes is not None
+        assert self.anime is not None
+        assert self.lang is not None
+
+        errors = DownloadComponent(
+            self.options, self.dl_path, "download"
+        ).download_anime(
+            [(self.anime, self.lang, self.episodes)],
+            only_skip_ep_on_err=True,
+            sub_only=self.options.subtitles,
+        )
+        DownloadComponent.serve_download_errors(errors, only_skip_ep_on_err=True)
+
+    def show(self):
+        pass
+
+    def post(self):
+        pass

anipy_cli/clis/history_cli.py

@@ -0,0 +1,96 @@
+from typing import TYPE_CHECKING, Optional
+
+from InquirerPy.base.control import Choice
+from anipy_api.anime import Anime
+from anipy_api.locallist import LocalList, LocalListEntry
+from InquirerPy import inquirer
+
+from anipy_cli.clis.base_cli import CliBase
+from anipy_cli.colors import colors
+from anipy_cli.config import Config
+from anipy_cli.menus import Menu
+from anipy_cli.util import DotSpinner, get_configured_player, migrate_locallist
+
+if TYPE_CHECKING:
+    from anipy_api.provider import ProviderStream
+
+    from anipy_cli.arg_parser import CliArgs
+
+
+class HistoryCli(CliBase):
+    def __init__(self, options: "CliArgs"):
+        super().__init__(options)
+
+        self.player = get_configured_player(self.options.optional_player)
+        self.history_list = LocalList(
+            Config()._history_file_path, migrate_cb=migrate_locallist
+        )
+
+        self.anime: Optional[Anime] = None
+        self.history_entry: Optional["LocalListEntry"] = None
+        self.stream: Optional["ProviderStream"] = None
+
+    def print_header(self):
+        pass
+
+    def take_input(self):
+        history = self.history_list.get_all()
+        history.sort(key=lambda h: h.timestamp, reverse=True)
+
+        if not history:
+            print("You have no History, exiting")
+            return False
+
+        entry = inquirer.fuzzy(  # type: ignore
+            message="Select History Entry:",
+            choices=[
+                Choice(value=h, name=f"{n + 1}. {repr(h)}")
+                for n, h in enumerate(history)
+            ],
+            long_instruction="To cancel this prompt press ctrl+z",
+            mandatory=False,
+        ).execute()
+
+        if entry is None:
+            return False
+
+        self.history_entry = LocalListEntry.from_dict(entry)
+        self.anime = Anime.from_local_list_entry(self.history_entry)
+
+    def process(self):
+        assert self.anime is not None
+        assert self.history_entry is not None
+
+        with DotSpinner(
+            "Extracting streams for ",
+            colors.BLUE,
+            self.history_entry,
+            "...",
+        ):
+            self.stream = self.anime.get_video(
+                self.history_entry.episode,
+                self.history_entry.language,
+                preferred_quality=self.options.quality,
+            )
+
+    def show(self):
+        assert self.anime is not None
+        assert self.stream is not None
+
+        self.player.play_title(self.anime, self.stream)
+        self.history_list.update(
+            self.anime,
+            episode=self.stream.episode,
+            language=self.stream.language,
+        )
+
+    def post(self):
+        assert self.anime is not None
+        assert self.stream is not None
+
+        Menu(
+            options=self.options,
+            anime=self.anime,
+            stream=self.stream,
+            player=self.player,
+        ).run()

anipy_cli/clis/mal_cli.py

@@ -0,0 +1,71 @@
+from typing import TYPE_CHECKING
+
+from anipy_api.error import MyAnimeListError
+from anipy_api.mal import MyAnimeList
+from InquirerPy import inquirer
+
+from anipy_cli.clis.base_cli import CliBase
+from anipy_cli.config import Config
+from anipy_cli.menus import MALMenu
+from anipy_cli.util import DotSpinner, error
+
+if TYPE_CHECKING:
+    from anipy_cli.arg_parser import CliArgs
+
+
+class MalCli(CliBase):
+    def __init__(self, options: "CliArgs"):
+        super().__init__(options)
+        self.user = ""
+        self.password = ""
+        self.mal = None
+
+    def print_header(self):
+        pass
+
+    def take_input(self):
+        config = Config()
+        self.user = self.options.mal_user or config.mal_user
+        self.password = self.options.mal_password or config.mal_password
+
+        if not self.user:
+            self.user = inquirer.text(  # type: ignore
+                "Your MyAnimeList Username:",
+                validate=lambda x: len(x) > 1,
+                invalid_message="You must enter a username!",
+                long_instruction="Hint: You can save your username and password in the config!",
+            ).execute()
+
+        if not self.password:
+            self.password = inquirer.secret(  # type: ignore
+                "Your MyAnimeList Password:",
+                transformer=lambda _: "[hidden]",
+                validate=lambda x: len(x) > 1,
+                invalid_message="You must enter a password!",
+                long_instruction="Hint: You can also pass the password via the `--mal-password` option!",
+            ).execute()
+
+    def process(self):
+        try:
+            with DotSpinner("Logging into MyAnimeList..."):
+                self.mal = MyAnimeList.from_password_grant(self.user, self.password)
+        except MyAnimeListError as e:
+            error(
+                f"{str(e)}\nCannot login to MyAnimeList, it is likely your credentials are wrong",
+                fatal=True,
+            )
+
+    def show(self):
+        pass
+
+    def post(self):
+        assert self.mal is not None
+
+        menu = MALMenu(mal=self.mal, options=self.options)
+
+        if self.options.auto_update:
+            menu.download()
+        elif self.options.mal_sync_seasonals:
+            menu.sync_mal_seasonls()
+        else:
+            menu.run()

anipy_cli/{cli/clis → clis}/seasonal_cli.py

@@ -1,11 +1,14 @@
-from anipy_cli.arg_parser import CliArgs
-from anipy_cli.cli.menus import SeasonalMenu
-from anipy_cli.cli.clis.base_cli import CliBase
+from typing import TYPE_CHECKING
+from anipy_cli.menus import SeasonalMenu
+from anipy_cli.clis.base_cli import CliBase
+
+if TYPE_CHECKING:
+    from anipy_cli.arg_parser import CliArgs
 
 
 class SeasonalCli(CliBase):
-    def __init__(self, options: CliArgs, rpc_client=None):
-        super().__init__(options, rpc_client)
+    def __init__(self, options: "CliArgs"):
+        super().__init__(options)
 
     def print_header(self):
         pass
@@ -20,7 +23,7 @@ class SeasonalCli(CliBase):
         pass
 
     def post(self):
-        menu = SeasonalMenu(self.options, self.rpc_client)
+        menu = SeasonalMenu(self.options)
 
         if self.options.auto_update:
             menu.download_latest()

anipy_cli/colors.py

@@ -1,7 +1,8 @@
-class colors:
-    """
-    Just a class for colors
-    """
+from typing import Any
+
+
+class colors:  # noqa: N801
+    """Just a class for colors."""
 
     GREEN = "\033[92m"
     ERROR = "\033[93m"
@@ -11,23 +12,28 @@ class colors:
     CYAN = "\u001b[36m"
     RED = "\u001b[31m"
     END = "\x1b[0m"
+    BOLD = "\033[1m"
+    UNDERLINE = "\033[4m"
+    RESET = "\033[0m"
 
 
-def color(*values, sep: str = "") -> str:
+def color(*values: Any, sep: str = "") -> str:
     """Decorate a string with color codes.
+
     Basically just ensures that the color doesn't "leak"
     from the text.
-    format: color(color1, text1, color2, text2...)"""
+    format: color(color1, text1, color2, text2...)
+    """
     return sep.join(map(str, values)) + colors.END
 
 
-def cinput(*prompt, input_color: str = "") -> str:
+def cinput(*prompt: Any, input_color: str = "") -> str:
     """An input function that handles coloring input."""
     inp = input(color(*prompt) + input_color)
     print(colors.END, end="")
     return inp
 
 
-def cprint(*values, sep: str = "", **kwargs) -> None:
+def cprint(*values: Any, sep: str = "", **kwargs: Any) -> None:
     """Prints colored text."""
     print(color(*values, sep=sep), **kwargs)