app.py

import gradio as gr
import joblib
import numpy as np
import os
import requests
import time
import threading
from datetime import datetime
from sklearn.ensemble import RandomForestClassifier

# Configuración de la API de Node-RED
NODE_RED_URL = "https://appairedecolmena.es/colmena1/datos"
USERNAME = "tu_usuario"
PASSWORD = "tu_contraseña"

# Ruta del modelo
modelo_path = "modelo_colmena.pkl"

# Cargar el modelo si existe, si no, crearlo vacío
if os.path.exists(modelo_path):
    modelo = joblib.load(modelo_path)
else:
    modelo = RandomForestClassifier(n_estimators=100)

# Variable para rastrear el último timestamp
ultimo_timestamp = None

def obtener_datos_colmena():
    """Obtiene los datos de Node-RED con autenticación."""
    try:
        respuesta = requests.get(NODE_RED_URL, auth=(USERNAME, PASSWORD), timeout=5)
        if respuesta.status_code == 200:
            return respuesta.json()
        else:
            print(f"⚠️ Error en la API de Node-RED: {respuesta.status_code}")
            return None
    except Exception as e:
        print("❌ No se pudo conectar a Node-RED:", e)
        return None

def entrenar_nuevo_modelo(datos):
    """Entrena un nuevo modelo con los datos recibidos."""
    global modelo

    # Convertir los datos en un array
    entrada = np.array([[float(datos["temperaturaInterior"]), float(datos["humedadInterior"]), float(datos["peso"]),
                         float(datos["co2"]), float(datos["vco"]), float(datos["frecuencia"]),
                         float(datos["voltaje"]), float(datos["temperatura_exterior"]),
                         float(datos["humedad_exterior"]), float(datos["ver_tempSelect"])]])
    
    # Salidas: [ultrasonido, calefactor, ventilador]
    salida = np.array([[int(datos["ver_ultrasonido"]), int(datos["ver_calefactor"]), int(datos["ver_ventilador"])]])  

    # Reentrenar el modelo
    modelo.fit(entrada, salida)

    # Guardar el nuevo modelo
    joblib.dump(modelo, modelo_path)
    print("✅ Modelo actualizado con nuevos datos.")

def verificar_nuevos_datos():
    """Consulta Node-RED cada hora y aprende si hay datos nuevos."""
    global ultimo_timestamp

    while True:
        datos = obtener_datos_colmena()

        if datos:
            timestamp_actual = datos["timestamp"]
            
            if timestamp_actual != ultimo_timestamp:
                print(f"📌 Nuevos datos detectados: {timestamp_actual}")
                entrenar_nuevo_modelo(datos)
                ultimo_timestamp = timestamp_actual
            else:
                print("⏳ No hay datos nuevos, esperando la próxima consulta...")
        else:
            print("⚠️ No se pudieron obtener datos.")

        # Esperar 1 hora antes de la próxima consulta
        time.sleep(3600)

# Iniciar el proceso en segundo plano
thread = threading.Thread(target=verificar_nuevos_datos, daemon=True)
thread.start()

# Función para hacer predicciones con el modelo
def predecir(temp, humedad, peso, co2, vco, frecuencia, voltaje, temp_ext, humedad_ext, ver_tempSelect):
    valores = [temp, humedad, peso, co2, vco, frecuencia, voltaje, temp_ext, humedad_ext, ver_tempSelect]
    valores_limpios = [0 if v is None or np.isnan(v) else v for v in valores]  # Reemplaza NaN y None con 0
    
    entrada = np.array([valores_limpios])
    
    prediccion = modelo.predict(entrada)[0]  # El modelo devuelve [ultrasonido, calefactor, ventilador]
    
    mensaje = f"🔹 Ultrasonido: {'ENCENDER' if prediccion[0] == 1 else 'APAGAR'}"
    mensaje += f"\n🔹 Calefactor: {'ENCENDER' if prediccion[1] == 1 else 'APAGAR'}"
    mensaje += f"\n🔹 Ventilador: {'ENCENDER' if prediccion[2] == 1 else 'APAGAR'}"
    
    return mensaje

# Crear la API en Gradio
iface = gr.Interface(
    fn=predecir,
    inputs=["number", "number", "number", "number", "number", "number", "number", "number", "number", "number"],
    outputs="text",
    title="🐝 IA Inteligente para Colmenas",
    description="Introduce los datos de la colmena y la IA predecirá si es necesario activar ventilador, calefactor y ultrasonidos."
)

# Lanzar la API
iface.launch()