# instalando biblioteca necessária !pip install XlsxWriter !pip install gradio --upgrade --quiet # importando bibliotecas necessárias import pandas as pd import numpy as np import gradio as gr from gradio import outputs # função da tratamento de dados por fatores def avaliacao_imovel(planilha): # Lendo a aba 'avaliando' da planilha df_avaliando = pd.read_excel(planilha.name, 'avaliando') df_dados = pd.read_excel(planilha.name, 'dados') # fator de atratividade local (fal) df_transp = df_dados.copy() df_transp = df_transp[['Atratividade local']] 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) 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) df_area_terreno['fat'] = round((df_area_terreno['razao']) ** (df_area_terreno['n']), 2) df_area_terreno = df_area_terreno[['fat']] #-----------------# # fator idade aparente e conservação (fic) # dicionário padrão construtivo dict_ic = { 'id<5 / ótimo': 1.00, 'id<5 / bom': 0.95, 'id<5 / regular': 0.90, 'id<5 / precário': 0.80, '630 / ótimo': 0.50, 'id>30 / bom': 0.45, 'id>30 / regular': 0.40, 'id>30 / precário': 0.30 } # cria dataframe apenas com as colunas necessárias a partir do dataframe dos dados df_idade_cons = df_dados.copy() df_idade_cons = df_idade_cons[['Idade aparente e conservação']] # cria dataframe apenas com as colunas necessárias a partir do dataframe do avaliando 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) # Aplicando a função para criar a coluna cod_topo 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, 'medio/baixo_residencial': 1.15, 'medio_residencial': 1.30, 'médio/alto_residencial': 1.45, 'alto_residencial': 1.65, 'baixo_comercial': 1.00, 'medio/baixo_comercial': 1.08, 'medio_comercial': 1.15, 'medio/alto_comercial': 1.25, 'alto_comercial': 1.4 } # cria dataframe apenas com as colunas necessárias a partir do dataframe dos dados df_padrao = df_dados.copy() df_padrao = df_padrao[['Padrão construtivo']] # cria dataframe apenas com as colunas necessárias a partir do dataframe do avaliando 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 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_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 'fcg' 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']] 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_idade_cons, df_padrao, df_vaga, df_exc], axis=1) result['Valor_desc'] = round(result['Valor']*(result['fof']), 2) result['Vunit'] = round((result['Valor_desc']/result['Área Construída']), 2) result = result[['Atratividade local', 'Área Construída', 'Área Terreno', 'Idade aparente e conservação', 'Padrão construtivo', 'Vagas', 'Coeficiente extra', 'Valor', 'fof','Valor_desc', 'Vunit','fal', 'fac', 'fat', 'fic', 'fpd', 'fvg', 'fex']] result['Vunit_hom'] = round(result['Vunit'] * result['fal'] * \ result['fac'] * \ result['fat'] * \ result['fic'] * \ result['fpd'] * \ result['fvg'] * \ result['fex'], 2) # 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'] = abs((result['Vunit_hom'] - media) / desvio_padrao) result['Status'] = np.where(result['z-score'] > vc, 'rejeitado', 'aceito') # DADOS REMOVIDOS outliers = result[result['Status'] == 'rejeitado'] # REMOÇÃO DE OUTLIERS PELO CRITÉRIO DE CHAUVENET result = result[result['Status'] != 'rejeitado'] # RESULTADOS ESTATÍSTICOS FINAIS 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: {num} dados Valor Crítico (Chauvenet): {vc} Outliers: {dados_outliers} dado(s) Média saneada: {media} R$/m² Valor máximo: {valor_hom_máximo} R$/m² Valor mínimo: {valor_hom_mínimo} R$/m² Lim superior (Média*1,3): {limite_superior} R$/m² Lim inferior (Média*0,7): {limite_inferior} R$/m² Desvio padrão: {desvio_padrao} R$/m² Coeficiente variação: {coef_variacao}% """ # 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) # Crie uma string formatada com o INTEREVALO DE CONFIANÇA DE 80% intervalo_confiança = f""" t student: {tc} Média saneada: {media} R$/m² limite infeiror IC_80%: {li_IC} R$/m² limite superior IC_80%: {ls_IC} R$/m² Aplitude: {A} R$/m² Aplitude %: {A_perc} % """ # 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() # ponderação pesos = [C1 * elemento for elemento in list_C1] + [C2 * elemento for elemento in list_C2] + [C3 * elemento for elemento in list_C3] soma_valores = round(sum(pesos), 2) nC1 = 1 if C1 == 0 else C1 nC2 = 1 if C2 == 0 else C2 nC3 = 1 if C3 == 0 else C3 nC = nC1 + nC2 + nC3 media_pond = round(soma_valores / nC, 2) # VALORES CALCULADOS Valor_imóvel = round(media * df_avaliando['Área Construída'], 2).item() Valor_imóvel_2 = round((media_pond) * df_avaliando['Área Construída'], 2).item() # Crie uma string formatada com os VALORES CALCULADOS valores_finais = f""" Área avaliando: {df_avaliando['Área Construída'].item()} m² Valor (média simples): R$ {Valor_imóvel} Vu (média simples): R$ {media} Valor (critério classes): R$ {Valor_imóvel_2} Vu (critério classes): R$ {media_pond} """ #-----------------# # OUTPUTS # Crie um objeto ExcelWriter para escrever no arquivo Excel output_file = 'relatório.xlsx' 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': [num], '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] }) # 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], 'Pesos - ponderações por classes': [pesos], 'Soma dos valores ponderados': [soma_valores], #'nC1': [nC1], #'nC2': [nC2], #'nC3': [nC3], 'Soma dos pesos': [nC], '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 total critério de ABUNAHMAN' : [Valor_imóvel_2], 'Valor total média simples' : [Valor_imóvel] }) # 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) #-----------------# # Salve o DataFrame 'result' em uma planilha result.to_excel('relatório.xlsx', index=False) #-----------------# # Retorna tanto a planilha quanto os resultados formatados return 'relatório.xlsx', resultados_formatados, intervalo_confiança, valores_finais # Interface do Gradio com input como arquivo XLS ou XLSX interface = gr.Interface( fn=avaliacao_imovel, inputs=[ gr.inputs.File(label="Upload planilha", type="file"), ], outputs=[ gr.outputs.File(label="Download planilha"), gr.outputs.Textbox(label="Resultados estatísticos"), gr.outputs.Textbox(label="Intervalo de confiança de 80%"), gr.outputs.Textbox(label="Valores Calculados"), ], live=True, capture_session=True, theme=gr.themes.Soft(), title="avaliaFACTOR", description="Aplicativo MCDDM com tratamento por fatores / Faça o upload de uma planilha XLS ou XLSX com os dados" ) # Executar o aplicativo Gradio if __name__ == "__main__": interface.launch(share=True, debug=True)