Update app.py

app.py

@@ -1,187 +1,173 @@
-""" OpenRouter Chatbot – con storico conversazione + modelli separati + Telegram Run: python app.py """
-
-import os import functools import threading import requests import gradio as gr
-
-from telegram import Update from telegram.ext import ApplicationBuilder, CommandHandler, MessageHandler, filters, ContextTypes
-
-------------------------------------------------------------------
-
-Configurazione
-
-------------------------------------------------------------------
-
-OPENROUTER_API_KEY = os.getenv( "OPENROUTER_API_KEY", "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" ) TELEGRAM_BOT_TOKEN = "7873487915:AAFZYgAlt5-qr7jdXG1tKkG9KnAZeP6uC8w"
-
-------------------------------------------------------------------
-
-Ottieni modelli raggruppati
-
-------------------------------------------------------------------
-
-@functools.lru_cache(maxsize=1) def fetch_models_grouped() -> dict: headers = {"Authorization": f"Bearer {OPENROUTER_API_KEY}"} try: resp = requests.get("https://openrouter.ai/api/v1/models", headers=headers, timeout=15) resp.raise_for_status() data = resp.json()
-
-reasoning_models = []
-    casual_models = []
-
+# app.py
+# Hugging Face Space version
+# Runs Gradio in the foreground, Telegram in a background thread
+# -----------------------------------------------------------------
+
+import os
+import functools
+import threading
+import requests
+import gradio as gr
+from telegram import Update
+from telegram.ext import ApplicationBuilder, CommandHandler, MessageHandler, filters, ContextTypes
+
+# -----------------------------------------------------------------
+# 1. Secrets (Hugging Face → Settings → Repository secrets)
+# -----------------------------------------------------------------
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")      # <-- set this in HF secrets
+TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")      # <-- optional, only if you want TG
+
+# -----------------------------------------------------------------
+# 2. Fetch & group models
+# -----------------------------------------------------------------
+@functools.lru_cache(maxsize=1)
+def fetch_models_grouped():
+    headers = {"Authorization": f"Bearer {OPENROUTER_API_KEY}"}
+    try:
+        resp = requests.get("https://openrouter.ai/api/v1/models", headers=headers, timeout=15)
+        resp.raise_for_status()
+        data = resp.json()
+    except Exception:
+        return {"reasoning": ["openai/gpt-4-turbo"], "casual": []}
+
+    reasoning, casual = [], []
     for m in data["data"]:
-        model_id = m["id"].lower()
-        if any(key in model_id for key in ["gpt", "claude", "llama", "mistral", "mixtral", "gemini", "command-r", "qwen"]):
-            reasoning_models.append(m["id"])
+        mid = m["id"].lower()
+        if any(k in mid for k in ["gpt", "claude", "llama", "mistral", "gemini", "command", "qwen"]):
+            reasoning.append(m["id"])
         else:
-            casual_models.append(m["id"])
-
-    return {
-        "reasoning": sorted(reasoning_models),
-        "casual": sorted(casual_models)
-    }
-except Exception as e:
-    return {
-        "reasoning": ["openai/gpt-4-turbo"],
-        "casual": []
-    }
-
-------------------------------------------------------------------
+            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()
+
+# -----------------------------------------------------------------
+# 4. Chat core
+# -----------------------------------------------------------------
+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}
+    headers = {"Authorization": f"Bearer {OPENROUTER_API_KEY}", "Content-Type": "application/json"}
+
+    try:
+        r = requests.post("https://openrouter.ai/api/v1/chat/completions", headers=headers, json=payload, timeout=60)
+        r.raise_for_status()
+        reply = r.json()["choices"][0]["message"]["content"]
+    except Exception as e:
+        reply = f"❌ Errore: {e}"
 
-Format cronologia
-
-------------------------------------------------------------------
-
-def format_history(history: list) -> str: output = "" for msg in history: if msg["role"] == "user": output += f"\U0001f9d1\u200d\U0001f4bb Tu:\n{msg['content']}\n\n" elif msg["role"] == "assistant": output += f"\U0001f916 Assistente:\n{msg['content']}\n\n" return output.strip()
-
-------------------------------------------------------------------
-
-Chat
-
-------------------------------------------------------------------
-
-def chat_with_openrouter(prompt: str, selected_model: str, history: list): headers = { "Authorization": f"Bearer {OPENROUTER_API_KEY}", "Content-Type": "application/json" }
-
-history.append({"role": "user", "content": prompt})
-
-payload = {
-    "model": selected_model,
-    "messages": history,
-    "max_tokens": 4096,
-    "temperature": 0.7,
-}
-
-try:
-    resp = requests.post("https://openrouter.ai/api/v1/chat/completions", headers=headers, json=payload, timeout=60)
-    resp.raise_for_status()
-    reply = resp.json()["choices"][0]["message"]["content"]
     history.append({"role": "assistant", "content": reply})
     return history, format_history(history)
