anipy-cli 3.5.9__py3-none-any.whl → 3.7.0__py3-none-any.whl

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
@@ -54,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)
 
@@ -93,7 +96,12 @@ class DownloadComponent:
         for ep in eps:
             try:
                 self.download_ep(spinner, downloader, anime, lang, ep, sub_only)
-            except Exception as e:
+            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:
@@ -101,7 +109,7 @@ class DownloadComponent:
                 spinner.write(
                     color(
                         colors.RED,
-                        f"! Error: {e}\n",
+                        f"! Error: {anime_download_error}\n",
                         error_msg,
                     )
                 )
@@ -136,9 +144,11 @@ class DownloadComponent:
 
         stream = anime.get_video(ep, lang, preferred_quality=self.options.quality)
 
-        spinner.write(
-            f"> Downloading Episode {stream.episode} of {anime.name} ({lang})"
+        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...")
 

anipy_cli/logger.py

@@ -0,0 +1,199 @@
+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,7 @@ 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 +112,7 @@ 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 +120,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 +145,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 +183,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 +212,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"]