def _setup(self, num_logs=50, **kwargs): super(OneHundredRandomLogUpdates, self)._setup(**kwargs) try: self.user = FacilityUser.objects.get(username=self.username) except: #take username from ExerciseLog all_exercises = ExerciseLog.objects.all() self.user = FacilityUser.objects.get(id=all_exercises[0].user_id) print self.username, " not in FacilityUsers, using ", self.user self.num_logs = num_logs #give the platform a chance to cache the logs ExerciseLog.objects.filter(user=self.user).delete() for x in range(num_logs): while True: ex_idx = int(self.random.random() * len(NODE_CACHE["Exercise"].keys())) ex_id = NODE_CACHE["Exercise"].keys()[ex_idx] if not ExerciseLog.objects.filter(user=self.user, exercise_id=ex_id): break ex = ExerciseLog(user=self.user, exercise_id=ex_id) ex.save() self.exercise_list = ExerciseLog.objects.filter(user=self.user) self.exercise_count = self.exercise_list.count() VideoLog.objects.filter(user=self.user).delete() for x in range(num_logs): while True: vid_idx = int(self.random.random() * len(NODE_CACHE["Video"].keys())) vid_id = NODE_CACHE["Video"].keys()[vid_idx] if not VideoLog.objects.filter(user=self.user, video_id=vid_id): break vid = VideoLog(user=self.user, video_id=vid_id) vid.save() self.video_list = VideoLog.objects.filter(user=self.user) self.video_count = self.video_list.count()
def handle(self, *args, **options): if settings.CENTRAL_SERVER: raise CommandError("Don't run this on the central server!! Data not linked to any zone on the central server is BAD.") facility = Facility(name="Wilson Elementary") facility.save() group1 = FacilityGroup(facility=facility, name="Class 4E") group1.full_clean() group1.save() group2 = FacilityGroup(facility=facility, name="Class 5B") group2.full_clean() group2.save() facilityusers = [] for i in range(0,10): newuser1 = FacilityUser(facility=facility, username=usernames[i], first_name=firstnames[i], last_name=lastnames[i], group=group1) if settings.DEBUG: newuser1.set_password(hashed_password = hashed_blah)#"blah") else: newuser1.set_password("blah") newuser1.full_clean() newuser1.save() facilityusers.append(newuser1) newuser2 = FacilityUser(facility=facility, username=usernames[i+10], first_name=firstnames[i+10], last_name=lastnames[i+10], group=group2) if settings.DEBUG: newuser2.set_password(hashed_password = hashed_blah)#"blah") else: newuser2.set_password("blah") newuser2.full_clean() newuser2.save() facilityusers.append(newuser2) for topic in topics: exercises = get_topic_exercises(topic_id=topic) exercises_a = [random.random() for i in range(len(exercises))] exercises_b = [float(i) / len(exercises) for i in range(len(exercises))] for i, user in enumerate(facilityusers): for j, exercise in enumerate(exercises): sig = sigmoid(proficiency[i], exercises_a[j], exercises_b[j]) if random.random() < 0.05 * (1-sig) and j > 2: break if random.random() < 0.15: continue attempts = random.random() * 40 + 10 streak_progress = max(10, min(100, 10 * random.random() + 10 * attempts * sig)) print int(attempts), int(streak_progress), user.first_name, exercise["name"] log = ExerciseLog(user=user, exercise_id=exercise["name"], attempts=attempts, streak_progress=streak_progress) log.full_clean() log.save()
def test_exerciselog_collision(self): # create a new exercise log with the same exercise_id and user, but different points/attempts exerciselog = ExerciseLog(exercise_id=self.EXERCISE_ID, user=self.user) exerciselog.points = self.NEW_POINTS exerciselog.attempts = self.NEW_ATTEMPTS # try saving the new ExerciseLog: this is where the collision will happen, hopefully leading to a merge exerciselog.save() # get a new reference to the existing ExerciseLog exerciselog2 = ExerciseLog.objects.get(id=self.original_exerciselog.id) # make sure the ExerciseLog has been properly merged self.assertEqual(exerciselog.points, max(self.ORIGINAL_POINTS, self.NEW_POINTS), "The ExerciseLog's points were not properly merged.") self.assertEqual(exerciselog.attempts, max(self.ORIGINAL_ATTEMPTS, self.NEW_ATTEMPTS), "The ExerciseLog's attempts have already changed.")
def handle(self, *args, **options): facility = Facility(name="Wilson Elementary") facility.save() group1 = FacilityGroup(facility=facility, name="Class 4E") group1.full_clean() group1.save() group2 = FacilityGroup(facility=facility, name="Class 5B") group2.full_clean() group2.save() facilityusers = [] for i in range(0,10): newuser1 = FacilityUser(facility=facility, username=usernames[i], first_name=firstnames[i], last_name=lastnames[i], group=group1) if settings.DEBUG: newuser1.set_password(hashed_password = hashed_blah)#"blah") else: newuser1.set_password("blah") newuser1.full_clean() newuser1.save() facilityusers.append(newuser1) newuser2 = FacilityUser(facility=facility, username=usernames[i+10], first_name=firstnames[i+10], last_name=lastnames[i+10], group=group2) if settings.DEBUG: newuser2.set_password(hashed_password = hashed_blah)#"blah") else: newuser2.set_password("blah") newuser2.full_clean() newuser2.save() facilityusers.append(newuser2) for topic in topics: exercises = get_topic_exercises(topic_id=topic) exercises_a = [random.random() for i in range(len(exercises))] exercises_b = [float(i) / len(exercises) for i in range(len(exercises))] for i, user in enumerate(facilityusers): for j, exercise in enumerate(exercises): sig = sigmoid(proficiency[i], exercises_a[j], exercises_b[j]) if random.random() < 0.05 * (1-sig) and j > 2: break if random.random() < 0.15: continue attempts = random.random() * 40 + 10 streak_progress = max(10, min(100, 10 * random.random() + 10 * attempts * sig)) print int(attempts), int(streak_progress), user.first_name, exercise["name"] log = ExerciseLog(user=user, exercise_id=exercise["name"], attempts=attempts, streak_progress=streak_progress) log.full_clean() log.save()
def handle(self, *args, **options): facility = Facility(name="Wilson Elementary") facility.save() group1 = FacilityGroup(facility=facility, name="Class 4E") group1.full_clean() group1.save() group2 = FacilityGroup(facility=facility, name="Class 5B") group2.full_clean() group2.save() facilityusers = [] for i in range(0,10): newuser1 = FacilityUser(facility=facility, username=usernames[i], first_name=firstnames[i], last_name=lastnames[i], group=group1) newuser1.set_password("blah") newuser1.full_clean() newuser1.save() facilityusers.append(newuser1) newuser2 = FacilityUser(facility=facility, username=usernames[i+10], first_name=firstnames[i+10], last_name=lastnames[i+10], group=group2) newuser2.set_password("blah") newuser2.full_clean() newuser2.save() facilityusers.append(newuser2) for topic in topics: exercises = json.load(open("./static/data/topicdata/" + topic + ".json","r")) exercises = sorted(exercises, key = lambda k: (k["h_position"], k["v_position"])) exercises_a = [random.random() for i in range(len(exercises))] exercises_b = [float(i) / len(exercises) for i in range(len(exercises))] for i, user in enumerate(facilityusers): for j, exercise in enumerate(exercises): sig = sigmoid(proficiency[i], exercises_a[j], exercises_b[j]) if random.random() < 0.05 * (1-sig) and j > 2: break if random.random() < 0.15: continue attempts = random.random() * 40 + 10 streak_progress = max(10, min(100, 10 * random.random() + 10 * attempts * sig)) print int(attempts), int(streak_progress), user.first_name, exercise["name"] log = ExerciseLog(user=user, exercise_id=exercise["name"], attempts=attempts, streak_progress=streak_progress) log.full_clean() log.save()
def generate_fake_exercise_logs(facility_user=None, topics=topics, start_date=datetime.datetime.now() - datetime.timedelta(days=30 * 6)): """Add exercise logs for the given topics, for each of the given users. If no users are given, they are created. If no topics exist, they are taken from the list at the top of this file. By default, users start learning randomly between 6 months ago and now. """ date_diff = datetime.datetime.now() - start_date exercise_logs = [] user_logs = [] # It's not a user: probably a list. # Recursive case if not hasattr(facility_user, "username"): # It's NONE :-/ generate the users first! if not facility_user: (facility_user, _, _) = generate_fake_facility_users() for topic in topics: for user in facility_user: (elogs, ulogs) = generate_fake_exercise_logs(facility_user=user, topics=[topic], start_date=start_date) exercise_logs.append(elogs) user_logs.append(ulogs) # Actually generate! else: # Get (or create) user type try: user_settings = json.loads(facility_user.notes) except: user_settings = sample_user_settings() facility_user.notes = json.dumps(user_settings) facility_user.save() date_diff_started = datetime.timedelta(seconds=datediff(date_diff, units="seconds") * user_settings["time_in_program"]) # when this user started in the program, relative to NOW for topic in topics: # Get all exercises related to the topic exercises = get_topic_exercises(topic_id=topic) # Problem: # Not realistic for students to have lots of unfinished exercises. # If they start them, they tend to get stuck, right? # # So, need to make it more probable that they will finish an exercise, # and less probable that they start one. # # What we need is P(streak|started), not P(streak) # Probability of doing any particular exercise p_exercise = probability_of(qty="exercise", user_settings=user_settings) logging.debug("# exercises: %d; p(exercise)=%4.3f, user settings: %s\n" % (len(exercises), p_exercise, json.dumps(user_settings))) # of exercises is related to for j, exercise in enumerate(exercises): if random.random() > p_exercise: continue # Probability of completing this exercise, and .. proportion of attempts p_completed = probability_of(qty="completed", user_settings=user_settings) p_attempts = probability_of(qty="attempts", user_settings=user_settings) attempts = int(random.random() * p_attempts * 30 + 10) # always enough to have completed completed = (random.random() < p_completed) if completed: streak_progress = 100 else: streak_progress = max(0, min(90, random.gauss(100 * user_settings["speed_of_learning"], 20))) streak_progress = int(floor(streak_progress / 10.)) * 10 points = streak_progress / 10 * 12 if completed else 0 # only get points when you master. # Choose a rate of exercises, based on their effort level and speed of learning. # Compute the latest possible start time. # Then sample a start time between their start time # and the latest possible start_time rate_of_exercises = 0.66 * user_settings["effort_level"] + 0.33 * user_settings["speed_of_learning"] # exercises per day time_for_attempts = min(datetime.timedelta(days=rate_of_exercises * attempts), date_diff_started) # protect with min time_delta_completed = datetime.timedelta(seconds=random.randint(int(datediff(time_for_attempts, units="seconds")), int(datediff(date_diff_started, units="seconds")))) date_completed = datetime.datetime.now() - time_delta_completed # Always create new logging.info("Creating exercise log: %-12s: %-25s (%d points, %d attempts, %d%% streak on %s)" % ( facility_user.first_name, exercise["name"], points, attempts, streak_progress, date_completed, )) try: elog = ExerciseLog.objects.get(user=facility_user, exercise_id=exercise["name"]) except ExerciseLog.DoesNotExist: elog = ExerciseLog( user=facility_user, exercise_id=exercise["name"], attempts=int(attempts), streak_progress=streak_progress, points=int(points), completion_timestamp=date_completed, completion_counter=datediff(date_completed, start_date, units="seconds"), ) elog.full_clean() elog.save() # TODO(bcipolli): bulk saving of logs # For now, make all attempts on an exercise into a single UserLog. seconds_per_attempt = 10 * (1 + user_settings["speed_of_learning"] * random.random()) time_to_navigate = 15 * (0.5 + random.random()) #between 7.5s and 22.5s time_to_logout = 5 * (0.5 + random.random()) # between 2.5 and 7.5s ulog = UserLog( user=facility_user, activity_type=1, start_datetime = date_completed - datetime.timedelta(seconds=int(attempts * seconds_per_attempt + time_to_navigate)), end_datetime = date_completed + datetime.timedelta(seconds=time_to_logout), last_active_datetime = date_completed, ) ulog.full_clean() ulog.save() user_logs.append(ulog) exercise_logs.append(elog) return (exercise_logs, user_logs)
class TestSaveExerciseLog(KALiteTestCase): ORIGINAL_POINTS = 37 ORIGINAL_ATTEMPTS = 3 ORIGINAL_STREAK_PROGRESS = 20 NEW_POINTS_LARGER = 22 NEW_ATTEMPTS = 5 NEW_STREAK_PROGRESS_LARGER = 10 NEW_POINTS_SMALLER = 0 NEW_STREAK_PROGRESS_SMALLER = 0 EXERCISE_ID = "number_line" EXERCISE_ID2 = "radius_diameter_and_circumference" USERNAME = "******" PASSWORD = "******" def setUp(self): super(TestSaveExerciseLog, self).setUp() # create a facility and user that can be referred to in models across tests self.facility = Facility(name="Test Facility") self.facility.save() self.user = FacilityUser(username=self.USERNAME, facility=self.facility) self.user.set_password(self.PASSWORD) self.user.save() # create an initial ExerciseLog instance so we have something to update later self.original_exerciselog = ExerciseLog(exercise_id=self.EXERCISE_ID, user=self.user) self.original_exerciselog.points = self.ORIGINAL_POINTS self.original_exerciselog.attempts = self.ORIGINAL_ATTEMPTS self.original_exerciselog.streak_progress = self.ORIGINAL_STREAK_PROGRESS self.original_exerciselog.save() def test_new_exerciselog(self): # make sure the target exercise log does not already exist exerciselogs = ExerciseLog.objects.filter(exercise_id=self.EXERCISE_ID2, user__username=self.USERNAME) self.assertEqual(exerciselogs.count(), 0, "The target exercise log to be newly created already exists") c = KALiteClient() # login success = c.login(username=self.USERNAME, password=self.PASSWORD, facility=self.facility.id) self.assertTrue(success, "Was not able to login as the test user") # save a new exercise log result = c.save_exercise_log( exercise_id=self.EXERCISE_ID2, streak_progress=self.NEW_STREAK_PROGRESS_LARGER, points=self.NEW_POINTS_LARGER, correct=True, attempts=self.NEW_ATTEMPTS, ) self.assertEqual(result.status_code, 200, "An error (%d) was thrown while saving the exercise log." % result.status_code) # get a reference to the newly created ExerciseLog exerciselog = ExerciseLog.objects.get(exercise_id=self.EXERCISE_ID2, user__username=self.USERNAME) # make sure the ExerciseLog was properly created self.assertEqual(exerciselog.points, self.NEW_POINTS_LARGER, "The ExerciseLog's points were not saved correctly.") self.assertEqual(exerciselog.streak_progress, self.NEW_STREAK_PROGRESS_LARGER, "The ExerciseLog's streak progress was not saved correctly.") self.assertEqual(exerciselog.attempts, self.NEW_ATTEMPTS, "The ExerciseLog did not have the correct number of attempts (%d)." % self.NEW_ATTEMPTS) def test_update_exerciselog(self): # get a new reference to the existing ExerciseLog exerciselog = ExerciseLog.objects.get(id=self.original_exerciselog.id) # make sure the ExerciseLog hasn't already been changed self.assertEqual(exerciselog.points, self.ORIGINAL_POINTS, "The ExerciseLog's points have already changed.") self.assertEqual(exerciselog.streak_progress, self.ORIGINAL_STREAK_PROGRESS, "The ExerciseLog's streak progress already changed.") self.assertEqual(exerciselog.attempts, self.ORIGINAL_ATTEMPTS, "The ExerciseLog's attempts have already changed.") c = KALiteClient() # login success = c.login(username=self.USERNAME, password=self.PASSWORD, facility=self.facility.id) self.assertTrue(success, "Was not able to login as the test user") # save a new record onto the exercise log, with a correct answer (increasing the points and streak) result = c.save_exercise_log( exercise_id=self.EXERCISE_ID, streak_progress=self.NEW_STREAK_PROGRESS_LARGER, points=self.NEW_POINTS_LARGER, correct=True, attempts=self.NEW_ATTEMPTS, ) self.assertEqual(result.status_code, 200, "An error (%d) was thrown while saving the exercise log." % result.status_code) # get a reference to the updated ExerciseLog exerciselog = ExerciseLog.objects.get(exercise_id=self.EXERCISE_ID, user__username=self.USERNAME) # make sure the ExerciseLog was properly updated self.assertEqual(exerciselog.points, self.NEW_POINTS_LARGER, "The ExerciseLog's points were not updated correctly.") self.assertEqual(exerciselog.streak_progress, self.NEW_STREAK_PROGRESS_LARGER, "The ExerciseLog's streak progress was not updated correctly.") self.assertEqual(exerciselog.attempts, self.NEW_ATTEMPTS, "The ExerciseLog did not have the correct number of attempts (%d)." % self.NEW_ATTEMPTS) # save a new record onto the exercise log, with an incorrect answer (decreasing the points and streak) result = c.save_exercise_log( exercise_id=self.EXERCISE_ID, streak_progress=self.NEW_STREAK_PROGRESS_SMALLER, points=self.NEW_POINTS_SMALLER, correct=False, attempts=self.NEW_ATTEMPTS + 1, ) self.assertEqual(result.status_code, 200, "An error (%d) was thrown while saving the exercise log." % result.status_code) # get a reference to the updated ExerciseLog exerciselog = ExerciseLog.objects.get(exercise_id=self.EXERCISE_ID, user__username=self.USERNAME) # make sure the ExerciseLog was properly updated self.assertEqual(exerciselog.points, self.NEW_POINTS_SMALLER, "The ExerciseLog's points were not saved correctly.") self.assertEqual(exerciselog.streak_progress, self.NEW_STREAK_PROGRESS_SMALLER, "The ExerciseLog's streak progress was not saved correctly.") self.assertEqual(exerciselog.attempts, self.NEW_ATTEMPTS + 1, "The ExerciseLog did not have the correct number of attempts.")
class TestSaveExerciseLog(KALiteTestCase): ORIGINAL_POINTS = 37 ORIGINAL_ATTEMPTS = 3 ORIGINAL_STREAK_PROGRESS = 20 NEW_POINTS_LARGER = 22 NEW_ATTEMPTS = 5 NEW_STREAK_PROGRESS_LARGER = 10 NEW_POINTS_SMALLER = 0 NEW_STREAK_PROGRESS_SMALLER = 0 EXERCISE_ID = "number_line" EXERCISE_ID2 = "radius_diameter_and_circumference" USERNAME = "******" PASSWORD = "******" def setUp(self): super(TestSaveExerciseLog, self).setUp() # create a facility and user that can be referred to in models across tests self.facility = Facility(name="Test Facility") self.facility.save() self.user = FacilityUser(username=self.USERNAME, facility=self.facility) self.user.set_password(self.PASSWORD) self.user.save() # create an initial ExerciseLog instance so we have something to update later self.original_exerciselog = ExerciseLog(exercise_id=self.EXERCISE_ID, user=self.user) self.original_exerciselog.points = self.ORIGINAL_POINTS self.original_exerciselog.attempts = self.ORIGINAL_ATTEMPTS self.original_exerciselog.streak_progress = self.ORIGINAL_STREAK_PROGRESS self.original_exerciselog.save() def test_new_exerciselog(self): # make sure the target exercise log does not already exist exerciselogs = ExerciseLog.objects.filter( exercise_id=self.EXERCISE_ID2, user__username=self.USERNAME) self.assertEqual( exerciselogs.count(), 0, "The target exercise log to be newly created already exists") c = KALiteClient() # login success = c.login(username=self.USERNAME, password=self.PASSWORD, facility=self.facility.id) self.assertTrue(success, "Was not able to login as the test user") # save a new exercise log result = c.save_exercise_log( exercise_id=self.EXERCISE_ID2, streak_progress=self.NEW_STREAK_PROGRESS_LARGER, points=self.NEW_POINTS_LARGER, correct=True, attempts=self.NEW_ATTEMPTS, ) self.assertEqual( result.status_code, 200, "An error (%d) was thrown while saving the exercise log." % result.status_code) # get a reference to the newly created ExerciseLog exerciselog = ExerciseLog.objects.get(exercise_id=self.EXERCISE_ID2, user__username=self.USERNAME) # make sure the ExerciseLog was properly created self.assertEqual(exerciselog.points, self.NEW_POINTS_LARGER, "The ExerciseLog's points were not saved correctly.") self.assertEqual( exerciselog.streak_progress, self.NEW_STREAK_PROGRESS_LARGER, "The ExerciseLog's streak progress was not saved correctly.") self.assertEqual( exerciselog.attempts, self.NEW_ATTEMPTS, "The ExerciseLog did not have the correct number of attempts (%d)." % self.NEW_ATTEMPTS) def test_update_exerciselog(self): # get a new reference to the existing ExerciseLog exerciselog = ExerciseLog.objects.get(id=self.original_exerciselog.id) # make sure the ExerciseLog hasn't already been changed self.assertEqual(exerciselog.points, self.ORIGINAL_POINTS, "The ExerciseLog's points have already changed.") self.assertEqual(exerciselog.streak_progress, self.ORIGINAL_STREAK_PROGRESS, "The ExerciseLog's streak progress already changed.") self.assertEqual(exerciselog.attempts, self.ORIGINAL_ATTEMPTS, "The ExerciseLog's attempts have already changed.") c = KALiteClient() # login success = c.login(username=self.USERNAME, password=self.PASSWORD, facility=self.facility.id) self.assertTrue(success, "Was not able to login as the test user") # save a new record onto the exercise log, with a correct answer (increasing the points and streak) result = c.save_exercise_log( exercise_id=self.EXERCISE_ID, streak_progress=self.NEW_STREAK_PROGRESS_LARGER, points=self.NEW_POINTS_LARGER, correct=True, attempts=self.NEW_ATTEMPTS, ) self.assertEqual( result.status_code, 200, "An error (%d) was thrown while saving the exercise log." % result.status_code) # get a reference to the updated ExerciseLog exerciselog = ExerciseLog.objects.get(exercise_id=self.EXERCISE_ID, user__username=self.USERNAME) # make sure the ExerciseLog was properly updated self.assertEqual( exerciselog.points, self.NEW_POINTS_LARGER, "The ExerciseLog's points were not updated correctly.") self.assertEqual( exerciselog.streak_progress, self.NEW_STREAK_PROGRESS_LARGER, "The ExerciseLog's streak progress was not updated correctly.") self.assertEqual( exerciselog.attempts, self.NEW_ATTEMPTS, "The ExerciseLog did not have the correct number of attempts (%d)." % self.NEW_ATTEMPTS) # save a new record onto the exercise log, with an incorrect answer (decreasing the points and streak) result = c.save_exercise_log( exercise_id=self.EXERCISE_ID, streak_progress=self.NEW_STREAK_PROGRESS_SMALLER, points=self.NEW_POINTS_SMALLER, correct=False, attempts=self.NEW_ATTEMPTS + 1, ) self.assertEqual( result.status_code, 200, "An error (%d) was thrown while saving the exercise log." % result.status_code) # get a reference to the updated ExerciseLog exerciselog = ExerciseLog.objects.get(exercise_id=self.EXERCISE_ID, user__username=self.USERNAME) # make sure the ExerciseLog was properly updated self.assertEqual(exerciselog.points, self.NEW_POINTS_SMALLER, "The ExerciseLog's points were not saved correctly.") self.assertEqual( exerciselog.streak_progress, self.NEW_STREAK_PROGRESS_SMALLER, "The ExerciseLog's streak progress was not saved correctly.") self.assertEqual( exerciselog.attempts, self.NEW_ATTEMPTS + 1, "The ExerciseLog did not have the correct number of attempts.")
class TestExerciseLogs(TestCase): ORIGINAL_POINTS = 37 ORIGINAL_ATTEMPTS = 3 NEW_POINTS = 22 NEW_ATTEMPTS = 5 EXERCISE_ID = "number_line" def setUp(self): # create a facility and user that can be referred to in models across tests self.facility = Facility(name="Test Facility") self.facility.save() self.user = FacilityUser(username="******", password="******", facility=self.facility) self.user.save() # create an initial ExerciseLog instance so we have something to collide with later self.original_exerciselog = ExerciseLog(exercise_id=self.EXERCISE_ID, user=self.user) self.original_exerciselog.points = self.ORIGINAL_POINTS self.original_exerciselog.attempts = self.ORIGINAL_ATTEMPTS self.original_exerciselog.save() # get a new reference to the existing ExerciseLog exerciselog = ExerciseLog.objects.get(id=self.original_exerciselog.id) # make sure the ExerciseLog was saved as intended self.assertEqual(exerciselog.points, self.ORIGINAL_POINTS, "The ExerciseLog's points have already changed.") self.assertEqual(exerciselog.attempts, self.ORIGINAL_ATTEMPTS, "The ExerciseLog's attempts have already changed.") def test_exerciselog_update(self): # get a new reference to the existing ExerciseLog exerciselog = ExerciseLog.objects.get(id=self.original_exerciselog.id) # update the ExerciseLog exerciselog.points = self.NEW_POINTS exerciselog.attempts = self.NEW_ATTEMPTS exerciselog.save() # get a new reference to the existing ExerciseLog exerciselog2 = ExerciseLog.objects.get(id=self.original_exerciselog.id) # make sure the ExerciseLog was updated self.assertEqual(exerciselog2.points, self.NEW_POINTS, "The ExerciseLog's points were not updated.") self.assertEqual(exerciselog2.attempts, self.NEW_ATTEMPTS, "The ExerciseLog's attempts were not updated.") @unittest.skip("Auto-merging is not yet automatic, so skip this") def test_exerciselog_collision(self): # create a new exercise log with the same exercise_id and user, but different points/attempts exerciselog = ExerciseLog(exercise_id=self.EXERCISE_ID, user=self.user) exerciselog.points = self.NEW_POINTS exerciselog.attempts = self.NEW_ATTEMPTS # try saving the new ExerciseLog: this is where the collision will happen, hopefully leading to a merge exerciselog.save() # get a new reference to the existing ExerciseLog exerciselog2 = ExerciseLog.objects.get(id=self.original_exerciselog.id) # make sure the ExerciseLog has been properly merged self.assertEqual(exerciselog.points, max(self.ORIGINAL_POINTS, self.NEW_POINTS), "The ExerciseLog's points were not properly merged.") self.assertEqual(exerciselog.attempts, max(self.ORIGINAL_ATTEMPTS, self.NEW_ATTEMPTS), "The ExerciseLog's attempts have already changed.")
def generate_fake_exercise_logs(facility_user=None, topics=topics, start_date=datetime.datetime.now() - datetime.timedelta(days=30 * 6)): """Add exercise logs for the given topics, for each of the given users. If no users are given, they are created. If no topics exist, they are taken from the list at the top of this file. By default, users start learning randomly between 6 months ago and now. """ own_device = Device.get_own_device() date_diff = datetime.datetime.now() - start_date exercise_logs = [] user_logs = [] # It's not a user: probably a list. # Recursive case if not hasattr(facility_user, "username"): # It's NONE :-/ generate the users first! if not facility_user: (facility_user, _, _) = generate_fake_facility_users() for topic in topics: for user in facility_user: (elogs, ulogs) = generate_fake_exercise_logs(facility_user=user, topics=[topic], start_date=start_date) exercise_logs.append(elogs) user_logs.append(ulogs) # Actually generate! else: # Get (or create) user type try: user_settings = json.loads(facility_user.notes) except: user_settings = sample_user_settings() facility_user.notes = json.dumps(user_settings) facility_user.save() date_diff_started = datetime.timedelta(seconds=datediff(date_diff, units="seconds") * user_settings["time_in_program"]) # when this user started in the program, relative to NOW for topic in topics: # Get all exercises related to the topic exercises = get_topic_exercises(topic_id=topic) # Problem: # Not realistic for students to have lots of unfinished exercises. # If they start them, they tend to get stuck, right? # # So, need to make it more probable that they will finish an exercise, # and less probable that they start one. # # What we need is P(streak|started), not P(streak) # Probability of doing any particular exercise p_exercise = probability_of(qty="exercise", user_settings=user_settings) logging.debug("# exercises: %d; p(exercise)=%4.3f, user settings: %s\n" % (len(exercises), p_exercise, json.dumps(user_settings))) # of exercises is related to for j, exercise in enumerate(exercises): if random.random() > p_exercise: continue # Probability of completing this exercise, and .. proportion of attempts p_completed = probability_of(qty="completed", user_settings=user_settings) p_attempts = probability_of(qty="attempts", user_settings=user_settings) attempts = int(random.random() * p_attempts * 30 + 10) # always enough to have completed completed = (random.random() < p_completed) if completed: streak_progress = 100 else: streak_progress = max(0, min(90, random.gauss(100 * user_settings["speed_of_learning"], 20))) streak_progress = int(floor(streak_progress / 10.)) * 10 points = streak_progress / 10 * 12 if completed else 0 # only get points when you master. # Choose a rate of exercises, based on their effort level and speed of learning. # Compute the latest possible start time. # Then sample a start time between their start time # and the latest possible start_time rate_of_exercises = 0.66 * user_settings["effort_level"] + 0.33 * user_settings["speed_of_learning"] # exercises per day time_for_attempts = min(datetime.timedelta(days=rate_of_exercises * attempts), date_diff_started) # protect with min time_delta_completed = datetime.timedelta(seconds=random.randint(int(datediff(time_for_attempts, units="seconds")), int(datediff(date_diff_started, units="seconds")))) date_completed = datetime.datetime.now() - time_delta_completed # Always create new logging.info("Creating exercise log: %-12s: %-25s (%d points, %d attempts, %d%% streak on %s)" % ( facility_user.first_name, exercise["name"], points, attempts, streak_progress, date_completed, )) try: elog = ExerciseLog.objects.get(user=facility_user, exercise_id=exercise["name"]) except ExerciseLog.DoesNotExist: elog = ExerciseLog( user=facility_user, exercise_id=exercise["name"], attempts=int(attempts), streak_progress=streak_progress, points=int(points), complete=completed, completion_timestamp=date_completed, completion_counter=datediff(date_completed, start_date, units="seconds"), ) elog.counter = own_device.increment_and_get_counter() elog.sign(own_device) # have to sign after setting the counter elog.save(imported=True) # avoid userlog issues # For now, make all attempts on an exercise into a single UserLog. seconds_per_attempt = 10 * (1 + user_settings["speed_of_learning"] * random.random()) time_to_navigate = 15 * (0.5 + random.random()) #between 7.5s and 22.5s time_to_logout = 5 * (0.5 + random.random()) # between 2.5 and 7.5s if settings.USER_LOG_MAX_RECORDS_PER_USER != 0: ulog = UserLog( user=facility_user, activity_type=1, start_datetime = date_completed - datetime.timedelta(seconds=int(attempts * seconds_per_attempt + time_to_navigate)), end_datetime = date_completed + datetime.timedelta(seconds=time_to_logout), last_active_datetime = date_completed, ) ulog.full_clean() ulog.save() user_logs.append(ulog) exercise_logs.append(elog) return (exercise_logs, user_logs)
class TestExerciseLogs(KALiteTestCase): ORIGINAL_POINTS = 37 ORIGINAL_ATTEMPTS = 3 NEW_POINTS = 22 NEW_ATTEMPTS = 5 EXERCISE_ID = "number_line" def setUp(self): super(TestExerciseLogs, self).setUp() # create a facility and user that can be referred to in models across tests self.facility = Facility(name="Test Facility") self.facility.save() self.user = FacilityUser(username="******", facility=self.facility) self.user.set_password("dumber") self.user.save() # create an initial ExerciseLog instance so we have something to collide with later self.original_exerciselog = ExerciseLog(exercise_id=self.EXERCISE_ID, user=self.user) self.original_exerciselog.points = self.ORIGINAL_POINTS self.original_exerciselog.attempts = self.ORIGINAL_ATTEMPTS self.original_exerciselog.save() # get a new reference to the existing ExerciseLog exerciselog = ExerciseLog.objects.get(id=self.original_exerciselog.id) # make sure the ExerciseLog was saved as intended self.assertEqual(exerciselog.points, self.ORIGINAL_POINTS, "The ExerciseLog's points have already changed.") self.assertEqual(exerciselog.attempts, self.ORIGINAL_ATTEMPTS, "The ExerciseLog's attempts have already changed.") def test_exerciselog_update(self): # get a new reference to the existing ExerciseLog exerciselog = ExerciseLog.objects.get(id=self.original_exerciselog.id) # update the ExerciseLog exerciselog.points = self.NEW_POINTS exerciselog.attempts = self.NEW_ATTEMPTS exerciselog.save() # get a new reference to the existing ExerciseLog exerciselog2 = ExerciseLog.objects.get(id=self.original_exerciselog.id) # make sure the ExerciseLog was updated self.assertEqual(exerciselog2.points, self.NEW_POINTS, "The ExerciseLog's points were not updated.") self.assertEqual(exerciselog2.attempts, self.NEW_ATTEMPTS, "The ExerciseLog's attempts were not updated.") @unittest.skip("Auto-merging is not yet automatic, so skip this") def test_exerciselog_collision(self): # create a new exercise log with the same exercise_id and user, but different points/attempts exerciselog = ExerciseLog(exercise_id=self.EXERCISE_ID, user=self.user) exerciselog.points = self.NEW_POINTS exerciselog.attempts = self.NEW_ATTEMPTS # try saving the new ExerciseLog: this is where the collision will happen, hopefully leading to a merge exerciselog.save() # get a new reference to the existing ExerciseLog exerciselog2 = ExerciseLog.objects.get(id=self.original_exerciselog.id) # make sure the ExerciseLog has been properly merged self.assertEqual(exerciselog.points, max(self.ORIGINAL_POINTS, self.NEW_POINTS), "The ExerciseLog's points were not properly merged.") self.assertEqual(exerciselog.attempts, max(self.ORIGINAL_ATTEMPTS, self.NEW_ATTEMPTS), "The ExerciseLog's attempts have already changed.")