V-3.4.0

Backend/__init__.py

@@ -11,4 +11,4 @@ StartTime = time()
 USE_DEFAULT_ID: str = None
 db = Database()  
 
-__version__ = "3.3.0"
+__version__ = "3.4.0"

Backend/helper/imdb.py

@@ -1,174 +1,128 @@
-import httpx
-import re
 import asyncio
+import re
 from typing import Optional, Dict, Any, List
 
+import httpx
+
 BASE_URL = "https://v3-cinemeta.strem.io"
 
 _client: Optional[httpx.AsyncClient] = None
 _client_lock = asyncio.Lock()
 
-# Pre-compiled emoji / unicode-symbol strip pattern
 _EMOJI_RE = re.compile(
     "["
-    "\U0001F600-\U0001F64F"   # emoticons
-    "\U0001F300-\U0001F5FF"   # symbols & pictographs
-    "\U0001F680-\U0001F6FF"   # transport & map
-    "\U0001F700-\U0001FAFF"   # extended symbols
-    "\U00002702-\U000027B0"   # dingbats
-    "\U000024C2-\U0001F251"   # enclosed chars
-    "\u2600-\u26FF"           # misc symbols
-    "\u2700-\u27BF"           # dingbats block
-    "\uFE00-\uFE0F"           # variation selectors
-    "\U0001F1E0-\U0001F1FF"   # flags
+    "\U0001F600-\U0001F64F" 
+    "\U0001F300-\U0001F5FF"   
+    "\U0001F680-\U0001F6FF"   
+    "\U0001F700-\U0001FAFF"   
+    "\U00002702-\U000027B0"  
+    "\U000024C2-\U0001F251"   
+    "\u2600-\u26FF"          
+    "\u2700-\u27BF"          
+    "\uFE00-\uFE0F"           
+    "\U0001F1E0-\U0001F1FF"   
     "]+",
     re.UNICODE,
 )
 
-
 async def _get_client() -> httpx.AsyncClient:
     global _client
     async with _client_lock:
         if _client is None or _client.is_closed:
-            _client = httpx.AsyncClient(
-                timeout=15.0,
-                follow_redirects=True
-            )
+            _client = httpx.AsyncClient(timeout=15.0, follow_redirects=True)
         return _client
 
+def _cinemeta_type(media_type: str) -> str:
+    return "series" if media_type in ("tvSeries", "tv", "series") else "movie"
+
+async def _fetch_json(url: str) -> Optional[Dict[str, Any]]:
+    try:
+        client = await _get_client()
+        resp = await client.get(url)
+        if resp.status_code != 200:
+            return None
+        return resp.json()
+    except Exception:
+        return None
 
 def _clean_search_query(query: str) -> str:
-    """
-    Strip emojis, decorative unicode symbols and non-essential punctuation
-    from a search query so Cinemeta can find the title reliably.
-    """
     q = _EMOJI_RE.sub(" ", query)
-    # Keep word chars, spaces, hyphens, apostrophes, ampersands, colons
     q = re.sub(r"[^\w\s\-\'&:.]", " ", q)
-    q = re.sub(r"\s+", " ", q).strip()
-    return q
-
+    return re.sub(r"\s+", " ", q).strip()
 
 def extract_first_year(year_string) -> int:
     if not year_string:
         return 0
-    year_str = str(year_string)
-    year_match = re.search(r'(\d{4})', year_str)
-    if year_match:
-        return int(year_match.group(1))
-    return 0
-
+    m = re.search(r"(\d{4})", str(year_string))
+    return int(m.group(1)) if m else 0
 
 async def search_title(query: str, type: str) -> Optional[Dict[str, Any]]:
-    """
-    Return the single top Cinemeta result (backward-compatible).
-    Uses cleaned query to handle emojis / special chars in titles.
-    """
     results = await search_title_multi(query=query, type=type, limit=1)
     return results[0] if results else None
 
-
 async def search_title_multi(query: str, type: str, limit: int = 8) -> List[Dict[str, Any]]:
-    """
-    Return up to *limit* Cinemeta results for *query*.
-    The caller is responsible for picking the best match via fuzzy scoring.
-    """
-    client = await _get_client()
-    cinemeta_type = "series" if type == "tvSeries" else type
-
-    # Clean the query before sending – emojis break the URL match
     cleaned = _clean_search_query(query)
     normalized = ".".join(cleaned.strip().lower().split())
-
-    url = f"{BASE_URL}/catalog/{cinemeta_type}/imdb/search={normalized}.json"
-    try:
-        resp = await client.get(url)
-        if resp.status_code != 200:
-            return []
-        data = resp.json()
-        results: List[Dict[str, Any]] = []
-        if data and "metas" in data and data["metas"]:
-            for meta in data["metas"][:limit]:
-                imdb_id = meta.get("imdb_id") or meta.get("id", "")
-                if not imdb_id:
-                    continue
-                results.append({
-                    "id": imdb_id,
-                    "type": type,
-                    "title": meta.get("name", ""),
-                    "year": meta.get("releaseInfo", ""),
-                    "poster": meta.get("poster", ""),
-                })
-        return results
-    except Exception:
-        return []
-
-
-async def get_detail(imdb_id: str, media_type: str) -> Optional[Dict[str, Any]]:
-    client = await _get_client()
-    cinemeta_type = "series" if media_type in ["tvSeries", "tv"] else "movie"
-
-    try:
-        url = f"{BASE_URL}/meta/{cinemeta_type}/{imdb_id}.json"
-        resp = await client.get(url)
-
-        if resp.status_code != 200:
-            return None
-
-        data = resp.json()
-        meta = data.get("meta")
-        if not meta:
-            return None
-
-        year_value = 0
-        for field in ["year", "releaseInfo", "released"]:
-            if meta.get(field):
-                year_value = extract_first_year(meta[field])
-                if year_value:
-                    break
-
-        return {
-            "id": meta.get("imdb_id") or meta.get("id"),
-            "moviedb_id": meta.get("moviedb_id"),
-            "type": meta.get("type", media_type),
+    url = f"{BASE_URL}/catalog/{_cinemeta_type(type)}/imdb/search={normalized}.json"
+
+    data = await _fetch_json(url)
+    metas = (data or {}).get("metas") or []
+    results: List[Dict[str, Any]] = []
+    for meta in metas[:limit]:
+        imdb_id = meta.get("imdb_id") or meta.get("id", "")
+        if not imdb_id:
+            continue
+        results.append({
+            "id": imdb_id,
+            "type": type,
             "title": meta.get("name", ""),
-            "plot": meta.get("description", ""),
-            "genre": meta.get("genres") or meta.get("genre", []),
-            "releaseDetailed": {"year": year_value},
-            "rating": {"star": float(meta.get("imdbRating", 0) or 0)},
+            "year": meta.get("releaseInfo", ""),
             "poster": meta.get("poster", ""),
-            "background": meta.get("background", ""),
-            "logo": meta.get("logo", ""),
-            "runtime": meta.get("runtime") or 0,
-            "director": meta.get("director", []),
-            "cast": meta.get("cast", []),
-            "videos": meta.get("videos", [])
-        }
+        })
+    return results
 
-    except Exception:
+async def get_detail(imdb_id: str, media_type: str) -> Optional[Dict[str, Any]]:
+    data = await _fetch_json(f"{BASE_URL}/meta/{_cinemeta_type(media_type)}/{imdb_id}.json")
+    meta = (data or {}).get("meta")
+    if not meta or not meta.get("name"):
         return None
 
+    year_value = 0
+    for field in ("year", "releaseInfo", "released"):
+        if meta.get(field):
+            year_value = extract_first_year(meta[field])
+            if year_value:
+                break
+
+    return {
+        "id": meta.get("imdb_id") or meta.get("id"),
+        "moviedb_id": meta.get("moviedb_id"),
+        "type": meta.get("type") or media_type,
+        "title": meta.get("name") or "",
+        "plot": meta.get("description") or "",
+        "genre": meta.get("genres") or meta.get("genre") or [],
+        "releaseDetailed": {"year": year_value},
+        "rating": {"star": float(meta.get("imdbRating") or 0)},
+        "poster": meta.get("poster") or "",
+        "background": meta.get("background") or "",
+        "logo": meta.get("logo") or "",
+        "runtime": meta.get("runtime") or 0,
+        "director": meta.get("director") or [],
+        "cast": meta.get("cast") or [],
+        "videos": meta.get("videos") or [],
+    }
 
 async def get_season(imdb_id: str, season_id: int, episode_id: int) -> Optional[Dict[str, Any]]:
-    client = await _get_client()
-    try:
-        url = f"{BASE_URL}/meta/series/{imdb_id}.json"
-        resp = await client.get(url)
-        if resp.status_code != 200:
-            return None
-        data = resp.json()
-        if 'meta' in data and 'videos' in data['meta']:
-            for video in data['meta']['videos']:
-                if (str(video.get('season', '')) == str(season_id) and
-                        str(video.get('episode', '')) == str(episode_id)):
-                    return {
-                        'title': video.get('title', f'Episode {episode_id}'),
-                        'no': str(episode_id),
-                        'season': str(season_id),
-                        'image': video.get('thumbnail', ''),
-                        'plot': video.get('overview', ''),
-                        'released': video.get('released', '')
-                    }
-        return None
-    except Exception:
-        return None
+    data = await _fetch_json(f"{BASE_URL}/meta/series/{imdb_id}.json")
+    videos = (data or {}).get("meta", {}).get("videos") or []
+    for video in videos:
+        if str(video.get("season", "")) == str(season_id) and str(video.get("episode", "")) == str(episode_id):
+            return {
+                "title": video.get("title", f"Episode {episode_id}"),
+                "no": str(episode_id),
+                "season": str(season_id),
+                "image": video.get("thumbnail", ""),
+                "plot": video.get("overview", ""),
+                "released": video.get("released", ""),
+            }
+    return None

Backend/helper/metadata.py

@@ -1,78 +1,73 @@
 import asyncio
-import traceback
-import PTN
 import re
-from re import compile, IGNORECASE
-from difflib import SequenceMatcher
+import traceback
 from typing import Optional, List
 
-from Backend.helper.imdb import get_detail, get_season, search_title, search_title_multi
-from themoviedb import aioTMDb
-from Backend.helper.settings_manager import SettingsManager
+import PTN
+
 import Backend
 from Backend.logger import LOGGER
+from Backend.helper.imdb import get_detail, get_season, search_title, search_title_multi
+from Backend.helper.settings_manager import SettingsManager
 from Backend.helper.encrypt import encode_string
 from Backend.helper.split_files import parse_split_info
+from themoviedb import aioTMDb
+from rapidfuzz import fuzz
+from guessit import guessit as _guessit
+from difflib import SequenceMatcher
+
+try:
+    def _fuzzy_ratio(a: str, b: str) -> float:
+        return fuzz.token_set_ratio(a, b) / 100.0
+except Exception:
+    def _fuzzy_ratio(a: str, b: str) -> float:
+        return SequenceMatcher(None, a, b).ratio()
 
-# ----------------- Configuration -----------------
 
-DELAY = 0
+_CINEMETA_THRESHOLD = 0.60
+_TMDB_THRESHOLD = 0.55
+_STRONG_MATCH = 0.92
+_ALT_TITLE_LOOKUPS = 5
+
+IMDB_CACHE: dict = {}
+TMDB_SEARCH_CACHE: dict = {}
+TMDB_DETAILS_CACHE: dict = {}
+EPISODE_CACHE: dict = {}
+ALT_TITLES_CACHE: dict = {}
+
+API_SEMAPHORE = asyncio.Semaphore(12)
+
+_MULTIPART_RE = re.compile(r"(?:part|cd|disc|disk)[s._-]*\d+(?=\.\w+$)", re.IGNORECASE)
 
 _tmdb_client: aioTMDb | None = None
 _tmdb_client_key: str | None = None
 
 
+# Return a cached TMDb client, rebuilding it when the configured API key changes.
 def get_tmdb_client() -> aioTMDb:
     global _tmdb_client, _tmdb_client_key
-
     current_key = SettingsManager.current().tmdb_api
     if _tmdb_client is None or _tmdb_client_key != current_key:
         _tmdb_client = aioTMDb(key=current_key, language="en-US", region="US")
         _tmdb_client_key = current_key
-
     return _tmdb_client
 
 
-# Cache dictionaries (per run)
-IMDB_CACHE: dict = {}
-TMDB_SEARCH_CACHE: dict = {}
-TMDB_DETAILS_CACHE: dict = {}
-EPISODE_CACHE: dict = {}
-
-# Concurrency semaphore for external API calls
-API_SEMAPHORE = asyncio.Semaphore(12)
-
-# Minimum title-similarity score to accept a Cinemeta result
-_CINEMETA_THRESHOLD = 0.60
-# Minimum score to accept TMDb first-result (without year bonus it's stricter)
-_TMDB_THRESHOLD = 0.55
-
-# ----------------- Image helpers -----------------
-
 def format_tmdb_image(path: str, size="w500") -> str:
-    if not path:
-        return ""
-    return f"https://image.tmdb.org/t/p/{size}{path}"
-
+    return f"https://image.tmdb.org/t/p/{size}{path}" if path else ""
 
 def get_tmdb_logo(images) -> str:
-    if not images:
-        return ""
-    logos = getattr(images, "logos", None)
+    logos = getattr(images, "logos", None) if images else None
     if not logos:
         return ""
     for logo in logos:
-        iso_lang = getattr(logo, "iso_639_1", None)
-        file_path = getattr(logo, "file_path", None)
-        if iso_lang == "en" and file_path:
-            return format_tmdb_image(file_path, "w300")
+        if getattr(logo, "iso_639_1", None) == "en" and getattr(logo, "file_path", None):
+            return format_tmdb_image(logo.file_path, "w300")
     for logo in logos:
-        file_path = getattr(logo, "file_path", None)
-        if file_path:
-            return format_tmdb_image(file_path, "w300")
+        if getattr(logo, "file_path", None):
+            return format_tmdb_image(logo.file_path, "w300")
     return ""
 
-
 def format_imdb_images(imdb_id: str) -> dict:
     if not imdb_id:
         return {"poster": "", "backdrop": "", "logo": ""}
@@ -83,327 +78,261 @@ def format_imdb_images(imdb_id: str) -> dict:
     }
 
 
-# ----------------- ID extraction -----------------
-
 def extract_default_id(text: str) -> str | None:
-    """
-    Extract an IMDb (tt…) or TMDb (numeric) ID from arbitrary text.
-
-    Handles:
-    • Bare IMDb IDs:      tt1234567
-    • IMDb URLs:          https://www.imdb.com/title/tt1234567/
-    • TMDb movie URLs:    https://www.themoviedb.org/movie/12345
-    • TMDb TV URLs:       https://www.themoviedb.org/tv/12345
-    • Bare TMDb IDs are intentionally NOT extracted from plain numbers to
-      avoid false matches; they must come via a URL or an explicit override.
-    """
     if not text:
         return None
-
-    # 1. Bare IMDb ID  (tt followed by 7–10 digits, word-bounded)
-    bare_imdb = re.search(r'\b(tt\d{7,10})\b', text)
+    bare_imdb = re.search(r"\b(tt\d{7,10})\b", text)
     if bare_imdb:
         return bare_imdb.group(1)
-
-    # 2. IMDb URL
-    imdb_url = re.search(r'/title/(tt\d+)', text)
+    imdb_url = re.search(r"/title/(tt\d+)", text)
     if imdb_url:
         return imdb_url.group(1)
-
-    # 3. TMDb URL  (/movie/NNN or /tv/NNN)
-    tmdb_url = re.search(r'/(?:movie|tv)/(\d+)', text)
+    tmdb_url = re.search(r"/(?:movie|tv)/(\d+)", text)
     if tmdb_url:
         return tmdb_url.group(1)
