Update app.py with new version

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

app.py

@@ -1,13 +1,12 @@
 from __future__ import annotations
 
-from concurrent.futures import ThreadPoolExecutor
-import asyncio
-from threading import Lock
+from concurrent.futures import ThreadPoolExecutor, wait
+import threading
 import time
 import os
 import re
 import html as html_lib
-from typing import List, Tuple, Union
+from typing import List, Optional, Tuple, Union
 
 import requests
 from fastapi import FastAPI
@@ -21,12 +20,6 @@ except Exception:
     TelegramClient = None
     StringSession = None
 
-try:
-    from playwright.sync_api import TimeoutError as PlaywrightTimeoutError, sync_playwright
-except Exception:
-    PlaywrightTimeoutError = Exception
-    sync_playwright = None
-
 APP_NAME = "pr-tool-backend"
 
 VK_API_VERSION = os.getenv("VK_API_VERSION", "5.131")
@@ -34,16 +27,34 @@ VK_ACCESS_TOKEN = os.getenv("VK_ACCESS_TOKEN", "")
 TELEGRAM_API_ID = int(os.getenv("TELEGRAM_API_ID", "0") or "0")
 TELEGRAM_API_HASH = os.getenv("TELEGRAM_API_HASH", "")
 TELEGRAM_STRING_SESSION = os.getenv("TELEGRAM_STRING_SESSION", "")
-REQUEST_TIMEOUT = float(os.getenv("REQUEST_TIMEOUT", "15"))
-TELEGRAM_OP_TIMEOUT = float(os.getenv("TELEGRAM_OP_TIMEOUT", "8"))
-TELEGRAM_CONCURRENCY = int(os.getenv("TELEGRAM_CONCURRENCY", "6"))
+
+# --- Таймауты и параллелизм (всё настраивается через переменные окружения) ---
+# Таймаут одного HTTP-запроса задаём кортежем (connect, read), чтобы зависший
+# коннект не съедал всё время.
+_TG_READ_TIMEOUT = float(os.getenv("TELEGRAM_OP_TIMEOUT", "8"))
+TG_HTTP_TIMEOUT = (3.05, _TG_READ_TIMEOUT)
+_MAX_READ_TIMEOUT = float(os.getenv("MAX_OP_TIMEOUT", "6"))
+MAX_HTTP_TIMEOUT = (3.05, _MAX_READ_TIMEOUT)
+REQUEST_TIMEOUT = float(os.getenv("REQUEST_TIMEOUT", "15"))  # для VK API
+
+TELEGRAM_CONCURRENCY = int(os.getenv("TELEGRAM_CONCURRENCY", "16"))
+MAX_CONCURRENCY = int(os.getenv("MAX_CONCURRENCY", "8"))
+
 VK_MAX_RETRIES = int(os.getenv("VK_MAX_RETRIES", "5"))
 VK_RETRY_DELAY = float(os.getenv("VK_RETRY_DELAY", "0.45"))
 VK_BATCH_SIZE = int(os.getenv("VK_BATCH_SIZE", "100"))
-PLAYWRIGHT_GOTO_TIMEOUT_MS = int(os.getenv("PLAYWRIGHT_GOTO_TIMEOUT_MS", "20000"))
-ENABLE_TELEGRAM_BROWSER_FALLBACK = os.getenv("ENABLE_TELEGRAM_BROWSER_FALLBACK", "1") != "0"
 
-_TELEGRAM_BROWSER_LOCK = Lock()
+# Сторонний прокси r.jina.ai заметно медленнее прямого запроса к t.me.
+# По умолчанию выключен — включается только при ENABLE_JINA_FALLBACK=1.
+ENABLE_JINA_FALLBACK = os.getenv("ENABLE_JINA_FALLBACK", "0") == "1"
+
+# Общий бюджет времени на весь запрос. По истечении возвращаем то, что успели
+# обработать, а остальное помечаем как «превышено время» — вместо того, чтобы
+# мини-приложение отвалилось по таймауту целиком.
+TOTAL_TIME_BUDGET = float(os.getenv("TOTAL_TIME_BUDGET", "25"))
+
+# Предохранитель от слишком больших списков. Лишнее отрезаем с пометкой.
+MAX_INPUT_LINKS = int(os.getenv("MAX_INPUT_LINKS", "1200"))
 
 app = FastAPI(title=APP_NAME)
 
@@ -53,10 +64,30 @@ app.add_middleware(
     allow_origins=["*"],
     allow_credentials=False,
     allow_methods=["POST", "GET", "OPTIONS"],
-    allow_headers=["*"]
+    allow_headers=["*"],
 )
 
 
+# ---------- HTTP-сессии с переиспользованием соединений ----------
+# Отдельная сессия на поток (потокобезопасно) + пул соединений, чтобы не
+# открывать TCP/TLS заново на каждую ссылку.
+_thread_local = threading.local()
+
+
+def _get_session() -> requests.Session:
+    sess = getattr(_thread_local, "session", None)
+    if sess is None:
+        sess = requests.Session()
+        adapter = requests.adapters.HTTPAdapter(
+            pool_connections=4, pool_maxsize=4, max_retries=0
+        )
+        sess.mount("http://", adapter)
+        sess.mount("https://", adapter)
+        sess.headers.update({"User-Agent": "Mozilla/5.0"})
+        _thread_local.session = sess
+    return sess
+
+
 class ParseRequest(BaseModel):
     links: Union[List[str], str]
 
@@ -67,6 +98,7 @@ class ParseResponse(BaseModel):
     telegram_total: int
     vk_total: int
     errors: List[str]
+    max_count: int = 0  # число ссылок MAX (просмотры из MAX недоступны)
 
 
 # ---------- Вспомогательные функции ----------
@@ -89,6 +121,16 @@ def clean_telegram_title(raw: str, fallback: str) -> str:
     title = re.sub(r"\s+", " ", title).strip()
     return title or fallback
 
+
+def clean_max_title(raw: str, fallback: str) -> str:
+    title = re.sub(r"<[^>]+>", "", (raw or "").strip())
+    title = html_lib.unescape(title)
+    # убираем хвосты вида " — MAX", " | MAX", " - MAX"
+    title = re.sub(r"\s*[-—|·]\s*MAX\s*$", "", title, flags=re.IGNORECASE)
+    title = re.sub(r"\s+", " ", title).strip()
+    return title or fallback
+
+
 def human_format_views(num: int) -> str:
     if num >= 1_000_000:
         value = num / 1_000_000
@@ -106,16 +148,34 @@ def human_format_views(num: int) -> str:
     return formatted.replace(".", ",")
 
 
+def _parse_views_number(raw: str) -> int:
+    if not raw:
+        return 0
+    normalized = raw.strip().replace("\u00a0", "").replace(" ", "").replace(",", ".")
+    match = re.match(r"([\d\.]+)\s*([kKmM]?)", normalized)
+    if not match:
+        return 0
+    value = float(match.group(1))
+    suffix = match.group(2).lower()
+    if suffix == "k":
+        value *= 1_000
+    elif suffix == "m":
+        value *= 1_000_000
+    return int(value)
+
+
 def detect_platform(link: str) -> str:
     link = link.strip().lower()
     if "t.me/" in link or "telegram.me/" in link:
         return "telegram"
     if "vk.com/wall" in link or "vk.ru/wall" in link:
         return "vk"
+    if "max.ru/" in link:
+        return "max"
     return ""
 
 
-def canonicalize_tg_link(link: str) -> Tuple[str | None, str | None, str | None]:
+def canonicalize_tg_link(link: str) -> Tuple[Optional[str], Optional[str], Optional[str]]:
     link = link.strip()
     private_match = re.match(r"https?://(?:t(?:elegram)?\.me)/c/(\d+)/(\d+)", link, re.IGNORECASE)
     if private_match:
@@ -129,7 +189,7 @@ def canonicalize_tg_link(link: str) -> Tuple[str | None, str | None, str | None]
     return canonical, username, message_id
 
 
-def canonicalize_vk_link(link: str) -> Tuple[str | None, int | None, str | None]:
+def canonicalize_vk_link(link: str) -> Tuple[Optional[str], Optional[int], Optional[str]]:
     link = link.strip()
     m = re.search(r"(?:vk\.com|vk\.ru)/wall(-?\d+)_(\d+)", link)
     if not m:
@@ -140,6 +200,17 @@ def canonicalize_vk_link(link: str) -> Tuple[str | None, int | None, str | None]
     return canonical, owner_id, post_id
 
 
+def canonicalize_max_link(link: str) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+    link = link.strip()
+    m = re.match(r"https?://(?:[\w-]+\.)?max\.ru/([^/?#]+)/([^/?#]+)", link, re.IGNORECASE)
+    if not m:
+        return None, None, None
+    slug = m.group(1)
+    post_id = m.group(2)
+    canonical = f"https://max.ru/{slug}/{post_id}"
+    return canonical, slug, post_id
+
+
 def _telethon_ready() -> bool:
     return bool(
         TelegramClient
@@ -150,125 +221,112 @@ def _telethon_ready() -> bool:
     )
 
 
-def process_telegram_batch(batch_items: List[Tuple[str, str, str]]) -> dict[str, Tuple[str, int]]:
-    if not batch_items:
-        return {}
-    results: dict[str, Tuple[str, int]] = {}
-    worker_count = max(1, min(8, len(batch_items)))
-
-    def _resolve(item: Tuple[str, str, str]) -> Tuple[str, Tuple[str, int]]:
-        canonical, username, message_id = item
-        return canonical, process_telegram_link(username, message_id, canonical)
-
-    with ThreadPoolExecutor(max_workers=worker_count) as executor:
-        for canonical, result in executor.map(_resolve, batch_items):
-            results[canonical] = result
-
-    return results
-
+# ---------- Обработчики одной ссылки ----------
 
 def process_telegram_link(channel_username: str, message_id: str, canonical_link: str) -> Tuple[str, int]:
