deploy from github actions

Dockerfile

@@ -2,6 +2,7 @@ FROM python:3.10-slim
 
 # Install system dependencies
 RUN apt-get update && apt-get install -y \
+    curl \
     ffmpeg \
     git \
     build-essential \
@@ -16,11 +17,15 @@ RUN pip install --upgrade pip "setuptools<70" wheel && \
     pip install --no-build-isolation madmom && \
     pip install --no-cache-dir --upgrade -r /code/requirements.txt
 
+# Pre-descargar pesos del modelo BTC de acordes en la imagen
+RUN mkdir -p /code/models && \
+    curl -L -o /code/models/btc_chord.pth https://huggingface.co/amaai-lab/music2emo/resolve/main/inference/data/btc_model.pt
+
 # Copy application files
 COPY . .
 
 # Create writable folders with permissions for Hugging Face user 1000
-RUN mkdir -p /code/processed /code/uploads /code/logs && chmod -R 777 /code
+RUN mkdir -p /code/processed /code/uploads /code/logs /code/models && chmod -R 777 /code
 
 # Grant execution rights to start script
 RUN chmod +x /code/start.sh

btc_toolkit/inference.py

@@ -144,7 +144,25 @@ class BTCChordRecognizer:
             # ==========================================
             # EXTRACCIÓN DE CARACTERÍSTICAS CQT
             # ==========================================
-            y, sr = librosa.load(audio_path, sr=SAMPLE_RATE, mono=True)
+            try:
+                y, sr = librosa.load(audio_path, sr=SAMPLE_RATE, mono=True)
+            except Exception as load_err:
+                logger.warning(f"[BTC] librosa.load falló ({load_err}), usando fallback soundfile/ffmpeg...")
+                try:
+                    import soundfile as sf
+                    y, orig_sr = sf.read(audio_path, dtype='float32')
+                    if y.ndim > 1:
+                        y = np.mean(y, axis=1)
+                    if orig_sr != SAMPLE_RATE:
+                        try:
+                            import soxr
+                            y = soxr.resample(y, orig_sr, SAMPLE_RATE)
+                        except Exception:
+                            y = librosa.resample(y, orig_sr=orig_sr, target_sr=SAMPLE_RATE)
+                    sr = SAMPLE_RATE
+                except Exception:
+                    from app.utils.harmony import _load_audio_via_ffmpeg
+                    y, sr = _load_audio_via_ffmpeg(audio_path, sr=SAMPLE_RATE)
 
             # Transformada de Q constante (CQT) - representación frecuencial de alta resolución
             # NOTA: Se ha omitido librosa.effects.harmonic por su altísimo costo en CPU

btc_toolkit/weights_manager.py

@@ -73,16 +73,28 @@ def ensure_weights_available() -> str:
     logger.info(f"[BTC] Destino: {weights_path}")
 
     try:
-        def reporthook(count, block_size, total_size):
-            """Callback de progreso durante la descarga."""
-            if total_size > 0:
-                downloaded = count * block_size
-                percent = min(100, int(downloaded * 100 / total_size))
-                mb_downloaded = downloaded / (1024 * 1024)
-                mb_total = total_size / (1024 * 1024)
-                logger.debug(f"[BTC] Descargando: {percent}% ({mb_downloaded:.1f} MB / {mb_total:.1f} MB)")
-
-        urllib.request.urlretrieve(BTC_WEIGHTS_URL, weights_path, reporthook)
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+        }
+        hf_token = os.getenv("HF_TOKEN")
+        if hf_token:
+            headers["Authorization"] = f"Bearer {hf_token}"
+
+        req = urllib.request.Request(BTC_WEIGHTS_URL, headers=headers)
+        with urllib.request.urlopen(req, timeout=60) as response, open(weights_path, 'wb') as out_file:
+            total_size = int(response.headers.get('content-length', 0))
+            downloaded = 0
+            block_size = 65536
+            while True:
+                chunk = response.read(block_size)
+                if not chunk:
+                    break
+                out_file.write(chunk)
+                downloaded += len(chunk)
+                if total_size > 0:
+                    percent = min(100, int(downloaded * 100 / total_size))
+                    if percent % 25 == 0:
+                        logger.debug(f"[BTC] Descargando: {percent}% ({downloaded / (1024*1024):.1f} MB / {total_size / (1024*1024):.1f} MB)")
 
         # Verificar que el archivo se descargó correctamente
         if not os.path.exists(weights_path) or os.path.getsize(weights_path) == 0:

requirements.txt

@@ -50,7 +50,7 @@ curl-cffi>=0.7.0             # Permite a yt-dlp impersonar Chrome (bypass bot-ch
 # Nota: ffmpeg debe estar instalado en el sistema
 
 # --- UTILIDADES ---
-setuptools
+setuptools<70.0.0
 aiofiles==23.2.1
 pydantic[email]>=2.5.3
 pydantic-settings==2.1.0

tasks.py

