anipy-cli 2.7.31__py3-none-any.whl → 3.0.0.dev0__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.0.0.dev0"

anipy_cli/arg_parser.py

@@ -1,8 +1,9 @@
 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)
@@ -15,17 +16,18 @@ class CliArgs:
     delete: bool
     quality: Optional[Union[str, int]]
     ffmpeg: bool
-    no_season_search: bool
     auto_update: bool
+    mal_sync_seasonals: bool
     optional_player: Optional[str]
+    search: Optional[str]
     location: Optional[Path]
     mal_password: Optional[str]
     config: 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,
     )
 
@@ -96,12 +98,22 @@ def parse_args() -> CliArgs:
         help="Delete your History.",
     )
 
+    options_group.add_argument(
+        "-s",
+        "--search",
+        required=False,
+        dest="search",
+        action="store",
+        help="Provide a search term to the 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'",
+    )
+
     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 +126,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", "syncplay", "mpvnet", "mpv-controlled"],
         help="Override the player set in the config.",
     )
 
@@ -160,6 +162,14 @@ def parse_args() -> CliArgs:
         help="Provide password for MAL login (overrides password 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`)",
+    )
+
     info_group.add_argument(
         "-h", "--help", action="help", help="show this help message and exit"
     )
@@ -174,4 +184,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,66 @@
+from typing import Optional
+
+from pypresence.exceptions import DiscordNotFound
+
+from anipy_cli.arg_parser import parse_args
+from anipy_cli.clis import *
+from anipy_cli.colors import colors, cprint
+from anipy_cli.util import error, DotSpinner
+from anipy_cli.config import Config
+from anipy_cli.discord import DiscordPresence
+
+
+def run_cli(override_args: Optional[list[str]] = None):
+    args = parse_args(override_args)
+    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
+
+    clis_dict = {
+        args.download: DownloadCli,
+        args.binge: BingeCli,
+        args.seasonal: SeasonalCli,
+        args.history: HistoryCli,
+        args.mal: MalCli,
+    }
+
+    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,15 @@
+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
+
+__all__ = [
+    "DefaultCli",
+    "HistoryCli",
+    "MalCli",
+    "SeasonalCli",
+    "BingeCli",
+    "DownloadCli",
+]

anipy_cli/clis/base_cli.py

@@ -0,0 +1,32 @@
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+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): ...
+
+    @abstractmethod
+    def take_input(self): ...
+
+    @abstractmethod
+    def process(self): ...
+
+    @abstractmethod
+    def show(self): ...
+
+    @abstractmethod
+    def post(self): ...
+
+    def run(self):
+        self.print_header()
+        self.take_input()
+        self.process()
+        self.show()
+        self.post()

anipy_cli/clis/binge_cli.py

@@ -0,0 +1,83 @@
+import sys
+from typing import TYPE_CHECKING
+
+from anipy_api.locallist import LocalList
+
+from anipy_cli.clis.base_cli import CliBase
+from anipy_cli.colors import colors, cprint
+from anipy_cli.config import Config
+from anipy_cli.prompts import (
+    pick_episode_range_prompt,
+    search_show_prompt,
+    lang_prompt,
+    parse_auto_search,
+)
+from anipy_cli.util import DotSpinner, get_configured_player, migrate_locallist
+
+if TYPE_CHECKING:
+    from anipy_cli.arg_parser import CliArgs
+
+
+class BingeCli(CliBase):
+    def __init__(self, options: "CliArgs"):
+        super().__init__(options)
+
+        self.player = get_configured_player(self.options.optional_player)
+        self.history_list = LocalList(
+            Config()._history_file_path, migrate_cb=migrate_locallist
+        )
+
+        self.anime = None
+        self.episodes = None
+        self.lang = None
+
+    def print_header(self):
+        cprint(colors.GREEN, "***Binge Mode***")
+
+    def take_input(self):
+        if self.options.search is not None:
+            self.anime, self.lang, self.episodes = parse_auto_search(
+                "binge", self.options.search
+            )
+            return
+
+        anime = search_show_prompt("binge")
+
+        if anime is None:
+            sys.exit(0)
+
+        self.lang = lang_prompt(anime)
+
+        episodes = pick_episode_range_prompt(anime, self.lang)
+
+        self.anime = anime
+        self.episodes = episodes
+
+    def process(self): ...
+
+    def show(self):
+        assert self.episodes is not None
+        assert self.anime is not None
+        assert self.lang is not None
+
+        for e in self.episodes:
+            with DotSpinner(
+                "Extracting streams for ",
+                colors.BLUE,
+                f"{self.anime.name} ({self.lang})",
+                colors.END,
+                " Episode ",
+                e,
+                "...",
+            ) as s:
+                stream = self.anime.get_video(
+                    e, self.lang, preferred_quality=self.options.quality
+                )
+                s.ok("✔")
+
+            self.history_list.update(self.anime, episode=e, language=self.lang)
+            self.player.play_title(self.anime, stream)
+            self.player.wait()
+
+    def post(self):
+        self.player.kill_player()

