Route TikTok media sends through tg_call

lumen_tiktok_flow.py

@@ -150,30 +150,40 @@ async def _send_tiktok_music(session, media_data: dict, message: Message, author
          # Слэш и управляющие из чужого названия — в "_" (AUD-E-005),
          # иначе multipart-имя файла битое.
          safe_title = re.sub(r'[\\/:*?"<>|\x00-\x1f]', "_", cleaned_title[:60]).strip() or "track"
-         try:
-              await bot.bot.send_audio(
-                   chat_id=message.chat.id,
-                   audio=BufferedInputFile(tagged_music_bytes, filename=f"{safe_title}.mp3"),
-                   title=cleaned_title,
-                   performer=performer_name,
-                   duration=music_duration if music_duration > 0 else None,
-                   thumbnail=thumbnail_file,
-                   reply_to_message_id=message.message_id
-              )
-         except Exception as send_exc:
+         # Через _tg_call: breaker-гейт, таймаут и RetryAfter вместо прямого send_audio.
+         # None вместо исключения — дальше та же логика, что раньше в except.
+         sent_audio = await bot._tg_call(
+              bot.bot.send_audio,
+              chat_id=message.chat.id,
+              audio=BufferedInputFile(tagged_music_bytes, filename=f"{safe_title}.mp3"),
+              title=cleaned_title,
+              performer=performer_name,
+              duration=music_duration if music_duration > 0 else None,
+              thumbnail=thumbnail_file,
+              reply_to_message_id=message.message_id,
+              call_timeout=bot.TELEGRAM_MEDIA_TIMEOUT,
+              # Без вслепую ретрая: повтор без обложки ниже и есть стратегия повтора.
+              retries=0,
+         )
+         if sent_audio is None:
               if thumbnail_file is None:
-                   raise
+                   raise RuntimeError("Telegram send_audio failed: connection timeout or proxy unavailable")
               # Обложка с TikWM бывает жирной — Telegram режет отправку целиком, и трек не приходит
               # вообще молча. Повторяем без обложки: музыка важнее картинки.
-              log.warning("[tiktok] send_audio with thumbnail failed, retrying without: %s", send_exc)
-              await bot.bot.send_audio(
+              log.warning("[tiktok] send_audio with thumbnail failed, retrying without")
+              sent_audio = await bot._tg_call(
+                   bot.bot.send_audio,
                    chat_id=message.chat.id,
                    audio=BufferedInputFile(tagged_music_bytes, filename=f"{safe_title}.mp3"),
                    title=cleaned_title,
                    performer=performer_name,
                    duration=music_duration if music_duration > 0 else None,
-                   reply_to_message_id=message.message_id
+                   reply_to_message_id=message.message_id,
+                   call_timeout=bot.TELEGRAM_MEDIA_TIMEOUT,
+                   retries=0,
               )
+              if sent_audio is None:
+                   raise RuntimeError("Telegram send_audio failed: connection timeout or proxy unavailable")
     except Exception as e:
          log.warning("[tiktok] failed to send music: %s", e)
 
@@ -282,23 +292,33 @@ async def _try_send_tiktok_slideshow(
                     # Один уцелевший слайд — обычным send_photo/send_video: media group требует минимум 2.
                    only_item = media_items[0]
                    if isinstance(only_item, InputMediaVideo):
-                        await bot.bot.send_video(
+                        sent_slide = await bot._tg_call(
+                             bot.bot.send_video,
                              chat_id=message.chat.id, video=only_item.media,
                              supports_streaming=True, reply_to_message_id=message.message_id,
+                             call_timeout=bot.TELEGRAM_MEDIA_TIMEOUT,
                         )
                    else:
-                        await bot.bot.send_photo(
+                        sent_slide = await bot._tg_call(
+                             bot.bot.send_photo,
                              chat_id=message.chat.id, photo=only_item.media,
                              reply_to_message_id=message.message_id,
+                             call_timeout=bot.TELEGRAM_MEDIA_TIMEOUT,
                         )
+                   if sent_slide is None:
+                        raise RuntimeError("Telegram slideshow slide send failed: connection timeout or proxy unavailable")
               else:
                     # Группы по 10 без хвоста из 1 (жёсткое требование Telegram 2–10); первая — ответом на ссылку.
                    chunks = _chunk_tiktok_media_items(media_items)
                    for chunk_idx, chunk in enumerate(chunks):
-                        await bot.bot.send_media_group(
+                        sent_chunk = await bot._tg_call(
+                             bot.bot.send_media_group,
                              chat_id=message.chat.id, media=chunk,
                              reply_to_message_id=message.message_id if chunk_idx == 0 else None,
+                             call_timeout=bot.TELEGRAM_MEDIA_TIMEOUT,
                         )
+                        if sent_chunk is None:
+                             raise RuntimeError("Telegram send_media_group failed: connection timeout or proxy unavailable")
                         if chunk_idx + 1 < len(chunks):
                               # Пауза между группами — против анти-флуда.
                              await asyncio.sleep(0.3)
@@ -311,12 +331,13 @@ async def _send_tiktok_single_video(
     session: aiohttp.ClientSession, media_data: dict, message: Message, status: Message | None,
     author: str, headers: dict,
 ) -> None:
-    """Пробуем качества HD → обычное → с водяным; EntityTooLarge — следующий вариант, не сдаёмся."""
+    """Пробуем качества HD → обычное → с водяным; переполнение лимита — следующий вариант, не сдаёмся."""
     import bot
     # Качества HD → обычное → с водяным (раньше без HD); EntityTooLarge — следующий вариант.дальше.
     video_candidates = _tiktok_video_candidates(media_data)
     if video_candidates:
          hit_size_limit = False
+         send_failed = False
          for candidate in video_candidates:
               if candidate["size"] and candidate["size"] > bot.TELEGRAM_BOT_API_UPLOAD_LIMIT_BYTES:
                     # Заранее большой размер пропускаем без скачивания и помечаем hit_size_limit, чтобы дать честное "слишком большое".
@@ -370,16 +391,24 @@ async def _send_tiktok_single_video(
               if thumb_bytes:
                    send_kwargs["thumbnail"] = BufferedInputFile(thumb_bytes, filename="thumb.jpg")
 
-              try:
-                   await bot.bot.send_video(**send_kwargs)
-              except TelegramEntityTooLarge:
-                   # Реальный размер больше лимита, хотя заявленный был неточен — пробуем следующий, более лёгкий вариант.
+              # Реальный размер уже скачан: лимит Telegram проверяем до отправки,
+              # а не по 413 от API (_tg_call клиентские ошибки не пробрасывает).
+              if len(video_bytes) > bot.TELEGRAM_BOT_API_UPLOAD_LIMIT_BYTES:
                    hit_size_limit = True
-                   log.warning(
-                        '[tiktok] Variant %s (%s, %d bytes) exceeded the Telegram limit when sending — trying the next quality option.',
+                   log.info(
+                        '[tiktok] Skipping variant %s (%s, %d bytes) — real size exceeds the Telegram Bot API limit.',
                         candidate["key"], candidate["label"], len(video_bytes),
                    )
                    continue
+              # Через _tg_call: breaker-гейт, таймаут и RetryAfter. None — сбой
+              # отправки: пробуем следующий вариант, как раньше при исключении.
+              sent_video = await bot._tg_call(
+                   bot.bot.send_video, **send_kwargs,
+                   call_timeout=bot.TELEGRAM_MEDIA_TIMEOUT,
+              )
+              if sent_video is None:
+                   send_failed = True
+                   continue
 
               await _send_tiktok_music(session, media_data, message, author, headers)
               await bot._delete_message_quietly(status)
@@ -390,6 +419,10 @@ async def _send_tiktok_single_video(
                raise TikTokUserFacingError(
                    bot._t(message.chat.id, "tiktok_too_big")
                )
+         if send_failed:
+              # Варианты скачались, но ни один не ушёл в Telegram — честная
+              # ошибка отправки, а не "контент удалён".
+              raise RuntimeError("Telegram send_video failed: connection timeout or proxy unavailable")
 
     raise TikTokUserFacingError(bot._t(message.chat.id, "tiktok_no_media"))
 

tests/test_bot_tiktok.py

@@ -1409,6 +1409,46 @@ def test_single_video_status_deleted_after_music():
         lumen_tiktok_flow._send_tiktok_music = original_music
 
 
+def test_single_video_send_goes_through_tg_call(monkeypatch):
+    # Отправки идут через _tg_call (breaker/таймаут/RetryAfter), а не напрямую:
+    # при недоступности Telegram прямой send_video не дёргается вообще.
+    import lumen_tiktok_flow
+    direct_calls = []
+
+    class _DirectBot:
+        async def send_video(self, **kwargs):
+            direct_calls.append(kwargs)
+            return SimpleNamespace()
+
+    async def fake_download(session, url, headers=None, cap_bytes=None):
+        return b"\x00" * 100
+
+    async def fake_probe_dims(path):
+        return 0, 0, 0
+
+    async def fake_thumb(path, duration):
+        return None
+
+    async def fake_tg_call(method, *args, **kwargs):
+        return None
+
+    monkeypatch.setattr(bot, "_download_url_bin", fake_download)
+    monkeypatch.setattr(bot, "_probe_video_dimensions", fake_probe_dims)
+    monkeypatch.setattr(bot, "_generate_video_thumbnail", fake_thumb)
+    monkeypatch.setattr(bot, "_tg_call", fake_tg_call)
+    monkeypatch.setattr(bot, "bot", _DirectBot())
+    incoming = _FakeIncomingMessage(999456)
+    incoming.message_id = 1
+    media_data = {"play": "https://tikwm.com/v.mp4", "size": 100, "author": {"nickname": "Nick"}}
+    try:
+        with pytest.raises(RuntimeError):
+            asyncio.run(lumen_tiktok_flow._send_tiktok_single_video(
+                None, media_data, incoming, None, "Nick", {}))
+        assert direct_calls == []
+    finally:
+        bot.chat_state.pop(999456, None)
+
+
 # ─────────────── S9: DNS в потоке, ручные редиректы, капы, N/A, WebM ───────────────
 
 def _fake_public_dns(host, port, *args, **kwargs):
@@ -1642,12 +1682,15 @@ def test_slideshow_stops_at_post_budget(monkeypatch):
     class _FakeTgBot:
         async def send_photo(self, **kwargs):
             calls["photo"] = calls.get("photo", 0) + 1
+            return SimpleNamespace()
 
         async def send_video(self, **kwargs):
             calls["video"] = calls.get("video", 0) + 1
+            return SimpleNamespace()
 
         async def send_media_group(self, **kwargs):
             calls["group"] = calls.get("group", 0) + 1
+            return SimpleNamespace()
 
     async def fake_edit(*args, **kwargs):
         return True