def _trim_lonely_muscle_groups(self, target_time):
if self.get_total_time() < target_time:
return
non_supersets = [_we for _we in self._workout__exercise_list if _we.first_super_set_workout_exercise_id is None]
muscle_id_to_ring = {}
ring_to_count = {}
for muscle_id_set in MuscleGroup.get_rings():
muscle_id_tuple = tuple(muscle_id_set)
for muscle_id in muscle_id_tuple:
muscle_id_to_ring[muscle_id] = muscle_id_tuple
ring_to_count[muscle_id_tuple] = 0
for _we in non_supersets:
exercise = Exercise.get_by_id(_we.exercise_id)
muscle_id_tuple = muscle_id_to_ring[exercise.muscle_group_id]
ring_to_count[muscle_id_tuple] += 1
for muscle_ring, count in ring_to_count.items():
if count == 1:
for _we in non_supersets:
_we.sets = 0
if self.get_total_time() < target_time:
break
else:
continue
break
def _select_exercise(exercise_filter, previous_exercise=None, retry_mode=False, logger=None):
logger = logger or mock.MagicMock()
if previous_exercise is not None:
for related_muscle_group_set in MuscleGroup.get_rings():
if previous_exercise.muscle_group_id in related_muscle_group_set:
logger.log_muscle_restriction(previous_exercise, related_muscle_group_set)
exercise_filter.restrict_to_muscle_group_ids(related_muscle_group_set)
break
elif not retry_mode:
logger.log_retry_mode()
exercise_filter = exercise_filter.compound_only()
elif retry_mode and previous_exercise is None:
logger.log_rollback_mode()
rollback_filter = exercise_filter.copy()
exercise_filter = exercise_filter.compound_only()
if exercise_filter.count() == 0:
exercise_filter = rollback_filter
if exercise_filter.count() == 0:
raise DeadEndException("Need a bigger exercise pool to continue")
exercise_list = [exercise for exercise in exercise_filter.query]
logger.log_available_exercises(exercise_list)
exercise_list = evenly_distribute_exercises_by_muscle_group(exercise_list)
try:
exercise = random.choice(exercise_list)
except IndexError:
raise NoExercisesAvailableException("No exercises left")
logger.log_exercise_selection(exercise)
return exercise
def _trim_most_worked_muscles(self, target_time):
if self.get_total_time() < target_time:
return
non_supersets = [_we for _we in self._workout__exercise_list if _we.first_super_set_workout_exercise_id is None]
while self.get_total_time() > target_time:
# SBL MOVE THIS LOGIC TO ITS OWN FUNCTION
muscle_id_to_ring = {}
ring_to_count = {}
for muscle_id_set in MuscleGroup.get_rings():
muscle_id_tuple = tuple(muscle_id_set)
for muscle_id in muscle_id_tuple:
muscle_id_to_ring[muscle_id] = muscle_id_tuple
ring_to_count[muscle_id_tuple] = 0
for _we in non_supersets:
exercise = Exercise.get_by_id(_we.exercise_id)
muscle_id_tuple = muscle_id_to_ring[exercise.muscle_group_id]
if _we.sets:
ring_to_count[muscle_id_tuple] += 1
muscle_ring__count = sorted(ring_to_count.items(), key=lambda t: t[1], reverse=True)
for _we in non_supersets:
exercise = Exercise.get_by_id(_we.exercise_id)
if _we.sets and exercise.muscle_group_id in muscle_ring__count[0][0]:
_we.sets = 0
if _we.second_exercise:
_we.second_exercise.sets = 0
break
def _get_muscle_tuple_to_should_use(user_exercise_filter, workout_component_id):
usable_muscle_group_ids = user_exercise_filter.copy().for_workout_component(workout_component_id).get_muscle_group_ids()
list_of_sets = MuscleGroup.get_required_rings()
for index in xrange(len(list_of_sets)):
list_of_sets[index] = {item for item in list_of_sets[index] if item in usable_muscle_group_ids}
list_of_tuples = [tuple(muscle_set) for muscle_set in list_of_sets if muscle_set]
muscle_tuple_to_should_use = {t: True for t in list_of_tuples}
return muscle_tuple_to_should_use
def log_available_superset_exercise(self, exercise_list):
available_muscle_group_ids = []
workout_component = "(No available exercises)"
if exercise_list:
workout_component = WorkoutComponent.get_by_id(exercise_list[0].workout_component_id).title
self._log("Before Superset exercise selection, %s exercises are available for %s" % (len(exercise_list), workout_component))
for exercise in exercise_list:
available_muscle_group_ids.append(exercise.muscle_group_id)
available_muscle_group_ids = list(set(available_muscle_group_ids))
muscle_names = ", ".join([MuscleGroup.get_name_for_id(id) for id in available_muscle_group_ids])
self._log("Available superset muscle groups: %s" % muscle_names)
def log_possible_flex_exercises(self, muscle_id, exercises):
muscle_name = MuscleGroup.get_name_for_id(muscle_id)
exercise_names = ", ".join([e.name for e in exercises])
self._log("Adding flexibility for %s. %s possible exercses: (%s)." %
(muscle_name, len(exercises), exercise_names))
def log_add_flexibility(self, muscle_ids):
muscle_names = ", ".join([MuscleGroup.get_name_for_id(id) for id in muscle_ids])
self._log("About to add flexibility for muscle groups: %s" % muscle_names)
def log_muscle_max_reached(self, muscle_group_id):
muscle_group = MuscleGroup.get_name_for_id(muscle_group_id)
self._log("Max exercises reached for %s, re-opening filter to other muscles" % muscle_group)
def log_muscle_restriction(self, previous_exercise, related_muscle_group_set):
self._log("Previous exercise was %s with muscle group %s" % (previous_exercise.name, MuscleGroup.get_name_for_id(previous_exercise.muscle_group_id)))
muscle_names = ", ".join([MuscleGroup.get_name_for_id(id) for id in related_muscle_group_set])
self._log("Restricting to muscle groups: %s" % muscle_names)
def log_exercise_selection(self, exercise):
self._log("Exercise selected: %s (Muscle Group: %s)\n" % (exercise.name, MuscleGroup.get_name_for_id(exercise.muscle_group_id)))
def log_superset_exercise(self, exercise):
if exercise is None:
self._log("Superset exercise is None, nothing was available")
else:
self._log("Superset Exercise selected: %s (Muscle Group: %s)\n" % (exercise.name, MuscleGroup.get_name_for_id(exercise.muscle_group_id)))
