Update app.py

app.py

@@ -9,327 +9,192 @@ import warnings
 import re
 warnings.filterwarnings("ignore", category=FutureWarning, module="google.api_core")
 
-# ============================================================================
-# CONFIGURAÇÃO
 # ============================================================================
 API_KEY = os.getenv("GOOGLE_API_KEY", "sua-chave-aqui")
 genai.configure(api_key=API_KEY)
 model = genai.GenerativeModel("gemini-2.0-flash")
 
-TITLE = "# 🚀 Pipeline v10\n**P0-P1 → X1-X2 → P2-P8**"
-
-# ============================================================================
-# LOGGER MELHORADO
 # ============================================================================
 class Logger:
-    def __init__(self, verbose=True):
-        self.verbose = verbose
-        self.logs = []
+    def __init__(self, verbose=True): self.verbose = verbose; self.logs = []
     def log(self, msg: str, level="INFO"):
         timestamp = datetime.now().strftime("%H:%M:%S")
-        log_msg = f"[{timestamp}] [{level}] {msg}"
-        self.logs.append(log_msg)
-        if self.verbose: print(log_msg)
+        print(f"[{timestamp}] [{level}] {msg}")
 
 logger = Logger(verbose=True)
 
 # ============================================================================
-# HELPERS ULTRA ROBUSTOS
-# ============================================================================
-def processar_anexo(arquivo) -> Tuple[str, str]:
-    if arquivo is None: return "", "nenhum"
+def processar_anexo(arquivo): 
+    if not arquivo: return "", "nenhum"
     try:
         caminho = str(arquivo)
-        if caminho.lower().endswith('.pdf'):
+        if caminho.endswith('.pdf'):
             try:
                 import PyPDF2
                 with open(caminho, 'rb') as f:
                     leitor = PyPDF2.PdfReader(f)
-                    texto = "".join(pagina.extract_text() + "\n" for pagina in leitor.pages[:3])
-                    return texto[:2000], "pdf"
-            except: return f"[PDF detectado]", "pdf"
-        elif any(caminho.lower().endswith(ext) for ext in ['.png','.jpg','.jpeg','.gif']):
+                    return "".join(p.extract_text()+"\n" for p in leitor.pages[:3])[:2000], "pdf"
+            except: return "[PDF]", "pdf"
+        if any(caminho.endswith(x) for x in ['.png','.jpg','.jpeg']):
             with open(caminho, 'rb') as f:
                 return base64.b64encode(f.read()).decode()[:500], "imagem"
-        return "", "nao_suportado"
-    except: return "", "erro"
+    except: pass
+    return "", "erro"
 
-def construir_prompt_com_anexo(pergunta: str, anexo_conteudo: str, tipo_anexo: str) -> str:
-    if not anexo_conteudo or tipo_anexo == "nenhum": return pergunta
-    if tipo_anexo == "pdf": return f"""DOCUMENTO:
-{anexo_conteudo[:1800]}
----
-PERGUNTA: {pergunta}"""
-    return f"""ANEXO VISUAL:
-PERGUNTA: {pergunta}"""
+def construir_prompt(pergunta: str, anexo: str, tipo: str):
+    if not anexo: return pergunta
+    return f"ANEXO {tipo.upper()}:\n{anexo}\n\nPERGUNTA: {pergunta}"
 
-def parse_json_ultra_robusto(texto: str) -> Dict:
-    """Extrai QUALQUER JSON de texto bagunçado"""
-    logger.log(f"Parse: {len(texto)} chars", "DEBUG")
+# ============================================================================
+def PARSER_SIMPLES(texto: str) -> Dict:
+    """PARSER ULTRA SIMPLES - PEGA PRIMEIRO JSON"""
     if not texto: return {"erro": "vazio"}
     
-    try:
-        # Regex múltiplos JSONs
-        matches = re.findall(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', texto, re.DOTALL)
-        for match in matches:
-            try: return json.loads(match)
-            except: continue
-        
-        # JSON balanceado primeiro
-        inicio = texto.find('{')
-        if inicio != -1:
-            count, i = 1, inicio + 1
-            while i < len(texto) and count > 0:
-                if texto[i] == '{': count += 1
-                elif texto[i] == '}': count -= 1
-                i += 1
-            if count == 0: return json.loads(texto[inicio:i])
-        
-        # Fallback último JSON
-        fim = texto.rfind('}')
-        if fim != -1:
-            count, i = 1, fim - 1
-            while i >= 0 and count > 0:
-                if texto[i] == '}': count += 1
-                elif texto[i] == '{': count -= 1
-                i -= 1
-            if count == 0: return json.loads(texto[i+1:fim+1])
-            
-    except Exception as e:
-        logger.log(f"Parse falhou: {str(e)[:100]}", "ERROR")
+    # 1. Regex simples
+    match = re.search(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', texto)
+    if match:
+        try: return json.loads(match.group(0))
+        except: pass
     
-    return {"erro": "parse_falhou", "fallback": texto[:200]}
-
-def chamar_gemini_json(prompt_base: str, temperatura=0.4, max_tokens=1500) -> Dict:
-    prompt = f"""{prompt_base}
-
----
-
-**JSON PURO OBRIGATÓRIO**
-SEM TEXTO EXTRA. APENAS:
-{{"chave": "valor"}}"""
+    # 2. Primeiro { até último }
+    ini = texto.find('{')
+    fim = texto.rfind('}')
+    if ini >= 0 and fim > ini:
+        try: return json.loads(texto[ini:fim+1])
+        except: pass
     
+    return {"erro": texto[:100]}
+
+def gemini_json(prompt: str, temp=0.4, tokens=1500) -> Dict:
+    prompt += "\n\n**JSON PURO. SEM TEXTO.**"
     try:
-        response = model.generate_content(prompt, 
+        resp = model.generate_content(prompt, 
             generation_config=genai.types.GenerationConfig(
-                temperature=temperatura, 
-                max_output_tokens=max_tokens))
-        logger.log(f"Gemini OK: {len(response.text)} chars", "DEBUG")
-        return parse_json_ultra_robusto(response.text or "")
+                temperature=temp, max_output_tokens=tokens))
+        raw = resp.text or ""
+        logger.log(f"RAW({len(raw)}): {raw[:200]}...", "RAW")
+        return PARSER_SIMPLES(raw)
     except Exception as e:
-        logger.log(f"API erro: {str(e)}", "ERROR")
+        logger.log(f"API ERRO: {e}", "ERROR")
         return {"erro": str(e)}
 
-def historico_compacto(historico: List) -> str:
-    if not historico: return "PRIMEIRO"
-    return "\n".join([str(msg).split("\n")[0][:80] for msg in historico[-2:]])
-
-def criar_dna() -> Dict:
-    return {
-        "historico_chat": [],
-        "historico_passos": {f"passo{i}": [] for i in range(10)},
-        "memoria": {"resumo": ""},
-        "meta": {"turnos": 0}
-    }
-
 # ============================================================================
-# PASSOS P0-P1 (ANTIGOS)
-# ============================================================================
-def passo_0_aluno(pergunta: str, historico: List) -> Dict:
-    logger.log("🧠 P0-ALUNO", "TASK")
-    prompt = f"""P0-ALUNO TELEGRÁFICO
-HISTÓRICO: {historico_compacto(historico)}
-PERGUNTA: {pergunta}
-
-{{"relacao": "continua|nova|corrige", "peso_hist": "alto|medio|baixo"}}"""
-    return chamar_gemini_json(prompt)
-
-def passo_1_triagem(pergunta: str, p0: Dict, historico: List) -> Dict:
-    logger.log("📊 P1-TRIAGEM", "TASK")
-    prompt = f"""P1-TRIAGEM TELEGRÁFICO
-P0: {json.dumps(p0)}
-PERGUNTA: {pergunta}
+def criar_dna(): return {
+    "chat": [],
+    "passos": {f"p{i}": [] for i in range(10)},
+    "meta": {"turnos": 0}
+}
 
-{{"tipo": "factual|subjetiva|aberta", 
-  "confianca": "alta|media|baixa",
-  "fatos": ["fato1", "fato2"]}}"""
-    return chamar_gemini_json(prompt)
+def hist_compacto(hist: List): 
+    return "\n".join([str(h).split("\n")[0][:60] for h in hist[-2:]] or ["PRIMEIRO"])
 
 # ============================================================================
-# NOVOS PASSOS X1-X2
-# ============================================================================
-def passo_x1_perguntas_necessarias(pergunta: str, p1: Dict, historico: List) -> Dict:
-    """X1: Quais perguntas precisamos responder antes dos cenários?"""
-    logger.log("❓ X1-PERGUNTAS NECESSÁRIAS", "TASK")
-    prompt = f"""X1-PERGUNTAS CRÍTICAS TELEGRÁFICO
-P1: {json.dumps(p1)}
-CONTEXTO: {historico_compacto(historico)}
-PERGUNTA PRINCIPAL: {pergunta}
-
-LACUNAS FACTUAIS/SUBJETIVAS:
-{{"perguntas": [
-  {{"texto": "pergunta curta", "necessidade": "alta|media|baixa", "relevancia": "alta|media"}}
-]}}"""
-    return chamar_gemini_json(prompt)
-
-def passo_x2_resolver_perguntas(pergunta: str, p1: Dict, x1: Dict, historico: List) -> Dict:
-    """X2: Responde as perguntas levantadas com confiança/conflito"""
-    logger.log("✅ X2-RESOLVER PERGUNTAS", "TASK")
-    perguntas = x1.get("perguntas", [])
-    prompt = f"""X2-RESOLUÇÃO TELEGRÁFICO
-P1: {json.dumps(p1)}
-PERGUNTAS X1: {json.dumps(perguntas)}
-CONTEXTO: {historico_compacto(historico)}
+# PASSOS
+def p0_aluno(pergunta: str, hist: List): 
+    logger.log("🧠 P0", "TASK")
+    return gemini_json(f"P0\nHIST: {hist_compacto(hist)}\nQ: {pergunta}\n{{\"relacao\": \"nova|continua\", \"peso\": \"alto|medio\"}}")
 
-PARA CADA PERGUNTA:
-{{"respostas": [
-  {{"pergunta": "texto original",
-    "resposta": "curta direta",
-    "confianca": "alta|media|baixa",
-    "conflito": "alto|medio|baixo",
-    "razao": "1-2 palavras"}}
-]}}"""
-    return chamar_gemini_json(prompt, max_tokens=2000)
+def p1_triagem(pergunta: str, p0: Dict, hist: List):
+    logger.log("📊 P1", "TASK")
+    return gemini_json(f"P1\nP0: {json.dumps(p0)}\nQ: {pergunta}\n{{\"tipo\": \"factual|subjetiva\", \"conf\": \"alta|baixa\"}}")
 
-# ============================================================================
-# PASSOS P2-P8 (MELHORADOS COM X1-X2)
-# ============================================================================
-def passo_2_cenarios(pergunta: str, p1: Dict, x1: Dict, x2: Dict, historico: List) -> Dict:
-    logger.log("🎯 P2-CENÁRIOS (com X1-X2)", "TASK")
-    prompt = f"""P2-CENÁRIOS TELEGRÁFICO
-P1: {json.dumps(p1)}
-X1-PERGUNTAS: {json.dumps(x1)}
-X2-RESPOSTAS: {json.dumps(x2)}
-PERGUNTA: {pergunta}
+def x1_perguntas(pergunta: str, p1: Dict, hist: List):
+    logger.log("❓ X1", "TASK")
+    return gemini_json(f"X1\nP1: {json.dumps(p1)}\nQ: {pergunta}\n{{\"perguntas\": [{{\"t\": \"pergunta\", \"nec\": \"alta|baixa\"}}]}}")
 
-{{"cenarios": {{"provaveis": [{{"id": "C1", "desc": "curto"}}],
-               "improvaveis": [{{"id": "C2", "desc": "curto"}}]}},
-  "total": 2}}"""
-    return chamar_gemini_json(prompt)
+def x2_respostas(pergunta: str, p1: Dict, x1: Dict, hist: List):
+    logger.log("✅ X2", "TASK")
+    return gemini_json(f"X2\nP1: {json.dumps(p1)}\nX1: {json.dumps(x1)}\n{{\"respostas\": [{{\"p\": \"pergunta\", \"r\": \"resposta\", \"conf\": \"alta\"}}]}}")
 
-def passo_3_isolar_cenarios(p2: Dict) -> Dict:
-    logger.log("🔍 P3-ISOLAR", "TASK")
-    exploracoes = []
-    for tipo in ['provaveis', 'improvaveis']:
-        for c in p2.get('cenarios', {}).get(tipo, [])[:2]:
-            prompt = f"""P3-ISOLAR: {c.get('id')}
-{{"id": "{c.get('id')}", "solucao": "direta", "balanco": "positivo|negativo"}}"""
-            exploracoes.append(chamar_gemini_json(prompt))
-    return {"isolados": exploracoes}
+def p2_cenarios(pergunta: str, p1: Dict, x1: Dict, x2: Dict, hist: List):
+    logger.log("🎯 P2", "TASK")
+    return gemini_json(f"P2\nP1: {json.dumps(p1)}\nX1: {json.dumps(x1)}\nX2: {json.dumps(x2)}\n{{\"cen\": {{\"prov\": [{{\"id\": \"C1\"}}], \"imp\": [{{\"id\": \"C2\"}}]}}}}")
 
-def passo_4_cruzar_validacoes(p1: Dict, p2: Dict, p3: Dict, x2: Dict) -> Dict:
-    logger.log("✅ P4-VALIDAR", "TASK")
-    prompt = f"""P4-VALIDAR TELEGRÁFICO
-{{"confiancas": [{{"fato": "X", "origem": "X1|X2|P3", "nivel": "alta|baixa"}}]}}"""
-    return chamar_gemini_json(prompt)
+def p3_isolar(p2: Dict):
+    logger.log("🔍 P3", "TASK")
+    res = []
+    for tipo in ['prov', 'imp']:
+        for c in p2.get('cen', {}).get(tipo, [])[:1]:
+            res.append(gemini_json(f"P3-{c.get('id')}\n{{\"id\": \"{c.get('id')}\", \"sol\": \"direta\"}}"))
+    return {"isol": res}
 
-def passo_5_lacunas_finais(p1: Dict, p4: Dict) -> Dict:
-    logger.log("🚨 P5-LACUNAS FINAIS", "TASK")
-    prompt = f"""P5-LACUNAS RESTANTES
-{{"lacunas": [{{"texto": "curto", "critica": "sim|nao"}}],
-  "decisao": "continuar|parar"}}"""
-    return chamar_gemini_json(prompt)
+def p4_validar(p1: Dict, p2: Dict, p3: Dict):
+    logger.log("✅ P4", "TASK")
+    return gemini_json(f"P4\n{{\"conf\": [{{\"f\": \"fato\", \"n\": \"alta\"}}]}}")
 
-def passo_6_ponderar(p2: Dict, p4: Dict, p5: Dict) -> Dict:
-    logger.log("⚖️ P6-PONDERAR", "TASK")
-    prompt = f"""P6-DECISÃO FINAL
-{{"vencedor": "C1", "peso": "0.8", "razao": "curta"}}"""
-    return chamar_gemini_json(prompt)
+def p5_lacunas(p1: Dict, p4: Dict):
+    logger.log("🚨 P5", "TASK")
+    return gemini_json(f"P5\n{{\"lac\": [{{\"t\": \"lacuna\", \"c\": \"sim\"}}], \"dec\": \"cont|par\"}}")
 
-def passo_7_sintetizar(p6: Dict) -> Dict:
-    logger.log("✍️ P7-SINTETIZAR", "TASK")
-    prompt = f"""P7-PROSA NATURAL
-P6: {json.dumps(p6)}
+def p6_ponderar(p2: Dict, p4: Dict, p5: Dict):
+    logger.log("⚖️ P6", "TASK")
+    return gemini_json(f"P6\n{{\"win\": \"C1\", \"peso\": 0.8}}")
 
-{{"resposta": "texto fluido completo"}}"""
-    return chamar_gemini_json(prompt, temperatura=0.7, max_tokens=2500)
+def p7_sintetizar(p6: Dict):
+    logger.log("✍️ P7", "TASK")
+    return gemini_json(f"P7\nP6: {json.dumps(p6)}\n{{\"resp\": \"texto final\"}}", temp=0.7, tokens=2000)
 
-def passo_8_verificar(p7: Dict) -> Dict:
-    logger.log("🔍 P8-FINAL", "TASK")
-    prompt = f"""P8-VERIFICAÇÃO
-{{"factual": "ok", "logica": "ok", "etica": "ok",
-  "final": "texto aprovado"}}"""
-    return chamar_gemini_json(prompt)
+def p8_verificar(p7: Dict):
+    logger.log("🔍 P8", "TASK")
+    return gemini_json(f"P8\n{{\"ok\": true, \"final\": \"aprovado\"}}")
 
 # ============================================================================
-# ORQUESTADOR PRINCIPAL v10
-# ============================================================================
-def processar_pipeline(pergunta: str, historico: List, arquivo_anexo=None, dna=None) -> Tuple[str, List, Dict]:
-    if dna is None or not isinstance(dna, dict):
-        dna = criar_dna()
+def processar(pergunta: str, hist: List, anexo=None, dna=None):
+    if dna is None: dna = criar_dna()
+    logger.log(f"🚀 {pergunta[:40]}", "START")
     
-    logger.log(f"🚀 v10: {pergunta[:50]}", "START")
-    if not pergunta.strip(): return "Pergunta inválida", historico, dna
+    if not pergunta.strip(): return "Pergunta inválida", hist, dna
     
-    anexo_c, tipo_a = processar_anexo(arquivo_anexo)
-    pergunta_final = construir_prompt_com_anexo(pergunta, anexo_c, tipo_a)
+    a_c, a_t = processar_anexo(anexo)
+    q = construir_prompt(pergunta, a_c, a_t)
     
-    try:
-        # P0-P1
-        p0 = passo_0_aluno(pergunta_final, historico)
-        p1 = passo_1_triagem(pergunta_final, p0, historico)
-        
-        # NOVOS X1-X2
-        x1 = passo_x1_perguntas_necessarias(pergunta_final, p1, historico)
-        x2 = passo_x2_resolver_perguntas(pergunta_final, p1, x1, historico)
-        
-        # P2 usa X1-X2
-        p2 = passo_2_cenarios(pergunta_final, p1, x1, x2, historico)
-        if p2.get("decisao") == "parar": 
-            return x1.get("perguntas", ["Esclareça"]), historico, dna
-        
-        # P3-P8 fluxo normal
-        p3 = passo_3_isolar_cenarios(p2)
-        p4 = passo_4_cruzar_validacoes(p1, p2, p3, x2)
-        p5 = passo_5_lacunas_finais(p1, p4)
-        
-        if p5.get("decisao") == "parar":
-            return "Lacuna crítica", historico, dna
-        
-        p6 = passo_6_ponderar(p2, p4, p5)
-        p7 = passo_7_sintetizar(p6)
-        p8 = passo_8_verificar(p7)
-        
-        resposta = p8.get("final", p7.get("resposta", "Erro"))
-        novo_hist = historico + [{"role": "user", "content": pergunta}, 
-                               {"role": "assistant", "content": resposta}]
-        
-        dna["historico_chat"].append({"u": pergunta, "a": resposta})
-        dna["meta"]["turnos"] += 1
-        
-        return resposta, novo_hist, dna
-        
-    except Exception as e:
-        logger.log(f"ERRO v10: {str(e)}", "ERROR")
-        return f"Erro: {str(e)}", historico, dna
+    # PIPELINE
+    p0 = p0_aluno(q, hist)
+    p1 = p1_triagem(q, p0, hist)
+    x1 = x1_perguntas(q, p1, hist)
+    x2 = x2_respostas(q, p1, x1, hist)
+    
+    p2 = p2_cenarios(q, p1, x1, x2, hist)
+    if p2.get("dec") == "par": return "Esclareça", hist, dna
+    
+    p3 = p3_isolar(p2)
+    p4 = p4_validar(p1, p2, p3)
+    p5 = p5_lacunas(p1, p4)
+    
+    if p5.get("dec") == "par": return "Lacuna", hist, dna
+    
+    p6 = p6_ponderar(p2, p4, p5)
+    p7 = p7_sintetizar(p6)
+    p8 = p8_verificar(p7)
+    
+    resp = p8.get("final") or p7.get("resp") or "Erro"
+    novo_hist = hist + [{"role": "user", "content": pergunta}, {"role": "assistant", "content": resp}]
+    
+    dna["chat"].append({"u": pergunta, "a": resp})
+    dna["meta"]["turnos"] += 1
+    
+    return resp, novo_hist, dna
 
 # ============================================================================
-# INTERFACE
-# ============================================================================
-def chat_interface(msg: str, hist: List, anexo=None, dna_json: str="{}") -> Tuple[List, str, str, None]:
-    try: dna = json.loads(dna_json) if dna_json else {}
+def chat(msg: str, hist: List, anexo=None, dna_j: str="{}"):
+    try: dna = json.loads(dna_j)
     except: dna = {}
-    
-    resp, novo_hist, dna_new = processar_pipeline(msg, hist, anexo, dna)
-    return novo_hist, "", json.dumps(dna_new, indent=2), None
+    r, nh, nd = processar(msg, hist, anexo, dna)
+    return nh, "", json.dumps(nd, indent=2)
 
 if __name__ == "__main__":
-    with gr.Blocks(title="Pipeline v10", theme=gr.themes.Soft()) as demo:
-        gr.Markdown(TITLE + "\n**X1-Perguntas → X2-Resolução → Cenários Aprofundados**")
-        
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🚀 v10 X1-X2")
         with gr.Row():
-            with gr.Column(scale=2):
-                chat = gr.Chatbot(height=550, type="messages")
-                dna_view = gr.Code(label="DNA", language="json", lines=12)
-            with gr.Column(scale=1):
-                input_txt = gr.Textbox(label="Pergunta", lines=3, scale=2)
-                file_up = gr.File(label="Anexo", file_types=[".pdf",".png",".jpg"])
-                btn_go = gr.Button("🚀 v10", variant="primary")
+            with gr.Column(2):
+                c = gr.Chatbot(height=500)
+                dj = gr.Code(label="DNA", language="json")
+            with gr.Column(1):
+                i = gr.Textbox(label="Pergunta", lines=3)
+                f = gr.File(file_types=[".pdf", ".png", ".jpg"])
+                b = gr.Button("GO", variant="primary")
         
-        btn_go.click(chat_interface, [input_txt, chat, file_up, dna_view], 
-                    [chat, input_txt, dna_view, file_up])
-        input_txt.submit(chat_interface, [input_txt, chat, file_up, dna_view], 
-                        [chat, input_txt, dna_view, file_up])
-    
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+        b.click(chat, [i,c,f,dj], [c,i,dj,f])
+        i.submit(chat, [i,c,f,dj], [c,i,dj,f])
     
+    demo.launch(server_name="0.0.0.0", port=7860)