Update app.py

app.py

@@ -2,18 +2,23 @@ import gradio as gr
 import pandas as pd
 import geopandas as gpd
 
+# ==============================
 # Carregamento único dos eixos
+# ==============================
 gdf_eixos = gpd.read_file("EixosLogradouros.shp", engine="fiona")
 gdf_eixos = gdf_eixos.to_crs("EPSG:4326")
 eixos_por_cdlog = {cdlog: grupo.copy() for cdlog, grupo in gdf_eixos.groupby("CDLOG")}
 
+# ==============================
 # Funções auxiliares
+# ==============================
 def formatar_float_visualizacao(df, casas=4):
     df_visual = df.copy()
     float_cols = df_visual.select_dtypes(include=["float"]).columns
     df_visual[float_cols] = df_visual[float_cols].round(casas)
     return df_visual
 
+
 def carregar_abas(arquivo_excel):
     if arquivo_excel is None:
         return gr.update(choices=[]), None
@@ -21,28 +26,49 @@ def carregar_abas(arquivo_excel):
     abas = xls.sheet_names
     return gr.update(choices=abas, value=abas[0]), abas[0]
 
+
 def listar_colunas(arquivo_excel, aba):
     if arquivo_excel is None or aba is None:
         return gr.update(choices=[]), gr.update(choices=[])
+
     df = pd.read_excel(arquivo_excel.name, sheet_name=aba)
     colunas = df.columns.tolist()
     colunas_upper = {col.upper(): col for col in colunas}
 
     coluna_cdlog_pre = colunas_upper.get("CTM", colunas_upper.get("CDLOG", None))
-    coluna_num_pre = next((colunas_upper[nome.upper()] for nome in ["Nº GEO", "NUM_GEO", "NUM"] if nome.upper() in colunas_upper), None)
+    coluna_num_pre = next(
+        (colunas_upper[nome.upper()] for nome in ["Nº GEO", "NUM_GEO", "NUM"]
+         if nome.upper() in colunas_upper),
+        None
+    )
+
+    return (
+        gr.update(choices=colunas, value=coluna_cdlog_pre),
+        gr.update(choices=colunas, value=coluna_num_pre),
+    )
 
-    return gr.update(choices=colunas, value=coluna_cdlog_pre), gr.update(choices=colunas, value=coluna_num_pre)
 
 def exibir_tabela(arquivo_excel, aba, coluna_num):
     if arquivo_excel is None or aba is None:
         return None, ""
+
     df = pd.read_excel(arquivo_excel.name, sheet_name=aba)
     df["_idx"] = range(len(df))
+
     if coluna_num in df.columns:
-        df[coluna_num] = pd.to_numeric(df[coluna_num], errors="coerce").fillna(0).astype(int)
+        df[coluna_num] = (
+            pd.to_numeric(df[coluna_num], errors="coerce")
+            .fillna(0)
+            .astype(int)
+        )
+
     texto = f"O DataFrame possui {df.shape[0]} linhas e {df.shape[1]} colunas."
     return formatar_float_visualizacao(df), texto
 
+
+# ==============================
+# INTERPOLAÇÃO
+# ==============================
 def interpolar(df, coluna_cdlog, coluna_num):
     df = df.copy()
     df[coluna_num] = pd.to_numeric(df[coluna_num], errors="coerce").fillna(0).astype(int)
@@ -50,7 +76,10 @@ def interpolar(df, coluna_cdlog, coluna_num):
     lons, lats, falhas = [], [], []
 
     for _, row in df.iterrows():
-        idx, cdlog, numero = row["_idx"], row[coluna_cdlog], row[coluna_num]
+        idx = row["_idx"]
+        cdlog = row[coluna_cdlog]
+        numero = row[coluna_num]
+
         segmentos = eixos_por_cdlog.get(cdlog)
 
         if segmentos is None:
@@ -68,70 +97,76 @@ def interpolar(df, coluna_cdlog, coluna_num):
             continue
 
         lado = "Par" if numero % 2 == 0 else "Ímpar"
-        ini_col, fim_col = ("NRPARINI", "NRPARFIN") if lado == "Par" else ("NRIMPINI", "NRIMPFIN")
+        ini_col, fim_col = (
+            ("NRPARINI", "NRPARFIN")
+            if lado == "Par"
+            else ("NRIMPINI", "NRIMPFIN")
+        )
+
         cond = (segmentos[ini_col] <= numero) & (segmentos[fim_col] >= numero)
         seg_validos = segmentos[cond]
 
         if seg_validos.empty:
             if not segmentos.empty:
                 diffs = (segmentos[ini_col] - numero).abs()