-
     return None
 
-
-# ----------------- Fuzzy-matching helpers -----------------
+def _split_default_id(default_id) -> tuple[str | None, int | None, bool, bool]:
+    if not default_id:
+        return None, None, False, False
+    value = str(default_id).strip()
+    if value.startswith("tt"):
+        return value, None, True, False
+    if value.isdigit():
+        return None, int(value), False, True
+    return None, None, False, False
 
 def _normalize_title(title: str) -> str:
-    """Lower-case, strip leading articles, collapse punctuation to spaces."""
     if not title:
         return ""
     t = title.lower().strip()
-    # Remove leading articles
-    t = re.sub(r'^\b(the|a|an)\b\s+', '', t)
-    # Replace punctuation with spaces
-    t = re.sub(r'[^\w\s]', ' ', t)
-    t = re.sub(r'\s+', ' ', t).strip()
-    return t
-
+    t = re.sub(r"^\b(the|a|an)\b\s+", "", t)
+    t = re.sub(r"[^\w\s]", " ", t)
+    return re.sub(r"\s+", " ", t).strip()
 
 def _title_similarity(t1: str, t2: str) -> float:
-    """Fuzzy similarity between two titles, 0–1."""
     n1, n2 = _normalize_title(t1), _normalize_title(t2)
     if not n1 or not n2:
         return 0.0
-    return SequenceMatcher(None, n1, n2).ratio()
-
+    return _fuzzy_ratio(n1, n2)
 
 def _year_from_str(year_val) -> int:
-    """Extract the first 4-digit year from strings like '2023', '2020–', '2019-2022'."""
     if not year_val:
         return 0
-    m = re.search(r'(\d{4})', str(year_val))
+    m = re.search(r"(\d{4})", str(year_val))
     return int(m.group(1)) if m else 0
 
-
-def _score_candidate(
-    query_title: str,
-    query_year: Optional[int],
-    result_title: str,
-    result_year: int,
-) -> float:
-    """
-    Combined score for a single API candidate.
-    Base = title similarity; year match adds a bonus.
-    """
+def _score_candidate(query_title: str, query_year: Optional[int], result_title: str, result_year: int) -> float:
     score = _title_similarity(query_title, result_title)
-
     if query_year and result_year:
         diff = abs(int(query_year) - result_year)
         if diff == 0:
-            score = min(1.0, score + 0.20)   # exact year: strong boost
+            score = min(1.0, score + 0.20)
         elif diff == 1:
-            score = min(1.0, score + 0.07)   # off by one: small boost
-        elif diff <= 2:
-            pass                              # neutral
-        else:
-            score = max(0.0, score - 0.10 * (diff - 2))  # growing penalty
-
+            score = min(1.0, score + 0.07)
+        elif diff > 2:
+            score = max(0.0, score - 0.10 * (diff - 2))
     return score
 
-
 def _build_query_variants(title: str, year: Optional[int] = None) -> List[str]:
-    """
-    Build an ordered list of search query variants to try when the primary
-    query produces a poor match.
-
-    Order: most-specific → least-specific.
-    """
-    variants: List[str] = []
-
-    # 1. Original title (as parsed by PTN)
-    variants.append(title)
-
-    # 2. Title with year appended (often improves Cinemeta recall for movies)
+    variants: List[str] = [title]
     if year:
         variants.append(f"{title} {year}")
 
-    # 3. Punctuation-stripped version (handles colons, hyphens, apostrophes)
-    stripped = re.sub(r'[^\w\s]', ' ', title)
-    stripped = re.sub(r'\s+', ' ', stripped).strip()
+    stripped = re.sub(r"\s+", " ", re.sub(r"[^\w\s]", " ", title)).strip()
     if stripped and stripped.lower() != title.lower():
         variants.append(stripped)
         if year:
             variants.append(f"{stripped} {year}")
 
-    # 4. Without leading article (The / A / An)
-    no_article = re.sub(r'^\b(the|a|an)\b\s+', '', title, flags=IGNORECASE).strip()
+    no_article = re.sub(r"^\b(the|a|an)\b\s+", "", title, flags=re.IGNORECASE).strip()
     if no_article and no_article.lower() != title.lower():
         variants.append(no_article)
 
-    # Deduplicate, preserve order, drop empty strings
     seen: set = set()
-    result: List[str] = []
+    ordered: List[str] = []
     for v in variants:
-        k = v.lower()
-        if k not in seen and v:
-            seen.add(k)
-            result.append(v)
-    return result
+        key = v.lower()
+        if v and key not in seen:
+            seen.add(key)
+            ordered.append(v)
+    return ordered
+
+def _first(value):
+    return value[0] if isinstance(value, list) else value
+
+def parse_media_name(name: str) -> dict:
+    try:
+        ptn = PTN.parse(name) or {}
+    except Exception as e:
+        LOGGER.warning(f"PTN parsing failed for {name}: {e}")
+        ptn = {}
+
+    parsed = {
+        "title": ptn.get("title"),
+        "year": ptn.get("year"),
+        "season": ptn.get("season"),
+        "episode": ptn.get("episode"),
+        "quality": ptn.get("resolution"),
+        "excess": ptn.get("excess"),
+    }
 
+    if _guessit:
+        try:
+            g = _guessit(name)
+            parsed["title"] = parsed["title"] or _first(g.get("title"))
+            parsed["year"] = parsed["year"] or _first(g.get("year"))
+            parsed["season"] = parsed["season"] or _first(g.get("season"))
+            parsed["episode"] = parsed["episode"] or _first(g.get("episode"))
+            parsed["quality"] = parsed["quality"] or _first(g.get("screen_size"))
+        except Exception as e:
+            LOGGER.warning(f"GuessIt parsing failed for {name}: {e}")
 
-# ----------------- Cached API wrappers -----------------
+    return parsed
 
 async def safe_imdb_search(title: str, type_: str, year: Optional[int] = None) -> str | None:
-    """
-    Search Cinemeta for *title* (+ optional *year*) with:
-    • Multiple query variants (original, stripped, with-year, no-article)
-    • Fuzzy title + year scoring across all returned results
-    • Acceptance threshold so partial/wrong matches are rejected early
-    • INFO log explaining what happened when no confident match is found
-    """
     cache_key = f"imdb::{type_}::{title}::{year}"
     if cache_key in IMDB_CACHE:
         return IMDB_CACHE[cache_key]
 
     query_variants = _build_query_variants(title, year)
-
     best_id: str | None = None
-    best_score: float = 0.0
-    best_result_title: str = ""
+    best_score = 0.0
+    best_title = ""
 
     for query in query_variants:
         try:
             async with API_SEMAPHORE:
                 results = await search_title_multi(query=query, type=type_, limit=8)
-
             for r in results:
-                r_title = r.get("title", "")
-                r_year = _year_from_str(r.get("year", ""))
-                score = _score_candidate(title, year, r_title, r_year)
-
+                score = _score_candidate(title, year, r.get("title", ""), _year_from_str(r.get("year", "")))
                 if score > best_score:
-                    best_score = score
-                    best_id = r.get("id")
-                    best_result_title = r_title
-
-                # Early-exit: perfect / near-perfect match
-                if best_score >= 0.92:
+                    best_score, best_id, best_title = score, r.get("id"), r.get("title", "")
+                if best_score >= _STRONG_MATCH:
                     break
-
         except Exception as e:
             LOGGER.warning(f"Cinemeta search variant '{query}' [{type_}] failed: {e}")
-
-        # Early-exit across variants too
-        if best_score >= 0.92:
+        if best_score >= _STRONG_MATCH:
             break
 
     if best_score >= _CINEMETA_THRESHOLD and best_id:
-        LOGGER.info(
-            f"Cinemeta match: '{title}' (year={year}) → "
-            f"'{best_result_title}' [{best_id}] (score={best_score:.2f})"
-        )
+        LOGGER.info(f"Cinemeta match: '{title}' (year={year}) -> '{best_title}' [{best_id}] (score={best_score:.2f})")
         IMDB_CACHE[cache_key] = best_id
         return best_id
 
-    # Log a clear, actionable INFO message so operators know why it fell back
     if best_id:
         LOGGER.info(
-            f"Cinemeta low-confidence for '{title}' (year={year}, type={type_}) "
-            f"| best candidate: '{best_result_title}' [{best_id}] score={best_score:.2f} "
-            f"(threshold={_CINEMETA_THRESHOLD}) → falling back to TMDb"
+            f"Cinemeta low-confidence for '{title}' (year={year}, type={type_}) | "
+            f"best '{best_title}' [{best_id}] score={best_score:.2f} -> falling back to TMDb"
         )
     else:
-        LOGGER.info(
-            f"Cinemeta returned no results for '{title}' (year={year}, type={type_}) "
-            f"| tried variants: {query_variants} → falling back to TMDb"
-        )
+        LOGGER.info(f"Cinemeta returned no results for '{title}' (year={year}, type={type_}) -> falling back to TMDb")
 
     IMDB_CACHE[cache_key] = None
     return None
 
+async def _tmdb_raw_search(title: str, media_type: str, year: Optional[int]):
+    client = get_tmdb_client()
+    async with API_SEMAPHORE:
+        if media_type == "movie":
+            results = await (client.search().movies(query=title, year=year) if year else client.search().movies(query=title))
+            if not results and year:
+                results = await client.search().movies(query=title)
+            return results
+        return await client.search().tv(query=title)
 
 async def safe_tmdb_search(title: str, type_: str, year: Optional[int] = None):
-    """
-    Search TMDb for *title*, scoring all returned results by title similarity
-    and year proximity.  Falls back to a year-agnostic retry when the
-    year-constrained search yields nothing.
-    """
     cache_key = f"tmdb_search::{type_}::{title}::{year}"
     if cache_key in TMDB_SEARCH_CACHE:
         return TMDB_SEARCH_CACHE[cache_key]
 
     try:
-        async with API_SEMAPHORE:
-            if type_ == "movie":
-                results = (
-                    await get_tmdb_client().search().movies(query=title, year=year)
-                    if year
-                    else await get_tmdb_client().search().movies(query=title)
-                )
-                # Year-constrained search sometimes returns nothing for new/limited releases
-                if not results and year:
-                    async with API_SEMAPHORE:
-                        results = await get_tmdb_client().search().movies(query=title)
-            else:
-                results = await get_tmdb_client().search().tv(query=title)
-
-        best = _pick_best_tmdb_result(results, title, year, type_)
-
+        results = await _tmdb_raw_search(title, type_, year)
+        best = await _pick_best_tmdb_result(results, title, year, type_)
         if best is None and results:
-            # Log what the top result actually was so operators can diagnose
             top = results[0]
             top_title = getattr(top, "title" if type_ == "movie" else "name", "?")
-            LOGGER.info(
-                f"TMDb '{title}' (year={year}) top result '{top_title}' "
-                f"did not meet threshold – no confident match"
-            )
-
+            LOGGER.info(f"TMDb '{title}' (year={year}) top result '{top_title}' did not meet threshold")
         TMDB_SEARCH_CACHE[cache_key] = best
         return best
-
     except Exception as e:
         LOGGER.error(f"TMDb search failed for '{title}' [{type_}]: {e}")
         TMDB_SEARCH_CACHE[cache_key] = None
         return None
 
+def _tmdb_title_year(item, media_type: str) -> tuple[str, int]:
+    if media_type == "movie":
+        date = getattr(item, "release_date", None)
+        return getattr(item, "title", "") or "", getattr(date, "year", 0) if date else 0
+    date = getattr(item, "first_air_date", None)
+    return getattr(item, "name", "") or "", getattr(date, "year", 0) if date else 0
 
-def _pick_best_tmdb_result(results, query_title: str, query_year: Optional[int], type_: str):
-    """
-    Score TMDb search results and return the best one above threshold,
-    or None if nothing is confident enough.
-    """
+async def _pick_best_tmdb_result(results, query_title: str, query_year: Optional[int], media_type: str):
     if not results:
         return None
 
-    best_item = None
-    best_score = 0.0
-
+    scored = []
+    best_item, best_score = None, 0.0
     for item in results:
-        if type_ == "movie":
-            r_title = getattr(item, "title", "") or ""
-            release = getattr(item, "release_date", None)
-            r_year = getattr(release, "year", 0) if release else 0
-        else:
-            r_title = getattr(item, "name", "") or ""
-            first_air = getattr(item, "first_air_date", None)
-            r_year = getattr(first_air, "year", 0) if first_air else 0
-
+        r_title, r_year = _tmdb_title_year(item, media_type)
         score = _score_candidate(query_title, query_year, r_title, r_year)
-
+        scored.append((score, item, r_year))
         if score > best_score:
-            best_score = score
-            best_item = item
+            best_score, best_item = score, item
 
-        if best_score >= 0.92:
-            break
-
-    if best_score >= _TMDB_THRESHOLD and best_item is not None:
+    if best_score >= _STRONG_MATCH:
         return best_item
 
-    return None
+    scored.sort(key=lambda x: x[0], reverse=True)
+    for _, item, r_year in scored[:_ALT_TITLE_LOOKUPS]:
+        alt_titles = await _tmdb_alternative_titles(media_type, getattr(item, "id", None))
+        for alt in alt_titles:
+            alt_score = _score_candidate(query_title, query_year, alt, r_year)
+            if alt_score > best_score:
+                best_score, best_item = alt_score, item
+                if best_score >= _STRONG_MATCH:
+                    break
+        if best_score >= _STRONG_MATCH:
+            break
 
+    return best_item if best_score >= _TMDB_THRESHOLD and best_item is not None else None
 
-async def _tmdb_movie_details(movie_id):
-    if movie_id in TMDB_DETAILS_CACHE:
-        return TMDB_DETAILS_CACHE[movie_id]
+async def _tmdb_alternative_titles(media_type: str, tmdb_id) -> list[str]:
+    if not tmdb_id:
+        return []
+    cache_key = (media_type, tmdb_id)
+    if cache_key in ALT_TITLES_CACHE:
+        return ALT_TITLES_CACHE[cache_key]
+    titles: list[str] = []
     try:
+        client = get_tmdb_client()
         async with API_SEMAPHORE:
-            details = await get_tmdb_client().movie(movie_id).details(
-                append_to_response="external_ids,credits"
-            )
-            images = await get_tmdb_client().movie(movie_id).images()
-            details.images = images
-
-        TMDB_DETAILS_CACHE[movie_id] = details
-        return details
+            target = client.movie(tmdb_id) if media_type == "movie" else client.tv(tmdb_id)
+            alt = await target.alternative_titles()
+        entries = list(getattr(alt, "titles", None) or []) + list(getattr(alt, "results", None) or [])
+        titles = [t for t in (getattr(e, "title", "") for e in entries) if t]
     except Exception as e:
-        LOGGER.warning(f"TMDb movie details fetch failed for id={movie_id}: {e}")
-        TMDB_DETAILS_CACHE[movie_id] = None
-        return None
-
-
-async def _tmdb_tv_details(tv_id):
-    if tv_id in TMDB_DETAILS_CACHE:
-        return TMDB_DETAILS_CACHE[tv_id]
+        LOGGER.warning(f"TMDb alternative-titles fetch failed for {media_type} id={tmdb_id}: {e}")
+    ALT_TITLES_CACHE[cache_key] = titles
+    return titles
+
+async def _tmdb_details(media_type: str, item_id):
+    cache_key = (media_type, item_id)
+    if cache_key in TMDB_DETAILS_CACHE:
+        return TMDB_DETAILS_CACHE[cache_key]
     try:
+        client = get_tmdb_client()
         async with API_SEMAPHORE:
