Update app.py

app.py

@@ -1,6 +1,6 @@
 # ╔════════════════════════════════════════════════════════════════════════════╗
-# ║ PIPELINE v33: DIVISÃO BURRA + VISÃO PURA + CONCATENAÇÃO FIEL ║
-# ║ SEM OCR/EXTRAÇÃO - APENAS METADADOS + OLHOS DO GEMINI ║
+# ║   PIPELINE v40: FRAGMENTAÇÃO + VISÃO PAGINADA + ORQUESTRAÇÃO EM ABAS      ║
+# ║   Upload de PDF → fragmentos → PAGINADOR_VISUAL → confext_upload JSON     ║
 # ╚════════════════════════════════════════════════════════════════════════════╝
 
 import os
@@ -8,95 +8,129 @@ import json
 import re
 import time
 from datetime import datetime
+
 import gradio as gr
 import google.generativeai as genai
 import pypdf  # pip install pypdf
 
 # ==================== 1. CONFIGURAÇÃO ====================
+
 api_key = os.getenv("GOOGLE_API_KEY", "SUA_API_KEY_AQUI")
-if api_key: genai.configure(api_key=api_key)
+if api_key:
+    genai.configure(api_key=api_key)
 
 model_flash = genai.GenerativeModel("gemini-flash-latest")
-model_pro = genai.GenerativeModel("gemini-pro-latest")
+model_pro   = genai.GenerativeModel("gemini-pro-latest")
 
-ARQUIVO_CONFIG = "protocolo_fragmentacao_visao.json"
+ARQUIVO_CONFIG = "protocolo_fragmentacao_visao-3.json"
 
 # ==================== 2. UTILIDADES ====================
+
 def carregar_protocolo():
+    """
+    Carrega o protocolo JSON de agentes. 
+    Se não existir, usa o protocolo básico de PAGINADOR_VISUAL.
+    """
     try:
-        with open(ARQUIVO_CONFIG, "r", encoding="utf-8") as f: 
+        with open(ARQUIVO_CONFIG, "r", encoding="utf-8") as f:
             return f.read()
-    except: 
-        return """[
-  {
-    "nome": "VISÃO_FRAGMENTO (PASSO 0)",
-    "missao": "Você é OLHO MECÂNICO. Descreva APENAS o que vê nestas páginas: imagens, texto visível, layout, objetos, cores, diagramas. SEM interpretações, julgamentos, omissões ou criações. Liste tudo fielmente.",
-    "tipo_saida": "texto",
-    "modelo": "flash"
-  },
-  {
-    "nome": "CATALOGADOR",
-    "missao": "Analise todas as descrições de visão acumuladas. Crie índices temáticos e estrutura sem alterar fatos visuais.",
-    "tipo_saida": "json",
-    "modelo": "pro"
-  },
-  {
-    "nome": "CONCATENADOR_FINAL",
-    "missao": "UNA TODAS descrições de visão em TEXTO ÚNICO CONTÍNUO. Mantenha ordem original. Sem resumos, só o retrato fiel completo do documento.",
-    "tipo_saida": "texto",
-    "modelo": "pro"
-  }
-]"""
+    except:
+        # fallback: protocolo mínimo de visão paginada
+        return json.dumps([
+            {
+                "nome": "PAGINADOR_VISUAL",
+                "missao": (
+                    "Você recebe o texto bruto de um conjunto de páginas de um PDF. "
+                    "Separe o conteúdo por PÁGINA, na ordem original. "
+                    "Para cada página, produza um objeto com: 'pagina', "
+                    "'transcricao_fiel' (texto integral, sem resumo) e "
+                    "'descricao_visual' (imagens, tabelas, diagramas, layout, sem julgamentos). "
+                    "Se o fragmento tiver 5 páginas, devolva uma lista JSON com EXATAMENTE 5 objetos, "
+                    "um por página."
+                ),
+                "tipo_saida": "json",
+                "modelo": "flash"
+            }
+        ], ensure_ascii=False, indent=2)
 
 def salvar_protocolo(conteudo):
+    """
+    Salva o JSON de protocolo após validar sintaxe.
+    """
     try:
         json.loads(conteudo)
-        with open("protocolo.json", "w", encoding="utf-8") as f: 
+        with open(ARQUIVO_CONFIG, "w", encoding="utf-8") as f:
             f.write(conteudo)
         return "✅ Salvo"
-    except: 
+    except:
         return "❌ Erro JSON"
 
-# DIVISÃO BURRA: SEM TEXTO/OCR - APENAS METADADOS
-def ler_anexo_e_fragmentar(arquivo, paginas_por_fragmento=3):
-    """DIVISÃO BURRA: APENAS METADADOS. LLM faz visão nativa."""
-    if arquivo is None: return [], ""
-    
-    filename = getattr(arquivo, 'name', arquivo)
-    if not os.path.exists(filename): 
+# --------- DIVISÃO BURRA: PDF EM BLOCOS DE 5 PÁGINAS ---------
+
+def ler_anexo_e_fragmentar(arquivo, paginas_por_fragmento=5):
+    """
+    DIVISÃO BURRA: 
+    - Se PDF: cria fragmentos de metadados indicando blocos de páginas.
+    - Se texto: devolve um único fragmento marcador.
+    """
+    if arquivo is None:
+        return [], ""
+
+    filename = getattr(arquivo, "name", arquivo)
+
+    if not os.path.exists(filename):
         return [], f"[ERRO: Arquivo não encontrado: {filename}]"
-    
+
     anexo_info = f"[PDF: {os.path.basename(filename)}]"
-    if not filename.lower().endswith('.pdf'):
+
+    # Se não for PDF, tratamos como arquivo texto simples
+    if not filename.lower().endswith(".pdf"):
         return [f"[ARQUIVO_TEXTO: {os.path.basename(filename)}]"], anexo_info
-    
+
     try:
         reader = pypdf.PdfReader(filename)
         total_pages = len(reader.pages)
         fragments = []
+
         for i in range(0, total_pages, paginas_por_fragmento):
             start = i + 1
             end = min(i + paginas_por_fragmento, total_pages)
-            fragment = f"=== FRAG {i//paginas_por_fragmento+1} (PÁGS {start}-{end}/{total_pages}) ===\n[VISÃO: Descreva IMAGENS/TEXTO_VISUAL/LAYOUT. SEM julgar/omitir/criar.]"
+
+            # Aqui o fragmento é apenas um cabeçalho + marcador
+            fragment = (
+                f"=== FRAG {i//paginas_por_fragmento + 1} "
+                f"(PÁGS {start}-{end}/{total_pages}) ===\n"
+                f"[PAGINADOR: você está vendo páginas {start}-{end}. "
+                f"Extraia JSON pagina/transcricao_fiel/descricao_visual.]"
+            )
             fragments.append(fragment)
+
         return fragments, anexo_info
     except Exception as e:
         return [f"[ERRO PDF: {str(e)}]"], anexo_info
 
 # ==================== 3. ENGINE DE EXECUÇÃO ====================
+
 def executar_no(timeline, config, fragmento_input=None):
+    """
+    Executa um nó (agente) do protocolo.
+    - Se fragmento_input for fornecido, ele é o INPUT PARA O AGENTE.
+    - Caso contrário, o input é o JSON da timeline inteira.
+    """
     modelo = model_pro if config.get("modelo") == "pro" else model_flash
-    
+
     if fragmento_input is not None:
         input_para_prompt = fragmento_input
     else:
         input_para_prompt = json.dumps(timeline, ensure_ascii=False, indent=2)
-    
-    prompt = f"""--- INPUT PARA O AGENTE ---
-{input_para_prompt}
-----------------
-AGENTE: {config['nome']}
-MISSÃO: {config['missao']}"""
+
+    prompt = (
+        "--- INPUT PARA O AGENTE ---\n"
+        f"{input_para_prompt}\n"
+        "----------------\n"
+        f"AGENTE: {config['nome']}\n"
+        f"MISSÃO: {config['missao']}"
+    )
 
     log = f"\n🔸 {config['nome']}..."
     try:
