def test_exercise_comment_model(self):
"""Test user commentting functionality on an exercise."""
# Create test exercises
e1 = Exercise(name="Bench Press",
description="Chest exercise",
category_id=10)
e1.id = 500
e2 = Exercise(name="Triceps Pushdown",
description="Triceps exercise",
category_id=11)
e2.id = 501
# Create test user
u = User.register("testing1", "password", "*****@*****.**", "John",
"Doe", None)
u.id = 777
db.session.add_all([e1, e2])
uc1 = ExerciseComment(content="Test1", user_id=u.id, exercise_id=e1.id)
uc2 = ExerciseComment(content="Test2", user_id=u.id, exercise_id=e2.id)
db.session.add_all([uc1, uc2])
db.session.commit()
ucs = ExerciseComment.query.filter_by(user_id=u.id)
self.assertEqual(ucs.count(), 2)
self.assertEqual(ucs[0].exercise_id, e1.id)
self.assertEqual(ucs[0].user_id, u.id)
self.assertEqual(ucs[1].exercise_id, e2.id)
self.assertEqual(ucs[1].user_id, u.id)
def test_user_exercise_model(self):
"""Test adding exercises to a user's exercises functionality."""
# Create test exercises
e1 = Exercise(name="Bench Press",
description="Chest exercise",
category_id=10)
e1.id = 500
e2 = Exercise(name="Triceps Pushdown",
description="Triceps exercise",
category_id=11)
e2.id = 501
# Create test user
u = User.register("testing1", "password", "*****@*****.**", "John",
"Doe", None)
u.id = 777
db.session.add_all([e1, e2])
ue1 = UserExercise(user_id=u.id, exercise_id=e1.id)
ue2 = UserExercise(user_id=u.id, exercise_id=e2.id)
db.session.add_all([ue1, ue2])
db.session.commit()
exc = UserExercise.query.filter_by(user_id=u.id)
self.assertEqual(exc.count(), 2)
self.assertEqual(exc[0].exercise_id, e1.id)
self.assertEqual(exc[1].exercise_id, e2.id)
def test_exercise_model(self):
"""Test basic exercise model."""
# Create test exercises
e1 = Exercise(name="Bench Press",
description="Chest exercise",
category_id=10)
e1.id = 500
e2 = Exercise(name="Triceps Pushdown",
description="Triceps exercise",
category_id=11)
e2.id = 501
db.session.add_all([e1, e2])
db.session.commit()
e = Exercise.query.all()
self.assertEqual(len(e), 2)
self.assertEqual(e[0].id, e1.id)
self.assertEqual(e[0].name, "Bench Press")
self.assertEqual(e[0].description, "Chest exercise")
self.assertEqual(e[1].id, e2.id)
self.assertEqual(e[1].name, "Triceps Pushdown")
self.assertEqual(e[1].description, "Triceps exercise")
def demo_exercise():
from models import Exercise
run = Exercise.query.filter(Exercise._name=='Run').first()
walk = Exercise.query.filter(Exercise._name=='Walk').first()
if run is None:
run = Exercise('Run', '4 mph')
db.session.add(run)
db.session.commit()
if walk is None:
walk = Exercise('Walk', '2 mph')
db.session.add(walk)
db.session.commit()
return run, walk
def process_exercise(name, starting_path, clone_dir, blob_prefix, mapper,
bucket, user):
tqdm.write(f"Processing exercise:{name}")
exercise_path = f"{starting_path}/{name}"
with tarfile.open(f"{exercise_path}/{name}.tar.gz", "w:gz") as f:
f.add(f"{exercise_path}/", arcname=name, recursive=True)
upload_folder(exercise_path, starting_path, mapper.language, bucket)
has_hint = mapper.hint_exists(exercise_path)
mappings = mapper.get_files_mappings(blob_prefix, name, has_hint=has_hint)
metadata = mapper.get_metadata(clone_dir)
topics, difficulty = next(
iter([(ex["topics"], ex["difficulty"]) for ex in metadata
if ex["slug"] == name]), (None, None))
exercise = Exercise(name=name,
language=mapper.language,
description=mapper.pluck_readme(exercise_path),
topics=topics,
difficulty=difficulty,
creator=user.email)
files = Artifact(readme=mappings["readme"],
solution=mappings["solution"],
starting_point=mappings["starting_point"],
test=mappings["test"],
hint=mappings["hint"],
compressed=mappings["compressed"],
exercise=exercise)
return (exercise, files)
def add_workout():
if request.method == 'POST':
user = User.query.filter_by(name=session['username']).first()
workout = Workout(date=datetime.utcnow(), user_id=user.id)
exercise_count = int(request.form['exercise_count'])
for exercise_num in range(1, exercise_count + 1):
exercise = Exercise(order=1,
exercise_id=request.form['exercise' +
str(exercise_num)],
workout=workout)
weights = request.form.getlist('weight' + str(exercise_num))
reps = request.form.getlist('reps' + str(exercise_num))
set_order = 1
for weight, rep in zip(weights, reps):
work_set = Set(order=set_order,
exercise=exercise,
weight=weight,
reps=reps)
set_order += 1
db.session.add(workout)
db.session.commit()
return redirect(url_for('index'))
exercises = Exercises.query.all()
return render_template('add_workout.html', exercises=exercises)
def get_all_exercises():
response = requests.get('https://curric.rithmschool.com/r13/exercises/')
soup = BeautifulSoup(response.text)
links = []
# Drop Exercise table
engine = create_engine(ProductionConfig.SQLALCHEMY_DATABASE_URI)
Exercise.__table__.drop(engine)
db.create_all()
# Set up current exercises to test for duplicates
current_exercises = []
for exercise in Exercise.query.all():
current_exercises.append(exercise.title)
for link in soup.find_all('a'):
links.append('https://curric.rithmschool.com/r13/exercises/' +
link.get('href'))
for link in links:
if 'zip' in link:
continue
response = requests.get(link)
soup = BeautifulSoup(response.text)
if (soup.title is None):
continue
if (soup.title.string == 'Rithm Curriculum'):
continue
else:
new_exercise = Exercise(title=soup.title.string, url=link)
db.session.add(new_exercise)
db.session.commit()
def get_exercises():
"""Get exercises from API and place them in db."""
request = requests.get(
'https://wger.de/api/v2/exercise?language=2&limit=250')
result = request.json()
# Find all exercises currently stored in database
exercises = Exercise.query.all()
exercise_ids = []
for exercise in exercises:
exercise_ids.append(exercise.id)
for item in result['results']:
if item['id'] not in exercise_ids:
exercise = Exercise(id=item['id'],
name=item['name'],
description=item['description'],
category_id=item['category'])
db.session.add(exercise)
db.session.commit()
def test_delete():
entry = ExerciseEntry.ExerciseEntry()
entry.delete(TEST_ENTRY_DATA["user_id"],
TEST_ENTRY_DATA["exercise_entry_id"])
exercise = Exercise.Exercise()
exercise.delete(TEST_EXERCISE_DATA["user_id"],
TEST_EXERCISE_DATA["exercise_id"])
assert entry.get_one(TEST_ENTRY_DATA["exercise_entry_id"]) is None
def generate_percentage_exercise():
percentage_equations_factory = PercentageEquationsFactory()
exercise = Exercise()
percentage_equations_factory.appendTo(exercise)
return render_template('exercise.html', exercise=exercise)
def test_update_invalid_data_types():
exercise = Exercise.Exercise()
copy = dict(TEST_EXERCISE_DATA)
copy.update({
"amount": "this is not an int",
"description": 123,
})
res = exercise.update(copy)
assert res is None
def generate_division_exercise():
three_digit_rounded_division_equations_factory = RoundedDivisionEquationsFactory(
)
exercise = Exercise()
three_digit_rounded_division_equations_factory.appendTo(exercise)
return render_template('exercise.html', exercise=exercise)
def generate_multiplication_exercise():
two_digit_multiplication_equations_factory = TwoDigitMultiplicationEquationsFactory(
)
exercise = Exercise()
two_digit_multiplication_equations_factory.appendTo(exercise)
return render_template('exercise.html', exercise=exercise)
def generate_exercise():
subtraction_equations_factory = SubtractionEquationsFactory()
multiplication_equations_factory = MultiplicationEquationsFactory()
exercise = Exercise()
subtraction_equations_factory.appendTo(exercise)
multiplication_equations_factory.appendTo(exercise)
return render_template('exercise.html', exercise=exercise)
def setUp(self):
"""
Define test variables and initialize app
Has to be in this awkward camelCase to overload method in TestCase
"""
self.app = create_app()
self.client = self.app.test_client
self.database_path = os.environ['HEROKU_POSTGRESQL_AQUA_URL']
setup_db(self.app, self.database_path)
# binds the app to the current context
with self.app.app_context():
# populate tables with test values
e1 = Exercise(
name='kb swing',
equipment='kettlebell',
target='reps',
link='dummy link'
)
e2 = Exercise(
name='kb goblet squat',
equipment='kettlebell',
target='reps',
link='another dummy link here'
)
e1.insert()
e2.insert()
w = Workout(
name='test workout',
focus='legs',
repeat=False
)
w.insert()
m = WorkoutExercise(
workout_id=1,
exercise_id=1,
sets=3,
reps=8,
weight=4
)
m.insert()
def create(self, validated_data):
e = Exercise(name=validated_data['name'],
order=validated_data['order'],
repsStart=validated_data['repsStart'],
repsEnd=validated_data['repsEnd'],
setsStart=validated_data['setsStart'],
setsEnd=validated_data['setsEnd'],
workout_id=validated_data['workout_id'],
owner=validated_data['owner'])
e.save()
return e
def test_create():
entry = ExerciseEntry.ExerciseEntry()
exercise = Exercise.Exercise()
exercise_id = exercise.create(TEST_EXERCISE_DATA["user_id"],
TEST_EXERCISE_DATA)["exercise_id"]
TEST_ENTRY_DATA["exercise_id"] = exercise_id
TEST_EXERCISE_DATA["exercise_id"] = exercise_id
res = entry.create(TEST_ENTRY_DATA["user_id"],
TEST_ENTRY_DATA["exercise_id"], TEST_ENTRY_DATA)
TEST_ENTRY_DATA.update({"exercise_entry_id": res["exercise_entry_id"]})
assert res is not None
def agregarExercise(idPersona, exerciseTime, date):
try:
query=Exercise(
idPersona=idPersona,
exerciseTime=exerciseTime,
date=date
)
db.session.add(query)
db.session.commit()
return "exercise added. exercise id={}".format(query.id)
except Exception as e:
return(str(e))
def test_update():
exercise = Exercise.Exercise()
copy = dict(TEST_EXERCISE_DATA)
copy.update({
"amount": 255,
"sets": 5,
"reps": 5,
"units": "lbs",
"description": "Update"
})
res = exercise.update(copy)
assert res is not None
def add_exercise():
body = request.get_json()
# creating list
exercise_list = []
if isinstance(body, list):
for exercise_body in body:
if 'name' not in exercise_body:
return 'please specify name', 400
if 'name_en' not in exercise_body:
return 'please specify name_en', 400
if 'type' not in exercise_body:
return 'please specify type', 400
exercise = Exercise(name=exercise_body['name'],
name_en=exercise_body['name_en'],
type=exercise_body['type'])
exercise_list.append(exercise)
db.session.add_all(exercise_list)
db.session.commit()
return jsonify(
exercises=[exercise.serialize()
for exercise in exercise_list]), 200
else:
if 'name' not in body:
return 'please specify name', 400
if 'name_en' not in body:
return 'please specify name_en', 400
if 'type' not in body:
return 'please specify type', 400
exercise = Exercise(name=body['name'],
name_en=body['name_en'],
type=body['type'])
db.session.add(exercise)
db.session.commit()
return jsonify(exercise.serialize()), 200
def add_exercise():
data = request.get_json()
new_exercise = Exercise(uid=data['user_id'],
name=data['name'],
category=data['category'],
primary_muscle=data['primary_muscle'],
secondary_muscle=data['secondary_muscle'],
equipment=data['equipment'])
db.session.add(new_exercise)
db.session.commit()
return jsonify({'message': 'Exercise added successfully!', 'status': 200})
def add_exercise(request, workout):
if not request.user.is_authenticated():
return redirect(index)
elif request.method == 'POST':
form = ExerciseForm(request.POST)
name = request.POST['name']
if form.is_valid():
e = Exercise(name=name,
owner=request.user,
workout=Workout.objects.get(id=workout))
e.save()
return redirect(index)
else:
print(form.errors)
else:
form = ExerciseForm()
return render(request, 'add_exercise.html', {'form': form})
def call_api(func_name):
try:
if func_name not in ENDPOINTS:
message = "No such endpoint " + "'" + func_name + "'"
return make_response({"message": message}, 404)
model = Exercise.Exercise()
# GET requests have no request bodies, so we must get data from the header
if func_name == "get":
user_id = request.headers.get("user_id")
token = request.headers.get("token")
return CONTROLLER.execute_model_logic(token, user_id, model, "get",
dict(user_id=user_id))
request_body = request.get_json()
print(request_body)
params = CONTROLLER.deconstruct_request_body(request_body, model,
func_name)
params.update({"model": model, "function_name": func_name})
return CONTROLLER.execute_model_logic(**params)
except Exception as e:
return make_response({"message": "Internal Error: " + str(e)}, 500)
def post(self):
# create a new exercise
data = request.get_json()
if not data:
ret = {
'message': 'Provide data.',
}
return jsonify(ret), 422
exercise = Exercise(name=data['name'], activity=data['activity'])
db.session.add(exercise)
db.session.commit()
db.session.refresh(exercise)
ret = {
'message': 'Exercise created successfully.',
'id': exercise.id,
'name': data['name']
}
return jsonify(ret), 200
pass
def create_exercise():
""" Page for creating a new exercise """
if not g.user:
flash("You must be logged in to view this page")
return redirect("/unauthorized")
else:
form = ExerciseForm()
if form.validate_on_submit():
new_exercise = Exercise(
name = form.name.data,
category = form.category.data,
muscles = form.muscles_used.data,
equipment = form.equipment.data,
description = form.description.data
)
category = form.category.data
equipment = form.equipment.data
muscles = form.muscles_used.data
category.exercises.append(new_exercise)
for equip in equipment:
equip.exercises.append(new_exercise)
for muscle in muscles:
muscle.exercises.append(new_exercise)
db.session.commit()
return redirect(url_for("show_all_exercises"))
return render_template("exercise/new.html", form=form)
def create_exercise():
try:
all_data = request.get_json()
name = all_data['name']
equipment = all_data['equipment']
target = all_data['target']
link = all_data['link']
for value in [name, equipment, target, link]:
if value is None:
abort(400)
exercise = Exercise(name=name,
equipment=equipment,
target=target,
link=link)
# could check whether we expect this to fail
# based on inputs, and abort(500) otherwise
exercise.insert()
except Exception:
abort(400)
return jsonify({'success': True, 'id': exercise.id})
def __init__(self):
if locale.getdefaultlocale()[0] == "en_US":
language = "en"
self.get_en_translation()
else:
language = "es"
self.get_es_translation()
Gtk.Window.__init__(self, title="IPM P1")
self.set_default_size(700, 500)
self.wk_grid = Gtk.Grid()
self.wk_grid.set_column_homogeneous(True)
self.wk_grid.set_row_spacing(20)
self.wk_grid.set_column_spacing(20)
self.scrolled_window = Gtk.ScrolledWindow()
self.scrolled_window.set_border_width(10)
self.add(self.scrolled_window)
self.scrolled_window.add(self.wk_grid)
# get collections from database
self.workouts = define_connection('search_workouts', 'workouts')
self.render_workouts()
self.exercises = define_connection('search_exercises', 'exercises')
self.render_exercises()
self.all_exercises = []
# make objects from all exercises in database
for exercise_db in self.exercises:
try:
exercise = Exercise(exercise_db['_id'],
exercise_db['description'],
exercise_db['image'], exercise_db['name'],
exercise_db['video'])
self.all_exercises.append(exercise)
except:
pass
self.all_workouts = []
# make objects from all workouts in database
exercises_not_in_db = []
for index, workout_db in enumerate(self.workouts):
workout = Workout(workout_db['_id'], workout_db['name'],
workout_db['description'], workout_db['image'])
# attach proper exercises to the workout
exercises_of_workout = []
no = 1
for workout_ex in workout_db['exercises']:
found_exercise_in_db = False
for exercise in self.all_exercises:
if found_exercise_in_db is False and workout_ex[
0] == exercise.name:
id_ = random.randint(1, 10000000)
found_exercise_in_db = True
ex_of_workout = ExerciseToWorkout(
id_, workout.id, exercise.id, workout_ex[1], no)
no = no + 1
exercises_of_workout.append(ex_of_workout)
# if the exercise given with workout is not in the exercises colllection in database
if found_exercise_in_db is False and len(
sys.argv) > 1 and sys.argv[1] == "1":
id_ = random.randint(1, 10000000)
exercise = Exercise(id_, "None", "None", workout_ex[0],
"None")
exercises_not_in_db.append("{}".format(
str(json.dumps(exercise.__dict__))))
self.all_exercises.append(exercise)
ex_of_workout = ExerciseToWorkout(workout.id, exercise.id,
workout_ex[1], no)
no = no + 1
exercises_of_workout.append(ex_of_workout)
# add list of exercises to the routine for faster displaying
workout.set_exercises(exercises_of_workout)
self.all_workouts.append(workout)
if len(sys.argv) > 1 and sys.argv[1] == "1":
result = define_connection("insert_ex",
"{}".format(exercises_not_in_db))
exercises_json = []
for ex in exercises_of_workout:
ex_json = json.dumps(ex.__dict__)
exercises_json.append(ex_json)
define_connection("insert_ex_to_wk", "{}".format(exercises_json))
self.make_workouts_grid()
def __init__(self):
self.__db = DbAccess.DbAccess()
self.__exercise = Exercise.Exercise(self.__db)
def import_data():
if Path('db/app.db').exists():
click.confirm('app.db already exist, want to remove it?', abort=True)
Path('db/app.db').unlink()
upgrade()
user = create_user()
with open("data/steps.csv", 'r') as f:
reader = DictReader(f)
for line in reader:
steps = Steps(steps=line['steps'])
steps.date = datetime.fromisoformat(line['datetime'])
steps.user = user
db.session.add(steps)
db.session.commit()
with open("data/weights.csv", 'r') as f:
reader = DictReader(f)
for line in reader:
weight = Weight(weight=line['weight'])
weight.date = datetime.fromisoformat(line['datetime'])
weight.user = user
db.session.add(weight)
db.session.commit()
with open("data/exercises.csv", 'r') as f:
reader = DictReader(f)
for line in reader:
exercise = Exercise(name=line['name'], kcal_per_rep=line['kcal'])
db.session.add(exercise)
db.session.commit()
with open("data/ingredients.csv", 'r') as f:
reader = DictReader(f)
for line in reader:
ingredient = Ingredient(name=line['name'],
kcal_per_100_gram=line['kcal'])
db.session.add(ingredient)
db.session.commit()
with open("data/food_log.csv", 'r') as f:
reader = DictReader(f)
for line in reader:
food_log = FoodLog()
food_log.user = user
food_log.ingredient_id = line['ingredient_id']
food_log.grams = line['grams']
food_log.timestamp = datetime.fromisoformat(line['datetime'])
db.session.add(food_log)
db.session.commit()
with open("data/exercise_log.csv", 'r') as f:
reader = DictReader(f)
for line in reader:
exercise_log = ExerciseLog()
exercise_log.user = user
exercise_log.exercise_id = line['exercise_id']
exercise_log.amount = line['amount']
food_log.timestamp = datetime.fromisoformat(line['datetime'])
db.session.add(exercise_log)
db.session.commit()
from factories import MultiplicationEquationsFactory, SubtractionEquationsFactory
from models import Exercise
subtraction_equations_factory = SubtractionEquationsFactory()
exercise = Exercise()
subtraction_equations_factory.appendTo(exercise)
def is_desired_question(question):
return question.answer > 10
with (open('dataset.csv', mode='wb')) as file:
for question in exercise.questions:
line = '{0},{1},{2},{3}\n'.format(
question.expression.first_term,
question.expression.second_term,
question.answer,
is_desired_question(question)
)
file.write(line.encode())
