resolvendo dependencias dos projetos

scripts/handler/main.py

@@ -127,9 +127,18 @@ def setup_logger():
 def process_single_file(args):
     """
     Worker robusto.
-    Recebe uma tupla (file_name, clean_slug) pré-calculada para evitar colisão de nomes inválidos.
+    Garante geração de WAV tanto para .mmpz quanto para .mmp.
     """
-    file_name, clean_slug = args
+    # === TRATAMENTO DE ENTRADA (Tupla ou String) ===
+    if isinstance(args, str):
+        file_name = args
+        original_base = os.path.splitext(file_name)[0]
+        clean_slug = slugify(original_base)
+        if not clean_slug:
+            clean_slug = f"upload-incorreto-{int(time.time())}"
+    else:
+        file_name, clean_slug = args
+    # ===============================================
     
     file_path = os.path.join(MMP_FOLDER, file_name)
     pid = os.getpid()
@@ -138,15 +147,18 @@ def process_single_file(args):
     # Recupera o nome original base para exibição
     original_base_name = os.path.splitext(file_name)[0]
     
-    # Define os nomes de saída baseados no Slug pré-calculado
+    # Define os nomes de saída baseados no Slug
     wav_name = clean_slug + ".wav"
     json_name = clean_slug + ".json"
     yml_name = clean_slug + ".yml"
     
+    # Variável que vai armazenar o caminho final do arquivo .mmp a ser processado/renderizado
+    target_mmp_path = ""
+
     try:
         logging.info(f"[PID {pid}] Processando: {file_name} -> Slug: {clean_slug}")
 
-        # 1. Tratamento MMPZ
+        # 1. Tratamento e Extração
         if file_name.endswith(".mmpz"):
             destination_path = os.path.join(MMPZ_FOLDER, file_name)
 
@@ -154,10 +166,9 @@ def process_single_file(args):
             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)
 
-            # Define o nome do arquivo MMP extraído usando o SLUG (padronizado)
+            # Define o nome do arquivo MMP extraído usando o SLUG
             mmp_temp_name = clean_slug + ".mmp" 
             output_mmp_path = os.path.join(MMP_FOLDER, mmp_temp_name)
 
@@ -176,18 +187,28 @@ def process_single_file(args):
                         check=True,
                         env={"QT_QPA_PLATFORM": "offscreen", **os.environ},
                     )
+                # Define o arquivo extraído como o alvo para renderização e parsing
+                target_mmp_path = output_mmp_path
+
             except subprocess.CalledProcessError as e:
                 result["error"] = f"Erro no dump MMP: {e.stderr.decode('utf-8')}"
                 logging.error(f"[PID {pid}] {result['error']}")
                 return result
 
-            # Comando para gerar WAV
+        elif file_name.endswith(".mmp"):
+            # Se já for MMP, ele é o próprio alvo
+            target_mmp_path = file_path
+
+        # 2. GERAÇÃO DE ÁUDIO (AGORA FORA DO IF/ELSE)
+        # Isso garante que rode tanto para MMPZ (usando o extraído) quanto para MMP puro
+        if os.path.exists(target_mmp_path):
+            abs_target_mmp = os.path.abspath(target_mmp_path)
             abs_wav_out = os.path.abspath(os.path.join(WAV_FOLDER, wav_name))
 
             wav_cmd = [
                 "lmms",
                 "-r",
-                abs_dest,
+                abs_target_mmp, # Usa sempre o .mmp descompactado
                 "-o",
                 abs_wav_out,
                 "-f",
@@ -196,30 +217,24 @@ def process_single_file(args):
 
             try:
                 subprocess.run(wav_cmd, check=True, capture_output=True, text=True)
-                logging.info(f"[PID {pid}] Áudio WAV gerado: {wav_name}")
+                logging.info(f"[PID {pid}] Áudio WAV gerado com sucesso: {wav_name}")
             except subprocess.CalledProcessError as e:
-                logging.warning(f"[PID {pid}] Falha no WAV: {e.stderr}")
+                logging.warning(f"[PID {pid}] Falha na geração do WAV: {e.stderr}")
+        else:
+            result["error"] = "Arquivo alvo MMP não encontrado para renderização."
+            logging.error(f"[PID {pid}] {result['error']}")
+            return result
 
-            # 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
-            
-            # (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)
+        # 3. Parsing e Salvamento de Dados
+        if os.path.exists(target_mmp_path):
+            mmp_data = parse_mmp_file(target_mmp_path)
 
             if mmp_data:
                 # Injeta metadados de padronização
                 mmp_data["file"] = clean_slug 
                 mmp_data["original_title"] = original_base_name
                 
-                # Salva metadados usando os nomes sanitizados
+                # Salva metadados
                 save_to_json(
                     mmp_data, os.path.join(METADATA_FOLDER, json_name)
                 )
@@ -228,9 +243,7 @@ def process_single_file(args):
                 result["success"] = True
                 result["data"] = mmp_data
                 
-                # === IMPORTANTE: NÃO DELETAMOS MAIS O ARQUIVO MMP ===
-                # O arquivo file_to_parse (que agora é slug.mmp) permanece na pasta.
-                
+                # Mantemos o arquivo .mmp na pasta para referência futura
             else:
                 result["error"] = "Dados vazios após parsing."
         else:
@@ -265,7 +278,6 @@ def main_parallel():
         return
 
     # === PRÉ-PROCESSAMENTO DOS SLUGS ===
-    # Calcula os slugs sequencialmente para garantir contagem correta de nomes inválidos
     tasks = []
     invalid_count = 0
     
@@ -286,7 +298,7 @@ def main_parallel():
     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)
+    # O pool.map envia a tupla (arquivo, slug)
     with multiprocessing.Pool(processes=num_cores) as pool:
         results = pool.map(process_single_file, tasks)