app.py

import gradio as gr
from queries import (clustering_esfuerzo_dieta_response, clustering_objetivo_response, clustering_entrenamiento_response, 
                     clustering_cumplimiento_dieta_response, clustering_compromiso_response, clustering_diferencia_peso_response,
                     make_query, get_min_max_mean_mode_macros_differences)
from find_matches import find_user_dates_matches, find_macros_that_match_dates_of_users

def clustering_responses(esfuerzo_dieta, objetivo, cumplimiento_entrenamiento, 
                    cumplimiento_dieta, compromiso, variacion_peso):
    cluster_esfuerzo_dieta = clustering_esfuerzo_dieta_response(esfuerzo_dieta)
    cluster_objetivo = clustering_objetivo_response(objetivo)
    cluster_entrenamiento = clustering_entrenamiento_response(cumplimiento_entrenamiento)
    cluster_cumplimiento_dieta = clustering_cumplimiento_dieta_response(cumplimiento_dieta)
    cluster_compromiso = clustering_compromiso_response(compromiso)
    diff_peso_min, diff_peso_max = clustering_diferencia_peso_response(variacion_peso)

    return cluster_esfuerzo_dieta, cluster_objetivo, cluster_entrenamiento, cluster_cumplimiento_dieta, cluster_compromiso, diff_peso_min, diff_peso_max

