Fix adversarial review findings across splitter quotas and backup

.github/workflows/state-backup.yml

@@ -59,7 +59,9 @@ jobs:
           cd backup-repo
           git add export_state.json
           git diff --cached --quiet || git commit -m "Backup $(date -u +%Y-%m-%d)"
-          git push origin HEAD:main
+          # extraheader только на эту команду: в конфиге клона секрета нет.
+          git -c "http.https://github.com/.extraheader=AUTHORIZATION: basic $(printf 'x-access-token:%s' "${STATE_BACKUP_TOKEN}" | base64 -w0)" \
+            push origin HEAD:main
 
       - name: Report backup failure
         # Канала уведомлений нет (нужен отдельный секрет/чат — решение владельца):

lumen_commands.py

@@ -341,9 +341,16 @@ async def inline_tts(message: Message, text: str) -> None:
         return
     # Дневные лимиты пользователя: общий и отдельный на озвучку (он же тратит квоту Gemini TTS).
     # Проба без создания: отказ не заводит запись и не раздувает day_users.
+    # Считаем сразу все чанки: каждый — отдельный синтез, иначе длинный текст
+    # уводил бы счётчик за лимит.
     uid = bot._user_key_for_message(message)
     _tts_entry = bot._user_daily_peek(uid)
-    if bot._user_daily_total_exhausted(uid, _tts_entry):
+    try:
+        _tts_over_total = int((_tts_entry or {}).get("total") or 0) + len(chunks) > bot._user_daily_limit(uid, "total", _tts_entry)
+        _tts_over_tts = int((_tts_entry or {}).get("tts") or 0) + len(chunks) > bot._user_daily_limit(uid, "tts", _tts_entry)
+    except (TypeError, ValueError):
+        _tts_over_total = _tts_over_tts = False
+    if bot._user_daily_total_exhausted(uid, _tts_entry) or _tts_over_total:
         hours, mins = bot._user_daily_reset_in()
         # Суточный счётчик /stats: отказ по лимиту, озвучки не будет.
         bot._record_stats_event("daily_limit_denials")
@@ -353,7 +360,7 @@ async def inline_tts(message: Message, text: str) -> None:
             hours=hours, mins=mins,
         ))
         return
