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

anime_sama_api/top_level.py

@@ -0,0 +1,376 @@
+import asyncio
+import logging
+import re
+from collections.abc import AsyncIterator, Generator
+from dataclasses import dataclass
+from datetime import datetime
+from html import unescape
+from html.parser import HTMLParser
+from typing import Any, cast, get_args
+from urllib.parse import urljoin
+
+from httpx import AsyncClient
+
+from .catalogue import Catalogue, Type
+from .episode import Episode
+from .langs import Lang, flagid2lang, flags
+from .season import Season
+from .utils import filter_literal, is_Literal
+
+logger = logging.getLogger(__name__)
+
+
+class _CatalogueCardParser(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.cards: list[dict[str, Any]] = []
+        self._card: dict[str, Any] | None = None
+        self._div_depth = 0
+        self._title_active = False
+        self._title_text = ""
+        self._badge_active = False
+        self._badge_text = ""
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        attributes = dict(attrs)
+        classes = (attributes.get("class") or "").split()
+
+        if tag == "div" and self._card is None and "as-carte" in classes:
+            self._card = {
+                "url": attributes.get("data-url") or "",
+                "name": attributes.get("data-nom") or "",
+                "image_url": attributes.get("data-img") or "",
+                "types": [],
+                "languages": [],
+            }
+            self._div_depth = 1
+            return
+
+        if self._card is None:
+            return
+
+        if tag == "div":
+            self._div_depth += 1
+        elif tag == "h3":
+            self._title_active = True
+            self._title_text = ""
+        elif tag == "span" and any(name.startswith("as-badge") for name in classes):
+            self._badge_active = True
+            self._badge_text = ""
+        elif tag == "img":
+            language_name = (attributes.get("title") or "").strip().casefold()
+            language_by_name = {
+                language.casefold(): language for language in get_args(Lang)
+            }
+            language = language_by_name.get(language_name)
+            if language is None:
+                language = next(
+                    (
+                        value
+                        for flag_id, value in flagid2lang.items()
+                        if flag_id.casefold() == language_name
+                    ),
+                    None,
+                )
+            if language is not None:
+                self._card["languages"].append(language)
+
+    def handle_data(self, data: str) -> None:
+        if self._title_active:
+            self._title_text += data
+        if self._badge_active:
+            self._badge_text += data
+
+    def handle_endtag(self, tag: str) -> None:
+        if self._card is None:
+            return
+
+        if tag == "h3" and self._title_active:
+            if self._title_text.strip():
+                self._card["name"] = self._title_text.strip()
+            self._title_active = False
+        elif tag == "span" and self._badge_active:
+            badge = self._badge_text.strip()
+            if badge:
+                self._card["types"].append(badge)
+            self._badge_active = False
+        elif tag == "div":
+            self._div_depth -= 1
+            if self._div_depth == 0:
+                if self._card["name"] and self._card["url"]:
+                    self.cards.append(self._card)
+                self._card = None
+
+
+async def find_site_url(
+    client: AsyncClient | None = None, provider_url="https://anime-sama.pw/"
+) -> str | None:
+    client = client or AsyncClient()
+
+    response = await client.get(provider_url)
+
+    if response.is_error:
+        return None
+
+    # * Sometimes need to check for the great word "anime-sama" in lowercase or uppercase but if add re.IGNORECASE it will work
+    match = re.search(
+        r"href=\"(.+?)\">Accéder à Anime-Sama", response.text, re.IGNORECASE
+    )
+
+    # * Ajouter un suive de redirection d'url au match au cas ou le site n'est pas a jour et redirige vers une autre url, puis garder l'url finale
+
+    if match:
+        redirected = await client.get(match.group(1), follow_redirects=True)
+        return str(redirected.url) + "/"
+
+
+@dataclass(frozen=True)
+class EpisodeRelease:
+    page_url: str
+    image_url: str
+    series_name: str
+    types: tuple[Type]
+    language: Lang
+    episode_name: str
+    timestamp: datetime
+
+    def get_real_episodes(self) -> list[Episode]:
+        raise NotImplementedError
+
+    @property
+    def fancy_name(self) -> str:
+        return (
+            f"{self.series_name} - {self.episode_name} {flags.get(self.language, '')}"
+        )
+
+
+class AnimeSama:
+    def __init__(self, site_url: str, client: AsyncClient | None = None) -> None:
+        self.site_url = site_url
+        self.client = client or AsyncClient()
+
+    async def _get_homepage_section(self, section_name: str, how_many: int = 1) -> str:
+        homepage = await self.client.get(self.site_url)
+
+        if homepage.is_error:
+            return ""
+
+        sections = homepage.text.split("<!--")
+        for index, section in enumerate(sections):
+            comment_end_pos = section.find("-->")
+            if section_name in section[:comment_end_pos]:
+                return "<!--" + "<!--".join(sections[index : index + how_many])
+
+        return ""
+
+    def _yield_catalogues_from(self, html: str) -> Generator[Catalogue]:
+        parser = _CatalogueCardParser()
+        parser.feed(html)
+        if parser.cards:
+            for card in parser.cards:
+                url = urljoin(self.site_url, card["url"])
+
+                def not_in_literal(value: Any, url=url) -> None:
+                    logger.warning(
+                        "Error while parsing '%s'. Please report this with URL: %s",
+                        value,
+                        url,
+                    )
+
+                card_types = cast(
+                    set[Type],
+                    set(filter_literal(card["types"], Type, not_in_literal)),
+                )
+                yield Catalogue(
+                    url=url,
+                    name=card["name"],
+                    types=card_types,
+                    languages=set(card["languages"]),
+                    image_url=card["image_url"],
+                    client=self.client,
+                )
+            return
+
+        text_without_script = re.sub(r"<script[\W\w]+?</script>", "", html)
+        for match in re.finditer(
+            rf"href=\"({self.site_url}catalogue/.+)\"[\W\w]+?src=\"(.+?)\"[\W\w]+?<h2.+?>(.*)\n?<[\W\w]+?<p.+?>(.*)\n?<[\W\w]+?<div class=\"genre-tags\">([\W\w]*?)</div[\W\w]+?<p.+?>(.*)\n?<[\W\w]+?<div class=\"lang-flags\">([\W\w]*?)</div",
+            text_without_script,
+        ):
+            (
+                url,
+                image_url,
+                name,
+                alternative_names_str,
+                genres_str,
+                types_str,
+                flags_str,
+            ) = (unescape(item) for item in match.groups())
+
+            alternative_names = (
+                alternative_names_str.split(", ") if alternative_names_str else []
+            )
+
+            genres = re.findall(r">(.+?)<", genres_str)
+            types = types_str.split(", ") if types_str else []
+            flags = re.findall(r"title=\"(.+?)\"", flags_str)
+
+            def not_in_literal(value: Any, url=url) -> None:
+                logger.warning(
+                    f"Error while parsing '{value}'. \nPlease report this to the developer with URL: {url}"
+                )
+
+            types_checked = cast(
+                set[Type], set(filter_literal(types, Type, not_in_literal))
+            )
+            languages = {
+                flagid2lang[flag.lower()]
+                for flag in flags
+                if flag.lower() in flagid2lang
+            }
+
+            yield Catalogue(
+                url=url,
+                name=name,
+                alternative_names=alternative_names,
+                genres=genres,
+                types=types_checked,
+                languages=languages,
+                image_url=image_url,
+                client=self.client,
+            )
+
+    def _yield_release_episodes_from(self, html: str) -> Generator[EpisodeRelease]:
+        for match in re.finditer(
+            r"href=\"/(catalogue\/.+)\"[\W\w]+?src=\"(.+?)\"[\W\w]+?>.*\n?<[\W\w]+?>.*\n?<[\W\w]+?>(.*)\n?<[\W\w]+?>.*\n?<[\W\w]+?\">([\W\w]*?)\n?</[\W\w]+?>(.*)\n?<[\W\w]+?>.*\n?<[\W\w]+?>(.*)\n?<[\W\w]+?>(.*)\n?<",
+            html,
+        ):
+            (
+                season_url,
+                image_url,
+                types,
+                language_str,
+                series_name,
+                episode_name,
+                timestamp,
+            ) = match.groups()
+            season_url = self.site_url + season_url
+
+            types = types.split(", ") if types else ["Anime"]
+
+            def not_in_literal(value: Any, season_url=season_url) -> None:
+                logger.warning(
+                    f"Error while parsing '{value}'. \nPlease report this to the developer with URL: {season_url} (from homepage)"
+                )
+
+            types_checked = cast(
+                tuple[Type],
+                tuple(filter_literal(types, Type, not_in_literal)),
+            )
+
+            language = re.findall(r"title=\"(.+?)\"", language_str)[0]
+            is_Literal(language, Lang, not_in_literal)
+
+            yield EpisodeRelease(
+                page_url=season_url,
+                image_url=image_url,
+                series_name=series_name,
+                types=types_checked,
+                language=language,
+                episode_name=episode_name,
+                timestamp=datetime.strptime(timestamp, "%d/%m/%Y %H:%M"),
+            )
+
+    async def search(self, query: str) -> list[Catalogue]:
+        response = (
+            await self.client.get(
+                f"{self.site_url}catalogue/", params={"search": query}
+            )
+        ).raise_for_status()
+
+        pages_regex = re.findall(r"page=(\d+)", response.text)
+
+        last_page = max((int(page) for page in pages_regex), default=1)
+
+        responses = [response] + await asyncio.gather(
+            *(
+                self.client.get(
+                    f"{self.site_url}catalogue/",
+                    params={"search": query, "page": num},
+                )
+                for num in range(2, last_page + 1)
+            )
+        )
+
+        catalogues = []
+        for response in responses:
+            if response.is_error:
+                continue
+
+            # catalogues += list(self._yield_catalogues_from(response.text))
+            # catalogues = [
+            #      *catalogue
+            #      for response in response
+            #      if not response.is_error
+            #      for catalogue in self._yield_catalogues_from(response.text)
+            #  ]
+
+            catalogues.extend(self._yield_catalogues_from(response.text))
+
+        return catalogues
+
+    async def search_iter(self, query: str) -> AsyncIterator[Catalogue]:
+        response = (
+            await self.client.get(
+                f"{self.site_url}catalogue/", params={"search": query}
+            )
+        ).raise_for_status()
+
+        pages_regex = re.findall(r"page=(\d+)", response.text)
+
+        last_page = max((int(page) for page in pages_regex), default=1)
+
+        for catalogue in self._yield_catalogues_from(response.text):
+            yield catalogue
+
+        for number in range(2, last_page + 1):
+            response = await self.client.get(
+                f"{self.site_url}catalogue/",
+                params={"search": query, "page": number},
+            )
+
+            if response.is_error:
+                continue
+
+            for catalogue in self._yield_catalogues_from(response.text):
+                yield catalogue
+
+    async def catalogues_iter(self) -> AsyncIterator[Catalogue]:
+        async for catalogue in self.search_iter(""):
+            yield catalogue
+
+    async def all_catalogues(self) -> list[Catalogue]:
+        return await self.search("")
+
+    async def planning(self) -> list[list[Season]]:
+        # Get from homepage, return value should be change
+        raise NotImplementedError
+
+    async def new_episodes(self) -> list[EpisodeRelease]:
+        """
+        Return the new available episodes on anime-sama using the homepage sorted from oldest to newest.
+        """
+        section = await self._get_homepage_section("ajouts animes", 4)
+        release_episodes = list(self._yield_release_episodes_from(section))
+        return release_episodes[::-1]
+
+    """async def new_scans(self) -> list[Scan]:
+        raise NotImplementedError"""
+
+    async def new_content(self) -> list[Catalogue]:
+        raise NotImplementedError
+
+    async def classics(self) -> list[Catalogue]:
+        raise NotImplementedError
+
+    async def highlights(self) -> list[Catalogue]:
+        raise NotImplementedError

anime_sama_api/utils.py

@@ -0,0 +1,54 @@
+import functools
+import operator
+import re
+from collections.abc import Callable, Generator, Iterable
+from itertools import zip_longest
+from typing import Any, TypeVar, cast, get_args
+
+T = TypeVar("T")
+NO_VALUE = object()
+
+
+def zip_varlen(*iterables: Iterable[T]) -> list[list[T]]:
+    return cast(
+        list[list[T]],
+        [
+            [entry for entry in row if entry is not NO_VALUE]
+            for row in zip_longest(*iterables, fillvalue=NO_VALUE)
+        ],
+    )
+
+
+def split_and_strip(string: str, delimiters: Iterable[str] | str) -> list[str]:
+    if isinstance(delimiters, str):
+        return [part.strip() for part in string.split(delimiters)]
+    string_list = [string]
+    for delimiter in delimiters:
+        string_list = functools.reduce(
+            operator.iadd, (part.split(delimiter) for part in string_list), []
+        )
+    return [part.strip() for part in string_list]
+
+
+def remove_some_js_comments(string: str) -> str:
+    string = re.sub(r"/\*[\W\w]*?\*/", "", string)
+    return re.sub(r"<!--[\W\w]*?-->", "", string)
+
+
+def is_Literal(
+    value: Any,
+    Lit: Any,
+    callback_when_false: Callable[[Any], None] = lambda _: None,
+) -> bool:
+    if value in get_args(Lit):
+        return True
+    callback_when_false(value)
+    return False
+
+
+def filter_literal(
+    iterable: Iterable[Any],
+    Lit: T,
+    callback_when_false: Callable[[Any], None] = lambda _: None,
+) -> Generator[T, None, None]:
+    return (value for value in iterable if is_Literal(value, Lit, callback_when_false))

anime_sama_cli_api-0.4.0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.5
+Name: anime-sama_cli_api
+Version: 0.4.0
+Summary: Api for anime-sama
+Project-URL: Repository, https://github.com/Mathieux83/anime-sama_api
+Author-email: NiniKo <pcninik@gmail.com>, Mathieux83 <car.math@live.fr>
+License-Expression: GPL-3.0-or-later
+License-File: LICENSE
+Keywords: anime,anime-sama,downloader
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Multimedia :: Video :: Capture
+Classifier: Topic :: System :: Archiving
+Requires-Python: >=3.11
+Requires-Dist: httpx2>=2.16.0
+Requires-Dist: httpx>=0.28.1
+Provides-Extra: cli
+Requires-Dist: platformdirs>=4.13.5; extra == 'cli'
+Requires-Dist: rich>=15.0.0; extra == 'cli'
+Requires-Dist: yt-dlp>=2026.8.19; extra == 'cli'
+Description-Content-Type: text/markdown
+
+> [!WARNING]
+> This project is an updated fork of the main repo of Niniko, with his authorization I only work in this fork no PR was send for now.
+
+---
+
+# Anime-Sama API
+
+An API for anime-sama, also provides a CLI to download videos.
+
+I have implemented all the features I care about. This project is now in maintenance mode.
+
+# Installation
+
+Requirements:
+
+- Python **3.11** or higher
+
+You can simply install it with (note that you can use tools like pipx to isolate the installation):
+
+```bash
+pip install anime-sama-api[cli]
+```
+
+And to run it:
+
+```bash
+anime-sama
+```
+
+## Configuration
+
+You can customize the config at :
+
+- Linux: `~/.config/anime-sama_cli/config.toml`
+- Windows: `%USER%/AppData/Local/anime-sama_cli/config.toml`
+- macOS: `~/Library/Application Support/anime-sama_api/config.toml`
+
+---
+
+# For developers
+
+## Requirements
+
+- git
+- [uv](https://docs.astral.sh/uv/#installation)
+
+## Install locally
+
+```bash
+git clone https://github.com/Sky-NiniKo/anime-sama_api.git
+cd anime-sama_downloader
+uv sync --extra cli
+```
+
+## Run
+
+```bash
+uv run anime-sama
+```
+
+## Update
+
+In the `anime_sama` folder:
+
+```bash
+git pull
+```
+
+---
+
+## Contribution
+
+I am open to contribution. Please only open a PR for ONE change. AKA, don't do "Various improvements" and explain your motivation behind your improvement ("Various typos fix"/"Cleanup" is fine).

anime_sama_cli_api-0.4.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+anime_sama_api/__init__.py,sha256=unxLlRekkszdKueHtqU6-wC_D9VZ0nOPlBdUxzcI99Y,1246
+anime_sama_api/catalogue.py,sha256=VIpVfl0xV9OiMlSUfhInC-PYNxJEiz6F3kC-lKl8buQ,7737
+anime_sama_api/episode.py,sha256=2E8ZzvgqXhX_SrRGAqjNDk2eW0e9CAflPPcZ0cKzc7U,7027
+anime_sama_api/langs.py,sha256=K8jjV4oIXTNfvbldPWlb0fA7AHB2JlzM22mp8eFmqO0,2072
+anime_sama_api/link_resolver.py,sha256=h5U6nPSvk2erTFc35LupaWFIa--zGIx7hDY0cVWi_nQ,6241
+anime_sama_api/season.py,sha256=5a2zsi6qmOvo0XH2QKLimam1Q0iaIQbawbazk1-T0X0,9317
+anime_sama_api/top_level.py,sha256=zwasoI_-DCxcokgaGEBUgOoPu2keBq6w5S96ZS_kh48,12981
+anime_sama_api/utils.py,sha256=0AmJAPigX8u4OPbY4PpcI7zksAxOQHsbEHtTEuI-jvM,1523
+anime_sama_api/cli/__main__.py,sha256=SMZU4ixVPQKP9tc_HSQBCMDZjqr4Nu-WjCGK0yLTs6c,2982
+anime_sama_api/cli/config.py,sha256=jVk5u727R8-TKREdeBwtm1Ncvbzs_2l3AWcgV2RRFbc,4061
+anime_sama_api/cli/config.toml,sha256=_vAsf5ZSTNYMIvBU7p_9OSj9STG8Oeg7YgN1RRNnDXM,1028
+anime_sama_api/cli/downloader.py,sha256=zjyQeUMpvYEcW0nsQlujhtGoCAPbR-R-RUglrtj3t14,10908
+anime_sama_api/cli/error_handling.py,sha256=PnWIlrwvYGVh8Hfh1shYhLYVJEP7XDd6IhOrypihiEY,2064
+anime_sama_api/cli/internal_player.py,sha256=Pqwiv0dcfZYr-H3xNLiqhBKVBYA6cri7lv2NSDVj1ho,1535
+anime_sama_api/cli/play_menu.py,sha256=nhvagx6Us3QbTYTJ9NfMYj45hRFDtZBFCefHnxPf_Hg,1637
+anime_sama_api/cli/utils.py,sha256=LVlcZzBn9lh3eFs2ekBpdeAchYuFQDp-OTGBIrnPtVk,4395
+anime_sama_cli_api-0.4.0.dist-info/METADATA,sha256=povEg3R0_18RuKNoqlr37KM0NYDp546q1cX8nnmrtpo,2579
+anime_sama_cli_api-0.4.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+anime_sama_cli_api-0.4.0.dist-info/entry_points.txt,sha256=AoSk4oUFjzp4TwPxqXFOfg7R7rTGtakEHrHUk_XeNQ0,51
+anime_sama_cli_api-0.4.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+anime_sama_cli_api-0.4.0.dist-info/RECORD,,

anime_sama_cli_api-0.4.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

anime_sama_cli_api-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+anime-sama = anime_sama_api:main