-                if not diffs.empty:
-                    min_index = diffs.idxmin()
-                    linha_proxima = segmentos.loc[min_index]
-                    ini, fim = linha_proxima[ini_col], linha_proxima[fim_col]
-                    if pd.notna(ini) and pd.notna(fim):
-                        numeros_validos = list(range(int(ini), int(fim) + 1, 2))
-                        numeros_validos.sort(key=lambda x: abs(x - numero))
-                        falhas.append({
-                            "_idx": idx,
-                            "CDLOG": cdlog,
-                            "Numero Atual": numero,
-                            "Motivo": "Numeração fora do intervalo",
-                            "Lado": lado,
-                            "Intervalo": f"{int(ini)} até {int(fim)}",
-                            "Sugestões": numeros_validos[:10]
-                        })
-                        lons.append(None)
-                        lats.append(None)
-                        continue
+                min_index = diffs.idxmin()
+                linha_proxima = segmentos.loc[min_index]
+
+                ini = linha_proxima[ini_col]
+                fim = linha_proxima[fim_col]
+
+                if pd.notna(ini) and pd.notna(fim):
+                    numeros_validos = list(range(int(ini), int(fim) + 1, 2))
+                    numeros_validos.sort(key=lambda x: abs(x - numero))
+
+                    falhas.append({
+                        "_idx": idx,
+                        "CDLOG": cdlog,
+                        "Numero Atual": numero,
+                        "Motivo": "Numeração fora do intervalo",
+                        "Lado": lado,
+                        "Intervalo": f"{int(ini)} até {int(fim)}",
+                        "Sugestões": numeros_validos[:10]
+                    })
+
             lons.append(None)
             lats.append(None)
-            falhas.append({
-                "_idx": idx,
-                "CDLOG": cdlog,
-                "Numero Atual": numero,
-                "Motivo": "Numeração fora do intervalo",
-                "Lado": lado,
-                "Intervalo": "",
-                "Sugestões": []
-            })
             continue
 
         linha = seg_validos.iloc[0]
         geom = linha.geometry
-        ini, fim = linha[ini_col], linha[fim_col]
+        ini = linha[ini_col]
+        fim = linha[fim_col]
+
         if fim == ini:
             lons.append(None)
             lats.append(None)
             continue
+
         frac = (numero - ini) / (fim - ini)
         frac = max(0, min(1, frac))
         ponto = geom.interpolate(geom.length * frac)
+
         lons.append(ponto.x)
         lats.append(ponto.y)
 
     df["lon"] = lons
     df["lat"] = lats
+
     output_path = "dados_interpolados.xlsx"
     df.to_excel(output_path, index=False)
 
     colunas_fixas = ["_idx", "CDLOG", "Numero Atual", "Motivo", "Lado", "Intervalo", "Sugestões"]
-    df_falhas = pd.DataFrame(falhas, columns=colunas_fixas) if falhas else pd.DataFrame(columns=colunas_fixas)
+    df_falhas = pd.DataFrame(falhas, columns=colunas_fixas)
 
     return formatar_float_visualizacao(df), output_path, df_falhas
 
+
+# ==============================
+# CORREÇÃO ASSISTIDA
+# ==============================
 def preparar_sugestoes(df_falhas, evt: gr.SelectData):
-    if df_falhas is None or evt is None or not hasattr(evt, "index") or not evt.index:
+    if df_falhas is None or evt is None or not evt.index:
         return None, "", "", gr.update(choices=[], value=None)
 
     linha = df_falhas.iloc[evt.index[0]]
@@ -142,25 +177,32 @@ def preparar_sugestoes(df_falhas, evt: gr.SelectData):
     sugestoes = linha.get("Sugestões", [])
 
     if isinstance(sugestoes, str):
-        sugestoes = [int(x.strip()) for x in sugestoes.split(",") if x.strip().isdigit()]
+        sugestoes = [
+            int(x.strip()) for x in sugestoes.split(",")
+            if x.strip().isdigit()
+        ]
 
     return idx, lado, intervalo, gr.update(choices=sugestoes, value=None)
-    
 
-def aplicar_sugestao(df_original, idx, numero_escolhido, coluna_num, df_falhas):
+
+# 🔥 ALTERAÇÃO PRINCIPAL AQUI
+def aplicar_sugestao(df_original, idx, numero_escolhido, coluna_num):
     if numero_escolhido is None:
