Update app.py

app.py

@@ -1,175 +1,116 @@
 import os
-import time
+import openai
+from google.cloud import texttospeech_v1 as texttospeech
 import streamlit as st
-from google.cloud import texttospeech
+import speech_recognition as sr
 from dotenv import load_dotenv
-import tempfile
-import base64
-from groq import Groq
-from datetime import datetime, timedelta
-from streamlit_autorefresh import st_autorefresh
 
-# Configurar la página de Streamlit (esto debe ir primero en el script)
-st.set_page_config(page_title="Asistente de Recordatorios", page_icon="📅", layout="centered")
+# Configurar la página de Streamlit
+st.set_page_config(page_title="Galatea Asistente - OMARDENT", layout="wide")
 
-# Cargar las variables de entorno desde el archivo .env
+# Cargar las claves API desde el archivo .env
 load_dotenv()
+openai_api_key = os.getenv("OPENAI_API_KEY")
+os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "botidinamix-g.json"
 
-# Configura las claves de API
-os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "credentials/botidinamix-g.json"
+# Verificar que las claves API están configuradas
+if not openai_api_key:
+    st.error("No API key provided for OpenAI. Please set your API key in the .env file.")
+else:
+    openai.api_key = openai_api_key
 
-# Inicializar cliente de Groq
-client_groq = Groq(api_key=os.getenv("GROQ_API_KEY"))
+# Función para obtener respuesta de OpenAI y generar audio con Google TTS
+def obtener_respuesta(pregunta, contexto="", modelo="gpt-3.5-turbo", temperatura=0.5):
+    if not pregunta:
+        st.error("La pregunta no puede estar vacía.")
+        return "Lo siento, la pregunta no puede estar vacía."
 
-# Crear carpeta para almacenar audios si no existe
-if not os.path.exists('audios'):
-    os.makedirs('audios')
-
-# Inicializar las variables en el estado de la sesión si no existen
-if 'reminders' not in st.session_state:
-    st.session_state.reminders = []
-
-if 'respuestas_anteriores' not in st.session_state:
-    st.session_state.respuestas_anteriores = []
-
-if 'fin_tiempo' not in st.session_state:
-    st.session_state.fin_tiempo = None
-
-if 'mensaje_recordatorio' not in st.session_state:
-    st.session_state.mensaje_recordatorio = None
-
-# Función para obtener respuesta de Groq actuando como Galatea
-def obtener_respuesta_groq(texto):
-    prompt = f"Actúa como Galatea, la asistente virtual de la clínica odontológica Omardent. Tienes la función de recordarme todo lo que se te pida. Responde de manera breve y amable: {texto}"
-    
     try:
