anipy-cli 3.5.9__tar.gz → 3.7.0__tar.gz

{anipy_cli-3.5.9 → anipy_cli-3.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: anipy-cli
-Version: 3.5.9
+Version: 3.7.0
 Summary: Watch and Download anime from the comfort of your Terminal
 License: GPL-3.0
 Keywords: anime,cli
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: anipy-api (>=3.5.9,<4.0.0)
+Requires-Dist: anipy-api (>=3.7.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.5.9 → anipy_cli-3.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "anipy-cli"
-version = "3.5.9"
+version = "3.7.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.5.9"
+anipy-api = "^3.7.0"
 
 [tool.poetry.scripts]
 anipy-cli = "anipy_cli.cli:run_cli"

{anipy_cli-3.5.9 → anipy_cli-3.7.0}/src/anipy_cli/__init__.py

@@ -1,2 +1,2 @@
 __appname__ = "anipy-cli"
-__version__ = "3.5.9"
+__version__ = "3.7.0"

anipy_cli-3.7.0/src/anipy_cli/anilist_proxy.py

@@ -0,0 +1,221 @@
+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-3.5.9 → anipy_cli-3.7.0}/src/anipy_cli/arg_parser.py

@@ -13,15 +13,19 @@ 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_password: Optional[str]
     config: bool
     seasonal_search: Optional[str]
@@ -93,6 +97,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,
@@ -176,6 +189,24 @@ 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",
@@ -201,6 +232,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-3.5.9 → anipy_cli-3.7.0}/src/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,34 @@ 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 +81,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-3.5.9 → anipy_cli-3.7.0}/src/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-3.7.0/src/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-3.5.9 → anipy_cli-3.7.0}/src/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)