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

anime_sama_api/episode.py

@@ -0,0 +1,207 @@
+import logging
+import re
+from collections.abc import Generator, Sequence
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import urlparse, urlsplit
+
+from httpx import HTTPError
+
+from .langs import Lang, LangId, flags, id2lang, lang2ids
+from .link_resolver import LinkError, RateLimitedError, validate_url
+
+logger = logging.getLogger(__name__)
+
+
+class Players(list[str]):
+    def __init__(self, *args: Sequence[Any], **kwargs: dict[Any, Any]):
+        super().__init__(*args, **kwargs)
+        self.swapPlayers()
+        for index, _ in enumerate(self):
+            self[index] = self[index].replace("vidmoly.to", "vidmoly.net")
+
+    def swapPlayers(self) -> None:
+        if len(self) < 2:
+            return
+        self[0], self[1] = (self[1], self[0])
+
+    def sort_and_filter(
+        self, prefer_players: list[str], ban_players: list[str]
+    ) -> list[str]:
+
+        def ban_filter(player: str) -> bool:
+            player_hostname = urlparse(player).hostname
+            if player_hostname is None:
+                return False
+            return player_hostname in ban_players
+
+        def key(player: str) -> int:
+            player_hostname = urlparse(player).hostname
+            if player_hostname is None:
+                return 0
+            try:
+                return prefer_players.index(player_hostname) - len(prefer_players)
+            except ValueError:
+                return 0
+
+        return sorted([player for player in self if not ban_filter(player)], key=key)
+
+
+class Languages(dict[LangId, Players]):
+    def __init__(self, *args: dict[LangId, Players], **kargs: Players) -> None:
+        super().__init__(*args, **kargs)
+        if not self:
+            logger.warning("No player available for %s", self)
+
+    @property
+    def availables(self) -> dict[Lang, list[Players]]:
+        availables: dict[Lang, list[Players]] = {}
+        for lang_id, players in self.items():
+            if availables.get(id2lang[lang_id]) is None:
+                availables[id2lang[lang_id]] = []
+            availables[id2lang[lang_id]].append(players)
+        return availables
+
+    def consume_player(self, prefer_languages, prefer_players, ban_players):
+        available = self.availables
+        seen_urls = set()
+        for language in ordered_languages(prefer_languages, available):
+            for players in available.get(language, []):
+                for url in players.sort_and_filter(prefer_players, ban_players):
+                    if url not in seen_urls:
+                        seen_urls.add(url)
+                        yield url
+
+
+@dataclass(frozen=True)
+class Episode:
+    languages: Languages
+    series_name: str = ""
+    season_name: str = ""
+    _name: str = ""
+    index: int = 1
+
+    @property
+    def name(self) -> str:
+        return self._name.strip()
+
+    @property
+    def fancy_name(self) -> str:
+        return f"{self._name.lstrip()} " + " ".join(
+            flags[lang] for lang in self.languages.availables if lang != "VOSTFR"
+        )
+
+    @property
+    def season_number(self) -> int:
+        match_season_number = re.search("\\d+", self.season_name)
+        return int(match_season_number.group(0)) if match_season_number else 0
+
+    @property
+    def long_name(self) -> str:
+        return f"{self.season_name} - {self.name}"
+
+    @property
+    def short_name(self) -> str:
+        return f"{self.series_name} S{self.season_number:02}E{self.index:02}"
+
+    def __str__(self) -> str:
+        return self.fancy_name
+
+    def consume_player(
+        self,
+        prefer_languages: list[Lang],
+        prefer_players: list[str] | None = None,
+        ban_players: list[str] | None = None,
+    ) -> Generator[str]:
+        if prefer_players is None:
+            prefer_players = []
+        if ban_players is None:
+            ban_players = []
+        yield from self.languages.consume_player(
+            prefer_languages, prefer_players, ban_players
+        )
+
+    def best(self, prefer_languages: list[Lang]) -> str | None:
+        try:
+            return next(self.consume_player(prefer_languages))
+        except StopIteration:
+            return None
+
+    async def aconsume_player(self, prefer_languages=None, ban_players=None):
+        """Yield resolved URLs on demand, suitable for the current HTML/API backend."""
+        async for url in iter_resolved_players(
+            self,
+            ["VOSTFR"] if prefer_languages is None else prefer_languages,
+            ban_players or [],
+        ):
+            yield url
+
+
+class DeferredPlayers(Players):
+    def __init__(self, references, resolver):
+        list.__init__(self, references)
+        self.resolver = resolver
+
+    def sort_and_filter(self, prefer_players, ban_players):
+        raise RuntimeError(
+            "Liens différés : utiliser Episode.aconsume_player() ou la CLI."
+        )
+
+
+def candidates_for(episode, prefer_languages):
+    order = ordered_languages(prefer_languages)
+    seen = set()
+    for language in order:
+        for lang_id, players in episode.languages.items():
+            if id2lang[lang_id] != language:
+                continue
+            for ref in players:
+                owner = (
+                    id(players.resolver)
+                    if isinstance(players, DeferredPlayers)
+                    else None
+                )
+                key = (owner, ref)
+                if ref and key not in seen:
+                    seen.add(key)
+                    yield (language, players, ref)
+
+
+async def resolve_reference(players, reference):
+    if isinstance(players, DeferredPlayers):
+        return await players.resolver.resolve(reference)
+    if reference.startswith("lien:"):
+        raise LinkError("Référence sans contexte de résolution")
+    return validate_url(reference)
+
+
+async def iter_resolved_players(
+    episode, prefer_languages, ban_players=(), resolve=None
+):
+    resolver = resolve or resolve_reference
+    seen_urls = set()
+    bans = set(ban_players)
+    for language, players, reference in candidates_for(episode, prefer_languages):
+        try:
+            url = await resolver(players, reference)
+        except RateLimitedError:
+            raise
+        except (LinkError, HTTPError) as exc:
+            logger.warning(
+                "%s / %s : résolution échouée (%s), candidat suivant",
+                episode.name,
+                language,
+                type(exc).__name__,
+            )
+            continue
+        if not url or url in seen_urls:
+            continue
+        seen_urls.add(url)
+        if urlsplit(url).hostname in bans:
+            continue
+        yield url
+
+
+def ordered_languages(prefer_languages, available=()):
+    """Preserve configured priorities, then append fallback languages once."""
+    return list(dict.fromkeys([*prefer_languages, *lang2ids, *available]))

