anime-sama-cli 2.0.0__py3-none-any.whl

anime_sama_api/__init__.py

@@ -0,0 +1,49 @@
+from .catalogue import Catalogue
+from .episode import Episode, Languages, Players
+from .langs import Lang, LangId, flags, id2lang, lang2ids
+from .season import Season
+from .top_level import AnimeSama, find_site_url, PlanningDay, PlanningEntry
+
+try:
+    from .cli.__main__ import main
+    from .cli.downloader import download, multi_download
+except ImportError:
+    import sys
+
+    def main() -> int:
+        print(
+            "This anime-sama_api function could not run because the required "
+            "dependencies were not installed.\nMake sure you've installed "
+            "everything with: pip install 'anime-sama_api[cli]'"
+        )
+
+        sys.exit(1)
+
+    download = multi_download = main  # type: ignore
+
+
+# __package__ = "anime-sama_api"
+__all__ = [
+    "AnimeSama",
+    "Catalogue",
+    "PlanningDay",
+    "PlanningEntry",
+    "Season",
+    "Players",
+    "Languages",
+    "Episode",
+    "Lang",
+    "LangId",
+    "lang2ids",
+    "id2lang",
+    "flags",
+    "download",
+    "multi_download",
+    "main",
+    "find_site_url",
+]
+
+"""__locals = locals()
+for __name in __all__:
+    if not __name.startswith("__"):
+        setattr(__locals[__name], "__module__", "anime-sama_api")  # noqa"""

anime_sama_api/assets/ascii_art

@@ -0,0 +1,6 @@
+ █████╗ ███╗   ██╗██╗███╗   ███╗███████╗    ███████╗ █████╗ ███╗   ███╗ █████╗ 
+██╔══██╗████╗  ██║██║████╗ ████║██╔════╝    ██╔════╝██╔══██╗████╗ ████║██╔══██╗
+███████║██╔██╗ ██║██║██╔████╔██║█████╗█████╗███████╗███████║██╔████╔██║███████║
+██╔══██║██║╚██╗██║██║██║╚██╔╝██║██╔══╝╚════╝╚════██║██╔══██║██║╚██╔╝██║██╔══██║
+██║  ██║██║ ╚████║██║██║ ╚═╝ ██║███████╗    ███████║██║  ██║██║ ╚═╝ ██║██║  ██║
+╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝╚═╝     ╚═╝╚══════╝    ╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝╚═╝  ╚═╝

anime_sama_api/catalogue.py

