fix(metadata): strip channel handle prefixes and sanitize BaseItems titles in Jellyfin

apex/apex_stream/extractor.py

@@ -37,11 +37,23 @@ _QUALITY_BOUNDARY_RE = re.compile(
 
 # Outer envelope spam (channels, domains, watermarks)
 _ENVELOPE_RE = re.compile(
-    r"(?i)(?:^|[\s_\.\-\[])(?:@[a-z0-9_]+|www\.[a-z0-9\-]+(?:\.[a-z0-9\-]+)+|"
+    r"(?i)(?:^|[\s_\.\-\[])(?:@(?:[a-z0-9]+)(?:[._-](?:movies|cinema|films|channel|linkz|official|hub|club|media|drive|hd|store|flim))?|"
+    r"www\.[a-z0-9\-]+(?:\.[a-z0-9\-]+)+|"
     r"[a-z0-9\-]+\.(?:com|org|net|vip|xyz|top|site|club|online|store|link))(?=[\]\s_\.\-]|$)"
 )
 
 
+def _clean_channel_title(text: str) -> str:
+    if not text:
+        return ""
+    t = re.sub(r"(?i)^@(?:[a-z0-9]+)(?:[._-](?:movies|cinema|films|channel|linkz|official|hub|club|media|drive|hd|store|flim))?[._\s-]*", "", text)
+    t = re.sub(r"^@[a-z0-9_]+\s*", "", t, flags=re.IGNORECASE)
+    t = re.sub(r"(?i)\b(?:wmr|wm|mm\s*linkz|tamilmv|tamilblasters|1tamilmv)\b", " ", t)
+    t = re.sub(r"^[^\w]+", "", t)
+    t = re.sub(r"\s+", " ", t).strip()
+    return t
+
+
 def _anchor_parse(filename: str) -> Dict[str, Any]:
     """Deterministic structural anchor parsing for filenames."""
     if not filename:
@@ -49,7 +61,9 @@ def _anchor_parse(filename: str) -> Dict[str, Any]:
 
     # 1. Clean outer extensions and channel handles
     clean = re.sub(r"(?i)\.(?:mkv|mp4|avi|mov|webm|strm|ts|m2ts)\s*$", "", filename.strip())
+    clean = re.sub(r"(?i)@(?:[a-z0-9]+)(?:[._-](?:movies|cinema|films|channel|linkz|official|hub|club|media|drive|hd|store|flim))?[._\s-]+", " ", clean)
     clean = _ENVELOPE_RE.sub(" ", clean)
+    clean = re.sub(r"(?i)\b(?:wmr|wm|mm\s*linkz|tamilmv|tamilblasters|1tamilmv)\b", " ", clean)
     clean = re.sub(r"^\[[^\]]+\]", "", clean).strip(" -._")
 
     # 2. Check for TV episode anchors
@@ -93,8 +107,10 @@ def _anchor_parse(filename: str) -> Dict[str, Any]:
 
     # 5. Clean punctuation to spaces
     title_clean = re.sub(r"[._\+]+", " ", title_raw)
+    title_clean = _clean_channel_title(title_clean)
     title_clean = re.sub(r"\s+", " ", title_clean).strip(" -._:,()[]{}")
     title_clean = re.sub(r"\s*\(\d{4}\)$", "", title_clean).strip()
+    title_clean = _clean_channel_title(title_clean)
 
     if not title_clean:
         title_clean = "Unknown_Media"
@@ -117,14 +133,14 @@ def extract_media_info(filename: str) -> Dict[str, Any]:
     if HAS_GUESSIT and _guessit_fn:
         try:
             g = _guessit_fn(filename)
-            g_title = g.get("title")
-            if g_title and len(str(g_title).strip()) >= 2:
+            g_title = _clean_channel_title(str(g.get("title") or ""))
+            if g_title and len(g_title) >= 2:
                 is_tv = g.get("type") == "episode" or "episode" in g or "season" in g
                 season = int(g["season"]) if "season" in g else (1 if is_tv else None)
                 episode = int(g["episode"]) if "episode" in g else (1 if is_tv else None)
                 year = int(g["year"]) if "year" in g else None
                 return {
-                    "title": str(g_title).strip(),
+                    "title": g_title,
                     "is_tv": is_tv,
                     "season": season,
                     "episode": episode,

apex/apex_stream/organize.py

@@ -124,11 +124,25 @@ def tmdb_language_code(language_name: str) -> str:
     return _TMDB_LANG_CODE.get(language_name or "", "")
 
 
+def _clean_channel_prefix(text: str) -> str:
+    if not text:
+        return ""
+    s = str(text).strip()
+    s = re.sub(r"(?i)^@(?:[a-z0-9]+)(?:[._-](?:movies|cinema|films|channel|linkz|official|hub|club|media|drive|hd|store|flim))?[._\s-]*", "", s)
+    s = re.sub(r"^@[a-z0-9_]+\s*", "", s, flags=re.IGNORECASE)
+    s = re.sub(r"(?i)\b(?:wmr|wm|mm\s*linkz|tamilmv|tamilblasters|1tamilmv)\b", " ", s)
+    s = re.sub(r"^[^\w]+", "", s)
+    s = re.sub(r"\s+", " ", s).strip()
+    return s
+
+
 def safe_folder(name: str) -> str:
     """Folders/Jellyfin-safe version of a title or language name."""
     if not name:
         return "Unknown"
-    cleaned = re.sub(r"[^\w .'(),\-!]+", "", name, flags=re.UNICODE).strip()
+    cleaned_name = _clean_channel_prefix(name) or name
+    cleaned = re.sub(r"[^\w .'(),\-!]+", "", cleaned_name, flags=re.UNICODE).strip()
+    cleaned = _clean_channel_prefix(cleaned) or cleaned
     cleaned = re.sub(r"\s+", " ", cleaned).strip(" .") if cleaned else "Unknown"
     return cleaned[:120] or "Unknown"
 
@@ -147,6 +161,7 @@ def folder_name(title: Optional[str], year: Optional[int] = None) -> str:
             except (ValueError, TypeError):
                 pass
         name = name[:m.start()].strip()
+    name = _clean_channel_prefix(name) or name
     if year:
         name = f"{name} ({year})"
     return name
@@ -229,7 +244,8 @@ def strm_base(entry: Dict) -> str:
         episode = int(entry.get("episode") or 1)
         return safe_folder(f"{clean_show} - S{season:02d}E{episode:02d}")
     title = entry.get("clean_title") or entry.get("title") or "Unknown"
-    return folder_name(title, entry.get("year"))
+    clean_title = _clean_channel_prefix(title) or title
+    return folder_name(clean_title, entry.get("year"))
 
 
 def strm_dir(movies_dir: str, shows_dir: str, entry: Dict) -> str:

apex/apex_stream/tmdb_meta.py

@@ -236,7 +236,11 @@ def _strip_noise(text: str) -> str:
     t = _URL_NOISE_RE.sub(" ", t)
     t = _WATERMARK_PAREN_RE.sub(" ", t)
     t = re.sub(r"\[[^\]]*\]", " ", t)
-    t = re.sub(r"@[\w.\-]+", " ", t)
+    # Strip channel handles (@Handle, @WM_Movies, etc.) without consuming adjacent title words
+    t = re.sub(r"(?i)@(?:[a-z0-9]+)(?:[._-](?:movies|cinema|films|channel|linkz|official|hub|club|media|drive|hd|store|flim))?[._\s-]+", " ", t)
+    t = re.sub(r"@[a-z0-9_]+", " ", t, flags=re.IGNORECASE)
+    # Strip standalone known release / channel prefixes like WMR, WM, MM Linkz, 1TamilMV
+    t = re.sub(r"(?i)\b(?:wmr|wm|mm\s*linkz|tamilmv|tamilblasters|1tamilmv)\b", " ", t)
     t = _MEDIA_EXT_RE.sub(" ", t)
     # "+" and "&" are release/present separators too ("Dd+5.1 H" -> "Dd 5 1 H",
     # "Birds of Prey & Fantabulous" -> "Birds of Prey  Fantabulous"). A dash is a
@@ -378,6 +382,7 @@ def _clean_search_title(text: str) -> str:
     """A title ready to send to the TMDB search API (no year/release tags)."""
     text = _SIZE_RE.sub(" ", text)
     text = _strip_noise(_drop_dotted_group_tail(text))
+    text = re.sub(r"(?i)\b(?:wmr|wm|mm\s*linkz|tamilmv|tamilblasters|1tamilmv)\b", " ", text)
     text = YEAR_RE.sub(" ", text)
     text = re.sub(r"\(\s*\)", " ", text)
     # Strip leading "Episode NN -" or "Ep NN -" prefix (e.g. "Episode 3 - Green Lantern")
@@ -539,9 +544,10 @@ def parse_media_meta(filename_or_caption: Optional[str]) -> Dict:
     if tv:
         show_raw, season, episode = tv
         clean_show = _clean_search_title(show_raw)
+        clean_show = re.sub(r"(?i)^(?:@\S+\s*|(?:wmr|wm|mm\s*linkz)\s+)", "", clean_show).strip()
         if not clean_show:
             clean_show = "Unknown_Show"
-        show_title = safe_folder(_clean_search_title(show_raw).title() or clean_show)
+        show_title = safe_folder(clean_show.title() or clean_show)
         title = f"{show_title} - S{int(season):02d}E{int(episode):02d}"
         return {
             "is_tv": True,
@@ -557,6 +563,7 @@ def parse_media_meta(filename_or_caption: Optional[str]) -> Dict:
         }
 
     movie_title = _clean_search_title(raw)
+    movie_title = re.sub(r"(?i)^(?:@\S+\s*|(?:wmr|wm|mm\s*linkz)\s+)", "", movie_title).strip()
     if not movie_title:
         # Numeric-only/recovered titles: "2018.2018.Malayalam.1080p" is the
         # Malayalam film "2018", not a bare year; TMDB knows it by that name.
@@ -791,6 +798,10 @@ def build_movie_nfo(data: Dict) -> str:
     country_line = "  <country>%s</country>\n" % xml_escape(country) if country else ""
     imdb_id = xml_escape(str(data.get("imdb_id") or ""))
     imdb_unique = f'  <uniqueid type="imdb" default="true">{imdb_id}</uniqueid>\n' if imdb_id else ""
+    raw_title = g("title")
+    clean_nfo_title = re.sub(r"(?i)^(?:@\S+\s*|(?:wmr|wm|mm\s*linkz)\s+)", "", raw_title).strip() or raw_title
+    raw_orig = g("original_title") or raw_title
+    clean_orig_title = re.sub(r"(?i)^(?:@\S+\s*|(?:wmr|wm|mm\s*linkz)\s+)", "", raw_orig).strip() or clean_nfo_title
     return """<?xml version="1.0" encoding="utf-8" standalone="yes"?>
 <movie>
   <title>%(title)s</title>
@@ -813,8 +824,8 @@ def build_movie_nfo(data: Dict) -> str:
   </art>
 </movie>
 """ % {
-        "title": xml_escape(g("title")),
-        "original_title": xml_escape(g("original_title")),
+        "title": xml_escape(clean_nfo_title),
+        "original_title": xml_escape(clean_orig_title),
         "year": xml_escape(g("release_date"))[:4],
         "premiered": xml_escape(g("release_date")),
         "releasedate": xml_escape(g("release_date")),
@@ -840,7 +851,9 @@ def build_tvshow_nfo(data: Dict) -> str:
     imdb_unique = f'  <uniqueid type="imdb" default="true">{imdb_id}</uniqueid>\n' if imdb_id else ""
     tmdb_unique = f'  <uniqueid type="tmdb">{tmdb_id}</uniqueid>\n' if tmdb_id else ""
     title_val = g("title") or g("name") or g("original_name") or g("original_title") or "Unknown"
-    orig_title_val = g("original_name") or g("original_title") or title_val
+    clean_tv_title = re.sub(r"(?i)^(?:@\S+\s*|(?:wmr|wm|mm\s*linkz)\s+)", "", title_val).strip() or title_val
+    orig_title_val = g("original_name") or g("original_title") or clean_tv_title
+    clean_tv_orig = re.sub(r"(?i)^(?:@\S+\s*|(?:wmr|wm|mm\s*linkz)\s+)", "", orig_title_val).strip() or clean_tv_title
     premiered_val = g("first_air_date") or g("premiered") or g("release_date") or ""
     year_val = str(data.get("year") or "") or premiered_val[:4]
     plot_val = g("overview") or g("plot") or ""

apex/repair_jellyfin_libraries.py

@@ -401,8 +401,66 @@ def heal_subtitle_files(roots=None):
         print(f"[REPAIR] Purged {purged} corrupt/broken subtitle files across media directories.")
 
 
+CHANNEL_PREFIX_RE = re.compile(
+    r"(?i)^(?:@(?:[a-z0-9]+)(?:[._-](?:movies|cinema|films|channel|linkz|official|hub|club|media|drive|hd|store|flim))?[._\s-]*|@[a-z0-9_]+\s*|(?:wmr|wm|mm\s*linkz|tamilmv|tamilblasters|1tamilmv)\s+)"
+)
+
+
+def _sanitize_media_title(text: str) -> str:
+    """Strip channel prefixes, handles, and clean duplicate years."""
+    if not text:
+        return ""
+    s = text.strip()
+    while True:
+        m = CHANNEL_PREFIX_RE.match(s)
+        if not m:
+            break
+        s = s[m.end():].strip()
+    s = re.sub(r"(?i)\b(?:wmr|wm|mm\s*linkz|tamilmv|tamilblasters|1tamilmv)\b[._\s-]*", "", s).strip()
+    s = re.sub(r"^[^\w]+", "", s).strip()
+    # Normalize duplicate years like "Title (2008) (2008)" -> "Title (2008)"
+    years = re.findall(r"\((\d{4})\)", s)
+    if len(years) >= 2 and len(set(years)) == 1:
+        y = years[0]
+        s = re.sub(r"\s*\(\d{4}\)", "", s).strip()
+        s = f"{s} ({y})"
+    return s.strip()
+
+
+def _heal_nfo_file(nfo_path: str):
+    """Clean corrupted/channel-prefixed <title> and <originaltitle> in NFO files."""
+    if not os.path.isfile(nfo_path):
+        return
+    try:
+        with open(nfo_path, "r", encoding="utf-8", errors="ignore") as f:
+            content = f.read()
+        changed = False
+        tm = re.search(r"<title>(.*?)</title>", content)
+        if tm:
+            t_val = tm.group(1)
+            clean_t = _sanitize_media_title(t_val)
+            clean_t = re.sub(r"\s*\(\d{4}\)$", "", clean_t).strip()
+            if clean_t and clean_t != t_val:
+                content = content.replace(f"<title>{t_val}</title>", f"<title>{clean_t}</title>")
+                changed = True
+        om = re.search(r"<originaltitle>(.*?)</originaltitle>", content)
+        if om:
+            o_val = om.group(1)
+            clean_o = _sanitize_media_title(o_val)
+            clean_o = re.sub(r"\s*\(\d{4}\)$", "", clean_o).strip()
+            if clean_o and clean_o != o_val:
+                content = content.replace(f"<originaltitle>{o_val}</originaltitle>", f"<originaltitle>{clean_o}</originaltitle>")
+                changed = True
+        if changed:
+            with open(nfo_path, "w", encoding="utf-8") as f:
+                f.write(content)
+            print(f"[REPAIR] Healed titles in NFO: {nfo_path}")
+    except Exception as e:
+        print(f"[REPAIR] Note healing NFO {nfo_path}: {e}")
+
+
 def heal_mismatched_media(roots=None, databases=None):
-    """Clean folder/file release-size noise non-destructively and update DB paths."""
+    """Clean folder/file release-size noise and channel prefixes non-destructively and update DB paths."""
     search_roots = roots or [
         "/data/jellyfin/media/Movies",
         "/data/jellyfin/media/TV Shows",
@@ -422,44 +480,49 @@ def heal_mismatched_media(roots=None, databases=None):
             if not dirname or dirpath == root_dir:
                 continue
 
-            # 1. Rename directories containing release-size noise: "Iron Man 3 780Mb (2013)" -> "Iron Man 3 (2013)"
-            if size_re.search(dirname):
-                clean_name = size_re.sub("", dirname)
-                clean_name = re.sub(r"\s+", " ", clean_name).strip(" -_.")
-                if clean_name and clean_name != dirname:
-                    parent_dir = os.path.dirname(dirpath)
-                    new_dirpath = os.path.join(parent_dir, clean_name)
-                    if not os.path.exists(new_dirpath):
+            # 1. Rename directories containing release-size or channel prefix noise
+            clean_name = dirname
+            if size_re.search(clean_name):
+                clean_name = size_re.sub("", clean_name)
+            clean_name = _sanitize_media_title(clean_name)
+            clean_name = re.sub(r"\s+", " ", clean_name).strip(" -_.")
+            if clean_name and clean_name != dirname:
+                parent_dir = os.path.dirname(dirpath)
+                new_dirpath = os.path.join(parent_dir, clean_name)
+                if not os.path.exists(new_dirpath):
+                    try:
+                        os.rename(dirpath, new_dirpath)
+                        print(f"[REPAIR] Cleaned folder name: '{dirpath}' -> '{new_dirpath}'")
+                        for db_p in db_list:
+                            if os.path.exists(db_p):
+                                try:
+                                    conn = sqlite3.connect(db_p, timeout=5)
+                                    cur = conn.cursor()
+                                    cur.execute("SELECT Id, Path FROM BaseItems WHERE Path LIKE ?", (dirpath + "%",))
+                                    for row_id, p in cur.fetchall():
+                                        updated_p = new_dirpath + p[len(dirpath):]
+                                        conn.execute("UPDATE BaseItems SET Path = ? WHERE Id = ?", (updated_p, row_id))
+                                    conn.commit()
+                                    conn.close()
+                                except Exception:
+                                    pass
+                        dirpath = new_dirpath
+                        dirname = clean_name
                         try:
-                            os.rename(dirpath, new_dirpath)
-                            print(f"[REPAIR] Cleaned folder name: '{dirpath}' -> '{new_dirpath}'")
-                            for db_p in db_list:
-                                if os.path.exists(db_p):
-                                    try:
-                                        conn = sqlite3.connect(db_p, timeout=5)
-                                        cur = conn.cursor()
-                                        cur.execute("SELECT Id, Path FROM BaseItems WHERE Path LIKE ?", (dirpath + "%",))
-                                        for row_id, p in cur.fetchall():
-                                            updated_p = new_dirpath + p[len(dirpath):]
-                                            conn.execute("UPDATE BaseItems SET Path = ? WHERE Id = ?", (updated_p, row_id))
-                                        conn.commit()
-                                        conn.close()
-                                    except Exception:
-                                        pass
-                            dirpath = new_dirpath
-                            dirname = clean_name
-                            try:
-                                filenames = os.listdir(new_dirpath)
-                            except Exception:
-                                pass
-                        except Exception as ren_err:
-                            print(f"[REPAIR] Note renaming folder {dirpath}: {ren_err}")
+                            filenames = os.listdir(new_dirpath)
+                        except Exception:
+                            pass
+                    except Exception as ren_err:
+                        print(f"[REPAIR] Note renaming folder {dirpath}: {ren_err}")
 
-            # 2. Rename .strm files inside directory that contain release-size noise
+            # 2. Rename .strm files inside directory and heal NFOs
             for fn in list(filenames):
-                if fn.endswith(".strm") and size_re.search(fn):
+                if fn.endswith(".strm"):
                     base_no_ext, ext = os.path.splitext(fn)
-                    clean_strm_base = size_re.sub("", base_no_ext)
+                    clean_strm_base = base_no_ext
+                    if size_re.search(clean_strm_base):
+                        clean_strm_base = size_re.sub("", clean_strm_base)
+                    clean_strm_base = _sanitize_media_title(clean_strm_base)
                     clean_strm_base = re.sub(r"\s+", " ", clean_strm_base).strip(" -_.")
                     if clean_strm_base and clean_strm_base != base_no_ext:
                         old_strm = os.path.join(dirpath, fn)
@@ -479,6 +542,66 @@ def heal_mismatched_media(roots=None, databases=None):
                                             pass
                             except Exception as strm_err:
                                 print(f"[REPAIR] Note renaming strm {old_strm}: {strm_err}")
+                elif fn.lower() in ("movie.nfo", "tvshow.nfo"):
+                    _heal_nfo_file(os.path.join(dirpath, fn))
+
+
+def heal_channel_and_db_names(databases=None):
+    """Directly sanitize BaseItems.Name and CleanName in Jellyfin databases."""
+    db_list = databases or TARGET_DATABASES
+    for db_p in db_list:
+        if not os.path.exists(db_p):
+            continue
+        try:
+            conn = sqlite3.connect(db_p, timeout=10)
+            conn.isolation_level = None
+            cur = conn.cursor()
+            cur.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='BaseItems'")
+            if not cur.fetchone():
+                conn.close()
+                continue
+
+            cur.execute(
+                "SELECT Id, Name, Path, type FROM BaseItems "
+                "WHERE (type LIKE '%Movie%' OR type LIKE '%Episode%' OR type LIKE '%Series%')"
+            )
+            rows = cur.fetchall()
+            updated = 0
+            for row_id, name, path, itype in rows:
+                if not name:
+                    continue
+                name_str = str(name).strip()
+                needs_clean = (
+                    name_str.startswith("@")
+                    or name_str.lower().startswith("wmr")
+                    or name_str.lower().startswith("wm ")
+                    or name_str.lower().startswith("mm linkz")
+                    or bool(re.search(r"\(\d{4}\)\s*\(\d{4}\)", name_str))
+                )
+                if needs_clean:
+                    candidate = name_str
+                    if "..." in name_str and path:
+                        parts = [p for p in path.replace("\\", "/").split("/") if p]
+                        for part in reversed(parts):
+                            p_clean = os.path.splitext(part)[0]
+                            if not p_clean.lower().endswith((".strm", ".mkv", ".mp4", ".avi")):
+                                candidate = p_clean
+                                break
+                    clean_name = _sanitize_media_title(candidate)
+                    clean_name = re.sub(r"\s*\(\d{4}\)$", "", clean_name).strip()
+                    if clean_name and clean_name != name_str:
+                        cur.execute("UPDATE BaseItems SET Name = ? WHERE Id = ?", (clean_name, row_id))
+                        try:
+                            cur.execute("UPDATE BaseItems SET CleanName = ? WHERE Id = ?", (clean_name, row_id))
+                        except Exception:
+                            pass
+                        updated += 1
+                        print(f"[REPAIR] Healed BaseItems.Name: '{name_str}' -> '{clean_name}' (Id={row_id})")
+            conn.close()
+            if updated:
+                print(f"[REPAIR] Healed {updated} BaseItems name(s) in {db_p}")
+        except Exception as e:
+            print(f"[REPAIR] Error healing BaseItems names in {db_p}: {e}")
 
 
 def repair_user_subtitle_preferences(configs=None):
@@ -648,6 +771,7 @@ def main():
     cleanup_empty_media_folders()
     heal_subtitle_files()
     heal_mismatched_media()
+    heal_channel_and_db_names()
     repair_user_subtitle_preferences()
     repair_user_policy_preferences()
     repair_system_xml()

apex/tests/test_repair_jellyfin_libraries.py

@@ -9,6 +9,7 @@ from repair_jellyfin_libraries import (
     cleanup_empty_media_folders,
     heal_subtitle_files,
     heal_mismatched_media,
+    heal_channel_and_db_names,
     repair_user_subtitle_preferences,
     repair_user_policy_preferences,
     repair_system_xml,
@@ -613,6 +614,65 @@ def test_cleanup_empty_media_folders_never_deletes_non_empty_unrecognized_format
     assert (folder_with_xml / "data.xml").exists()
 
 
+def test_heal_channel_names_and_database(tmp_path):
+    movies_root = tmp_path / "Movies"
+    movies_root.mkdir()
+
+    # Create folder and strm with WMR and double-year
+    folder = movies_root / "WMR Iron Man (2008) (2008)"
+    folder.mkdir()
+    strm = folder / "WMR Iron Man (2008) (2008).strm"
+    strm.write_text("http://stream/1")
+    nfo = folder / "movie.nfo"
+    nfo.write_text("<movie><title>@WMR Iron Man (2008)</title><originaltitle>@WMR Iron Man</originaltitle></movie>")
+
+    db_file = tmp_path / "jellyfin.db"
+    conn = sqlite3.connect(str(db_file))
+    cur = conn.cursor()
+    cur.execute("""
+        CREATE TABLE BaseItems (
+            Id TEXT PRIMARY KEY,
+            Path TEXT,
+            Name TEXT,
+            CleanName TEXT,
+            type TEXT
+        )
+    """)
+    cur.execute("INSERT INTO BaseItems VALUES (?, ?, ?, ?, ?)", (
+        "item-ironman", str(strm), "@WM...", "@WM...", "MediaBrowser.Controller.Entities.Movies.Movie"
+    ))
+    conn.commit()
+    conn.close()
+
+    heal_mismatched_media(roots=[str(movies_root)], databases=[str(db_file)])
+    heal_channel_and_db_names(databases=[str(db_file)])
+
+    # Directory was renamed
+    healed_folder = movies_root / "Iron Man (2008)"
+    assert healed_folder.exists()
+    assert not folder.exists()
+    assert (healed_folder / "Iron Man (2008).strm").exists()
+
+    # NFO was healed
+    healed_nfo_text = (healed_folder / "movie.nfo").read_text()
+    assert "<title>Iron Man</title>" in healed_nfo_text
+    assert "@" not in healed_nfo_text
+    assert "WMR" not in healed_nfo_text
+
+    # Database name was healed
+    conn = sqlite3.connect(str(db_file))
+    cur = conn.cursor()
+    cur.execute("SELECT Name, CleanName, Path FROM BaseItems WHERE Id = ?", ("item-ironman",))
+    row = cur.fetchone()
+    conn.close()
+
+    assert row is not None
+    assert row[0] == "Iron Man"
+    assert "@" not in row[0]
+    assert "WMR" not in row[0]
+
+
+
 
 
 

apex/tests/test_tmdb_meta.py

@@ -29,6 +29,26 @@ class TestParseMediaMeta:
         assert "malayalam" not in meta["search_title"]
         assert "wmr" not in meta["search_title"]
 
+    def test_movie_channel_handles_stripped_top_three(self):
+        # Top 3 items from Jellyfin screenshot
+        meta1 = parse_media_meta("@WM_Movies_Iron_Man_2_2008_1080p.mkv")
+        assert not meta1["clean_title"].startswith("@")
+        assert not meta1["clean_title"].lower().startswith("wm")
+        assert "Iron Man 2" in meta1["clean_title"]
+        assert meta1["year"] == 2008
+
+        meta2 = parse_media_meta("@WMR Resident Evil Apocalypse (2004).mkv")
+        assert not meta2["clean_title"].startswith("@")
+        assert not meta2["clean_title"].lower().startswith("wmr")
+        assert "Resident Evil" in meta2["clean_title"]
+        assert meta2["year"] == 2004
+
+        meta3 = parse_media_meta("@WM.Spider-Man.Homecoming.2017.mkv")
+        assert not meta3["clean_title"].startswith("@")
+        assert not meta3["clean_title"].lower().startswith("wm")
+        assert "Spider" in meta3["clean_title"]
+        assert meta3["year"] == 2017
+
     def test_tv_sxe(self):
         meta = parse_media_meta("Breaking Bad S01E01 720p x264")
         assert meta["is_tv"] is True
@@ -783,4 +803,4 @@ class TestNfoRepair:
         monkeypatch.setattr("aiohttp.ClientSession", FailingClientSession)
         fail_res = await tg_streamer._ai_disambiguate_candidates("Other Movie 2026", candidates)
         assert fail_res is None
-
+

apex/tg_streamer.py

@@ -1537,6 +1537,14 @@ async def _fetch_imdb_suggestion(query: str, year: Optional[int] = None, media_t
     """Query official IMDb suggestion API with composite disambiguation scoring."""
     if not query:
         return None
+    # Strip channel prefixes before searching IMDb
+    q_clean = re.sub(r"(?i)^@(?:[a-z0-9]+)(?:[._-](?:movies|cinema|films|channel|linkz|official|hub|club|media|drive|hd|store|flim))?[._\s-]*", "", query)
+    q_clean = re.sub(r"^@[a-z0-9_]+\s*", "", q_clean, flags=re.IGNORECASE)
+    q_clean = re.sub(r"(?i)\b(?:wmr|wm|mm\s*linkz|tamilmv|tamilblasters|1tamilmv)\b", " ", q_clean)
+    q_clean = re.sub(r"^[^\w]+", "", q_clean)
+    q_clean = re.sub(r"\s+", " ", q_clean).strip(" -._")
+    if q_clean:
+        query = q_clean
     clean = re.sub(r"[^a-zA-Z0-9]+", "_", query).strip("_").lower()
     if not clean:
         return None
@@ -3089,7 +3097,13 @@ def _meta_to_entry(msg_id, chat_id, file_id, file_size, file_name):
     ext = extract_media_info(file_name)
 
     is_tv = bool(ext.get("is_tv") or meta.get("is_tv"))
-    clean_title = ext.get("title") or meta.get("clean_title") or meta.get("title")
+    clean_title = ext.get("title") or meta.get("clean_title") or meta.get("title") or ""
+    if clean_title:
+        clean_title = re.sub(r"(?i)^@(?:[a-z0-9]+)(?:[._-](?:movies|cinema|films|channel|linkz|official|hub|club|media|drive|hd|store|flim))?[._\s-]*", "", clean_title)
+        clean_title = re.sub(r"^@[a-z0-9_]+\s*", "", clean_title, flags=re.IGNORECASE)
+        clean_title = re.sub(r"(?i)\b(?:wmr|wm|mm\s*linkz|tamilmv|tamilblasters|1tamilmv)\b", " ", clean_title)
+        clean_title = re.sub(r"^[^\w]+", "", clean_title)
+        clean_title = re.sub(r"\s+", " ", clean_title).strip(" -._")
     year = ext.get("year") or meta.get("year")
     season = ext.get("season") or meta.get("season")
     episode = ext.get("episode") or meta.get("episode")
@@ -3106,6 +3120,11 @@ def _meta_to_entry(msg_id, chat_id, file_id, file_size, file_name):
         title = f"{clean_title} ({year})" if year else clean_title
 
     candidates = _search_candidates(file_name)
+    candidates = [
+        re.sub(r"(?i)^(?:@\S+\s*|(?:wmr|wm|mm\s*linkz)\s+)", "", c).strip(" -._")
+        for c in candidates
+    ]
+    candidates = [c for c in candidates if c]
     if clean_title and clean_title not in candidates:
         candidates.insert(0, clean_title)
 
@@ -5619,6 +5638,12 @@ async def reindex_all_with_imdb(force_all: bool = True) -> int:
             is_tv = bool(ext.get("is_tv") or data.get("is_tv") or parsed.get("is_tv"))
             mtype = "tv" if is_tv else "movie"
             title = ext.get("title") or parsed.get("clean_title") or data.get("clean_title") or data.get("title") or ""
+            if title:
+                title = re.sub(r"(?i)^@(?:[a-z0-9]+)(?:[._-](?:movies|cinema|films|channel|linkz|official|hub|club|media|drive|hd|store|flim))?[._\s-]*", "", title)
+                title = re.sub(r"^@[a-z0-9_]+\s*", "", title, flags=re.IGNORECASE)
+                title = re.sub(r"(?i)\b(?:wmr|wm|mm\s*linkz|tamilmv|tamilblasters|1tamilmv)\b", " ", title)
+                title = re.sub(r"^[^\w]+", "", title)
+                title = re.sub(r"\s+", " ", title).strip(" -._")
             year = ext.get("year") or parsed.get("year") or data.get("year")
             season = ext.get("season") or data.get("season") or 1
             episode = ext.get("episode") or data.get("episode") or 1
@@ -5628,9 +5653,20 @@ async def reindex_all_with_imdb(force_all: bool = True) -> int:
             if not imdb_hit and year:
                 imdb_hit = await _fetch_imdb_suggestion(title, None, mtype)
             if not imdb_hit and parsed.get("title") and parsed["title"] != title:
-                imdb_hit = await _fetch_imdb_suggestion(parsed["title"], year, mtype)
+                p_cand = parsed["title"]
+                p_cand = re.sub(r"(?i)^@(?:[a-z0-9]+)(?:[._-](?:movies|cinema|films|channel|linkz|official|hub|club|media|drive|hd|store|flim))?[._\s-]*", "", p_cand)
+                p_cand = re.sub(r"^@[a-z0-9_]+\s*", "", p_cand, flags=re.IGNORECASE)
+                p_cand = re.sub(r"(?i)\b(?:wmr|wm|mm\s*linkz|tamilmv|tamilblasters|1tamilmv)\b", " ", p_cand)
+                p_cand = re.sub(r"^[^\w]+", "", p_cand).strip(" -._")
+                imdb_hit = await _fetch_imdb_suggestion(p_cand, year, mtype)
 
             official_title = (imdb_hit.get("l") if imdb_hit else None) or title
+            if official_title:
+                official_title = re.sub(r"(?i)^@(?:[a-z0-9]+)(?:[._-](?:movies|cinema|films|channel|linkz|official|hub|club|media|drive|hd|store|flim))?[._\s-]*", "", official_title)
+                official_title = re.sub(r"^@[a-z0-9_]+\s*", "", official_title, flags=re.IGNORECASE)
+                official_title = re.sub(r"(?i)\b(?:wmr|wm|mm\s*linkz|tamilmv|tamilblasters|1tamilmv)\b", " ", official_title)
+                official_title = re.sub(r"^[^\w]+", "", official_title)
+                official_title = re.sub(r"\s+", " ", official_title).strip(" -._")
             official_year = (imdb_hit.get("y") if imdb_hit else None) or year
             imdb_id = (imdb_hit.get("id") if imdb_hit else None) or data.get("imdb_id")
             poster_url = ((imdb_hit.get("i") or {}).get("imageUrl") if imdb_hit else None) or data.get("poster_url")