anipy-cli 3.1.10__tar.gz → 3.2.0__tar.gz

{anipy_cli-3.1.10 → anipy_cli-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: anipy-cli
-Version: 3.1.10
+Version: 3.2.0
 Summary: Watch and Download anime from the comfort of your Terminal
 Home-page: https://sdaqo.github.io/anipy-cli
 License: GPL-3.0
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: anipy-api (>=3.1.10,<4.0.0)
+Requires-Dist: anipy-api (>=3.2.0,<4.0.0)
 Requires-Dist: appdirs (>=1.4.4,<2.0.0)
 Requires-Dist: inquirerpy (>=0.3.4,<0.4.0)
 Requires-Dist: pypresence (>=4.3.0,<5.0.0)

{anipy_cli-3.1.10 → anipy_cli-3.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "anipy-cli"
-version = "3.1.10"
+version = "3.2.0"
 description = "Watch and Download anime from the comfort of your Terminal"
 authors = ["sdaqo <sdaqo.dev@protonmail.com>"]
 license = "GPL-3.0"
@@ -20,7 +20,7 @@ yaspin = "^3.0.2"
 inquirerpy = "^0.3.4"
 appdirs = "^1.4.4"
 pypresence = "^4.3.0"
-anipy-api = "^3.1.10"
+anipy-api = "^3.2.0"
 
 [tool.poetry.scripts]
 anipy-cli = "anipy_cli.cli:run_cli"

{anipy_cli-3.1.10 → anipy_cli-3.2.0}/src/anipy_cli/__init__.py

@@ -1,2 +1,2 @@
 __appname__ = "anipy-cli"
-__version__ = "3.1.10"
+__version__ = "3.2.0"

{anipy_cli-3.1.10 → anipy_cli-3.2.0}/src/anipy_cli/clis/download_cli.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Optional, List
 
-from anipy_api.download import Downloader
+from anipy_cli.download_component import DownloadComponent
 
 from anipy_cli.clis.base_cli import CliBase
 from anipy_cli.colors import colors, cprint
@@ -12,10 +12,6 @@ from anipy_cli.prompts import (
     lang_prompt,
     parse_auto_search,
 )
-from anipy_cli.util import (
-    DotSpinner,
-    get_download_path,
-)
 
 if TYPE_CHECKING:
     from anipy_api.anime import Anime
@@ -73,45 +69,10 @@ class DownloadCli(CliBase):
         assert self.anime is not None
         assert self.lang is not None
 
-        config = Config()
-        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 e in self.episodes:
-                s.set_text(
-                    "Extracting streams for ",
-                    colors.BLUE,
-                    f"{self.anime.name} ({self.lang})",
-                    colors.END,
-                    " Episode ",
-                    e,
-                    "...",
-                )
-
-                stream = self.anime.get_video(
-                    e, self.lang, preferred_quality=self.options.quality
-                )
-
-                info_display(
-                    f"Downloading Episode {stream.episode} of {self.anime.name} ({self.lang})"
-                )
-                s.set_text("Downloading...")
-
-                downloader.download(
-                    stream,
-                    get_download_path(
-                        self.anime, stream, parent_directory=self.dl_path
-                    ),
-                    container=config.remux_to,
-                    ffmpeg=self.options.ffmpeg or config.ffmpeg_hls,
-                )
+        errors = DownloadComponent(self.options, self.dl_path).download_anime(
+            [(self.anime, self.lang, self.episodes)], only_skip_ep_on_err=True
+        )
+        DownloadComponent.serve_download_errors(errors, only_skip_ep_on_err=True)
 
     def show(self):
         pass

anipy_cli-3.2.0/src/anipy_cli/download_component.py

@@ -0,0 +1,166 @@
+from pathlib import Path
+from typing import List, Protocol, Tuple
+from anipy_cli.arg_parser import CliArgs
+from anipy_cli.colors import color, colors
+from anipy_cli.config import Config
+from anipy_cli.util import DotSpinner, get_download_path
+
+from anipy_api.anime import Anime
+from anipy_api.download import Downloader
+from anipy_api.provider.base import Episode, LanguageTypeEnum
+
+
+class SuccessfulEpDownload(Protocol):
+    """
+    Callback for when an episode successfully downloads
+    """
+
+    def __call__(self, anime: Anime, ep: Episode, lang: LanguageTypeEnum):
+        """
+        Args:
+            anime: The relevant anime
+            ep: An int/float for the episode
+            lang: The language that downloaded
+        """
+        ...
+
+
+class DownloadComponent:
+    """
+    A component used to download anime for
+    the ani-py CLI.
+    """
+
+    def __init__(self, cliArgs: CliArgs, dl_path: Path) -> None:
+        self.options = cliArgs
+        self.dl_path = dl_path
+
+    def download_anime(
+        self,
+        picked: List[Tuple[Anime, LanguageTypeEnum, List[Episode]]],
+        after_success_ep: SuccessfulEpDownload = lambda anime, ep, lang: None,
+        only_skip_ep_on_err: bool = False,
+    ) -> List[Tuple[Anime, Episode]]:
+        """
+        Attributes:
+            picked: The chosen animes to download
+            after_success_ep: The code to run when an anime successful downloads
+            only_skip_ep_on_err: If we should skip the specific episode on an error. If false, we skip the entire anime.
+        """
+        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}")
+
+            def error_display(message: str):
+                s.write(color(colors.RED, "! ", message))
+
+            downloader = Downloader(progress_indicator, info_display, error_display)
+
+            failed: List[Tuple[Anime, Episode]] = []
+
+            for anime, lang, eps in picked:
+                failed = self.download_episodes(
+                    s,
+                    downloader,
+                    anime,
+                    lang,
+                    eps,
+                    after_success_ep,
+                    only_skip_ep_on_err,
+                )
+
+            return failed
+
+    def download_episodes(
+        self,
+        spinner: DotSpinner,
+        downloader: Downloader,
+        anime: Anime,
+        lang: LanguageTypeEnum,
+        eps: List[Episode],
+        after_success_ep: SuccessfulEpDownload = lambda anime, ep, lang: None,
+        only_skip_ep_on_err: bool = False,
+    ) -> List[Tuple[Anime, Episode]]:
+        fails = []
+        for ep in eps:
+            try:
+                self.download_ep(spinner, downloader, anime, lang, ep)
+            except Exception as e:
+                if only_skip_ep_on_err:
+                    error_msg = f"! Issues downloading episode {ep} of {anime.name}. Skipping..."
+                else:
+                    error_msg = f"! Issues occurred while downloading the series ${anime.name}. Skipping..."
+                spinner.write(
+                    color(
+                        colors.RED,
+                        f"! Error: {e}\n",
+                        error_msg,
+                    )
+                )
+                fails.append((anime, ep))
+                if only_skip_ep_on_err:
+                    continue
+                return fails
+
+            after_success_ep(anime, ep, lang)
+        return fails
+
+    def download_ep(
+        self,
+        spinner: DotSpinner,
+        downloader: Downloader,
+        anime: Anime,
+        lang: LanguageTypeEnum,
+        ep: Episode,
+    ):
+        config = Config()
+
+        spinner.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)
+
+        spinner.write(
+            f"> Downloading Episode {stream.episode} of {anime.name} ({lang})"
+        )
+
+        spinner.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,
+        )
+
+    @staticmethod
+    def serve_download_errors(
+        failures: List[Tuple[Anime, Episode]],
+        only_skip_ep_on_err: bool = False,
+    ):
+        if not failures:
+            return
+        text = ", ".join([f"\n\tEpisode {i[1]} of {i[0].name}" for i in failures])
+        extra_info = (
+            " (and the remaining episodes in that series)"
+            if not only_skip_ep_on_err
+            else ""
+        )
+
+        print(
+            color(
+                colors.RED,
+                f"! Unable to download the following episodes{extra_info}: {text}",
+            )
+        )

