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

anipy_cli/__init__.py

@@ -1,20 +1,2 @@
-"""
- █████  ███    ██ ██ ██████  ██    ██       ██████ ██      ██ 
-██   ██ ████   ██ ██ ██   ██  ██  ██       ██      ██      ██ 
-███████ ██ ██  ██ ██ ██████    ████  █████ ██      ██      ██ 
-██   ██ ██  ██ ██ ██ ██         ██         ██      ██      ██ 
-██   ██ ██   ████ ██ ██         ██          ██████ ███████ ██ 
-
-~ The best tool to watch and Download your favourite anime.
-
-https://github.com/sdaqo/anipy-cli
-
-"""
-from anipy_cli.download import download
-from anipy_cli.url_handler import epHandler, videourl
-from anipy_cli import config
-from anipy_cli.query import query
-from anipy_cli.player import get_player
-from anipy_cli.misc import Entry, get_anime_info
-from anipy_cli.seasonal import Seasonal
-from anipy_cli.history import history
+__appname__ = "anipy-cli"
+__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

@@ -1,31 +1,41 @@
 import argparse
-from pathlib import Path
 from dataclasses import dataclass
-from typing import Union, Optional
-from anipy_cli.version import __version__
+from pathlib import Path
+from typing import Optional, Union
 
+from anipy_cli import __version__
 
-@dataclass(frozen=True)
+
+@dataclass()
 class CliArgs:
     download: bool
     binge: bool
     history: bool
     seasonal: bool
     mal: bool
+    anilist: bool
     delete: bool
+    migrate_hist: bool
     quality: Optional[Union[str, int]]
     ffmpeg: bool
-    no_season_search: 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() -> CliArgs:
+def parse_args(override_args: Optional[list[str]] = None) -> CliArgs:
     parser = argparse.ArgumentParser(
-        description="Play Animes from gogoanime in local video-player or Download them.",
+        description="Play Animes from online anime providers locally or download them, and much more.",
         add_help=False,
     )
 
@@ -88,6 +98,15 @@ def parse_args() -> 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,
@@ -96,12 +115,41 @@ def parse_args() -> CliArgs:
         help="Delete your History.",
     )
 
+    actions_group.add_argument(
+        "--migrate-history",
+        required=False,
+        dest="migrate_hist",
+        action="store_true",
+        help="Migrate your history to the current provider.",
+    )
+
+    options_group.add_argument(
+        "-s",
+        "--search",
+        required=False,
+        dest="search",
+        action="store",
+        help="Provide a search term to Default, Download or Binge mode in this format: {query}:{episode range}:{dub/sub}. Examples: 'frieren:1-10:sub' or 'frieren:1:sub' or 'frieren:1-3 7-12:dub', this argument may be appended to any of the modes mentioned like so: 'anipy-cli (-D/B) -s <search>'",
+    )
+
+    options_group.add_argument(
+        "-ss",
+        "--seasonal-search",
+        required=False,
+        dest="seasonal_search",
+        nargs="?",  # 1 or none possible args
+        default=None,  # Used if flag is not present (added this line for clarity, because default is always None)
+        const=True,  # Used if flag is present, but no value
+        help="Provide search parameters for seasons to Default, Download, or Binge mode in this format: {year}:{season}. You can only use part of the season name if you wish. Examples: '2024:win' or '2020:fa'",
+    )
+
     options_group.add_argument(
         "-q",
         "--quality",
         action="store",
         required=False,
-        default="auto",
+        default="best",
+        type=lambda v: int(v) if v.isdigit() else v,
         help="Change the quality of the video, accepts: best, worst or 360, 480, 720 etc.  Default: best",
     )
 
@@ -114,30 +162,20 @@ def parse_args() -> CliArgs:
         help="Use ffmpeg to download m3u8 playlists, may be more stable but is way slower than internal downloader",
     )
 
