Upload 24 files

README.md

@@ -1,13 +1,67 @@
 ---
-title: VIRTUALOMARDENT
-emoji: 💻
-colorFrom: indigo
-colorTo: yellow
-sdk: streamlit
-sdk_version: 1.36.0
-app_file: app.py
-pinned: false
 license: mit
+title: VIRTUAL OMARDENT pro
+sdk: streamlit
+emoji: 🐨
+colorFrom: blue
+colorTo: purple
+short_description: Una aplicacion para gestionar una clinica dental mediante IA
+sdk_version: 1.35.0
 ---
+# Chatbot con OpenAI
+
+Este proyecto consiste en un chatbot desarrollado utilizando la API de OpenAI. El chatbot es capaz de responder preguntas sobre un texto proporcionado por el usuario, utilizando modelos de lenguaje avanzados de OpenAI.
+
+## Descripción
+
+El chatbot puede cargar un documento PDF, extraer su contenido de texto, preprocesarlo y luego responder preguntas sobre ese texto utilizando la API de OpenAI. Los usuarios pueden seleccionar diferentes modelos de lenguaje de OpenAI para generar respuestas.
+
+## Instalación
+
+Para ejecutar este proyecto localmente, sigue estos pasos:
+
+1. Clona este repositorio en tu máquina local utilizando Git:
+
+    ```bash
+    git clone https://github.com/tu_usuario/tu_repositorio.git
+    ```
+
+2. Navega al directorio del proyecto:
+
+    ```bash
+    cd tu_repositorio
+    ```
+
+3. Instala las dependencias necesarias utilizando pip:
+
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+4. Configura tu clave de API de OpenAI. Puedes hacerlo estableciendo la variable de entorno `OPENAI_API_KEY` o directamente en el archivo `chat.py`.
+
+## Uso
+
+Una vez que hayas configurado el proyecto y las dependencias, puedes ejecutar el chatbot utilizando el siguiente comando:
+
+```bash
+streamlit run chat.py
+```
+## Dependencias
+
+Este proyecto utiliza las siguientes dependencias de Python:
+
+- Streamlit: Para la interfaz de usuario interactiva.
+- OpenAI: Para acceder a la API de OpenAI y obtener respuestas del chatbot.
+- NLTK: Para el preprocesamiento de texto, incluyendo tokenización y eliminación de palabras vacías.
+- PyPDF2: Para extraer texto de documentos PDF.
+
+Puedes encontrar las versiones específicas de las dependencias en el archivo `requirements.txt`.
+
+## Contribuciones
+
+Las contribuciones son bienvenidas. Si deseas contribuir a este proyecto, por favor, abre un issue para discutir los cambios propuestos antes de enviar un pull request.
+
+## Licencia
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Este proyecto está bajo la Licencia MIT. Para más detalles, consulta el archivo `LICENSE`.

app.py

