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

anipy_cli/config.py

@@ -42,6 +42,10 @@ class Config:
     def _mal_local_user_list_path(self) -> Path:
         return self.user_files_path / "mal_list.json"
 
+    @property
+    def _anilist_local_user_list_path(self) -> Path:
+        return self.user_files_path / "anilist_list.json"
+
     @property
     def download_folder_path(self) -> Path:
         """Path to your download folder/directory.
@@ -66,13 +70,13 @@ class Config:
     def providers(self) -> Dict[str, List[str]]:
         """A list of pairs defining which providers will search for anime
         in different parts of the program. Configurable areas are as follows:
-        default (and history), download (-D), seasonal (-S), binge (-B) and mal
-        (-M) The example will show you how it is done! Please note that for seasonal
+        default (and history), download (-D), seasonal (-S), binge (-B), anilist (-A)
+        and mal (-M) The example will show you how it is done! Please note that for seasonal
         search always the first provider that supports it is used.
 
         For an updated list of providers look here: https://sdaqo.github.io/anipy-cli/availabilty
 
-        Supported providers (as of $version): animekai
+        Supported providers (as of $version): allanime, animekai (animekai is not functional for now), native (filesystem provider, set root in provider_urls config)
 
         Examples:
             providers:
@@ -81,13 +85,15 @@ class Config:
                 seasonal: ["provider3"]
                 binge: ["provider4"]
                 mal: ["provider2", "provider3"]
+                anilist: ["provider1"]
         """
         defaults = {
-            "default": ["animekai"],
-            "download": ["animekai"],
-            "seasonal": ["animekai"],
-            "binge": ["animekai"],
-            "mal": ["animekai"],
+            "default": ["allanime"],
+            "download": ["allanime"],
+            "seasonal": ["allanime"],
+            "binge": ["allanime"],
+            "mal": ["allanime"],
+            "anilist": ["allanime"],
         }
 
         value = self._get_value("providers", defaults, dict)
@@ -100,9 +106,12 @@ class Config:
     def provider_urls(self) -> Dict[str, str]:
         """A list of pairs to override the default urls that providers use.
 
+        Note: the native provider accepts a path instead of a url, it defaults to ~/Videos
+
         Examples:
             provider_urls:
               gogoanime: "https://gogoanime3.co"
+              native: "~/Videos"
             provider_urls: {} # do not override any urls
         """
 
@@ -227,9 +236,9 @@ class Config:
         """With this option you can define scripts that run after a file
         has been downloaded. As with the 'providers' option, you can configure
         different behaviour, depending on which part of anipy-cli the download occurs.
-        Configurable areas are as follows: default (and history), download (-D), seasonal (-S)
-        and mal (-M). The example will show you how it is done! Please note that if you define 
-        several scripts for one area, they will run in the order you put them in the list.
+        Configurable areas are as follows: default (and history), download (-D), seasonal (-S),
+        anilist (-A) and mal (-M). The example will show you how it is done! Please note that
+        if you define several scripts for one area, they will run in the order you put them in the list.
         You can also define a timeout (in seconds), after which a script will be terminated,
         if set to null there will be no timeout and any script will run forever.
 
@@ -254,7 +263,8 @@ class Config:
             "download": [],
             "seasonal": [],
             "mal": [],
-            "timeout": None
+            "anilist": [],
+            "timeout": None,
         }
 
         value = self._get_value("post_download_scripts", defaults, dict)
@@ -279,6 +289,11 @@ class Config:
         """Your MyAnimeList username for MAL mode."""
         return self._get_value("mal_user", "", str)
 
+    @property
+    def anilist_token(self) -> str:
+        """Your AniList access token for AniList mode."""
+        return self._get_value("anilist_token", "", str)
+
     @property
     def mal_password(self) -> str:
         """Your MyAnimeList password for MAL mode.
@@ -289,55 +304,55 @@ class Config:
         return self._get_value("mal_password", "", str)
 
     @property
-    def mal_ignore_tag(self) -> str:
+    def tracker_ignore_tag(self) -> str:
         """All anime in your MyAnimeList with this tag will be ignored by
         anipy-cli.
 
         Examples:
-            mal_ignore_tag: ignore # all anime with ignore tag will be ignored
-            mal_ignore_tag: "" # no anime will be ignored
+            tracker_ignore_tag: ignore # all anime with ignore tag will be ignored
+            tracker_ignore_tag: "" # no anime will be ignored
         """
-        return self._get_value("mal_ignore_tag", "ignore", str)
+        return self._get_value("tracker_ignore_tag", "ignore", str)
 
     @property
-    def mal_dub_tag(self) -> str:
-        """All anime in your MyAnimeList with this tag will be switched over to
-        dub in MAL mode, if the dub is available. If you do not specify a tag,
-        anipy-cli will use `preferred_type` to choose dub or sub in MAL mode.
+    def tracker_dub_tag(self) -> str:
+        """All anime in your Anime Tracker with this tag will be switched over to
+        dub in tracker mode, if the dub is available. If you do not specify a tag,
+        anipy-cli will use `preferred_type` to choose dub or sub in tracker mode.
 
         Examples:
-            mal_dub_tag: dub # all anime with this tag will be switched to dub
-            mal_dub_tag: "" # no anime will be switched to dub, except you have preferred_type on dub
+            tracker_dub_tag: dub # all anime with this tag will be switched to dub
+            tracker_dub_tag: "" # no anime will be switched to dub, except you have preferred_type on dub
         """
-        return self._get_value("mal_dub_tag", "dub", str)
+        return self._get_value("tracker_dub_tag", "dub", str)
 
     @property
-    def mal_tags(self) -> List[str]:
-        """Custom tags to tag all anime in your MyAnimeList that are
+    def tracker_tags(self) -> List[str]:
+        """Custom tags to tag all anime in your Anime Tracker that are
         altered/added by anipy-cli.
 
         Examples:
-            mal_tags: ["anipy-cli"] # tag all anime with anipy-cli
-            mal_tags: ["anipy-cli", "important"] # tag all anime with anipy-cli and important
-            mal_tags: null or mal_tags: [] # Do not tag the anime
+            tracker_tags: ["anipy-cli"] # tag all anime with anipy-cli
+            tracker_tags: ["anipy-cli", "important"] # tag all anime with anipy-cli and important
+            tracker_tags: null or tracker_tags: [] # Do not tag the anime
         """
-        return self._get_value("mal_tags", [], list)
+        return self._get_value("tracker_tags", [], list)
 
     @property
-    def mal_status_categories(self) -> List[str]:
-        """Status categories of your MyAnimeList that anipy-cli uses for
+    def tracker_status_categories(self) -> List[str]:
+        """Status categories of your Anime Tracker that anipy-cli uses for
         downloading/watching new episodes listing anime in your list and stuff
         like that. Normally the watching catagory should be enough as you would
         normally put anime you currently watch in the watching catagory.
 
         Valid values are: watching, completed, on_hold, dropped, plan_to_watch
         """
-        return self._get_value("mal_status_categories", ["watching"], list)
+        return self._get_value("tracker_status_categories", ["watching"], list)
 
     @property
-    def mal_mapping_min_similarity(self) -> float:
+    def tracker_mapping_min_similarity(self) -> float:
         """
-        The minumum similarity between titles when mapping anime in MAL mode.
+        The minumum similarity between titles when mapping anime in tracker mode.
         This is a decimal number from 0 - 1, 1 meaning 100% match and 0 meaning all characters are different.
         If the similarity of a map is below the threshold you will be prompted for a manual map.
 
@@ -347,24 +362,24 @@ class Config:
 
         If you are interested, the algorithm being used here is this: https://en.wikipedia.org/wiki/Levenshtein_distance
         """
-        return self._get_value("mal_mapping_min_similarity", 0.8, float)
+        return self._get_value("tracker_mapping_min_similarity", 0.8, float)
 
     @property
-    def mal_mapping_use_alternatives(self) -> bool:
+    def tracker_mapping_use_alternatives(self) -> bool:
         """Check alternative names when mapping anime.
 
         If turned on this will slow down mapping but provide better
         chances of finding a match.
         """
-        return self._get_value("mal_mapping_use_alternatives", True, bool)
+        return self._get_value("tracker_mapping_use_alternatives", True, bool)
 
     @property
-    def mal_mapping_use_filters(self) -> bool:
+    def tracker_mapping_use_filters(self) -> bool:
         """Use filters (e.g. year, season etc.) of providers to narrow down the
         results, this will lead to more accurate mapping, but provide wrong
         results if the filters of the provider do not work properly or if anime
         are not correctly marked with the correct data."""
-        return self._get_value("mal_mapping_use_filters", True, bool)
+        return self._get_value("tracker_mapping_use_filters", True, bool)
 
     @property
     def auto_sync_mal_to_seasonals(self) -> bool:
@@ -414,7 +429,7 @@ class Config:
         except RuntimeError:
             return fallback
 
