teste padronização do nome dos projetos

scripts/handler/main.py

@@ -10,10 +10,10 @@ import time
 import platform
 import sys
 import re
-import unicodedata  # ### NOVO: Para remover acentos
+import unicodedata
 from datetime import datetime
 
-# Importando seus módulos
+# Importando seus módulos locais
 from generate_manifest import generate_manifests
 from file_parser import parse_mmp_file
 from file_saver import save_to_json, save_to_yaml
@@ -30,7 +30,7 @@ from utils import (
     LOG_FOLDER,
 )
 
-# ### NOVO: Função para padronizar nomes (igual ao Jekyll slugify) ###
+# === Função de Sanitização (Slugify) ===
 def slugify(value):
     """
     Normaliza a string: remove acentos, converte para minúsculas,
@@ -124,17 +124,21 @@ def setup_logger():
     return logger, log_filename
 
 
-def process_single_file(file_name):
-    """Worker robusto com padronização de nomes (Slugify)."""
+def process_single_file(args):
+    """
+    Worker robusto.
+    Recebe uma tupla (file_name, clean_slug) pré-calculada para evitar colisão de nomes inválidos.
+    """
+    file_name, clean_slug = args
+    
     file_path = os.path.join(MMP_FOLDER, file_name)
     pid = os.getpid()
     result = {"success": False, "file": file_name, "data": None, "error": None}
 
-    # ### NOVO: Calcula os nomes sanitizados no início ###
+    # Recupera o nome original base para exibição
     original_base_name = os.path.splitext(file_name)[0]
-    clean_slug = slugify(original_base_name)
     
-    # Define os nomes de saída baseados no Slug
+    # Define os nomes de saída baseados no Slug pré-calculado
     wav_name = clean_slug + ".wav"
     json_name = clean_slug + ".json"
     yml_name = clean_slug + ".yml"
@@ -146,19 +150,21 @@ def process_single_file(file_name):
         if file_name.endswith(".mmpz"):
             destination_path = os.path.join(MMPZ_FOLDER, file_name)
 
+            # Move o mmpz original para a pasta de backup/mmpz
             if not os.path.exists(destination_path):
                 shutil.move(file_path, destination_path)
             elif os.path.exists(file_path):
+                # Se já existe lá, apaga o da origem para não duplicar/confundir
                 os.remove(file_path)
 
-            # O dump precisa ser um arquivo temporário ou manter o nome original para processamento interno
-            # mas vamos manter o fluxo original de dump para parsing
-            mmp_temp_name = original_base_name + ".mmp" 
+            # Define o nome do arquivo MMP extraído usando o SLUG (padronizado)
+            mmp_temp_name = clean_slug + ".mmp" 
             output_mmp_path = os.path.join(MMP_FOLDER, mmp_temp_name)
 
             abs_dest = os.path.abspath(destination_path)
             abs_mmp_out = os.path.abspath(output_mmp_path)
 
+            # Comando para descompactar (dump)
             dump_cmd = ["lmms", "--dump", abs_dest]
 
             try:
@@ -175,7 +181,7 @@ def process_single_file(file_name):
                 logging.error(f"[PID {pid}] {result['error']}")
                 return result
 
-            # ### ALTERADO: Geração do WAV usa o nome sanitizado ###
+            # Comando para gerar WAV
             abs_wav_out = os.path.abspath(os.path.join(WAV_FOLDER, wav_name))
 
             wav_cmd = [
@@ -194,28 +200,26 @@ def process_single_file(file_name):
             except subprocess.CalledProcessError as e:
                 logging.warning(f"[PID {pid}] Falha no WAV: {e.stderr}")
 
+            # Define qual arquivo será lido pelo parser
             file_to_parse = output_mmp_path
 
         elif file_name.endswith(".mmp"):
+            # Se já for MMP, usa ele direto
             file_to_parse = file_path
             
-            # Se for apenas MMP, geramos o wav também se não existir? 
-            # O código original não gerava WAV para .mmp puros explicitamente aqui, 
-            # mas assumindo que segue a lógica do mmpz:
-            # (Adicione logica de render wav p/ mmp puro se necessário aqui)
+            # (Opcional) Gerar WAV para .mmp puro se necessário
+            # Se quiser gerar wav para .mmp puro, a lógica seria similar à acima
 
         # 2. Parsing e Salvamento
         if os.path.exists(file_to_parse):
             mmp_data = parse_mmp_file(file_to_parse)
 
             if mmp_data:
-                # ### NOVO: Injeta metadados de padronização ###
-                # Substitui o nome do arquivo nos dados pelo slug (para links funcionarem)
+                # Injeta metadados de padronização
                 mmp_data["file"] = clean_slug 
-                # Adiciona o título original para exibição bonita na tela
                 mmp_data["original_title"] = original_base_name
                 
-                # Salva usando os nomes sanitizados
+                # Salva metadados usando os nomes sanitizados
                 save_to_json(
                     mmp_data, os.path.join(METADATA_FOLDER, json_name)
                 )
@@ -224,9 +228,9 @@ def process_single_file(file_name):
                 result["success"] = True
                 result["data"] = mmp_data
                 
-                # Limpeza do mmp temporário gerado do dump (opcional, para não lotar a pasta)
-                if file_name.endswith(".mmpz") and os.path.exists(file_to_parse):
-                    os.remove(file_to_parse)
+                # === IMPORTANTE: NÃO DELETAMOS MAIS O ARQUIVO MMP ===
+                # O arquivo file_to_parse (que agora é slug.mmp) permanece na pasta.
+                
             else:
                 result["error"] = "Dados vazios após parsing."
         else:
@@ -246,7 +250,7 @@ def main_parallel():
     check_system_dependencies()
 
     log_system_info()
-    logging.info("=== Iniciando Pipeline Otimizado (Com Sanitização) ===")
+    logging.info("=== Iniciando Pipeline Otimizado (Com Sanitização e Persistência MMP) ===")
 
     create_folders_if_not_exist([MMPZ_FOLDER, WAV_FOLDER, METADATA_FOLDER, DATA_FOLDER])
 
@@ -254,17 +258,37 @@ def main_parallel():
         logging.critical(f"Pasta {MMP_FOLDER} não encontrada.")
         return
 
-    all_files = [f for f in os.listdir(MMP_FOLDER) if f.endswith((".mmp", ".mmpz"))]
+    all_files_raw = [f for f in os.listdir(MMP_FOLDER) if f.endswith((".mmp", ".mmpz"))]
 
-    if not all_files:
+    if not all_files_raw:
         logging.warning("Nenhum arquivo encontrado.")
         return
 
-    num_cores = multiprocessing.cpu_count()
-    logging.info(f"Processando {len(all_files)} arquivos com {num_cores} workers.")
+    # === PRÉ-PROCESSAMENTO DOS SLUGS ===
+    # Calcula os slugs sequencialmente para garantir contagem correta de nomes inválidos
+    tasks = []
+    invalid_count = 0
+    
+    logging.info("Calculando nomes sanitizados e preparando tarefas...")
+    
+    for file_name in all_files_raw:
+        original_base = os.path.splitext(file_name)[0]
+        slug = slugify(original_base)
+        
+        # Se o nome sanitizado ficou vazio (ex: "!!!.mmp" -> ""), gera nome padrão
+        if not slug:
+            invalid_count += 1
+            slug = f"titulo-incorreto-{invalid_count}"
+            logging.warning(f"Nome inválido detectado: '{file_name}'. Renomeando para '{slug}'")
+            
+        tasks.append((file_name, slug))
 
+    num_cores = multiprocessing.cpu_count()
+    logging.info(f"Processando {len(tasks)} arquivos com {num_cores} workers.")
+
+    # O pool.map agora envia a tupla (arquivo, slug)
     with multiprocessing.Pool(processes=num_cores) as pool:
-        results = pool.map(process_single_file, all_files)
+        results = pool.map(process_single_file, tasks)
 
     successful_data = [r["data"] for r in results if r["success"]]
     failed_files = [r for r in results if not r["success"]]