update

app.py

@@ -1,52 +1,123 @@
-import gradio as gr
+# --- 1. IMPORTS ---
+# Imports do seu train.py e do Gradio
 import os
-import time
+import glob
+import json
+import csv
+import numpy as np
+from sentence_transformers import SentenceTransformer
 import zipfile
+import xml.etree.ElementTree as ET
+import gradio as gr
 import shutil
 
-# --- 1. CONFIGURAÇÕES E CONSTANTES ---
-# Defina os caminhos e nomes de arquivos importantes aqui.
-# Isso facilita a manutenção.
+# --- 2. CONFIGURAÇÕES E CONSTANTES ---
+# Caminhos relativos são melhores para portabilidade no Hugging Face Spaces
+DATA_DIR = "dados"
+EXTRACT_DIR = os.path.join(DATA_DIR, "dados_extraidos")
+
+# ATIVA O ARMAZENAMENTO PERSISTENTE NAS CONFIGURAÇÕES DO SEU SPACE!
+# Se ativado, mude o caminho para algo como "/data/meus_embeddings.npy"
+OUTPUT_FILENAME = "meus_embeddings_e5_large.npy" 
 
-# ATENÇÃO: No Hugging Face Spaces, o armazenamento é efêmero por padrão.
-# Para salvar os embeddings permanentemente, ative o "Persistent Storage" nas configurações do seu Space.
-# O caminho para o armazenamento persistente geralmente começa com /data
-# Se você tiver armazenamento persistente, mude o caminho abaixo:
-# OUTPUT_EMBEDDINGS_FILE = "/data/embeddings_gerados.faiss" 
-OUTPUT_EMBEDDINGS_FILE = "embeddings_gerados.faiss" # Usando armazenamento temporário por enquanto
+# --- 3. SUAS FUNÇÕES DE PROCESSAMENTO (DO TRAIN.PY) ---
+# Copiamos suas funções de ajuda diretamente para cá.
 
-DATA_DIR = "dados"
-ZIP_FILE_PATH = os.path.join(DATA_DIR, "Treinamento do PGL_4.zip")
-EXTRACT_PATH = os.path.join(DATA_DIR, "extraidos")
+def setup_data():
+    """Descompacta os arquivos .zip e retorna o diretório de processamento."""
+    os.makedirs(EXTRACT_DIR, exist_ok=True)
+    zip_files = glob.glob(os.path.join(DATA_DIR, "*.zip")) # Simplificado para buscar zips na pasta 'dados'
+    if not zip_files:
+        print("Nenhum arquivo .zip encontrado, usando o diretório de dados principal.")
+        return DATA_DIR
+    for zip_path in zip_files:
+        with zipfile.ZipFile(zip_path, 'r') as zf:
+            zf.extractall(EXTRACT_DIR)
+    return EXTRACT_DIR
+
+def xml_to_dict(element):
+    """Converte um elemento XML para um dicionário Python."""
+    d = {}
+    for child in element:
+        child_dict = xml_to_dict(child)
+        if child.tag in d:
+            if not isinstance(d[child.tag], list):
+                d[child.tag] = [d[child.tag]]
+            d[child.tag].append(child_dict)
+        else:
+            d[child.tag] = child_dict
+    if not d:
+        return element.text
+    return d
 
-# --- 2. FUNÇÕES DE PROCESSAMENTO ---
-# Cada etapa do seu processo original foi transformada em uma função.
+def serialize_item_to_text(item_dict):
+    """Converte um dicionário (de JSON, CSV, etc.) para uma string de texto plano."""
+    parts = []
+    if not isinstance(item_dict, dict):
+        return str(item_dict)
+    for key, value in item_dict.items():
+        if isinstance(value, dict):
+            nested_text = serialize_item_to_text(value)
+            parts.append(f"{key} ({nested_text})")
+        elif isinstance(value, list):
+            list_str = ', '.join([serialize_item_to_text(i) for i in value])
+            parts.append(f"{key}: [{list_str}]")
+        else:
+            parts.append(f"{key}: {value}")
+    return ", ".join(parts)
 