-            details = await get_tmdb_client().tv(tv_id).details(
-                append_to_response="external_ids,credits"
-            )
-            images = await get_tmdb_client().tv(tv_id).images()
-            details.images = images
-        TMDB_DETAILS_CACHE[tv_id] = details
+            target = client.movie(item_id) if media_type == "movie" else client.tv(item_id)
+            details = await target.details(append_to_response="external_ids,credits")
+            details.images = await target.images()
+        TMDB_DETAILS_CACHE[cache_key] = details
         return details
     except Exception as e:
-        LOGGER.warning(f"TMDb tv details fetch failed for id={tv_id}: {e}")
-        TMDB_DETAILS_CACHE[tv_id] = None
+        LOGGER.warning(f"TMDb {media_type} details fetch failed for id={item_id}: {e}")
+        TMDB_DETAILS_CACHE[cache_key] = None
         return None
 
-
 async def _tmdb_episode_details(tv_id, season, episode):
     key = (tv_id, season, episode)
     if key in EPISODE_CACHE:
@@ -417,28 +346,163 @@ async def _tmdb_episode_details(tv_id, season, episode):
         EPISODE_CACHE[key] = None
         return None
 
+async def _cached_imdb_detail(imdb_id: str, media_type: str):
+    cached = IMDB_CACHE.get(imdb_id)
+    if isinstance(cached, dict):
+        return cached
+    async with API_SEMAPHORE:
+        detail = await get_detail(imdb_id=imdb_id, media_type=media_type)
+    IMDB_CACHE[imdb_id] = detail
+    return detail
+
+async def _cached_imdb_season(imdb_id: str, season, episode):
+    key = f"{imdb_id}::{season}::{episode}"
+    if key in EPISODE_CACHE:
+        return EPISODE_CACHE[key]
+    async with API_SEMAPHORE:
+        ep = await get_season(imdb_id=imdb_id, season_id=season, episode_id=episode)
+    EPISODE_CACHE[key] = ep
+    return ep
+
+async def _tmdb_external_imdb_id(media_type: str, tmdb_id) -> str | None:
+    try:
+        details = await _tmdb_details(media_type, tmdb_id)
+        ext = getattr(details, "external_ids", None) if details else None
+        return getattr(ext, "imdb_id", None) if ext else None
+    except Exception:
+        return None
+
+
+
+def _extract_cast(details) -> list:
+    credits = getattr(details, "credits", None) or {}
+    cast = getattr(credits, "cast", []) or []
+    return [getattr(c, "name", None) or getattr(c, "original_name", None) for c in cast]
+
+
+def _format_runtime(minutes) -> str:
+    return f"{minutes} min" if minutes else ""
+
+
+# Build the indexer movie payload from a TMDb details object.
+def _build_tmdb_movie_payload(movie, quality, encoded_string) -> dict:
+    release = getattr(movie, "release_date", None)
+    return {
+        "tmdb_id": movie.id,
+        "imdb_id": getattr(getattr(movie, "external_ids", None), "imdb_id", None),
+        "title": movie.title,
+        "year": getattr(release, "year", 0) if release else 0,
+        "rate": getattr(movie, "vote_average", 0) or 0,
+        "description": movie.overview or "",
+        "poster": format_tmdb_image(movie.poster_path),
+        "backdrop": format_tmdb_image(movie.backdrop_path, "original"),
+        "logo": get_tmdb_logo(getattr(movie, "images", None)),
+        "cast": _extract_cast(movie),
+        "runtime": str(_format_runtime(getattr(movie, "runtime", None))),
+        "media_type": "movie",
+        "genres": [g.name for g in (movie.genres or [])],
+        "quality": quality,
+        "encoded_string": encoded_string,
+    }
+
+
+# Build the indexer TV payload from TMDb series + episode details.
+def _build_tmdb_tv_payload(tv, ep, season, episode, quality, encoded_string) -> dict:
+    first_air = getattr(tv, "first_air_date", None)
+    series_runtime = tv.episode_run_time[0] if getattr(tv, "episode_run_time", None) else None
+    runtime = _format_runtime((getattr(ep, "runtime", None) if ep else None) or series_runtime)
+    fallback_ep_title = f"S{season:02d}E{episode:02d}"
+    return {
+        "tmdb_id": tv.id,
+        "imdb_id": getattr(getattr(tv, "external_ids", None), "imdb_id", None),
+        "title": tv.name,
+        "year": getattr(first_air, "year", 0) if first_air else 0,
+        "rate": getattr(tv, "vote_average", 0) or 0,
+        "description": tv.overview or "",
+        "poster": format_tmdb_image(tv.poster_path),
+        "backdrop": format_tmdb_image(tv.backdrop_path, "original"),
+        "logo": get_tmdb_logo(getattr(tv, "images", None)),
+        "genres": [g.name for g in (tv.genres or [])],
+        "media_type": "tv",
+        "cast": _extract_cast(tv),
+        "runtime": str(runtime),
+        "season_number": season,
+        "episode_number": episode,
+        "episode_title": getattr(ep, "name", fallback_ep_title) if ep else fallback_ep_title,
+        "episode_backdrop": format_tmdb_image(getattr(ep, "still_path", None), "original") if ep else "",
+        "episode_overview": getattr(ep, "overview", "") if ep else "",
+        "episode_released": ep.air_date.strftime("%Y-%m-%dT05:00:00.000Z") if (ep and getattr(ep, "air_date", None)) else "",
+        "quality": quality,
+        "encoded_string": encoded_string,
+    }
+
+
+# Build the indexer movie payload from Cinemeta/IMDb details.
+def _build_imdb_movie_payload(imdb, imdb_id, title, quality, encoded_string) -> dict:
+    images = format_imdb_images(imdb_id)
+    return {
+        "tmdb_id": imdb.get("moviedb_id") or (imdb_id.replace("tt", "") if imdb_id else None),
+        "imdb_id": imdb_id,
+        "title": imdb.get("title", title),
+        "year": imdb.get("releaseDetailed", {}).get("year", 0),
+        "rate": imdb.get("rating", {}).get("star", 0),
+        "description": imdb.get("plot", ""),
+        "poster": images["poster"],
+        "backdrop": images["backdrop"],
+        "logo": images["logo"],
+        "cast": imdb.get("cast", []),
+        "runtime": str(imdb.get("runtime") or ""),
+        "media_type": "movie",
+        "genres": imdb.get("genre", []),
+        "quality": quality,
+        "encoded_string": encoded_string,
+    }
+
+
+# Build the indexer TV payload from Cinemeta/IMDb series + episode details.
+def _build_imdb_tv_payload(imdb, ep, imdb_id, title, season, episode, quality, encoded_string) -> dict:
+    images = format_imdb_images(imdb_id)
+    return {
+        "tmdb_id": imdb.get("moviedb_id") or (imdb_id.replace("tt", "") if imdb_id else None),
+        "imdb_id": imdb_id,
+        "title": imdb.get("title", title),
+        "year": imdb.get("releaseDetailed", {}).get("year", 0),
+        "rate": imdb.get("rating", {}).get("star", 0),
+        "description": imdb.get("plot", ""),
+        "poster": images["poster"],
+        "backdrop": images["backdrop"],
+        "logo": images["logo"],
+        "cast": imdb.get("cast", []),
+        "runtime": str(imdb.get("runtime") or ""),
+        "genres": imdb.get("genre", []),
+        "media_type": "tv",
+        "season_number": season,
+        "episode_number": episode,
+        "episode_title": ep.get("title", f"S{season:02d}E{episode:02d}"),
+        "episode_backdrop": ep.get("image", ""),
+        "episode_overview": ep.get("plot", ""),
+        "episode_released": str(ep.get("released", "")),
+        "quality": quality,
+        "encoded_string": encoded_string,
+    }
+
 
-# =============================================================================
-# Main entry-point
-# =============================================================================
+# ----------------- Main entry-point -----------------
 
+# Parse a filename/caption and resolve full movie or TV metadata for the indexer.
 async def metadata(filename: str, channel: int, msg_id, override_id: str = None) -> dict | None:
     try:
-        parsed = PTN.parse(filename)
+        parsed = parse_media_name(filename)
     except Exception as e:
-        LOGGER.error(f"PTN parsing failed for {filename}: {e}\n{traceback.format_exc()}")
+        LOGGER.error(f"Parsing failed for {filename}: {e}\n{traceback.format_exc()}")
         return None
 
-
-    # Skip split files that are not supported 
-    multipart_pattern = compile(r'(?:part|cd|disc|disk)[s._-]*\d+(?=\.\w+$)', IGNORECASE)
-    if multipart_pattern.search(filename):
-        LOGGER.info(f"Skipping {filename}: seems to be a split video file that is not supposed to combine in stremio use .mkv.001, .mkv.002 split files")
+    if _MULTIPART_RE.search(filename):
+        LOGGER.info(f"Skipping {filename}: split video file not meant to be combined in Stremio")
         return None
 
-    
-    # Skip combined/invalid files
-    if "excess" in parsed and any("combined" in item.lower() for item in parsed["excess"]):
+    excess = parsed.get("excess")
+    if excess and any("combined" in item.lower() for item in excess):
         LOGGER.info(f"Skipping {filename}: contains 'combined'")
         return None
 
@@ -449,7 +513,7 @@ async def metadata(filename: str, channel: int, msg_id, override_id: str = None)
     season = parsed.get("season")
     episode = parsed.get("episode")
     year = parsed.get("year")
-    quality = parsed.get("resolution")
+    quality = parsed.get("quality")
 
     if isinstance(season, list) or isinstance(episode, list):
         LOGGER.warning(f"Invalid season/episode format for {filename}: {parsed}")
@@ -464,35 +528,14 @@ async def metadata(filename: str, channel: int, msg_id, override_id: str = None)
         LOGGER.info(f"No title parsed from: {filename} (parsed={parsed})")
         return None
 
-    # --- Resolve override / default ID ---
-    default_id = None
-    if override_id:
-        try:
-            default_id = extract_default_id(override_id) or override_id
-        except Exception:
-            pass
-
-    if not default_id:
-        try:
-            default_id = extract_default_id(Backend.USE_DEFAULT_ID)
-        except Exception:
-            pass
+    default_id = _resolve_default_id(override_id, filename)
 
-    if not default_id:
-        try:
-            default_id = extract_default_id(filename)
-        except Exception:
-            pass
-
-    data = {"chat_id": channel, "msg_id": msg_id}
     try:
-        encoded_string = await encode_string(data)
+        encoded_string = await encode_string({"chat_id": channel, "msg_id": msg_id})
     except Exception:
         encoded_string = None
 
-    group_key = None
-    if split_info:
-        group_key = f"{channel}:{quality}:{split_info[0]}"
+    group_key = f"{channel}:{quality}:{split_info[0]}" if split_info else None
 
     try:
         if season and episode:
@@ -510,487 +553,186 @@ async def metadata(filename: str, channel: int, msg_id, override_id: str = None)
         return None
 
 
-# =============================================================================
-# TV metadata
-# =============================================================================
+# Pick a default id from the override, the global setting, then the filename itself.
+def _resolve_default_id(override_id, filename) -> str | None:
+    for source in (override_id, getattr(Backend, "USE_DEFAULT_ID", None), filename):
+        if not source:
+            continue
+        try:
+            found = extract_default_id(source) or (override_id if source is override_id else None)
+        except Exception:
+            found = None
+        if found:
+            return found
+    return None
+
+
+# ----------------- TV metadata -----------------
 
+# Resolve TV metadata, preferring Cinemeta and falling back to TMDb.
 async def fetch_tv_metadata(title, season, episode, encoded_string, year=None, quality=None, default_id=None) -> dict | None:
-    imdb_id = None
-    tmdb_id = None
+    imdb_id, tmdb_id, explicit_imdb_id, use_tmdb = _split_default_id(default_id)
     imdb_tv = None
     imdb_ep = None
-    use_tmdb = False
-    explicit_imdb_id = False
-
-    # ------------------------------------------------------------------
-    # 1. Handle explicit default ID
-    # ------------------------------------------------------------------
-    if default_id:
-        default_id = str(default_id)
-        if default_id.startswith("tt"):
-            imdb_id = default_id
-            explicit_imdb_id = True
-        elif default_id.isdigit():
-            tmdb_id = int(default_id)
-            use_tmdb = True
 
-    # ------------------------------------------------------------------
-    # 2. No ID → fuzzy Cinemeta search with query variants
-    # ------------------------------------------------------------------
     if not imdb_id and not tmdb_id:
         imdb_id = await safe_imdb_search(title, "tvSeries", year)
         use_tmdb = not bool(imdb_id)
 
-    # ------------------------------------------------------------------
-    # 3. IMDb / Cinemeta detail fetch
-    # ------------------------------------------------------------------
     if imdb_id and not use_tmdb:
         try:
-            if imdb_id in IMDB_CACHE and isinstance(IMDB_CACHE.get(imdb_id), dict):
-                imdb_tv = IMDB_CACHE[imdb_id]
-            else:
-                async with API_SEMAPHORE:
-                    imdb_tv = await get_detail(imdb_id=imdb_id, media_type="tvSeries")
-                IMDB_CACHE[imdb_id] = imdb_tv
-
-            ep_key = f"{imdb_id}::{season}::{episode}"
-            if ep_key in EPISODE_CACHE:
-                imdb_ep = EPISODE_CACHE[ep_key]
-            else:
-                async with API_SEMAPHORE:
-                    imdb_ep = await get_season(imdb_id=imdb_id, season_id=season, episode_id=episode)
-                EPISODE_CACHE[ep_key] = imdb_ep
-
+            imdb_tv = await _cached_imdb_detail(imdb_id, "tvSeries")
+            imdb_ep = await _cached_imdb_season(imdb_id, season, episode)
         except Exception as e:
-            LOGGER.warning(f"IMDb TV fetch failed [{imdb_id}] → {e}")
-            imdb_tv = None
-            imdb_ep = None
+            LOGGER.warning(f"IMDb TV fetch failed [{imdb_id}] -> {e}")
+            imdb_tv = imdb_ep = None
             use_tmdb = True
 
-    # ------------------------------------------------------------------
-    # 4. Validate IMDb result against query title (guard against Cinemeta
-    #    returning a stale wrong hit despite the fuzzy pre-filter).
-    #    Skipped when the IMDb ID was supplied explicitly, since the user
-    #    deliberately chose that exact ID.
-    # ------------------------------------------------------------------
+    # Guard against Cinemeta returning a wrong hit (skipped for user-supplied ids).
     if imdb_tv and not use_tmdb and not explicit_imdb_id:
-        matched_title = imdb_tv.get("title", "")
-        sim = _title_similarity(title, matched_title)
+        sim = _title_similarity(title, imdb_tv.get("title", ""))
         if sim < _CINEMETA_THRESHOLD:
-            LOGGER.info(
-                f"IMDb detail title mismatch for '{title}': "
-                f"got '{matched_title}' (sim={sim:.2f}) → switching to TMDb"
-            )
+            LOGGER.info(f"IMDb TV title mismatch for '{title}': got '{imdb_tv.get('title', '')}' (sim={sim:.2f}) -> TMDb")
             imdb_tv = None
             use_tmdb = True
 
-    # ------------------------------------------------------------------
-    # 5. Fallback: TMDb
-    # ------------------------------------------------------------------
-    must_use_tmdb = use_tmdb or not imdb_tv
-
-    if must_use_tmdb:
-        LOGGER.info(f"No valid Cinemeta TV data for '{title}' S{season:02d}E{episode:02d} → using TMDb")
-
+    if use_tmdb or not imdb_tv:
+        LOGGER.info(f"No valid Cinemeta TV data for '{title}' S{season:02d}E{episode:02d} -> using TMDb")
         if not tmdb_id:
-            # Try with year first, then without
-            tmdb_search = await safe_tmdb_search(title, "tv", year)
-            if not tmdb_search and year:
-                tmdb_search = await safe_tmdb_search(title, "tv", None)
-
+            tmdb_search = await safe_tmdb_search(title, "tv", year) or (await safe_tmdb_search(title, "tv", None) if year else None)
             if not tmdb_search:
-                LOGGER.info(
-                    f"No TMDb TV result for '{title}' S{season:02d}E{episode:02d} "
-                    f"(year={year}) – metadata unavailable"
-                )
+                LOGGER.info(f"No TMDb TV result for '{title}' S{season:02d}E{episode:02d} (year={year})")
                 return None
             tmdb_id = tmdb_search.id
 
-        tv = await _tmdb_tv_details(tmdb_id)
+        tv = await _tmdb_details("tv", tmdb_id)
         if not tv:
             LOGGER.info(f"TMDb TV details failed for id={tmdb_id} ('{title}')")
             return None
-
         ep = await _tmdb_episode_details(tmdb_id, season, episode)
+        return _build_tmdb_tv_payload(tv, ep, season, episode, quality, encoded_string)
 
-        credits = getattr(tv, "credits", None) or {}
-        cast_arr = getattr(credits, "cast", []) or []
-        cast = [
-            getattr(c, "name", None) or getattr(c, "original_name", None)
-            for c in cast_arr
-        ]
+    return _build_imdb_tv_payload(imdb_tv, imdb_ep or {}, imdb_id, title, season, episode, quality, encoded_string)
 
-        ep_runtime = getattr(ep, "runtime", None) if ep else None
-        series_runtime = tv.episode_run_time[0] if getattr(tv, "episode_run_time", None) else None
-        runtime_val = ep_runtime or series_runtime
-        runtime = f"{runtime_val} min" if runtime_val else ""
-
-        return {
-            "tmdb_id": tv.id,
-            "imdb_id": getattr(getattr(tv, "external_ids", None), "imdb_id", None),
-            "title": tv.name,
-            "year": getattr(tv.first_air_date, "year", 0) if getattr(tv, "first_air_date", None) else 0,
-            "rate": getattr(tv, "vote_average", 0) or 0,
-            "description": tv.overview or "",
-            "poster": format_tmdb_image(tv.poster_path),
-            "backdrop": format_tmdb_image(tv.backdrop_path, "original"),
-            "logo": get_tmdb_logo(getattr(tv, "images", None)),
-            "genres": [g.name for g in (tv.genres or [])],
-            "media_type": "tv",
-            "cast": cast,
-            "runtime": str(runtime),
-            "season_number": season,
-            "episode_number": episode,
-            "episode_title": getattr(ep, "name", f"S{season:02d}E{episode:02d}") if ep else f"S{season:02d}E{episode:02d}",
-            "episode_backdrop": format_tmdb_image(getattr(ep, "still_path", None), "original") if ep else "",
-            "episode_overview": getattr(ep, "overview", "") if ep else "",
-            "episode_released": (
-                ep.air_date.strftime("%Y-%m-%dT05:00:00.000Z")
-                if getattr(ep, "air_date", None)
-                else ""
-            ),
-            "quality": quality,
-            "encoded_string": encoded_string,
-        }
-
-    # ------------------------------------------------------------------
-    # 6. IMDb / Cinemeta path
-    # ------------------------------------------------------------------
-    imdb = imdb_tv or {}
-    ep = imdb_ep or {}
-    images = format_imdb_images(imdb_id)
-
-    return {
-        "tmdb_id": imdb.get("moviedb_id") or (imdb_id.replace("tt", "") if imdb_id else None),
-        "imdb_id": imdb_id,
-        "title": imdb.get("title", title),
-        "year": imdb.get("releaseDetailed", {}).get("year", 0),
-        "rate": imdb.get("rating", {}).get("star", 0),
-        "description": imdb.get("plot", ""),
-        "poster": images["poster"],
-        "backdrop": images["backdrop"],
-        "logo": images["logo"],
-        "cast": imdb.get("cast", []),
-        "runtime": str(imdb.get("runtime") or ""),
-        "genres": imdb.get("genre", []),
-        "media_type": "tv",
-        "season_number": season,
-        "episode_number": episode,
-        "episode_title": ep.get("title", f"S{season:02d}E{episode:02d}"),
-        "episode_backdrop": ep.get("image", ""),
-        "episode_overview": ep.get("plot", ""),
-        "episode_released": str(ep.get("released", "")),
-        "quality": quality,
-        "encoded_string": encoded_string,
-    }
 
+# ----------------- Movie metadata -----------------
 
-# =============================================================================
-# Movie metadata
-# =============================================================================
-
+# Resolve movie metadata, preferring Cinemeta and falling back to TMDb.
 async def fetch_movie_metadata(title, encoded_string, year=None, quality=None, default_id=None) -> dict | None:
-    imdb_id = None
-    tmdb_id = None
+    imdb_id, tmdb_id, explicit_imdb_id, use_tmdb = _split_default_id(default_id)
     imdb_details = None
-    use_tmdb = False
-    explicit_imdb_id = False
-
-    # ------------------------------------------------------------------
-    # 1. Explicit default ID
-    # ------------------------------------------------------------------
-    if default_id:
-        default_id = str(default_id).strip()
-        if default_id.startswith("tt"):
-            imdb_id = default_id
-            explicit_imdb_id = True
-        elif default_id.isdigit():
-            tmdb_id = int(default_id)
-            use_tmdb = True
 
-    # ------------------------------------------------------------------
-    # 2. No ID → fuzzy Cinemeta search (tries year variants internally)
-    # ------------------------------------------------------------------
     if not imdb_id and not tmdb_id:
         imdb_id = await safe_imdb_search(title, "movie", year)
         use_tmdb = not bool(imdb_id)
 
-    # ------------------------------------------------------------------
-    # 3. IMDb detail fetch
-    # ------------------------------------------------------------------
     if imdb_id and not use_tmdb:
         try:
-            if imdb_id in IMDB_CACHE and isinstance(IMDB_CACHE.get(imdb_id), dict):
-                imdb_details = IMDB_CACHE[imdb_id]
-            else:
-                async with API_SEMAPHORE:
-                    imdb_details = await get_detail(imdb_id=imdb_id, media_type="movie")
-                IMDB_CACHE[imdb_id] = imdb_details
-
+            imdb_details = await _cached_imdb_detail(imdb_id, "movie")
         except Exception as e:
-            LOGGER.warning(f"IMDb movie fetch failed [{title}] → {e}")
+            LOGGER.warning(f"IMDb movie fetch failed [{title}] -> {e}")
             imdb_details = None
             use_tmdb = True
 
-    # ------------------------------------------------------------------
-    # 4. Validate IMDb result title against query
-    #    (skipped when the IMDb ID was supplied explicitly — e.g. manual
-    #     /set or web "Rescan Metadata" — since the user chose the exact ID)
-    # ------------------------------------------------------------------
+    # Guard against Cinemeta returning a wrong hit (skipped for user-supplied ids).
     if imdb_details and not use_tmdb and not explicit_imdb_id:
-        matched_title = imdb_details.get("title", "")
-        sim = _title_similarity(title, matched_title)
+        sim = _title_similarity(title, imdb_details.get("title", ""))
         if sim < _CINEMETA_THRESHOLD:
-            LOGGER.info(
-                f"IMDb detail title mismatch for '{title}': "
-                f"got '{matched_title}' (sim={sim:.2f}) → switching to TMDb"
-            )
+            LOGGER.info(f"IMDb movie title mismatch for '{title}': got '{imdb_details.get('title', '')}' (sim={sim:.2f}) -> TMDb")
             imdb_details = None
             use_tmdb = True
 
-    # ------------------------------------------------------------------
-    # 5. Fallback: TMDb
-    # ------------------------------------------------------------------
-    must_use_tmdb = use_tmdb or not imdb_details
-
-    if must_use_tmdb:
-        LOGGER.info(f"No valid Cinemeta movie data for '{title}' (year={year}) → using TMDb")
-
+    if use_tmdb or not imdb_details:
+        LOGGER.info(f"No valid Cinemeta movie data for '{title}' (year={year}) -> using TMDb")
         if not tmdb_id:
-            tmdb_result = await safe_tmdb_search(title, "movie", year)
-            # Retry without year restriction for newer/unlisted titles
-            if not tmdb_result and year:
-                tmdb_result = await safe_tmdb_search(title, "movie", None)
-
+            tmdb_result = await safe_tmdb_search(title, "movie", year) or (await safe_tmdb_search(title, "movie", None) if year else None)
             if not tmdb_result:
-                LOGGER.info(
-                    f"No TMDb movie found for '{title}' (year={year}) "
-                    f"– metadata unavailable"
-                )
+                LOGGER.info(f"No TMDb movie found for '{title}' (year={year})")
                 return None
             tmdb_id = tmdb_result.id
 
-        movie = await _tmdb_movie_details(tmdb_id)
+        movie = await _tmdb_details("movie", tmdb_id)
         if not movie:
             LOGGER.info(f"TMDb movie details failed for id={tmdb_id} ('{title}')")
             return None
+        return _build_tmdb_movie_payload(movie, quality, encoded_string)
 
-        credits = getattr(movie, "credits", None) or {}
-        cast_arr = getattr(credits, "cast", []) or []
-        cast_names = [
-            getattr(c, "name", None) or getattr(c, "original_name", None)
-            for c in cast_arr
-        ]
+    return _build_imdb_movie_payload(imdb_details, imdb_id, title, quality, encoded_string)
 
-        runtime_val = getattr(movie, "runtime", None)
-        runtime = f"{runtime_val} min" if runtime_val else ""
 
-        return {
-            "tmdb_id": movie.id,
-            "imdb_id": getattr(movie.external_ids, "imdb_id", None),
-            "title": movie.title,
-            "year": getattr(movie.release_date, "year", 0) if getattr(movie, "release_date", None) else 0,
-            "rate": getattr(movie, "vote_average", 0) or 0,
-            "description": movie.overview or "",
-            "poster": format_tmdb_image(movie.poster_path),
-            "backdrop": format_tmdb_image(movie.backdrop_path, "original"),
-            "logo": get_tmdb_logo(getattr(movie, "images", None)),
-            "cast": cast_names,
-            "runtime": str(runtime),
-            "media_type": "movie",
-            "genres": [g.name for g in (movie.genres or [])],
-            "quality": quality,
-            "encoded_string": encoded_string,
-        }
-
-    # ------------------------------------------------------------------
-    # 6. IMDb / Cinemeta path
-    # ------------------------------------------------------------------
-    images = format_imdb_images(imdb_id)
-    imdb = imdb_details or {}
+# ----------------- Candidate search (used by the /set command UI) -----------------
 
+# Build a single candidate dict for the picker UI.
+def _candidate_entry(source, title, year, imdb_id, tmdb_id, poster, backdrop, subtitle) -> dict:
     return {
-        "tmdb_id": imdb.get("moviedb_id") or (imdb_id.replace("tt", "") if imdb_id else None),
+        "source": source,
+        "title": title or "",
+        "year": year or "",
         "imdb_id": imdb_id,
-        "title": imdb.get("title", title),
-        "year": imdb.get("releaseDetailed", {}).get("year", 0),
-        "rate": imdb.get("rating", {}).get("star", 0),
-        "description": imdb.get("plot", ""),
-        "poster": images["poster"],
-        "backdrop": images["backdrop"],
-        "logo": images["logo"],
-        "cast": imdb.get("cast", []),
-        "runtime": str(imdb.get("runtime") or ""),
-        "media_type": "movie",
-        "genres": imdb.get("genre", []),
-        "quality": quality,
-        "encoded_string": encoded_string,
+        "tmdb_id": tmdb_id,
+        "poster": poster,
+        "backdrop": backdrop,
+        "subtitle": subtitle,
     }
 
 
-# =============================================================================
-# Candidate-search helpers (used by the /set command UI)
-# =============================================================================
-
-async def search_movie_candidates(query: str, year: int | None = None, limit: int = 8) -> list[dict]:
+# Search IMDb + TMDb for picker candidates of the given media type.
+async def _search_candidates(query: str, media_type: str, year: int | None = None, limit: int = 8) -> list[dict]:
     query = (query or "").strip()
     if not query:
         return []
 
+    imdb_type = "movie" if media_type == "movie" else "tvSeries"
     results: list[dict] = []
     seen: set[tuple[str, str]] = set()
 
     try:
-        imdb_result = await search_title(query=query, type="movie")
-        if imdb_result and imdb_result.get("id"):
-            key = ("imdb", imdb_result["id"])
-            if key not in seen:
-                seen.add(key)
-                results.append({
-                    "source": "imdb",
-                    "title": imdb_result.get("title", ""),
-                    "year": imdb_result.get("year", ""),
-                    "imdb_id": imdb_result.get("id"),
-                    "tmdb_id": imdb_result.get("moviedb_id"),
-                    "poster": imdb_result.get("poster", ""),
-                    "backdrop": "",
-                    "subtitle": "IMDb / Cinemeta",
-                })
+        imdb_hit = await search_title(query=query, type=imdb_type)
+        if imdb_hit and imdb_hit.get("id"):
+            seen.add(("imdb", imdb_hit["id"]))
+            results.append(_candidate_entry(
+                "imdb", imdb_hit.get("title", ""), imdb_hit.get("year", ""),
+                imdb_hit.get("id"), imdb_hit.get("moviedb_id"),
+                imdb_hit.get("poster", ""), "", "IMDb / Cinemeta",
+            ))
     except Exception as e:
-        LOGGER.warning(f"IMDb movie candidate search failed for '{query}': {e}")
+        LOGGER.warning(f"IMDb {media_type} candidate search failed for '{query}': {e}")
 
     try:
-        async with API_SEMAPHORE:
-            tmdb_results = (
-                await get_tmdb_client().search().movies(query=query, year=year)
-                if year
-                else await get_tmdb_client().search().movies(query=query)
-            )
-
+        tmdb_results = await _tmdb_raw_search(query, media_type, year if media_type == "movie" else None)
         for item in (tmdb_results or [])[:limit]:
             tmdb_id = getattr(item, "id", None)
-            if not tmdb_id:
-                continue
-
-            imdb_id = None
-            try:
-                details = await _tmdb_movie_details(tmdb_id)
-                ext = getattr(details, "external_ids", None) if details else None
-                imdb_id = getattr(ext, "imdb_id", None) if ext else None
-            except Exception:
-                pass
-
-            key = ("tmdb", str(tmdb_id))
-            if key in seen:
+            if not tmdb_id or ("tmdb", str(tmdb_id)) in seen:
                 continue
-            seen.add(key)
-
-            release_date = getattr(item, "release_date", None)
-            year_value = getattr(release_date, "year", None) if release_date else None
-
-            results.append({
-                "source": "tmdb",
-                "title": getattr(item, "title", "") or "",
-                "year": year_value or "",
-                "imdb_id": imdb_id,
-                "tmdb_id": tmdb_id,
-                "poster": format_tmdb_image(getattr(item, "poster_path", None)),
-                "backdrop": format_tmdb_image(getattr(item, "backdrop_path", None), "original"),
-                "subtitle": "TMDb",
-            })
+            seen.add(("tmdb", str(tmdb_id)))
+            imdb_id = await _tmdb_external_imdb_id(media_type, tmdb_id)
+            r_title, r_year = _tmdb_title_year(item, media_type)
+            results.append(_candidate_entry(
+                "tmdb", r_title, r_year or "", imdb_id, tmdb_id,
+                format_tmdb_image(getattr(item, "poster_path", None)),
+                format_tmdb_image(getattr(item, "backdrop_path", None), "original"),
+                "TMDb",
+            ))
     except Exception as e:
