fix: regex for multi-part probe - use greedy (.+) to match last 2 digits before .m3u8

shorts_carousel.py

@@ -61,51 +61,57 @@ def scrape_24h_news_shorts():
 
 
 def _extract_24h_video_url(article_url):
-    """Extract m3u8 video URL(s) from a 24h article. 
-    Tries multiple methods to find ALL video parts."""
+    """Extract m3u8 video URL(s) from a 24h article.
+    Returns dict with 'src', 'poster', 'vtype', and optionally 'all_parts' list."""
     try:
         r = requests.get(article_url, headers=HEADERS, timeout=10)
         r.encoding = "utf-8"
         html = r.text
+
+        # Find all m3u8 URLs in HTML (including escaped ones like \/)
+        raw_m3u8 = re.findall(r'(https?://cdn\.24h\.com\.vn/[^\s"\'\\<>]+\.m3u8)', html)
+        escaped_m3u8 = re.findall(r'(https?:\\/\\/cdn\.24h\.com\.vn\\/[^\s"\'<>]+\.m3u8)', html)
+        escaped_m3u8 = [u.replace('\\/', '/') for u in escaped_m3u8]
         
-        # Method 1: Find all m3u8 URLs directly in HTML
-        all_m3u8 = re.findall(r'(https?://cdn\.24h\.com\.vn/[^\s"\'\\<>]+\.m3u8)', html)
-        full_quality = list(dict.fromkeys(u for u in all_m3u8 if '_720p' not in u))
-        
+        all_m3u8 = list(dict.fromkeys(raw_m3u8 + escaped_m3u8))
+        full_quality = [u for u in all_m3u8 if '_720p' not in u]
+
         if not full_quality:
             return None
-        
+
         # Get poster
         soup = BeautifulSoup(html, "lxml")
         og = soup.find("meta", property="og:image")
         poster = og.get("content", "") if og else ""
-        
-        # Method 2: Check how many playlist items the page has
-        playlist_count = len(set(re.findall(r'track_slow_playlist_next_(\d+)', html)))
-        
-        # Method 3: Try to find playlist JSON in page
-        # Look for patterns like: sources: [{file:'...'}] or playlist:[{sources:[{file:'...'}]}]
-        playlist_urls = []
-        
-        # Search for all CDN video URLs (including escaped ones)
-        escaped_m3u8 = re.findall(r'(https?:\\/\\/cdn\.24h\.com\.vn\\/[^\s"\'\\<>]+\.m3u8)', html)
-        escaped_m3u8 = [u.replace('\\/','/' ) for u in escaped_m3u8]
-        all_found = list(dict.fromkeys(u for u in (full_quality + escaped_m3u8) if '_720p' not in u))
-        
-        if len(all_found) > 1:
-            # Multiple m3u8 URLs found directly - these ARE the parts
-            return {"src": all_found[0], "poster": poster, "vtype": "hls", "all_parts": all_found}
-        
-        # Method 4: Probe numbered variants
+
+        # If multiple full-quality URLs found directly → those are the parts
+        if len(full_quality) > 1:
+            return {"src": full_quality[0], "poster": poster, "vtype": "hls", "all_parts": full_quality}
+
+        # Probe for numbered parts using GREEDY regex
+        # Example: ...psg_bayern01.m3u8 → base="...psg_bayern", num="01"
+        # Use GREEDY (.+) so it matches the LONGEST prefix, leaving only last digits
         base_url = full_quality[0]
         parts_found = [base_url]
+
+        # Pattern: ends with 2 digits before .m3u8 (like "01.m3u8", "02.m3u8")
+        match_2digit = re.match(r'^(.+?)(\d{2})(\.m3u8)$', base_url)
+        if not match_2digit:
+            # Try 1 digit at end
+            match_2digit = re.match(r'^(.+?)(\d)(\.m3u8)$', base_url)
         