@@ -104,156 +138,216 @@ MISSÃO: {config['missao']}"""
         resp = modelo.generate_content(prompt)
         out = resp.text
         tempo = time.time() - inicio
-        
-        content = (json.loads(out.strip().replace('``````','')) 
-                  if config['tipo_saida']=='json' else out)
-        
+
+        if config["tipo_saida"] == "json":
+            # limpeza mínima de cercas de código
+            cleaned = out.strip().replace("``````", "")
+            content = json.loads(cleaned)
+        else:
+            content = out
+
         log += f" (OK - {tempo:.2f}s)"
-        return {"role": "assistant", "agent": config['nome'], "content": content}, log, out
+        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 ====================
-def orquestrador(texto, arquivo, history, json_config):
-    # 1. Leitura e Fragmentação BURRA
+
+def orquestrador(texto, arquivo, history, json_config, confext_state):
+    """
+    Pipeline:
+    1) Se houver arquivo, faz divisão burra + visão PAGINADOR_VISUAL por fragmento.
+       - Resultado consolidado em confext_upload (state) por página.
+    2) Timeline recebe um nó de sistema com esse confext_upload.
+    3) Protocolos adicionais (se existirem além do PAGINADOR_VISUAL) usam só esse contexto.
+    """
+    # 1. Fragmentação
     fragmentos, anexo_info = ler_anexo_e_fragmentar(arquivo)
-    
+
     if not texto and not fragmentos:
-        yield history, {}, "⚠️ Sem input ou erro ao ler arquivo."
+        yield history, {}, "⚠️ Sem input ou erro ao ler arquivo.", confext_state
         return
-    
-    # 2. Setup Inicial
+
+    # 2. Setup inicial
     history = history + [[texto + (" 📎" if arquivo else ""), None]]
-    try: 
+
+    try:
         protocolo = json.loads(json_config)
     except:
         history[-1][1] = "❌ Erro no JSON de Configuração."
-        yield history, {}, "Erro JSON"
+        yield history, {}, "Erro JSON", confext_state
         return
-    
+
     timeline = [{"role": "user", "content": texto}]
     logs = f"🚀 START: {datetime.now().strftime('%H:%M:%S')}\n"
-    if fragmentos: 
-        logs += f"📎 PDF dividido: {len(fragmentos)} fragments burros.\n"
-    
-    history[-1][1] = "⏳ Dividindo + Visão..."
-    yield history, timeline, logs
-    
-    # --- PASSO 0: LOOP DE VISÃO ---
-    concatenated_vision = anexo_info + "\n\n"
-    if protocolo and protocolo[0]['nome'] == 'VISÃO_FRAGMENTO (PASSO 0)' and len(fragmentos) > 0:
-        cfg_visao = protocolo.pop(0)  # Remove PASSO 0
-        
+
+    # Estrutura interna de contexto de anexos
+    confext_upload = {
+        "arquivo": os.path.basename(getattr(arquivo, "name", "sem_arquivo"))
+        if arquivo else None,
+        "meta": anexo_info,
+        "paginas": []  # cada item: {pagina, transcricao_fiel, descricao_visual}
+    }
+
+    if fragmentos:
+        logs += f"📎 PDF dividido: {len(fragmentos)} fragmentos burros.\n"
+        history[-1][1] = "⏳ Fragmentando + visão paginada..."
+        yield history, timeline, logs, confext_upload
+
+    # 3. PASSO DE VISÃO PAGINADA (PAGINADOR_VISUAL)
+    # Espera-se que seja o primeiro (único) agente, mas tratamos genericamente.
+    if protocolo and fragmentos:
+        cfg_visao = protocolo[0]  # usamos apenas o primeiro como PAGINADOR_VISUAL
+
         for i, fragmento in enumerate(fragmentos):
-            history[-1][1] = f"👁️ {cfg_visao['nome']} frag {i+1}/{len(fragmentos)}..."
-            yield history, timeline, logs
-            
+            history[-1][1] = (
+                f"👁️ {cfg_visao['nome']} frag {i+1}/{len(fragmentos)}..."
+            )
+            yield history, timeline, logs, confext_upload
+
             res, log_add, raw = executar_no(timeline, cfg_visao, fragmento_input=fragmento)
             logs += log_add + "\n"
-            
-            if 'error' in res:
+
+            if "error" in res:
                 logs += f"❌ Erro frag {i+1}: {res['error']}\n"
-            
-            concatenated_vision += f"\n--- VISÃO FRAG {i+1} ---\n{res['content']}\n"
-        
-        logs += "\n✅ Visões completas.\n"
-        timeline.append({
-            "role": "system",
-            "agent": "DOCUMENTO_VISAO_COMPLETA",
-            "content": concatenated_vision
-        })
-    elif len(fragmentos) > 0:
-        timeline.append({
-            "role": "system",
-            "agent": "FRAGMENTS_RAW",
-            "content": concatenated_vision + "\n".join(fragmentos)
-        })
-    
-    # --- PASSOS 1+: ANÁLISE SEQUENCIAL ---
+                continue
+
+            # res['content'] deve ser lista JSON de páginas [{pagina, transcricao_fiel, descricao_visual}, ...]
+            try:
+                paginas_res = res["content"]
+                if isinstance(paginas_res, dict):
+                    paginas_res = [paginas_res]
+                for p in paginas_res:
+                    confext_upload["paginas"].append(p)
+            except Exception as e:
+                logs += f"❌ Erro ao incorporar páginas do frag {i+1}: {e}\n"
+
+        logs += "✅ Visões paginadas completas.\n"
+
+    # 4. Injeta confext_upload na timeline como nó de sistema
+    timeline.append({
+        "role": "system",
+        "agent": "CONFEXT_UPLOAD",
+        "content": confext_upload
+    })
+
+    # 5. Se existirem passos adicionais além do PAGINADOR_VISUAL, executa-os sequencialmente
     final_response = ""
-    for cfg in protocolo:
+    # pula o primeiro passo se ele é o PAGINADOR_VISUAL
+    restante = protocolo[1:] if protocolo else []
+
+    for cfg in restante:
         history[-1][1] = f"⚙️ {cfg['nome']}..."
-        yield history, timeline, logs
-        
+        yield history, timeline, logs, confext_upload
+
         res, log_add, raw = executar_no(timeline, cfg)
         timeline.append(res)
         logs += log_add + "\n"
-        
-        if cfg['tipo_saida'] == 'texto':
-            final_response = res['content']
+
+        if cfg["tipo_saida"] == "texto":
+            final_response = res["content"]
             history[-1][1] = final_response
-            yield history, timeline, logs
-    
-    logs += "✅ FIM."
-    yield history, timeline, logs
 
-# ==================== 5. UI LIMPA (v33) ====================
+        yield history, timeline, logs, confext_upload
+
+    if not restante and not texto:
+        # se não há mais agentes e não houve prompt, só confirma pré-processamento
+        history[-1][1] = "✅ PDF processado. Pronto para perguntas usando contexto interno."
+        final_response = history[-1][1]
+
+    logs += "✅ FIM.\n"
+    yield history, timeline, logs, confext_upload
+
+# ==================== 5. UI LIMPA ====================
+
 def ui_clean():
     css = """
     footer {display: none !important;}
     .contain {border: none !important;}
     """
-    
+
     config_init = carregar_protocolo()
-    
-    with gr.Blocks(title="👁️ AI Visão Pura", css=css, theme=gr.themes.Soft()) as app:
+
+    with gr.Blocks(title="AI Forensics – Visão Paginada", css=css, theme=gr.themes.Soft()) as app:
+        confext_state = gr.State(value=None)
+
         with gr.Tabs():
-            # === ABA 1: CHAT ===
+            # === ABA 1: CHAT / INVESTIGADOR ===
             with gr.Tab("💬 Investigador"):
                 chatbot = gr.Chatbot(
-                    label="", show_label=False, height=600,
-                    show_copy_button=True, render_markdown=True
+                    label="",
+                    show_label=False,
+                    height=600,
+                    show_copy_button=True,
+                    render_markdown=True,
                 )
-                
+
                 with gr.Row():
                     with gr.Column(scale=10):
                         txt_in = gr.Textbox(
                             show_label=False,
-                            placeholder="Instruções opcionais...",
-                            lines=1, max_lines=5, container=False
+                            placeholder="Descreva o caso ou faça perguntas (opcional após upload)...",
+                            lines=1,
+                            max_lines=5,
+                            container=False,
                         )
                     with gr.Column(scale=1, min_width=50):
                         file_in = gr.UploadButton(
-                            "📎", file_types=[".txt", ".md", ".csv", ".json", ".pdf"], size="sm"
+                            "📎",
+                            file_types=[".txt", ".md", ".csv", ".json", ".pdf"],
+                            size="sm",
                         )
                     with gr.Column(scale=1, min_width=80):
                         btn_send = gr.Button("Enviar", variant="primary", size="sm")
-                
+
                 file_status = gr.Markdown("", visible=True)
+                # Mostra nome do arquivo ao subir
                 file_in.upload(
-                    lambda x: f"📎 PDF pronto: {os.path.basename(getattr(x, 'name', x))}",
-                    file_in, file_status
+                    lambda x: f"📎 Anexo recebido: {os.path.basename(getattr(x, 'name', x))}",
+                    inputs=file_in,
+                    outputs=file_status,
                 )
-            
-            # === ABA 2: LOGS ===
+
+            # === ABA 2: DEPURAÇÃO ===
             with gr.Tab("🕵️ Depuração"):
                 with gr.Row():
                     out_dna = gr.JSON(label="DNA (Timeline)")
                     out_logs = gr.Textbox(label="Logs do Sistema", lines=20)
-            
+                confext_view = gr.JSON(label="confext_upload")
+
             # === ABA 3: CONFIG ===
             with gr.Tab("⚙️ Config"):
                 with gr.Row():
                     btn_save = gr.Button("Salvar Config")
                     lbl_save = gr.Label(show_label=False)
-                code_json = gr.Code(
-                    value=config_init, language="json", label="protocolo.json"
-                )
+                code_json = gr.Code(value=config_init, language="json", label=ARQUIVO_CONFIG)
                 btn_save.click(salvar_protocolo, code_json, lbl_save)
-        
+
         # === TRIGGERS ===
+        def _orq_wrapper(texto, arquivo, history, json_cfg, confext_old):
+            # delega para o orquestrador, passando state antigo
+            for h, dna, logs, confext_new in orquestrador(texto, arquivo, history, json_cfg, confext_old):
+                yield h, dna, logs, confext_new
+
         triggers = [btn_send.click, txt_in.submit]
+
         for trig in triggers:
             trig(
-                orquestrador,
-                inputs=[txt_in, file_in, chatbot, code_json],
-                outputs=[chatbot, out_dna, out_logs]
+                _orq_wrapper,
+                inputs=[txt_in, file_in, chatbot, code_json, confext_state],
+                outputs=[chatbot, out_dna, out_logs, confext_state],
+            ).then(
+                lambda c: (None, None, "", c),
+                inputs=confext_state,
+                outputs=[txt_in, file_in, file_status, confext_state],
             ).then(
-                lambda: (None, None, ""),
-                outputs=[txt_in, file_in, file_status]
+                lambda c: c,
+                inputs=confext_state,
+                outputs=confext_view,
             )
-    
+
     return app
 
+
 if __name__ == "__main__":
     ui_clean().launch()