Update pipeline.py

pipeline.py

@@ -601,15 +601,24 @@ async def _upload_one(app, entry, thumb, movie_name, upload_lock, status_prefix=
             )
 
     tg_send_status(f"{status_prefix}⏫ {label}: Uploading...")
+    sent = None
     async with upload_lock:
-        try:
-            sent=await app.send_video(
-                chat_id=CHAT_ID, video=file_path, file_name=fname,
-                caption=caption, duration=dur, width=w, height=h,
-                thumb=thumb_ok, supports_streaming=True, progress=_prog
-            )
-        except Exception as e:
-            tg_log_error(f"Upload failed ({label}): {e}"); return None
+        for attempt in range(1, 4):
+            try:
+                if attempt > 1:
+                    tg_send_status(f"{status_prefix}⏫ {label}: Retry {attempt}/3...")
+                    await asyncio.sleep(10 * attempt)
+                    us[0] = time.time()  # reset speed timer on retry
+                sent = await app.send_video(
+                    chat_id=CHAT_ID, video=file_path, file_name=fname,
+                    caption=caption, duration=dur, width=w, height=h,
+                    thumb=thumb_ok, supports_streaming=True, progress=_prog
+                )
+                break  # success
+            except Exception as e:
+                tg_log_error(f"Upload failed ({label}) attempt {attempt}/3: {e}")
+                if attempt == 3:
+                    return None
 
     tg_link  = generate_telegram_link(CHAT_ID, sent.id)
     dl_link  = generate_direct_link(tg_link)
@@ -659,12 +668,10 @@ def post_mega_link_payload(movie, abyss_link, abyss_iframe, collected):
     website    = movie.get("website","")
     author     = movie.get("author","")
 
-    with_sub    = {}
-    without_sub = {}
+    with_sub = {}
     for e in collected:
         q = str(e["quality"])
-        if e["is_burned"]: with_sub[q]    = e
-        else:              without_sub[q] = e
+        if e["is_burned"]: with_sub[q] = e
 
     def _q(entry, with_iframe=False):
         if not entry: return {}
@@ -688,11 +695,6 @@ def post_mega_link_payload(movie, abyss_link, abyss_iframe, collected):
                 "720p":  _q(with_sub.get("720")),
                 "480p":  _q(with_sub.get("480")),
             },
-            "without_sinhala_subtitle": {
-                "1080p": _q(without_sub.get("1080")),
-                "720p":  _q(without_sub.get("720")),
-                "480p":  _q(without_sub.get("480")),
-            },
         },
     }
 
@@ -711,9 +713,9 @@ def post_mega_link_payload(movie, abyss_link, abyss_iframe, collected):
         tg_log_error(f"Movie DB POST failed: {e}")
 
     # Send the final formatted links as a NEW message
-    _send_links_message(movie, abyss_iframe, with_sub, without_sub)
+    _send_links_message(movie, abyss_iframe, with_sub)
 
-def _send_links_message(movie, abyss_iframe, with_sub, without_sub):
+def _send_links_message(movie, abyss_iframe, with_sub):
     """Single new Telegram message with all final links — sent once at the very end."""
     name   = movie["name"]
     year   = movie.get("year","")
@@ -746,15 +748,6 @@ def _send_links_message(movie, abyss_iframe, with_sub, without_sub):
             if e.get("bot_link"):    lines.append(f"    🤖 {e['bot_link']}")
             lines.append(f"    📦 {fmt_size(e['file_size'])}")
 
-    lines += ["","<b>Without Sinhala Subtitle</b>"]
-    for qk, ql in [("1080","1080p"),("720","720p"),("480","480p")]:
-        if qk in without_sub:
-            e=without_sub[qk]
-            lines.append(f"  <b>{ql}</b>")
-            if e.get("direct_link"): lines.append(f"    📥 {e['direct_link']}")
-            if e.get("bot_link"):    lines.append(f"    🤖 {e['bot_link']}")
-            lines.append(f"    📦 {fmt_size(e['file_size'])}")
-
     tg_send_new("\n".join(lines))
 
 def _trigger_uploaded_kv(imdb, movie_name, payload):
@@ -827,80 +820,7 @@ def run_burn_1080(movie, input_video, src_w, src_h, file_type):
     # burned_path stays on disk for GH artifact upload
 
 
-# ─── Variant: plain_all ───────────────────────────────────────────────────────
-
-def run_plain_all(movie, input_video, src_w, src_h, file_type, all_qualities, thumb=None):
-    name   = movie["name"]; year=movie.get("year","")
-    ft     = file_type
-    prefix = f"🎬 <b>{name} {year}</b>\nEncode: <b>{ft} x264</b> | 1080p/720p/480p\n\n"
-
-    # Include ALL qualities (1080p included) — upload order: 1080 → 720 → 480
-    plain_qualities = sorted([q for q in all_qualities if q in (1080, 720, 480)], reverse=True)
-    tg_send_status(f"{prefix}📄 plain_all — encoding {plain_qualities}")
-
-    total_secs  = get_duration(input_video)
-    src_bitrate = get_video_bitrate(input_video)
-    src_is_x265 = is_x265(input_video)
-    ref_pixels  = src_w*src_h
-    q_icons     = {2160:"🔴",1080:"🔵",720:"🟢",480:"🟡"}
-
-    import nest_asyncio; nest_asyncio.apply()
-
-    async def _upload_one_plain(entry):
-        from pyrogram import Client
-        lock=asyncio.Lock()
-        async with Client("user_session",api_id=API_ID,api_hash=API_HASH,
-                          session_string=SESSION_CODE) as app:
-            return await _upload_one(app, entry, thumb, name, lock, prefix)
-
-    # ── Phase 1: Encode ALL qualities first ──────────────────────────────────
-    encoded_entries = []
-    for q in plain_qualities:
-        w, h = get_res(q, src_w, src_h)
-        plain_path = os.path.join(WORK_DIR, make_filename(name, q, ft, burned=False))
-
-        # Only stream-copy if SAME resolution AND already x264 (no transcode needed)
-        is_same = (w == src_w and h == src_h)
-        if is_same and not src_is_x265:
-            cmd = ["ffmpeg", "-y", "-i", input_video, "-c", "copy",
-                   "-progress", "pipe:1", "-nostats", plain_path]
-        else:
-            if src_bitrate:
-                tbv = max(int(src_bitrate * (w * h) / ref_pixels), 400_000)
-                ea  = ["-c:v", "libx264", "-pix_fmt", "yuv420p",
-                       "-b:v", str(tbv), "-maxrate", str(int(tbv * 1.1)),
-                       "-bufsize", str(int(tbv * 2))]
-            else:
-                ea = ["-c:v", "libx264", "-pix_fmt", "yuv420p", "-crf", str(get_crf(q))]
-            # Use explicit w:h so ffmpeg never defaults to 16:9
-            cmd = (["ffmpeg", "-y", "-i", input_video, "-vf", f"scale={w}:{h}"]
-                   + ea + ["-c:a", "copy", "-progress", "pipe:1", "-nostats", plain_path])
-
-        ok = run_ffmpeg(cmd, total_secs, f"Plain {q}p ({w}x{h})", prefix)
-        if not ok:
-            tg_send_status(f"{prefix}⚠️ Plain {q}p failed — skipping"); continue
-
-        entry = {"file_path": plain_path, "quality": q, "is_burned": False,
-                 "abyss_link": "", "icon": q_icons.get(q, "⚪"), "label": f"{q}p | Plain"}
-        encoded_entries.append(entry)
-
-    # ── Phase 2: Upload ONE AT A TIME in order 1080 → 720 → 480 ─────────────
-    collected=[]
-    for entry in encoded_entries:  # already sorted highest→lowest from plain_qualities
-        result=asyncio.run(_upload_one_plain(entry))
-        if result: collected.append(result)
-        try: os.remove(entry["file_path"])
-        except: pass
-
-    plain_links_path = os.path.join(WORK_DIR, "plain_links.json")
-    try:
-        with open(plain_links_path, "w", encoding="utf-8") as _f:
-            json.dump(collected, _f)
-    except Exception as _e:
-        tg_log_error(f"Failed to save plain_links.json: {_e}")
-
-    tg_send_status(f"{prefix}✅ plain_all complete — {len(collected)} files uploaded")
-    return collected
+# plain_all removed — only burned (Sinhala subtitle) versions are produced
 
 
 # ─── Variant: downscale_upload ────────────────────────────────────────────────
@@ -968,15 +888,6 @@ def run_downscale_upload(movie, src_w, src_h, file_type, all_qualities, thumb):
     import nest_asyncio; nest_asyncio.apply()
     collected=asyncio.run(tg_upload_all(entries, thumb, name, prefix))
 
-    tg_send_status(f"{prefix}📡 Posting to movie DB...")
-    plain_links_path = os.path.join(WORK_DIR, "plain_links.json")
-    if os.path.exists(plain_links_path):
-        try:
-            with open(plain_links_path, "r", encoding="utf-8") as _f:
-                plain_data = json.load(_f)
-            collected = collected + plain_data
-        except Exception as _e:
-            tg_log_error(f"Failed to load plain_links.json: {_e}")
     post_mega_link_payload(movie, abyss_link, abyss_iframe, collected)
 
     cleanup(list(burned_files.values())+([thumb] if thumb else []))
@@ -1070,4 +981,4 @@ def main():
     run_downscale_upload(movie, src_w, src_h, file_type, all_q, thumb)
 
 if __name__=="__main__":
-    main()
+    main()