anime_sama_api/langs.py

@@ -0,0 +1,76 @@
+from typing import Literal
+
+Lang = Literal["VASTFR", "VCN", "VF", "VJSTFR", "VKR", "VQC", "VOSTFR"]
+LangId = Literal["va", "vcn", "vf", "vf1", "vf2", "vj", "vkr", "vqc", "vostfr"]
+FlagId = Literal["cn", "qc", "en", "pal", "kr", "fr", "jp"]
+
+lang2ids: dict[Lang, list[LangId]] = {
+    "VOSTFR": ["vostfr"],
+    "VASTFR": ["va"],
+    "VCN": ["vcn"],
+    "VF": ["vf", "vf1", "vf2"],
+    "VJSTFR": ["vj"],
+    "VKR": ["vkr"],
+    "VQC": ["vqc"],
+}
+
+id2lang: dict[LangId, Lang] = {
+    lang_id: lang for lang, langs_id in lang2ids.items() for lang_id in langs_id
+}
+
+flags: dict[Lang | LangId, str] = {
+    "VOSTFR": "",
+    "VASTFR": "🇬🇧",
+    "VCN": "🇨🇳",
+    "VF": "🇫🇷",
+    "VJSTFR": "🇯🇵",
+    "VKR": "🇰🇷",
+    "VQC": "🏴󠁣󠁡󠁱󠁣󠁿",
+}
+
+flagid2lang: dict[FlagId, Lang] = {
+    "cn": "VCN",
+    "qc": "VQC",
+    "en": "VASTFR",
+    "kr": "VKR",
+    "fr": "VF",
+    "jp": "VJSTFR",
+}
+
+for language, language_ids in lang2ids.items():
+    for lang_id in language_ids:
+        flags[lang_id] = flags[language]
+
+
+if __name__ == "__main__":
+    import asyncio
+    import re
+    from pprint import pprint
+
+    import httpx
+
+    from anime_sama_api.top_level import AnimeSama
+
+    SCRIPT_VIDEO_URL = "https://anime-sama.si/js/contenu/script_videos.js"
+    page = httpx.get(SCRIPT_VIDEO_URL).text
+    langs = {}
+
+    matches = re.findall(r"if\((.+)\){langue = \"(.+)\";}", page)
+    for match in matches:
+        langs[match[1]] = match[0].split('"')[1::2]
+
+    pprint(langs)
+
+    async def main() -> None:
+        async for catalogue in AnimeSama("https://anime-sama.to/").catalogues_iter():
+            if await catalogue.seasons():
+                break
+        else:
+            raise RuntimeError
+
+        vostfr_url = (await catalogue.seasons())[0].url + "vostfr/"
+        response = await catalogue.client.get(vostfr_url)
+        response.raise_for_status()
+        print(set(re.findall(r"src=\".+flag_(.+?)\.png\"", response.text)))
+
+    asyncio.run(main())

anime_sama_api/link_resolver.py

@@ -0,0 +1,187 @@
+"""Inline episode references and Anime-Sama link API. No JavaScript execution."""
+
+import asyncio
+import json
+import re
+from dataclasses import dataclass
+from html.parser import HTMLParser
+from urllib.parse import urljoin, urlsplit
+
+
+class LinkError(RuntimeError):
+    pass
+
+
+class BddScriptParser(HTMLParser):
+    def __init__(self):
+        super().__init__(convert_charrefs=False)
+        self.active = False
+        self.parts = []
+
+    def handle_starttag(self, tag, attrs):
+        if tag.lower() == "script":
+            attributes = dict(attrs)
+            self.active = attributes.get("data-source") == "bdd"
+
+    def handle_data(self, data):
+        if self.active:
+            self.parts.append(data)
+
+    def handle_endtag(self, tag):
+        if tag.lower() == "script":
+            self.active = False
+
+
+def extract_bdd_script(html):
+    parser = BddScriptParser()
+    parser.feed(html)
+
+    source = "\n".join(parser.parts)
+
+    if not source.strip():
+        raise LinkError('Script <script data-source="bdd"> introuvable.')
+
+    return source
+
+
+class RateLimitedError(LinkError):
+    pass
+
+
+@dataclass
+class PageData:
+    token: str
+    players: dict[int, list[str]]
+    final_order: bool
+
+
+def parse_page(html):
+    source = extract_bdd_script(html)
+    token = re.search(
+        r"\b(?:var|let|const)\s+epsJeton\s*=\s*([\"'])(.*?)\1", source, re.DOTALL
+    )
+    players = {}
+    for match in re.finditer(
+        r"\b(?:var|let|const)\s+eps(\d+)\s*=\s*(\[[^;]*?\])\s*;", source, re.DOTALL
+    ):
+        try:
+            values = json.loads(match[2])
+        except ValueError as exc:
+            raise LinkError("Unsupported episode array syntax (expected JSON)") from exc
+        if not isinstance(values, list) or not all(isinstance(v, str) for v in values):
+            raise LinkError("Invalid episode array")
+        players[int(match[1])] = values
+    if not players:
+        raise LinkError(
+            "No inline epsN arrays found; page unavailable or format changed"
+        )
+    needs_token = any(v.startswith("lien:") for a in players.values() for v in a)
+    if needs_token and not token:
+        raise LinkError("epsJeton missing")
+    final = bool(re.search(r"\bepsOrdreFinal\s*=\s*true\b", source))
+    return PageData(token[2] if token else "", players, final)
+
+
+def validate_url(value):
+    if not isinstance(value, str):
+        raise LinkError("API field u must be a string")
+    parsed = urlsplit(value)
+    if (
+        parsed.scheme not in ("https", "http")
+        or not parsed.hostname
+        or parsed.username
+        or parsed.password
+    ):
+        raise LinkError("Invalid player URL")
+    return value
+
+
+class LinkResolver:
+    def __init__(self, client, page_url):
+        self.client = client
+        self.page_url = page_url
+        self.data = None
+        self.cache = {}
+        self.min_interval = 0.0
+        self._last_request = 0.0
+        self._refresh_lock = asyncio.Lock()
+
+    async def load(self):
+        response = await self.client.get(self.page_url, follow_redirects=True)
+        response.raise_for_status()
+        self.page_url = str(response.url)
+        self.data = parse_page(response.text)
+        self.cache.clear()
+        return response.text
+
+    async def resolve(self, reference):
+        if not reference:
+            return ""
+        if not reference.startswith("lien:"):
+            return validate_url(reference)
+        identifier = reference[5:]
+        if not identifier.isdecimal():
+            raise LinkError("Invalid lien ID")
+        if self.data is None:
+            await self.load()
+        refreshed = False
+        for attempt in range(3):
+            key = (self.data.token, identifier)
+            if key in self.cache:
+                return self.cache[key]
+            try:
+                loop = asyncio.get_running_loop()
+                wait = self.min_interval - (loop.time() - self._last_request)
+                if wait > 0:
+                    await asyncio.sleep(wait)
+                self._last_request = loop.time()
+                response = await self.client.get(
+                    urljoin(self.page_url, "/api/lien.php"),
+                    params={"j": self.data.token, "l": identifier},
+                    headers={"Referer": self.page_url},
+                    follow_redirects=False,
+                )
+                if response.status_code == 429:
+                    retry_after = response.headers.get("Retry-After")
+
+                    detail = (
+                        f"Retry-After reçu : {retry_after}."
+                        if retry_after
+                        else "Aucun délai Retry-After fourni par le serveur."
+                    )
+
+                    raise RateLimitedError(
+                        "Anime-Sama limite actuellement les requêtes. " + detail
+                    )
+
+                response.raise_for_status()
+                try:
+                    payload = response.json()
+                except ValueError as exc:
+                    raise LinkError(
+                        "API did not return JSON (possibly a verification page)"
+                    ) from exc
+                if not isinstance(payload, dict):
+                    raise LinkError("API response must be an object")
+                if payload.get("u"):
+                    value = validate_url(payload["u"])
+                    self.cache[key] = value
+                    return value
+                error = payload.get("erreur", "missing u")
+                if error == "expire" and not refreshed:
+                    refreshed = True
+                    async with self._refresh_lock:
+                        if self.data.token == key[0]:
+                            await self.load()
+                    continue
+                if error in ("absent", "expire"):
+                    raise LinkError("Terminal API error: " + str(error))
+                if attempt == 2:
+                    raise LinkError("API error: " + str(error))
+            except LinkError:
+                raise
+            except Exception:
+                if attempt == 2:
+                    raise
+            await asyncio.sleep((1, 3)[min(attempt, 1)])
+        raise LinkError("Resolution failed after token refresh")