-except Exception as e:
-    error_msg = f"\u274c Errore: {e}"
-    history.append({"role": "assistant", "content": error_msg})
-    return history, format_history(history)
-
-------------------------------------------------------------------
-
-Interfaccia Gradio
-
-------------------------------------------------------------------
-
-def build_interface(): grouped_models = fetch_models_grouped() default_model = grouped_models["reasoning"][0] if grouped_models["reasoning"] else ""
-
-with gr.Blocks(title="NotExistChatter – Chat con storico") as demo:
-    gr.Markdown("## \U0001f916 Project Adam – Chat dinamica con modelli open source")
-
-    saved_chats = gr.State({})
-    current_chat_name = gr.State("Chat #1")
-
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### \U0001f4ac Chat salvate")
-            chat_selector = gr.Radio(choices=[], label="Storico", interactive=True)
-            load_btn = gr.Button("\U0001f4c2 Carica Chat")
-            new_chat_btn = gr.Button("\U0001f195 Nuova Chat")
-            save_name = gr.Textbox(label="\U0001f4be Nome", placeholder="Es. brainstorming")
-            save_btn = gr.Button("\U0001f4be Salva Chat")
-
-        with gr.Column(scale=4):
-            with gr.Row():
-                reasoning_dropdown = gr.Dropdown(choices=grouped_models["reasoning"], label="\U0001f9e0 Modelli con Ragionamento", interactive=True)
-                casual_dropdown = gr.Dropdown(choices=grouped_models["casual"], label="\u26a1\ufe0f Modelli Generici", interactive=True)
-
-            output_box = gr.Textbox(label="Conversazione", interactive=False, lines=20, max_lines=40)
-            prompt_box = gr.Textbox(label="Prompt", placeholder="Scrivi qui il tuo messaggio...", lines=4, max_lines=10)
-            send_btn = gr.Button("Invia", variant="primary")
-            chat_history = gr.State([])
-
-    def resolve_model(prompt, reasoning_model, casual_model, history):
-        model = reasoning_model or casual_model
-        if not model:
-            history.append({"role": "assistant", "content": "\u26a0\ufe0f Seleziona almeno un modello."})
-            return history, format_history(history)
-        return chat_with_openrouter(prompt, model, history)
-
-    def reset_chat():
-        return [], "", f"Chat #{os.urandom(2).hex()}", gr.update(value=None)
-
-    def save_chat_fn(chats, name, history):
-        if not name:
-            return chats, gr.update(choices=list(chats.keys())), "\u26a0\ufe0f Inserisci un nome valido."
-        chats[name] = history.copy()
-        return chats, gr.update(choices=list(chats.keys())), f"\u2705 Chat salvata: '{name}'"
-
-    def load_chat_fn(chats, selected_name):
-        if not selected_name or selected_name not in chats:
-            return [], "", "\u26a0\ufe0f Seleziona una chat valida."
-        history = chats[selected_name]
-        return history, format_history(history), selected_name
-
-    send_btn.click(fn=resolve_model, inputs=[prompt_box, reasoning_dropdown, casual_dropdown, chat_history], outputs=[chat_history, output_box])
-    prompt_box.submit(fn=resolve_model, inputs=[prompt_box, reasoning_dropdown, casual_dropdown, chat_history], outputs=[chat_history, output_box])
-    new_chat_btn.click(fn=reset_chat, inputs=[], outputs=[chat_history, output_box, current_chat_name, chat_selector])
-    save_btn.click(fn=save_chat_fn, inputs=[saved_chats, save_name, chat_history], outputs=[saved_chats, chat_selector, output_box])
-    load_btn.click(fn=load_chat_fn, inputs=[saved_chats, chat_selector], outputs=[chat_history, output_box, current_chat_name])
-
-return demo
-
-------------------------------------------------------------------
-
-Bot Telegram
-
-------------------------------------------------------------------
-
-telegram_chat_states = {}
-
-async def start(update: Update, context: ContextTypes.DEFAULT_TYPE): chat_id = update.effective_chat.id telegram_chat_states[chat_id] = {"history": [], "model": fetch_models_grouped()["reasoning"][0]} await update.message.reply_text("\U0001f916 Benvenuto! Scrivimi un messaggio per iniziare a chattare.")
-
-async def setmodel(update: Update, context: ContextTypes.DEFAULT_TYPE): chat_id = update.effective_chat.id args = context.args available_models = fetch_models_grouped() all_models = available_models["reasoning"] + available_models["casual"]
-
-if not args:
-    await update.message.reply_text("\U0001f4cc Specifica il modello. Es: /setmodel openai/gpt-4-turbo")
-    return
-
-selected_model = args[0]
-if selected_model not in all_models:
-    await update.message.reply_text("❌ Modello non valido. Scegli tra:\n" + "\n".join(all_models))
-    return
-
-telegram_chat_states.setdefault(chat_id, {"history": [], "model": selected_model})
-telegram_chat_states[chat_id]["model"] = selected_model
-await update.message.reply_text(f"\u2705 Modello impostato: {selected_model}")
-
-async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE): chat_id = update.effective_chat.id user_input = update.message.text
-
-if chat_id not in telegram_chat_states:
-    telegram_chat_states[chat_id] = {"history": [], "model": fetch_models_grouped()["reasoning"][0]}
-
-state = telegram_chat_states[chat_id]
-history, _ = chat_with_openrouter(user_input, state["model"], state["history"])
-reply = history[-1]["content"]
-telegram_chat_states[chat_id]["history"] = history
-await update.message.reply_text(reply)
-
-def run_telegram_bot(): app = ApplicationBuilder().token(TELEGRAM_BOT_TOKEN).build() app.add_handler(CommandHandler("start", start)) app.add_handler(CommandHandler("setmodel", setmodel)) app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message)) print("\U0001f916 Telegram bot in esecuzione...") app.run_polling()
-
-------------------------------------------------------------------
-
-Avvio
-
-------------------------------------------------------------------
-
-if name == "main": threading.Thread(target=run_telegram_bot, daemon=True).start() build_interface().launch()
 
+# -----------------------------------------------------------------
+# 5. Gradio interface
+# -----------------------------------------------------------------
+def build_interface():
+    grouped = fetch_models_grouped()
+    default_model = grouped["reasoning"][0] if grouped["reasoning"] else ""
+
+    with gr.Blocks(title="OpenRouter Chat – HF Space") as demo:
+        gr.Markdown("## 🤖 OpenRouter Chatbot (HF Space edition)")
+        saved_chats = gr.State({})
+        current_name = gr.State("Chat #1")
+        history = gr.State([])
+
+        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...")
+
+        # helpers
+        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")
+
+        # wiring
+        prompt.submit(fn=resolve, inputs=[prompt, reasoning_dd, casual_dd, history], outputs=[history, output])
+        save_btn.click(fn=save_fn, inputs=[saved_chats, save_name, history], outputs=[saved_chats, chat_selector, output])
+        load_btn.click(fn=load_fn, inputs=[saved_chats, chat_selector], outputs=[history, output, current_name])
+        new_btn.click(fn=new_chat, outputs=[history, output, current_name, chat_selector])
+
+    return demo
+
+# -----------------------------------------------------------------
+# 6. Optional Telegram bot (background)
+# -----------------------------------------------------------------
+telegram_states = {}
+
+async def tg_start(update: Update, ctx):
+    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_setmodel(update: Update, ctx):
+    chat_id = update.effective_chat.id
+    all_models = fetch_models_grouped()["reasoning"] + fetch_models_grouped()["casual"]
+    if not ctx.args or ctx.args[0] not in all_models:
+        await update.message.reply_text("❌ Modello non valido.\nEsempio: /setmodel openai/gpt-4-turbo")
+        return
+    telegram_states.setdefault(chat_id, {})["model"] = ctx.args[0]
+    await update.message.reply_text(f"✅ Modello: {ctx.args[0]}")
+
+async def tg_msg(update: Update, ctx):
+    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)
+
+def run_telegram():
+    if not TELEGRAM_BOT_TOKEN:
+        return
+    app = ApplicationBuilder().token(TELEGRAM_BOT_TOKEN).build()
+    app.add_handler(CommandHandler("start", tg_start))
+    app.add_handler(CommandHandler("setmodel", tg_setmodel))
+    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, tg_msg))
+    print("🤖 Telegram bot in background...")
+    app.run_polling(stop_signals=None)
+
+# -----------------------------------------------------------------
+# 7. Entry-point
+# -----------------------------------------------------------------
+if __name__ == "__main__":
+    # Telegram thread (optional)
+    if TELEGRAM_BOT_TOKEN:
+        threading.Thread(target=run_telegram, daemon=True).start()
+    # Launch Gradio (HF Space)
+    build_interface().queue().launch()