@@ -0,0 +1,825 @@
+import os
+import tempfile
+import openai
+from dotenv import load_dotenv
+import PyPDF2
+import nltk
+from nltk.tokenize import word_tokenize
+from nltk.corpus import stopwords
+from nltk.stem import SnowballStemmer
+import pandas as pd
+from fpdf import FPDF
+import streamlit as st
+import requests
+from google.cloud import texttospeech, vision
+import base64
+
+nltk.download('punkt', quiet=True)
+nltk.download('stopwords', quiet=True)
+
+# Cargar las claves API desde el archivo .env
+load_dotenv()
+openai_api_key = os.getenv("OPENAI_API_KEY")
+brevo_api_key = os.getenv("BREVO_API_KEY")
+os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "botidinamix-g.json"
+
+# Verifica 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
+
+if not brevo_api_key:
+    st.error("No API key provided for Brevo. Please set your API key in the .env file.")
+
+def extraer_texto_pdf(archivo):
+    texto = ""
+    if archivo:
+        with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+            temp_file.write(archivo.read())
+            temp_file_path = temp_file.name
+        try:
+            with open(temp_file_path, 'rb') as file:
+                reader = PyPDF2.PdfReader(file)
+                for page in range(len(reader.pages)):
+                    texto += reader.pages[page].extract_text()
+        except Exception as e:
+            st.error(f"Error al extraer texto del PDF: {e}")
+        finally:
+            os.unlink(temp_file_path)
+    return texto
+
+def preprocesar_texto(texto):
+    tokens = word_tokenize(texto, language='spanish')
+    tokens = [word.lower() for word in tokens if word.isalpha()]
+    stopwords_es = set(stopwords.words('spanish'))
+    tokens = [word for word in tokens if word not in stopwords_es]
+    stemmer = SnowballStemmer('spanish')
+    tokens = [stemmer.stem(word) for word in tokens]
+    return " ".join(tokens)
+
+def obtener_respuesta(pregunta, texto_preprocesado, modelo, temperatura=0.5, assistant_id="asst_4ZYvBvf4IUVQPjnugSZGLdV2", contexto=""):
+    try:
+        response = openai.ChatCompletion.create(
+            model=modelo,
+            messages=[
+                {"role": "system", "content": "Actua como Galatea la asistente de la clinica Odontologica OMARDENT y resuelve las inquietudes"},
+                {"role": "user", "content": f"{contexto}\n\n{pregunta}\n\nContexto: {texto_preprocesado}"}
+            ],
+            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
+        )
+
+        # 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."
+
+    except Exception as e:
+        st.error(f"Error al generar la respuesta y el audio: {e}")
+        return "Lo siento, ocurrió un error al procesar tu solicitud."
+
+def guardar_en_txt(nombre_archivo, datos):
+    carpeta = "datos_guardados"
+    os.makedirs(carpeta, exist_ok=True)
+    ruta_archivo = os.path.join(carpeta, nombre_archivo)
+    try:
+        with open(ruta_archivo, 'a', encoding='utf-8') as archivo:  # Append mode
+            archivo.write(datos + "\n")
+    except Exception as e:
+        st.error(f"Error al guardar datos en el archivo: {e}")
+    return ruta_archivo
+
+def cargar_desde_txt(nombre_archivo):
+    carpeta = "datos_guardados"
+    ruta_archivo = os.path.join(carpeta, nombre_archivo)
+    try:
+        if os.path.exists(ruta_archivo):
+            with open(ruta_archivo, 'r', encoding='utf-8') as archivo:
+                return archivo.read()
+        else:
+            st.warning("Archivo no encontrado.")
+            return ""
+    except Exception as e:
+        st.error(f"Error al cargar datos desde el archivo: {e}")
+        return ""
+
+def listar_archivos_txt():
+    carpeta = "datos_guardados"
+    try:
+        if not os.path.exists(carpeta):
+            return []
+        archivos = [f for f in os.listdir(carpeta) if f.endswith('.txt')]
+        archivos_ordenados = sorted(archivos, key=lambda x: os.path.getctime(os.path.join(carpeta, x)), reverse=True)
+        return archivos_ordenados
+    except Exception as e:
+        st.error(f"Error al listar archivos: {e}")
+        return []
+
+def generar_pdf(dataframe, titulo, filename):
+    pdf = FPDF()
+    pdf.add_page()
+    pdf.set_font("Arial", size=12)
+    pdf.cell(200, 10, txt=titulo, ln=True, align='C')
+
+    for i, row in dataframe.iterrows():
+        row_text = ", ".join(f"{col}: {val}" for col, val in row.items())
+        pdf.cell(200, 10, txt=row_text, ln=True)
+    
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp_file:
+            pdf.output(tmp_file.name)
+            return tmp_file.name
+    except Exception as e:
+        st.error(f"Error al generar PDF: {e}")
+        return None
+
+def enviar_correo(destinatario, asunto, contenido):
+    url = "https://api.brevo.com/v3/smtp/email"
+    headers = {
+        "accept": "application/json",
+        "api-key": brevo_api_key,
+        "content-type": "application/json"
+    }
+    payload = {
+        "sender": {"email": "tu_correo@dominio.com"},
+        "to": [{"email": destinatario}],
+        "subject": asunto,
+        "htmlContent": contenido
+    }
+    try:
+        response = requests.post(url, json=payload, headers=headers)
+        if response.status_code == 201:
+            st.success(f"Correo enviado a {destinatario}")
+        else:
+            st.error(f"Error al enviar el correo: {response.text}")
+    except Exception as e:
+        st.error(f"Error al enviar el correo: {e}")
+
+def enviar_whatsapp(numero, mensaje):
+    url = "https://api.brevo.com/v3/whatsapp/send"
+    headers = {
+        "accept": "application/json",
+        "api-key": brevo_api_key,
+        "content-type": "application/json"
+    }
+    payload = {
+        "recipient": {"number": numero},
+        "sender": {"number": "tu_numero_whatsapp"},
+        "content": mensaje
+    }
+    try:
+        response = requests.post(url, json=payload, headers=headers)
+        if response.status_code == 201:
+            st.success(f"Mensaje de WhatsApp enviado a {numero}")
+        else:
+            st.error(f"Error al enviar el mensaje de WhatsApp: {response.text}")
+    except Exception as e:
+        st.error(f"Error al enviar el mensaje de WhatsApp: {e}")
+
+def flujo_laboratorio():
+    st.title("🦷 Gestión de Trabajos de Laboratorio")
+
+    if 'laboratorio' not in st.session_state:
+        st.session_state.laboratorio = []
+
+    with st.form("laboratorio_form"):
+        tipo_trabajo = st.selectbox("Tipo de trabajo:", [
+            "Protesis total", "Protesis removible metal-acrilico", "Parcialita acrilico",
+            "Placa de blanqueamiento", "Placa de bruxismo", "Corona de acrilico", 
+            "Corona en zirconio", "Protesis flexible", "Acker flexible"
+        ])
+        doctor = st.selectbox("Doctor que requiere el trabajo:", ["Dr. Jose Daniel C", "Dr. Jose Omar C"])
+        fecha_entrega = st.date_input("Fecha de entrega:")
+        fecha_envio = st.date_input("Fecha de envío:")
+        laboratorio = st.selectbox("Laboratorio dental:", ["Ernesto Correa lab", "Formando Sonrisas"])
+        nombre_paciente = st.text_input("Nombre paciente:")
+        observaciones = st.text_input("Observaciones:")
+        numero_orden = st.text_input("Número de orden:")
+        cantidad = st.number_input("Cantidad:", min_value=1, step=1)
+
+        submitted = st.form_submit_button("Registrar Trabajo")
+
+        if submitted:
+            trabajo = {
+                "tipo_trabajo": tipo_trabajo,
+                "doctor": doctor,
+                "fecha_entrega": str(fecha_entrega),
+                "fecha_envio": str(fecha_envio),
+                "laboratorio": laboratorio,
+                "nombre_paciente": nombre_paciente,
+                "observaciones": observaciones,
+                "numero_orden": numero_orden,
+                "cantidad": cantidad,
+                "estado": "pendiente"
+            }
+            st.session_state.laboratorio.append(trabajo)
+            datos_guardados = mostrar_datos_como_texto([trabajo])  # Append only the new entry
+            guardar_en_txt('trabajos_laboratorio.txt', datos_guardados)
+            st.success("Trabajo registrado con éxito.")
+    
+    if st.session_state.laboratorio:
+        st.write("### Trabajos Registrados")
+        df_trabajos = pd.DataFrame(st.session_state.laboratorio)
+        st.write(df_trabajos)
+
+        pdf_file = generar_pdf(df_trabajos, "Registro de Trabajos de Laboratorio", "trabajos_laboratorio.pdf")
+        st.download_button(
+            label="📥 Descargar PDF",
+            data=open(pdf_file, 'rb').read(),
+            file_name="trabajos_laboratorio.pdf",
+            mime="application/pdf"
+        )
+
+def flujo_insumos():
+    st.title("📦 Gestión de Insumos")
+
+    if 'insumos' not in st.session_state:
+        st.session_state.insumos = []
+
+    with st.form("insumos_form"):
+        insumo_nombre = st.text_input("Nombre del Insumo:")
+        insumo_cantidad = st.number_input("Cantidad Faltante:", min_value=0, step=1)
+        submitted = st.form_submit_button("Agregar Insumo")
+
+        if submitted and insumo_nombre:
+            insumo = {"nombre": insumo_nombre, "cantidad": insumo_cantidad}
+            st.session_state.insumos.append(insumo)
+            datos_guardados = mostrar_datos_como_texto([insumo])  # Append only the new entry
+            guardar_en_txt('insumos.txt', datos_guardados)
+            st.success(f"Insumo '{insumo_nombre}' agregado con éxito.")
+
+    if st.session_state.insumos:
+        st.write("### Insumos Registrados")
+        insumos_df = pd.DataFrame(st.session_state.insumos)
+        st.write(insumos_df)
+
+        pdf_file = generar_pdf(insumos_df, "Registro de Insumos Faltantes", "insumos.pdf")
+        st.download_button(
+            label="📥 Descargar PDF",
+            data=open(pdf_file, 'rb').read(),
+            file_name="insumos_faltantes.pdf",
+            mime="application/pdf"
+        )
+
+def buscar_datos_guardados():
+    st.title("🔍 Buscar Datos Guardados")
+
+    carpeta = "datos_guardados"
+    if not os.path.exists(carpeta):
+        st.info("No se encontraron archivos de datos guardados.")
+        return
+
+    archivos = listar_archivos_txt()
+
+    if archivos:
+        archivo_seleccionado = st.selectbox("Selecciona un archivo para ver:", archivos)
+        
+        if archivo_seleccionado:
+            datos = cargar_desde_txt(archivo_seleccionado)
+            if datos:
+                st.write(f"### Datos del archivo {archivo_seleccionado}")
+                for linea in datos.split('\n'):
+                    if linea.strip():  # Verificar si la línea no está vacía
+                        st.markdown(f"**{linea.split(':')[0]}:** {linea.split(':')[1]}")
+                # Link to download the file
+                try:
+                    with open(os.path.join(carpeta, archivo_seleccionado), 'rb') as file:
+                        st.download_button(
+                            label="📥 Descargar Archivo TXT",
+                            data=file,
+                            file_name=archivo_seleccionado,
+                            mime="text/plain"
+                        )
+                except Exception as e:
+                    st.error(f"Error al preparar la descarga: {e}")
+
+                # Enviar el archivo seleccionado por correo
+                if st.button("Enviar por correo"):
+                    contenido = f"Datos del archivo {archivo_seleccionado}:\n\n{datos}"
+                    enviar_correo("josedcape@gmail.com", f"Datos del archivo {archivo_seleccionado}", contenido)
+
+                # Enviar el archivo seleccionado por WhatsApp
+                if st.button("Enviar por WhatsApp"):
+                    mensaje = f"Datos del archivo {archivo_seleccionado}:\n\n{datos}"
+                    enviar_whatsapp("3114329322", mensaje)
+
+            else:
+                st.warning(f"No se encontraron datos en el archivo {archivo_seleccionado}")
+    else:
+        st.info("No se encontraron archivos de datos guardados.")
+
+def generar_notificaciones_pendientes():
+    if 'laboratorio' not in st.session_state or not st.session_state.laboratorio:
+        st.info("No hay trabajos pendientes.")
+        return
+    
+    pendientes = [trabajo for trabajo in st.session_state.laboratorio if trabajo["estado"] == "pendiente"]
+    if pendientes:
+        st.write("### Notificaciones de Trabajos Pendientes")
+        for trabajo in pendientes:
+            st.info(f"Pendiente: {trabajo['tipo_trabajo']} - {trabajo['numero_orden']} para {trabajo['doctor']}. Enviado a {trabajo['laboratorio']} el {trabajo['fecha_envio']}.")
+
+def mostrar_datos_como_texto(datos):
+    texto = ""
+    if isinstance(datos, dict):
+        for key, value in datos.items():
+            texto += f"{key}: {value}\n"
+    elif isinstance(datos, list):
+        for item in datos:
+            if isinstance(item, dict):
+                for key, value in item.items():
+                    texto += f"{key}: {value}\n"
+                texto += "\n"
+            else:
+                texto += f"{item}\n"
+    return texto
+
+def flujo_presupuestos():
+    st.title("💰 Asistente de Presupuestos")
+    st.markdown("Hola Dr. cuénteme en que puedo ayudarle?")
+
+    lista_precios = {
+        "Restauraciones en resina de una superficie": 75000,
+        "Restauraciones en resina de dos superficies": 95000,
+        "Restauraciones en resina de tres o más superficies": 120000,
+        "Restauración en resina cervical": 60000,
+        "Coronas metal-porcelana": 750000,
+        "Provisional": 80000,
+        "Profilaxis simple": 75000,
+        "Profilaxis completa": 90000,
+        "Corona en zirconio": 980000,
+        "Blanqueamiento dental láser por sesión": 150000,
+        "Blanqueamiento dental casero": 330000,
+        "Blanqueamiento mixto": 430000,
+        "Prótesis parcial acrílico hasta 6 dientes": 530000,
+        "Prótesis parcial acrílico de más de 6 dientes": 580000,
+        "Prótesis flexible hasta 6 dientes": 800000,
+        "Prótesis flexible de más de 6 dientes": 900000,
+        "Prótesis total de alto impacto": 650000,
+        "Acker flexible hasta 2 dientes": 480000,
+        "Exodoncia por diente": 85000,
+        "Exodoncia cordal": 130000,
+        "Endodoncia con dientes terminados en 6": 580000,
+        "Endodoncia de un conducto": 380000,
+        "Endodoncia de premolares superiores": 480000,
+    }
+
+    if 'presupuesto' not in st.session_state:
+        st.session_state['presupuesto'] = []
+
+    with st.form("presupuesto_form"):
+        tratamiento = st.selectbox("Selecciona el tratamiento", list(lista_precios.keys()))
+        cantidad = st.number_input("Cantidad", min_value=1, step=1)
+        agregar = st.form_submit_button("Agregar al Presupuesto")
+
+        if agregar:
+            precio_total = lista_precios[tratamiento] * cantidad
+            st.session_state['presupuesto'].append({"tratamiento": tratamiento, "cantidad": cantidad, "precio_total": precio_total})
+            st.success(f"Agregado: {cantidad} {tratamiento} - Total: {precio_total} COP")
+
+    if st.session_state['presupuesto']:
+        st.write("### Servicios Seleccionados")
+        total_presupuesto = sum(item['precio_total'] for item in st.session_state['presupuesto'])
+        for item in st.session_state['presupuesto']:
+            st.write(f"{item['cantidad']} x {item['tratamiento']} - {item['precio_total']} COP")
+        st.write(f"**Total: {total_presupuesto} COP**")
+
+        if st.button("Copiar Presupuesto al Asistente"):
+            servicios = "\n".join([f"{item['cantidad']} x {item['tratamiento']} - {item['precio_total']} COP" for item in st.session_state['presupuesto']])
+            total = f"**Total: {total_presupuesto} COP**"
+            st.session_state['presupuesto_texto'] = f"{servicios}\n{total}"
+            st.success("Presupuesto copiado al asistente de chat.")
+            st.session_state['mostrar_chat'] = True
+
+    if st.session_state['mostrar_chat']:
+        st.markdown("### Chat con Asistente")
+        pregunta_usuario = st.text_input("Escribe tu pregunta aquí:", value=st.session_state.get('presupuesto_texto', ''))
+        if st.button("Enviar Pregunta"):
+            manejar_pregunta_usuario(pregunta_usuario)
+
+def flujo_radiografias():
+    st.title("📸 Registro de Radiografías")
+
+    if 'radiografias' not in st.session_state:
+        st.session_state.radiografias = []
+
+    with st.form("radiografias_form"):
+        nombre_paciente = st.text_input("Nombre del Paciente:")
+        tipo_radiografia = st.selectbox("Tipo de Radiografía:", ["Periapical", "Panorámica", "Cefalométrica"])
+        fecha_realizacion = st.date_input("Fecha de Realización:")
+        observaciones = st.text_area("Observaciones:")
+        
+        submitted = st.form_submit_button("Registrar Radiografía")
+
+        if submitted:
+            radiografia = {
+                "nombre_paciente": nombre_paciente,
+                "tipo_radiografia": tipo_radiografia,
+                "fecha_realizacion": str(fecha_realizacion),
+                "observaciones": observaciones
+            }
+            st.session_state.radiografias.append(radiografia)
+            datos_guardados = mostrar_datos_como_texto([radiografia])
+            guardar_en_txt('radiografias.txt', datos_guardados)
+            st.success("Radiografía registrada con éxito.")
+
+    if st.session_state.radiografias:
+        st.write("### Radiografías Registradas")
+        df_radiografias = pd.DataFrame(st.session_state.radiografias)
+        st.write(df_radiografias)
+
+        pdf_file = generar_pdf(df_radiografias, "Registro de Radiografías", "radiografias.pdf")
+        st.download_button(
+            label="📥 Descargar PDF",
+            data=open(pdf_file, 'rb').read(),
+            file_name="radiografias.pdf",
+            mime="application/pdf"
+        )
+
+def mostrar_recomendaciones():
+    st.title("⭐ Recomendaciones")
+    st.write("Aquí puedes encontrar recomendaciones y consejos útiles.")
+
+def interpretar_imagen(imagen):
+    client = vision.ImageAnnotatorClient()
+    content = imagen.read()
+    image = vision.Image(content=content)
+    response = client.document_text_detection(image=image)
+
+    if response.error.message:
+        st.error(f"Error en la interpretación de la imagen: {response.error.message}")
+        return None
+
+    return response.full_text_annotation.text
+
+def mostrar_interpretacion_imagen():
+    st.title("🖼️ Interpretación de Imágenes con Google Vision")
+
+    imagen = st.file_uploader("Sube una imagen para interpretar", type=['png', 'jpg', 'jpeg'])
+
+    if imagen:
+        texto_interpretado = interpretar_imagen(imagen)
+        if texto_interpretado:
+            st.write("### Texto Interpretado:")
+            st.write(texto_interpretado)
+
+            st.session_state['mensajes_chat'].append({"role": "user", "content": texto_interpretado})
+            pregunta_usuario = st.text_input("Haz una pregunta sobre la imagen interpretada:")
+
+            if st.button("Enviar Pregunta"):
+                manejar_pregunta_usuario(pregunta_usuario, archivo_pdf=None, contexto=texto_interpretado)
+
+def main():
+    st.set_page_config(page_title="Galatea OMARDENT", layout="wide")
+    
+    # Inicializar el estado de la sesión
+    if 'modelo' not in st.session_state:
+        st.session_state['modelo'] = "gpt-3.5-turbo"
+    if 'temperatura' not in st.session_state:
+        st.session_state['temperatura'] = 0.5
+    if 'mensajes_chat' not in st.session_state:
+        st.session_state['mensajes_chat'] = []
+    if 'transcripcion_voz' not in st.session_state:
+        st.session_state['transcripcion_voz'] = ""
+    if 'imagen_asistente' not in st.session_state:
+        st.session_state['imagen_asistente'] = None
+    if 'video_estado' not in st.session_state:
+        st.session_state['video_estado'] = 'paused'
+    if 'assistant_id' not in st.session_state:
+        st.session_state['assistant_id'] = 'asst_4ZYvBvf4IUVQPjnugSZGLdV2'
+    if 'presupuesto_texto' not in st.session_state:
+        st.session_state['presupuesto_texto'] = ''
+    if 'mostrar_chat' not in st.session_state:
+        st.session_state['mostrar_chat'] = False
+    if 'memoria' not in st.session_state:
+        st.session_state['memoria'] = {}
+
+    # Cargar y preprocesar el texto del PDF predefinido
+    with open("assets/instrucciones.pdf", "rb") as file:
+        texto_pdf = extraer_texto_pdf(file)
+        st.session_state['texto_preprocesado_pdf'] = preprocesar_texto(texto_pdf)
+
+    # Barra lateral
+    ruta_logo = os.path.join("assets", "Logo Omardent.png")
+    if os.path.exists(ruta_logo):
+        st.sidebar.image(ruta_logo, use_column_width=True)
+    else:
+        st.sidebar.warning(f"Error: No se pudo encontrar la imagen en la ruta: {ruta_logo}")
+
+    st.sidebar.title("🤖 Galatea OMARDENT")
+    st.sidebar.markdown("---")
+    st.sidebar.subheader("🧠 Configuración del Modelo")
+    st.session_state['modelo'] = st.sidebar.selectbox(
+        "Selecciona el modelo:",
+        ["gpt-3.5-turbo", "gpt-4", "gpt-4-32k", "gpt-4o"],
+        index=0,
+        key='modelo_selectbox',  # Clave única
+        help="Elige el modelo de lenguaje de OpenAI que prefieras."
+    )
+    st.sidebar.markdown("---")
+    st.session_state['temperatura'] = st.sidebar.slider(
+        "🌡️ Temperatura",
+        min_value=0.0, max_value=1.0,
+        value=st.session_state['temperatura'],
+        step=0.1,
+        key='temperatura_slider'  # Clave única
+    )
+    assistant_id = st.sidebar.text_input("Assistant ID", key="assistant_id", help="Introduce el Assistant ID del playground de OpenAI")
+    
+    st.sidebar.markdown("---")
+    st.sidebar.subheader("🌟 Navegación")
+    lateral_page = st.sidebar.radio("Ir a", ["Página Principal", "Gestión de Trabajos", "Gestión de Insumos", "Registro de Radiografías", "Buscar Datos", "Notificaciones", "Recomendaciones", "Asistente de Presupuestos", "Comunicación", "Asistente de Agendamiento", "Interpretación de Imágenes"])
+
+    top_page = st.selectbox("Navegación Superior", ["Página Principal", "Galatea-Asistente"])
+
+    if top_page == "Galatea-Asistente":
+        mostrar_galatea_asistente()
+    else:
+        if lateral_page == "Página Principal":
+            mostrar_pagina_principal()
+        elif lateral_page == "Gestión de Trabajos":
+            flujo_laboratorio()
+        elif lateral_page == "Gestión de Insumos":
+            flujo_insumos()
+        elif lateral_page == "Registro de Radiografías":
+            flujo_radiografias()
+        elif lateral_page == "Buscar Datos":
+            buscar_datos_guardados()
+        elif lateral_page == "Notificaciones":
+            generar_notificaciones_pendientes()
+        elif lateral_page == "Recomendaciones":
+            mostrar_recomendaciones()
+        elif lateral_page == "Asistente de Presupuestos":
+            flujo_presupuestos()
+        elif lateral_page == "Comunicación":
+            st.write("Página de Comunicación")  # Implementar según sea necesario
+        elif lateral_page == "Asistente de Agendamiento":
+            st.write("Página de Agendamiento")  # Implementar según sea necesario
+        elif lateral_page == "Interpretación de Imágenes":
+            mostrar_interpretacion_imagen()
+
+def mostrar_pagina_principal():
+    st.title("VIRTUAL OMARDENT AI-BOTIDINAMIX")
+    st.markdown(
+        f"""
+        <style>
+        #video-container {{
+            position: relative;
+            width: 100%;
+            padding-bottom: 56.25%;
+            background-color: lightblue;
+            overflow: hidden;
+        }}
+        #background-video {{
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+        }}
+        </style>
+        <div id="video-container">
+            <video id="background-video" autoplay loop muted playsinline>
+                <source src="https://cdn.leonardo.ai/users/645c3d5c-ca1b-4ce8-aefa-a091494e0d09/generations/0c4f0fe7-5937-4644-b984-bdbd95018990/0c4f0fe7-5937-4644-b984-bdbd95018990.mp4" type="video/mp4">
+            </video>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+
+    archivo_pdf = st.file_uploader("📂 Cargar PDF", type='pdf', key='chat_pdf')
+
+    col1, col2 = st.columns([3, 1])
+    with col1:
+        pregunta_usuario = st.text_input("Pregunta:", key='unique_chat_input_key', value=st.session_state['transcripcion_voz'])
+    with col2:
+        capturar_voz()
+    
+    if pregunta_usuario:
+        manejar_pregunta_usuario(pregunta_usuario, archivo_pdf)
+
+def mostrar_galatea_asistente():
+    st.markdown(
+        """
+        <style>
+        #video-container {
+            position: relative;
+            width: 100%;
+            height: 40vh;
+            background-color: lightblue;
+            overflow: hidden;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+        }
+        #background-video {
+            width: 100%;
+            height: auto;
+        }
+        #chat-container {
+            margin-top: 20px;
+            width: 100%;
+            display: flex;
+            flex-direction: column;
+            justify-content: center;
+            align-items: center;
+        }
+        .chat-message {
+            background: rgba(255, 255, 255, 0.8);
+            border-radius: 10px;
+            padding: 10px;
+            margin-bottom: 10px;
+            max-width: 70%;
+            border: 2px solid #007BFF;
+        }
+        .chat-message.user {
+            align-self: flex-start;
+        }
+        .chat-message.assistant {
+            align-self: flex-end;
+            background: rgba(0, 123, 255, 0.8);
+            color: white;
+        }
+        </style>
+        <div id="video-container">
+            <video id="background-video" autoplay loop muted playsinline>
+                <source src="https://cdn.pika.art/v1/081128be-944b-4999-9c2e-16f61d7e7a83/lip_sync.mp4" type="video/mp4">
+            </video>
+        </div>
+        <div id="chat-container">
+        """,
+        unsafe_allow_html=True
+    )
+
+    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)
+
+    pregunta_usuario = st.text_input("Escribe tu pregunta aquí:", key='unique_chat_input_key', value=st.session_state['transcripcion_voz'])
+    if st.button("Enviar Pregunta"):
+        manejar_pregunta_usuario(pregunta_usuario)
+
+    st.markdown("</div>", unsafe_allow_html=True)
+
+    if st.session_state['imagen_asistente']:
+        st.image(st.session_state['imagen_asistente'], use_column_width=True)
+    else:
+        st.warning("No se ha cargado ninguna imagen. Por favor, carga una imagen en la página principal.")
+
+def manejar_pregunta_usuario(pregunta_usuario, archivo_pdf=None, contexto=""):
+    st.session_state['mensajes_chat'].append({"role": "user", "content": pregunta_usuario})
+    with st.chat_message("user"):
+        st.markdown(pregunta_usuario)
+
+    texto_preprocesado = ""
+    if archivo_pdf:
+        texto_pdf = extraer_texto_pdf(archivo_pdf)
+        texto_preprocesado = preprocesar_texto(texto_pdf)
+    else:
+        texto_preprocesado = st.session_state['texto_preprocesado_pdf']
+
+    # Obtener respuesta del modelo usando Assistant ID si está presente
+    assistant_id = st.session_state.get('assistant_id', '')
+    if assistant_id:
+        prompt = f"{contexto}\n\n{pregunta_usuario}"
+        response = openai.ChatCompletion.create(
+            model=st.session_state['modelo'],
+            messages=[
+                {"role": "system", "content": "Actúa como Galatea, la asistente de la clínica Odontológica Omardent, y resuelve las inquietudes."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=st.session_state['temperatura'],
+            user=assistant_id
+        )
+        respuesta = response.choices[0].message['content'].strip()
+    else:
+        respuesta = obtener_respuesta(
+            pregunta_usuario,
+            texto_preprocesado,
+            st.session_state['modelo'],
+            st.session_state['temperatura'],
+            assistant_id,
+            contexto
+        )
+    
+    st.session_state['mensajes_chat'].append({"role": "assistant", "content": respuesta})
+    with st.chat_message("assistant"):
+        st.markdown(respuesta)
+
+    # Convertir la respuesta en voz
+    client = texttospeech.TextToSpeechClient()
+    synthesis_input = 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)
+    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
+
+    # Incrustar el audio en la página y reproducirlo automáticamente
+    audio_html = f"""
+    <audio id="response-audio" src="data:audio/mp3;base64,{base64.b64encode(response.audio_content).decode()}" autoplay></audio>
+    <script>
+    document.getElementById('response-audio').onended = function() {{
+        document.getElementById('background-video').pause();
+    }};
+    </script>
+    """
+    st.markdown(audio_html, unsafe_allow_html=True)
+
+    # Reproducir el video solo cuando el chat está activo
+    st.session_state['video_estado'] = 'playing'
+    st.markdown(f"<script>document.getElementById('background-video').play();</script>", unsafe_allow_html=True)
+
+    # Almacenar la información importante en la memoria
+    if "nombre" in pregunta_usuario.lower() or "teléfono" in pregunta_usuario.lower():
+        st.session_state['memoria']['última_interacción'] = pregunta_usuario
+        guardar_en_txt('memoria_asistente.txt', f"Última interacción: {pregunta_usuario}")
+
+def capturar_voz():
+    st.markdown(
+        """
+        <style>
+        .assistant-button {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background-color: #4CAF50;
+            color: white;
+            padding: 10px;
+            border: none;
+            border-radius: 5px;
+            cursor: pointer;
+            font-size: 16px;
+            margin-top: 10px;
+        }
+        .assistant-button img {
+            margin-right: 10px;
+        }
+        </style>
+        <button class="assistant-button" onclick="startRecording()">
+            <img src='https://img2.gratispng.com/20180808/cxq/kisspng-robotics-science-computer-icons-robot-technology-robo-to-logo-svg-png-icon-free-download-45527-5b6baa46a5e322.4713113715337825986795.jpg' alt='icon' width='20' height='20'/>
+            Capturar Voz
+        </button>
+        <script>
+            function startRecording() {
+                const recognition = new (window.SpeechRecognition || window.webkitSpeechRecognition)();
+                recognition.lang = 'es-ES';
+                recognition.interimResults = false;
+                recognition.maxAlternatives = 1;
+                recognition.start();
+                recognition.onresult = (event) => {
+                    const lastResult = event.results.length - 1;
+                    const text = event.results[lastResult][0].transcript;
+                    const customEvent = new CustomEvent('audioTranscription', { detail: text });
+                    document.dispatchEvent(customEvent);
+                };
+                recognition.onspeechend = () => {
+                    recognition.stop();
+                };
+                recognition.onerror = (event) => {
+                    console.error(event.error);
+                };
+            }
+            document.addEventListener('audioTranscription', (event) => {
+                const transcription = event.detail;
+                document.querySelector("input[name='unique_chat_input_key']").value = transcription;
+                // También puedes actualizar el estado de Streamlit aquí si es necesario
+                fetch('/process_audio', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ transcription })
+                }).then(response => response.json())
+                  .then(data => {
+                      // Manejo de la respuesta de Flask si es necesario
+                  });
+            });
+        </script>
+        """,
+        unsafe_allow_html=True
+    )
+
+if __name__ == "__main__":
+    main()

audio_recorder.html

@@ -0,0 +1,57 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Audio Recorder</title>
+</head>
+<body>
+    <button id="startRecording" onclick="startRecording()">Start Recording</button>
+    <button id="stopRecording" onclick="stopRecording()" disabled>Stop Recording</button>
+    <script>
+        let mediaRecorder;
+        let audioChunks = [];
+
+        function startRecording() {
+            navigator.mediaDevices.getUserMedia({ audio: true })
+                .then(stream => {
+                    mediaRecorder = new MediaRecorder(stream);
+                    mediaRecorder.start();
+
+                    mediaRecorder.addEventListener("dataavailable", event => {
+                        audioChunks.push(event.data);
+                    });
+
+                    mediaRecorder.addEventListener("stop", () => {
+                        const audioBlob = new Blob(audioChunks);
+                        audioChunks = [];
+                        const reader = new FileReader();
+                        reader.readAsDataURL(audioBlob);
+                        reader.onloadend = () => {
+                            const base64AudioMessage = reader.result.split(',')[1];
+                            fetch('/process_audio', {
+                                method: 'POST',
+                                headers: {
+                                    'Content-Type': 'application/json'
+                                },
+                                body: JSON.stringify({ audio_data: base64AudioMessage })
+                            }).then(response => response.json())
+                              .then(data => {
+                                  const event = new CustomEvent('audioTranscription', { detail: data.transcription });
+                                  document.dispatchEvent(event);
+                              });
+                        };
+                    });
+
+                    document.getElementById("startRecording").disabled = true;
+                    document.getElementById("stopRecording").disabled = false;
+                });
+        }
+
+        function stopRecording() {
+            mediaRecorder.stop();
+            document.getElementById("startRecording").disabled = false;
+            document.getElementById("stopRecording").disabled = true;
+        }
+    </script>
+</body>
+</html>

botidinamix-g.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "assistant-9nteod",
+  "private_key_id": "2a6b434c79db1c61fd01a4aa0fdb4581abd03134",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDf3Kus0HiXPybh\n06C05KvyuM/LfHBQXIMdMRDHaCp8Wj17h8HOmND7P+e/DcM45AevY2xfvq5ZOMCa\nCEFGXQHaiy6kDYpBiEzBYaLK2mfamUdkURejsE4yZr3piZkhJ4+lGke+jouAey01\nxwM5bVaCUSP1iWcryHrohaOr9rhbniCDheXu4J7d+q/ajyC8iw2UHKbL2RXwuK1y\nl7BAUxEGxLtu4yREWBo3dK0f9z/s3Vpva4zUuDbXqflgazDm0ak5ruRqAk/x6Xqy\nz9jhX3IuJc+MDlGiGDtNo40obT9jyknkbD03lmdRLlPeFNqNoiOeUOWIFX+YtsA0\noB0LixiHAgMBAAECggEAHdKn8PUG6Qip6pIxydeK9reF60hv2AIzGhZOyMSeSwRk\nm3U0WGHFuYBuebvgzaPx8tIj08Td35dZb/Z4kmH9R2WdDZBGN8EWOfmtYSk5MQc+\n2mTulB5+lGVZQz2oWkvgbZuI16CQLMomyuVxObB7bWSs4zRDu91Qo8h7S63/Kn6F\nwt41fHsJmRwSV21ZMzrYtFXrmYuNZxsfhzLV1JFiPF+LgJT+AojhZO1r4FtDS+kI\nBtoD8QZn+T5+TDgj7NLDL+kMn8EWQU2o+PQDtbi69hQxHTo4rxdXB5z6BmZbPt9B\n7jLIRS/rfeaPgvdjSi0z7IsJWEbZlu9KSeUfkgZoxQKBgQD1XU/7sGZqiF7GO9yr\ncm2rAvFh1e+/jOd1iwQ48KJ8lITO52lEyLq53T+OAJbULWseHXi0VQNsd7kzs0Zl\nIVImOuHsG087vXVrxk75yzJBuwPCBMakBKRtkcpETEti477yo+Szw3mKEmsBfHYr\nMW5+MISaWbPzqQ7O51Fx0h1MjQKBgQDpkMFs7ID+ski1sRm4K1Szo+RWhm1ag8Mb\nIYJhcL0K1WRFfIyTyzm5krrXsUQTydX/oNinMtv/hS379CgyqobWO85+YBh3kYbZ\nn8FOJOhJ176sE4soti8p5aktyQSpqjVVtsf7OKw50CgGE5lAxxGOolQTD4d8zYjL\n9y7o8QP2YwKBgEvRYLS6Rntm1jpVJxQHUOIGD8aWj/XVuXP12AEsQllSn1M76Khr\nil+CgXAEuJapzi7JFpJKrrsmp6DVJcx8JmFP0p3dtncUTSNXbPH9GvN6sWeTiDoI\ngTKmWSUPmj/ddhSOFk6B+Z1zoYMdDXq9VJJDtcXoMBX7yGqgyebs8UbFAoGAAY6y\ni3xkO86Kh5OfvUekr/H20tDgp8rbITIvAWFUEV9s5L243j9rqh4dWtTWxF8DK0oy\nR6MiLmj/7n8pSXUzovgRH2yanSl+QbM8Ab5jQiLLJbCXq/TTCa97Wk/N1SfKZUDr\nwnQVSelmauv0iKcLKe1RLDNdTuq778g9KtZ4lUsCgYBebKvZbG8S9xHZcUNBxEty\nKCtknf2DoO3cvQ6zCEaIaMbdRH+NEuBxgGYKX2brHLSxJSOaAWoX+yiIxFlHdAAz\n0BiMkgqnJThevrfEs30zTYQBU78HP8WUnzUqsqwooqr7ry4hq5z78RXL0NP8BepH\nBavhIQYovXSFy6l0m6JFng==\n-----END PRIVATE KEY-----\n",
+  "client_email": "botidinamix@assistant-9nteod.iam.gserviceaccount.com",
+  "client_id": "104652076455278864571",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/botidinamix%40assistant-9nteod.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}

env (1)

@@ -0,0 +1,5 @@
+OPENAI_API_KEY ='sk-proj-3LjZDUxPCK7NOxAGsBrcT3BlbkFJPwq200vDWf5JG2YWgAsx'
+GOOGLE_APPLICATION_CREDENTIALS='botidinamix-g.json'	
+BREVO_API_KEY='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'
+SUPABASE_URL='https://tifknbrtyuhxhqtmvywx.supabase.co
+SUPABASE_API_KEY='eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InRpZmtuYnJ0eXVoeGhxdG12eXd4Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3MDAxMzM4OTUsImV4cCI6MjAxNTcwOTg5NX0.M-kT-5VSN1FSKtecO0luQvEGaOz7B28q44RWxTMeOus'

gitattributes

@@ -0,0 +1,37 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+Hola[[:space:]]Bienv(1).mp4 filter=lfs diff=lfs merge=lfs -text
+Welcome[[:space:]]to.mp4 filter=lfs diff=lfs merge=lfs -text

google_calendar (1).py

@@ -0,0 +1,43 @@
+import os
+import pickle
+import datetime
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from google.auth.transport.requests import Request
+from googleapiclient.discovery import build
+
+SCOPES = ['https://www.googleapis.com/auth/calendar']
+
+def get_calendar_service():
+    creds = None
+    if os.path.exists('token.pickle'):
+        with open('token.pickle', 'rb') as token:
+            creds = pickle.load(token)
+    if not creds or not creds.valid:
+        if creds and creds.expired and creds.refresh_token:
+            creds.refresh(Request())
+        else:
+            flow = InstalledAppFlow.from_client_secrets_file(
+                'credentials.json', SCOPES)
+            creds = flow.run_local_server(port=0)
+        with open('token.pickle', 'wb') as token:
+            pickle.dump(creds, token)
+    service = build('calendar', 'v3', credentials=creds)
+    return service
+
+def add_event(summary, description, start_time, end_time):
+    service = get_calendar_service()
+    event = {
+        'summary': summary,
+        'description': description,
+        'start': {
+            'dateTime': start_time,
+            'timeZone': 'America/Bogota',
+        },
+        'end': {
+            'dateTime': end_time,
+            'timeZone': 'America/Bogota',
+        },
+    }
+    event = service.events().insert(calendarId='primary', body=event).execute()
+    return event.get('htmlLink')

pages_agendamiento.py

@@ -0,0 +1,37 @@
+import streamlit as st
+from datetime import datetime, timedelta
+from google.oauth2.service_account import Credentials
+from googleapiclient.discovery import build
+
+def show():
+    st.title("📅 Asistente de Agendamiento")
+
+    SCOPES = ['https://www.googleapis.com/auth/calendar']
+    creds = Credentials.from_service_account_file('botidinamix-g.json', scopes=SCOPES)
+    service = build('calendar', 'v3', credentials=creds)
+
+    with st.form("agendamiento_form"):
+        paciente = st.text_input("Nombre del Paciente:")
+        doctor = st.selectbox("Doctor", ["Dr. José Daniel", "Dr. José Omar"])
+        motivo = st.text_area("Motivo de la consulta:")
+        fecha_cita = st.date_input("Fecha de la cita:")
+        hora_cita = st.time_input("Hora de la cita:")
+        submitted = st.form_submit_button("Agendar Cita")
+
+        if submitted:
+            start_time = datetime.combine(fecha_cita, hora_cita)
+            end_time = start_time + timedelta(hours=1)
+            event = {
+                'summary': f'Cita con {doctor} - {paciente}',
+                'description': motivo,
+                'start': {
+                    'dateTime': start_time.isoformat(),
+                    'timeZone': 'America/Bogota',
+                },
+                'end': {
+                    'dateTime': end_time.isoformat(),
+                    'timeZone': 'America/Bogota',
+                },
+            }
+            event = service.events().insert(calendarId='primary', body=event).execute()
+            st.success(f'Cita agendada para {paciente} con {doctor} el {start_time}')

pages_buscar_datos.py

@@ -0,0 +1,30 @@
+# pages/buscar_datos.py
+import streamlit as st
+from utils.data_manager import cargar_desde_txt, listar_archivos_txt
+
+def show():
+    st.title("🔍 Buscar Datos Guardados")
+
+    archivos = listar_archivos_txt()
+
+    if archivos:
+        archivo_seleccionado = st.selectbox("Selecciona un archivo para ver:", archivos)
+        
+        if archivo_seleccionado:
+            datos = cargar_desde_txt(archivo_seleccionado)
+            if datos:
+                st.write(f"### Datos del archivo {archivo_seleccionado}")
+                st.text_area("Datos", datos, height=300)
+
+                # Link to download the file
+                with open(archivo_seleccionado, 'rb') as file:
+                    st.download_button(
+                        label="📥 Descargar Archivo TXT",
+                        data=file,
+                        file_name=archivo_seleccionado,
+                        mime="text/plain"
+                    )
+            else:
+                st.warning(f"No se encontraron datos en el archivo {archivo_seleccionado}")
+    else:
+        st.info("No se encontraron archivos de datos guardados.")

pages_comunicacion.py

@@ -0,0 +1,25 @@
+import streamlit as st
+from utils.data_manager import enviar_correo, enviar_whatsapp
+
+def show():
+    st.title("📧 Comunicación")
+
+    st.subheader("Enviar Correo Electrónico")
+    destinatario_correo = st.text_input("Correo del destinatario:")
+    asunto_correo = st.text_input("Asunto del correo:")
+    contenido_correo = st.text_area("Contenido del correo:")
+    if st.button("Enviar Correo"):
+        if destinatario_correo and asunto_correo and contenido_correo:
+            enviar_correo(destinatario_correo, asunto_correo, contenido_correo)
+        else:
+            st.warning("Por favor, completa todos los campos del correo.")
+
+    st.markdown("---")
+    st.subheader("📱 Enviar Mensaje de WhatsApp")
+    numero_whatsapp = st.text_input("Número de WhatsApp del destinatario:")
+    mensaje_whatsapp = st.text_area("Mensaje de WhatsApp:")
+    if st.button("Enviar WhatsApp"):
+        if numero_whatsapp and mensaje_whatsapp:
+            enviar_whatsapp(numero_whatsapp, mensaje_whatsapp)
+        else:
+            st.warning("Por favor, completa todos los campos del mensaje de WhatsApp.")

pages_correo.py

@@ -0,0 +1,5 @@
+import streamlit as st
+from utils.data_manager import flujo_enviar_correo
+
+def show():
+    flujo_enviar_correo()

pages_galatea_asistente.py

@@ -0,0 +1,161 @@
+import os
+import tempfile
+import openai
+import streamlit as st
+import PyPDF2
+
+from dotenv import load_dotenv
+
+# Configurar página de Streamlit
+st.set_page_config(page_title="Galatea Asistente", layout="wide")
+
+# Función para inicializar el estado de la sesión
+def inicializar_estado():
+    if 'modelo' not in st.session_state:
+        st.session_state['modelo'] = "gpt-3.5-turbo"
+    if 'temperatura' not in st.session_state:
+        st.session_state['temperatura'] = 0.5
+    if 'mensajes_chat' not in st.session_state:
+        st.session_state['mensajes_chat'] = []
+    if 'transcripcion_voz' not in st.session_state:
+        st.session_state['transcripcion_voz'] = ""
+    if 'texto_preprocesado_pdf' not in st.session_state:
+        st.session_state['texto_preprocesado_pdf'] = ""
+
+inicializar_estado()
+
+# Configuración de la barra lateral
+st.sidebar.title("Configuración del Asistente")
+st.sidebar.subheader("Modelo de Lenguaje")
+st.session_state['modelo'] = st.sidebar.selectbox(
+    "Selecciona el modelo:",
+    ["gpt-3.5-turbo", "gpt-4"],
+    index=0
+)
+st.sidebar.subheader("Ajustes del Modelo")
+st.session_state['temperatura'] = st.sidebar.slider(
+    "Temperatura",
+    min_value=0.0, max_value=1.0,
+    value=st.session_state['temperatura'],
+    step=0.1
+)
+st.sidebar.text_input("Assistant ID", key="assistant_id", help="Introduce el Assistant ID del playground de OpenAI")
+
+# Función para extraer texto de un PDF
+def extraer_texto_pdf(ruta_archivo):
+    texto = ""
+    try:
+        with open(ruta_archivo, 'rb') as file:
+            reader = PyPDF2.PdfReader(file)
+            for page in range(len(reader.pages)):
+                texto += reader.pages[page].extract_text()
+    except Exception as e:
+        st.error(f"Error al extraer texto del PDF: {e}")
+    return texto
+
+# Cargar y preprocesar el texto del PDF predefinido
+ruta_pdf_predefinido = "/assets/instrucciones.pdf"  # Actualiza esta ruta con la ruta real de tu archivo PDF
+texto_pdf = extraer_texto_pdf(ruta_pdf_predefinido)
+st.session_state['texto_preprocesado_pdf'] = texto_pdf
+
+# Función para manejar la pregunta del usuario
+def manejar_pregunta_usuario(pregunta_usuario):
+    st.session_state['mensajes_chat'].append({"role": "user", "content": pregunta_usuario})
+    with st.chat_message("user"):
+        st.markdown(pregunta_usuario)
+    
+    # Aquí debes agregar la lógica para obtener la respuesta del modelo
+    contexto = st.session_state['texto_preprocesado_pdf']
+    respuesta = obtener_respuesta(pregunta_usuario, contexto)
+    
+    st.session_state['mensajes_chat'].append({"role": "assistant", "content": respuesta})
+    with st.chat_message("assistant"):
+        st.markdown(respuesta)
+
+# Función para obtener la respuesta del modelo
+def obtener_respuesta(pregunta, contexto):
+    try:
+        response = openai.Completion.create(
+            model=st.session_state['modelo'],
+            prompt=f"Eres Galatea, un auxiliar de odontología en la clínica odontológica Omardent. Resuelve las inquietudes de los pacientes basándote en el siguiente contexto:\n\n{contexto}\n\nPregunta: {pregunta}\nRespuesta:",
+            max_tokens=150,
+            temperature=st.session_state['temperatura']
+        )
+        return response.choices[0].text.strip()
+    except Exception as e:
+        st.error(f"Error al obtener respuesta del modelo: {e}")
+        return "Lo siento, ocurrió un error al procesar tu solicitud."
+
+# Mostrar el fondo de video y superponer texto
+st.markdown(
+    """
+    <style>
+    #video-container {
+        position: relative;
+        width: 100%;
+        height: 90vh;
+        overflow: hidden;
+    }
+    #background-video {
+        position: absolute;
+        top: 0;
+        left: 0;
+        width: 90%;
+        height: 90%;
+        object-fit: cover;
+        z-index: -1;
+    }
+    #chat-container {
+        position: absolute;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        display: flex;
+        flex-direction: column;
+        justify-content: flex-end;
+        padding: 20px;
+        box-sizing: border-box;
+    }
+    .chat-message {
+        background: rgba(255, 255, 255, 0.8);
+        border-radius: 10px;
+        padding: 10px;
+        margin-bottom: 10px;
+        max-width: 70%;
+        border: 2px solid #007BFF;  /* Borde azul */
+    }
+    .chat-message.user {
+        align-self: flex-start;
+        border-color: #007BFF;  /* Borde azul para usuario */
+    }
+    .chat-message.assistant {
+        align-self: flex-end;
+        background: rgba(0, 123, 255, 0.8);
+        color: white;
+        border-color: #0056b3;  /* Borde azul oscuro para asistente */
+    }
+    </style>
+    <div id="video-container">
+        <video id="background-video" autoplay loop muted>
+            <source src="https://cdn.leonardo.ai/users/645c3d5c-ca1b-4ce8-aefa-a091494e0d09/generations/0c4f0fe7-5937-4644-b984-bdbd95018990/0c4f0fe7-5937-4644-b984-bdbd95018990.mp4" type="video/mp4">
+        </video>
+        <div id="chat-container">
+    """,
+    unsafe_allow_html=True
+)
+
+# 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)
+
+# Campo de entrada de texto para el usuario
+pregunta_usuario = st.text_input("Escribe tu pregunta aquí:", key='unique_chat_input_key', value=st.session_state['transcripcion_voz'])
+if st.button("Enviar Pregunta"):
+    manejar_pregunta_usuario(pregunta_usuario)
+
+st.markdown("</div></div>", unsafe_allow_html=True)
+
+# Incluir imagen de fondo (opcional)
+st.image("/mnt/data/clara asesora.jpg", use_column_width=True)

pages_home.py

@@ -0,0 +1,65 @@
+# pages/home.py
+import os 
+import streamlit as st
+from utils.data_manager import (
+    extraer_texto_pdf, 
+    preprocesar_texto, 
+    obtener_respuesta
+)
+
+def show():
+    st.header("💬 Hablar con Galatea OMARDENT")
+
+    # Inicializa los valores predeterminados si no existen
+    if 'modelo' not in st.session_state:
+        st.session_state.modelo = "gpt-3.5-turbo"
+    if 'temperatura' not in st.session_state:
+        st.session_state.temperatura = 0.5
+
+    # --- Barra lateral ---
+    with st.sidebar:
+        st.image(os.path.join("assets", "Logo Omardent.png"), use_column_width=True)
+        st.title("🤖 Galatea OMARDENT")
+        st.markdown("---")
+
+        # Selección de modelo de lenguaje
+        st.subheader("🧠 Configuración del Modelo")
+        st.session_state.modelo = st.selectbox(
+            "Selecciona el modelo:",
+            ["gpt-3.5-turbo", "gpt-4", "gpt-4-32k"],
+            index=0,
+            help="Elige el modelo de lenguaje de OpenAI que prefieras."
+        )
+
+        # Opciones adicionales
+        st.markdown("---")
+        st.session_state.temperatura = st.slider("🌡️ Temperatura", min_value=0.0, max_value=1.0, value=st.session_state.temperatura, step=0.1)
+
+    # --- Área principal de la aplicación ---
+    # Carga de archivo PDF
+    archivo_pdf = st.file_uploader("📂 Cargar PDF", type='pdf')
+
+    # --- Chatbot ---
+    if 'mensajes' not in st.session_state:
+        st.session_state.mensajes = []
+
+    for mensaje in st.session_state.mensajes:
+        with st.chat_message(mensaje["role"]):
+            st.markdown(mensaje["content"])
+
+    pregunta_usuario = st.chat_input("Pregunta:")
+    if pregunta_usuario:
+        st.session_state.mensajes.append({"role": "user", "content": pregunta_usuario})
+        with st.chat_message("user"):
+            st.markdown(pregunta_usuario)
+
+        if archivo_pdf:
+            texto_pdf = extraer_texto_pdf(archivo_pdf)
+            texto_preprocesado = preprocesar_texto(texto_pdf)
+        else:
+            texto_preprocesado = ""  
+
+        respuesta = obtener_respuesta(pregunta_usuario, texto_preprocesado, st.session_state.modelo, st.session_state.temperatura)
+        st.session_state.mensajes.append({"role": "assistant", "content": respuesta})
+        with st.chat_message("assistant"):
+            st.markdown(respuesta)

pages_insumos.py

@@ -0,0 +1,6 @@
+import streamlit as st
+from utils.data_manager import flujo_insumos
+
+def show():
+    flujo_insumos()
+

pages_notificaciones.py

@@ -0,0 +1,6 @@
+# pages/notificaciones.py
+import streamlit as st
+from utils.data_manager import generar_notificaciones_pendientes
+
+def show():
+    generar_notificaciones_pendientes()

pages_presupuesto.py

@@ -0,0 +1,123 @@
+import streamlit as st
+from utils.data_manager import flujo_presupuestos, obtener_respuesta
+
+def show():
+    st.title("💰 Asistente de Presupuestos")
+    st.markdown("Hola Dr. cuénteme en qué puedo ayudarle?")
+
+    # Listado de precios
+    lista_precios = {
+        "Restauraciones en resina de una superficie": 75000,
+        "Restauraciones en resina de dos superficies": 95000,
+        "Restauraciones en resina de tres o más superficies": 120000,
+        "Restauración en resina cervical": 60000,
+        "Coronas metal-porcelana": 750000,
+        "Provisional": 80000,
+        "Profilaxis simple": 75000,
+        "Profilaxis completa": 90000,
+        "Corona en zirconio": 980000,
+        "Blanqueamiento dental láser por sesión": 150000,
+        "Blanqueamiento dental casero": 330000,
+        "Blanqueamiento mixto": 430000,
+        "Prótesis parcial acrílico hasta 6 dientes": 530000,
+        "Prótesis parcial acrílico de más de 6 dientes": 580000,
+        "Prótesis flexible hasta 6 dientes": 800000,
+        "Prótesis flexible de más de 6 dientes": 900000,
+        "Prótesis total de alto impacto": 650000,
+        "Acker flexible hasta 2 dientes": 480000,
+        "Exodoncia por diente": 85000,
+        "Exodoncia cordal": 130000,
+        "Endodoncia con dientes terminados en 6": 580000,
+        "Endodoncia de un conducto": 380000,
+        "Endodoncia de premolares superiores": 480000,
+    }
+
+    if 'presupuesto' not in st.session_state:
+        st.session_state['presupuesto'] = []
+
+    # Mostrar lista de precios en un menú desplegable
+    with st.expander("Mostrar Lista de Precios"):
+        st.markdown("### Lista de Precios")
+        for tratamiento, precio in lista_precios.items():
+            st.markdown(f"**{tratamiento}:** {precio} COP")
+
+    # Selección de tratamientos y cantidad
+    tratamiento = st.selectbox("Selecciona el tratamiento", list(lista_precios.keys()))
+    cantidad = st.number_input("Cantidad", min_value=1, step=1)
+    agregar = st.button("Agregar al Presupuesto")
+
+    if agregar:
+        precio_total = lista_precios[tratamiento] * cantidad
+        st.session_state['presupuesto'].append({"tratamiento": tratamiento, "cantidad": cantidad, "precio_total": precio_total})
+        st.success(f"Agregado: {cantidad} {tratamiento} - Total: {precio_total} COP")
+
+    # Mostrar servicios seleccionados y total
+    if st.session_state['presupuesto']:
+        st.write("### Servicios Seleccionados")
+        total_presupuesto = sum(item['precio_total'] for item in st.session_state['presupuesto'])
+        for item in st.session_state['presupuesto']:
+            st.write(f"{item['cantidad']} x {item['tratamiento']} - {item['precio_total']} COP")
+        st.write(f"**Total: {total_presupuesto} COP**")
+
+    # Copiar presupuesto al asistente de chat
+    copiar_presupuesto = st.button("Copiar Presupuesto al Asistente")
+    if copiar_presupuesto:
+        servicios = "\n".join([f"{item['cantidad']} x {item['tratamiento']} - {item['precio_total']} COP" for item in st.session_state['presupuesto']])
+        total = f"**Total: {total_presupuesto} COP**"
+        st.session_state['presupuesto_texto'] = f"{servicios}\n{total}"
+        st.success("Presupuesto copiado al asistente de chat.")
+
+    if 'mostrar_chat' not in st.session_state:
+        st.session_state['mostrar_chat'] = False
+
+    def mostrar_chat():
+        st.session_state['mostrar_chat'] = not st.session_state['mostrar_chat']
+
+    st.markdown(
+        """
+        <style>
+        .assistant-button {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background-color: #4CAF50;
+            color: white;
+            padding: 10px;
+            border: none;
+            border-radius: 5px;
+            cursor: pointer;
+            font-size: 16px;
+            margin-top: 10px;
+        }
+        .assistant-button img {
+            margin-right: 10px;
+        }
+        </style>
+        <button class="assistant-button" onclick="window.location.href='#assistant_chat'">
+            <img src='https://img2.gratispng.com/20180808/cxq/kisspng-robotics-science-computer-icons-robot-technology-robo-to-logo-svg-png-icon-free-download-45527-5b6baa46a5e322.4713113715337825986795.jpg' alt='icon' width='20' height='20'/>
+            Hablar con Asistente
+        </button>
+        """,
+        unsafe_allow_html=True
+    )
+
+    if st.button("Mostrar Chat", key="assistant_button"):
+        mostrar_chat()
+
+    if st.session_state['mostrar_chat']:
+        st.markdown("<div id='assistant_chat'></div>", unsafe_allow_html=True)
+        st.markdown("### Chat con Asistente")
+        
+        pregunta_usuario = st.text_input("Escribe tu pregunta aquí:", value=st.session_state.get('presupuesto_texto', ''))
+        if st.button("Enviar Pregunta"):
+            respuesta = obtener_respuesta(
+                pregunta_usuario, 
+                "",  # No se necesita texto preprocesado en este caso
+                st.session_state['modelo'], 
+                st.session_state['temperatura'],
+                st.session_state.get('assistant_id', 'asst_KngkX6sbRccg5a6fcnDHO06R')
+            )
+            st.markdown(f"**Asistente**: {respuesta}")
+
+if __name__ == "__main__":
+    show()

pages_radiografias.py

@@ -0,0 +1,48 @@
+import streamlit as st
+import pandas as pd
+from utils.data_manager import guardar_en_txt, cargar_desde_txt, mostrar_datos_como_texto, generar_pdf
+
+def show():
+    st.title("📸 Registro de Radiografías")
+
+    if 'radiografias' not in st.session_state:
+        st.session_state.radiografias = []
+
+    with st.form("radiografias_form"):
+        paciente = st.text_input("Nombre del Paciente:")
+        fecha = st.date_input("Fecha:")
+        motivo_consulta = st.text_input("Motivo de Consulta:")
+        doctor = st.text_input("Doctor que envía la radiografía:")
+        diagnostico = st.text_area("Diagnóstico:")
+        respuesta = st.text_area("Respuesta:")
+        descripcion = st.text_area("Descripción:")
+        submitted = st.form_submit_button("Registrar Radiografía")
+
+        if submitted:
+            radiografia = {
+                "paciente": paciente,
+                "fecha": str(fecha),
+                "motivo_consulta": motivo_consulta,
+                "doctor": doctor,
+                "diagnostico": diagnostico,
+                "respuesta": respuesta,
+                "descripcion": descripcion
+            }
+            st.session_state.radiografias.append(radiografia)
+            datos_guardados = mostrar_datos_como_texto([radiografia])  # Append only the new entry
+            guardar_en_txt('radiografias.txt', datos_guardados)
+            st.success("Radiografía registrada con éxito.")
+
+    if st.session_state.radiografias:
+        st.write("### Radiografías Registradas")
+        df_radiografias = pd.DataFrame(st.session_state.radiografias)
+        st.write(df_radiografias)
+
+        pdf_file = generar_pdf(df_radiografias, "Registro de Radiografías", "radiografias.pdf")
+        st.download_button(
+            label="📥 Descargar PDF",
+            data=open(pdf_file, 'rb').read(),
+            file_name="radiografias.pdf",
+            mime="application/pdf"
+        )
+

requirements.txt

@@ -0,0 +1,70 @@
+altair==5.3.0
+annotated-types==0.6.0
+anyio==4.3.0
+attrs==23.2.0
+blinker==1.7.0
+cachetools==5.3.3
+certifi==2024.2.2
+charset-normalizer==3.3.2
+click==8.1.7
+distro==1.9.0
+exceptiongroup==1.2.0
+gitdb==4.0.11
+GitPython==3.1.43
+h11==0.14.0
+httpcore==1.0.5
+httpx==0.27.0
+idna==3.6
+Jinja2==3.1.3
+joblib==1.3.2
+jsonschema==4.21.1
+jsonschema-specifications==2023.12.1
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+mdurl==0.1.2
+nltk==3.8.1
+numpy==1.26.4
+openai==0.28
+packaging==23.2
+pandas==2.2.1
+pillow==10.3.0
+protobuf==4.25.3
+pyarrow==15.0.2
+pydantic==2.6.4
+pydantic_core==2.16.3
+pydeck==0.8.1b0
+Pygments==2.17.2
+PyPDF2==3.0.1
+python-dateutil==2.9.0.post0
+python-docx==0.8.11
+pytz==2024.1
+referencing==0.34.0
+regex==2023.12.25
+requests==2.31.0
+rich==13.7.1
+rpds-py==0.18.0
+six==1.16.0
+smmap==5.0.1
+sniffio==1.3.1
+streamlit==1.32.2
+tenacity==8.2.3
+toml==0.10.2
+toolz==0.12.1
+tornado==6.4
+tqdm==4.66.2
+typing_extensions==4.10.0
+tzdata==2024.1
+urllib3==2.2.1
+watchdog==4.0.0
+transformers==4.25.1
+torch==2.0.1
+fpdf==1.7.2
+SpeechRecognition==3.10.4
+google-cloud-texttospeech==2.16.3
+Flask==3.0.3
+google-auth==2.30.0
+google-auth-oauthlib==1.2.0
+google-auth-httplib2==0.2.0
+google-api-python-client==2.134.0
+supabase==2.5.1
+google-cloud-vision==3.7.2