Update app.py

app.py

@@ -1,129 +1,197 @@
-import os
-import time
-import schedule
-import streamlit as st
-from google.cloud import texttospeech
-import openai
-from dotenv import load_dotenv
-import threading
-from datetime import datetime, timedelta
-from streamlit_autorefresh import st_autorefresh
-import tempfile
-import base64
-import PyPDF2
-
-# Cargar las variables de entorno desde el archivo .env
-load_dotenv()
-
-# Configura la clave de API de Google Cloud
-os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "credentials/botidinamix-g.json"
-
-# Configura la clave de API de OpenAI
-openai.api_key = os.getenv("OPENAI_API_KEY")
-
-# Verifica que la clave API de OpenAI esté configurada
-if not openai.api_key:
-    st.error("No API key provided for OpenAI. Please set your API key in the .env file.")
-
-# Función para leer un archivo PDF y extraer el texto
-def leer_pdf(file):
-    pdf_reader = PyPDF2.PdfFileReader(file)
-    texto = ""
-    for page_num in range(pdf_reader.numPages):
-        page = pdf_reader.getPage(page_num)
-        texto += page.extract_text()
-    return texto
-
-# Función para dividir el texto en una lista de recordatorios
-def procesar_recordatorios(texto):
-    recordatorios = texto.split('\n')
-    return [r.strip() for r in recordatorios if r.strip()]
-
-# 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)
-
-    try:
-        response = client.synthesize_speech(input=synthesis_input, voice=voice, audio_config=audio_config)
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
-            tmp_file.write(response.audio_content)
-            audio_file_path = tmp_file.name
-
-        st.write(f"Audio generado en: {audio_file_path}")  # Depuración
-        return audio_file_path
-    except Exception as e:
-        st.error(f"Error al generar el audio: {e}")
-        return None
-
-# Función para generar y reproducir mensajes periódicos
-def tarea_periodica(mensaje):
-    audio_path = generar_respuesta_de_voz(mensaje)
-    if audio_path:
-        st.session_state.last_audio_path = audio_path
-        st.experimental_rerun()
-    else:
-        st.error("No se pudo generar el audio para el mensaje.")
-
-# Función para programar los recordatorios en horas específicas
-def programar_recordatorios(recordatorios, horarios):
-    schedule.clear()  # Limpiar tareas programadas anteriormente
-    for i, (recordatorio, horario) in enumerate(zip(recordatorios, horarios)):
-        schedule.every().day.at(horario).do(lambda r=recordatorio: tarea_periodica(r))
-        st.write(f"Recordatorio {i+1} programado para las {horario}.")
-
-# Crear la aplicación Streamlit
-st.title("Asistente de Recordatorios de Voz")
-st.write("Este asistente reproduce recordatorios en voz automáticamente según los horarios configurados.")
-
-# Inicializar el índice de recordatorios en la sesión
-if 'indice_recordatorio' not in st.session_state:
-    st.session_state.indice_recordatorio = 0
-
-# Controles de interfaz para subir el archivo PDF y configurar los horarios
-pdf_file = st.file_uploader("Sube el archivo PDF con los recordatorios", type="pdf")
-
-# Procesar el archivo PDF y obtener la lista de recordatorios
-if pdf_file:
-    texto_pdf = leer_pdf(pdf_file)
-    recordatorios = procesar_recordatorios(texto_pdf)
-    st.write("Recordatorios extraídos del PDF:")
-    st.write(recordatorios)
-
-    # Campo de texto para ingresar los horarios de los recordatorios
-    horarios_input = st.text_area("Escribe los horarios de los recordatorios en formato HH:MM, separados por comas", "09:00,13:00,18:00")
-    horarios = [h.strip() for h in horarios_input.split(',')]
-
-    if st.button("Programar Recordatorios"):
-        programar_recordatorios(recordatorios, horarios)
-        st.success("Recordatorios programados según los horarios indicados.")
-
-# Iniciar el scheduler en un hilo separado
-def run_scheduler():
-    while True:
-        schedule.run_pending()
-        time.sleep(1)
-
-if 'scheduler_thread' not in st.session_state:
-    st.session_state.scheduler_thread = threading.Thread(target=run_scheduler)
-    st.session_state.scheduler_thread.start()
-
-# Código JavaScript para reproducción automática de audio
-if 'last_audio_path' in st.session_state:
-    with open(st.session_state.last_audio_path, "rb") as audio_file:
-        audio_bytes = audio_file.read()
-        audio_base64 = base64.b64encode(audio_bytes).decode()
-
-    audio_html = f"""
-    <audio autoplay>
-        <source src="data:audio/mp3;base64,{audio_base64}" type="audio/mp3">
-        Your browser does not support the audio element.
-    </audio>
-    """
-    st.markdown(audio_html, unsafe_allow_html=True)
-
-# Autorefresh cada 30 segundos (puedes ajustar este intervalo)
-st_autorefresh(interval=30000, key="datarefresh")
+import os
+import time
+import schedule
+import streamlit as st
+from google.cloud import texttospeech
+import openai
+from dotenv import load_dotenv
+import threading
+from datetime import datetime, timedelta
+from streamlit_autorefresh import st_autorefresh
+import tempfile
+import base64
+import random
+
+# Cargar las variables de entorno desde el archivo .env
+load_dotenv()
+
+# Configura la clave de API de Google Cloud
+os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "credentials/botidinamix-g.json"
+
+# Configura la clave de API de OpenAI
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+# Verifica que la clave API de OpenAI esté configurada
+if not openai.api_key:
+    st.error("No API key provided for OpenAI. Please set your API key in the .env file.")
+
+# Lista de preguntas para generar mensajes aleatorios
+preguntas = [
+    "Bienvenido a la clínica odontológica Omardent. ¿En qué puedo ayudarte hoy?",
+    "Hola, soy tu asistente de recepción. ¿Tienes alguna consulta?",
+    "Gracias por elegir Omardent. ¿Cómo puedo asistirte?",
+    "Bienvenido a Omardent. ¿Necesitas ayuda con algo específico?",
+    "Hola, estoy aquí para ayudarte. ¿Tienes alguna pregunta o necesitas asistencia?"
+]
+
+# Función para obtener respuesta del agente utilizando GPT-4
+def obtener_respuesta():
+    pregunta = random.choice(preguntas)
+    prompt = f"Como asistente de recepción en la clínica odontológica Omardent, mi trabajo es asegurar que todos se sientan bienvenidos y cómodos. Transmitiendo mensajes de seguridad, confianza y tranquilidad en un tono amable y profesional. {pregunta}"
+    try:
+        response = openai.ChatCompletion.create(
+            model="gpt-4",
+            messages=[
+                {"role": "system", "content": "Eres un asistente carismático y profesional."},
+                {"role": "user", "content": prompt},
+            ],
+            max_tokens=150
+        )
+        mensaje_generado = response['choices'][0]['message']['content'].strip()
+        st.write(f"Mensaje generado: {mensaje_generado}")  # Depuración
+        return mensaje_generado
+    except Exception as e:
+        st.error(f"Error al generar el mensaje: {e}")
+        return "Lo siento, hubo un problema al generar el mensaje."
+
+# 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)
+
+    try:
+        response = client.synthesize_speech(input=synthesis_input, voice=voice, audio_config=audio_config)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
+            tmp_file.write(response.audio_content)
+            audio_file_path = tmp_file.name
+
+        st.write(f"Audio generado en: {audio_file_path}")  # Depuración
+        return audio_file_path
+    except Exception as e:
+        st.error(f"Error al generar el audio: {e}")
+        return None
+
+# Función para verificar que la respuesta sea diferente
+def verificar_respuesta_diferente(nueva_respuesta, respuestas_anteriores):
+    return nueva_respuesta not in respuestas_anteriores
+
+# Función para generar y reproducir mensajes periódicos
+def tarea_periodica():
+    respuestas_anteriores = st.session_state.get('respuestas_anteriores', [])
+    nueva_respuesta = obtener_respuesta()
+    
+    # Verificar que la respuesta sea diferente
+    if verificar_respuesta_diferente(nueva_respuesta, respuestas_anteriores):
+        audio_path = generar_respuesta_de_voz(nueva_respuesta)
+        if audio_path:
+            st.session_state.last_audio_path = audio_path
+            st.session_state.respuestas_anteriores.append(nueva_respuesta)
+            if len(st.session_state.respuestas_anteriores) > 10:  # Mantener solo las últimas 10 respuestas
+                st.session_state.respuestas_anteriores.pop(0)
+            st.session_state.next_run_time = datetime.now() + timedelta(minutes=st.session_state.intervalo)
+            st.experimental_rerun()
+        else:
+            st.error("No se pudo generar el audio para el mensaje.")
+    else:
+        st.write("La respuesta generada es similar a la anterior. Generando una nueva respuesta...")
+        tarea_periodica()  # Intentar generar una nueva respuesta
+
+# Función para programar la tarea según el intervalo deseado
+def programar_tarea(intervalo):
+    schedule.clear()  # Limpiar tareas programadas anteriormente
+    schedule.every(intervalo).minutes.do(tarea_periodica)
+    st.session_state.next_run_time = datetime.now() + timedelta(minutes=intervalo)
+
+# Crear la aplicación Streamlit
+st.title("Asistente de Recepción para Clínica Odontológica Omardent")
+st.write("Este asistente reproduce mensajes de voz automáticamente según el intervalo configurado.")
+
+# Inicializar respuestas anteriores en la sesión
+if 'respuestas_anteriores' not in st.session_state:
+    st.session_state.respuestas_anteriores = []
+
+# Controles de interfaz
+intervalo = st.slider("Selecciona el intervalo de tiempo (minutos)", min_value=1, max_value=120, value=30, step=1)
+
+if st.button("Actualizar Intervalo"):
+    st.session_state.intervalo = intervalo
+    programar_tarea(intervalo)
+    st.success(f"Intervalo de tiempo actualizado a {intervalo} minutos.")
+
+# Campo de texto para ingresar un mensaje personalizado
+mensaje_personalizado = st.text_area("Escribe el mensaje que quieres que se reproduzca:")
+
+# Controles para reproducir el mensaje personalizado
+if st.button("Reproducir ahora"):
+    if mensaje_personalizado:
+        audio_path = generar_respuesta_de_voz(mensaje_personalizado)
+        if audio_path:
+            st.session_state.last_audio_path = audio_path
+            st.experimental_rerun()
+        else:
+            st.error("No se pudo generar el audio para el mensaje personalizado.")
+    else:
+        st.warning("Por favor, ingresa un mensaje.")
+
+intervalo_personalizado = st.slider("Selecciona el intervalo de tiempo para el mensaje personalizado (minutos)", min_value=1, max_value=120, value=30, step=1)
+
+if st.button("Programar Reproducción"):
+    if mensaje_personalizado:
+        schedule.every(intervalo_personalizado).minutes.do(lambda: reproducir_mensaje_personalizado(mensaje_personalizado))
+        st.success(f"Mensaje personalizado programado para cada {intervalo_personalizado} minutos.")
+    else:
+        st.warning("Por favor, ingresa un mensaje.")
+
+# Función para reproducir mensaje personalizado
+def reproducir_mensaje_personalizado(mensaje):
+    audio_path = generar_respuesta_de_voz(mensaje)
+    if audio_path:
+        st.session_state.last_audio_path = audio_path
+        st.experimental_rerun()
+    else:
+        st.error("No se pudo generar el audio para el mensaje.")
+
+# Iniciar el scheduler en un hilo separado
+def run_scheduler():
+    while True:
+        schedule.run_pending()
+        time.sleep(1)
+
+if 'scheduler_thread' not in st.session_state:
+    st.session_state.scheduler_thread = threading.Thread(target=run_scheduler)
+    st.session_state.scheduler_thread.start()
+
+# Mostrar el contador
+if 'next_run_time' in st.session_state:
+    time_remaining = st.session_state.next_run_time - datetime.now()
+    if time_remaining.total_seconds() > 0:
+        st.write(f"Tiempo restante para el próximo mensaje: {str(time_remaining).split('.')[0]}")
+    else:
+        st.write("El mensaje se reproducirá pronto.")
+
+# Mensaje de bienvenida inicial
+if 'last_audio_path' not in st.session_state:
+    mensaje_bienvenida = obtener_respuesta()
+    audio_path = generar_respuesta_de_voz(mensaje_bienvenida)
+    if audio_path:
+        st.session_state.last_audio_path = audio_path
+
+# Código JavaScript para reproducción automática de audio
+if 'last_audio_path' in st.session_state:
+    with open(st.session_state.last_audio_path, "rb") as audio_file:
+        audio_bytes = audio_file.read()
+        audio_base64 = base64.b64encode(audio_bytes).decode()
+
+    audio_html = f"""
+    <audio autoplay>
+        <source src="data:audio/mp3;base64,{audio_base64}" type="audio/mp3">
+        Your browser does not support the audio element.
+    </audio>
+    """
+    st.markdown(audio_html, unsafe_allow_html=True)
+
+# Autorefresh cada 30 segundos (puedes ajustar este intervalo)
+st_autorefresh(interval=30000, key="datarefresh")