anipy_cli/clis/default_cli.py

@@ -0,0 +1,104 @@
+import sys
+from typing import TYPE_CHECKING, Optional
+
+from anipy_api.locallist import LocalList
+
+from anipy_cli.clis.base_cli import CliBase
+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,
+)
+from anipy_cli.util import (
+    DotSpinner,
+    get_configured_player,
+    migrate_locallist,
+)
+
+if TYPE_CHECKING:
+    from anipy_api.anime import Anime
+    from anipy_api.provider import Episode, ProviderStream, LanguageTypeEnum
+    from anipy_cli.arg_parser import CliArgs
+
+
+# TODO: Add Resume feature
+class DefaultCli(CliBase):
+    def __init__(self, options: "CliArgs"):
+        super().__init__(options)
+
+        self.player = get_configured_player(self.options.optional_player)
+        self.history_list = LocalList(
+            Config()._history_file_path, migrate_cb=migrate_locallist
+        )
+
+        self.anime: Optional["Anime"] = None
+        self.epsiode: Optional["Episode"] = None
+        self.stream: Optional["ProviderStream"] = None
+        self.lang: Optional["LanguageTypeEnum"] = None
+
+    def print_header(self):
+        pass
+
+    def take_input(self):
+        if self.options.search is not None:
+            self.anime, self.lang, episodes = parse_auto_search(
+                "default", self.options.search
+            )
+            self.epsiode = episodes[0]
+            return
+
+        anime = search_show_prompt("default")
+
+        if anime is None:
+            sys.exit(0)
+
+        self.lang = lang_prompt(anime)
+
+        episode = pick_episode_prompt(anime, self.lang)
+
+        if episode is None:
+            sys.exit(0)
+
+        self.anime = anime
+        self.epsiode = episode
+
+    def process(self):
+        assert self.anime is not None
+        assert self.epsiode is not None
+        assert self.lang is not None
+
+        with DotSpinner(
+            "Extracting streams for ",
+            colors.BLUE,
+            f"{self.anime.name} ({self.lang})",
+            " Episode ",
+            self.epsiode,
+            "...",
+        ):
+            self.stream = self.anime.get_video(
+                self.epsiode, self.lang, preferred_quality=self.options.quality
+            )
+
+    def show(self):
+        assert self.anime is not None
+        assert self.stream is not None
+
+        self.history_list.update(
+            self.anime, episode=self.epsiode, language=self.stream.language
+        )
+        self.player.play_title(self.anime, self.stream)
+
+    def post(self):
+        assert self.anime is not None
+        assert self.stream is not None
+
+        Menu(
+            options=self.options,
+            anime=self.anime,
+            stream=self.stream,
+            player=self.player,
+        ).run()

anipy_cli/clis/download_cli.py