@@ -0,0 +1,157 @@
+import re
+from collections.abc import Sequence
+from typing import Any, Literal, cast
+
+from httpx import AsyncClient
+
+from .langs import Lang, flags
+from .season import Season
+from .utils import remove_some_js_comments
+
+# Oversight from anime-sama that we should handle
+# 'Animes' instead of 'Anime' seen in Cyberpunk: Edgerunners and Valkyrie Apocalypse
+# 'Autre' instead of 'Autres' seen in Hazbin Hotel
+# 'Scans' is in the language section for Watamote (harder to handle)
+Category = Literal["Anime", "Scans", "Film", "Autres"]
+
+
+class Catalogue:
+    def __init__(
+        self,
+        url: str,
+        name: str = "",
+        alternative_names: Sequence[str] | None = None,
+        genres: Sequence[str] | None = None,
+        categories: set[Category] | None = None,
+        languages: set[Lang] | None = None,
+        image_url: str = "",
+        client: AsyncClient | None = None,
+    ) -> None:
+        if alternative_names is None:
+            alternative_names = []
+        if genres is None:
+            genres = []
+        if categories is None:
+            categories = set()
+        if languages is None:
+            languages = set()
+
+        self.url = url + "/" if url[-1] != "/" else url
+        self.site_url = "/".join(url.split("/")[:3]) + "/"
+        self.client = client or AsyncClient()
+
+        self.name = name or url.split("/")[-2]
+
+        self._page: str | None = None
+        self.alternative_names = alternative_names
+        self.genres = genres
+        self.categories = categories
+        self.languages = languages
+        self.image_url = image_url
+
+    async def page(self) -> str:
+        if self._page is not None:
+            return self._page
+
+        response = await self.client.get(self.url)
+
+        if response.is_error:
+            self._page = ""
+        else:
+            self._page = response.text
+
+        return self._page
+
+    async def seasons(self) -> list[Season]:
+        page_without_comments = remove_some_js_comments(string=await self.page())
+
+        # Insensible à la casse pour VOSTFR/Vf (ex. Berserk, pages avec VOSTFR en majuscules)
+        seasons = re.findall(
+            r'panneauAnime\("(.+?)", *"(.+?)(?:vostfr|vf)"\);',
+            page_without_comments,
+            re.IGNORECASE,
+        )
+
+        seasons = [
+            Season(
+                url=self.url + link,
+                name=name,
+                serie_name=self.name,
+                client=self.client,
+            )
+            for name, link in seasons
+        ]
+
+        return seasons
+
+    async def advancement(self) -> str:
+        search = cast(list[str], re.findall(r"Actualité.+?>(.+?)<", await self.page()))
+
+        if not search:
+            return ""
+
+        return search[0]
+
+    async def correspondence(self) -> str:
+        search = cast(
+            list[str], re.findall(r"Correspondance.+?>(.+?)<", await self.page())
+        )
+
+        if not search:
+            return ""
+
+        return search[0]
+
+    async def synopsis(self) -> str:
+        search = cast(
+            list[str], re.findall(r"Synopsis[\W\w]+?>(.+)<", await self.page())
+        )
+
+        if not search:
+            return ""
+
+        return search[0]
+
+    async def is_mature(self) -> bool:
+        """Return True if the catalogue contain a warning about adult content"""
+        return (
+            re.search(
+                r'<div class=".*?yellow.*?">[\W\w]+?public averti', await self.page()
+            )
+            is not None
+        )
+
+    @property
+    def is_anime(self) -> bool:
+        return "Anime" in self.categories
+
+    @property
+    def is_manga(self) -> bool:
+        return "Scans" in self.categories
+
+    @property
+    def is_film(self) -> bool:
+        return "Film" in self.categories
+
+    @property
+    def is_other(self) -> bool:
+        return "Autres" in self.categories
+
+    @property
+    def fancy_name(self) -> str:
+        names = [""] + list(self.alternative_names) if self.alternative_names else []
+        return f"{self.name}[bright_black]{' - '.join(names)} {' '.join(flags[lang] for lang in self.languages if lang != 'VOSTFR')}"
+
+    def __repr__(self) -> str:
+        return f"Catalogue({self.url!r}, {self.name!r})"
+
+    def __str__(self) -> str:
+        return self.fancy_name
+
+    def __eq__(self, value: Any) -> bool:
+        if not isinstance(value, Catalogue):
+            return False
+        return self.url == value.url
+
+    def __hash__(self) -> int:
+        return hash(self.url + self.name + "".join(self.alternative_names))

anime_sama_api/cli/__main__.py

@@ -0,0 +1,96 @@
+import asyncio
+import logging
+from urllib.error import URLError
+
+from httpx import AsyncClient
+from rich import get_console
+from rich.logging import RichHandler
+from rich.status import Status
+
+from anime_sama_api.cli import downloader, internal_player
+from anime_sama_api.cli.config import config
+from anime_sama_api.cli.episode_extra_info import convert_with_extra_info
+from anime_sama_api.cli.episode_tree import run_episode_tree
+from anime_sama_api.cli.utils import safe_input, select_one, select_range
+from anime_sama_api.top_level import AnimeSama, find_site_url
+
+console = get_console()
+console._highlight = False
+logging.basicConfig(format="%(message)s", datefmt="[%X]", handlers=[RichHandler()])
+
+
+def spinner(text: str) -> Status:
+    return console.status(text, spinner_style="cyan")
+
+
+async def async_main() -> None:
+    query = safe_input("Anime name: \033[0;34m", str)
+
+    client = AsyncClient()
+    url = config.url or await find_site_url(client, config.provider_url)
+
+    if url is None:
+        raise URLError("Failed to get AnimeSama url")
+
+    with spinner(f"Searching for [blue]{query}"):
+        catalogues = await AnimeSama(url, client).search(query)
+    catalogue = select_one(catalogues)
+
+    with spinner(f"Getting season list for [blue]{catalogue.name}"):
+        seasons_list = await catalogue.seasons()
+
+    selected_seasons = select_range(seasons_list, msg="Choose season(s)")
+
+    if len(selected_seasons) > 1:
+        # Multi-season automatic download
+        selected_episodes = []
+        for s in selected_seasons:
+            with spinner(f"Getting episode list for [blue]{s.name}"):
+                episodes = await s.episodes()
+                selected_episodes.extend(episodes)
+    else:
+        # Single season: affichage des épisodes en Tree (Textual)
+        season = selected_seasons[0]
+        with spinner(f"Getting episode list for [blue]{season.name}"):
+            episodes = await season.episodes()
+
+        # Tree : Espace = sélection (parent = tout, enfants = épisodes), Tab = déplier/replier, Entrée = valider
+        selected_episodes = run_episode_tree(season, episodes)
+        if not selected_episodes:
+            console.print("\n[red]Aucun épisode sélectionné.")
+            return
+
+    if config.download:
+        downloader.multi_download(
+            [
+                convert_with_extra_info(episode, catalogue)
+                for episode in selected_episodes
+            ],
+            config.download_path,
+            config.episode_path,
+            config.concurrent_downloads,
+            config.prefer_languages,
+            config.players_config,
+            config.max_retry_time,
+            config.format,
+            config.format_sort,
+        )
+    else:
+        command = internal_player.play_episode(
+            selected_episodes[0], config.prefer_languages
+        )
+        if command is not None:
+            command.wait()
+
+
+def main() -> int:
+    try:
+        asyncio.run(async_main())
+    except (KeyboardInterrupt, asyncio.exceptions.CancelledError, EOFError):
+        console.print("\n[red]Exiting...")
+
+    return 0
+
+
+if __name__ == "__main__":
+    main()

