Merge branch #Katieearl1513/APP_SPACE' into 'esab/APP_SPACE'

app.py

@@ -1,6 +1,9 @@
 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
@@ -8,61 +11,107 @@ genai.configure(api_key=api_key)
 
 # Define the model with desired generation configuration
 generation_config = {
-    "temperature": 1,
-    "top_p": 0.95,
-    "top_k": 40,
-    "max_output_tokens": 8192,
+    "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
 
-# Update the system instruction to meet the requirements
-system_instruction = (
-    "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."
-)
-
-model = genai.GenerativeModel(
-    model_name=model_name,
-    generation_config=generation_config,
-    system_instruction=system_instruction
-)
-
-def chatbot(user_input, history, chat_session):
-    # Initialize a new chat session for Gemini AI if history is empty
+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."
+    ),
+    "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"
+    )
+}
+
+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
+
+# 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
+async def chatbot_async(user_input, history, chat_session):
+    if contains_inappropriate_language(user_input):
+        warning = "El lenguaje inapropiado no está permitido. Por favor, formula tu pregunta de manera respetuosa."
+        history.append({"role": "assistant", "content": warning})
+        return render_chat(history), history, chat_session
+
+    lang = detect_language(user_input)
+    system_instruction = instructions[lang]
+
     if chat_session is None:
-        chat_session = model.start_chat()
+        chat_session = genai.GenerativeModel(
+            model_name=model_name,
+            generation_config=generation_config,
+            system_instruction=system_instruction
+        ).start_chat()
 
-    # Send the user query to Gemini AI
-    response = chat_session.send_message(user_input)
+    response = await asyncio.to_thread(chat_session.send_message, user_input)
     reply = response.text
 
-    # Update history
     history.append({"role": "user", "content": user_input})
     history.append({"role": "assistant", "content": reply})
 
-    # Convert to Gradio's format
-    gradio_history = [[msg["role"], msg["content"]] for msg in history]
-    return gradio_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 chatbot(user_input, history, chat_session)
+        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:
-    chatbot_interface = gr.Chatbot()
+    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
 
     with gr.Row():
         txt = gr.Textbox(show_label=False, placeholder="Escribe tu pregunta aquí...")
-        txt.submit(chatbot_with_error_handling, [txt, state], [chatbot_interface, state])
+        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
+
+    send_button.click(chatbot_with_error_handling, [txt, state, chat_session], [chatbot_interface, state, chat_session])
+    send_button.click(lambda: "", None, txt)
 
 demo.launch()

requirements.txt

@@ -1,5 +1,4 @@
 gradio
-torch
-transformers
-accelerate
 google-generativeai
+langdetect
+asyncio