Update app.py

app.py

@@ -6,128 +6,142 @@ from pymongo import MongoClient
 from bson.objectid import ObjectId
 import pyttsx3
 
-client = MongoClient("mongodb://localhost:27017/")
-db = client["search_history"]
-history_collection = db["history"]
-
+# Configuración de la base de datos MongoDB
+def obtener_cliente_mongo():
+    try:
+        cliente = MongoClient("mongodb://localhost:27017/")
+        cliente.server_info()  # Verifica la conexión
+        return cliente
+    except Exception as e:
+        st.error(f"Error: No se pudo conectar a MongoDB. Verifica que el servidor esté en ejecución. Detalles: {e}")
+        return None
+
+cliente = obtener_cliente_mongo()
+if cliente:
+    db = cliente["historial_busquedas"]
+    coleccion_historial = db["historial"]
+
+# Clave API para Google Generative AI
 api_key = 'AIzaSyDJZ3r6VRhRivR0pb96cBRg_VvGg_fXq5k'
 params = {
     'key': api_key,
 }
 
-def save_history(input_mode, user_input, response):
-    history_entry = {
-        "input_mode": input_mode,
-        "user_input": user_input,
-        "response": response
+def guardar_historial(modo_entrada, entrada_usuario, respuesta):
+    entrada_historial = {
+        "modo_entrada": modo_entrada,
+        "entrada_usuario": entrada_usuario,
+        "respuesta": respuesta
     }
-    history_collection.insert_one(history_entry)
+    coleccion_historial.insert_one(entrada_historial)
 
-def load_history():
-    history_entries = list(history_collection.find().sort("_id", -1))
-    return history_entries
+def cargar_historial():
+    entradas_historial = list(coleccion_historial.find().sort("_id", -1))
+    return entradas_historial
 
-def delete_history(entry_id):
-    history_collection.delete_one({"_id": ObjectId(entry_id)})
+def eliminar_historial(id_entrada):
+    coleccion_historial.delete_one({"_id": ObjectId(id_entrada)})
 
-def process_text(text):
+def procesar_texto(texto):
     genai.configure(api_key=api_key)
-    model = genai.GenerativeModel('gemini-1.5-pro-latest')
-    response = model.generate_content(text)
-    result = response.text
-    save_history("Text", text, result)
-    return result
+    modelo = genai.GenerativeModel('gemini-1.5-pro-latest')
+    respuesta = modelo.generate_content(texto)
+    resultado = respuesta.text
+    guardar_historial("Texto", texto, resultado)
+    return resultado
 
-def process_image(text):
+def procesar_imagen(imagen):
     genai.configure(api_key=api_key)
-    model = genai.GenerativeModel('gemini-1.5-pro-latest')
-    response = model.generate_content(text)
-    save_history("Image", image.name, response)
-    return response
-
-def recognize_speech():
-    recognizer = sr.Recognizer()
-    with sr.Microphone() as source:
-        st.write("Listening...")
-        audio = recognizer.listen(source)
+    modelo = genai.GenerativeModel('gemini-1.5-pro-latest')
+    respuesta = modelo.generate_content(imagen.name)  # Asume que `generate_content` maneja el nombre de la imagen como entrada válida
+    resultado = respuesta.text
+    guardar_historial("Imagen", imagen.name, resultado)
+    return resultado
+
+def reconocer_voz():
+    reconocedor = sr.Recognizer()
+    with sr.Microphone() as fuente:
+        st.write("Escuchando...")
+        audio = reconocedor.listen(fuente)
     try:
-        text = recognizer.recognize_google(audio)
-        return text
+        texto = reconocedor.recognize_google(audio)
+        return texto
     except sr.UnknownValueError:
-        return "Google Speech Recognition could not understand audio"
+        return "El reconocimiento de voz de Google no pudo entender el audio"
     except sr.RequestError as e:
-        return f"Could not request results from Google Speech Recognition service; {e}"
+        return f"No se pudieron solicitar resultados del servicio de reconocimiento de voz de Google; {e}"
 
-def speak_text(text):
-    engine = pyttsx3.init()
-    engine.say(text)
-    engine.runAndWait()
+def hablar_texto(texto):
+    motor = pyttsx3.init()
+    motor.say(texto)
+    motor.runAndWait()
 
 st.set_page_config(layout="wide")
-st.sidebar.title("History")
+st.sidebar.title("Historial")
 
-history = load_history()
-selected_response = None
+historial = cargar_historial()
+respuesta_seleccionada = None
 
-for entry in history:
-    with st.sidebar.expander(f"{entry['user_input']}"):
+# Mostrar historial en la barra lateral
+for entrada in historial:
+    with st.sidebar.expander(f"{entrada['entrada_usuario']}"):
         col1, col2 = st.columns([1, 1])
         with col1:
-            if st.button("Response", key=str(entry['_id'])):
-                selected_response = entry['response']
+            if st.button("Respuesta", key=str(entrada['_id'])):
+                respuesta_seleccionada = entrada['respuesta']
         with col2:
-            if st.button("Delete", key=f"delete_{entry['_id']}"):
-                delete_history(entry['_id'])
-                st.experimental_rerun()
+            if st.button("Eliminar", key=f"eliminar_{entrada['_id']}"):
+                eliminar_historial(entrada['_id'])
+                st.rerun()  # Usa `st.rerun()` en lugar de `st.experimental_rerun()`
 
 st.title("🤖 ChatBot")
 
-generated_content_placeholder = st.empty()
+espacio_contenido_generado = st.empty()
 
-if selected_response:
-    generated_content_placeholder.write(selected_response)
-    if st.button("🔊 Speak"):
-        speak_text(selected_response)
+# Mostrar respuesta seleccionada
+if respuesta_seleccionada:
+    espacio_contenido_generado.write(respuesta_seleccionada)
+    if st.button("🔊 Hablar"):
+        hablar_texto(respuesta_seleccionada)
 
-# Load and apply custom CSS
+# Cargar y aplicar CSS personalizado
 with open("./style.css") as f:
     st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
 
-
-# Main content
+# Contenido principal
 col1, col2 = st.columns([1, 3])
 
 with col1:
-    input_type = st.selectbox("Select input type", ["Ask a Question❓", "🖼️ upload Image", "🎤 use Microphone"])
+    tipo_entrada = st.selectbox("Selecciona el tipo de entrada", ["Haz una pregunta❓", "🖼️ Subir imagen", "🎤 Usar micrófono"])
 
 with col2:
-    if input_type == "Ask a Question❓":
-        text_input = st.text_input("Enter your prompt here")
-        if text_input:
-            with st.spinner("Generating response..."):
-                result = process_text(text_input)
-            generated_content_placeholder.write(result)
-            if st.button("🔊 Speak", key="speak_text_input"):
-                speak_text(result)
-
-    elif input_type == "🖼️ upload Image":
-        image_input = st.file_uploader("Upload an image", type=["jpg", "png", "jpeg"])
-        if image_input:
-            image = Image.open(image_input)
-            st.image(image, caption='Uploaded Image.', use_column_width=True)
-            with st.spinner("Processing image..."):
-                response = process_text(image_input)
-            generated_content_placeholder.write(response)
-
-    elif input_type == "🎤 use Microphone":
-        if st.button("Record"):
-            with st.spinner("Listening and processing..."):
-                text_from_speech = recognize_speech()
-            if text_from_speech:
-                text_input = st.text_input("Speak", value=text_from_speech)
-                if text_input:
-                    with st.spinner("Generating response..."):
-                        result = process_text(text_input)
-                    generated_content_placeholder.write(result)
-                    if st.button("🔊 Speak", key="speak_speech_input"):
-                        speak_text(result)
+    if tipo_entrada == "Haz una pregunta❓":
+        entrada_texto = st.text_input("Ingresa tu pregunta aquí")
+        if entrada_texto:
+            with st.spinner("Generando respuesta..."):
+                resultado = procesar_texto(entrada_texto)
+            espacio_contenido_generado.write(resultado)
+            if st.button("🔊 Hablar", key="hablar_entrada_texto"):
+                hablar_texto(resultado)
+
+    elif tipo_entrada == "🖼️ Subir imagen":
+        entrada_imagen = st.file_uploader("Sube una imagen", type=["jpg", "png", "jpeg"])
+        if entrada_imagen:
+            imagen = Image.open(entrada_imagen)
+            st.image(imagen, caption='Imagen subida.', use_column_width=True)
+            with st.spinner("Procesando imagen..."):
+                respuesta = procesar_imagen(entrada_imagen)
+            espacio_contenido_generado.write(respuesta)
+
+    elif tipo_entrada == "🎤 Usar micrófono":
+        if st.button("Grabar"):
+            with st.spinner("Escuchando y procesando..."):
+                texto_de_voz = reconocer_voz()
+            if texto_de_voz:
+                entrada_texto = st.text_input("Habla", value=texto_de_voz)
+                if entrada_texto:
+                    with st.spinner("Generando respuesta..."):
+                        resultado = procesar_texto(entrada_texto)
+                    espacio_contenido_generado.write(resultado)
+                    if st.button("🔊 Hablar", key="hablar_entrada_voz"):
+                        hablar_texto(resultado)