Update app.py

app.py

@@ -1,268 +1,121 @@
-# ---------------------------------------------------------------
-#  app.py
-#  Hugging Face Space – OpenRouter Chat (Gradio + Telegram)
-# ---------------------------------------------------------------
+"""
+OpenRouter Chatbot – elenco dinamico completo
+Run: gradio app.py
+"""
+
 import os
 import functools
-import threading
 import requests
 import gradio as gr
-from telegram import (
-    Update,
-    InlineKeyboardButton,
-    InlineKeyboardMarkup,
-)
-from telegram.ext import (
-    ApplicationBuilder,
-    CommandHandler,
-    MessageHandler,
-    filters,
-    ContextTypes,
-    CallbackQueryHandler,
-)
 
-# ----------------------------------------------------------------
-# 1.  Secrets (set them in HF Space → Settings → Repository secrets)
-# ----------------------------------------------------------------
-OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
-TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
+# ------------------------------------------------------------------
+# Configurazione
+# ------------------------------------------------------------------
+OPENROUTER_API_KEY = os.getenv(
+    "OPENROUTER_API_KEY",
+    "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"
+)
 
-# ----------------------------------------------------------------
-# 2.  Fetch & group models (cached at start-up)
-# ----------------------------------------------------------------
+# ------------------------------------------------------------------
+# Utility per ottenere l’elenco modelli
+# ------------------------------------------------------------------
 @functools.lru_cache(maxsize=1)
-def fetch_models_grouped():
+def fetch_models() -> list[str]:
+    """
+    Restituisce la lista completa di modelli offerti da OpenRouter.
+    Il decorator @lru_cache la memorizza in cache per tutta la durata
+    del processo (si aggiorna solo al riavvio del container).
+    """
     headers = {"Authorization": f"Bearer {OPENROUTER_API_KEY}"}
     try:
-        resp = requests.get("https://openrouter.ai/api/v1/models", headers=headers, timeout=15)
+        resp = requests.get(
+            "https://openrouter.ai/api/v1/models",
+            headers=headers,
+            timeout=15
+        )
         resp.raise_for_status()
         data = resp.json()
+        models = sorted(m["id"] for m in data["data"])
+        return models
     except Exception as e:
-        print("⚠️  Could not fetch models – using fallbacks:", e)
-        return {
-            "reasoning": ["openai/gpt-4-turbo"],
-            "casual": ["meta-llama/llama-3.2-3b-instruct"],
-        }
-
-    reasoning, casual = [], []
-    for m in data["data"]:
-        mid = m["id"].lower()
-        if any(k in mid for k in ["gpt", "claude", "gemini", "qwen", "mistral", "llama"]):
-            reasoning.append(m["id"])
-        else:
-            casual.append(m["id"])
-    return {"reasoning": sorted(reasoning), "casual": sorted(casual)}
-
-# ----------------------------------------------------------------
-# 3.  Format helpers
-# ----------------------------------------------------------------
-def format_history(history):
-    lines = []
-    for msg in history:
-        role = "Tu" if msg["role"] == "user" else "Assistente"
-        lines.append(f"{role}:\n{msg['content']}\n")
-    return "\n".join(lines).strip()
+        gr.Warning(f"Impossibile scaricare l’elenco modelli: {e}")
+        return ["openai/gpt-4-turbo"]  # fallback statico
 
-# ----------------------------------------------------------------
-# 4.  Core chat engine
-# ----------------------------------------------------------------
-def chat_with_openrouter(prompt: str, model: str, history: list):
-    if not model:
-        history.append({"role": "assistant", "content": "⚠️ Seleziona un modello prima di inviare."})
-        return history, format_history(history)
-
-    history.append({"role": "user", "content": prompt})
-    payload = {"model": model, "messages": history, "max_tokens": 4096, "temperature": 0.7}
+# ------------------------------------------------------------------
+# Funzione di chiamata al modello
+# ------------------------------------------------------------------
+def chat_with_openrouter(prompt: str, model: str):
     headers = {
         "Authorization": f"Bearer {OPENROUTER_API_KEY}",
-        "Content-Type": "application/json",
+        "Content-Type": "application/json"
+    }
+
+    payload = {
+        "model": model,
+        "messages": [{"role": "user", "content": prompt}],
+        "max_tokens": 4096,
+        "temperature": 0.7,
     }
 
     try:
