Update app.py

app.py

@@ -1,6 +1,7 @@
 import os
 import re
 import gc
+import inspect
 from typing import List, Dict, Tuple, Iterable, Optional, Any
 
 import gradio as gr
@@ -53,7 +54,7 @@ def _load_encoder(name: str):
 
 
 def _load_seq2seq(name: str):
-    # критично для T5/MT5: use_fast=False
+    # критично для T5/MT5: use_fast=False (SentencePiece)
     tok = AutoTokenizer.from_pretrained(name, use_fast=False)
     model = AutoModelForSeq2SeqLM.from_pretrained(
         name,
@@ -68,7 +69,6 @@ print("Loading models...")
 emb_tok, emb_model = _load_encoder(EMB_MODEL_NAME)
 gen_tok, gen_model = _load_seq2seq(PRIMARY_GEN_MODEL)
 
-# fallback лениво (экономия памяти)
 fb_tok = None
 fb_model = None
 print("Models loaded.")
@@ -272,7 +272,6 @@ def _ensure_embeddings_size(tokenizer, model, required_size: int):
     cur = int(emb.num_embeddings)
     if required_size > cur:
         model.resize_token_embeddings(required_size)
-        # на всякий случай вернём на нужное устройство после ресайза
         model.to(DEVICE)
 
 
@@ -289,17 +288,13 @@ def seq2seq_generate(tokenizer, model, prompt: str, max_new_tokens: int = 220, m
         max_length=max_input_tokens,
     )
 
-    # ВАЖНО: before .to(DEVICE) можно посчитать max_id на CPU
     input_ids = batch["input_ids"]
     max_id = int(input_ids.max().item()) if input_ids.numel() else 0
     needed = max(int(len(tokenizer)), max_id + 1)
-
     _ensure_embeddings_size(tokenizer, model, needed)
 
-    # После возможного resize — переносим на устройство
     batch = {k: v.to(DEVICE) for k, v in batch.items()}
 
-    # Доп. страховка: если по какой-то причине всё ещё OOR — зажмём
     emb_size = int(model.get_input_embeddings().num_embeddings)
     if int(batch["input_ids"].max().item()) >= emb_size:
         batch["input_ids"] = batch["input_ids"].clamp_max(emb_size - 1)
@@ -314,7 +309,6 @@ def seq2seq_generate(tokenizer, model, prompt: str, max_new_tokens: int = 220, m
             early_stopping=True,
         )
     except IndexError:
-        # retry: синхронизируем по len(tokenizer) и повторяем
         _ensure_embeddings_size(tokenizer, model, int(len(tokenizer)))
         out_ids = model.generate(
             **batch,
@@ -479,22 +473,42 @@ def generate_questions(difficulty: str, num_q: int, state: Dict[str, Any]) -> st
 
 
 # =======================
-# ЧАТ
+# ЧАТ (messages)
 # =======================
-def chat_answer(message: str, chat_history: List[Tuple[str, str]], state: Dict[str, Any]):
+def _append_messages(history: Any, user_text: str, assistant_text: str) -> List[Dict[str, str]]:
+    if not history:
+        history = []
+    # если вдруг пришли tuples — конвертируем
+    if isinstance(history, list) and history and isinstance(history[0], (tuple, list)) and len(history[0]) == 2:
+        msgs: List[Dict[str, str]] = []
+        for u, a in history:
+            msgs.append({"role": "user", "content": str(u)})
+            msgs.append({"role": "assistant", "content": str(a)})
+        history = msgs
+    # если уже messages
+    if isinstance(history, list) and (not history or isinstance(history[0], dict)):
+        history = list(history)
+        history.append({"role": "user", "content": user_text})
+        history.append({"role": "assistant", "content": assistant_text})
+        return history
+    # fallback
+    return [{"role": "user", "content": user_text}, {"role": "assistant", "content": assistant_text}]
+
+
+def chat_answer(message: str, chat_history: List[Dict[str, str]], state: Dict[str, Any]):
     q = (message or "").strip()
     if not q:
         return chat_history, ""
 
     if not state or not state.get("chunks") or state.get("embeddings") is None:
-        return chat_history + [(q, "Сначала загрузите документ.")], ""
+        return _append_messages(chat_history, q, "Сначала загрузите документ."), ""
 
     chunks: List[str] = state["chunks"]
     emb: np.ndarray = state["embeddings"]
 
     top_idx, best_sim = retrieve_topk(q, emb, top_k=4)
     if best_sim < RETRIEVE_MIN_SIM:
-        return chat_history + [(q, "В документе нет информации для ответа на этот вопрос.")], ""
+        return _append_messages(chat_history, q, "В документе нет информации для ответа на этот вопрос."), ""
 
     ctx_idx = []
     for i in top_idx:
@@ -520,7 +534,7 @@ def chat_answer(message: str, chat_history: List[Tuple[str, str]], state: Dict[s
         a = "В документе нет информации для ответа на этот вопрос."
 
     cleanup_memory()
-    return chat_history + [(q, a)], ""
+    return _append_messages(chat_history, q, a), ""
 
 
 def clear_chat():
@@ -631,7 +645,7 @@ with gr.Blocks(title="EduMultiSpace") as demo:
         q_btn.click(generate_questions, inputs=[diff, n_q, state], outputs=[q_out])
 
     with gr.Tab("Чат"):
-        chat = gr.Chatbot(label="Чат")
+        chat = gr.Chatbot(label="Чат", type="messages")
         msg = gr.Textbox(lines=2, label="Вопрос")
         send = gr.Button("Отправить")
         clear = gr.Button("Очистить")
@@ -640,6 +654,33 @@ with gr.Blocks(title="EduMultiSpace") as demo:
         clear.click(clear_chat, inputs=None, outputs=[chat, msg])
 
 
+def _launch_compat(app: gr.Blocks):
+    """
+    Совместимо с разными версиями gradio:
+    - где есть concurrency_count
+    - где есть concurrency_limit / default_concurrency_limit
+    - где queue() без этих параметров
+    """
+    q_params = inspect.signature(app.queue).parameters
+    kwargs = {}
+
+    if "max_size" in q_params:
+        kwargs["max_size"] = 16
+
+    # разные версии gradio используют разные имена
+    if "concurrency_count" in q_params:
+        kwargs["concurrency_count"] = 1
+    elif "concurrency_limit" in q_params:
+        kwargs["concurrency_limit"] = 1
+    elif "default_concurrency_limit" in q_params:
+        kwargs["default_concurrency_limit"] = 1
+
+    try:
+        app.queue(**kwargs).launch()
+    except TypeError:
+        # если queue() совсем другой — просто launch()
+        app.launch()
+
+
 if __name__ == "__main__":
-    # чтобы не было параллельных генераций, которые могут раздувать память на Spaces
-    demo.queue(concurrency_count=1, max_size=16).launch()
+    _launch_compat(demo)