{anipy_cli-3.1.10 → anipy_cli-3.2.0}/src/anipy_cli/menus/mal_menu.py

@@ -2,8 +2,9 @@ import sys
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import Dict, List, Tuple
 
+from anipy_cli.download_component import DownloadComponent
+
 from anipy_api.anime import Anime
-from anipy_api.download import Downloader
 from anipy_api.mal import MALAnime, MALMyListStatusEnum, MyAnimeList
 from anipy_api.provider import LanguageTypeEnum
 from anipy_api.provider.base import Episode
@@ -23,7 +24,6 @@ from anipy_cli.util import (
     error,
     find_closest,
     get_configured_player,
-    get_download_path,
     migrate_locallist,
 )
 from anipy_cli.prompts import search_show_prompt
@@ -249,7 +249,6 @@ class MALMenu(MenuBase):
 
     def download(self, all: bool = False):
         picked = self._choose_latest(all=all)
-        config = Config()
         total_eps = sum([len(e) for a, m, lang, e in picked])
         if total_eps == 0:
             print("Nothing to download, returning...")
@@ -257,49 +256,26 @@ class MALMenu(MenuBase):
         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, mal_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,
-                        "...",
-                    )
+        convert: Dict[Anime, MALAnime] = {d[0]: d[1] for d in picked}
+        new_picked = [
+            (anime_info[0], anime_info[2], anime_info[3]) for anime_info in picked
+        ]
 