@@ -431,7 +431,29 @@ def detectar_y_corregir_afinacion_440(audio_path: str, output_base: str):
             return tuning_info
 
         # Cargar los primeros 45s para estimación rápida y precisa
-        y, sr = librosa.load(audio_path, sr=22050, duration=45.0, mono=True)
+        try:
+            y, sr = librosa.load(audio_path, sr=22050, duration=45.0, mono=True)
+        except Exception:
+            try:
+                y, orig_sr = sf.read(audio_path, dtype='float32')
+                if y.ndim > 1:
+                    y = np.mean(y, axis=1)
+                max_samples = int(orig_sr * 45.0)
+                if len(y) > max_samples:
+                    y = y[:max_samples]
+                if orig_sr != 22050:
+                    try:
+                        import soxr
+                        y = soxr.resample(y, orig_sr, 22050)
+                    except Exception:
+                        y = librosa.resample(y, orig_sr=orig_sr, target_sr=22050)
+                sr = 22050
+            except Exception:
+                from app.utils.harmony import _load_audio_via_ffmpeg
+                y, sr = _load_audio_via_ffmpeg(audio_path, sr=22050)
+                if len(y) > 22050 * 45:
+                    y = y[:22050 * 45]
+
         if len(y) == 0:
             return tuning_info
 
@@ -646,47 +668,39 @@ def extraer_acordes_pro(audio_path, bpm=None, beats=None):
     Intenta usar primero madmom, y si no está disponible o falla, utiliza
     el fallback a BTCChordRecognizer (PyTorch Transformer).
     """
-    # Intentar madmom primero
+    # Intentar madmom primero si está disponible
     acordes = extraer_acordes_madmom(audio_path)
-    if acordes is not None:
-        logger.info("[Acordes] Utilizando resultado exitoso de Madmom.")
+    if acordes is not None and len(acordes) > 0:
+        logger.info(f"[Acordes] Utilizando resultado exitoso de Madmom ({len(acordes)} acordes).")
         return acordes
         
     # Fallback a BTC Transformer
-    logger.info("[Acordes] Madmom no disponible o falló. Usando fallback a BTC Transformer...")
+    logger.info("[Acordes] Madmom no disponible o no retornó acordes. Usando BTC Transformer...")
     if BTCChordRecognizer is None or torch is None:
         logger.warning("[BTC] Modelo de acordes o PyTorch no disponible (no importado).")
         return []
         
     try:
-        import warnings
-        import logging as _logging
-        # Silenciar todos los logs internos de BTCChordRecognizer
-        _logging.getLogger('btc_toolkit').setLevel(_logging.CRITICAL)
-        _logging.getLogger('urllib3').setLevel(_logging.CRITICAL)
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            device = "cuda" if torch.cuda.is_available() else "cpu"
-            recognizer = BTCChordRecognizer(device=device)
-            btc_acordes = recognizer.recognize(audio_path, bpm=bpm, beats=beats)
-            
-            # Normalizar los acordes obtenidos de BTC por si acaso
-            acordes_normalizados = []
-            prev_chord = None
-            for item in btc_acordes:
-                mapped_chord = normalize_chord_to_maj_min(item["ch"])
-                if mapped_chord != 'N' and mapped_chord != prev_chord:
-                    acordes_normalizados.append({"t": item["t"], "ch": mapped_chord})
-                    prev_chord = mapped_chord
-                    
-            if acordes_normalizados and acordes_normalizados[0]["t"] > 0.5:
-                acordes_normalizados.insert(0, {"t": 0.0, "ch": acordes_normalizados[0]["ch"]})
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        recognizer = BTCChordRecognizer(device=device)
+        btc_acordes = recognizer.recognize(audio_path, bpm=bpm, beats=beats)
+        
+        # Normalizar los acordes obtenidos de BTC por si acaso
+        acordes_normalizados = []
+        prev_chord = None
+        for item in btc_acordes:
+            mapped_chord = normalize_chord_to_maj_min(item["ch"])
+            if mapped_chord != 'N' and mapped_chord != prev_chord:
+                acordes_normalizados.append({"t": item["t"], "ch": mapped_chord})
+                prev_chord = mapped_chord
                 
-            logger.info(f"[BTC] Acordes detectados tras normalización: {len(acordes_normalizados)}")
-            return acordes_normalizados
+        if acordes_normalizados and acordes_normalizados[0]["t"] > 0.5:
+            acordes_normalizados.insert(0, {"t": 0.0, "ch": acordes_normalizados[0]["ch"]})
+            
+        logger.info(f"[BTC] ✅ Acordes detectados tras normalización: {len(acordes_normalizados)}")
+        return acordes_normalizados
     except Exception as e:
-        logger.warning(f"[BTC] Falló el fallback de acordes a BTC: {e}")
-        logger.exception("Error en fallback a BTC:")
+        logger.error(f"[BTC] Error en fallback de acordes a BTC: {e}", exc_info=True)
         return []