Update app.py

app.py

@@ -5,23 +5,23 @@ import re
 import json
 from difflib import get_close_matches
 
-# Load channel mapping JSON
+# Load channel mapping JSON (unchanged)
 with open("channels_fixed.json", "r", encoding="utf-8") as f:
     channel_map = json.load(f)
 
-# Random 3-character filename generator
+# Random 3-character filename generator (unchanged)
 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"
 
-# Insert tvg-id immediately after #EXTINF:-1
+# Insert tvg-id immediately after #EXTINF:-1 (unchanged)
 def insert_tvg_id(extinf_line, tvg_id):
-    line = re.sub(r'tvg-id="[^"]*"', '', extinf_line)  # remove existing
+    line = re.sub(r'tvg-id="[^"]*"', '', extinf_line)  # remove existing tvg-id if present
     line = line.replace('#EXTINF:-1', f'#EXTINF:-1 tvg-id="{tvg_id}"', 1)
     line = re.sub(r'\s+', ' ', line).strip()
     return line
 
-# Apply special event rules
+# Apply special event rules (unchanged)
 def apply_event_special_cases(extinf_line, channel_name):
     line = extinf_line
     if "MLB LEAGUE PASS" in channel_name:
@@ -34,14 +34,23 @@ def apply_event_special_cases(extinf_line, channel_name):
         return insert_tvg_id(line, "Live.Event.us")
     return line
 
-# Main processor
+# Normalize helper: remove non-alphanum, lowercase
+def normalize_name(s: str) -> str:
+    if not s:
+        return ""
+    s = s.upper()
+    # Remove punctuation but keep letters and digits
+    s = re.sub(r'[^A-Z0-9]', '', s)
+    return s
+
+# Main processor (Project 1 Base with minimal fix)
 def process_m3u(m3u_text):
     lines = m3u_text.splitlines()
     out_247_blocks = []
     out_events_blocks = []
     log = []
 
-    # Hardcoded abbreviation + forced fixes
+    # Hardcoded abbreviation + forced fixes (now includes your new entries)
     hardcoded_fixes = {
         "BTN": "Big.Ten.Network.HD.us2",
         "SNY": "SNY.SportsNet.New.York.HD.us2",
@@ -50,6 +59,7 @@ def process_m3u(m3u_text):
         "MSG": "MSG.National.us2",
         "REELZ USA": "ReelzChannel.HD.us2",
         "ABCNY USA": "ABC.(WABC).New.York,.NY.us",
+        "ABC NY USA": "ABC.(WABC).New.York,.NY.us",   # handle space variant
         "OWN USA": "Oprah.Winfrey.Network.HD.us2",
         "DISCOVERY USA": "Discovery.Channel.ca2",
         "OUTDOOR CHANNEL": "Outdoor.Channel.HD.us2",
@@ -57,12 +67,15 @@ def process_m3u(m3u_text):
         "LOITV": "Soccer.Dummy.us",
     }
 
+    # Precompute normalized hardcoded map for fast comparisons
+    normalized_hardcoded = {normalize_name(k): v for k, v in hardcoded_fixes.items()}
+
     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
+            # Extract tvg-id and channel name (same as base)
             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)
@@ -83,49 +96,71 @@ def process_m3u(m3u_text):
 
             # --- EVENTS ---
             elif group_title and "EVENTS" in group_title:
-                candidate = channel_name
+                # candidate extraction: prefer bracketed network name if present
+                bracket_match = re.search(r'\[([^\]]+)\]', channel_name)
+                if bracket_match:
+                    candidate_raw = bracket_match.group(1).strip()
+                else:
+                    # fallback to entire display string
+                    candidate_raw = channel_name
+
+                candidate_norm = normalize_name(candidate_raw)
 
-                # Check hardcoded fixes first
+                # 1) Check hardcoded fixes FIRST using normalized keys
                 matched_fix = False
-                for key, fixed_id in hardcoded_fixes.items():
-                    if candidate.upper().startswith(key.upper()):
+                if candidate_norm:
+                    # exact normalized match
+                    if candidate_norm in normalized_hardcoded:
+                        fixed_id = normalized_hardcoded[candidate_norm]
                         new_ext = insert_tvg_id(extinf, fixed_id)
-                        new_ext = apply_event_special_cases(new_ext, candidate)
+                        new_ext = apply_event_special_cases(new_ext, candidate_raw)
                         out_events_blocks.append((new_ext, url))
-                        log.append(f"✅ EVENTS | {candidate} → {fixed_id} (hardcoded)")
+                        log.append(f"✅ EVENTS | {candidate_raw} → {fixed_id} (hardcoded exact)")
                         matched_fix = True
-                        break
+                    else:
+                        # sometimes bracket may be abbreviation (e.g. BTN), so check startswith any key
+                        for key_norm, fixed_id in normalized_hardcoded.items():
+                            # if candidate begins with the key (normalized), or key appears within candidate_norm
+                            if candidate_norm.startswith(key_norm) or key_norm in candidate_norm:
+                                new_ext = insert_tvg_id(extinf, fixed_id)
+                                new_ext = apply_event_special_cases(new_ext, candidate_raw)
+                                out_events_blocks.append((new_ext, url))
+                                log.append(f"✅ EVENTS | {candidate_raw} → {fixed_id} (hardcoded partial)")
+                                matched_fix = True
+                                break
+
                 if matched_fix:
                     continue
 
-                # Try matching against JSON
+                # 2) Try matching against JSON (same behavior as base)
                 match = None
                 for key, data in channel_map.items():
-                    if data.get("tvg_id") and key.lower() in candidate.lower():
+                    if data.get("tvg_id") and key.lower() in candidate_raw.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)
+                    guesses = get_close_matches(candidate_raw, keys, n=1, cutoff=0.6)
                     if guesses:
                         match = channel_map[guesses[0]].get("tvg_id")
+
                 if match:
                     new_ext = insert_tvg_id(extinf, match)
-                    log.append(f"✅ EVENTS | {candidate} → {match}")
+                    log.append(f"✅ EVENTS | {candidate_raw} → {match}")
                 else:
                     new_ext = insert_tvg_id(extinf, "Live.Event.us")
-                    log.append(f"⚠️ EVENTS | {candidate} → Live.Event.us (fallback)")
+                    log.append(f"⚠️ EVENTS | {candidate_raw} → Live.Event.us (fallback)")
 
-                new_ext = apply_event_special_cases(new_ext, candidate)
+                new_ext = apply_event_special_cases(new_ext, candidate_raw)
                 out_events_blocks.append((new_ext, url))
 
-    # Build output playlists
+    # Build output playlists (unchanged formatting)
     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 with better panel sizing
+# Gradio UI with requested sizing (small input, larger log)
 def run_app(m3u_text):
     out_247, out_events, log = process_m3u(m3u_text)
     file_247 = random_filename(uppercase=True)