Update app.py

app.py

@@ -1,6 +1,6 @@
 # ╔════════════════════════════════════════════════════════════════════════════╗
-# ║        PIPELINE v32: FRAGMENTAÇÃO, TRANSCRIÇÃO (LOOP) & CATALOGAÇÃO        ║
-# ║        CORREÇÃO: MANIPULAÇÃO ROBUSTA DE ANEXOS E LIMPEZA DE BUFFER         ║
+# ║ PIPELINE v33: DIVISÃO BURRA + VISÃO PURA + CONCATENAÇÃO FIEL ║
+# ║ SEM OCR/EXTRAÇÃO - APENAS METADADOS + OLHOS DO GEMINI ║
 # ╚════════════════════════════════════════════════════════════════════════════╝
 
 import os
@@ -10,100 +10,94 @@ import time
 from datetime import datetime
 import gradio as gr
 import google.generativeai as genai
-import pypdf # Certifique-se de que 'pip install pypdf' foi executado
+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)
 
 model_flash = genai.GenerativeModel("gemini-flash-latest")
-model_pro   = genai.GenerativeModel("gemini-pro-latest")
+model_pro = genai.GenerativeModel("gemini-pro-latest")
 
-# Configuração Padrão do Protocolo
-ARQUIVO_CONFIG = "protocolo_fragmentacao_transcricao.json"
+ARQUIVO_CONFIG = "protocolo_fragmentacao_visao.json"
 
 # ==================== 2. UTILIDADES ====================
-
 def carregar_protocolo():
     try:
-        with open(ARQUIVO_CONFIG, "r", encoding="utf-8") as f: return f.read()
-    except: return "[]"
+        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"
+  }
+]"""
 
 def salvar_protocolo(conteudo):
     try:
         json.loads(conteudo)
-        with open("protocolo.json", "w", encoding="utf-8") as f: f.write(conteudo) 
+        with open("protocolo.json", "w", encoding="utf-8") as f: 
+            f.write(conteudo)
         return "✅ Salvo"
-    except: return "❌ Erro JSON"
+    except: 
+        return "❌ Erro JSON"
 
-# **CORREÇÃO: Função de Leitura Robusta**
-def ler_anexo_e_fragmentar(arquivo, paginas_por_fragmento=5):
-    """Lê o anexo com segurança, tratando objetos do Gradio."""
-    if arquivo is None: 
-        return [], ""
+# 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 [], ""
     
-    # Tratamento seguro do caminho do arquivo
-    # O Gradio pode enviar um objeto NamedString ou apenas o caminho
     filename = getattr(arquivo, 'name', arquivo)
+    if not os.path.exists(filename): 
+        return [], f"[ERRO: Arquivo não encontrado: {filename}]"
     
-    if not os.path.exists(filename):
-        return [], f"[ERRO SISTEMA: Arquivo temporário não encontrado: {filename}]"
-
-    anexo_info = f"[ANEXO SISTEMA: {os.path.basename(filename)}]"
-    
-    # Lógica PDF
-    if filename.lower().endswith(".pdf"):
-        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):
-                    try:
-                        # Tenta extrair. Se falhar ou vier vazio, coloca um placeholder
-                        text = reader.pages[j].extract_text()
-                        if not text or text.strip() == "":
-                            text = f"[PAG {j+1}: (Texto Vazio/Imagem) - Necessário OCR via LLM]"
-                        fragment_text.append(text)
-                    except Exception as e:
-                        fragment_text.append(f"[PAG {j+1}: Erro de Leitura: {e}]")
-                
-                # Cabeçalho claro para o LLM saber onde está
-                fragment_header = f"=== FRAGMENTO {i//paginas_por_fragmento + 1} (Páginas {start_page+1} a {end_page} de {total_pages}) ===\n"
-                fragments.append(fragment_header + "\n".join(fragment_text))
-
-            return fragments, anexo_info
-            
-        except Exception as e:
-            return [f"ERRO CRÍTICO NA LEITURA DO PDF: {str(e)}"], anexo_info
+    anexo_info = f"[PDF: {os.path.basename(filename)}]"
+    if not filename.lower().endswith('.pdf'):
+        return [f"[ARQUIVO_TEXTO: {os.path.basename(filename)}]"], anexo_info
     
-    # Lógica para TXT/MD/JSON (Lê como um único fragmento)
     try:
-        with open(filename, "r", encoding="utf-8") as f:
-            return [f.read()], anexo_info
-    except: 
-        return [f"Erro ao ler arquivo de texto."], anexo_info
-
+        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.]"
+            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):
     modelo = model_pro if config.get("modelo") == "pro" else model_flash
     
-    # Se receber um fragmento direto (Passo 0), usa apenas ele como input
     if fragmento_input is not None:
         input_para_prompt = fragmento_input
     else:
-        # Caso contrário, usa toda a timeline acumulada
         input_para_prompt = json.dumps(timeline, ensure_ascii=False, indent=2)
-
-    prompt = f"--- INPUT PARA O AGENTE ---\n{input_para_prompt}\n----------------\nAGENTE: {config['nome']}\nMISSÃO: {config['missao']}"
     
+    prompt = f"""--- INPUT PARA O AGENTE ---
+{input_para_prompt}
+----------------
+AGENTE: {config['nome']}
+MISSÃO: {config['missao']}"""
+
     log = f"\n🔸 {config['nome']}..."
     try:
         inicio = time.time()
@@ -111,178 +105,155 @@ def executar_no(timeline, config, fragmento_input=None):
         out = resp.text
         tempo = time.time() - inicio
         
-        # Se for JSON, faz o parse. Se for texto (Transcrição), retorna puro.
-        content = json.loads(out.strip().replace('```json','').replace('```','')) if config['tipo_saida']=='json' else out
+        content = (json.loads(out.strip().replace('``````','')) 
+                  if config['tipo_saida']=='json' 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 ====================
-
 def orquestrador(texto, arquivo, history, json_config):
-    # 1. Leitura e Fragmentação
+    # 1. Leitura e Fragmentação BURRA
     fragmentos, anexo_info = ler_anexo_e_fragmentar(arquivo)
     
-    # Validação básica
     if not texto and not fragmentos:
-        # Se não tem texto E não tem fragmentos válidos
         yield history, {}, "⚠️ Sem input ou erro ao ler arquivo."
         return
-
+    
     # 2. Setup Inicial
     history = history + [[texto + (" 📎" if arquivo else ""), None]]
-    try: protocolo = json.loads(json_config)
-    except: 
+    try: 
+        protocolo = json.loads(json_config)
+    except:
         history[-1][1] = "❌ Erro no JSON de Configuração."
         yield history, {}, "Erro JSON"
         return
-
-    # Timeline inicial
+    
     timeline = [{"role": "user", "content": texto}]
     logs = f"🚀 START: {datetime.now().strftime('%H:%M:%S')}\n"
-    if fragmentos: logs += f"📎 Arquivo processado: {len(fragmentos)} fragmentos gerados.\n"
+    if fragmentos: 
+        logs += f"📎 PDF dividido: {len(fragmentos)} fragments burros.\n"
     
-    history[-1][1] = "⏳ Iniciando análise..."
+    history[-1][1] = "⏳ Dividindo + Visão..."
     yield history, timeline, logs
-
-    # --- PASSO 0: LOOP DE TRANSCRIÇÃO ---
-    # Verifica se o primeiro passo é o transcritor e se temos arquivo
-    concatenated_transcription = anexo_info + "\n\n"
     
-    if protocolo and protocolo[0]['nome'] == 'TRANSCRITOR_FRAGMENTO (PASSO 0 - LOOP)' and len(fragmentos) > 0:
-        
-        cfg_transcricao = protocolo.pop(0) # Remove o passo 0 da fila
+    # --- 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
         
         for i, fragmento in enumerate(fragmentos):
-            history[-1][1] = f"⚙️ {cfg_transcricao['nome']} processando parte {i+1} de {len(fragmentos)}..."
+            history[-1][1] = f"👁️ {cfg_visao['nome']} frag {i+1}/{len(fragmentos)}..."
             yield history, timeline, logs
             
-            # Chama o LLM passando APENAS o fragmento atual
-            res, log_add, raw = executar_no(timeline, cfg_transcricao, fragmento_input=fragmento)
+            res, log_add, raw = executar_no(timeline, cfg_visao, fragmento_input=fragmento)
             logs += log_add + "\n"
             
             if 'error' in res:
-                logs += f"❌ Erro no fragmento {i+1}: {res['error']}\n"
-                # Continua mesmo com erro, ou para? Vamos continuar concatenando o erro para registro.
+                logs += f"❌ Erro frag {i+1}: {res['error']}\n"
             
-            # Acumula o resultado
-            concatenated_transcription += f"\n--- TRANSCRIÇÃO PARTE {i+1} ---\n{res['content']}\n"
-
-        logs += "\n✅ Transcrição completa.\n"
+            concatenated_vision += f"\n--- VISÃO FRAG {i+1} ---\n{res['content']}\n"
         
-        # Adiciona o texto COMPLETO transcrito à timeline para o Bibliotecário ler
+        logs += "\n✅ Visões completas.\n"
         timeline.append({
-            "role": "system", 
-            "agent": "DOCUMENTO_COMPLETO_TRANSCRITO", 
-            "content": concatenated_transcription
+            "role": "system",
+            "agent": "DOCUMENTO_VISAO_COMPLETA",
+            "content": concatenated_vision
         })
-        
     elif len(fragmentos) > 0:
-        # Se não tinha o passo de transcrição configurado, injeta o texto cru
         timeline.append({
-            "role": "system", 
-            "agent": "DOCUMENTO_COMPLETO_RAW", 
-            "content": concatenated_transcription + "\n".join(fragmentos)
+            "role": "system",
+            "agent": "FRAGMENTS_RAW",
+            "content": concatenated_vision + "\n".join(fragmentos)
         })
-
-    # --- PASSO 1 e SEGUINTES: CATALOGAÇÃO SEQUENCIAL ---
+    
+    # --- PASSOS 1+: ANÁLISE SEQUENCIAL ---
     final_response = ""
-    for cfg in protocolo: 
-        history[-1][1] = f"⚙️ {cfg['nome']} analisando..."
+    for cfg in protocolo:
+        history[-1][1] = f"⚙️ {cfg['nome']}..."
         yield history, timeline, logs
         
-        # Executa com a timeline completa
         res, log_add, raw = executar_no(timeline, cfg)
         timeline.append(res)
         logs += log_add + "\n"
         
         if cfg['tipo_saida'] == 'texto':
             final_response = res['content']
-            history[-1][1] = final_response 
-        
-        yield history, timeline, logs
-
+            history[-1][1] = final_response
+            yield history, timeline, logs
+    
     logs += "✅ FIM."
     yield history, timeline, logs
 
-
-# ==================== 5. UI LIMPA (v32) ====================
-
+# ==================== 5. UI LIMPA (v33) ====================
 def ui_clean():
     css = """
-    footer {display: none !important;} 
+    footer {display: none !important;}
     .contain {border: none !important;}
     """
     
     config_init = carregar_protocolo()
-
-    with gr.Blocks(title="AI Bibliotecário", css=css, theme=gr.themes.Soft()) as app:
-        
+    
+    with gr.Blocks(title="👁️ AI Visão Pura", css=css, theme=gr.themes.Soft()) as app:
         with gr.Tabs():
-            
             # === ABA 1: CHAT ===
             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
+                            show_label=False,
+                            placeholder="Instruções opcionais...",
+                            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")
                 
-                # Feedback do arquivo
                 file_status = gr.Markdown("", visible=True)
-                file_in.upload(lambda x: f"📎 Anexo pronto: {os.path.basename(getattr(x, 'name', x))}", file_in, file_status)
-
+                file_in.upload(
+                    lambda x: f"📎 PDF pronto: {os.path.basename(getattr(x, 'name', x))}",
+                    file_in, file_status
+                )
+            
             # === ABA 2: LOGS ===
             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)
-
+            
             # === 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="protocolo.json"
+                )
                 btn_save.click(salvar_protocolo, code_json, lbl_save)
-
+        
         # === TRIGGERS ===
         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]
             ).then(
-                # CORREÇÃO: Limpa txt_in E file_in E file_status após o envio
-                lambda: (None, None, ""), 
-                outputs=[txt_in, file_in, file_status] 
+                lambda: (None, None, ""),
+                outputs=[txt_in, file_in, file_status]
             )
-
+    
     return app
 
 if __name__ == "__main__":
-    ui_clean().launch()
+    ui_clean().launch()