cinnamon-cli 0.2.19__py3-none-any.whl

cinnamon/scrapers/webstream.py

@@ -0,0 +1,282 @@
+import re
+import time as _time
+from typing import Optional
+
+import requests
+
+from ..errors import ScraperNetworkError, ScraperNoStreamError, ScraperParseError
+from .base import BaseScraper, ScraperResult
+
+from ..player import DEFAULT_UA as UA
+TIMEOUT = 15
+
+
+class WebStreamScraper(BaseScraper):
+    name = "webstream"
+    description = "HTTP streams from vixsrc.to and vidlink.pro (no browser needed)"
+
+    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)
+        quality = episode_info.get("quality", "")
+
+        if not tmdb_id:
+            raise ScraperParseError(self.name, "Missing tmdb_id/movie_id/tv_id in episode_info")
+
+        deadline = _time.time() + 30
+
+        if media_type == "movie":
+            # Try vixsrc.to first
+            if _time.time() < deadline:
+                try:
+                    result = _try_vixsrc_movie(tmdb_id, quality)
+                    if result:
+                        label = quality.upper() if quality else "vixsrc"
+                        return ScraperResult(
+                            title=f"{show} ({label})",
+                            m3u8_url=result,
+                            referer=f"https://vixsrc.to/embed/movie/{tmdb_id}",
+                            user_agent=UA,
+                        )
+                except ScraperNetworkError:
+                    pass
+
+            # Try vidlink.pro as fallback
+            if _time.time() < deadline:
+                try:
+                    result = _try_vidlink_movie(tmdb_id)
+                    if result:
+                        return ScraperResult(
+                            title=f"{show} (vidlink)",
+                            m3u8_url=result,
+                            referer="https://vidlink.pro/",
+                            user_agent=UA,
+                        )
+                except ScraperNetworkError:
+                    pass
+
+            raise ScraperNoStreamError(self.name, f"No HTTP stream found for {show}")
+
+        # TV
+        if _time.time() < deadline:
+            try:
+                result = _try_vixsrc(tmdb_id, season, episode, quality)
+                if result:
+                    label = quality.upper() if quality else "vixsrc"
+                    return ScraperResult(
+                        title=f"{show} S{season:02d}E{episode:02d} ({label})",
+                        m3u8_url=result,
+                        referer=f"https://vixsrc.to/embed/tv/{tmdb_id}/{season}/{episode}",
+                        user_agent=UA,
+                    )
+            except ScraperNetworkError:
+                pass
+
+        if _time.time() < deadline:
+            try:
+                result = _try_vidlink(tmdb_id, season, episode)
+                if result:
+                    return ScraperResult(
+                        title=f"{show} S{season:02d}E{episode:02d} (vidlink)",
+                        m3u8_url=result,
+                        referer="https://vidlink.pro/",
+                        user_agent=UA,
+                    )
+            except ScraperNetworkError:
+                pass
+
+        raise ScraperNoStreamError(self.name,
+            f"No HTTP stream found for {show} S{season:02d}E{episode:02d}")
+
+
+_QUALITY_RENDITIONS = {"480p": "480p", "720p": "720p", "1080p": "1080p", "best": "", "worst": "worst"}
+
+def _try_vixsrc(tmdb_id, season, episode, quality="") -> Optional[str]:
+    session = requests.Session()
+    session.headers.update({"User-Agent": UA})
+
+    api_url = f"https://vixsrc.to/api/tv/{tmdb_id}/{season}/{episode}?lang=en"
+    embed_resp = session.get(api_url, timeout=TIMEOUT, headers={
+        "Accept": "application/json, text/javascript, */*; q=0.01",
+        "Referer": "https://vixsrc.to",
+    })
+    if embed_resp.status_code != 200:
+        raise ScraperNetworkError("vixsrc", f"API returned {embed_resp.status_code}")
+    embed_src = embed_resp.json().get("src")
+    if not embed_src:
+        raise ScraperNetworkError("vixsrc", "No src in API response")
+
+    full_embed = "https://vixsrc.to" + embed_src
+    sep = "&" if "?" in full_embed else "?"
+    full_embed += f"{sep}lang=en"
+    html = session.get(full_embed, timeout=TIMEOUT, headers={
+        "Accept": "text/html,application/xhtml+xml,*/*",
+    }).text
+
+    token = re.search(r'token["\']\s*:\s*["\']([^"\']+)', html)
+    expires = re.search(r'expires["\']\s*:\s*["\']([^"\']+)', html)
+    playlist = re.search(r'url\s*:\s*["\']([^"\']+)', html)
+    if not (token and expires and playlist):
+        raise ScraperNetworkError("vixsrc", "Could not extract token/playlist from embed page")
+
+    sep = "&" if "?" in playlist.group(1) else "?"
+    master_url = f'{playlist.group(1)}{sep}token={token.group(1)}&expires={expires.group(1)}&h=1&lang=en'
+
+    if not quality:
+        return master_url
+
+    # Parse master playlist and filter by quality
+    master_resp = session.get(master_url, timeout=TIMEOUT)
+    if master_resp.status_code != 200:
+        return master_url
+
+    variants = re.findall(
+        r'#EXT-X-STREAM-INF:.*?RESOLUTION=\d+x(\d+).*?\n(https?://\S+)',
+        master_resp.text,
+    )
+    if not variants:
+        return master_url
+
+    target = quality.replace("p", "")
+    if quality == "best":
+        match = max(variants, key=lambda v: int(v[0]))
+    elif quality == "worst":
+        match = min(variants, key=lambda v: int(v[0]))
+    else:
+        matches = [v for v in variants if v[0] == target]
+        match = matches[0] if matches else max(variants, key=lambda v: int(v[0]))
+
+    return match[1]
+
+
+def _try_vidlink(tmdb_id, season, episode) -> Optional[str]:
+    session = requests.Session()
+    session.headers.update({"User-Agent": UA})
+
+    enc = session.get(
+        f"https://enc-dec.app/api/enc-vidlink?text={tmdb_id}",
+        timeout=TIMEOUT,
+    )
+    if enc.status_code != 200:
+        raise ScraperNetworkError("vidlink", f"Encryption API returned {enc.status_code}")
+    try:
+        encoded = enc.json().get("result")
+    except ValueError:
+        raise ScraperNetworkError("vidlink", "Non-JSON response from encryption API")
+    if not encoded:
+        raise ScraperNetworkError("vidlink", "No encrypted ID from API")
+
+    stream_url = f"https://vidlink.pro/api/b/tv/{encoded}/{season}/{episode}?multiLang=0&audio=eng&subLang=eng"
+    stream_resp = session.get(stream_url, timeout=TIMEOUT, headers={
+        "Referer": "https://vidlink.pro/",
+    })
+    if stream_resp.status_code != 200:
+        raise ScraperNetworkError("vidlink", f"Stream API returned {stream_resp.status_code}")
+
+    try:
+        data = stream_resp.json()
+    except ValueError:
+        raise ScraperNetworkError("vidlink", "Non-JSON response from stream API")
+    playlist = data.get("stream", {}).get("playlist")
+    if not playlist:
+        raise ScraperNetworkError("vidlink", "No playlist in stream response")
+
+    return playlist
+
+
+def _try_vixsrc_movie(tmdb_id, quality="") -> Optional[str]:
+    session = requests.Session()
+    session.headers.update({"User-Agent": UA})
+
+    api_url = f"https://vixsrc.to/api/movie/{tmdb_id}?lang=en"
+    embed_resp = session.get(api_url, timeout=TIMEOUT, headers={
+        "Accept": "application/json, text/javascript, */*; q=0.01",
+        "Referer": "https://vixsrc.to",
+    })
+    if embed_resp.status_code != 200:
+        raise ScraperNetworkError("vixsrc", f"API returned {embed_resp.status_code}")
+    embed_src = embed_resp.json().get("src")
+    if not embed_src:
+        raise ScraperNetworkError("vixsrc", "No src in API response")
+
+    full_embed = "https://vixsrc.to" + embed_src
+    sep = "&" if "?" in full_embed else "?"
+    full_embed += f"{sep}lang=en"
+    html = session.get(full_embed, timeout=TIMEOUT, headers={
+        "Accept": "text/html,application/xhtml+xml,*/*",
+    }).text
+
+    token = re.search(r'token["\']\s*:\s*["\']([^"\']+)', html)
+    expires = re.search(r'expires["\']\s*:\s*["\']([^"\']+)', html)
+    playlist = re.search(r'url\s*:\s*["\']([^"\']+)', html)
+    if not (token and expires and playlist):
+        raise ScraperNetworkError("vixsrc", "Could not extract token/playlist from embed page")
+
+    sep = "&" if "?" in playlist.group(1) else "?"
+    master_url = f'{playlist.group(1)}{sep}token={token.group(1)}&expires={expires.group(1)}&h=1&lang=en'
+
+    if not quality:
+        return master_url
+
+    master_resp = session.get(master_url, timeout=TIMEOUT)
+    if master_resp.status_code != 200:
+        return master_url
+
+    variants = re.findall(
+        r'#EXT-X-STREAM-INF:.*?RESOLUTION=\d+x(\d+).*?\n(https?://\S+)',
+        master_resp.text,
+    )
+    if not variants:
+        return master_url
+
+    target = quality.replace("p", "")
+    if quality == "best":
+        match = max(variants, key=lambda v: int(v[0]))
+    elif quality == "worst":
+        match = min(variants, key=lambda v: int(v[0]))
+    else:
+        matches = [v for v in variants if v[0] == target]
+        match = matches[0] if matches else max(variants, key=lambda v: int(v[0]))
+
+    return match[1]
+
+
+def _try_vidlink_movie(tmdb_id) -> Optional[str]:
+    session = requests.Session()
+    session.headers.update({"User-Agent": UA})
+
+    enc = session.get(
+        f"https://enc-dec.app/api/enc-vidlink?text={tmdb_id}",
+        timeout=TIMEOUT,
+    )
+    if enc.status_code != 200:
+        raise ScraperNetworkError("vidlink", f"Encryption API returned {enc.status_code}")
+    try:
+        encoded = enc.json().get("result")
+    except ValueError:
+        raise ScraperNetworkError("vidlink", "Non-JSON response from encryption API")
+    if not encoded:
+        raise ScraperNetworkError("vidlink", "No encrypted ID from API")
+
+    stream_url = f"https://vidlink.pro/api/b/movie/{encoded}?multiLang=0&audio=eng&subLang=eng"
+    stream_resp = session.get(stream_url, timeout=TIMEOUT, headers={
+        "Referer": "https://vidlink.pro/",
+    })
+    if stream_resp.status_code != 200:
+        raise ScraperNetworkError("vidlink", f"Stream API returned {stream_resp.status_code}")
+
+    try:
+        data = stream_resp.json()
+    except ValueError:
+        raise ScraperNetworkError("vidlink", "Non-JSON response from stream API")
+    playlist = data.get("stream", {}).get("playlist")
+    if not playlist:
+        raise ScraperNetworkError("vidlink", "No playlist in stream response")
+
+    return playlist

