app.py

import accelerate
import gradio as gr
import joblib
import numpy as np
import requests
import torch
import os
import json
import matplotlib.pyplot as plt
from io import BytesIO
from transformers import AutoModelForCausalLM, AutoTokenizer

# Configuración del modelo de lenguaje
MODEL_NAME = "PlanTL-GOB-ES/roberta-base-bne"
device = "cuda" if torch.cuda.is_available() else "cpu"
HF_TOKEN = os.getenv("HF_TOKEN")

if not HF_TOKEN:
    raise ValueError("❌ ERROR: No se encontró HF_TOKEN. Asegúrate de definirlo en las variables de entorno.")

print("🔄 Cargando modelo de lenguaje...")
tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
model = AutoModelForCausalLM.from_pretrained(MODEL_NAME).to(device)

# API de Node-RED
NODE_RED_URL = "https://appairedecolmena.es/colmena1/datos"
USERNAME = "user"
PASSWORD = "velutina"

def obtener_datos_colmena():
    """Obtiene los datos más recientes de Node-RED."""
    try:
        respuesta = requests.get(NODE_RED_URL, auth=(USERNAME, PASSWORD), timeout=5)
        if respuesta.status_code == 200:
            datos = respuesta.json()
            if "data" in datos and isinstance(datos["data"], list) and datos["data"]:
                return datos["data"]
            return {"error": "No hay datos recientes en Node-RED."}
        else:
            return {"error": f"Error en la API: {respuesta.status_code}"}
    except Exception as e:
        return {"error": str(e)}

def analizar_tendencia(datos, variable):
    """Analiza la tendencia de una variable específica."""
    valores = [float(d[variable]) for d in datos if variable in d]
    timestamps = [d["timestamp"] for d in datos if variable in d]
    promedio = np.mean(valores)
    maximo = np.max(valores)
    minimo = np.min(valores)

    respuesta = f"📊 **Análisis de {variable}:**\n"
    respuesta += f"- Promedio: {promedio:.2f}\n"
    respuesta += f"- Máximo: {maximo:.2f}\n"
    respuesta += f"- Mínimo: {minimo:.2f}\n"

    return respuesta, valores, timestamps

def generar_grafico(valores, timestamps, variable):
    """Genera un gráfico de la variable analizada."""
    plt.figure(figsize=(10, 5))
    plt.plot(timestamps, valores, marker='o', linestyle='-')
    plt.xlabel("Tiempo")
    plt.ylabel(variable)
    plt.title(f"Tendencia de {variable}")
    plt.xticks(rotation=45)
    plt.grid()
    
    buf = BytesIO()
    plt.savefig(buf, format="png")
    buf.seek(0)
    return buf

def interpretar_instruccion(mensaje, datos):
    """Interpreta la consulta del usuario y ejecuta el análisis solicitado."""
    mensaje = mensaje.lower()
    
    # Mapeo de variables con términos comunes
    variable_map = {
        "temperatura": "temperaturaInterior",
        "humedad": "humedadInterior",
        "co2": "co2",
        "peso": "peso"
    }
    
    for key, var in variable_map.items():
        if key in mensaje:
            respuesta, valores, timestamps = analizar_tendencia(datos, var)
            grafico = generar_grafico(valores, timestamps, var)
            return respuesta, grafico
    
    return "🤖 No entiendo la consulta. Pregunta sobre el estado de la colmena o análisis de variables."

def conversar_con_colmena(mensaje):
    """Genera una respuesta combinando el modelo de lenguaje con análisis de datos."""
    datos = obtener_datos_colmena()
    if "error" in datos:
        return datos["error"]
    
    resultado = interpretar_instruccion(mensaje, datos)
    if isinstance(resultado, tuple):
        texto, grafico = resultado
        return texto, grafico
    else:
        return resultado

iface = gr.Interface(
    fn=conversar_con_colmena,
    inputs="text",
    outputs=["text", "image"],
    title="🐝 Chat con la Colmena",
    description="Consulta el estado de la colmena y pide análisis de datos."
)

iface.launch()