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 os
import json
import re
import base64



st.set_page_config(page_title="Cantidades IFC / SDI", page_icon="📈")

st.title("Cantidades IFC / SDI")

###---- 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"



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


def cargar_datos_desde_json(tipo_modelo, nivel_avance):
    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']})

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)


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 cargar_ifc_y_obtener_datos(class_type):
    df_Ifc = 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)
        
        # Inicializar lista para almacenar los datos de las entidades
        entity_data_list = []

        for entity in entity_list:
            # Obtener información de la entidad
            psets = Element.get_psets(entity)
            attribute_names = [attribute for attribute in dir(entity) if not attribute.startswith("_")]
            # Obtener atributos específicos de la entidad
            attribute_values = {}
            for attribute_name in dir(entity):
                if not attribute_name.startswith("_"):
                    try:
                        attribute_value = getattr(entity, attribute_name)
                        attribute_values[attribute_name] = attribute_value
                    except AttributeError:
                        attribute_values[attribute_name] = None

            # Inicializar un diccionario para almacenar las propiedades agrupadas por nombre de conjunto de propiedades
            propiedades_dict = {}

            # Inicializar `property_value` con un valor por defecto
            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(f"{property_name}({property_value})")
                propiedades_dict[pset_name] = propiedades

            # Crear un diccionario con la información de la entidad
            object_data = {
                'Entidad': entity.is_a(),
                'Atributos': ', '.join(attribute_names),
                'Valores atributos': attribute_values,
                'Propiedades': propiedades_dict,
            }
            # Agregar los datos de la entidad a la lista
            entity_data_list.append(object_data)

        # Crear DataFrame con los datos de las entidades
        df = pd.DataFrame(entity_data_list)
        df_Ifc = df
    return df_Ifc

class_type = "IfcRoot"  # Cambia esto por la clase deseada
df_Ifc = cargar_ifc_y_obtener_datos(class_type)