-    def _get_value(self, key: str, fallback, _type: Type) -> Any:
+    def _get_value(self, key: str, fallback: Any, _type: Type) -> Any:
         value = self._yaml_conf.get(key, fallback)
         if isinstance(value, _type):
             return value

anipy_cli/download_component.py

@@ -4,6 +4,7 @@ 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
@@ -32,7 +33,7 @@ class DownloadComponent:
     """
 
     def __init__(self, options: CliArgs, dl_path: Path, mode: str) -> None:
-        self.options = options 
+        self.options = options
         self.dl_path = dl_path
         self.mode = mode
 
@@ -41,6 +42,7 @@ class DownloadComponent:
         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:
@@ -53,11 +55,13 @@ class DownloadComponent:
             def progress_indicator(percentage: float):
                 s.set_text(f"Progress: {percentage:.1f}%")
 
-            def info_display(message: str):
+            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):
-                s.write(color(colors.RED, "! ", 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)
 
@@ -72,6 +76,7 @@ class DownloadComponent:
                     eps,
                     after_success_ep,
                     only_skip_ep_on_err,
+                    sub_only,
                 )
 
             return failed
@@ -85,12 +90,18 @@ class DownloadComponent:
         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)
-            except Exception as e:
+                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:
@@ -98,7 +109,7 @@ class DownloadComponent:
                 spinner.write(
                     color(
                         colors.RED,
-                        f"! Error: {e}\n",
+                        f"! Error: {anime_download_error}\n",
                         error_msg,
                     )
                 )
@@ -117,6 +128,7 @@ class DownloadComponent:
         anime: Anime,
         lang: LanguageTypeEnum,
         ep: Episode,
+        sub_only: bool = False,
     ):
         config = Config()
 
@@ -132,19 +144,33 @@ class DownloadComponent:
 
         stream = anime.get_video(ep, lang, preferred_quality=self.options.quality)
 
-        spinner.write(
-            f"> Downloading Episode {stream.episode} of {anime.name} ({lang})"
+        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...")
 
-        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)
-        )
+        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(

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

@@ -82,7 +82,10 @@ class MyAnimeListProxy:
         config = Config()
         for e in mylist:
             if self.local_list.mappings.get(e.id, None):
-                if e.my_list_status and config.mal_ignore_tag in e.my_list_status.tags:
+                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
@@ -112,7 +115,10 @@ class MyAnimeListProxy:
             status_catagories
             if status_catagories is not None
             else set(
-                [MALMyListStatusEnum[s.upper()] for s in config.mal_status_categories]
+                [
+                    MALMyListStatusEnum[s.upper()]
+                    for s in config.tracker_status_categories
+                ]
             )
         )
 
@@ -120,7 +126,7 @@ class MyAnimeListProxy:
             mylist.extend(
                 filter(
                     lambda e: (
-                        config.mal_ignore_tag not in e.my_list_status.tags
+                        config.tracker_ignore_tag not in e.my_list_status.tags
                         if e.my_list_status
                         else True
                     ),
@@ -145,7 +151,7 @@ class MyAnimeListProxy:
         tags: Set[str] = set(),
     ) -> MALMyListStatus:
         config = Config()
-        tags |= set(config.mal_tags)
+        tags |= set(config.tracker_tags)
         result = self.mal.update_anime_list(
             anime.id, status=status, watched_episodes=episode, tags=list(tags)
         )
@@ -183,9 +189,9 @@ class MyAnimeListProxy:
             adapter = MyAnimeListAdapter(self.mal, p)
             result = adapter.from_myanimelist(
                 anime,
-                config.mal_mapping_min_similarity,
-                config.mal_mapping_use_filters,
-                config.mal_mapping_use_alternatives,
+                config.tracker_mapping_min_similarity,
+                config.tracker_mapping_use_filters,
+                config.tracker_mapping_use_alternatives,
             )
 
             if result is not None:
@@ -212,8 +218,8 @@ class MyAnimeListProxy:
         adapter = MyAnimeListAdapter(self.mal, anime.provider)
         result = adapter.from_provider(
             anime,
-            config.mal_mapping_min_similarity,
-            config.mal_mapping_use_alternatives,
+            config.tracker_mapping_min_similarity,
+            config.tracker_mapping_use_alternatives,
         )
 
         if result:

anipy_cli/menus/__init__.py

@@ -1,5 +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", "SeasonalMenu"]
+__all__ = ["Menu", "MALMenu", "AniListMenu", "SeasonalMenu"]