def calcular_macros(esfuerzo_dieta, objetivo, cumplimiento_entrenamiento, 
                    cumplimiento_dieta, compromiso, variacion_peso,
                    train_day_protein_initial, train_day_carbs_initial, train_day_fat_initial,
                    intratrain_protein_initial, intratrain_carbs_initial,
                    rest_day_protein_initial, rest_day_carbs_initial, rest_day_fat_initial):
    # Obtenemos los valores correspondientes a cada selección
    valor_esfuerzo = next(list(opcion.values())[0]["value"] 
                         for opcion in opciones_esfuerzo 
                         if list(opcion.values())[0]["text"] == esfuerzo_dieta)
    
    valor_objetivo = next(list(opcion.values())[0]["value"] 
                         for opcion in opciones_objetivo 
                         if list(opcion.values())[0]["text"] == objetivo)
    
    valor_cumplimiento_entr = next(list(opcion.values())[0]["value"] 
                                  for opcion in opciones_cumplimiento_entrenamiento 
                                  if list(opcion.values())[0]["text"] == cumplimiento_entrenamiento)
    
    valor_cumplimiento_dieta = next(list(opcion.values())[0]["value"] 
                                   for opcion in opciones_cumplimiento_dieta 
                                   if list(opcion.values())[0]["text"] == cumplimiento_dieta)
    
    valor_compromiso = next(list(opcion.values())[0]["value"] 
                          for opcion in opciones_compromiso 
                          if list(opcion.values())[0]["text"] == compromiso)
    
    # Clustering
    (cluster_esfuerzo_dieta, cluster_objetivo, cluster_entrenamiento, cluster_cumplimiento_dieta, 
     cluster_compromiso, diff_peso_min, diff_peso_max) = clustering_responses(valor_esfuerzo, valor_objetivo, 
                                                                           valor_cumplimiento_entr, 
                                                                           valor_cumplimiento_dieta, valor_compromiso, 
                                                                           variacion_peso)
    
    # Imprimimos los resultados
    print(f"Consulta:")
    print(f"\tEsfuerzo para cumplir dieta: {cluster_esfuerzo_dieta}")
    print(f"\tObjetivo: {cluster_objetivo}")
    print(f"\tEntrenamiento: {cluster_entrenamiento}")
    print(f"\tCumplimiento dieta: {cluster_cumplimiento_dieta}")
    print(f"\tCompromiso: {cluster_compromiso}")
    print(f"\tVariación de peso: {variacion_peso}")
    print(f"\t{diff_peso_min} <= Diferencia peso <= {diff_peso_max}")

    # Crear query
    query = make_query(cluster_esfuerzo_dieta, cluster_objetivo, cluster_entrenamiento, cluster_cumplimiento_dieta, cluster_compromiso, diff_peso_min, diff_peso_max)

    # Print query
    print(f"Query: {query}")

    # Crear diccionario de matches
    matches_dict = find_user_dates_matches(query)

    # Print matches
    print(f"Matches:\n{matches_dict}")

    # Find macros that match dates of users
    macros_differences_list = find_macros_that_match_dates_of_users(matches_dict)

    # Print macros
    print(f"Macros:\n{macros_differences_list}")

    # Calculate macros min, max and mean
    if len(macros_differences_list) > 0:
        (train_day_protein_std, train_day_carbs_std, train_day_fat_std, intratrain_protein_std, intratrain_carbs_std, 
        rest_day_protein_std, rest_day_carbs_std, rest_day_fat_std) = get_min_max_mean_mode_macros_differences(macros_differences_list)
    else:
        train_day_protein_std = [0, 0, 0, 0]
        train_day_carbs_std = [0, 0, 0, 0]
        train_day_fat_std = [0, 0, 0, 0]
        intratrain_protein_std = [0, 0, 0, 0]
        intratrain_carbs_std = [0, 0, 0, 0]
        rest_day_protein_std = [0, 0, 0, 0]
        rest_day_carbs_std = [0, 0, 0, 0]
        rest_day_fat_std = [0, 0, 0, 0]
    
    # Print macros min, max and mean
    print(f"Macros min, max and mean:\n{train_day_protein_std}, {train_day_carbs_std}, {train_day_fat_std}, {intratrain_protein_std}, {intratrain_carbs_std}, {rest_day_protein_std}, {rest_day_carbs_std}, {rest_day_fat_std}")

    # Get macros min, max, mean and mode
    train_day_protein_min, train_day_protein_max, train_day_protein_mean, train_day_protein_mode = train_day_protein_std
    train_day_carbs_min, train_day_carbs_max, train_day_carbs_mean, train_day_carbs_mode = train_day_carbs_std
    train_day_fat_min, train_day_fat_max, train_day_fat_mean, train_day_fat_mode = train_day_fat_std
    
    intratrain_protein_min, intratrain_protein_max, intratrain_protein_mean, intratrain_protein_mode = intratrain_protein_std
    intratrain_carbs_min, intratrain_carbs_max, intratrain_carbs_mean, intratrain_carbs_mode = intratrain_carbs_std
    
    rest_day_protein_min, rest_day_protein_max, rest_day_protein_mean, rest_day_protein_mode = rest_day_protein_std
    rest_day_carbs_min, rest_day_carbs_max, rest_day_carbs_mean, rest_day_carbs_mode = rest_day_carbs_std
    rest_day_fat_min, rest_day_fat_max, rest_day_fat_mean, rest_day_fat_mode = rest_day_fat_std

    # Calculate macros final
    train_day_protein_final = train_day_protein_initial + train_day_protein_mode
    train_day_carbs_final = train_day_carbs_initial + train_day_carbs_mode
    train_day_fat_final = train_day_fat_initial + train_day_fat_mode

    intratrain_protein_final = intratrain_protein_initial + intratrain_protein_mode
    intratrain_carbs_final = intratrain_carbs_initial + intratrain_carbs_mode

    rest_day_protein_final = rest_day_protein_initial + rest_day_protein_mode
    rest_day_carbs_final = rest_day_carbs_initial + rest_day_carbs_mode
    rest_day_fat_final = rest_day_fat_initial + rest_day_fat_mode

    return (train_day_protein_final, train_day_carbs_final, train_day_fat_final,
            intratrain_protein_final, intratrain_carbs_final,
            rest_day_protein_final, rest_day_carbs_final, rest_day_fat_final)

