deploy from github actions

app/models/process.py

@@ -58,4 +58,5 @@ class Worker(Base):
     token = Column(String, unique=True, index=True, nullable=True)
     command = Column(String, default="none")  # start | stop | none
     is_active = Column(Boolean, default=False)
+    url = Column(String, nullable=True)  # URL de despertar / HuggingFace Space URL
 

app/routers/lyrics.py

@@ -475,8 +475,8 @@ def update_repertoire(id: int, rep: RepertorioCreate, db: Session = Depends(get_
         for idx, lyric_id in enumerate(rep.lyrics_ids):
             db_rep_lyric = RepertorioLyric(repertorio_id=id, lyric_id=lyric_id, order=idx)
             db.add(db_rep_lyric)
-        db.commit()
-        
+            
+    db.commit()
     db.refresh(db_rep)
     if db_rep.group_id is not None:
         try:

app/routers/songs.py

@@ -43,6 +43,7 @@ load_dotenv()
 # Importar tasks desde el directorio padre
 sys.path.append(os.getcwd())
 from tasks import procesar_cancion_completa, celery_app
+from app.utils.hf_wake import wake_hf_workers
 
 # ==========================================
 # CONFIGURACIÓN Y LOGGING
@@ -240,6 +241,7 @@ async def queue_cloud_song(
         job = procesar_cancion_completa.apply_async(**kwargs_async)
         nuevo_proceso.celery_id = job.id
         db.commit()
+        wake_hf_workers()
         return {
             "message": "Encolado desde la nube",
             "task_id": task_id,
@@ -420,6 +422,7 @@ async def subir_cancion(
             kwargs_async["queue"] = queue_name
         job = procesar_cancion_completa.apply_async(**kwargs_async)
         logger.info(f"[{task_id}] Tarea encolada: {job.id}")
+        wake_hf_workers()
 
         return {
             "celery_id": job.id,
@@ -504,6 +507,7 @@ def subir_youtube(
             kwargs_async["queue"] = queue_name
         job = procesar_cancion_completa.apply_async(**kwargs_async)
         logger.info(f"[{task_id}] Tarea YouTube encolada: {job.id}")
+        wake_hf_workers()
         return {
             "celery_id": job.id,
             "task_id": task_id,

app/routers/workers.py

@@ -157,6 +157,15 @@ def delete_worker(worker_id: int, db: Session = Depends(get_db), current_admin:
     ws_manager.broadcast_sync({"type": "refresh", "tab": "workers"})
     return {"message": "Worker eliminado exitosamente"}
 
+@router.post("/wake")
+def wake_workers():
+    """
+    Endpoint para despertar manualmente los workers de Hugging Face y la red.
+    """
+    from app.utils.hf_wake import wake_hf_workers
+    wake_hf_workers()
+    return {"message": "Peticiones de despertar enviadas a los workers de Hugging Face."}
+
 # ==========================================
 # BYOK / LOCAL WORKERS ENDPOINTS
 # ==========================================

app/utils/hf_wake.py

@@ -0,0 +1,149 @@
+import os
+import logging
+import threading
+import time
+import requests
+from datetime import datetime, timedelta
+
+logger = logging.getLogger(__name__)
+
+def get_hf_spaces_config():
+    """
+    Obtiene la lista de Hugging Face Spaces o URLs de workers configuradas desde las variables de entorno.
+    Soporta repositorios (ej: 'Isaac105/melodix-worker') o URLs completas.
+    """
+    raw = os.getenv("HF_SPACES") or os.getenv("HF_WORKER_SPACES") or os.getenv("HF_WORKERS") or ""
+    spaces = [s.strip() for s in raw.split(",") if s.strip()]
+    return spaces
+
+def wake_hf_workers():
+    """
+    Intenta despertar los Hugging Face Spaces o workers remotos configurados.
+    Utiliza la API de Hugging Face (HfApi.restart_space / get_space_runtime)
+    y pings HTTP directos a las URLs de los Spaces.
+    """
+    def _do_wake():
+        hf_token = os.getenv("HF_TOKEN")
+        spaces_config = get_hf_spaces_config()
+        
+        # Buscar también en la base de datos workers con URL configurada
+        try:
+            from app.database import SessionLocal
+            from app.models.process import Worker
+            db = SessionLocal()
+            try:
+                db_workers = db.query(Worker).all()
+                for w in db_workers:
+                    if w.url and w.url not in spaces_config:
+                        spaces_config.append(w.url)
+            finally:
+                db.close()
+        except Exception as e:
+            logger.warning(f"[HF Wake] Error consultando URLs de workers en DB: {e}")
+
+        if not spaces_config:
+            logger.info("[HF Wake] No hay Hugging Face Spaces o URLs configuradas en HF_SPACES ni en DB.")
+            return
+
+        logger.info(f"[HF Wake] Iniciando intento de despertar para {len(spaces_config)} space(s) / worker(s)...")
+
+        # Inicializar HfApi si existe token
+        hf_api = None
+        if hf_token:
+            try:
+                from huggingface_hub import HfApi
+                hf_api = HfApi(token=hf_token)
+            except Exception as e:
+                logger.warning(f"[HF Wake] No se pudo inicializar HfApi: {e}")
+
+        for target in spaces_config:
+            try:
+                # Si el target es formato repo_id ("Usuario/nombre-space")
+                if "/" in target and not target.startswith("http"):
+                    space_repo = target
+                    if hf_api:
+                        try:
+                            runtime = hf_api.get_space_runtime(repo_id=space_repo)
+                            stage = getattr(runtime, 'stage', 'UNKNOWN')
+                            logger.info(f"[HF Wake] Space '{space_repo}' estado runtime: {stage}")
+                            if stage in ["SLEEPING", "PAUSED", "STOPPED", "OFF", "BUILD_ERROR", "RUNTIME_ERROR"]:
+                                logger.info(f"[HF Wake] Reiniciando Space dormido '{space_repo}' vía HF API...")
+                                hf_api.restart_space(repo_id=space_repo)
+                        except Exception as ex_api:
+                            logger.warning(f"[HF Wake] Error en restart_space para '{space_repo}': {ex_api}")
+
+                    parts = space_repo.split('/')
+                    target_url = f"https://huggingface.co/spaces/{parts[0]}/{parts[1]}"
+                else:
+                    target_url = target
+
+                # Hacer ping HTTP para activar el proxy de Hugging Face
+                if target_url.startswith("http"):
+                    logger.info(f"[HF Wake] Enviando ping HTTP para despertar a: {target_url}")
+                    try:
+                        resp = requests.get(target_url, timeout=12, headers={"User-Agent": "Melodix-Wake-Bot/1.0"})
+                        logger.info(f"[HF Wake] Ping HTTP a {target_url} enviado. Status code: {resp.status_code}")
+                    except Exception as http_err:
+                        logger.warning(f"[HF Wake] Respuesta del ping HTTP a {target_url}: {http_err}")
+            except Exception as err:
+                logger.error(f"[HF Wake] Error despertando worker '{target}': {err}")
+
+    # Ejecutar en hilo daemon independiente para no bloquear el hilo de FastAPI
+    threading.Thread(target=_do_wake, daemon=True).start()
+
+def check_and_wake_workers_if_needed():
+    """
+    Verifica si hay tareas pendientes en la DB y si NO hay workers activos.
+    Si hay tareas sin atender, invoca wake_hf_workers().
+    """
+    try:
+        from app.database import SessionLocal
+        from app.models.process import Task, Worker
+        db = SessionLocal()
+        try:
+            # 1. Tareas en espera
+            pending_count = db.query(Task).filter(Task.status.in_(["PENDING", "PROCESSING"])).count()
+            if pending_count == 0:
+                return
+
+            # 2. Workers reportando en los últimos 2 minutos
+            two_mins_ago = datetime.utcnow() - timedelta(minutes=2)
+            active_workers_count = db.query(Worker).filter(
+                Worker.status.in_(["online", "busy"]),
+                Worker.last_seen >= two_mins_ago
+            ).count()
+
+            logger.info(f"[HF Monitor] Tareas pendientes: {pending_count} | Workers activos: {active_workers_count}")
+
+            if active_workers_count == 0:
+                logger.warning(f"[HF Monitor] ⚠️ {pending_count} tarea(s) en espera y 0 workers activos. Despertando Hugging Face Workers...")
+                wake_hf_workers()
+        finally:
+            db.close()
+    except Exception as e:
+        logger.error(f"[HF Monitor] Error verificando estado de tareas/workers: {e}")
+
+
+_monitor_thread_started = False
+
+def start_worker_monitor_loop(interval_seconds: int = 45):
+    """
+    Inicia un hilo en segundo plano que monitorea periódicamente la cola de tareas
+    y despierta los workers de Hugging Face si están dormidos.
+    """
+    global _monitor_thread_started
+    if _monitor_thread_started:
+        return
+    _monitor_thread_started = True
+
+    def _loop():
+        logger.info(f"[HF Monitor] Bucle de monitoreo de workers iniciado (intervalo: {interval_seconds}s).")
+        while True:
+            try:
+                check_and_wake_workers_if_needed()
+            except Exception as e:
+                logger.error(f"[HF Monitor] Error en ciclo de monitoreo: {e}")
+            time.sleep(interval_seconds)
+
+    thread = threading.Thread(target=_loop, daemon=True)
+    thread.start()

main.py

@@ -145,6 +145,11 @@ async def startup_event():
     logger.info("=" * 50)
     logger.info("MELODIX API INICIANDO")
     logger.info("=" * 50)
+    try:
+        from app.utils.hf_wake import start_worker_monitor_loop
+        start_worker_monitor_loop(interval_seconds=45)
+    except Exception as e:
+        logger.error(f"Error iniciando monitor de workers HF: {e}")
 
 @app.on_event("shutdown")
 async def shutdown_event():

migrate_worker_url.py

@@ -0,0 +1,19 @@
+import sys
+import os
+sys.path.insert(0, os.path.abspath('.'))
+
+from sqlalchemy import text
+from app.database import engine
+
+def run_migration():
+    print("Ejecutando migracion para agregar columna 'url' a la tabla 'workers'...")
+    with engine.connect() as conn:
+        try:
+            conn.execute(text("ALTER TABLE workers ADD COLUMN IF NOT EXISTS url TEXT DEFAULT NULL;"))
+            conn.commit()
+            print("Columna 'url' agregada a la tabla 'workers' exitosamente.")
+        except Exception as e:
+            print(f"Error o ya existe: {e}")
+
+if __name__ == "__main__":
+    run_migration()