pablo.gg
🎮
coding

Usando Google Fitness API para calcular meu TDEE e mais

De calorias para código: Integrando Google Fitness API para insights personalizados de saúde

Escrito em 2 de agosto de 2023 - 🕒 16 min. de leitura

Quer alcançar os seus objetivos de fitness, como perder peso ou ganhar músculos? Tudo se resume a saber quantas calorias você queima em um dia, o que é chamado de Gasto Energético Diário Total (TDEE).

Pense no TDEE como o número dourado que guia as suas escolhas de alimentação e treino. Você precisa conhecê-lo para descobrir quanto comer se quiser manter, ganhar alguns quilos ou emagrecer.

Agora, existem várias ferramentas online que podem estimar o seu TDEE, mas obter dados do seu próprio corpo lhe dará o valor real.

Eu entendo, calcular esses números pode ser chato, especialmente se a matemática não for a sua praia. Mas ei, a Google Fitness API está aqui para te ajudar nessa!

Neste post, mostraremos como usar a Google Fitness API para calcular o seu TDEE e acompanhar o seu progresso ao longo do tempo.

Claro, para que isso funcione, você precisa monitorar consistentemente o seu peso e ingestão de alimentos. Eu recomendo obter uma balança de bioimpedância, que pode medir o seu peso, percentual de gordura corporal e massa muscular e o aplicativo Lifesum para rastrear a sua alimentação.

Usando a Google Fitness API

Já entendeu o básico sobre o TDEE? Show, agora vamos mergulhar em como podemos obter essas informações usando a Google Fitness API. Essa ferramenta bacana permite que programadores obtenham dados do Google Fit – esse é o aplicativo que coleta informações de saúde do seu telefone, smartwatches e outros aplicativos.

Para começar com a Google Fitness API, primeiro, vá ao Google Cloud Console e ative a Fitness API. Depois, precisaremos criar credenciais para o nosso projeto, para podermos acessar a API. Para obter mais detalhes, consulte o Guia de primeiros passos.

Uma vez que tudo esteja configurado, é só usar a API para colocar as mãos em alguns dados suculentos do Google Fit. Estamos falando de estatísticas de peso e alimentação, que nos ajudarão a acertar o cálculo do nosso TDEE.

Recuperando e Analisando os Dados

Agora que temos a nossa Google Fitness API configurada e pronta para usar, é hora de começar a recuperar e analisar os dados de que precisamos para calcular o nosso TDEE. O primeiro passo é fazer uma solicitação à API, pedindo os nossos dados de peso e nutrição dos últimos 30 dias.

Aqui está um exemplo de como essa solicitação pode ser feita:

const { google } = require('googleapis');

const fetchData = async () => {
  const auth = await google.auth.fromJSON({
    type: process.env.TOKEN_TYPE,
    client_id: process.env.CLIENT_ID,
    client_secret: process.env.CLIENT_SECRET,
    refresh_token: process.env.REFRESH_TOKEN,
  });

  auth.scopes = [
    'https://www.googleapis.com/auth/fitness.nutrition.read',
    'https://www.googleapis.com/auth/fitness.body.read',
  ];


  const endDate = new Date();
  const startDate = new Date();
  startDate.setDate(startDate.getDate() - 30); // past 30 days
  const startTimeNs = startDate.getTime() * 1000000;
  const endTimeNs = endDate.getTime() * 1000000;

  const weightData = await fetchDataForDataSource(
    'derived:com.google.weight:com.google.android.gms:merge_weight',
    auth,
    startTimeNs,
    endTimeNs
  );

  const fatPercentageData = await fetchDataForDataSource(
    'derived:com.google.body.fat.percentage:com.google.android.gms:merged',
    auth,
    startTimeNs,
    endTimeNs
  );

  const nutritionData = await fetchDataForDataSource(
    'derived:com.google.nutrition:com.google.android.gms:merged',
    auth,
    startTimeNs,
    endTimeNs
  );
};