# Definimos las opciones para cada menú desplegable
opciones_esfuerzo = [
    {
        "No entiendo la calculadora, quiero menús tipo": {
            "text": "No entiendo la calculadora, quiero menús tipo",
            "value": " | no data"
        }
    },
    {
        "No costó nada": {
            "text": "No costó nada",
            "value": " | no costo"
        }
    },
    {
        "Costó demasiado, súbeme macros": {
            "text": "Costó demasiado, súbeme macros",
            "value": " | costo subir macros"
        }
    },
    {
        "Costó demasiado, bájame macros": {
            "text": "Costó demasiado, bájame macros",
            "value": " | costo bajar macros"
        }
    },
    {
        "Costó, pero me adapto a nuevos ajustes": {
            "text": "Costó, pero me adapto a nuevos ajustes",
            "value": " | costo y me adapto a nuevos ajustes"
        }
    },
    {
        "Iba a coger menús tipo, pero al final por precio no": {
            "text": "Iba a coger menús tipo, pero al final por precio no",
            "value": " | no data"
        }
    }
]

opciones_objetivo = [
    {
        "definición (nada cambia)": {
            "text": "definición (nada cambia)",
            "value": " | definicion"
        }
    },
    {
        "empezamos a definir (cambia)": {
            "text": "empezamos a definir (cambia)",
            "value": " | definicion"
        }
    },
    {
        "perder peso (nada cambia)": {
            "text": "perder peso (nada cambia)",
            "value": " | definicion"
        }
    },
    {
        "volumen (nada cambia)": {
            "text": "volumen (nada cambia)",
            "value": " | volumen"
        }
    },
    {
        "empezamos a coger volumen (cambia)": {
            "text": "empezamos a coger volumen (cambia)",
            "value": " | volumen"
        }
    },
    {
        "empezamos a coger volumen, sobre todo tren inferior (cambia)": {
            "text": "empezamos a coger volumen, sobre todo tren inferior (cambia)",
            "value": " | volumen"
        }
    },
    {
        "empezamos a coger volumen, en todo el cuerpo (cambia)": {
            "text": "empezamos a coger volumen, en todo el cuerpo (cambia)",
            "value": " | volumen"
        }
    }
]

opciones_cumplimiento_entrenamiento = [
    {
        "Lo hice perfecto": {
            "text": "Lo hice perfecto",
            "value": " | bien"
        }
    },
    {
        "He fallado algunos días, pero sí": {
            "text": "He fallado algunos días, pero sí",
            "value": " | bien"
        }
    },
    {
        "Lesión importante": {
            "text": "Lesión importante",
            "value": " | mal"
        }
    },
    {
        "Lo hice prácticamente perfecto": {
            "text": "Lo hice prácticamente perfecto",
            "value": " | bien"
        }
    },
    {
        "Pequeña lesión": {
            "text": "Pequeña lesión",
            "value": " | mal"
        }
    },
    {
        "No hice nada, mantenemos la rutina un mes más": {
            "text": "No hice nada, mantenemos la rutina un mes más",
            "value": " | mal"
        }
    },
    {
        "Alárgame la rutina una semana más": {
            "text": "Alárgame la rutina una semana más",
            "value": " | mal"
        }
    }
]

opciones_cumplimiento_dieta = [
    {
        "al 70%": {
            "text": "al 70%",
            "value": " | bien"
        }
    },
    {
        "regular, me cuesta llegar": {
            "text": "regular, me cuesta llegar",
            "value": " | regular"
        }
    },
    {
        "Nada, mantén mis macros": {
            "text": "Nada, mantén mis macros",
            "value": " | mal"
        }
    },
    {
        "casi perfecta": {
            "text": "casi perfecta",
            "value": " | bien"
        }
    },
    {
        "regular, me salto la dieta": {
            "text": "regular, me salto la dieta",
            "value": " | regular"
        }
    },
    {
        "Perfecta": {
            "text": "Perfecta",
            "value": " | bien"
        }
    }
]

