cinnamon-cli 0.2.19__py3-none-any.whl

cinnamon/scrapers/anime.py

@@ -0,0 +1,196 @@
+import json
+import re
+import time as _time
+from typing import Optional
+
+import requests
+
+from ..errors import ScraperNetworkError, ScraperNoStreamError, ScraperParseError
+from ..player import DEFAULT_UA as UA
+from .base import BaseScraper, ScraperResult
+
+TIMEOUT = 15
+API = "https://api.allanime.day/api"
+
+_ALLANIME_KEY = None
+
+def _get_key():
+    global _ALLANIME_KEY
+    if not _ALLANIME_KEY:
+        import hashlib
+        _ALLANIME_KEY = hashlib.sha256(b"Xot36i3lK3:v1").digest()
+    return _ALLANIME_KEY
+
+_HEX_MAP = {
+    "79": "A", "7a": "B", "7b": "C", "7c": "D", "7d": "E", "7e": "F", "7f": "G",
+    "70": "H", "71": "I", "72": "J", "73": "K", "74": "L", "75": "M", "76": "N",
+    "77": "O", "68": "P", "69": "Q", "6a": "R", "6b": "S", "6c": "T", "6d": "U",
+    "6e": "V", "6f": "W", "60": "X", "61": "Y", "62": "Z",
+    "59": "a", "5a": "b", "5b": "c", "5c": "d", "5d": "e", "5e": "f", "5f": "g",
+    "50": "h", "51": "i", "52": "j", "53": "k", "54": "l", "55": "m", "56": "n",
+    "57": "o", "48": "p", "49": "q", "4a": "r", "4b": "s", "4c": "t", "4d": "u",
+    "4e": "v", "4f": "w", "40": "x", "41": "y", "42": "z",
+    "08": "0", "09": "1", "0a": "2", "0b": "3", "0c": "4", "0d": "5", "0e": "6",
+    "0f": "7", "00": "8", "01": "9",
+    "15": "-", "16": ".", "67": "_", "46": "~", "02": ":", "17": "/", "07": "?",
+    "1b": "#", "63": "[", "65": "]", "78": "@", "19": "!", "1c": "$", "1e": "&",
+    "10": "(", "11": ")", "12": "*", "13": "+", "14": ",", "03": ";", "05": "=",
+    "1d": "%",
+}
+
+def _decode_custom_hex(encoded):
+    out = []
+    for i in range(0, len(encoded), 2):
+        out.append(_HEX_MAP.get(encoded[i:i+2], "?"))
+    return "".join(out)
+
+def _decrypt_tobeparsed(tp):
+    try:
+        from Crypto.Cipher import AES
+
+        raw = __import__("base64").b64decode(tp)
+        iv, ct = raw[1:13], raw[13:-16]
+        ctr_iv = iv + b"\x00\x00\x00\x02"
+        cipher = AES.new(_get_key(), AES.MODE_CTR, nonce=b"", initial_value=ctr_iv)
+        return json.loads(cipher.decrypt(ct).decode("utf-8"))
+    except Exception:
+        return None
+
+_SEARCH_GQL = """query ($search: SearchInput) {
+  shows(search: $search, limit: 10, page: 1, translationType: sub, countryOrigin: ALL) {
+    edges { _id name availableEpisodes __typename }
+  }
+}"""
+
+_EP_GQL = "query ($showId: String!) { show(_id: $showId) { _id availableEpisodesDetail } }"
+
+_SRC_GQL = "query ($showId: String!, $translationType: VaildTranslationTypeEnumType!, $episodeString: String!) { episode(showId: $showId translationType: $translationType episodeString: $episodeString) { episodeString sourceUrls } }"
+
+_QUERY_HASH = "d405d0edd690624b66baba3068e0edc3ac90f1597d898a1ec8db4e5c43c00fec"
+
+_LAST_REQUEST = 0.0
+
+def _gql(session, query, variables):
+    global _LAST_REQUEST
+    elapsed = _time.time() - _LAST_REQUEST
+    if elapsed < 3.5:
+        _time.sleep(3.5 - elapsed)
+    body = json.dumps({"variables": json.dumps(variables), "query": query}, ensure_ascii=False, separators=(",", ":"))
+    resp = session.post(API, data=body, timeout=TIMEOUT, headers={"Content-Type": "application/json"})
+    _LAST_REQUEST = _time.time()
+    if resp.status_code != 200:
+        raise ScraperNetworkError("allanime", f"GraphQL returned {resp.status_code}")
+    return resp.json()
+
+def _gql_src(session, variables):
+    global _LAST_REQUEST
+    elapsed = _time.time() - _LAST_REQUEST
+    if elapsed < 3.5:
+        _time.sleep(3.5 - elapsed)
+    body = json.dumps({"extensions": {"persistedQuery": {"version": 1, "sha256Hash": _QUERY_HASH}}, "variables": json.dumps(variables)}, ensure_ascii=False, separators=(",", ":"))
+    resp = session.post(API, data=body, timeout=TIMEOUT, headers={"Content-Type": "application/json"})
+    _LAST_REQUEST = _time.time()
+    if resp.status_code != 200:
+        raise ScraperNetworkError("allanime", f"Source GQL returned {resp.status_code}")
+    return resp.json()
+
+def _allanime_search(session, query):
+    data = _gql(session, _SEARCH_GQL, {"search": {"allowAdult": False, "allowUnknown": False, "query": query}})
+    return data.get("data", {}).get("shows", {}).get("edges", [])
+
+def _allanime_episodes(session, show_id):
+    data = _gql(session, _EP_GQL, {"showId": show_id})
+    return data.get("data", {}).get("show", {}).get("availableEpisodesDetail", {})
+
+def _allanime_sources(session, show_id, ep_str, tt="sub"):
+    data = _gql_src(session, {"showId": show_id, "translationType": tt, "episodeString": ep_str})
+    tp = data.get("data", {}).get("tobeparsed", "") if isinstance(data, dict) else ""
+    if not tp:
+        raise ScraperNetworkError("allanime", "No tobeparsed data in response")
+    parsed = _decrypt_tobeparsed(tp)
+    if not parsed:
+        raise ScraperNoStreamError("allanime", "Failed to decrypt stream sources (source format may have changed)")
+    episode = parsed.get("episode")
+    if not isinstance(episode, dict):
+        raise ScraperNoStreamError("allanime", "No stream data for this episode (source may be unavailable)")
+    return episode.get("sourceUrls", [])
+
+def _find_show(session, name):
+    results = _allanime_search(session, name)
+    if not results:
+        return None
+    q = name.lower().strip()
+    for r in results:
+        rn = r.get("name", "").lower().strip()
+        if q == rn:
+            return r["_id"]
+    for r in results:
+        rn = r.get("name", "").lower().strip()
+        if q in rn or rn in q:
+            return r["_id"]
+    return results[0]["_id"]
+
+def _extract_mp4upload(session, embed_url):
+    resp = session.get(embed_url, timeout=TIMEOUT)
+    if resp.status_code != 200:
+        return None
+    m = re.search(r'src:\s*"([^"]+)"', resp.text)
+    return m.group(1) if m else None
+
+
+class AnimeScraper(BaseScraper):
+    name = "anime"
+    description = "Anime streams from allanime.day via mp4upload (no browser needed)"
+
+    def search(self, query):
+        return []
+
+    def resolve(self, episode_info):
+        show_name = episode_info.get("show", "")
+        episode = episode_info.get("episode", 1)
+        quality = episode_info.get("quality", "")
+        translation = episode_info.get("translation", "sub")
+
+        if not show_name:
+            raise ScraperParseError(self.name, "Missing show name in episode_info")
+
+        deadline = _time.time() + 30
+        session = requests.Session()
+        session.headers.update({"User-Agent": UA, "Origin": "https://youtu-chan.com"})
+
+        if _time.time() >= deadline:
+            raise ScraperNoStreamError(self.name, "Timeout searching allanime")
+        show_id = _find_show(session, show_name)
+        if not show_id:
+            raise ScraperNoStreamError(self.name, f'No allanime match for "{show_name}"')
+
+        if _time.time() >= deadline:
+            raise ScraperNoStreamError(self.name, "Timeout fetching sources")
+        sources = _allanime_sources(session, show_id, str(episode), translation)
+
+        if not sources:
+            raise ScraperNoStreamError(self.name, f"No sources for episode {episode}")
+
+        for src in sources:
+            if _time.time() >= deadline:
+                break
+            url = src.get("sourceUrl", "")
+            if not url or "mp4upload" not in url:
+                continue
+            if url.startswith("//"):
+                url = "https:" + url
+            try:
+                direct = _extract_mp4upload(session, url)
+                if direct:
+                    label = quality.upper() if quality else "Mp4upload"
+                    return ScraperResult(
+                        title=f"{show_name} E{episode:02d} ({label})",
+                        m3u8_url=direct,
+                        referer="https://mp4upload.com/",
+                        user_agent=UA,
+                    )
+            except Exception:
+                pass
+
+        raise ScraperNoStreamError(self.name,
+            f"No playable stream found for {show_name} E{episode}")