-        return df_original, df_falhas
+        return df_original
+
     df_original = df_original.copy()
     df_original.loc[df_original["_idx"] == idx, coluna_num] = int(numero_escolhido)
 
-    # Remove a linha corrigida do DataFrame de falhas
-    df_falhas = df_falhas[df_falhas["_idx"] != idx]
+    return df_original
 
-    return df_original, df_falhas
 
-# Interface
+# ==============================
+# INTERFACE
+# ==============================
 with gr.Blocks() as app:
+
     gr.Markdown("## DAI - Geolocalização com Correção Assistida")
+
     estado_tabela = gr.State()
 
     arquivo = gr.File(label="Arquivo Excel", file_types=[".xlsx"])
@@ -168,12 +210,17 @@ with gr.Blocks() as app:
     linhas_info = gr.Textbox(label="Linhas e Colunas", interactive=False)
     dropdown_cdlog = gr.Dropdown(label="Coluna CDLOG")
     dropdown_num = gr.Dropdown(label="Coluna Número")
+
     tabela = gr.Dataframe(label="Tabela Original", interactive=False)
     btn_interpolar = gr.Button("Interpolar")
+
     tabela_resultado = gr.Dataframe(label="Com Coordenadas", interactive=False)
     arquivo_saida = gr.File(label="Arquivo Gerado")
-    falhas = gr.Dataframe(label="Falhas (Editar Novo Número)", interactive=True)
+
+    falhas = gr.Dataframe(label="Falhas", interactive=True)
+
     gr.Markdown("### Correção Assistida")
+
     idx_selecionado = gr.Number(visible=False)
     info_lado = gr.Textbox(label="Lado", interactive=False)
     info_intervalo = gr.Textbox(label="Intervalo Válido", interactive=False)
@@ -182,23 +229,42 @@ with gr.Blocks() as app:
 
     # Eventos
     arquivo.change(fn=carregar_abas, inputs=arquivo, outputs=[dropdown_abas, dropdown_abas])
-    dropdown_abas.change(fn=exibir_tabela, inputs=[arquivo, dropdown_abas, dropdown_num], outputs=[tabela, linhas_info]).then(
-        fn=lambda df: df, inputs=tabela, outputs=estado_tabela
-    ).then(fn=listar_colunas, inputs=[arquivo, dropdown_abas], outputs=[dropdown_cdlog, dropdown_num])
 
-    btn_interpolar.click(fn=interpolar, inputs=[tabela, dropdown_cdlog, dropdown_num], outputs=[tabela_resultado, arquivo_saida, falhas])
-    falhas.select(fn=preparar_sugestoes, inputs=[falhas], outputs=[idx_selecionado, info_lado, info_intervalo, radio_sugestoes])
-    btn_aplicar_sugestao.click(
-        fn=aplicar_sugestao,
-        inputs=[estado_tabela, idx_selecionado, radio_sugestoes, dropdown_num, falhas],
-        outputs=[estado_tabela, falhas]
+    dropdown_abas.change(
+        fn=exibir_tabela,
+        inputs=[arquivo, dropdown_abas, dropdown_num],
+        outputs=[tabela, linhas_info],
     ).then(
+        fn=lambda df: df,
+        inputs=tabela,
+        outputs=estado_tabela
+    ).then(
+        fn=listar_colunas,
+        inputs=[arquivo, dropdown_abas],
+        outputs=[dropdown_cdlog, dropdown_num]
+    )
+
+    btn_interpolar.click(
         fn=interpolar,
         inputs=[estado_tabela, dropdown_cdlog, dropdown_num],
         outputs=[tabela_resultado, arquivo_saida, falhas]
     )
 
+    falhas.select(
+        fn=preparar_sugestoes,
+        inputs=[falhas],
+        outputs=[idx_selecionado, info_lado, info_intervalo, radio_sugestoes]
+    )
 
+    btn_aplicar_sugestao.click(
+        fn=aplicar_sugestao,
+        inputs=[estado_tabela, idx_selecionado, radio_sugestoes, dropdown_num],
+        outputs=estado_tabela
+    ).then(
+        fn=interpolar,
+        inputs=[estado_tabela, dropdown_cdlog, dropdown_num],
+        outputs=[tabela_resultado, arquivo_saida, falhas]
+    )
 
 
 app.launch(server_name="0.0.0.0", server_port=7860)