opciones_compromiso = [
    {
        "Bueno, pero mejorable": {
            "text": "Bueno, pero mejorable",
            "value": " | bueno"
        }
    },
    {
        "Mal, pero a partir de ahora voy a por todas": {
            "text": "Mal, pero a partir de ahora voy a por todas",
            "value": " | mal"
        }
    },
    {
        "Mal, demasiado exigente": {
            "text": "Mal, demasiado exigente",
            "value": " | mal"
        }
    },
    {
        "Máximo": {
            "text": "Máximo",
            "value": " | bueno"
        }
    }
]

# Definimos el color naranja
naranja = "#ea580b"

title_macros_iniciales_html = f"""
<h1 style="text-align: center; color: {naranja}; margin: 0; padding: 0;">Macros iniciales</h1>
"""

title_cuestionario_html = f"""
<h1 style="text-align: center; color: {naranja}; margin: 0; padding: 0;">Respuestas cuestionario</h1>
"""

title_macros_finales_html = f"""
<h1 style="text-align: center; color: {naranja}; margin: 0; padding: 0;">Macros finales</h1>
"""

style_css = f"""
<style>
    .demo {{
        background-color: {naranja};
    }}
    .input-group, .output-group {{
        background-color: {naranja};
        padding: 2px;
        border-radius: 7px;
    }}
    .input-row .output-row {{
    }}
    .input-column {{
    }}
    .input-number {{
        background-color: black;
        color: white;
    }}
    .input-dropdown {{
        background-color: black;
        color: white;
    }}
    .calcular-btn {{
        background-color: {naranja};
        color: white;
        border-radius: 7px;
        margin-bottom: 70px;
    }}
    .output-number {{
        background-color: black;
        color: white;
    }}
</style>
"""