anime_sama_api/cli/config.py

@@ -0,0 +1,119 @@
+# TODO: Allway hard to read but I can't find a better way to do it
+import logging
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+# import platformdirs for config_dir and download_dir
+from platformdirs import user_config_dir, user_downloads_dir
+
+from anime_sama_api.langs import Lang, lang2ids
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class PlayersConfig:
+    prefers: list[str] = field(default_factory=list)
+    bans: list[str] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class Config:
+    prefer_languages: list[Lang]
+    download_path: Path
+    episode_path: str
+    download: bool
+    show_players: bool
+    max_retry_time: int
+    format: str
+    format_sort: str
+    internal_player_command: list[str]
+    url: str
+    provider_url: str
+    players_config: PlayersConfig
+    concurrent_downloads: dict[str, int]
+
+
+def load_config() -> Config:
+    # 1. Load default config from the package
+    default_config_file = Path(__file__).parent / "config.toml"
+    if not default_config_file.exists():
+        raise FileNotFoundError(
+            f"The default config.toml could not be found at {default_config_file}"
+        )
+
+    with open(default_config_file, "rb") as f:
+        config_dict = tomllib.load(f)
+
+    # 2. Determine user config path
+    # Order of priority:
+    # - current directory (./config.toml)
+    # - system config directory (e.g. ~/AppData/Local/anime-sama_api/config.toml)
+    local_config = Path("config.toml")
+    system_config_dir = Path(user_config_dir("anime-sama_api", appauthor=False))
+    system_config_file = system_config_dir / "config.toml"
+
+    user_config_data = {}
+    if local_config.exists():
+        with open(local_config, "rb") as f:
+            user_config_data = tomllib.load(f)
+    elif system_config_file.exists():
+        with open(system_config_file, "rb") as f:
+            user_config_data = tomllib.load(f)
+    else:
+        # Recreate default config if not found anywhere
+        from shutil import copy
+
+        system_config_dir.mkdir(parents=True, exist_ok=True)
+        copy(default_config_file, system_config_file)
+        logger.info("Default config created at %s", system_config_file)
+
+    # 3. Merge configs (user values override defaults)
+    config_dict.update(user_config_data)
+
+    # 4. Backward compatibility and data cleaning
+    # Languages conversion
+    new_langs: list[Lang] = []
+    for lang in config_dict.get("prefer_languages", []):
+        if lang == "VO":
+            lang = "VOSTFR"
+        if lang in lang2ids:
+            new_langs.append(lang)
+        else:
+            logger.warning("« %s » n'est pas une langue valide, ignorée.", lang)
+    config_dict["prefer_languages"] = new_langs
+
+    # Path detection and expansion
+    raw_path = config_dict.get("download_path")
+    if not raw_path:
+        # Default to system Downloads / Anime-Sama if not specified
+        config_dict["download_path"] = Path(user_downloads_dir()) / "Anime-Sama"
+    else:
+        config_dict["download_path"] = Path(raw_path).expanduser()
+
+    # Internal player command string to list
+    player_cmd = config_dict.get("internal_player_command")
+    if isinstance(player_cmd, str):
+        config_dict["internal_player_command"] = player_cmd.split()
+    elif player_cmd is None:
+        config_dict["internal_player_command"] = []
+
+    # Players config mapping
+    players_data = config_dict.pop("players_hostname", {})
+    if "players" in config_dict:  # Old key removal
+        del config_dict["players"]
+    config_dict["players_config"] = PlayersConfig(**players_data)
+
+    # Ensure all required keys are present for Config dataclass
+    # (Checking against keys in Config.__annotations__ if necessary)
+    return Config(**config_dict)
+
+
+# Exported config instance
+config = load_config()

