Update main.py

main.py

@@ -1131,8 +1131,10 @@ async def edit_placeholder_with_media(
     effectively replacing the placeholder with the real content at the exact same
     chat position.
 
-    Retries on FloodWait. Returns True on success, False on any other failure.
+    Falls back gracefully if edit_message_media fails for any reason.
+    Returns True if the in-place replacement succeeded, False otherwise.
     """
+    # Build the appropriate InputMedia wrapper
     type_map = {
         "photo":    InputMediaPhoto,
         "video":    InputMediaVideo,
@@ -1141,32 +1143,20 @@ async def edit_placeholder_with_media(
     }
     media_cls = type_map.get(media_type, InputMediaDocument)
 
-    for attempt in range(1, PyroConf.MAX_UPLOAD_RETRIES + 1):
-        try:
-            input_media = media_cls(media=media_path, caption=caption or "")
-            await user.edit_message_media(
-                chat_id=chat_id,
-                message_id=placeholder_msg_id,
-                media=input_media,
-            )
-            LOGGER(__name__).info(
-                f"✅ Placeholder {placeholder_msg_id} replaced with media in-place")
-            return True
-        except FloodWait as e:
-            wait_s = int(getattr(e, "value", 0) or 5)
-            LOGGER(__name__).warning(
-                f"edit_message_media FloodWait {wait_s}s (attempt {attempt}/"
-                f"{PyroConf.MAX_UPLOAD_RETRIES})")
-            if attempt < PyroConf.MAX_UPLOAD_RETRIES:
-                await asyncio.sleep(wait_s + 1)
-                continue
-            LOGGER(__name__).error("edit_message_media FloodWait retries exhausted")
-            return False
-        except Exception as e:
-            LOGGER(__name__).warning(
-                f"edit_message_media failed (attempt {attempt}): {e}")
-            return False
-    return False
+    try:
+        input_media = media_cls(media=media_path, caption=caption or "")
+        await user.edit_message_media(
+            chat_id=chat_id,
+            message_id=placeholder_msg_id,
+            media=input_media,
+        )
+        LOGGER(__name__).info(
+            f"✅ Placeholder {placeholder_msg_id} replaced with media in-place")
+        return True
+    except Exception as e:
+        LOGGER(__name__).warning(
+            f"edit_message_media failed (will fall back to reply): {e}")
+        return False
 
 
 async def _send_with_flood_retry(send_fn, *args, retries: int = 3, **kwargs) -> Optional[Any]:
@@ -2050,7 +2040,7 @@ async def _send_one_slot(
         fname  = short_name(result.filename or f"Post #{index + 1}", 35)
         LOGGER(__name__).error(f"[Sender] Slot {index} abandoned: {result.error}")
         try:
-            placeholder = await user.send_message(
+            placeholder = await bot.send_message(
                 chat_id,
                 f"🔲 **File Unavailable** — Post #{index + 1}\n"
                 f"━━━━━━━━━━━━━━━━━━━\n"
@@ -2127,7 +2117,7 @@ async def _send_one_slot(
                 LOGGER(__name__).warning(
                     f"Group item missing/failed: {ifname} — {ierr}")
                 try:
-                    ph = await user.send_message(
+                    ph = await bot.send_message(
                         chat_id,
                         f"🔲 **File Unavailable** (group item)\n"
                         f"━━━━━━━━━━━━━━━━━━━\n"
@@ -2165,7 +2155,7 @@ async def _send_one_slot(
             failed = 1
             LOGGER(__name__).error(f"[Sender] Slot {index}: file gone before send")
             try:
-                ph = await user.send_message(
+                ph = await bot.send_message(
                     chat_id,
                     f"🔲 **File Lost** — Post #{index + 1}\n\n"
                     f"`{os.path.basename(result.media_path)}`\n"
@@ -2220,7 +2210,7 @@ async def _send_one_slot(
             await state_mgr.put(index, status=TaskStatus.FAILED, error=str(e))
             LOGGER(__name__).error(f"[Sender] Send failed slot {index}: {e}")
             try:
-                ph = await user.send_message(
+                ph = await bot.send_message(
                     chat_id,
                     f"🔲 **Upload Failed** — Post #{index + 1}\n\n"
                     f"`{str(e)[:200]}`\n_Use `/retry` to try again._")
@@ -2355,9 +2345,7 @@ async def _sonic_sender(
                     continue          # placeholder already sent — skip
                 if kill_event.is_set():
                     break
-                # Need a placeholder for this gap.
-                # MUST use the user client — edit_message_media can only edit
-                # messages sent by the same account (MESSAGE_AUTHOR_REQUIRED).
+                # Need a placeholder for this gap
                 gap_ts  = state_mgr.state_map.get(gap)
                 fname   = gap_ts.filename if gap_ts else f"Post #{gap + 1}"
                 fsize   = gap_ts.file_size if gap_ts else 0
@@ -2366,7 +2354,7 @@ async def _sonic_sender(
                 LOGGER(__name__).info(
                     f"[Sonic] Creating gap placeholder for slot {gap}: {fname}")
                 try:
-                    ph = await user.send_message(
+                    ph = await bot.send_message(
                         chat_id,
                         f"⚡ **Downloading…** — Post #{gap + 1}\n"
                         f"━━━━━━━━━━━━━━━━━━━\n"
@@ -2384,7 +2372,7 @@ async def _sonic_sender(
                         f"[Sonic] FloodWait {wait_s}s sending gap placeholder")
                     await asyncio.sleep(wait_s + 1)
                     try:
-                        ph = await user.send_message(
+                        ph = await bot.send_message(
                             chat_id,
                             f"⚡ **Downloading…** — Post #{gap + 1}\n"
                             f"📄 `{short_name(fname, 35)}`\n"
@@ -2428,7 +2416,7 @@ async def _sonic_sender(
             ph_id = sonic_ph_map.get(index)
             if ph_id:
                 try:
-                    await user.edit_message_text(
+                    await bot.edit_message_text(
                         chat_id, ph_id,
                         f"🔲 **File Unavailable** — Post #{index + 1}\n"
                         f"━━━━━━━━━━━━━━━━━━━\n"
@@ -2440,7 +2428,7 @@ async def _sonic_sender(
             else:
                 # No placeholder yet — send an abandoned placeholder
                 try:
-                    ph = await user.send_message(
+                    ph = await bot.send_message(
                         chat_id,
                         f"🔲 **File Unavailable** — Post #{index + 1}\n"
                         f"━━━━━━━━━━━━━━━━━━━\n"
@@ -2529,7 +2517,7 @@ async def _sonic_sender(
                 # Update the gap placeholder to show group result
                 try:
                     icon = "✅" if group_failed_count == 0 else "⚠️"
-                    await user.edit_message_text(
+                    await bot.edit_message_text(
                         chat_id, ph_id,
                         f"{icon} **Media Group** — Post #{index + 1}\n"
                         f"`{group_sent_count}` files sent"
@@ -2557,7 +2545,7 @@ async def _sonic_sender(
                 ph_id = sonic_ph_map.get(index)
                 if ph_id:
                     try:
-                        await user.edit_message_text(
+                        await bot.edit_message_text(
                             chat_id, ph_id,
                             f"🔲 **File Lost** — Post #{index + 1}\n"
                             f"_File removed before upload. Use `/retry`._")
@@ -2638,7 +2626,7 @@ async def _sonic_sender(
                                     f"{str(chat_id).lstrip('-100')}/{sent_msg.id}")
                             icon  = "⚠️" if result.is_partial else "✅"
                             label = "Partial" if result.is_partial else "Uploaded"
-                            await user.edit_message_text(
+                            await bot.edit_message_text(
                                 chat_id, ph_id,
                                 f"{icon} **{label}** — Post #{index + 1}\n"
                                 f"[Jump to message ↑]({link})",
@@ -2674,7 +2662,7 @@ async def _sonic_sender(
                     try:
                         link = (f"https://t.me/c/"
                                 f"{str(chat_id).lstrip('-100')}/{sent_msg.id}")
-                        await user.edit_message_text(
+                        await bot.edit_message_text(
                             chat_id, ph_id,
                             f"✅ **Forwarded** — Post #{index + 1}\n"
                             f"[Jump to message ↑]({link})",
@@ -2841,12 +2829,9 @@ async def _strict_sonic_sender(
             f"🔗 `{url}`\n\n"
             f"_Will be replaced automatically when ready._"
         )
-        # MUST use the user client — edit_message_media can only edit messages
-        # sent by the same account. Bot-sent placeholders cannot be edited
-        # by the user client (Telegram returns MESSAGE_AUTHOR_REQUIRED).
         for attempt in range(2):
             try:
-                ph = await user.send_message(chat_id, text)
+                ph = await bot.send_message(chat_id, text)
                 sonic_ph_map[gap] = ph.id
                 if gap_ts:
                     gap_ts.placeholder_msg_id = ph.id
@@ -2882,91 +2867,39 @@ async def _strict_sonic_sender(
 
         # ── Error / abandoned ────────────────────────────────────────────
         if result.error and not result.media_path and result.media_type != "group":
-            # The download worker already exhausted MAX_DOWNLOAD_RETRIES.
-            # Before giving up, do one final attempt here: re-fetch the
-            # message from Telegram (gets a fresh file_reference) and try
-            # the download once more. This catches the most common cause —
-            # a stale file_reference that expired between fetch and download.
-            fname       = short_name(result.filename or f"Post #{index + 1}", 35)
-            recovered   = False
-            retry_path  = None
-            if src_msg and getattr(src_msg, "id", None):
+            failed += 1
+            fname = short_name(result.filename or f"Post #{index + 1}", 35)
+            LOGGER(__name__).error(
+                f"[StrictSonic] Slot {index} abandoned: {result.error}")
+            err_text = (
+                f"🔲 **File Unavailable** — Post #{index + 1}\n"
+                f"━━━━━━━━━━━━━━━━━━━\n"
+                f"📄 `{fname}`\n"
+                f"⚠️ _{result.error[:150]}_\n\n"
+                f"_Use `/retry` to attempt re-download._"
+            )
+            if ph_id:
                 try:
-                    LOGGER(__name__).info(
-                        f"[StrictSonic] Slot {index} — re-fetching for final "
-                        f"download attempt (original error: {result.error})")
-                    src_chat = getattr(getattr(src_msg, "chat", None), "id", None)
-                    if src_chat:
-                        fresh_msg = await user.get_messages(
-                            chat_id=src_chat, message_ids=src_msg.id)
-                        if fresh_msg and fresh_msg.id and has_downloadable_media(fresh_msg):
-                            retry_filename = get_file_name(fresh_msg.id, fresh_msg)
-                            retry_path     = get_download_path(
-                                state_mgr.reply_to_id, retry_filename)
-                            rpath, rerr, rpartial = await download_single_message(
-                                fresh_msg, retry_path,
-                                retries=1,
-                                _src_chat_id=src_chat)
-                            if rpath:
-                                LOGGER(__name__).info(
-                                    f"[StrictSonic] ✅ Final retry download succeeded "
-                                    f"for slot {index}")
-                                # Patch result in-place so the upload path below handles it
-                                result.media_path  = rpath
-                                result.media_type  = (
-                                    "photo"    if fresh_msg.photo else
-                                    "video"    if fresh_msg.video else
-                                    "audio"    if fresh_msg.audio else
-                                    "document")
-                                result.filename   = retry_filename
-                                result.is_partial = rpartial
-                                result.error      = rerr
-                                recovered = True
-                except Exception as re_err:
-                    LOGGER(__name__).warning(
-                        f"[StrictSonic] Final retry attempt failed for slot "
-                        f"{index}: {re_err}")
-
-            if recovered:
-                # Fall through to the single-media upload path below
-                pass
+                    await bot.edit_message_text(chat_id, ph_id, err_text)
+                except Exception as e:
+                    LOGGER(__name__).debug(
+                        f"[StrictSonic] Placeholder update failed: {e}")
             else:
-                # Truly unrecoverable — mark ABANDONED with placeholder
-                failed += 1
-                LOGGER(__name__).error(
-                    f"[StrictSonic] Slot {index} abandoned after all retries: "
-                    f"{result.error}")
-                err_text = (
-                    f"🔲 **File Unavailable** — Post #{index + 1}\n"
-                    f"━━━━━━━━━━━━━━━━━━━\n"
-                    f"📄 `{fname}`\n"
-                    f"⚠️ _{result.error[:150] if result.error else 'Download failed'}_\n\n"
-                    f"_Use `/retry` to attempt re-download._"
-                )
-                if ph_id:
-                    try:
-                        await user.edit_message_text(chat_id, ph_id, err_text)
-                    except Exception as e:
-                        LOGGER(__name__).debug(
-                            f"[StrictSonic] Placeholder update failed: {e}")
-                else:
-                    try:
-                        ph = await user.send_message(chat_id, err_text)
-                        sonic_ph_map[index] = ph.id
-                    except Exception:
-                        pass
-                _ph2 = sonic_ph_map.get(index)
-                if index in state_mgr.state_map:
-                    state_mgr.state_map[index].status = TaskStatus.ABANDONED
-                    if _ph2:
-                        state_mgr.state_map[index].placeholder_msg_id = _ph2
-                _put_kw: dict = {"status": TaskStatus.ABANDONED}
+                try:
+                    ph = await bot.send_message(chat_id, err_text)
+                    sonic_ph_map[index] = ph.id
+                except Exception:
+                    pass
+            _ph2 = sonic_ph_map.get(index)
+            if index in state_mgr.state_map:
+                state_mgr.state_map[index].status = TaskStatus.ABANDONED
                 if _ph2:
-                    _put_kw["placeholder_msg_id"] = _ph2
-                await state_mgr.put(index, **_put_kw)
-                return
-
-        # ── (recovered from download failure — fall through to upload) ───
+                    state_mgr.state_map[index].placeholder_msg_id = _ph2
+            _put_kw: dict = {"status": TaskStatus.ABANDONED}
+            if _ph2:
+                _put_kw["placeholder_msg_id"] = _ph2
+            await state_mgr.put(index, **_put_kw)
+            return
 
         # ── Media group ──────────────────────────────────────────────────
         if result.media_type == "group" and result.media_path:
@@ -3026,7 +2959,7 @@ async def _strict_sonic_sender(
             if ph_id:
                 try:
                     icon = "✅" if group_failed_count == 0 else "⚠️"
-                    await user.edit_message_text(
+                    await bot.edit_message_text(
                         chat_id, ph_id,
                         f"{icon} **Media Group** — Post #{index + 1}\n"
                         f"`{group_sent_count}` files sent"
@@ -3055,7 +2988,7 @@ async def _strict_sonic_sender(
                     f"[StrictSonic] Slot {index}: file gone before upload")
                 if ph_id:
                     try:
-                        await user.edit_message_text(
+                        await bot.edit_message_text(
                             chat_id, ph_id,
                             f"🔲 **File Lost** — Post #{index + 1}\n"
                             f"_File removed before upload. Use `/retry`._")
@@ -3103,26 +3036,22 @@ async def _strict_sonic_sender(
                     src_to_dst_map[src_msg.id] = ph_id
                     await state_mgr.put(index, sent_msg_id=ph_id)
             elif ph_id:
-                # edit_message_media failed with a placeholder already in chat.
-                # We must NOT delete the placeholder and re-send — that creates
-                # a gap that breaks sequence. Keep the placeholder as an anchor
-                # and mark ABANDONED so /retry can re-attempt at the correct
-                # position later. The file on disk is cleaned up here because
-                # /retry will re-download fresh.
+                # edit_message_media failed AND a placeholder is already in chat.
+                # Sending a new message here would break sequence (it would appear
+                # below later slots). Instead: mark ABANDONED and edit the placeholder
+                # to a clear error notice so the user can /retry at the correct position.
                 failed += 1
                 cleanup_download(result.media_path)
                 LOGGER(__name__).warning(
                     f"[StrictSonic] edit_message_media failed for slot {index} "
-                    f"(ph {ph_id}) — keeping placeholder, marking ABANDONED")
-                icon = "⚠️" if result.is_partial else "🔲"
-                label = "Partial — re-upload needed" if result.is_partial else "Upload failed"
+                    f"(placeholder {ph_id}) — marking ABANDONED for /retry")
                 try:
-                    await user.edit_message_text(
+                    await bot.edit_message_text(
                         chat_id, ph_id,
-                        f"{icon} **{label}** — Post #{index + 1}\n"
+                        f"🔲 **Upload Failed** — Post #{index + 1}\n"
                         f"━━━━━━━━━━━━━━━━━━━\n"
                         f"📄 `{short_name(result.filename or f'Post #{index+1}', 35)}`\n\n"
-                        f"_Could not upload (edit_message_media failed).\n"
+                        f"_edit_message_media failed (permissions or unsupported type).\n"
                         f"Use `/retry` to re-upload at this position._")
                 except Exception as edit_err:
                     LOGGER(__name__).debug(
@@ -3186,7 +3115,7 @@ async def _strict_sonic_sender(
                     try:
                         link = (f"https://t.me/c/"
                                 f"{str(chat_id).lstrip('-100')}/{sent_msg.id}")
-                        await user.edit_message_text(
+                        await bot.edit_message_text(
                             chat_id, ph_id,
                             f"✅ **Forwarded** — Post #{index + 1}\n"
                             f"[Jump to message ↑]({link})",
@@ -3205,16 +3134,16 @@ async def _strict_sonic_sender(
 
     # ── chat_writer: THE ONLY coroutine that ever touches chat ───────────
     # Phase A: walk write_pointer from 0..n-1 in strict order.
-    #   - If slot is ready → send real content immediately (no placeholder).
-    #   - If slot is not ready → yield one event-loop tick, re-check once,
-    #     THEN send a placeholder and record in pending_replace.
-    # Phase B: replace placeholders as downloads finish (FIRST_COMPLETED).
-    #   Positions are already locked in chat by the placeholders sent in
-    #   Phase A. Waiting for FIRST_COMPLETED means fast slots never wait
-    #   behind slow ones — the bot stays maximally responsive.
-    #   Sequence safety: edit_message_media replaces IN-PLACE. If it fails,
-    #   we keep the placeholder as an anchor (ABANDONED) — we never send a
-    #   new message that could appear in the wrong position.
+    #   - If slot is ready → send real content immediately.
+    #   - If slot is not ready → yield one event-loop tick (gives just-
+    #     finishing downloads a chance to land), re-check once, THEN send
+    #     a placeholder and record in pending_replace.
+    # Phase B: replace placeholders in strict ascending index order.
+    #   Waiting for each slot in order guarantees that the fallback path
+    #   (when edit_message_media fails) also produces messages top-to-bottom.
+    #   If edit_message_media fails AND a placeholder is in chat, we mark
+    #   ABANDONED and edit the placeholder to an error notice — we never
+    #   send a new message that would appear below later slots.
     async def chat_writer():
         nonlocal skipped
         write_pointer   = 0
@@ -3272,62 +3201,33 @@ async def _strict_sonic_sender(
                 pending_replace.append(write_pointer)
                 write_pointer += 1
 
-        # ── Phase B: replace placeholders as downloads finish ─────────────
-        # Positions are already locked in chat by the placeholders sent in
-        # Phase A. We can safely process whichever slot finishes downloading
-        # FIRST — no need for strict order here. Waiting in strict order
-        # would block a fast slot behind a slow one unnecessarily, making
-        # the bot appear stalled even when files are ready.
-        #
-        # Sequence safety: edit_message_media replaces the placeholder
-        # IN-PLACE at its existing chat position. No new messages are sent
-        # that could land in the wrong order. If edit_message_media fails
-        # (no edit rights etc.), we keep the placeholder as an anchor and
-        # mark ABANDONED — we never send a new out-of-order message.
-        remaining = list(pending_replace)
-        while remaining and not kill_event.is_set():
+        # ── Phase B: replace placeholders in strict slot order ───────────
+        # We wait for each slot in ascending index order. Because every slot
+        # already has a placeholder holding its position in chat, the visual
+        # sequence is already established. Processing in order here ensures
+        # that the fallback "send new message" path (when edit_message_media
+        # fails) also produces messages in the correct top-to-bottom order.
+        for idx in pending_replace:
+            if kill_event.is_set():
+                break
             if skip_event.is_set():
                 skip_event.clear()
-                if remaining:
-                    idx = remaining.pop(0)
-                    await state_mgr.put(idx, status=TaskStatus.SKIPPED)
-                    skipped += 1
-                    LOGGER(__name__).info(
-                        f"[StrictSonic] Phase B slot {idx} skipped by user.")
+                await state_mgr.put(idx, status=TaskStatus.SKIPPED)
+                skipped += 1
+                LOGGER(__name__).info(
+                    f"[StrictSonic] Phase B slot {idx} skipped by user.")
                 continue
-
-            # Build a wait-task for every remaining slot
-            wait_map: Dict[asyncio.Task, int] = {}
-            for idx in remaining:
-                if ready_events[idx].is_set():
-                    t = asyncio.ensure_future(asyncio.sleep(0))
-                else:
-                    t = asyncio.ensure_future(ready_events[idx].wait())
-                wait_map[t] = idx
-
-            if not wait_map:
-                break
-
-            done_tasks, _ = await asyncio.wait(
-                list(wait_map.keys()), return_when=asyncio.FIRST_COMPLETED)
-
-            # Cancel the waiter tasks that didn't fire
-            for t in wait_map:
-                if t not in done_tasks:
-                    t.cancel()
-
-            # Process the first slot that became ready
-            for done_task in done_tasks:
-                idx = wait_map[done_task]
-                if idx in remaining:
-                    remaining.remove(idx)
-                if kill_event.is_set():
-                    break
+            # Wait for this specific slot to finish downloading
+            if not ready_events[idx].is_set():
                 LOGGER(__name__).info(
-                    f"[StrictSonic] Phase B: replacing placeholder for slot {idx}")
-                await _send_real(idx)
-                await state_mgr.move_status_to_bottom()
-                break  # restart outer while so wait_map is rebuilt fresh
+                    f"[StrictSonic] Phase B: waiting for slot {idx}…")
+                await ready_events[idx].wait()
+            if kill_event.is_set():
+                break
+            LOGGER(__name__).info(
+                f"[StrictSonic] Phase B: replacing placeholder for slot {idx}")
+            await _send_real(idx)
+            await state_mgr.move_status_to_bottom()
 
     await chat_writer()
     return {"sent": sent, "failed": failed, "skipped": skipped}
@@ -3782,7 +3682,7 @@ async def handle_retry(chat_id: int, reply_to_id: int):
                 if ts.placeholder_msg_id and sent_msg:
                     try:
                         link = f"https://t.me/c/{str(chat_id).lstrip('-100')}/{sent_msg.id}"
-                        await user.edit_message_text(
+                        await bot.edit_message_text(
                             chat_id, ts.placeholder_msg_id,
                             f"✅ **Fixed!** — Post #{ts.index + 1}\n"
                             f"_Text forwarded._\n"
@@ -3917,7 +3817,7 @@ async def handle_retry(chat_id: int, reply_to_id: int):
                         link = f"https://t.me/c/{str(chat_id).lstrip('-100')}/{sent_msg.id}"
                         icon  = "⚠️" if is_partial else "✅"
                         label = "Still Partial" if is_partial else "Fixed!"
-                        await user.edit_message_text(
+                        await bot.edit_message_text(
                             chat_id, ts.placeholder_msg_id,
                             f"{icon} **{label}** — Post #{ts.index + 1}\n"
                             f"[Jump to message ↑]({link})",