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

anipy_cli/download_component.py

@@ -0,0 +1,194 @@
+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, get_post_download_scripts_hook
+import anipy_cli.logger as logger
+
+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, options: CliArgs, dl_path: Path, mode: str) -> None:
+        self.options = options
+        self.dl_path = dl_path
+        self.mode = mode
+
+    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,
+        sub_only: 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, 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)
+
+            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,
+                    sub_only,
+                )
+
+            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,
+        sub_only: bool = False,
+    ) -> List[Tuple[Anime, Episode]]:
+        fails = []
+        for ep in eps:
+            try:
+                self.download_ep(spinner, downloader, anime, lang, ep, sub_only)
+            except Exception as anime_download_error:
+                # Log it first so we don't run into another error below
+                logger.error(
+                    f"Error downloading episode {ep} of {anime.name}. Skipped.",
+                    anime_download_error,
+                )
+                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: {anime_download_error}\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,
+        sub_only: bool = False,
+    ):
+        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)
+
+        if stream is None:
+            logger.info("Could not find a stream")
+            DownloadComponent.serve_download_errors(
+                [(anime, ep)], only_skip_ep_on_err=True
+            )
+            return
+
+        download_message_update = (
+            f"Downloading Episode {stream.episode} of {anime.name} ({lang})"
+        )
+        logger.info(download_message_update)
+        spinner.write(f"> {download_message_update}")
+
+        spinner.set_text("Downloading...")
+
+        if not sub_only:
+            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,
+                post_dl_cb=get_post_download_scripts_hook(self.mode, anime, spinner),
+            )
+        else:
+            downloader.download_sub(
+                stream, get_download_path(anime, stream, parent_directory=self.dl_path)
+            )
+
+    @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/logger.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import logging
+import logging.handlers
+from pathlib import Path
+import sys
+from types import TracebackType
+from typing import Protocol
+import datetime
+
+from anipy_cli.config import Config
+from anipy_cli import __appname__
+from appdirs import user_data_dir
+
+
+class FatalHandler(Protocol):
+    def __call__(
+        self, exc_val: BaseException, exc_tb: TracebackType, logs_location: Path
+    ): ...
+
+
+class FatalCatcher:
+    def __init__(
+        self,
+        logs_location: Path,
+        fatal_handler: FatalHandler | None = None,
+        ignore_system_exit: bool = True,
+    ):
+        self._fatal_handler = fatal_handler
+
+        self.logs_location = logs_location
+        self.ignore_system_exit = ignore_system_exit
+
+    def __enter__(self):
+        info("Initializing program...")
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ):
+        if (not exc_type) or (not exc_val) or (not exc_tb):
+            info("Program exited successfully...")
+            return True
+
+        if exc_type is SystemExit and self.ignore_system_exit:
+            return True
+
+        try:
+            # Attempt to let a handler know something is up
+            # so it can get to the user
+            if self._fatal_handler:
+                self._fatal_handler(exc_val, exc_tb, self.logs_location)
+        except Exception:
+            # If that fails, at least get something to the user
+            sys.stderr.write("An extra fatal error occurred...")
+
+        fatal(f"A fatal error has occurred - {','.join(exc_val.args)}", exc_val)
+        info("Program exited with fatal errors...")
+
+        return True  # Return true because we have processed the error
+
+
+LOGGER_NAME = "cli_logger"
+MAX_LOGS = 5
+DEFAULT_FILE_LOG_LEVEL = 10
+DEFAULT_CONSOLE_LOG_LEVEL = 60
+
+
+def get_logs_location():
+    user_file_path = Path()
+    try:
+        user_file_path = Config().user_files_path
+    except Exception:
+        user_file_path = Path(user_data_dir(__appname__, appauthor=False))
+    finally:
+        return user_file_path / "logs"
+
+
+_logger = logging.getLogger(LOGGER_NAME)
+
+_logger.setLevel(10)
+
+file_formatter = logging.Formatter(
+    "{asctime} - {levelname} - {message}", style="{", datefmt=r"%Y-%m-%d %H:%M:%S"
+)
+console_formatter = logging.Formatter("{levelname} -> {message}", style="{")
+
+console_handler = logging.StreamHandler()
+console_handler.setFormatter(console_formatter)
+console_handler.setLevel(DEFAULT_CONSOLE_LOG_LEVEL)
+_logger.addHandler(console_handler)
+
+log_dir = get_logs_location()
+log_dir.mkdir(parents=True, exist_ok=True)
+
+current_time = datetime.datetime.now()
+file_handler = logging.handlers.RotatingFileHandler(
+    get_logs_location() / f"{current_time.isoformat().replace(':', '.')}.log",
+    backupCount=5,
+    encoding="utf-8",
+)
+file_handler.setFormatter(file_formatter)
+file_handler.setLevel(DEFAULT_FILE_LOG_LEVEL)
+_logger.addHandler(file_handler)
+
+
+def get_console_log_level():
+    return console_handler.level
+
+
+def set_console_log_level(value: logging._Level):
+    console_handler.setLevel(value)
+
+
+def get_file_log_level():
+    return file_handler.level
+
+
+def set_file_log_level(value: logging._Level):
+    file_handler.setLevel(value)
+
+
+def set_cli_verbosity(level: int):
+    """
+    Set how extreme the error has to
+    be for it to be printed in the CLI.
+
+    Default is 0.
+
+    0 = No Statements To CLI
+    1 = Fatal
+    2 = Warnings
+    3 = Info
+    """
+    level_conversion = {
+        0: 60,
+        1: 50,
+        2: 30,
+        3: 20,
+    }
+    other = 10  # If anything else, default to debug.
+    console_handler.setLevel(level_conversion.get(level, other))
+
+
+def safe(fatal_handler: FatalHandler | None = None):
+    return FatalCatcher(get_logs_location(), fatal_handler)
+
+
+_stack_always = False
+
+
+def set_stack_always(value: bool):
+    global _stack_always
+
+    _stack_always = value
+
+
+def is_stack_always(passthrough: bool):
+    """
+    If _stack_always is true, return true.
+
+    Otherwise return passthrough.
+    """
+    return True if _stack_always else passthrough
+
+
+def debug(
+    content: str, exc_info: logging._ExcInfoType = None, stack_info: bool = False
+):
+    _logger.debug(content, exc_info=exc_info, stack_info=is_stack_always(stack_info))
+
+
+def info(content: str, exc_info: logging._ExcInfoType = None, stack_info: bool = False):
+    _logger.info(content, exc_info=exc_info, stack_info=is_stack_always(stack_info))
+
+
+def warn(content: str, exc_info: logging._ExcInfoType = None, stack_info: bool = False):
+    _logger.warning(content, exc_info=exc_info, stack_info=is_stack_always(stack_info))
+
+
+def error(content: str, exc_info: logging._ExcInfoType = None):
+    _logger.error(content, exc_info=exc_info, stack_info=True)
+
+
+def fatal(content: str, exc_info: logging._ExcInfoType = None):
+    _logger.critical(content, exc_info=exc_info, stack_info=True)
+
+
+def log(
+    level: int,
+    content: str,
+    exc_info: logging._ExcInfoType = None,
+    stack_info: bool = False,
+):
+    _logger.log(
+        level, content, exc_info=exc_info, stack_info=is_stack_always(stack_info)
+    )