-        LOGGER.warning(f"TMDb movie candidate search failed for '{query}': {e}")
+        LOGGER.warning(f"TMDb {media_type} candidate search failed for '{query}': {e}")
 
     return results[:limit]
 
 
-async def search_tv_candidates(query: str, limit: int = 8) -> list[dict]:
-    query = (query or "").strip()
-    if not query:
-        return []
-
-    results: list[dict] = []
-    seen: set[tuple[str, str]] = set()
-
-    try:
-        imdb_result = await search_title(query=query, type="tvSeries")
-        if imdb_result and imdb_result.get("id"):
-            key = ("imdb", imdb_result["id"])
-            if key not in seen:
-                seen.add(key)
-                results.append({
-                    "source": "imdb",
-                    "title": imdb_result.get("title", ""),
-                    "year": imdb_result.get("year", ""),
-                    "imdb_id": imdb_result.get("id"),
-                    "tmdb_id": imdb_result.get("moviedb_id"),
-                    "poster": imdb_result.get("poster", ""),
-                    "backdrop": "",
-                    "subtitle": "IMDb / Cinemeta",
-                })
-    except Exception as e:
-        LOGGER.warning(f"IMDb TV candidate search failed for '{query}': {e}")
-
-    try:
-        async with API_SEMAPHORE:
-            tmdb_results = await get_tmdb_client().search().tv(query=query)
-
-        for item in (tmdb_results or [])[:limit]:
-            tmdb_id = getattr(item, "id", None)
-            if not tmdb_id:
-                continue
-
-            imdb_id = None
-            try:
-                details = await _tmdb_tv_details(tmdb_id)
-                ext = getattr(details, "external_ids", None) if details else None
-                imdb_id = getattr(ext, "imdb_id", None) if ext else None
-            except Exception:
-                pass
-
-            key = ("tmdb", str(tmdb_id))
-            if key in seen:
-                continue
-            seen.add(key)
-
-            first_air_date = getattr(item, "first_air_date", None)
-            year_value = getattr(first_air_date, "year", None) if first_air_date else None
-
-            results.append({
-                "source": "tmdb",
-                "title": getattr(item, "name", "") or "",
-                "year": year_value or "",
-                "imdb_id": imdb_id,
-                "tmdb_id": tmdb_id,
-                "poster": format_tmdb_image(getattr(item, "poster_path", None)),
-                "backdrop": format_tmdb_image(getattr(item, "backdrop_path", None), "original"),
-                "subtitle": "TMDb",
-            })
-    except Exception as e:
-        LOGGER.warning(f"TMDb TV candidate search failed for '{query}': {e}")
-
-    return results[:limit]
+# Search movie candidates for the picker UI.
+async def search_movie_candidates(query: str, year: int | None = None, limit: int = 8) -> list[dict]:
+    return await _search_candidates(query, "movie", year, limit)
 
 
-# =============================================================================
-# Manual /set command helpers
-# =============================================================================
+# Search TV candidates for the picker UI.
+async def search_tv_candidates(query: str, limit: int = 8) -> list[dict]:
+    return await _search_candidates(query, "tv", None, limit)
 
-async def fetch_selected_movie_metadata(selected_id: str) -> dict | None:
-    selected_id = str(selected_id).strip()
-    if not selected_id:
-        return None
 
-    data = await fetch_movie_metadata(
-        title="manual-rescan",
-        encoded_string=None,
-        year=None,
-        quality=None,
-        default_id=selected_id
-    )
-    if not data:
-        return None
+# ----------------- Manual /set command helpers -----------------
 
+# Reshape an indexer payload into the manual-rescan response shape.
+def _to_selection_payload(data: dict, media_type: str) -> dict:
     return {
         "tmdb_id": data.get("tmdb_id"),
         "imdb_id": data.get("imdb_id"),
@@ -1004,28 +746,29 @@ async def fetch_selected_movie_metadata(selected_id: str) -> dict | None:
         "genres": data.get("genres", []),
         "cast": data.get("cast", []),
         "runtime": data.get("runtime"),
-        "media_type": "movie",
+        "media_type": media_type,
     }
 
 
-async def fetch_selected_tv_metadata(selected_id: str) -> dict | None:
+# Fetch full movie metadata for a manually selected id.
+async def fetch_selected_movie_metadata(selected_id: str) -> dict | None:
     selected_id = str(selected_id).strip()
     if not selected_id:
         return None
+    data = await fetch_movie_metadata(
+        title="manual-rescan", encoded_string=None, year=None, quality=None, default_id=selected_id
+    )
+    return _to_selection_payload(data, "movie") if data else None
 
-    imdb_id = None
-    tmdb_id = None
-    imdb_tv = None
-    use_tmdb = False
 
-    if selected_id.startswith("tt"):
-        imdb_id = selected_id
-    elif selected_id.isdigit():
-        tmdb_id = int(selected_id)
-        use_tmdb = True
-    else:
+# Fetch full TV metadata for a manually selected id.
+async def fetch_selected_tv_metadata(selected_id: str) -> dict | None:
+    selected_id = str(selected_id).strip()
+    imdb_id, tmdb_id, _, use_tmdb = _split_default_id(selected_id)
+    if not imdb_id and not tmdb_id:
         return None
 
+    imdb_tv = None
     if imdb_id and not use_tmdb:
         try:
             imdb_tv = await get_detail(imdb_id=imdb_id, media_type="tvSeries")
@@ -1039,36 +782,26 @@ async def fetch_selected_tv_metadata(selected_id: str) -> dict | None:
                 tmdb_id = int(imdb_tv["moviedb_id"])
             except Exception:
                 tmdb_id = None
-
         if not tmdb_id:
             return None
 
-        tv = await _tmdb_tv_details(tmdb_id)
+        tv = await _tmdb_details("tv", tmdb_id)
         if not tv:
             return None
-
-        credits = getattr(tv, "credits", None) or {}
-        cast_arr = getattr(credits, "cast", []) or []
-        cast = [
-            getattr(c, "name", None) or getattr(c, "original_name", None)
-            for c in cast_arr
-        ]
-
-        runtime_val = tv.episode_run_time[0] if getattr(tv, "episode_run_time", None) else None
-        runtime = f"{runtime_val} min" if runtime_val else ""
-
+        first_air = getattr(tv, "first_air_date", None)
+        runtime = _format_runtime(tv.episode_run_time[0] if getattr(tv, "episode_run_time", None) else None)
         return {
             "tmdb_id": tv.id,
             "imdb_id": getattr(getattr(tv, "external_ids", None), "imdb_id", None),
             "title": tv.name,
-            "release_year": getattr(tv.first_air_date, "year", 0) if getattr(tv, "first_air_date", None) else 0,
+            "release_year": getattr(first_air, "year", 0) if first_air else 0,
             "rating": getattr(tv, "vote_average", 0) or 0,
             "description": tv.overview or "",
             "poster": format_tmdb_image(tv.poster_path),
             "backdrop": format_tmdb_image(tv.backdrop_path, "original"),
             "logo": get_tmdb_logo(getattr(tv, "images", None)),
             "genres": [g.name for g in (tv.genres or [])],
-            "cast": cast,
+            "cast": _extract_cast(tv),
             "runtime": str(runtime),
             "media_type": "tv",
         }

README.md

