app.py

# importando bibliotecas necessárias
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import gradio as gr
from gradio import components
from gradio import Interface
import xlsxwriter
import shutil
import os
import plotly.express as px
import ast
from docx import Document
from docx.shared import Pt
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
from docx.shared import Inches
import plotly.io as pio
from pandas.plotting import table
from num2words import num2words
#from docx.shared import RGBColor

    #-----------------#

#função para criar um mapa no plotly
def plotar_mapa_com_dois_dataframes(df1, df2):
    fig1 = px.scatter_mapbox(
        df1,
        lat='lat',
        lon='lon',
        zoom=12.5,
        center={"lat": df1['lat'].mean(), "lon": df1['lon'].mean()},
        color_discrete_sequence=['blue'],
    )  
    fig1.update_traces(marker=dict(size=10))  # Define o tamanho dos marcadores para o DataFrame 1

    fig2 = px.scatter_mapbox(
        df2,
        lat='lat',
        lon='lon',
        color_discrete_sequence=['red'],
    )
    fig2.update_traces(marker=dict(size=20))  # Define o tamanho dos marcadores para o DataFrame 2

    # Combine as duas figuras em uma única figura
    for data in fig2.data:
        fig1.add_trace(data)
    # Personalize o layout do mapa, se desejar
    fig1.update_layout(
        mapbox_style="open-street-map",
    )
    # Mostrar o mapa
    fig1.show()
    
    #Salvar a figura como um arquivo PNG
    pio.write_image(fig1, 'fig2.png')

    return fig1 #, fig2

    #-----------------#
    
#função para criação de um gráfico    
def grafico_barras(data):
    # Calcular a média da coluna 'Vunit_hom'
    media = data['Vunit_hom'].mean()
    
    # Calcular o percentual de distância à média para cada ponto
    data['Percentual_Distancia'] = round(((data['Vunit_hom'] - media) / media) * 100, 1)
    
    # Criar o gráfico de dispersão em relação à média com rótulos
    plt.figure(figsize=(8, 8))  # Define o tamanho da figura (opcional)
    plt.bar(data['ordem'], data['Percentual_Distancia'], color = 'gray')
    
    # Adicionar rótulos com percentual de distância à média
    for i, Percentual_Distancia in enumerate(data['Percentual_Distancia']):
        plt.text(data['ordem'][i], Percentual_Distancia, f'{Percentual_Distancia}%', ha='center', va='bottom', fontsize = 12)

    # Configurações de gráfico
    plt.title('Distância percentual dos dados homogeneizados à média saneada')
    plt.xlabel('Ordem dos dados')
    plt.ylabel('% de distância à média')
    plt.legend()

    # Salvar o gráfico como uma imagem (por exemplo, em formato PNG)
    plt.savefig('scatter_plot.png')  # Escolha o nome e o formato do arquivo desejado
    # Mostrar o gráfico
    plt.show()
    
     #-----------------#
    
#função para escrever por extenso o valor atribuído     
def numero_por_extenso(numero):
    reais = int(numero)

    extenso_reais = num2words(reais, lang='pt_BR')

    if reais == 1:
        extenso_reais += ' real'
    else:
        extenso_reais += ' reais'

    return extenso_reais
    
    #-----------------#
    
