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

anipy_cli/__init__.py

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

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/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/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/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/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)

anipy_cli/config.py

@@ -12,8 +12,6 @@ from anipy_cli import __appname__, __version__
 
 
 class Config:
-    _EXPAND_PATHS = True
-
     def __init__(self):
         self._config_file, self._yaml_conf = Config._read_config()
 
@@ -44,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.
@@ -68,8 +70,8 @@ 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
@@ -83,6 +85,7 @@ class Config:
                 seasonal: ["provider3"]
                 binge: ["provider4"]
                 mal: ["provider2", "provider3"]
+                anilist: ["provider1"]
         """
         defaults = {
             "default": ["allanime"],
@@ -90,6 +93,7 @@ class Config:
             "seasonal": ["allanime"],
             "binge": ["allanime"],
             "mal": ["allanime"],
+            "anilist": ["allanime"],
         }
 
         value = self._get_value("providers", defaults, dict)
@@ -229,9 +233,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.
 
@@ -256,6 +260,7 @@ class Config:
             "download": [],
             "seasonal": [],
             "mal": [],
+            "anilist": [],
             "timeout": None,
         }
 
@@ -281,6 +286,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.
@@ -291,55 +301,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.
 
@@ -349,24 +359,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:
@@ -412,14 +422,11 @@ class Config:
             # os.path.expanduser is equivalent to Path().expanduser()
             # But because pathlib doesn't have expandvars(), we resort
             # to using the os module inside the Path constructor
-            if self._EXPAND_PATHS:
-                return Path(os.path.expandvars(path)).expanduser()
-
-            return Path(path)
+            return Path(os.path.expandvars(path)).expanduser()
         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
@@ -429,8 +436,6 @@ class Config:
     def _create_config(self):
         self._get_config_path().mkdir(exist_ok=True, parents=True)
         self._config_file.touch()
-        
-        self._EXPAND_PATHS = False
 
         dump = ""
         # generate config based on attrs and default values of config class
@@ -455,8 +460,7 @@ class Config:
                 + yaml.dump({attribute: val}, indent=4, default_flow_style=False)
                 + "\n"
             )
-        
-        self._EXPAND_PATHS = True
+
         self._config_file.write_text(dump)
 
     @staticmethod