Fix build: bump gradio 5.5.0 -> 6.26.0, migrate to google-genai, drop asyncio pin

README.md

@@ -4,7 +4,7 @@ emoji: 🚀
 colorFrom: indigo
 colorTo: purple
 sdk: gradio
-sdk_version: 5.5.0
+sdk_version: 6.26.0
 app_file: app.py
 pinned: false
 license: apache-2.0

app.py

@@ -1,117 +1,142 @@
 import os
-import gradio as gr
-import google.generativeai as genai
 import re
 import asyncio
-from langdetect import detect
 
-# Configure Gemini AI
-api_key = os.getenv("GEMINI_API")  # Fetch the Gemini API key securely
-genai.configure(api_key=api_key)
+import gradio as gr
+from google import genai
+from google.genai import types
+from langdetect import detect, DetectorFactory
+
+# Make language detection deterministic across restarts
+DetectorFactory.seed = 0
+
+api_key = os.getenv("GEMINI_API")
+if not api_key:
+    raise RuntimeError(
+        "Falta la variable de entorno GEMINI_API. "
+        "Configurala como secreto del Space (Settings > Variables and secrets)."
+    )
+
+client = genai.Client(api_key=api_key)
+
+MODEL_NAME = os.getenv("GEMINI_MODEL", "gemini-2.5-flash")
 