cinnamon/scrapers/base.py

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class ScraperResult:
+    title: str
+    m3u8_url: str
+    referer: Optional[str] = None
+    user_agent: Optional[str] = None
+    headers: dict = field(default_factory=dict)
+
+    def __post_init__(self):
+        if not self.title:
+            raise ValueError("ScraperResult.title is required")
+        if not self.m3u8_url:
+            raise ValueError("ScraperResult.m3u8_url is required")
+        if not (self.m3u8_url.startswith("http") or self.m3u8_url.startswith("magnet:")):
+            raise ValueError(f"ScraperResult.m3u8_url must be a valid URL, got: {self.m3u8_url}")
+
+
+class BaseScraper(ABC):
+    name: str = ""
+    description: str = ""
+    config_schema: dict = {}
+
+    @abstractmethod
+    def search(self, query: str) -> list[dict]:
+        ...
+
+    @abstractmethod
+    def resolve(self, episode_info: dict) -> Optional[ScraperResult]:
+        ...

cinnamon/scrapers/torrentio.py

@@ -0,0 +1,123 @@
+from typing import Optional
+
+import requests
+
+from ..errors import ScraperNoStreamError, ScraperNetworkError
+from ..player import DEFAULT_UA as UA
+from .base import BaseScraper, ScraperResult
+
+TORRENTIO_BASE = "https://torrentio.strem.fun"
+QUALITY_ORDER = ["4k", "2160p", "1080p", "720p", "480p", "360p"]
+TRACKERS = [
+    "http://tracker3.itzmx.com:6961/announce",
+    "http://tracker1.itzmx.com:8080/announce",
+    "http://tracker.itzmx.com:6961/announce",
+    "udp://tracker.opentrackr.org:1337/announce",
+    "udp://exodus.desync.com:6969/announce",
+    "udp://open.demonii.com:1337/announce",
+]
+
+
+def _quality_from_name(name: str) -> tuple[int, str]:
+    name_lower = name.lower()
+    for q in QUALITY_ORDER:
+        if q in name_lower:
+            return (len(QUALITY_ORDER) - QUALITY_ORDER.index(q), q)
+    return (0, "unknown")
+
+
+def _magnet_from_info(info_hash: str, name: str = "") -> str:
+    magnet = f"magnet:?xt=urn:btih:{info_hash}"
+    if name:
+        import urllib.parse
+        magnet += f"&dn={urllib.parse.quote(name)}"
+    for tr in TRACKERS:
+        magnet += f"&tr={tr}"
+    return magnet
+
+
+class TorrentioScraper(BaseScraper):
+    name = "torrentio"
+    description = "Finds torrent streams via Torrentio (scrapes 1337x, TPB, RARBG, etc.)"
+
+    def search(self, query):
+        return []
+
+    def resolve(self, episode_info):
+        media_type = episode_info.get("media_type", "tv")
+        tmdb_id = episode_info.get("tv_id") or episode_info.get("tmdb_id") or episode_info.get("movie_id")
+        season = episode_info.get("season", 1)
+        episode = episode_info.get("episode", 1)
+        show_name = episode_info.get("show", "?")
+
+        if not tmdb_id:
+            from ..errors import ScraperParseError
+            raise ScraperParseError(self.name, "Missing tmdb_id/movie_id/tv_id in episode_info")
+
+        imdb_id = self._get_imdb_id(tmdb_id, media_type)
+        if not imdb_id:
+            raise ScraperNoStreamError(self.name,
+                f"Could not find IMDb ID for TMDB ID {tmdb_id}")
+
+        if media_type == "movie":
+            streams = self._fetch_movie_streams(imdb_id)
+            label = f"{show_name} (movie torrent)"
+        else:
+            streams = self._fetch_streams(imdb_id, season, episode)
+            label = f"{show_name} S{season:02d}E{episode:02d}"
+
+        if not streams:
+            raise ScraperNoStreamError(self.name,
+                f"No torrents found for {label}")
+
+        best = max(streams, key=lambda s: _quality_from_name(s.get("name", "")))
+        info_hash = best["infoHash"]
+        filename = best.get("behaviorHints", {}).get("filename", "")
+
+        magnet = _magnet_from_info(info_hash, filename)
+        _, quality_label = _quality_from_name(best.get("name", ""))
+
+        return ScraperResult(
+            title=f"{label} ({quality_label} torrent)",
+            m3u8_url=magnet,
+        )
+
+    def _get_imdb_id(self, tmdb_id: int, media_type: str = "tv") -> Optional[str]:
+        try:
+            from ..config import get_tmdb_api_key
+            api_key = get_tmdb_api_key()
+            headers = {"User-Agent": UA}
+            tmdb_type = "movie" if media_type == "movie" else "tv"
+            r = requests.get(
+                f"https://api.themoviedb.org/3/{tmdb_type}/{tmdb_id}",
+                headers=headers,
+                params={"api_key": api_key, "append_to_response": "external_ids"},
+                timeout=15,
+            )
+            r.raise_for_status()
+            data = r.json()
+            return data.get("external_ids", {}).get("imdb_id")
+        except requests.RequestException:
+            return None
+
+    def _fetch_streams(self, imdb_id: str, season: int, episode: int) -> list:
+        try:
+            url = f"{TORRENTIO_BASE}/stream/series/{imdb_id}:{season}:{episode}.json"
+            headers = {"User-Agent": UA}
+            r = requests.get(url, headers=headers, timeout=15)
+            r.raise_for_status()
+            data = r.json()
+            return data.get("streams", [])
+        except requests.RequestException as e:
+            raise ScraperNetworkError(self.name, str(e))
+
+    def _fetch_movie_streams(self, imdb_id: str) -> list:
+        try:
+            url = f"{TORRENTIO_BASE}/stream/movie/{imdb_id}.json"
+            headers = {"User-Agent": UA}
+            r = requests.get(url, headers=headers, timeout=15)
+            r.raise_for_status()
+            data = r.json()
+            return data.get("streams", [])
+        except requests.RequestException as e:
+            raise ScraperNetworkError(self.name, str(e))