-        r = requests.post(
+        resp = requests.post(
             "https://openrouter.ai/api/v1/chat/completions",
             headers=headers,
             json=payload,
-            timeout=60,
+            timeout=60
         )
-        r.raise_for_status()
-        reply = r.json()["choices"][0]["message"]["content"]
+        resp.raise_for_status()
+        return resp.json()["choices"][0]["message"]["content"]
     except Exception as e:
-        reply = f"❌ Errore: {e}"
-
-    history.append({"role": "assistant", "content": reply})
-    return history, format_history(history)
+        return f"❌ Errore: {e}"
 
-# ----------------------------------------------------------------
-# 5.  Gradio interface
-# ----------------------------------------------------------------
+# ------------------------------------------------------------------
+# Interfaccia Gradio
+# ------------------------------------------------------------------
 def build_interface():
-    grouped = fetch_models_grouped()
-    default_model = grouped["reasoning"][0] if grouped["reasoning"] else ""
-
-    with gr.Blocks(title="NOT EXIST Chat – Space") as demo:
-        gr.Markdown("## 🤖 Open Source models Chatbot (HF Space edition)")
-
-        saved_chats = gr.State({})
-        current_name = gr.State("Chat #1")
-        history = gr.State([])
+    models = fetch_models()
 
+    with gr.Blocks(title="NotExistChatter – Tutti i modelli") as demo:
+        gr.Markdown("🤖project Adam🤖")
+        gr.Markdown("Il menù mostra **tutti** i modelli disponibili.")
         with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### 💬 Storico")
-                chat_selector = gr.Radio(choices=[], label="Salvate")
-                load_btn = gr.Button("📂 Carica")
-                new_btn = gr.Button("🆕 Nuova")
-                save_name = gr.Textbox(label="Nome", placeholder="es. brainstorming")
-                save_btn = gr.Button("💾 Salva")
-
-            with gr.Column(scale=4):
-                reasoning_dd = gr.Dropdown(
-                    choices=grouped["reasoning"], label="🧠 Reasoning", value=default_model
-                )
-                casual_dd = gr.Dropdown(
-                    choices=grouped["casual"], label="⚡ Casual"
-                )
-                output = gr.Textbox(label="Conversazione", lines=20, interactive=False)
-                prompt = gr.Textbox(label="Prompt", lines=3, placeholder="Scrivi qui...")
-                send_btn = gr.Button("📤 Invia")          # <--- ADDED
-
-        # --- wiring -------------------------------------------------
-        def resolve(prompt, r, c, hist):
-            model = r or c
-            return chat_with_openrouter(prompt, model, hist)
-
-        def new_chat():
-            return [], "", f"Chat #{os.urandom(2).hex()}", gr.update(choices=[])
-
-        def save_fn(chats, name, hist):
-            if not name:
-                return chats, gr.update(), "⚠️ Inserisci un nome"
-            chats[name] = hist.copy()
-            return chats, gr.update(choices=list(chats.keys())), f"✅ Salvata '{name}'"
-
-        def load_fn(chats, sel):
-            return (chats[sel], format_history(chats[sel]), sel) if sel in chats else ([], "", "⚠️ Seleziona chat")
-
-        # Gradio events
-        send_btn.click(                                   # <--- NEW EVENT
-            fn=resolve,
-            inputs=[prompt, reasoning_dd, casual_dd, history],
-            outputs=[history, output],
-            queue=False,
-        )
-        prompt.submit(
-            fn=resolve,
-            inputs=[prompt, reasoning_dd, casual_dd, history],
-            outputs=[history, output],
-            queue=False,
-        )
-        save_btn.click(
-            fn=save_fn,
-            inputs=[saved_chats, save_name, history],
-            outputs=[saved_chats, chat_selector, output],
-            queue=False,
-        )
-        load_btn.click(
-            fn=load_fn,
-            inputs=[saved_chats, chat_selector],
-            outputs=[history, output, current_name],
-            queue=False,
+            model_dropdown = gr.Dropdown(
+                choices=models,
+                value=models[0] if models else None,
+                label="Modello",
+                allow_custom_value=False,
+                interactive=True
+            )
+
+        prompt_box = gr.Textbox(
+            label="Prompt",
+            placeholder="Scrivi qui il tuo messaggio...",
+            lines=4,
+            max_lines=10
         )
-        new_btn.click(
-            fn=new_chat,
-            outputs=[history, output, current_name, chat_selector],
-            queue=False,
-        )
-
-    return demo
-
-# ----------------------------------------------------------------
-# 6.  Telegram bot (background)
-# ----------------------------------------------------------------
-telegram_states = {}
 
-def tg_model_menu():
-    grouped = fetch_models_grouped()
-    buttons = [
-        [InlineKeyboardButton("🧠 Reasoning", callback_data="reasoning")],
-        *[InlineKeyboardButton(m[:40], callback_data=f"model:{m}")
-          for m in grouped["reasoning"][:6]],
-        [InlineKeyboardButton("⚡ Casual", callback_data="casual")],
-        *[InlineKeyboardButton(m[:40], callback_data=f"model:{m}")
-          for m in grouped["casual"][:6]],
-    ]
-    return InlineKeyboardMarkup(buttons)
-
-async def tg_start(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
-    chat_id = update.effective_chat.id
-    telegram_states[chat_id] = {
-        "history": [],
-        "model": fetch_models_grouped()["reasoning"][0],
-    }
-    await update.message.reply_text("👋 Benvenuto! Scrivimi pure.")
-
-async def tg_menu(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
-    await update.message.reply_text("Scegli un modello:", reply_markup=tg_model_menu())
-
-async def tg_model_button(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
-    query = update.callback_query
-    await query.answer()
-    data = query.data
-    chat_id = query.message.chat_id
-
-    grouped = fetch_models_grouped()
-    all_models = grouped["reasoning"] + grouped["casual"]
-
-    if data == "reasoning":
-        await query.edit_message_text(
-            "Seleziona un *reasoning* modello:",
-            reply_markup=InlineKeyboardMarkup(
-                [[InlineKeyboardButton(m[:40], callback_data=f"model:{m}")] for m in grouped["reasoning"][:6]]
-            ),
-            parse_mode="Markdown",
+        output_box = gr.Textbox(
+            label="Risposta",
+            interactive=False,
+            lines=15,
+            max_lines=20
         )
-    elif data == "casual":
-        await query.edit_message_text(
-            "Seleziona un *casual* modello:",
-            reply_markup=InlineKeyboardMarkup(
-                [[InlineKeyboardButton(m[:40], callback_data=f"model:{m}")] for m in grouped["casual"][:6]]
-            ),
-            parse_mode="Markdown",
+
+        send_btn = gr.Button("Invia", variant="primary")
+        send_btn.click(
+            fn=chat_with_openrouter,
+            inputs=[prompt_box, model_dropdown],
+            outputs=output_box
         )
-    elif data.startswith("model:"):
-        model = data[6:]
-        telegram_states.setdefault(chat_id, {})["model"] = model
-        await query.edit_message_text(f"✅ Modello impostato su: *{model}*", parse_mode="Markdown")
 
-async def tg_msg(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
-    chat_id = update.effective_chat.id
-    user_input = update.message.text
-    state = telegram_states.setdefault(
-        chat_id, {"history": [], "model": fetch_models_grouped()["reasoning"][0]}
-    )
-    hist, _ = chat_with_openrouter(user_input, state["model"], state["history"])
-    reply = hist[-1]["content"]
-    state["history"] = hist
-    await update.message.reply_text(reply)
+        prompt_box.submit(
+            fn=chat_with_openrouter,
+            inputs=[prompt_box, model_dropdown],
+            outputs=output_box
+        )
 
-def run_telegram():
-    if not TELEGRAM_BOT_TOKEN:
-        print("🤖 TELEGRAM_BOT_TOKEN non trovato – bot Telegram OFF.")
-        return
-    app = ApplicationBuilder().token(TELEGRAM_BOT_TOKEN).build()
-    app.add_handler(CommandHandler("start", tg_start))
-    app.add_handler(CommandHandler("menu", tg_menu))
-    app.add_handler(CallbackQueryHandler(tg_model_button))
-    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, tg_msg))
-    print("🤖 Telegram bot in background...")
-    app.run_polling(stop_signals=None)
+    return demo
 
-# ----------------------------------------------------------------
-# 7.  Entry-point
-# ----------------------------------------------------------------
+# Lancia l’interfaccia
 if __name__ == "__main__":
-    if TELEGRAM_BOT_TOKEN:
-        threading.Thread(target=run_telegram, daemon=True).start()
-    demo = build_interface()
-    demo.queue().launch()
+    build_interface().launch()