Update app.py

app.py

@@ -1,5 +1,5 @@
 # ╔════════════════════════════════════════════════════════════════════════════╗
-# ║             PIPELINE v28: ANÁLISE EPISTÊMICA (COM LÓGICA DE FRAGMENTAÇÃO)  ║
+# ║             PIPELINE v29: ANÁLISE EPISTÊMICA (COM LÓGICA REAL PYPDF)       ║
 # ║        Layout: Chat (Aba 1) | Debug (Aba 2) | Config (Aba 3)               ║
 # ╚════════════════════════════════════════════════════════════════════════════╝
 
@@ -10,7 +10,7 @@ import time
 from datetime import datetime
 import gradio as gr
 import google.generativeai as genai
-##mport PyMuPDF as fitz # <-- BIBLIOTECA NECESSÁRIA
+import pypdf # <--- BIBLIOTECA NECESSÁRIA AGORA
 
 # ==================== 1. CONFIGURAÇÃO ====================
 api_key = os.getenv("GOOGLE_API_KEY", "SUA_API_KEY_AQUI")
@@ -19,7 +19,7 @@ if api_key: genai.configure(api_key=api_key)
 model_flash = genai.GenerativeModel("gemini-flash-latest")
 model_pro   = genai.GenerativeModel("gemini-pro-latest")
 
-# **ATUALIZAÇÃO: Usando o novo nome de arquivo de configuração**
+# Usando o nome do protocolo de análise epistêmica
 ARQUIVO_CONFIG = "protocolo_epistemico_forense.json"
 
 # ==================== 2. UTILIDADES ====================
@@ -32,34 +32,48 @@ def carregar_protocolo():
 def salvar_protocolo(conteudo):
     try:
         json.loads(conteudo)
-        with open(ARQUIVO_CONFIG, "w", encoding="utf-8") as f: f.write(conteudo)
-        # O nome do arquivo salvo DEVE ser o ARQUIVO_CONFIG, mas o Gradio usa o label, vamos manter o nome.
-        # with open("protocolo.json", "w", encoding="utf-8") as f: f.write(conteudo)
+        # Assumindo que o Gradio salva como 'protocolo.json'
+        with open("protocolo.json", "w", encoding="utf-8") as f: f.write(conteudo) 
         return "✅ Salvo"
     except: return "❌ Erro JSON"
 
-# **NOVA FUNÇÃO: Prepara fragmentos de PDF (Placeholder para a lógica de fragmentação)**
-def ler_anexo_e_fragmentar(arquivo):
-    """Lê o anexo. Se for PDF, divide em fragmentos de 5 páginas. 
+# **FUNÇÃO REAL: Lógica de Fragmentação de PDF com pypdf**
+def ler_anexo_e_fragmentar(arquivo, paginas_por_fragmento=5):
+    """Lê o anexo. Se for PDF, usa pypdf para dividir em fragmentos de X páginas. 
        Se for TXT/Outro, retorna o texto completo em uma lista de 1 fragmento."""
     if arquivo is None: return [], ""
     filename = arquivo.name
     anexo_info = f"\n\n[ANEXO SISTEMA: {os.path.basename(filename)}]\n"
     
-    # Adicionando suporte para PDF (necessita de biblioteca externa)
+    # Lógica REAL para PDF
     if filename.lower().endswith(".pdf"):
-        # ⚠️ PLACEHOLDER: A lógica real de divisão de PDF (ex: usando PyMuPDF) vai aqui ⚠️
-        print(f"DEBUG: Arquivo PDF detectado. Simulando fragmentação de 5 páginas.")
+        print(f"DEBUG: Arquivo PDF detectado. Iniciando fragmentação de {paginas_por_fragmento} páginas.")
         
-        # O retorno é uma lista de fragmentos de texto (simulados)
-        # Se fosse um agente de transcrição, o loop chamaria o LLM aqui.
-        # Aqui, simulamos o texto extraído da divisão em fragmentos.
-        return [
-            "FRAGMENTO 1 (Pgs 1-5): Regras de Contrato: O preço base é R$100.000,00. O prazo de entrega é 180 dias.", 
-            "FRAGMENTO 2 (Pgs 6-10): Termos de Aditivo: Um aditivo posterior (data X) modificou o preço para R$120.000,00 e o prazo para 210 dias.",
-            "FRAGMENTO 3 (Pgs 11-15): Finalização: O cliente alega que o preço final acordado era R$110.000,00 e que houve falha na entrega de evidências.",
-            "FRAGMENTO 4 (Pgs 16-20): Conclusão: O sistema de auditoria não conseguiu rastrear a evidência E1."
-        ], anexo_info
+        fragments = []
+        try:
+            reader = pypdf.PdfReader(filename)
+            total_pages = len(reader.pages)
+            
+            for i in range(0, total_pages, paginas_por_fragmento):
+                fragment_text = []
+                start_page = i
+                end_page = min(i + paginas_por_fragmento, total_pages)
+                
+                for j in range(start_page, end_page):
+                    # pypdf usa índice 0, então página N é reader.pages[N-1]
+                    try:
+                        fragment_text.append(reader.pages[j].extract_text())
+                    except Exception as e:
+                        fragment_text.append(f"[ERRO DE EXTRAÇÃO NA PÁGINA {j+1}: {e}]")
+                
+                fragment_header = f"FRAGMENTO (Pgs {start_page+1}-{end_page} / Total {total_pages}):\n"
+                fragments.append(fragment_header + "\n".join(fragment_text))
+
+            return fragments, anexo_info
+            
+        except Exception as e:
+            # Em caso de erro na leitura/extração do PDF
+            return [f"ERRO CRÍTICO NA LEITURA DE PDF: {e}"], anexo_info
     
     # Para arquivos não PDF, lê o conteúdo como um único fragmento.
     try:
@@ -70,16 +84,13 @@ def ler_anexo_e_fragmentar(arquivo):
 
 # ==================== 3. ENGINE DE EXECUÇÃO ====================
 
-# **MODIFICADA para aceitar um fragmento de texto como input se for o Passo 0**
+# Funções inalteradas, pois a lógica de loop foi centralizada no ORQUESTRADOR
 def executar_no(timeline, config, fragmento_input=None):
     modelo = model_pro if config.get("modelo") == "pro" else model_flash
     
-    # Se fragmento_input for fornecido (i.e., estamos no Passo 0-LOOP), o LLM recebe o fragmento
     if fragmento_input is not None:
-        # Prompt para o LLM processar o fragmento. O contexto da timeline é ignorado aqui.
         input_para_prompt = fragmento_input
     else:
-        # Prompt padrão para os passos sequenciais, que usam a TIMELINE completa como contexto
         contexto = json.dumps(timeline, ensure_ascii=False, indent=2)
         input_para_prompt = contexto
 
@@ -92,14 +103,13 @@ def executar_no(timeline, config, fragmento_input=None):
         out = resp.text
         tempo = time.time() - inicio
         
-        # O Passo 0 pode retornar texto, mas os outros passos JSON precisam de parsing
         content = json.loads(out.strip().replace('```json','').replace('```','')) if config['tipo_saida']=='json' and fragmento_input is None else out
         log += f" (OK - {tempo:.2f}s)"
         return {"role": "assistant", "agent": config['nome'], "content": content}, log, out
     except Exception as e:
         return {"role": "system", "error": str(e)}, f" (ERRO: {e})", str(e)
 
-# ==================== 4. ORQUESTRADOR (LÓGICA DO LOOP) ====================
+# ==================== 4. ORQUESTRADOR (LÓGICA DO LOOP/FRAGMENTAÇÃO) ====================
 
 def orquestrador(texto, arquivo, history, json_config):
     # 1. Input Check e Fragmentação
@@ -123,47 +133,26 @@ def orquestrador(texto, arquivo, history, json_config):
     history[-1][1] = "⏳ Iniciando análise..."
     yield history, timeline, logs
 
-    # 3. Execução: Loop e Sequência
+    # 3. Lógica de Pré-processamento/Conciliação de Fragmentos
     
-    # 3a. PASSO 0: LÓGICA DE LOOP/FRAGEMENTAÇÃO (NOVA LÓGICA)
-    # O protocolo epistêmico começa no ESTADO_INICIAL (Fase 0)
-    if protocolo and 'fase' in protocolo[0] and protocolo[0]['fase'] == 0 and len(fragmentos) > 1:
-        
-        # O Agente 0 será executado UMA ÚNICA VEZ, mas com o input pré-processado/concatenado
-        # A instrução aqui é: Chamar o LLM (ESTADO_INICIAL) para CADA fragmento, mas isso não faz sentido
-        # para o objetivo do ESTADO_INICIAL, que precisa do input COMPLETO.
-        
-        # ADAPTAÇÃO: Vamos concatenar os fragmentos ANTES de chamar o ESTADO_INICIAL (Agente 0)
-        # O Agente 0 (ESTADO_INICIAL) recebe o texto concatenado no seu input inicial.
-        
+    if len(fragmentos) > 0:
         concatenated_input = anexo_info + "\n\n" + "\n\n".join(fragmentos)
         full_input_to_pass = f"{texto}\n{concatenated_input}".strip()
         
         # O full_input_to_pass torna-se o 'content' do primeiro item da timeline
         timeline[0]['content'] = full_input_to_pass
-        history[-1][1] = "✅ Fragmentos concatenados. Iniciando FASE 0..."
+        history[-1][1] = "✅ Pré-processamento: Anexo lido e concatenado. Iniciando FASE 0..."
         yield history, timeline, logs
         
-        
-    elif fragmentos:
-        # Caso o input seja um arquivo não-PDF (1 fragmento), adicionamos ao full_input
-        full_input_to_pass = f"{texto}\n{anexo_info}{fragmentos[0]}".strip()
-        timeline[0]['content'] = full_input_to_pass
-        history[-1][1] = "✅ Anexo lido. Iniciando FASE 0..."
-        yield history, timeline, logs
+    else:
+        # Se não há anexo ou só a pergunta
+        pass
 
 
-    # 3b. PASSOS SEGUINTES: EXECUÇÃO SEQUENCIAL (Lógica original, mas aprimorada)
+    # 4. PASSOS SEGUINTES: EXECUÇÃO SEQUENCIAL (Protocolo Epistêmico)
     final_response = ""
     for cfg in protocolo: 
         
-        # Lógica de Controle de Iteração (Baseada no TESTE_CRUCIALIDADE, Passo 7)
-        if cfg['nome'] == 'TESTE_CRUCIALIDADE':
-            # ⚠️ Aqui deveria haver a lógica de 'Se PASSOU=false, voltar para FASE 3', 
-            # mas o orquestrador não suporta iterar fases passadas sem reescrita total.
-            # Executamos o teste, mas ignoramos a ação 'VOLTAR_FASE_3' no loop simples.
-            pass
-            
         history[-1][1] = f"⚙️ FASE {cfg.get('fase', '?')}: {cfg['nome']} trabalhando..."
         yield history, timeline, logs
         
@@ -216,7 +205,7 @@ def ui_clean():
                     with gr.Column(scale=1, min_width=50):
                         file_in = gr.UploadButton(
                             "📎", 
-                            file_types=[".txt", ".md", ".csv", ".json", ".pdf"], # Adicionado suporte a PDF
+                            file_types=[".txt", ".md", ".csv", ".json", ".pdf"], 
                             size="sm"
                         )
                     with gr.Column(scale=1, min_width=80):
@@ -237,8 +226,8 @@ def ui_clean():
                 with gr.Row():
                     btn_save = gr.Button("Salvar Config")
                     lbl_save = gr.Label(show_label=False)
-                # **ATUALIZAÇÃO: Label para refletir o novo protocolo**
-                code_json = gr.Code(value=config_init, language="json", label=ARQUIVO_CONFIG)
+                # Label para refletir o novo protocolo
+                code_json = gr.Code(value=config_init, language="json", label="protocolo.json") 
                 btn_save.click(salvar_protocolo, code_json, lbl_save)
 
         # === TRIGGERS ===