#função para avaliação do imóvel
def avaliacao_imovel(planilha, num_linhas_desejadas=3, finalidade='Defina o tipo de imovel',
                    nome="-", prof="Engenheiro Civil", ent="CREA", uf = 'RS', reg="-", data= None,
                    lograd="-", munic="-", tipo_imo="-", solic="-", final_espec="-", objetivo="-", press="-",
                    infra="Água Potável", serv="Coleta de Lixo", uso="Residencial", pad_reg="-", tipo_via="-", obs_gerais="-",
                    per="Sem destaque", ofe="Sem destaque", liq="Sem destaque", 
                    caract_avaliando='Defina o item 1 de Fundamentação', ident_dados='Defina o item 3 de Fundamentação', v_atrib=0):
    
    
    #-------------------------------------------------INPUT AVALIANDO-------------------------------------------------------#
    
    # Lendo a aba 'avaliando' da planilha
    df_avaliando = pd.read_excel(planilha.name, 'avaliando')
    
    # Verificar se a coluna 'Coordenadas' contém valores válidos (não NaN)
    df_avaliando['Coordenadas'] = df_avaliando['Coordenadas'].apply(lambda x: ast.literal_eval(x) if not pd.isna(x) else np.nan)

    # Criando as colunas "lat" e "lon" a partir da coluna "Coordenadas" ou definindo como NaN se estiver vazia
    df_avaliando['lat'] = df_avaliando['Coordenadas'].apply(lambda x: round(x[0], 5) if not pd.isna(x) else np.nan)
    df_avaliando['lon'] = df_avaliando['Coordenadas'].apply(lambda x: round(x[1], 5) if not pd.isna(x) else np.nan)

    # Excluindo a coluna 'Coordenadas' se você não precisar dela mais
    df_avaliando = df_avaliando.drop('Coordenadas', axis=1)
    
    #--------------------------------------------------INPUT DAODS----------------------------------------------------------#
    
    # Lendo a aba 'dados' da planilha, limitando o número de linhas
    df_dados = pd.read_excel(planilha.name, 'dados').iloc[:int(num_linhas_desejadas)]
    
   # Verificar se a coluna 'Coordenadas' contém valores válidos (não NaN)
    df_dados['Coordenadas'] = df_dados['Coordenadas'].apply(lambda x: ast.literal_eval(x) if not pd.isna(x) else np.nan)

    # Criando as colunas "lat" e "lon" a partir da coluna "Coordenadas" ou definindo como NaN se estiver vazia
    df_dados['lat'] = df_dados['Coordenadas'].apply(lambda x: round(x[0], 5) if not pd.isna(x) else np.nan)
    df_dados['lon'] = df_dados['Coordenadas'].apply(lambda x: round(x[1], 5) if not pd.isna(x) else np.nan)

    # Excluindo a coluna 'Coordenadas'
    df_dados = df_dados.drop('Coordenadas', axis=1)

    #-----------------------------------------------------FATORES-----------------------------------------------------------# 
    
    # fator de atratividade local (fal)
    df_transp = df_dados.copy()
    df_transp = df_transp[['Atratividade local']]

    # Verificação se o valor é zero
    if df_avaliando['Atratividade local'][0] == 0:
        df_transp['fal'] = 1
    else:
        df_transp['fal'] = round(df_avaliando['Atratividade local'][0] / df_transp['Atratividade local'], 2)

    df_transp = df_transp[['fal']]

    #-----------------#

    # fator de correção da área construída (fac)
    df_area_const = df_dados.copy()
    df_area_const = df_area_const[['Área Construída']]
    df_area_const['razao'] = (df_area_const['Área Construída'] / df_avaliando['Área Construída'][0])
    df_area_const['dif'] = abs(df_area_const['Área Construída'] - df_avaliando['Área Construída'][0])
    # 30% da área do terreno do avaliando
    x_ac = 0.3 * df_avaliando['Área Construída'][0]
    # coeficiente n conforme a diferença entre a área do avaliando e dos dados
    df_area_const['n'] = df_area_const['dif'].apply(lambda dif: 0.250 if dif <= x_ac else 0.125)

    # Verificação se o valor é zero
    if df_avaliando['Área Construída'][0] == 0:
        df_area_const['fac'] = 1
    else:
        df_area_const['fac'] = round((df_area_const['razao']) ** (df_area_const['n']), 2)

    df_area_const = df_area_const[['fac']]

    #-----------------#

    # fator de correção da área do terreno (fat)
    df_area_terreno = df_dados.copy()
    df_area_terreno = df_area_terreno[['Área Terreno']]
    df_area_terreno['razao'] = (df_area_terreno['Área Terreno'] / df_avaliando['Área Terreno'][0])
    df_area_terreno['dif'] = abs(df_area_terreno['Área Terreno'] - df_avaliando['Área Terreno'][0])
    # 30% da área do terreno do avaliando
    x_at = 0.3 * df_avaliando['Área Terreno'][0]
    # coeficiente n conforme a diferença entre a área do avaliando e dos dados
    df_area_terreno['n'] = df_area_terreno['dif'].apply(lambda dif: 0.250 if dif <= x_at else 0.125)

    # Verificação se o valor é zero
    if df_avaliando['Área Terreno'][0] == 0:
        df_area_terreno['fat'] = 1
    else:
        df_area_terreno['fat'] = round((df_area_terreno['razao']) ** (df_area_terreno['n']), 2)

    df_area_terreno = df_area_terreno[['fat']]

    #-----------------#

    # fator profundidade (fpe)
    # Define a função coeficiente_profundidade antes de criar os DataFrames
    def coeficiente_profundidade(row):
        A = row['Área Terreno']
        t = row['Testada']

        pe = round(A/t, 2)
        hipotese_1 = A > 5000 and pe > 90
        hipotese_2 = A <= 5000 or (A > 5000 and pe <= 90)

        if t == 0:
           coef_pe = 1 
        else:
            if finalidade == "Tipologias com área construída":
                coef_pe = 1
            else:
                if hipotese_1:
                    coef_pe = round(4.8 * (t ** 0.2) * (A ** -0.4), 3)
                else:
                    if pe < 20:
                        coef_pe = round((pe/20) ** 0.5, 3)
                    elif 20 <= pe < 33:
                        coef_pe = 1
                    elif 33 <= pe < 90:
                        coef_pe = round((33/pe) ** 0.5, 3)
                    else:
                        coef_pe = 0.6

        return coef_pe

    # Cria os DataFrames df_profundidade e df_profundidade_aval
    df_profundidade = df_dados[['Área Terreno','Testada']].copy()
    df_profundidade['coef_pe'] = df_profundidade.apply(coeficiente_profundidade, axis=1)

    df_profundidade_aval = df_avaliando[['Área Terreno','Testada']].copy()
    df_profundidade_aval['coef_pe'] = df_profundidade_aval.apply(coeficiente_profundidade, axis=1)

    df_profundidade['fpe'] = round(df_profundidade_aval['coef_pe'][0]/df_profundidade['coef_pe'],2)
    df_profundidade = df_profundidade[['fpe']]

    #-----------------#

    # fator topografia (ftp)
    # dicionário topografia
    dict_topo = {
        'plano <5%': 1,
        'aclive_leve 5% e 30%': 0.95,
        'declive_leve 5% e 30%': 0.90,
        'aclive_acentuado >30%': 0.85,
        'declive_acentuado >30%': 0.80,
        'não se aplica' : 1,
    }

    # Cria os DataFrames df_topografia e df_topografia_aval
    df_topografia = df_dados.copy()
    df_topografia = df_topografia[['Topografia']]

    df_topografia_aval = df_avaliando.copy()
    df_topografia_aval = df_topografia_aval[['Topografia']]

    # Função para mapear os valores de Topografia para cod_topo usando o dicionário
    def mapear_cod_topo(topografia):
        return dict_topo.get(topografia, 0)  # 0 como valor padrão caso a topografia não esteja no dicionário
    # Aplicando a função para criar a coluna cod_topo em df_dados e df_avaliando
    df_topografia['coef_tp'] = df_topografia['Topografia'].apply(mapear_cod_topo)
    df_topografia_aval['coef_tp'] = df_topografia_aval['Topografia'].apply(mapear_cod_topo)
    df_topografia['ftp'] = round(df_topografia_aval['coef_tp'][0]/df_topografia['coef_tp'],2)
    df_topografia = df_topografia[['ftp']] 

    #-----------------#

    # fator relevo (frv)
    # dicionário relevo
    dict_rel = {
        'plana' : 1.1,
        'ondulada': 1.00,
        'montanhosa/acidentada': 0.80,
        'não se aplica' : 1.00,
    } 

    # Cria os DataFrames df_relevo e df_relevo_aval
    df_relevo = df_dados.copy()
    df_relevo = df_relevo[['Relevo']]

    df_relevo_aval = df_avaliando.copy()
    df_relevo_aval = df_relevo_aval[['Relevo']]

    # Função para mapear os valores de Relevo para cod_rel usando o dicionário
    def mapear_cod_rel(relevo):
        return dict_rel.get(relevo, 0)  # 0 como valor padrão caso o relevo não esteja no dicionário
    # Aplicando a função para criar a coluna cod_rel em df_dados e df_avaliando
    df_relevo['coef_rv'] = df_relevo['Relevo'].apply(mapear_cod_rel)
    df_relevo_aval['coef_rv'] = df_relevo_aval['Relevo'].apply(mapear_cod_rel)
    df_relevo['frv'] = round(df_relevo_aval['coef_rv'][0]/df_relevo['coef_rv'],2)
    df_relevo = df_relevo[['frv']]

    #-----------------#     

    # fator superfície (fsp)
    # dicionário superfície
    dict_sup = {
        'Seca': 1.00,
        'Região inundável mas não atingida': 0.90,
        'Região inundável mas atingida periodicamente': 0.70,
        'Alagada': 0.60,
        'não se aplica' : 1.00,
    }       

    # Cria os DataFrames df_superficie e df_superficie_aval
    df_superficie = df_dados.copy()
    df_superficie = df_superficie[['Superfície']]

    df_superficie_aval = df_avaliando.copy()
    df_superficie_aval = df_superficie_aval[['Superfície']]

    # Função para mapear os valores de Superfície para cod_sup usando o dicionário
    def mapear_cod_sup(superficie):
        return dict_sup.get(superficie, 0)  # 0 como valor padrão caso a superficie não esteja no dicionário
    # Aplicando a função para criar a coluna cod_sup em df_dados e df_avaliando
    df_superficie['coef_sp'] = df_superficie['Superfície'].apply(mapear_cod_sup)
    df_superficie_aval['coef_sp'] = df_superficie_aval['Superfície'].apply(mapear_cod_sup)
    df_superficie['fsp'] = round(df_superficie_aval['coef_sp'][0]/df_superficie['coef_sp'],2)
    df_superficie = df_superficie[['fsp']]        

    #-----------------#

    # fator aproveitamento (fap)
    # dicionário aproveitamento
    dict_apr = {
        'Loteamento': 1.00,
        'Indústria': 0.90,
        'Culturas': 0.80,
        'não se aplica' : 1.00,
    }

    # Cria os DataFrames df_aproveitamento e df_aproveitamento_aval
    df_aproveitamento = df_dados.copy()
    df_aproveitamento = df_aproveitamento[['Aproveitamento']]

    df_aproveitamento_aval = df_avaliando.copy()
    df_aproveitamento_aval = df_aproveitamento_aval[['Aproveitamento']]

    # Função para mapear os valores de Aproveitamento para cod_apr usando o dicionário
    def mapear_cod_apr(aproveitamento):
        return dict_apr.get(aproveitamento, 0)  # 0 como valor padrão caso o aproveitamento não esteja no dicionário
    # Aplicando a função para criar a coluna cod_apr em df_dados e df_avaliando
    df_aproveitamento['coef_ap'] = df_aproveitamento['Aproveitamento'].apply(mapear_cod_apr)
    df_aproveitamento_aval['coef_ap'] = df_aproveitamento_aval['Aproveitamento'].apply(mapear_cod_apr)
    df_aproveitamento['fap'] = round(df_aproveitamento_aval['coef_ap'][0]/df_aproveitamento['coef_ap'],2)
    df_aproveitamento = df_aproveitamento[['fap']] 

    #-----------------#

    # fator acessibilidade viária (fav)
    # dicionário acessibilidade
    dict_ace = {
        'Ótima': 1.00,
        'Muito boa': 0.95,
        'Boa': 0.90,
        'Desfavorável': 0.80,
        'Má': 0.75,
        'Péssima': 0.70,
        'não se aplica' : 1.00,
    }
    
    # Cria os DataFrames df_acesso e df_acesso_aval
    df_acesso = df_dados.copy()
    df_acesso = df_acesso[['Acessibilidade']]

    df_acesso_aval = df_avaliando.copy()
    df_acesso_aval = df_acesso_aval[['Acessibilidade']]

    # Função para mapear os valores de Acessibilidade para cod_ace usando o dicionário
    def mapear_cod_ace(acesso):
        return dict_ace.get(acesso, 0)  # 0 como valor padrão caso a acessibilidade não esteja no dicionário
    # Aplicando a função para criar a coluna cod_ace em df_dados e df_avaliando
    df_acesso['coef_av'] = df_acesso['Acessibilidade'].apply(mapear_cod_ace)
    df_acesso_aval['coef_av'] = df_acesso_aval['Acessibilidade'].apply(mapear_cod_ace)
    df_acesso['fav'] = round(df_acesso_aval['coef_av'][0]/df_acesso['coef_av'],2)
    df_acesso = df_acesso[['fav']]

    #-----------------#

    # fator idade aparente e conservação (fic)
    # dicionário padrão construtivo
    dict_ic = {
            'id<5_novo': 1.00,
            'id<5_bom': 0.95,
            'id<5_reparos simples': 0.80,
            'id<5_reparos importantes': 0.45,
            'id entre 6 e 10_novo': 0.95,
            'id entre 6 e 10_bom': 0.90,
            'id entre 6 e 10_reparos simples': 0.75,
            'id entre 6 e 10_reparos importantes': 0.40,
            'id entre 11 e 30_novo': 0.85,
            'id entre 11 e 30_bom': 0.80,
            'id entre 11 e 30_reparos simples': 0.65,
            'id entre 11 e 30_reparos importantes': 0.35,
            'id entre 31 e 50_novo': 0.55,
            'id entre 31 e 50_bom': 0.50,
            'id entre 31 e 50_reparos simples': 0.45,
            'id entre 31 e 50_reparos importantes': 0.25,
            'id>50_novo': 0.30,
            'id>50_bom': 0.20,
            'id>50_reparos simples': 0.15,
            'id>50_reparos importantes': 0.10,
            'não se aplica' : 1,
        }
    # Cria os DataFrames df_idade_cons e df_idade_cons_aval
    df_idade_cons = df_dados.copy()
    df_idade_cons = df_idade_cons[['Idade aparente e conservação']]
    
    df_idade_cons_aval = df_avaliando.copy()
    df_idade_cons_aval = df_idade_cons_aval[['Idade aparente e conservação']]
    
    # Função para mapear os valores de idade aparente e conservação para cod_id_cons usando o dicionário
    def mapear_cod_id_cons(id_cons):
        return dict_ic.get(id_cons, 0) # 0 como valor padrão caso a Idade e Conservação não esteja no dicionário
    # Aplicando a função para criar a coluna cod_ic em df_dados e df_avaliando
    df_idade_cons['coef_ic'] = df_idade_cons['Idade aparente e conservação'].apply(mapear_cod_id_cons)
    df_idade_cons_aval['coef_ic'] = df_idade_cons_aval['Idade aparente e conservação'].apply(mapear_cod_id_cons)
    df_idade_cons['fic'] = round(df_idade_cons_aval['coef_ic'][0] / df_idade_cons['coef_ic'],2)
    df_idade_cons = df_idade_cons[['fic']]

    #-----------------#

    # fator padrão construtivo (fpd)
    # dicionário padrão construtivo
    dict_pad = {
        'baixo_residencial': 1.00,
        'médio/baixo_residencial': 1.15,
        'médio_residencial': 1.30,
        'médio/alto_residencial': 1.45,
        'alto_residencial': 1.65,
        'baixo_comercial': 1.00,
        'médio/baixo_comercial': 1.08,
        'médio_comercial': 1.15,
        'médio/alto_comercial': 1.25,
        'alto_comercial': 1.40,
        'não se aplica' : 1,
        }

    # Cria os DataFrames df_padrao e df_padrao_aval
    df_padrao = df_dados.copy()
    df_padrao = df_padrao[['Padrão construtivo']]
    
    df_padrao_aval = df_avaliando.copy()
    df_padrao_aval = df_padrao_aval[['Padrão construtivo']]
    # Função para mapear os valores de padrão construtivo para cod_pad usando o dicionário
    def mapear_cod_pad(padrao):
        return dict_pad.get(padrao, 0)  # 0 como valor padrão caso o padrão não esteja no dicionário
    # Aplicando a função para criar a coluna cod_pad em df_dados e df_avaliando
    df_padrao['coef_pd'] = df_padrao['Padrão construtivo'].apply(mapear_cod_pad)
    df_padrao_aval['coef_pd'] = df_padrao_aval['Padrão construtivo'].apply(mapear_cod_pad)
    df_padrao['fpd'] = round(df_padrao_aval['coef_pd'][0]/df_padrao['coef_pd'],2)
    df_padrao = df_padrao[['fpd']]

    #-----------------#

    # fator vagas de estacionamento (fvg)
    df_vaga = df_dados[['Vagas']].copy()
    df_vaga_aval = df_avaliando[['Vagas']].copy()
    # Calcular a diferença entre as colunas 'Vagas' nos dois DataFrames
    df_vaga['dif'] = df_vaga['Vagas'] - df_vaga_aval['Vagas'][0]
    # Definir a função para o cálculo da coluna 'fvg'
    def calculate_fcg(dif, vagas):
        if dif == 0:
            return 1
        else:
            return 1 - 0.067 * dif
    # Aplicar a função para calcular a coluna 'fvg'
    df_vaga['fvg'] = round(df_vaga.apply(lambda row: calculate_fcg(row['dif'], row['Vagas']), axis=1), 2)
    df_vaga = df_vaga[['fvg']]

    #-----------------#

    # fator extra (à critério do avaliador) (fex)
    df_exc = df_dados.copy()
    df_exc = df_exc[['Coeficiente extra']]

    # Verificação se o valor é zero
    if df_avaliando['Coeficiente extra'][0] == 0:
        df_exc['fex'] = 1
    else:
        df_exc['fex'] = round(df_avaliando['Coeficiente extra'][0] / df_exc['Coeficiente extra'], 2)

    df_exc = df_exc[['fex']]

    #-----------------#

    # concatemando o dataframe principal com as dataframes dos fatores
    result = pd.concat([df_dados, df_transp, df_area_const, df_area_terreno, df_profundidade, df_topografia, df_relevo,
                        df_superficie,df_aproveitamento, df_acesso, df_idade_cons, df_padrao, df_vaga, df_exc], axis=1)
    result['Valor_desc'] = round(result['Valor']*(result['fof']), 2)
    if finalidade == "Tipologias com área construída":
        result['Vunit'] = round((result['Valor_desc']/result['Área Construída']), 2)
    else:
        result['Vunit'] = round((result['Valor_desc']/result['Área Terreno']), 2)
        
    result['ordem'] = range(1, len(result)+1)

    result = result[['ordem', 'lat','lon','Endereço','Atratividade local', 'Área Construída', 'Área Terreno', 'Testada', 'Topografia', 
                     'Relevo','Superfície','Aproveitamento','Acessibilidade', 'Idade aparente e conservação', 'Padrão construtivo', 'Vagas',
                     'Coeficiente extra', 'Valor', 'fof','Valor_desc', 'Vunit','fal', 'fac', 'fat','fpe', 'ftp','frv','fsp',
                     'fap','fav', 'fic','fpd', 'fvg', 'fex']]


    result['Vunit_hom'] = round(result['Vunit'] * result['fal'] * \
                                                        result['fac'] * \
                                                        result['fat'] * \
                                                        result['fpe'] * \
                                                        result['ftp'] * \
                                                        result['frv'] * \
                                                        result['fsp'] * \
                                                        result['fap'] * \
                                                        result['fav'] * \
                                                        result['fic'] * \
                                                        result['fpd'] * \
                                                        result['fvg'] * \
                                                        result['fex'], 2)

    #-----------------------------------------------------RESULTADOS---------------------------------------------------------#
        
    # RESULTADOS ESTATÍSTICOS INICIAIS 
    num = len(result)
    media = round(result['Vunit_hom'].mean(), 2)
    valor_hom_máximo = round(result['Vunit_hom'].max(), 2)
    valor_hom_mínimo = round(result['Vunit_hom'].min(), 2)
    limite_superior = round(media * 1.3 ,2)
    limite_inferior = round(media * 0.7 ,2)
    desvio_padrao = round(result['Vunit_hom'].std(), 2)
    coef_variacao = round((desvio_padrao / media)*100, 2)
    
    # CRITÉRIO DE CHAUVENET
    dict_vc = {
        2: 1.15,3: 1.38,4: 1.54,5: 1.65,6: 1.73,7: 1.80,8: 1.85,9: 1.91,10: 1.96,11: 1.99,
        12: 2.03,13: 2.06,14: 2.10,15: 2.13,16: 2.16,17: 2.18,18: 2.20,19: 2.21,20: 2.24,
        21: 2.26,22: 2.28,23: 2.30,24: 2.31,25: 2.33,26: 2.35,27: 2.36,28: 2.37,29: 2.38,
        30: 2.93
    }
    vc = dict_vc[num]
    vc
    result['z-score'] = round(abs((result['Vunit_hom'] - media) / desvio_padrao), 2)
    result['Status'] = np.where(result['z-score'] > vc, 'rejeitado', 'aceito')
    
    # cópia para dataframe na interface
    df_interface = result.copy()

    # DADOS REMOVIDOS
    outliers = result[result['Status'] == 'rejeitado']
    
    # REMOÇÃO DE OUTLIERS PELO CRITÉRIO DE CHAUVENET
    result = result[result['Status'] != 'rejeitado']
    
    # CÓPIA DO DATAFRAME ORIGINAL PARA PLOTAGEM NA INTERFACE
    df_grafico = result.copy()
    
    # GRAU DE FUNDAMENTAÇÃO
    # item_1 - Graus de Fundamentação (Caracterização do imóvel avaliando)
    if caract_avaliando == "Completa quanto a todos os fatores analisados":
        item_1 = 3
    elif caract_avaliando == "Completa quanto aos fatores utilizados no tratamento":
        item_1 = 2
    else:
        item_1 = 1

    # item_2 - Graus de Fundamentação (Quantidade mínima de dados)
    if num >= 12:
        item_2 = 3
    elif 5 <= num <12:
            item_2 = 2
    elif 3 <= num <5:
            item_2 = 1
    else:
        item_2 = 0

    # item_3 - Graus de Fundamentação (Identificação dos dados)  
    if ident_dados == "Apresentação de informações relativas a todas as características dos dados analisados, com foto e características observadas pelo autor do laudo":
        item_3 = 3
    elif ident_dados == "Apresentação de informações relativas a todas as características dos dados analisados":
        item_3 = 2
    else:
        item_3 = 1

    # item_4 - Graus de Fundamentação (Intervalo admissível de ajuste para o conjunto de fatores)
    max = result.iloc[:, 21:34].max().max()
    min = result.iloc[:, 21:34].min().min()
    if num >= 5:
        if min >= 0.8 and max <= 1.2:
            item_4 = 3
        elif min >= 0.5 and max <= 2.0:
            item_4 = 2
        else:
            item_4 = 1  # Condição ausente aqui
    else:
        if min >= 0.8 and max <= 1.2:
            item_4 = 1
        else:
            item_4 = 0

    # enquadramento
    soma = item_1 + item_2 + item_3 + item_4
    if soma > 10 and item_2 == 3 and item_4 == 3 and item_1 >= 2 and item_3 >= 2:
        fundamentacao = "III"
    elif soma > 6 and item_2 >= 2 and item_4 >= 2 and item_1 >= 1 and item_3 >= 1:
        fundamentacao = "II"
    elif soma > 4 and item_2 >= 1 and item_4 >= 1 and item_1 >= 1 and item_3 >= 1:
        fundamentacao = "I"
    else:
        fundamentacao = "Fora dos critérios"
    
    # RESULTADOS ESTATÍSTICOS FINAIS 
    num_dados = len(df_dados)
    num = len(result)
    dados_outliers = len(outliers)
    media = round(result['Vunit_hom'].mean(), 2)
    valor_hom_máximo = round(result['Vunit_hom'].max(), 2)
    valor_hom_mínimo = round(result['Vunit_hom'].min(), 2)
    limite_superior = round(media * 1.3 ,2)
    limite_inferior = round(media * 0.7 ,2)
    desvio_padrao = round(result['Vunit_hom'].std(), 2)
    coef_variacao = round((desvio_padrao / media)*100, 2)
    # Crie uma string formatada com os RESULTADOS ESTATÍSTICOS FINAIS
    resultados_formatados = f"""
    Número de dados iniciais: {num_dados} dados
    Número de dados utilizados: {num} dados
    Valor Crítico (Chauvenet): {vc}
    Outliers: {dados_outliers} dado(s)
    Média saneada: R$ {media:,.2f} /m²
    Valor máximo: R$ {valor_hom_máximo:,.2f} /m²
    Valor mínimo: R$ {valor_hom_mínimo:,.2f} /m²
    Lim superior (Média*1,3): R$ {limite_superior:,.2f} /m²
    Lim inferior (Média*0,7): R$ {limite_inferior:,.2f} /m²
    Desvio padrão: R$ {desvio_padrao:,.2f} /m²
    Coeficiente variação: {coef_variacao} %
    """
    # Substituindo ponto por vírgula
    resultados_formatados = resultados_formatados.replace('.', '@')
    resultados_formatados = resultados_formatados.replace(',', '.')
    resultados_formatados = resultados_formatados.replace('@', ',')
  
    
    # INTEREVALO DE CONFIANÇA DE 80%
    # importando a tabela de t de student
    df_t = pd.read_excel('TABELAS.xlsx','t')
    # número de dados
    n =  result.shape[0]-1
    # "t" de student
    gl = df_t[df_t['gl (n-1)'] == n]
    tc = gl.iloc[0, 3]
    # limites infeiror e superior do IC de 80% e amplitude
    li_IC = round(media - tc * ((desvio_padrao/(num-1)**0.5)), 2)
    ls_IC = round(media + tc * ((desvio_padrao/(num-1)**0.5)), 2)
    A = round(ls_IC - li_IC, 2)
    A_perc = round((A / media)*100, 2)
    
    def calcular_grau(a):
        if a <= 30:
            return "Grau III"
        elif a <= 40:
            return "Grau II"
        elif a <= 50:
            return "Grau I"
        else:
            return "Fora dos critérios"
            
    precisao = calcular_grau(A_perc)
    
    # Crie uma string formatada com o INTEREVALO DE CONFIANÇA DE 80%
    intervalo_confiança = f"""
    t student: {tc}
    Média saneada: R$ {media:,.2f} /m²
    Limite inferior: R$ {li_IC:,.2f} /m²
    Limite superior: R$ {ls_IC:,.2f} /m²
    Amplitude: R$ {A} /m²
    Amplitude percentual: {A_perc} %
    Grau de Fundamentação {fundamentacao}
    Grau de Precisão: {precisao}
    """
    # Substituindo ponto por vírgula
    intervalo_confiança = intervalo_confiança.replace('.', '@')
    intervalo_confiança = intervalo_confiança.replace(',', '.')
    intervalo_confiança = intervalo_confiança.replace('@', ',')

    # VALOR CALCULADO A PARTIR DOS VALORES HOMOGENEIZADOS UTILIZANDO O CRITÉRIO DE CLASSAS D0 ABUNAHMAN
    # dividindo a amplitude em 3 classes
    C = round((A / 3), 2)
    # calculando os intervalos das 3 classes
    C1 = round(result[(result['Vunit_hom'] >= li_IC) & (result['Vunit_hom'] <= li_IC + C)]['Vunit_hom'].count(), 2)
    C2 = round(result[(result['Vunit_hom'] >= li_IC + C) & (result['Vunit_hom'] <= ls_IC - C)]['Vunit_hom'].count(), 2)
    C3 = round(result[(result['Vunit_hom'] >= ls_IC - C) & (result['Vunit_hom'] <= ls_IC)]['Vunit_hom'].count(), 2)
    # crinado listas com os valores encontrados nos intervalos
    list_C1 = result[(result['Vunit_hom'] >= li_IC) & (result['Vunit_hom'] <= li_IC + C)]['Vunit_hom'].tolist()
    list_C2 = result[(result['Vunit_hom'] >= li_IC + C) & (result['Vunit_hom'] <= ls_IC - C)]['Vunit_hom'].tolist()
    list_C3 = result[(result['Vunit_hom'] >= ls_IC - C) & (result['Vunit_hom'] <= ls_IC)]['Vunit_hom'].tolist()
 

    pC1 = round(sum(C1 * elemento for elemento in list_C1), 2)
    pC2 = round(sum(C2 * elemento for elemento in list_C2), 2)
    pC3 = round(sum(C3 * elemento for elemento in list_C3), 2)

    divisor = ((C1 * C1) if C1 != 0 else 0) +((C2 * C2) if C2 != 0 else 0) + ((C3 * C3) if C3 != 0 else 0)

    media_pond = round((pC1 + pC2 + pC3) / divisor, 2)

    # VALORES CALCULADOS
     
    if finalidade == "Tipologias com área construída":
        Valor_imóvel = round(media * df_avaliando['Área Construída'], 2).item()
    else:
        Valor_imóvel = round(media * df_avaliando['Área Terreno'], 2).item()
    LI = round(Valor_imóvel* 0.85, 2)
    LS = round(Valor_imóvel* 1.15, 2)
    
    if finalidade == "Tipologias com área construída":
        Valor_imóvel_2 = round((media_pond) * df_avaliando['Área Construída'], 2).item()
    else:
        Valor_imóvel_2 = round((media_pond) * df_avaliando['Área Terreno'], 2).item()
    LI_classes = round(Valor_imóvel_2* 0.85, 2)
    LS_classes = round(Valor_imóvel_2* 1.15, 2)
    
    # Crie uma string formatada com os VALORES CALCULADOS
    if finalidade == "Tipologias com área construída":
        area = df_avaliando['Área Construída'].item()
    else:
        area = df_avaliando['Área Terreno'].item()
        
    valores_finais = f"""
    Área avaliando: {area:,.2f} m²
    ---------
    Valor (média simples): R$ {Valor_imóvel:,.2f}
    LI: R$ {LI:,.2f} 
    LS: R$ {LS:,.2f}
    Vu (média simples): R$ {media:,.2f} /m²
    ---------
    Valor (critério classes): R$ {Valor_imóvel_2:,.2f}
    LI: R$ {LI_classes:,.2f} 
    LS: R$ {LS_classes:,.2f}
    Vu (critério classes): R$ {media_pond:,.2f} /m²
    """

    # Substituindo ponto por vírgula
    valores_finais = valores_finais.replace('.', '@')
    valores_finais = valores_finais.replace(',', '.')
    valores_finais = valores_finais.replace('@', ',')
    
    # Crie uma string formatada com VALOR FINAL ATRIBUÍDO
    v_atrib = int(v_atrib)
    valor_ext = numero_por_extenso(v_atrib)
    
    v_relat = f"{v_atrib:,.2f}"
    v_relat = v_relat.replace('.', '@')
    v_relat = v_relat.replace(',', '.')
    v_relat = v_relat.replace('@', ',')

    #-----------------#
    
    # criação de strings p/ relatórios (interface/word) dos campos do responsável, introdução, região, diagnóstico e avalaliando.
    dados_resp = f"""
    Responsável Técnico: {nome}
    Profissão: {prof} 
    Entidade de Classe: {ent} {uf}
    Número do registro: {reg}
    """
    introd = f"""
    Logradouro e número: {lograd}
    Município: {munic}
    Tipo de imóvel: {tipo_imo}
    Solicitante: {solic}
    Finalidade: {final_espec}
    Objetivo: {objetivo}
    Pressupostos, Ressalvas e Fatores Limitantes: {press}
    """
    aval_infos = f"""
    Latitude: {df_avaliando['lat'].iloc[0]}
    Longitude: {df_avaliando['lon'].iloc[0]}
    Atratividade local: {str(df_avaliando['Atratividade local'].iloc[0]).replace(".", ",")}
    area_construida = {str(df_avaliando['Área Construída'].iloc[0]).replace(".", ",")} m²
    area_terreno = {str(df_avaliando['Área Terreno'].iloc[0]).replace(".", ",")} m²
    testada = {str(df_avaliando['Testada'].iloc[0]).replace(".", ",")} m
    Topografia: {df_avaliando['Topografia'].iloc[0]}
    Relevo: {df_avaliando['Relevo'].iloc[0]}
    Superfície: {df_avaliando['Superfície'].iloc[0]}
    Aproveitamento: {df_avaliando['Aproveitamento'].iloc[0]}
    Acessibilidade: {df_avaliando['Acessibilidade'].iloc[0]}
    Idade aparente e conservação: {df_avaliando['Idade aparente e conservação'].iloc[0]}
    Padrão construtivo: {df_avaliando['Padrão construtivo'].iloc[0]}
    Vagas: {df_avaliando['Vagas'].iloc[0]}
    Coeficiente extra: {str(df_avaliando['Coeficiente extra'].iloc[0]).replace(".", ",")}
    """
    regiao = f"""
    Infraestrutura: {str(infra).replace("[", "").replace("]", "").replace("'", "")}
    Serviços públicos: {str(serv).replace("[", "").replace("]", "").replace("'", "")}
    Uso: {uso}
    Padrão predominante na região: {pad_reg}
    Tipo de via de acesso: {tipo_via}
    Outras observações: {obs_gerais}
    """
    diag = f"""
    Performance: {per}
    Nível de Ofertas do Segmento: {ofe}
    Liquidez: {liq}
    """
    valor_atribuido = f"""
    CONCLUSÃO DE VALOR
    Valor atribuído: R$ {v_relat} 
    ({valor_ext})
    """
    assinatura = f"""
    Data: {data}
    
    
    {nome} | {prof} 
    {ent}-{uf} {reg}
    """
    
 #-------------------------------------------------------ANEXO EXCEL----------------------------------------------------#
    
    # Crie um objeto ExcelWriter para escrever no arquivo Excel
    nome_com_extensao = os.path.basename(planilha.name)
    nome_do_arquivo = os.path.splitext(nome_com_extensao)[0]
    # Defina o nome da planilha de saída com base no nome da planilha de entrada
    output_file = f"{nome_do_arquivo}_relatório.xlsx"
    #output_file = 'relatório.xlsx' (substituído pelo código acima)
    
    with pd.ExcelWriter(output_file, engine='xlsxwriter') as writer:
        
        # Salve o DataFrame 'avaliando' na planilha 'relatório'
        df_avaliando.to_excel(writer, sheet_name='avaliando', index=False)
        
 #-----------------#
        
        # Salve o DataFrame 'result' na planilha 'relatório'
        df_dados.to_excel(writer, sheet_name='dados', index=False)
        
 #-----------------#
        
        # Salve o DataFrame 'dado_hom' na planilha 'relatório'
        result.to_excel(writer, sheet_name='dados_hom', index=False)
    
 #-----------------#
    
        # Salve o DataFrame 'outliers' na planilha 'relatório'
        outliers.to_excel(writer, sheet_name='outliers', index=False)
        
 #-----------------#
        
        # Crie um novo DataFrame com os resultados estatísticos
        result_estatisticos = pd.DataFrame({
            'Número de dados iniciais': [num],
            'Número de dados utilizados': [num_dados],
            'Valor Crítico (Chauvenet)': [vc],
            'Outliers': [dados_outliers],
            'Média': [media],
            'Valor homogeneizado máximo': [valor_hom_máximo],
            'Valor homogeneizado mínimo': [valor_hom_mínimo],
            'Limite superior (Média x 1,3)': [limite_superior],
            'Limite inferior (Média x 0,7)': [limite_inferior],
            'Desvio padrão': [desvio_padrao],
            'Coeficiente_variacao (%)': [coef_variacao]
        })

        # Transponha o DataFrame
        result_estatisticos = result_estatisticos.T.reset_index()
        # Defina os nomes das colunas do novo DataFrame
        result_estatisticos.columns = ['Nome da Coluna', 'Valor']
        result_estatisticos.to_excel(writer, sheet_name='resultados', index=False)

 #-----------------#
        
        # Crie um novo DataFrame com os resultados do IC
        result_ic = pd.DataFrame({
            'Número de dados': [n],
            't student': [tc],
            'Limite superior do IC de 80%': [ls_IC],
            'Limite inferior do IC de 80%': [li_IC],
            'Amplitude': [A],
            'Amplitude%':[A_perc],
            'Grau de Fundamentação': [fundamentacao],
            'Grau de Precisão': [precisao]
        })
        
        # Transponha o DataFrame
        result_ic = result_ic.T.reset_index()
        # Defina os nomes das colunas do novo DataFrame
        result_ic.columns = ['Nome da Coluna', 'Valor']
        result_ic.to_excel(writer, sheet_name='IC', index=False)
 
 #-----------------#

        # Crie um novo DataFrame com os resultados do cálculo das classes de Abunahman
        result_classes = pd.DataFrame({
            'C = Amplitude / 3': [round(C, 2)],
            'li_IC = limite inferior do IC': [round(li_IC, 2)],
            'li_IC + C = limite inferior do IC + C': [round(li_IC + C, 2)],
            'ls_IC - C = limite superior do IC + C': [round(ls_IC - C, 2)],
            'ls_IC = limite superior do IC': [round(ls_IC, 2)],
            'C1 = quantidade de dados na classe 1': [C1],
            'C2 = quantidade de dados na classe 2': [C2],
            'C3 = quantidade de dados na classe 3': [C3],
            'list_C1 = listagem de dados na classe 1': [list_C1],
            'list_C2 = listagem de dados na classe 2': [list_C2],
            'list_C3 = listagem de dados na classe 3': [list_C3],
            'Soma da multiplicação dos valor pelos pesos - classe 1': [pC1],
            'Soma da multiplicação dos valor pelos pesos - classe 2': [pC2],
            'Soma da multiplicação dos valor pelos pesos - classe 3': [pC3],
            'Divisor da somas das classes': [divisor],
            'Média ponderada': [media_pond]
        })

        
        # Transponha o DataFrame
        result_classes = result_classes.T.reset_index()
        # Defina os nomes das colunas do novo DataFrame
        result_classes.columns = ['Nome da Coluna', 'Valor']
        result_classes.to_excel(writer, sheet_name='classes', index=False)
        
 #-----------------#
        
           # Crie um novo DataFrame com os resultados do valor do imóvel
        result_valores = pd.DataFrame({
            'Valor (média simples): R$': [Valor_imóvel],
            'LI: R$': [LI], 
            'LS: R$': [LS],
            'Vu (média simples): R$/m²': [media],
            'Valor (critério classes) R$:': [Valor_imóvel_2],
            'Vu (critério classes): R$/m²': [media_pond],
            'LI_classes: R$': [LI_classes], 
            'LS_classes: R$': [LS_classes]  
        })
        
        # Transponha o DataFrame
        result_valores = result_valores.T.reset_index()
        # Defina os nomes das colunas do novo DataFrame
        result_valores.columns = ['Nome da Coluna', 'Valor']
        result_valores.to_excel(writer, sheet_name='valor', index=False)
        
 #-----------------#
       
        mapa = plotar_mapa_com_dois_dataframes(result, df_avaliando)
        plt.savefig('mapa_rel.png')
        
 #-----------------#
        
        # para gerar um gráfico
        grafico_barras(df_grafico)
        
 #-----------------#
    
        # Salve o DataFrame 'result' em uma planilha
        result.to_excel(output_file, index=False)
        
 #-------------------------------------------------------RELATÓRIO NO WORD----------------------------------------------------#
        
        # Criação de um relatório da avaliação no word
        # Criar um novo documento do Word
        doc = Document()

        # Definir o título do documento
        doc.add_heading('Relatório de Avaliação de Imóvel', level=1)
        
        # Definir a cor do texto para preto
        #for paragraph in doc.paragraphs:
            #for run in paragraph.runs:
                #run.font.color.rgb = RGBColor(0, 0, 0)  # RGB para a cor preta

        # Definir as seções do relatório
        sections = [
            (dados_resp, "Informações do Responsável Técnico"),
            (introd, "Introdução"),
            (aval_infos, "Informações do avaliando"),
            (regiao, "Características da Região"),
            (diag, "Diagmóstico de Mercado"),
            ('Ver anexo', "Dados homogeneizados"),
            (resultados_formatados, "Resultados estatísticos"),
            (intervalo_confiança, "Intervalo de confiança de 80%"),
            (valores_finais, "Valores Calculados"),
            (valor_atribuido, "Valor final atribuído"),
            ('fig2.png', "Geolocalização da amostra"),
            ('scatter_plot.png', "Gráfico"),
            (assinatura,""),
        ]

        for content, title in sections:
            doc.add_heading(title, level=2)
            p = doc.add_paragraph()
            if title == "Geolocalização da amostra":  # Adiciona mapa como imagem
                doc.add_picture('fig2.png', width=Inches(4))  # Substitua 'mapa.png' pelo seu caminho e nome do arquivo
            elif title == "Gráfico":  # Adiciona gráfico como imagem
                doc.add_picture('scatter_plot.png', width=Inches(4))  # Substitua 'scatter_plot.png' pelo seu caminho e nome do arquivo
            else:  # Adiciona outros tipos de conteúdo
                run = p.add_run(str(content))
                run.font.size = Pt(12)
                p.alignment = WD_PARAGRAPH_ALIGNMENT.LEFT  # Define o alinhamento para à esquerda
                
            # Adiciona alinhamento à direita para a assinatura
            if title == "":
                p.alignment = WD_PARAGRAPH_ALIGNMENT.RIGHT

        # Salvar o documento em um arquivo .doc
        doc.save('relatorio_avaliacao.doc')
        
 #---------------------------------------------------------OUTPUTS-----------------------------------------------------------#
        
        # OUPUTS
        return dados_resp, introd, aval_infos, regiao, diag, df_interface, resultados_formatados, intervalo_confiança, valores_finais, mapa, 'scatter_plot.png', 'relatorio_avaliacao.doc', output_file
        
 #---------------------------------------------------------DEPLOY------------------------------------------------------------#
        