cinnamon/tmdb.py

@@ -0,0 +1,83 @@
+import time
+
+import requests
+
+from .config import get_tmdb_api_key
+from .errors import (
+    MissingAPIKey,
+    TMDBAuthError,
+    TMDBConnectionError,
+    TMDBError,
+    TMDBRateLimitError,
+    TMDBNotFoundError,
+    TMDBAPIError,
+)
+
+BASE_URL = "https://api.themoviedb.org/3"
+MAX_RETRIES = 3
+RETRY_DELAY = 2
+
+
+class TMDBClient:
+    def __init__(self, api_key=None):
+        self.api_key = api_key or get_tmdb_api_key()
+        if not self.api_key:
+            raise MissingAPIKey()
+
+    def _request(self, path, params=None):
+        params = params or {}
+        params["api_key"] = self.api_key
+        url = f"{BASE_URL}{path}"
+
+        for attempt in range(MAX_RETRIES):
+            try:
+                resp = requests.get(url, params=params, timeout=15)
+
+                if resp.status_code == 429:
+                    retry_after = int(resp.headers.get("Retry-After", RETRY_DELAY))
+                    if attempt < MAX_RETRIES - 1:
+                        time.sleep(retry_after)
+                        continue
+                    raise TMDBRateLimitError(retry_after)
+
+                if resp.status_code == 401:
+                    raise TMDBAuthError()
+                if resp.status_code == 404:
+                    hint = path.strip("/").replace("/", " > ").title()
+                    raise TMDBNotFoundError(hint)
+
+                resp.raise_for_status()
+                return resp.json()
+
+            except TMDBError:
+                raise
+            except requests.ConnectionError as e:
+                if attempt == MAX_RETRIES - 1:
+                    raise TMDBConnectionError(str(e))
+                time.sleep(RETRY_DELAY)
+            except requests.Timeout as e:
+                if attempt == MAX_RETRIES - 1:
+                    raise TMDBConnectionError(f"Request timed out: {e}")
+                time.sleep(RETRY_DELAY)
+            except requests.HTTPError as e:
+                raise TMDBAPIError(resp.status_code, str(e))
+
+    def search_tv(self, query):
+        return self._request("/search/tv", {"query": query})
+
+    def get_tv_details(self, tv_id):
+        return self._request(f"/tv/{tv_id}")
+
+    def get_movie_details(self, movie_id):
+        return self._request(f"/movie/{movie_id}")
+
+    def get_season_details(self, tv_id, season_number):
+        return self._request(f"/tv/{tv_id}/season/{season_number}")
+
+    def get_episode_details(self, tv_id, season_number, episode_number):
+        return self._request(
+            f"/tv/{tv_id}/season/{season_number}/episode/{episode_number}"
+        )
+
+    def search_movie(self, query):
+        return self._request("/search/movie", {"query": query})