cinnamon-cli 0.2.40__tar.gz → 0.3.0__tar.gz

{cinnamon_cli-0.2.40/cinnamon_cli.egg-info → cinnamon_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinnamon-cli
-Version: 0.2.40
+Version: 0.3.0
 Summary: Watch Movies, TV shows and anime from your terminal.
 Author: pizza-droid
 License: CC BY-NC 4.0

cinnamon_cli-0.3.0/cinnamon/__init__.py

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

{cinnamon_cli-0.2.40 → cinnamon_cli-0.3.0}/cinnamon/anilist.py

@@ -120,6 +120,39 @@ query ($page: Int, $perPage: Int, $airingAtGreater: Int, $airingAtLesser: Int) {
 """
 
 
+_MEDIA_AIRING_QUERY = """
+query ($mediaId: Int) {
+  Page(page: 1, perPage: 100) {
+    airingSchedules(mediaId: $mediaId, sort: EPISODE) {
+      airingAt
+      episode
+      timeUntilAiring
+    }
+  }
+}
+"""
+
+
+def get_media_airing(media_id):
+    """Return list of {airingAt, episode, timeUntilAiring} for a given media ID."""
+    try:
+        resp = requests.post(
+            API,
+            json={"query": _MEDIA_AIRING_QUERY, "variables": {"mediaId": media_id}},
+            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("airingSchedules", [])
+    except requests.ConnectionError:
+        return []
+    except requests.Timeout:
+        return []
+    except requests.HTTPError:
+        return []
+
+
 def get_schedule(days=7):
     now = int(_time.time())
     end = now + (days * 86400)

{cinnamon_cli-0.2.40 → cinnamon_cli-0.3.0}/cinnamon/cli.py

@@ -132,6 +132,7 @@ def _q_style():
             ("separator", f"fg:{dim}"),
             ("instruction", f"fg:{dim}"),
             ("answer", f"bold fg:{accent}"),
+            ("disabled", f"fg:{dim} italic"),
         ]
     )
 
@@ -163,7 +164,7 @@ def _prompt(message, default=None, password=False):
 
 
 _UPDATE_CHECK_CACHE = 86400  # 24 hours
-
+_UPDATE_CHECKED = False  # in-process dedup
 
 _UPDATE_REPO = "pizza-droid/cinnamon"
 
@@ -171,6 +172,10 @@ _UPDATE_REPO = "pizza-droid/cinnamon"
 _UPDATE_CHECK_FALLBACK_DAYS = 7
 
 
+_search_cache = {}
+_search_history = []  # Track search queries in this session
+
+
 def _latest_version():
     import requests
 
@@ -207,6 +212,10 @@ def _latest_version():
 
 
 def _check_for_updates():
+    global _UPDATE_CHECKED
+    if _UPDATE_CHECKED:
+        return
+    _UPDATE_CHECKED = True
     try:
         cfg = load_config()
         last_check = cfg.get("_update_check", 0)
@@ -243,11 +252,430 @@ def _check_for_updates():
         pass
 
 
+_tmdb_client_instance = None
+
+
 def _get_tmdb():
+    global _tmdb_client_instance
+    if _tmdb_client_instance is not None:
+        return _tmdb_client_instance
     try:
-        return TMDBClient()
-    except MissingAPIKey:
-        return EmbedClient()
+        client = TMDBClient()
+        # Validate the key with a minimal request so a revoked/invalid key
+        # falls back to EmbedClient immediately instead of mid-search.
+        client.search_tv("a")
+        _tmdb_client_instance = client
+        return client
+    except (MissingAPIKey, TMDBAuthError):
+        _tmdb_client_instance = EmbedClient()
+        return _tmdb_client_instance
+
+
+# ---------------------------------------------------------------------------
+# unified search pipeline
+# ---------------------------------------------------------------------------
+
+
+def _search_tmdb(query: str, media_type: str | None = None) -> list[dict]:
+    """Search TMDB (or 2embed fallback) for TV and/or movies."""
+    tmdb = _get_tmdb()
+    results = []
+
+    if media_type in (None, "tv"):
+        tv = tmdb.search_tv(query).get("results", [])
+        for r in tv:
+            r["_media_type"] = "tv"
+            r["_source"] = "tmdb"
+            results.append(r)
+
+    if media_type in (None, "movie"):
+        movie = tmdb.search_movie(query).get("results", [])
+        for r in movie:
+            r["_media_type"] = "movie"
+            r["_source"] = "tmdb"
+            results.append(r)
+
+    return results
+
+
+def _search_anilist(query: str) -> list[dict]:
+    """Search AniList for anime."""
+    try:
+        from .anilist import search_anime
+
+        results = search_anime(query)
+        for r in results:
+            r["_media_type"] = "anime"
+            r["_source"] = "anilist"
+        return results
+    except Exception:
+        return []
+
+
+def _merge_and_rank_results(
+    tmdb_results: list[dict],
+    anilist_results: list[dict],
+    query: str,
+) -> list[dict]:
+    """Merge TMDB and AniList results, deduplicate, and sort by relevance."""
+    # Build a map of normalized titles to detect duplicates across sources.
+    # Key is just the normalized title — if TMDB and AniList return the same
+    # show, only the TMDB entry is kept (it has real IDs for scrapers).
+    seen = set()
+    merged = []
+
+    def norm_title(t: str) -> str:
+        import re
+        return re.sub(r"[^\w]", "", t.lower())
+
+    q_norm = norm_title(query)
+
+    # Add TMDB results first (they have real IDs for scrapers)
+    for r in tmdb_results:
+        title = r.get("name") or r.get("title") or "?"
+        key = norm_title(title)
+        if key not in seen:
+            seen.add(key)
+            merged.append(r)
+
+    # Add AniList results, skipping cross-source duplicates
+    for r in anilist_results:
+        title = (
+            r.get("title", {}).get("english")
+            or r.get("title", {}).get("romaji")
+            or r.get("title", {}).get("native")
+            or "?"
+        )
+        key = norm_title(title)
+        if key not in seen:
+            seen.add(key)
+            merged.append(r)
+
+    # Score and sort by relevance
+    def score(item: dict) -> tuple:
+        if item.get("_media_type") == "anime":
+            title = (
+                item.get("title", {}).get("english")
+                or item.get("title", {}).get("romaji")
+                or item.get("title", {}).get("native")
+                or ""
+            )
+            # anime has genre, season info etc. - prioritize exact matches
+        else:
+            title = item.get("name") or item.get("title") or ""
+
+        t_norm = norm_title(title)
+        # Exact match first
+        if t_norm == q_norm:
+            return (0, -item.get("popularity", 0))
+        # Starts with query
+        if t_norm.startswith(q_norm):
+            return (1, -item.get("popularity", 0))
+        # Contains query
+        if q_norm in t_norm:
+            return (2, -item.get("popularity", 0))
+        # Fuzzy: word overlap
+        q_words = set(q_norm.split())
+        t_words = set(t_norm.split())
+        overlap = len(q_words & t_words)
+        if overlap > 0:
+            return (3, -overlap, -item.get("popularity", 0))
+        return (4, -item.get("popularity", 0))
+
+    merged.sort(key=score)
+    return merged
+
+
+def _format_search_result(item: dict) -> tuple[str, str, str]:
+    """Return (title, year, tag) for a search result item."""
+    mtype = item.get("_media_type", "tv")
+    source = item.get("_source", "tmdb")
+
+    if mtype == "anime":
+        title = (
+            item.get("title", {}).get("english")
+            or item.get("title", {}).get("romaji")
+            or item.get("title", {}).get("native")
+            or "?"
+        )
+        year = str((item.get("startDate") or {}).get("year", ""))
+        tag = "Anime"
+        return title, year, tag
+
+    if mtype == "movie":
+        title = item.get("title", "?")
+        year = (item.get("release_date", "") or "")[:4]
+        tag = "Movie"
+        return title, year, tag
+
+    # TV
+    title = item.get("name", "?")
+    year = (item.get("first_air_date", "") or "")[:4]
+    tag = "Anime" if _is_anime(item) else "TV"
+    return title, year, tag
+
+
+def _pick_search_result(results: list[dict], message: str) -> dict | None:
+    """Unified picker for search results with type tags."""
+    if not results:
+        return None
+
+    try:
+        choices = []
+        for item in results:
+            title, year, tag = _format_search_result(item)
+            parts = []
+            if year:
+                parts.append(f"({year})")
+            parts.append(f"[{tag}]")
+            label = f"{title}  {' '.join(parts)}"
+            choices.append(questionary.Choice(title=label, value=item))
+        return _select(message, choices)
+    except Exception:
+        # Fallback to numbered table
+        table = Table(border_style="dim")
+        table.add_column("#", style="cyan")
+        table.add_column("Title", style="white")
+        table.add_column("Info", style="green")
+        for i, item in enumerate(results, 1):
+            title, year, tag = _format_search_result(item)
+            info = f"({year}) [{tag}]" if year else f"[{tag}]"
+            table.add_row(str(i), title, info)
+        console.print(table)
+        attempts = 0
+        while True:
+            try:
+                choice = int(_prompt(f"{message} (enter number)", default="1"))
+                if 1 <= choice <= len(results):
+                    return results[choice - 1]
+                console.print(f"[red]Pick a number between 1 and {len(results)}.[/red]")
+            except ValueError:
+                console.print("[red]Invalid input. Enter a number.[/red]")
+            attempts += 1
+            if attempts >= 10:
+                console.print("[red]Too many invalid attempts.[/red]")
+                return None
+
+
+def _narrow_and_search(query: str, tmdb_only: bool = False) -> list[dict]:
+    """Progressively narrow query by removing trailing words until results found."""
+    cache_key = (query, tmdb_only)
+    if cache_key in _search_cache:
+        return _search_cache[cache_key]
+
+    narrowed = query.split()
+    while narrowed:
+        q = " ".join(narrowed)
+        tmdb_results = _search_tmdb(q)
+        anilist_results = [] if tmdb_only else _search_anilist(q)
+        results = _merge_and_rank_results(tmdb_results, anilist_results, query)
+        if results:
+            _search_cache[cache_key] = results
+            return results
+        narrowed = narrowed[:-1]
+
+    _search_cache[cache_key] = []
+    return []
+
+
+def _run_unified_search(query: str, tmdb_only: bool = False) -> dict | None:
+    """Run unified search and return selected item, or None if cancelled."""
+    if not query or not query.strip():
+        return None
+
+    query = query.strip().replace("'", "")
+
+    # Save to search history
+    global _search_history
+    if query not in _search_history and load_config().get("history_enabled", True):
+        _search_history.append(query)
+        # Keep only last 50
+        if len(_search_history) > 50:
+            _search_history = _search_history[-50:]
+
+    # Try cached or fresh search
+    results = _narrow_and_search(query, tmdb_only=tmdb_only)
+
+    if not results:
+        _print_info(f"No results found for \"{query}\".")
+        return None
+
+    show = _pick_search_result(results, "Select a title:")
+    return show
+
+
+def _show_search_history():
+    """Show in-memory search history and let user pick one to re-search."""
+    if not load_config().get("history_enabled", True):
+        _print_info("Search history is disabled (use 'cinnamon history toggle' to enable).")
+        return
+    global _search_history
+
+    if not _search_history:
+        _print_info("No search history in this session.")
+        return
+
+    # Show most recent first
+    history = list(reversed(_search_history))
+
+    table = Table(border_style="dim")
+    table.add_column("#", style="cyan")
+    table.add_column("Recent Searches", style="white")
+
+    for i, q in enumerate(history, 1):
+        table.add_row(str(i), q)
+
+    console.print(table)
+
+    try:
+        choice = int(_prompt("Search again (enter number)", default="1"))
+        if 1 <= choice <= len(history):
+            selected = history[choice - 1]
+            ctx = click.get_current_context()
+            if ctx:
+                ctx.invoke(search, query=(selected,))
+    except (ValueError, EOFError, KeyboardInterrupt):
+        pass
+
+
+def _find_show_allanime(session, show_dict):
+    """Try to find an anime on allanime using all available title variants
+    from an AniList result dict (english, romaji, native)."""
+    from .scrapers.anime import _find_show
+    titles = show_dict.get("title", {})
+    tried = set()
+    for key in ("english", "romaji", "native"):
+        name = titles.get(key)
+        if name:
+            lowered = name.lower().strip()
+            if lowered not in tried:
+                tried.add(lowered)
+                aid = _find_show(session, name)
+                if aid:
+                    return aid
+    return None
+
+
+def _handle_anime_selection(show: dict, season: int | None, ep_str: str | None,
+                            player: str | None, quality: str | None,
+                            info_only: bool, download: bool,
+                            scraper: str | None):
+    """Route an anime result through the anime flow."""
+    from .scrapers.anime import _find_show, _allanime_episodes, _run_anime_flow
+    from .history import get_history as _get_history
+    import requests as _req
+
+    show_name = _format_search_result(show)[0]
+    theme = get_theme()
+
+    session = _req.Session()
+    session.headers.update({"User-Agent": "Mozilla/5.0"})
+
+    allanime_id = _find_show(session, show_name)
+    if not allanime_id:
+        allanime_id = _find_show_allanime(session, show)
+    if not allanime_id:
+        _print_error(f"No match for \"{show_name}\" on allanime.")
+        return
+
+    episodes_detail = _allanime_episodes(session, allanime_id)
+    if not episodes_detail:
+        _print_error("No episode data from allanime.")
+        return
+
+    # Check history for resume
+    if not ep_str:
+        entries = _get_history(show_name)
+        if entries:
+            last = entries[0]
+            if last.get("episode"):
+                resume_ep = last["episode"] + 1
+                try:
+                    answer = Prompt.ask(
+                        f"  Resume from [bold]S{last.get('season', 1)}E{resume_ep}[/bold]? [dim](y/n)[/dim]",
+                        default="y",
+                        show_default=False,
+                    ).strip().lower()
+                    if answer in ("", "y", "yes"):
+                        ep_str = str(resume_ep)
+                except (EOFError, KeyboardInterrupt):
+                    ep_str = str(resume_ep)
+
+    anilist_id = show.get("id") if show.get("_source") == "anilist" else None
+    _run_anime_flow(show_name, episodes_detail, season, ep_str, player, quality, info_only, download, allanime_id=allanime_id, anilist_id=anilist_id)
+
+
+def _handle_tv_selection(show: dict, tmdb, season: int | None, ep_start: int | None,
+                         ep_end: int | None, scraper: str | None,
+                         player: str | None, quality: str | None,
+                         info_only: bool, download: bool):
+    """Route a TV result through the episode picker."""
+    mtype = show.get("_media_type", "tv")
+    title_key = "name" if mtype == "tv" else "title"
+    date_key = "first_air_date" if mtype == "tv" else "release_date"
+    show_name = show.get(title_key, "?")
+    show_id = show["id"]
+
+    # Auto-detect anime from TMDB data
+    if scraper is None and mtype == "tv" and _is_anime(show):
+        scraper = "anime"
+        _print_info(f"Detected anime — using [bold]anime[/bold] scraper")
+
+    if mtype == "movie":
+        _play_movie(show, scraper, player, quality, info_only, download)
+        return
+
+    if season is not None and ep_start is not None:
+        _play_with_menu(show, season, ep_start, ep_end, f"S{season:02d}E{ep_start:02d}", scraper, player, quality, info_only, download)
+        return
+
+    theme = get_theme()
+    console.clear()
+    console.print(Panel(f"[bold {theme['accent']}]{show_name}[/bold {theme['accent']}]", border_style=theme["border"]))
+
+    _interactive_episode_picker(tmdb, show, scraper, player, quality, info_only, download, ep_start, ep_end)
+
+
+def _handle_search_selection(show: dict, season: int | None, ep_str: str | None,
+                             player: str | None, quality: str | None,
+                             info_only: bool, download: bool,
+                             scraper: str | None):
+    """Route a search result to the appropriate handler."""
+    mtype = show.get("_media_type", "tv")
+    source = show.get("_source", "tmdb")
+
+    tmdb = _get_tmdb()
+
+    if mtype == "anime":
+        _handle_anime_selection(show, season, ep_str, player, quality, info_only, download, scraper)
+        return
+
+    # TV or Movie from TMDB
+    if mtype == "movie":
+        _play_movie(show, scraper, player, quality, info_only, download)
+        return
+
+    # TV show
+    ep_start, ep_end = _parse_episode(ep_str) if ep_str else (None, None)
+
+    # Auto-detect anime
+    if scraper is None and _is_anime(show):
+        scraper = "anime"
+        _print_info(f"Detected anime — using [bold]anime[/bold] scraper")
+
+    if season is not None and ep_start is not None:
+        _play_with_menu(show, season, ep_start, ep_end, f"S{season:02d}E{ep_start:02d}", scraper, player, quality, info_only, download)
+        return
+
+    theme = get_theme()
+    console.clear()
+    show_name = show.get("name", "?")
+    console.print(Panel(f"[bold {theme['accent']}]{show_name}[/bold {theme['accent']}]", border_style=theme["border"]))
+
+    _interactive_episode_picker(tmdb, show, scraper, player, quality, info_only, download, ep_start, ep_end)
+
+
+# ---------------------------------------------------------------------------
 
 
 def _handle_errors(fn):
@@ -385,12 +813,12 @@ def _parse_episode(ep_str):
         return None, None
     parts = str(ep_str).split("-", 1)
     try:
-        start = int(parts[0])
+        start = float(parts[0])
     except ValueError:
         return None, None
     if len(parts) == 2:
         try:
-            end = int(parts[1])
+            end = float(parts[1])
         except ValueError:
             return None, None
         if end < start:
@@ -535,6 +963,8 @@ def _resolve_and_play(show, season_num, ep_num, ep_name, scraper, player, qualit
                         info["translation"] = translation
                     if download:
                         info["download"] = True
+                    if show.get("allanime_id"):
+                        info["allanime_id"] = show["allanime_id"]
                     future = pool.submit(attempt.resolve, info)
                     result = future.result(timeout=RESOLVE_TIMEOUT)
             if result:
@@ -708,7 +1138,8 @@ class CinnamonGroup(click.Group):
 @click.pass_context
 def cli(ctx, setup):
     """Cinnamon - Stream TV shows, movies & anime from the command line."""
-    _check_for_updates()
+    if ctx.invoked_subcommand != "update":
+        _check_for_updates()
     if setup:
         ctx.invoke(setup_cmd)
         return
@@ -732,6 +1163,9 @@ def cli(ctx, setup):
         query = _prompt(f"[bold]Search for a[/bold] [{theme['info']}]show or movie[/{theme['info']}]")
         if query and query.strip():
             ctx.invoke(search, query=(query.strip(),))
+        else:
+            # Empty input - show search history
+            _show_search_history()
 
 
 # ---------------------------------------------------------------------------
@@ -890,69 +1324,22 @@ def _theme_preview(name):
 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()
-    tmdb = _get_tmdb()
 
     ep_start, ep_end = _parse_episode(ep_str) if ep_str else (None, None)
 
-    query_str = " ".join(query) if query else None
+    query_str = " ".join(query).replace("'", "") if query else None
     if not query_str:
         console.clear()
         query_str = Prompt.ask("[bold]Search for a[/bold] [cyan]show or movie[/cyan]")
 
-    if media_type == "tv":
-        combined = [dict(r, _media_type="tv") for r in tmdb.search_tv(query_str).get("results", [])]
-    elif media_type == "movie":
-        combined = [dict(r, _media_type="movie") for r in tmdb.search_movie(query_str).get("results", [])]
-    else:
-        tv = [dict(r, _media_type="tv") for r in tmdb.search_tv(query_str).get("results", [])]
-        movie = [dict(r, _media_type="movie") for r in tmdb.search_movie(query_str).get("results", [])]
-        combined = tv + movie
-
-    if not combined:
-        _print_info(f"No results found for \"{query_str}\".")
-        return
-
-    show = _pick_combined(combined, "Select a title:")
+    # Use unified search - include anime results unless media_type is explicitly set
+    tmdb_only = media_type is not None
+    show = _run_unified_search(query_str, tmdb_only=tmdb_only)
 
     if not show:
         return
 
-    mtype = show.get("_media_type", "tv")
-    title_key = "name" if mtype == "tv" else "title"
-    date_key = "first_air_date" if mtype == "tv" else "release_date"
-    show_name = show.get(title_key, "?")
-    show_id = show["id"]
-
-    if scraper is None and mtype == "tv" and _is_anime(show):
-        # Route anime through allanime's available-episode list so we never
-        # offer an episode the source doesn't have (same as `cinnamon anime`).
-        from .scrapers.anime import _find_show, _allanime_episodes
-        import requests as _req
-        _as = _req.Session()
-        _as.headers.update({"User-Agent": "Mozilla/5.0"})
-        _aid = _find_show(_as, show_name)
-        if _aid:
-            _ed = _allanime_episodes(_as, _aid)
-            if _ed:
-                _run_anime_flow(show_name, _ed, season, ep_str, player, quality, info_only, download)
-                return
-        # Fall through to generic TV flow if allanime lookup fails.
-        scraper = "anime"
-        _print_info(f"Detected anime — using [bold]anime[/bold] scraper")
-
-    if mtype == "movie":
-        _play_movie(show, scraper, player, quality, info_only, download)
-        return
-
-    if season is not None and ep_start is not None:
-        _play_with_menu(show, season, ep_start, ep_end, f"S{season:02d}E{ep_start:02d}", scraper, player, quality, info_only, download)
-        return
-
-    theme = get_theme()
-    console.clear()
-    console.print(Panel(f"[bold {theme['accent']}]{show_name}[/bold {theme['accent']}]", border_style=theme["border"]))
-
-    _interactive_episode_picker(tmdb, show, scraper, player, quality, info_only, download, ep_start, ep_end)
+    _handle_search_selection(show, season, ep_str, player, quality, info_only, download, scraper)
 
 
 # ---------------------------------------------------------------------------
@@ -1002,6 +1389,14 @@ def watch(query, tmdb_id, media_type, season, ep_str, scraper, player, download,
             _interactive_episode_picker(_get_tmdb(), show, scraper, player, quality, info_only, ep_start=ep_start, ep_end=ep_end)
         return
 
+    # If query provided but no type, use unified search
+    if query and media_type is None:
+        show = _run_unified_search(query.strip().replace("'", ""))
+        if not show:
+            return
+        _handle_search_selection(show, season, ep_str, player, quality, info_only, download, scraper)
+        return
+
     tmdb = _get_tmdb()
 
     # Explicit movie request.
@@ -1047,53 +1442,15 @@ def watch(query, tmdb_id, media_type, season, ep_str, scraper, player, download,
         _interactive_episode_picker(tmdb, show, scraper, player, quality, info_only, ep_start=ep_start, ep_end=ep_end)
         return
 
-    # No type given: search both TV and movies, then dispatch by what is picked.
-    if tmdb_id:
-        # Ambiguous id without a type — try TV first, fall back to movie.
-        try:
-            show = tmdb.get_tv_details(tmdb_id)
-            mtype = "tv"
-        except TMDBNotFoundError:
-            show = tmdb.get_movie_details(tmdb_id)
-            mtype = "movie"
-    elif query:
-        tv = [dict(r, _media_type="tv") for r in tmdb.search_tv(query).get("results", [])]
-        movie = [dict(r, _media_type="movie") for r in tmdb.search_movie(query).get("results", [])]
-        combined = tv + movie
-        if not combined:
-            _print_info(f"No results found for \"{query}\".")
-            return
-        show = _pick_combined(combined, "Select a title:")
-        if not show:
-            return
-        mtype = show.get("_media_type", "tv")
-    else:
-        query = _prompt("[bold]Search for a[/bold] [cyan]show or movie[/cyan]")
-        if not query or not query.strip():
-            return
-        query = query.strip()
-        tv = [dict(r, _media_type="tv") for r in tmdb.search_tv(query).get("results", [])]
-        movie = [dict(r, _media_type="movie") for r in tmdb.search_movie(query).get("results", [])]
-        combined = tv + movie
-        if not combined:
-            _print_info(f"No results found for \"{query}\".")
-            return
-        show = _pick_combined(combined, "Select a title:")
-        if not show:
-            return
-        mtype = show.get("_media_type", "tv")
-
-    if mtype == "movie":
-        _play_movie(show, scraper, player, quality, info_only, download)
+    # No query, no type, no id - prompt for search
+    query = _prompt("[bold]Search for a[/bold] [cyan]show or movie[/cyan]")
+    if not query or not query.strip():
         return
-
-    if scraper is None and _is_anime(show):
-        scraper = "anime"
-        _print_info(f"Detected anime — using [bold]anime[/bold] scraper")
-    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)
+    query = query.strip()
+    show = _run_unified_search(query.replace("'", ""))
+    if not show:
         return
-    _interactive_episode_picker(tmdb, show, scraper, player, quality, info_only, ep_start=ep_start, ep_end=ep_end)
+    _handle_search_selection(show, season, ep_str, player, quality, info_only, download, scraper)
 
 
 # ---------------------------------------------------------------------------
@@ -1168,6 +1525,22 @@ def _interactive_episode_picker(tmdb, show, scraper, player, quality, info_only,
         _play_with_menu(show, season_num, ep_start, ep_end, ep_name, scraper, player, quality, info_only, download)
         return
 
+    # Instant episode search/filter
+    def _filter_episodes(eps, search_term):
+        """Filter episodes by episode number or title."""
+        if not search_term:
+            return eps
+        search_term = search_term.lower().strip()
+        filtered = []
+        for ep in eps:
+            ep_num = ep.get("episode_number")
+            ep_title = (ep.get("name") or "").lower()
+            if isinstance(ep_num, int) and search_term in str(ep_num):
+                filtered.append(ep)
+            elif search_term in ep_title:
+                filtered.append(ep)
+        return filtered
+
     try:
         ep_choices = []
         for ep in episodes:
@@ -1175,10 +1548,41 @@ def _interactive_episode_picker(tmdb, show, scraper, player, quality, info_only,
             ep_title = ep.get("name", f"Episode {ep_num}")
             label = f"E{ep_num:02d}  {ep_title}" if isinstance(ep_num, int) else f"{ep_num}  {ep_title}"
             ep_choices.append(questionary.Choice(title=label, value=ep))
-        ep_chosen = _select(
-            f"Season {season_num} - Select an episode:",
-            choices=ep_choices,
+
+        # Add a search/filter option at the top
+        search_choice = questionary.Choice(
+            title="[Search episodes by number/title...]",
+            value="__search__"
         )
+        ep_choices.insert(0, search_choice)
+
+        while True:
+            ep_chosen = _select(
+                f"Season {season_num} - Select an episode:",
+                choices=ep_choices,
+            )
+            if not ep_chosen:
+                return
+
+            if ep_chosen == "__search__":
+                search_term = _prompt("Filter episodes (number or title)")
+                if search_term:
+                    filtered = _filter_episodes(episodes, search_term)
+                    if not filtered:
+                        console.print(f"  [dim]No episodes match \"{search_term}\"[/dim]")
+                        continue
+                    # Rebuild choices with filtered episodes
+                    ep_choices = []
+                    for ep in filtered:
+                        ep_num = ep.get("episode_number", "?")
+                        ep_title = ep.get("name", f"Episode {ep_num}")
+                        label = f"E{ep_num:02d}  {ep_title}" if isinstance(ep_num, int) else f"{ep_num}  {ep_title}"
+                        ep_choices.append(questionary.Choice(title=label, value=ep))
+                    ep_choices.insert(0, search_choice)
+                    continue
+                continue
+            break
+
         if not ep_chosen:
             return
     except Exception:
@@ -1585,15 +1989,20 @@ def anime(query, season, ep_str, download, player, quality, info_only, prefer_su
     """Search anime via AniList (no API key needed) and stream from allanime."""
     _check_for_updates()
 
-    query_str = " ".join(query) if query else None
+    query_str = " ".join(query).replace("'", "") if query else None
     if not query_str:
         query_str = Prompt.ask("[bold]Search for an[/bold] [magenta]anime[/magenta]")
     from .anilist import search_anime
 
     results = search_anime(query_str)
     if not results:
-        _print_info(f"No anime found for \"{query_str}\".")
-        return
+        narrowed = query_str.split()
+        while not results and len(narrowed) > 1:
+            narrowed = narrowed[:-1]
+            results = search_anime(" ".join(narrowed))
+        if not results:
+            _print_info(f"No anime found for \"{query_str}\".")
+            return
 
     def _title(m):
         return m.get("title", {}).get("english") or m.get("title", {}).get("romaji") or m.get("title", {}).get("native", "?")
@@ -1635,6 +2044,10 @@ def anime(query, season, ep_str, download, player, quality, info_only, prefer_su
         session = _req.Session()
         session.headers.update({"User-Agent": "Mozilla/5.0"})
         allanime_id = _find_show(session, show_name)
+        if not allanime_id:
+            allanime_id = _find_show_allanime(session, show)
+        if allanime_id:
+            show_dict["allanime_id"] = allanime_id
         tt = "sub"
         if allanime_id:
             eps = _allanime_episodes(session, allanime_id)
@@ -1652,6 +2065,7 @@ def anime(query, season, ep_str, download, player, quality, info_only, prefer_su
                     tt = "sub"
             elif tt_keys:
                 tt = tt_keys[0]
+                console.print(f"  [dim]Only {tt} available[/dim]")
 
         proc = _resolve_and_play(show_dict, None, 1, show_name, "anime", player, quality, info_only, download, translation=tt)
         if proc is None and not info_only and not download:
@@ -1698,6 +2112,8 @@ def anime(query, season, ep_str, download, player, quality, info_only, prefer_su
     session.headers.update({"User-Agent": "Mozilla/5.0"})
 
     allanime_id = _find_show(session, show_name)
+    if not allanime_id:
+        allanime_id = _find_show_allanime(session, show)
     if not allanime_id:
         _print_error(f"No match for \"{show_name}\" on allanime.")
         return
@@ -1711,7 +2127,7 @@ def anime(query, season, ep_str, download, player, quality, info_only, prefer_su
         _print_info("Both --sub and --dub given; ignoring and asking.")
         prefer_sub = prefer_dub = False
     translation = "sub" if prefer_sub else ("dub" if prefer_dub else None)
-    _run_anime_flow(show_name, episodes_detail, season, ep_str, player, quality, info_only, download, translation=translation)
+    _run_anime_flow(show_name, episodes_detail, season, ep_str, player, quality, info_only, download, translation=translation, allanime_id=allanime_id, anilist_id=show.get("id"))
 
 
 def _anime_movie_tmdb_id(show_name, year=None):
@@ -1793,7 +2209,37 @@ def _normalize_movie_title(name):
     return n
 
 
-def _run_anime_flow(show_name, episodes_detail, season=None, ep_str=None, player=None, quality=None, info_only=False, download=False, translation=None):
+def _format_airing_time(airing_at):
+    """Format a future Unix timestamp into a human-readable relative time string."""
+    import time as _time
+    now = int(_time.time())
+    diff = airing_at - now
+    if diff <= 0:
+        return "now"
+    if diff < 3600:
+        minutes = diff // 60
+        return f"in {minutes}m"
+    if diff < 86400:
+        hours = diff // 3600
+        return f"in {hours}h"
+    if diff < 604800:
+        days = diff // 86400
+        return f"in {days}d"
+    import datetime as _dt
+    dt = _dt.datetime.fromtimestamp(airing_at, tz=_dt.timezone.utc)
+    return dt.strftime("on %b %d")
+
+
+def _format_airing_date(timestamp):
+    """Format a past Unix timestamp as an aired-date string."""
+    import datetime as _dt
+    dt = _dt.datetime.fromtimestamp(timestamp, tz=_dt.timezone.utc)
+    return dt.strftime("on %b %d")
+
+
+def _run_anime_flow(show_name, episodes_detail, season=None, ep_str=None,
+                    player=None, quality=None, info_only=False, download=False,
+                    translation=None, allanime_id=None, anilist_id=None):
     """Drive the episode picker from allanime's *available* episodes (not TMDB's
     full list), so we never offer an episode the anime source doesn't have."""
     parsed = {}
@@ -1842,25 +2288,79 @@ def _run_anime_flow(show_name, episodes_detail, season=None, ep_str=None, player
             tt = "sub"
     else:
         tt = tt_keys[0]
-        if tt != "sub":
-            console.print(f"  [dim]Using {tt}[/dim]")
+        console.print(f"  [dim]Only {tt} available[/dim]")
 
-    episodes = [int(e) for e in season_data[tt]]
+    episodes = [float(e) for e in season_data[tt]]
+    available = set(episodes)
     max_ep = max(episodes)
+
+    # Fetch airing schedule from AniList — show future episodes and recently
+    # aired ones (within 14 days) that haven't appeared on allanime yet.
+    # Cap at 10 total to avoid clutter (One Piece has 27+ stale entries).
+    airing_map = {}  # episode -> (airingAt, timeUntilAiring)
+    if anilist_id:
+        try:
+            from .anilist import get_media_airing
+            schedule = get_media_airing(anilist_id)
+            now = time.time()
+            for entry in schedule:
+                ep = entry.get("episode")
+                airing_at = entry.get("airingAt", 0)
+                if not ep or ep in available:
+                    continue
+                is_future = airing_at > now
+                recently_aired = not is_future and (now - airing_at) <= 14 * 86400
+                if not is_future and not recently_aired:
+                    continue
+                airing_map[ep] = (airing_at, entry.get("timeUntilAiring", 0))
+            # Cap at 10 closest entries
+            if len(airing_map) > 10:
+                sorted_eps = sorted(airing_map.items(), key=lambda x: x[1][0])
+                airing_map = dict(sorted_eps[:10])
+        except Exception:
+            pass
+
+    # Merge available + scheduled episodes for the picker
+    all_known = sorted(available | set(airing_map.keys()))
+    max_ep = max(all_known) if all_known else max_ep
+
     ep_start, ep_end = _parse_episode(ep_str) if ep_str else (None, None)
 
     if ep_start is not None:
-        if ep_start not in episodes:
-            # The suggested next episode may not exist yet (e.g. unaired) —
-            # fall back to the last available episode instead of hard-erroring.
-            fallback = max_ep
-            _print_info(f"Episode {ep_start} not available yet — using E{fallback}.")
-            ep_start = fallback
+        if ep_start not in available:
+            # Only fall back if it's a confirmed future episode
+            is_future = ep_start in airing_map and airing_map[ep_start][0] > time.time()
+            if is_future:
+                fallback = max_ep
+                _print_info(f"Episode {ep_start} not available yet — using E{fallback}.")
+                ep_start = fallback
         if ep_end is not None and ep_end > max_ep:
             ep_end = max_ep
     else:
         try:
-            ep_choices = [questionary.Choice(title=f"Episode {e}", value=e) for e in sorted(episodes)]
+            ep_choices = []
+            for e in all_known:
+                ep_label = f"Episode {int(e)}" if e == int(e) else f"Episode {e}"
+                if e in available:
+                    ep_choices.append(questionary.Choice(title=ep_label, value=e))
+                elif e in airing_map:
+                    airing_at, _ = airing_map[e]
+                    if airing_at > time.time():
+                        time_str = _format_airing_time(airing_at)
+                        label = f"Airs {time_str}"
+                    else:
+                        label = f"Aired {_format_airing_date(airing_at)} — coming soon"
+                    ep_choices.append(questionary.Choice(
+                        title=ep_label,
+                        value=e,
+                        disabled=label,
+                    ))
+                else:
+                    ep_choices.append(questionary.Choice(
+                        title=f"Episode {e}",
+                        value=e,
+                        disabled="Not yet aired",
+                    ))
             ep_chosen = _select("Select an episode:", choices=ep_choices)
             if not ep_chosen:
                 return
@@ -1876,6 +2376,8 @@ def _run_anime_flow(show_name, episodes_detail, season=None, ep_str=None, player
     scraper = "anime"
 
     show_dict = {"name": show_name, "id": 0}
+    if allanime_id:
+        show_dict["allanime_id"] = allanime_id
     ep_name = f"S{season:02d}E{ep_start:02d}"
     _play_with_menu(show_dict, season, ep_start, ep_end, ep_name, scraper, player, quality, info_only, download, translation=tt)
 
@@ -1946,6 +2448,7 @@ def update():
 @click.pass_context
 def schedule(ctx):
     """Show this week's trending TV shows and movies (requires TMDB key)."""
+    _check_for_updates()
     if ctx.invoked_subcommand is None:
         _schedule_impl()
 

{cinnamon_cli-0.2.40 → cinnamon_cli-0.3.0}/cinnamon/scrapers/anime.py

@@ -404,48 +404,90 @@ def _allanime_sources(session, show_id, ep_str, tt="sub"):
         raise ScraperNoStreamError("allanime", "No stream data for this episode (source may be unavailable)")
     return episode.get("sourceUrls", [])
 
+def _normalize_quotes(text: str) -> str:
+    """Replace fancy/curly quotes with straight ASCII equivalents."""
+    return text.replace("\u2018", "'").replace("\u2019", "'").replace("\u201c", '"').replace("\u201d", '"').replace("\u2013", "-").replace("\u2014", "--")
+
+
+def _simplify_query(text: str) -> str:
+    """Strip common punctuation that allanime's search may choke on."""
+    import re
+    return re.sub(r"[!?.,;:()\[\]{}@#$%^&*+=~`<>|/\\]", "", text).strip()
+
+
+def _normalize_name(s):
+    """Normalize Unicode characters commonly used in anime titles to ASCII."""
+    return s.replace("\u00d7", "x")  # multiplication sign → x
+
 def _find_show(session, name):
-    results = _allanime_search(session, name)
+    name = _normalize_quotes(name)
+
+    # Try the original query, then a simplified version without punctuation.
+    queries = [name]
+    simplified = _simplify_query(name)
+    if simplified != name:
+        queries.append(simplified)
+
+    results = None
+    for q in queries:
+        results = _allanime_search(session, q)
+        if results:
+            break
     if not results:
         return None
-    q = name.lower().strip()
+
+    q = _normalize_name(name.lower().strip())
+    # Exact match first
     for r in results:
         rn = r.get("name", "").lower().strip()
         if q == rn:
             return r["_id"]
-    q_words = frozenset(w for w in re.split(r"\W+", q) if len(w) > 2)
-    best_sub = None
-    best_sub_diff = float("inf")
+
+    # Collect episode totals once
+    ep_info = {}  # _id -> total
     for r in results:
-        rn = r.get("name", "").lower().strip()
-        r_words = set(re.split(r"\W+", rn))
-        shared = q_words & r_words
-        if len(shared) >= max(len(q_words) * 0.5, 1) or rn in q or q in rn:
-            diff = abs(len(rn) - len(q))
-            if diff < best_sub_diff:
-                best_sub_diff = diff
-                best_sub = r["_id"]
-    if best_sub:
-        return best_sub
-
-    q_has_movie = bool(re.search(r"\b(?:movie|film)\b", q))
-    q_words = frozenset(w for w in re.split(r"[^\w]+", q) if len(w) > 2)
+        ep_data = r.get("availableEpisodes", {})
+        if isinstance(ep_data, dict):
+            total = sum(int(v) for v in ep_data.values() if isinstance(v, (int, str)) and str(v).isdigit())
+        else:
+            total = 0
+        ep_info[r["_id"]] = total
+
+    # Shortcut: if one result has dramatically more episodes than all others
+    # (5x the next best) and at least 50 total episodes, it's likely the main
+    # series under an abbreviated name (e.g. "1P" = One Piece, 1171 eps).
+    ranked = sorted(ep_info.items(), key=lambda x: -x[1])
+    if len(ranked) >= 2 and ranked[0][1] >= 50 and ranked[0][1] > ranked[1][1] * 5:
+        return ranked[0][0]
+
+    # Split query into significant words (len > 1)
+    q_words = frozenset(w for w in re.split(r"\W+", q) if len(w) > 1)
+
+    # Score each result by word overlap, episode count, name closeness
     scored = []
+    scored_single = []
     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))
-        if q_has_movie:
-            suffix_bonus = 1 if has_suffix else 0
-        else:
-            suffix_bonus = 0 if has_suffix else 1
-        extra_words = len(r_words - q_words)
-        name_len = len(rn)
-        scored.append((overlap, all_match, suffix_bonus, 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]
+        rn_raw = r.get("name", "").lower().strip()
+        rn = _normalize_name(rn_raw)
+        r_words = set(re.split(r"\W+", rn))
+        shared = q_words & r_words if q_words else frozenset()
+        word_score = len(shared)
+        ep_total = ep_info.get(r["_id"], 0)
+        cond_multi = len(q_words) >= 2 and word_score >= max(len(q_words) // 2, 2)
+        if cond_multi:
+            scored.append((word_score * 20 + min(ep_total, 9999), r["_id"]))
+        elif len(q_words) < 2 and (
+            q.replace(" ", "") in rn.replace(" ", "") or rn.replace(" ", "") in q.replace(" ", "")
+        ):
+            scored_single.append((ep_total, r["_id"]))
+
+    if scored or scored_single:
+        if scored:
+            scored.sort(key=lambda x: -x[0])
+            return scored[0][1]
+        # Single-word path: return highest-episode-count match
+        scored_single.sort(key=lambda x: -x[0])
+        return scored_single[0][1]
 
 def _extract_mp4upload(session, embed_url):
     resp = session.get(embed_url, timeout=TIMEOUT)
@@ -551,7 +593,7 @@ class AnimeScraper(BaseScraper):
 
         if _time.time() >= deadline:
             raise ScraperNoStreamError(self.name, "Timeout searching allanime")
-        show_id = _find_show(session, show_name)
+        show_id = episode_info.get("allanime_id") or _find_show(session, show_name)
         if not show_id:
             raise ScraperNoStreamError(self.name, f'No allanime match for "{show_name}"')
 

{cinnamon_cli-0.2.40 → cinnamon_cli-0.3.0/cinnamon_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinnamon-cli
-Version: 0.2.40
+Version: 0.3.0
 Summary: Watch Movies, TV shows and anime from your terminal.
 Author: pizza-droid
 License: CC BY-NC 4.0

{cinnamon_cli-0.2.40 → cinnamon_cli-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cinnamon-cli"
-version = "0.2.40"
+version = "0.3.0"
 description = "Watch Movies, TV shows and anime from your terminal."
 license = { text = "CC BY-NC 4.0" }
 readme = "README.md"

{cinnamon_cli-0.2.40 → cinnamon_cli-0.3.0}/tests/test_ui_smoke.py

@@ -206,7 +206,7 @@ def test_setup_wizard():
     import webbrowser
     webbrowser.open = lambda *a, **k: True
     c._setup_api_key = lambda: "fakekey"
-    _run("setup", ["setup"], "")
+    _run("setup", ["setup"], "y\n")
 
 
 def test_tui_command_dead():

cinnamon_cli-0.2.40/cinnamon/__init__.py

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