Update app.py

app.py

@@ -1,246 +1,138 @@
-import re
-import json
+import gradio as gr
 import random
 import string
-import gradio as gr
+import re
+import json
 from difflib import get_close_matches
 
-CHANNELS_JSON = "channels_fixed.json"
-
-# Abbreviations mapping for Events channels
-ABBREVIATIONS = {
-    "BTN": "BIG TEN Network (BTN USA)",
-    # add other known abbreviations here
-}
-
-# Special-case tvg-ids
-SPECIAL_CASES = {
-    "MLB LEAGUE PASS": "MLB.Baseball.Dummy.us",
-    "NHL GAMECENTER": "NHL.Hockey.Dummy.us",
-}
-
-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:
-        return norm_map[matches[0]]
-    return None
-
-def generate_filename(upper=False):
-    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:
-            channels_ref = json.load(f)
-    except Exception as e:
-        return f"Error loading {CHANNELS_JSON}: {e}", None, None
-
+# Load channel mapping JSON
+with open("channels_fixed.json", "r", encoding="utf-8") as f:
+    channel_map = json.load(f)
+
+# Random 3-character filename generator
+def random_filename(uppercase=True):
+    letters = string.ascii_uppercase if uppercase else string.ascii_lowercase
+    return "".join(random.choice(letters) for _ in range(3)) + ".m3u"
+
+# Apply special event rules
+def apply_event_special_cases(extinf_line, channel_name):
+    line = extinf_line
+    if "MLB LEAGUE PASS" in channel_name:
+        return re.sub(r'tvg-id="[^"]*"', 'tvg-id="MLB.Baseball.Dummy.us"', line)
+    if "NHL GAMECENTER" in channel_name:
+        return re.sub(r'tvg-id="[^"]*"', 'tvg-id="NHL.Hockey.Dummy.us"', line)
+    if "ATP" in channel_name or "WTA" in channel_name:
+        return re.sub(r'tvg-id="[^"]*"', 'tvg-id="Tennis.Channel.us"', line)
+    if 'tvg-id="test"' in line:
+        return line.replace('tvg-id="test"', 'tvg-id="Live.Event.us"')
+    return line
+
+# Main processor
+def process_m3u(m3u_text):
     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:
-                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:
-            # 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_247_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
+    # Hardcoded abbreviation exceptions
+    exceptions = {
+        "BTN": "Big.Ten.Network.HD.us2",
+        "SNY": "SNY.SportsNet.New.York.HD.us2",
+        "MASN": "MASN.-.Mid.Atlantic.Sports.Network.us2",
+    }
+
+    for i, line in enumerate(lines):
+        if line.startswith("#EXTINF"):
+            url = lines[i+1] if i+1 < len(lines) else ""
+            extinf = line
+
+            # Extract tvg-id and channel name
+            tvg_match = re.search(r'tvg-id="([^"]*)"', extinf)
+            tvg_id = tvg_match.group(1) if tvg_match else None
+            name_match = re.search(r",(.*)", extinf)
+            channel_name = name_match.group(1).strip() if name_match else ""
+
+            # Extract group
+            group_match = re.search(r'group-title="([^"]*)"', extinf)
+            group_title = group_match.group(1).upper() if group_match else ""
+
+            # --- 24/7 CHANNELS ---
+            if "24/7" in group_title:
+                if tvg_id == "test" or not tvg_id:
+                    new_ext = re.sub(r'tvg-id="[^"]*"', 'tvg-id="Info.Guide.Dummy.us"', extinf) \
+                        if 'tvg-id="' in extinf else extinf + ' tvg-id="Info.Guide.Dummy.us"'
+                    log.append(f"ℹ️ 24/7 | {channel_name} → Info.Guide.Dummy.us")
                 else:
-                    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 ext had tvg-id="test", override with Live.Event.us (explicit)
-            if 'tvg-id="test"' in ext:
-                tvg_id = "Live.Event.us"
-
-            # 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)
+                    new_ext = extinf
+                out_247_blocks.append((new_ext, url))
+
+            # --- EVENTS ---
+            elif "EVENTS" in group_title:
+                candidate = channel_name
+
+                # Check hardcoded abbreviation exceptions
+                matched_exception = False
+                for abbr, fixed_id in exceptions.items():
+                    if candidate.upper().startswith(abbr):
+                        tvg_id = fixed_id
+                        new_ext = re.sub(r'tvg-id="[^"]*"', f'tvg-id="{tvg_id}"', extinf) \
+                            if 'tvg-id="' in extinf else extinf + f' tvg-id="{tvg_id}"'
+                        new_ext = apply_event_special_cases(new_ext, candidate)
+                        out_events_blocks.append((new_ext, url))
+                        log.append(f"✅ EVENTS | {candidate} → {tvg_id} (hardcoded {abbr} exception)")
+                        matched_exception = True
+                        break
+                if matched_exception:
+                    continue
+
+                # Try matching against JSON
+                match = None
+                for key, data in channel_map.items():
+                    if data.get("tvg_id") and key.lower() in candidate.lower():
+                        match = data["tvg_id"]
+                        break
+                if not match:
+                    keys = list(channel_map.keys())
+                    guesses = get_close_matches(candidate, keys, n=1, cutoff=0.6)
+                    if guesses:
+                        match = channel_map[guesses[0]].get("tvg_id")
+
+                if match:
+                    new_ext = re.sub(r'tvg-id="[^"]*"', f'tvg-id="{match}"', extinf) \
+                        if 'tvg-id="' in extinf else extinf + f' tvg-id="{match}"'
+                    log.append(f"✅ EVENTS | {candidate} → {match}")
                 else:
-                    # 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)
-
-            # clean up chosen_tvg variable for next loop
-            if 'chosen_tvg' in locals():
-                del chosen_tvg
-
-            # 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)")
-
-            out_events_blocks.append((new_ext, url))
-
-        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"
-
-            # replace test if present
-            if 'tvg-id="test"' in ext:
-                tvg_id = "Info.Guide.Dummy.us"
-
-            # 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)")
-
-            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_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"),
-    ],
-    title="Project 1 — M3U Updater (stable output format)"
+                    new_ext = re.sub(r'tvg-id="[^"]*"', 'tvg-id="Live.Event.us"', extinf) \
+                        if 'tvg-id="' in extinf else extinf + ' tvg-id="Live.Event.us"'
+                    log.append(f"⚠️ EVENTS | {candidate} → Live.Event.us (fallback)")
+
+                new_ext = apply_event_special_cases(new_ext, candidate)
+                out_events_blocks.append((new_ext, url))
+
+    # Build output playlists
+    out_247 = "\n".join([f"{ext}\n{url}" for ext, url in out_247_blocks])
+    out_events = "\n".join([f"{ext}\n{url}" for ext, url in out_events_blocks])
+
+    return out_247, out_events, "\n".join(log)
+
+# Gradio UI
+def run_app(m3u_text):
+    out_247, out_events, log = process_m3u(m3u_text)
+    file_247 = random_filename(uppercase=True)
+    file_events = random_filename(uppercase=False)
+    with open(file_247, "w", encoding="utf-8") as f:
+        f.write(out_247)
+    with open(file_events, "w", encoding="utf-8") as f:
+        f.write(out_events)
+    return f"✅ Processed!\n24/7 file: {file_247}\nEvents file: {file_events}\n\nLog:\n{log}"
+
+iface = gr.Interface(
+    fn=run_app,
+    inputs=gr.Textbox(lines=15, placeholder="Paste your M3U playlist here..."),
+    outputs="text",
+    title="Project 1 Playlist Processor",
+    description="Splits 24/7 and Events playlists, applies JSON tvg-id mappings, adds special sports rules, and outputs two clean M3Us."
 )
 
 if __name__ == "__main__":
-    demo.launch()
+    iface.launch()