-    options_group.add_argument(
-        "-o",
-        "--no-seas-search",
-        required=False,
-        dest="no_season_search",
-        action="store_true",
-        help="Turn off search in season. "
-        "Disables prompting if GoGoAnime is to be searched for anime in specific season.",
-    )
-
     options_group.add_argument(
         "-a",
         "--auto-update",
         required=False,
         dest="auto_update",
         action="store_true",
-        help="Automatically update and download all Anime in seasonals list from start EP to newest.",
+        help="Automatically update and download all Anime in seasonals or mal mode from start EP to newest.",
     )
 
     options_group.add_argument(
         "-p",
         "--optional-player",
         required=False,
-        choices=["mpv", "vlc", "syncplay", "mpvnet"],
+        choices=["mpv", "vlc", "iina", "syncplay", "mpvnet", "mpv-controlled"],
         help="Override the player set in the config.",
     )
 
@@ -152,6 +190,33 @@ def parse_args() -> 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,
@@ -159,6 +224,29 @@ def parse_args() -> 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",
+        required=False,
+        dest="mal_sync_seasonals",
+        action="store_true",
+        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"
@@ -174,4 +262,4 @@ def parse_args() -> CliArgs:
         help="Print path to the config file.",
     )
 
-    return CliArgs(**vars(parser.parse_args()))
+    return CliArgs(**vars(parser.parse_args(args=override_args)))

anipy_cli/cli.py

@@ -0,0 +1,98 @@
+from pathlib import Path
+from types import TracebackType
+from typing import Optional
+
+from pypresence.exceptions import DiscordNotFound
+
+from anipy_api.locallist import LocalList
+from anipy_cli.prompts import migrate_provider
+
+from anipy_cli.arg_parser import CliArgs, parse_args
+from anipy_cli.clis import *
+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()
+
+    if config.dc_presence:
+        with DotSpinner("Intializing Discord Presence...") as s:
+            try:
+                DiscordPresence()
+                s.set_text(colors.GREEN, "Initialized Discord Presence")
+                s.ok("✔")
+            except DiscordNotFound:
+                s.set_text(
+                    colors.RED,
+                    "Discord is not opened, can't initialize Discord Presence",
+                )
+                s.fail("✘")
+            except ConnectionError:
+                s.set_text(
+                    colors.RED,
+                    "Can't Connect to discord, can't initialize Discord Presence",
+                )
+                s.fail("✘")
+
+    if args.config:
+        print(config._config_file)
+        return
+    elif args.delete:
+        try:
+            config._history_file_path.unlink()
+            cprint(colors.RED, "Done")
+        except FileNotFoundError:
+            error("no history file found")
+        return
+    elif args.migrate_hist:
+        history_list = LocalList(
+            Config()._history_file_path, migrate_cb=migrate_locallist
+        )
+        migrate_provider("default", history_list)
+        return
+
+    clis_dict = {
+        args.download: DownloadCli,
+        args.binge: BingeCli,
+        args.seasonal: SeasonalCli,
+        args.history: HistoryCli,
+        args.mal: MalCli,
+        args.anilist: AniListCli,
+    }
+
+    cli_class = clis_dict.get(True, DefaultCli)
+
+    try:
+        cli_class(options=args).run()
+    except KeyboardInterrupt:
+        error("interrupted", fatal=True)
+
+
+if __name__ == "__main__":
+    run_cli()

anipy_cli/clis/__init__.py

@@ -0,0 +1,17 @@
+from anipy_cli.clis.default_cli import DefaultCli
+from anipy_cli.clis.history_cli import HistoryCli
+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

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from anipy_cli.arg_parser import CliArgs
+
+
+class CliBase(ABC):
+    def __init__(self, options: "CliArgs"):
+        self.options = options
+
+    @abstractmethod
+    def print_header(self) -> Optional[bool]: ...
+
+    @abstractmethod
+    def take_input(self) -> Optional[bool]: ...
+
+    @abstractmethod
+    def process(self) -> Optional[bool]: ...
+
+    @abstractmethod
+    def show(self) -> Optional[bool]: ...
+
+    @abstractmethod
+    def post(self) -> Optional[bool]: ...
+
+    def run(self):
+        funcs = ["print_header", "take_input", "process", "show", "post"]
+        for f in funcs:
+            func = getattr(self, f)
+            ret = func()
+
+            if ret is False:
+                break