anime_sama_api/cli/config.toml

@@ -0,0 +1,35 @@
+# Languages at the start of the list are preferred over the ones that come after
+# Possible values: "VASTFR", "VCN", "VF", "VJSTFR", "VKR", "VQC", "VOSTFR"
+prefer_languages = ["VOSTFR"]
+
+# Where to put the downloads
+download_path = "~/Downloads/Anime-Sama"
+# How to organize the downloads (you can use {serie} {season} {episode} {release_year_parentheses})
+episode_path = "{serie}/{season}/{episode}"
+
+# If it downloads or plays the selected episodes
+download = true
+show_players = false
+max_retry_time = 1024
+
+# See https://github.com/yt-dlp/yt-dlp#format-selection
+# For exemple, if you want the lowest size, put "+size,+br,+res,+fps" in format_sort
+format = "all"
+format_sort = ""
+
+# What application to use to play
+internal_player_command = "mpv"
+
+# url of anime-sama (You shouldn't touch that)
+url = ""
+provider_url = "https://anime-sama.pw/"
+
+[concurrent_downloads]
+# how many fragment of a video to download at once
+fragment = 3
+# how many video to download at once
+video = 5
+
+[players_hostname]
+prefers = []
+bans = []

anime_sama_api/cli/downloader.py

@@ -0,0 +1,217 @@
+import logging
+import random
+import time
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from typing import cast
+from urllib.parse import urlparse
+
+from rich import get_console
+from rich.console import Group
+from rich.live import Live
+from rich.progress import (
+    BarColumn,
+    MofNCompleteColumn,
+    Progress,
+    ProgressColumn,
+    TaskID,
+    TextColumn,
+    TimeRemainingColumn,
+    TotalFileSizeColumn,
+    TransferSpeedColumn,
+)
+from rich.table import Column
+from yt_dlp import YoutubeDL
+from yt_dlp.utils import DownloadError
+
+from anime_sama_api.langs import Lang
+from anime_sama_api.cli.config import PlayersConfig, config
+from anime_sama_api.cli.episode_extra_info import EpisodeWithExtraInfo
+from anime_sama_api.cli.error_handeling import YDL_log_filter, reaction_to
+
+logger = logging.getLogger(__name__)
+logger.addFilter(YDL_log_filter)
+
+console = get_console()
+download_progress_list: list[str | ProgressColumn] = [
+    "[bold blue]{task.fields[episode_name]}",
+    BarColumn(bar_width=None),
+    "[progress.percentage]{task.percentage:>3.1f}%",  # TODO: should disappear if the console is not wide enough
+    TransferSpeedColumn(),
+    TotalFileSizeColumn(),
+    TimeRemainingColumn(compact=True, elapsed_when_finished=True),
+]
+if config.show_players:
+    download_progress_list.insert(
+        1,
+        TextColumn(
+            "[green]{task.fields[site]}",
+            table_column=Column(max_width=12),
+            justify="right",
+        ),
+    )
+
+download_progress = Progress(*download_progress_list, console=console)
+
+total_progress = Progress(
+    TextColumn("[bold cyan]{task.description}"),
+    BarColumn(bar_width=None),
+    MofNCompleteColumn(),
+    TimeRemainingColumn(elapsed_when_finished=True),
+    console=console,
+)
+progress = Group(total_progress, download_progress)
+
+
+def download(
+    episode: EpisodeWithExtraInfo,
+    path: Path,
+    episode_path: str = "{episode}",
+    prefer_languages: list[Lang] | None = None,
+    players_config: PlayersConfig | None = None,
+    concurrent_fragment_downloads: int = 3,
+    max_retry_time: int = 1024,
+    video_format: str = "",
+    format_sort: str = "",
+) -> None:
+    if prefer_languages is None:
+        prefer_languages = ["VOSTFR"]
+    if players_config is None:
+        players_config = PlayersConfig([], [])
+
+    if not any(episode.warpped.languages.values()):
+        logger.error("No player available")
+        return
+
+    me = download_progress.add_task(
+        "download", episode_name=episode.warpped.name, site="", total=None
+    )
+    task = next(t for t in download_progress.tasks if t.id == me)
+
+    full_path = (
+        path
+        / episode_path.format(
+            serie=episode.warpped.serie_name,
+            season=episode.warpped.season_name,
+            episode=episode.warpped.name,
+            release_year_parentheses=episode.release_year_parentheses(),
+        )
+    ).expanduser()
+
+    def hook(data: dict) -> None:
+        if data.get("status") != "downloading":
+            return
+
+        # Directly accessing .total is needed to not reset the speed
+        task.total = data.get("total_bytes") or data.get("total_bytes_estimate")
+        download_progress.update(me, completed=data.get("downloaded_bytes", 0))
+
+    option = {
+        "outtmpl": f"{full_path}.%(ext)s",
+        "concurrent_fragment_downloads": concurrent_fragment_downloads,
+        "progress_hooks": [hook],
+        "logger": logger,
+        "format": video_format,
+        "format_sort": format_sort.split(","),
+    }
+
+    for player in episode.warpped.consume_player(
+        prefer_languages, players_config.prefers, players_config.bans
+    ):
+        retry_time = 1
+        sucess = False
+        download_progress.update(me, site=urlparse(player).hostname)
+
+        while True:
+            try:
+                with YoutubeDL(option) as ydl:  # type: ignore
+                    error_code = cast(int, ydl.download([player]))
+
+                    if not error_code:
+                        sucess = True
+                    else:
+                        logger.fatal(
+                            "The download encountered an error code %s. Please report this to the developer with URL: %s",
+                            error_code,
+                            player,
+                        )
+
+                    break
+
+            except DownloadError as exception:
+                match reaction_to(exception.msg):
+                    case "continue":
+                        break
+
+                    case "retry":
+                        if retry_time >= max_retry_time:
+                            break
+
+                        logger.warning(
+                            "« %s » interrompu (%s). Nouvelle tentative dans %s s.",
+                            episode.warpped.name,
+                            exception.msg,
+                            retry_time,
+                        )
+                        # random is used to spread the resume time and so mitigate deadlock when multiple downloads resume at the same time
+                        time.sleep(retry_time * random.uniform(0.8, 1.2))
+                        retry_time *= 2
+
+                    case "crash":
+                        raise exception
+
+                    case "":
+                        logger.debug(
+                            "Download failed (trying next player): %s - URL: %s",
+                            exception.msg,
+                            player,
+                        )
+                        break
+
+        if sucess:
+            break
+
+    download_progress.update(me, visible=False)
+    if total_progress.tasks:
+        total_progress.update(TaskID(0), advance=1)
+
+
+def multi_download(
+    episodes: list[EpisodeWithExtraInfo],
+    path: Path,
+    episode_path: str = "{episode}",
+    concurrent_downloads: dict[str, int] | None = None,
+    prefer_languages: list[Lang] | None = None,
+    players_config: PlayersConfig | None = None,
+    max_retry_time: int = 1024,
+    video_format: str = "",
+    format_sort: str = "",
+) -> None:
+    if concurrent_downloads is None:
+        concurrent_downloads = {}
+    if prefer_languages is None:
+        prefer_languages = ["VOSTFR"]
+    if players_config is None:
+        players_config = PlayersConfig([], [])
+
+    """
+    Not sure if you can use this function multiple times
+    """
+    total_progress.add_task("Downloaded", total=len(episodes))
+    with Live(progress, console=console):
+        with ThreadPoolExecutor(
+            max_workers=concurrent_downloads.get("video", 1)
+        ) as executor:
+            for episode in episodes:
+                executor.submit(
+                    download,
+                    episode,
+                    path,
+                    episode_path,
+                    prefer_languages,
+                    players_config,
+                    concurrent_downloads.get("fragment", 1),
+                    max_retry_time,
+                    video_format,
+                    format_sort,
+                )