-def unzip_data():
-    """Descompacta o arquivo ZIP de dados."""
-    if os.path.exists(EXTRACT_PATH):
-        shutil.rmtree(EXTRACT_PATH) # Limpa extrações antigas
-    os.makedirs(EXTRACT_PATH, exist_ok=True)
+# --- 4. FUNÇÃO ORQUESTRADORA (LÓGICA PRINCIPAL) ---
+# Esta função substitui a sua função `main()` e é chamada pelo Gradio.
+# Ela usa `yield` para enviar atualizações de progresso para a interface.
+
+def run_full_process():
+    """Executa o pipeline completo e envia o progresso para a UI."""
+    
+    # --- ETAPA 1: SETUP E PROCESSAMENTO DE ARQUIVOS ---
+    yield "Iniciando... Descompactando arquivos..."
+    process_dir = setup_data()
     
-    with zipfile.ZipFile(ZIP_FILE_PATH, 'r') as zip_ref:
-        zip_ref.extractall(EXTRACT_PATH)
+    csv.field_size_limit(10_000_000)
+    all_files = glob.glob(os.path.join(process_dir, "**/*.json"), recursive=True) + \
+                glob.glob(os.path.join(process_dir, "**/*.csv"), recursive=True) + \
+                glob.glob(os.path.join(process_dir, "**/*.xml"), recursive=True)
     
-    # Conta os arquivos para dar um feedback similar ao original
-    files = [os.path.join(root, name) for root, dirs, files in os.walk(EXTRACT_PATH) for name in files]
-    return len(files)
-
-def process_files(num_files_to_process):
-    """
-    Simula o processamento dos 265 arquivos.
-    Esta função usa 'yield' para enviar o progresso para a interface.
-    """
-    yield f"🔎 Encontrados {num_files_to_process} arquivos para processar."
+    yield f"🔎 Encontrados {len(all_files)} arquivos para processar."
+
+    documents = []
+    for idx, filepath in enumerate(all_files):
+        try:
+            # Mostra o progresso na interface em vez de usar tqdm
+            yield f"Processando arquivo {idx + 1}/{len(all_files)}: {os.path.basename(filepath)}"
+            
+            if filepath.endswith('.json'):
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    if isinstance(data, list):
+                        for item in data: documents.append(serialize_item_to_text(item))
+                    else:
+                        documents.append(serialize_item_to_text(data))
+            elif filepath.endswith('.csv'):
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    reader = csv.DictReader(f)
+                    for row in reader: documents.append(serialize_item_to_text(row))
+            elif filepath.endswith('.xml'):
+                tree = ET.parse(filepath)
+                root = tree.getroot()
+                xml_dict = {root.tag: xml_to_dict(root)}
+                documents.append(serialize_item_to_text(xml_dict))
+        except Exception as e:
+            yield f"⚠️ Erro ao processar {os.path.basename(filepath)}: {e}"
+
+    yield f"Processamento de arquivos concluído! {len(documents)} documentos criados."
+    if not documents:
+        yield "Nenhum documento encontrado para gerar embeddings. Processo encerrado."
+        return
+
+    # --- ETAPA 2: GERAÇÃO DE EMBEDDINGS ---
+    yield "Carregando modelo de alta performance: intfloat/multilingual-e5-large..."
     
-    # Simulação do processamento de arquivos
-    for i in range(num_files_to_process + 1):
-        # ATENÇÃO: Substitua este 'time.sleep' pelo seu CÓDIGO REAL de processamento de um arquivo.
-        time.sleep(0.01) 
-        
-        # Atualiza a barra de progresso a cada iteração
-        progress_bar = "█" * int((i / num_files_to_process) * 20)
-        yield f"Processando arquivos: {int((i / num_files_to_process) *
+    # Use um cache dentro do seu Space para não baixar o modelo toda vez
+    cache_path = './model_cache'
+    os.makedirs(cache_path, exist_ok=True)
+    model = SentenceTransformer('intfloat/multilingual-