Update app.py

app.py

@@ -2,28 +2,18 @@ import gradio as gr
 import pandas as pd
 import geopandas as gpd
 
-# --------------------------------------------------
-# Carregamento único dos eixos (feito uma vez)
-# --------------------------------------------------
+# 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")}
 
-# Pré-agrupamento para evitar filtro a cada linha
-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
@@ -31,437 +21,164 @@ 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()
-
-    # Criar versão upper para comparação
     colunas_upper = {col.upper(): col for col in colunas}
 
-    # -----------------------------------
-    # Pré-seleção CDLOG
-    # -----------------------------------
-    coluna_cdlog_pre = None
-
-    if "CTM" in colunas_upper:
-        coluna_cdlog_pre = colunas_upper["CTM"]
-    elif "CDLOG" in colunas_upper:
-        coluna_cdlog_pre = colunas_upper["CDLOG"]
-
-    # -----------------------------------
-    # Pré-seleção Número
-    # -----------------------------------
-    coluna_num_pre = None
-
-    prioridades_num = ["Nº GEO", "NUM_GEO", "NUM"]
-
-    for nome in prioridades_num:
-        if nome.upper() in colunas_upper:
-            coluna_num_pre = colunas_upper[nome.upper()]
-            break
-
-    return (
-        gr.update(choices=colunas, value=coluna_cdlog_pre),
-        gr.update(choices=colunas, value=coluna_num_pre),
-    )
+    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)
 
+    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)
-
-    # Criar índice técnico estável
     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)
-
     texto = f"O DataFrame possui {df.shape[0]} linhas e {df.shape[1]} colunas."
     return formatar_float_visualizacao(df), texto
 
-def gerar_sugestoes(segmentos, numero):
-
-    if segmentos is None or segmentos.empty:
-        return ""
-
-    linha = segmentos.iloc[0]
-
-    if numero % 2 == 0:
-        ini = linha["NRPARINI"]
-        fim = linha["NRPARFIN"]
-    else:
-        ini = linha["NRIMPINI"]
-        fim = linha["NRIMPFIN"]
-
-    if pd.isna(ini) or pd.isna(fim):
-        return ""
-
-    numeros_validos = list(range(int(ini), int(fim) + 1, 2))
-
-    # limitar quantidade
-    sugestoes = numeros_validos[:20]
-
-    return ", ".join(map(str, sugestoes))
-
-
-# --------------------------------------------------
-# Motor de 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)
 
-    lons = []
-    lats = []
-    falhas = []
+    lons, lats, falhas = [], [], []
 
     for _, row in df.iterrows():
-
-        idx = row["_idx"]
-        cdlog = row[coluna_cdlog]
-        numero = row[coluna_num]
-
+        idx, cdlog, numero = row["_idx"], row[coluna_cdlog], row[coluna_num]
         segmentos = eixos_por_cdlog.get(cdlog)
 
-        # --------------------------------------------------
-        # CDLOG não encontrado
-        # --------------------------------------------------
         if segmentos is None:
-
             lons.append(None)
             lats.append(None)
-
             falhas.append({
                 "_idx": idx,
                 "CDLOG": cdlog,
                 "Numero Atual": numero,
                 "Motivo": "CDLOG não encontrado",
-                "Sugestões": "",
-                "Novo Número": None
+                "Lado": "",
+                "Intervalo": "",
+                "Sugestões": []
             })
             continue
 
-        # --------------------------------------------------
-        # Verificar lado par / ímpar
-        # --------------------------------------------------
-        if numero % 2 == 0:
-            cond = (segmentos["NRPARINI"] <= numero) & (segmentos["NRPARFIN"] >= numero)
-            ini_col = "NRPARINI"
-            fim_col = "NRPARFIN"
-        else:
-            cond = (segmentos["NRIMPINI"] <= numero) & (segmentos["NRIMPFIN"] >= numero)
-            ini_col = "NRIMPINI"
-            fim_col = "NRIMPFIN"
-
+        lado = "Par" if numero % 2 == 0 else "Ímpar"
+        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]
 
-        # # --------------------------------------------------
-        # # Número fora do intervalo
-        # # --------------------------------------------------
-        # if seg_validos.empty:
-        
-        #     sugestao_formatada = ""
-        
-        #     if not segmentos.empty:
-        
-        #         if numero % 2 == 0:
-        #             diffs = (segmentos["NRPARINI"] - numero).abs()
-        #             ini_col = "NRPARINI"
-        #             fim_col = "NRPARFIN"
-        #         else:
-        #             diffs = (segmentos["NRIMPINI"] - numero).abs()
-        #             ini_col = "NRIMPINI"
-        #             fim_col = "NRIMPFIN"
-        
-        #         if not diffs.empty:
-        #             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):
-        #                 sugestao_formatada = f"Intervalo válido: {int(ini)} até {int(fim)}"
-        
-        #     lons.append(None)
-        #     lats.append(None)
-        
-        #     falhas.append({
-        #         "_idx": idx,
-        #         "CDLOG": cdlog,
-        #         "Numero Atual": numero,
-        #         "Motivo": "Numeração fora do intervalo",
-        #         "Sugestões": sugestao_formatada,
-        #         "Novo Número": None
-        #     })
-        
-        #     continue
-
-        # --------------------------------------------------
-        # Número fora do intervalo
-        # --------------------------------------------------
         if seg_validos.empty:
-        
-            sugestoes_lista = []
-            lado = "Par" if numero % 2 == 0 else "Ímpar"
-            intervalo_texto = ""
-        
             if not segmentos.empty:
-        
-                if numero % 2 == 0:
-                    diffs = (segmentos["NRPARINI"] - numero).abs()
-                    ini_col = "NRPARINI"
-                    fim_col = "NRPARFIN"
-                else:
-                    diffs = (segmentos["NRIMPINI"] - numero).abs()
-                    ini_col = "NRIMPINI"
-                    fim_col = "NRIMPFIN"
-        
+                diffs = (segmentos[ini_col] - numero).abs()
                 if not diffs.empty:
                     min_index = diffs.idxmin()
                     linha_proxima = segmentos.loc[min_index]
-        
-                    ini = linha_proxima[ini_col]
-                    fim = linha_proxima[fim_col]
-        
+                    ini, fim = linha_proxima[ini_col], linha_proxima[fim_col]
                     if pd.notna(ini) and pd.notna(fim):
-        
-                        intervalo_texto = f"{int(ini)} até {int(fim)}"
-        
                         numeros_validos = list(range(int(ini), int(fim) + 1, 2))
                         numeros_validos.sort(key=lambda x: abs(x - numero))
-                        sugestoes_lista = numeros_validos[:10]
-        
+                        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
             lons.append(None)
             lats.append(None)
-        
             falhas.append({
                 "_idx": idx,
                 "CDLOG": cdlog,
                 "Numero Atual": numero,
                 "Motivo": "Numeração fora do intervalo",
                 "Lado": lado,
-                "Intervalo": intervalo_texto,
-                "Sugestões": sugestoes_lista,
+                "Intervalo": "",
+                "Sugestões": []
             })
-        
             continue
 
-        # --------------------------------------------------
-        # Interpolação válida
-        # --------------------------------------------------
         linha = seg_validos.iloc[0]
         geom = linha.geometry
-
-        ini = linha[ini_col]
-        fim = linha[fim_col]
-
+        ini, fim = linha[ini_col], 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)
 
-    # --------------------------------------------------
-    # Atualizar dataframe principal
-    # --------------------------------------------------
     df["lon"] = lons
     df["lat"] = lats
-
     output_path = "dados_interpolados.xlsx"
     df.to_excel(output_path, index=False)
 
-    # --------------------------------------------------
-    # Garantir estrutura fixa das falhas
-    # --------------------------------------------------
-    # colunas_fixas = [
-    #     "_idx",
-    #     "CDLOG",
-    #     "Numero Atual",
-    #     "Motivo",
-    #     "Sugestões",
-    #     "Novo Número"
-    # ]
-
-    colunas_fixas = [
-        "_idx",
-        "CDLOG",
-        "Numero Atual",
-        "Motivo",
-        "Lado",
-        "Intervalo",
-        "Sugestões"
-    ]
-
-    if len(falhas) == 0:
-        df_falhas = pd.DataFrame(columns=colunas_fixas)
-    else:
-        df_falhas = pd.DataFrame(falhas)
-        df_falhas = df_falhas[colunas_fixas]
+    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)
 
     return formatar_float_visualizacao(df), output_path, df_falhas
 
-# --------------------------------------------------
-# Preparar sugestões
-# --------------------------------------------------
-
-def preparar_sugestoes(df_falhas, evt: gr.SelectData):
-
+def preparar_sugestoes(df_falhas, evt):
     linha = df_falhas.iloc[evt.index[0]]
-
     idx = linha["_idx"]
     lado = linha.get("Lado", "")
     intervalo = linha.get("Intervalo", "")
     sugestoes = linha.get("Sugestões", [])
-
-    # 🔴 CORREÇÃO AQUI
     if isinstance(sugestoes, str):
         sugestoes = [int(x.strip()) for x in sugestoes.split(",") if x.strip().isdigit()]
+    return idx, lado, intervalo, gr.update(choices=sugestoes, value=None)
 
-    if not isinstance(sugestoes, list):
-        sugestoes = []
-
-    return (
-        idx,
-        lado,
-        intervalo,
-        gr.update(choices=sugestoes, value=None)
-    )
-
-# --------------------------------------------------
-# Aplicar Sugestões
-# --------------------------------------------------
 def aplicar_sugestao(df_original, idx, numero_escolhido, coluna_num):
-
     if numero_escolhido is None:
         return df_original
-
     df_original = df_original.copy()
-
     df_original.loc[df_original["_idx"] == idx, coluna_num] = int(numero_escolhido)
-
     return df_original
 
-# --------------------------------------------------
-# Aplicar Correções
-# --------------------------------------------------
-def aplicar_correcoes(df_original, df_falhas, coluna_num):
-
-    if df_falhas is None or df_falhas.empty:
-        return df_original
-
-    df_original = df_original.copy()
-
-    for _, row in df_falhas.iterrows():
-        if pd.notna(row["Novo Número"]):
-            idx = row["_idx"]
-            df_original.loc[df_original["_idx"] == idx, coluna_num] = int(row["Novo Número"])
-
-    return df_original
-
-
-
-# --------------------------------------------------
 # 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"])
     dropdown_abas = gr.Dropdown(label="Aba")
     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)
-
     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)
     radio_sugestoes = gr.Radio(label="Escolha o Número Correto")
     btn_aplicar_sugestao = gr.Button("Aplicar Sugestão")
-   
-
-    # =============================
-    # 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],
-        outputs=estado_tabela
-    ).then(
-        fn=lambda df: df,
-        inputs=estado_tabela,
-        outputs=tabela
-    ).then(
-        fn=interpolar,
-        inputs=[estado_tabela, dropdown_cdlog, dropdown_num],
-        outputs=[tabela_resultado, arquivo_saida, falhas]
-    )
 
+    # 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], outputs=estado_tabela).then(
+        fn=lambda df: df, inputs=estado_tabela, outputs=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)
+app.launch(server_name="0.0.0.0", server_port=7860)