-    if bot._user_daily_tts_exhausted(uid, _tts_entry):
+    if bot._user_daily_tts_exhausted(uid, _tts_entry) or _tts_over_tts:
         bot._record_stats_event("daily_limit_denials")
         await bot._safe_reply(message, bot._t(
             message.chat.id, "user_daily_tts",

lumen_formatting.py

@@ -727,6 +727,24 @@ def _split_to_fit_html(chunk_md: str, max_len: int) -> list[str]:
     return out
 
 
+def _merge_short_chunks(chunks: list[str], max_len: int) -> list[str]:
+    """Склейка соседних кусков обратно, пока влезают: сегментация по заборам
+    иначе дробила бы каждое короткое сообщение с кодом на три."""
+    merged: list[str] = []
+    acc = ""
+    for chunk in chunks:
+        candidate = chunk if not acc else acc + chunk
+        if _tg_len(_md_to_html(candidate)) <= max_len:
+            acc = candidate
+        else:
+            if acc:
+                merged.append(acc)
+            acc = chunk
+    if acc or not merged:
+        merged.append(acc)
+    return merged
+
+
 def _split_text_chunks(text: str, max_len: int = 4096) -> list[str]:
     """Разбивает длинный текст на части не длиннее max_len, стараясь резать по
     границам абзацев/строк/предложений, а не посреди слова. Раньше сообщения
@@ -765,7 +783,7 @@ def _split_text_chunks(text: str, max_len: int = 4096) -> list[str]:
     out: list[str] = []
     for chunk in md_chunks:
         out.extend(_split_to_fit_html(chunk, max_len))
-    return out or [text]
+    return _merge_short_chunks(out, max_len) or [text]
 
 
 def _truncate_html_to_fit(md_text: str, limit: int) -> str:

lumen_routes.py

@@ -280,8 +280,9 @@ async def _chat_completion_chain(
                     label, model_trial,
                 )
                 raise
-            # 429 — в карантин/остывку, как стриминг выше: иначе модель долбят
-            # каждым сообщением, а _is_quota_exhausted её не видит.
+            # 429 — в карантин/остывку, как стриминг выше. Account-wide сюда не
+            # доходит: stop_on выше уже оборвал цепочку без метки (иначе метка
+            # каскадом расползлась бы по всем моделям, хотя лимит общий).
             try:
                 _txt = bot._error_text(exc).strip() or exc.__class__.__name__
                 if bot._classify_model_error(bot._error_status(exc, _txt), _txt) == "rate_limit":

lumen_tiktok.py

@@ -480,9 +480,8 @@ async def _communicate_process(proc: asyncio.subprocess.Process, *, timeout: flo
             with contextlib.suppress(ProcessLookupError):
                 proc.kill()
         # Дренаж ограничен: communicate, переживший kill, не держит loop вечно.
-        # Результат дренажа уже опоздал (таймаут был) — только подчищаем задачу,
-        # наружу по-прежнему исходный TimeoutError. Внешняя отмена из дренажа
-        # летит сама: CancelledError здесь не ловим.
+        # Ошибка самого дренажа летит как есть (вызывающие ловят широкий
+        # Exception); исходный TimeoutError — когда дренаж просто не уложился.
         try:
             await asyncio.wait_for(asyncio.shield(completion), timeout=_COMMUNICATE_DRAIN_SEC)
         except asyncio.TimeoutError:
@@ -497,7 +496,10 @@ async def _communicate_process(proc: asyncio.subprocess.Process, *, timeout: flo
         if proc.returncode is None:
             with contextlib.suppress(ProcessLookupError):
                 proc.kill()
-        if not completion.done():
+        if completion.done():
+            with contextlib.suppress(Exception, asyncio.CancelledError):
+                completion.result()
+        else:
             completion.cancel()
         raise
 

lumen_tiktok_flow.py

@@ -163,7 +163,7 @@ async def _send_tiktok_music(session, media_data: dict, message: Message, author
               thumbnail=thumbnail_file,
               reply_to_message_id=message.message_id,
               call_timeout=bot.TELEGRAM_MEDIA_TIMEOUT,
-              # Без вслепую ретрая: повтор без обложки ниже и есть стратегия повтора.
+              # Без слепого ретрая: повтор без обложки ниже и есть стратегия повтора.
               retries=0,
          )
          if sent_audio is None:
@@ -214,8 +214,11 @@ async def _fetch_tikwm_media_data_with_proxy_fallback(session: aiohttp.ClientSes
         try:
             result = await bot._fetch_tikwm_media_data(session, resolved_url, headers, proxy_base_url=candidate)
         except Exception as exc:
-            # Упавший кандидат не отменяет остальных: пробуем дальше.
-            log.warning("[tiktok] TikWM proxy candidate %r failed: %s", candidate, exc)
+            # Рутина сети — warning без Sentry; остальное пахнет багом — error.
+            if isinstance(exc, (aiohttp.ClientError, asyncio.TimeoutError, OSError)):
+                log.warning("[tiktok] TikWM proxy candidate %r failed: %s", candidate, exc)
+            else:
+                log.exception("[tiktok] TikWM proxy candidate %r failed unexpectedly", candidate)
             continue
         if result is not None:
             return result
@@ -307,6 +310,8 @@ async def _try_send_tiktok_slideshow(
                              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,
+                             # Без слепого ретрая: повтор отправки после сбоя дал бы дубль.
+                             retries=0,
                         )
                    else:
                         sent_slide = await bot._tg_call(
@@ -314,6 +319,7 @@ async def _try_send_tiktok_slideshow(
                              chat_id=message.chat.id, photo=only_item.media,
                              reply_to_message_id=message.message_id,
                              call_timeout=bot.TELEGRAM_MEDIA_TIMEOUT,
+                             retries=0,
                         )
                    if sent_slide is None:
                         raise RuntimeError("Telegram slideshow slide send failed: connection timeout or proxy unavailable")
@@ -326,6 +332,7 @@ async def _try_send_tiktok_slideshow(
                              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,
+                             retries=0,
                         )
                         if sent_chunk is None:
                              raise RuntimeError("Telegram send_media_group failed: connection timeout or proxy unavailable")
@@ -401,20 +408,16 @@ async def _send_tiktok_single_video(
               if thumb_bytes:
                    send_kwargs["thumbnail"] = BufferedInputFile(thumb_bytes, filename="thumb.jpg")
 
-              # Реальный размер уже скачан: лимит Telegram проверяем до отправки,
-              # а не по 413 от API (_tg_call клиентские ошибки не пробрасывает).
-              if len(video_bytes) > bot.TELEGRAM_BOT_API_UPLOAD_LIMIT_BYTES:
-                   hit_size_limit = True
-                   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
+              # Реальный размер уже скачан: больше лимита сюда не приезжает
+              # (кап скачивания выше), заявленный перебор отсеян до скачивания.
+              # Проверка лимита Telegram — парой выше, здесь только отправка.
               # Через _tg_call: breaker-гейт, таймаут и RetryAfter. None — сбой
               # отправки: пробуем следующий вариант, как раньше при исключении.
+              # Без слепого ретрая: повтор отправки после сбоя дал бы дубль.
               sent_video = await bot._tg_call(
                    bot.bot.send_video, **send_kwargs,
                    call_timeout=bot.TELEGRAM_MEDIA_TIMEOUT,
+                   retries=0,
               )
               if sent_video is None:
                    send_failed = True
@@ -424,15 +427,15 @@ async def _send_tiktok_single_video(
               await bot._delete_message_quietly(status)
               return
 
+         if send_failed:
+              # Варианты скачались, но ни один не ушёл в Telegram — честная
+              # ошибка отправки, а не "контент удалён".
+              raise RuntimeError("Telegram send_video failed: connection timeout or proxy unavailable")
          if hit_size_limit:
               # Скачался, но ни один вариант не влез в лимит — отличаем от "TikTok ничего не отдал" (иначе вводящее "контент удалён").
                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

@@ -1512,6 +1512,43 @@ def test_single_video_send_goes_through_tg_call(monkeypatch):
         bot.chat_state.pop(999456, None)
 
 
+def test_single_video_send_does_not_retry_transient_failure(monkeypatch):
+    # Повтор отправки после сбоя дал бы дубль: одна попытка, ошибка наружу.
+    import lumen_tiktok_flow
+    attempts = []
+
+    class _FlakyBot:
+        async def send_video(self, **kwargs):
+            attempts.append(kwargs)
+            if len(attempts) == 1:
+                raise RuntimeError("connection reset by peer")
+            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
+
+    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, "bot", _FlakyBot())
+    incoming = _FakeIncomingMessage(999457)
+    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 len(attempts) == 1
+    finally:
+        bot.chat_state.pop(999457, None)
+
+
 # ─────────────── S9: DNS в потоке, ручные редиректы, капы, N/A, WebM ───────────────
 
 def _fake_public_dns(host, port, *args, **kwargs):

tests/test_bot_tts.py

@@ -562,3 +562,37 @@ def test_inline_tts_charges_each_synthesized_chunk():
         bot.GLOBAL_QUOTA.get("user_daily", {}).pop("777015", None)
         bot.chat_state.pop(999810, None)
 
+
+def test_inline_tts_refuses_when_chunks_would_exceed_limit(monkeypatch):
+    # Проверка считает все чанки сразу: 4/5 + текст на 3 чанка — отказ до синтеза.
+    import lumen_commands
+    from types import SimpleNamespace
+    limit = bot.TTS_MAX_CHARS
+    part = "Предложение номер раз про интересные вещи. "
+    text = part * ((limit // len(part)) + 2)
+    assert len(text) > limit
+    incoming = _FakeIncomingMessage(999811)
+    incoming.message_id = 12361
+    incoming.from_user = SimpleNamespace(id=777016)
+    monkeypatch.setattr(bot, "DAILY_USER_TTS_LIMIT", 5)
+    for _ in range(4):
+        bot._record_user_daily(777016, tts=True)
+
+    async def fail_synth(chunk_text):
+        raise AssertionError("synthesis must not run when chunks exceed the limit")
+
+    monkeypatch.setattr(lumen_commands, "_synthesize_tts_voice", fail_synth)
+    replies = []
+
+    async def fake_safe_reply(msg, reply_text, **kwargs):
+        replies.append(reply_text)
+
+    monkeypatch.setattr(bot, "_safe_reply", fake_safe_reply)
+    try:
+        asyncio.run(bot.inline_tts(incoming, text))
+        assert len(replies) == 1
+        assert bot._user_daily_entry(777016)["tts"] == 4
+    finally:
+        bot.GLOBAL_QUOTA.get("user_daily", {}).pop("777016", None)
+        bot.chat_state.pop(999811, None)
+

tests/test_lumen_formatting.py

@@ -120,6 +120,13 @@ def test_split_chunks_keep_fences_intact():
         assert "```" not in lumen_formatting._md_to_html(chunk)
 
 
+def test_split_chunks_merge_short_fenced_message_back():
+    # Короткое сообщение с кодом едет одним куском, а не тремя.
+    text = "Hi\n```python\nx = 1\n```\nBye"
+    chunks = lumen_formatting._split_text_chunks(text, 4096)
+    assert chunks == [text]
+
+
 def test_md_to_html_link_with_inline_code_has_no_placeholder_leak():
     # Код внутри метки ссылки: плейсхолдер не протекает, оба тега на месте.
     html = lumen_formatting._md_to_html("[`code` текст](https://example.com)")