reanimdl 0.1.0__tar.gz

reanimdl-0.1.0/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.3
+Name: reanimdl
+Version: 0.1.0
+Summary: An asynchronous anime downloader CLI for reanime.to
+Requires-Dist: aiohttp>=3.12
+Requires-Dist: av>=19.0.1
+Requires-Dist: json5>=0.12
+Requires-Dist: m3u8>=6.0,<7
+Requires-Dist: platformdirs>=4.13.5
+Requires-Dist: pycryptodome>=3.21
+Requires-Dist: pywasm>=2.2,<3
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# reanimdl
+
+An asynchronous command-line anime downloader for reanime.to.
+
+It searches the site's public API, resolves the FlixCloud player, downloads
+HLS video/audio segments directly, decrypts them, and muxes everything into an
+MKV with subtitles, audio tracks, fonts, and chapter markers. Downloaded media
+stays in memory; only the final MKV is written to disk.
+
+## Requirements
+
+- Linux, macOS, or Windows (tested on Linux and Windows)
+- [uv](https://docs.astral.sh/uv/)
+
+Python itself is managed by `uv`; the project uses Python 3.14. Muxing uses
+[PyAV](https://pyav.org/), which bundles its own FFmpeg libraries, so no system
+`ffmpeg` binary is required.
+
+## PyAV
+
+[PyAV](https://pyav.org/) is a Pythonic binding for FFmpeg. It bundles its own
+FFmpeg libraries, so reanimdl does not require a system `ffmpeg` binary.  It
+provides direct access to stream templates, per-stream metadata and disposition,
+chapters, and `add_attachment` for embedding subtitle fonts — all without
+re-encoding a single frame.  In reanimdl, video, audio, and subtitle streams stay
+entirely in memory while PyAV remuxes them directly into a Matroska container,
+writing only the final MKV to disk.  No temporary media files are written.
+
+## Usage
+
+### Preferences
+
+Save defaults for the output directory, preferred quality, and audio mode:
+
+```bash
+reanimdl preferences -o ~/Videos/Anime -q 720 --audio dual
+reanimdl preferences              # show saved preferences
+reanimdl preferences --reset      # restore built-in defaults
+```
+
+`--audio` accepts `sub`, `dub`, or `dual`. Command-line options on
+`reanimdl download` override saved preferences. The preferences file lives in the
+platform-specific user config directory chosen by
+[`platformdirs`](https://pypi.org/project/platformdirs/), for example:
+
+- Linux: `~/.config/reanimdl/preferences.json`
+- macOS: `~/Library/Application Support/reanimdl/preferences.json`
+- Windows: `%LOCALAPPDATA%\reanimdl\preferences.json`
+
+### Search
+
+```bash
+reanimdl search "solo leveling"
+reanimdl s frieren --limit 5
+```
+
+Show anime details and episodes:
+
+```bash
+reanimdl info solo-leveling-gyycz8
+reanimdl episodes solo-leveling-gyycz8
+reanimdl eps solo-leveling-gyycz8 --limit 5 --reverse
+```
+
+### Download
+
+```bash
+# all episodes, best quality up to 1080p
+reanimdl download solo-leveling-gyycz8
+
+# episodes 1-3 and 7, English dub
+reanimdl download solo-leveling-gyycz8 -e 1-3,7 --dub
+
+# the newest five episodes, 720p, into a specific folder
+reanimdl download solo-leveling-gyycz8 --latest 5 -q 720 -o ~/Videos/Anime
+
+# both Japanese and English audio tracks
+reanimdl download solo-leveling-gyycz8 -e 1 --dual
+```
+
+A title can be passed instead of an ID. If several anime match, `reanimdl`
+prints a numbered list and asks you to choose (or use `--yes` to accept the
+best match):
+
+```bash
+reanimdl download "frieren beyond journeys end" -e 1
+```
+
+### Episode selection
+
+`-e/--episodes` accepts:
+
+| Value | Meaning |
+| --- | --- |
+| `all` or omitted | every episode |
+| `1,3,5-8` | explicit numbers and ranges |
+| `latest` | the last episode |
+| `1-last` | from episode 1 to the end |
+| `-5` | the last five episodes |
+
+Use `--latest N` as a shortcut for the newest `N` episodes.
+
+### Download options
+
+| Option | Description |
+| --- | --- |
+| `-q, --quality N` | preferred vertical resolution (default: saved preference or `1080`) |
+| `--audio sub\|dub\|dual` | audio track (default: saved preference or `sub`) |
+| `--dub` | shortcut for `--audio dub` |
+| `--dual` | shortcut for `--audio dual` |
+| `--server HD-1\|HD-2` | pick the CDN/server (default `HD-1`) |
+| `-o, --output DIR` | output directory (default: saved preference or `.`) |
+| `--workers N` | concurrent segment downloads (default `32`) |
+| `-f, --force` | overwrite existing output files |
+| `--no-subs` | do not mux subtitles |
+| `--no-fonts` | do not attach subtitle fonts |
+| `--no-chapters` | do not write chapter markers |
+| `-y, --yes` | accept automatic choices / skip confirmation |
+| `--quiet` | hide progress and status output |
+
+Files are written as:
+
+```text
+<output>/<Anime Title>/<Anime Title> - E01 [1080p] [Sub].mkv
+```
+
+Video/audio segments, subtitles, and fonts are kept in memory. PyAV muxes
+directly from those in-memory streams into the final MKV, so no temporary media
+files are written.
+
+## Disclaimer
+
+Downloading copyrighted material may be illegal where you live. Use this tool
+only for content you are allowed to download. The project is not affiliated
+with reanime.to, FlixCloud, or their CDNs.

reanimdl-0.1.0/README.md

@@ -0,0 +1,135 @@
+# reanimdl
+
+An asynchronous command-line anime downloader for reanime.to.
+
+It searches the site's public API, resolves the FlixCloud player, downloads
+HLS video/audio segments directly, decrypts them, and muxes everything into an
+MKV with subtitles, audio tracks, fonts, and chapter markers. Downloaded media
+stays in memory; only the final MKV is written to disk.
+
+## Requirements
+
+- Linux, macOS, or Windows (tested on Linux and Windows)
+- [uv](https://docs.astral.sh/uv/)
+
+Python itself is managed by `uv`; the project uses Python 3.14. Muxing uses
+[PyAV](https://pyav.org/), which bundles its own FFmpeg libraries, so no system
+`ffmpeg` binary is required.
+
+## PyAV
+
+[PyAV](https://pyav.org/) is a Pythonic binding for FFmpeg. It bundles its own
+FFmpeg libraries, so reanimdl does not require a system `ffmpeg` binary.  It
+provides direct access to stream templates, per-stream metadata and disposition,
+chapters, and `add_attachment` for embedding subtitle fonts — all without
+re-encoding a single frame.  In reanimdl, video, audio, and subtitle streams stay
+entirely in memory while PyAV remuxes them directly into a Matroska container,
+writing only the final MKV to disk.  No temporary media files are written.
+
+## Usage
+
+### Preferences
+
+Save defaults for the output directory, preferred quality, and audio mode:
+
+```bash
+reanimdl preferences -o ~/Videos/Anime -q 720 --audio dual
+reanimdl preferences              # show saved preferences
+reanimdl preferences --reset      # restore built-in defaults
+```
+
+`--audio` accepts `sub`, `dub`, or `dual`. Command-line options on
+`reanimdl download` override saved preferences. The preferences file lives in the
+platform-specific user config directory chosen by
+[`platformdirs`](https://pypi.org/project/platformdirs/), for example:
+
+- Linux: `~/.config/reanimdl/preferences.json`
+- macOS: `~/Library/Application Support/reanimdl/preferences.json`
+- Windows: `%LOCALAPPDATA%\reanimdl\preferences.json`
+
+### Search
+
+```bash
+reanimdl search "solo leveling"
+reanimdl s frieren --limit 5
+```
+
+Show anime details and episodes:
+
+```bash
+reanimdl info solo-leveling-gyycz8
+reanimdl episodes solo-leveling-gyycz8
+reanimdl eps solo-leveling-gyycz8 --limit 5 --reverse
+```
+
+### Download
+
+```bash
+# all episodes, best quality up to 1080p
+reanimdl download solo-leveling-gyycz8
+
+# episodes 1-3 and 7, English dub
+reanimdl download solo-leveling-gyycz8 -e 1-3,7 --dub
+
+# the newest five episodes, 720p, into a specific folder
+reanimdl download solo-leveling-gyycz8 --latest 5 -q 720 -o ~/Videos/Anime
+
+# both Japanese and English audio tracks
+reanimdl download solo-leveling-gyycz8 -e 1 --dual
+```
+
+A title can be passed instead of an ID. If several anime match, `reanimdl`
+prints a numbered list and asks you to choose (or use `--yes` to accept the
+best match):
+
+```bash
+reanimdl download "frieren beyond journeys end" -e 1
+```
+
+### Episode selection
+
+`-e/--episodes` accepts:
+
+| Value | Meaning |
+| --- | --- |
+| `all` or omitted | every episode |
+| `1,3,5-8` | explicit numbers and ranges |
+| `latest` | the last episode |
+| `1-last` | from episode 1 to the end |
+| `-5` | the last five episodes |
+
+Use `--latest N` as a shortcut for the newest `N` episodes.
+
+### Download options
+
+| Option | Description |
+| --- | --- |
+| `-q, --quality N` | preferred vertical resolution (default: saved preference or `1080`) |
+| `--audio sub\|dub\|dual` | audio track (default: saved preference or `sub`) |
+| `--dub` | shortcut for `--audio dub` |
+| `--dual` | shortcut for `--audio dual` |
+| `--server HD-1\|HD-2` | pick the CDN/server (default `HD-1`) |
+| `-o, --output DIR` | output directory (default: saved preference or `.`) |
+| `--workers N` | concurrent segment downloads (default `32`) |
+| `-f, --force` | overwrite existing output files |
+| `--no-subs` | do not mux subtitles |
+| `--no-fonts` | do not attach subtitle fonts |
+| `--no-chapters` | do not write chapter markers |
+| `-y, --yes` | accept automatic choices / skip confirmation |
+| `--quiet` | hide progress and status output |
+
+Files are written as:
+
+```text
+<output>/<Anime Title>/<Anime Title> - E01 [1080p] [Sub].mkv
+```
+
+Video/audio segments, subtitles, and fonts are kept in memory. PyAV muxes
+directly from those in-memory streams into the final MKV, so no temporary media
+files are written.
+
+## Disclaimer
+
+Downloading copyrighted material may be illegal where you live. Use this tool
+only for content you are allowed to download. The project is not affiliated
+with reanime.to, FlixCloud, or their CDNs.

reanimdl-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "reanimdl"
+version = "0.1.0"
+description = "An asynchronous anime downloader CLI for reanime.to"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "aiohttp>=3.12",
+    "av>=19.0.1",
+    "json5>=0.12",
+    "m3u8>=6.0,<7",
+    "platformdirs>=4.13.5",
+    "pycryptodome>=3.21",
+    "pywasm>=2.2,<3",
+]
+
+[project.scripts]
+reanimdl = "reanimdl.cli:run"
+
+[build-system]
+requires = ["uv_build>=0.13.1,<0.14.0"]
+build-backend = "uv_build"

reanimdl-0.1.0/pyproject.toml.orig

@@ -0,0 +1,23 @@
+[project]
+name = "reanimdl"
+version = "0.1.0"
+description = "An asynchronous anime downloader CLI for reanime.to"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "aiohttp>=3.12",
+    "av>=19.0.1",
+    "json5>=0.12",
+    "m3u8>=6.0,<7",
+    "platformdirs>=4.13.5",
+    "pycryptodome>=3.21",
+    "pywasm>=2.2,<3",
+]
+
+[project.scripts]
+reanimdl = "reanimdl.cli:run"
+
+[build-system]
+requires = ["uv_build>=0.13.1,<0.14.0"]
+build-backend = "uv_build"
+

reanimdl-0.1.0/src/reanimdl/__init__.py

@@ -0,0 +1,9 @@
+"""reanimdl - an asynchronous anime downloader for reanime.to."""
+
+__version__ = "0.1.0"
+
+
+def main() -> None:
+    from .cli import main as cli_main
+
+    cli_main()

reanimdl-0.1.0/src/reanimdl/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

reanimdl-0.1.0/src/reanimdl/api.py

@@ -0,0 +1,221 @@
+"""Asynchronous client for the reanime.to public API."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Any
+
+import aiohttp
+
+from .utils import AnimdlError, _Retryable, retry_async
+
+REANIME_BASE = "https://reanime.to"
+
+
+class ApiError(AnimdlError):
+    def __init__(self, status: int, detail: str) -> None:
+        self.status = status
+        self.detail = detail
+        super().__init__(f"reanime.to API error ({status}): {detail}")
+
+
+class AnimeNotFound(ApiError):
+    def __init__(self, slug: str) -> None:
+        super().__init__(404, f"anime not found: {slug}")
+
+
+@dataclass(frozen=True)
+class Server:
+    name: str
+    data_type: str
+    url: str
+    softsub: bool = False
+
+
+@dataclass
+class ServerSet:
+    sub: list[Server] = field(default_factory=list)
+    dub: list[Server] = field(default_factory=list)
+    anilist_id: int | None = None
+
+
+def _anilist_from_anime(anime: dict | None) -> int | None:
+    if not anime:
+        return None
+    for key in ("anilist_id", "anilist"):
+        value = anime.get(key)
+        if value:
+            try:
+                return int(value)
+            except (TypeError, ValueError):
+                pass
+    cover = anime.get("cover_image") or {}
+    for key in ("extra_large", "large", "medium"):
+        match = re.search(r"/bx(\d+)-", cover.get(key, "") or "")
+        if match:
+            return int(match.group(1))
+    return None
+
+
+class ReAnimeClient:
+    def __init__(
+        self, session: aiohttp.ClientSession, base: str = REANIME_BASE
+    ) -> None:
+        self.session = session
+        self.base = base.rstrip("/")
+
+    async def _get_json(
+        self,
+        path: str,
+        params: dict[str, Any] | None = None,
+        *,
+        attempts: int = 4,
+    ) -> Any:
+        url = f"{self.base}{path}"
+
+        async def attempt() -> Any:
+            async with self.session.get(
+                url,
+                params=params,
+                headers={"Accept": "application/json"},
+            ) as response:
+                body = await response.text()
+                if response.status == 404:
+                    raise AnimeNotFound(path.rsplit("/", 1)[-1])
+                if response.status in {429, 500, 502, 503, 504}:
+                    raise _Retryable(ApiError(response.status, body[:200]))
+                if not response.ok:
+                    raise ApiError(response.status, body[:300])
+                try:
+                    return _json_loads(body)
+                except ValueError as exc:
+                    raise ApiError(
+                        response.status, "invalid JSON response"
+                    ) from exc
+
+        return await retry_async(
+            attempt,
+            attempts=attempts,
+            final=lambda error: error
+            if isinstance(error, ApiError)
+            else AnimdlError(f"request to reanime.to failed: {error}"),
+        )
+
+    async def search(self, query: str, *, limit: int = 20, offset: int = 0) -> dict:
+        query = query.strip()
+        if not query:
+            raise AnimdlError("search query must not be empty")
+        data = await self._get_json(
+            "/api/v1/search",
+            {"q": query, "limit": max(1, min(limit, 100)), "offset": max(offset, 0)},
+        )
+        if not isinstance(data, dict):
+            raise AnimdlError("unexpected search response")
+        results = data.get("results") or []
+        if not isinstance(results, list):
+            results = []
+        data["results"] = results
+        return data
+
+    async def anime(self, slug: str) -> dict:
+        data = await self._get_json(f"/api/v1/anime/{slug}")
+        if not isinstance(data, dict):
+            raise AnimdlError("unexpected anime response")
+        return data
+
+    async def episodes(self, slug: str) -> list[dict]:
+        data = await self._get_json(
+            f"/api/v1/anime/{slug}/episodes",
+            {"limit": 2000},
+        )
+        if isinstance(data, list):
+            episodes = data
+        elif isinstance(data, dict):
+            episodes = data.get("data") or data.get("episodes") or []
+        else:
+            episodes = []
+
+        cleaned: list[dict] = []
+        for episode in episodes:
+            if not isinstance(episode, dict):
+                continue
+            try:
+                number = int(episode.get("episode_number"))
+            except (TypeError, ValueError):
+                continue
+            episode["episode_number"] = number
+            cleaned.append(episode)
+        return sorted(cleaned, key=lambda item: item["episode_number"])
+
+    async def servers(
+        self,
+        slug: str,
+        episode: int,
+        *,
+        anilist_id: int | None = None,
+        anime: dict | None = None,
+    ) -> ServerSet:
+        if episode < 1:
+            raise AnimdlError("episode numbers start at 1")
+
+        aid = anilist_id or _anilist_from_anime(anime)
+        if aid is None:
+            anime_data = await self.anime(slug)
+            aid = _anilist_from_anime(anime_data)
+        if aid is None:
+            raise AnimdlError(
+                "reanime.to did not provide an AniList ID for this anime, "
+                "so its streaming servers cannot be resolved"
+            )
+
+        data = await self._get_json(f"/api/flix/{aid}/{episode}")
+        if not isinstance(data, dict) or not data.get("success"):
+            raise AnimdlError("the streaming server did not return any playable links")
+
+        links = data.get("servers") or []
+        order = {"HD-1": 0, "HD-2": 1}
+
+        def build(items: list[dict]) -> list[Server]:
+            servers: list[Server] = []
+            for item in items:
+                url = item.get("dataLink")
+                if not url:
+                    continue
+                servers.append(
+                    Server(
+                        name=str(item.get("serverName") or "HD-1"),
+                        data_type=str(item.get("dataType") or ""),
+                        url=str(url),
+                        softsub=bool(item.get("softsub")),
+                    )
+                )
+            return sorted(
+                servers, key=lambda server: (order.get(server.name, 9), server.name)
+            )
+
+        return ServerSet(
+            sub=build(
+                [
+                    item
+                    for item in links
+                    if isinstance(item, dict)
+                    and item.get("dataType") in {"sub", "s-sub"}
+                ]
+            ),
+            dub=build(
+                [
+                    item
+                    for item in links
+                    if isinstance(item, dict)
+                    and item.get("dataType") in {"dub", "s-dub"}
+                ]
+            ),
+            anilist_id=aid,
+        )
+
+
+def _json_loads(body: str) -> Any:
+    import json
+
+    return json.loads(body)