cinnamon/scrapers/vidsrc.py

@@ -0,0 +1,131 @@
+import asyncio
+import time as _time
+from typing import Optional
+
+from ..errors import (
+    ScraperNetworkError,
+    ScraperNoStreamError,
+    ScraperParseError,
+)
+from ..player import DEFAULT_UA as _UA
+from .base import BaseScraper, ScraperResult
+
+_DOMAINS = [
+    ("vidsrc.pm", "https://vidsrc.pm/embed/tv/{tmdb_id}/{season}/{episode}"),
+    ("vidsrc.to", "https://vidsrc.to/embed/tv/{tmdb_id}/{season}/{episode}"),
+    ("vidsrc.in", "https://vidsrc.in/embed/tv/{tmdb_id}/{season}/{episode}"),
+    ("vidsrc.net", "https://vidsrc.net/embed/tv/{tmdb_id}/{season}/{episode}"),
+    ("vidsrc.xyz", "https://vidsrc.xyz/embed/tv/{tmdb_id}/{season}/{episode}"),
+    ("vidsrc.cc", "https://vidsrc.cc/embed/tv/{tmdb_id}/{season}/{episode}"),
+]
+
+
+class VidSrcScraper(BaseScraper):
+    name = "vidsrc"
+    description = "Scrapes m3u8 streams from vidsrc domains using Playwright"
+
+    def search(self, query):
+        return []
+
+    def resolve(self, episode_info):
+        media_type = episode_info.get("media_type", "tv")
+        tmdb_id = episode_info.get("tv_id") or episode_info.get("tmdb_id") or episode_info.get("movie_id")
+        show = episode_info.get("show", "?")
+        season = episode_info.get("season", 1)
+        episode = episode_info.get("episode", 1)
+
+        if not tmdb_id:
+            raise ScraperParseError(self.name, "Missing tmdb_id/movie_id/tv_id in episode_info")
+
+        if media_type == "movie":
+            embed_urls = [
+                f"https://{domain}/embed/movie/{tmdb_id}"
+                for domain, _ in _DOMAINS
+            ]
+        else:
+            embed_urls = [
+                url_template.format(tmdb_id=tmdb_id, season=season, episode=episode)
+                for _, url_template in _DOMAINS
+            ]
+
+        last_error = None
+        for embed_url in embed_urls:
+            try:
+                m3u8_url = _playwright_resolve(embed_url, timeout=30)
+                if m3u8_url:
+                    if media_type == "movie":
+                        title = f"{show}"
+                    else:
+                        title = f"{show} S{season:02d}E{episode:02d}"
+                    return ScraperResult(
+                        title=title,
+                        m3u8_url=m3u8_url,
+                        referer=embed_url,
+                        user_agent=_UA,
+                    )
+            except ScraperNoStreamError:
+                continue
+            except Exception as e:
+                last_error = e
+                continue
+
+        if last_error:
+            raise last_error if isinstance(last_error, ScraperNoStreamError) else ScraperNoStreamError(self.name)
+        raise ScraperNoStreamError(self.name)
+
+
+def _playwright_resolve(embed_url: str, timeout: int = 30) -> Optional[str]:
+    return asyncio.run(_async_resolve(embed_url, timeout))
+
+
+async def _async_resolve(embed_url: str, timeout: int = 30) -> Optional[str]:
+    try:
+        from playwright.async_api import async_playwright
+    except ImportError:
+        raise ScraperNetworkError(
+            "vidsrc",
+            "Playwright is required for the vidsrc scraper. Install it with: pip install playwright && python -m playwright install chromium"
+        )
+
+    found_urls = []
+
+    async with async_playwright() as p:
+        browser = await p.chromium.launch(
+            headless=True,
+            args=['--disable-blink-features=AutomationControlled']
+        )
+        context = await browser.new_context(
+            viewport={'width': 1920, 'height': 1080},
+            user_agent=_UA,
+        )
+        page = await context.new_page()
+
+        await page.add_init_script("""
+        Object.defineProperty(navigator, 'webdriver', { get: () => false });
+        """)
+
+        all_urls = []
+        page.on('response', lambda r: all_urls.append(r.url))
+
+        try:
+            await page.goto(embed_url, wait_until="domcontentloaded", timeout=timeout * 1000)
+        except Exception as e:
+            await browser.close()
+            raise ScraperNetworkError("vidsrc", f"Navigation failed: {e}")
+
+        deadline = _time.time() + timeout
+        while _time.time() < deadline:
+            await asyncio.sleep(1)
+            for u in all_urls:
+                if '.m3u8' in u.lower() and u not in found_urls:
+                    found_urls.append(u)
+            if found_urls:
+                break
+
+        await browser.close()
+
+    if not found_urls:
+        raise ScraperNoStreamError("vidsrc")
+
+    master = [u for u in found_urls if 'master.m3u8' in u]
+    return master[0] if master else found_urls[0]