A função google.auth.fromJSON é usada para criar um objeto de autenticação que pode ser utilizado para fazer solicitações à Google Fitness API. Em seguida, definimos os escopos para os quais queremos solicitar dados, que neste caso são https://www.googleapis.com/auth/fitness.nutrition.read e https://www.googleapis.com/auth/fitness.body.read. Depois disso, definimos a data de início e a data de término para a nossa solicitação, que são 30 dias atrás e hoje, respectivamente. Finalmente, chamamos a função fetchDataForDataSource três vezes, uma para os dados de peso, uma para os dados de percentual de gordura e uma para os dados de nutrição.

Mas o que a função fetchDataForDataSource faz? Vamos dar uma olhada:

const fitness = google.fitness('v1');

const fetchDataForDataSource = async (dataSourceId, auth, startTimeNs, endTimeNs) => {
  const response = await fitness.users.dataSources.datasets.get({
    userId: 'me',
    dataSourceId,
    datasetId: `${startTimeNs}-${endTimeNs}`,
    auth,
  });

  return response.data;
};

Com a API de fitness do googleapis, podemos fazer solicitações à Google Fitness API. Neste caso, estamos usando o método users.dataSources.datasets.get para obter dados de uma fonte de dados específica. Passamos o userId como me para obter dados do usuário atual, o dataSourceId que queremos obter dados, e o datasetId, que é uma combinação do horário de início e término em nanossegundos. Finalmente, passamos o objeto de autenticação que criamos anteriormente.

Agregando os Dados

Vamos dar uma olhada nos dados que recebemos da Google Fitness API:

Weight

{
  "minStartTimeNs": "1690662651313000000",
  "maxEndTimeNs": "1691008251313000000",
  "dataSourceId": "derived:com.google.weight:com.google.android.gms:merge_weight",
  "point": [
    {
      "startTimeNanos": "1690961397000000000",
      "endTimeNanos": "1690961397000000000",
      "dataTypeName": "com.google.weight",
      "originDataSourceId": "raw:com.google.weight:cn.fitdays.fitdays:",
      "value": [
        {
          "fpVal": 77.59,
          "mapVal": []
        }
      ],
      "modifiedTimeMillis": "1690963181330"
    }
  ]
}

Fat Percentage

{
  "minStartTimeNs": "1690662651313000000",
  "maxEndTimeNs": "1691008251313000000",
  "dataSourceId": "derived:com.google.body.fat.percentage:com.google.android.gms:merged",
  "point": [
    {
      "startTimeNanos": "1690961397000000000",
      "endTimeNanos": "1690961397000000000",
      "dataTypeName": "com.google.body.fat.percentage",
      "originDataSourceId": "raw:com.google.body.fat.percentage:cn.fitdays.fitdays:",
      "value": [
        {
          "fpVal": 20,
          "mapVal": []
        }
      ],
      "modifiedTimeMillis": "1690963181468"
    }
  ]
}

Nutrition

{
  "minStartTimeNs": "1690662651313000000",
  "maxEndTimeNs": "1691008251313000000",
  "dataSourceId": "derived:com.google.nutrition:com.google.android.gms:merged",
  "point": [
    {
      "startTimeNanos": "1690961397000000000",
      "endTimeNanos": "1690961397000000000",
      "dataTypeName": "com.google.nutrition",
      "originDataSourceId": "raw:com.google.nutrition:com.sillens.shapeupclub:health_platform",
      "value": [
        {
          "mapVal": [
            {
              "key": "fat.total",
              "value": {
                "fpVal": 16.349998474121094
              }
            },
            {
              "key": "sodium",
              "value": {
                "fpVal": 0
              }
            },
            {
              "key": "potassium",
              "value": {
                "fpVal": 0
              }
            },
            {
              "key": "fat.unsaturated",
              "value": {
                "fpVal": 3
              }
            },
            {
              "key": "fat.saturated",
              "value": {
                "fpVal": 13.34999942779541
              }
            },
            {
              "key": "protein",
              "value": {
                "fpVal": 5.25
              }
            },
            {
              "key": "carbs.total",
              "value": {
                "fpVal": 60.45000076293945
              }
            },
            {
              "key": "cholesterol",
              "value": {
                "fpVal": 0
              }
            },
            {
              "key": "calories",
              "value": {
                "fpVal": 412.5
              }
            },
            {
              "key": "sugar",
              "value": {
                "fpVal": 42.599998474121094
              }
            },
            {
              "key": "dietary_fiber",
              "value": {
                "fpVal": 0
              }
            }
          ]
        },
        {
          "intVal": 1,
          "mapVal": []
        },
        {
          "stringVal": "Salted caramel cornetto",
          "mapVal": []
        }
      ],
      "modifiedTimeMillis": "1690805813623"
    }
  ]
}

Como você pode ver, os dados estão num formato que não é muito fácil de trabalhar. Precisamos analisar esses dados e agregá-los num formato utilizável.

const curatedWeightData = extractBodyData(weightData, 'weight');
const curatedFatPercentageData = extractBodyData(fatPercentageData, 'fatPercentage');
const curatedNutritionData = aggregateNutritionData(extractNutritionData(nutritionData));

Após usar essas funções misteriosas, os seus dados ficarão assim:

console.log(curatedWeightData);
// [{ date: '02/08/2023', weight: 77.5999984741211 }]
console.log(curatedFatPercentageData);
// [{ date: '02/08/2023', fatPercentage: 20 }]
console.log(curatedNutritionData);
// [{ date: '02/08/2023', foods: ['Salted caramel cornetto'], protein: 5.25, fat: 16.349998474121094, carbs: 60.45000076293945, fiber: 0, sugar: 42.599998474121094 }]

Ok, agora vamos escrever as funções que fazem essa mágica, ou melhor, vamos pedir ao Chat GPT para fazer isso para nós.

function nanosToDateString(nanos) {
  const milliseconds = parseInt(nanos, 10) / 1000000;
  return new Date(milliseconds).toLocaleDateString('en-GB');
}

function extractBodyData(jsonArray, type) {
  return jsonArray.point.map((dataPoint) => {
    const date = nanosToDateString(dataPoint.startTimeNanos);
    const data = dataPoint.value[0].fpVal;
    return { date, [type]: data };
  });
}

E para a agregação de dados nutricionais:

function aggregateNutritionData(nutritionArray) {
  const aggregatedData = {};

  nutritionArray.forEach((nutrition) => {
    const { date, foodName, ...nutritionValues } = nutrition;

    if (!aggregatedData[date]) {
      aggregatedData[date] = {
        date,
        foods: [foodName],
        ...nutritionValues,
      };
    } else {
      aggregatedData[date].foods.push(foodName);

      Object.keys(nutritionValues).forEach((key) => {
        if (Object.prototype.hasOwnProperty.call(nutritionValues, key)) {
          aggregatedData[date][key] += nutritionValues[key];
        }
      });
    }
  });

  return Object.values(aggregatedData);
}

A última coisa a fazer é mesclar essas 3 matrizes em uma e classificá-la por data.

function mergeDataArrays(...arrays) {
  const mergedData = {};

  arrays.forEach((array) => {
    array.forEach((item) => {
      const { date, ...rest } = item;
      if (!mergedData[date]) {
        mergedData[date] = { date, ...rest };
      } else {
        Object.assign(mergedData[date], rest);
      }
    });
  });

  return Object.values(mergedData);
}

console.log(mergeDataArrays(curatedWeightData, curatedFatPercentageData, curatedNutritionData));
// [{"date":"02/08/2023","weight":77.5999984741211,"fatPercentage":20,"foods":["Salted caramel cornetto"],"protein":5.25,"fat":16.349998474121094,"carbs":60.45000076293945,"fiber":0,"sugar":42.599998474121094}]

