Upload vtv_api.py

vtv_api.py

@@ -1,11 +1,9 @@
 """
-VTV Channels API v2 — Multi-source with auto-failover
-Sources per channel (priority order):
-  1. xemtv.net scraping (fresh, changes dynamically)
-  2. VTVGo failover CDN (vtvgolive-failover.vtvdigital.vn)
-  3. fptplay CDN (live247 / fnxch2 / epzhd1)
-  4. fptplay ABR (.smil/chunklist)
-Every source is verified with HTTP HEAD before returning.
+VTV Channels API v3 — Fast, multi-source, parallel scraping
+Strategy:
+  - Return cached/static sources immediately (< 500ms)
+  - Scrape xemtv.net in background thread for next request
+  - Frontend has full source list for client-side failover
 """
 import re, time, threading
 import requests
@@ -26,9 +24,8 @@ CHANNEL_NAMES = {
     "vtv9": "VTV9", "vtv10": "VTV10", "vtvprime": "VTVPrime",
 }
 
-# ===== SOURCE LISTS — multiple backups per channel =====
-# Each channel has a list of URLs to try in order
-CHANNEL_SOURCES = {
+# ===== STATIC SOURCE LISTS =====
+STATIC_SOURCES = {
     "vtv1": [
         "https://live-a.fptplay53.net/live/media/vtv1/live247-hls-avc/index.m3u8",
         "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv1-manifest.m3u8",
@@ -45,10 +42,11 @@ CHANNEL_SOURCES = {
         "https://live.fptplay53.net/fnxch2/vtv3hd_abr.smil/chunklist.m3u8",
     ],
     "vtv4": [
+        "https://live-a.fptplay53.net/live/media/vtv4/live247-hls-avc/index.m3u8",
         "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv4-manifest.m3u8",
-        "https://live.fptplay53.net/fnxch2/vtv4hd_abr.smil/chunklist.m3u8",
     ],
     "vtv5": [
+        "https://live-a.fptplay53.net/live/media/vtv5/live247-hls-avc/index.m3u8",
         "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv5-manifest.m3u8",
         "https://live-a.fptplay53.net/live/media/VTV5HD/live_hls_avc/index.m3u8",
     ],
@@ -57,16 +55,17 @@ CHANNEL_SOURCES = {
         "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",
         "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv7-manifest.m3u8",
         "https://live.fptplay53.net/fnxhd1/vtv7hd_vhls.smil/chunklist_b5000000.m3u8",
     ],
     "vtv8": [
-        "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv8-manifest.m3u8",
         "https://live.fptplay53.net/epzhd1/vtv8hd_vhls.smil/chunklist.m3u8",
+        "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv8-manifest.m3u8",
     ],
     "vtv9": [
-        "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv9-manifest.m3u8",
         "https://live.fptplay53.net/fnxhd1/vtv9hd_vhls.smil/chunklist.m3u8",
+        "https://vtvgolive-failover.vtvdigital.vn/vtvgo/vtv9-manifest.m3u8",
     ],
     "vtv10": [
         "https://live-a.fptplay53.net/live/media/vtv10/live247-hls-avc/vtv10-avc1_5600000=10000-mp4a_131600=20000.m3u8",
@@ -77,7 +76,6 @@ CHANNEL_SOURCES = {
     ],
 }
 
-# xemtv.net PHP endpoints for dynamic scraping
 XEMTV_PHP = {
     "vtv1": "https://hd.xemtv.net/kenh/vtv1.php",
     "vtv2": "https://hd.xemtv.net/kenh/vtv2.php",
@@ -92,56 +90,33 @@ XEMTV_PHP = {
     "vtvprime": "https://hd.xemtv.net/kenh/vtvprime.php",
 }
 
-_vtv_cache = {}
+_vtv_xemtv_cache = {}
 _vtv_lock = threading.Lock()
-_CACHE_TTL = 120  # 2 min cache
+_XEMTV_CACHE_TTL = 300
 
 
-def _cached(key):
+def _get_cached_xemtv(ch_id):
     with _vtv_lock:
-        if key in _vtv_cache and time.time() - _vtv_cache[key]['t'] < _CACHE_TTL:
-            return _vtv_cache[key]['d']
+        entry = _vtv_xemtv_cache.get(ch_id)
+        if entry and time.time() - entry['t'] < _XEMTV_CACHE_TTL:
+            return entry['url']
     return None
 
 
-def _set_cache(key, data):
+def _set_cached_xemtv(ch_id, url):
     with _vtv_lock:
-        _vtv_cache[key] = {'t': time.time(), 'd': data}
-
-
-def _verify_url(url, timeout=5):
-    """Verify a stream URL is reachable."""
-    try:
-        headers = {"User-Agent": UA["User-Agent"]}
-        if "fptplay" in url:
-            headers["Referer"] = "https://fptplay.vn/"
-            headers["Origin"] = "https://fptplay.vn"
-        # Try GET with range first (more reliable than HEAD for CDNs)
-        headers["Range"] = "bytes=0-0"
-        r = requests.get(url, headers=headers, timeout=timeout, allow_redirects=True)
-        return r.status_code in (200, 206)
-    except:
-        return False
+        _vtv_xemtv_cache[ch_id] = {'t': time.time(), 'url': url}
 
 
 def extract_m3u8_from_html(html):
-    """Extract m3u8/smil URL from xemtv PHP page."""
     if not html:
         return None
-    # jwplayer file: 'URL'
     m = re.search(r"file\s*:\s*['\"]([^'\"]+\.(?:m3u8|smil)[^'\"]*)['\"]", html, re.IGNORECASE)
     if m:
         url = m.group(1).strip()
         if len(url) > 20:
             return url
-    # Generic m3u8 URL
-    m = re.search(r"(https?://[^\s\"'<>\\]+\.m3u8[^\s\"'<>\\]*)", html, re.IGNORECASE)
-    if m:
-        url = m.group(1).strip()
-        if len(url) > 20:
-            return url
-    # Generic smil URL
-    m = re.search(r"(https?://[^\s\"'<>\\]+\.smil[^\s\"'<>\\]*)", html, re.IGNORECASE)
+    m = re.search(r"(https?://[^\s\"'<>\\]+\.(?:m3u8|smil)[^\s\"'<>\\]*)", html, re.IGNORECASE)
     if m:
         url = m.group(1).strip()
         if len(url) > 20:
@@ -149,90 +124,73 @@ def extract_m3u8_from_html(html):
     return None
 
 
-def fetch_xemtv_stream(channel_id):
-    """Scrape xemtv.net PHP page for fresh stream URL."""
-    php_url = XEMTV_PHP.get(channel_id)
+def scrape_xemtv_one(ch_id):
+    php_url = XEMTV_PHP.get(ch_id)
     if not php_url:
         return None
     try:
-        r = requests.get(php_url, headers=UA, timeout=10, allow_redirects=True)
+        r = requests.get(php_url, headers=UA, timeout=8, allow_redirects=True)
         if r.status_code == 200:
             url = extract_m3u8_from_html(r.text)
-            if url and _verify_url(url):
+            if url:
+                _set_cached_xemtv(ch_id, url)
                 return url
     except:
         pass
     return None
 
 
-def fetch_vtv_stream(channel_id):
-    """
-    Fetch m3u8 stream URL with multi-source failover.
-    Returns (url, num_sources_tried) or (None, 0).
-    """
-    channel_id = channel_id.lower().strip()
-    name_map = {
-        'vtvct': 'vtv10', 'vtv-can-tho': 'vtv10', 'vtv can tho': 'vtv10',
-        'vtv_can_tho': 'vtv10', 'cantho': 'vtv10',
-    }
-    channel_id = name_map.get(channel_id, channel_id)
-
-    cached = _cached(channel_id)
-    if cached is not None:
-        return cached
-
-    sources_tried = []
-
-    # 1. Try xemtv.net scraping first (fresh, dynamic)
-    xemtv_url = fetch_xemtv_stream(channel_id)
+def scrape_xemtv_all_parallel():
+    from concurrent.futures import ThreadPoolExecutor, as_completed
+    with ThreadPoolExecutor(max_workers=6) as ex:
+        futs = {ex.submit(scrape_xemtv_one, ch): ch for ch in XEMTV_PHP}
+        for f in as_completed(futs, timeout=15):
+            try:
+                f.result()
+            except:
+                pass
+
+
+def get_stream_url(ch_id):
+    ch_id = ch_id.lower().strip()
+    name_map = {'vtvct': 'vtv10', 'vtv-can-tho': 'vtv10', 'cantho': 'vtv10'}
+    ch_id = name_map.get(ch_id, ch_id)
+    all_sources = STATIC_SOURCES.get(ch_id, [])
+    if not all_sources:
+        return None, "none", []
+    xemtv_url = _get_cached_xemtv(ch_id)
     if xemtv_url:
-        result = {"url": xemtv_url, "source": "xemtv", "all_sources": [xemtv_url]}
-        _set_cache(channel_id, result)
-        return result
-
-    # 2. Try all static sources in order
-    static_sources = CHANNEL_SOURCES.get(channel_id, [])
-    for url in static_sources:
-        sources_tried.append(url)
-        if _verify_url(url):
-            result = {"url": url, "source": "static", "all_sources": static_sources}
-            _set_cache(channel_id, result)
-            return result
-
-    # 3. VTVPrime special: no free sources
-    result = {"url": None, "source": "none", "all_sources": []}
-    _set_cache(channel_id, result)
-    return result
+        sources = [xemtv_url] + [s for s in all_sources if s != xemtv_url]
+        return xemtv_url, "xemtv", sources
+    return all_sources[0], "static", all_sources
 
 
 @router.get("/api/vtv/streams")
 def api_vtv_streams():
-    """Get all VTV channel stream URLs with multi-source info."""
     result = {}
     for ch_id in CHANNEL_NAMES:
-        stream = fetch_vtv_stream(ch_id)
+        url, source, all_sources = get_stream_url(ch_id)
         result[ch_id] = {
             "name": CHANNEL_NAMES[ch_id],
-            "stream_url": stream.get("url") if stream else None,
-            "source": stream.get("source", "none") if stream else "none",
-            "all_sources": stream.get("all_sources", []) if stream else [],
-            "status": "ok" if stream and stream.get("url") else "offline",
+            "stream_url": url,
+            "source": source,
+            "all_sources": all_sources,
+            "status": "ok" if url else "offline",
         }
+    threading.Thread(target=scrape_xemtv_all_parallel, daemon=True).start()
     return JSONResponse(result)
 
 
 @router.get("/api/vtv/stream/{channel_id}")
 def api_vtv_stream(channel_id: str):
-    """Get stream URL for a specific VTV channel."""
-    stream = fetch_vtv_stream(channel_id)
-    if stream and stream.get("url"):
-        return JSONResponse({"stream_url": stream["url"], "source": stream["source"], "status": "ok"})
+    url, source, all_sources = get_stream_url(channel_id)
+    if url:
+        return JSONResponse({"stream_url": url, "source": source, "all_sources": all_sources, "status": "ok"})
     return JSONResponse({"error": "stream not found", "status": "offline"}, status_code=404)
 
 
 @router.get("/api/proxy/m3u8/vtv")
 def proxy_vtv_m3u8(url: str = Query(...)):
-    """Proxy an m3u8 stream URL with proper headers."""
     try:
         headers = {"User-Agent": UA["User-Agent"], "Accept": "*/*"}
         if "fptplay" in url:
@@ -242,16 +200,13 @@ def proxy_vtv_m3u8(url: str = Query(...)):
             headers["Referer"] = "https://vtvgo.vn/"
         elif "xemtv" in url:
             headers["Referer"] = "https://hd.xemtv.net/"
-
         r = requests.get(url, headers=headers, timeout=15, allow_redirects=True)
         if r.status_code != 200:
             return Response(status_code=502, content=f"upstream error: {r.status_code}")
-
         content = r.text
         lines = content.split('\n')
         rewritten = []
         base_url = url.rsplit('/', 1)[0] + '/'
-
         for line in lines:
             line = line.strip()
             if not line or line.startswith('#'):
@@ -261,19 +216,13 @@ def proxy_vtv_m3u8(url: str = Query(...)):
                 if not seg_url.startswith('http'):
                     seg_url = base_url + seg_url
                 rewritten.append("/api/proxy/seg/vtv?url=" + requests.utils.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": "no-cache"}
-        )
+        return Response(content='\n'.join(rewritten).encode('utf-8'), media_type="application/vnd.apple.mpegurl", headers={"Access-Control-Allow-Origin": "*", "Cache-Control": "no-cache"})
     except Exception as e:
         return Response(status_code=502, content="proxy error: " + str(e))
 
 
 @router.get("/api/proxy/seg/vtv")
 def proxy_vtv_segment(url: str = Query(...)):
-    """Proxy a video segment with proper headers."""
     try:
         headers = {"User-Agent": UA["User-Agent"], "Accept": "*/*"}
         if "fptplay" in url:
@@ -281,22 +230,12 @@ def proxy_vtv_segment(url: str = Query(...)):
             headers["Origin"] = "https://fptplay.vn"
         elif "vtvgolive" in url or "vtvdigital" in url:
             headers["Referer"] = "https://vtvgo.vn/"
-
         r = requests.get(url, headers=headers, timeout=30, allow_redirects=True, stream=True)
         if r.status_code != 200:
             return Response(status_code=502, content=f"upstream error: {r.status_code}")
-
         data = r.content
-        # Strip PNG header if present (some CDNs prepend it)
         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"}
-        )
+        return Response(content=data, media_type="video/mp2t", headers={"Access-Control-Allow-Origin": "*", "Cache-Control": "public, max-age=3600"})
     except:
         return Response(status_code=502, content="proxy error")
-
-# Updated: 1781062125