# Interface do Gradio
interface = gr.Interface(
    fn=avaliacao_imovel,
    inputs=[
        
        # Imput da planilha
        gr.components.File(label="Upload planilha", type="file", info="Importação de planilha padrão com o avaliando e os dados"),
        gr.Slider(3, 26, value=26, label="Número de dados", info="Escolha o número de dados", step=1),
        gr.Radio(["Terrenos e glebas", "Tipologias com área construída"], label="Tipo de Imóvel", info="Escolha o tipo de imóvel",
                value="Terrenos e glebas"),
        
        # Informações do Responsável Técnico
        gr.Textbox(label="Responsável Técnico", value="-"),
        gr.Dropdown(["Engenheiro Civil", "Arquiteto e Urbanista", "Corretor de Imóveis"],label="Profissão", value="-"),
        gr.Dropdown(["CREA", "CAU", "CRECI"],label="Entidade de Classe", value="-"),
        gr.Dropdown(["AC", "AL", "AP", "AM", "BA", "CE", "DF", "ES", "GO", "MA", "MT", "MS", "MG", "PA", "PB", "PR", "PE", "PI", "RJ", "RN", "RS", "RO", "RR", "SC", "SP", "SE", "TO"],label="Unidade Federativa", value="RS"),
        gr.Textbox(label="Nº do registro", value="-"),
        gr.Textbox(label="Data", value="-"),

        # Introdução
        gr.Textbox(label="Endereço (Logradouro, nº e bairro)", value="-"),
        gr.Textbox(label="Município", value="-"),
        gr.Textbox(label="Tipo de Imóvel", value="-"),
        gr.Textbox(label="Solicitante", value="-"),
        gr.Textbox(label="Finalidade", value="-"),
        gr.Textbox(label="Objetivo", value="-"),

        # Características da Região
        gr.Textbox(label="Pressupostos, Ressalvas e Fatores Limitantes", value="-"),
        gr.Dropdown(["Água Potável", "Energia Elétrica", "Telefone", "Pavimentação", "Esgoto Pluvial", "Esgoto Cloacal",
                   "Iluminação Pública"], value=["Água Potável"], multiselect=True, label="Infraestrutura Urbana"),
        gr.Dropdown(["Coleta de Lixo", "Transporte Coletivo", "Comércio", "Educação", "Saúde"], 
                  value=["Coleta de Lixo"], multiselect=True, label="Serviços Públicos"),
        gr.Radio(["Residencial", "Comercial", "Misto"], label="Uso",value="Residencial"),
        gr.Radio(["Baixo", "Normal", "Alto"], label="Padrão predominante na região",value="Normal"),
        gr.Radio(["Local", "Coletora", "Arterial"], label="Tipo de via de acesso ao imóvel",value="Local"),
        gr.Textbox(label="Outras informação", value="-"),

        # Diagnóstico de Mercado
        gr.Radio(["Aparentemente aquecido", "Sem destaque", "Aparentemente recessivo"], label="Performance",value="Sem destaque"),
        gr.Radio(["Aparentemente alto", "Sem destaque", "Aparentemente baixo"], label="Nível de Ofertas do Segmento",value="Sem destaque"),
        gr.Radio(["Provavelmente alto", "Sem destaque", "Provavelmente baixo"], label="Liquidez",value="Sem destaque"),
        
        # Para enquadramento
        gr.Radio(["Completa p/ todos fatores analisados", "Completa p/ os fatores utilizados", "Situação paradigma"],
                 label="Caracterização do avaliando", info="Para enquadramento quanto a fundamentação - ítem 1 da tabela 6 do anexo 2 - NBR 14.653-2",
                 value="Completa p/ os fatores utilizados"),
        gr.Radio(["Apresentação de informações relativas a todas as características dos dados analisados, com foto e características observadas pelo autor do laudo",
                      "Apresentação de informações relativas a todas as características dos dados analisados",
                      "Apresentação de informações relativas a todas as características dos dados correspondentes aos fatores analisados"],
                       label="Identificação dos dados",info="Para enquadramento quanto a fundamentação - ítem 3 da tabela 6 do anexo 2 - NBR 14.653-2",
                 value="Apresentação de informações relativas a todas as características dos dados analisados"),
        
        # Valor atribuído
        gr.Number(label="Valor atribuído", info="Este campo deverá ser preenchido após a execução do cálculo. O valor encontrado deverá ser inserido como número inteiro. Após isso, refazer o cálculo para que o valor atribuído conste no Laudo de Avaliação (valor e valor por extenso)", value=0),
        
    ],
    outputs=[
        gr.Textbox(label ="Informações do Responsável Técnico"),
        gr.Textbox(label ="Introdução"),
        gr.Textbox(label ="Informações do Avaliando"),
        gr.Textbox(label ="Características da Região"),
        gr.Textbox(label ="Diagnóstico de Mercado"),
        gr.Dataframe(label="Dados homogeneizados"),
        gr.components.Textbox(label="Resultados estatísticos"),
        gr.components.Textbox(label="Intervalo de confiança de 80%"),
        gr.components.Textbox(label="Valores Calculados"),
        gr.Plot(label="Geolocalização da amostra"),
        gr.Image(label="Gráfico"),
        gr.File(label="Laudo de Avaliação"),
        gr.components.File(label="Anexos"),
    
    ],
    live=False,
    capture_session=True,
    theme=gr.themes.Monochrome(primary_hue="yellow", secondary_hue="yellow"),
    #title = "<span style='color: gray; font-size: 48px;'>aval</span><span style='color: gray; font-size: 48px;'>ia</span><span style='color: gray; font-size: 48px;'>.FACTOR</span>",
    description=f"""
    <p style="text-align: left;"><b><span style='color: gray; font-size: 40px;'>aval</span><span style='color: orange; font-size: 40px;'>ia</span><span style='color: gray; font-size: 40px;'>.se</b></p>
    <p style="text-align: left;"></span>Aplicativo MCDDM com tratamento por fatores  /  Faça o upload de uma planilha XLS ou XLSX com os dados / Para um exemplo de estrutura de planilha, você pode baixar <a href='https://huggingface.co/spaces/DavidSB/avaliaFACTOR/resolve/main/dados_entrada_factor.xlsx' download='dados_entrada_factor.xlsx'>aqui</a><br><br></p>
    """
    )
# Executar o aplicativo Gradio
if __name__ == "__main__":
    interface.launch(debug=True)