# Creamos la interfaz
with gr.Blocks(css=style_css, elem_classes="demo") as demo:
    
    # Procesamos las opciones para obtener solo los textos
    textos_esfuerzo = [list(opcion.values())[0]["text"] for opcion in opciones_esfuerzo]
    textos_objetivo = [list(opcion.values())[0]["text"] for opcion in opciones_objetivo]
    textos_cumplimiento_entr = [list(opcion.values())[0]["text"] for opcion in opciones_cumplimiento_entrenamiento]
    textos_cumplimiento_dieta = [list(opcion.values())[0]["text"] for opcion in opciones_cumplimiento_dieta]
    textos_compromiso = [list(opcion.values())[0]["text"] for opcion in opciones_compromiso]
    
    # Entradas
    gr.Markdown(title_macros_iniciales_html)
    with gr.Group(elem_classes="input-group"):
        with gr.Row(elem_classes="input-row"):
            with gr.Column(elem_classes="input-column"):
                train_day_protein_initial = gr.Number(
                    label="Proteína día de entreno (g)", 
                    precision=0,
                    value=150,
                    step=10,
                    minimum=0,
                    elem_classes="input-number"
                )
                train_day_carbs_initial = gr.Number(
                    label="Carbohidratos día de entreno (g)", 
                    precision=0,
                    value=150,
                    step=10,
                    minimum=0,
                    elem_classes="input-number"
                )
                train_day_fat_initial = gr.Number(
                    label="Grasas día de entreno (g)", 
                    precision=0,
                    value=150,
                    step=10,
                    minimum=0,
                    elem_classes="input-number"
                )
            with gr.Column(elem_classes="input-column"):
                intratrain_protein_initial = gr.Number(
                    label="Proteína intraentreno (g)", 
                    precision=0,
                    value=150,
                    step=10,
                    minimum=0,
                    elem_classes="input-number"
                )
                intratrain_carbs_initial = gr.Number(
                    label="Carbohidratos intraentreno (g)", 
                    precision=0,
                    value=150,
                    step=10,
                    minimum=0,
                    elem_classes="input-number"
                )
            with gr.Column(elem_classes="input-column"):
                rest_day_protein_initial = gr.Number(
                    label="Proteína día de descanso (g)", 
                    precision=0,
                    value=150,
                    step=10,
                    minimum=0,
                    elem_classes="input-number"
                )
                rest_day_carbs_initial = gr.Number(
                    label="Carbohidratos día de descanso (g)", 
                    precision=0,
                    value=150,
                    step=10,
                    minimum=0,
                    elem_classes="input-number"
                )
                rest_day_fat_initial = gr.Number(
                    label="Grasas día de descanso (g)", 
                    precision=0,
                    value=150,
                    step=10,
                    minimum=0,
                    elem_classes="input-number"
                )
    
    gr.Markdown(title_cuestionario_html)
    with gr.Group(elem_classes="input-group"):
        with gr.Row(elem_classes="input-row"):
            esfuerzo = gr.Dropdown(
                choices=textos_esfuerzo, 
                label="Esfuerzo dieta",
                value="No costó nada",
                elem_classes="input-dropdown"
            )
            cumplimiento_dieta = gr.Dropdown(
                choices=textos_cumplimiento_dieta, 
                label="Cumplimiento de la dieta",
                value="Perfecta",
                elem_classes="input-dropdown"
            )
            objetivo = gr.Dropdown(
                choices=textos_objetivo, 
                label="Objetivo",
                value="volumen (nada cambia)",
                elem_classes="input-dropdown"
            )
        with gr.Row(elem_classes="input-row"):
            cumplimiento_entr = gr.Dropdown(
                choices=textos_cumplimiento_entr, 
                label="Cumplimiento del entrenamiento",
                value="Lo hice perfecto",
                elem_classes="input-dropdown"
            )
            compromiso = gr.Dropdown(
                choices=textos_compromiso, 
                label="Compromiso",
                value="Máximo",
                elem_classes="input-dropdown"
            )
            variacion_peso = gr.Number(
                label="Variación de peso", 
                precision=2,
                value=0.7,
                step=0.1,
                elem_classes="input-number"
            )
    
    # Versión simple del botón
    calcular_btn = gr.Button(
        "Calcular macros",
        variant="primary",
        size="lg",
        elem_classes="calcular-btn"
    )
    
    # Salidas
    gr.Markdown(title_macros_finales_html)
    with gr.Group(elem_classes="output-group"):
        with gr.Row(elem_classes="output-row"):
            with gr.Column():
                train_day_protein_final = gr.Number(label="Proteína día de entreno Final (g)", precision=0, elem_classes="output-number")
                train_day_carbs_final = gr.Number(label="Carbohidratos día de entreno Final (g)", precision=0, elem_classes="output-number")
                train_day_fat_final = gr.Number(label="Grasas día de entreno Final (g)", precision=0, elem_classes="output-number")
            with gr.Column():
                intratrain_protein_final = gr.Number(label="Proteína intraentreno Final (g)", precision=0, elem_classes="output-number")
                intratrain_carbs_final = gr.Number(label="Carbohidratos intraentreno Final (g)", precision=0, elem_classes="output-number")
            with gr.Column():
                rest_day_protein_final = gr.Number(label="Proteína día de descanso Final (g)", precision=0, elem_classes="output-number")
                rest_day_carbs_final = gr.Number(label="Carbohidratos día de descanso Final (g)", precision=0, elem_classes="output-number")
                rest_day_fat_final = gr.Number(label="Grasas día de descanso Final (g)", precision=0, elem_classes="output-number")
    
    # Conectamos el botón con la función
    calcular_btn.click(
        fn=calcular_macros,
        inputs=[esfuerzo, objetivo, cumplimiento_entr, cumplimiento_dieta, 
                compromiso, variacion_peso,
                train_day_protein_initial, train_day_carbs_initial, train_day_fat_initial,
                intratrain_protein_initial, intratrain_carbs_initial,
                rest_day_protein_initial, rest_day_carbs_initial, rest_day_fat_initial],
        outputs=[train_day_protein_final, train_day_carbs_final, train_day_fat_final,
                 intratrain_protein_final, intratrain_carbs_final,
                 rest_day_protein_final, rest_day_carbs_final, rest_day_fat_final]
    )

demo.launch()