@@ -46,16 +46,10 @@
 
 * [🔧 Configuration Guide](#-configuration-guide)
 
-  * [🚀 Quick Setup](#-quick-setup)
-  * [🧩 Startup Configuration](#-startup-configuration)
-  * [📚 Media & Catalog Settings](#-media--catalog-settings)
-  * [🌐 Proxy Settings](#-proxy-settings)
-  * [💳 Subscription System](#-subscription-system)
-  * [🧠 Admin Panel](#-admin-panel)
-  * [🔄 Update Settings](#-update-settings)
-  * [🗄️ Multi-Database Support](#️-multi-database-support)
-  * [🔑 Multi-Token System](#-multi-token-system)
-  * [🔍 Global Search Requirements](#-global-search-requirements)
+  * [🪜 Step 1: Create Your config.env File](#-step-1-create-your-configenv-file)
+  * [🔑 Step 2: How to Get Each Value](#-step-2-how-to-get-each-value)
+  * [📱 Step 3: Generate Your Telegram Session String](#-step-3-generate-your-telegram-session-string)
+  * [🧩 Step 4: Configure Everything Else (Web Settings Page)](#-step-4-configure-everything-else-web-settings-page)
 
 * [🚀 Deployment Guide](#-deployment-guide)
 
@@ -63,10 +57,10 @@
   * [🐙 Heroku Guide](#-heroku-guide)
   * [🐳 VPS Guide (Recommended)](#-vps-guide-recommended)
 
-* [📺 Setting Up Stremio](#-setting-up-stremio)
+* [📺 Setting Up Your App (Nuvio Recommended)](#-setting-up-your-app-nuvio-recommended)
 
-  * [🌐 Add the Addon](#-step-3-add-the-addon)
-  * [⚙️ Optional: Remove Cinemeta](#️-optional-remove-cinemeta)
+  * [📥 Install Nuvio](#-step-1-install-nuvio)
+  * [🌐 Add the Addon](#-step-2-add-the-addon)
 
 * [🏅 Contributors](#-contributors)
 
@@ -248,7 +242,7 @@ The `/set` command is used to manually upload a specific Movie or TV show to you
 **Example:**
 
 ```
-/set https://m.imdb.com/title/tt665723
+/set https://www.imdb.com/title/tt0468569/
 ```
 
 **Steps:**
@@ -263,117 +257,200 @@ The `/set` command is used to manually upload a specific Movie or TV show to you
 
 # 🔧 Configuration Guide
 
-> 💡 You only need to edit `config.env` for startup credentials, database connection, and optional Userbot configuration. Everything else can be managed from the Web UI.
+> 😌 **Don’t worry — setup is easier than it looks.**
+> You only fill in **6 values once** inside a single file called `config.env`. Everything else (TMDB key, channels, admin login, subscriptions, proxy…) is configured later from a friendly **Web Settings page** — no code, no restarts.
+
+Think of configuration as **two simple layers**:
+
+| Layer | Where | When you set it | What goes here |
+| :--- | :--- | :--- | :--- |
+| 🧱 **Startup** | `config.env` file | Once, before first launch | The core credentials needed to boot |
+| 🎛️ **Runtime** | **Web Settings page** | Anytime, after launch | Everything else — saved to the database, applied live |
 
 ---
 
-## 🧩 Startup Configuration
+## 🪜 Step 1: Create Your config.env File
+
+After cloning the project, copy the sample file and open it for editing:
+
+```bash
+cp sample_config.env config.env
+nano config.env
+```
 
-| Variable                  | Description                                                                                                 |
-| :------------------------ | :---------------------------------------------------------------------------------------------------------- |
-| **`API_ID`**              | Telegram API ID obtained from `my.telegram.org`. Required for all Telegram client connections.              |
-| **`API_HASH`**            | Telegram API Hash obtained from `my.telegram.org`. Required for Telegram authentication.                    |
-| **`BOT_TOKEN`**           | Main bot token generated via `@BotFather`. Used for streaming, indexing, and user interactions.             |
-| **`OWNER_ID`**            | Your Telegram User ID. Grants full administrative access to the system.                                     |
-| **`DATABASE`**            | MongoDB connection URI(s). Used to store metadata, settings, catalogs, subscriptions, and application data. |
-| **`PORT`**                | Port on which the FastAPI server runs. Default: `8000`.                                                     |
-| **`USER_SESSION_STRING`** | Optional Userbot session string. Required only for Global Search functionality.                             |
+Fill in these values:
+
+| Variable | Required | What it is |
+| :--- | :---: | :--- |
+| `API_ID` | ✅ | Telegram API ID (from my.telegram.org) |
+| `API_HASH` | ✅ | Telegram API Hash (from my.telegram.org) |
+| `BOT_TOKEN` | ✅ | Your bot token (from @BotFather) |
+| `OWNER_ID` | ✅ | Your numeric Telegram user ID |
+| `DATABASE` | ✅ | **Two** MongoDB URIs, separated by a comma |
+| `PORT` | ✅ | Web server port (keep `8000` unless it’s busy) |
+| `USER_SESSION_STRING` | ⬜ | Optional — only needed for **Global Search** |
+
+A completed file looks like this (these are just example values):
+
+```env
+API_ID="1234567"
+API_HASH="abc123def456ghi789jkl012mno345pq"
+BOT_TOKEN="1234567890:AAEabcdEFGhijkLMnOPqrsTUVwxyz12345"
+USER_SESSION_STRING=""
+OWNER_ID="987654321"
+DATABASE="mongodb+srv://user:pass@cluster0.xxxx.mongodb.net/tracking,mongodb+srv://user:pass@cluster0.xxxx.mongodb.net/storage1"
+PORT="8000"
+```
+
+> 💾 To save in nano: press `Ctrl + O`, then `Enter`, then `Ctrl + X`.
 
 ---
 
-# ⚙️ Web Panel Configuration
+## 🔑 Step 2: How to Get Each Value
 
-The following settings are automatically loaded from the database and can be managed through the Web Admin Panel.
+Take it one line at a time — each value comes from a quick, free step.
 
-## 📚 Media & Catalog Settings
+### 🆔 API_ID & API_HASH
+1. Go to **https://my.telegram.org** and log in with your phone number.
+2. Open **API development tools**.
+3. Create an app (any title works, e.g. `stremio`).
+4. Copy **App api_id** → `API_ID` and **App api_hash** → `API_HASH`.
 
-| Variable                     | Description                                                                                                    |
-| :--------------------------- | :------------------------------------------------------------------------------------------------------------- |
-| **`REPLACE_MODE`**           | When enabled, newly uploaded files replace existing files with the same quality label (`720p`, `1080p`, etc.). |
-| **`HIDE_CATALOG`**           | Hides the default Telegram Stremio catalog and shows streams only through Cinemata integration.                |
-| **`AUTH_CHANNEL`**           | Telegram channel IDs used for media indexing and streaming. Multiple channels are supported.                   |
-| **`TMDB_API`**               | TMDb API key used to fetch movie and TV show metadata automatically.                                           |
-| **`GLOBAL_SEARCH`**          | Enables searching media across configured Global Search channels. Requires a valid `USER_SESSION_STRING`.      |
-| **`GLOBAL_SEARCH_CHANNELS`** | List of channel IDs included in Global Search. Searches are restricted to these channels only.                 |
+### 🤖 BOT_TOKEN
+1. Open **@BotFather** in Telegram.
+2. Send `/newbot` and follow the prompts (choose a name and a username).
+3. Copy the token it gives you → `BOT_TOKEN`.
+4. ⭐ Add this bot as an **admin** in every channel you’ll use for media.
 
----
+### 👤 OWNER_ID
+1. Open **@userinfobot** in Telegram (or send `/id` to **@MissRose_bot**).
+2. It replies with your numeric ID → `OWNER_ID`.
 
-## 🌐 Proxy Settings
+### 🗄️ DATABASE (two MongoDB URIs)
+You need **two** free MongoDB databases — the first stores tracking/metadata, the second stores your media references.
 
-| Variable                            | Description                                                             |
-| :---------------------------------- | :---------------------------------------------------------------------- |
-| **`HTTP_PROXY_URL`**                | Optional HTTP proxy used for metadata requests and external API access. |
-| **`SHOW_PROXY_AND_NON_PROXY_BOTH`** | Shows both proxied and direct stream links simultaneously.              |
+1. Create a free account at **https://www.mongodb.com/atlas** (the forever-free **M0** tier is enough to start).
+2. Create a cluster → in **Database Access**, add a database user and password.
+3. In **Network Access**, add `0.0.0.0/0` (allow access from anywhere).
+4. Click **Connect → Drivers** and copy the connection string, e.g.
+   `mongodb+srv://user:pass@cluster0.xxxx.mongodb.net/`
+5. Add a database name at the end of each (e.g. `/tracking` and `/storage1`).
+6. Put **both** strings on one line, separated by a comma:
+   ```
+   DATABASE="mongodb+srv://.../tracking,mongodb+srv://.../storage1"
+   ```
 
----
+> 💡 You can use the **same cluster** for both — just give them two different database names. Need more space later? Add extra storage databases from the Web Settings page (no restart required).
 
-## 💳 Subscription System
+### 🔢 PORT
+Leave it as `8000` unless that port is already in use. Your reverse proxy / domain will point here.
 
-| Variable                    | Description                                                                |
-| :-------------------------- | :------------------------------------------------------------------------- |
-| **`SUBSCRIPTION`**          | Enables subscription-based access control for streams.                     |
-| **`SUBSCRIPTION_GROUP_ID`** | Telegram group/channel where approved subscribers are invited.             |
-| **`APPROVER_IDS`**          | Telegram user IDs allowed to approve or reject subscription requests.      |
-| **`SUBSCRIPTION_URL`**      | Bot or payment URL displayed to users when their subscription has expired. |
+### 📱 USER_SESSION_STRING (optional)
+Only needed if you want **Global Search**. It’s safe and quick to generate — see **Step 3** below. If you don’t need Global Search, leave it empty.
 
 ---
 
-## 🧠 Admin Panel
+## 📱 Step 3: Generate Your Telegram Session String
 
-| Variable             | Description                                                                                      |
-| :------------------- | :----------------------------------------------------------------------------------------------- |
-| **`ADMIN_USERNAME`** | Username used to access the Web Admin Panel.                                                     |
-| **`ADMIN_PASSWORD`** | Password used to access the Web Admin Panel. Change the default values immediately for security. |
+> 😊 **No app installation required — and it’s safe.**
+> A session string is simply a “stay logged in” token for **your own** Telegram account, exactly like signing into Telegram Web. The bot never sees your password, and you can revoke access anytime from **Telegram → Settings → Devices**.
 
----
+> ⏭️ **Skip this step** entirely if you don’t plan to use Global Search.
 
-## 🔄 Update Settings
+### 🌐 Easiest Method: Google Colab (works right in your phone’s browser)
 
-| Variable              | Description                                   |
-| :-------------------- | :-------------------------------------------- |
-| **`UPSTREAM_REPO`**   | Git repository URL used by the update system. |
-| **`UPSTREAM_BRANCH`** | Branch that the updater should track.         |
+1️⃣ Open **https://colab.new** in your browser.
 
----
+2️⃣ Sign in with your Google account.
 
-## 🗄️ Multi-Database Support
+3️⃣ Tap **“+ Code”** to add a new code cell.
 
-| Variable              | Description                                                                                                                             |
-| :-------------------- | :-------------------------------------------------------------------------------------------------------------------------------------- |
-| **`EXTRA_DATABASES`** | Additional MongoDB databases used for load balancing, scalability, and redundancy. Can be added or removed directly from the Web Panel. |
+4️⃣ Paste the code below and press ▶ **Run**:
 
----
+```python
+!pip install pyrogram tgcrypto
+
+import asyncio
+from pyrogram import Client
 
-## 🔑 Multi-Token System
+api_id = int(input("API ID: "))
+api_hash = input("API HASH: ")
 
-| Variable           | Description                                                                                |
-| :----------------- | :----------------------------------------------------------------------------------------- |
-| **`MULTI_TOKENS`** | Additional bot tokens used to distribute download traffic and reduce Telegram rate limits. |
+async def main():
+    async with Client("temp_session", api_id, api_hash) as app:
+        print("\nYour USER_SESSION_STRING is:\n")
+        print(await app.export_session_string())
+
+await main()
+```
 
-### About Multi-Token Support
+5️⃣ Enter your **API ID** and **API HASH** when prompted.
 
-If your addon handles a large number of concurrent streams or downloads, Telegram may rate-limit a single bot.
+6️⃣ Enter the **login code** Telegram sends you (and your 2-step password, if you have one).
 
-To avoid this:
+7️⃣ Your **USER_SESSION_STRING** is printed on screen — copy the whole string into `config.env`.
 
-1. Create multiple bots using `@BotFather`.
-2. Add each bot as an admin in all AUTH CHANNELS.
-3. Add their tokens in the **Multi Token** section of the Web Panel.
-4. The system automatically distributes traffic across all available bots.
+> 🔒 **Keep it private.** Anyone who has this string can access your account, so never share it or commit it to a public repository. To invalidate it instantly, just remove the session from Telegram’s **Devices** list.
 
 ---
 
-## 🔍 Global Search Requirements
+## 🧩 Step 4: Configure Everything Else (Web Settings Page)
+
+Once the server is running, open it in your browser:
+
+| Setup | Open this URL |
+| :--- | :--- |
+| **VPS with a domain** | `https://your-domain.com` |
+| **Local / direct IP** | `http://<your-vps-ip>:8000` |
+
+You’ll land on the **login page** (`/login`). Sign in with the default credentials:
+
+```
+Username: admin
+Password: admin
+```
 
-Global Search requires a valid Userbot session.
+Then go to **Settings** (`/admin/settings`).
 
-* Configure `USER_SESSION_STRING` in `config.env`.
-* Enable **Global Search** from the Web Panel.
-* Add one or more **Global Search Channels**.
-* Searches will only be performed within the configured Global Search channels.
+> 🚨 **Do this first:** change the admin password in the **Admin Authentication** card, then click **Save Settings**.
 
-> ⚠️ If `USER_SESSION_STRING` is not configured, Global Search cannot be enabled.
+Everything below is stored in the database and applied **instantly — no restart needed** (the only exception is `USER_SESSION_STRING`, which lives in `config.env`).
 
+### ⚙️ General
+| Option | What it does |
+| :--- | :--- |
+| **Replace Mode** | When a new file has the same quality (`720p`, `1080p`…) as an existing one, it replaces the old entry. Recommended **ON**. |
+| **Hide Catalog** | Hides the public Stremio catalog (direct streams still work). |
+
+### 🛡️ Admin Authentication
+| Field | What to enter |
+| :--- | :--- |
+| **Admin Username / Password** | Your Web Panel login. Leave the password blank to keep the current one. **Change the defaults right away.** |
+| **AUTH_CHANNELS** | The channel(s) the bot indexes and streams from. Add each one by `@username` or `-100…` ID. Make sure your bot is an **admin** in each channel. |
+
+### 🎬 Media & Content
+| Field | What to enter |
+| :--- | :--- |
+| **TMDB API Key** | A free TMDB **v3** key from themoviedb.org → Settings → API. Powers automatic metadata matching. |
+| **Base URL** | Your public address, e.g. `https://your-domain.com`. **Important:** Stremio uses this to reach your streams. |
+| **Upstream Repo / Branch** | Optional — used by `/restart` to auto-update (e.g. repo `weebzone/Telegram-Stremio`, branch `master`). |
+
+### 💳 Subscription (optional)
+Turn this on to monetise access. Set the **Subscription Group ID**, **Subscription URL**, **Payment Instructions** (your UPI / bank / PayPal text), an optional **Payment QR image URL**, and the **Approver IDs** (who can approve requests). The full flow is described in [Subscription Management](#-subscription-management).
+
+### 🌐 Global Search (optional)
+Requires `USER_SESSION_STRING` in `config.env` plus one app restart to unlock. Then enable the toggle and add the **channel IDs** to search. Results that aren’t in your local catalog are tagged **🌐 GLOBAL** in Stremio.
+
+### 🌐 Proxy (optional)
+Set an **HTTP Proxy URL** for outbound metadata/API requests, and optionally **show both** proxied and direct stream links.
+
+### 🗄️ Extra Storage Databases
+Your first two databases (from `config.env`) are **locked** as *Tracking* and *Storage 1*. Add more MongoDB URIs here to expand storage capacity — 🟢 means connected. Remove entries only from the **end** of the list, since existing media reference databases by position.
+
+### 📨 Multi-Token Clients
+Add extra **bot tokens** for faster parallel streaming under heavy load. Create more bots with @BotFather, add them as **admins** in all your AUTH channels, then paste their tokens here. Changes apply immediately.
+
+> ✅ Click **Save Settings** when you’re done. That’s it — you’re live!
 
 ---
 
@@ -662,112 +739,39 @@ sudo apt install caddy
 ➡️ `https://your-domain.com`
 
 
-# 📺 Setting up Stremio
+# 📺 Setting Up Your App (Nuvio Recommended)
+
+Your media server works as a standard **Stremio-style addon**, so it plays in any compatible client. For the **best compatibility and smoothest experience across devices, we recommend the [Nuvio](https://play.google.com/store/apps/details?id=com.nuvio.app) app** — a free, open-source media hub for **Android, Android TV, Fire TV, iOS, Windows, and TV** that supports Stremio addon manifest URLs natively. *(Content was rephrased for compliance with licensing restrictions.)*
 
-Follow these steps to connect your deployed addon to the **Stremio** app.
+> 💡 Already using **Stremio**? It works too — just install the same addon URL below. Nuvio simply tends to handle these Telegram streams more reliably across more devices.
 
-### 📥 Step 1: Download Stremio
+## 📥 Step 1: Install Nuvio
 
-Download Stremio for your device:
-👉 [https://www.stremio.com/downloads](https://www.stremio.com/downloads)
+Download Nuvio from an official source:
 
-### 👤 Step 2: Sign In
+| Platform | Source |
+| :--- | :--- |
+| **Android / Android TV / Fire TV** | [Google Play](https://play.google.com/store/apps/details?id=com.nuvio.app) |
+| **All platforms / latest builds** | [GitHub — tapframe/NuvioStreaming](https://github.com/tapframe/NuvioStreaming) |
 
-  - Create or log in to your **Stremio account**.
+> 🔗 *(Optional)* Connect **Trakt** in the app to sync your watch history and progress across devices.
 
-### 🌐 Step 3: Add the Addon
+## 🌐 Step 2: Add the Addon
 
-1.  Open the **Stremio App**.
-2.  Go to the **Addon Section** (usually represented by a puzzle piece icon 🧩).
-3.  In the search bar, paste the appropriate addon URL:
+1. Open **Nuvio** and go to the **Addons** section.
+2. Paste your addon **manifest URL** and install it:
 
 | Deployment Method | Addon URL |
 | :--- | :--- |
 | **Heroku** | `https://<your-heroku-app>.herokuapp.com/stremio/manifest.json` |
 | **Custom Domain** | `https://<your-domain>/stremio/manifest.json` |
 
+3. Done! 🎉 Your Telegram library now appears in the catalog and streams directly.
 
-## ⚙️ Optional: Remove Cinemeta
-
-If you want to use **only** your **Telegram Stremio Media Server addon** for metadata and streaming, follow this guide to remove the default `Cinemeta` addon.
-
-### 1️⃣ Step 1: Uninstall Other Addons
-
-1.  Go to the **Addon Section** in the Stremio App.
-2.  **Uninstall all addons** except your Telegram Stremio Media Server.
-3.  Attempt to remove **Cinemeta**. If Stremio prevents it, proceed to Step 2.
-
-### 2️⃣ Step 2: Remove “Cinemeta” Protection
-
-1.  Log in to your **Stremio account** using **Chrome or Chromium-based browser** :
-    👉 [https://web.stremio.com/](https://web.stremio.com/)
-2.  Once logged in, open your **browser console** (`Ctrl + Shift + J` on Windows/Linux or `Cmd + Option + J` on macOS).
-3.  Copy and paste the code below into the console and press **Enter**:
-
-<!-- end list -->
-
-```js
-(function() {
-
-	const token = JSON.parse(localStorage.getItem("profile")).auth.key;
-
-    const requestData = {
-        type: "AddonCollectionGet",
-        authKey: token,
-        update: true
-    };
-
-    fetch('https://api.strem.io/api/addonCollectionGet', {
-        method: 'POST',
-        body: JSON.stringify(requestData)
-    })
-    .then(response => response.json())
-    .then(data => {
-
-    if (data && data.result) {
-
-        let result = JSON.stringify(data.result).substring(1).replace(/"protected":true/g, '"protected":false').replace('"idPrefixes":["tmdb:"]', '"idPrefixes":["tmdb:","tt"]');
-            
-        const index = result.indexOf("}}],");
-            
-        if (index !== -1) {
-            result = result.substring(0, index + 3) + "}";
-        }
-
-		let addons = '{"type":"AddonCollectionSet","authKey":"' + token + '",' + result;
-
-		fetch('https://api.strem.io/api/addonCollectionSet', {
-    		method: 'POST',
-			body: addons 
-		})
-      	.then(response => response.text())
-      	.then(data => {
-      		console.log('Success:', data);
-      	})
-      	.catch((error) => {
-      		console.error('Error:', error);
-      	});
-
-        } else {
-            console.error('Error:', error);
-        }
-    })
-    .catch((error) => {
-        console.error('Erro:', error);
-    });
-})();
-```
-
-### 3️⃣ Step 3: Confirm Success
-
-  - Wait until you see this message in the console:
-    ```
-    Success: {"result":{"success":true}}
-    ```
-  - Refresh the page (**F5**). You will now be able to **remove Cinemeta** from your addons list.
+> 🔑 If you run in **subscription mode**, each user installs their own **personal** addon URL (`/stremio/{token}/manifest.json`) that the bot gives them.
 
 
-## 🏅 **Contributor**
+## 🏅 Contributors
 
 |<img width="80" src="https://avatars.githubusercontent.com/u/113664541">|<img width="80" src="https://avatars.githubusercontent.com/u/13152917">|<img width="80" src="https://avatars.githubusercontent.com/u/14957082">|<img width="80" src="https://raw.githubusercontent.com/vflixa1prime/Readme/main/VFlixPRime.png">|
 |:---:|:---:|:---:|:---:|

pyproject.toml

@@ -1,12 +1,13 @@
 [project]
 name = "Telegram-Stremio"
-version = "3.3.0"
+version = "3.4.0"
 description = "A powerful, self-hosted Telegram Stremio Media Server built with FastAPI, MongoDB, and PyroFork seamlessly integrated with Stremio for automated media streaming and discovery."
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
     "aiofiles>=24.1.0",
     "fastapi>=0.115.12",
+    "guessit>=3.8.0",
     "httptools>=0.8.0",
     "httpx>=0.28.1",
     "itsdangerous>=2.2.0",
@@ -17,6 +18,7 @@ dependencies = [
     "python-dotenv>=1.1.0",
     "python-multipart>=0.0.20",
     "pytz>=2025.2",
+    "rapidfuzz>=3.14.5",
     "requests>=2.32.3",
     "tgcrypto>=1.2.5",
     "themoviedb>=1.0.2",

requirements.txt

@@ -1,9 +1,11 @@
 aiofiles
 fastapi
+guessit
 httpx
 motor
 parse-torrent-title
 pyrofork
+rapidfuzz
 python-dotenv
 pytz
 tgcrypto

uv.lock

@@ -129,6 +129,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/77/06/bb80f5f86020c4551da315d78b3ab75e8228f89f0162f2c3a819e407941a/attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3", size = 63815, upload-time = "2025-03-13T11:10:21.14Z" },
 ]
 
+[[package]]
+name = "babelfish"
+version = "0.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c5/8f/17ff889327f8a1c36a28418e686727dabc06c080ed49c95e3e2424a77aa6/babelfish-0.6.1.tar.gz", hash = "sha256:decb67a4660888d48480ab6998309837174158d0f1aa63bebb1c2e11aab97aab", size = 87706, upload-time = "2024-05-09T21:16:24.357Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/95/a1/bd4f759db13cd8beb9c9f68682aced5d966781b9d7380cf514a306f56762/babelfish-0.6.1-py3-none-any.whl", hash = "sha256:512f1501d4c8f7d38f0921f48660be7542de1a7b24abb6a6a65324a670150293", size = 94231, upload-time = "2024-05-09T21:16:22.633Z" },
+]
+
 [[package]]
 name = "certifi"
 version = "2025.4.26"
@@ -338,6 +347,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/71/3e/b04a0adda73bd52b390d730071c0d577073d3d26740ee1bad25c3ad0f37b/frozenlist-1.6.0-py3-none-any.whl", hash = "sha256:535eec9987adb04701266b92745d6cdcef2e77669299359c3009c3404dd5d191", size = 12404, upload-time = "2025-04-17T22:38:51.668Z" },
 ]
 
+[[package]]
+name = "guessit"
+version = "3.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "babelfish" },
+    { name = "python-dateutil" },
+    { name = "rebulk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d0/07/5a88020bfe2591af2ffc75841200b2c17ff52510779510346af5477e64cd/guessit-3.8.0.tar.gz", hash = "sha256:6619fcbbf9a0510ec8c2c33744c4251cad0507b1d573d05c875de17edc5edbed", size = 271285, upload-time = "2023-12-14T10:24:20.582Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b8/9b/924a8f9709c3143d4c9a301a88042cbce37e09789378217284b19d4f8132/guessit-3.8.0-py3-none-any.whl", hash = "sha256:eb5747b1d0fbca926562c1e5894dbc3f6507c35e8c0bd9e38148401cd9579d83", size = 206049, upload-time = "2023-12-14T10:24:17.753Z" },
+]
+
 [[package]]
 name = "h11"
 version = "0.16.0"
@@ -867,6 +890,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/8d/59/b4572118e098ac8e46e399a1dd0f2d85403ce8bbaad9ec79373ed6badaf9/PySocks-1.7.1-py3-none-any.whl", hash = "sha256:2725bd0a9925919b9b51739eea5f9e2bae91e83288108a9ad338b2e3a4435ee5", size = 16725, upload-time = "2019-09-20T02:06:22.938Z" },
 ]
 
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
+]
+
 [[package]]
 name = "python-dotenv"
 version = "1.1.0"
@@ -894,6 +929,94 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225, upload-time = "2025-03-25T02:24:58.468Z" },
 ]
 
+[[package]]
+name = "rapidfuzz"
+version = "3.14.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2c/21/ef6157213316e85790041254259907eb722e00b03480256c0545d98acd33/rapidfuzz-3.14.5.tar.gz", hash = "sha256:ba10ac57884ce82112f7ed910b67e7fb6072d8ef2c06e30dc63c0f604a112e0e", size = 57901753, upload-time = "2026-04-07T11:16:31.931Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e1/f9/3c41a7be8855803f4f6c713b472226a98d31d41869d98f64f4ca790510d6/rapidfuzz-3.14.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e251126d48615e1f02b4a178f2cd0cd4f0332b8a019c01a2e10480f7552554b4", size = 1952372, upload-time = "2026-04-07T11:13:58.32Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/89/c2557e37531d03465193bff0ab9de70b468420a807d71a26a65100635459/rapidfuzz-3.14.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5ab449c9abd0d4e1f8145dce0798a4c822a1a1933d613c764a641bea88b8bdab", size = 1159782, upload-time = "2026-04-07T11:14:00.127Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/b2/ffeeb7eca1a897d51b998f4c0ef0281696c3b06abcca4f88f9def708ffe1/rapidfuzz-3.14.5-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cb2829fedd672dd7107267189dabe2bbe07972801d636014417c6861eb89e358", size = 1383677, upload-time = "2026-04-07T11:14:01.696Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/d0/4539e42a2d596e068f7738f279638a4a74edd1fbb6f8594e2458058979c6/rapidfuzz-3.14.5-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3d50e5861872935fece391351cbb5ba21d1bced277cf5e1143d207a0a35f1925", size = 3168906, upload-time = "2026-04-07T11:14:03.29Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/1c/3ec897eb9d8b05308aa8ef6ae4ed64b088ad521a3f9d8ff469e7e97bc2b0/rapidfuzz-3.14.5-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:7092a216728f80c960bd6b3807275d1ee318b168986bd5dc523349581d4890b8", size = 1478176, upload-time = "2026-04-07T11:14:04.94Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/ba/970c03a12ce20a5399e22afe9f8932fd4cd1265b8a8461d0e63b00eb4eae/rapidfuzz-3.14.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9669753caef7fdc6529f6adcc5883ed98d65976445d9322e7dbdb6b697feee13", size = 2402441, upload-time = "2026-04-07T11:14:07.228Z" },
+    { url = "https://files.pythonhosted.org/packages/81/93/61d351cae60c1d0e21ba5ff1a1015ad045539ed215da9d6e302204ed887a/rapidfuzz-3.14.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:823b1b9d9230809d8edcc18872770764bfe8ef4357995e16744047c8ccf0e489", size = 2511628, upload-time = "2026-04-07T11:14:09.234Z" },
+    { url = "https://files.pythonhosted.org/packages/87/52/374d2d4f60fd98155142a869323aa221e30868cfa1f15171a0f64070c247/rapidfuzz-3.14.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f0b2af76b7e7060c09e1a0dfa9410eb19369cbe6164509bff2ef94094b54d2b6", size = 4275480, upload-time = "2026-04-07T11:14:11.332Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/04/82e7989bc9ec20a15b720a335c5cb6b0724bf6582013898f90a3280cfccd/rapidfuzz-3.14.5-cp311-cp311-win32.whl", hash = "sha256:c5801a89604c65ab4cc9e91b23bc4076d0ca80efd8c976fb63843d7879a85d7f", size = 1725627, upload-time = "2026-04-07T11:14:13.217Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/b5/eca8ac5609bc9bcb02bb6ff87fa5983cc92b8772d66a431556ab8a8c178f/rapidfuzz-3.14.5-cp311-cp311-win_amd64.whl", hash = "sha256:d7ca16637c0ede8243f84074044bd0b2335a0341421f8227c85756de2d18c819", size = 1545977, upload-time = "2026-04-07T11:14:14.766Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/e1/dbf318de28f65fa2cdd0a9dfbdee380f8199eb83b19259bc4f8592551b4e/rapidfuzz-3.14.5-cp311-cp311-win_arm64.whl", hash = "sha256:8c90cdf8516d9057e502aa6003cea71cf5ec27cc44699ca52412b502a04761bb", size = 816827, upload-time = "2026-04-07T11:14:16.788Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/e3/574435c6aafb80254c191ef40d7aca2cb2bb97a095ec9395e9fa59ac307a/rapidfuzz-3.14.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0d3378f471ef440473a396ce2f8e97ee12f89a78b495540e0a5617bbfe895638", size = 1944601, upload-time = "2026-04-07T11:14:18.771Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/1f/fbad3102a255ecc112ce9a7e779bacab7fd14398217be8868dc9082ba363/rapidfuzz-3.14.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1e910eebca9fd0eba245c0555e764597e8a0cccb673a92da2dc2397050725f48", size = 1164293, upload-time = "2026-04-07T11:14:20.534Z" },
+    { url = "https://files.pythonhosted.org/packages/88/37/a3eb7ff6121ed3a5f199a8c38cc86c8e481816f879cb0e0b738b078c9a7e/rapidfuzz-3.14.5-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:01550fe5f60fd176aa66b7611289d46dc4aa4b1b904874c7b6d1d54e581c5ec1", size = 1371999, upload-time = "2026-04-07T11:14:22.63Z" },
+    { url = "https://files.pythonhosted.org/packages/79/72/97a9728c711c7c1b06e107d3f0623880fb4ef90e147ed13c551a1730e7cc/rapidfuzz-3.14.5-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:48bee0b91bebfaec41e1081e351000659ab7570cc4598d617aa04d5bf827f9e6", size = 3145715, upload-time = "2026-04-07T11:14:24.508Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/54/d5caabbea233ac90c286c87c260e49d7641467e87438a18d858e41c82e91/rapidfuzz-3.14.5-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:7e580cb04ad849ae9b786fa21383c6b994b6e6c1444ad1cb9f22392759d72741", size = 1456304, upload-time = "2026-04-07T11:14:26.515Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/a7/2d1a81250ac8c01a0100c026018e76f0e7a097ff63e4c553e02a6938c6fb/rapidfuzz-3.14.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:09d6c9ba091854f07817055d795d604179c12a8f308ba4c7d56f3719dfea1646", size = 2389089, upload-time = "2026-04-07T11:14:28.635Z" },
+    { url = "https://files.pythonhosted.org/packages/65/0d/c47c3872203ae88e6506997c0b576ad731f5261daa25d559be09c9756658/rapidfuzz-3.14.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1e989f86113be66574113b9c7bdf4793f3f863d248e47d911b355e05ca6b6b10", size = 2493404, upload-time = "2026-04-07T11:14:30.577Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/2f/71e0a5a3130792146c8a200a2dd1e52aa16f7c1074012e17f2601eea9a90/rapidfuzz-3.14.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0ebd1a18e2e47bc0b292a07e6ed9c3642f8aaa672d12253885f599b50807a4f9", size = 4251709, upload-time = "2026-04-07T11:14:32.451Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/d39874901abacef325adb5b34ae416817c8486dfb4fb87c7a9b74ec5b072/rapidfuzz-3.14.5-cp312-cp312-win32.whl", hash = "sha256:9981d38a703b86f0e315a3cd229fd1906fe1d91c989ed121fb975b3c849f89f5", size = 1710069, upload-time = "2026-04-07T11:14:34.37Z" },
+    { url = "https://files.pythonhosted.org/packages/85/0b/f65572c53de8a1c704bda707f63a447b67bdbe95d7cdc70d18885e191df5/rapidfuzz-3.14.5-cp312-cp312-win_amd64.whl", hash = "sha256:d8375e3da319593389727c3187ccaf3e0e84199accc530866b8e0f2b79af05e9", size = 1540630, upload-time = "2026-04-07T11:14:36.287Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/c3/143be3a578f989758cae516f3270d5cbb49783a7bfdf57cc27a670e00456/rapidfuzz-3.14.5-cp312-cp312-win_arm64.whl", hash = "sha256:478b59bb018a6780d73f33e38d0b3ec5e968a6c1ed42876b993dd456b7aa20e8", size = 813137, upload-time = "2026-04-07T11:14:38.289Z" },
+    { url = "https://files.pythonhosted.org/packages/11/66/252803f2010ba699618cdc048b6e1f7cc1f433c08b4a9a17579b92ab0142/rapidfuzz-3.14.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ebd8fd343bf8492a1e60bcb6dc99f90f74f65d98d8241a6b3e1fed225b76ecd6", size = 1940205, upload-time = "2026-04-07T11:14:40.319Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/59/b2afd98e41af9cd54554a4c1c423d84cdd60e6b1c0a09496f033b55f60ec/rapidfuzz-3.14.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6737b35d5af7479c5bf9710f7b17edd9d2c43128d974d25fb4ea653e42c64609", size = 1159639, upload-time = "2026-04-07T11:14:42.52Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/31/7aa7e62c4c516a7af322ed0c4f0774208b72d457d0cfec808bad0df12f4a/rapidfuzz-3.14.5-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b002c7994cc9f2bc9d9856f0fbaee6e8072c983873846c92f25cefba5b2a925f", size = 1367194, upload-time = "2026-04-07T11:14:44.25Z" },
+    { url = "https://files.pythonhosted.org/packages/90/79/2fc252a63bc91d3c3b234d0a3a6ad4ebc460037a23cdcdaf9285f986e6c9/rapidfuzz-3.14.5-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:17a34330cd2a538c1ce5d400b61ba358c5b72c654b928ff87b362e88f8b864c7", size = 3151805, upload-time = "2026-04-07T11:14:46.21Z" },
+    { url = "https://files.pythonhosted.org/packages/17/54/0c83508f2683ea70e2d05f8527eb07328acf7bb1e9d97a3bece5702378e7/rapidfuzz-3.14.5-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:95d937e74c1a7a1287dfb03b62a827be08ede10a155cf1af73bbf47f2b73ee6e", size = 1455667, upload-time = "2026-04-07T11:14:47.991Z" },
+    { url = "https://files.pythonhosted.org/packages/71/1b/070175e873177814d58850a01ebe80e20ae11e93eb4da894d563988660fa/rapidfuzz-3.14.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:46b92a9970dcc34f0096901c792644094cab49554ac3547f35e3aebbdf0a3610", size = 2388246, upload-time = "2026-04-07T11:14:50.098Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/dd/77caf7aaf9c2be050ad1f128d7c24ff0f59079aa62c5f62f9df41c0af45e/rapidfuzz-3.14.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e012177c8e8a8a0754ae0d6027d63042aa5ff036d9f40f07cb3466a6082e21b8", size = 2494333, upload-time = "2026-04-07T11:14:52.303Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/e2/dd7e1f2aa31a8fbbfc16b0610af1d770ffaf1287490f3c8c5b1c52da264f/rapidfuzz-3.14.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a2ae6f53f99c9a0eca7a0afc5b4e45fc73bc1dd4ac74c00509031d76df80ed98", size = 4258579, upload-time = "2026-04-07T11:14:54.538Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/0a/ac99e1ba347ba0e85e0bb60b74231d55fb93c0eff43f2920ccb413d0be08/rapidfuzz-3.14.5-cp313-cp313-win32.whl", hash = "sha256:4a60f0057231188e3bd30216f7b4e0f279b11fa4ec818bb6c1d9f014d1562fbc", size = 1709231, upload-time = "2026-04-07T11:14:56.524Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/cb/0e251d731b3166378644238e8f0cf9e89858c024e19f75ca9f7e3ae83fd5/rapidfuzz-3.14.5-cp313-cp313-win_amd64.whl", hash = "sha256:11bfc2ed8fbe4ab86bd516fadefab126f90e6dcadffa761739fcb304707dfd35", size = 1538519, upload-time = "2026-04-07T11:14:58.635Z" },
+    { url = "https://files.pythonhosted.org/packages/30/6f/4548132acc947db6d5346a248e44a8b3a22d608ef30e770fb578caaf2d00/rapidfuzz-3.14.5-cp313-cp313-win_arm64.whl", hash = "sha256:b486b5218808f6f4dc471b114b1054e63553db69705c97da0271f47bd706aedd", size = 812628, upload-time = "2026-04-07T11:15:00.552Z" },
+    { url = "https://files.pythonhosted.org/packages/00/60/69b177577290c5eab892c6f75fe89c3aff3f9ae80298a78d9372b1cecb9a/rapidfuzz-3.14.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:39ef8658aaf67d51667e7bdaf7096f432333377d8302ac43c70b5df8a4cf89b8", size = 1970231, upload-time = "2026-04-07T11:15:02.603Z" },
+    { url = "https://files.pythonhosted.org/packages/48/38/2fd790052659cc4e2907b63c25433f0987864b445c1aeec1a302ef5ad948/rapidfuzz-3.14.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:9ad37a0be705b544af6296da8edddc260d10a8ae5462530fc9991f66498bb1f9", size = 1194394, upload-time = "2026-04-07T11:15:04.572Z" },
+    { url = "https://files.pythonhosted.org/packages/80/f4/28430ad8472fc3536e8ebd51a864a226e979cfe924c6e3f83d111373aa74/rapidfuzz-3.14.5-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d45e06f60729e07d9b20c205f7e5cff90b6ef2584e852eecf46e045aea69627d", size = 1377051, upload-time = "2026-04-07T11:15:06.728Z" },
+    { url = "https://files.pythonhosted.org/packages/77/7e/9aeacabcfd1e77397968362e5b98fe14248b8307011136b17daf99752a8e/rapidfuzz-3.14.5-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e52da10236aa6212de71b9e170bace65b64b129c0dea7fc243d6c9ce976f5074", size = 3160565, upload-time = "2026-04-07T11:15:08.667Z" },
+    { url = "https://files.pythonhosted.org/packages/56/f4/db4dd7be0cd2f2022117ac5407d905f435d60e48baaea313a567ad27e865/rapidfuzz-3.14.5-cp313-cp313t-manylinux_2_39_riscv64.whl", hash = "sha256:440d30faaf682ca496170a7f0cc5453ec942e3e079f0fd802c9a7f938dfb50a3", size = 1442113, upload-time = "2026-04-07T11:15:11.138Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/99/0e9f6aa57f3e32a767216f797e56dc96b720fcecfb9d8ee907ecc82f8d66/rapidfuzz-3.14.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:56227a61fd3d17b0cd9793132431f3a3d07c8654be96794ba9f89fe0fc8b2d09", size = 2396618, upload-time = "2026-04-07T11:15:13.154Z" },
+    { url = "https://files.pythonhosted.org/packages/60/94/44a78e39ffce17cbdd3e2b53b696acc751d5d153be0f499d052b07a4d904/rapidfuzz-3.14.5-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:2e83cd2e25bb4edd97b689d9979d9c3acccdaaf26ceac08212ceece202febcfa", size = 2478220, upload-time = "2026-04-07T11:15:15.193Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/df/454311469a09a507e9d784a35796742bec22e4cebe75551e2da4e0e290fd/rapidfuzz-3.14.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:af3b859726cd3374287e405e14b9634563c078c5531a4f62375508addebddad1", size = 4265027, upload-time = "2026-04-07T11:15:17.28Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/01/175465a9ab3e3b70ba669058372f009d1d49c1746e2dcd56b69df188d3a5/rapidfuzz-3.14.5-cp313-cp313t-win32.whl", hash = "sha256:8ce1d850b3c0178440efde9e884d98421b5e87ff925f364d6d79e23910d7593f", size = 1766814, upload-time = "2026-04-07T11:15:19.687Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/a0/a9b84a47af06ebed94a1439eb2f02adebfb8628bcd30af1fe3e02f5ef56c/rapidfuzz-3.14.5-cp313-cp313t-win_amd64.whl", hash = "sha256:c84af70bcf34e99aee894e46a0f1ac77f17d0ef828179c387407642e2466d28a", size = 1582448, upload-time = "2026-04-07T11:15:21.98Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/f1/5937800238b3f8248e70860d79f69ba8f73e764fff47e36bc9e2f26dbcc6/rapidfuzz-3.14.5-cp313-cp313t-win_arm64.whl", hash = "sha256:aac0ad28c686a5e72b81668b906c030ee28050b244544b8af68e12fb32543895", size = 832932, upload-time = "2026-04-07T11:15:24.358Z" },
+    { url = "https://files.pythonhosted.org/packages/81/41/aa3ffb3355e62e1bf91f6599b3092e866bc88487a07c524004943c7676df/rapidfuzz-3.14.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1a31cc6d7d03e7318a0974c038959c59e19c752b81115f2e9138b3331cd64d45", size = 1943327, upload-time = "2026-04-07T11:15:26.266Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/e1/c2141f1840a41e07ad2db6f724945f8f8ff3065463899a22939152dd6e09/rapidfuzz-3.14.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0298d357e2bc59d572da4db0bc631009b6f8f6c9bc8c11e99a12b833f16b6575", size = 1161755, upload-time = "2026-04-07T11:15:28.659Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/07/66e753eeaa353161d1d331b7dd517bb349b0bacfebe8496d7b26be26f81f/rapidfuzz-3.14.5-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:59b3dba758661a318995655435c6ab20a04ade79fa51e75bc8dc107cac8df280", size = 1376571, upload-time = "2026-04-07T11:15:31.225Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/85/9535df0b78ba51f478c9ce7eb6d1f85535cc31fe356773b48fd9d3e563ca/rapidfuzz-3.14.5-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4900143d82071bdda533b00300c40b14b963ff826b3642cc463b6dd0f036585e", size = 3156468, upload-time = "2026-04-07T11:15:33.428Z" },
+    { url = "https://files.pythonhosted.org/packages/81/ee/b667eb93bba6dc4e0de658edd778e1619dc4d6aab68fa5e5c7f075152735/rapidfuzz-3.14.5-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:feedf219672eef83ea6be6f3bb093bba396a8560fc75be85ba225f082903df0a", size = 1458311, upload-time = "2026-04-07T11:15:35.557Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/ce/479074f5624364a48df3403c538797ef22d3ac49c19dc76c3f79fcdcc70c/rapidfuzz-3.14.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:419e4397a36e2665ec992d8d64c20ba4b2a42500c76ecadeca78a4f19cb9cc32", size = 2398228, upload-time = "2026-04-07T11:15:37.669Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/15/a8982f649150fffbdcd6f17565974501f6ab33b2795267bffbd4a7ba905b/rapidfuzz-3.14.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:97131ab2be39043054ee28d99e09efe316e6d53449b7e962dfcf3c2de8b2b246", size = 2497226, upload-time = "2026-04-07T11:15:39.857Z" },
+    { url = "https://files.pythonhosted.org/packages/19/52/5267c03ef6759831b7d4625a0c9c06e87baa2fae084b61ac9c388858317b/rapidfuzz-3.14.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:593c00dac4e30231c35bf3b4f1da8ec0998762e9e94425586a5d636fcd57f9d0", size = 4262283, upload-time = "2026-04-07T11:15:42.279Z" },
+    { url = "https://files.pythonhosted.org/packages/71/c0/2579f343a97f5254c43bb5853baccc01488357dcb64a27bcb869b7888a4a/rapidfuzz-3.14.5-cp314-cp314-win32.whl", hash = "sha256:0084b687b02b4e569b46d8d6d4ad25659528e6081cd6d067ca453a69035f07e4", size = 1744614, upload-time = "2026-04-07T11:15:44.498Z" },
+    { url = "https://files.pythonhosted.org/packages/17/eb/8edfed1e80119dc9c35b11df4bc701eea85622ad681fff0263b6961d3224/rapidfuzz-3.14.5-cp314-cp314-win_amd64.whl", hash = "sha256:5dfa89d78f22cd773054caff44827b846161a29f2dcf7e78b8f90d086621e502", size = 1588971, upload-time = "2026-04-07T11:15:46.86Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/04/5676df93c85cfa57a3045d8047318df9f3cd58c7b8a99340dd95f874795e/rapidfuzz-3.14.5-cp314-cp314-win_arm64.whl", hash = "sha256:67f3f9d2b444268ab53e47d31bab89954888d23c04c6789f2c727e51fe4b1d13", size = 834985, upload-time = "2026-04-07T11:15:49.411Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/0d/4a8988cea658fe335048ddef8c876addff1b6daa3c9ca8ad65a5a2196e69/rapidfuzz-3.14.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:77eac0526899b3c3ad1454bb2b03cdb491d67358ec8ef0c9c48bd61b632b431d", size = 1972517, upload-time = "2026-04-07T11:15:51.819Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/a3/f5cfd9965a9d9a9e32249159797c47b5d6299ea6d1629f9126b25f1c10a3/rapidfuzz-3.14.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b9c6bd754d11f6e78ac54e3d86b4b11dc1ba2f13e5fc958899574532897f5a99", size = 1196056, upload-time = "2026-04-07T11:15:54.292Z" },
+    { url = "https://files.pythonhosted.org/packages/64/07/561c2e40cfd10e6630a7b0ac5a2a813aef50d944bcd1f3d260319d659d5b/rapidfuzz-3.14.5-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:738c96944d076deeaff70e92b65696ab4f7ecb8081d7791c5403a3257dfaf8ff", size = 1374732, upload-time = "2026-04-07T11:15:56.584Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/39/123bb94fee40e2fb3b7c49b80827c7ef42d838e18def3fc2fef5a3cf817a/rapidfuzz-3.14.5-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4c1bca487a17fe4226b4ffb2d30e799d2b274d692cffa76bd0746f56235fca3", size = 3166902, upload-time = "2026-04-07T11:15:58.768Z" },
+    { url = "https://files.pythonhosted.org/packages/75/0a/45716fafc9fd2e028cf20b5ac5bc704887081cd312f84edb0e325599414b/rapidfuzz-3.14.5-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:af6a90a4ed2a48fa1a2d17e9d824e6c7c950bea5bad0b707c77fd55751e6bfef", size = 1452130, upload-time = "2026-04-07T11:16:01.453Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/49/4e96c413114398481c0a5b0086af32c364a18613c9a2ea578d17c4bea4ee/rapidfuzz-3.14.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bf5018938208d4597b2e679a4f8cff9fd252f1df53583130ae56281a21801b64", size = 2396308, upload-time = "2026-04-07T11:16:03.588Z" },
+    { url = "https://files.pythonhosted.org/packages/89/b7/49fea9fc6878d59bd259d01dd1972d9b86117992b1c66d9b16f0a65273c3/rapidfuzz-3.14.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:c0919d1f89ddf91129906705723118ea09754171e4116f5a5dbc667c7bc9b261", size = 2488210, upload-time = "2026-04-07T11:16:05.871Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/44/a1f732b93ffacbdad077b7c801149549b2938e1bece6addb5ad85ed74df8/rapidfuzz-3.14.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:93d8da883a35116d6813432177f35e570db5b0a5e30ecb0cbd7cb39c815735df", size = 4270621, upload-time = "2026-04-07T11:16:08.483Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/ce/ff942d19fce5385054650bb71a58495ddda299d94661ccc4e6e7fa44868b/rapidfuzz-3.14.5-cp314-cp314t-win32.whl", hash = "sha256:0f23e37019ec07712d58976b1ab2b889f8649a7f7c2f626a2f34ea9139e79279", size = 1803950, upload-time = "2026-04-07T11:16:10.873Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/0f/9aafc63f9661222b819b391c187eed29fc90ad5935f9690e5ecc2d2047a4/rapidfuzz-3.14.5-cp314-cp314t-win_amd64.whl", hash = "sha256:7d5ca9c7832e6879a707296d1463685f7c243a27846227044504741640caec66", size = 1632357, upload-time = "2026-04-07T11:16:13.1Z" },
+    { url = "https://files.pythonhosted.org/packages/70/a6/51fc1b0e61e3326e1c68a61cfd0c6b3c34c843681c4b1eefbf0596f59162/rapidfuzz-3.14.5-cp314-cp314t-win_arm64.whl", hash = "sha256:3e91dcd2549b8f8d843f98ba03a17e01f3d8b72ce942adbbb6761bc58ffce813", size = 855409, upload-time = "2026-04-07T11:16:15.787Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/ee/e71853bf82846c5c2174b924b71d8e8099fb05ff87c958a720380b434ba3/rapidfuzz-3.14.5-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:578e6051f6d5e6200c259b47a103cf06bb875ab5814d17333fc0b5c290b22f4c", size = 1888603, upload-time = "2026-04-07T11:16:18.223Z" },
+    { url = "https://files.pythonhosted.org/packages/36/82/40f67b730f32be2ebad9f62add1571c754f52249254b2e88af094b907eee/rapidfuzz-3.14.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:fbf1b8bb2695415b347f3727da1addca2acb82c9b97ac86bebf8b1bead1eb12d", size = 1120599, upload-time = "2026-04-07T11:16:20.682Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/9f/a3635cc4ec8fc6e14b46e7db1f7f8763d8c4bef33dcc124eea2e6cb2c8f3/rapidfuzz-3.14.5-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f4a8f5cc84c7ad6bffa0e9947b33eb343ad66e6b53e94fe54378a5508c5ed53", size = 1348524, upload-time = "2026-04-07T11:16:23.451Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/1b/2b229520f0b48464cfcd7aa758f74551d12c9bc4ab544022a60210aab064/rapidfuzz-3.14.5-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:97c6d85283629646fa87acc22c66b30ea9d4de7f6fdf887daa2e30fa041829b5", size = 3099302, upload-time = "2026-04-07T11:16:25.858Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b5/363906b1064fc6fe611783a61764927bbd91919aaaabe8cba82151ca93ef/rapidfuzz-3.14.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:dfef96543ced67d9513a422755db422ae1dc34dade0a1485e0b43e7342ed3ebf", size = 1509889, upload-time = "2026-04-07T11:16:28.487Z" },
+]
+
+[[package]]
+name = "rebulk"
+version = "3.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f2/06/24c69f8d707c9eefc1108a64e079da56b5f351e3f59ed76e8f04b9f3e296/rebulk-3.2.0.tar.gz", hash = "sha256:0d30bf80fca00fa9c697185ac475daac9bde5f646ce3338c9ff5d5dc1ebdfebc", size = 261685, upload-time = "2023-02-18T09:10:14.378Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/4d/df073d593f7e7e4a5a7e19148b2e9b4ae63b4ddcbb863f1e7bb2b6f19c62/rebulk-3.2.0-py3-none-any.whl", hash = "sha256:6bc31ae4b37200623c5827d2f539f9ec3e52b50431322dad8154642a39b0a53e", size = 56298, upload-time = "2023-02-18T09:10:12.435Z" },
+]
+
 [[package]]
 name = "requests"
 version = "2.32.3"
@@ -921,6 +1044,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/bd/60/50fbb6ffb35f733654466f1a90d162bcbea358adc3b0871339254fbc37b2/requirements_parser-0.13.0-py3-none-any.whl", hash = "sha256:2b3173faecf19ec5501971b7222d38f04cb45bb9d87d0ad629ca71e2e62ded14", size = 14782, upload-time = "2025-05-21T13:42:04.007Z" },
 ]
 
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
 [[package]]
 name = "sniffio"
 version = "1.3.1"
@@ -944,11 +1076,12 @@ wheels = [
 
 [[package]]
 name = "telegram-stremio"
-version = "3.1.0"
+version = "3.3.0"
 source = { virtual = "." }
 dependencies = [
     { name = "aiofiles" },
     { name = "fastapi" },
+    { name = "guessit" },
     { name = "httptools" },
     { name = "httpx" },
     { name = "itsdangerous" },
@@ -959,6 +1092,7 @@ dependencies = [
     { name = "python-dotenv" },
     { name = "python-multipart" },
     { name = "pytz" },
+    { name = "rapidfuzz" },
     { name = "requests" },
     { name = "tgcrypto" },
     { name = "themoviedb" },
@@ -975,6 +1109,7 @@ dev = [
 requires-dist = [
     { name = "aiofiles", specifier = ">=24.1.0" },
     { name = "fastapi", specifier = ">=0.115.12" },
+    { name = "guessit", specifier = ">=3.8.0" },
     { name = "httptools", specifier = ">=0.8.0" },
     { name = "httpx", specifier = ">=0.28.1" },
     { name = "itsdangerous", specifier = ">=2.2.0" },
@@ -985,6 +1120,7 @@ requires-dist = [
     { name = "python-dotenv", specifier = ">=1.1.0" },
     { name = "python-multipart", specifier = ">=0.0.20" },
     { name = "pytz", specifier = ">=2025.2" },
+    { name = "rapidfuzz", specifier = ">=3.14.5" },
     { name = "requests", specifier = ">=2.32.3" },
     { name = "tgcrypto", specifier = ">=1.2.5" },
     { name = "themoviedb", specifier = ">=1.0.2" },