-        # Crear la solicitud de completado con el modelo de Groq
-        chat_completion = client_groq.chat.completions.create(
-            messages=[
-                {
-                    "role": "user",
-                    "content": prompt
-                }
-            ],
-            model="llama3-8b-8192",
+        with st.spinner('Evaluando su respuesta...'):
+            response = openai.ChatCompletion.create(
+                model=modelo,
+                messages=[
+                    {"role": "system", "content": contexto},
+                    {"role": "user", "content": pregunta}
+                ],
+                temperature=temperatura
+            )
+        respuesta = response.choices[0].message['content'].strip()
+
+        # Configura la solicitud de síntesis de voz
+        client = texttospeech.TextToSpeechClient()
+        input_text = texttospeech.SynthesisInput(text=respuesta)
+        voice = texttospeech.VoiceSelectionParams(
+            language_code="es-ES", ssml_gender=texttospeech.SsmlVoiceGender.FEMALE
+        )
+        audio_config = texttospeech.AudioConfig(
+            audio_encoding=texttospeech.AudioEncoding.MP3
         )
-        # Extraer el mensaje generado por Groq
-        return chat_completion.choices[0].message.content.strip()
-    except Exception as e:
-        st.error(f"Error al generar el mensaje desde Groq: {e}")
-        return "Lo siento, hubo un problema al generar el mensaje desde Groq."
 
-# Función para generar una respuesta de voz usando Google Cloud Text-to-Speech
-def generar_respuesta_de_voz(text):
-    client = texttospeech.TextToSpeechClient()
-    synthesis_input = texttospeech.SynthesisInput(text=text)
-    voice = texttospeech.VoiceSelectionParams(language_code="es-ES", ssml_gender=texttospeech.SsmlVoiceGender.FEMALE)
-    audio_config = texttospeech.AudioConfig(audio_encoding=texttospeech.AudioEncoding.MP3)
+        # Realiza la solicitud de síntesis de voz
+        response = client.synthesize_speech(
+            input=input_text, voice=voice, audio_config=audio_config
+        )
+
+        # Reproduce el audio en Streamlit
+        st.audio(response.audio_content, format="audio/mp3")
+        return respuesta
+
+    except openai.OpenAIError as e:
+        st.error(f"Error al comunicarse con OpenAI: {e}")
+        return "Lo siento, no puedo procesar tu solicitud en este momento."
 
-    try:
-        response = client.synthesize_speech(input=synthesis_input, voice=voice, audio_config=audio_config)
-        
-        # Ruta del archivo de audio en la carpeta audios
-        timestamp = int(time.time())
-        audio_file_path = os.path.join('audios', f'recordatorio_{timestamp}.mp3')
-        
-        # Guardar el archivo de audio en la carpeta audios
-        with open(audio_file_path, 'wb') as tmp_file:
-            tmp_file.write(response.audio_content)
-        
-        return audio_file_path  # Devolver la ruta del archivo
     except Exception as e:
-        st.error(f"Error al generar el audio: {e}")
-        return None
-
-# Función para reproducir el mensaje y mostrar texto
-def reproducir_mensaje(mensaje, audio_path):
-    # Mostrar el mensaje en texto
-    st.success(f"**Recordatorio:** {mensaje}")
-
-    # Reproducir el audio
-    if audio_path:
-        with open(audio_path, "rb") as audio_file:
-            audio_bytes = audio_file.read()
-            st.audio(audio_bytes, format="audio/mp3")
-    else:
-        st.error("No se pudo generar el audio para el mensaje.")
-
-# Función para programar un recordatorio usando Groq como Galatea
-def programar_recordatorio_groq(mensaje, intervalo):
-    respuesta_generada = obtener_respuesta_groq(mensaje)
-    
-    # Calcular el tiempo de finalización
-    fin_tiempo = datetime.now() + timedelta(minutes=intervalo)
-    
-    # Generar la ruta del archivo de audio
-    audio_path = generar_respuesta_de_voz(respuesta_generada)
-    
-    # Agregar el recordatorio a la lista en la sesión
-    st.session_state.reminders.append({
-        'mensaje': respuesta_generada,
-        'fin_tiempo': fin_tiempo,
-        'audio_path': audio_path
-    })
-    
-    st.session_state.respuestas_anteriores.append(respuesta_generada)
-    st.success(f"Recordatorio programado para dentro de {intervalo} minutos con Galatea.")
-
-# Autorefresh cada segundo para actualizar la cuenta regresiva
-st_autorefresh(interval=1000, key="datarefresh")
-
-# Estilo CSS para el fondo
-st.markdown(
-    """
-    <style>
-    .reportview-container {
-        background: radial-gradient(circle, rgba(209,238,174,1) 0%, rgba(11,135,128,1) 90%);
-    }
-    </style>
-    """,
-    unsafe_allow_html=True
-)
-
-# Agregar el logo
-st.image("Logo icon.jpg", use_column_width=True)  # Asegúrate de que el archivo icon.jpg esté en la misma carpeta
-
-# Contenido de la aplicación
-st.title("Asistente de Recordatorios - Galatea de Omardent")
-st.write("Crea recordatorios y elige el intervalo de tiempo para recibir notificaciones de Galatea.")
-
-# Campo de texto para ingresar el recordatorio
-mensaje_recordatorio = st.text_input("¿Qué recordatorio deseas establecer?", "")
-
-# Selector desplegable para seleccionar el intervalo de tiempo
-intervalo_opciones = [1, 2, 5, 10, 15, 30, 60, 120]
-intervalo = st.selectbox("Selecciona el intervalo de tiempo (minutos)", intervalo_opciones)
-
-# Botón para programar el recordatorio con Groq
-if st.button("Programar Recordatorio con Galatea (Groq)"):
-    if mensaje_recordatorio:
-        programar_recordatorio_groq(mensaje_recordatorio, intervalo)
-    else:
-        st.warning("Por favor, ingresa un recordatorio.")
-
-# Mostrar los recordatorios activos
-if st.session_state.reminders:
-    st.subheader("Recordatorios Activos")
-    for idx, reminder in enumerate(st.session_state.reminders):
-        tiempo_restante = reminder['fin_tiempo'] - datetime.now()
-        if tiempo_restante.total_seconds() > 0:
-            minutos, segundos = divmod(int(tiempo_restante.total_seconds()), 60)
-            horas, minutos = divmod(minutos, 60)
-            tiempo_str = f"{horas}h {minutos}m {segundos}s" if horas > 0 else f"{minutos}m {segundos}s"
-            st.write(f"**Recordatorio {idx + 1}:** {reminder['mensaje']}")
-            st.write(f"**Tiempo restante:** {tiempo_str}")
-        else:
-            # Reproducir el mensaje y mostrar texto
-            reproducir_mensaje(reminder['mensaje'], reminder['audio_path'])
-            # Eliminar el recordatorio de la lista
-            st.session_state.reminders.pop(idx)
-
-# Mostrar el estado de los recordatorios programados
-if st.session_state.reminders:
-    st.write("**Recordatorios Activos:**")
-    for reminder in st.session_state.reminders:
-        st.write(f"- {reminder['mensaje']} (Finaliza en: {reminder['fin_tiempo']})")
+        st.error(f"Error al generar la respuesta y el audio: {e}")
+        return "Lo siento, ocurrió un error al procesar tu solicitud."
+
+# Función para manejar el chat del asistente
+def mostrar_galatea_asistente():
+    st.title("🦷 Galatea - Asistente Virtual OMARDENT")
+
+    # Inicializa el historial del chat
+    if 'mensajes_chat' not in st.session_state:
+        st.session_state['mensajes_chat'] = []
+
+    # Mostrar los mensajes del chat
+    for mensaje in st.session_state['mensajes_chat']:
+        clase = "user" if mensaje["role"] == "user" else "assistant"
+        st.markdown(f'<div class="chat-message {clase}">{mensaje["content"]}</div>', unsafe_allow_html=True)
+
+    # Entrada de texto para la pregunta del usuario
+    pregunta_usuario = st.text_input("Escribe tu pregunta aquí:")
+
+    # Grabar y transcribir audio
+    if st.button("Grabar y Transcribir Audio"):
+        recognizer = sr.Recognizer()
+        with sr.Microphone() as source:
+            st.info("Grabando...")
+            audio = recognizer.listen(source, timeout=5)
+            st.info("Grabación completa")
+
+        try:
+            text = recognizer.recognize_google(audio, language="es-ES")
+            pregunta_usuario = text  # Usar la transcripción como la pregunta
+        except sr.UnknownValueError:
+            st.error("No se pudo entender el audio")
+        except sr.RequestError:
+            st.error("Error al solicitar el servicio de reconocimiento de voz")
+
+    # Enviar la pregunta y obtener la respuesta
+    if st.button("Enviar Pregunta"):
+        if pregunta_usuario:
+            # Guardar la pregunta en el historial
+            st.session_state['mensajes_chat'].append({"role": "user", "content": pregunta_usuario})
+
+            # Obtener respuesta de OpenAI
+            respuesta = obtener_respuesta(pregunta_usuario)
+
+            # Guardar la respuesta en el historial
+            st.session_state['mensajes_chat'].append({"role": "assistant", "content": respuesta})
+
+# Función principal
+def main():
+    mostrar_galatea_asistente()
+
+if __name__ == "__main__":
+    main()