Delete app.py

app.py

@@ -1,520 +0,0 @@
-import streamlit as st
-import streamlit.components.v1 as components
-import pandas as pd
-import ifcopenshell
-import ifcopenshell.util.element as Element
-import tempfile
-import plotly.express as px
-import plotly.graph_objects as go
-import plotly.io as pio
-import os
-import json
-import re
-import matplotlib.pyplot as plt
-import base64
-import pdfkit
-import mysql.connector
-##-hola-
-
-st.set_page_config(page_title="Revisor de Modelos IFC", page_icon="📈")
-
-st.title("Revisor de Modelos IFC")
-
-###---- HIDE STREAMLIT STYLE ----
-hide_st_style = """
-            <style>
-            #MainMenu {visibility: hidden;}
-            footer {visibility: hidden;}
-            header {visibility: hidden;}
-            </style>
-            """
-st.markdown(hide_st_style, unsafe_allow_html=True)
-base="light"
-
-connection = mysql.connector.connect(
-    host="srv848.hstgr.io",
-    user="u539776097_oWm4C",
-    password="Nekoryu1234.",
-    database="u539776097_f0Qes"
-)
-
-def cargar_datos_desde_json(tipo_modelo, nivel_avance):
-    # Genera la ruta completa del archivo JSON basado en la selección del usuario
-    nombre_archivo = f"{tipo_modelo}_{nivel_avance}.json"
-    ruta_archivo = os.path.join(nombre_archivo)
-    
-    try:
-        # Intenta abrir y cargar el archivo JSON correspondiente
-        with open(ruta_archivo, 'r') as file:
-            data = json.load(file)
-        return data
-    except FileNotFoundError:
-        st.error(f"No existe EAIM para este tipo de modelo.")
-        return None
-    except Exception as e:
-        st.error(f"Error datos")
-        return None
-
-def obtener_informacion(data, tipo_modelo, nivel_avance):
-    if data and tipo_modelo in data and nivel_avance in data[tipo_modelo]:
-        info_seleccionada = data[tipo_modelo][nivel_avance]
-        rows = []
-        for entidad, ndi_info in info_seleccionada.items():
-            for ndi, ndi_data in ndi_info.items():
-                atributos = ndi_data.get('Atributos', None)
-                Propiedades = ndi_data.get('Propiedades', None)
-
-                # Utiliza apply con una función lambda para formatear la columna 'Atributos'
-                atributos_str = ', '.join(atributos) if atributos else ''
-
-                rows.append([entidad, ndi, atributos_str, Propiedades])
-
-        df = pd.DataFrame(rows, columns=['Entidad', 'NDI', 'Atributos', 'Propiedades'])
-        return df
-    else:
-        return pd.DataFrame({'Mensaje': ['No se encontró información para la selección']})
-
-
-# Crear la aplicación de Streamlit con el tamaño de título personalizado
-#st.markdown("<h1 style='text-left: center; font-size: 35px;'>Revisor de Modelos IFC</h1>", unsafe_allow_html=True)
-
-# Definir las listas de tipos de modelo y niveles de avance
-tipos_modelo = ["Sitio", "Volumetrico", "Arquitectura","Estructura",
-               "Agua caliente","Agua fria","Agua lluvia","Alcantarillado","CCDD","Climatización","Electricidad","Gas","Iluminación","PCI", "Coordinacion"]
-
-nivel_avance = ["DA", "DB", "DD"]
-
-# Etiqueta para el tipo de modelo
-st.write("Seleccione el tipo de modelo:")
-tipo_modelo = st.selectbox("Tipo de Modelo:", tipos_modelo)
-
-# Etiqueta para el nivel de avance
-st.write("Seleccione el EAIM:")
-nivel_avance = st.selectbox("EAIM:", nivel_avance)
-
-data = cargar_datos_desde_json(tipo_modelo, nivel_avance)   
- 
-# Agrega un botón de "Aceptar"
-if st.button("Aceptar"):
-    st.write("Entidades, atributos y propiedades minimas de EBPP")
-    # Código que se ejecutará cuando se presione el botón
-    resultado_df = obtener_informacion(data, tipo_modelo, nivel_avance)
-    #st.write(resultado_df)  # Muestra el resultado en la aplicación
-
-resultado_df = obtener_informacion(data, tipo_modelo, nivel_avance)
-
-    
-# Crear la aplicación de Streamlit con el tamaño de título personalizado
-st.markdown("<h1 style='text-left: center; font-size: 25px;'>Cargar Modelo IFC</h1>", unsafe_allow_html=True)
-#st.write("Seleccione y cargue el modelo ifc que desea validar:")
-
-def get_objects_data_by_class(entity):
-    psets = Element.get_psets(entity)
-    attribute_names = [attribute for attribute in dir(entity) if not attribute.startswith("_")]
-    
-    # Initialize a dictionary to store properties grouped by Pset name
-    propiedades_dict = {}
-
-    for pset_name, properties in psets.items():
-        propiedades = []
-        for property_name, property_value in properties.items():
-            if isinstance(property_value, ifcopenshell.entity_instance):
-                property_value = property_value.Name
-            propiedades.append(property_name)
-        propiedades_dict[pset_name] = propiedades
-
-    object_data = {
-        'Entidad': entity.is_a(),
-        'Atributos': ', '.join(attribute_names),
-        'Propiedades': propiedades_dict,
-    }
-
-    return object_data
-
-class_type = "IfcRoot"  # Change this to the desired class
-
-
-if "file_uploader_key" not in st.session_state:
-    st.session_state["file_uploader_key"] = 0
-
-if "uploaded_files" not in st.session_state:
-    st.session_state["uploaded_files"] = []
-
-archivo_subido = st.file_uploader(
-    "Seleccione y cargue el modelo ifc que desea validar:",
-    type=["ifc"],
-    key=st.session_state["file_uploader_key"],
-)
-
-if archivo_subido:
-    st.session_state["uploaded_files"] = [archivo_subido]
-
-def main():
-    df_Ifc = None
-    tmp_filename = None
-    #archivo_subido = st.file_uploader("Seleccione y cargue el modelo ifc que desea validar:", type=["ifc"])
-
-    if archivo_subido is not None:
-            with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
-                tmp_file.write(archivo_subido.read())
-                tmp_filename = tmp_file.name
-    
-            modelo = ifcopenshell.open(tmp_filename)
-            entity_list = modelo.by_type(class_type)  # Use 'class_type' here
-            entity_data_list = [get_objects_data_by_class(entidad) for entidad in entity_list]
-    
-            df = pd.DataFrame(entity_data_list)
-            df_Ifc = df.drop_duplicates(subset=["Entidad", "Atributos"])
-    
-            # Eliminar el archivo temporal
-            #os.unlink(tmp_filename)
-    # Return the DataFrame df_Ifc
-    return df_Ifc
-
-df_Ifc = main()
-
-
-
-# Cargar el primer DataFrame
-df1 = resultado_df
-#st.write(df1)
-# Cargar el segundo DataFrame
-df2 = df_Ifc
-#st.write(df2)
-
-
-st.markdown("<h1 style='text-left: center; font-size: 25px;'>Iniciar validación</h1>", unsafe_allow_html=True)
-st.write("haga click en validar para obtener estadisitcas de cumplimiento de su modelo :")  
-
-# Inicializar un nuevo DataFrame para resumir los resultados
-resumen = pd.DataFrame(columns=['Entidad', 'Entidad_existe_si/no', 'Atributos', 'Atributos_existe_si/no'])
-
-#color del boton validar
-def ChangeButtonColour(widget_label, font_color, background_color='transparent'):
-    htmlstr = f"""
-        <script>
-            var elements = window.parent.document.querySelectorAll('button');
-            for (var i = 0; i < elements.length; ++i) {{ 
-                if (elements[i].innerText == '{widget_label}') {{ 
-                    elements[i].style.color ='{font_color}';
-                    elements[i].style.background = '{background_color}'
-                }}
-            }}
-        </script>
-        """
-    components.html(f"{htmlstr}", height=0, width=0)
-    
-ChangeButtonColour("Validar Ifc", "#ffffff", "#ff9317") # button txt to find, colour to assign   
-
-# Crear un botón de validación
-if st.button("Validar Ifc"):
-    st.session_state["file_uploader_key"] += 1
-    # Revisar las entidades
-    for entidad in df1['Entidad']:
-        if entidad in df2['Entidad'].values:
-            cumple_entidad = 'Si'
-        else:
-            cumple_entidad = 'La entidad no existe en el modelo'
-        row = pd.DataFrame({'Entidad': [entidad], 'Entidad_existe_si/no': [cumple_entidad]})
-        resumen = pd.concat([resumen, row], ignore_index=True)
-
-    # Revisar los atributos
-    for entidad, atributos in zip(df1['Entidad'], df1['Atributos']):
-        if entidad in df2['Entidad'].values:
-            # Dividir los atributos de df2 en una lista
-            atributos_df2 = df2[df2['Entidad'] == entidad]['Atributos'].iloc[0].split(", ")
-            
-            # Verificar si alguno de los atributos en df1 coincide con los atributos en df2
-            if any(atributo in atributos_df2 for atributo in atributos.split(', ')):
-                cumple_atributo = 'Si'
-                
-            else:
-                cumple_atributo = 'No'
-
-        else:
-            cumple_atributo = 'No'  # Si la entidad no existe en df2, los atributos tampoco pueden existir
-      
-        resumen.loc[resumen['Entidad'] == entidad, 'Atributos'] = atributos
-        resumen.loc[resumen['Entidad'] == entidad, 'Atributos_existe_si/no'] = cumple_atributo
-
-    # Rellenar los valores faltantes en el DataFrame de resumen2
-    resumen.fillna('', inplace=True)
-
-    # Mostrar el resumen de propiedades en Streamlit
-    st.write("Resultados de Validación de entidades y atributos:")
-    st.write(resumen)
-   
-    # Datos del DataFrame 1
-    data_df1 = {
-        'Entidad': df1['Entidad'],
-        #'Grupo de Propiedades': df1['Propiedades'].apply(lambda x: set(x.keys())),
-        'Propiedades': df1['Propiedades'].apply(lambda x: ', '.join([f'{key}: {value}' for key, value in x.items()]))
-    }
-    df1_nuevo = pd.DataFrame(data_df1)
-
-    # Datos del DataFrame 2
-    data_df2 = {
-        'Entidad': df2['Entidad'],
-        #'Grupo de Propiedades': df2['Propiedades'].apply(lambda x: set(x.keys())),
-        'Propiedades': df2['Propiedades'].apply(lambda x: ', '.join([f'{key}: {value}' for key, value in x.items()]))
-    }
-    df2_nuevo = pd.DataFrame(data_df2)
-      
-    #st.write(df1_nuevo)
-    #st.write(df2_nuevo)
-    
-    # Encontrar grupos que coinciden y que no coinciden
-    grupos_coinciden = df1_nuevo[df1_nuevo.apply(lambda x: x['Entidad'] in df2_nuevo['Entidad'].values, axis=1)]
-    grupos_no_coinciden1 = df1_nuevo[~df1_nuevo['Entidad'].isin(df2_nuevo['Entidad'].values)]
-    #grupos_no_coinciden2 = df2_nuevo[~df2_nuevo['Entidad'].isin(df1_nuevo['Entidad'].values)]
-    #st.write(grupos_coinciden)
-    st.write("Propiedades que faltan agregar por entidad")
-    st.write(grupos_no_coinciden1)
-    
-    
-    propiedades1= grupos_coinciden
-    propiedades2 = df2_nuevo
-    
-    #st.write(propiedades1)
-    #st.write(propiedades2)
-    
-    # Función para extraer grupos y propiedades de la cadena
-    def extraer_grupos_propiedades(cadena):
-        grupos_propiedades = re.findall(r"(\w+): \[(.*?)\]", cadena)
-        resultado = {}
-        for grupo, propiedades in grupos_propiedades:
-            resultado[grupo] = propiedades.split(', ')
-        return resultado
- 
-    # Crear una lista para almacenar los datos
-    data = []
-
-    # Iterar a través de las filas de propiedades1
-    for index, row in propiedades1.iterrows():
-        entidad = row['Entidad']
-        propiedades_grupo1 = extraer_grupos_propiedades(row['Propiedades'])
-        
-        # Iterar sobre los grupos y propiedades en el grupo
-        for grupo, propiedades in propiedades_grupo1.items():
-            if entidad in propiedades2['Entidad'].values:
-                propiedades_grupo2 = extraer_grupos_propiedades(propiedades2[propiedades2['Entidad'] == entidad]['Propiedades'].values[0])
-                coincide_grupo = "Si" if grupo in propiedades_grupo2 else "No"
-                
-                propiedades_coinciden = []
-                for propiedad in propiedades:
-                    if propiedad in propiedades_grupo2.get(grupo, []):
-                        coincide_propiedad = "Si"
-                    else:
-                        coincide_propiedad = "No"
-                    propiedades_coinciden.append((propiedad, coincide_propiedad))
-            else:
-                coincide_grupo = "No"
-                propiedades_coinciden = [(propiedad, "No") for propiedad in propiedades]
-
-            data.extend([(entidad, grupo, coincide_grupo, prop, coincide_prop) for prop, coincide_prop in propiedades_coinciden])
-
-    # Crear el DataFrame
-    df = pd.DataFrame(data, columns=["Entidad", "Grupo", "Grupo_coincide_si/no_EBPP", "Propiedad", "Propiedad_coincide_si/no_EBPP"])
-
-    st.write("Resultados de Validación: grupos de propiedades y propiedades:")
-    # Imprimir el DataFrame
-    st.write(df)
-   
-     
-    # Definir los colores que deseas usar para cada sección
-    colores = ['#1f77b4', '#ff7f0e']  # Puedes cambiar estos códigos de color según tus preferencias
-    
-    
-    # Crear un DataFrame a partir de resultados_df
-    resultados_df_dataframe = pd.DataFrame(resumen)
-    
-    # Realizar estadísticas simples sobre resultados_df_dataframe
-    if not resultados_df_dataframe.empty:
-        st.subheader("Estadísticas sobre los resultados")
-        num_coincidencias = len(resultados_df_dataframe[resultados_df_dataframe['Entidad_existe_si/no'] == "Si"])
-        num_diferencias = len(resultados_df_dataframe[resultados_df_dataframe['Entidad_existe_si/no'] == "La entidad no existe en el modelo"])
-        # Crear un gráfico de anillo con Plotly para las estadísticas globales
-        anillo = px.pie(
-            names=["La entidad existe en el modelo", "La entidad no existe en el modelo"],
-            values=[num_coincidencias, num_diferencias],
-            hole=0.4,  # Controla el tamaño del agujero en el centro del gráfico (0.4 significa un donut)
-            color_discrete_sequence=colores,  # Especifica los colores personalizados aquí
-            labels={"names": "Estadisitcas del modelo"}
-        )
-            # Personalizar el diseño del gráfico
-        anillo.update_layout(
-            title='Cumplimiento del modelo según EBPP '
-            )
-        # Mostrar el gráfico de anillo en Streamlit
-        st.plotly_chart(anillo)
-
-    
-    # Calcular el recuento de cada tipo en 'Entidad_existe_si/no'
-    counts = resultados_df_dataframe['Entidad_existe_si/no'].value_counts()
-    # Definir los colores que deseas usar para cada sección
-    colores = ['#1f77b4', '#ff7f0e']  # Puedes cambiar estos códigos de color según tus preferencias
-    # Filtrar el DataFrame para obtener los nombres de entidades donde 'Entidad_existe_si/no' es igual a 'Si'
-    nombres_entidades = resumen[resumen['Entidad_existe_si/no'] == 'Si']['Entidad']
-    nombres_entidades2 = resumen[resumen['Entidad_existe_si/no'] == 'La entidad no existe en el modelo']['Entidad']
-    serie_de_nombres = pd.Series(nombres_entidades)
-    serie_de_nombres2 = pd.Series(nombres_entidades2)
-    # Concatena los elementos de la serie en un solo texto
-    texto_concatenado = serie_de_nombres.str.cat(sep=',')
-    texto_concatenado1 = serie_de_nombres2.str.cat(sep=',')   
-
-    # Crear el gráfico de barras personalizado con los valores numéricos encima de las barras y colores personalizados
-    fig = go.Figure()
-    
-    for index, row in counts.items():
-        color_barra = colores.pop(0)  # Obtener el próximo color de la lista
-        entidad_name = nombres_entidades if index == 'Si' else nombres_entidades2
-        entidad_name = ', '.join(entidad_name)  # Convierte la lista en una cadena separada por comas
-        fig.add_trace(go.Bar(
-            x=[index],
-            y=[row],
-            text=[row],  # Agregar el valor numérico encima de la barra
-            textposition=['outside'],  # Posicionar el valor fuera de la barra
-            name=str(index),  # Usar el valor como etiqueta
-            marker_color=color_barra  # Establecer el color de la barra
-        ))
-
-    # Personalizar el diseño del gráfico
-    fig.update_layout(
-        xaxis_title='Cumplimiento',
-        yaxis_title='N° de Clases',   #[f"{index} ({entidad_name})"]
-        title='Cumplimiento por Entidades',
-        yaxis_title_text="N° de Clases"
-    )
-    
-    st.write("Entidades que cumplen: "+texto_concatenado) 
-    st.write("Entidades que no cumplen: "+texto_concatenado1) 
-    # Mostrar el gráfico de barras en Streamlit
-    #st.plotly_chart(fig)
-    
-       
-    # Crear un DataFrame a partir de resultados_df
-    df = pd.DataFrame(df)
-
-    # Realizar estadísticas y crear un gráfico de barras apilado con Plotly
-    fig1 = go.Figure()
-
-    # Agrupar los datos y crear un gráfico de barras apilado
-    grouped = df.groupby(['Entidad','Grupo_coincide_si/no_EBPP'])['Grupo'].nunique().reset_index(name='Cantidad')
-    # Obtener los nombres de los grupos para cada entidad
-    group_names = df.groupby('Entidad')['Grupo'].unique().apply(lambda x: ', '.join(x)).reset_index(name='Grupos')
-    # Combinar los nombres de los grupos con las cantidades
-    grouped = pd.merge(grouped, group_names, on='Entidad')    
-    fig1 = px.bar(grouped, x='Entidad', y='Cantidad', color='Grupo_coincide_si/no_EBPP',color_discrete_sequence=['#1f77b4', 'lightblue'],hover_data={'Entidad': False, 'Grupo_coincide_si/no_EBPP': False,'Cantidad': False, 'Grupos': True})
-
-    # Personalizar el diseño del gráfico
-    fig1.update_layout(
-        xaxis_title='Entidad',
-        yaxis_title='Cumplimiento',
-        title='Cumplimiento de grupos de propiedades por entidades existentes en el modelo',
-    )
-    
-    fig1.update_traces(texttemplate='%{y}', textposition='outside')
-
-    # Mostrar el gráfico con st.plotly_chart en Streamlit
-    st.plotly_chart(fig1)
-    st.write("Para mas detalle revise la tabla: grupos de propiedades y propiedades la columna'Grupo'")
-    
-    # Crear un DataFrame a partir de resultados_df
-    df = pd.DataFrame(df)
-
-    # Realizar estadísticas y crear un gráfico de barras apilado con Plotly
-    barra_propiedades = go.Figure()
-
-    # Agrupar los datos y crear un gráfico de barras apilado
-    grouped = df.groupby(['Grupo', 'Propiedad_coincide_si/no_EBPP']).size().reset_index(name='Cantidad')
-    group_names = df.groupby('Grupo')['Propiedad'].apply(lambda x: '\n'.join(x)).reset_index(name='Propiedad')
-    grouped = pd.merge(grouped, group_names, on='Grupo')  
-    barra_propiedades = px.bar(grouped, x='Grupo', y='Cantidad', color='Propiedad_coincide_si/no_EBPP',color_discrete_sequence=['#1f77b4', 'lightblue'],hover_data={'Grupo': False, 'Cantidad': False,'Propiedad_coincide_si/no_EBPP': False, 'Propiedad': True})
-
-
-    # Personalizar el diseño del gráfico
-    barra_propiedades.update_layout(
-        xaxis_title='Entidad',
-        yaxis_title='Cumplimiento',
-        title='Cumplimiento propiedades por grupo de propiedades',
-    )
-
-    # Agregar el valor numérico encima de cada barra
-    barra_propiedades.update_traces(texttemplate='%{y}', textposition='inside')
-
-    # Mostrar el gráfico con st.plotly_chart en Streamlit
-    st.plotly_chart(barra_propiedades)
-    st.write("Para mas detalle revise la tabla: grupos de propiedades y propiedades la columna'Propiedad'")
-    
-           
-    # Crear un escritor Excel para guardar los DataFrames en hojas diferentes
-    with pd.ExcelWriter('resultados_validacion.xlsx', engine='xlsxwriter') as writer:
-        resumen.to_excel(writer, sheet_name='Resumen_entidades')
-        df.to_excel(writer, sheet_name='Resumen_Propiedades')
-        grupos_no_coinciden1.to_excel(writer, sheet_name='entidades_propiedades_faltantes')
-    ChangeButtonColour("Terminar validación", "#ffffff", "#ff9317")
-    if st.button("Terminar validación"):
-        #st.session_state["file_uploader_key"] += 1
-        st.experimental_rerun()
-
-
-def main():
-    # Editar el tamaño del título principal aquí
-    size_titulo_principal = "20px"  # Tamaño deseado del título principal
-
-    # Aplicar el tamaño del título principal utilizando Markdown y CSS
-    st.markdown(f"<h1 style='font-size:{size_titulo_principal}'>Cuestionario de Evaluación del Proyecto</h1>", unsafe_allow_html=True)
-
-    respuestas = {}
-    
-    # Tamaño de los títulos y las preguntas
-    st.markdown(f"<h1 style='font-size:{20}px'>I. Funcionalidad General</h1>", unsafe_allow_html=True)
-
-    tiempo_procesamiento = st.radio("¿Cuál es el tiempo promedio de procesamiento por cada modelo BIM representativo en formato IFC?",
-                                    options=["a) Entre 1 y 5 minutos", "b) Entre 5 y 10 minutos", "c) Más de 10 minutos"])
-    respuestas["tiempo_procesamiento"] = tiempo_procesamiento
-
-    st.markdown(f"<h1 style='font-size:{20}px'>II. Operacionabilidad</h1>", unsafe_allow_html=True)
-    tiempo_ejecucion = st.radio("¿Cuánto tiempo promedio tarda en ejecutar el flujo de trabajo completo (revisión de modelos BIM IFC y emisión de reportes de gestión?",
-                                options=["a) Menos de 5 minutos", "b) Entre 5 y 10 minutos", "c) Más de 10 minutos"])
-    respuestas["tiempo_ejecucion"] = tiempo_ejecucion
-
-    st.markdown(f"<h1 style='font-size:{20}px'>III. Confianza en los Resultados</h1>", unsafe_allow_html=True)
-    concordancia_revisiones = st.radio("¿Cuál es el porcentaje de precisión en la cantidad de parámetros IFC que se revisan automatizadamente en comparación con revisiones manuales?",
-                                       options=["a) Más del 90%", "b) Entre 70% y 90%", "c) Menos del 70%"])
-    respuestas["concordancia_revisiones"] = concordancia_revisiones
-
-    st.markdown(f"<h1 style='font-size:{20}px'>IV. Compatibilidad con SDI BIM</h1>", unsafe_allow_html=True)
-    cumplimiento_requisitos = st.radio("¿Cuál es el tiempo promedio de carga de los modelos BIM en formato IFC de prueba?",
-                                       options=["a) Cumple totalmente", "b) Cumple parcialmente", "c) No cumple"])
-    respuestas["cumplimiento_requisitos"] = cumplimiento_requisitos
-
-    st.markdown(f"<h1 style='font-size:{20}px'>V. Tiempo de Respuesta</h1>", unsafe_allow_html=True)
-    tiempo_respuesta = st.radio("¿Cuál es el tiempo promedio de respuesta del sistema en modelos de prueba?",
-                                options=["a) Menos de 1 minuto", "b) Entre 1 y 3 minutos", "c) Más de 3 minutos"])
-    respuestas["tiempo_respuesta"] = tiempo_respuesta
-
-    st.markdown(f"<h1 style='font-size:{20}px'>VI. Interoperabilidad</h1>", unsafe_allow_html=True)
-    problemas_interoperabilidad = st.radio("¿Cuántos problemas de uso de la plataforma web se han identificado y resuelto durante el mes en curso?",
-                                           options=["a) Más de 5", "b) Entre 2 y 5", "c) Menos de 2"])
-    respuestas["problemas_interoperabilidad"] = problemas_interoperabilidad
-
-    # Mostrar respuestas al finalizar el cuestionario
-    if st.button("Finalizar cuestionario"):
-        # Generar insercion de base datos 
-        cursor2 = connection.cursor()
-
-        insert_KPI = "INSERT INTO `TablaKPI`(`DIRECCION`, `TiempoPromedioProceso`, `TiempoPromedioEjecucion`, `PorcentajeConcordancia`, `CumpleRequisitosSDO`, `TiempoPromedioRespuesta`, `ProblemaInteroperabilidad`) VALUES (%s,%s,%s,%s,%s,%s,%s)"
-        cursor2.execute(insert_KPI,("DA", tiempo_procesamiento ,  tiempo_ejecucion , concordancia_revisiones , cumplimiento_requisitos , tiempo_respuesta , problemas_interoperabilidad ))
-        connection.commit()
-         
-        # Generar el enlace para descargar el archivo Excel
-        with open('resultados_validacion.xlsx', 'rb') as f:
-            excel_data = f.read()
-        b64 = base64.b64encode(excel_data).decode()
-        href = f'<a href="data:file/excel;base64,{b64}" download="resultados_validacion.xlsx">Descargar Resultados de Validación (Excel)</a>'
-        st.markdown(href, unsafe_allow_html=True)
-
-
-if __name__ == "__main__":
-    main()