Update app.py

app.py

@@ -9,146 +9,238 @@ CHANNELS_JSON = "channels_fixed.json"
 
 # Abbreviations mapping for Events channels
 ABBREVIATIONS = {
-    "BTN": "BIG TEN Network (BTN USA)"
-    # Add more abbreviations here if needed
+    "BTN": "BIG TEN Network (BTN USA)",
+    # add other known abbreviations here
 }
 
-# Special cases mapping
+# Special-case tvg-ids
 SPECIAL_CASES = {
     "MLB LEAGUE PASS": "MLB.Baseball.Dummy.us",
-    "NHL GAMECENTER": "NHL.Hockey.Dummy.us"
+    "NHL GAMECENTER": "NHL.Hockey.Dummy.us",
 }
 
-def normalize(name):
-    name = name.lower()
-    name = re.sub(r'[^a-z0-9]', '', name)
-    name = re.sub(r'0+', '', name)
-    return name
-
-def fuzzy_match(name, json_keys, cutoff=0.8):
-    matches = get_close_matches(normalize(name), [normalize(k) for k in json_keys], n=1, cutoff=cutoff)
+def normalize(s: str) -> str:
+    s = (s or "").lower()
+    s = re.sub(r'[^a-z0-9]', '', s)
+    s = re.sub(r'^0+', '', s)  # remove leading zeros
+    return s
+
+def find_best_match(candidate: str, keys):
+    """Normalize + fuzzy match candidate against keys; returns matching key or None."""
+    if not candidate:
+        return None
+    candidate_norm = normalize(candidate)
+    norm_map = {normalize(k): k for k in keys}
+    # direct normalized match
+    if candidate_norm in norm_map:
+        return norm_map[candidate_norm]
+    # fuzzy on normalized keys
+    matches = get_close_matches(candidate_norm, list(norm_map.keys()), n=1, cutoff=0.75)
     if matches:
-        for k in json_keys:
-            if normalize(k) == matches[0]:
-                return k
+        return norm_map[matches[0]]
     return None
 
 def generate_filename(upper=False):
-    chars = ''.join(random.choices(string.ascii_uppercase if upper else string.ascii_lowercase, k=3))
-    return f"{chars}.m3u"
-
-def process_playlist(m3u_content):
-    m3u_lines = m3u_content.splitlines()
+    letters = ''.join(random.choices(string.ascii_uppercase if upper else string.ascii_lowercase, k=3))
+    return f"{letters}.m3u"
 
+def process_playlist_text(m3u_text):
+    # load JSON reference
     try:
-        with open(CHANNELS_JSON, 'r', encoding='utf-8') as f:
+        with open(CHANNELS_JSON, "r", encoding="utf-8") as f:
             channels_ref = json.load(f)
     except Exception as e:
-        return f"Error reading JSON: {e}", None, None
-
-    m3u_24_7 = []
-    m3u_events = []
-    current_section = None
-
-    for line in m3u_lines:
-        if line.startswith('#EXTINF'):
-            if 'group-title="24/7 CHANNELS' in line:
-                current_section = '24_7'
-            elif 'EVENTS|' in line:
-                current_section = 'events'
+        return f"Error loading {CHANNELS_JSON}: {e}", None, None
+
+    lines = m3u_text.splitlines()
+    headers = []
+    blocks = []  # list of dicts: {ext, url, section, orig_index}
+
+    i = 0
+    idx = 0
+    while i < len(lines):
+        line = lines[i].rstrip("\n")
+        if line.startswith("#EXTINF"):
+            ext = line
+            url = ""
+            # take the next line as the URL if present
+            if i + 1 < len(lines):
+                url = lines[i+1].rstrip("\n")
+                i += 2
             else:
-                current_section = None
-
-        if current_section == '24_7':
-            m3u_24_7.append(line)
-        elif current_section == 'events':
-            line = re.sub(r'group-title="24/7 CHANNELS[^"]*"', '', line)
-            m3u_events.append(line)
+                i += 1
+            # determine section
+            sec = "other"
+            # robust check for 24/7 and EVENTS
+            if 'group-title="' in ext and '24/7' in ext:
+                sec = "24_7"
+            elif 'EVENTS|' in ext:
+                sec = "events"
+            blocks.append({"ext": ext, "url": url, "section": sec, "idx": idx})
+            idx += 1
         else:
