Rename app_4.py to app.py

app_4.py → app.py

@@ -110,107 +110,6 @@ def gerar_sugestoes(segmentos, numero):
     return ", ".join(map(str, sugestoes))
 
 
-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 = []
-
-    for _, row in df.iterrows():
-
-        idx = row["_idx"]
-        cdlog = row[coluna_cdlog]
-        numero = row[coluna_num]
-
-        segmentos = eixos_por_cdlog.get(cdlog)
-
-        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
-            })
-            continue
-
-        if numero % 2 == 0:
-            cond = (segmentos["NRPARINI"] <= numero) & (segmentos["NRPARFIN"] >= numero)
-        else:
-            cond = (segmentos["NRIMPINI"] <= numero) & (segmentos["NRIMPFIN"] >= numero)
-
-        seg_validos = segmentos[cond]
-
-        if seg_validos.empty:
-
-            sugestoes = gerar_sugestoes(segmentos, numero)
-
-            lons.append(None)
-            lats.append(None)
-
-            falhas.append({
-                "_idx": idx,
-                "CDLOG": cdlog,
-                "Numero Atual": numero,
-                "Motivo": "Fora do intervalo",
-                "Sugestões": sugestoes,
-                "Novo Número": None
-            })
-            continue
-
-        linha = seg_validos.iloc[0]
-        geom = linha.geometry
-
-        if numero % 2 == 0:
-            ini = linha["NRPARINI"]
-            fim = linha["NRPARFIN"]
-        else:
-            ini = linha["NRIMPINI"]
-            fim = linha["NRIMPFIN"]
-
-        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)
-
-    # 🔴 GARANTIR ESTRUTURA FIXA
-    if len(falhas) == 0:
-        df_falhas = pd.DataFrame(columns=[
-            "_idx",
-            "CDLOG",
-            "Numero Atual",
-            "Motivo",
-            "Sugestões",
-            "Novo Número"
-        ])
-    else:
-        df_falhas = pd.DataFrame(falhas)[[
-            "_idx",
-            "CDLOG",
-            "Numero Atual",
-            "Motivo",
-            "Sugestões",
-            "Novo Número"
-        ]]
-
-    return formatar_float_visualizacao(df), output_path, df_falhas
-
-
 # --------------------------------------------------
 # Motor de Interpolação
 # --------------------------------------------------
@@ -263,12 +162,56 @@ def interpolar(df, coluna_cdlog, coluna_num):
 
         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:
         
-            sugestao_formatada = ""
+            sugestoes_lista = []
+            lado = "Par" if numero % 2 == 0 else "Ímpar"
+            intervalo_texto = ""
         
             if not segmentos.empty:
         
@@ -289,7 +232,12 @@ def interpolar(df, coluna_cdlog, coluna_num):
                     fim = linha_proxima[fim_col]
         
                     if pd.notna(ini) and pd.notna(fim):
-                        sugestao_formatada = f"Intervalo válido: {int(ini)} até {int(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]
         
             lons.append(None)
             lats.append(None)
@@ -299,8 +247,9 @@ def interpolar(df, coluna_cdlog, coluna_num):
                 "CDLOG": cdlog,
                 "Numero Atual": numero,
                 "Motivo": "Numeração fora do intervalo",
-                "Sugestões": sugestao_formatada,
-                "Novo Número": None
+                "Lado": lado,
+                "Intervalo": intervalo_texto,
+                "Sugestões": sugestoes_lista,
             })
         
             continue
@@ -338,13 +287,23 @@ def interpolar(df, coluna_cdlog, coluna_num):
     # --------------------------------------------------
     # Garantir estrutura fixa das falhas
     # --------------------------------------------------
+    # colunas_fixas = [
+    #     "_idx",
+    #     "CDLOG",
+    #     "Numero Atual",
+    #     "Motivo",
+    #     "Sugestões",
+    #     "Novo Número"
+    # ]
+
     colunas_fixas = [
         "_idx",
         "CDLOG",
         "Numero Atual",
         "Motivo",
-        "Sugestões",
-        "Novo Número"
+        "Lado",
+        "Intervalo",
+        "Sugestões"
     ]
 
     if len(falhas) == 0:
@@ -355,6 +314,40 @@ def interpolar(df, coluna_cdlog, coluna_num):
 
     return formatar_float_visualizacao(df), output_path, df_falhas
 
+# --------------------------------------------------
+# Preparar sugestões
+# --------------------------------------------------
+
+def preparar_sugestoes(df_falhas, evt: gr.SelectData):
+
+    linha = df_falhas.iloc[evt.index[0]]
+
+    idx = linha["_idx"]
+    lado = linha["Lado"]
+    intervalo = linha["Intervalo"]
+    sugestoes = linha["Sugestões"]
+
+    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
@@ -374,6 +367,7 @@ def aplicar_correcoes(df_original, df_falhas, coluna_num):
     return df_original
 
 
+
 # --------------------------------------------------
 # Interface
 # --------------------------------------------------
@@ -397,10 +391,23 @@ with gr.Blocks() as app:
 
     falhas = gr.Dataframe(label="Falhas (Editar Novo Número)", interactive=True)
 
-    btn_corrigir = gr.Button("Aplicar Correções")
-
-    # Eventos
-    arquivo.change(fn=carregar_abas, inputs=arquivo, outputs=[dropdown_abas, dropdown_abas])
+    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,
@@ -418,9 +425,20 @@ with gr.Blocks() as app:
         outputs=[tabela_resultado, arquivo_saida, falhas]
     )
 
-    btn_corrigir.click(
-        fn=aplicar_correcoes,
-        inputs=[tabela, falhas, dropdown_num],
+    falhas.select(
+        fn=preparar_sugestoes,
+        inputs=falhas,
+        outputs=[
+            idx_selecionado,
+            info_lado,
+            info_intervalo,
+            radio_sugestoes
+        ]
+    )
+
+    btn_aplicar_sugestao.click(
+        fn=aplicar_sugestao,
+        inputs=[tabela, idx_selecionado, radio_sugestoes, dropdown_num],
         outputs=tabela
     ).then(
         fn=interpolar,
@@ -428,4 +446,6 @@ with gr.Blocks() as app:
         outputs=[tabela_resultado, arquivo_saida, falhas]
     )
 
+
+
 app.launch(server_name="0.0.0.0", server_port=7860)