Update main.py

main.py

@@ -84,7 +84,7 @@ cache = TTLCache(CACHE_TTL, MAX_CACHE_ITEMS)
 queue = Queue(MAX_CONCURRENT)
 
 # ─── yt-dlp helpers ───────────────────────────────────────
-YDL_OPTS = {
+YDL_OPTS_BASE = {
     "quiet":          True,
     "no_warnings":    True,
     "skip_download":  True,
@@ -102,187 +102,215 @@ def _size(b) -> str:
         b /= 1024
     return f"{b:.1f} GB"
 
-def _formats(fmts: list, webpage_url: str = "") -> list[dict]:
+def _formats(fmts: list) -> list[dict]:
     """
-    بناء قائمة جودات نظيفة ومرتبة.
-    ندمج الفيديو والصوت يدوياً لو مفيش مدمج.
+    نجيب الفورمات المدمجة (فيديو+صوت) أولاً.
+    لو مفيش، ندمج يدوياً.
     """
-    result, seen = [], set()
+    result = []
+    seen_heights = set()
     
-    # فصل الفورمات
-    video_only = []   # فيديو بدون صوت
-    audio_only = []   # صوت فقط
-    merged = []       # فيديو + صوت مدمج
+    # ─── الخطوة 1: نفصل الفورمات ─────────────────────────
+    merged_formats = []      # فيديو+صوت مدمج (الأفضل)
+    video_only = []          # فيديو بدون صوت
+    audio_only = []          # صوت فقط
     
     for f in fmts:
         vcodec = f.get("vcodec", "none")
         acodec = f.get("acodec", "none")
+        url = f.get("url", "")
         
+        if not url:
+            continue
+            
         is_video = vcodec not in ("none", None, "")
         is_audio = acodec not in ("none", None, "")
         
         if is_video and is_audio:
-            merged.append(f)
+            # مدمج! ده اللي عايزينه
+            merged_formats.append(f)
         elif is_video:
             video_only.append(f)
         elif is_audio:
             audio_only.append(f)
     
-    # ─── أولاً: نضيف الـ merged (الأفضل) ─────────────────
-    for f in merged:
-        url    = f.get("url", "")
-        if not url:
-            continue
-            
+    # ─── الخطوة 2: نضيف المدمج (الأفضل) ──────────────────
+    # نرتبهم: أعلى جودة أولاً
+    merged_formats.sort(key=lambda x: x.get("height", 0) or 0, reverse=True)
+    
+    for f in merged_formats:
         height = f.get("height", 0) or 0
-        ext    = f.get("ext", "mp4")
-        fps    = f.get("fps", 0) or 0
-        size_b = f.get("filesize") or f.get("filesize_approx")
-        fmt_id = f.get("format_id", "")
+        ext = f.get("ext", "mp4")
         
-        key = f"{height}_{ext}_merged"
-        if key in seen:
+        # dedup بالـ height
+        if height in seen_heights:
             continue
-        seen.add(key)
+        seen_heights.add(height)
+        
+        fps = f.get("fps", 0) or 0
+        size_b = f.get("filesize") or f.get("filesize_approx")
         
         lbl = f"{height}p" if height else "Video"
         if fps > 30:
             lbl += f" {int(fps)}fps"
         
         result.append({
-            "id":          fmt_id,
-            "label":       lbl,
-            "type":        "🎬 فيديو+صوت",
-            "ext":         ext,
-            "height":      height,
-            "has_audio":   True,
-            "is_merged":   True,
-            "size":        _size(size_b),
-            "size_bytes":  size_b or 0,
-            "url":         url,
-            "audio_url":   None,  # مدمج، مفيش صوت منفصل
+            "id": f.get("format_id", ""),
+            "label": lbl,
+            "type": "🎬 فيديو+صوت",
+            "ext": ext,
+            "height": height,
+            "has_audio": True,
+            "is_merged": True,  # ← مهم: ده مدمج أصلاً
+            "is_real_merged": True,
+            "size": _size(size_b),
+            "size_bytes": size_b or 0,
+            "url": f["url"],
+            "audio_url": None,
         })
     
-    # ─── ثانياً: ندمج فيديو + صوت يدوياً ─────────────────
-    # ناخد أحسن صوت (أعلى bitrate) ندمجه مع كل فيديو
-    if audio_only and video_only:
+    # ─── الخطوة 3: لو مفيش مدمج، ندمج يدوياً ─────────────
+    if not result and video_only and audio_only:
+        # أحسن صوت
         best_audio = max(audio_only, 
-                        key=lambda x: x.get("abr", 0) or x.get("asr", 0) or 0)
-        audio_url = best_audio.get("url", "")
-        audio_ext = best_audio.get("ext", "m4a")
+                        key=lambda x: (x.get("abr", 0) or 0, x.get("asr", 0) or 0))
+        
+        # ناخد فيديوهات مختلفة الجودات
+        video_only.sort(key=lambda x: x.get("height", 0) or 0, reverse=True)
         
         for f in video_only:
-            url = f.get("url", "")
-            if not url:
-                continue
-                
             height = f.get("height", 0) or 0
-            ext    = f.get("ext", "mp4")
-            fps    = f.get("fps", 0) or 0
-            size_b = f.get("filesize") or f.get("filesize_approx") or 0
-            fmt_id = f.get("format_id", "")
+            if height in seen_heights:
+                continue
+            seen_heights.add(height)
             
-            key = f"{height}_{ext}_manual"
-            if key in seen:
+            # نتخطى الجودات العالية جداً (4K) عشان مفيش صوت ليها غالباً
+            if height > 1080 and len([x for x in result if x["height"] >= 720]) > 0:
                 continue
-            seen.add(key)
             
-            # نحسب الحجم التقريبي المدمج
-            audio_size = best_audio.get("filesize") or best_audio.get("filesize_approx") or 0
-            total_size = size_b + (audio_size * 0.8)  # تقدير: الصوت يضيف ~80% من حجمه
+            ext = f.get("ext", "mp4")
+            fps = f.get("fps", 0) or 0
+            v_size = f.get("filesize") or f.get("filesize_approx") or 0
+            a_size = best_audio.get("filesize") or best_audio.get("filesize_approx") or 0
             
             lbl = f"{height}p" if height else "Video"
             if fps > 30:
                 lbl += f" {int(fps)}fps"
             
             result.append({
-                "id":          f"{fmt_id}+{best_audio.get('format_id', '')}",
-                "label":       lbl,
-                "type":        "🎬 فيديو+صوت",
-                "ext":         ext,
-                "height":      height,
-                "has_audio":   True,
-                "is_merged":   False,  # هندمج في الواجهة
-                "size":        _size(total_size),
-                "size_bytes":  total_size,
-                "url":         url,           # رابط الفيديو
-                "audio_url":   audio_url,     # رابط الصوت
-                "audio_ext":   audio_ext,
+                "id": f"{f.get('format_id')}+{best_audio.get('format_id')}",
+                "label": lbl,
+                "type": "🎬 فيديو+صوت",
+                "ext": ext,
+                "height": height,
+                "has_audio": True,
+                "is_merged": False,  # ← هندمج يدوياً
+                "is_real_merged": False,
+                "size": _size(v_size + a_size),
+                "size_bytes": v_size + a_size,
+                "url": f["url"],
+                "audio_url": best_audio["url"],
+                "audio_ext": best_audio.get("ext", "m4a"),
             })
     
-    # ─── ثالثاً: نضيف الصوت المنفصل ──────────────────────
+    # ─── الخطوة 4: نضيف الصوت المنفصل ────────────────────
+    audio_only.sort(key=lambda x: x.get("abr", 0) or 0, reverse=True)
+    best_audio_added = False
+    
     for f in audio_only:
         url = f.get("url", "")
         if not url:
             continue
             
+        # أحسن صوت بس
+        if best_audio_added:
+            continue
+        best_audio_added = True
+        
         abr = f.get("abr", 0) or 0
         ext = f.get("ext", "m4a")
         size_b = f.get("filesize") or f.get("filesize_approx")
-        fmt_id = f.get("format_id", "")
-        
-        lbl = f"{int(abr)}kbps" if abr else "Audio"
         
         result.append({
-            "id":          fmt_id,
-            "label":       lbl,
-            "type":        "🎵 صوت فقط",
-            "ext":         ext,
-            "height":      0,
-            "has_audio":   True,
-            "is_audio":    True,
-            "size":        _size(size_b),
-            "size_bytes":  size_b or 0,
-            "url":         url,
-            "audio_url":   None,
+            "id": f.get("format_id", ""),
+            "label": f"{int(abr)}kbps" if abr else "Audio",
+            "type": "🎵 صوت فقط",
+            "ext": ext,
+            "height": 0,
+            "has_audio": True,
+            "is_audio": True,
+            "is_merged": False,
+            "size": _size(size_b),
+            "size_bytes": size_b or 0,
+            "url": url,
+            "audio_url": None,
         })
     
-    # ترتيب: مدمج أولاً ← أعلى جودة
-    result.sort(key=lambda x: (
-        not x.get("is_merged", False),  # المدمج الحقيقي أولاً
-        not x.get("has_audio", False),   # اللي معاه صوت
-        -x["height"],                    # أعلى جودة
-        x.get("is_audio", False)         # الصوت فقط آخر
-    ))
-    
     return result
 
 def _extract_info(url: str) -> dict:
-    """تشغيل yt-dlp (blocking — يُشغَّل في thread executor)"""
+    """تشغيل yt-dlp"""
     
-    opts = YDL_OPTS.copy()
+    opts = YDL_OPTS_BASE.copy()
     
-    # للـ Facebook/Instagram: نجيب كل الفورمات عشان ندمج يدوياً
-    if any(x in url.lower() for x in ["facebook", "instagram", "fb.watch"]):
-        opts["format"] = "all"  # نجيب كل حاجة
+    # ─── مهم: نجيب الفورمات المدمجة أولاً ─────────────────
+    # نجرب format specs مختلفة حسب المنصة
+    
+    if "youtube" in url.lower() or "youtu.be" in url.lower():
+        # YouTube: نفضل المدمج
+        opts["format"] = "bestvideo[height<=1080][ext=mp4]+bestaudio[ext=m4a]/best[height<=1080][ext=mp4]/best"
+    elif "facebook" in url.lower() or "fb.watch" in url.lower():
+        # Facebook: نجيب كل حاجة
+        opts["format"] = "best"
+    elif "instagram" in url.lower():
+        opts["format"] = "best"
+    else:
+        opts["format"] = "best"
     
     with yt_dlp.YoutubeDL(opts) as ydl:
         info = ydl.extract_info(url, download=False)
         if not info:
             raise ValueError("لم يُعثر على معلومات")
-
-        # صورة مصغرة أفضل جودة
+        
+        # ─── مهم: نجيب الـ format المختار من yt-dlp ────────
+        # ده بيكون أحسن فيديو+صوت مدمج
+        requested_formats = info.get("requested_formats", [])
+        format_id = info.get("format_id", "")
+        
+        # لو requested_formats موجود، نضيفهم للـ formats
+        all_formats = info.get("formats", [])
+        
+        # نضيف علامة على الـ format المختار
+        for f in all_formats:
+            if f.get("format_id") == format_id:
+                f["_selected"] = True
+            # لو هو جزء من requested_formats
+            if any(rf.get("format_id") == f.get("format_id") for rf in requested_formats):
+                f["_requested"] = True
+        
+        # صورة مصغرة
         thumbs = info.get("thumbnails") or []
-        thumb  = (
+        thumb = (
             sorted(thumbs, key=lambda t: t.get("width", 0), reverse=True)[0]["url"]
             if thumbs else info.get("thumbnail", "")
         )
-
-        fmts = _formats(info.get("formats", []), info.get("webpage_url", url))
+        
+        fmts = _formats(all_formats)
+        
         if not fmts:
             raise ValueError("لا توجد صيغ قابلة للتحميل")
-
+        
         return {
-            "id":           info.get("id",""),
-            "title":        info.get("title","فيديو"),
-            "thumbnail":    thumb,
-            "duration":     info.get("duration"),
-            "duration_str": info.get("duration_string",""),
-            "uploader":     info.get("uploader","") or info.get("channel",""),
-            "platform":     info.get("extractor_key",""),
-            "webpage_url":  info.get("webpage_url", url),
-            "view_count":   info.get("view_count"),
-            "formats":      fmts,
+            "id": info.get("id", ""),
+            "title": info.get("title", "فيديو"),
+            "thumbnail": thumb,
+            "duration": info.get("duration"),
+            "duration_str": info.get("duration_string", ""),
+            "uploader": info.get("uploader", "") or info.get("channel", ""),
+            "platform": info.get("extractor_key", ""),
+            "webpage_url": info.get("webpage_url", url),
+            "view_count": info.get("view_count"),
+            "formats": fmts,
         }
 
 # ─── FastAPI ──────────────────────────────────────────────
@@ -314,31 +342,28 @@ class ExtractReq(BaseModel):
 @app.get("/health")
 async def health():
     return {
-        "status":  "online",
+        "status": "online",
         "version": "1.0.0",
-        "queue":   queue.active,
-        "max":     MAX_CONCURRENT,
-        "cache":   await cache.stats(),
+        "queue": queue.active,
+        "max": MAX_CONCURRENT,
+        "cache": await cache.stats(),
     }
 
 @app.post("/extract")
 @app.post("/extract/")
 async def extract(req: ExtractReq):
     url = req.url.strip()
-    if not url.startswith(("http://","https://")):
+    if not url.startswith(("http://", "https://")):
         raise HTTPException(400, "رابط غير صالح")
 
-    # تأخير بسيط للـ Instagram/Facebook عشان Rate Limit
     if any(x in url.lower() for x in ["instagram", "facebook", "fb.watch"]):
         await asyncio.sleep(0.5)
 
-    # كاش
-    key    = hashlib.sha256(url.encode()).hexdigest()
+    key = hashlib.sha256(url.encode()).hexdigest()
     cached = await cache.get(key)
     if cached:
         return {"success": True, "cached": True, "data": cached}
 
-    # استخراج
     async with queue.slot():
         log.info(f"🔍 [{queue.active}/{MAX_CONCURRENT}] {url[:80]}")
         loop = asyncio.get_event_loop()
@@ -351,17 +376,17 @@ async def extract(req: ExtractReq):
             raise HTTPException(408, "انتهى وقت الاستخراج — جرّب مرة أخرى")
         except yt_dlp.utils.DownloadError as e:
             msg = str(e)
-            if "Private video"  in msg: 
+            if "Private video" in msg:
                 raise HTTPException(403, "الفيديو خاص")
-            if "not available"  in msg and "rate-limit" in msg.lower(): 
+            if "not available" in msg and "rate-limit" in msg.lower():
                 raise HTTPException(429, "تم تجاوز الحد المسموح — جرّب بعد شوية")
-            if "not available"  in msg: 
+            if "not available" in msg:
                 raise HTTPException(404, "الفيديو غير متاح في منطقتك")
-            if "login required" in msg.lower(): 
+            if "login required" in msg.lower():
                 raise HTTPException(401, "يتطلب تسجيل دخول")
-            if "copyright"      in msg.lower(): 
+            if "copyright" in msg.lower():
                 raise HTTPException(451, "محجوب بسبب حقوق النشر")
-            if "Unable to extract" in msg: 
+            if "Unable to extract" in msg:
                 raise HTTPException(422, "المنصة حظرت الاستخراج — جرّب رابط تاني")
             raise HTTPException(422, f"لا يمكن استخراج الرابط: {msg[:150]}")
         except ValueError as e: