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

anipy_cli/__init__.py

@@ -1,2 +1,2 @@
 __appname__ = "anipy-cli"
-__version__ = "3.4.8"
+__version__ = "3.8.2"

anipy_cli/anilist_proxy.py

@@ -0,0 +1,229 @@
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Set
+
+from anipy_api.anime import Anime
+from anipy_api.anilist import (
+    AniListAnime,
+    AniListMyListStatus,
+    AniListMyListStatusEnum,
+    AniList,
+    AniListAdapter,
+)
+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 AniListProviderMapping(DataClassJsonMixin):
+    anilist_anime: AniListAnime
+    mappings: Dict[str, ProviderMapping]
+
+
+@dataclass
+class AniListLocalList(DataClassJsonMixin):
+    mappings: Dict[int, AniListProviderMapping]
+
+    def write(self, user_id: int):
+        config = Config()
+        local_list = config._anilist_local_user_list_path.with_stem(
+            f"{config._anilist_local_user_list_path.stem}_{user_id}"
+        )
+        local_list.write_text(self.to_json())
+
+    @staticmethod
+    def read(user_id: int) -> "AniListLocalList":
+        config = Config()
+        local_list = config._anilist_local_user_list_path.with_stem(
+            f"{config._anilist_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 = AniListLocalList({})
+            mylist.write(user_id)
+            return mylist
+
+        try:
+            mylist: AniListLocalList = AniListLocalList.from_json(
+                local_list.read_text()
+            )
+        except KeyError:
+            choice = inquirer.confirm(
+                message=f"Your local AniList ({str(local_list)}) is not in the correct format, should it be deleted?",
+                default=False,
+            ).execute()
+            if choice:
+                local_list.unlink()
+                return AniListLocalList.read(user_id)
+            else:
+                error("could not read your AniList", fatal=True)
+
+        return mylist
+
+
+class AniListProxy:
+    def __init__(self, anilist: AniList):
+        self.anilist = anilist
+        self.user_id = anilist.get_user().id
+        self.local_list = AniListLocalList.read(self.user_id)
+
+    def _cache_list(self, mylist: List[AniListAnime]):
+        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].anilist_anime = e
+            else:
+                self.local_list.mappings[e.id] = AniListProviderMapping(e, {})
+
+        self.local_list.write(self.user_id)
+
+    def _write_mapping(self, anilist_anime: AniListAnime, mapping: Anime):
+        self._cache_list([anilist_anime])
+
+        self.local_list.mappings[anilist_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[AniListMyListStatusEnum]] = None
+    ) -> List[AniListAnime]:
+        config = Config()
+        mylist: List[AniListAnime] = []
+
+        catagories = (
+            status_catagories
+            if status_catagories is not None
+            else set(
+                [
+                    AniListMyListStatusEnum[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.anilist.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: AniListAnime,
+        status: Optional[AniListMyListStatusEnum] = None,
+        episode: Optional[int] = None,
+        tags: Set[str] = set(),
+    ) -> AniListMyListStatus:
+        config = Config()
+        tags |= set(config.tracker_tags)
+        result = self.anilist.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: AniListAnime) -> None:
+        self.local_list.mappings.pop(anime.id)
+        self.local_list.write(self.user_id)
+
+        self.anilist.remove_from_anime_list(anime.id)
+
+    def map_from_anilist(
+        self, anime: AniListAnime, 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("anilist"):
+            adapter = AniListAdapter(self.anilist, p)
+            result = adapter.from_anilist(
+                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[AniListAnime] = None
+    ) -> Optional[AniListAnime]:
+        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.anilist_anime
+
+        config = Config()
+        adapter = AniListAdapter(self.anilist, 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/arg_parser.py

@@ -13,18 +13,24 @@ class CliArgs:
     history: bool
     seasonal: bool
     mal: bool
+    anilist: bool
     delete: bool
     migrate_hist: bool
     quality: Optional[Union[str, int]]
     ffmpeg: bool
     auto_update: bool
     mal_sync_seasonals: bool
+    anilist_sync_seasonals: bool
     optional_player: Optional[str]
     search: Optional[str]
     location: Optional[Path]
+    verbosity: int
+    stack_always: bool
+    mal_user: Optional[str]
     mal_password: Optional[str]
     config: bool
     seasonal_search: Optional[str]
+    subtitles: bool
 
 
 def parse_args(override_args: Optional[list[str]] = None) -> CliArgs:
@@ -92,6 +98,15 @@ def parse_args(override_args: Optional[list[str]] = None) -> CliArgs:
         "(requires MAL account credentials to be set in config).",
     )
 
+    actions_group.add_argument(
+        "-A",
+        "--anilist",
+        required=False,
+        dest="anilist",
+        action="store_true",
+        help="Anilist mode. Similar to seasonal mode, but using Anilist",
+    )
+
     actions_group.add_argument(
         "--delete-history",
         required=False,
@@ -175,6 +190,33 @@ def parse_args(override_args: Optional[list[str]] = None) -> CliArgs:
         help="Override all configured download locations",
     )
 
+    options_group.add_argument(
+        "-V",
+        "--verbose",
+        required=False,
+        dest="verbosity",
+        action="count",
+        default=0,
+        help="Verbosity levels in the console: -V = 'fatal' -VV = 'warnings' -VVV = 'info'",
+    )
+
+    options_group.add_argument(
+        "--stack-always",
+        required=False,
+        dest="stack_always",
+        action="store_true",
+        help="Always show the stack trace on any log outputs.",
+    )
+
+    options_group.add_argument(
+        "-so",
+        "--sub-only",
+        required=False,
+        dest="subtitles",
+        action="store_true",
+        help="Download only subtitles",
+    )
+
     options_group.add_argument(
         "--mal-password",
         required=False,
@@ -182,6 +224,13 @@ def parse_args(override_args: Optional[list[str]] = None) -> CliArgs:
         action="store",
         help="Provide password for MAL login (overrides password set in config)",
     )
+    options_group.add_argument(
+        "--mal-user",
+        required=False,
+        dest="mal_user",
+        action="store",
+        help="Provide username for MAL login (overrides username set in config)",
+    )
 
     options_group.add_argument(
         "--mal-sync-to-seasonals",
@@ -191,6 +240,14 @@ def parse_args(override_args: Optional[list[str]] = None) -> CliArgs:
         help="Automatically sync myanimelist to seasonals (only works with `-M`)",
     )
 
+    options_group.add_argument(
+        "--anilist-sync-to-seasonals",
+        required=False,
+        dest="anilist_sync_seasonals",
+        action="store_true",
+        help="Automatically sync anilist to seasonals (only works with `-A`)",
+    )
+
     info_group.add_argument(
         "-h", "--help", action="help", help="show this help message and exit"
     )

anipy_cli/cli.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+from types import TracebackType
 from typing import Optional
 
 from pypresence.exceptions import DiscordNotFound
@@ -5,16 +7,36 @@ from pypresence.exceptions import DiscordNotFound
 from anipy_api.locallist import LocalList
 from anipy_cli.prompts import migrate_provider
 
-from anipy_cli.arg_parser import parse_args
+from anipy_cli.arg_parser import CliArgs, parse_args
 from anipy_cli.clis import *
-from anipy_cli.colors import colors, cprint
+from anipy_cli.colors import color, colors, cprint
 from anipy_cli.util import error, DotSpinner, migrate_locallist
 from anipy_cli.config import Config
 from anipy_cli.discord import DiscordPresence
+import anipy_cli.logger as logger
 
 
 def run_cli(override_args: Optional[list[str]] = None):
     args = parse_args(override_args)
+
+    logger.set_cli_verbosity(args.verbosity)
+    logger.set_stack_always(args.stack_always)
+
+    def fatal_handler(
+        exc_val: BaseException, exc_tb: TracebackType, logs_location: Path
+    ):
+        print(
+            color(
+                colors.RED,
+                f'A fatal error of type [{exc_val.__class__.__name__}] has occurred with message "{exc_val.args[0]}". Logs can be found at {logs_location}.',
+            )
+        )
+
+    with logger.safe(fatal_handler):
+        _safe_cli(args)
+
+
+def _safe_cli(args: CliArgs):
     config = Config()
     # This updates the config, adding new values doc changes and the like.
     config._create_config()
@@ -61,6 +83,7 @@ def run_cli(override_args: Optional[list[str]] = None):
         args.seasonal: SeasonalCli,
         args.history: HistoryCli,
         args.mal: MalCli,
+        args.anilist: AniListCli,
     }
 
     cli_class = clis_dict.get(True, DefaultCli)

anipy_cli/clis/__init__.py

@@ -4,11 +4,13 @@ from anipy_cli.clis.mal_cli import MalCli
 from anipy_cli.clis.seasonal_cli import SeasonalCli
 from anipy_cli.clis.binge_cli import BingeCli
 from anipy_cli.clis.download_cli import DownloadCli
+from anipy_cli.clis.anilist_cli import AniListCli
 
 __all__ = [
     "DefaultCli",
     "HistoryCli",
     "MalCli",
+    "AniListCli",
     "SeasonalCli",
     "BingeCli",
     "DownloadCli",

anipy_cli/clis/anilist_cli.py

@@ -0,0 +1,62 @@
+from typing import TYPE_CHECKING
+
+from anipy_api.error import AniListError
+from anipy_api.anilist import AniList
+from InquirerPy import inquirer
+
+from anipy_cli.clis.base_cli import CliBase
+from anipy_cli.config import Config
+from anipy_cli.menus import AniListMenu
+from anipy_cli.util import DotSpinner, error
+import webbrowser
+
+if TYPE_CHECKING:
+    from anipy_cli.arg_parser import CliArgs
+
+
+class AniListCli(CliBase):
+    def __init__(self, options: "CliArgs"):
+        super().__init__(options)
+        self.access_token = ""
+        self.anilist = None
+
+    def print_header(self):
+        pass
+
+    def take_input(self):
+        config = Config()
+        self.access_token = config.anilist_token
+
+        if not self.access_token:
+            webbrowser.open(AniList.AUTH_URL)
+            self.access_token = inquirer.text(  # type: ignore
+                "Paste the token from the browser for Auth",
+                validate=lambda x: len(x) > 1,
+                invalid_message="You must enter a access_token!",
+                long_instruction="Hint: You can save your access token in the config!",
+            ).execute()
+
+    def process(self):
+        try:
+            with DotSpinner("Logging into AniList..."):
+                self.anilist = AniList.from_implicit_grant(self.access_token)
+        except AniListError as e:
+            error(
+                f"{str(e)}\nCannot login to AniList, it is likely your response token is wrong",
+                fatal=True,
+            )
+
+    def show(self):
+        pass
+
+    def post(self):
+        assert self.anilist is not None
+
+        menu = AniListMenu(anilist=self.anilist, options=self.options)
+
+        if self.options.auto_update:
+            menu.download()
+        elif self.options.anilist_sync_seasonals:
+            menu.sync_anilist_seasonls()
+        else:
+            menu.run()

anipy_cli/clis/base_cli.py

@@ -30,5 +30,5 @@ class CliBase(ABC):
             func = getattr(self, f)
             ret = func()
 
-            if ret == False:  # noqa: E712
+            if ret is False:
                 break

anipy_cli/clis/binge_cli.py

@@ -13,7 +13,7 @@ from anipy_cli.prompts import (
     lang_prompt,
     parse_auto_search,
 )
-from anipy_cli.util import DotSpinner, get_configured_player, migrate_locallist
+from anipy_cli.util import DotSpinner, get_configured_player, migrate_locallist, error
 
 if TYPE_CHECKING:
     from anipy_cli.arg_parser import CliArgs
@@ -83,6 +83,9 @@ class BingeCli(CliBase):
                 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)

anipy_cli/clis/default_cli.py

@@ -7,21 +7,18 @@ from anipy_cli.colors import colors
 from anipy_cli.config import Config
 from anipy_cli.menus import Menu
 from anipy_cli.prompts import (
-    pick_episode_prompt,
-    search_show_prompt,
     lang_prompt,
     parse_auto_search,
     parse_seasonal_search,
+    pick_episode_prompt,
+    search_show_prompt,
 )
-from anipy_cli.util import (
-    DotSpinner,
-    get_configured_player,
-    migrate_locallist,
-)
+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, ProviderStream, LanguageTypeEnum
+    from anipy_api.provider import Episode, LanguageTypeEnum, ProviderStream
+
     from anipy_cli.arg_parser import CliArgs
 
 
@@ -91,6 +88,11 @@ class DefaultCli(CliBase):
             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

anipy_cli/clis/download_cli.py

@@ -69,8 +69,12 @@ class DownloadCli(CliBase):
         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
+        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)
 

anipy_cli/clis/mal_cli.py

@@ -25,7 +25,7 @@ class MalCli(CliBase):
 
     def take_input(self):
         config = Config()
-        self.user = config.mal_user
+        self.user = self.options.mal_user or config.mal_user
         self.password = self.options.mal_password or config.mal_password
 
         if not self.user:

anipy_cli/colors.py

@@ -1,4 +1,7 @@
-class colors:
+from typing import Any
+
+
+class colors:  # noqa: N801
     """Just a class for colors."""
 
     GREEN = "\033[92m"
@@ -14,7 +17,7 @@ class colors:
     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"
@@ -24,13 +27,13 @@ def color(*values, sep: str = "") -> str:
     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)