-    urls = [
+    primary_urls = [
         f"https://t.me/{channel_username}/{message_id}?embed=1",
         f"https://t.me/s/{channel_username}/{message_id}",
-        f"https://telegram.me/{channel_username}/{message_id}?embed=1",
-        f"https://r.jina.ai/http://t.me/{channel_username}/{message_id}?embed=1",
-        f"https://r.jina.ai/http://t.me/s/{channel_username}/{message_id}",
-        f"https://r.jina.ai/http://telegram.me/{channel_username}/{message_id}?embed=1",
     ]
-    headers = {"User-Agent": "Mozilla/5.0"}
-
-    def _parse_views_number(raw: str) -> int:
-        if not raw:
-            return 0
-        normalized = raw.strip().replace("\u00a0", "").replace(" ", "").replace(",", ".")
-        match = re.match(r"([\d\.]+)\s*([kKmM]?)", normalized)
-        if not match:
-            return 0
-        value = float(match.group(1))
-        suffix = match.group(2).lower()
-        if suffix == "k":
-            value *= 1_000
-        elif suffix == "m":
-            value *= 1_000_000
-        return int(value)
-
-    def _fetch_first_ok(url_list: List[str]) -> str:
-        last_err = None
-        for url in url_list:
-            try:
-                resp = requests.get(url, headers=headers, timeout=REQUEST_TIMEOUT)
-                if resp.status_code == 200 and resp.text:
-                    return resp.text
-            except Exception as exc:
-                last_err = exc
-        raise last_err or Exception("Не удалось получить страницу Telegram")
+    fallback_urls = []
+    if ENABLE_JINA_FALLBACK:
+        fallback_urls = [
+            f"https://r.jina.ai/https://t.me/{channel_username}/{message_id}?embed=1",
+        ]
+
+    session = _get_session()
+    page_html = None
+    last_err: Optional[Exception] = None
+    for url in primary_urls + fallback_urls:
+        try:
+            resp = session.get(url, timeout=TG_HTTP_TIMEOUT)
+            if resp.status_code == 200 and resp.text:
+                page_html = resp.text
+                break
+        except Exception as exc:  # noqa: BLE001
+            last_err = exc
 
-    try:
-        page_html = _fetch_first_ok(urls)
+    if page_html is None:
+        return f"Ошибка (TG) при обработке {canonical_link}: {last_err or 'нет ответа'}", 0
 
-        title = None
-        meta_title = re.search(
-            r"<meta[^>]*property=[\"']og:title[\"'][^>]*content=[\"']([^\"']+)[\"']",
+    title = None
+    meta_title = re.search(
+        r"<meta[^>]*property=[\"']og:title[\"'][^>]*content=[\"']([^\"']+)[\"']",
+        page_html,
+        re.IGNORECASE,
+    )
+    if meta_title:
+        title = meta_title.group(1).strip()
+    if not title:
+        owner_title = re.search(
+            r'class="tgme_widget_message_owner_name".*?<span[^>]*>(.*?)</span>',
             page_html,
-            re.IGNORECASE,
+            re.IGNORECASE | re.DOTALL,
         )
-        if meta_title:
-            title = meta_title.group(1).strip()
-        if not title:
-            owner_title = re.search(
-                r'class="tgme_widget_message_owner_name".*?<span[^>]*>(.*?)</span>',
-                page_html,
-                re.IGNORECASE | re.DOTALL,
-            )
-            if owner_title:
-                title = owner_title.group(1).strip()
-        title = clean_telegram_title(title or "", channel_username)
-
-        views = 0
-        widget_views = re.search(
-            r'class="tgme_widget_message_views[^"]*">([\d\s\.,kKmM]+)<',
+        if owner_title:
+            title = owner_title.group(1).strip()
+    title = clean_telegram_title(title or "", channel_username)
+
+    views = 0
+    widget_views = re.search(
+        r'class="tgme_widget_message_views[^"]*">([\d\s\.,kKmM]+)<',
+        page_html,
+        re.IGNORECASE,
+    )
+    if widget_views:
+        views = _parse_views_number(widget_views.group(1))
+    else:
+        candidates = re.findall(
+            r"(\d[\d\s\.,]*)([kKmM]?)\s*(?:views|просмотр|просмотра|просмотров|переглядів|visualizações|visualizzazioni|ansichten|visninger|visitas)",
             page_html,
             re.IGNORECASE,
         )
-        if widget_views:
-            views = _parse_views_number(widget_views.group(1))
-        else:
-            candidates = re.findall(
-                r"(\d[\d\s\.,]*)([kKmM]?)\s*(?:views|просмотр|просмотра|просмотров|переглядів|visualizações|visualizzazioni|ansichten|visninger|visitas)?",
+        if candidates:
+            last_num, last_suffix = candidates[-1]
+            views = _parse_views_number(last_num + last_suffix)
+
+    return title, views
+
+
+def process_max_link(slug: str, post_id: str, canonical_link: str) -> Tuple[str, None]:
+    """MAX: подхватываем название канала из страницы поста.
+    Просмотры из MAX недоступны, поэтому всегда возвращаем None."""
+    title = slug
+    try:
+        session = _get_session()
+        resp = session.get(canonical_link, timeout=MAX_HTTP_TIMEOUT)
+        if resp.status_code == 200 and resp.text:
+            page_html = resp.text
+            m = re.search(
+                r"<meta[^>]*property=[\"']og:title[\"'][^>]*content=[\"']([^\"']+)[\"']",
                 page_html,
                 re.IGNORECASE,
             )
-            if candidates:
-                last_num, last_suffix = candidates[-1]
-                views = _parse_views_number(last_num + last_suffix)
-
-        return title, views
-    except Exception as exc:
-        return f"Ошибка (TG) при обработке {canonical_link}: {exc}", 0
+            if not m:
+                m = re.search(r"<title[^>]*>(.*?)</title>", page_html, re.IGNORECASE | re.DOTALL)
+            if m:
+                title = clean_max_title(m.group(1), slug)
+    except Exception:  # noqa: BLE001
+        title = slug  # тихо откатываемся к слагу из URL
+    return title or slug, None
 
 
 def process_vk_link(owner_id: int, post_id: str, canonical_link: str) -> Tuple[str, int]:
+    """Одиночный запрос к VK (запасной путь; основной — батч process_vk_batch)."""
     posts_param = f"{owner_id}_{post_id}"
     api_url = "https://api.vk.com/method/wall.getById"
 
+    data = None
     for attempt in range(1, VK_MAX_RETRIES + 1):
-        params = {
-            "posts": posts_param,
-            "v": VK_API_VERSION,
-            "extended": 1,
-        }
+        params = {"posts": posts_param, "v": VK_API_VERSION, "extended": 1}
         if VK_ACCESS_TOKEN:
             params["access_token"] = VK_ACCESS_TOKEN
-
         try:
             resp = requests.get(api_url, params=params, timeout=REQUEST_TIMEOUT)
-        except Exception as exc:
+        except Exception as exc:  # noqa: BLE001
             return f"**Ошибка (VK)**: {exc} — {canonical_link}", 0
-
         if resp.status_code != 200:
             return f"**Ошибка (VK)**: HTTP {resp.status_code} — {canonical_link}", 0
-
         data = resp.json()
         if "error" in data:
             error = data["error"]
@@ -282,7 +340,7 @@ def process_vk_link(owner_id: int, post_id: str, canonical_link: str) -> Tuple[s
     else:
         return f"**Ошибка (VK)**: Too many requests per second — {canonical_link}", 0
 
-    response_data = data.get("response", {})
+    response_data = (data or {}).get("response", {})
     items = response_data.get("items", [])
     if not items:
         return f"**Ошибка (VK)**: пост не найден — {canonical_link}", 0
@@ -299,47 +357,31 @@ def process_vk_link(owner_id: int, post_id: str, canonical_link: str) -> Tuple[s
                 title = group.get("name")
                 break
     else:
-        user_id = post_owner_id
         for profile in response_data.get("profiles", []):
-            if profile.get("id") == user_id:
-                first_name = profile.get("first_name", "")
-                last_name = profile.get("last_name", "")
-                title = (first_name + " " + last_name).strip()
+            if profile.get("id") == post_owner_id:
+                title = (profile.get("first_name", "") + " " + profile.get("last_name", "")).strip()
                 break
     if not title:
         title = "VK пост"
-
     return title, views
 
 
-def process_vk_batch(
-    batch_items: List[Tuple[str, int, str]]
-) -> dict[str, Tuple[str, int]]:
+def process_vk_batch(batch_items: List[Tuple[str, int, str]]) -> dict:
     api_url = "https://api.vk.com/method/wall.getById"
     posts = ",".join(f"{owner_id}_{post_id}" for _, owner_id, post_id in batch_items)
 
+    data = None
     for attempt in range(1, VK_MAX_RETRIES + 1):
-        params = {
-            "posts": posts,
-            "v": VK_API_VERSION,
-            "extended": 1,
-        }
+        params = {"posts": posts, "v": VK_API_VERSION, "extended": 1}
         if VK_ACCESS_TOKEN:
             params["access_token"] = VK_ACCESS_TOKEN
-
         try:
             resp = requests.get(api_url, params=params, timeout=REQUEST_TIMEOUT)
-        except Exception as exc:
-            return {
-                canonical: (f"**Ошибка (VK)**: {exc} — {canonical}", 0)
-                for canonical, _, _ in batch_items
-            }
+        except Exception as exc:  # noqa: BLE001
+            return {c: (f"**Ошибка (VK)**: {exc} — {c}", 0) for c, _, _ in batch_items}
 
         if resp.status_code != 200:
-            return {
-                canonical: (f"**Ошибка (VK)**: HTTP {resp.status_code} — {canonical}", 0)
-                for canonical, _, _ in batch_items
-            }
+            return {c: (f"**Ошибка (VK)**: HTTP {resp.status_code} — {c}", 0) for c, _, _ in batch_items}
 
         data = resp.json()
         if "error" in data:
@@ -349,18 +391,12 @@ def process_vk_batch(
             if error_code == 6 or "too many requests per second" in error_msg.lower():
                 time.sleep(VK_RETRY_DELAY * attempt)
                 continue
-            return {
-                canonical: (f"**Ошибка (VK)**: {error_msg or 'API error'} — {canonical}", 0)
-                for canonical, _, _ in batch_items
-            }
+            return {c: (f"**Ошибка (VK)**: {error_msg or 'API error'} — {c}", 0) for c, _, _ in batch_items}
         break
     else:
-        return {
-            canonical: (f"**Ошибка (VK)**: Too many requests per second — {canonical}", 0)
-            for canonical, _, _ in batch_items
-        }
+        return {c: (f"**Ошибка (VK)**: Too many requests per second — {c}", 0) for c, _, _ in batch_items}
 
-    response_data = data.get("response", {})
+    response_data = (data or {}).get("response", {})
     items = response_data.get("items", [])
     groups = {group.get("id"): group for group in response_data.get("groups", [])}
     profiles = {profile.get("id"): profile for profile in response_data.get("profiles", [])}
@@ -370,7 +406,7 @@ def process_vk_batch(
         if item.get("owner_id") is not None and item.get("id") is not None
     }
 
-    result: dict[str, Tuple[str, int]] = {}
+    result: dict = {}
     for canonical, owner_id, post_id in batch_items:
         key = f"{owner_id}_{post_id}"
         post = item_map.get(key)
@@ -381,7 +417,6 @@ def process_vk_batch(
         views = post.get("views", {}).get("count", 0)
         post_owner_id = post.get("owner_id", owner_id)
         title = None
-
         if post_owner_id < 0:
             group = groups.get(-post_owner_id)
             if group:
@@ -389,15 +424,91 @@ def process_vk_batch(
         else:
             profile = profiles.get(post_owner_id)
             if profile:
-                first_name = profile.get("first_name", "")
-                last_name = profile.get("last_name", "")
-                title = (first_name + " " + last_name).strip()
+                title = (profile.get("first_name", "") + " " + profile.get("last_name", "")).strip()
 
         result[canonical] = (title or "VK пост", views)
 
     return result
 
 
+# ---------- Параллельное разрешение ссылок с бюджетом времени ----------
+
+def _resolve_pool(tasks, worker, max_workers, deadline, timeout_label, defaults=None):
+    """tasks: список (canonical, args_tuple). worker(*args) -> (title, views).
+    Возвращаем dict canonical -> (title, views). Незавершённые к дедлайну
+    помечаем timeout_label (или оставляем значение из defaults, если оно есть)."""
+    results = dict(defaults) if defaults else {}
+    if not tasks:
+        return results
+
+    workers = max(1, min(max_workers, len(tasks)))
+    ex = ThreadPoolExecutor(max_workers=workers)
+    fut_map = {ex.submit(worker, *args): canonical for canonical, args in tasks}
+
+    timeout = max(0.0, deadline - time.monotonic())
+    done, not_done = wait(list(fut_map.keys()), timeout=timeout)
+
+    for fut in done:
+        canonical = fut_map[fut]
+        try:
+            results[canonical] = fut.result()
+        except Exception as exc:  # noqa: BLE001
+            if canonical not in results:
+                results[canonical] = (f"Ошибка при обработке {canonical}: {exc}", 0)
+
+    for fut in not_done:
+        canonical = fut_map[fut]
+        fut.cancel()
+        if canonical not in results:
+            results[canonical] = (timeout_label, 0)
+
+    # Не блокируемся на «зависших» запросах — отдаём управление сразу.
+    try:
+        ex.shutdown(wait=False, cancel_futures=True)
+    except TypeError:  # Python < 3.9
+        ex.shutdown(wait=False)
+
+    return results
+
+
+def resolve_telegram(tg_tasks, deadline):
+    # tg_tasks: список (canonical, username, message_id)
+    tasks = [(c, (u, mid, c)) for (c, u, mid) in tg_tasks if u and mid]
+    return _resolve_pool(
+        tasks,
+        process_telegram_link,
+        TELEGRAM_CONCURRENCY,
+        deadline,
+        "Ошибка (TG): превышено время обработки",
+    )
+
+
+def resolve_max(max_tasks, deadline):
+    # max_tasks: список (canonical, slug, post_id)
+    defaults = {c: (slug, None) for (c, slug, _post) in max_tasks}
+    tasks = [(c, (slug, post_id, c)) for (c, slug, post_id) in max_tasks]
+    fetched = _resolve_pool(
+        tasks, process_max_link, MAX_CONCURRENCY, deadline, None, defaults=defaults
+    )
+    # просмотры из MAX недоступны всегда
+    return {c: (t, None) for c, (t, _v) in fetched.items()}
+
+
+def resolve_vk(vk_tasks, deadline):
+    # vk_tasks: список (canonical, owner_id, post_id)
+    results = {}
+    valid = [(c, o, p) for (c, o, p) in vk_tasks if o is not None and p is not None]
+    batch_size = max(1, VK_BATCH_SIZE)
+    for start in range(0, len(valid), batch_size):
+        if time.monotonic() > deadline:
+            for c, _, _ in valid[start:]:
+                results[c] = ("**Ошибка (VK)**: превышено время обработки", 0)
+            break
+        chunk = valid[start:start + batch_size]
+        results.update(process_vk_batch(chunk))
+    return results
+
+
 def normalize_links(links: Union[List[str], str]) -> List[str]:
     if isinstance(links, str):
         raw = links.splitlines()
@@ -411,35 +522,78 @@ def normalize_links(links: Union[List[str], str]) -> List[str]:
 def _escape(text: str) -> str:
     return html_lib.escape(text, quote=True)
 
-def build_output(lines: List[Tuple[str, str, object, object]]) -> Tuple[str, str, int, int, List[str]]:
+
+def _fmt_views(v) -> str:
+    return "—" if v is None else human_format_views(v)
+
+
+def _render_groups(groups, has_views, default_title):
+    """Сортируем группы и рендерим в HTML (<ol>) и текст. Возвращаем (html_str, text_lines)."""
+    if has_views:
+        ordered = sorted(
+            groups.items(),
+            key=lambda kv: sum((v or 0) for _, v in kv[1]["items"]),
+            reverse=True,
+        )
+    else:
+        ordered = sorted(groups.items(), key=lambda kv: (kv[1]["title"] or "").lower())
+
+    html_lines = ["<ol>"]
+    text_lines: List[str] = []
+    for idx, (_, data) in enumerate(ordered, start=1):
+        title = data["title"] or default_title
+        items = data["items"]
+        first_link, _first_views = items[0]
+
+        line_html = f'<li><a href="{_escape(first_link)}">{_escape(title)}</a>'
+        if len(items) > 1:
+            for link2, _v in items[1:]:
+                line_html += f' + <a href="{_escape(link2)}">ещё</a>'
+
+        if has_views:
+            views_str = " + ".join(_fmt_views(v) for _, v in items)
+            line_html += f" — {views_str}</li>"
+        else:
+            line_html += " — </li>"
+        html_lines.append(line_html)
+
+        line_text = f"{idx}. {title} ({first_link})"
+        if len(items) > 1:
+            line_text += " + ещё: " + ", ".join(link2 for link2, _v in items[1:])
+        if has_views:
+            line_text += f" — {views_str}"
+        else:
+            line_text += " —"
+        text_lines.append(line_text)
+
+    html_lines.append("</ol>")
+    return "\n".join(html_lines), text_lines
+
+
+def build_output(lines, deadline):
     errors: List[str] = []
 
-    tg_groups = {}
-    vk_groups = {}
-
-    telegram_lines = [line for line in lines if line[0] == "telegram"]
-    vk_lines = [line for line in lines if line[0] == "vk"]
-    telegram_results = {}
-    vk_results = {}
-
-    if telegram_lines:
-        valid_telegram_batch: List[Tuple[str, str, str]] = []
-        for _, canonical, username, mid in telegram_lines:
-            if username and mid:
-                valid_telegram_batch.append((canonical, username, mid))
-        if valid_telegram_batch:
-            telegram_results = process_telegram_batch(valid_telegram_batch)
-
-    valid_vk_batch: List[Tuple[str, int, str]] = []
-    for _, canonical, owner_id, post_id in vk_lines:
-        if owner_id is not None and post_id is not None:
-            valid_vk_batch.append((canonical, owner_id, post_id))
-
-    if valid_vk_batch:
-        batch_size = max(1, VK_BATCH_SIZE)
-        for start in range(0, len(valid_vk_batch), batch_size):
-            chunk = valid_vk_batch[start:start + batch_size]
-            vk_results.update(process_vk_batch(chunk))
+    tg_lines = [ln for ln in lines if ln[0] == "telegram"]
+    vk_lines = [ln for ln in lines if ln[0] == "vk"]
+    max_lines = [ln for ln in lines if ln[0] == "max"]
+
+    tg_fetch = [(c, a, b) for _, c, a, b in tg_lines if a and b]
+    vk_fetch = [(c, a, b) for _, c, a, b in vk_lines if a is not None and b is not None]
+    max_fetch = [(c, a, b) for _, c, a, b in max_lines if a and b]
+
+    # Telegram, VK и MAX обрабатываем параллельно (раньше шли друг за другом).
+    tg_results, vk_results, max_results = {}, {}, {}
+    with ThreadPoolExecutor(max_workers=3) as top:
+        f_tg = top.submit(resolve_telegram, tg_fetch, deadline)
+        f_vk = top.submit(resolve_vk, vk_fetch, deadline)
+        f_max = top.submit(resolve_max, max_fetch, deadline)
+        tg_results = f_tg.result()
+        vk_results = f_vk.result()
+        max_results = f_max.result()
+
+    tg_groups: dict = {}
+    vk_groups: dict = {}
+    max_groups: dict = {}
 
     for plat, canonical, a, b in lines:
         if plat == "telegram":
@@ -447,16 +601,16 @@ def build_output(lines: List[Tuple[str, str, object, object]]) -> Tuple[str, str
             if not username or not mid:
                 key = canonical
                 invalid_title = "Ошибка (TG): ссылка Telegram недоступна для публичного парсинга"
-                if re.search(r"https?://(?:t(?:elegram)?\\.me)/c/\\d+/\\d+", canonical, re.IGNORECASE):
+                if re.search(r"https?://(?:t(?:elegram)?\.me)/c/\d+/\d+", canonical, re.IGNORECASE):
                     invalid_title = "Ошибка (TG): ссылки вида t.me/c/... не поддерживаются"
                 tg_groups.setdefault(key, {"title": invalid_title, "items": []})
                 tg_groups[key]["items"].append((canonical, 0))
             else:
-                title, views = telegram_results.get(canonical, (username, 0))
+                title, views = tg_results.get(canonical, (username, 0))
                 key = username
                 if key not in tg_groups:
                     tg_groups[key] = {"title": title, "items": []}
-                if not tg_groups[key].get("title") or str(tg_groups[key]["title"]).startswith("**Ошибка"):
+                if not tg_groups[key].get("title") or str(tg_groups[key]["title"]).startswith("Ошибка"):
                     tg_groups[key]["title"] = title
                 tg_groups[key]["items"].append((canonical, views))
 
@@ -467,29 +621,35 @@ def build_output(lines: List[Tuple[str, str, object, object]]) -> Tuple[str, str
                 vk_groups.setdefault(key, {"title": "VK пост", "items": []})
                 vk_groups[key]["items"].append((canonical, 0))
             else:
-                title, views = vk_results.get(canonical, process_vk_link(owner_id, post_id, canonical))
+                title, views = vk_results.get(canonical, (f"**Ошибка (VK)**: нет данных — {canonical}", 0))
                 key = str(owner_id)
                 if key not in vk_groups:
                     vk_groups[key] = {"title": title, "items": []}
                 if not vk_groups[key].get("title") or str(vk_groups[key]["title"]).startswith("**Ошибка"):
                     vk_groups[key]["title"] = title
                 vk_groups[key]["items"].append((canonical, views))
+
+        elif plat == "max":
+            slug, post_id = a, b
+            if not slug or not post_id:
+                key = canonical
+                max_groups.setdefault(key, {"title": "MAX", "items": []})
+                max_groups[key]["items"].append((canonical, None))
+            else:
+                title, _views = max_results.get(canonical, (slug, None))
+                key = slug
+                if key not in max_groups:
+                    max_groups[key] = {"title": title, "items": []}
+                if not max_groups[key].get("title"):
+                    max_groups[key]["title"] = title
+                max_groups[key]["items"].append((canonical, None))
+
         else:
             errors.append(f"Неизвестная платформа: {canonical}")
 
-    tg_total_views = sum(v for g in tg_groups.values() for _, v in g["items"])
-    vk_total_views = sum(v for g in vk_groups.values() for _, v in g["items"])
-
-    tg_sorted = sorted(
-        tg_groups.items(),
-        key=lambda kv: sum(v for _, v in kv[1]["items"]),
-        reverse=True,
-    )
-    vk_sorted = sorted(
-        vk_groups.items(),
-        key=lambda kv: sum(v for _, v in kv[1]["items"]),
-        reverse=True,
-    )
+    tg_total_views = sum(v for g in tg_groups.values() for _, v in g["items"] if v)
+    vk_total_views = sum(v for g in vk_groups.values() for _, v in g["items"] if v)
+    max_count = sum(len(g["items"]) for g in max_groups.values())
 
     html_lines: List[str] = []
     text_lines: List[str] = []
@@ -499,30 +659,10 @@ def build_output(lines: List[Tuple[str, str, object, object]]) -> Tuple[str, str
     html_lines.append(f'Суммарно посты собрали <b>{human_format_views(tg_total_views)}</b> просмотров.')
     text_lines.append("Telegram")
     text_lines.append(f"Суммарно посты собрали {human_format_views(tg_total_views)} просмотров.")
-    if tg_sorted:
-        html_lines.append("<ol>")
-        for idx, (_, data) in enumerate(tg_sorted, start=1):
-            title = data["title"] or "Telegram"
-            items = data["items"]
-            first_link, _first_views = items[0]
-
-            title_html = _escape(title)
-            first_link_html = _escape(first_link)
-            line_html = f'<li><a href="{first_link_html}">{title_html}</a>'
-            if len(items) > 1:
-                for link2, _v in items[1:]:
-                    line_html += f' + <a href="{_escape(link2)}">ещё</a>'
-            views_str = " + ".join(human_format_views(v) for _, v in items)
-            line_html += f" — {views_str}</li>"
-            html_lines.append(line_html)
-
-            line_text = f"{idx}. {title} ({first_link})"
-            if len(items) > 1:
-                extra_links = ", ".join(link2 for link2, _v in items[1:])
-                line_text += f" + ещё: {extra_links}"
-            line_text += f" — {views_str}"
-            text_lines.append(line_text)
-        html_lines.append("</ol>")
+    if tg_groups:
+        h, t = _render_groups(tg_groups, has_views=True, default_title="Telegram")
+        html_lines.append(h)
+        text_lines.extend(t)
     else:
         html_lines.append("<i>Нет ссылок на Telegram</i>")
         text_lines.append("Нет ссылок на Telegram")
@@ -534,36 +674,28 @@ def build_output(lines: List[Tuple[str, str, object, object]]) -> Tuple[str, str
     html_lines.append(f'Суммарно посты собрали <b>{human_format_views(vk_total_views)}</b> просмотров.')
     text_lines.append("ВКонтакте")
     text_lines.append(f"Суммарно посты собрали {human_format_views(vk_total_views)} просмотров.")
-    if vk_sorted:
-        html_lines.append("<ol>")
-        for idx, (_, data) in enumerate(vk_sorted, start=1):
-            title = data["title"] or "VK пост"
-            items = data["items"]
-            first_link, _first_views = items[0]
-
-            title_html = _escape(title)
-            first_link_html = _escape(first_link)
-            line_html = f'<li><a href="{first_link_html}">{title_html}</a>'
-            if len(items) > 1:
-                for link2, _v in items[1:]:
-                    line_html += f' + <a href="{_escape(link2)}">ещё</a>'
-            views_str = " + ".join(human_format_views(v) for _, v in items)
-            line_html += f" — {views_str}</li>"
-            html_lines.append(line_html)
-
-            line_text = f"{idx}. {title} ({first_link})"
-            if len(items) > 1:
-                extra_links = ", ".join(link2 for link2, _v in items[1:])
-                line_text += f" + ещё: {extra_links}"
-            line_text += f" — {views_str}"
-            text_lines.append(line_text)
-        html_lines.append("</ol>")
+    if vk_groups:
+        h, t = _render_groups(vk_groups, has_views=True, default_title="VK пост")
+        html_lines.append(h)
+        text_lines.extend(t)
     else:
         html_lines.append("<i>Нет ссылок на ВКонтакте</i>")
         text_lines.append("Нет ссылок на ВКонтакте")
     html_lines.append("<br/>")
     text_lines.append("")
 
+    # --- MAX (секцию показываем только если есть ссылки MAX) ---
+    if max_groups:
+        html_lines.append("<h2>MAX</h2>")
+        html_lines.append("<i>Просмотры из MAX недоступны.</i>")
+        text_lines.append("MAX")
+        text_lines.append("Просмотры из MAX недоступны.")
+        h, t = _render_groups(max_groups, has_views=False, default_title="MAX")
+        html_lines.append(h)
+        text_lines.extend(t)
+        html_lines.append("<br/>")
+        text_lines.append("")
+
     if errors:
         html_lines.append("<h2>Ошибки</h2>")
         html_lines.append("<ul>")
@@ -574,7 +706,14 @@ def build_output(lines: List[Tuple[str, str, object, object]]) -> Tuple[str, str
         html_lines.append("<br/>")
         text_lines.append("")
 
-    return "\n".join(html_lines), "\n".join(text_lines), tg_total_views, vk_total_views, errors
+    return (
+        "\n".join(html_lines),
+        "\n".join(text_lines),
+        tg_total_views,
+        vk_total_views,
+        errors,
+        max_count,
+    )
 
 
 @app.get("/health")
@@ -584,10 +723,17 @@ def health_check():
 
 @app.post("/parse", response_model=ParseResponse)
 def parse_links(payload: ParseRequest):
+    deadline = time.monotonic() + TOTAL_TIME_BUDGET
+
     raw_lines = normalize_links(payload.links)
     if not raw_lines:
         return ParseResponse(html="", text="", telegram_total=0, vk_total=0, errors=["Нет ссылок для обработки."])
 
+    truncated = False
+    if len(raw_lines) > MAX_INPUT_LINKS:
+        raw_lines = raw_lines[:MAX_INPUT_LINKS]
+        truncated = True
+
     seen = set()
     lines: List[Tuple[str, str, object, object]] = []
     for link in raw_lines:
@@ -595,9 +741,7 @@ def parse_links(payload: ParseRequest):
         if plat == "telegram":
             canonical, username, mid = canonicalize_tg_link(link)
             if not canonical:
-                canonical = link
-                username = None
-                mid = None
+                canonical, username, mid = link, None, None
             if canonical in seen:
                 continue
             seen.add(canonical)
@@ -610,14 +754,29 @@ def parse_links(payload: ParseRequest):
                 continue
             seen.add(canonical)
             lines.append(("vk", canonical, owner_id, post_id))
+        elif plat == "max":
+            canonical, slug, post_id = canonicalize_max_link(link)
+            if not canonical:
+                canonical, slug, post_id = link, None, None
+            if canonical in seen:
+                continue
+            seen.add(canonical)
+            lines.append(("max", canonical, slug, post_id))
         else:
             lines.append(("unknown", link, None, None))
 
-    html, text, tg_total, vk_total, errors = build_output(lines)
+    html, text, tg_total, vk_total, errors, max_count = build_output(lines, deadline)
+
+    if truncated:
+        note = f"Обработаны первые {MAX_INPUT_LINKS} ссылок (список был длиннее)."
+        errors = errors + [note]
+        text = text + ("\n" if text else "") + "- " + note
+
     return ParseResponse(
         html=html,
         text=text,
         telegram_total=tg_total,
         vk_total=vk_total,
         errors=errors,
+        max_count=max_count,
     )