app.py

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()