-        # Try pattern: {name}01.m3u8 → {name}02.m3u8
-        base_match = re.match(r'(.+?)(\d{1,2})(\.m3u8)$', base_url)
-        if base_match:
-            base, num, ext = base_match.group(1), int(base_match.group(2)), base_match.group(3)
-            for i in range(num + 1, num + 5):
-                probe_url = f"{base}{i:02d}{ext}" if num >= 10 else f"{base}{i}{ext}"
+        if match_2digit:
+            base = match_2digit.group(1)
+            start_num = int(match_2digit.group(2))
+            ext = match_2digit.group(3)
+            num_width = len(match_2digit.group(2))  # 1 or 2 digits
+            
+            # Probe next numbers
+            for i in range(start_num + 1, start_num + 6):
+                if num_width == 2:
+                    probe_url = f"{base}{i:02d}{ext}"
+                else:
+                    probe_url = f"{base}{i}{ext}"
                 try:
                     pr = requests.head(probe_url, headers=HEADERS, timeout=3, allow_redirects=True)
                     if pr.status_code == 200:
@@ -114,77 +120,11 @@ def _extract_24h_video_url(article_url):
                         break
                 except:
                     break
-        
-        # Method 5: Try common naming patterns for hiep/part
-        if len(parts_found) == 1 and playlist_count > 0:
-            # The page DOES have a playlist but we can't find URLs
-            # Try variations of the filename
-            filename = base_url.rsplit('/', 1)[-1]  # e.g. "cp_special_bundesliga-1777224470-dortmund_freiburg01.m3u8"
-            dir_url = base_url.rsplit('/', 1)[0] + '/'
-            
-            # Try: remove trailing digits and probe 1,2,3...
-            name_no_num = re.sub(r'\d+\.m3u8$', '', filename)
-            if name_no_num != filename.replace('.m3u8',''):
-                for i in range(1, 5):
-                    probe = dir_url + name_no_num + str(i) + '.m3u8'
-                    if probe not in parts_found:
-                        try:
-                            pr = requests.head(probe, headers=HEADERS, timeout=3, allow_redirects=True)
-                            if pr.status_code == 200:
-                                parts_found.append(probe)
-                        except:
-                            pass
-            
-            # Try: append _part2, _hiep2 etc
-            base_name = base_url.replace('.m3u8','')
-            for suffix in ['_2.m3u8', '_part2.m3u8', '_hiep2.m3u8', 'b.m3u8']:
-                probe = base_name + suffix
-                try:
-                    pr = requests.head(probe, headers=HEADERS, timeout=3, allow_redirects=True)
-                    if pr.status_code == 200:
-                        parts_found.append(probe)
-                except:
-                    pass
-
-        # Method 6: Try AJAX endpoint for playlist
-        article_id_match = re.search(r'a(\d+)\.html', article_url)
-        if article_id_match and len(parts_found) == 1 and playlist_count > 0:
-            article_id = article_id_match.group(1)
-            ajax_urls = [
-                f"https://24h.24hstatic.com/ajax/video/get_playlist?id={article_id}",
-                f"{BASE_24H}/ajax/video/playlist/{article_id}",
-            ]
-            for ajax_url in ajax_urls:
-                try:
-                    ar = requests.get(ajax_url, headers={**HEADERS, "X-Requested-With": "XMLHttpRequest"}, timeout=5)
-                    if ar.status_code == 200 and ar.text.strip():
-                        # Try parse as JSON
-                        try:
-                            data = ar.json()
-                            if isinstance(data, list):
-                                for item in data:
-                                    if isinstance(item, dict):
-                                        src = item.get("file") or item.get("src") or item.get("source") or ""
-                                        if src and 'm3u8' in src and src not in parts_found:
-                                            parts_found.append(src)
-                                    elif isinstance(item, str) and 'm3u8' in item:
-                                        if item not in parts_found:
-                                            parts_found.append(item)
-                        except:
-                            # Try extract m3u8 from text
-                            ajax_m3u8 = re.findall(r'(https?://[^\s"\'\\<>]+\.m3u8)', ar.text)
-                            for u in ajax_m3u8:
-                                if '_720p' not in u and u not in parts_found:
-                                    parts_found.append(u)
-                        if len(parts_found) > 1:
-                            break
-                except:
-                    pass
 
         if len(parts_found) > 1:
             return {"src": parts_found[0], "poster": poster, "vtype": "hls", "all_parts": parts_found}
-        else:
-            return {"src": parts_found[0], "poster": poster, "vtype": "hls"}
+        
+        return {"src": full_quality[0], "poster": poster, "vtype": "hls"}
     except:
         return None