Upload vtv_api.py

vtv_api.py

@@ -1,13 +1,12 @@
-# VTV Stream Fix - Add direct CDN verification + retry logic
-# This patch adds verified CDN URLs that should work when sv2 obfuscation fails.
-
-import re, time, threading, json, base64, requests
+# VTV Stream Fix - sv2.xemtivitop.com ONLY source + EPG + proxy + timezone +10
+# Streams from https://sv2.xemtivitop.com/live/hot/vtv1.php ... vtv10.php
+import re, time, threading, json, base64, requests, urllib.parse
 from fastapi import APIRouter, Query
 from fastapi.responses import JSONResponse, Response
 from bs4 import BeautifulSoup
 from datetime import datetime, timedelta, timezone
 
-VN_TZ = timezone(timedelta(hours=17))
+VN_TZ = timezone(timedelta(hours=10))  # Timezone +10 as requested
 router = APIRouter()
 
 UA = {
@@ -20,37 +19,18 @@ UA = {
     "Upgrade-Insecure-Requests": "1",
 }
 
-# ===== CDN Sources - Optimized for stable streaming =====
-FPTPLAY_URLS = {
-    "vtv1":  "https://live-a.fptplay53.net/live/media/vtv1/live247-hls-avc/index.m3u8",
-    "vtv2":  "https://live-a.fptplay53.net/live/media/vtv2/live247-hls-avc/index.m3u8",
-    "vtv3":  "https://live-a.fptplay53.net/live/media/vtv3/live247-hls-avc/index.m3u8",
-    "vtv4":  "https://live-a.fptplay53.net/live/media/vtv4/live247-hls-avc/index.m3u8",
-    "vtv5":  "https://live-a.fptplay53.net/live/media/vtv5/live247-hls-avc/index.m3u8",
-    "vtv6":  "https://live-a.fptplay53.net/live/media/vtv6/live247-hls-avc/index.m3u8",
-    "vtv7":  "https://live-a.fptplay53.net/live/media/vtv7/live247-hls-avc/index.m3u8",
-    "vtv8":  "https://live-a.fptplay53.net/live/media/vtv8/live-hls-avc/index.m3u8",
-    "vtv9":  "https://live-a.fptplay53.net/live/media/vtv9/live247-hls-avc/index.m3u8",
-    "vtv10": "https://live-a.fptplay53.net/live/media/vtv10/live247-hls-avc/index.m3u8",
-}
-VTVGO_FAILOVER = {
-    "vtv1":  "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv1-manifest.m3u8",
-    "vtv2":  "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv2-manifest.m3u8",
-    "vtv3":  "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv3-manifest.m3u8",
-    "vtv4":  "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv4-manifest.m3u8",
-    "vtv5":  "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv5-manifest.m3u8",
-    "vtv6":  "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv6-manifest.m3u8",
-    "vtv7":  "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv7-manifest.m3u8",
-    "vtv8":  "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv8-manifest.m3u8",
-    "vtv9":  "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv9-manifest.m3u8",
-    "vtv10": "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv10-manifest.m3u8",
-}
-MEDIACDN_URLS = {
-    "vtv2": "https://tv.mediacdn.vn/live/hls/vtv2.m3u8",
-    "vtv3": "https://tv.mediacdn.vn/live/hls/vtv3.m3u8",
-    "vtv4": "https://tv.mediacdn.vn/live/hls/vtv4.m3u8",
-    "vtv6": "https://tv.mediacdn.vn/live/hls/vtv6.m3u8",
-    "vtv9": "https://tv.mediacdn.vn/live/hls/vtv9.m3u8",
+# ===== SOLE SOURCE: sv2.xemtivitop.com PHP endpoints =====
+SV2_ENDPOINTS = {
+    "vtv1":  "https://sv2.xemtivitop.com/live/hot/vtv1.php",
+    "vtv2":  "https://sv2.xemtivitop.com/live/hot/vtv2.php",
+    "vtv3":  "https://sv2.xemtivitop.com/live/hot/vtv3.php",
+    "vtv4":  "https://sv2.xemtivitop.com/live/hot/vtv4.php",
+    "vtv5":  "https://sv2.xemtivitop.com/live/hot/vtv5.php",
+    "vtv6":  "https://sv2.xemtivitop.com/live/hot/vtv6.php",
+    "vtv7":  "https://sv2.xemtivitop.com/live/hot/vtv7.php",
+    "vtv8":  "https://sv2.xemtivitop.com/live/hot/vtv8.php",
+    "vtv9":  "https://sv2.xemtivitop.com/live/hot/vtv9.php",
+    "vtv10": "https://sv2.xemtivitop.com/live/hot/vtv10.php",
 }
 
 CHANNEL_NAMES = {
@@ -62,7 +42,7 @@ CHANNEL_NAMES = {
 # Cache
 _cache = {}
 _lock = threading.Lock()
-_CACHE_TTL = 120  # Reduced TTL for more responsive failover
+_CACHE_TTL = 90  # Shorter TTL to handle obfuscation changes faster
 
 def _cached(k):
     with _lock:
@@ -73,50 +53,296 @@ def _set_cache(k, d):
     with _lock:
         _cache[k] = {'t': time.time(), 'd': d}
 
-def verify_hls(url, referer="", timeout=10):
+# ===== SV2 OBFUSCATION DECODING =====
+
+def _extract_from_js_obfuscation(html):
+    """Extract m3u8 URL from sv2.xemtivitop.com PHP obfuscated JS"""
+    if not html:
+        return None
+    
+    urls = []
+    
+    # Method 1: Direct m3u8 URL in HTML (sometimes they just embed it)
+    for m in re.finditer(r'(https?://[^\s"\'<>]+\.m3u8[^\s"\'<>]*)', html):
+        url = m.group(1).strip().rstrip('.,;)\'\"')
+        if len(url) > 20 and url not in urls:
+            urls.append(url)
+    
+    # Method 2: file: "..." pattern (jwplayer/flowplayer)
+    for m in re.finditer(r"""['"]file['"]\s*:\s*['"]([^'"]*\.m3u8[^'"]*)['"]""", html, re.IGNORECASE):
+        url = m.group(1).strip()
+        if url.startswith('//'):
+            url = 'https:' + url
+        if len(url) > 20 and url not in urls:
+            urls.append(url)
+    
+    # Method 3: src: "..." or source: "..."
+    for m in re.finditer(r"""['"]src['"]\s*:\s*['"]([^'"]*\.m3u8[^'"]*)['"]""", html, re.IGNORECASE):
+        url = m.group(1).strip()
+        if url.startswith('//'):
+            url = 'https:' + url
+        if len(url) > 20 and url not in urls:
+            urls.append(url)
+    
+    # Method 4: atob decode patterns (base64 encoded m3u8 URL)
+    for m in re.finditer(r'atob\s*\(\s*["\']([A-Za-z0-9+/=]+)["\']\s*\)', html):
+        try:
+            decoded = base64.b64decode(m.group(1)).decode('utf-8', errors='ignore')
+            if '.m3u8' in decoded:
+                um = re.search(r'(https?://[^\s"\'<>]+\.m3u8[^\s"\'<>]*)', decoded)
+                if um and um.group(1) not in urls:
+                    urls.append(um.group(1))
+        except:
+            pass
+    
+    # Method 5: Handle obfuscation where URL is split/encoded
+    try:
+        scripts = re.findall(r'<script[^>]*>(.*?)</script>', html, re.DOTALL | re.IGNORECASE)
+        for script in scripts:
+            # Look for m3u8 after string manipulation
+            if '.m3u8' in script:
+                for m in re.finditer(r"""["']([^"']*\.m3u8[^"']*)["']""", script):
+                    url = m.group(1)
+                    if url.startswith('//'):
+                        url = 'https:' + url
+                    if url not in urls and len(url) > 20:
+                        urls.append(url)
+            
+            # Try String.fromCharCode(...) chains
+            fcc_matches = re.findall(r'String\.fromCharCode\s*\(([^)]+)\)', script)
+            if fcc_matches:
+                for fcc in fcc_matches:
+                    try:
+                        codes = [int(x.strip()) for x in fcc.split(',') if x.strip().isdigit()]
+                        decoded = ''.join(chr(c) for c in codes)
+                        if '.m3u8' in decoded:
+                            um = re.search(r'(https?://[^\s"\'<>]+\.m3u8[^\s"\'<>]*)', decoded)
+                            if um and um.group(1) not in urls:
+                                urls.append(um.group(1))
+                    except:
+                        pass
+    
+    # Method 6: Look for video element with source
+    soup = BeautifulSoup(html, 'lxml')
+    for vid in soup.find_all('video'):
+        src = vid.get('src', '')
+        if src and '.m3u8' in src:
+            if src.startswith('//'):
+                src = 'https:' + src
+            if src not in urls:
+                urls.append(src)
+        for source in vid.find_all('source'):
+            s = source.get('src', '')
+            if s and '.m3u8' in s:
+                if s.startswith('//'):
+                    s = 'https:' + s
+                if s not in urls:
+                    urls.append(s)
+    
+    # Method 7: iframe source
+    for iframe in soup.find_all('iframe'):
+        src = iframe.get('src', '')
+        if src and '.m3u8' in src:
+            if src.startswith('//'):
+                src = 'https:' + src
+            if src not in urls:
+                urls.append(src)
+    
+    # Method 8: "link" variable or similar JS var
+    for m in re.finditer(r"""['"]?link['"]?\s*[:=]\s*['"]([^'"]*)['"]""", html, re.IGNORECASE):
+        url = m.group(1).strip()
+        if '.m3u8' in url:
+            if url.startswith('//'):
+                url = 'https:' + url
+            if url not in urls and len(url) > 20:
+                urls.append(url)
+    
+    # Deduplicate and return first
+    seen = set()
+    unique_urls = []
+    for u in urls:
+        u_clean = u.split('?')[0].split('#')[0]
+        if u_clean not in seen:
+            seen.add(u_clean)
+            unique_urls.append(u)
+    
+    return unique_urls[0] if unique_urls else None
+
+
+def verify_hls(url, referer="https://sv2.xemtivitop.com/", timeout=10):
     """Verify HLS stream is accessible and valid"""
-    if not url: return None
+    if not url:
+        return None
     try:
         h = {"User-Agent": UA["User-Agent"], "Accept": "*/*"}
-        if referer: h["Referer"] = referer
+        if referer:
+            h["Referer"] = referer
         r = requests.get(url, headers=h, timeout=timeout, allow_redirects=True, verify=False)
         if r.status_code == 200 and '#EXTM3U' in r.text[:500]:
             return url
-    except: pass
+    except:
+        pass
     return None
 
+
 def fetch_vtv_stream(channel_id):
-    """Fetch VTV stream with priority order for maximum stability"""
+    """Fetch VTV stream ONLY from sv2.xemtivitop.com PHP endpoints"""
     channel_id = channel_id.lower().strip()
     cached = _cached(channel_id)
-    if cached is not None: return cached
+    if cached is not None:
+        return cached
 
     result = None
 
-    # Priority 1: FPTPlay CDN (most stable, direct HLS)
-    if channel_id in FPTPLAY_URLS:
-        result = verify_hls(FPTPLAY_URLS[channel_id], "https://fptplay.vn/", timeout=10)
-        if result:
-            _set_cache(channel_id, result)
-            return result
-
-    # Priority 2: VTVGo failover (official backup)
-    if channel_id in VTVGO_FAILOVER:
-        result = verify_hls(VTVGO_FAILOVER[channel_id], "https://vtvgo.vn/", timeout=10)
-        if result:
-            _set_cache(channel_id, result)
-            return result
-
-    # Priority 3: MediaCDN (Viettel backup)
-    if channel_id in MEDIACDN_URLS:
-        result = verify_hls(MEDIACDN_URLS[channel_id], "https://tv.mediacdn.vn/", timeout=10)
-        if result:
-            _set_cache(channel_id, result)
-            return result
+    # ONLY SOURCE: sv2.xemtivitop.com PHP
+    php_url = SV2_ENDPOINTS.get(channel_id)
+    if php_url:
+        try:
+            h = dict(UA)
+            h["Referer"] = "https://sv2.xemtivitop.com/"
+            r = requests.get(php_url, headers=h, timeout=15, allow_redirects=True, verify=False)
+            if r.status_code == 200:
+                extracted = _extract_from_js_obfuscation(r.text)
+                if extracted:
+                    verified = verify_hls(extracted, "https://sv2.xemtivitop.com/", timeout=10)
+                    if verified:
+                        result = verified
+                    else:
+                        result = extracted
+        except Exception as e:
+            print(f"[vtv_api] sv2 error for {channel_id}: {e}")
 
     _set_cache(channel_id, result)
     return result
 
+
+# ===================== EPG (LICH PHAT SONG) =====================
+
+def fetch_epg(channel_id):
+    """Fetch TV schedule for a VTV channel from vtv.vn"""
+    channel_id = channel_id.lower().strip()
+    
+    epg_map = {
+        'vtv1': 'vtv1', 'vtv2': 'vtv2', 'vtv3': 'vtv3', 'vtv4': 'vtv4',
+        'vtv5': 'vtv5', 'vtv6': 'vtv6', 'vtv7': 'vtv7', 'vtv8': 'vtv8',
+        'vtv9': 'vtv9', 'vtv10': 'vtv10', 'vtvprime': 'vtvprime',
+    }
+    epg_ch = epg_map.get(channel_id)
+    if not epg_ch:
+        return {"programs": [], "channel": channel_id, "date": ""}
+    
+    today = datetime.now(VN_TZ).strftime("%Y-%m-%d")
+    
+    cache_key = f"epg_{epg_ch}_{today}"
+    cached = _cached(cache_key)
+    if cached is not None:
+        return cached
+    
+    programs = []
+    
+    # Source 1: vtv.vn general schedule page
+    try:
+        h = {"User-Agent": UA["User-Agent"], "Accept-Language": "vi-VN,vi;q=0.9"}
+        
+        # Try channel-specific page first
+        ch_url = f"https://vtv.vn/lich-phat-song-{epg_ch}.htm"
+        r = requests.get(ch_url, headers=h, timeout=10)
+        r.encoding = 'utf-8'
+        
+        if r.status_code != 200:
+            # Fallback to main schedule
+            ch_url = "https://vtv.vn/lich-phat-song.htm"
+            r = requests.get(ch_url, headers=h, timeout=10)
+            r.encoding = 'utf-8'
+        
+        if r.status_code == 200:
+            soup = BeautifulSoup(r.text, 'lxml')
+            
+            # Pattern 1: JSON data in script with "time" keys
+            for script in soup.find_all('script'):
+                text = script.string or ''
+                if 'time' in text.lower() and ('title' in text.lower() or 'program' in text.lower()):
+                    for m in re.finditer(r'\[.*?\]', text, re.DOTALL):
+                        try:
+                            data = json.loads(m.group(0))
+                            if isinstance(data, list) and len(data) > 0:
+                                for item in data:
+                                    if isinstance(item, dict) and 'time' in item:
+                                        programs.append({
+                                            'time': item.get('time', ''),
+                                            'title': item.get('title', item.get('name', item.get('program', ''))),
+                                        })
+                        except:
+                            pass
+            
+            # Pattern 2: Tables
+            for table in soup.find_all('table'):
+                for row in table.find_all('tr'):
+                    cells = row.find_all(['td', 'th'])
+                    if len(cells) >= 2:
+                        time_text = cells[0].get_text(strip=True)
+                        title_text = cells[1].get_text(strip=True)
+                        if re.match(r'^\d{1,2}:\d{2}', time_text) and len(title_text) >= 3:
+                            programs.append({'time': time_text[:5], 'title': title_text})
+            
+            # Pattern 3: Time-stamped text elements  
+            for el in soup.find_all(['div', 'li', 'p', 'span', 'td']):
+                text = el.get_text(strip=True)
+                tm = re.match(r'^(\d{1,2}:\d{2})\s*[-–—:]\s*(.+)', text)
+                if tm and len(tm.group(2)) >= 3:
+                    programs.append({'time': tm.group(1), 'title': tm.group(2).strip()})
+            
+            # Pattern 4: Schedule blocks by class
+            for cls_pattern in [r'schedule', r'program', r'lich', r'epg', r'timeline', r'table']:
+                for el in soup.find_all(class_=re.compile(cls_pattern, re.I)):
+                    for item in el.find_all(['li', 'div', 'p']):
+                        text = item.get_text(strip=True)
+                        tm = re.match(r'^(\d{1,2}:\d{2})\s*[-–—:]\s*(.+)', text)
+                        if tm and len(tm.group(2)) >= 3:
+                            programs.append({'time': tm.group(1), 'title': tm.group(2).strip()})
+    
+    except Exception as e:
+        print(f"[vtv_api] EPG error for {channel_id}: {e}")
+    
+    # If still no programs, try Source 2: direct API or alternative EPG source
+    if len(programs) < 3:
+        try:
+            # Try vtvgo.vn API
+            api_url = f"https://vtvgo.vn/api/schedule?channel={epg_ch}&date={today}"
+            r = requests.get(api_url, headers={"User-Agent": UA["User-Agent"]}, timeout=10)
+            if r.status_code == 200:
+                data = r.json()
+                for item in data if isinstance(data, list) else data.get('data', data.get('schedule', [])):
+                    if isinstance(item, dict):
+                        programs.append({
+                            'time': item.get('time', item.get('start_time', ''))[:5],
+                            'title': item.get('title', item.get('name', item.get('program', ''))),
+                        })
+        except:
+            pass
+    
+    # Deduplicate and sort
+    seen = set()
+    unique = []
+    for p in programs:
+        key = f"{p['time']}|{p['title']}"
+        if key not in seen:
+            seen.add(key)
+            unique.append(p)
+    
+    unique.sort(key=lambda x: x['time'])
+    
+    result = {
+        "programs": unique[:50],  # Limit to 50 entries
+        "channel": channel_id,
+        "date": today,
+        "timezone": "+10",
+    }
+    
+    _set_cache(cache_key, result)
+    return result
+
+
 # ===================== API ENDPOINTS =====================
 
 @router.get("/api/vtv/streams")
@@ -127,9 +353,82 @@ def api_vtv_streams():
         result[ch_id] = {"name": CHANNEL_NAMES[ch_id], "stream_url": stream_url, "status": "ok" if stream_url else "offline"}
     return JSONResponse(result)
 
+
 @router.get("/api/vtv/stream/{channel_id}")
 def api_vtv_stream(channel_id: str):
     stream_url = fetch_vtv_stream(channel_id)
     if stream_url:
         return JSONResponse({"stream_url": stream_url, "status": "ok"})
-    return JSONResponse({"error": "stream not found", "status": "offline"}, status_code=404)
+    return JSONResponse({"error": "stream not found", "status": "offline"}, status_code=404)
+
+
+@router.get("/api/vtv/epg/{channel_id}")
+def api_vtv_epg(channel_id: str):
+    """Get TV schedule for a VTV channel"""
+    channel_id = channel_id.lower().strip()
+    if channel_id not in CHANNEL_NAMES:
+        channel_id = "vtv1"
+    data = fetch_epg(channel_id)
+    return JSONResponse(data)
+
+
+# ===== PROXY ENDPOINTS for VTV HLS streams =====
+
+@router.get("/api/proxy/m3u8/vtv")
+def proxy_m3u8_vtv(url: str = Query(...)):
+    """Proxy HLS manifest for VTV streams, rewriting segment URLs"""
+    try:
+        h = {"User-Agent": UA["User-Agent"], "Accept": "*/*", "Referer": "https://sv2.xemtivitop.com/"}
+        r = requests.get(url, headers=h, timeout=15, verify=False)
+        if r.status_code != 200:
+            return Response(status_code=502, content="upstream error")
+        
+        base_url = url[:url.rfind('/')]
+        lines = r.text.strip().split('\n')
+        rewritten = []
+        for line in lines:
+            stripped = line.strip()
+            if stripped.startswith('#') or not stripped:
+                rewritten.append(line)
+            elif stripped.startswith('http'):
+                seg_url = stripped
+                rewritten.append(f"/api/proxy/seg/vtv?url={urllib.parse.quote(seg_url, safe='')}")
+            else:
+                seg_url = f"{base_url}/{stripped}"
+                rewritten.append(f"/api/proxy/seg/vtv?url={urllib.parse.quote(seg_url, safe='')}")
+        
+        return Response(
+            content='\n'.join(rewritten).encode('utf-8'),
+            media_type="application/vnd.apple.mpegurl",
+            headers={
+                "Access-Control-Allow-Origin": "*",
+                "Cache-Control": "public, max-age=60",
+            }
+        )
+    except Exception as e:
+        return Response(status_code=502, content=f"proxy error: {e}")
+
+
+@router.get("/api/proxy/seg/vtv")
+def proxy_seg_vtv(url: str = Query(...)):
+    """Proxy TS segment for VTV streams"""
+    try:
+        h = {"User-Agent": UA["User-Agent"], "Accept": "*/*", "Referer": "https://sv2.xemtivitop.com/"}
+        r = requests.get(url, headers=h, timeout=30, verify=False)
+        if r.status_code != 200:
+            return Response(status_code=502, content="upstream error")
+        
+        data = r.content
+        if len(data) > 188 and data[0:4] == b'\x89PNG' and data[188] == 0x47:
+            data = data[188:]
+        
+        return Response(
+            content=data,
+            media_type="video/mp2t",
+            headers={
+                "Access-Control-Allow-Origin": "*",
+                "Cache-Control": "public, max-age=3600",
+            }
+        )
+    except Exception as e:
+        return Response(status_code=502, content=f"proxy error: {e}")