@@ -0,0 +1,111 @@
+import sys
+from typing import TYPE_CHECKING, Optional, List
+
+from anipy_api.download import Downloader
+
+from anipy_cli.clis.base_cli import CliBase
+from anipy_cli.colors import colors, cprint
+from anipy_cli.config import Config
+from anipy_cli.prompts import (
+    pick_episode_range_prompt,
+    search_show_prompt,
+    lang_prompt,
+    parse_auto_search,
+)
+from anipy_cli.util import (
+    DotSpinner,
+    get_download_path,
+)
+
+if TYPE_CHECKING:
+    from anipy_api.anime import Anime
+    from anipy_api.provider import Episode, LanguageTypeEnum
+
+    from anipy_cli.arg_parser import CliArgs
+
+
+class DownloadCli(CliBase):
+    def __init__(self, options: "CliArgs"):
+        super().__init__(options)
+
+        self.anime: Optional["Anime"] = None
+        self.episodes: Optional[List["Episode"]] = None
+        self.lang: Optional["LanguageTypeEnum"] = None
+
+        self.dl_path = Config().download_folder_path
+        if options.location:
+            self.dl_path = options.location
+
+    def print_header(self):
+        cprint(colors.GREEN, "***Download Mode***")
+        cprint(colors.GREEN, "Downloads are stored in: ", colors.END, str(self.dl_path))
+
+    def take_input(self):
+        if self.options.search is not None:
+            self.anime, self.lang, self.episodes = parse_auto_search(
+                "download", self.options.search
+            )
+            return
+
+        anime = search_show_prompt("download")
+
+        if anime is None:
+            sys.exit(0)
+
+        self.lang = lang_prompt(anime)
+
+        episodes = pick_episode_range_prompt(anime, self.lang)
+
+        self.anime = anime
+        self.episodes = episodes
+
+    def process(self):
+        assert self.episodes is not None
+        assert self.anime is not None
+        assert self.lang is not None
+
+        config = Config()
+        with DotSpinner("Starting Download...") as s:
+
+            def progress_indicator(percentage: float):
+                s.set_text(f"Progress: {percentage:.1f}%")
+
+            def info_display(message: str):
+                s.write(f"> {message}")
+
+            downloader = Downloader(progress_indicator, info_display)
+
+            for e in self.episodes:
+                s.set_text(
+                    "Extracting streams for ",
+                    colors.BLUE,
+                    f"{self.anime.name} ({self.lang})",
+                    colors.END,
+                    " Episode ",
+                    e,
+                    "...",
+                )
+
+                stream = self.anime.get_video(
+                    e, self.lang, preferred_quality=self.options.quality
+                )
+
+                info_display(
+                    f"Downloading Episode {stream.episode} of {self.anime.name} ({self.lang})"
+                )
+                s.set_text("Downloading...")
+
+                downloader.download(
+                    stream,
+                    get_download_path(
+                        self.anime, stream, parent_directory=self.dl_path
+                    ),
+                    container=config.remux_to,
+                    ffmpeg=self.options.ffmpeg or config.ffmpeg_hls,
+                )
+
+    def show(self):
+        pass
+
+    def post(self):
+        pass

anipy_cli/clis/history_cli.py

@@ -0,0 +1,93 @@
+import sys
+from typing import TYPE_CHECKING, Optional
+
+from anipy_api.anime import Anime
+from anipy_api.locallist import LocalList, LocalListEntry
+from InquirerPy import inquirer
+
+from anipy_cli.clis.base_cli import CliBase
+from anipy_cli.colors import colors
+from anipy_cli.config import Config
+from anipy_cli.menus import Menu
+from anipy_cli.util import DotSpinner, get_configured_player, migrate_locallist
+
+if TYPE_CHECKING:
+    from anipy_api.provider import ProviderStream
+
+    from anipy_cli.arg_parser import CliArgs
+
+
+class HistoryCli(CliBase):
+    def __init__(self, options: "CliArgs"):
+        super().__init__(options)
+
+        self.player = get_configured_player(self.options.optional_player)
+        self.history_list = LocalList(
+            Config()._history_file_path, migrate_cb=migrate_locallist
+        )
+
+        self.anime: Optional[Anime] = None
+        self.history_entry: Optional["LocalListEntry"] = None
+        self.stream: Optional["ProviderStream"] = None
+
+    def print_header(self):
+        pass
+
+    def take_input(self):
+        history = self.history_list.get_all()
+        history.sort(key=lambda h: h.timestamp, reverse=True)
+
+        if not history:
+            print("You have no History, exiting")
+            sys.exit(0)
+
+        entry = inquirer.select(  # type: ignore
+            message="Select History Entry:",
+            choices=history,
+            long_instruction="To cancel this prompt press ctrl+z",
+            mandatory=False,
+        ).execute()
+
+        if entry is None:
+            sys.exit(0)
+
+        self.history_entry = entry
+        self.anime = Anime.from_local_list_entry(entry)
+
+    def process(self):
+        assert self.anime is not None
+        assert self.history_entry is not None
+
+        with DotSpinner(
+            "Extracting streams for ",
+            colors.BLUE,
+            self.history_entry,
+            "...",
+        ):
+            self.stream = self.anime.get_video(
+                self.history_entry.episode,
+                self.history_entry.language,
+                preferred_quality=self.options.quality,
+            )
+
+    def show(self):
+        assert self.anime is not None
+        assert self.stream is not None
+
+        self.player.play_title(self.anime, self.stream)
+        self.history_list.update(
+            self.anime,
+            episode=self.stream.episode,
+            language=self.stream.language,
+        )
+
+    def post(self):
+        assert self.anime is not None
+        assert self.stream is not None
+
+        Menu(
+            options=self.options,
+            anime=self.anime,
+            stream=self.stream,
+            player=self.player,
+        ).run()