anipy_cli/mal_proxy.py

@@ -0,0 +1,228 @@
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Set
+
+from anipy_api.anime import Anime
+from anipy_api.mal import (
+    MALAnime,
+    MALMyListStatus,
+    MALMyListStatusEnum,
+    MyAnimeList,
+    MyAnimeListAdapter,
+)
+from anipy_api.provider import LanguageTypeEnum, list_providers
+from dataclasses_json import DataClassJsonMixin, config
+from InquirerPy import inquirer
+
+from anipy_cli.config import Config
+from anipy_cli.util import error, get_prefered_providers
+
+
+@dataclass
+class ProviderMapping(DataClassJsonMixin):
+    provider: str = field(metadata=config(field_name="pv"))
+    name: str = field(metadata=config(field_name="na"))
+    identifier: str = field(metadata=config(field_name="id"))
+    languages: Set[LanguageTypeEnum] = field(metadata=config(field_name="la"))
+
+
+@dataclass
+class MALProviderMapping(DataClassJsonMixin):
+    mal_anime: MALAnime
+    mappings: Dict[str, ProviderMapping]
+
+
+@dataclass
+class MALLocalList(DataClassJsonMixin):
+    mappings: Dict[int, MALProviderMapping]
+
+    def write(self, user_id: int):
+        config = Config()
+        local_list = config._mal_local_user_list_path.with_stem(
+            f"{config._mal_local_user_list_path.stem}_{user_id}"
+        )
+        local_list.write_text(self.to_json())
+
+    @staticmethod
+    def read(user_id: int) -> "MALLocalList":
+        config = Config()
+        local_list = config._mal_local_user_list_path.with_stem(
+            f"{config._mal_local_user_list_path.stem}_{user_id}"
+        )
+
+        if not local_list.is_file():
+            local_list.parent.mkdir(exist_ok=True, parents=True)
+            local_list.touch()
+            mylist = MALLocalList({})
+            mylist.write(user_id)
+            return mylist
+
+        try:
+            mylist: MALLocalList = MALLocalList.from_json(local_list.read_text())
+        except KeyError:
+            choice = inquirer.confirm(
+                message=f"Your local MyAnimeList ({str(local_list)}) is not in the correct format, should it be deleted?",
+                default=False,
+            ).execute()
+            if choice:
+                local_list.unlink()
+                return MALLocalList.read(user_id)
+            else:
+                error("could not read your MyAnimeList", fatal=True)
+
+        return mylist
+
+
+class MyAnimeListProxy:
+    def __init__(self, mal: MyAnimeList):
+        self.mal = mal
+        self.user_id = mal.get_user().id
+        self.local_list = MALLocalList.read(self.user_id)
+
+    def _cache_list(self, mylist: List[MALAnime]):
+        config = Config()
+        for e in mylist:
+            if self.local_list.mappings.get(e.id, None):
+                if (
+                    e.my_list_status
+                    and config.tracker_ignore_tag in e.my_list_status.tags
+                ):
+                    self.local_list.mappings.pop(e.id)
+                else:
+                    self.local_list.mappings[e.id].mal_anime = e
+            else:
+                self.local_list.mappings[e.id] = MALProviderMapping(e, {})
+
+        self.local_list.write(self.user_id)
+
+    def _write_mapping(self, mal_anime: MALAnime, mapping: Anime):
+        self._cache_list([mal_anime])
+
+        self.local_list.mappings[mal_anime.id].mappings[
+            f"{mapping.provider.NAME}:{mapping.identifier}"
+        ] = ProviderMapping(
+            mapping.provider.NAME, mapping.name, mapping.identifier, mapping.languages
+        )
+
+        self.local_list.write(self.user_id)
+
+    def get_list(
+        self, status_catagories: Optional[Set[MALMyListStatusEnum]] = None
+    ) -> List[MALAnime]:
+        config = Config()
+        mylist: List[MALAnime] = []
+
+        catagories = (
+            status_catagories
+            if status_catagories is not None
+            else set(
+                [
+                    MALMyListStatusEnum[s.upper()]
+                    for s in config.tracker_status_categories
+                ]
+            )
+        )
+
+        for c in catagories:
+            mylist.extend(
+                filter(
+                    lambda e: (
+                        config.tracker_ignore_tag not in e.my_list_status.tags
+                        if e.my_list_status
+                        else True
+                    ),
+                    self.mal.get_anime_list(c),
+                )
+            )
+
+        self._cache_list(mylist)
+        filtered_list = filter(
+            lambda x: (
+                x.my_list_status.status in catagories if x.my_list_status else False
+            ),
+            mylist,
+        )
+        return list(filtered_list)
+
+    def update_show(
+        self,
+        anime: MALAnime,
+        status: Optional[MALMyListStatusEnum] = None,
+        episode: Optional[int] = None,
+        tags: Set[str] = set(),
+    ) -> MALMyListStatus:
+        config = Config()
+        tags |= set(config.tracker_tags)
+        result = self.mal.update_anime_list(
+            anime.id, status=status, watched_episodes=episode, tags=list(tags)
+        )
+        anime.my_list_status = result
+        self._cache_list([anime])
+        return result
+
+    def delete_show(self, anime: MALAnime) -> None:
+        self.local_list.mappings.pop(anime.id)
+        self.local_list.write(self.user_id)
+
+        self.mal.remove_from_anime_list(anime.id)
+
+    def map_from_mal(
+        self, anime: MALAnime, mapping: Optional[Anime] = None
+    ) -> Optional[Anime]:
+        if mapping is not None:
+            self._write_mapping(anime, mapping)
+            return mapping
+
+        if self.local_list.mappings[anime.id].mappings:
+            for map in self.local_list.mappings[anime.id].mappings.values():
+                provider = next(
+                    filter(lambda x: x.NAME == map.provider, list_providers()), None
+                )
+
+                if provider is None:
+                    continue
+
+                return Anime(provider(), map.name, map.identifier, map.languages)
+
+        config = Config()
+        result = None
+        for p in get_prefered_providers("mal"):
+            adapter = MyAnimeListAdapter(self.mal, p)
+            result = adapter.from_myanimelist(
+                anime,
+                config.tracker_mapping_min_similarity,
+                config.tracker_mapping_use_filters,
+                config.tracker_mapping_use_alternatives,
+            )
+
+            if result is not None:
+                break
+
+        if result:
+            self._write_mapping(anime, result)
+
+        return result
+
+    def map_from_provider(
+        self, anime: Anime, mapping: Optional[MALAnime] = None
+    ) -> Optional[MALAnime]:
+        if mapping is not None:
+            self._write_mapping(mapping, anime)
+            return mapping
+
+        for _, m in self.local_list.mappings.items():
+            existing = m.mappings.get(f"{anime.provider.NAME}:{anime.identifier}", None)
+            if existing:
+                return m.mal_anime
+
+        config = Config()
+        adapter = MyAnimeListAdapter(self.mal, anime.provider)
+        result = adapter.from_provider(
+            anime,
+            config.tracker_mapping_min_similarity,
+            config.tracker_mapping_use_alternatives,
+        )
+
+        if result:
+            self._write_mapping(result, anime)
+
+        return result

anipy_cli/menus/__init__.py

@@ -0,0 +1,6 @@
+from anipy_cli.menus.menu import Menu
+from anipy_cli.menus.mal_menu import MALMenu
+from anipy_cli.menus.anilist_menu import AniListMenu
+from anipy_cli.menus.seasonal_menu import SeasonalMenu
+
+__all__ = ["Menu", "MALMenu", "AniListMenu", "SeasonalMenu"]