-            m3u_24_7.append(line)
-            m3u_events.append(line)
-
-    log_lines = []
-
-    def update_tvg_id(lines, is_event=False):
-        updated = []
-        for line in lines:
-            if line.startswith('#EXTINF'):
-                parts = line.split(',')
-                ch_name = parts[-1].strip()
-
-                new_tvg_id = None
-
-                if is_event:
-                    match_brackets = re.search(r'\[(.*?)\]', ch_name)
-                    ch_name_to_match = match_brackets.group(1) if match_brackets else ch_name
-
-                    if ch_name_to_match in SPECIAL_CASES:
-                        new_tvg_id = SPECIAL_CASES[ch_name_to_match]
-                    elif ch_name_to_match in ABBREVIATIONS:
-                        match_key = ABBREVIATIONS[ch_name_to_match]
-                        new_tvg_id = channels_ref.get(match_key, {}).get('tvg_id', 'Live.Event.us')
-                    else:
-                        if re.search(r'ATP|WTA', ch_name_to_match, re.IGNORECASE):
-                            new_tvg_id = 'Tennis.Channel.us'
-                        else:
-                            ch_name_norm = normalize(ch_name_to_match)
-                            json_keys_norm = {k: normalize(k) for k in channels_ref.keys()}
-                            match_key = None
-                            matches = get_close_matches(ch_name_norm, list(json_keys_norm.values()), n=1, cutoff=0.7)
-                            if matches:
-                                for k, v in json_keys_norm.items():
-                                    if v == matches[0]:
-                                        match_key = k
-                                        break
-                            new_tvg_id = channels_ref[match_key]['tvg_id'] if match_key else 'Live.Event.us'
-
-                    # Ensure tvg-id="test" is replaced with tvg-id="Live.Event.us"
-                    line = re.sub(r'tvg-id="test"', 'tvg-id="Live.Event.us"', line)
+            # header / comment lines (keep for both outputs)
+            headers.append(line)
+            i += 1
+
+    # now process each block to decide tvg-id updates; we will NOT remove group-title here
+    out_24_7_blocks = []
+    out_events_blocks = []
+    log = []
+
+    json_keys = list(channels_ref.keys())
+
+    for b in blocks:
+        ext = b["ext"]
+        url = b["url"]
+        sec = b["section"]
+
+        # default: no change
+        new_ext = ext
+
+        if sec == "events":
+            # extract bracketed channel name if present, otherwise fallback to display name (after last comma)
+            m = re.search(r'\[([^\]]+)\]', ext)
+            candidate = m.group(1).strip() if m else ext.split(",")[-1].strip()
+
+            # check abbreviations first (exact match)
+            match_key = None
+            if candidate in ABBREVIATIONS:
+                mapkey = ABBREVIATIONS[candidate]
+                if mapkey in channels_ref:
+                    match_key = mapkey
+
+            # special cases by substring/inclusion in candidate or ext line
+            if not match_key:
+                up = candidate.upper()
+                ext_up = ext.upper()
+                if "MLB LEAGUE PASS" in up or "MLB LEAGUE PASS" in ext_up:
+                    chosen_tvg = SPECIAL_CASES["MLB LEAGUE PASS"]
+                    match_key = None
+                elif "NHL GAMECENTER" in up or "NHL GAMECENTER" in ext_up:
+                    chosen_tvg = SPECIAL_CASES["NHL GAMECENTER"]
+                    match_key = None
                 else:
-                    match_key = fuzzy_match(ch_name, channels_ref.keys())
-                    new_tvg_id = channels_ref[match_key]['tvg_id'] if match_key else 'Info.Guide.Dummy.us'
-                    line = re.sub(r'tvg-id="test"', 'tvg-id="Info.Guide.Dummy.us"', line)
+                    chosen_tvg = None
+
+            # ATP/WTA fallback
+            if not match_key and not ('chosen_tvg' in locals() and chosen_tvg):
+                if re.search(r'\b(ATP|WTA)\b', candidate, flags=re.IGNORECASE):
+                    chosen_tvg = "Tennis.Channel.us"
+
+            # if no chosen_tvg yet, attempt fuzzy lookup
+            if not ('chosen_tvg' in locals() and chosen_tvg):
+                if match_key is None:
+                    best = find_best_match(candidate, json_keys)
+                    if best:
+                        match_key = best
+
+            # derive tvg-id
+            if 'chosen_tvg' in locals() and chosen_tvg:
+                tvg_id = chosen_tvg
+            elif match_key:
+                tvg_id = channels_ref.get(match_key, {}).get("tvg_id", None)
+            else:
+                tvg_id = "Live.Event.us"
 
-                if is_event:
-                    line = re.sub(r'group-title="[^"]*"', '', line)
+            # if ext had tvg-id="test", override with Live.Event.us (explicit)
+            if 'tvg-id="test"' in ext:
+                tvg_id = "Live.Event.us"
 
-                if 'tvg-id=' in line:
-                    line = re.sub(r'tvg-id=".*?"', f'tvg-id="{new_tvg_id}"', line)
+            # insert or replace tvg-id attribute (do NOT strip group-title here)
+            if tvg_id:
+                if 'tvg-id="' in new_ext:
+                    new_ext = re.sub(r'tvg-id="[^"]*"', f'tvg-id="{tvg_id}"', new_ext, count=1)
                 else:
-                    line = line.replace('#EXTINF:', f'#EXTINF:-1 tvg-id="{new_tvg_id}",')
+                    # insert after the #EXTINF:-1 token (keep other attributes)
+                    new_ext = re.sub(r'(#EXTINF:-?\d+)(\s*)', r'\1 tvg-id="' + tvg_id + r'"\2', new_ext, count=1)
 
-                log_lines.append(f"{'✅' if (match_key or not is_event) else '⚠️'} {ch_name} → {new_tvg_id}")
+            # clean up chosen_tvg variable for next loop
+            if 'chosen_tvg' in locals():
+                del chosen_tvg
 
-            updated.append(line)
-        return updated
+            # logging
+            if match_key:
+                log.append(f"✅ EVENTS | {candidate} → {tvg_id} (matched {match_key})")
+            else:
+                # if we used an abbreviations mapped key, we already set match_key; otherwise unmatched
+                log.append(f"⚠️ EVENTS | {candidate} → {tvg_id} (no exact json match)")
 
-    updated_24_7 = update_tvg_id(m3u_24_7, is_event=False)
-    updated_events = update_tvg_id(m3u_events, is_event=True)
+            out_events_blocks.append((new_ext, url))
 
-    filename_24_7 = generate_filename(upper=True)
-    filename_events = generate_filename(upper=False)
+        elif sec == "24_7":
+            # use display name after last comma
+            display_name = ext.split(",")[-1].strip()
+            best = find_best_match(display_name, json_keys)
+            if best:
+                tvg_id = channels_ref.get(best, {}).get("tvg_id", None)
+            else:
+                tvg_id = "Info.Guide.Dummy.us"
 
-    with open(filename_24_7, 'w', encoding='utf-8') as f:
-        f.write('\n'.join(updated_24_7))
+            # replace test if present
+            if 'tvg-id="test"' in ext:
+                tvg_id = "Info.Guide.Dummy.us"
 
-    with open(filename_events, 'w', encoding='utf-8') as f:
-        f.write('\n'.join(updated_events))
+            # insert or replace
+            if 'tvg-id="' in new_ext:
+                new_ext = re.sub(r'tvg-id="[^"]*"', f'tvg-id="{tvg_id}"', new_ext, count=1)
+            else:
+                new_ext = re.sub(r'(#EXTINF:-?\d+)(\s*)', r'\1 tvg-id="' + tvg_id + r'"\2', new_ext, count=1)
+
+            log.append(f"✅ 24/7  | {display_name} → {tvg_id}" if best else f"⚠️ 24/7  | {display_name} → {tvg_id} (no json match)")
 
-    log_text = '\n'.join(log_lines)
-    return log_text, filename_24_7, filename_events
+            out_24_7_blocks.append((new_ext, url))
+
+        else:
+            # other: keep as-is (but still write as block if has URL)
+            out_24_7_blocks.append((ext, url))
+            out_events_blocks.append((ext, url))
+
+    # Build output text for both playlists (headers first, then blocks)
+    def build_text(header_lines, block_list):
+        out = []
+        # write header lines, but skip the url-tvg epg line if present (optional)
+        for h in header_lines:
+            # optional: skip url-tvg line that pointed to xml epg if present
+            if h.strip().startswith('#EXTM3U url-tvg='):
+                continue
+            out.append(h)
+        # then blocks
+        for ext, url in block_list:
+            out.append(ext)
+            # write URL on next line (even if empty)
+            if url is not None:
+                out.append(url)
+        return "\n".join(out) + "\n"
+
+    text_24_7 = build_text(headers, out_24_7_blocks)
+    text_events = build_text(headers, out_events_blocks)
+
+    # write to files with random names
+    f24 = generate_filename(upper=True)
+    fev = generate_filename(upper=False)
+    with open(f24, "w", encoding="utf-8") as f:
+        f.write(text_24_7)
+    with open(fev, "w", encoding="utf-8") as f:
+        f.write(text_events)
+
+    return ("\n".join(log), f24, fev)
 
 # --- Gradio UI ---
+def run_gradio(m3u_text):
+    status, f1, f2 = process_playlist_text(m3u_text)
+    return status, f1, f2
+
 demo = gr.Interface(
-    fn=process_playlist,
-    inputs=[gr.Textbox(label="Paste M3U8 Playlist Here", lines=25)],
+    fn=process_playlist_text,
+    inputs=[gr.Textbox(label="Paste M3U8 Playlist Here", lines=30)],
     outputs=[
         gr.Textbox(label="Update Log", lines=25),
         gr.File(label="Download 24/7 Channels M3U"),
-        gr.File(label="Download Events M3U")
+        gr.File(label="Download Events M3U"),
     ],
-    title="Project 1 Playlist Updater - Smart Events",
-    description="Paste the M3U8 playlist content. Updates 24/7 and Events channels tvg-id using channels_fixed.json with smart Events matching. Handles special cases like MLB, NHL, ATP/WTA. Replaces tvg-id=\"test\" properly."
+    title="Project 1 — M3U Updater (stable output format)"
 )
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()