cinnamon-cli 0.2.34__tar.gz → 0.2.37__tar.gz

{cinnamon_cli-0.2.34/cinnamon_cli.egg-info → cinnamon_cli-0.2.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinnamon-cli
-Version: 0.2.34
+Version: 0.2.37
 Summary: CLI to search TV shows, movies & anime via TMDB/AniList, scrape m3u8 links, and play in VLC/mpv
 Author: pizza-droid
 License: CC BY-NC 4.0
@@ -47,7 +47,7 @@ pip install cinnamon-cli
 cinnamon setup
 ```
 
-> The setup wizard asks for a TMDB API key ([Create a free account here](https://www.themoviedb.org/signup)), the api key is used for show and movie information.
+> The setup wizard asks for a TMDB API key ([Create a free account here](https://www.themoviedb.org/signup)), the api key is used for show and movie information. If you skip it, `search` & `watch` fall back to an **experimental** 2embed metadata proxy (no key needed) — it works but is less reliable.
 
 
 
@@ -149,6 +149,7 @@ cinnamon search "Breaking Bad" -d -e 1-5
 | `webstream` | TV shows & movies from vixsrc.to and vidlink.pro (HLS) |
 | `anime` | Anime from allanime.day via mp4upload |
 
+
 **Optional (install with `cinnamon install <name>`):**
 
 | Name | Needs |
@@ -177,6 +178,8 @@ cinnamon config set-api-key YOUR_KEY
 
 ## Notes
 
+**Experimental 2embed metadata proxy:** When no TMDB API key is configured, `search` and `watch` fall back to `api.2embed.cc` (no key needed). This works for most popular shows/movies but may be slower, less reliable, or return incomplete results. We reccomend getting a TMDB key for a more reliable experience
+
 This project is mostly vibe coded and our lazy ass didnt even write more than 300 lines.
 feel free to give us feedback so we can improve this project and make it as good as possible.
 

{cinnamon_cli-0.2.34 → cinnamon_cli-0.2.37}/README.md

@@ -18,7 +18,7 @@ pip install cinnamon-cli
 cinnamon setup
 ```
 
-> The setup wizard asks for a TMDB API key ([Create a free account here](https://www.themoviedb.org/signup)), the api key is used for show and movie information.
+> The setup wizard asks for a TMDB API key ([Create a free account here](https://www.themoviedb.org/signup)), the api key is used for show and movie information. If you skip it, `search` & `watch` fall back to an **experimental** 2embed metadata proxy (no key needed) — it works but is less reliable.
 
 
 
@@ -120,6 +120,7 @@ cinnamon search "Breaking Bad" -d -e 1-5
 | `webstream` | TV shows & movies from vixsrc.to and vidlink.pro (HLS) |
 | `anime` | Anime from allanime.day via mp4upload |
 
+
 **Optional (install with `cinnamon install <name>`):**
 
 | Name | Needs |
@@ -148,6 +149,8 @@ cinnamon config set-api-key YOUR_KEY
 
 ## Notes
 
+**Experimental 2embed metadata proxy:** When no TMDB API key is configured, `search` and `watch` fall back to `api.2embed.cc` (no key needed). This works for most popular shows/movies but may be slower, less reliable, or return incomplete results. We reccomend getting a TMDB key for a more reliable experience
+
 This project is mostly vibe coded and our lazy ass didnt even write more than 300 lines.
 feel free to give us feedback so we can improve this project and make it as good as possible.
 

cinnamon_cli-0.2.37/cinnamon/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.37"

cinnamon_cli-0.2.37/cinnamon/anilist.py

@@ -0,0 +1,92 @@
+import requests
+
+from .errors import CinnamonError
+
+API = "https://graphql.anilist.co"
+UA = "cinnamon/0.1.0"
+
+_SEARCH_QUERY = """
+query ($search: String, $page: Int) {
+  Page(page: $page, perPage: 20) {
+    media(search: $search, type: ANIME) {
+      id
+      idMal
+      title { romaji english native }
+      episodes
+      status
+      format
+      startDate { year }
+      genres
+    }
+  }
+}
+"""
+
+
+_RELATION_QUERY = """
+query ($search: String) {
+  Page(page: 1, perPage: 5) {
+    media(search: $search, type: ANIME) {
+      id
+      title { romaji english }
+      relations {
+        edges {
+          relationType
+          node {
+            id
+            title { romaji english }
+            episodes
+            status
+            format
+          }
+        }
+      }
+    }
+  }
+}
+"""
+
+
+def search_anime(query):
+    try:
+        resp = requests.post(
+            API,
+            json={"query": _SEARCH_QUERY, "variables": {"search": query, "page": 1}},
+            timeout=15,
+            headers={"User-Agent": UA, "Content-Type": "application/json", "Accept": "application/json"},
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        return data.get("data", {}).get("Page", {}).get("media", [])
+    except requests.ConnectionError:
+        raise CinnamonError("Could not reach AniList. Check your internet connection.")
+    except requests.Timeout:
+        raise CinnamonError("AniList request timed out.")
+    except requests.HTTPError as e:
+        raise CinnamonError(f"AniList returned an error (HTTP {e.response.status_code}).")
+
+
+def find_sequel(anime_name):
+    """Search AniList for an anime and return its first SEQUEL relation, or None."""
+    try:
+        resp = requests.post(
+            API,
+            json={"query": _RELATION_QUERY, "variables": {"search": anime_name}},
+            timeout=15,
+            headers={"User-Agent": UA, "Content-Type": "application/json", "Accept": "application/json"},
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        media_list = data.get("data", {}).get("Page", {}).get("media", [])
+        for m in media_list:
+            edges = m.get("relations", {}).get("edges", [])
+            for e in edges:
+                if e.get("relationType") == "SEQUEL":
+                    node = e.get("node", {})
+                    title = node.get("title", {})
+                    name = title.get("romaji") or title.get("english") or ""
+                    if name:
+                        return {"id": node["id"], "name": name}
+        return None
+    except (requests.RequestException, CinnamonError):
+        return None

{cinnamon_cli-0.2.34 → cinnamon_cli-0.2.37}/cinnamon/cli.py

@@ -27,6 +27,7 @@ from .config import (
 from .errors import (
     CinnamonError,
     MissingAPIKey,
+    PlayerError,
     PlayerLaunchError,
     PlayerNotFoundError,
     ScraperError,
@@ -38,6 +39,7 @@ from .errors import (
 )
 from .player import download_video, play, ytdlp_install_hint
 from .scrapers import get_scraper, list_scrapers
+from .embedapi import EmbedClient
 from .tmdb import TMDBClient
 
 console = Console()
@@ -245,14 +247,10 @@ def _get_tmdb():
     try:
         return TMDBClient()
     except MissingAPIKey:
-        _print_error(
-            "TMDB API key not configured.",
-            'Run "cinnamon setup" for a step-by-step guide to get a free key.',
-        )
-        raise SystemExit(1)
+        return EmbedClient()
 
 
-def _handle_tmdb_error(fn):
+def _handle_errors(fn):
     @wraps(fn)
     def wrapper(*a, **kw):
         try:
@@ -267,8 +265,12 @@ def _handle_tmdb_error(fn):
             _print_error(str(e))
         except TMDBError as e:
             _print_error(str(e))
+        except (ScraperError, PlayerError) as e:
+            _print_error(str(e))
         except MissingAPIKey:
             _get_tmdb()
+        except Exception as e:
+            _print_error("Something went wrong.", str(e)[:500])
 
     return wrapper
 
@@ -452,17 +454,19 @@ def _play_with_menu(show, season_num, ep_start, ep_end, ep_name, scraper, player
         theme = get_theme()
         console.print()
 
+        choices = [
+            questionary.Choice(title="Next episode", value="next"),
+            questionary.Choice(title="Previous episode", value="prev"),
+            questionary.Choice(title="Replay", value="replay"),
+        ]
+        if scraper == "anime":
+            choices.append(questionary.Choice(title="Next season \u2192", value="next_season"))
+        choices += [
+            questionary.Choice(title="Change quality", value="quality"),
+            questionary.Choice(title="Quit", value="quit"),
+        ]
         try:
-            choice = _select(
-                "Options",
-                choices=[
-                    questionary.Choice(title="Next episode", value="next"),
-                    questionary.Choice(title="Previous episode", value="prev"),
-                    questionary.Choice(title="Replay", value="replay"),
-                    questionary.Choice(title="Change quality", value="quality"),
-                    questionary.Choice(title="Quit", value="quit"),
-                ],
-            )
+            choice = _select("Options", choices=choices)
         except Exception:
             return
 
@@ -476,6 +480,29 @@ def _play_with_menu(show, season_num, ep_start, ep_end, ep_name, scraper, player
             ep_name = f"S{season_num:02d}E{ep_num:02d}"
         elif choice == "replay":
             pass
+        elif choice == "next_season":
+            try:
+                from .anilist import find_sequel as _find_sequel
+                sequel = _find_sequel(show.get("name", ""))
+                if not sequel:
+                    _print_error("No next season found on AniList.")
+                    continue
+                from .scrapers.anime import _find_show as _aa_find, _allanime_episodes as _aa_eps
+                import requests as _req
+                _as = _req.Session()
+                _as.headers.update({"User-Agent": "Mozilla/5.0"})
+                _aid = _aa_find(_as, sequel["name"])
+                if not _aid:
+                    _print_error(f"No match for \"{sequel['name']}\" on allanime.")
+                    continue
+                _ed = _aa_eps(_as, _aid)
+                if not _ed:
+                    _print_error("No episode data from allanime.")
+                    continue
+                _run_anime_flow(sequel["name"], _ed, player=player, quality=quality, info_only=info_only, download=download)
+                return
+            except Exception as _e:
+                _print_error("Failed to load next season.", str(_e))
         elif choice == "quality":
             try:
                 quality = _select(
@@ -605,7 +632,7 @@ def _resolve_and_play(show, season_num, ep_num, ep_name, scraper, player, qualit
             return None  # magnets: can't wait for process
         else:
             console.print(f"  [{theme['info']}]Opening in {player_choice.upper()}...[/{theme['info']}]")
-            return play(result.m3u8_url, title=result.title, player=player_choice, season=season_num, episode=ep_num, referer=result.referer)
+            return play(result.m3u8_url, title=result.title, player=player_choice, season=season_num, episode=ep_num, referer=result.referer, subtitle_url=result.subtitle_url)
     except PlayerNotFoundError as e:
         _print_error(str(e))
         return None
@@ -718,7 +745,8 @@ def cli(ctx, setup):
                 border_style="bright_yellow",
             ))
             console.print()
-            if Confirm.ask("No API key found. Run setup?", default=True):
+            console.print("  [dim]Search & watch will use an experimental proxy (no key needed).[/dim]")
+            if Confirm.ask("Add a TMDB API key for better results?", default=False):
                 ctx.invoke(setup_cmd)
                 return
         theme = get_theme()
@@ -764,7 +792,12 @@ def _setup_wizard():
         else:
             api_key = _setup_api_key()
     else:
-        api_key = _setup_api_key()
+        console.print("  No TMDB API key found.")
+        console.print("  [dim]Without it, search & watch use an experimental 2embed proxy (less reliable).[/dim]")
+        if Confirm.ask("  Add a TMDB API key now?", default=True):
+            api_key = _setup_api_key()
+        else:
+            api_key = None
 
     if api_key and api_key != existing_key:
         cfg["tmdb_api_key"] = api_key
@@ -843,7 +876,7 @@ def _setup_api_key():
         webbrowser.open("https://www.themoviedb.org/signup")
 
     console.print()
-    api_key = Prompt.ask("[bold]Paste your TMDB API Key[/bold]")
+    api_key = Prompt.ask("[bold]Paste your TMDB API Key[/bold] [dim](leave empty to skip)[/dim]")
     if not api_key.strip():
         return None
 
@@ -880,7 +913,7 @@ def _theme_preview(name):
 @click.option("-q", "--quality", help="Video quality: 480p, 720p, 1080p, best, worst")
 @click.option("-d", "--download", is_flag=True, help="Download instead of streaming")
 @click.option("--info-only", is_flag=True, help="Show the m3u8 URL without playing")
-@_handle_tmdb_error
+@_handle_errors
 def search(query, media_type, season, ep_str, scraper, player, quality, download, info_only):
     """Search for a show or movie, pick one, and watch it."""
     _check_for_updates()
@@ -965,7 +998,7 @@ def search(query, media_type, season, ep_str, scraper, player, quality, download
 @click.option("-d", "--download", is_flag=True, help="Download instead of streaming")
 @click.option("--info-only", is_flag=True, help="Show the m3u8 URL without playing")
 @click.option("-q", "--quality", help="Video quality: 480p, 720p, 1080p, best, worst")
-@_handle_tmdb_error
+@_handle_errors
 def watch(query, tmdb_id, media_type, season, ep_str, scraper, player, download, info_only, quality):
     """Browse episodes interactively and play one."""
     _check_for_updates()
@@ -983,7 +1016,7 @@ def watch(query, tmdb_id, media_type, season, ep_str, scraper, player, download,
         if season is not None and ep_start is not None:
             _play_with_menu(show, season, ep_start, ep_end, f"E{ep_start}", scraper, player, quality, info_only, download)
         else:
-            _interactive_episode_picker(None, show, scraper, player, quality, info_only, ep_start=ep_start, ep_end=ep_end)
+            _interactive_episode_picker(_get_tmdb(), show, scraper, player, quality, info_only, ep_start=ep_start, ep_end=ep_end)
         return
 
     tmdb = _get_tmdb()
@@ -1185,6 +1218,7 @@ def _interactive_episode_picker(tmdb, show, scraper, player, quality, info_only,
 @click.argument("url")
 @click.option("--player", help="Player: vlc, mpv, or auto")
 @click.option("--title", default="", help="Media title")
+@_handle_errors
 def play_url(url, player, title):
     """Play a direct m3u8 URL in VLC or mpv."""
     config = load_config()
@@ -1205,7 +1239,7 @@ def play_url(url, player, title):
 
 
 @cli.command()
-@_handle_tmdb_error
+@_handle_errors
 def resume():
     """List interrupted downloads and resume one."""
     from .downloads import get, list_all, update as _track_update
@@ -1474,6 +1508,7 @@ def config_scraper_show(name):
 
 
 @cli.command()
+@_handle_errors
 def scrapers():
     """List available scrapers."""
     all_scrapers = list_scrapers()
@@ -1507,6 +1542,7 @@ def scrapers():
 
 @cli.command()
 @click.argument("name")
+@_handle_errors
 def install(name):
     """Install an optional scraper (vidsrc, torrentio)."""
     from .scrapers import _OPTIONAL_SCRAPERS, install_optional
@@ -1533,6 +1569,7 @@ def install(name):
 @click.option("--info-only", is_flag=True, help="Show the stream URL without playing")
 @click.option("--sub", "prefer_sub", is_flag=True, help="Prefer subtitled audio")
 @click.option("--dub", "prefer_dub", is_flag=True, help="Prefer dubbed audio")
+@_handle_errors
 def anime(query, season, ep_str, download, player, quality, info_only, prefer_sub, prefer_dub):
     """Search anime via AniList (no API key needed) and stream from allanime."""
     _check_for_updates()
@@ -1548,7 +1585,7 @@ def anime(query, season, ep_str, download, player, quality, info_only, prefer_su
         return
 
     def _title(m):
-        return m.get("title", {}).get("romaji") or m.get("title", {}).get("english") or m.get("title", {}).get("native", "?")
+        return m.get("title", {}).get("english") or m.get("title", {}).get("romaji") or m.get("title", {}).get("native", "?")
     def _year(m):
         sd = m.get("startDate") or {}
         return str(sd.get("year", "")) if sd.get("year") else ""
@@ -1650,7 +1687,11 @@ def _run_anime_flow(show_name, episodes_detail, season=None, ep_str=None, player
         _print_error(f"No episodes for season {season}.")
         return
 
-    tt_keys = list(season_data.keys())
+    tt_keys = [k for k in season_data if season_data[k]]
+    if not tt_keys:
+        _print_error(f"No episodes available for season {season}.")
+        return
+
     if translation and translation in tt_keys:
         tt = translation
     elif "sub" in tt_keys and len(tt_keys) > 1:
@@ -1765,6 +1806,7 @@ def update():
 @cli.command()
 @click.argument("query", nargs=-1, required=False)
 @click.option("--clear", is_flag=True, help="Clear all watch history")
+@_handle_errors
 def history(query, clear):
     """Show watch history and resume from last episode."""
     from .history import clear_history, get_history, list_history

cinnamon_cli-0.2.37/cinnamon/embedapi.py

@@ -0,0 +1,198 @@
+import time
+
+import requests
+
+from .errors import (
+    TMDBConnectionError,
+    TMDBError,
+    TMDBNotFoundError,
+    TMDBAPIError,
+)
+
+BASE_URL = "https://api.2embed.cc"
+MAX_RETRIES = 3
+RETRY_DELAY = 2
+
+_COUNTRY_FULL_TO_CODE = {
+    "Japan": "JP",
+    "United States of America": "US",
+    "United States": "US",
+    "South Korea": "KR",
+    "China": "CN",
+    "United Kingdom": "GB",
+    "France": "FR",
+    "Germany": "DE",
+    "Italy": "IT",
+    "Spain": "ES",
+    "Canada": "CA",
+    "Australia": "AU",
+    "India": "IN",
+    "Brazil": "BR",
+    "Mexico": "MX",
+    "Russia": "RU",
+    "Taiwan": "TW",
+    "Hong Kong": "HK",
+    "Thailand": "TH",
+    "Philippines": "PH",
+    "Indonesia": "ID",
+    "Malaysia": "MY",
+    "Vietnam": "VN",
+    "Sweden": "SE",
+    "Norway": "NO",
+    "Denmark": "DK",
+    "Finland": "FI",
+    "Netherlands": "NL",
+    "Belgium": "BE",
+    "Switzerland": "CH",
+    "Austria": "AT",
+    "Poland": "PL",
+    "Turkey": "TR",
+    "Argentina": "AR",
+    "Chile": "CL",
+    "Colombia": "CO",
+    "New Zealand": "NZ",
+    "Ireland": "IE",
+    "Portugal": "PT",
+    "Czech Republic": "CZ",
+}
+
+_LANG_FULL_TO_CODE = {
+    "Japanese": "ja",
+    "English": "en",
+    "Korean": "ko",
+    "Chinese": "zh",
+    "French": "fr",
+    "German": "de",
+    "Italian": "it",
+    "Spanish": "es",
+    "Portuguese": "pt",
+    "Russian": "ru",
+    "Arabic": "ar",
+    "Hindi": "hi",
+    "Bengali": "bn",
+    "Turkish": "tr",
+    "Dutch": "nl",
+    "Polish": "pl",
+    "Swedish": "sv",
+    "Danish": "da",
+    "Finnish": "fi",
+    "Norwegian": "no",
+    "Czech": "cs",
+    "Thai": "th",
+    "Vietnamese": "vi",
+    "Indonesian": "id",
+    "Malay": "ms",
+    "Tagalog": "tl",
+    "Romanian": "ro",
+    "Hungarian": "hu",
+    "Greek": "el",
+    "Hebrew": "he",
+}
+
+
+def _normalize_country(val):
+    if isinstance(val, list):
+        return [_COUNTRY_FULL_TO_CODE.get(c, c) for c in val]
+    if isinstance(val, str):
+        return _COUNTRY_FULL_TO_CODE.get(val, val)
+    return val
+
+
+def _normalize_language(val):
+    return _LANG_FULL_TO_CODE.get(val, val)
+
+
+def _normalize_search_result(item, media_type="tv"):
+    item["_media_type"] = media_type
+    if media_type == "tv":
+        item["id"] = item.get("tmdb_id")
+        item["_media_type"] = "tv"
+    else:
+        item["id"] = item.get("tmdb_id")
+        item["_media_type"] = "movie"
+    if "origin_country" in item:
+        item["origin_country"] = _normalize_country(item["origin_country"])
+    if "original_language" in item:
+        item["original_language"] = _normalize_language(item["original_language"])
+    return item
+
+
+class EmbedClient:
+    def __init__(self, api_key=None):
+        pass
+
+    def _request(self, path, params=None):
+        params = params or {}
+        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 TMDBError(f"2embed rate limit hit. Retry in {retry_after}s.", status_code=429)
+
+                if resp.status_code == 404:
+                    hint = path.strip("/").replace("/", " > ").title()
+                    raise TMDBNotFoundError(hint)
+
+                if resp.status_code == 400:
+                    body = resp.text[:200]
+                    raise TMDBNotFoundError(f"2embed: {body}")
+
+                resp.raise_for_status()
+                return resp.json()
+
+            except (TMDBError, TMDBNotFoundError):
+                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):
+        data = self._request("/searchtv", {"q": query, "page": 1})
+        results = [_normalize_search_result(r, "tv") for r in data.get("results", [])]
+        return {"results": results}
+
+    def search_movie(self, query):
+        data = self._request("/search", {"q": query, "page": 1})
+        results = [_normalize_search_result(r, "movie") for r in data.get("results", [])]
+        return {"results": results}
+
+    def get_tv_details(self, tv_id):
+        data = self._request("/tv", {"tmdb_id": tv_id})
+        if "origin_country" in data:
+            data["origin_country"] = _normalize_country(data["origin_country"])
+        if "original_language" in data:
+            data["original_language"] = _normalize_language(data["original_language"])
+        seasons = data.get("seasons", [])
+        real_seasons = [s for s in seasons if s.get("season_number", 0) > 0]
+        data["number_of_seasons"] = len(real_seasons)
+        return data
+
+    def get_season_details(self, tv_id, season_number):
+        return self._request("/season", {"tmdb_id": tv_id, "season": season_number})
+
+    def get_episode_details(self, tv_id, season_number, episode_number):
+        season_data = self.get_season_details(tv_id, season_number)
+        for ep in season_data.get("episodes", []):
+            if ep.get("episode_number") == episode_number:
+                return ep
+        raise TMDBNotFoundError(f"Episode S{season_number}E{episode_number}")
+
+    def get_movie_details(self, movie_id):
+        data = self._request("/movie", {"tmdb_id": movie_id})
+        if "original_language" in data:
+            data["original_language"] = _normalize_language(data["original_language"])
+        return data

{cinnamon_cli-0.2.34 → cinnamon_cli-0.2.37}/cinnamon/player.py

@@ -3,6 +3,7 @@ import os
 import shutil
 import subprocess
 import sys
+import tempfile
 import time
 
 from .errors import PlayerNotFoundError, PlayerLaunchError
@@ -142,7 +143,7 @@ def ytdlp_install_hint():
         return "brew install yt-dlp"
     if _platform_os() == "termux":
         return "pkg install yt-dlp"
-    return "pip install yt-dlp"
+    return "python -m pip install yt-dlp"
 
 
 def _termux_ensure_mpv_conf():
@@ -318,21 +319,39 @@ def play_vlc(url, title="", referer=None):
     return _launch("VLC", cmd)
 
 
-def play_mpv(url, title="", referer=None):
+def play_mpv(url, title="", referer=None, subtitle_url=None):
     exe = _mpv_path()
     if not exe:
         raise PlayerNotFoundError("mpv")
     if _in_termux():
         return _termux_open(url, "mpv", referer=referer, user_agent=DEFAULT_UA)
-    cmd = [exe, f"--title={title}", "--alang=eng", "--slang=eng", "--subs-with-matching-audio=yes",
+    cmd = [exe, f"--title={title}", "--alang=eng",
            "--cache=yes", "--cache-secs=300", "--ytdl=no",
            "--network-timeout=20", "--keep-open=no"]
     if referer:
         cmd += ["--http-header-fields=Referer: " + referer]
+    if subtitle_url:
+        sub_path = _download_subtitle(subtitle_url)
+        cmd += [f"--sub-file={sub_path}"]
+    else:
+        cmd += ["--slang=eng", "--subs-with-matching-audio=yes"]
     cmd.append(url)
     return _launch("mpv", cmd)
 
 
+def _download_subtitle(url):
+    import requests
+    fd, path = tempfile.mkstemp(suffix=".srt", prefix="cinnamon_sub_")
+    r = requests.get(url, timeout=15, headers={"User-Agent": DEFAULT_UA})
+    r.raise_for_status()
+    content = r.text
+    if content.startswith("\ufeff"):
+        content = content[1:]
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
+        f.write(content)
+    return path
+
+
 def _streamer_path():
     return os.path.join(os.path.dirname(__file__), "webtorrent_stream.mjs")
 
@@ -545,7 +564,7 @@ def download_video(url, title="", referer=None, output_dir=".", track_id=None):
         raise
 
 
-def play(url, title="", player="auto", season=None, episode=None, referer=None):
+def play(url, title="", player="auto", season=None, episode=None, referer=None, subtitle_url=None):
     if url.startswith("magnet:"):
         return _play_magnet(url, title, player, season, episode)
     if player == "auto":
@@ -553,7 +572,7 @@ def play(url, title="", player="auto", season=None, episode=None, referer=None):
         vlc = _vlc_path()
         if mpv:
             try:
-                return play_mpv(url, title, referer)
+                return play_mpv(url, title, referer, subtitle_url)
             except PlayerLaunchError:
                 if not vlc:
                     raise
@@ -563,5 +582,5 @@ def play(url, title="", player="auto", season=None, episode=None, referer=None):
     if player == "vlc":
         return play_vlc(url, title, referer)
     if player == "mpv":
-        return play_mpv(url, title, referer)
+        return play_mpv(url, title, referer, subtitle_url)
     raise ValueError(f"Unknown player: {player}. Use vlc, mpv, or auto.")

{cinnamon_cli-0.2.34 → cinnamon_cli-0.2.37}/cinnamon/scrapers/__init__.py

@@ -8,7 +8,6 @@ from pathlib import Path
 from .base import BaseScraper
 from .webstream import WebStreamScraper
 from .anime import AnimeScraper
-
 _BUILTIN_SCRAPERS = [WebStreamScraper, AnimeScraper]
 
 _OPTIONAL_SCRAPERS = {

{cinnamon_cli-0.2.34 → cinnamon_cli-0.2.37}/cinnamon/scrapers/anime.py

@@ -299,7 +299,20 @@ def _find_show(session, name):
         rn = r.get("name", "").lower().strip()
         if q in rn or rn in q:
             return r["_id"]
-    return results[0]["_id"]
+
+    q_words = frozenset(w for w in re.split(r"[^\w]+", q) if len(w) > 2)
+    scored = []
+    for r in results:
+        rn = r.get("name", "").lower().strip()
+        r_words = set(re.split(r"[^\w]+", rn))
+        overlap = len(q_words & r_words)
+        all_match = q_words <= r_words
+        has_suffix = bool(re.search(r"\b(?:part|season|special|cour|ova|movie|film)\s*\d*\b", rn))
+        extra_words = len(r_words - q_words)
+        name_len = len(rn)
+        scored.append((overlap, all_match, 0 if has_suffix else 1, extra_words, name_len, r["_id"]))
+    scored.sort(key=lambda x: (-x[0], -x[1], -x[2], x[3], x[4]))
+    return scored[0][5]
 
 def _extract_mp4upload(session, embed_url):
     resp = session.get(embed_url, timeout=TIMEOUT)

{cinnamon_cli-0.2.34 → cinnamon_cli-0.2.37}/cinnamon/scrapers/base.py

@@ -10,6 +10,7 @@ class ScraperResult:
     referer: Optional[str] = None
     user_agent: Optional[str] = None
     headers: dict = field(default_factory=dict)
+    subtitle_url: Optional[str] = None
 
     def __post_init__(self):
         if not self.title:

{cinnamon_cli-0.2.34 → cinnamon_cli-0.2.37}/cinnamon/scrapers/vidsrc.py

@@ -84,7 +84,7 @@ async def _async_resolve(embed_url: str, timeout: int = 30) -> Optional[str]:
     except ImportError:
         raise ScraperNetworkError(
             "vidsrc",
-            "Playwright is required for the vidsrc scraper. Install it with: pip install playwright && python -m playwright install chromium"
+            "Playwright is required for the vidsrc scraper. Install it with: python -m pip install playwright && python -m playwright install chromium"
         )
 
     found_urls = []

{cinnamon_cli-0.2.34 → cinnamon_cli-0.2.37}/cinnamon/scrapers/webstream.py

@@ -1,6 +1,6 @@
 import re
 import time as _time
-from typing import Optional
+from typing import Optional, Tuple
 
 import requests
 
@@ -28,6 +28,9 @@ def _verify_playlist(session, master_url, source):
 
 
 
+
+
+
 class WebStreamScraper(BaseScraper):
     name = "webstream"
     description = "HTTP streams from vixsrc.to and vidlink.pro (no browser needed)"
@@ -53,17 +56,15 @@ class WebStreamScraper(BaseScraper):
 
         if media_type == "movie":
             vixsrc_ref = f"https://vixsrc.to/embed/movie/{tmdb_id}"
+            vixsrc_url = None
+            vidlink_url = None
+            sub_url = None
+
             if _time.time() < deadline:
                 try:
-                    result = _try_vixsrc_movie(tmdb_id, quality)
-                    if result:
-                        label = quality.upper() if quality else "Auto"
-                        return ScraperResult(
-                            title=f"{show} ({label})",
-                            m3u8_url=result,
-                            referer=vixsrc_ref,
-                            user_agent=UA,
-                        )
+                    res = _try_vixsrc_movie(tmdb_id, quality)
+                    if res:
+                        vixsrc_url, _ = res
                 except ScraperNetworkError:
                     pass
 
@@ -71,55 +72,79 @@ class WebStreamScraper(BaseScraper):
                 try:
                     result = _try_vidlink_movie(tmdb_id, quality)
                     if result:
-                        label = quality.upper() if quality else "Auto"
-                        return ScraperResult(
-                            title=f"{show} ({label})",
-                            m3u8_url=result,
-                            referer="https://vidlink.pro/",
-                            user_agent=UA,
-                        )
+                        vidlink_url, sub_url = result
                 except ScraperNetworkError:
                     pass
 
+            if vixsrc_url:
+                label = quality.upper() if quality else "Auto"
+                return ScraperResult(
+                    title=f"{show} ({label})",
+                    m3u8_url=vixsrc_url,
+                    referer=vixsrc_ref,
+                    user_agent=UA,
+                    subtitle_url=sub_url,
+                )
+
+            if vidlink_url:
+                label = quality.upper() if quality else "Auto"
+                return ScraperResult(
+                    title=f"{show} ({label})",
+                    m3u8_url=vidlink_url,
+                    referer="https://vidlink.pro/",
+                    user_agent=UA,
+                    subtitle_url=sub_url,
+                )
+
             raise ScraperNoStreamError(self.name, f"No HTTP stream found for {show}")
 
         # TV
         vixsrc_ref = f"https://vixsrc.to/embed/tv/{tmdb_id}/{season}/{episode}"
+        vixsrc_url = None
+        vixsrc_has_subs = False
+        vidlink_url = None
+        sub_url = None
+
         if _time.time() < deadline:
             try:
-                result = _try_vixsrc(tmdb_id, season, episode, quality)
-                if result:
-                    label = quality.upper() if quality else "Auto"
-                    return ScraperResult(
-                        title=f"{show} S{season:02d}E{episode:02d} ({label})",
-                        m3u8_url=result,
-                        referer=vixsrc_ref,
-                        user_agent=UA,
-                    )
+                res = _try_vixsrc(tmdb_id, season, episode, quality)
+                if res:
+                    vixsrc_url, vixsrc_has_subs = res
             except ScraperNetworkError:
                 pass
 
-        if _time.time() < deadline:
+        if not vixsrc_has_subs and _time.time() < deadline:
             try:
                 result = _try_vidlink(tmdb_id, season, episode, quality)
                 if result:
-                    label = quality.upper() if quality else "Auto"
-                    return ScraperResult(
-                        title=f"{show} S{season:02d}E{episode:02d} ({label})",
-                        m3u8_url=result,
-                        referer="https://vidlink.pro/",
-                        user_agent=UA,
-                    )
+                    vidlink_url, sub_url = result
             except ScraperNetworkError:
                 pass
 
-        raise ScraperNoStreamError(self.name,
-            f"No HTTP stream found for {show} S{season:02d}E{episode:02d}")
+        if vixsrc_url:
+            label = quality.upper() if quality else "Auto"
+            return ScraperResult(
+                title=f"{show} S{season:02d}E{episode:02d} ({label})",
+                m3u8_url=vixsrc_url,
+                referer=vixsrc_ref,
+                user_agent=UA,
+                subtitle_url=sub_url,
+            )
+
+        if vidlink_url:
+            label = quality.upper() if quality else "Auto"
+            return ScraperResult(
+                title=f"{show} S{season:02d}E{episode:02d} ({label})",
+                m3u8_url=vidlink_url,
+                referer="https://vidlink.pro/",
+                user_agent=UA,
+                subtitle_url=sub_url,
+            )
 
 
 _QUALITY_RENDITIONS = {"480p": "480p", "720p": "720p", "1080p": "1080p", "best": "", "worst": "worst"}
 
-def _try_vixsrc(tmdb_id, season, episode, quality="") -> Optional[str]:
+def _try_vixsrc(tmdb_id, season, episode, quality="") -> Optional[Tuple[str, bool]]:
     session = requests.Session()
     session.headers.update({"User-Agent": UA})
 
@@ -156,19 +181,19 @@ def _try_vixsrc(tmdb_id, season, episode, quality="") -> Optional[str]:
     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'
 
+    master_resp = _verify_playlist(session, master_url, "vixsrc")
+    has_subs = "#EXT-X-MEDIA:TYPE=SUBTITLES" in master_resp.text
+
     if not quality:
-        _verify_playlist(session, master_url, "vixsrc")
-        return master_url
+        return (master_url, has_subs)
 
     # Parse master playlist and filter by quality
-    master_resp = _verify_playlist(session, master_url, "vixsrc")
-
     variants = re.findall(
         r'#EXT-X-STREAM-INF:.*?RESOLUTION=\d+x(\d+).*?\n(https?://\S+)',
         master_resp.text,
     )
     if not variants:
-        return master_url
+        return (master_url, has_subs)
 
     target = quality.replace("p", "")
     if quality == "best":
@@ -179,7 +204,19 @@ def _try_vixsrc(tmdb_id, season, episode, quality="") -> Optional[str]:
         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]
+    return (match[1], has_subs)
+
+
+def _vidlink_subtitle_url(data):
+    captions = data.get("stream", {}).get("captions", [])
+    eng = None
+    for cap in captions:
+        lang = (cap.get("language", "") or cap.get("lang", "")).strip().lower()
+        if lang in ("eng", "en", "english"):
+            return cap.get("url")
+        if not eng and lang:
+            eng = cap
+    return eng["url"] if eng else (captions[0]["url"] if captions else None)
 
 
 def _vidlink_quality_url(data, quality=""):
@@ -198,7 +235,7 @@ def _vidlink_quality_url(data, quality=""):
     return qualities[res]["url"]
 
 
-def _try_vidlink(tmdb_id, season, episode, quality="") -> Optional[str]:
+def _try_vidlink(tmdb_id, season, episode, quality="") -> Optional[tuple[str, Optional[str]]]:
     session = requests.Session()
     session.headers.update({"User-Agent": UA})
 
@@ -226,10 +263,13 @@ def _try_vidlink(tmdb_id, season, episode, quality="") -> Optional[str]:
         data = stream_resp.json()
     except ValueError:
         raise ScraperNetworkError("vidlink", "Non-JSON response from stream API")
-    return _vidlink_quality_url(data, quality)
+
+    url = _vidlink_quality_url(data, quality)
+    sub_url = _vidlink_subtitle_url(data)
+    return (url, sub_url)
 
 
-def _try_vixsrc_movie(tmdb_id, quality="") -> Optional[str]:
+def _try_vixsrc_movie(tmdb_id, quality="") -> Optional[Tuple[str, bool]]:
     session = requests.Session()
     session.headers.update({"User-Agent": UA})
 
@@ -266,18 +306,18 @@ def _try_vixsrc_movie(tmdb_id, quality="") -> Optional[str]:
     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:
-        _verify_playlist(session, master_url, "vixsrc")
-        return master_url
-
     master_resp = _verify_playlist(session, master_url, "vixsrc")
+    has_subs = "#EXT-X-MEDIA:TYPE=SUBTITLES" in master_resp.text
+
+    if not quality:
+        return (master_url, has_subs)
 
     variants = re.findall(
         r'#EXT-X-STREAM-INF:.*?RESOLUTION=\d+x(\d+).*?\n(https?://\S+)',
         master_resp.text,
     )
     if not variants:
-        return master_url
+        return (master_url, has_subs)
 
     target = quality.replace("p", "")
     if quality == "best":
@@ -288,10 +328,10 @@ def _try_vixsrc_movie(tmdb_id, quality="") -> Optional[str]:
         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]
+    return (match[1], has_subs)
 
 
-def _try_vidlink_movie(tmdb_id, quality="") -> Optional[str]:
+def _try_vidlink_movie(tmdb_id, quality="") -> Optional[Tuple[str, Optional[str]]]:
     session = requests.Session()
     session.headers.update({"User-Agent": UA})
 
@@ -319,4 +359,7 @@ def _try_vidlink_movie(tmdb_id, quality="") -> Optional[str]:
         data = stream_resp.json()
     except ValueError:
         raise ScraperNetworkError("vidlink", "Non-JSON response from stream API")
-    return _vidlink_quality_url(data, quality)
+
+    url = _vidlink_quality_url(data, quality)
+    sub_url = _vidlink_subtitle_url(data)
+    return (url, sub_url)

{cinnamon_cli-0.2.34 → cinnamon_cli-0.2.37/cinnamon_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinnamon-cli
-Version: 0.2.34
+Version: 0.2.37
 Summary: CLI to search TV shows, movies & anime via TMDB/AniList, scrape m3u8 links, and play in VLC/mpv
 Author: pizza-droid
 License: CC BY-NC 4.0
@@ -47,7 +47,7 @@ pip install cinnamon-cli
 cinnamon setup
 ```
 
-> The setup wizard asks for a TMDB API key ([Create a free account here](https://www.themoviedb.org/signup)), the api key is used for show and movie information.
+> The setup wizard asks for a TMDB API key ([Create a free account here](https://www.themoviedb.org/signup)), the api key is used for show and movie information. If you skip it, `search` & `watch` fall back to an **experimental** 2embed metadata proxy (no key needed) — it works but is less reliable.
 
 
 
@@ -149,6 +149,7 @@ cinnamon search "Breaking Bad" -d -e 1-5
 | `webstream` | TV shows & movies from vixsrc.to and vidlink.pro (HLS) |
 | `anime` | Anime from allanime.day via mp4upload |
 
+
 **Optional (install with `cinnamon install <name>`):**
 
 | Name | Needs |
@@ -177,6 +178,8 @@ cinnamon config set-api-key YOUR_KEY
 
 ## Notes
 
+**Experimental 2embed metadata proxy:** When no TMDB API key is configured, `search` and `watch` fall back to `api.2embed.cc` (no key needed). This works for most popular shows/movies but may be slower, less reliable, or return incomplete results. We reccomend getting a TMDB key for a more reliable experience
+
 This project is mostly vibe coded and our lazy ass didnt even write more than 300 lines.
 feel free to give us feedback so we can improve this project and make it as good as possible.
 

{cinnamon_cli-0.2.34 → cinnamon_cli-0.2.37}/cinnamon_cli.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ cinnamon/anilist.py
 cinnamon/cli.py
 cinnamon/config.py
 cinnamon/downloads.py
+cinnamon/embedapi.py
 cinnamon/errors.py
 cinnamon/history.py
 cinnamon/player.py

{cinnamon_cli-0.2.34 → cinnamon_cli-0.2.37}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cinnamon-cli"
-version = "0.2.34"
+version = "0.2.37"
 description = "CLI to search TV shows, movies & anime via TMDB/AniList, scrape m3u8 links, and play in VLC/mpv"
 license = { text = "CC BY-NC 4.0" }
 readme = "README.md"

{cinnamon_cli-0.2.34 → cinnamon_cli-0.2.37}/tests/test_ui_smoke.py

@@ -73,7 +73,7 @@ def _install_fakes():
     c.list_scrapers = lambda: [{"name": "webstream", "description": "fake", "builtin": True}]
     c.play = lambda *a, **k: _Proc()
     c.download_video = lambda *a, **k: None
-    c.ytdlp_install_hint = lambda: "pip install yt-dlp"
+    c.ytdlp_install_hint = lambda: "python -m pip install yt-dlp"
 
 
 class _Proc:

cinnamon_cli-0.2.34/cinnamon/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.34"

cinnamon_cli-0.2.34/cinnamon/anilist.py

@@ -1,33 +0,0 @@
-import requests
-
-API = "https://graphql.anilist.co"
-UA = "cinnamon/0.1.0"
-
-_SEARCH_QUERY = """
-query ($search: String, $page: Int) {
-  Page(page: $page, perPage: 20) {
-    media(search: $search, type: ANIME) {
-      id
-      idMal
-      title { romaji english native }
-      episodes
-      status
-      format
-      startDate { year }
-      genres
-    }
-  }
-}
-"""
-
-
-def search_anime(query):
-    resp = requests.post(
-        API,
-        json={"query": _SEARCH_QUERY, "variables": {"search": query, "page": 1}},
-        timeout=15,
-        headers={"User-Agent": UA, "Content-Type": "application/json", "Accept": "application/json"},
-    )
-    resp.raise_for_status()
-    data = resp.json()
-    return data.get("data", {}).get("Page", {}).get("media", [])