# 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("Extraer cantidades Ifc"):
    # 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([', '.join(value) for value in x.values()]))
    }   

    df1_nuevo = pd.DataFrame(data_df1)


    # Eliminar duplicados basados en la columna 'Entidad'
    df2_unique = df2.drop_duplicates(subset=['Entidad'])
    # Datos del DataFrame 2 viene desde la carga de IFC a la app
    data_df2 = {
        'Entidad': df2_unique['Entidad'],
        'Grupo de Propiedades': df2_unique['Propiedades'].apply(lambda x: set(x.keys())),
        'Propiedades': df2_unique['Propiedades'].apply(lambda x: ', '.join([key + ": [" + ', '.join([re.sub(r'\([^)]*\)', '', val) for val in value]) + "]" for key, value in x.items()]))
    }
    # Actualización de 'Propiedades' en data_df2 para incluir solo los valores dentro de []
    data_df2['Propiedades'] = data_df2['Propiedades'].apply(lambda x: ', '.join([item.strip() for item in re.findall(r'\[([^]]*)\]', x)]))
    
    df2_nuevo = pd.DataFrame(data_df2)
      
    #st.write(df1_nuevo)
    #st.write(df2_nuevo)

    # Convertir diccionarios a DataFrames
    data_df1 = pd.DataFrame(df1_nuevo)
    data_df2 = pd.DataFrame(df2_nuevo)

    # Función para comparar propiedades entre data_df1 y data_df2
    def comparar_propiedades(data_df1, data_df2):
        data = []

        for idx1, row1 in data_df1.iterrows():
            entidad = row1['Entidad']
            grupos1 = row1['Grupo de Propiedades']
            propiedades1 = set(row1['Propiedades'].split(', '))
            
            if entidad in data_df2['Entidad'].values:
                row2 = data_df2[data_df2['Entidad'] == entidad].iloc[0]
                grupos2 = row2['Grupo de Propiedades']
                propiedades2 = set(row2['Propiedades'].split(', '))
                
                for grupo in grupos1:
                    coincide_grupo = "Si" if grupo in grupos2 else "No"
                    
                    for propiedad in propiedades1:
                        coincide_propiedad = "Si" if coincide_grupo == "Si" and propiedad in propiedades2 else "No"
                        data.append((entidad, grupo, coincide_grupo, propiedad, coincide_propiedad))
            else:
                for grupo in grupos1:
                    for propiedad in propiedades1:
                        data.append((entidad, grupo, "No", propiedad, "No"))


        df_resultado =  pd.DataFrame(data, columns=["Entidad", "Grupo", "Grupo_cumple_SDI_si/no", "Propiedad", "Propiedad_cumple_SDI_si/no"])
        # Eliminar duplicados basados en la columna "Propiedad"
        df_resultado = df_resultado.drop_duplicates(subset=["Entidad", "Grupo", "Propiedad"])
        return df_resultado
    

    # Comparar data_df1 y data_df2
    df_resultado = comparar_propiedades(data_df1, data_df2)

    # Comparar data_df1 y data_df2
    df = comparar_propiedades(data_df1, data_df2)
    # Filtrar los resultados para mostrar solo donde la propiedad coincide
    df_resultado_si = df_resultado[df_resultado["Propiedad_cumple_SDI_si/no"] == "Si"]

    st.write("Resultado de validación de cantidades según SDI:")
    # Imprimir el DataFrame Mostrar los resultados filtrados en Streamlit
    st.write(df_resultado_si[["Entidad", "Grupo", "Propiedad", "Propiedad_cumple_SDI_si/no"]])
    
    #presentar data frame de cantidades
    st.write("Cantidades totales de propiedades")

    # Función para extraer valores entre paréntesis
    def extraer_valores(diccionario):
        valores = []
        for valor_lista in diccionario.values():
            for valor in valor_lista:
                match = re.search(r'\((.*?)\)', valor)
                if match:
                    valores.append(match.group(1))
        return ', '.join(valores)

    # Aplicar la función para extraer valores y crear el DataFrame df_cantidades
    df_cantidades = pd.DataFrame({
        'Entidad': df2['Entidad'],
        #'Grupo de Propiedades': df2['Propiedades'].apply(lambda x: set(x.keys())),
        'GUID': df2['Valores atributos'].apply(lambda x: x.get('GlobalId', '')),
        'Tipo': df2['Valores atributos'].apply(lambda x: x.get('ObjectType', '')),
        'Propiedades':df2['Propiedades'].apply(lambda x: ', '.join([', '.join(val) for val in x.values()])),
        #'Valores': df2['Propiedades'].apply(extraer_valores)
    })

    # Crear nuevas columnas para cada propiedad separada
    properties_list = df_cantidades['Propiedades'].str.split(', ')
    max_properties = properties_list.apply(len).max()

    for i in range(max_properties):
        df_cantidades[f'Propiedad_{i+1}'] = properties_list.apply(lambda x: x[i] if len(x) > i else None)

    # Eliminar la columna original 'Propiedades'
    df_cantidades.drop(columns=['Propiedades'], inplace=True)
    #st.write(df_cantidades)

    # Crear una lista para almacenar los resultados filtrados
    resultados_filtrados = []

    # Filtrar las entidades de df_cantidades basado en df_resultado_si
    entidades_filtradas = df_cantidades[df_cantidades['Entidad'].isin(df_resultado_si['Entidad'])]

    # Iterar sobre cada fila de df_resultado_si
    for index, row in df_resultado_si.iterrows():
        entidad = row['Entidad']
        propiedad_inicio = row['Propiedad']

        # Verificar las propiedades en df_cantidades que comienzan con propiedad_inicio
        for col in entidades_filtradas.columns:
            if col.startswith('Propiedad_'):
                propiedades = entidades_filtradas.loc[entidades_filtradas['Entidad'] == entidad, col].dropna().tolist()
                for prop in propiedades:
                    if prop.startswith(propiedad_inicio):
                        # Obtener GlobalId y ObjectType correspondiente a la entidad
                        global_id = df_cantidades.loc[df_cantidades['Entidad'] == entidad, 'GUID'].iloc[0]
                        object_type = df_cantidades.loc[df_cantidades['Entidad'] == entidad, 'Tipo'].iloc[0]

                        resultados_filtrados.append({
                            'Entidad': entidad,
                            'GUID': global_id,
                            'Tipo': object_type,
                            'Propiedad_inicio': propiedad_inicio,
                            'Valores': prop
                        })

    # Convertir resultados_filtrados en un dataframe
    df_resultados_filtrados = pd.DataFrame(resultados_filtrados)
    #st.write(df_resultados_filtrados)
    # Actualización de 'Propiedades' en data_df2 para incluir solo los valores dentro de []
    df_resultados_filtrados['Valores'] = df_resultados_filtrados['Valores'].apply(lambda x: re.search(r'\((.*?)\)', x).group(1))
    #convertir valores a float
    df_resultados_filtrados['Valores']= df_resultados_filtrados['Valores'].astype(float)
    df_resultados_filtrados['Valores']= df_resultados_filtrados['Valores'].round(3)

    Valores_totales = df_resultados_filtrados['Valores'].sum()
    Valores_totales_rounded = round(Valores_totales, 3)
    # Mostrar los resultados en Streamlit

    #st.write(df_resultados_filtrados)
    # Mostrar el total de los valores con estilo personalizado
    #st.subheader("Total de metros cúbicos:")
    #st.markdown(f'<p class="estilo-negro-grande">{Valores_totales_rounded}</p>', unsafe_allow_html=True)
    
    entidades_dfs = {}
    
    entidades_unicas = df_resultados_filtrados['Entidad'].unique()
    for entidad in entidades_unicas:
        entidades_dfs[entidad] = df_resultados_filtrados[df_resultados_filtrados['Entidad'] == entidad]
    for entidad, df_entidad in entidades_dfs.items():
        st.write(f"Cantidades totales de propiedades {entidad}")
        st.dataframe(df_entidad)

    def guardar_y_descargar_excel(entidades_dfs, df_resultados_filtrados, df_resultado_si):
        # Crear un escritor Excel para guardar los DataFrames en hojas diferentes
        with tempfile.NamedTemporaryFile(delete=False, suffix='.xlsx') as tmp_file:
            with pd.ExcelWriter(tmp_file.name, engine='xlsxwriter') as writer:
                df_resultado_si.to_excel(writer, sheet_name='Resumen_entidades', index=False)
                # Guardar los DataFrames por entidad en hojas separadas
                for entidad, df_entidad in entidades_dfs.items():
                    df_entidad.to_excel(writer, sheet_name=f'Cantidades_{entidad}', index=False)
                
            # Generar el enlace para descargar el archivo Excel
            with open(tmp_file.name, '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)
    guardar_y_descargar_excel(entidades_dfs, df_resultados_filtrados, df_resultado_si)