Upload 8 files

modules/dados.py

@@ -0,0 +1,257 @@
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import gradio as gr
+from math import radians, sin, cos, sqrt, atan2
+import googlemaps
+import locale
+from .shared_state import state  # Importa o estado compartilhado
+
+# Inicializando o cliente Google Maps com a chave da API
+gmaps = googlemaps.Client(key='AIzaSyDoJ6C7NE2CHqFcaHTnhreOfgJeTk4uSH0')
+
+# Configurando o locale para português do Brasil
+locale.setlocale(locale.LC_ALL, 'pt_BR.UTF-8')
+
+# Load the data
+data_path = 'data_2.xlsx'
+df = pd.read_excel(data_path, sheet_name='Planilha1')
+# Garantir que a coluna "Data" seja do tipo datetime
+df['Data'] = pd.to_datetime(df['Data'], errors='coerce')
+
+# Função para calcular a distância haversine
+def haversine(lat1, lon1, lat2, lon2):
+    raio_terra = 6371000  # Raio da Terra em metros
+    dlat = radians(lat2 - lat1)
+    dlon = radians(lon2 - lon1)
+    a = sin(dlat / 2)**2 + cos(radians(lat1)) * cos(radians(lat2)) * sin(dlon / 2)**2
+    c = 2 * atan2(sqrt(a), sqrt(1 - a))
+    return raio_terra * c
+
+# Função unificada para gerar mapa, estatísticas, DataFrame filtrado e arquivo de download
+def unified_action(selected_types, selected_bairros, selected_fonte, min_atotal, max_atotal, min_apriv, max_apriv, min_ater, max_ater, min_date, max_date, address=None, radius=None):
+    filtered_df = df.copy()
+
+    # Filtrando os dados com base nos tipos
+    if "Todos" not in selected_types:
+        filtered_df = filtered_df[filtered_df['Tipo'].isin(selected_types)]
+
+    # Filtrando os dados com base nos bairros
+    if "Todos" not in selected_bairros:
+        filtered_df = filtered_df[filtered_df['Bairro'].isin(selected_bairros)]
+
+    # Filtrando os dados com base na fonte
+    if "Todos" not in selected_fonte:
+        filtered_df = filtered_df[filtered_df['Fonte'].isin(selected_fonte)]
+
+    # Filtrando por área total
+    if min_atotal is not None:
+        filtered_df = filtered_df[filtered_df['Atotal'] >= min_atotal]
+    if max_atotal is not None:
+        filtered_df = filtered_df[filtered_df['Atotal'] <= max_atotal]
+
+    # Filtrando por área privativa
+    if min_apriv is not None:
+        filtered_df = filtered_df[filtered_df['Apriv'] >= min_apriv]
+    if max_apriv is not None:
+        filtered_df = filtered_df[filtered_df['Apriv'] <= max_apriv]
+
+    # Filtrando por área de terreno
+    if min_ater is not None:
+        filtered_df = filtered_df[filtered_df['Ater'] >= min_ater]
+    if max_ater is not None:
+        filtered_df = filtered_df[filtered_df['Ater'] <= max_ater]
+        
+    # Filtrando por data, se especificada
+    if min_date is not None:
+        filtered_df = filtered_df[filtered_df['Data'] >= pd.to_datetime(min_date)]
+    
+    if max_date is not None:
+        filtered_df = filtered_df[filtered_df['Data'] <= pd.to_datetime(max_date)]
+
+    # Filtrando por endereço e raio, se fornecidos
+    if address:
+        try:
+            result = gmaps.geocode(address)
+            if result:
+                coordinates = result[0]['geometry']['location']
+                center_lat = coordinates['lat']
+                center_lon = coordinates['lng']
+    
+                if radius:  # Se o raio for especificado
+                    # Calculando distâncias e filtrando
+                    filtered_df['Distance'] = filtered_df.apply(
+                        lambda row: haversine(center_lat, center_lon, row['Latitude'], row['Longitude']),
+                        axis=1
+                    )
+                    filtered_df = filtered_df[filtered_df['Distance'] <= radius]
+                else:  # Se nenhum raio for especificado
+                    # Filtrar pelo nome da rua ou bairro
+                    address_components = result[0]['address_components']
+                    street = None
+                    neighborhood = None
+    
+                    for component in address_components:
+                        if 'route' in component['types']:  # Rua
+                            street = component['long_name']
+                        if 'sublocality' in component['types'] or 'locality' in component['types']:  # Bairro
+                            neighborhood = component['long_name']
+    
+                    if street:
+                        filtered_df = filtered_df[filtered_df['Localização'].str.contains(street, na=False)]
+                    elif neighborhood:
+                        filtered_df = filtered_df[filtered_df['Bairro'].str.contains(neighborhood, na=False)]
+        except Exception as e:
+            print(f"Erro ao filtrar pelo endereço: {e}")
+
+
+    # Criando o mapa
+    fig = px.scatter_mapbox(
+        filtered_df,
+        lat="Latitude",
+        lon="Longitude",
+        hover_name="Localização",
+        hover_data={
+            "Valor": True,
+            "Vunit_priv": True,
+            "Tipo": True,
+            "url": True,
+        },
+        color="Tipo",
+        size="Valor",
+        size_max=30,
+        zoom=10
+    )
+
+    fig.update_layout(
+        mapbox_style="open-street-map",
+        autosize=True,
+        height=600,
+        margin={"r": 0, "t": 0, "l": 0, "b": 0},
+    )
+
+    # Adicionando círculo ao mapa se endereço e raio forem fornecidos
+    if address and radius:
+        try:
+            raio_terra = 6371000
+            pontos_lat = []
+            pontos_lon = []
+            for angulo in range(360):
+                ang_rad = radians(angulo)
+                d_lat = (radius / raio_terra) * cos(ang_rad)
+                d_lon = (radius / (raio_terra * cos(radians(center_lat)))) * sin(ang_rad)
+                pontos_lat.append(center_lat + d_lat * (180 / 3.141592653589793))
+                pontos_lon.append(center_lon + d_lon * (180 / 3.141592653589793))
+
+            fig.add_trace(go.Scattermapbox(
+                lat=pontos_lat,
+                lon=pontos_lon,
+                mode='lines',
+                fill='toself',
+                fillcolor='rgba(0, 0, 255, 0.2)',
+                line=dict(color='blue', width=2),
+                name='Raio'
+            ))
+
+            fig.add_trace(go.Scattermapbox(
+                lat=[center_lat],
+                lon=[center_lon],
+                mode='markers',
+                marker=dict(size=10, color='red'),
+                name='Centro'
+            ))
+        except Exception as e:
+            print(f"Erro ao adicionar o círculo no mapa: {e}")
+
+    # Gerando estatísticas
+    if filtered_df.empty:
+        stats_text = "Nenhum dado disponível."
+    else:
+        stats_text = (f"Quantidade de Dados: {len(filtered_df):n}\n"
+                      f"Média do Valor: {locale.format_string('%.2f', filtered_df['Valor'].mean(), grouping=True)}\n"
+                      f"Máximo do Valor: {locale.format_string('%.2f', filtered_df['Valor'].max(), grouping=True)}\n"
+                      f"Mínimo do Valor: {locale.format_string('%.2f', filtered_df['Valor'].min(), grouping=True)}")
+
+    # Salvando DataFrame filtrado em arquivo CSV
+    file_path = "dados_filtrados.xlsx"
+    filtered_df.to_excel(file_path)
+
+    return fig, stats_text, filtered_df, file_path
+
+# List of unique property types, bairros, and fonte, with "Todos" as default
+property_types = ["Todos"] + sorted(df['Tipo'].dropna().unique().tolist())
+bairro_list = ["Todos"] + sorted(df['Bairro'].dropna().unique().tolist())
+fonte_list = ["Todos"] + sorted(df['Fonte'].dropna().unique().tolist())
+
+
+def dados_tab():
+    with gr.Tab("Pesquisar Dados"):
+        toggle_filters = gr.Checkbox(label="Exibir Campos de Pesquisa", value=True)
+
+        with gr.Row(visible=True) as filters:
+            tipo_filter = gr.Dropdown(label="Selecione os Tipos de Imóvel", choices=property_types, value=["Todos"], multiselect=True)
+            bairro_filter = gr.Dropdown(label="Selecione os Bairros", choices=bairro_list, value=["Todos"], multiselect=True)
+            fonte_filter = gr.Dropdown(label="Selecione a Fonte", choices=fonte_list, value=["Todos"], multiselect=True)
+
+        with gr.Row(visible=True) as area_filters:
+            min_atotal = gr.Number(label="Área Total Mínima", value=None)
+            max_atotal = gr.Number(label="Área Total Máxima", value=None)
+            min_apriv = gr.Number(label="Área Privativa Mínima", value=None)
+            max_apriv = gr.Number(label="Área Privativa Máxima", value=None)
+            min_ater = gr.Number(label="Área Terreno Mínima", value=None)
+            max_ater = gr.Number(label="Área Terreno Máxima", value=None)
+            
+        with gr.Row(visible=True) as date_filters:
+            min_date = gr.Textbox(label="Data Inicial (AAAA-MM-DD)", value="")
+            max_date = gr.Textbox(label="Data Final (AAAA-MM-DD)", value="")
+
+        with gr.Row(visible=True) as address_filters:
+            address_input = gr.Textbox(label="Endereço (Opcional)")
+            radius_input = gr.Number(label="Raio em metros (Opcional)")
+
+        with gr.Row():
+            search_button = gr.Button("Pesquisar")
+            clear_button = gr.Button("Limpar")
+
+        map_output = gr.Plot()
+        stats_output = gr.Textbox(lines=4, label="Estatísticas")
+        filtered_df_output = gr.DataFrame(label="Dados Filtrados")
+        download_output = gr.File(label="Baixar Dados Filtrados")
+
+        def clear_action():
+            return (["Todos"], ["Todos"], ["Todos"], None, None, None, None, None, None, "", "", "", None, None, "", pd.DataFrame(), None)
+
+        toggle_filters.change(
+            lambda show: (
+                gr.update(visible=show), 
+                gr.update(visible=show), 
+                gr.update(visible=show),
+                gr.update(visible=show)  # Adiciona o filtro de data na visibilidade
+            ), 
+            inputs=[toggle_filters], 
+            outputs=[filters, area_filters, address_filters, date_filters]
+        )
+
+
+        search_button.click(
+            unified_action,
+            inputs=[tipo_filter, bairro_filter, fonte_filter, min_atotal, max_atotal, min_apriv, max_apriv, 
+                    min_ater, max_ater, min_date, max_date, address_input, radius_input],
+            outputs=[map_output, stats_output, filtered_df_output, download_output]
+        )
+
+        clear_button.click(
+            clear_action, 
+            outputs=[tipo_filter, bairro_filter, fonte_filter, min_atotal, max_atotal, min_apriv, max_apriv, 
+                     min_ater, max_ater, min_date, max_date, address_input, radius_input, 
+                     map_output, stats_output, filtered_df_output, download_output]
+        )
+
+    return locals(), filtered_df_output
+
+
+### implementar o KNN
+### Arrumar a questão de que somente clicando no botão "Limpar" é possível acionar os filtros
+### Filtro por data
+### Zoon oelo filtro de raio
+### Gráfico de linhas

modules/evo.py

@@ -0,0 +1,436 @@
+import gradio as gr
+import pandas as pd
+from datetime import datetime
+from docx import Document
+from docx.shared import Pt
+from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
+from num2words import num2words
+import warnings  # Somente se voc� realmente quer suprimir avisos
+
+
+# Suprimir todos os avisos durante a execução do script
+warnings.filterwarnings("ignore")
+
+# Calcular a data mais recente do CUB fora da função
+df_cub = pd.read_excel('TABELAS_evo.xlsx', sheet_name='CUB')
+ultimo_cub = df_cub.columns[-1]
+
+#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 calcular o valor do imóvel
+def calcular_valor_imovel(
+                          area=100, data_refer_str=None, data_const_str=None, tipo_cub="R 1-N (Res. Unifamiliar)",
+                          data_cub_str=None, percentual_cub=1, est_custo_dir="-", BDI=22.5, BDI_tipo ="Arbitrado", fator_local = 1,
+                          just_fator_local = "-", tipologia="APARTAMENTOS",
+                          estado="B - entre novo e regular", VR=0.0, deprec="Arbitrada",
+                          valor_terreno=0,
+                          est_ter="Grau III",
+                          fc=1, fc_just="Arbitrado"):
+
+    # Carregar dados dos arquivos Excel
+    df_cub = pd.read_excel('TABELAS_evo.xlsx', sheet_name='CUB')
+    df_vida = pd.read_excel('TABELAS_evo.xlsx', sheet_name='VUTIL')
+    df_dep = pd.read_excel('TABELAS_evo.xlsx', sheet_name='DEP')
+    df_estado_cons = pd.read_excel('TABELAS_evo.xlsx', sheet_name='CONS')
+
+    # Converter datas de entrada
+    if data_refer_str is None or data_refer_str == "":
+        data_refer = datetime.now()
+    else:
+        data_refer = datetime.strptime(data_refer_str, "%m/%Y")
+    data_const = datetime.strptime(data_const_str, "%m/%Y")
+    if data_cub_str is None or data_cub_str == "":
+        data_cub = datetime.now()
+    else:
+        data_cub = datetime.strptime(data_cub_str, "%m/%Y")
+
+    # Filtrar por tipo_cub
+    df_tipo_cub = df_cub[df_cub['CÓDIGO'] == tipo_cub]
+
+    # Obter o valor do CUB na coluna correspondente à data
+    valor_cub_column = data_cub.strftime("%m/%Y")
+    valor_cub = df_tipo_cub.at[df_tipo_cub.index[0], valor_cub_column]
+
+    # Idade
+    idade = data_refer.toordinal() - data_const.toordinal()
+    if idade > 1:
+        idade = idade // 365
+    else:
+        idade = 1
+
+    # Filtrar por %de Vida
+    vdu = df_vida.loc[(df_vida['FINAL'] == tipologia)]
+
+    # % de vida útil
+    perc_vdu = (idade / vdu['VIDAUTIL']) * 100
+    perc_vdu = int(round(perc_vdu, 0))
+
+    if perc_vdu >= 100:
+        percentual_vdu = 100
+    elif perc_vdu < 2:
+        percentual_vdu = 2
+    else:
+        percentual_vdu = perc_vdu
+
+    # Filtrar conforme o % de vida útil
+    df_conserv = df_dep.loc[df_dep['%deVida'] == percentual_vdu]
+
+     # Converter o valor residual de string para número (float)
+    try:
+        VR = float(VR.strip()) if isinstance(VR, str) and VR.strip() != "" else 0.0
+    except ValueError:
+        VR = 0.0
+    # Obter da depreciação
+    coef_HH = float(df_conserv[estado]/100)
+    coef_HH = round(coef_HH, 3)
+
+    # Valor do "Kd"
+    kd = VR + (1 - coef_HH) * (1 - VR)
+    kd = round(kd, 3)
+        
+    # Converter o valor do terreno de string para número (float)
+    #try:
+        #valor_terreno = float(valor_terreno.strip()) if isinstance(valor_terreno, str) and valor_terreno.strip() != "" else 0.0
+    #except ValueError:
+        #valor_terreno = 0.0     
+        
+    # Cálculos
+    Valor_sem_deprec = round(area * valor_cub * percentual_cub * (1 + BDI / 100) * fator_local, 2)
+    Valor_com_deprec = Valor_sem_deprec * kd
+    Valor_com_deprec = round(Valor_com_deprec, 2)
+    valor_imovel = round((valor_terreno + Valor_com_deprec) * float(fc), 0)
+
+
+    # Atributo da coluna "cons" pelo qual você deseja fazer a correspondência
+    atributo_desejado = estado
+    # Encontrar o valor da coluna "obs" com base no atributo da coluna "cons"
+    valor_obs = df_estado_cons.loc[df_estado_cons['cons'] == atributo_desejado, 'obs'].iloc[0]
+
+    # -------------------------------------- #
+
+    # GRAU DE FUNDAMENTAÇÃO CUSTOS
+
+    # item_1 - Graus de Fundamentação (Estimativa do custo direto)
+    if est_custo_dir == "Elaboração de orçamento, no mínimo sintético":
+        cust_1 = 3
+    elif est_custo_dir == "Utilização CUB para projeto semelhante ao projeto padrão":
+        cust_1 = 2
+    else:
+        cust_1 = 1
+
+    # item_2 - Graus de Fundamentação (BDI)
+    if BDI_tipo == "Calculado":
+        cust_2 = 3
+    elif BDI_tipo == "Justificado":
+        cust_2 = 2
+    else:
+        cust_2 = 1
+
+    # item_3 - Graus de Fundamentação (Depreciação física)
+    if deprec == "Por levantamento do custo de recuperação do bem, para deixá-lo no estado de novo ou caso de bens novos ou projetos hipotéticos":
+        cust_3 = 3
+    elif deprec == "Por métodos técnicos consagrados, considerando-se idade, vida útil e estado de conservação":
+        cust_3 = 2
+    else:
+        cust_3 = 1
+
+    # enquadramento
+    soma_custo = cust_1 + cust_2 + cust_3
+    if soma_custo >= 7 and cust_1 == 3 and cust_2 >= 2 and cust_3 >= 2:
+        est_cr = "Grau III"
+    elif soma_custo >= 5 and cust_1 >= 2 and cust_2 >= 2:
+        est_cr = "Grau II"
+    elif soma_custo >= 3 and cust_1 >= 1 and cust_2 >= 1 and cust_3 >= 1:
+        est_cr = "Grau I"
+    else:
+        est_cr = "Fora dos critérios"
+
+    # -------------------------------------- #
+
+     # GRAU DE FUNDAMENTAÇÃO EVOLUTIVO
+
+    # item_1 - Graus de Fundamentação (Estimativa do valor do terreno)
+    if est_ter == "Grau III":
+        evo_1 = 3
+    elif est_ter == "Grau II":
+        evo_1 = 2
+    else:
+        evo_1 = 1
+
+    # item_2 - Graus de Fundamentação (Estimativa dos custos de reedição)
+    if est_cr == "Grau III":
+        evo_2 = 3
+    elif est_cr == "Grau II":
+        evo_2 = 2
+    else:
+        evo_2 = 1
+
+    # item_3 - Graus de Fundamentação (Forma de cálculo do FC)
+    if fc_just == "Inferido em mercado semelhante":
+        evo_3 = 3
+    elif fc_just == "Justificado:":
+        evo_3 = 2
+    else:
+        evo_3 = 1
+
+    # enquadramento
+    soma_evo = evo_1 + evo_2 + evo_3
+    if soma_evo >= 8 and evo_1 == 3 and evo_2 == 3 and evo_3 >= 2: # confirmar!!!!!
+        fundamentacao_evolutivo = "Grau III"
+    elif soma_evo >= 5 and evo_1 >= 2 and evo_2 >= 2:
+        fundamentacao_evolutivo = "Grau II"
+    elif soma_evo >= 3 and evo_1 >= 1 and evo_2 >= 1 and evo_3 >= 1:
+        fundamentacao_evolutivo = "Grau I"
+    else:
+        fundamentacao_evolutivo = "Fora dos critérios"
+
+    # -------------------------------------- #
+
+    # criação de strings para os relatórios da interface e do word
+
+    #####
+    tipo_cub = tipo_cub.replace('.', '@').replace(',', '.').replace('@', ',')
+    est_custo_dir = est_custo_dir.replace('.', '@').replace(',', '.').replace('@', ',')
+    just_fator_local = just_fator_local.replace('.', '@').replace(',', '.').replace('@', ',')
+    valor_inicial = f"""
+    Área construída : {area:,.2f} m²
+    Data de referência: {data_refer.strftime("%m/%Y")}
+    Data da construção: {data_const_str}
+    Data do CUB: {data_cub.strftime("%m/%Y")}
+    Tipo de CUB: {tipo_cub}
+    Fator para adequação do CUB: {percentual_cub}
+    Estimativa do custo direto: {est_custo_dir}
+    BDI (%): {BDI}
+    Método de elaboração do BDI: {BDI_tipo}
+    Valor CUB: R$ {valor_cub:,.2f}
+    Fator local: {fator_local}
+    Fator local(justificativa): {just_fator_local}
+    Valor antes da depreciação = área construída * CUB * fator adequação CUB * (1 + BDI / 100) * fator local
+    Valor sem depreciação: R$ {Valor_sem_deprec:,.2f}
+    """
+
+        # Substituindo ponto por vírgula
+    valor_inicial = valor_inicial.replace('.', '@')
+    valor_inicial = valor_inicial.replace(',', '.')
+    valor_inicial = valor_inicial.replace('@', ',')
+
+    #####
+    valor_obs = valor_obs.replace('.', '@').replace(',', '.').replace('@', ',')
+    deprec = deprec.replace('.', '@').replace(',', '.').replace('@', ',')
+    deprec = f"""
+    Tipologia: {tipologia}
+    Vida útil da tipologia: {int(vdu['VIDAUTIL'])}
+    Estado de conservação: {estado}
+    Estado de conservação - descrição: {valor_obs}
+    % de Vida Útil: {percentual_vdu}
+    Coeficiente de Depreciação: {coef_HH}
+    Valor residual (0, 0.1 ou 0.2): {VR}
+    Forma de cálculo da depreciação física: {deprec}
+    Kd: {kd}
+    onde: Kd = (Valor residual + (1 - percentual de depreciação)*(1 - Valor residual))
+    Valor depois da depreciação = (Valor antes da depreciação) x Kd (com coeficiente de valor residual)
+    Valor final construção: R$ {Valor_com_deprec:,.2f}
+    Especificação da Avaliação (benfeitorias) - Método da Quantificação do Custo: {est_cr}
+    """
+    # Substituindo ponto por vírgula
+    deprec = deprec.replace('.', '@')
+    deprec = deprec.replace(',', '.')
+    deprec = deprec.replace('@', ',')
+
+    #####
+    valor_ter = f"""
+    Valor do Terreno: R$ {valor_terreno:,.2f}
+    Especificação da Avaliação (terreno ou gleba) -  Método Comparativo ou Involutivo: {est_ter}
+    """
+    # Substituindo ponto por vírgula
+    valor_ter = valor_ter.replace('.', '@')
+    valor_ter = valor_ter.replace(',', '.')
+    valor_ter = valor_ter.replace('@', ',')
+
+    #####
+    valor_ext = numero_por_extenso(valor_imovel)
+
+    v_relat = f"{valor_imovel:,.2f}"
+    v_relat = v_relat.replace('.', '@')
+    v_relat = v_relat.replace(',', '.')
+    v_relat = v_relat.replace('@', ',')
+
+    valor_final = f"""
+    FC (Fator de Comercialização): {fc}
+    Observação sobre o FC: {fc_just}
+    ---------------------
+    VI = (VT + CA) * FC
+    Onde:
+    VI: Valor estimado do imóvel;
+    VT: Valor estimado do terreno;
+    CA: Custo de reedição das benfeitorias;
+    FC: Fator de comercialização.
+    ---------------------
+    Valor do Imóvel (c/ arredondamento): R$ {v_relat}
+    ({valor_ext})
+    ---------------------
+    Especificação da Avaliação - Método Evolutivo: {fundamentacao_evolutivo}
+    """
+
+    # -------------------------------------- #
+
+    # 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 as seções do relatório
+    sections = [
+        (valor_inicial, "Valor Inicial da Construção"),
+        (deprec, "Cálculo da Depreciação"),
+        (valor_ter, "Valor Estimado para o Terreno"),
+        (valor_final, "Valor Final do Imóvel"),
+    ]
+
+    for content, title in sections:
+        doc.add_heading(title, level=2)
+        p = doc.add_paragraph()
+        run = p.add_run(content)
+        run.font.size = Pt(12)
+
+        if title == "":  # Se for a seção de assinatura
+            p.alignment = WD_PARAGRAPH_ALIGNMENT.RIGHT  # Define o alinhamento para à direita
+        else:
+            p.alignment = WD_PARAGRAPH_ALIGNMENT.LEFT  # Define o alinhamento para à esquerda
+
+    # Salvar o documento em um arquivo .doc
+    doc.save('relatorio_avaliacao.doc')
+
+    # -------------------------------------- #
+
+    # Outputs
+    return valor_inicial, deprec, valor_ter, valor_final, 'relatorio_avaliacao.doc'
+
+    # -------------------------------------- #
+
+# Interface Gradio
+
+def evo_tab():
+    with gr.Tab("Evolutivo"):
+        with gr.Row():
+            with gr.Column():
+                # Valor Inicial da Construção
+                with gr.Row():
+                    area = gr.Number(label="Área (m²)", value=100, info="Área construída", scale=0.5)  # Remova a vírgula aqui
+                    data_r = gr.Textbox(label="Data referência (mm/aaaa)", value=ultimo_cub, info="Data do fato gerador da demanda", scale=1)  # Remova a vírgula aqui
+                    data_c = gr.Textbox(label="Data construção (mm/aaaa)", value=ultimo_cub, info="Data de construção do imóvel", scale=1)
+                with gr.Group():
+                    with gr.Row():
+                        cub = gr.Dropdown(label="Tipo de CUB", 
+                                      choices=["R 1-B (Res. Unifamiliar)", "R 1-N (Res. Unifamiliar)", "R 1-A (Res. Unifamiliar)",
+                                               "PP 4-B (Prédio Popular)", "PP 4-N (Prédio Popular)", "R 8-B  (Res. Multifamiliar)", 
+                                               "R 8-N (Res. Multifamiliar)", "R 8-A (Res. Multifamiliar)", "R 16-N (Res. Multifamiliar)", 
+                                               "R 16-A (Res. Multifamiliar)", "PIS (Projeto Inter. Social)", "RP1Q (Residência Popular)", 
+                                               "CAL 8-N (Com. Andar Livres)", "CAL 8-A (Com. Andar Livres)", 
+                                               "CSL 8-N (Com.Salas e Lojas)", "CSL 8-A (Com.Salas e Lojas)", 
+                                               "CSL 16-N (Com.Salas e Lojas)", "CSL 16-A (Com.Salas e Lojas)", "GI (Galpão Industrial)"], 
+                                      value="R 1-N (Res. Unifamiliar)", scale=1)
+                        data_cub = gr.Textbox(label="Data do CUB (mm/aaaa)", value=ultimo_cub, scale=1)
+                        fator_cub = gr.Slider(0.5, 2.0, value=1, label="Fator para adequação do CUB", 
+                                          info="Para contemplar insumos/serviços que não constam na composição", step=0.1)
+                    forma_cub = gr.Dropdown(["Utilização CUB para projeto semelhante ao projeto padrão",
+                                          "Utilização CUB para projeto diferente do projeto padrão, com os devidos ajustes"], 
+                                         label="Estimativa do custo direto", value="Utilização CUB para projeto semelhante ao projeto padrão")
+                with gr.Row():
+                    bdi = gr.Number(label="BDI (%)", value=22.5, scale=0.5)
+                    tipo_bdi = gr.Dropdown(["Calculado", "Justificado", "Arbitrado"], label="Tipo de BDI", value="Justificado", scale=1)
+                with gr.Row():
+                    fator_local = gr.Slider(0.5, 1.5, value=1, label="Fator local", info="Atribua um coeficiente de valorização se necessário", step=0.1)
+                    just_local = gr.Textbox(label="Justificativa para o Fator Local", value="-", info="Justifique tecnicamente o fator")
+    
+                # Cálculo da Depreciação
+                with gr.Group():
+                    with gr.Row():
+                        tipo = gr.Dropdown(label="Tipologia", choices=["APARTAMENTOS", "BANCOS", "CASAS DE ALVENARIA",
+                                                                   "CASAS DE MADEIRA", "HOTÉIS", "LOJAS", "TEATROS", 
+                                                                   "ARMAZÉNS", "FÁBRICAS", "CONST. RURAIS", "GARAGENS", 
+                                                                   "EDIFÍCIOS DE ESCRITÓRIOS", "GALPÕES (DEPÓSITOS)", "SILOS"], value="CASAS DE ALVENARIA", scale=1)
+                        rst_con = gr.Dropdown(label="Estado de conservação", choices=["A - novo", "B - entre novo e regular", 
+                                                                                  "C - regular", "D - entre regular e reparos simples", 
+                                                                                  "E - reparos simples", "F - entre reparos simples e importantes", 
+                                                                                  "G - reparos importantes", "H - entre reparos importantes e sem valor"], value="A - novo", scale=1)
+                        vr = gr.Dropdown(label="Valor residual", choices=["0", "0.1", "0.2"], value="0", scale=0.5)
+                    deprec = gr.Dropdown(["Por levantamento do custo de recuperação do bem, para deixá-lo no estado de novo ou caso de bens novos ou projetos hipotéticos", 
+                                       "Por métodos técnicos consagrados, considerando-se idade, vida útil e estado de conservação", 
+                                       "Arbitrado"], 
+                                      label="Depreciação Física", 
+                                      info="Forma pela qual a depreciação física foi calculada", 
+                                      value="Por métodos técnicos consagrados, considerando-se idade, vida útil e estado de conservação")
+                #-------------------------------------------------------#
+                button_1 = gr.Button("Calcular Construção")
+                #-------------------------------------------------------#
+                    
+                # Valor do Terreno
+                with gr.Row():
+                    vt_inp = gr.Number(label="Valor do Terreno", info="Campo não precisade de preenchimento p/ o cálculo do Custo de Reprodução", value=0)
+                    grau_t = gr.Radio(["Grau III", "Grau II", "Grau I"], info="Escolha o Grau de Fundamentação alcançado pela avaliação do terreno", label="", value="Grau III")
+    
+                # Valor final do imóvel
+                fc = gr.Slider(0.1, 2.0, value=1.0, label="FC (Fator de Comercialização)", info="O Fator de Comercialização, também chamado de Terceiro Componente ou Vantagem da Coisa Feita, é definido no item 3.20 da NBR 14653-1:2001: “Fator de comercialização: Razão entre o valor de mercado de um bem e o seu custo de reedição ou de substituição, que pode ser maior ou menor que 1", step=0.1)
+                forma_fc = gr.Radio(["Inferido em mercado semelhante", "Justificado", "Arbitrado"], label="", info="Estipule como foi elaborado o FC", value="Justificado")
+    
+                #-------------------------------------------------------#
+                button_2 = gr.Button("Calcular Terreno + Construção")
+                #-------------------------------------------------------#
+    
+            with gr.Column():
+                vi = gr.Textbox(label="Valor Inicial da Contrução")
+                cd = gr.Textbox(label="Cálculo da Depreciação")
+                vt_out = gr.Textbox(label="Valor estimado para o terreno")
+                vf = gr.Textbox(label="Valor final do imóvel")
+                la = gr.File(label="Laudo de Avaliação")
+    
+        inputs = [
+            area,              # Área construída (m²)
+            data_r,            # Data de referência (mm/aaaa)
+            data_c,            # Data da construção (mm/aaaa)
+            cub,               # Tipo de CUB
+            data_cub,          # Data do CUB (mm/aaaa)
+            fator_cub,         # Fator para adequação do CUB
+            forma_cub,         # Estimativa do custo direto
+            bdi,               # BDI (%)
+            tipo_bdi,          # Tipo de BDI
+            fator_local,       # Fator local
+            just_local,        # Justificativa para o Fator Local
+            tipo,              # Tipologia
+            rst_con,           # Estado de conservação
+            vr,                # Valor residual (0, 0.1 ou 0.2)
+            deprec,            # Depreciação Física
+            vt_inp,                # Valor do Terreno
+            grau_t,            # Grau de Fundamentação alcançado pela avaliação do terreno
+            fc,                # FC (Fator de Comercialização)
+            forma_fc           # Forma como foi elaborado o FC
+        ]
+    
+        outputs = [
+            vi,  # Valor Inicial da Construção
+            cd,  # Cálculo da Depreciação
+            vt_out,  # Valor estimado para o terreno
+            vf,  # Valor final do imóvel
+            la   # Laudo de Avaliação (arquivo)
+        ]
+    
+        button_1.click(calcular_valor_imovel, inputs=inputs, outputs=outputs)
+        button_2.click(calcular_valor_imovel, inputs=inputs, outputs=outputs)
+
+    return locals()
+
+# Substituir a tabela pelo c�lculo da deprecia��o

modules/ml.py

@@ -0,0 +1,154 @@
+import gradio as gr
+import matplotlib.pyplot as plt
+from sklearn.linear_model import LinearRegression, Ridge, BayesianRidge
+from sklearn.tree import DecisionTreeRegressor
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.svm import SVR
+from sklearn.neural_network import MLPRegressor
+from sklearn.neighbors import KNeighborsRegressor
+from sklearn.metrics import r2_score
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import MinMaxScaler
+from .shared_state import state  # Estado compartilhado
+import io
+from PIL import Image
+
+# Global model state to save the trained model
+global_model = {"model": None, "scaler": None, "columns": None}
+
+# Train the model
+def apply_ml(df, var_dep, ml_model_name, test_size):
+    if df is None:
+        df = state.get('new_df')  # Busca o DataFrame no estado compartilhado
+    if df is None:
+        raise ValueError("Nenhum DataFrame disponível para aplicação.")
+    df = df.dropna()
+    y = df[var_dep]
+    X = df.drop(columns=[var_dep])
+
+    # Remover a coluna "Índice" se ela existir
+    if "Índice" in X.columns:
+        X = X.drop(columns=["Índice"])
+
+    # Normalizar os dados com MinMaxScaler
+    scaler = MinMaxScaler()
+    X = scaler.fit_transform(X)
+
+    # Divisão em treino e teste com test_size ajustável
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=1)
+
+    # Escolha do modelo
+    if ml_model_name == "Linear Regression":
+        model = LinearRegression()
+    elif ml_model_name == "Ridge Regression":
+        model = Ridge(alpha=0.5)
+    elif ml_model_name == "Bayesian Ridge":
+        model = BayesianRidge()
+    elif ml_model_name == "Decision Tree":
+        model = DecisionTreeRegressor()
+    elif ml_model_name == "Random Forest":
+        model = RandomForestRegressor()
+    elif ml_model_name == "Support Vector Regression (SVR)":
+        model = SVR()
+    elif ml_model_name == "Neural Network (MLP)":
+        model = MLPRegressor(max_iter=5000, tol=0.1, random_state=1)
+    elif ml_model_name == "K-Neighbors Regressor":
+        model = KNeighborsRegressor(n_neighbors=5)
+    else:
+        raise ValueError("Modelo de ML inválido.")
+
+    # Treinamento e avaliação
+    model.fit(X_train, y_train)
+    train_r2 = r2_score(y_train, model.predict(X_train))
+    test_r2 = r2_score(y_test, model.predict(X_test))
+    
+    print(f"Train R²: {train_r2}, Test R²: {test_r2}")
+
+    # Save the trained model, scaler, and column names for prediction
+    global_model["model"] = model
+    global_model["scaler"] = scaler
+    global_model["columns"] = df.drop(columns=[var_dep]).columns.tolist()
+
+    # Gerar o gráfico
+    plt.figure(figsize=(6, 4))
+    plt.bar(["Treino", "Teste"], [train_r2, test_r2], color=["blue", "orange"])
+    plt.title(f"Desempenho do Modelo: {ml_model_name} - Test Size: {test_size}")
+    plt.ylabel("R²")
+    plt.ylim(0, 1)  # Limite entre 0 e 1 para facilitar a visualização
+    plt.tight_layout()
+
+    # Salvar o gráfico em um buffer
+    buffer = io.BytesIO()
+    plt.savefig(buffer, format='png')
+    buffer.seek(0)
+    plt.close()
+
+    # Convert the buffer to a PIL Image
+    image = Image.open(buffer)
+
+    return image
+
+# Função para atualizar as opções de variáveis dependentes
+def update_var_dep_dropdown(df):
+    if df is None:
+        df = state.get('new_df')  # Busca o DataFrame no estado compartilhado
+    if df is None:
+        return gr.update(choices=[])
+    return gr.update(choices=df.columns.tolist())
+
+def predict_new_values(*inputs):
+    if global_model["model"] is None:
+        return "O modelo ainda não foi treinado. Execute o modelo primeiro."
+    
+    # Reshape input to match model expectation
+    new_data = [float(value) for value in inputs]
+    new_data_scaled = global_model["scaler"].transform([new_data])
+    
+    # Predict
+    prediction = global_model["model"].predict(new_data_scaled)[0]
+    return f"Previsão: {prediction:.4f}"
+
+# Função para criar a aba Machine Learning
+def ml_tab(new_df_output):
+    with gr.Tab("Machine Learning"):
+        var_dep_dropdown = gr.Dropdown(choices=[], label="Variável Dependente")
+        ml_model_dropdown = gr.Dropdown(
+            choices=[
+                "Linear Regression", "Ridge Regression", "Bayesian Ridge",
+                "Decision Tree", "Random Forest", "Support Vector Regression (SVR)",
+                "Neural Network (MLP)", "K-Neighbors Regressor"
+            ],
+            label="Modelo de Machine Learning"
+        )
+        test_size_slider = gr.Slider(minimum=0.1, maximum=0.5, step=0.05, value=0.3, label="Tamanho do Teste")
+        submit_button = gr.Button("Executar Modelo")
+        r2_graph_output = gr.Image(label="Gráfico de Desempenho")
+
+        # Callback to execute the function
+        submit_button.click(
+            apply_ml,
+            inputs=[new_df_output, var_dep_dropdown, ml_model_dropdown, test_size_slider],
+            outputs=[r2_graph_output]
+        )
+
+        # Update dropdown options
+        new_df_output.change(update_var_dep_dropdown, inputs=[new_df_output], outputs=[var_dep_dropdown])
+
+        # Add prediction section
+        gr.Markdown("### Previsão de Novos Valores")
+
+        inputs = []
+        if global_model["columns"]:  # Check if columns exist
+            for col in global_model["columns"]:
+                inputs.append(gr.Textbox(label=f"Valor para '{col}'"))
+        else:
+            gr.Markdown("O modelo ainda não foi treinado. Execute o modelo primeiro para realizar previsões.")
+
+        predict_button = gr.Button("Prever Valores")
+        prediction_output = gr.Textbox(label="Resultado da Previsão")
+
+        # Predict only if inputs were generated
+        if inputs:
+            predict_button.click(predict_new_values, inputs=inputs, outputs=prediction_output)
+
+    return locals()

modules/otimiza.py

@@ -0,0 +1,120 @@
+import gradio as gr
+import numpy as np
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import r2_score
+from itertools import product
+from .shared_state import state  # Importa o estado compartilhado
+
+# OTIMIZA
+def apply_transformation(data, transformation):
+    if transformation == "exp" and (data > 50).any():
+        return data
+    if transformation == "direct":
+        return data
+    elif transformation == "inverse":
+        return 1 / (data + 0.001)
+    elif transformation == "log":
+        return np.log(data + 0.001)
+    elif transformation == "exp":
+        return np.exp(data)
+    elif transformation == "square":
+        return data ** 2
+
+def find_best_transformations(df, var_dep, ignore_dichotomous):
+    if df is None:
+        df = state.get('new_df')  # Busca o DataFrame no estado compartilhado
+    if df is None:
+        raise ValueError("Nenhum DataFrame disponível para otimização.")
+    df = df.dropna()
+    y = df[var_dep]
+    X = df.drop(columns=[var_dep])
+    
+    # Remover a coluna "Índice" se ela existir
+    if "Índice" in X.columns:
+        X = X.drop(columns=["Índice"])
+    
+    dichotomous_columns = [col for col in X.columns if set(X[col].unique()).issubset({0, 1})]
+    if ignore_dichotomous:
+        X = X.drop(columns=dichotomous_columns)
+    transformations = ["direct", "inverse", "log", "exp", "square"]
+    scores = []
+    for y_transformation in transformations:
+        y_transformed = apply_transformation(y, y_transformation)
+        for transformation_combo in product(transformations, repeat=X.shape[1]):
+            X_transformed = X.copy()
+            for i, transformation in enumerate(transformation_combo):
+                column = X.iloc[:, i]
+                X_transformed.iloc[:, i] = apply_transformation(column, transformation)
+            model = LinearRegression()
+            try:
+                model.fit(X_transformed, y_transformed)
+                predictions = model.predict(X_transformed)
+                score = r2_score(y_transformed, predictions)
+                scores.append((transformation_combo, y_transformation, score, model))
+            except ValueError as e:
+                if "Input X contains NaN" in str(e):
+                    raise ValueError("O conjunto de dados apresenta valores nulos.") from e
+                else:
+                    raise e  # Propague outras exceções
+                    
+    scores = sorted(scores, key=lambda x: x[2], reverse=True)[:5]
+    top_equations = []
+    top_transformation_info = []
+    top_scores = []
+    for combo, y_trans, score, model in scores:
+        equation = f"y = {model.intercept_:.4f} " + " ".join(
+            [f"{'+' if coef >= 0 else '-'} ({abs(coef):.4f}) * {trans}" for coef, trans in zip(model.coef_, X.columns)]
+        )
+        transformation_info = {"y": y_trans}
+        transformation_info.update(dict(zip(X.columns, combo)))
+        top_equations.append([equation])
+        top_transformation_info.append(transformation_info)
+        top_scores.append([float(score)])
+    return top_equations, top_transformation_info, top_scores
+
+def update_var_dep_dropdown(df):
+    if df is None:
+        df = state.get('new_df')  # Busca o DataFrame no estado compartilhado
+    if df is None:
+        return gr.update(choices=[])
+    return gr.update(choices=df.columns.tolist())
+
+def otimiza_tab(new_df_output):
+    with gr.Tab("Otimizar Modelo"):
+        var_dep_dropdown = gr.Dropdown(
+            choices=[],  # Inicialmente vazio
+            label="Variável Dependente"
+        )
+        ignore_dichotomous_checkbox = gr.Checkbox(
+            label="Ignorar Variáveis Dicotômicas", value=False
+        )
+        submit_button = gr.Button("Otimizar variáveis")
+
+        with gr.Row():
+            equations_output = gr.Dataframe(headers=["Equação"], label="Equações (Top 5)")
+        with gr.Row():
+            transformations_output = gr.JSON(label="Transformações Aplicadas (Top 5)")
+        with gr.Row():
+            scores_output = gr.Dataframe(headers=["R2_Score"], label="R2_Scores (Top 5)")
+
+        # Callback para executar a função
+        submit_button.click(
+            find_best_transformations,
+            inputs=[new_df_output, var_dep_dropdown, ignore_dichotomous_checkbox],
+            outputs=[equations_output, transformations_output, scores_output]
+        )
+
+        # Atualiza o dropdown de variáveis dependentes quando o DataFrame é atualizado
+        new_df_output.change(
+            update_var_dep_dropdown,
+            inputs=[new_df_output],
+            outputs=[var_dep_dropdown]
+        )
+
+        return locals()
+
+
+### Fixar variáveis para efeutar a otimização
+### Trocar o y pelo nome da variável dependente
+### Exibir resultados estatísticos simples (como o SISREG)
+### Exportar para o ML e RL

modules/planilha.py

@@ -0,0 +1,247 @@
+import gradio as gr
+import pandas as pd
+from modules.utils import create_new_dataframe_with_index_and_value_unit  # Importe a função necessária
+from .shared_state import state  # Importa o estado compartilhado
+
+# Variável global para armazenar o DataFrame original
+original_df = None
+
+# PLANILHA
+def list_sheets(file):
+    if file is None:
+        return "Nenhum arquivo carregado.", []
+    excel_file = pd.ExcelFile(file.name)
+    sheet_names = excel_file.sheet_names
+    return "\n".join(sheet_names), sheet_names
+
+def load_sheet(file, sheet_name):
+    if file is None or not sheet_name:
+        return pd.DataFrame({"Erro": ["Carregue um arquivo e selecione uma aba."]}), "", []
+    df = pd.read_excel(file.name, sheet_name=sheet_name)
+    rows, cols = df.shape
+    column_list = df.columns.tolist()
+    return df, f"{rows} linhas e {cols} colunas", column_list
+
+def update_column_selector(file, sheet_name):
+    if file is None or not sheet_name:
+        return gr.update(choices=[], value=[])
+    df = pd.read_excel(file.name, sheet_name=sheet_name)
+    columns = df.columns.tolist()
+    return gr.update(choices=columns, value=columns)
+
+def select_all_columns(select_all, choices):
+    if select_all:
+        return gr.update(value=choices)
+    else:
+        return gr.update(value=[])
+
+def toggle_sheet_visibility(view_sheet):
+    return gr.update(visible=view_sheet)
+
+def toggle_operations_inputs(enable_operations):
+    return gr.update(visible=enable_operations)
+
+def add_new_variable(file, sheet_name, first_var, operation, second_var, new_var_name):
+    if file is None or not sheet_name or not first_var or not second_var or not new_var_name:
+        return pd.DataFrame({"Erro": ["Preencha todos os campos necessários."]})
+    df = pd.read_excel(file.name, sheet_name=sheet_name)
+    if first_var not in df.columns or second_var not in df.columns:
+        return pd.DataFrame({"Erro": ["Variáveis selecionadas não existem no DataFrame."]})
+
+    try:
+        if operation == "Adição":
+            df[new_var_name] = df[first_var] + df[second_var]
+        elif operation == "Subtração":
+            df[new_var_name] = df[first_var] - df[second_var]
+        elif operation == "Multiplicação":
+            df[new_var_name] = df[first_var] * df[second_var]
+        elif operation == "Divisão":
+            df[new_var_name] = df[first_var] / df[second_var]
+    except ZeroDivisionError:
+        return pd.DataFrame({"Erro": ["Divisão por zero detectada."]})
+    except Exception as e:
+        return pd.DataFrame({"Erro": [f"Erro ao realizar a operação: {str(e)}"]})
+
+    return df
+
+def update_variable_choices(file, sheet_name):
+    if file is None or not sheet_name:
+        return gr.update(choices=[]), gr.update(choices=[])
+    df = pd.read_excel(file.name, sheet_name=sheet_name)
+    return gr.update(choices=df.columns.tolist()), gr.update(choices=df.columns.tolist())
+
+def update_dropdown(file):
+    sheet_names_text, sheet_names = list_sheets(file)
+    return sheet_names_text, gr.update(choices=sheet_names)
+
+def update_columns(file, sheet_name):
+    df, info, columns = load_sheet(file, sheet_name)
+    return (
+        df,
+        info,
+        columns,
+        gr.update(choices=columns, value=[], interactive=True)
+    )
+
+# Função para restaurar o DataFrame ao estado inicial
+def restore_dataframe():
+    global original_df
+    if original_df is not None:
+        return original_df, None  # Retorna o DataFrame e um valor nulo para limpar o download
+    return pd.DataFrame(), None  # Retorna DataFrame vazio e nenhum arquivo
+
+def finalize_dataframe(file, sheet_name, selected_columns, first_var, operation, second_var, new_var_name, add_index):
+    if file is None or not sheet_name:
+        return pd.DataFrame({"Erro": ["Carregue um arquivo e selecione uma aba."]})
+    df = pd.read_excel(file.name, sheet_name=sheet_name)
+
+    # Adiciona a nova variável, se necessário
+    if new_var_name and first_var and second_var:
+        try:
+            if operation == "Adição":
+                df[new_var_name] = df[first_var] + df[second_var]
+            elif operation == "Subtração":
+                df[new_var_name] = df[first_var] - df[second_var]
+            elif operation == "Multiplicação":
+                df[new_var_name] = df[first_var] * df[second_var]
+            elif operation == "Divisão":
+                df[new_var_name] = df[first_var] / df[second_var]
+        except ZeroDivisionError:
+            return pd.DataFrame({"Erro": ["Divisão por zero detectada."]})
+        except Exception as e:
+            return pd.DataFrame({"Erro": [f"Erro ao realizar a operação: {str(e)}"]})
+
+    # Adiciona a nova variável às colunas selecionadas, se existir
+    if new_var_name and new_var_name in df.columns:
+        selected_columns.append(new_var_name)
+
+    if selected_columns:
+        df = df[selected_columns]
+
+    # Adiciona índice na primeira coluna, se necessário
+    if add_index:
+        df.insert(0, 'Índice', range(1, len(df) + 1))
+
+    # Salvando DataFrame filtrado em arquivo CSV
+    file_path = "Planilha_final.xlsx"
+    df.to_excel(file_path)
+
+    return df, file_path
+
+def planilha_tab(filtered_df_output):
+    # Criação da aba
+    with gr.Tab("Carregar Planilha"):
+        # Checkbox para escolher entre usar o arquivo da aba anterior ou carregar um novo arquivo
+        use_filtered_df = gr.Checkbox(label="Usar arquivo da aba anterior", value=True)
+
+        # Upload do arquivo Excel
+        with gr.Row():
+            excel_file = gr.File(label="Carregue sua planilha Excel", file_types=[".xls", ".xlsx"], elem_classes=["small-file-upload"], visible=False)
+
+        with gr.Row():
+            list_button = gr.Button("Listar Abas")
+
+        # Exibição das abas disponíveis e seleção de aba
+        with gr.Row():
+            sheet_output = gr.Textbox(label="Abas disponíveis", interactive=False)
+            sheet_dropdown = gr.Dropdown(label="Selecione uma aba")
+
+        # Botão para carregar aba e exibir colunas
+        with gr.Row():
+            load_button = gr.Button("Carregar Aba")
+
+        # Informações e exibição de colunas da aba carregada
+        with gr.Row():
+            sheet_info = gr.Text(label="Informação de Linhas e Colunas")
+            sheet_columns = gr.JSON(label="Lista de Colunas", visible=False)
+            view_sheet_checkbox = gr.Checkbox(label="Visualizar a planilha", value=False)
+
+        # Exibição do conteúdo da aba selecionada
+        with gr.Row():
+            sheet_content = gr.Dataframe(
+                label="Conteúdo da Aba Selecionada",
+                visible=False
+            )
+
+        # CheckboxGroup para seleção de colunas
+        with gr.Row():
+            column_selector = gr.CheckboxGroup(
+                label="Selecione colunas para análise",
+                choices=[],  # Inicia vazio
+                interactive=True
+            )
+
+        # Checkbox para adicionar índice na primeira coluna
+        with gr.Row():
+            add_index_checkbox = gr.Checkbox(label="Adicionar índice na primeira coluna", value=False)
+
+        # Checkbox para habilitar operações com variáveis
+        operations_checkbox = gr.Checkbox(label="Operações com variáveis", value=False)
+
+        # Elementos relacionados às operações, inicialmente invisíveis
+        with gr.Row(visible=False) as operations_inputs:
+            variable_name_textbox = gr.Textbox(
+                label="Nome da nova variável",
+                placeholder="Digite o nome da nova variável",
+                interactive=True
+            )
+            first_variable_dropdown = gr.Dropdown(
+                label="Selecione a primeira variável",
+                choices=[],
+                interactive=True
+            )
+            operation_dropdown = gr.Dropdown(
+                label="Selecione a operação",
+                choices=["Adição", "Subtração", "Multiplicação", "Divisão"],
+                interactive=True
+            )
+            second_variable_dropdown = gr.Dropdown(
+                label="Selecione a segunda variável",
+                choices=[],
+                interactive=True
+            )
+
+        # Associações de eventos
+        use_filtered_df.change(lambda x: gr.update(visible=not x), inputs=[use_filtered_df], outputs=[excel_file])
+        list_button.click(update_dropdown, inputs=[excel_file], outputs=[sheet_output, sheet_dropdown])
+        load_button.click(update_columns, inputs=[excel_file, sheet_dropdown], outputs=[sheet_content, sheet_info, sheet_columns])
+        load_button.click(update_column_selector, inputs=[excel_file, sheet_dropdown], outputs=[column_selector])
+        view_sheet_checkbox.change(toggle_sheet_visibility, inputs=[view_sheet_checkbox], outputs=[sheet_content])
+        operations_checkbox.change(toggle_operations_inputs, inputs=[operations_checkbox], outputs=[operations_inputs])
+
+        apply_operations_button = gr.Button("Criar Nova Variável")
+        new_df_output = gr.Dataframe(label="Novo DataFrame", interactive=True)
+        apply_operations_button.click(add_new_variable, inputs=[excel_file, sheet_dropdown, first_variable_dropdown, operation_dropdown, second_variable_dropdown, variable_name_textbox], outputs=[new_df_output])
+        load_button.click(update_variable_choices, inputs=[excel_file, sheet_dropdown], outputs=[first_variable_dropdown, second_variable_dropdown])
+
+        # Botão para finalizar o DataFrame
+        finalize_button = gr.Button("Finalizar DataFrame")
+        download_output = gr.File(label="Baixar Novo Dataframe")
+        finalize_button.click(finalize_dataframe, inputs=[excel_file, sheet_dropdown, column_selector, first_variable_dropdown, operation_dropdown, second_variable_dropdown, variable_name_textbox, add_index_checkbox], outputs=[new_df_output, download_output])
+
+        # Adicionar botões "Restaurar" e "Limpar"
+        with gr.Row():
+            restore_button = gr.Button("Restaurar")
+            clear_button = gr.ClearButton(components=[excel_file, sheet_output, sheet_dropdown, sheet_info, sheet_columns, view_sheet_checkbox, sheet_content, column_selector, add_index_checkbox, operations_checkbox, variable_name_textbox, first_variable_dropdown, operation_dropdown, second_variable_dropdown, new_df_output, download_output],
+                                          value="Limpar")
+
+        # Associações de eventos para os botões "Restaurar"
+        restore_button.click(restore_dataframe, outputs=[new_df_output, download_output])
+
+        # Se a opção "Usar arquivo da aba anterior" estiver marcada, carregue o filtered_df_output
+        def load_filtered_df(use_filtered_df, filtered_df_output):
+            if use_filtered_df:
+                df = pd.DataFrame(filtered_df_output)
+                return df, f"{df.shape[0]} linhas e {df.shape[1]} colunas", df.columns.tolist(), df.columns.tolist()
+            return None, "", [], []
+
+        use_filtered_df.change(load_filtered_df, inputs=[use_filtered_df, filtered_df_output], outputs=[sheet_content, sheet_info, column_selector, column_selector])
+
+    return locals(), new_df_output
+
+
+
+
+
+### Manipulação de colunas
+### Receber planilha da aba dados

modules/rl.py

@@ -0,0 +1,1477 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+import statsmodels.api as sm
+import matplotlib.pyplot as plt
+import seaborn as sns
+import plotly.graph_objects as go
+import plotly.express as px
+import scipy.stats as stats
+from joblib import dump
+import joblib
+import os
+import locale
+
+# Configurar o locale para o Brasil
+locale.setlocale(locale.LC_ALL, 'pt_BR.UTF-8')
+
+# Função para carregar a planilha de dados
+def carregar_planilha(file):
+    try:
+        # Carregar o arquivo Excel sem forçar o tipo inicialmente
+        df = pd.read_excel(file.name)
+
+        # Garantir que todas as colunas sejam convertidas para float, ignorando erros
+        for col in df.columns:
+            df[col] = pd.to_numeric(df[col], errors='coerce')  # Converte para número, valores inválidos viram NaN
+
+        # Substituir NaN por zero ou outro valor padrão, se necessário
+        df.fillna(0, inplace=True)
+
+        # Garantir que os cabeçalhos sejam strings
+        df.columns = [str(col) for col in df.columns]
+
+        # Adicionar índice baseado na posição
+        df.insert(0, "Dado", range(1, len(df) + 1))
+
+        # Arredondar colunas de tipo float para 4 casas decimais
+        for col in df.select_dtypes(include=[float]).columns:
+            df[col] = df[col].round(4)
+
+        cabecalhos = list(df.columns)
+        return cabecalhos, df
+    except Exception as e:
+        print(f"Erro ao carregar a planilha: {e}")
+        return [], pd.DataFrame()
+    
+# Função para aplicar a transformação selecionada
+def aplicar_transformacao(df, coluna, transformacao):
+    try:
+        if transformacao == "1/x":
+            return 1 / df[coluna].replace(0, np.nan).fillna(0)  # Evitar divisão por zero
+        elif transformacao == "ln(x)":
+            return np.log(df[coluna].replace(0, np.nan).fillna(0))  # Evitar log de zero
+        elif transformacao == "x²":
+            return df[coluna] ** 2
+        elif transformacao == "exp(x)":
+            return np.exp(df[coluna])
+        else:
+            return df[coluna]  # Sem transformação, retorna a coluna original
+    except Exception as e:
+        return df[coluna]  # Retorna original em caso de erro   
+    
+# Função para criar gráficos de dispersão para análise exploratória com transformações
+def grafico_dispersao(df, y_coluna, transformacao_y, x_coluna, transformacao_x, dados_out):
+    if df.empty or x_coluna not in df.columns or y_coluna not in df.columns:
+        return None  # Retornar None se o DataFrame estiver vazio ou as colunas não forem válidas
+
+    # Copiar o DataFrame para manipulação
+    df_grafico = df.copy()
+    # Convertendo a entrada manual em uma lista de inteiros
+    dados_out = [int(num.strip()) for num in dados_out.split(",") if num.strip()]
+    # Removendo os outliers dos DataFrames
+    df_grafico = df_grafico[~df_grafico["Dado"].isin(dados_out)]
+    # Aplicar transformações nas colunas x e y
+    x = aplicar_transformacao(df_grafico, x_coluna, transformacao_x)
+    y = aplicar_transformacao(df_grafico, y_coluna, transformacao_y)
+    # Calcular a linha de tendência
+    coef = np.polyfit(x, y, 1)  # Coeficientes da linha de tendência (linear)
+    linha_tendencia = np.poly1d(coef)
+    y_tendencia = linha_tendencia(x)
+    # Calcular resíduos (distância dos pontos à linha de tendência)
+    residuos = np.abs(y - y_tendencia)
+    # Normalizar os resíduos para aplicar o colormap
+    residuos_norm = (residuos - residuos.min()) / (residuos.max() - residuos.min())
+    # Calcular o valor de correlação
+    correlacao = np.corrcoef(x, y)[0, 1]
+    # Criar o gráfico de dispersão com Plotly
+    fig = go.Figure()
+    # Adicionar os pontos ao gráfico com colormap
+    fig.add_trace(go.Scatter(
+        x=x,
+        y=y,
+        mode='markers',
+        marker=dict(
+            size=8,
+            color=residuos_norm,  # Colormap com base nos resíduos
+            colorscale='Spectral',  # Escolher o esquema de cores (pode ser ajustado)
+            showscale=False,  # Desabilitar a barra de cores
+        ),
+        text=[f"Índice: {idx}<br>{x_coluna}: {x_val:.2f}<br>{y_coluna}: {y_val:.2f}<br>Resíduo: {resid:.2f}"
+              for idx, x_val, y_val, resid in zip(df_grafico["Dado"], x, y, residuos)],  # Informações no tooltip
+        hoverinfo="text"
+    ))
+
+    # Adicionar a linha de tendência ao gráfico
+    fig.add_trace(go.Scatter(
+        x=x,
+        y=y_tendencia,
+        mode='lines',
+        line=dict(color='darkred', width=2),  # Linha de tendência com vermelho escuro
+    ))
+
+    # Atualizar o layout do gráfico
+    fig.update_layout(
+        title=f"Gráfico de Dispersão: {x_coluna} vs {y_coluna}<br>Correlação: {correlacao:.2f}",
+        xaxis_title=f"{x_coluna} ({transformacao_x})",
+        yaxis_title=f"{y_coluna} ({transformacao_y})",
+        template="plotly_white",
+        showlegend=False
+    )
+
+    return fig
+
+# Função para criar boxplot para análise exploratória com transformações
+def grafico_boxplot(df, y_coluna, transformacao_y, x_coluna, transformacao_x, dados_out):
+    if df.empty or y_coluna not in df.columns:
+        return None  # Retorna None se o DataFrame estiver vazio ou as colunas não forem válidas
+
+    # Copiar o DataFrame para manipulação
+    df_boxplot = df.copy()
+
+    # Convertendo a entrada manual em uma lista de inteiros
+    dados_out = [int(num.strip()) for num in dados_out.split(",") if num.strip()]
+    # Removendo os outliers dos DataFrames
+    df_boxplot = df_boxplot[~df_boxplot["Dado"].isin(dados_out)]
+
+    # Aplicar transformação na coluna Y
+    y = aplicar_transformacao(df_boxplot, y_coluna, transformacao_y)
+
+    # Criar lista de textos personalizados para hover
+    hover_text = [
+        f"Índice: {idx}<br>{y_coluna}: {y_val:.2f}"
+        for idx, y_val in zip(df_boxplot["Dado"], y)
+    ]
+
+    # Criar o gráfico de boxplot com Plotly
+    fig = go.Figure()
+
+    # Adicionar os dados ao gráfico
+    fig.add_trace(go.Box(
+        y=y,
+        name=y_coluna,
+        boxpoints='all',  # Mostra todos os pontos, incluindo outliers
+        jitter=0.8,  # Espalhamento horizontal dos pontos
+        pointpos=-1.8,  # Posição relativa dos pontos em relação ao boxplot
+        marker=dict(
+            color='orange',
+            size=8
+        ),
+        line=dict(color='gray'),
+        hovertemplate="%{text}",  # Personaliza o hover
+        text=hover_text  # Insere a lista de textos no hover
+    ))
+
+    # Atualizar o layout do gráfico
+    fig.update_layout(
+        title=f"Boxplot da Coluna: {y_coluna} ({transformacao_y})",
+        yaxis_title=f"{y_coluna} ({transformacao_y})",
+        template="plotly_white",
+        showlegend=False
+    )
+
+    return fig
+
+# Função para atualizar os dropdowns    
+def atualizar_dropdowns(cabeçalhos):
+    if cabeçalhos:
+        # Remover 'Índice' das opções, se não for relevante para as análises
+        cabecalhos_sem_indice = [col for col in cabeçalhos if col != "Dado"]
+        dropdown_update_x = gr.update(choices=cabecalhos_sem_indice, value=cabecalhos_sem_indice)
+        dropdown_update = gr.update(choices=cabecalhos_sem_indice, value=[])
+        return [dropdown_update_x] + [dropdown_update] * 4 + [dropdown_update]  # Inclui var_dep
+    else:
+        dropdown_reset = gr.update(choices=[], value=[])
+        return [dropdown_reset] * 5 + [dropdown_reset]  # Inclui var_dep
+
+# Função para criar os cabeçalhos e colocar os limites por variável sem os outliers
+def criar_dataframe_cabecalhos(cabecalhos, x, ln_x, exp_x, inv_x, quad_x, dados, dados_out, var_dep):
+    if dados.empty:
+        return pd.DataFrame(), {}
+
+    # Remover os outliers antes de calcular os limites
+    if dados_out:
+        dados_out = [int(num.strip()) for num in dados_out.split(",") if num.strip()]
+        dados = dados[~dados["Dado"].isin(dados_out)]
+
+    # Criar um dicionário com as seleções
+    escalas = {
+        col: [escala] for col, escala in zip(
+            x + ln_x + exp_x + inv_x + quad_x,
+            ["(x)"] * len(x) + ["ln(x)"] * len(ln_x) + ["exp(x)"] * len(exp_x)
+            + ["1/(x)"] * len(inv_x) + ["(x)²"] * len(quad_x)
+        )
+    }
+
+    # Criar o DataFrame base
+    df = pd.DataFrame.from_dict(escalas, orient='index', columns=['Escala']).transpose()
+
+    # Reorganizar as colunas para garantir que 'var_dep' seja a primeira
+    if var_dep in df.columns:
+        cols = [var_dep] + [col for col in df.columns if col != var_dep]
+        df = df[cols]
+
+    # Calcular as linhas adicionais (máximo, mínimo, média) com duas casas decimais
+    limites = {
+        "Máximo": dados.max().round(2),
+        "Mínimo": dados.min().round(2),
+        "Média": dados.mean().round(2)
+    }
+
+    # Adicionar as linhas ao DataFrame
+    for label, valores in limites.items():
+        linha = {col: valores[col] if col in valores else '' for col in df.columns}
+        df = pd.concat([df, pd.DataFrame([linha], index=[label])])
+
+    return df, escalas
+
+# Função para criar DataFrames original, escalado, correlação e outliers
+def criar_dataframes(dados, x, ln_x, exp_x, inv_x, quad_x, dados_out, var_dep):
+    if dados.empty:
+        return pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), None
+
+    # Selecionar as colunas escolhidas e incluir "Dado" como identificador
+    colunas_escolhidas = x + ln_x + exp_x + inv_x + quad_x
+    df_original = dados[["Dado"] + colunas_escolhidas]  # Incluindo "Dado"
+
+    # Aplicar escalas e manter "Dado"
+    df_escalado = pd.DataFrame()
+    df_escalado["Dado"] = dados["Dado"]  # Preservar "Dado" no escalado
+
+    for col in x:
+        df_escalado[col] = dados[col]  # (x)
+    for col in ln_x:
+        df_escalado[col] = np.log(dados[col].replace(0, np.nan)).fillna(0)  # ln(x), evitando log de zero
+    for col in exp_x:
+        df_escalado[col] = np.exp(dados[col])  # exp(x)
+    for col in inv_x:
+        df_escalado[col] = 1 / dados[col].replace(0, np.nan).fillna(0)  # 1/(x), evitando divisão por zero
+    for col in quad_x:
+        df_escalado[col] = dados[col] ** 2  # (x)²
+
+    # Reorganizar colunas para que var_dep fique como a segunda coluna
+    if var_dep in df_original.columns:
+        colunas_reorganizadas_original = (
+            ["Dado", var_dep] + [col for col in df_original.columns if col not in ["Dado", var_dep]]
+        )
+        df_original = df_original[colunas_reorganizadas_original]
+
+    if var_dep in df_escalado.columns:
+        colunas_reorganizadas_escalado = (
+            ["Dado", var_dep] + [col for col in df_escalado.columns if col not in ["Dado", var_dep]]
+        )
+        df_escalado = df_escalado[colunas_reorganizadas_escalado]
+
+    # Criando o novo DataFrame com a coluna 'variáveis' sem índice
+    df_variaveis = pd.DataFrame({'variáveis': df_original.columns})
+    df_variaveis.reset_index(drop=True, inplace=True)
+
+    # Verificar se dados_out está em branco
+    if not dados_out.strip():
+        df_outliers = pd.DataFrame()  # DataFrame vazio para outliers
+    else:
+        # Convertendo a entrada manual em uma lista de inteiros
+        dados_out = [int(num.strip()) for num in dados_out.split(",") if num.strip()]
+        # Criando o DataFrame de outliers
+        df_outliers = df_original[df_original["Dado"].isin(dados_out)]  # Filtrar com base nos valores de dados_out
+        # Removendo os outliers dos DataFrames originais e escalados
+        df_original = df_original[~df_original["Dado"].isin(dados_out)]
+        df_escalado = df_escalado[~df_escalado["Dado"].isin(dados_out)]
+    
+    # Criar matriz de correlação
+    correlation_matrix = df_escalado.drop(columns=["Dado"]).corr().round(2)  # "Dado" não entra na correlação
+
+    return df_original, df_escalado, df_outliers  # , correlation_matrix
+
+# Função para Regressão Linear
+def realizar_regressao(var_dep, dados_transformados, df_original, escalas):
+    if isinstance(dados_transformados, pd.DataFrame) and not dados_transformados.empty:
+        try:
+            import statsmodels.api as sm
+            import numpy as np
+
+            if var_dep in dados_transformados.columns:
+                # Separando X e y
+                y = dados_transformados[var_dep]
+                X = dados_transformados.drop(columns=[var_dep, "Dado"])
+
+                # Número de variáveis independentes
+                num_variaveis = X.shape[1]
+
+                # Adicionando constante
+                X = sm.add_constant(X)
+
+                # Ajustando modelo
+                modelo = sm.OLS(y, X).fit()
+                
+                # Inicializar resultados gerais
+                resultados_gerais = ""
+
+                # Estatísticas gerais do modelo
+                residuos = modelo.resid
+                desvio_padrao_residuos = round(np.std(residuos), 8)
+                erro_padronizado = np.round(residuos / desvio_padrao_residuos, 8)
+                estatistica_F = round(modelo.fvalue, 8)
+                nivel_significancia = round(modelo.f_pvalue, 8)
+                r_squared = round(modelo.rsquared, 8)
+                r_squared_adjusted = round(modelo.rsquared_adj, 8)
+                num_observacoes = int(round(modelo.nobs, 0))
+                coef_correlacao = round(np.sqrt(r_squared), 8)
+
+                # Comparação com a curva normal de resíduos
+                intervalos = [(-1.00, 1.00), (-1.64, 1.64), (-1.96, 1.96)]
+                percentuais = []
+                for intervalo in intervalos:
+                    min_intervalo, max_intervalo = intervalo
+                    count = np.sum((erro_padronizado >= min_intervalo) & (erro_padronizado <= max_intervalo))
+                    percentual = round(count / len(erro_padronizado) * 100, 0)
+                    percentuais.append(f"{percentual:.0f}%")
+                perc_resid = ", ".join(percentuais)
+
+                # Teste Kolmogorov-Smirnov (KS)
+                ks_test = sm.stats.diagnostic.kstest_normal(residuos)
+                ks_test_formatted = tuple(f"{val:.4f}" for val in ks_test)
+                
+                import statsmodels.api as sm
+
+                # Teste Kolmogorov-Smirnov (KS)
+                ks_test = sm.stats.diagnostic.kstest_normal(residuos)
+                ks_test_formatted = tuple(f"{val:.4f}" for val in ks_test)
+                
+                # Interpretando o resultado
+                estatistica_ks, p_valor_ks = ks_test  # Desempacotando os valores
+                
+                if p_valor_ks > 0.05:
+                    ks_interpretacao = "Não há evidências estatísticas suficientes para rejeitar a hipótese nula. Os resíduos podem seguir uma distribuição normal."
+                else:
+                    ks_interpretacao = "Rejeitamos a hipótese nula. Há evidências estatísticas de que os resíduos não seguem uma distribuição normal."
+
+
+                # Distância de Cook
+                influencia = modelo.get_influence()
+                distancia_cook = influencia.cooks_distance[0]
+
+                # Criar DataFrame com resultados por variável
+                coeficientes = modelo.params
+                erros_padrao = modelo.bse
+                t_values = modelo.tvalues
+                p_values = modelo.pvalues
+
+                # Adicionar a coluna Escala com base no dicionário de escalas
+                escalas_coluna = [escalas[var][0] if var in escalas else "Nenhuma" for var in coeficientes.index]
+
+                resultados_vars = pd.DataFrame({
+                    "Variável": coeficientes.index,
+                    "Escala": escalas_coluna,  # Adicionando a coluna Escala
+                    "Coeficiente": coeficientes.values.round(4),
+                    "Erro Padrão": erros_padrao.values.round(4),
+                    "t-valor": t_values.values.round(4),
+                    "P>|t|": p_values.values.round(4)
+                })
+
+                # Expressão da equação do modelo com a variável dependente transformada
+                if var_dep in escalas:
+                    escala_y = escalas[var_dep][0]  # Obter a escala associada
+                    if escala_y == "ln(x)":
+                        y_label_transformada = f"ln({var_dep})"
+                        ajustar_termo = lambda termo: f"exp({termo})"  # Aplicar exponencial
+                    elif escala_y == "1/(x)":
+                        y_label_transformada = f"1/({var_dep})"
+                        ajustar_termo = lambda termo: f"1/({termo})"  # Aplicar inverso
+                    elif escala_y == "(x)²":
+                        y_label_transformada = f"({var_dep})²"
+                        ajustar_termo = lambda termo: f"sqrt({termo})"  # Aplicar raiz quadrada
+                    elif escala_y == "exp(x)":
+                        y_label_transformada = f"exp({var_dep})"
+                        ajustar_termo = lambda termo: f"ln({termo})"  # Aplicar logaritmo natural
+                    else:
+                        y_label_transformada = var_dep  # Sem transformação
+                        ajustar_termo = lambda termo: termo  # Sem ajuste
+                else:
+                    y_label_transformada = var_dep  # Sem transformação
+                    ajustar_termo = lambda termo: termo  # Sem ajuste
+
+                # Construir os termos da equação
+                termos = []
+                for var, coef in zip(coeficientes.index, coeficientes.values):
+                    if var == 'const':
+                        interseção = f"{coef:.4f}"
+                    else:
+                        if var in escalas:
+                            escala_var = escalas[var][0]  # Obter a escala associada
+                            if escala_var == "ln(x)":
+                                var_label = f"ln({var})"
+                            elif escala_var == "1/(x)":
+                                var_label = f"1/({var})"
+                            elif escala_var == "(x)²":
+                                var_label = f"({var})²"
+                            elif escala_var == "exp(x)":
+                                var_label = f"exp({var})"
+                            else:
+                                var_label = var  # Sem transformação
+                        else:
+                            var_label = var  # Sem transformação
+                        termos.append(f"{coef:.4f} * {var_label}")
+
+                # Montar a equação com a variável dependente transformada
+                lado_direito = interseção + " + " + " + ".join(termos)
+                equacao_transformada = f"{y_label_transformada} = {lado_direito}"
+                # Montar a equação com a variável dependente na escala direta
+                equacao_revertida = f"{var_dep} = {ajustar_termo(lado_direito)}"
+                # Substituir pontos por vírgulas nas equações
+                equacao_transformada = equacao_transformada.replace('.', ',')
+                equacao_revertida = equacao_revertida.replace('.', ',')
+                # Adicionar as duas formas da equação aos resultados gerais
+                #resultados_gerais += f"\nEquação do modelo (variável dependente transformada): {equacao_transformada}"
+                resultados_gerais += f"\nEquação do modelo (variável dependente na escala direta): {equacao_revertida}"
+
+                # Classificar variáveis com base nos p-valores
+                def classificar(valor):
+                    if valor > 0.3:
+                        return "Fora dos critérios"
+                    elif valor > 0.2:
+                        return "Grau I"
+                    elif valor > 0.1:
+                        return "Grau II"
+                    else:
+                        return "Grau III"
+
+                resultados_vars['Classificação'] = resultados_vars['P>|t|'].apply(classificar)
+
+                # Determinar grau único considerando todas as variáveis
+                def determinar_grau_unico(classificacoes):
+                    if "Fora dos critérios" in classificacoes:
+                        return "Fora dos critérios"
+                    elif "Grau I" in classificacoes:
+                        return "Grau I"
+                    elif "Grau II" in classificacoes:
+                        return "Grau II"
+                    else:
+                        return "Grau III"
+
+                tab5 = determinar_grau_unico(resultados_vars['Classificação'])
+
+                # Enquadramento na NBR 14.653-2
+                # Item 2 da tabela
+                if num_observacoes >= 6 * (num_variaveis + 1):
+                    tab2 = "Grau III"
+                elif num_observacoes >= 4 * (num_variaveis + 1):
+                    tab2 = "Grau II"
+                elif num_observacoes >= 3 * (num_variaveis + 1):
+                    tab2 = "Grau I"
+                else:
+                    tab2 = "Fora dos critérios"
+
+                # Item 6 da tabela
+                if nivel_significancia <= 0.01:
+                    tab6 = "Grau III"
+                elif nivel_significancia <= 0.02:
+                    tab6 = "Grau II"
+                elif nivel_significancia <= 0.05:
+                    tab6 = "Grau I"
+                else:
+                    tab6 = "Fora dos critérios"
+
+                # Resultados gerais formatados
+                resultados_gerais = f"""
+                Desvio Padrão dos Resíduos: {desvio_padrao_residuos}
+                Estatística F: {estatistica_F} | Nível de Significância: {nivel_significancia}
+                R²: {r_squared} | R² Ajustado: {r_squared_adjusted}
+                Correlação: {coef_correlacao}
+                Número de Observações: {num_observacoes}
+                Número de Variáveis Independentes: {num_variaveis}
+
+                Fundamentação - Quant. min. dados (Item 2 tab 9.2.1 NBR 14.653-2): {tab2}
+                Fundamentação - Signif. Regressores (Item 5 tab 9.2.1 NBR 14.653-2): {tab5}
+                Fundamentação - Signif. Modelo (Item 6 tab 9.2.1 NBR 14.653-2): {tab6}
+
+                Testes de normalidade:
+                1) Comparação (curva normal) - Percentuais atingidos: {perc_resid}
+                   Ideal 68% - aceitável de 64% a 75%
+                   Ideal 90% - aceitável de 88% a 95%
+                   Ideal 95% - aceitável de 95% a 100%
+
+                Teste Kolmogorov-Smirnov: Estatística = {ks_test_formatted[0]}, Valor-p = {ks_test_formatted[1]} - ({ks_interpretacao})
+
+                Distância de Cook (Máxima): {np.max(distancia_cook):.8f}
+                
+                Equação do modelo: {equacao_revertida}
+                """
+                
+                # Adicionando a coluna de erro padronizado ao df_final
+                df_original_res = df_original.copy()
+                df_original_res['Erro Padronizado'] = erro_padronizado
+
+                # Criar DataFrame apenas com os dados cujo erro padronizado é maior que 2
+                df_grandes_residuos = df_original_res[abs(df_original_res['Erro Padronizado']) > 2].copy()
+                df_grandes_residuos['Erro Abs'] = abs(df_grandes_residuos['Erro Padronizado'])        
+                           
+                # Listagem de pontos com resíduos > 2  
+                listagem_grandes_residuos = ", ".join(map(str, df_grandes_residuos.iloc[:, 0].tolist()))
+                
+                # Listagem dos pontos influenciantes
+                limite_cook = 1
+                pontos_influentes = []
+                for i, cook_dist in enumerate(distancia_cook):
+                    if cook_dist > limite_cook:
+                        pontos_influentes.append(dados_transformados.iloc[i]["Dado"])  # Usando a primeira coluna como rótulo
+
+                # Transformando a lista em uma string separada por vírgula
+                listagem_pontos_influentes = ", ".join(map(str, pontos_influentes))
+                              
+                # Criação de um dataframe para valores previstos
+                valores_previstos = modelo.predict(X)
+                valores_previstos_trans = valores_previstos.copy()
+                # Reverter a escala da variável dependente, se aplicável
+                if var_dep in escalas:
+                    escala_var_dep = escalas[var_dep][0]  # Obtém a escala associada
+
+                    if escala_var_dep == "ln(x)":
+                        valores_previstos = np.exp(valores_previstos)  # Reverte ln(x) para x
+                    elif escala_var_dep == "1/(x)":
+                        valores_previstos = 1 / valores_previstos  # Reverte 1/(x) para x
+                    elif escala_var_dep == "(x)²":
+                        valores_previstos = np.sqrt(valores_previstos)  # Reverte (x)² para x
+                    elif escala_var_dep == "exp(x)":
+                        valores_previstos = np.log(valores_previstos)  # Reverte exp(x) para x
+                    # Caso não seja necessário reverter, mantém os valores ajustados como estão
+
+                # Adicionando os valores ajustados como uma nova coluna ao DataFrame original
+                df_calc_obs = df_original.copy()
+                df_calc_obs['Valores Ajustados'] = round(valores_previstos, 8)
+                # Resíduo
+                df_calc_obs['Resíduo'] = (df_calc_obs[var_dep].replace(0, np.nan) - df_calc_obs['Valores Ajustados']).round(4)
+                # Erro padronizado
+                df_calc_obs['Erro Padronizado'] = erro_padronizado.round(4)
+                # Adicionando a coluna de Erro
+                # Certifique-se de evitar divisão por zero
+                df_calc_obs['Erro'] = df_calc_obs['Valores Ajustados'] / df_calc_obs[var_dep].replace(0, np.nan)
+                # Arredondar os valores da coluna 'Erro' para melhorar a apresentação
+                df_calc_obs['Erro'] = df_calc_obs['Erro'].round(4)
+                # Criando a coluna de erro percentual
+                df_calc_obs['Erro Percentual (%)'] = (abs(df_calc_obs['Erro'] - 1) * 100).round(4)
+                           
+                # Adicionando os valores ajustados como uma nova coluna ao DataFrame original
+                df_calc_obs_trans = dados_transformados.copy()
+                df_calc_obs_trans['Valores Ajustados'] = round(valores_previstos_trans, 8)           
+                            
+                return resultados_gerais, resultados_vars, df_grandes_residuos, listagem_grandes_residuos, listagem_pontos_influentes, df_calc_obs, df_calc_obs_trans, erro_padronizado, modelo
+            else:
+                return "Erro: A variável dependente não está nos dados transformados.", pd.DataFrame(), pd.DataFrame(), "Erro", "Erro", pd.DataFrame(), pd.DataFrame(), [], None
+        except Exception as e:
+            return f"Erro na regressão: {str(e)}", pd.DataFrame(), pd.DataFrame(), "Erro", "Erro", pd.DataFrame(), pd.DataFrame(), [], None
+    else:
+        return "Erro: Dados transformados inválidos ou vazios.", pd.DataFrame(), pd.DataFrame(), "Erro", "Erro", pd.DataFrame(), pd.DataFrame(), [], None
+
+# Função para plotar gráficos do modelo
+def graficos(escala_dependente, df_calc_obs, df_calc_obs_trans, erro_padronizado, var_dep, num_bins=20):
+
+    # Gráfico 1: Resíduos Padronizados
+    # Normalizar os resíduos padronizados para o colormap
+    residuos_norm = (np.abs(erro_padronizado) - np.abs(erro_padronizado).min()) / \
+                    (np.abs(erro_padronizado).max() - np.abs(erro_padronizado).min())
+
+    fig1 = go.Figure()
+    fig1.add_trace(go.Scatter(
+        x=df_calc_obs_trans['Valores Ajustados'],
+        y=erro_padronizado,
+        mode='markers',
+        marker=dict(
+            size=8,
+            color=residuos_norm,  # Aplicar o colorscale
+            colorscale='Spectral',  # Escolher a paleta de cores
+        ),
+        text=df_calc_obs_trans.iloc[:, 0],
+        hovertemplate="<b>Índice: %{text}</b><br>Valores Ajustados: %{x:.2f}<br>Resíduos: %{y:.2f}<extra></extra>"
+    ))
+    fig1.add_hline(y=0, line_dash="dash", line_color="black")
+    fig1.add_hline(y=2, line_dash="dot", line_color="red")
+    fig1.add_hline(y=-2, line_dash="dot", line_color="red")
+    fig1.update_layout(
+        title="Gráfico de Resíduos Padronizados",
+        xaxis_title="Valores Ajustados",
+        yaxis_title="Resíduos Padronizados",
+        template="plotly_white"
+    )
+
+    # Gráfico 2: Histograma dos Resíduos Padronizados com Curva Normal
+    # Calcula média e desvio padrão dos resíduos
+    mean_residuos = np.mean(erro_padronizado)
+    std_residuos = np.std(erro_padronizado)
+
+    # Dados para a curva normal
+    x_vals = np.linspace(mean_residuos - 4 * std_residuos, mean_residuos + 4 * std_residuos, 500)
+    y_vals = stats.norm.pdf(x_vals, mean_residuos, std_residuos)  # PDF da curva normal
+
+    # Criar o histograma (frequência normalizada)
+    hist_values, bin_edges = np.histogram(erro_padronizado, bins=num_bins, density=True)
+    scale_factor = max(hist_values) / max(y_vals)  # Ajustar altura da curva normal
+    y_vals_scaled = y_vals * scale_factor
+
+    # Calcular o valor médio dos resíduos absolutos para cada bin
+    bin_centers = bin_edges[:-1] + np.diff(bin_edges) / 2
+    bin_colors = 1 - (np.abs(bin_centers) - np.abs(bin_centers).min()) / (np.abs(bin_centers).max() - np.abs(bin_centers).min()) 
+
+    fig2 = go.Figure()
+    fig2.add_trace(go.Bar(
+        x=bin_centers,  # Centraliza as barras
+        y=hist_values,
+        width=np.diff(bin_edges),
+        marker=dict(
+            color=bin_colors,  # Aplicar o colorscale
+            colorscale='Reds',
+        ),
+        opacity=0.7,
+        name='Histograma'
+    ))
+
+    # Adicionar a curva normal ajustada
+    fig2.add_trace(go.Scatter(
+        x=x_vals,
+        y=y_vals_scaled,
+        mode='lines',
+        line=dict(color='red', width=2),
+        name='Curva Normal'
+    ))
+
+    fig2.update_layout(
+        title="Histograma dos Resíduos Padronizados com Curva Normal",
+        xaxis_title="Resíduos Padronizados",
+        yaxis_title="Frequência Normalizada",
+        template="plotly_white",
+    )
+    
+    # Gráfico 3: Valores Ajustados vs Preços Observados
+    if escala_dependente == "Direta":
+        df_graf_ao = df_calc_obs
+    else:
+        df_graf_ao = df_calc_obs_trans
+    
+    # Definir os eixos
+    valores_observados = df_graf_ao.iloc[:, 1]  # Segunda coluna do DataFrame
+    valores_calculados = df_graf_ao['Valores Ajustados']
+    
+    # Cálculo dos resíduos normalizados
+    residuos = np.abs(valores_observados - valores_calculados)
+    residuos_norm = (residuos - residuos.min()) / (residuos.max() - residuos.min())  # Normalizar para o colorscale
+    
+    # Ajustar a reta de regressão linear com statsmodels
+    X = sm.add_constant(valores_observados)  # Adicionar uma constante (intercepto)
+    modelo = sm.OLS(valores_calculados, X).fit()  # Ajustar o modelo OLS
+    x_reta = np.linspace(valores_observados.min(), valores_observados.max(), 100)  # Valores de X para a reta
+    y_reta = modelo.predict(sm.add_constant(x_reta))  # Predizer Y com base no modelo
+    
+    # Criar o gráfico
+    fig3 = go.Figure()
+    fig3.add_trace(go.Scatter(
+        x=valores_observados,
+        y=valores_calculados,
+        mode='markers',
+        marker=dict(
+            size=8,
+            color=residuos_norm,  # Aplicar o colorscale
+            colorscale='Spectral',  # Escolher a paleta de cores
+            showscale=False
+        ),
+        text=df_graf_ao.iloc[:, 0],  # Índice ou outra coluna para hover
+        hovertemplate="<b>Índice: %{text}</b><br>Observado: %{x:.2f}<br>Ajustado: %{y:.2f}<extra></extra>",
+        showlegend=False  # Remover legenda deste trace
+    ))
+    
+    # Adicionar a reta ajustada (linha de regressão)
+    fig3.add_trace(go.Scatter(
+        x=x_reta,
+        y=y_reta,
+        mode="lines",
+        line=dict(color="green", dash="solid"),
+        name="Reta Ajustada"
+    ))
+    
+    # Configuração do layout
+    fig3.update_layout(
+        title="Valores Ajustados vs Preços Observados",
+        xaxis_title="Preços Observados",
+        yaxis_title="Valores Ajustados",
+        template="plotly_white",
+        showlegend=False  # Remover legenda
+    )
+
+
+
+    # Gráfico 4: Matriz de Correlações
+    corr_matrix = df_calc_obs_trans.drop(columns=["Dado", "Valores Ajustados"], errors='ignore').corr()
+
+    # Criar o Heatmap diretamente com texto
+    fig4 = go.Figure()
+
+    # Adicionar os valores manualmente como anotação no gráfico
+    for i, row in enumerate(corr_matrix.index):
+        for j, col in enumerate(corr_matrix.columns):
+            # Determinar a cor do texto com base nas condições
+            if row == col:
+                color = "black"  # Preto para a diagonal (mesma variável)
+            elif corr_matrix.loc[row, col] > 0.8:  # Correlação acima de 0.8
+                if row == var_dep or col == var_dep:
+                    color = "blue"  #tr Azul para correlação com var_dep
+                else:
+                    color = "red"  # Vermelho para correlação alta entre variáveis independentes
+            else:
+                color = "black"  # Preto para todas as outras correlações
+
+            # Adicionar o texto no gráfico
+            fig4.add_trace(go.Scatter(
+                x=[col],
+                y=[row],
+                text=[f"{corr_matrix.loc[row, col]:.2f}"],
+                mode="text",
+                textfont=dict(size=12, color=color),  # Aplicar a cor
+            ))
+
+    # Atualizar o layout
+    fig4.update_layout(
+        title="Matriz de Correlações",
+        xaxis=dict(title="Variáveis", tickmode='array', tickvals=corr_matrix.columns),
+        yaxis=dict(title="Variáveis", tickmode='array', tickvals=corr_matrix.index),
+        template="plotly_white",
+        showlegend=False
+    )
+
+    return fig1, fig2, fig3, fig4
+
+# Função para exportar para o excel
+def exportar_para_excel(nome_arquivo, df_planilha, df_infos, df_original, df_escalado, df_outliers, resultados_gerais, resultados_vars, df_calc_obs, df_calc_obs_trans):
+    try:
+        # Criar um arquivo Excel com múltiplas abas
+        with pd.ExcelWriter(nome_arquivo, engine='xlsxwriter') as writer:
+            # Adicionar os DataFrames em abas específicas
+            df_planilha.to_excel(writer, sheet_name='Dados Originais', index=False)
+            df_infos.to_excel(writer, sheet_name='Infos', index=False)
+            df_original.to_excel(writer, sheet_name='Dados Modelo', index=False)
+            #df_escalado.to_excel(writer, sheet_name='Dados Modelo Transformados', index=False)
+            df_outliers.to_excel(writer, sheet_name='Outliers', index=False)
+            
+            # Converter "Resultados Gerais" para um DataFrame formatado
+            resultados_lista = [linha.strip() for linha in resultados_gerais.split("\n") if linha.strip()]
+            resultados_df = pd.DataFrame({"Descrição": resultados_lista})
+            resultados_df.to_excel(writer, sheet_name='Resultados Gerais', index=False)
+            
+            # Resultados por variável
+            resultados_vars.to_excel(writer, sheet_name='Resultados Variáveis', index=False)
+                  
+            # Valores calculados x observados
+            df_calc_obs.to_excel(writer, sheet_name='Calc x Obs', index=False)
+            
+            # Valores calculados transformados
+            #df_calc_obs_trans.to_excel(writer, sheet_name='Calculados Transformados', index=False)
+
+        return f"Arquivo '{nome_arquivo}' criado com sucesso."
+    except Exception as e:
+        return f"Erro ao criar o arquivo Excel: {str(e)}"
+    
+# Função para salvar o modelo
+def exportar_modelo_completo_avse(nome_pacote, modelo, resultados_gerais, df_planilha, df_infos, df_original, df_outliers, resultados_vars, df_calc_obs):
+    try:
+        # Verificar se o nome do pacote está vazio
+        if not nome_pacote:
+            return "Erro: O nome do arquivo não pode estar vazio."
+
+        # Garantir que o nome do pacote tenha a extensão .avse
+        if not nome_pacote.endswith(".avse"):
+            nome_pacote += ".avse"
+
+        # Empacotar todos os itens em um dicionário
+        pacote = {
+            "modelo": modelo,
+            "Resultados Gerais": resultados_gerais,
+            "df_planilha": df_planilha,
+            "df_infos": df_infos,
+            "df_original": df_original,
+            "df_outliers": df_outliers,
+            "resultados_vars": resultados_vars,
+            "df_calc_obs": df_calc_obs
+        }
+
+        # Salvar o pacote usando joblib
+        dump(pacote, nome_pacote)
+        return f"Pacote '{nome_pacote}' criado com sucesso."
+    except Exception as e:
+        return f"Erro ao criar o pacote: {str(e)}"
+    
+# Função para carregar o modelo
+def carregar_modelo(nome_pacote):
+    try:
+        # Carregar o pacote salvo
+        pacote = joblib.load(nome_pacote)
+
+        # Recuperar os objetos do pacote
+        modelo = pacote.get("modelo", None)  # Objeto do modelo salvo
+        resultados_gerais = pacote.get("Resultados Gerais", "")  # Resultados gerais do modelo
+        df_planilha = pacote.get("df_planilha", pd.DataFrame())
+        df_infos = pacote.get("df_infos", pd.DataFrame())
+        df_original = pacote.get("df_original", pd.DataFrame())
+        df_outliers = pacote.get("df_outliers", pd.DataFrame())
+        resultados_vars = pacote.get("resultados_vars", pd.DataFrame())
+        df_calc_obs = pacote.get("df_calc_obs", pd.DataFrame())
+
+        # Adicionar uma linha em branco no df_infos se ele não estiver vazio
+        if not df_infos.empty:
+            df_infos.loc[len(df_infos)] = [None] * len(df_infos.columns)
+            
+        # Transpor o DataFrame
+        df_infos_transposed = df_infos.T
+        
+        # Renomear as colunas
+        df_infos_transposed.columns = ['Escalas', 'Máximo', 'Mínimo', 'Médio', 'Avaliando']
+        
+        # Adicionar a coluna 'Variáveis' com os nomes das colunas originais
+        df_infos_transposed.insert(0, 'Variáveis', df_infos.columns)   
+        
+        # Atribuir o valor padrão "------" à célula da primeira linha da última coluna
+        df_infos_transposed.iloc[0, -1] = "Variável dependente"
+        
+        # Obter apenas o nome do arquivo, sem o caminho
+        nome_arquivo = os.path.basename(nome_pacote)
+        
+        # Criar mensagem de sucesso com o nome do modelo
+        mensagem_sucesso = f"Modelo '{nome_arquivo}' carregado com sucesso."
+            
+        # Retornar todos os componentes necessários
+        return (
+            mensagem_sucesso,  # Mensagem de sucesso com o nome do modelo
+            modelo,  # Modelo carregado para previsões
+            resultados_gerais,  # Resultados gerais do modelo
+            df_planilha,  # Dados originais
+            df_original,  # Dados usados no modelo
+            df_outliers,  # Outliers identificados
+            resultados_vars,  # Resultados por variável
+            df_calc_obs,  # Dados calculados x observados
+            df_infos_transposed,  # Informações adicionais do modelo
+        )
+    except Exception as e:
+        # Retornar valores padrão em caso de erro
+        return (
+            "Carregue o modelo antes de clicar no botão VISUALIZAR MODELO",
+            None,  # Modelo não carregado
+            "",  # Resultados gerais vazio
+            pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), pd.DataFrame(),
+        )
+
+
+
+def realizar_previsoes(modelo, tab_infos_carregada):
+    try:
+        if modelo is None or tab_infos_carregada.empty:
+            return "Erro: Modelo não carregado ou tabela de informações vazia.", pd.DataFrame(), pd.DataFrame(), ""
+
+        # Identificar as escalas das variáveis independentes e dependente
+        escalas_independentes = tab_infos_carregada.iloc[1:, 1].to_list()  # a partir da 2ª linha da 2ª coluna
+        escala_dependente = tab_infos_carregada.iloc[0, 1]  # 1ª linha da 2ª coluna
+
+        # Valores para previsão estão a partir da 2ª linha da 6ª coluna
+        valores_entrada = tab_infos_carregada.iloc[1:, 5].values
+
+        # Converter valores para numéricos, substituindo inválidos por NaN
+        valores_entrada = pd.to_numeric(valores_entrada, errors='coerce')
+
+        # Aplicar escalas às variáveis independentes
+        valores_transformados = []
+        for valor, escala in zip(valores_entrada, escalas_independentes):
+            if np.isnan(valor):
+                valores_transformados.append(np.nan)  # Manter NaN se o valor for inválido
+            elif escala == "ln(x)":
+                valores_transformados.append(np.log(valor) if valor > 0 else np.nan)  # Evitar log de zero ou negativo
+            elif escala == "1/(x)":
+                valores_transformados.append(1 / valor if valor != 0 else np.nan)  # Evitar divisão por zero
+            elif escala == "(x)²":
+                valores_transformados.append(valor ** 2)
+            elif escala == "exp(x)":
+                valores_transformados.append(np.exp(valor))
+            else:
+                valores_transformados.append(valor)
+
+        # Transformar em DataFrame para manter o formato necessário
+        df_previsao = pd.DataFrame([valores_transformados], columns=tab_infos_carregada.iloc[1:, 0])
+
+        # Adicionar constante ao modelo para previsão
+        X = sm.add_constant(df_previsao, has_constant='add')
+
+        # Garantir que as colunas em X correspondam às usadas no modelo
+        colunas_modelo = modelo.model.exog_names
+        X = X.reindex(columns=colunas_modelo, fill_value=0)  # Reordenar e preencher colunas faltantes com 0
+
+        # Verificar se existem valores NaN nos dados transformados
+        if X.isnull().values.any():
+            return "Erro: Existem valores inválidos após a transformação. Verifique os dados de entrada.", df_previsao, pd.DataFrame(), ""
+
+        # Realizar a previsão
+        previsao_transformada = modelo.predict(X).iloc[0]
+
+        # Ajustar para a escala direta da variável dependente
+        if escala_dependente == "ln(x)":
+            previsao_final = np.exp(previsao_transformada)
+        elif escala_dependente == "1/(x)":
+            previsao_final = 1 / previsao_transformada
+        elif escala_dependente == "(x)²":
+            previsao_final = np.sqrt(previsao_transformada)
+        elif escala_dependente == "exp(x)":
+            previsao_final = np.log(previsao_transformada)
+        else:
+            previsao_final = previsao_transformada
+
+        # Calcular limites do campo de arbítrio
+        limite_inferior_arbitrio = previsao_final * 0.85
+        limite_superior_arbitrio = previsao_final * 1.15
+
+        # Calcular intervalo de confiança de 80%
+        intervalos = modelo.get_prediction(X).conf_int(alpha=0.2)
+        limite_inferior_ic = intervalos[0, 0]  # Acessar diretamente o valor do array
+        limite_superior_ic = intervalos[0, 1]  # Acessar diretamente o valor do array
+
+        # Ajustar limites de IC para a escala direta, se necessário
+        if escala_dependente == "ln(x)":
+            limite_inferior_ic = np.exp(limite_inferior_ic)
+            limite_superior_ic = np.exp(limite_superior_ic)
+        elif escala_dependente == "1/(x)":
+            limite_inferior_ic = 1 / limite_inferior_ic
+            limite_superior_ic = 1 / limite_superior_ic
+        elif escala_dependente == "(x)²":
+            limite_inferior_ic = np.sqrt(limite_inferior_ic)
+            limite_superior_ic = np.sqrt(limite_superior_ic)
+        elif escala_dependente == "exp(x)":
+            limite_inferior_ic = np.log(limite_inferior_ic)
+            limite_superior_ic = np.log(limite_superior_ic)
+
+        # Cálculo da extrapolação
+        extrapolacao_info = ""
+        valores_ajustados = valores_entrada.copy()
+        contagem_extrapolacoes = 0
+        fora_dos_criterios = False
+        for i, valor in enumerate(valores_entrada):
+            maximo = pd.to_numeric(tab_infos_carregada.iloc[i+1, 2], errors='coerce')  # Coluna 3 (Mínimo)
+            minimo = pd.to_numeric(tab_infos_carregada.iloc[i+1, 3], errors='coerce')  # Coluna 4 (Máximo)
+
+            if not np.isnan(valor):
+                if valor < minimo:
+                    percentual_extrapolacao = ((minimo - valor) / minimo) * -100
+                    extrapolacao_info += f"Variável '{tab_infos_carregada.iloc[i+1, 0]}' está {percentual_extrapolacao:.2f}% abaixo do mínimo da amostra.\n"
+                    valores_ajustados[i] = minimo  # Ajustar valor para o mínimo
+                    contagem_extrapolacoes += 1
+                    if percentual_extrapolacao < -50:
+                        fora_dos_criterios = True
+                elif valor > maximo:
+                    percentual_extrapolacao = ((valor - maximo) / maximo) * 100
+                    extrapolacao_info += f"Variável '{tab_infos_carregada.iloc[i+1, 0]}' está {percentual_extrapolacao:.2f}% acima do máximo da amostra.\n"
+                    valores_ajustados[i] = maximo  # Ajustar valor para o máximo
+                    contagem_extrapolacoes += 1
+                    if percentual_extrapolacao > 100:
+                        fora_dos_criterios = True
+
+        # Criar novos DataFrames para cada variável que extrapolou
+        previsoes_extrapoladas = []
+        for i, (valor, ajustado) in enumerate(zip(valores_entrada, valores_ajustados)):
+            if valor != ajustado:
+                valores_transformados_ext = []
+                for valor_ext, escala in zip(valores_ajustados, escalas_independentes):
+                    if np.isnan(valor_ext):
+                        valores_transformados_ext.append(np.nan)
+                    elif escala == "ln(x)":
+                        valores_transformados_ext.append(np.log(valor_ext) if valor_ext > 0 else np.nan)
+                    elif escala == "1/(x)":
+                        valores_transformados_ext.append(1 / valor_ext if valor_ext != 0 else np.nan)
+                    elif escala == "(x)²":
+                        valores_transformados_ext.append(valor_ext ** 2)
+                    elif escala == "exp(x)":
+                        valores_transformados_ext.append(np.exp(valor_ext))
+                    else:
+                        valores_transformados_ext.append(valor_ext)
+
+                df_previsao_ext = pd.DataFrame([valores_transformados_ext], columns=tab_infos_carregada.iloc[1:, 0])
+                X_ext = sm.add_constant(df_previsao_ext, has_constant='add')
+                X_ext = X_ext.reindex(columns=colunas_modelo, fill_value=0)
+
+                if X_ext.isnull().values.any():
+                    continue
+
+                previsao_transformada_ext = modelo.predict(X_ext).iloc[0]
+
+                if escala_dependente == "ln(x)":
+                    previsao_final_ext = np.exp(previsao_transformada_ext)
+                elif escala_dependente == "1/(x)":
+                    previsao_final_ext = 1 / previsao_transformada_ext
+                elif escala_dependente == "(x)²":
+                    previsao_final_ext = np.sqrt(previsao_transformada_ext)
+                elif escala_dependente == "exp(x)":
+                    previsao_final_ext = np.log(previsao_transformada_ext)
+                else:
+                    previsao_final_ext = previsao_transformada_ext
+
+                previsoes_extrapoladas.append((df_previsao_ext, previsao_final_ext))
+
+        # Determinar a fundamentação da extrapolação
+        if fora_dos_criterios:
+            fundamentacao = "Fundamentação - Extrapolação (Item 4 (a) tab 9.2.1 NBR 14.653-2): Fora dos critérios"
+        elif contagem_extrapolacoes == 1:
+            fundamentacao = "Fundamentação - Extrapolação (Item 4 (a) tab 9.2.1 NBR 14.653-2): Grau II"
+        elif contagem_extrapolacoes > 1:
+            fundamentacao = "Fundamentação - Extrapolação (Item 4 (a) tab 9.2.1 NBR 14.653-2): Grau I"
+        else:
+            fundamentacao = ""
+
+        # Retornar as informações
+        resultado_texto = (
+            f"Valor estimado central: {locale.currency(previsao_final, grouping=True)}\n"
+            "------------------------------------\n"
+            f"Limite inferior do campo de arbítrio (- 15% do Valor estimado central): {locale.currency(limite_inferior_arbitrio, grouping=True)}\n"
+            f"Limite superior do campo de arbítrio (+ 15% do Valor estimado central): {locale.currency(limite_superior_arbitrio, grouping=True)}\n"
+            "------------------------------------\n"
+            f"Limite inferior do Intervalo de Confiança de 80%: {locale.currency(limite_inferior_ic, grouping=True)}\n"
+            f"Limite superior do Intervalo de Confiança de 80%: {locale.currency(limite_superior_ic, grouping=True)}\n"
+            "------------------------------------\n"
+            f"{extrapolacao_info.strip()}\n"
+            f"{fundamentacao}\n"
+        )
+        
+        
+        resultado_df = df_previsao
+        resultado_df_ext = pd.DataFrame()
+        resultado_texto_ext = ""
+        
+        if previsoes_extrapoladas:
+            for df_ext, previsao_ext in previsoes_extrapoladas:
+                resultado_df_ext = df_ext
+                resultado_texto_ext = (
+                    f"Valor estimado central (na fronteira amostral): {locale.currency(previsao_ext, grouping=True)}\n"
+                    "------------------------------------\n"
+                )
+                
+                # Cálculo da variação percentual
+                variacao_percentual = abs((previsao_final - previsao_ext) / previsao_final) * 100
+        
+                # Determinar a fundamentação com base na variação percentual
+                if variacao_percentual > 20:
+                    fundamentacao_ext = "Fundamentação - Extrapolação (Item 4 (b) tab 9.2.1 NBR 14.653-2): Fora dos critérios"
+                elif variacao_percentual > 15:
+                    fundamentacao_ext = "Fundamentação - Extrapolação (Item 4 (b) tab 9.2.1 NBR 14.653-2): Grau I"
+                else:
+                    fundamentacao_ext = "Fundamentação - Extrapolação (Item 4 (b) tab 9.2.1 NBR 14.653-2): Grau II"
+        
+                resultado_texto_ext += f"{fundamentacao_ext}\n"
+
+        return resultado_df, resultado_texto, resultado_df_ext, resultado_texto_ext
+
+    except Exception as e:
+        return pd.DataFrame(), "Erro ao realizar a previsão: {str(e)}", pd.DataFrame(), ""
+
+
+#--------------------------------------------INTERFACE-------------------------------------------#
+
+def rl_tab():
+    # Criação da aba
+    with gr.Tab("Regressão Linear"):
+        planilha_input = gr.File(label="Carregar Planilha", file_types=[".xls", ".xlsx"], elem_classes=["small-file-upload"])
+
+        with gr.Group():
+
+        #---------ESTADOS DE ARMAZENAMENTO-------------#
+
+            # Estado para armazenamentos
+            cabeçalhos_state = gr.State([])
+            dados_state = gr.State(pd.DataFrame())
+            escalas_state = gr.State({})
+            erro_padronizado_state = gr.State([])
+            # Estados para armazenar os gráficos Plotly gerados
+            grafico_residuos_state = gr.State(None)
+            grafico_histograma_state = gr.State(None)
+            grafico_ajustados_state = gr.State(None)
+            matriz_corr_state = gr.State(None)
+            # Estado para armazenar o modelo gerado
+            modelo_state = gr.State(None)
+
+        #---------PLANILHA DE ENTRADA-------------#
+
+            # Checkbox para controlar a visibilidade da planilha carregada
+            mostrar_planilha = gr.Checkbox(label="MOSTRAR PLANILHA CARREGADA e GRÁFICOS PARA ANÁLISE EXPLORATÓRIA   (Os gráficos de dispersão e boxplot são atualizados com a retirada de dados)", value=False)
+            tabela_planilha = gr.Dataframe(visible=False, max_height=250, elem_classes=["small span"])  # Oculto por padrão
+
+        #---------GRÁFICOS DE DISPERSÃO-------------#
+
+            # Gráficos de dispersão
+            with gr.Row(equal_height=True):
+                coluna_y_dispersao = gr.Dropdown(label="Eixo Y (Dispersão)", choices=[], interactive=True, visible=False, scale=3)
+                transformacao_y = gr.Dropdown(
+                    label="Transformação para Eixo Y",
+                    choices=["Nenhuma", "1/x", "ln(x)", "x²", "exp(x)"],
+                    value="Nenhuma",
+                    interactive=True,
+                    visible=False,
+                    scale=2
+                )
+                coluna_x_dispersao = gr.Dropdown(label="Eixo X (Dispersão)", choices=[], interactive=True, visible=False, scale=3)
+                transformacao_x = gr.Dropdown(
+                    label="Transformação para Eixo X",
+                    choices=["Nenhuma", "1/x", "ln(x)", "x²", "exp(x)"],
+                    value="Nenhuma",
+                    interactive=True,
+                    visible=False,
+                    scale=2
+                )
+                # Adicionando os gráficos de dispersão e boxplot lado a lado com o mesmo botão
+                botao_dispersao_boxplot = gr.Button("Gerar Gráficos de Dispersão e Boxplot", visible=False)
+            with gr.Row():
+                grafico_dispersao_saida = gr.Plot(label="Gráfico de Dispersão", visible=False, scale=3)
+                grafico_boxplot_saida = gr.Plot(label="Gráfico Boxplot", visible=False, scale=1)
+
+        #---------ESCOLHA DAS VARIÁVEIS-------------#
+
+        # Checkbox para controlar a visibilidade dos dropdowns
+        mostrar_dropdowns = gr.Checkbox(label="VARIÁVEIS E ESCALAS   (Variável dependente e variáveis independentes)", value=False, elem_classes="checkbox-yellow")
+        # Dropdown multi-select para cabeçalhos
+        # Título do conjunto
+        with gr.Group():
+            var_ind = gr.Markdown("Selecione as variáveis desejadas no dropdown da escala para a transformação", visible=False)  # Adiciona um título ao grupo de dropdowns
+            with gr.Row():
+                colunas_x = gr.Dropdown(label="(Direta: y ou x)", multiselect=True, choices=[], value=[], interactive=True, visible=False)
+                colunas_ln_x = gr.Dropdown(label="Logarítmica: ln(y) ou ln(x)", multiselect=True, choices=[], interactive=True, visible=False)
+                colunas_exp_x = gr.Dropdown(label="Exponencial: exp(y) ou exp(x)", multiselect=True, choices=[], interactive=True, visible=False)
+                colunas_inv_x = gr.Dropdown(label="Inversa: 1/(y) ou 1/(x)", multiselect=True, choices=[], interactive=True, visible=False)
+                colunas_quad_x = gr.Dropdown(label="Quadrática: (x)² ou (y²) ", multiselect=True, choices=[], interactive=True, visible=False)
+        # Escolha da variável dependente
+        var_dep = gr.Dropdown(label="Variável Dependente", multiselect=False, choices=[], interactive=True, visible=False)
+
+        #---------DATAFRAMES-------------#
+
+        with gr.Row(equal_height=True):
+            # Botão para gerar DataFrames
+            botao_gerar_df = gr.Button("Gerar Planilhas", scale=1)
+            # Checkbox para controlar visibilidade dos DataFrames gerados
+            mostrar_dataframes = gr.Checkbox(label="MOSTRAR PLANILHAS   (Escalas e limites, Variáveis transformadas e Outliers)", value=False, scale=3)
+        # DataFrames para visualização
+        tabela_cabecalhos = gr.Dataframe(label="Planilha com Cabeçalhos, Escalas, Máximo, Mínimo e Média das variáveis utilizadas", max_height=200, visible=False, elem_classes=["small span"])
+        tabela_original = gr.Dataframe(label="Planilha original com Variáveis Escolhidas", max_height=250, visible=False, elem_classes=["small span"])
+        tabela_escalada = gr.Dataframe(label="Planilha com Variáveis Transformadas", max_height=250, visible=False, interactive=True, headers=None, elem_classes=["small span"])
+        #matriz_correl = gr.Dataframe(label="Matriz de correlações", max_height=250, visible=False, interactive=True, headers=None, elem_classes=["small span"])
+        df_out = gr.Dataframe(label="Outliers", max_height=150, visible=False, interactive=True, headers=None, elem_classes=["small span"])
+
+        #---------MODELO-------------#
+
+        with gr.Row(equal_height=True):
+            # Adicionando botão para executar a regressão
+            botao_regressao = gr.Button("Gerar Modelo", scale=1)
+            # Checkbox para visualizar os resultados
+            mostrar_resultados = gr.Checkbox(label="REGRESSÃO LINEAR   (Resultados gerais e por variável, Resíduos > 2 e Pontos Influenciantes, Valores calculados x valores observados)", value=False, scale=3)
+        # Resultados gerais e por variáveis
+        with gr.Row():
+            resultado_geral = gr.Textbox(label="Resultados Gerais", lines=25, interactive=False, visible=False, scale=1)
+            resultado_coef = gr.Dataframe(label="Resultados por Variável", interactive=False, visible=False, scale=1, elem_classes=["small span"])
+        # Resíduos (dataframe e listagem)
+        residuos = gr.Dataframe(label="Resíduos padronizados > 2", interactive=False, max_height=250, visible=False, scale=1, elem_classes=["small span"])
+        with gr.Row():
+            # Resíduos > 2
+            residuos_list = gr.Textbox(label="Listagem resíduos padronizados > 2", lines=2, interactive=False, visible=False, scale=2)
+            # Pontos influenciantes
+            pontos_inf = gr.Textbox(label="Listagem dos Pontos Influenciantes", lines=2, interactive=False, visible=False, scale=1)
+            # Entrada dinâmica
+            entrada_dinamica = gr.Textbox(label="Retirar dados", lines=2, placeholder="Copie e cole os dados da caixa de texto ao lado ou escolha o dado a ser retirado",
+                interactive=True, visible=False, scale=2)
+
+        # Adicionando a visualização para df_calc_obs
+        calc_obs = gr.Dataframe(label="Calculados x Observados", max_height=250, visible=False, interactive=True, headers=None, elem_classes=["small span"])
+        calc_obs_trans = gr.Dataframe(label="Calculados Transformados", max_height=250, visible=False, interactive=True, elem_classes=["small span"])
+
+        #---------GRÁFICOS DO MODELO-------------#
+
+        with gr.Row(equal_height=True):
+            # Adicionar botão para gerar gráficos
+            botao_graficos = gr.Button("Gerar Gráficos", scale=1)
+            # Checkbox para controlar a visibilidade da seção de gráficos do modelo
+            mostrar_graficos = gr.Checkbox(label="GRÁFICOS DO MODELO   (Resíduos padronizados, histograma e valores ajustados vs observados, Matriz de Correlações)", value=False, scale=3)
+        # Escolha a escala da variável dependente para o gráfico Ajustados x Observado
+        escala_graf_ao = gr.Dropdown(label="Escolha a escala da variável dependente para o gráfico Valores Ajustados x Observado", choices=["Transformada", "Direta"])
+
+        # Adicionar rádio para selecionar o gráfico
+        grafico_selecao = gr.Radio(
+            choices=["Resíduos Padronizados", "Histograma", "Valores Ajustados vs Observados", "Matriz de Correlações"],
+            label="Selecione o Gráfico",
+            interactive=True,
+            visible=False
+        )
+
+        # Adicionar saída para o gráfico selecionado
+        grafico_saida = gr.Plot(label="Gráfico Selecionado", visible=False)
+
+        #---------EXPORTAR PARA O EXCEL-------------#
+
+        with gr.Row(equal_height=True):
+            botao_exportar_excel = gr.Button("Exportar Planilha")
+            arquivo_excel = gr.File(label="Baixar Excel", interactive=False, visible=False)
+
+        #---------SALVAR MODELO-------------#
+
+        with gr.Row(equal_height=True):
+            # Adicionar campo de entrada para o nome do arquivo
+            nome_arquivo_modelo = gr.Textbox(
+                label="Nome do Arquivo do Modelo",
+                placeholder="Digite o nome do modelo e clique no botão ao lado para salvar",
+                interactive=True,
+                scale=3
+            )
+            # Adicionar botão "SALVAR MODELO" e output para indicar o sucesso/erro
+            botao_salvar_modelo = gr.Button("Salvar Modelo", scale=1)
+        saida_salvar_modelo = gr.Textbox(
+            label="Status do Salvamento do Modelo",
+            interactive=False,
+            visible=False,
+            lines=2
+        )
+
+        #---------CARREGAR MODELO-------------#
+
+        with gr.Row(equal_height=True):
+           # Entrada para carregar o modelo
+            modelo_input = gr.File(label="Carregar Modelo", file_types=[".avse"], elem_classes=["small-file-upload"])
+            # Botão para carregar o modelo
+            botao_carregar_modelo = gr.Button("Visualizar Modelo")
+            # Checkbox abaixo do botão "Visualizar Modelo"
+            mostrar_modelo_checkbox = gr.Checkbox(
+                label="MOSTRAR DETALHES DO MODELO",
+                value=False,
+                elem_classes=["checkbox-yellow"]
+            )
+        # Mensagem de status para aparecer logo abaixo do modelo_input
+        status_carregamento = gr.Textbox(
+            label="Status do Carregamento do Modelo",
+            interactive=False,
+            visible=False,  # Certifique-se de que está visível
+            lines=1,
+            elem_classes=["small span"]
+        )
+
+        # TextBox para exibir os resultados gerais
+        resultado_geral_carregado = gr.Textbox(
+            label="Resultados Gerais (Carregados)",
+            interactive=False,
+            visible=False,
+            lines=25,  # Ajuste o número de linhas conforme necessário
+            elem_classes=["small span"]
+        )
+
+        # DataFrames para exibição
+        tabela_planilha_carregada = gr.Dataframe(label="Dados Originais", visible=False, max_height=250, elem_classes=["small span"])
+        tabela_original_carregada = gr.Dataframe(label="Dados Modelo", visible=False, max_height=250, elem_classes=["small span"])
+        tabela_outliers_carregada = gr.Dataframe(label="Outliers", visible=False, max_height=250, elem_classes=["small span"])
+        tabela_resultados_vars_carregada = gr.Dataframe(label="Resultados Variáveis", visible=False, max_height=250, elem_classes=["small span"])
+        tabela_calc_obs_carregada = gr.Dataframe(label="Calculados x Observados", visible=False, max_height=250, elem_classes=["small span"])
+        tab_infos_carregada = gr.Dataframe(label="Variáveis, escalas, limites e avaliando", interactive=True, visible=False, elem_classes=["small span"])
+
+        #---------AVALIAÇÃO-------------#
+
+        botao_previsao = gr.Button("Realizar Previsão")
+        tabela_previsao = gr.Dataframe(label="Valores Transformados para Previsão", visible=True, max_height=250)
+        previsao_saida = gr.Textbox(label="Resultado da Previsão", lines=8, interactive=False, visible=True)
+
+        # Adicionar DataFrames para exibir os resultados das previsões ajustadas
+        tabela_previsao_ajustada = gr.Dataframe(label="Valores Transformados para Previsão Ajustada", visible=True, max_height=250)
+        previsao_ajustada_saida = gr.Textbox(label="Resultado da Previsão Ajustada", lines=8, interactive=False, visible=True)
+
+        # 1. CONTROLE DE VISIBILIDADE
+
+        # 1.1. Mostrar ou ocultar a planilha carregada e os gráficos
+        mostrar_planilha.change(
+            lambda visible, dados: [gr.update(visible=visible, value=dados)] * 8,
+            inputs=[mostrar_planilha, dados_state],
+            outputs=[
+                tabela_planilha, coluna_y_dispersao, transformacao_y, coluna_x_dispersao,
+                transformacao_x, botao_dispersao_boxplot,
+                grafico_dispersao_saida, grafico_boxplot_saida
+            ]
+        )
+
+        # 1.2. Mostrar ou ocultar os dropdowns para escolha de variáveis transformadas
+        mostrar_dropdowns.change(
+            lambda visible: [gr.update(visible=visible)] * 7,
+            inputs=[mostrar_dropdowns],
+            outputs=[var_ind, colunas_x, colunas_ln_x, colunas_exp_x, colunas_inv_x, colunas_quad_x, var_dep]
+        )
+
+        # 1.3. Mostrar ou ocultar os DataFrames gerados (cabeçalhos, escalas, correlação, etc.)
+        mostrar_dataframes.change(
+            lambda visible: [gr.update(visible=visible)] * 3,
+            inputs=[mostrar_dataframes],
+            outputs=[tabela_cabecalhos, tabela_escalada, df_out] #matriz_correl,
+        )
+
+        # 1.4. Mostrar ou ocultar os resultados da regressão (resultados gerais, resíduos, etc.)
+        mostrar_resultados.change(
+            lambda visible: [gr.update(visible=visible)] * 7,
+            inputs=[mostrar_resultados],
+            outputs=[resultado_geral, resultado_coef, residuos, residuos_list, pontos_inf, entrada_dinamica, calc_obs]
+        )
+
+        # 1.5. Mostrar ou ocultar a seção de gráficos e componentes associados
+        mostrar_graficos.change(
+            lambda visible: [gr.update(visible=visible)] * 2,
+            inputs=[mostrar_graficos],
+            outputs=[grafico_selecao, grafico_saida]
+        )
+
+        # 1.6. Mostrar ou ocultar os detalhes do modelo carregado
+        mostrar_modelo_checkbox.change(
+            lambda visible: [gr.update(visible=visible)] * 8,
+            inputs=[mostrar_modelo_checkbox],
+            outputs=[
+                resultado_geral_carregado, tabela_planilha_carregada, tabela_original_carregada,
+                tabela_outliers_carregada, tabela_resultados_vars_carregada, tabela_calc_obs_carregada,
+                tab_infos_carregada, status_carregamento
+            ]
+        )
+
+        # 2. CARREGAMENTO DE PLANILHA E ATUALIZAÇÃO DE DADOS
+
+        # 2.1. Carregar a planilha e extrair cabeçalhos e dados
+        planilha_input.change(
+            lambda file: carregar_planilha(file),
+            inputs=[planilha_input],
+            outputs=[cabeçalhos_state, dados_state]
+        )
+
+        # 2.2. Atualizar as opções de dropdown para o gráfico de dispersão ao carregar uma planilha
+        cabeçalhos_state.change(
+            lambda cabecalhos: [gr.update(choices=cabecalhos, value=None)] * 2,
+            inputs=[cabeçalhos_state],
+            outputs=[coluna_y_dispersao, coluna_x_dispersao]
+        )
+
+        # 2.3. Atualizar os dropdowns para transformações e seleção de variáveis dependentes/independentes
+        cabeçalhos_state.change(
+            atualizar_dropdowns,
+            inputs=[cabeçalhos_state],
+            outputs=[colunas_x, colunas_ln_x, colunas_exp_x, colunas_inv_x, colunas_quad_x, var_dep]
+        )
+
+        # 2.4. Atualizar o gráfico exibido com base na seleção do usuário
+        grafico_selecao.change(
+            lambda escala, selecao, fig1, fig2, fig3, fig4: (
+                fig1 if selecao == "Resíduos Padronizados" else
+                (fig2 if selecao == "Histograma" else
+                (fig3 if selecao == "Valores Ajustados vs Observados" else fig4))
+            ),
+            inputs=[escala_graf_ao, grafico_selecao, grafico_residuos_state, grafico_histograma_state, grafico_ajustados_state, matriz_corr_state],
+            outputs=[grafico_saida]
+        )
+
+        # 3. BOTÕES
+        # 3.1. Botão para conectar à função de Gerar os gráficos de dispersão e boxplot (GERAR DISPERSÃO E BOXPLOT)
+        botao_dispersao_boxplot.click(
+            lambda df, y_coluna, transformacao_y, x_coluna, transformacao_x, dados_out: (
+                grafico_dispersao(df, y_coluna, transformacao_y, x_coluna, transformacao_x, dados_out),
+                grafico_boxplot(df, y_coluna, transformacao_y, x_coluna, transformacao_x, dados_out)
+            ),
+            inputs=[dados_state, coluna_y_dispersao, transformacao_y, coluna_x_dispersao, transformacao_x, entrada_dinamica],
+            outputs=[grafico_dispersao_saida, grafico_boxplot_saida]
+        )
+
+        # 3.2. Botão para conectar à função de Gerar os dataframes cabeçalhos, escalas e estatísticas básicas (máximo, mínimo, média) e
+        # transformados, escalados e correlação (GERAR PLANILHAS)
+        botao_gerar_df.click(
+            criar_dataframe_cabecalhos,
+            inputs=[cabeçalhos_state, colunas_x, colunas_ln_x, colunas_exp_x, colunas_inv_x, colunas_quad_x, dados_state, entrada_dinamica, var_dep],
+            outputs=[tabela_cabecalhos, escalas_state]
+        )
+
+        botao_gerar_df.click(
+            criar_dataframes,
+            inputs=[dados_state, colunas_x, colunas_ln_x, colunas_exp_x, colunas_inv_x, colunas_quad_x, entrada_dinamica, var_dep],
+            outputs=[tabela_original, tabela_escalada, df_out]  # , matriz_correl
+        )
+
+        # 3.3. Botão para conectar à função de realizar regressão linear com base nas variáveis selecionadas (GERAR MODELO)
+        botao_regressao.click(
+            realizar_regressao,
+            inputs=[var_dep, tabela_escalada, tabela_original, escalas_state],
+            outputs=[resultado_geral, resultado_coef, residuos, residuos_list, pontos_inf, calc_obs, calc_obs_trans,
+                    erro_padronizado_state, modelo_state]
+        )
+
+        # 3.4. Botão para conectar à função de Gerar gráficos do modelo (GERAR GRÁFICOS - resíduos, histograma, ajustados vs observados)
+        botao_graficos.click(
+            graficos,  # Função que gera os gráficos Plotly
+            inputs=[escala_graf_ao, calc_obs, calc_obs_trans, erro_padronizado_state, var_dep],
+            outputs=[grafico_residuos_state, grafico_histograma_state, grafico_ajustados_state, matriz_corr_state]
+        )
+
+        # 3.5. Botão para conectar à função de exportar para o excel (EXPORTAR PLANILHA)
+        botao_exportar_excel.click(
+            lambda df_planilha, df_infos, df_original, df_escalado, df_out, resultados_gerais, resultados_vars, df_calc_obs, df_calc_obs_trans: (
+                "resultado.xlsx",
+                exportar_para_excel(
+                    "resultado.xlsx", df_planilha, df_infos, df_original, df_escalado, df_out,
+                    resultados_gerais, resultados_vars, df_calc_obs, df_calc_obs_trans
+                )
+            )[0],
+            inputs=[
+                dados_state, tabela_cabecalhos, tabela_original, tabela_escalada, df_out,
+                resultado_geral, resultado_coef, calc_obs, calc_obs_trans
+            ],
+            outputs=[arquivo_excel]
+        )
+        # Atualizar visibilidade do status após clique no botão
+        botao_exportar_excel.click(
+            lambda *args: gr.update(visible=True),
+            inputs=[],
+            outputs=[arquivo_excel]
+        )
+
+        # 3.6. Botão para conectar à função de salvar o modelo (SALVAR MODELO)
+        botao_salvar_modelo.click(
+            lambda nome_arquivo, modelo, resultados_gerais, df_planilha, df_infos, df_original, df_outliers, resultados_vars, df_calc_obs: (
+                exportar_modelo_completo_avse(
+                    nome_arquivo, modelo, resultados_gerais, df_planilha, df_infos, df_original,
+                    df_outliers, resultados_vars, df_calc_obs
+                )
+            ),
+            inputs=[
+                nome_arquivo_modelo, modelo_state, resultado_geral, dados_state, tabela_cabecalhos,
+                tabela_original, df_out, resultado_coef, calc_obs
+            ],
+            outputs=[saida_salvar_modelo]
+        )
+        # Atualizar visibilidade do status após clique no botão
+        botao_salvar_modelo.click(
+            lambda: gr.update(visible=True),
+            inputs=[],
+            outputs=[saida_salvar_modelo]
+        )
+
+        # 3.7. Botão para conectar à função de carregamento do modelo (VISUALIZAR MODELO)
+        botao_carregar_modelo.click(
+            carregar_modelo,
+            inputs=[modelo_input],
+            outputs=[
+                status_carregamento,  # Mensagem de status aparece logo abaixo da caixa de upload
+                modelo_state,         # Estado para armazenar o modelo carregado
+                resultado_geral_carregado,
+                tabela_planilha_carregada, tabela_original_carregada, tabela_outliers_carregada,
+                tabela_resultados_vars_carregada, tabela_calc_obs_carregada, tab_infos_carregada
+            ]
+        )
+
+        # 3.8. Botão para conectar à função de realizar previsões (REALIZAR PREVISÃO)
+        botao_previsao.click(
+            realizar_previsoes,
+            inputs=[modelo_state, tab_infos_carregada],
+            outputs=[tabela_previsao, previsao_saida, tabela_previsao_ajustada, previsao_ajustada_saida]
+        )
+
+    return locals()
+
+
+### Pontos de máximo e mínimo
+### Colunas com Coordenadas (ter a possibilidade de dizer se há ou não coordenadas para criar uma dispesão espacial)
+### Endereços
+### Colunas que possuem valor 0, não podem ser utilizados na ln ou inversa (mensagem de erro?)
+### Micronumerosidade
+### Média, mediana e moda
+### Problema no ordenamento dos dataframes
+### Implementar avaliação em massa
+### Implementar relatório em word
+### Conectar a elaboração do modelo com o carregamento