Tudo bem, é hora de usar esses dados para obter algumas informações. Na verdade, precisamos de mais uma coisa antes de podermos fazer isso.

Massa muscular e composição de gordura corporal

Antes de mergulhar nos cálculos, precisamos entender como o músculo e a gordura estão distribuídos no corpo.

Eu queria descobrir quantas calorias existem em 1kg de músculo e 1kg de gordura, então comecei a procurar livros no Google Books para encontrar a composição exata do tecido muscular e da gordura, e encontrei algumas informações em The Nutritionist Food, Nutrition, and Optimal Health By Robert Wildman.

muscle and fat composition

Mas eu ainda precisava saber qual é o custo energético para construir esse 1kg de músculo e 1kg de gordura, então, para isso, perguntei ao ChatGPT (em inglês e traduzido para essa postagem).

Olá. Qual é a composição exata em porcentagens de 1kg de músculo esquelético e 1kg de tecido adiposo? Além disso, forneça a fonte da informação. Por favor, me dê uma resposta curta, obrigado.

Claro! Aqui está uma resposta curta para a composição geral de 1kg de músculo esquelético e 1kg de tecido adiposo:

Músculo Esquelético (1kg):

  • Água: ~75%
  • Proteína: ~20%
  • Gorduras: ~5%
  • Outros (minerais, glicogênio, etc.): Quantidades vestigiais

Tecido Adiposo (1kg):

  • Lipídios: ~80-90%
  • Água: ~10-20%
  • Proteína: ~2%
  • Outros (minerais, etc.): Quantidades vestigiais

Por favor, note que esses valores podem variar dependendo de fatores como idade, sexo, dieta e saúde geral. A informação é baseada no entendimento científico geral e pode ser encontrada em vários livros de fisiologia e anatomia humana, como “Human Anatomy & Physiology” de Elaine N. Marieb e Katja Hoehn.

E qual é a eficiência de síntese em porcentagem para construir 1 grama de proteína muscular e 1 grama de lipídios? Além disso, forneça a fonte da informação. Por favor, me dê uma resposta curta, obrigado.

A eficiência de síntese para construir proteína muscular e lipídios varia amplamente dependendo de fatores como espécie, dieta, idade e saúde. No entanto, uma estimativa geral pode ser fornecida:

  • Para proteína muscular, a eficiência é geralmente em torno de 20-25%. Isso significa que apenas cerca de 20-25% dos aminoácidos consumidos são incorporados à proteína muscular.
  • Para lipídios, a eficiência de conversão de gorduras dietéticas pode ser maior, em torno de 90-95%.

Esses números são estimativas aproximadas e podem variar significativamente. A informação é derivada do conhecimento geral em bioquímica nutricional e pode ser encontrada em livros como “Biochemical, Physiological, and Molecular Aspects of Human Nutrition” de Martha H. Stipanuk e Marie A. Caudill, e artigos científicos sobre o assunto. Sempre consulte pesquisas específicas ou um profissional da área para informações mais precisas adaptadas a uma situação particular.

Legal. Vamos fazer alguns cálculos agora!

Cálculo do músculo

Agora que sabemos que um quilograma de músculo é composto por 20% de proteína e 5% de gordura. Com 1g de proteína tendo 4 calorias e 1g de gordura contendo 9 calorias, isso significa que 1kg de músculo tem 800 calorias de proteína e 450 de gordura, totalizando 1250 calorias.

Cálculo de gordura

Quanto à gordura, um quilograma é composto por 85% de lipídios e 2% de proteína. Com 1g de lipídios tendo 9 calorias, 1g de proteína tendo 4 calorias, isso significa que 1kg de gordura tem 7650 calorias de lipídios e 80 calorias de proteína, totalizando 7730 calorias.

Custo de síntese

Quando se trata de construir os componentes essenciais do nosso corpo, a eficiência varia para diferentes substâncias.