-# Define the model with desired generation configuration
-generation_config = {
+GENERATION_CONFIG = {
     "temperature": 0.7,
     "top_p": 0.9,
     "top_k": 30,
     "max_output_tokens": 2500,
-    "response_mime_type": "text/plain",
 }
-model_name = "gemini-1.5-flash"  # Use the updated model
+
+# La deteccion automatica de idioma no es fiable en frases cortas sin acentos,
+# asi que la instruccion pide ademas responder en el idioma que use el estudiante.
+LANGUAGE_RULE = (
+    "Responde siempre en el mismo idioma que utilice el estudiante "
+    "(castellano o catalan), aunque la instruccion inicial este en otro idioma."
+)
 
 instructions = {
-    "es" : (
-        "Eres un tutor experto que responde exclusivamente en castellano o catalán. "
-        "Tus respuestas deben centrarse únicamente en temas de estadística básica y "
-        "todo el código proporcionado debe implementarse exclusivamente en R."
+    "es": (
+        "Eres un tutor experto en estadistica. "
+        + LANGUAGE_RULE
+        + " Tus respuestas deben centrarse unicamente en temas de estadistica basica y "
+        "todo el codigo proporcionado debe implementarse exclusivamente en R."
     ),
     "ca": (
-        "Ets un tutor expert que respon exclusivament en catala."
-        "Les teves respostes s'han de centrar unicament en temes d'estadistica basica i"
-        "tot el codi proporcionat s'ha d'implementar exclusivament en R"
-    )
+        "Ets un tutor expert en estadistica. "
+        + LANGUAGE_RULE
+        + " Les teves respostes s'han de centrar unicament en temes d'estadistica basica i "
+        "tot el codi proporcionat s'ha d'implementar exclusivament en R."
+    ),
 }
 
+INAPPROPRIATE_PATTERNS = [
+    re.compile(r"\b(joder|maleducado)\b", re.IGNORECASE),
+]
+
+
 def detect_language(user_input):
     try:
         lang = detect(user_input)
-        return lang if lang in instructions else "es"  # Default to Spanish if unsupported
     except Exception:
-        return "es"  # Default to Spanish on detection failure
+        return "es"
+    return lang if lang in instructions else "es"
+
 
-# Function to detect inappropriate language
 def contains_inappropriate_language(text):
-    inappropriate_patterns = [
-        r"\b(joder|maleducado)\b",  # Replace with actual patterns
-        # Spanish examples: r"\b(maleducado|grosero)\b",  
-    ]
-    for pattern in inappropriate_patterns:
-        if re.search(pattern, text, re.IGNORECASE):
-            return True
-    return False
-
-# Define a custom render function for the chatbot interface
-def render_chat(messages):
-    rendered = []
-    for message in messages:
-        role, content = message["role"], message["content"]
-        if role == "user":
-            rendered.append((content, None))  # User messages on the left
-        else:
-            rendered.append((None, content))  # Assistant messages on the right
-    return rendered
-
-# Updated chatbot function with rendering
+    return any(pattern.search(text) for pattern in INAPPROPRIATE_PATTERNS)
+
+
+def create_chat_session(system_instruction):
+    return client.chats.create(
+        model=MODEL_NAME,
+        config=types.GenerateContentConfig(
+            system_instruction=system_instruction,
+            **GENERATION_CONFIG,
+        ),
+    )
+
+
 async def chatbot_async(user_input, history, chat_session):
+    user_input = (user_input or "").strip()
+    if not user_input:
+        return history, history, chat_session, ""
+
+    history = history + [{"role": "user", "content": user_input}]
+
     if contains_inappropriate_language(user_input):
-        warning = "El lenguaje inapropiado no está permitido. Por favor, formula tu pregunta de manera respetuosa."
+        warning = (
+            "El lenguaje inapropiado no esta permitido. "
+            "Por favor, formula tu pregunta de manera respetuosa."
+        )
         history.append({"role": "assistant", "content": warning})
-        return render_chat(history), history, chat_session
+        return history, history, chat_session, ""
 
-    lang = detect_language(user_input)
-    system_instruction = instructions[lang]
-
-    if chat_session is None:
-        chat_session = genai.GenerativeModel(
-            model_name=model_name,
-            generation_config=generation_config,
-            system_instruction=system_instruction
-        ).start_chat()
+    try:
+        if chat_session is None:
+            lang = detect_language(user_input)
+            chat_session = create_chat_session(instructions[lang])
 
-    response = await asyncio.to_thread(chat_session.send_message, user_input)
-    reply = response.text
+        response = await asyncio.to_thread(chat_session.send_message, user_input)
+        reply = (response.text or "").strip() or "No he podido generar una respuesta."
+    except Exception as exc:
+        reply = f"Ha ocurrido un error: {exc}"
 
-    history.append({"role": "user", "content": user_input})
     history.append({"role": "assistant", "content": reply})
+    return history, history, chat_session, ""
 
-    return render_chat(history), history, chat_session
 
-# Handling errors
-def chatbot_with_error_handling(user_input, history, chat_session):
-    try:
-        return asyncio.run(chatbot_async(user_input, history, chat_session))
-    except Exception as e:
-        error_message = f"Ha ocurrido un error: {str(e)}"
-        history.append({"role": "assistant", "content": error_message})
-        gradio_history = [[msg["role"], msg["content"]] for msg in history]
-        return gradio_history, history, chat_session
-        
-# User interface
-with gr.Blocks() as demo:
-    gr.Markdown("# Chatbot de Estadística \nInteractúa con un tutor experto en estadística básica.")
-    
-    chatbot_interface = gr.Chatbot()  # Gradio's Chatbot element, customized with rendering
-    state = gr.State([])  # For chat history
-    chat_session = gr.State(None)  # For the chat session
+def reset_chat():
+    return [], [], None, ""
 
-    with gr.Row():
-        txt = gr.Textbox(show_label=False, placeholder="Escribe tu pregunta aquí...")
-        send_button = gr.Button("Enviar")
 
-    txt.submit(chatbot_with_error_handling, [txt, state, chat_session], [chatbot_interface, state, chat_session])
-    txt.submit(lambda: "", None, txt)  # Clear input box
+with gr.Blocks(title="Chatbot de Estadistica") as demo:
+    gr.Markdown(
+        "# Chatbot de Estadistica\n"
+        "Interactua con un tutor experto en estadistica basica. "
+        "El codigo de ejemplo se proporciona en R."
+    )
 
-    send_button.click(chatbot_with_error_handling, [txt, state, chat_session], [chatbot_interface, state, chat_session])
-    send_button.click(lambda: "", None, txt)
+    chatbot_interface = gr.Chatbot(height=450)
+    state = gr.State([])          # chat history in messages format
+    chat_session = gr.State(None)  # google-genai chat session
 
-demo.launch()
+    with gr.Row():
+        txt = gr.Textbox(
+            show_label=False,
+            placeholder="Escribe tu pregunta aqui...",
+            scale=8,
+            autofocus=True,
+        )
+        send_button = gr.Button("Enviar", variant="primary", scale=1)
+        clear_button = gr.Button("Limpiar", scale=1)
+
+    inputs = [txt, state, chat_session]
+    outputs = [chatbot_interface, state, chat_session, txt]
+
+    txt.submit(chatbot_async, inputs, outputs)
+    send_button.click(chatbot_async, inputs, outputs)
+    clear_button.click(reset_chat, None, outputs)
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -1,4 +1,3 @@
-gradio
-google-generativeai
-langdetect
-asyncio
+gradio==6.26.0
+google-genai>=1.0
+langdetect==1.0.9