modules/shared_state.py

@@ -0,0 +1,3 @@
+state = {}
+
+

modules/utils.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Nov 22 11:36:45 2024
+
+@author: fernando.schwartzer
+"""
+import pandas as pd
+from .shared_state import state
+
+def create_new_dataframe_with_index_and_value_unit(file, sheet_name, selected_columns, add_index, calculate_unit_value, col_value, col_area):
+    if file is None or not sheet_name or not selected_columns:
+        return pd.DataFrame({"Erro": ["Carregue um arquivo, selecione uma aba e colunas."]})
+    
+    # Carrega o DataFrame da aba especificada
+    df = pd.read_excel(file.name, sheet_name=sheet_name)
+    
+    # Seleciona apenas as colunas especificadas
+    new_df = df[selected_columns]
+    
+    # Adiciona um índice se necessário
+    if add_index:
+        new_df.insert(0, "Índice", range(1, len(new_df) + 1))
+    
+    # Renomeia e formata a coluna de valor total
+    if col_value:
+        new_df.rename(columns={col_value: "Valor Total"}, inplace=True)
+        new_df["Valor Total"] = new_df["Valor Total"].round(2)
+        cols = new_df.columns.tolist()
+        cols.insert(1, cols.pop(cols.index("Valor Total")))
+        new_df = new_df[cols]
+    
+    # Calcula o valor unitário se necessário
+    if calculate_unit_value and col_value and col_area:
+        try:
+            new_df["Valor Unitário"] = (new_df["Valor Total"] / new_df[col_area]).round(2)
+            cols = new_df.columns.tolist()
+            cols.insert(2, cols.pop(cols.index("Valor Unitário")))
+            new_df = new_df[cols]
+        except ZeroDivisionError:
+            new_df["Valor Unitário"] = "Erro: Divisão por zero"
+        except KeyError:
+            new_df["Valor Unitário"] = "Erro: Coluna inválida"
+    
+    # Salva o novo DataFrame no estado compartilhado
+    new_df.columns = new_df.columns.map(str)
+    state['new_df'] = new_df  
+    return new_df