Update utils/data_manager.py

utils/data_manager.py

@@ -1,185 +1,107 @@
-import openai
 import os
+import pandas as pd
+from fpdf import FPDF
 import tempfile
-import PyPDF2
-from dotenv import load_dotenv
-from google.cloud import texttospeech
-import nltk
-from nltk.tokenize import word_tokenize
-from nltk.corpus import stopwords
-from nltk.stem import SnowballStemmer
 import streamlit as st
-import requests
 
-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
+# Aquí irían otras importaciones y funciones...
+
+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"
+        )
 
-if not brevo_api_key:
-    st.error("No API key provided for Brevo. Please set your API key in the .env file.")
+# Aquí pueden ir otras funciones...
 
-def extraer_texto_pdf(archivo):
+def mostrar_datos_como_texto(datos):
     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)
+    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 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)
-
-client = texttospeech.TextToSpeechClient()
-
-def obtener_respuesta(pregunta, texto_preprocesado, modelo, temperatura=0.5, assistant_id=None):
-    try:
-        messages = [
-            {"role": "system", "content": "Actua como Galatea la asistente de la clinica Odontologica OMARDENT y resuelve las inquietudes"},
-            {"role": "user", "content": f"{pregunta}\n\nContexto: {texto_preprocesado}"}
-        ]
-
-        if assistant_id:
-            response = openai.Completion.create(
-                model=assistant_id,
-                prompt=f"{messages}",
-                temperature=temperatura
-            )
-            respuesta = response.choices[0].text.strip()
-        else:
-            response = openai.ChatCompletion.create(
-                model=modelo,
-                messages=messages,
-                temperature=temperatura
-            )
-            respuesta = response.choices[0].message['content'].strip()
-
-        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
-        )
-
-        response = client.synthesize_speech(
-            input=input_text, voice=voice, audio_config=audio_config
-        )
-
-        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:
+        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')
 
-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
-    }
+    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:
-        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}")
+        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 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}")
-
-# Añadir funciones para buscar datos guardados, generar notificaciones y mostrar datos como texto si es necesario
+        st.error(f"Error al generar PDF: {e}")
+        return None