anime_sama_api/season.py

@@ -0,0 +1,226 @@
+import logging
+import re
+from ast import literal_eval
+from dataclasses import dataclass, replace
+from functools import reduce
+from typing import get_args
+
+from httpx import AsyncClient
+
+from anime_sama_api.episode import DeferredPlayers
+
+from .episode import Episode, Languages, Players
+from .langs import LangId, flagid2lang, lang2ids
+from .link_resolver import LinkError, LinkResolver, RateLimitedError, parse_page
+from .utils import remove_some_js_comments, split_and_strip
+
+logger = logging.getLogger(__name__)
+
+
+class EpisodeDataUnavailableError(RuntimeError):
+    pass
+
+
+@dataclass
+class SeasonLangPage:
+    lang_id: LangId
+    html: str = ""
+    episodes_js: str = ""
+
+
+class Season:
+    def __init__(
+        self,
+        url: str,
+        name: str = "",
+        series_name: str = "",
+        client: AsyncClient | None = None,
+    ) -> None:
+        self.url = url
+        self.site_url = "/".join(url.split("/")[:3]) + "/"
+        self.name = name or url.split("/")[-2]
+        self.series_name = series_name or url.split("/")[-3]
+        self.client = client or AsyncClient()
+
+    async def get_all_pages(self):
+        pages = []
+        self._api_rows = {}
+        for lang_id in get_args(LangId):
+            page_url = self.url.rstrip("/") + "/" + lang_id + "/"
+            response = await self.client.get(page_url, follow_redirects=True)
+            if response.status_code == 404:
+                continue
+            if response.status_code == 429:
+                delay = response.headers.get("Retry-After", "non fourni")
+                raise RateLimitedError(
+                    "Limitation lors du chargement HTML. Retry-After : " + delay
+                )
+            response.raise_for_status()
+            try:
+                data = parse_page(response.text)
+            except LinkError as exc:
+                logger.warning("Page langue ignorée (%s) : %s", page_url, exc)
+                continue
+            resolver = LinkResolver(self.client, str(response.url))
+            resolver.data = data
+            arrays = [data.players[n] for n in sorted(data.players)]
+            rows = []
+            for index in range(max(map(len, arrays), default=0)):
+                refs = [a[index] if index < len(a) else "" for a in arrays]
+                if not data.final_order and len(refs) > 1:
+                    refs[0], refs[1] = (refs[1], refs[0])
+                rows.append(DeferredPlayers([r for r in refs if r], resolver))
+            self._api_rows[lang_id] = rows
+            pages.append(SeasonLangPage(lang_id=lang_id, html=response.text))
+        mapping = {p.lang_id: p for p in pages}
+        if "vostfr" in mapping:
+            matches = re.findall(
+                'src="[^"]*flag_([^"]+?)\\.png".*?<span[^>]*>\\s*VOSTFR\\s*</span>',
+                remove_some_js_comments(mapping["vostfr"].html),
+                re.DOTALL | re.IGNORECASE,
+            )
+            if matches and matches[0] in flagid2lang:
+                for target in lang2ids[flagid2lang[matches[0]]]:
+                    if target not in mapping:
+                        pages.append(replace(mapping["vostfr"], lang_id=target))
+                        self._api_rows[target] = self._api_rows["vostfr"]
+                        break
+        if not pages:
+            raise EpisodeDataUnavailableError(
+                "Aucune page avec données bdd exploitable : " + self.url
+            )
+        return pages
+
+    def _get_players_from(self, page):
+        return self._api_rows[page.lang_id]
+
+    def _get_episodes_names(
+        self, page: SeasonLangPage, number_of_episodes: int, number_of_episodes_max: int
+    ) -> list[str]:
+        functions = re.findall(
+            "resetListe\\(\\); *[\\n\\r]+\\t*(.*?)}",
+            remove_some_js_comments(page.html),
+            re.DOTALL,
+        )
+        if not functions:
+            raise EpisodeDataUnavailableError(
+                f"Could not find episode names for {self.series_name} - {self.name} ({self.url + page.lang_id}/)."
+            )
+        functions = functions[-1]
+        functions_list = split_and_strip(functions, (";", "\n"))[:-1]
+
+        def padding(n: int) -> str:
+            return " " * (len(str(number_of_episodes_max)) - len(str(n)))
+
+        def episode_name_range(*args) -> list[str]:
+            return [f"Episode {n}{padding(n)}" for n in range(*args)]
+
+        episodes_name: list[str] = []
+        for function in functions_list:
+            if function.startswith("//"):
+                continue
+            call_start = function.find("(")
+            function, args_sting = (
+                function[:call_start],
+                function[call_start + 1 : -1],
+            )
+            if args_sting:
+                args = literal_eval(node_or_string=args_sting + ",")
+                if type(args) is not tuple:
+                    continue
+            else:
+                args = ()
+            match function:
+                case "":
+                    continue
+                case "creerListe":
+                    if len(args) < 2:
+                        continue
+                    episodes_name += episode_name_range(int(args[0]), int(args[1]) + 1)
+                case "finirListe" | "finirListeOP":
+                    if not args:
+                        break
+                    episodes_name += episode_name_range(
+                        int(args[0]),
+                        int(args[0]) + number_of_episodes - len(episodes_name),
+                    )
+                    break
+                case "newSP":
+                    if not args:
+                        raise NotImplementedError(
+                            f"Error while parsing 'newSP'.\nPlease report this to the developer with URL: {self.url + page.lang_id}/"
+                        )
+                    episodes_name.append(f"Episode {args[0]}")
+                case "newSPF":
+                    if not args:
+                        raise NotImplementedError(
+                            f"Error while parsing 'newSPF'.\nPlease report this to the developer with URL: {self.url + page.lang_id}/"
+                        )
+                    episodes_name.append(args[0])
+                case name:
+                    raise NotImplementedError(
+                        f"Error cannot parse '{name}'.\nPlease report this to the developer with URL: {self.url + page.lang_id}/"
+                    )
+        return episodes_name
+
+    @staticmethod
+    def _extend_episodes(
+        current: list[tuple[str, Languages]],
+        new: tuple[SeasonLangPage, list[str], list[Players]],
+    ) -> list[tuple[str, Languages]]:
+        """
+        Extend a list of episodes AKA (name, languages) from a list names and players corresponding
+        to a language while preserving the relative order of names.
+        This function is intended to be used with reduce.
+        """
+        page, names, players_list = new
+        fusion = []
+        curr_done = 0
+        for name_new, players in zip(names, players_list):
+            for pos, (name_current, languages) in enumerate(current[curr_done:]):
+                if name_new == name_current:
+                    languages[page.lang_id] = players
+                    fusion.extend(current[curr_done : curr_done + pos + 1])
+                    curr_done += pos + 1
+                    break
+            else:
+                fusion.append((name_new, Languages({page.lang_id: players})))
+        fusion.extend(current[curr_done:])
+        return fusion
+
+    async def episodes(self) -> list[Episode]:
+        pages = await self.get_all_pages()
+        if not pages:
+            raise EpisodeDataUnavailableError(
+                f"Could not retrieve episode data for {self.series_name} - {self.name} ({self.url}). The season may be unavailable or Anime-Sama's page structure may have changed."
+            )
+        players_list = [self._get_players_from(page) for page in pages]
+        if not any(players_list):
+            raise EpisodeDataUnavailableError(
+                f"Could not parse episode players for {self.series_name} - {self.name} ({self.url}). Anime-Sama's page structure may have changed."
+            )
+        number_of_episodes_max = max(
+            len(episodes_page) for episodes_page in players_list
+        )
+        episodes_names = [
+            self._get_episodes_names(page, len(episodes_page), number_of_episodes_max)
+            for page, episodes_page in zip(pages, players_list)
+        ]
+        episodes: list[tuple[str, Languages]] = reduce(
+            self._extend_episodes, zip(pages, episodes_names, players_list), []
+        )
+        return [
+            Episode(languages, self.series_name, self.name, name, index)
+            for index, (name, languages) in enumerate(episodes, start=1)
+        ]
+
+    def __repr__(self) -> str:
+        return f"Season({self.name!r}, {self.series_name!r})"
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __eq__(self, value: object) -> bool:
+        if not isinstance(value, Season):
+            return False
+        return self.url == value.url