Update app.py

app.py

@@ -1,231 +1,93 @@
-import gradio as gr
-import json
-import sqlite3
-from datetime import datetime
-from pathlib import Path
-import os
-
-# Configuración de la base de datos
-DB_FILE = 'osorno_runners.db'
-
-def init_db():
-    """Inicializar base de datos SQLite"""
-    conn = sqlite3.connect(DB_FILE)
-    cursor = conn.cursor()
-    
-    # Tabla de planes
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS planes (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            plan_data TEXT NOT NULL,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-            created_by TEXT NOT NULL,
-            athlete_name TEXT NOT NULL,
-            distance TEXT NOT NULL,
-            race_date TEXT NOT NULL
-        )
-    ''')
-    
-    # Tabla de usuarios
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS users (
-            username TEXT PRIMARY KEY,
-            password TEXT NOT NULL,
-            role TEXT NOT NULL,
-            name TEXT NOT NULL
-        )
-    ''')
-    
-    # Insertar usuarios por defecto si no existen
-    cursor.execute('SELECT COUNT(*) FROM users')
-    if cursor.fetchone()[0] == 0:
-        cursor.execute("INSERT INTO users VALUES ('USER', '123', 'user', 'Usuario')")
-        cursor.execute("INSERT INTO users VALUES ('ADMIN', '123', 'admin', 'Administrador')")
-        print("✅ Usuarios por defecto creados: USER/123 y ADMIN/123")
-    
-    conn.commit()
-    conn.close()
-    print("✅ Base de datos inicializada correctamente")
-
-def save_plan_to_db(plan_data, username):
-    """Guardar plan en la base de datos"""
-    try:
-        conn = sqlite3.connect(DB_FILE)
-        cursor = conn.cursor()
-        
-        cursor.execute('''
-            INSERT INTO planes (plan_data, created_by, athlete_name, distance, race_date)
-            VALUES (?, ?, ?, ?, ?)
-        ''', (
-            json.dumps(plan_data),
-            username,
-            plan_data['userData']['name'],
-            plan_data['userData']['distance'],
-            plan_data['userData']['raceDate']
-        ))
-        
-        conn.commit()
-        plan_id = cursor.lastrowid
-        conn.close()
-        
-        print(f"✅ Plan guardado con ID: {plan_id}")
-        return plan_id
-    except Exception as e:
-        print(f"❌ Error al guardar plan: {e}")
-        return None
-
-def get_all_plans(username=None, role='user'):
-    """Obtener todos los planes según permisos"""
-    try:
-        conn = sqlite3.connect(DB_FILE)
-        cursor = conn.cursor()
-        
-        if role == 'admin':
-            cursor.execute('SELECT id, plan_data, created_at, created_by FROM planes ORDER BY created_at DESC')
-        else:
-            cursor.execute('SELECT id, plan_data, created_at, created_by FROM planes WHERE created_by = ? ORDER BY created_at DESC', (username,))
-        
-        plans = []
-        for row in cursor.fetchall():
-            plan_data = json.loads(row[1])
-            plan_data['id'] = row[0]
-            plan_data['createdAt'] = row[2]
-            plan_data['createdBy'] = row[3]
-            plans.append(plan_data)
-        
-        conn.close()
-        print(f"✅ Cargados {len(plans)} planes para {username} ({role})")
-        return plans
-    except Exception as e:
-        print(f"❌ Error al cargar planes: {e}")
-        return []
-
-def delete_plan_from_db(plan_id):
-    """Eliminar plan de la base de datos"""
-    try:
-        conn = sqlite3.connect(DB_FILE)
-        cursor = conn.cursor()
-        cursor.execute('DELETE FROM planes WHERE id = ?', (plan_id,))
-        conn.commit()
-        conn.close()
-        print(f"✅ Plan {plan_id} eliminado")
-        return True
-    except Exception as e:
-        print(f"❌ Error al eliminar plan: {e}")
-        return False
-
-def authenticate_user(username, password):
-    """Autenticar usuario"""
-    try:
-        conn = sqlite3.connect(DB_FILE)
-        cursor = conn.cursor()
-        cursor.execute('SELECT role, name FROM users WHERE username = ? AND password = ?', 
-                      (username.upper(), password))
-        result = cursor.fetchone()
-        conn.close()
-        
-        if result:
-            user_data = {
-                'username': username.upper(),
-                'role': result[0],
-                'name': result[1]
-            }
-            print(f"✅ Login exitoso: {username} ({result[0]})")
-            return user_data
-        else:
-            print(f"❌ Login fallido: {username}")
-            return None
-    except Exception as e:
-        print(f"❌ Error en autenticación: {e}")
-        return None
-
-# APIs para el frontend
-def api_login(request: gr.Request):
-    """API de login"""
-    try:
-        data = json.loads(request.query_params.get('data', '{}'))
-        username = data.get('username', '')
-        password = data.get('password', '')
-        
-        user = authenticate_user(username, password)
-        if user:
-            return json.dumps({'success': True, 'user': user})
-        return json.dumps({'success': False, 'error': 'Credenciales inválidas'})
-    except Exception as e:
-        return json.dumps({'success': False, 'error': str(e)})
-
-def api_save_plan(request: gr.Request):
-    """API para guardar plan"""
-    try:
-        data = json.loads(request.query_params.get('data', '{}'))
-        plan_json = data.get('plan', '{}')
-        username = data.get('username', '')
-        
-        plan_data = json.loads(plan_json)
-        plan_id = save_plan_to_db(plan_data, username)
-        
-        if plan_id:
-            return json.dumps({'success': True, 'id': plan_id})
-        return json.dumps({'success': False, 'error': 'Error al guardar'})
-    except Exception as e:
-        return json.dumps({'success': False, 'error': str(e)})
-
-def api_get_plans(request: gr.Request):
-    """API para obtener planes"""
-    try:
-        data = json.loads(request.query_params.get('data', '{}'))
-        username = data.get('username', '')
-        role = data.get('role', 'user')
-        
-        plans = get_all_plans(username, role)
-        return json.dumps({'success': True, 'plans': plans})
-    except Exception as e:
-        return json.dumps({'success': False, 'error': str(e)})
-
-def api_delete_plan(request: gr.Request):
-    """API para eliminar plan"""
-    try:
-        data = json.loads(request.query_params.get('data', '{}'))
-        plan_id = data.get('plan_id', 0)
-        
-        success = delete_plan_from_db(plan_id)
-        if success:
-            return json.dumps({'success': True})
-        return json.dumps({'success': False, 'error': 'Error al eliminar'})
-    except Exception as e:
-        return json.dumps({'success': False, 'error': str(e)})
-
-# Inicializar BD al arrancar
-print("🚀 Iniciando Osorno Runners - Sistema de Entrenamiento")
-init_db()
-
-# Leer HTML
-html_path = Path("index.html")
-if html_path.exists():
-    html_content = html_path.read_text(encoding='utf-8')
-    print("✅ HTML cargado correctamente")
-else:
-    html_content = "<h1>Error: index.html no encontrado</h1>"
-    print("❌ Error: index.html no encontrado")
-
-# Crear interfaz Gradio
-with gr.Blocks(
-    title="Osorno Runners",
-    theme=gr.themes.Soft(),
-    css="""
-        .gradio-container {padding: 0 !important;}
-        .contain {max-width: 100% !important;}
-    """
-) as app:
-    gr.HTML(html_content)
-
-# Configuración del servidor
+import os, json, io
+lines = []
+try:
+path = hf_hub_download(repo_id=OUT_DATASET, repo_type="dataset", filename=OUT_FILE, token=HF_TOKEN)
+with open(path, "r", encoding="utf-8") as f:
+lines = f.read().splitlines()
+except Exception:
+lines = []
+
+
+lines.append(json.dumps(record, ensure_ascii=False))
+content = "\n".join(lines).encode("utf-8")
+
+
+upload_file(
+path_or_fileobj=io.BytesIO(content),
+path_in_repo=OUT_FILE,
+repo_id=OUT_DATASET,
+repo_type="dataset",
+token=HF_TOKEN
+)
+return f"Guardado en {OUT_DATASET}/{OUT_FILE}"
+
+
+# --- Callback principal ---
+
+
+def on_generate(name, age, sex, distance, target_date,
+days_per_week, long_run_day, current_5k_pace, long_run_km, experience,
+keywords, topk):
+# 1) búsqueda en el dataset
+table = search_papers(keywords, topk)
+# 2) generar plan
+plan = build_plan(distance, target_date, int(days_per_week), long_run_day,
+float(current_5k_pace), float(long_run_km), experience)
+# 3) guardar
+record = {
+"ts": datetime.utcnow().isoformat()+"Z",
+"user": {"name": name, "age": age, "sex": sex},
+"goal": {"distance": distance, "target_date": target_date},
+"prefs": {"days_per_week": days_per_week, "long_run_day": long_run_day, "experience": experience},
+"benchmarks": {"current_5k_pace_min_per_km": current_5k_pace, "long_run_km": long_run_km},
+"keywords": keywords,
+"plan": plan
+}
+saved = ensure_repo_and_push(record)
+return table, json.dumps(plan, ensure_ascii=False, indent=2), saved
+
+
+# --- UI ---
+with gr.Blocks(title="OR_Training — Running Plan Builder") as demo:
+gr.Markdown("""
+# 🏃 OR_Training — Running Plan Builder
+Este Space busca en literatura (dataset NCBI extraído) y genera un **plan básico** personalizado.
+- Dataset: `florentgbelidji/ncbi_extracted_running` (recomendado **duplicarlo** a `rogarces85/ncbi_extracted_running`).
+- Cada envío puede guardarse como una línea en `dataset` propio (`OR_Training_submissions`).
+""")
+
+
+with gr.Row():
+with gr.Column():
+gr.Markdown("### 🔎 Búsqueda en el dataset")
+keywords = gr.Textbox(label="Palabras clave (ej: injury, marathon, VO2max)")
+topk = gr.Slider(1, 20, value=5, step=1, label="Resultados (top-k)")
+table_out = gr.Dataframe(label="Artículos coincidentes (id, title, date, authors, language, snippet)", wrap=True, height=300)
+
+
+with gr.Column():
+gr.Markdown("### 📝 Formulario del atleta")
+name = gr.Textbox(label="Nombre", value="")
+age = gr.Number(label="Edad", value=30)
+sex = gr.Radio(["F","M","Otro"], label="Sexo", value="F")
+distance = gr.Dropdown(["5K","10K","21K","42K"], value="21K", label="Objetivo")
+target_date = gr.Textbox(label="Fecha objetivo (YYYY-MM-DD)", value="2026-03-01")
+days_per_week = gr.Slider(3,6,value=4,step=1,label="Días/semana")
+long_run_day = gr.Dropdown(["Sábado","Domingo"], value="Domingo", label="Día de fondo")
+current_5k_pace = gr.Number(label="Ritmo actual 5K (min/km)", value=5.30)
+long_run_km = gr.Number(label="Fondo actual (km)", value=12)
+experience = gr.Dropdown(["Principiante","Intermedio","Avanzado"], value="Intermedio", label="Experiencia")
+btn = gr.Button("Generar plan y guardar envío")
+plan_json = gr.Code(label="Plan (JSON)", language="json", lines=20)
+saved_label = gr.Markdown()
+
+
+btn.click(on_generate,
+inputs=[name, age, sex, distance, target_date, days_per_week, long_run_day,
+current_5k_pace, long_run_km, experience, keywords, topk],
+outputs=[table_out, plan_json, saved_label])
+
+
 if __name__ == "__main__":
-    print("🌐 Iniciando servidor en puerto 7860")
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True
-    )
+demo.launch()