Para proteínas, a eficiência do nosso corpo é de cerca de ~23%. Isso significa que para cada 1g de proteína, que tem 4kcal, precisamos de cerca de ~17kcal para produzi-la. Pense assim: 4kcal vão para os aminoácidos reais na proteína, e as outras 13kcal são a energia usada no processo de construção.

Agora, os lipídios são uma história diferente. Nosso corpo é um pouco mais eficiente aqui, em ~93%. Então, para 1g de lipídios, que tem 9kcal, só leva cerca de 10kcal para produzi-lo. São 9kcal para os aminoácidos nos lipídios, e apenas 1kcal para a síntese.

Calculando o custo energético

Então, vamos entender todos esses números e ver o que eles significam para o custo energético de construir músculo e gordura.

Para o músculo, temos 1kg com 200g de proteína e 50g de lipídios. Como leva cerca de 17kcal para fazer 1g de proteína e 10kcal para 1g de lipídios, o custo energético total para 1kg de músculo é:

  • Proteína: 200 x 17 = 3400kcal
  • Gordura: 50 x 10 = 500kcal
  • Total Geral: 3400 + 500 = 3900kcal

Agora, para a gordura corporal, com 1kg tendo 850g de lipídios e 20g de proteína, o custo energético total é:

  • Lipídios: 850 x 10 = 8500kcal
  • Proteína: 20 x 17 = 340kcal
  • Total Geral: 8500 + 340 = 8840kcal

Então, aí está! Com esses números, vou adicionar as seguintes constantes ao meu código:

const CALORIES_STORED_KG_FAT = 7730;
const CALORIES_BUILD_KG_FAT = 8840;
const CALORIES_STORED_KG_MUSCLE = 1250;
const CALORIES_BUILD_KG_MUSCLE = 3900;

Lembrete rápido de que essas são todas estimativas, e os números reais podem variar dependendo da composição do seu corpo, dieta e outros fatores. Além disso, eu não sou médico nem nutricionista, então, por favor, não tome isso como um conselho médico.

Calculando o TDEE

Agora que temos os nossos dados de peso e percentual de gordura analisados e agregados em um formato utilizável, podemos começar a calcular o nosso TDEE.

Para calcular o seu TDEE, siga estas etapas:

  1. Obtenha o número total de calorias consumidas durante o período de 30 dias.
  2. Calcule a diferença de peso entre o início e o fim do período de 30 dias.
  3. Converta a diferença de peso em calorias multiplicando-a pelo número de músculo/gordura ganho/perdido.
  4. Subtraia o resultado da etapa 3 do total de calorias consumidas no período de 30 dias.
  5. Divida o resultado da etapa 4 por 30 para obter a sua ingestão média diária de calorias, que deve ser o seu TDEE.

Aqui está o código para calcular o TDEE e mais usando o código:

function calculateStatistics(dataArray) {
  const totalDays = dataArray.length;

  const {
    totalFat,
    totalFiber,
    totalCarbs,
    finalWeight,
    totalProtein,
    totalCalories,
    initialWeight,
    initialFatPercentage,
    finalFatPercentage,
    initialDate,
    finalDate,
  } = accumulateData(dataArray);

  const {
    fatDifference,
    weightDifference,
    muscleDifference,
    fatDifferencePercentage,
  } = calculateWeightDifference(initialWeight, finalWeight, initialFatPercentage, finalFatPercentage);

  const { muscleCalories, fatCalories } = calculateMuscleAndFatCalories(muscleDifference, fatDifference);
  const tdee = calculateTDEE(totalCalories, muscleCalories, fatCalories, totalDays);

  return [
    `*From ${initialDate} to ${finalDate}*\n`,
    `Days Range: ${totalDays}`,
    `TDEE: ${tdee?.toFixed(2)} kcal`,
    `Average Calories: ${(totalCalories / totalDays)?.toFixed(2)} kcal`,
    `Average Protein: ${(totalProtein / totalDays)?.toFixed(2)} g`,
    `Average Carbs: ${(totalCarbs / totalDays)?.toFixed(2)} g`,
    `Average Fat: ${(totalFat / totalDays)?.toFixed(2)} g`,
    `Average Fiber: ${(totalFiber / totalDays)?.toFixed(2)} g`,
    `Weight Difference: ${weightDifference > 0 ? '+' : ''}${weightDifference?.toFixed(2)} kg (${initialWeight?.toFixed(2)} -> ${finalWeight?.toFixed(2)})`,
    `Fat Difference: ${fatDifference > 0 ? '+' : ''}${fatDifference?.toFixed(2)} kg`,
    `Non-Fat Difference: ${muscleDifference > 0 ? '+' : ''}${muscleDifference?.toFixed(2)} kg`,
    `Fat Percentage Difference: ${fatDifferencePercentage > 0 ? '+' : ''}${fatDifferencePercentage?.toFixed(2)}%  (${initialFatPercentage?.toFixed(2)} -> ${finalFatPercentage?.toFixed(2)})`,
  ].join('\n');
}

Esta função retorna uma string com detalhes para um período de 30 dias, incluindo o número de dias, TDEE, ingestão média diária de calorias, proteínas, carboidratos, gordura e fibras, bem como as diferenças de peso, gordura, não gordura e percentual de gordura entre o início e o fim do período.

Quanto às funções ausentes accumulateData, calculateWeightDifference e calculateTDEE, aqui estão elas:

function accumulateData(dataArray) {
  const lastOccurrence = dataArray[dataArray.length - 1];
  const firstOccurrence = dataArray[0];

  const accumulator = {
    totalCalories: 0,
    totalProtein: 0,
    totalCarbs: 0,
    totalFat: 0,
    totalFiber: 0,
    initialWeight: firstOccurrence?.weight,
    finalWeight: lastOccurrence?.weight,
    initialFatPercentage: firstOccurrence?.fatPercentage,
    finalFatPercentage: lastOccurrence?.fatPercentage,
    initialDate: firstOccurrence?.date || '',
    finalDate: lastOccurrence?.date || '',
  };

  dataArray.forEach((data) => {
    accumulator.totalCalories += data.caloriesConsumed;
    accumulator.totalProtein += data.protein;
    accumulator.totalCarbs += data.carbs;
    accumulator.totalFat += data.fat;
    accumulator.totalFiber += data.fiber;
  });

  return accumulator;
}

function calculateWeightDifference(initialWeight, finalWeight, initialFatPercentage, finalFatPercentage) {
  const weightDifference = finalWeight - initialWeight;
  const initialFat = (initialFatPercentage * initialWeight) / 100;
  const finalFat = (finalFatPercentage * finalWeight) / 100;
  const fatDifference = finalFat - initialFat;
  const muscleDifference = weightDifference - fatDifference;
  const fatDifferencePercentage = finalFatPercentage - initialFatPercentage;

  return { weightDifference, fatDifference, muscleDifference, fatDifferencePercentage };
}

function calculateTDEE(totalCalories, muscleCalories, fatCalories, totalDays) {
  const caloriesDifference = fatCalories + muscleCalories;

  return (totalCalories - caloriesDifference) / totalDays;
}

Como você pode ver, a função calculateStatistics chama a função accumulateData para obter o total de calorias, proteínas, carboidratos, gordura e fibras consumidas durante o período de 30 dias, bem como o peso inicial e final e o percentual de gordura.

Em seguida, ela chama a função calculateWeightDifference para calcular as diferenças de peso, gordura, não gordura e percentual de gordura entre o início e o fim do período.

Finalmente, ela chama a função calculateTDEE para calcular o TDEE.

Enviar os dados para o Telegram

Após calcular o seu TDEE, você pode querer compartilhar essa informação com outras pessoas, como um personal trainer ou um amigo. Uma maneira fácil de fazer isso é enviando os dados para um grupo de chat no Telegram. Isso pode ser feito usando a API do Bot do Telegram.

Aqui está um exemplo de trecho de código que envia o resultado do TDEE para um grupo de chat no Telegram:

const text = calculateStatistics(agragatedData);
await nodeFetch(`https://api.telegram.org/bot${process.env.TELEGRAM_BOT_ID}/sendMessage`, {
  method: 'POST',
  headers: {
  'Content-Type': 'application/json',
  },
  body: JSON.stringify({
  text,
  chat_id: process.env.TELEGRAM_GROUP_ID,
  parse_mode: 'markdown',
  }),
});

Neste código, estamos usando o pacote node-fetch para fazer uma requisição HTTP POST ao método sendMessage da API do Bot do Telegram. Passamos o resultado do TDEE como o campo de texto no corpo da requisição, junto com o chat_id do grupo do Telegram para o qual queremos enviar a mensagem. Também definimos o campo parse_mode como markdown para habilitar a formatação na mensagem.

Note que, para usar esse código, você precisará definir as variáveis de ambiente TELEGRAM_BOT_ID e TELEGRAM_GROUP_ID com os valores apropriados.

Bônus

Você pode copiar o texto que obteve deste script e enviá-lo para o ChatGPT para obter ainda mais insights 👀.

Olá. O que você acha desses dados do meu acompanhamento de saúde pessoal dos últimos 30 dias ou mais? Você pode me dar uma análise curta e concisa sobre o que estou fazendo bem e onde devo melhorar? Obrigado <- Meus Dados em Texto ->

Claro! Com base nos dados que você forneceu, aqui está uma análise breve:

O Que Você Está Fazendo Bem: Equilíbrio Calórico: A sua ingestão calórica média está muito próxima do seu Gasto Energético Diário Total (TDEE), o que sugere que você está mantendo seu peso efetivamente. Perda de Peso: Você perdeu 0,80 kg no último mês, o que é uma taxa de perda de peso saudável e sustentável, se esse for o seu objetivo. Ingestão de Proteína: A sua ingestão média de proteína parece estar em uma boa faixa, especialmente se você está praticando atividades físicas que requerem reparo e crescimento muscular.

Áreas para Melhoria: Aumento da Porcentagem de Gordura: O aumento na porcentagem de gordura e na massa gorda pode ser uma preocupação se você estiver buscando reduzir a gordura corporal. Isso pode estar relacionado ao tipo de alimentos que você está consumindo ou ao equilíbrio de macronutrientes. Ingestão de Fibras: Sua ingestão média de fibras está um pouco baixa. Aumentar a ingestão de fibras consumindo mais grãos integrais, frutas e vegetais pode auxiliar na digestão e pode ajudar no controle do peso.

Lembre-se, esses insights são baseados nos dados fornecidos e nas diretrizes gerais. As necessidades individuais podem variar amplamente, então é sempre uma boa ideia consultar um profissional de saúde ou nutricionista para obter orientação personalizada.

Conclusão

Pronto, agora você sempre saberá exatamente qual é o seu TDEE. Você pode usar essa informação para ajustar a sua dieta e rotina de exercícios para alcançar os seus objetivos de fitness, você pode até colocar este script num fluxo de trabalho do GitHub Actions para executá-lo automaticamente todos os dias e enviar os resultados para um grupo de chat no Telegram.

Se você quiser ver o código completo, você pode encontrá-lo no meu GitHub, que inclui um workflow do GitHub Action que executa o script diariamente e envia os resultados para um chat do Telegram, portanto, sinta-se à vontade para simplesmente clonar o repositório e usá-lo.

Espero que você tenha achado este artigo útil. Se tiver alguma dúvida ou comentário, fique à vontade para entrar em contato ou deixar o sua opinião na seção de comentários abaixo.

Tags:

Publicar um comentário
Comentários

Nenhum comentário.