-                    stream = anime.get_video(
-                        ep, lang, preferred_quality=self.options.quality
-                    )
+        def on_successful_download(anime: Anime, ep: Episode, lang: LanguageTypeEnum):
+            if all:
+                return
+            self.mal_proxy.update_show(
+                convert[anime],
+                status=MALMyListStatusEnum.WATCHING,
+                episode=int(ep),
+            )
 
-                    info_display(
-                        f"Downloading Episode {stream.episode} of {anime.name} ({lang})"
-                    )
-                    s.set_text("Downloading...")
+        errors = DownloadComponent(self.options, self.dl_path).download_anime(
+            new_picked, on_successful_download
+        )
+        DownloadComponent.serve_download_errors(errors)
 
-                    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,
-                    )
-                    if not all:
-                        self.mal_proxy.update_show(
-                            mal_anime,
-                            status=MALMyListStatusEnum.WATCHING,
-                            episode=int(ep),
-                        )
+        self.print_options(clear_screen=len(errors) == 0)
 
     def binge_latest(self):
         picked = self._choose_latest()
@@ -417,6 +393,10 @@ class MALMenu(MenuBase):
             if e.my_list_status.num_episodes_watched == e.num_episodes:
                 mylist.pop(i)
 
+        if not mylist:
+            error("MAL is empty", False)
+            return []
+
         if not (all or self.options.auto_update):
             choices = inquirer.fuzzy(  # type: ignore
                 message="Select shows to catch up to:",

{anipy_cli-3.1.10 → anipy_cli-3.2.0}/src/anipy_cli/menus/menu.py

@@ -211,7 +211,10 @@ class Menu(MenuBase):
             def info_display(message: str):
                 s.write(f"> {message}")
 
-            downloader = Downloader(progress_indicator, info_display)
+            def error_display(message: str):
+                s.write(f"{colors.RED}! {message}{colors.END}")
+
+            downloader = Downloader(progress_indicator, info_display, error_display)
 
             s.set_text(
                 "Extracting streams for ",

{anipy_cli-3.1.10 → anipy_cli-3.2.0}/src/anipy_cli/menus/seasonal_menu.py

@@ -1,8 +1,9 @@
 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.download import Downloader
 from anipy_api.provider import LanguageTypeEnum
 from anipy_api.provider.base import Episode
 from anipy_api.locallist import LocalList, LocalListEntry
@@ -17,7 +18,6 @@ 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
@@ -75,6 +75,9 @@ class SeasonalMenu(MenuBase):
         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,
@@ -86,6 +89,7 @@ class SeasonalMenu(MenuBase):
                 {"long_instruction": "fg:#5FAFFF bg:#222"}, style_override=False
             ),
         ).execute()
+
         return choices or []
 
     def add_anime(self):
@@ -180,65 +184,39 @@ class SeasonalMenu(MenuBase):
                 print(f"> {new_lang} is for {e.name} not available")
 
     def list_animes(self):
-        for i in self.seasonal_list.get_all():
+        all_seasonals = self.seasonal_list.get_all()
+        if not all_seasonals:
+            error("No seasonals configured.")
+            return
+
+        for i in all_seasonals:
             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...")
+            print("All up to date on downloads.")
             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
-                    )
+        def on_successful_download(anime: Anime, ep: Episode, lang: LanguageTypeEnum):
+            self.seasonal_list.update(anime, episode=ep, language=lang)
 
-                    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)
+        failed_series = DownloadComponent(self.options, self.dl_path).download_anime(
+            picked, on_successful_download
+        )
 
         if not self.options.auto_update:
-            self.print_options(clear_screen=True)
+            # Clear screen only if there were no issues
+            self.print_options(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("Nothing to watch, returning...")
+            print("Up to date on binge.")
             return
         else:
             print(f"Playing a total of {total_eps} episode(s)")

{anipy_cli-3.1.10 → anipy_cli-3.2.0}/src/anipy_cli/util.py

@@ -59,16 +59,17 @@ def error(error: str, fatal: bool = False) -> Union[NoReturn, None]:
         sys.stderr.write(
             color(colors.RED, "anipy-cli: error: ", colors.END, f"{error}\n")
         )
-    else:
-        sys.stderr.write(
-            color(
-                colors.RED,
-                "anipy-cli: fatal error: ",
-                colors.END,
-                f"{error}, exiting\n",
-            )
+        return
+
+    sys.stderr.write(
+        color(
+            colors.RED,
+            "anipy-cli: fatal error: ",
+            colors.END,
+            f"{error}, exiting\n",
         )
-        sys.exit(1)
+    )
+    sys.exit(1)
 
 
 def get_prefered_providers(mode: str) -> Iterator["BaseProvider"]: