model_inference.py

import os
import warnings
import tempfile
from basic_pitch.inference import predict_and_save
from basic_pitch import ICASSP_2022_MODEL_PATH
import tensorflow as tf

# Configurar TensorFlow para evitar problemas de GPU
os.environ['CUDA_VISIBLE_DEVICES'] = '-1'  # Forzar uso de CPU
tf.config.set_visible_devices([], 'GPU')  # Desabilitar GPU


# Suprime warnings de runtime (p.ej. invalid value encountered in divide)
warnings.filterwarnings("ignore", category=RuntimeWarning)

# Carpeta raíz donde guardamos archivos midi
BASE_MIDI_DIR = "data/midi"


def inferir_basic_pitch(input_file: str) -> str:
    """
    Procesa un archivo de audio y genera un archivo MIDI usando Basic Pitch.
    
    Args:
        input_file: Ruta al archivo de audio de entrada
        
    Returns:
        Ruta al archivo MIDI generado
    """
    # Crear directorio de salida si no existe
    os.makedirs(BASE_MIDI_DIR, exist_ok=True)
    
    try:
        print(f"Procesando archivo: {input_file}")
        print(f"Directorio de salida: {BASE_MIDI_DIR}")
        
        # Verificar que el archivo de entrada existe
        if not os.path.exists(input_file):
            print(f"Error: El archivo de entrada no existe: {input_file}")
            return None
        
        # Limpiar el directorio de salida antes del procesamiento
        for f in os.listdir(BASE_MIDI_DIR):
            if f.endswith('.mid'):
                os.remove(os.path.join(BASE_MIDI_DIR, f))
        
        # Realizar predicción y guardar archivo MIDI
        try:
            predict_and_save(
                model_or_model_path=ICASSP_2022_MODEL_PATH,
                audio_path_list=[input_file],
                output_directory=BASE_MIDI_DIR,
                save_midi=True,
                sonify_midi=False,
                save_model_outputs=False,
                save_notes=False,
            )
            print("Predicción completada")
        except Exception as model_error:
            print(f"Error específico del modelo: {model_error}")
            # Intentar con una configuración alternativa
            try:
                print("Intentando configuración alternativa...")
                predict_and_save(
                    audio_path_list=[input_file],
                    output_directory=BASE_MIDI_DIR,
                    save_midi=True,
                    sonify_midi=False,
                    save_model_outputs=False,
                    save_notes=False,
                )
                print("Predicción alternativa completada")
            except Exception as alt_error:
                print(f"Error en configuración alternativa: {alt_error}")
                return None
        
        # Buscar archivos MIDI generados
        generated_files = [f for f in os.listdir(BASE_MIDI_DIR) if f.endswith('.mid')]
        print(f"Archivos generados: {generated_files}")
        
        if generated_files:
            # Tomar el archivo más reciente
            latest_file = max([os.path.join(BASE_MIDI_DIR, f) for f in generated_files], 
                            key=os.path.getctime)
            print(f"Archivo MIDI encontrado: {latest_file}")
            return latest_file
        else:
            print("No se generó ningún archivo MIDI")
            return None
        
    except Exception as e:
        print(f"Error general durante la inferencia: {e}")
        print(f"Tipo de error: {type(e).__name__}")
        return None