Skip to content

armgit / wger

Public Imported from GitHub
0

Self hosted FLOSS fitness/workout, nutrition and weight tracker

Add some optimizations and cache to speed up the calculations

Roland Geidera685015dcac8
diff --git a/wger/exercises/sync.py b/wger/exercises/sync.py
index 2e3e6c518..dce85c413 100644
--- a/wger/exercises/sync.py
+++ b/wger/exercises/sync.py
@@ -88,7 +88,7 @@ def sync_exercises(
uuid=uuid,
defaults={'category_id': category_id, 'created': created},
)
- print_fn(f"{'created' if exercise_created else 'updated'} exercise {uuid}")
+ print_fn(f'{"created" if exercise_created else "updated"} exercise {uuid}')
exercise.muscles.set(muscles)
exercise.muscles_secondary.set(muscles_sec)
@@ -346,7 +346,7 @@ def handle_deleted_entries(
try:
obj = Translation.objects.get(uuid=uuid)
obj.delete()
- print_fn(f"Deleted translation {uuid} ({data['comment']})")
+ print_fn(f'Deleted translation {uuid} ({data["comment"]})')
except Translation.DoesNotExist:
pass
diff --git a/wger/exercises/tests/test_exercise_translation.py b/wger/exercises/tests/test_exercise_translation.py
index 21ee69873..6a509050c 100644
--- a/wger/exercises/tests/test_exercise_translation.py
+++ b/wger/exercises/tests/test_exercise_translation.py
@@ -26,9 +26,9 @@ from wger.core.tests import api_base_test
from wger.core.tests.api_base_test import ExerciseCrudApiTestCase
from wger.core.tests.base_testcase import WgerTestCase
from wger.exercises.models import (
+ Exercise,
Muscle,
Translation,
- Exercise,
)
from wger.utils.constants import CC_BY_SA_4_ID
diff --git a/wger/manager/api/views.py b/wger/manager/api/views.py
index 29108577e..cad0bf745 100644
--- a/wger/manager/api/views.py
+++ b/wger/manager/api/views.py
@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
# This file is part of wger Workout Manager.
#
# wger Workout Manager is free software: you can redistribute it and/or modify
@@ -16,14 +14,12 @@
# along with Workout Manager. If not, see <http://www.gnu.org/licenses/>.
# Standard Library
-import json
from datetime import datetime
# Django
from django.conf import settings
from django.core.cache import cache
from django.db.models import Q
-from django.shortcuts import get_object_or_404
# Third Party
from rest_framework import viewsets
@@ -31,7 +27,6 @@ from rest_framework.decorators import action
from rest_framework.response import Response
# wger
-from wger.exercises.models import Exercise
from wger.manager.api.consts import BASE_CONFIG_FIELDS
from wger.manager.api.filtersets import (
BaseConfigFilterSet,
@@ -117,18 +112,14 @@ class RoutineViewSet(viewsets.ModelViewSet):
"""
serializer.save(user=self.request.user)
- @action(detail=True, url_path='day-sequence')
- def day_sequence(self, request, pk):
- """
- Return the day sequence of the routine
- """
- return Response(DaySerializer(self.get_object().day_sequence, many=True).data)
-
@action(detail=True, url_path='date-sequence-display')
def date_sequence_display_mode(self, request, pk):
"""
Return the day sequence of the routine
"""
+ # profiler = cProfile.Profile()
+ # profiler.enable()
+
cache_key = CacheKeyMapper.get_routine_api_date_sequence_key(pk)
cached_data = cache.get(cache_key)
if cached_data is not None:
@@ -137,6 +128,9 @@ class RoutineViewSet(viewsets.ModelViewSet):
out = WorkoutDayDataDisplayModeSerializer(self.get_object().date_sequence, many=True).data
cache.set(cache_key, out, settings.WGER_SETTINGS['ROUTINE_CACHE_TTL'])
+ # profiler.disable()
+ # profiler.dump_stats("profile_results.prof")
+
return Response(out)
@action(detail=True, url_path='date-sequence-gym')
diff --git a/wger/manager/dataclasses.py b/wger/manager/dataclasses.py
index 9a0d42f8a..ccc9c7232 100644
--- a/wger/manager/dataclasses.py
+++ b/wger/manager/dataclasses.py
@@ -168,9 +168,17 @@ class SetExerciseData:
@dataclass
class SlotData:
comment: str
- exercises: List[int] = field(default_factory=list)
sets: List[SetConfigData] = field(default_factory=list)
+ @property
+ def exercises(self) -> List[int]:
+ out = set()
+
+ for set_config in self.sets:
+ out.add(set_config.exercise)
+
+ return list(out)
+
@property
def is_superset(self) -> bool:
return len(self.exercises) > 1
diff --git a/wger/manager/fixtures/test-routine-data.json b/wger/manager/fixtures/test-routine-data.json
index 5501929d0..d258d14d5 100644
--- a/wger/manager/fixtures/test-routine-data.json
+++ b/wger/manager/fixtures/test-routine-data.json
@@ -141,7 +141,8 @@
"order": 1,
"comment": "",
"type": "normal",
- "class_name": null
+ "class_name": null,
+ "has_progression": false
}
},
{
@@ -157,7 +158,8 @@
"order": 1,
"comment": "",
"type": "normal",
- "class_name": null
+ "class_name": null,
+ "has_progression": false
}
},
{
@@ -173,7 +175,8 @@
"order": 1,
"comment": "",
"type": "normal",
- "class_name": null
+ "class_name": null,
+ "has_progression": false
}
},
{
@@ -189,7 +192,8 @@
"order": 1,
"comment": "",
"type": "normal",
- "class_name": null
+ "class_name": null,
+ "has_progression": false
}
},
{
diff --git a/wger/manager/helpers.py b/wger/manager/helpers.py
index 486aeb63f..e2385e813 100644
--- a/wger/manager/helpers.py
+++ b/wger/manager/helpers.py
@@ -184,12 +184,19 @@ def render_workout_day(
def reset_routine_cache(instance: Routine):
"""Resets all caches related to a routine"""
+
cache.delete(CacheKeyMapper.get_routine_date_sequence_key(instance.id))
cache.delete(CacheKeyMapper.get_routine_api_date_sequence_key(instance.id))
cache.delete(CacheKeyMapper.get_routine_api_current_iteration_display_key(instance.id))
cache.delete(CacheKeyMapper.get_routine_api_structure_key(instance.id))
cache.delete(CacheKeyMapper.get_routine_api_stats(instance.id))
+ if instance.pk:
+ for day in instance.days.all():
+ for slot in day.slots.all():
+ for entry in slot.entries.all():
+ cache.delete(CacheKeyMapper.slot_entry_configs_key(entry.id))
+
def brzycki_one_rm(weight: float | None, reps: float | None) -> Decimal:
return Decimal(weight) / (Decimal(1.0278) - Decimal(0.0278) * Decimal(reps))
diff --git a/wger/manager/management/commands/dummy-generator-routines.py b/wger/manager/management/commands/dummy-generator-routines.py
index 33b6069d1..e588980e3 100644
--- a/wger/manager/management/commands/dummy-generator-routines.py
+++ b/wger/manager/management/commands/dummy-generator-routines.py
@@ -64,7 +64,7 @@ class Command(BaseCommand):
)
def handle(self, **options):
- self.stdout.write(f"** Generating {options['nr_plans']} dummy routine(s) per user")
+ self.stdout.write(f'** Generating {options["nr_plans"]} dummy routine(s) per user')
users = (
[User.objects.get(pk=options['user_id'])] if options['user_id'] else User.objects.all()
@@ -83,6 +83,7 @@ class Command(BaseCommand):
name=f'Dummy routine - {uid[0]}',
start=start_date,
end=start_date + datetime.timedelta(weeks=6),
+ fit_in_week=True,
)
routine.save()
diff --git a/wger/manager/migrations/0018_flexible_routines.py b/wger/manager/migrations/0018_flexible_routines.py
index 6179d195d..c9037a000 100644
--- a/wger/manager/migrations/0018_flexible_routines.py
+++ b/wger/manager/migrations/0018_flexible_routines.py
@@ -73,7 +73,7 @@ class Migration(migrations.Migration):
),
(
'order',
- models.PositiveIntegerField(default=1, verbose_name='Order'),
+ models.PositiveIntegerField(default=1, verbose_name='Order', db_index=True),
),
(
'config',
@@ -219,7 +219,7 @@ class Migration(migrations.Migration):
),
(
'order',
- models.PositiveIntegerField(default=1, verbose_name='Order'),
+ models.PositiveIntegerField(default=1, verbose_name='Order', db_index=True),
),
(
'comment',
@@ -255,7 +255,7 @@ class Migration(migrations.Migration):
verbose_name='ID',
),
),
- ('order', models.PositiveIntegerField(blank=True)),
+ ('order', models.PositiveIntegerField(blank=True, db_index=True)),
(
'type',
models.CharField(
diff --git a/wger/manager/migrations/0022_slotentry_has_progression.py b/wger/manager/migrations/0022_slotentry_has_progression.py
new file mode 100644
index 000000000..e03456baf
--- /dev/null
+++ b/wger/manager/migrations/0022_slotentry_has_progression.py
@@ -0,0 +1,17 @@
+# Generated by Django 4.2.16 on 2025-02-12 19:23
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ('manager', '0021_flexible_routines_cleanup'),
+ ]
+
+ operations = [
+ migrations.AddField(
+ model_name='slotentry',
+ name='has_progression',
+ field=models.BooleanField(default=False, editable=False),
+ ),
+ ]
diff --git a/wger/manager/models/day.py b/wger/manager/models/day.py
index d43cbe5af..3caa8c675 100644
--- a/wger/manager/models/day.py
+++ b/wger/manager/models/day.py
@@ -58,6 +58,7 @@ class Day(models.Model):
default=1,
null=False,
verbose_name=_('Order'),
+ db_index=True,
)
type = models.CharField(
@@ -144,8 +145,7 @@ class Day(models.Model):
Return the sets for this day
"""
return [
- SlotData(comment=s.comment, exercises=s.get_exercises(), sets=s.get_sets(iteration))
- for s in self.slots.all()
+ SlotData(comment=s.comment, sets=s.set_data_gym(iteration)) for s in self.slots.all()
]
def get_slots_display_mode(self, iteration: int) -> List[SlotData]:
@@ -170,29 +170,37 @@ class Day(models.Model):
out = []
last_exercise_id = None
current_slot = None
- for slot in self.slots.all():
- if slot.is_superset:
- out.append(
- SlotData(
- comment=slot.comment,
- exercises=slot.get_exercises(),
- sets=[s.data for s in slot.set_data(iteration)],
- )
- )
+ # slots = self.slots.prefetch_related(
+ # Prefetch('entries', to_attr='prefetched_entries')
+ # ).all()
+
+ slots = self.slots.all()
+
+ for slot in slots:
+ # for slot in self.slots.all():
+ slot_data = SlotData(
+ comment=slot.comment,
+ sets=[s.data for s in slot.set_data(iteration)],
+ )
+ exercises = slot_data.exercises
+
+ # slot is superset
+ if len(exercises) > 1:
+ out.append(slot_data)
current_slot = None
- elif not slot.get_exercises():
+
+ # empty slot
+ elif not exercises:
continue
+
+ # one exercise
else:
- exercise_id = slot.get_exercises()[0]
+ exercise_id = exercises[0]
if exercise_id != last_exercise_id:
- current_slot = SlotData(
- comment=slot.comment,
- exercises=[exercise_id],
- sets=[s.data for s in slot.set_data(iteration)],
- )
- out.append(current_slot)
+ current_slot = slot_data
+ out.append(slot_data)
last_exercise_id = exercise_id
else:
- current_slot.sets.extend([s.data for s in slot.set_data(iteration)])
+ current_slot.sets.extend(slot_data.sets)
return out
diff --git a/wger/manager/models/routine.py b/wger/manager/models/routine.py
index 70647a7b2..2ad1fcea9 100644
--- a/wger/manager/models/routine.py
+++ b/wger/manager/models/routine.py
@@ -16,6 +16,7 @@
# Standard Library
import datetime
+import logging
from collections import Counter
from decimal import Decimal
from typing import List
@@ -41,9 +42,16 @@ from wger.manager.managers import (
RoutineManager,
RoutineTemplateManager,
)
+from wger.manager.models import (
+ Day,
+ WorkoutLog,
+)
from wger.utils.cache import CacheKeyMapper
+logger = logging.getLogger(__name__)
+
+
class Routine(models.Model):
"""
Model for a routine
@@ -151,13 +159,6 @@ class Routine(models.Model):
super().save(*args, **kwargs)
- @property
- def day_sequence(self):
- """
- Return a sequence of days.
- """
- return list(self.days.all())
-
@property
def label_dict(self) -> dict[datetime.date, str]:
out = {}
@@ -176,7 +177,6 @@ class Routine(models.Model):
If a day needs logs to continue it will be repeated until the user adds one.
"""
-
cache_key = CacheKeyMapper.get_routine_date_sequence_key(self.id)
cached_data = cache.get(cache_key)
if cached_data is not None:
@@ -186,17 +186,22 @@ class Routine(models.Model):
delta = datetime.timedelta(days=1)
current_date = self.start
days = list(self.days.all())
- current_day = self.days.first()
- nr_days = self.days.count()
+ nr_days = len(days)
counter = Counter()
skip_til_date = None
out = []
- if current_day is None:
+ logs = {}
+ for day in self.days.all():
+ # logger.debug(f'fetching log data for day {day.pk}')
+ logs[day.id] = list(WorkoutLog.objects.filter(slot_entry__slot__day=day))
+
+ if not days:
return out
index = 0
+ current_day: Day = days[0]
while current_date <= self.end:
# Fill all days till the end of the week with empty workout days
if skip_til_date:
diff --git a/wger/manager/models/slot.py b/wger/manager/models/slot.py
index 86c2342b4..00ffd8d26 100644
--- a/wger/manager/models/slot.py
+++ b/wger/manager/models/slot.py
@@ -32,6 +32,7 @@ class Slot(models.Model):
default=1,
null=False,
verbose_name=_('Order'),
+ db_index=True,
)
comment = models.CharField(
@@ -74,9 +75,13 @@ class Slot(models.Model):
def set_data(self, iteration: int) -> List[SetExerciseData]:
"""Calculates the set data for a specific iteration"""
- return [SetExerciseData(data=s.get_config(iteration), config=s) for s in self.entries.all()]
+ result = [
+ SetExerciseData(data=s.get_config_data(iteration), config=s) for s in self.entries.all()
+ ]
+
+ return result
- def get_sets(self, iteration: int) -> list[SetConfigData]:
+ def set_data_gym(self, iteration: int) -> list[SetConfigData]:
"""
Calculates the sets as they would be performed in the gym
@@ -130,9 +135,3 @@ class Slot(models.Model):
result.append(slot.data)
sets[i] -= 1
return result
-
- def get_exercises(self) -> List[int]:
- """
- Returns the list of distinct exercises in the configs
- """
- return [slot.exercise.id for slot in self.entries.all()]
diff --git a/wger/manager/models/slot_entry.py b/wger/manager/models/slot_entry.py
index dbb45a0bf..f2253d6f4 100644
--- a/wger/manager/models/slot_entry.py
+++ b/wger/manager/models/slot_entry.py
@@ -16,12 +16,20 @@
# Standard Library
import copy
+import enum
import importlib
+import logging
from decimal import Decimal
-from typing import List
+from typing import (
+ Dict,
+ List,
+)
# Django
+from django.conf import settings
+from django.core.cache import cache
from django.db import models
+from django.db.models import QuerySet
from django.utils.translation import gettext_lazy as _
# wger
@@ -34,11 +42,26 @@ from wger.manager.dataclasses import (
SetConfigData,
round_value,
)
+from wger.manager.models import WorkoutLog
from wger.manager.models.abstract_config import (
AbstractChangeConfig,
OperationChoices,
StepChoices,
)
+from wger.utils.cache import CacheKeyMapper
+
+
+class ConfigType(enum.Enum):
+ WEIGHT = enum.auto()
+ MAXWEIGHT = enum.auto()
+ REPETITIONS = enum.auto()
+ MAXREPETITIONS = enum.auto()
+ RIR = enum.auto()
+ MAXRIR = enum.auto()
+ REST = enum.auto()
+ MAXREST = enum.auto()
+ SETS = enum.auto()
+ MAXSETS = enum.auto()
class ExerciseType(models.TextChoices):
@@ -52,6 +75,9 @@ class ExerciseType(models.TextChoices):
JUMP = 'jump'
+logger = logging.getLogger(__name__)
+
+
class SlotEntry(models.Model):
"""
Set configuration for an exercise (weight, reps, etc.)
@@ -109,6 +135,7 @@ class SlotEntry(models.Model):
order = models.PositiveIntegerField(
blank=True,
+ db_index=True,
)
comment = models.CharField(
@@ -140,6 +167,14 @@ class SlotEntry(models.Model):
)
"""JSON configuration field for custom behaviour"""
+ has_progression = models.BooleanField(
+ default=False,
+ editable=False,
+ )
+ """
+ Flag indicating if this entry should be used for progression.
+ """
+
# Metaclass to set some other properties
class Meta:
ordering = [
@@ -147,6 +182,8 @@ class SlotEntry(models.Model):
'id',
]
+ config_entries = {}
+
def save(self, *args, **kwargs):
"""
Save the object to the database
@@ -168,6 +205,47 @@ class SlotEntry(models.Model):
"""
return self.slot.day.routine
+ def load_all_configs(
+ self, iteration: int
+ ) -> Dict[str, Dict[str, List[AbstractChangeConfig] | AbstractChangeConfig]]:
+ key = CacheKeyMapper.slot_entry_configs_objects_key(self.pk, iteration)
+ configs = cache.get(key)
+ if configs is None:
+ data = {
+ 'weight': list(self.weightconfig_set.filter(iteration__lte=iteration)),
+ 'maxweight': list(self.maxweightconfig_set.filter(iteration__lte=iteration)),
+ 'repetitions': list(self.repetitionsconfig_set.filter(iteration__lte=iteration)),
+ 'maxrepetitions': list(
+ self.maxrepetitionsconfig_set.filter(iteration__lte=iteration)
+ ),
+ 'rir': list(self.rirconfig_set.filter(iteration__lte=iteration)),
+ 'maxrir': list(self.maxrirconfig_set.filter(iteration__lte=iteration)),
+ 'rest': list(self.restconfig_set.filter(iteration__lte=iteration)),
+ 'maxrest': list(self.maxrestconfig_set.filter(iteration__lte=iteration)),
+ 'sets': list(self.setsconfig_set.filter(iteration__lte=iteration)),
+ 'maxsets': list(self.maxsetsconfig_set.filter(iteration__lte=iteration)),
+ }
+
+ last_entries = {key: data[key][-1] if data[key] else None for key in data}
+
+ configs = {
+ 'all': data,
+ 'last': last_entries,
+ }
+
+ cache.set(
+ key,
+ configs,
+ settings.WGER_SETTINGS['ROUTINE_CACHE_TTL'],
+ )
+
+ return configs
+
+ def get_configuration_entries(
+ self, config_type: ConfigType, iteration
+ ) -> List[AbstractChangeConfig]:
+ return self.load_all_configs(iteration)['all'][config_type.name.lower()]
+
@staticmethod
def calculate_config_value(configs: List[AbstractChangeConfig]) -> Decimal | None:
if not configs:
@@ -211,7 +289,7 @@ class SlotEntry(models.Model):
return out
- def get_config(self, iteration: int) -> SetConfigData:
+ def get_config_data(self, iteration: int) -> SetConfigData:
"""
This method calculates the configuration for a given iteration of a slot entry.
@@ -223,6 +301,14 @@ class SlotEntry(models.Model):
met, the weight will be increased.
"""
+ # If there are no progressions, the value will be always the same
+ key = CacheKeyMapper.slot_entry_configs_key(self.pk)
+ result = cache.get(key)
+ if result and not self.has_progression:
+ return result
+
+ logs = list(self.workoutlog_set.all())
+
# If there is a custom class set, pass all responsibilities to it
if self.class_name:
try:
@@ -262,15 +348,11 @@ class SlotEntry(models.Model):
}
for i in range(1, iteration + 1):
- configs = {
- 'weight': self.weightconfig_set.filter(iteration__lte=i).last(),
- 'repetitions': self.repetitionsconfig_set.filter(iteration__lte=i).last(),
- 'rir': self.rirconfig_set.filter(iteration__lte=i).last(),
- 'rest': self.restconfig_set.filter(iteration__lte=i).last(),
- 'sets': self.setsconfig_set.filter(iteration__lte=i).last(),
- 'max_sets': self.maxsetsconfig_set.filter(iteration__lte=i).last(),
- }
- log_data = self.workoutlog_set.filter(slot_entry_id=self.id, iteration=i - 1)
+ configs = self.load_all_configs(i)['last']
+
+ log_data = [
+ log for log in logs if log.iteration == i - 1 and log.slot_entry_id == self.id
+ ]
for field, config in configs.items():
if not config:
@@ -278,6 +360,7 @@ class SlotEntry(models.Model):
if not config.requirements:
max_iterations[field] = i
+ # logger.debug(f'No requirements for {field} in iteration {i}')
continue
requirements = config.requirements_object
@@ -289,28 +372,30 @@ class SlotEntry(models.Model):
>= getattr(self, f'calculate_{req_field}')(max_iterations[req_field])
for req_field in requirements.rules
)
+ # logger.debug(f'all_fields_met for {field} in iteration {i}: {all_fields_met}')
if all_fields_met:
max_iterations[field] = i
+ continue
sets = self.calculate_sets(max_iterations['sets'])
- max_sets = self.calculate_max_sets(max_iterations['max_sets'])
+ max_sets = self.calculate_maxsets(max_iterations['max_sets'])
weight = self.calculate_weight(max_iterations['weight'])
- max_weight = self.calculate_max_weight(max_iterations['max_weight'])
+ max_weight = self.calculate_maxweight(max_iterations['max_weight'])
repetitions = self.calculate_repetitions(max_iterations['repetitions'])
- max_repetitions = self.calculate_max_repetitions(max_iterations['max_repetitions'])
+ max_repetitions = self.calculate_maxrepetitions(max_iterations['max_repetitions'])
rir = self.calculate_rir(max_iterations['rir'])
- max_rir = self.calculate_max_rir(max_iterations['max_rir'])
+ max_rir = self.calculate_maxrir(max_iterations['max_rir'])
rest = self.calculate_rest(max_iterations['rest'])
- max_rest = self.calculate_max_rest(max_iterations['max_rest'])
+ max_rest = self.calculate_maxrest(max_iterations['max_rest'])
- return SetConfigData(
+ result = SetConfigData(
slot_entry_id=self.id,
- exercise=self.exercise.id,
+ exercise=self.exercise_id,
type=str(self.type),
comment=self.comment,
sets=sets if sets is not None else 1,
@@ -321,53 +406,67 @@ class SlotEntry(models.Model):
else None,
weight_rounding=self.weight_rounding if weight is not None else None,
# TODO: decide on whether to return None or always the unit
- # weight_unit=self.weight_unit.pk if weight is not None else None,
- weight_unit=self.weight_unit.pk,
+ # weight_unit=self.weight_unit_id if weight is not None else None,
+ weight_unit=self.weight_unit_id,
repetitions=round_value(repetitions, self.repetition_rounding),
max_repetitions=round_value(max_repetitions, self.repetition_rounding)
if max_repetitions and repetitions and max_repetitions > repetitions
else None,
repetitions_rounding=self.repetition_rounding if repetitions is not None else None,
- repetitions_unit=self.repetition_unit.pk,
+ repetitions_unit=self.repetition_unit_id,
# TODO: decide on whether to return None or always the unit
- # reps_unit=self.repetition_unit.pk if reps is not None else None,
+ # reps_unit=self.repetition_unit_id if reps is not None else None,
rir=round_value(rir, 0.5),
max_rir=round_value(max_rir, 0.5) if max_rir and rir and max_rir > rir else None,
rest=round_value(rest, 1),
max_rest=round_value(max_rest, 1) if max_rest and rest and max_rest > rest else None,
)
+ cache.set(
+ key,
+ result,
+ settings.WGER_SETTINGS['ROUTINE_CACHE_TTL'],
+ )
+ return result
+
#
# Note: don't rename these methods, they are accessed in get_config via getattr
#
def calculate_sets(self, iteration: int) -> Decimal | None:
+ logger.debug(f'calculate_sets for slot entry {self.id} and iteration {iteration}')
+
return self.calculate_config_value(
self.duplicate_configs(
iteration,
- list(self.setsconfig_set.filter(iteration__lte=iteration)),
+ self.get_configuration_entries(ConfigType.SETS, iteration),
+ # list(self.setsconfig_set.filter(iteration__lte=iteration)),
)
)
- def calculate_max_sets(self, iteration: int) -> Decimal | None:
+ def calculate_maxsets(self, iteration: int) -> Decimal | None:
return self.calculate_config_value(
self.duplicate_configs(
iteration,
- list(self.maxsetsconfig_set.filter(iteration__lte=iteration)),
+ self.get_configuration_entries(ConfigType.MAXSETS, iteration),
+ # list(self.maxsetsconfig_set.filter(iteration__lte=iteration)),
)
)
def calculate_weight(self, iteration: int) -> Decimal | None:
return self.calculate_config_value(
self.duplicate_configs(
- iteration, list(self.weightconfig_set.filter(iteration__lte=iteration))
+ iteration,
+ self.get_configuration_entries(ConfigType.WEIGHT, iteration),
+ # list(self.weightconfig_set.filter(iteration__lte=iteration))
)
)
- def calculate_max_weight(self, iteration: int) -> Decimal | None:
+ def calculate_maxweight(self, iteration: int) -> Decimal | None:
return self.calculate_config_value(
self.duplicate_configs(
iteration,
- list(self.maxweightconfig_set.filter(iteration__lte=iteration)),
+ self.get_configuration_entries(ConfigType.MAXWEIGHT, iteration),
+ # list(self.maxweightconfig_set.filter(iteration__lte=iteration)),
)
)
@@ -375,15 +474,17 @@ class SlotEntry(models.Model):
return self.calculate_config_value(
self.duplicate_configs(
iteration,
- list(self.repetitionsconfig_set.filter(iteration__lte=iteration)),
+ self.get_configuration_entries(ConfigType.REPETITIONS, iteration),
+ # list(self.repetitionsconfig_set.filter(iteration__lte=iteration)),
)
)
- def calculate_max_repetitions(self, iteration: int) -> Decimal | None:
+ def calculate_maxrepetitions(self, iteration: int) -> Decimal | None:
return self.calculate_config_value(
self.duplicate_configs(
iteration,
- list(self.maxrepetitionsconfig_set.filter(iteration__lte=iteration)),
+ self.get_configuration_entries(ConfigType.MAXREPETITIONS, iteration),
+ # list(self.maxrepetitionsconfig_set.filter(iteration__lte=iteration)),
)
)
@@ -391,15 +492,17 @@ class SlotEntry(models.Model):
return self.calculate_config_value(
self.duplicate_configs(
iteration,
- list(self.rirconfig_set.filter(iteration__lte=iteration)),
+ self.get_configuration_entries(ConfigType.RIR, iteration),
+ # list(self.rirconfig_set.filter(iteration__lte=iteration)),
)
)
- def calculate_max_rir(self, iteration: int) -> Decimal | None:
+ def calculate_maxrir(self, iteration: int) -> Decimal | None:
return self.calculate_config_value(
self.duplicate_configs(
iteration,
- list(self.maxrirconfig_set.filter(iteration__lte=iteration)),
+ self.get_configuration_entries(ConfigType.MAXRIR, iteration),
+ # list(self.maxrirconfig_set.filter(iteration__lte=iteration)),
)
)
@@ -407,14 +510,16 @@ class SlotEntry(models.Model):
return self.calculate_config_value(
self.duplicate_configs(
iteration,
- list(self.restconfig_set.filter(iteration__lte=iteration)),
+ self.get_configuration_entries(ConfigType.REST, iteration),
+ # list(self.restconfig_set.filter(iteration__lte=iteration)),
)
)
- def calculate_max_rest(self, iteration: int) -> Decimal | None:
+ def calculate_maxrest(self, iteration: int) -> Decimal | None:
return self.calculate_config_value(
self.duplicate_configs(
iteration,
- list(self.maxrestconfig_set.filter(iteration__lte=iteration)),
+ self.get_configuration_entries(ConfigType.MAXREST, iteration),
+ # list(self.maxrestconfig_set.filter(iteration__lte=iteration)),
)
)
diff --git a/wger/manager/signals.py b/wger/manager/signals.py
index 8ac78fae1..b7ca75dc0 100644
--- a/wger/manager/signals.py
+++ b/wger/manager/signals.py
@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
# This file is part of wger Workout Manager.
#
# wger Workout Manager is free software: you can redistribute it and/or modify
@@ -15,6 +13,7 @@
# You should have received a copy of the GNU Affero General Public License
# Django
+from django.core.cache import cache
from django.db.models.signals import (
post_save,
pre_delete,
@@ -25,9 +24,12 @@ from django.db.models.signals import (
from wger.gym.helpers import get_user_last_activity
from wger.manager.helpers import reset_routine_cache
from wger.manager.models import (
+ AbstractChangeConfig,
Day,
MaxRepetitionsConfig,
MaxRestConfig,
+ MaxRiRConfig,
+ MaxSetsConfig,
MaxWeightConfig,
RepetitionsConfig,
RestConfig,
@@ -40,6 +42,7 @@ from wger.manager.models import (
WorkoutLog,
WorkoutSession,
)
+from wger.utils.cache import CacheKeyMapper
def update_activity_cache(sender, instance, **kwargs):
@@ -68,36 +71,42 @@ def update_cache_slot_entry(sender, instance: SlotEntry, **kwargs):
reset_routine_cache(instance.slot.day.routine)
-def update_cache_weight_config(sender, instance: WeightConfig, **kwargs):
- reset_routine_cache(instance.slot_entry.slot.day.routine)
-
-
-def update_cache_max_weight_config(sender, instance: MaxWeightConfig, **kwargs):
- reset_routine_cache(instance.slot_entry.slot.day.routine)
-
-
-def update_cache_repetitions_config(sender, instance: RepetitionsConfig, **kwargs):
- reset_routine_cache(instance.slot_entry.slot.day.routine)
-
-
-def update_cache_max_repetitions_config(sender, instance: MaxRepetitionsConfig, **kwargs):
- reset_routine_cache(instance.slot_entry.slot.day.routine)
-
-
-def update_cache_sets_config(sender, instance: SetsConfig, **kwargs):
+def handle_config_change(sender, instance: AbstractChangeConfig, **kwargs):
reset_routine_cache(instance.slot_entry.slot.day.routine)
+ update_has_progression_flag(instance)
+ update_object_cache(instance)
-def update_cache_rest_config(sender, instance: RestConfig, **kwargs):
- reset_routine_cache(instance.slot_entry.slot.day.routine)
-
-
-def update_cache_max_rest_config(sender, instance: MaxRestConfig, **kwargs):
- reset_routine_cache(instance.slot_entry.slot.day.routine)
-
+def update_has_progression_flag(instance: AbstractChangeConfig):
+ """
+ Update the has_progression flag on the slot entry
+ """
+ slot_entry = instance.slot_entry
+
+ slot_entry.has_progression = any(
+ config_set.count() > 1
+ for config_set in [
+ slot_entry.weightconfig_set.all(),
+ slot_entry.maxweightconfig_set.all(),
+ slot_entry.repetitionsconfig_set.all(),
+ slot_entry.maxrepetitionsconfig_set.all(),
+ slot_entry.setsconfig_set.all(),
+ slot_entry.maxsetsconfig_set.all(),
+ slot_entry.restconfig_set.all(),
+ slot_entry.maxrestconfig_set.all(),
+ slot_entry.rirconfig_set.all(),
+ slot_entry.maxrirconfig_set.all(),
+ ]
+ )
+
+
+def update_object_cache(instance: AbstractChangeConfig):
+ """
+ Update the has_progression flag on the slot entry
+ """
-def update_cache_rir_config(sender, instance: RiRConfig, **kwargs):
- reset_routine_cache(instance.slot_entry.slot.day.routine)
+ slot_entry = instance.slot_entry
+ cache.delete(CacheKeyMapper.slot_entry_configs_objects_key(slot_entry.id, instance.iteration))
def update_cache_log(sender, instance: WorkoutLog, **kwargs):
@@ -112,26 +121,33 @@ pre_save.connect(update_cache_routine, sender=Routine)
pre_save.connect(update_cache_day, sender=Day)
pre_save.connect(update_cache_slot, sender=Slot)
pre_save.connect(update_cache_slot_entry, sender=SlotEntry)
-pre_save.connect(update_cache_weight_config, sender=WeightConfig)
-pre_save.connect(update_cache_max_weight_config, sender=MaxWeightConfig)
-pre_save.connect(update_cache_repetitions_config, sender=RepetitionsConfig)
-pre_save.connect(update_cache_max_repetitions_config, sender=MaxRepetitionsConfig)
-pre_save.connect(update_cache_sets_config, sender=SetsConfig)
-pre_save.connect(update_cache_rest_config, sender=RestConfig)
-pre_save.connect(update_cache_max_rest_config, sender=MaxRestConfig)
-pre_save.connect(update_cache_rir_config, sender=RiRConfig)
pre_save.connect(update_cache_log, sender=WorkoutLog)
+post_save.connect(handle_config_change, sender=WeightConfig)
+post_save.connect(handle_config_change, sender=MaxWeightConfig)
+post_save.connect(handle_config_change, sender=RepetitionsConfig)
+post_save.connect(handle_config_change, sender=MaxRepetitionsConfig)
+post_save.connect(handle_config_change, sender=SetsConfig)
+post_save.connect(handle_config_change, sender=MaxSetsConfig)
+post_save.connect(handle_config_change, sender=RestConfig)
+post_save.connect(handle_config_change, sender=MaxRestConfig)
+post_save.connect(handle_config_change, sender=RiRConfig)
+post_save.connect(handle_config_change, sender=MaxRiRConfig)
+
pre_delete.connect(update_cache_routine, sender=Routine)
pre_delete.connect(update_cache_day, sender=Day)
pre_delete.connect(update_cache_slot, sender=Slot)
pre_delete.connect(update_cache_slot_entry, sender=SlotEntry)
-pre_delete.connect(update_cache_weight_config, sender=WeightConfig)
-pre_delete.connect(update_cache_max_weight_config, sender=MaxWeightConfig)
-pre_delete.connect(update_cache_repetitions_config, sender=RepetitionsConfig)
-pre_delete.connect(update_cache_max_repetitions_config, sender=MaxRepetitionsConfig)
-pre_delete.connect(update_cache_sets_config, sender=SetsConfig)
-pre_delete.connect(update_cache_rest_config, sender=RestConfig)
-pre_delete.connect(update_cache_max_rest_config, sender=MaxRestConfig)
-pre_delete.connect(update_cache_rir_config, sender=RiRConfig)
+
+pre_delete.connect(handle_config_change, sender=WeightConfig)
+pre_delete.connect(handle_config_change, sender=MaxWeightConfig)
+pre_delete.connect(handle_config_change, sender=RepetitionsConfig)
+pre_delete.connect(handle_config_change, sender=MaxRepetitionsConfig)
+pre_delete.connect(handle_config_change, sender=SetsConfig)
+pre_delete.connect(handle_config_change, sender=MaxSetsConfig)
+pre_delete.connect(handle_config_change, sender=RestConfig)
+pre_delete.connect(handle_config_change, sender=MaxRestConfig)
+pre_delete.connect(handle_config_change, sender=RiRConfig)
+pre_delete.connect(handle_config_change, sender=MaxRiRConfig)
+
pre_delete.connect(update_cache_log, sender=WorkoutLog)
diff --git a/wger/manager/tests/test_routine.py b/wger/manager/tests/test_routine.py
index 40f42744c..dfb36bf90 100644
--- a/wger/manager/tests/test_routine.py
+++ b/wger/manager/tests/test_routine.py
@@ -66,12 +66,6 @@ class RoutineTestCase(WgerTestCase):
Label(routine=self.routine, start_offset=0, end_offset=3, label='First label').save()
Label(routine=self.routine, start_offset=4, end_offset=5, label='Second label').save()
- def test_day_sequences(self):
- self.assertListEqual(
- self.routine.day_sequence,
- [self.day1, self.day2, self.day3],
- )
-
def test_date_sequences(self):
"""
Test that the days are correctly outputted in a sequence
diff --git a/wger/manager/tests/test_slot.py b/wger/manager/tests/test_slot.py
index 9512710e9..23283cd55 100644
--- a/wger/manager/tests/test_slot.py
+++ b/wger/manager/tests/test_slot.py
@@ -52,7 +52,7 @@ class SlotTestCase(WgerTestCase):
Test that the correct sets are returned for supersets
"""
- result = self.slot.get_sets(1)
+ result = self.slot.set_data_gym(1)
self.assertEqual(len(result), 9)
@@ -71,24 +71,13 @@ class SlotTestCase(WgerTestCase):
self.assertEqual(result[7].exercise, 2)
self.assertEqual(result[8].exercise, 1)
- def test_get_exercises(self):
- """
- Test that the correct exercises are returned for supersets
- """
-
- result = self.slot.get_exercises()
-
- self.assertEqual(result[0], 1)
- self.assertEqual(result[1], 2)
- self.assertEqual(result[2], 3)
-
def test_get_sets_one_exercise(self):
"""
Test that the correct sets are returned for regular sets
"""
SlotEntry.objects.filter(id__in=(101, 102)).delete()
- result = self.slot.get_sets(1)
+ result = self.slot.set_data_gym(1)
self.assertEqual(len(result), 4)
for i in range(0, 3):
diff --git a/wger/manager/tests/test_slot_entry.py b/wger/manager/tests/test_slot_entry.py
index dc346de18..cafe0f72c 100644
--- a/wger/manager/tests/test_slot_entry.py
+++ b/wger/manager/tests/test_slot_entry.py
@@ -13,9 +13,11 @@
# You should have received a copy of the GNU Affero General Public License
# Standard Library
+from dataclasses import asdict
from decimal import Decimal
# Django
+from django.core.cache import cache
from django.test import SimpleTestCase
# wger
@@ -36,6 +38,7 @@ from wger.manager.models.abstract_config import (
OperationChoices,
StepChoices,
)
+from wger.utils.cache import CacheKeyMapper
class SlotEntryTestCase(WgerTestCase):
@@ -173,7 +176,7 @@ class SlotEntryTestCase(WgerTestCase):
).save()
self.assertEqual(
- self.slot_entry.get_config(1),
+ self.slot_entry.get_config_data(1),
SetConfigData(
slot_entry_id=self.slot_entry.pk,
exercise=1,
@@ -188,7 +191,7 @@ class SlotEntryTestCase(WgerTestCase):
)
self.assertEqual(
- self.slot_entry.get_config(2),
+ self.slot_entry.get_config_data(2),
SetConfigData(
slot_entry_id=self.slot_entry.pk,
exercise=1,
@@ -203,7 +206,7 @@ class SlotEntryTestCase(WgerTestCase):
)
self.assertEqual(
- self.slot_entry.get_config(3),
+ self.slot_entry.get_config_data(3),
SetConfigData(
slot_entry_id=self.slot_entry.pk,
exercise=1,
@@ -218,7 +221,7 @@ class SlotEntryTestCase(WgerTestCase):
)
self.assertEqual(
- self.slot_entry.get_config(4),
+ self.slot_entry.get_config_data(4),
SetConfigData(
slot_entry_id=self.slot_entry.pk,
exercise=1,
@@ -233,7 +236,7 @@ class SlotEntryTestCase(WgerTestCase):
)
self.assertEqual(
- self.slot_entry.get_config(5),
+ self.slot_entry.get_config_data(5),
SetConfigData(
slot_entry_id=self.slot_entry.pk,
exercise=1,
@@ -248,7 +251,7 @@ class SlotEntryTestCase(WgerTestCase):
)
self.assertEqual(
- self.slot_entry.get_config(6),
+ self.slot_entry.get_config_data(6),
SetConfigData(
slot_entry_id=self.slot_entry.pk,
exercise=1,
@@ -311,7 +314,7 @@ class SlotEntryTestCase(WgerTestCase):
).save()
self.assertDictEqual(
- self.slot_entry.get_config(1).__dict__,
+ self.slot_entry.get_config_data(1).__dict__,
SetConfigData(
slot_entry_id=self.slot_entry.pk,
exercise=1,
@@ -324,7 +327,7 @@ class SlotEntryTestCase(WgerTestCase):
# Sets did increase
self.assertDictEqual(
- self.slot_entry.get_config(2).__dict__,
+ self.slot_entry.get_config_data(2).__dict__,
SetConfigData(
slot_entry_id=self.slot_entry.pk,
exercise=1,
@@ -384,7 +387,7 @@ class SlotEntryTestCase(WgerTestCase):
).save()
self.assertEqual(
- self.slot_entry.get_config(1),
+ self.slot_entry.get_config_data(1),
SetConfigData(
slot_entry_id=self.slot_entry.pk,
exercise=1,
@@ -397,7 +400,7 @@ class SlotEntryTestCase(WgerTestCase):
# Sets don't increase
self.assertEqual(
- self.slot_entry.get_config(2),
+ self.slot_entry.get_config_data(2),
SetConfigData(
slot_entry_id=self.slot_entry.pk,
exercise=1,
@@ -456,7 +459,7 @@ class SlotEntryTestCase(WgerTestCase):
).save()
self.assertEqual(
- self.slot_entry.get_config(1),
+ self.slot_entry.get_config_data(1),
SetConfigData(
slot_entry_id=self.slot_entry.pk,
exercise=1,
@@ -473,7 +476,7 @@ class SlotEntryTestCase(WgerTestCase):
)
self.assertEqual(
- self.slot_entry.get_config(2),
+ self.slot_entry.get_config_data(2),
SetConfigData(
slot_entry_id=self.slot_entry.pk,
exercise=1,
@@ -510,15 +513,15 @@ class SlotEntryTestCase(WgerTestCase):
RiRConfig(slot_entry=self.slot_entry, iteration=1, value=2).save()
self.assertEqual(
- self.slot_entry.get_config(1),
+ self.slot_entry.get_config_data(1),
SetConfigData(exercise=1, sets=2, weight=24, repetitions=1, rir=2, rest=120),
)
self.assertEqual(
- self.slot_entry.get_config(2),
+ self.slot_entry.get_config_data(2),
SetConfigData(exercise=2, sets=4, weight=42, repetitions=10, rir=1, rest=90),
)
self.assertEqual(
- self.slot_entry.get_config(3),
+ self.slot_entry.get_config_data(3),
SetConfigData(exercise=2, sets=4, weight=42, repetitions=10, rir=1, rest=90),
)
@@ -528,7 +531,7 @@ class SlotEntryTestCase(WgerTestCase):
"""
self.assertEqual(
- self.slot_entry.get_config(1),
+ self.slot_entry.get_config_data(1),
SetConfigData(
slot_entry_id=self.slot_entry.pk,
exercise=1,
@@ -545,6 +548,47 @@ class SlotEntryTestCase(WgerTestCase):
),
)
+ def test_has_progression_flag(self):
+ """Tests that the has_progression flag is automatically set"""
+
+ self.assertFalse(self.slot_entry.has_progression)
+ SetsConfig(slot_entry=self.slot_entry, iteration=1, value=4).save()
+ SetsConfig(slot_entry=self.slot_entry, iteration=2, value=6).save()
+
+ self.assertTrue(self.slot_entry.has_progression)
+
+ def test_cache_load_all_configs(self):
+ """Tests that cache used in load_all_configs is correctly (re)set"""
+
+ key = CacheKeyMapper.slot_entry_configs_objects_key(self.slot_entry.pk, 1)
+
+ set_config = SetsConfig(slot_entry=self.slot_entry, iteration=1, value=4)
+ set_config.save()
+
+ self.assertIsNone(cache.get(key))
+ self.slot_entry.load_all_configs(1)
+ self.assertTrue(cache.get(key))
+
+ set_config.value = 5
+ set_config.save()
+ self.assertIsNone(cache.get(key))
+
+ def test_cache_get_config_data(self):
+ """Tests that cache used in get_config_data is correctly (re)set"""
+
+ key = CacheKeyMapper.slot_entry_configs_key(self.slot_entry.pk)
+
+ set_config = SetsConfig(slot_entry=self.slot_entry, iteration=1, value=4)
+ set_config.save()
+
+ self.assertIsNone(cache.get(key))
+ self.slot_entry.get_config_data(1)
+ self.assertTrue(cache.get(key))
+
+ set_config.value = 5
+ set_config.save()
+ self.assertIsNone(cache.get(key))
+
class SlotEntryDuplicateConfigTestCase(SimpleTestCase):
def test_duplicate_configs(self):
diff --git a/wger/utils/cache.py b/wger/utils/cache.py
index a84257805..98dfe829b 100644
--- a/wger/utils/cache.py
+++ b/wger/utils/cache.py
@@ -62,6 +62,8 @@ class CacheKeyMapper:
ROUTINE_API_CURRENT_ITERATION_DISPLAY_KEY = 'routine-api-current-iteration-sequence-display-{0}'
ROUTINE_API_STATS_KEY = 'routine-api-stats-{0}'
ROUTINE_API_STRUCTURE_KEY = 'routine-api-structure-{0}'
+ SLOT_ENTRY_CONFIGS_KEY = 'slot-entry-configs-{0}'
+ SLOT_ENTRY_CONFIG_DICT_KEY = 'slot-entry-configs-dict-{0}-{1}'
def get_pk(self, param):
"""
@@ -120,5 +122,13 @@ class CacheKeyMapper:
def get_routine_api_structure_key(cls, id: int):
return cls.ROUTINE_API_STRUCTURE_KEY.format(id)
+ @classmethod
+ def slot_entry_configs_key(cls, id: int):
+ return cls.SLOT_ENTRY_CONFIGS_KEY.format(id)
+
+ @classmethod
+ def slot_entry_configs_objects_key(cls, slot_entry_id: int, iteration: int):
+ return cls.SLOT_ENTRY_CONFIG_DICT_KEY.format(slot_entry_id, iteration)
+
cache_mapper = CacheKeyMapper()