anime-sama-cli-api 0.4.0__py3-none-any.whl

anime_sama_api/__init__.py

@@ -0,0 +1,52 @@
+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
+
+try:
+    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
+else:
+
+    def main() -> int:
+        from .cli.__main__ import main as cli_main
+
+        return cli_main()
+
+
+# __package__ = "anime-sama_api"
+__all__ = [
+    "AnimeSama",
+    "Catalogue",
+    "Episode",
+    "Lang",
+    "LangId",
+    "Languages",
+    "Players",
+    "Season",
+    "download",
+    "find_site_url",
+    "flags",
+    "id2lang",
+    "lang2ids",
+    "main",
+    "multi_download",
+]
+
+"""__locals = locals()
+for __name in __all__:
+    if not __name.startswith("__"):
+        setattr(__locals[__name], "__module__", "anime-sama_api")  # noqa"""

anime_sama_api/catalogue.py

@@ -0,0 +1,252 @@
+import logging
+import re
+from collections.abc import Sequence
+from datetime import date
+from html import unescape
+from typing import Literal, get_args
+
+from httpx import AsyncClient
+
+from .langs import Lang, flags
+from .season import Season
+from .utils import remove_some_js_comments
+
+Type = Literal["Anime", "Film", "Scans", "Webtoon", "Autres"]
+State = Literal["À venir", "En cours", "Terminé", "Annulé", "En pause"]
+
+logger = logging.getLogger(__name__)
+
+
+class Catalogue:
+    def __init__(
+        self,
+        url: str,
+        name: str = "",
+        alternative_names: Sequence[str] | None = None,
+        genres: Sequence[str] | None = None,
+        types: set[Type] | 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 types is None:
+            types = 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.types = types
+        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())
+
+        seasons = re.findall(
+            r'panneauAnime\("(.+?)", *"(.+?)(?:vostfr|vf)"\);?', page_without_comments
+        )
+
+        seasons = [
+            Season(
+                url=self.url + link,
+                name=name,
+                series_name=self.name,
+                client=self.client,
+            )
+            for name, link in seasons
+        ]
+
+        return seasons
+
+    async def _info_values(self) -> dict[str, list[str]]:
+        values: dict[str, list[str]] = {}
+        page = await self.page()
+        info_blocks = re.findall(
+            r"""<dl\b[^>]*class=["'][^"']*\boe-infos\b[^"']*["'][^>]*>(.*?)</dl\s*>""",
+            page,
+            re.IGNORECASE | re.DOTALL,
+        )
+        for block in info_blocks:
+            for label, value in re.findall(
+                r"<dt\b[^>]*>(.*?)</dt\s*>\s*<dd\b[^>]*>(.*?)</dd\s*>",
+                block,
+                re.IGNORECASE | re.DOTALL,
+            ):
+                clean_label = self._clean_html(label).casefold()
+                values.setdefault(clean_label, []).append(self._clean_html(value))
+        return values
+
+    # TODO: move to utils
+    @staticmethod
+    def _clean_html(value: str) -> str:
+        return re.sub(r"\s+", " ", unescape(re.sub(r"<[^>]*>", " ", value))).strip()
+
+    async def news(self) -> str:
+        search = re.findall(r"Actualité.+?>(.+?)<", await self.page())
+
+        if not search:
+            return ""
+
+        return search[0].lstrip()
+
+    async def state(self) -> str:
+        info = await self._info_values()
+        states = info.get("statut", [])
+        if states:
+            if states[0] in get_args(State):
+                return states[0]
+            logger.warning(
+                f"Error while parsing '{states[0]}'. \nPlease report this to the developer with URL: {self.url}",
+            )
+        return ""
+
+    async def broadcasting_date(self) -> date | None:
+        raise NotImplementedError
+
+        info = await self._info_values()
+        diffusions = info.get("diffusion", [])
+
+        if not diffusions:
+            return
+
+        import time
+
+        return date(
+            *(time.strptime(diffusions[0], "%d %b. %Y")[0:3])
+        )  # issue with local: %b should be interpreted with french local
+
+    async def year(self) -> int | None:
+        info = await self._info_values()
+        for label in ("diffusion", "année", "année de sortie", "début"):
+            for value in info.get(label, []):
+                match = re.search(r"\b(?:19|20)\d{2}\b", value)
+                if match:
+                    return int(match.group(0))
+
+    async def episode_count(self) -> int | None:
+        info = await self._info_values()
+        for value in info.get("épisodes", []):
+            match = re.search(r"\d+", value)
+            if match:
+                return int(match.group(0))
+
+    # Currently not provided by Anime Sama. We consider this as deprecated: TODO add a warning
+    async def chapter_count(self) -> int | None:
+        info = await self._info_values()
+        for value in info.get("chapitres", []):
+            match = re.search(r"\d+", value)
+            if match:
+                return int(match.group(0))
+
+    async def creator(self) -> str:
+        info = await self._info_values()
+        creators = info.get("auteur", [])
+
+        if not creators:
+            return ""
+
+        return creators[0]
+
+    async def studio(self) -> str:
+        info = await self._info_values()
+        studios = info.get("studio", [])
+
+        if not studios:
+            return ""
+
+        return studios[0]
+
+    async def correspondence(self) -> str:
+        page = await self.page()
+        match = re.search(
+            r"Correspondance\s*:.*?</strong>\s*(.*?)</span>",
+            page,
+            re.IGNORECASE | re.DOTALL,
+        )
+
+        if not match:
+            return ""
+
+        return self._clean_html(match.group(1))
+
+    async def synopsis(self) -> str:
+        page = await self.page()
+        synopsis = re.search(
+            r"""<p\b[^>]*id=["'][^"']*\bsynopsisText\b[^"']*["'][^>]*>(.*?)</p\s*>""",
+            page,
+            re.IGNORECASE | re.DOTALL,
+        )
+
+        if not synopsis:
+            return ""
+
+        return self._clean_html(synopsis.group(1))
+
+    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.types
+
+    @property
+    def is_manga(self) -> bool:
+        return "Scans" in self.types
+
+    @property
+    def is_film(self) -> bool:
+        return "Film" in self.types
+
+    @property
+    def is_other(self) -> bool:
+        return "Autres" in self.types
+
+    @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: object) -> 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,80 @@
+"""CLI using the package's HTML backend and lazy API resolution."""
+
+import asyncio
+import logging
+from urllib.error import URLError
+
+from httpx import AsyncClient, HTTPError
+from rich import get_console
+from rich.logging import RichHandler
+
+from anime_sama_api.cli.downloader import download_episodes
+from anime_sama_api.cli.utils import install_clean_prompts
+from anime_sama_api.link_resolver import LinkError, RateLimitedError
+from anime_sama_api.season import EpisodeDataUnavailableError
+from anime_sama_api.top_level import AnimeSama, find_site_url
+
+from . import utils as cli_utils
+from .config import config
+
+console = get_console()
+
+
+async def async_main():
+    query = cli_utils.safe_input("Anime name: ", str)
+    async with AsyncClient(timeout=30, follow_redirects=True) as client:
+        url = config.url or await find_site_url(client, config.provider_url)
+        if not url:
+            raise URLError("Could not find the Anime-Sama domain")
+        with console.status("Searching..."):
+            catalogues = await AnimeSama(url, client).search(query)
+        if not catalogues:
+            console.print("No results found.")
+            return True
+        catalogue = cli_utils.select_one(catalogues)
+        with console.status("Loading seasons..."):
+            seasons = await catalogue.seasons()
+        if not seasons:
+            console.print("No seasons found.")
+            return True
+        selected = cli_utils.select_range(seasons, msg="Choose season(s)")
+        if not selected:
+            return True
+        episodes = []
+        for season in selected:
+            with console.status("Loading episodes: " + season.name):
+                available = await season.episodes()
+            if len(selected) == 1:
+                console.print(season.series_name + " - " + season.name, markup=False)
+                episodes = cli_utils.select_range(
+                    available, msg="Choose episode(s)", print_choices=True
+                )
+            else:
+                episodes.extend(available)
+        if not episodes:
+            return True
+        if config.download:
+            return await download_episodes(episodes, config, await catalogue.year())
+
+
+def main():
+    install_clean_prompts()
+    logging.basicConfig(
+        level=logging.INFO, format="%(message)s", handlers=[RichHandler()]
+    )
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    try:
+        return 0 if asyncio.run(async_main()) else 1
+    except (KeyboardInterrupt, asyncio.CancelledError, EOFError):
+        console.print("Interrupted.", style="red", markup=False)
+        return 130
+    except RateLimitedError as exc:
+        console.print("Server rate limit: " + str(exc), style="red", markup=False)
+        return 2
+    except (LinkError, EpisodeDataUnavailableError, HTTPError, URLError) as exc:
+        console.print("Error: " + str(exc), style="red", markup=False)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(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 tomllib
+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
+
+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' is not a valid language, ignoring it.", 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)
+
+    # Spelling
+    config_dict["episode_path"] = config_dict["episode_path"].replace(
+        "{serie}", "{series}"
+    )
+
+    # 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 {series} {season} {episode} {release_year_parentheses})
+episode_path = "{series}/{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 example, 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 = []