Update app.py

app.py

@@ -3,6 +3,8 @@ import json
 import time
 import hashlib
 from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
 import gradio as gr
 import google.generativeai as genai
 
@@ -26,6 +28,7 @@ model_pro = genai.GenerativeModel("gemini-pro-latest")
 ARQUIVO_CONFIG = "protocolo.json"
 PASTA_TRANSCRICOES = "transcricoes"
 PAGES_PER_CHUNK = 10
+MAX_WORKERS = 5  # Limite de chamadas paralelas
 
 os.makedirs(PASTA_TRANSCRICOES, exist_ok=True)
 
@@ -51,7 +54,6 @@ def salvar_protocolo(conteudo):
         return "❌ Erro JSON"
 
 def limpar_nome_arquivo(nome):
-    # Remove caracteres inválidos para nome de arquivo e garante extensão .json
     nome_base = os.path.basename(nome)
     nome_limpo = "".join([c for c in nome_base if c.isalnum() or c in (' ', '.', '_', '-')]).strip()
     return nome_limpo + ".json"
@@ -129,6 +131,7 @@ def ler_arquivo_texto(arquivo):
 # ==================== 3. PIPELINE DE IA ====================
 
 def transcrever_chunk(chunk_data, config_agentes):
+    # Função auxiliar para ser executada na thread
     modelo = model_flash
     try:
         if config_agentes and isinstance(config_agentes, list):
@@ -146,9 +149,17 @@ Texto extraído:
 Retorne JSON: {{ "transcricao": "...", "objetos": ["..."], "resumo": "..." }}
 """
     try:
-        resposta = modelo.generate_content(prompt)
-        texto_resp = resposta.text.replace("```json", "").replace("```", "")
-        return json.loads(texto_resp.strip()), None
+        # Retry simples em caso de erro 429 (rate limit)
+        for tentativa in range(3):
+            try:
+                resposta = modelo.generate_content(prompt)
+                texto_resp = resposta.text.replace("```json", "").replace("```", "")
+                return json.loads(texto_resp.strip()), None
+            except Exception as inner_e:
+                if "429" in str(inner_e):
+                    time.sleep(2 * (tentativa + 1))
+                    continue
+                raise inner_e
     except Exception as e:
         return None, str(e)
 
@@ -178,13 +189,13 @@ class GerenciadorArquivos:
                 prompt += f"\n[ARQUIVO: {nome}]\n"
                 
                 if isinstance(trans, dict) and "chunks_processados" in trans:
+                    # Como garantimos a ordem na lista chunks_processados, iteramos normalmente
                     for chunk in trans["chunks_processados"]:
                         if chunk.get("status") == "OK":
                             resumo = chunk.get('resumo', '')
                             resumo = str(resumo) if resumo else ""
                             prompt += f"Páginas {chunk['paginas']}: {resumo}\n"
                             
-                            # Correção do erro de slice
                             texto_full = chunk.get('transcricao', '')
                             if texto_full:
                                 texto_seguro = str(texto_full)
@@ -236,27 +247,21 @@ def automacao_upload_processamento(files, history, config_json):
         caminho_cache = os.path.join(PASTA_TRANSCRICOES, nome_cache)
         
         if os.path.exists(caminho_cache):
-            # Se já existe, carrega e pula o processamento
             try:
                 with open(caminho_cache, "r", encoding="utf-8") as cache_file:
                     dados_cache = json.load(cache_file)
-                
                 item["transcricao"] = dados_cache
                 item["status"] = "processado"
-                
-                # Simula estrutura de processamento básico se for PDF para manter compatibilidade
                 if nome.lower().endswith('.pdf') and "chunks_processados" in dados_cache:
-                     item["processado"] = {"tipo": "pdf", "chunks": []} # Simplificado pois já temos a transcrição
-
-                history.append([None, f"♻️ **Cache Encontrado:** `{nome}` já foi processado anteriormente. Carregando..."])
+                     item["processado"] = {"tipo": "pdf", "chunks": []}
+                history.append([None, f"♻️ **Cache Encontrado:** `{nome}` já foi processado. Carregando..."])
                 yield history
-                continue # Pula para o próximo arquivo
+                continue
             except Exception as e:
-                history.append([None, f"⚠️ Erro ao ler cache de `{nome}`: {e}. Reprocessando..."])
-
-        # --- FIM VERIFICAÇÃO ---
+                history.append([None, f"⚠️ Erro cache `{nome}`: {e}. Reprocessando..."])
+        # ---------------------------
 
-        history.append([None, f"⚙️ **Processando (Nova Transcrição):** `{nome}`..."])
+        history.append([None, f"⚙️ **Processando:** `{nome}`..."])
         yield history
 
         if nome.lower().endswith('.pdf'):
@@ -274,44 +279,67 @@ def automacao_upload_processamento(files, history, config_json):
             item["processado"] = pdf_proc
             chunks = pdf_proc["chunks"]
             total_chunks = len(chunks)
-            chunks_processados = []
             
-            history.append([None, f"���� `{nome}` fragmentado em {total_chunks} partes. Iniciando IA..."])
+            # Inicializa lista com o tamanho exato para garantir a ordem
+            chunks_ordenados = [None] * total_chunks
+            
+            history.append([None, f"📄 `{nome}` fragmentado em {total_chunks} partes. Iniciando IA (Paralelo: {MAX_WORKERS} threads)..."])
             yield history
 
-            for i, chunk in enumerate(chunks):
-                res, err = transcrever_chunk(chunk, config_agentes)
-                if err:
-                    chunks_processados.append({"status": "ERRO", "paginas": chunk["paginas"]})
-                else:
-                    chunks_processados.append({
-                        "status": "OK",
-                        "paginas": chunk["paginas"],
-                        "transcricao": res.get("transcricao"),
-                        "resumo": res.get("resumo")
-                    })
-            
+            # --- PROCESSAMENTO PARALELO ---
+            with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+                # Dicionário para mapear Future -> Índice Original
+                futures_map = {}
+                
+                # Submeter todas as tarefas
+                for i, chunk in enumerate(chunks):
+                    future = executor.submit(transcrever_chunk, chunk, config_agentes)
+                    futures_map[future] = i
+                
+                # Coletar resultados conforme ficam prontos
+                concluidos = 0
+                for future in as_completed(futures_map):
+                    index_original = futures_map[future]
+                    res, err = future.result()
+                    
+                    if err:
+                        chunks_ordenados[index_original] = {"status": "ERRO", "paginas": chunks[index_original]["paginas"]}
+                    else:
+                        chunks_ordenados[index_original] = {
+                            "status": "OK",
+                            "paginas": chunks[index_original]["paginas"],
+                            "transcricao": res.get("transcricao"),
+                            "resumo": res.get("resumo")
+                        }
+                    
+                    concluidos += 1
+                    # Atualiza a UI a cada 2 chunks ou no final para não flodar
+                    if concluidos % 2 == 0 or concluidos == total_chunks:
+                        msg_base = f"📄 `{nome}`: Processando partes... ({concluidos}/{total_chunks})"
+                        history[-1][1] = msg_base
+                        yield history
+            # ------------------------------
+
             dados_finais = {
                 "arquivo": nome,
                 "data_processamento": str(datetime.now()),
-                "chunks_processados": chunks_processados
+                "chunks_processados": chunks_ordenados # Agora contém a lista na ordem correta
             }
             
             item["transcricao"] = dados_finais
             item["status"] = "processado"
             
-            # --- SALVAR NO CACHE ---
             try:
                 with open(caminho_cache, "w", encoding="utf-8") as f_out:
                     json.dump(dados_finais, f_out, indent=2, ensure_ascii=False)
                 history.append([None, f"💾 `{nome}` processado e salvo no cache."])
             except Exception as e:
                  history.append([None, f"⚠️ Erro ao salvar cache: {e}"])
-            # -----------------------
-
+            
             yield history
 
         else:
+            # Processamento de Texto Simples (não precisa de paralelismo pois é 1 chunk)
             res = ler_arquivo_texto(item["arquivo"])
             if res:
                 item["processado"] = res
@@ -319,7 +347,6 @@ def automacao_upload_processamento(files, history, config_json):
                 item["transcricao"] = dados_finais
                 item["status"] = "processado"
                 
-                # Salvar Cache Texto
                 with open(caminho_cache, "w", encoding="utf-8") as f_out:
                     json.dump(dados_finais, f_out, indent=2, ensure_ascii=False)
                 
@@ -333,7 +360,6 @@ def automacao_upload_processamento(files, history, config_json):
 
 
 def chat_orquestrador(message, history, config_json):
-    # 1. Montar Prompt (Agora com correção no Gerenciador)
     try:
         prompt_contexto = gerenciador.gerar_prompt_com_transcricoes(message)
     except Exception as e: