fix secrets no found

SETUP_PERSISTENCE.md

@@ -0,0 +1,72 @@
+# 🔧 Configuración de Persistencia de Datos
+
+Este directorio contiene scripts para configurar la persistencia de datos usando Hugging Face Datasets.
+
+## 📋 Problema
+
+Cuando haces un **factory rebuild** en Hugging Face Spaces, todos los datos se pierden porque el contenedor se recrea desde cero.
+
+## ✅ Solución
+
+Usar Hugging Face Datasets para almacenar los datos de forma permanente.
+
+## 🚀 Pasos Rápidos
+
+### 1️⃣ Crear los Datasets (Una sola vez)
+
+Ejecuta desde tu máquina local:
+
+```bash
+python3 setup_datasets.py
+```
+
+Esto creará 4 datasets privados en tu cuenta de Hugging Face:
+- `Edoruin/makerpage-users`
+- `Edoruin/makerpage-classrooms`
+- `Edoruin/makerpage-loans`
+- `Edoruin/makerpage-faces`
+
+### 2️⃣ Configurar Secretos en HF Spaces
+
+Ve a tu Space → **Settings** → **Repository secrets** y agrega:
+
+```
+HF_TOKEN=hf_tu_token_aqui
+HF_DATASET_USERS=Edoruin/makerpage-users
+HF_DATASET_CLASSROOMS=Edoruin/makerpage-classrooms
+HF_DATASET_LOANS=Edoruin/makerpage-loans
+HF_DATASET_FACES=Edoruin/makerpage-faces
+```
+
+### 3️⃣ Migrar Datos Existentes (Opcional)
+
+Si ya tienes datos que quieres preservar, ejecuta desde el Space:
+
+```bash
+python migrate_data.py
+```
+
+### 4️⃣ Reiniciar
+
+Haz **restart** (no factory rebuild) del Space.
+
+## ✨ Verificación
+
+Revisa los logs del Space. Deberías ver:
+
+```
+[UserManager] HF Datasets: ENABLED
+[ClassroomManager] HF Datasets: ENABLED
+[LoanManager] HF Datasets: ENABLED
+[FaceManager] HF Datasets: ENABLED
+```
+
+## 🎉 ¡Listo!
+
+Ahora puedes hacer factory rebuild sin perder datos. Todo se guarda automáticamente en Hugging Face Datasets.
+
+## 📝 Notas
+
+- Los datasets son **privados** por defecto
+- Los datos se guardan en local (backup) y en HF (persistente)
+- Necesitas un token de Hugging Face con permisos de escritura

app/main.py

@@ -269,13 +269,30 @@ class ClassroomManager(HFDatasetManager):
         self.classrooms = self._load()
         
     def _load(self):
-        data = super()._load_from_hf() if self.use_hf else super()._load_from_local()
-        return data if data else []
+        """Carga los cursos desde HF Dataset o archivo JSON local."""
+        if self.use_hf:
+            data = self._load_from_hf()
+            if data is not None:
+                print(f"[ClassroomManager] Loaded {len(data)} courses from HF Dataset")
+                return data
+            print("[ClassroomManager] Failed to load from HF, trying local...")
+        
+        data = self._load_from_local()
+        print(f"[ClassroomManager] Loaded {len(data)} courses from local JSON")
+        return data
 
     def save(self):
-        if self.use_hf:
-            self._save_to_hf(self.classrooms)
+        """Guarda la lista de cursos en HF Dataset y/o archivo JSON."""
+        # Siempre guardar localmente como backup
         self._save_to_local(self.classrooms)
+        
+        # Intentar guardar en HF si está habilitado
+        if self.use_hf:
+            success = self._save_to_hf(self.classrooms)
+            if success:
+                print(f"[ClassroomManager] Saved {len(self.classrooms)} courses to HF Dataset")
+            else:
+                print("[ClassroomManager] Failed to save to HF, data saved locally only")
 
     def get_courses(self):
         return self.classrooms
@@ -426,16 +443,30 @@ class FaceManager(HFDatasetManager):
         self.faces = self._load()
     
     def _load(self):
+        """Carga los rostros desde HF Dataset o archivo JSON local."""
         if self.use_hf:
             data = self._load_from_hf()
             if data is not None:
+                print(f"[FaceManager] Loaded {len(data)} faces from HF Dataset")
                 return data
-        return self._load_from_local()
+            print("[FaceManager] Failed to load from HF, trying local...")
+        
+        data = self._load_from_local()
+        print(f"[FaceManager] Loaded {len(data)} faces from local JSON")
+        return data
 
     def save(self):
+        """Guarda la lista de rostros en HF Dataset y/o archivo JSON."""
+        # Siempre guardar localmente como backup
         self._save_to_local(self.faces)
+        
+        # Intentar guardar en HF si está habilitado
         if self.use_hf:
-            self._save_to_hf(self.faces)
+            success = self._save_to_hf(self.faces)
+            if success:
+                print(f"[FaceManager] Saved {len(self.faces)} faces to HF Dataset")
+            else:
+                print("[FaceManager] Failed to save to HF, data saved locally only")
 
     def add_face(self, label, descriptor):
         # El descriptor es una lista de 128 floats (face-api.js)

migrate_data.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+"""
+Script para migrar datos locales existentes a Hugging Face Datasets.
+Ejecutar DESPUÉS de crear los datasets vacíos con setup_datasets.py
+"""
+
+import os
+import json
+from datasets import Dataset
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Configuración
+HF_TOKEN = os.getenv("HF_TOKEN")
+USERNAME = "Edoruin"
+
+# Mapeo de archivos locales a datasets
+MIGRATIONS = [
+    {
+        "local_file": "/app/data/users.json",
+        "dataset_name": f"{USERNAME}/makerpage-users",
+        "data_key": "users",
+        "description": "Usuarios"
+    },
+    {
+        "local_file": "/app/data/classrooms.json",
+        "dataset_name": f"{USERNAME}/makerpage-classrooms",
+        "data_key": "classrooms",
+        "description": "Aulas/Cursos"
+    },
+    {
+        "local_file": "/app/data/prestamos.json",
+        "dataset_name": f"{USERNAME}/makerpage-loans",
+        "data_key": "loans",
+        "description": "Préstamos"
+    },
+    {
+        "local_file": "/app/data/faces.json",
+        "dataset_name": f"{USERNAME}/makerpage-faces",
+        "data_key": "faces",
+        "description": "Rostros"
+    }
+]
+
+def migrate_file(local_file, dataset_name, data_key, description):
+    """Migra un archivo JSON local a un dataset de HF."""
+    
+    # Verificar si el archivo existe
+    if not os.path.exists(local_file):
+        print(f"⚠️  {description}: Archivo no encontrado ({local_file}), usando datos vacíos")
+        data = []
+    else:
+        # Leer datos locales
+        try:
+            with open(local_file, 'r') as f:
+                data = json.load(f)
+            print(f"📂 {description}: {len(data)} registros encontrados")
+        except Exception as e:
+            print(f"❌ {description}: Error leyendo archivo - {e}")
+            return False
+    
+    # Subir a Hugging Face
+    try:
+        dataset_dict = {data_key: [data]}
+        dataset = Dataset.from_dict(dataset_dict)
+        dataset.push_to_hub(
+            dataset_name,
+            token=HF_TOKEN,
+            private=True
+        )
+        print(f"✅ {description}: Migrado exitosamente a {dataset_name}\n")
+        return True
+        
+    except Exception as e:
+        print(f"❌ {description}: Error subiendo a HF - {e}\n")
+        return False
+
+def main():
+    if not HF_TOKEN:
+        print("❌ ERROR: No se encontró HF_TOKEN")
+        return
+    
+    print("🔄 Iniciando migración de datos locales a Hugging Face Datasets\n")
+    print("=" * 60)
+    
+    success_count = 0
+    for migration in MIGRATIONS:
+        if migrate_file(**migration):
+            success_count += 1
+    
+    print("=" * 60)
+    print(f"\n✨ Migración completada: {success_count}/{len(MIGRATIONS)} datasets actualizados")
+    
+    if success_count == len(MIGRATIONS):
+        print("\n🎉 ¡Todos los datos han sido migrados exitosamente!")
+        print("\n📋 Próximos pasos:")
+        print("1. Reinicia tu Hugging Face Space")
+        print("2. Verifica que los datos aparezcan correctamente")
+        print("3. Ahora puedes hacer factory rebuild sin perder datos")
+    else:
+        print("\n⚠️  Algunos datasets no se pudieron migrar. Revisa los errores arriba.")
+
+if __name__ == "__main__":
+    main()

setup_datasets.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""
+Script para inicializar los datasets de Hugging Face con datos vacíos.
+Ejecutar SOLO UNA VEZ para crear los datasets iniciales.
+"""
+
+import os
+from datasets import Dataset
+from huggingface_hub import HfApi
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Configuración
+HF_TOKEN = os.getenv("HF_TOKEN")
+USERNAME = "Edoruin"  # Tu usuario de Hugging Face
+
+# Datasets a crear
+DATASETS = {
+    "users": {
+        "name": f"{USERNAME}/makerpage-users",
+        "data_key": "users",
+        "initial_data": []
+    },
+    "classrooms": {
+        "name": f"{USERNAME}/makerpage-classrooms",
+        "data_key": "classrooms",
+        "initial_data": []
+    },
+    "loans": {
+        "name": f"{USERNAME}/makerpage-loans",
+        "data_key": "loans",
+        "initial_data": []
+    },
+    "faces": {
+        "name": f"{USERNAME}/makerpage-faces",
+        "data_key": "faces",
+        "initial_data": []
+    }
+}
+
+def create_dataset(dataset_name, data_key, initial_data):
+    """Crea un dataset vacío en Hugging Face Hub."""
+    try:
+        # Crear dataset con estructura inicial
+        dataset_dict = {data_key: [initial_data]}
+        dataset = Dataset.from_dict(dataset_dict)
+        
+        # Subir a Hugging Face Hub
+        dataset.push_to_hub(
+            dataset_name,
+            token=HF_TOKEN,
+            private=True  # Dataset privado
+        )
+        
+        print(f"✅ Dataset creado: {dataset_name}")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error creando {dataset_name}: {e}")
+        return False
+
+def main():
+    if not HF_TOKEN:
+        print("❌ ERROR: No se encontró HF_TOKEN en las variables de entorno")
+        print("   Asegúrate de tener un archivo .env con HF_TOKEN=tu_token")
+        return
+    
+    print(f"🚀 Iniciando creación de datasets para usuario: {USERNAME}\n")
+    
+    for key, config in DATASETS.items():
+        print(f"📦 Creando dataset: {config['name']}")
+        create_dataset(
+            config['name'],
+            config['data_key'],
+            config['initial_data']
+        )
+        print()
+    
+    print("✨ Proceso completado!")
+    print("\n📋 Próximos pasos:")
+    print("1. Ve a Hugging Face Spaces → Settings → Repository secrets")
+    print("2. Verifica que estos secretos estén configurados:")
+    print(f"   - HF_TOKEN = {HF_TOKEN[:10]}...")
+    print(f"   - HF_DATASET_USERS = {DATASETS['users']['name']}")
+    print(f"   - HF_DATASET_CLASSROOMS = {DATASETS['classrooms']['name']}")
+    print(f"   - HF_DATASET_LOANS = {DATASETS['loans']['name']}")
+    print(f"   - HF_DATASET_FACES = {DATASETS['faces']['name']}")
+    print("\n3. Reinicia tu Space (NO factory rebuild todavía)")
+    print("4. Verifica que los logs muestren 'HF Datasets: ENABLED'")
+
+if __name__ == "__main__":
+    main()