feat(SRC): :rocket: Add all logic

app.py

@@ -1,85 +1,386 @@
 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):
-    # Por ahora, devolvemos 10 para todas las salidas como solicitado
-    return 10, 10, 10, 10, 10, 10, 10, 10
+    # 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
+    (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)
+
+    # 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}")
+
+    # Create strings for the outputs
+    train_day_protein_str = f"min: {train_day_protein_std[0]}, max: {train_day_protein_std[1]}, mean: {train_day_protein_std[2]:.2f}, mode: {train_day_protein_std[3]}"
+    train_day_carbs_str = f"min: {train_day_carbs_std[0]}, max: {train_day_carbs_std[1]}, mean: {train_day_carbs_std[2]:.2f}, mode: {train_day_carbs_std[3]}"
+    train_day_fat_str = f"min: {train_day_fat_std[0]}, max: {train_day_fat_std[1]}, mean: {train_day_fat_std[2]:.2f}, mode: {train_day_fat_std[3]}"
+    intratrain_protein_str = f"min: {intratrain_protein_std[0]}, max: {intratrain_protein_std[1]}, mean: {intratrain_protein_std[2]:.2f}, mode: {intratrain_protein_std[3]}"
+    intratrain_carbs_str = f"min: {intratrain_carbs_std[0]}, max: {intratrain_carbs_std[1]}, mean: {intratrain_carbs_std[2]:.2f}, mode: {intratrain_carbs_std[3]}"
+    rest_day_protein_str = f"min: {rest_day_protein_std[0]}, max: {rest_day_protein_std[1]}, mean: {rest_day_protein_std[2]:.2f}, mode: {rest_day_protein_std[3]}"
+    rest_day_carbs_str = f"min: {rest_day_carbs_std[0]}, max: {rest_day_carbs_std[1]}, mean: {rest_day_carbs_std[2]:.2f}, mode: {rest_day_carbs_std[3]}"
+    rest_day_fat_str = f"min: {rest_day_fat_std[0]}, max: {rest_day_fat_std[1]}, mean: {rest_day_fat_std[2]:.2f}, mode: {rest_day_fat_std[3]}"
+
+    return train_day_protein_str, train_day_carbs_str, train_day_fat_str, intratrain_protein_str, intratrain_carbs_str, rest_day_protein_str, rest_day_carbs_str, rest_day_fat_str
 
 # Definimos las opciones para cada menú desplegable
 opciones_esfuerzo = [
-    "No entiendo la calculadora, quiero menús tipo",
-    "No costó nada",
-    "Costó demasiado, súbeme macros",
-    "Costó, pero me adapto a nuevos ajustes",
-    "Iba a coger menús tipo, pero al final por precio no",
-    "Costó demasiado, bájame macros"
+    {
+        "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)",
-    "empezamos a definir (cambia)",
-    "perder peso (nada cambia)",
-    "volumen (nada cambia)",
-    "empezamos a coger volumen (cambia)",
-    "empezamos a coger volumen, sobre todo tren inferior (cambia)",
-    "empezamos a coger volumen, en todo el cuerpo (cambia)"
+    {
+        "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",
-    "He fallado algunos días, pero sí",
-    "Lesión importante",
-    "Lo hice prácticamente perfecto",
-    "Pequeña lesión",
-    "No hice nada, mantenemos la rutina un mes más",
-    "Alárgame la rutina una semana más"
+    {
+        "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%",
-    "regular, me cuesta llegar",
-    "Nada, mantén mis macros",
-    "casi perfecta",
-    "regular, me salto la dieta",
-    "Perfecto"
+    {
+        "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",
-    "Mal, pero a partir de ahora voy a por todas",
-    "Mal, demasiado exigente",
-    "Máximo"
+    {
+        "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"
+        }
+    }
 ]
 
 # Creamos la interfaz
 with gr.Blocks() as demo:
-    # Entradas
-    esfuerzo = gr.Dropdown(choices=opciones_esfuerzo, label="Esfuerzo dieta")
-    objetivo = gr.Dropdown(choices=opciones_objetivo, label="Objetivo")
-    cumplimiento_entr = gr.Dropdown(choices=opciones_cumplimiento_entrenamiento, 
-                                   label="Cumplimiento del entrenamiento")
-    cumplimiento_dieta = gr.Dropdown(choices=opciones_cumplimiento_dieta, 
-                                    label="Cumplimiento de la dieta")
-    compromiso = gr.Dropdown(choices=opciones_compromiso, label="Compromiso")
-    variacion_peso = gr.Textbox(label="Variación de peso")
+    # Definimos el color naranja
+    naranja = "#FF9300"
     
-    # Botón de cálculo
-    calcular_btn = gr.Button("Calcular")
+    # 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]
     
-    # Salidas
+    # Entradas
     with gr.Row():
-        proteina_entreno = gr.Textbox(label="Proteína día de entreno")
-        carbs_entreno = gr.Textbox(label="Carbohidratos día de entreno")
-        grasas_entreno = gr.Textbox(label="Grasas día de entreno")
-    
+        esfuerzo = gr.Dropdown(
+            choices=textos_esfuerzo, 
+            label="Esfuerzo dieta",
+            value="No costó nada"
+        )
+        cumplimiento_dieta = gr.Dropdown(
+            choices=textos_cumplimiento_dieta, 
+            label="Cumplimiento de la dieta",
+            value="Perfecta"
+        )
+        objetivo = gr.Dropdown(
+            choices=textos_objetivo, 
+            label="Objetivo",
+            value="volumen (nada cambia)"
+        )
     with gr.Row():
-        proteina_intra = gr.Textbox(label="Proteína intraentreno")
-        carbs_intra = gr.Textbox(label="Carbohidratos intraentreno")
+        cumplimiento_entr = gr.Dropdown(
+            choices=textos_cumplimiento_entr, 
+            label="Cumplimiento del entrenamiento",
+            value="Lo hice perfecto"
+        )
+        compromiso = gr.Dropdown(
+            choices=textos_compromiso, 
+            label="Compromiso",
+            value="Máximo"
+        )
+        variacion_peso = gr.Number(
+            label="Variación de peso", 
+            precision=2,
+            value=0.7
+        )
     
-    with gr.Row():
-        proteina_descanso = gr.Textbox(label="Proteína día de descanso")
-        carbs_descanso = gr.Textbox(label="Carbohidratos día de descanso")
-        grasas_descanso = gr.Textbox(label="Grasas día de descanso")
+    # Versión simple del botón
+    calcular_btn = gr.Button(
+        "Calcular",
+        variant="primary",
+        size="lg"
+    )
+    
+    # Añadimos el estilo CSS personalizado
+    css = f"""
+        <style>
+        #boton-naranja {{
+            background-color: {naranja} !important;
+            border: 1px solid {naranja} !important;
+        }}
+        #boton-naranja:hover {{
+            background-color: {naranja}DD !important;
+            border: 1px solid {naranja}DD !important;
+        }}
+        </style>
+    """
+    
+    css_outputs = """
+        <style>
+        .output-row {
+            align-items: flex-end !important;
+            display: flex !important;
+            gap: 1rem !important;
+        }
+        .output-row > * {
+            flex: 1;
+            min-width: 0;
+        }
+        </style>
+    """
+    
+    gr.Markdown(css + css_outputs)
+    
+    # Salidas
+    with gr.Row(elem_classes="output-row"):
+        proteina_entreno = gr.Textbox(label="Proteína día de entreno (g)")
+        carbs_entreno = gr.Textbox(label="Carbohidratos día de entreno (g)")
+        grasas_entreno = gr.Textbox(label="Grasas día de entreno (g)")
+        proteina_intra = gr.Textbox(label="Proteína intraentreno (g)")
+        carbs_intra = gr.Textbox(label="Carbohidratos intraentreno (g)")
+        proteina_descanso = gr.Textbox(label="Proteína día de descanso (g)")
+        carbs_descanso = gr.Textbox(label="Carbohidratos día de descanso (g)")
+        grasas_descanso = gr.Textbox(label="Grasas día de descanso (g)")
     
     # Conectamos el botón con la función
     calcular_btn.click(

create_new_formularios.py

@@ -0,0 +1,221 @@
+from pathlib import Path
+import json
+from datetime import datetime
+from tqdm import tqdm
+
+# Paths
+formularios_path = 'formularios'
+formularios_weight_difference_path = 'formularios_weight_difference'
+
+# Get sorted date keys
+def get_sorted_date_keys(data):
+    keys = list(data.keys())
+    keys_dates = []
+    for key in keys:
+        try:
+            keys_dates.append(datetime.strptime(key, '%Y-%m-%d'))
+        except ValueError:
+            pass
+    keys_sorted = sorted(keys_dates)
+    keys_sorted = [key.strftime('%Y-%m-%d') for key in keys_sorted]
+    keys_sorted = [key.replace('-01', '-1') for key in keys_sorted]
+    keys_sorted = [key.replace('-02', '-2') for key in keys_sorted]
+    keys_sorted = [key.replace('-03', '-3') for key in keys_sorted]
+    keys_sorted = [key.replace('-04', '-4') for key in keys_sorted]
+    keys_sorted = [key.replace('-05', '-5') for key in keys_sorted]
+    keys_sorted = [key.replace('-06', '-6') for key in keys_sorted]
+    keys_sorted = [key.replace('-07', '-7') for key in keys_sorted]
+    keys_sorted = [key.replace('-08', '-8') for key in keys_sorted]
+    keys_sorted = [key.replace('-09', '-9') for key in keys_sorted]
+    return keys_sorted
+
+# Get non date keys
+def get_non_date_keys(data):
+    keys = list(data.keys())
+    keys_non_dates = []
+    for key in keys:
+        try:
+            datetime.strptime(key, '%Y-%m-%d')
+        except ValueError:
+            keys_non_dates.append(key)
+    return keys_non_dates
+
+# Add empty weight difference to all the dates
+def add_empty_weight_difference(data):
+    data['diferencia_peso'] = 'None'
+    return data
+
+# Change esfuerzo para cumplir dieta
+def change_esfuerzo_para_cumplir_dieta(data):
+    # Get the date keys
+    data_date_keys = list(get_sorted_date_keys(data))
+
+    # Iterate over the date keys
+    for key in data_date_keys:
+        # If data hasn't 'esfuerzoParaCumplirDieta' key, create it
+        if 'esfuerzoParaCumplirDieta' not in data[key]:
+            data[key]['esfuerzoParaCumplirDieta'] = 'None | no data'
+        
+        # If data has 'esfuerzoParaCumplirDieta' key, change it
+        if 'esfuerzoParaCumplirDieta' in data[key]:
+            if 'No entiendo la calculadora' in data[key]['esfuerzoParaCumplirDieta'] or 'Iba a coger menús tipo' in data[key]['esfuerzoParaCumplirDieta']:
+                data[key]['esfuerzoParaCumplirDieta'] += ' | No data'
+            elif 'Costó demasiado, súbeme macros' in data[key]['esfuerzoParaCumplirDieta']:
+                data[key]['esfuerzoParaCumplirDieta'] += ' | costo subir macros'
+            elif 'Costó demasiado, bájame macros' in data[key]['esfuerzoParaCumplirDieta']:
+                data[key]['esfuerzoParaCumplirDieta'] += ' | costo bajar macros'
+            elif 'Costó, pero me adapto a nuevos ajustes' in data[key]['esfuerzoParaCumplirDieta']:
+                data[key]['esfuerzoParaCumplirDieta'] += ' | costo y me adapto a nuevos ajustes'
+            elif 'No costó nada' in data[key]['esfuerzoParaCumplirDieta']:
+                data[key]['esfuerzoParaCumplirDieta'] += ' | no costo'
+            else:
+                data[key]['esfuerzoParaCumplirDieta'] += ' | no data'
+    return data
+
+# Change cumplimiento dieta
+def change_cumplimiento_dieta(data):
+    # Get the date keys
+    data_date_keys = list(get_sorted_date_keys(data))
+
+    # Iterate over the date keys
+    for key in data_date_keys:
+        # If data hasn't 'cumplimientoDieta' key, create it
+        if 'cumplimientoDieta' not in data[key]:
+            data[key]['cumplimientoDieta'] = 'None | no data'
+    
+        # If data has 'cumplimientoDieta' key, change it
+        if 'cumplimientoDieta' in data[key]:
+            if 'al 70%' in data[key]['cumplimientoDieta'] or 'casi perfecta' in data[key]['cumplimientoDieta'] or 'Perfecta' in data[key]['cumplimientoDieta']:
+                data[key]['cumplimientoDieta'] += ' | bien'
+            elif 'regular, me cuesta llegar' in data[key]['cumplimientoDieta'] or 'regular, me salto la dieta' in data[key]['cumplimientoDieta']:
+                data[key]['cumplimientoDieta'] += ' | regular'
+            elif 'Nada, mantén mis macros' in data[key]['cumplimientoDieta']:
+                data[key]['cumplimientoDieta'] += ' | mal'
+            else:
+                data[key]['cumplimientoDieta'] += ' | no data'
+    return data
+
+# Change objetivo
+def change_objetivo(data):
+    # Get the date keys
+    data_date_keys = list(get_sorted_date_keys(data))
+
+    # Iterate over the date keys
+    for key in data_date_keys:
+        # If data hasn't 'objetivo' key, create it
+        if 'objetivo' not in data[key]:
+            data[key]['objetivo'] = 'None | no data'
+
+        # If data has 'objetivo' key, change it
+        if 'objetivo' in data[key]:
+            if 'definición (nada cambia)' in data[key]['objetivo'] or 'empezamos a definir (cambia)' in data[key]['objetivo'] or 'perder peso (nada cambia)' in data[key]['objetivo']:
+                data[key]['objetivo'] += ' | definicion'
+            elif 'volumen (nada cambia)' in data[key]['objetivo'] or 'empezamos a coger volumen (cambia)' in data[key]['objetivo'] or 'empezamos a coger volumen, sobre todo tren inferior (cambia)' in data[key]['objetivo'] or 'empezamos a coger volumen, en todo el cuerpo (cambia)' in data[key]['objetivo']:
+                data[key]['objetivo'] += ' | volumen'
+            else:
+                data[key]['objetivo'] += ' | no data'
+    return data
+
+# Change cumplimientoEntrenamiento
+def change_cumplimiento_entrenamiento(data):
+    # Get the date keys
+    data_date_keys = list(get_sorted_date_keys(data))
+
+    # Iterate over the date keys
+    for key in data_date_keys:
+        # If data hasn't 'cumplimientoEntrenamiento' key, create it
+        if 'cumplimientoEntrenamiento' not in data[key]:
+            data[key]['cumplimientoEntrenamiento'] = 'None | no data'
+
+        # If data has 'cumplimientoEntrenamiento' key, change it
+        if 'cumplimientoEntrenamiento' in data[key]:
+            if 'Lo hice perfecto' in data[key]['cumplimientoEntrenamiento'] or 'He fallado algunos días, pero sí' in data[key]['cumplimientoEntrenamiento'] or 'Lo hice prácticamente perfecto' in data[key]['cumplimientoEntrenamiento']:
+                data[key]['cumplimientoEntrenamiento'] += ' | bien'
+            elif 'Lesión importante' in data[key]['cumplimientoEntrenamiento'] or 'Pequeña lesión' in data[key]['cumplimientoEntrenamiento'] or 'No hice nada, mantenemos la rutina un mes más' in data[key]['cumplimientoEntrenamiento'] or 'Alárgame la rutina una semana más' in data[key]['cumplimientoEntrenamiento']:
+                data[key]['cumplimientoEntrenamiento'] += ' | mal'
+            else:
+                data[key]['cumplimientoEntrenamiento'] += ' | no data'
+    return data
+
+# Change compromiso
+def change_compromiso(data):
+    # Get the date keys
+    data_date_keys = list(get_sorted_date_keys(data))
+
+    # Iterate over the date keys
+    for key in data_date_keys:
+        # If data hasn't 'compromiso' key, create it
+        if 'compromiso' not in data[key]:
+            data[key]['compromiso'] = 'None | no data'
+
+
+        # If data has 'compromiso' key, change it
+        if 'compromiso' in data[key]:
+            if 'Bueno, pero mejorable' in data[key]['compromiso'] or 'Máximo' in data[key]['compromiso']:
+                data[key]['compromiso'] += ' | bueno'
+            elif 'Mal, pero a partir de ahora voy a por todas' in data[key]['compromiso'] or 'Mal, demasiado exigente' in data[key]['compromiso']:
+                data[key]['compromiso'] += ' | mal'
+            else:
+                data[key]['compromiso'] += ' | no data'
+    return data
+
+# Add real weight difference to all the dates
+def add_real_weight_difference(data, keys_dates):
+    number_of_keys_dates = len(keys_dates)
+    for i in range(1,number_of_keys_dates):
+        data[keys_dates[i]]['diferencia_peso'] = data[keys_dates[i]]['peso'] - data[keys_dates[i-1]]['peso']
+    return data
+
+if __name__ == '__main__':
+    # Get all the files in the formularios_path
+    files = Path(formularios_path).glob('*.json')
+
+    # Sort the files by name
+    # files = sorted(files, key=lambda x: x.name)
+
+    # Load all the files
+    for file in tqdm(files):
+        # Get data from the file
+        with open(file, 'r') as f:
+            data = json.load(f)
+
+        # Create new empty dictionary
+        data_sorted = {}
+        
+        # Get the date and non date keys
+        keys_dates = get_sorted_date_keys(data)
+        keys_non_dates = get_non_date_keys(data)
+
+        # Add empty weight difference to all the dates
+        for key_date in keys_dates:
+            data[key_date] = add_empty_weight_difference(data[key_date])
+
+        # Add real weight difference to all the dates
+        data = add_real_weight_difference(data, keys_dates)
+
+        # Change esfuerzo para cumplir dieta
+        data = change_esfuerzo_para_cumplir_dieta(data)
+
+        # Change cumplimiebto dieta
+        data = change_cumplimiento_dieta(data)
+
+        # Change objetivo
+        data = change_objetivo(data)
+
+        # Change cumplimientoEntrenamiento
+        data = change_cumplimiento_entrenamiento(data)
+
+        # Change compromiso
+        data = change_compromiso(data)
+
+        # Sort the keys
+        sorted_keys = keys_non_dates + keys_dates
+
+        # Add the sorted keys to the new dictionary
+        for key in sorted_keys:
+            data_sorted[key] = data[key]
+
+        # Save the data to the file
+        file_path = Path(formularios_weight_difference_path) / file.name
+        with open(file_path, 'w') as f:
+            json.dump(data_sorted, f, indent=4)

create_new_usuarios.py

@@ -0,0 +1,131 @@
+from pathlib import Path
+import json
+from datetime import datetime
+from tqdm import tqdm
+
+# Paths
+usuarios_path = 'usuarios'
+usuarios_macros_difference_path = 'usuarios_macros_difference'
+
+# Get sorted date keys
+def get_sorted_date_keys(data):
+    keys = list(data.keys())
+    keys_dates = []
+    for key in keys:
+        try:
+            keys_dates.append(datetime.strptime(key, '%Y-%m-%d'))
+        except ValueError:
+            pass
+    keys_sorted = sorted(keys_dates)
+    keys_sorted = [key.strftime('%Y-%m-%d') for key in keys_sorted]
+    keys_sorted = [key.replace('-01', '-1') for key in keys_sorted]
+    keys_sorted = [key.replace('-02', '-2') for key in keys_sorted]
+    keys_sorted = [key.replace('-03', '-3') for key in keys_sorted]
+    keys_sorted = [key.replace('-04', '-4') for key in keys_sorted]
+    keys_sorted = [key.replace('-05', '-5') for key in keys_sorted]
+    keys_sorted = [key.replace('-06', '-6') for key in keys_sorted]
+    keys_sorted = [key.replace('-07', '-7') for key in keys_sorted]
+    keys_sorted = [key.replace('-08', '-8') for key in keys_sorted]
+    keys_sorted = [key.replace('-09', '-9') for key in keys_sorted]
+    return keys_sorted
+
+# Get non date keys
+def get_non_date_keys(data):
+    keys = list(data.keys())
+    keys_non_dates = []
+    for key in keys:
+        try:
+            datetime.strptime(key, '%Y-%m-%d')
+        except ValueError:
+            keys_non_dates.append(key)
+    return keys_non_dates
+
+# Get macros from string data
+def get_macros_from_string(data):
+    macros = data.split(' ')
+    if len(macros) != 8:
+        return None
+    for i, macro in enumerate(macros):
+        if '.' in macro:
+            macro = macro.split('.')[0]
+            macros[i] = macro
+        if macro == '':
+            return None
+    macros = [int(macro) for macro in macros]
+    is_all_numbers = all((type(macro)==int or type(macro)==float) for macro in macros)
+    if not is_all_numbers:
+        return None
+    return macros
+
+# Add empty weight difference to all the dates
+def add_empty_macros_difference(data):
+    new_data = {}
+    new_data['macros'] = data
+    new_data['diferencia_macros'] = '0 0 0 0 0 0 0 0'
+    return new_data
+
+# Add real macros difference to all the dates
+def add_real_macros_difference(data, keys_dates):
+    # Get the number of keys dates
+    number_of_keys_dates = len(keys_dates)
+
+    # Iterate over the keys dates
+    for i in range(1,number_of_keys_dates):
+        # Get the previous macros
+        previous_macros = data[keys_dates[i-1]]['macros']
+        previous_macros = get_macros_from_string(previous_macros)
+        if previous_macros is None:
+            return data
+
+        # Get the current macros
+        current_macros = data[keys_dates[i]]['macros']
+        current_macros = get_macros_from_string(current_macros)
+        if current_macros is None:
+            return data
+
+        # Calculate the difference
+        diferencia_macros = [current_macros[i] - previous_macros[i] for i in range(8)]
+        diferencia_macros = ' '.join(str(diferencia) for diferencia in diferencia_macros)
+
+        # Add the difference to the data
+        data[keys_dates[i]]['diferencia_macros'] = diferencia_macros
+    return data
+
+if __name__ == '__main__':
+    # Get all the files in the formularios_path
+    files = Path(usuarios_path).glob('*.json')
+
+    # Sort the files by name
+    files = sorted(files, key=lambda x: x.name)
+
+    # Load all the files
+    for file in tqdm(files):
+        # Get data from the file
+        with open(file, 'r') as f:
+            data = json.load(f)
+
+        # Create new empty dictionary
+        data_sorted = {}
+        
+        # Get the date and non date keys
+        keys_dates = get_sorted_date_keys(data)
+        keys_non_dates = get_non_date_keys(data)
+
+        # Add empty weight difference to all the dates
+        for key_date in keys_dates:
+            data[key_date] = add_empty_macros_difference(data[key_date])
+
+        # Add real weight difference to all the dates
+        data = add_real_macros_difference(data, keys_dates)
+
+        # Concatenate the non date keys and the date keys
+        sorted_keys = keys_non_dates + keys_dates
+
+        # Add the sorted keys to the new dictionary
+        for key in sorted_keys:
+            data_sorted[key] = data[key]
+
+        # Save the data to the file
+        file_path = Path(usuarios_macros_difference_path) / file.name
+        with open(file_path, 'w') as f:
+            json.dump(data_sorted, f, indent=4)

find_matches.py

@@ -0,0 +1,82 @@
+from pathlib import Path
+import json
+from queries import query_formularios, query_usuarios, get_macros_differences
+                     
+formularios_weight_difference_path = 'anonymized_formularios_weight_difference'
+usuarios_macros_difference_path = 'usuarios_macros_difference'
+
+# Find users dates that match the query
+def find_user_dates_matches(query, debug=False):
+    # Create a dictionary to store the matches
+    matches_dict = {}
+
+    # Get all the files in the formularios_path
+    files = Path(formularios_weight_difference_path).glob('*.json')
+    files = list(files)
+    files.sort()
+
+    # Iterate over the user data
+    for i, file in enumerate(files):
+        with open(file, 'r') as f:
+            data = json.load(f)
+
+        if file.name == '[email protected]':
+            dates = query_formularios(data, query, debug=False, file_name=file.name)
+        else:
+            dates = query_formularios(data, query, debug=debug)
+        if len(dates) > 0:
+            file_name = file.name
+            matches_dict[file_name] = dates
+            if debug:
+                if i > 0:
+                    print("")
+                print(f"{file_name} has {len(dates)} dates that match the query:")
+                for date in dates:
+                    print(f"\t{date}")
+                    for query_item in query:
+                        key = list(query_item.keys())[0]
+                        data_value = data[date][key]
+                        query_value = query_item[key]['value']
+                        operator = query_item[key]['operator']
+                        if type(data_value) == int or type(data_value) == float:
+                            data_value = f"{data_value:.2f}"
+                        if operator == 'in' or operator == 'contains':
+                            print(f"\t\t{key} data: \"{data_value}\", query: \"{query_value}\"")
+                        else:
+                            print(f"\t\t{key} data: \"{data_value}\" \"{operator}\" query: \"{query_value}\"")
+    
+    return matches_dict
+
+def find_macros_that_match_dates_of_users(matches_dict, debug=False):
+    # Create a list to store the macros differences
+    macros_differences_list = []
+
+    # Iterate over the matches dictionary
+    for match_user in matches_dict:
+        if debug: print(f"match_user: {match_user}")
+
+        # Get dates list
+        dates_list_from_user = matches_dict[match_user]
+
+        # Get user data
+        user_data = usuarios_macros_difference_path + '/' + match_user
+        user_data = json.load(open(user_data, 'r'))
+
+        # Query usuarios
+        dates_that_match = query_usuarios(user_data, dates_list_from_user, debug=False, limit_days=31)
+        if len(dates_that_match) > 0:
+            if debug: print(f"\tdates that match: {dates_that_match}")
+
+            # Get macros differences
+            macros_differences = get_macros_differences(user_data, dates_that_match)
+            if type(macros_differences) == list:
+                if len(macros_differences) > 0:
+                    for macros_difference in macros_differences:
+                        macros_differences_list.append(macros_difference)
+                        if debug: print(f"\tmacros_differences: {macros_difference}")
+                    if debug: print("")
+            else:
+                macros_differences_list.append(macros_differences)
+                if debug: print(f"\tmacros_differences: {macros_differences}\n")
+    
+    return macros_differences_list

queries.py

@@ -0,0 +1,685 @@
+from create_new_formularios import get_sorted_date_keys
+from pathlib import Path
+from datetime import datetime
+from create_new_usuarios import get_macros_from_string
+import statistics
+
+def query_formularios(data, query_list, debug=False, file_name=None):
+
+    if file_name is not None:
+        debug = True
+        print(f"***************** file_name: {file_name} *****************")
+
+    # Get date keys
+    date_keys = get_sorted_date_keys(data)
+    if debug: print(f"\n\n\ndate_keys: {date_keys}")
+
+    # List of date keys that match the query
+    date_keys_that_match = []
+
+    # No data value
+    no_data_value = "| no data"
+
+    # Get all the keys in the query_list
+    queries_list = []
+    for query in query_list:
+        queries_list.append(query)
+    if debug:
+        print("queries_list:")
+        for query in queries_list:
+            for key in query.keys():
+                print(f"\tkey: {key}", end=" --> ")
+                for second_key in query[key].keys():
+                    print(f"{key}: {query[key][second_key]}", end=", ")
+                print("")
+
+    # For each date key get all the keys
+    for date_key in date_keys:
+        if debug: print(f"\n * date_key: {date_key}")
+
+        # match is a boolean that will be true if the key is in query_dict
+        match = False
+        if debug: print(f"\tinitial match value: {match}")
+
+        # Get all the keys in the data
+        data_keys = data[date_key].keys()
+        if debug: print(f"\tkeys: {data_keys}")
+
+        # Find for each key if it is in query_dict
+        for query in queries_list:
+            # Get the query key
+            query_key = list(query.keys())[0]
+
+            # Get the query operator and value
+            query_operator = query[query_key]['operator']
+            is_operator_for_numbers = query_operator == '>' or query_operator == '<' or query_operator == '>=' or query_operator == '<='
+            query_value = query[query_key]['value']
+            type_of_query_value = type(query_value)
+            is_query_value_string = type_of_query_value == str
+            is_query_value_number = type_of_query_value == int or type_of_query_value == float
+
+            # Check if the query key is in the data
+            if query_key in data_keys:
+                # Get the data value
+                data_value = data[date_key][query_key]
+                type_of_data_value = type(data_value)
+                is_data_value_string = type_of_data_value == str
+                is_data_value_number = type_of_data_value == int or type_of_data_value == float
+                is_data_value_and_query_value_number = is_data_value_number and is_query_value_number
+                is_data_value_and_query_value_string = is_data_value_string and is_query_value_string
+                is_data_value_or_query_value_number = is_data_value_number or is_query_value_number
+                is_data_value_or_query_value_string = is_data_value_string or is_query_value_string
+                if debug: print(f"\t\tchecking \"{query_key}\" in data, query operator: \"{query_operator}\", query value: \"{query_value}\", data value: \"{data_value}\"")
+
+                # Check if the data value matches the query value
+                if query_operator == '==':
+                    if query_value == data_value:
+                        match = True
+                        if debug: print(f"\t\t\t\"{query_value}\" is equal to \"{data_value}\", match: {match}")
+                    else:
+                        match = False
+                        if debug: print(f"\t\t\t\"{query_value}\" is NOT equal to \"{data_value}\", match: {match}")
+                        break
+                    # continue
+                elif query_operator == '!=':
+                    if query_value != data_value:
+                        match = True
+                        if debug: print(f"\t\t\t\"{query_value}\" is NOT equal to \"{data_value}\", match: {match}")
+                    else:
+                        match = False
+                        if debug: print(f"\t\t\t\"{query_value}\" is NOT equal to \"{data_value}\", match: {match}")
+                        break
+                    # continue
+                elif is_query_value_number and is_data_value_number and query_operator == '>':
+                    if data_value > query_value:
+                        match = True
+                        if debug: print(f"\t\t\t\"{query_value}\" is greater than \"{data_value}\", match: {match}")
+                    else:
+                        match = False
+                        if debug: print(f"\t\t\t\"{query_value}\" is NOT greater than \"{data_value}\", match: {match}")
+                        break
+                    # continue
+                elif is_query_value_number and is_data_value_number and query_operator == '<':
+                    if data_value < query_value:
+                        match = True
+                        if debug: print(f"\t\t\t\"{query_value}\" is less than \"{data_value}\", match: {match}")
+                    else:
+                        match = False
+                        if debug: print(f"\t\t\t\"{query_value}\" is NOT less than \"{data_value}\", match: {match}")
+                        break
+                    # continue
+                elif is_query_value_number and is_data_value_number and query_operator == '>=':
+                    if data_value >= query_value:
+                        match = True
+                        if debug: print(f"\t\t\t\"{query_value}\" is greater than or equal to \"{data_value}\", match: {match}")
+                    else:
+                        match = False
+                        if debug: print(f"\t\t\t\"{query_value}\" is NOT greater than or equal to \"{data_value}\", match: {match}")
+                        break
+                    # continue
+                elif is_query_value_number and is_data_value_number and query_operator == '<=':
+                    if data_value <= query_value:
+                        match = True
+                        if debug: print(f"\t\t\t\"{query_value}\" is less than or equal to \"{data_value}\", match: {match}")
+                    else:
+                        match = False
+                        if debug: print(f"\t\t\t\"{query_value}\" is NOT less than or equal to \"{data_value}\", match: {match}")
+                        break
+                    # continue
+                elif is_query_value_string and is_data_value_string and query_operator == 'in' or query_operator == 'contains':
+                    if query_value in data_value or no_data_value in data_value:
+                        match = True
+                        if debug: print(f"\t\t\t\"{query_value}\" is in \"{data_value}\", match: {match}")
+                    else:
+                        match = False
+                        if debug: print(f"\t\t\t\"{query_value}\" is NOT in \"{data_value}\", match: {match}")
+                        break
+                    # continue
+                elif is_query_value_string and is_data_value_string and (query_operator == 'NOT in' or query_operator == 'NOT contains'):
+                    if query_value not in data_value or no_data_value in data_value:
+                        match = True
+                        if debug: print(f"\t\t\t\"{query_value}\" is NOT in \"{data_value}\", match: {match}")
+                    else:
+                        match = False
+                        if debug: print(f"\t\t\t\"{query_value}\" is NOT in \"{data_value}\", match: {match}")
+                        break
+                    # continue
+                elif query_operator == 'is null':
+                    if data_value is None:
+                        match = True
+                        if debug: print(f"\t\t\t\"{query_value}\" is null, match: {match}")
+                    else:
+                        match = False
+                        if debug: print(f"\t\t\t\"{query_value}\" is NOT null, match: {match}")
+                        break
+                    # continue
+                elif query_operator == 'is NOT null':
+                    if data_value is not None:
+                        match = True
+                        if debug: print(f"\t\t\t\"{query_value}\" is NOT null, match: {match}")
+                    else:
+                        match = False
+                        if debug: print(f"\t\t\t\"{query_value}\" is NOT null, match: {match}")
+                        break
+                    # continue
+                elif is_operator_for_numbers and is_data_value_or_query_value_string:
+                    if is_data_value_string and is_query_value_string:
+                        match = False
+                        if debug: print(f"\t\t\toperator \"{query_operator}\" NOT supported, because data value is string and query value is string, match: {match}")
+                        break
+                    elif is_data_value_string and is_query_value_number:
+                        match = False
+                        if debug: print(f"\t\t\toperator \"{query_operator}\" NOT supported, because data value is string, match: {match}")
+                        break
+                    else:
+                        match = False
+                        if debug: print(f"\t\t\toperator \"{query_operator}\" NOT supported, because query value is number, match: {match}")
+                        break
+                else:
+                    match = False
+                    if debug: print(f"\t\t\toperator \"{query_operator}\" NOT supported, match: {match}")
+                    break
+                    # continue
+            
+        # If the match is true, add the date_key to the list
+        if match:
+            if debug: print(f"\t***** {query_key} matches, adding date_key: {date_key} *****")
+            date_keys_that_match.append(date_key)
+            if debug:
+                print("\t dates that match:")
+                for date_key in date_keys_that_match:
+                    print(f"\t\t{date_key}")
+
+    return date_keys_that_match
+
+def string_date_list_to_date_list(string_date_list):
+    date_list = []
+    for string_date in string_date_list:
+        date_list.append(datetime.strptime(string_date, '%Y-%m-%d'))
+    return date_list
+
+def date_to_string(date):
+    string_date = date.strftime('%Y-%m-%d')
+    string_date = string_date.replace('-01', '-1')
+    string_date = string_date.replace('-02', '-2')
+    string_date = string_date.replace('-03', '-3')
+    string_date = string_date.replace('-04', '-4')
+    string_date = string_date.replace('-05', '-5')
+    string_date = string_date.replace('-06', '-6')
+    string_date = string_date.replace('-07', '-7')
+    string_date = string_date.replace('-08', '-8')
+    string_date = string_date.replace('-09', '-9')
+    return string_date
+
+def get_days_between_dates(date1, date2):
+    return (date1 - date2).days
+
+def query_usuarios(data, query_list, limit_days=8, debug=False):
+    # Get date keys
+    date_keys = get_sorted_date_keys(data)
+    if debug: print(f"\tdate_keys: {date_keys}")
+
+    # Format date_keys to date objects
+    date_keys = string_date_list_to_date_list(date_keys)
+
+    # Format query_list to date objects
+    if debug: print(f"\tquery_list: {query_list}")
+    query_list = string_date_list_to_date_list(query_list)
+
+    # Create empty list to store the date_keys that match
+    date_keys_that_match = []
+
+    # Iterate for each query_list date
+    for query_date in query_list:
+        # Iterate for each date_key
+        for date_key in date_keys:
+            # Get the days between the query_date and the date_key
+            days_between = get_days_between_dates(query_date, date_key)
+            if days_between <= limit_days and days_between > 0:
+                if debug: print(f"\tdays between form data {date_to_string(query_date)} and macros change data {date_to_string(date_key)}: {days_between}")
+
+                # Add the date_key to the list and break the loop, because is first mach so is match with less days between dates
+                date_keys_that_match.append(date_to_string(date_key))
+                break
+
+    return date_keys_that_match
+
+def get_macros_differences(data, dates_list):
+    macros_differences_list = []
+    for date in dates_list:
+        macros_differences_list.append(data[date]['diferencia_macros'])
+    return macros_differences_list
+
+def get_min_max_mean_mode_macros_differences(macros_differences_list):
+    # Create list for each macro
+    train_day_protein_list = []
+    train_day_carbs_list = []
+    train_day_fat_list = []
+    intratrain_protein_list = []
+    intratrain_carbs_list = []
+    rest_day_protein_list = []
+    rest_day_carbs_list = []
+    rest_day_fat_list = []
+
+    # Iterate over the macros differences list
+    for macros_difference in macros_differences_list:
+        # Get the macros difference as a list of integers
+        macros_difference_int_list = get_macros_from_string(macros_difference)
+
+        # Append the macros difference to the list
+        train_day_protein_list.append(macros_difference_int_list[0])
+        train_day_carbs_list.append(macros_difference_int_list[1])
+        train_day_fat_list.append(macros_difference_int_list[2])
+        intratrain_protein_list.append(macros_difference_int_list[3])
+        intratrain_carbs_list.append(macros_difference_int_list[4])
+        rest_day_protein_list.append(macros_difference_int_list[5])
+        rest_day_carbs_list.append(macros_difference_int_list[6])
+        rest_day_fat_list.append(macros_difference_int_list[7])
+    
+    # Get the min, max, mean and mode of the macros differences
+    min_train_day_protein = min(train_day_protein_list)
+    max_train_day_protein = max(train_day_protein_list)
+    mean_train_day_protein = sum(train_day_protein_list) / len(train_day_protein_list)
+    mode_train_day_protein = statistics.mode(train_day_protein_list)
+    train_day_protein_std = (min_train_day_protein, max_train_day_protein, mean_train_day_protein, mode_train_day_protein)
+
+    min_train_day_carbs = min(train_day_carbs_list)
+    max_train_day_carbs = max(train_day_carbs_list)
+    mean_train_day_carbs = sum(train_day_carbs_list) / len(train_day_carbs_list)
+    mode_train_day_carbs = statistics.mode(train_day_carbs_list)
+    train_day_carbs_std = (min_train_day_carbs, max_train_day_carbs, mean_train_day_carbs, mode_train_day_carbs)
+
+    min_train_day_fat = min(train_day_fat_list)
+    max_train_day_fat = max(train_day_fat_list)
+    mean_train_day_fat = sum(train_day_fat_list) / len(train_day_fat_list)
+    mode_train_day_fat = statistics.mode(train_day_fat_list)
+    train_day_fat_std = (min_train_day_fat, max_train_day_fat, mean_train_day_fat, mode_train_day_fat)
+
+    min_intratrain_protein = min(intratrain_protein_list)
+    max_intratrain_protein = max(intratrain_protein_list)
+    mean_intratrain_protein = sum(intratrain_protein_list) / len(intratrain_protein_list)
+    mode_intratrain_protein = statistics.mode(intratrain_protein_list)
+    intratrain_protein_std = (min_intratrain_protein, max_intratrain_protein, mean_intratrain_protein, mode_intratrain_protein)
+
+    min_intratrain_carbs = min(intratrain_carbs_list)
+    max_intratrain_carbs = max(intratrain_carbs_list)
+    mean_intratrain_carbs = sum(intratrain_carbs_list) / len(intratrain_carbs_list)
+    mode_intratrain_carbs = statistics.mode(intratrain_carbs_list)
+    intratrain_carbs_std = (min_intratrain_carbs, max_intratrain_carbs, mean_intratrain_carbs, mode_intratrain_carbs)
+
+    min_rest_day_protein = min(rest_day_protein_list)
+    max_rest_day_protein = max(rest_day_protein_list)
+    mean_rest_day_protein = sum(rest_day_protein_list) / len(rest_day_protein_list)
+    mode_rest_day_protein = statistics.mode(rest_day_protein_list)
+    rest_day_protein_std = (min_rest_day_protein, max_rest_day_protein, mean_rest_day_protein, mode_rest_day_protein)
+
+    min_rest_day_carbs = min(rest_day_carbs_list)
+    max_rest_day_carbs = max(rest_day_carbs_list)
+    mean_rest_day_carbs = sum(rest_day_carbs_list) / len(rest_day_carbs_list)
+    mode_rest_day_carbs = statistics.mode(rest_day_carbs_list)
+    rest_day_carbs_std = (min_rest_day_carbs, max_rest_day_carbs, mean_rest_day_carbs, mode_rest_day_carbs)
+
+    min_rest_day_fat = min(rest_day_fat_list)
+    max_rest_day_fat = max(rest_day_fat_list)
+    mean_rest_day_fat = sum(rest_day_fat_list) / len(rest_day_fat_list)
+    mode_rest_day_fat = statistics.mode(rest_day_fat_list)
+    rest_day_fat_std = (min_rest_day_fat, max_rest_day_fat, mean_rest_day_fat, mode_rest_day_fat)
+
+    return 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
+
+def clustering_esfuerzo_dieta_response(response, debug=False):
+    # Options:
+    #     No entiendo la calculadora, quiero menús tipo, cárgame 4|I: 2
+	#     No costó nada|A: 1504
+	#     Costó demasiado, súbeme macros|D: 28
+	#     Costó, pero me adapto a nuevos ajustes|C: 331
+	#     Iba a coger menús tipo, pero al final por precio no|D: 13
+	#     Costó demasiado, bájame macros|D: 42
+	#     No entiendo la calculadora, quiero menús tipo, cárgame 2|I: 3
+    # 
+    # Clustering:
+    #     0 (No data): 
+    #         No entiendo la calculadora, quiero menús tipo, cárgame 4|I: 2 | No data
+    #         Iba a coger menús tipo, pero al final por precio no|D: 13 | No data
+    #         No entiendo la calculadora, quiero menús tipo, cárgame 2|I: 3 | No data
+    #     1 (costó subir macros): 
+    #         Costó demasiado, súbeme macros|D: 28 | costo subir macros
+    #     2 (costó bajar macros): 
+    #         Costó demasiado, bájame macros|D: 42 | costo bajar macros
+    #     3 (costó y me adapto a nuevos ajustes): 
+    #         Costó, pero me adapto a nuevos ajustes|C: 331 | costo y me adapto a nuevos ajustes
+    #     4 (no costó): 
+    #         No costó nada|A: 1504 | no costo
+
+    if " | No data".lower() in response.lower():
+        if debug: print(f"\t\t{response} -> no data")
+        return 'no data'
+    elif " | costo subir macros".lower() in response.lower():
+        if debug: print(f"\t\t{response} -> costo subir macros")
+        return 'costo subir macros'
+    elif " | costo bajar macros".lower() in response.lower():
+        if debug: print(f"\t\t{response} -> costo bajar macros")
+        return 'costo bajar macros'
+    elif " | costo y me adapto a nuevos ajustes".lower() in response.lower():
+        if debug: print(f"\t\t{response} -> costo y me adapto a nuevos ajustes")
+        return 'costo y me adapto a nuevos ajustes'
+    elif " | no costo".lower() in response.lower():
+        if debug: print(f"\t\t{response} -> no costo")
+        return 'no costo'
+    else:
+        if debug: print(f"\t\t{response} -> no data")
+        return 'no data'
+
+def clustering_objetivo_response(response, debug=False):
+    # Options:
+    #     definición (nada cambia)|A: 1031
+    #     empezamos a definir (cambia)|C: 92
+    #     perder peso (nada cambia)|A: 21
+    #     volumen (nada cambia)|A: 688
+    #     empezamos a coger volumen (cambia)|C: 78
+    #     empezamos a coger volumen, sobre todo tren inferior (cambia)|C: 7
+    #     empezamos a coger volumen, en todo el cuerpo (cambia)|C: 6
+    # 
+    # Clustering:
+    #     0 (definición): 
+    #         definición (nada cambia)|A: 1031 | definición
+    #         empezamos a definir (cambia)|C: 92 | definición
+    #         perder peso (nada cambia)|A: 21 | definición
+    #     1 (volumen): 
+    #         volumen (nada cambia)|A: 688 | volumen
+    #         empezamos a coger volumen (cambia)|C: 78 | volumen
+    #         empezamos a coger volumen, sobre todo tren inferior (cambia)|C: 7 | volumen
+    #         empezamos a coger volumen, en todo el cuerpo (cambia)|C: 6 | volumen
+
+    if " | definicion".lower() in response.lower():
+        if debug: print(f"\t\t{response} -> definicion")
+        return 'definicion'
+    elif " | volumen".lower() in response.lower():
+        if debug: print(f"\t\t{response} -> volumen")
+        return 'volumen'
+    else:
+        if debug: print(f"\t\t{response} -> no data")
+        return 'no data'
+
+def clustering_entrenamiento_response(response, debug=False):
+    # Options:
+    #     Lo hice perfecto|A|10: 838
+    #     He fallado algunos días, pero sí|B|5: 98
+    #     Lesión importante: 16
+    #     Lo hice prácticamente perfecto|A|8: 416
+    #     Pequeña lesión: 63
+    #     No hice nada, mantenemos la rutina un mes más|I|0: 64
+    #     Alárgame la rutina una semana más|I|6: 32
+    # 
+    # Clustering:
+    #     0 (bien): 
+    #         Lo hice perfecto|A|10: 838 | bien
+    #         He fallado algunos días, pero sí|B|5: 98 | bien
+    #         Lo hice prácticamente perfecto|A|8: 416 | bien
+    #     1 (mal): 
+    #         Lesión importante: 16 | mal
+    #         Pequeña lesión: 63 | mal
+    #         No hice nada, mantenemos la rutina un mes más|I|0: 64 | mal
+    #         Alárgame la rutina una semana más|I|6: 32 | mal
+    
+    if " | bien".lower() in response.lower():
+        if debug: print(f"\t\t{response} -> bien")
+        return 'bien'
+    elif " | mal".lower() in response.lower():
+        if debug: print(f"\t\t{response} -> mal")
+        return 'mal'
+    else:
+        if debug: print(f"\t\t{response} -> no data")
+        return 'no data'
+
+def clustering_cumplimiento_dieta_response(response, debug=False):
+    # Options:
+    #     al 70%|B|6: 564
+    #     regular, me cuesta llegar|C|5: 57
+    #     Nada, mantén mis macros|I|0: 123
+    #     casi perfecta|A|9: 610
+    #     regular, me salto la dieta|C|4: 6
+    #     Perfecta|A|10: 563
+    # 
+    # Clustering:
+    #     0 (bien): 
+    #         al 70%|B|6: 564 | bien
+    #         casi perfecta|A|9: 610 | bien
+    #         Perfecta|A|10: 563 | bien
+    #     1 (regular): 
+    #         regular, me cuesta llegar|C|5: 57 | regular
+    #         regular, me salto la dieta|C|4: 6 | regular
+    #     2 (mal): 
+    #         Nada, mantén mis macros|I|0: 123 | mal
+
+    if " | bien".lower() in response.lower():
+        if debug: print(f"\t\t{response} -> bien")
+        return 'bien'
+    elif " | regular".lower() in response.lower():
+        if debug: print(f"\t\t{response} -> regular")
+        return 'regular'
+    elif "nada" in response.lower():
+        if debug: print(f"\t\t{response} -> mal")
+        return 'mal'
+    else:
+        if debug: print(f"\t\t{response} -> no data")
+        return 'no data'
+
+def clustering_compromiso_response(response, debug=False):
+    # Options:
+    #     Bueno, pero mejorable|B|7: 604
+    #     Mal, pero a partir de ahora voy a por todas|C|0: 319
+    #     Mal, demasiado exigente|D|0: 15
+    #     Máximo|A|10: 985
+    # 
+    # Clustering:
+    #     0 (bueno): 
+    #         Bueno, pero mejorable|B|7: 604 | bueno
+    #         Máximo|A|10: 985 | bueno
+    #     1 (mal): 
+    #         Mal, pero a partir de ahora voy a por todas|C|0: 319 | mal
+    #         Mal, demasiado exigente|D|0: 15 | mal
+
+    if " | bueno".lower() in response.lower():
+        if debug: print(f"\t\t{response} -> bueno")
+        return 'bueno'
+    elif " | mal".lower() in response.lower():
+        if debug: print(f"\t\t{response} -> mal")
+        return 'mal'
+    else:
+        if debug: print(f"\t\t{response} -> no data")
+        return 'no data'
+
+def clustering_diferencia_peso_response(diff, debug=False):
+    diff_min = None
+    diff_max = None
+    if diff <= -5.0:
+        if debug: print(f"\t\t-10 <= {diff} <= -5")
+        diff_min = -10
+        diff_max = -5
+    elif diff <= -4.5:
+        if debug: print(f"\t\t-5 <= {diff} <= -4.5")
+        diff_min = -5
+        diff_max = -4.5
+    elif diff <= -4.0:
+        if debug: print(f"\t\t-4.5 <= {diff} <= -4.0")
+        diff_min = -4.5
+        diff_max = -4.0
+    elif diff <= -3.5:
+        if debug: print(f"\t\t-4.0 <= {diff} <= -3.5")
+        diff_min = -4.0
+        diff_max = -3.5
+    elif diff <= -3.0:
+        if debug: print(f"\t\t-3.5 <= {diff} <= -3.0")
+        diff_min = -3.5
+        diff_max = -3.0
+    elif diff <= -2.5:
+        if debug: print(f"\t\t-3.0 <= {diff} <= -2.5")
+        diff_min = -3.0
+        diff_max = -2.5
+    elif diff <= -2.0:
+        if debug: print(f"\t\t-2.5 <= {diff} <= -2.0")
+        diff_min = -2.5
+        diff_max = -2.0
+    elif diff <= -1.5:
+        if debug: print(f"\t\t-2.0 <= {diff} <= -1.5")
+        diff_min = -2.0
+        diff_max = -1.5
+    elif diff <= -1.0:
+        if debug: print(f"\t\t-1.5 <= {diff} <= -1.0")
+        diff_min = -1.5
+        diff_max = -1.0
+    elif diff <= -0.5:
+        if debug: print(f"\t\t-1.0 <= {diff} <= -0.5")
+        diff_min = -1.0
+        diff_max = -0.5
+    elif diff <= 0.0:
+        if debug: print(f"\t\t-0.5 <= {diff} <= 0.0")
+        diff_min = -0.5
+        diff_max = 0.0
+    elif diff <= 0.5:
+        if debug: print(f"\t\t0.0 <= {diff} <= 0.5")
+        diff_min = 0.0
+        diff_max = 0.5
+    elif diff <= 1.0:
+        if debug: print(f"\t\t0.5 <= {diff} <= 1.0")
+        diff_min = 0.5
+        diff_max = 1.0
+    elif diff <= 1.5:
+        if debug: print(f"\t\t1.0 <= {diff} <= 1.5")
+        diff_min = 1.0
+        diff_max = 1.5
+    elif diff <= 2.0:
+        if debug: print(f"\t\t1.5 <= {diff} <= 2.0")
+        diff_min = 1.5
+        diff_max = 2.0
+    elif diff <= 2.5:
+        if debug: print(f"\t\t2.0 <= {diff} <= 2.5")
+        diff_min = 2.0
+        diff_max = 2.5
+    elif diff <= 3.0:
+        if debug: print(f"\t\t2.5 <= {diff} <= 3.0")
+        diff_min = 2.5
+        diff_max = 3.0
+    elif diff <= 3.5:
+        if debug: print(f"\t\t3.0 <= {diff} <= 3.5")
+        diff_min = 3.0
+        diff_max = 3.5
+    elif diff <= 4.0:
+        if debug: print(f"\t\t3.5 <= {diff} <= 4.0")
+        diff_min = 3.5
+        diff_max = 4.0
+    elif diff <= 4.5:
+        if debug: print(f"\t\t4.0 <= {diff} <= 4.5")
+        diff_min = 4.0
+        diff_max = 4.5
+    elif diff <= 5.0:
+        if debug: print(f"\t\t4.5 <= {diff} <= 5.0")
+        diff_min = 4.5
+        diff_max = 5.0
+    else:
+        if debug: print(f"\t\t{diff} -> no data")
+        diff_min = None
+        diff_max = None
+    
+    return diff_min, diff_max
+
+def dieta_response(response_esfuerzo, response_cumplimiento, debug=False):
+    # esfuerzo dieta:
+    #     0 (No data): 
+    #         No entiendo la calculadora, quiero menús tipo, cárgame 4|I: 2
+    #         Iba a coger menús tipo, pero al final por precio no|D: 13
+    #         No entiendo la calculadora, quiero menús tipo, cárgame 2|I: 3
+    #     1 (costó subir macros): 
+    #         Costó demasiado, súbeme macros|D: 28
+    #     2 (costó bajar macros): 
+    #         Costó demasiado, bájame macros|D: 42
+    #     3 (costó y me adapto a nuevos ajustes): 
+    #         Costó, pero me adapto a nuevos ajustes|C: 331
+    #     4 (no costó): 
+    #         No costó nada|A: 1504
+    # compromiso dieta:
+    #     0 (bien): 
+    #         al 70%|B|6: 564
+    #         casi ©|A|9: 610
+    #         Perfecta|A|10: 563
+    #     1 (regular): 
+    #         regular, me cuesta llegar|C|5: 57
+    #         regular, me salto la dieta|C|4: 6
+    #     2 (mal): 
+    #         Nada, mantén mis macros|I|0: 123
+
+    esfuerzo_dieta_cluster = clustering_esfuerzo_dieta_response(response_esfuerzo, debug)
+    cumplimiento_dieta_cluster = clustering_cumplimiento_dieta_response(response_cumplimiento, debug)
+
+    if esfuerzo_dieta_cluster == 0:
+        dieta_bien = cumplimiento_dieta_cluster == 0
+        dieta_regular = cumplimiento_dieta_cluster == 1
+        dieta_mal = cumplimiento_dieta_cluster == 2
+    else:
+        dieta_bien = esfuerzo_dieta_cluster == 4 and cumplimiento_dieta_cluster == 0
+        dieta_regular = esfuerzo_dieta_cluster == 3 and cumplimiento_dieta_cluster == 1
+        dieta_mal = (esfuerzo_dieta_cluster == 2 or esfuerzo_dieta_cluster == 1) and cumplimiento_dieta_cluster == 2
+    
+    if dieta_bien:
+        return 0
+    elif dieta_regular:
+        return 1
+    elif dieta_mal:
+        return 2
+    else:
+        return 3
+
+def make_query(cluster_esfuerzo_dieta, cluster_objetivo, cluster_entrenamiento, cluster_cumplimiento_dieta, cluster_compromiso, diff_peso_min, diff_peso_max):
+    query = [
+        {
+            'esfuerzoParaCumplirDieta':
+                {
+                    'operator': 'in',
+                    'value': cluster_esfuerzo_dieta,
+                }
+        },
+        {
+            'objetivo':
+                {
+                    'operator': 'in',
+                    'value': cluster_objetivo,
+                }
+        },
+        {
+            'cumplimientoEntrenamiento':
+                {
+                    'operator': 'in',
+                    'value': cluster_entrenamiento,
+                }
+        },
+        {
+            'cumplimientoDieta':
+                {
+                    'operator': 'in',
+                    'value': cluster_cumplimiento_dieta,
+                }
+        },
+        {
+            'compromiso':
+                {
+                    'operator': 'in',
+                    'value': cluster_compromiso,
+                }
+        },
+        {
+            'diferencia_peso':
+                {
+                    'operator': '<=',
+                    'value': diff_peso_max,
+                }
+        },
+        {
+            'diferencia_peso':
+                {
+                    'operator': '>=',
+                    'value': diff_peso_min,
+                }
+        }
+    ]
+    return query