app.py

   1 #!/usr/bin/env python
   2
   3 import pandas as pd
   4 from random import choices, shuffle
   5 from datetime import datetime
   6 import csv
   7 import os
   8 from flask import Flask, render_template, request, abort
   9
  10 app = Flask(__name__)
  11
  12 @app.route("/")
  13 def hello_world():
  14     return "<p>Hello, Test!</p>"
  15
  16
  17 @app.route('/response_quality', methods=['POST'])
  18 def response_quality():
  19     student_name = request.form['studentName']
  20     button_value = request.form['buttonValue']
  21     course = request.form['course']
  22
  23     fn = f'../assessments/{course}/{course}.csv'
  24
  25     if button_value == 'absent':
  26         answered = 'F'
  27         button_value = ''
  28     else:
  29         answered = 'T'
  30
  31     write_to_file(student_name, fn,
  32             answered=answered,
  33             assessment=button_value)
  34
  35     return 'Received feedback from ' + student_name + ': ' + button_value
  36
  37 @app.route("/coldcaller/<course>", methods=['POST','GET'])
  38 def coldcaller(course):
  39     if course not in ["com_304","com_411","com_674"]:
  40         abort(404)
  41     weight = 2
  42     students = pd.read_csv(f'../assessments/{course}/{course}_students.csv').Name
  43     student = ''
  44     out_fn = f'../assessments/{course}/{course}.csv'
  45     caller = Caller(out_fn, students, weight)
  46     if request.method == "POST":
  47         student = caller.get_random_student()
  48     return render_template('cold_caller.html', student=student)
  49
  50 @app.route("/shuffler", methods=['POST','GET'])
  51 def shuffler():
  52     course = request.args.get('course')
  53     try:
  54         student_list = pd.read_csv(f'../assessments/{course}/{course}_students.csv').Name
  55     except FileNotFoundError:
  56         abort(404)
  57     shuffle(student_list)
  58     print(student_list)
  59     return render_template('shuffler.html', result=student_list)
  60
  61 @app.route("/make_groups", methods=['POST','GET'])
  62 def make_groups():
  63     course = request.args.get('course')
  64     group_size = int(request.args.get('group_size'))
  65     print('running')
  66     try:
  67         student_list = pd.read_csv(f'../assessments/{course}/{course}_students.csv').Name
  68     except FileNotFoundError:
  69         abort(404)
  70     shuffle(student_list)
  71     print(student_list)
  72     print(range(0,len(student_list)//group_size + 1, group_size))
  73     result = []
  74     j = 1
  75     for i in range(0,len(student_list), group_size):
  76         result.append((j, student_list[i:i+group_size]))
  77         j += 1
  78     return render_template('group_maker.html', result=result)
  79
  80
  81
  82 class Caller:
  83
  84     def __init__(self, out_fn, students, weight = 2):
  85         self.weight = weight
  86         self.fn = out_fn
  87         self.students = students
  88         self.last_chosen = None
  89         self.today = datetime.now().date()
  90         self.weights_dict = self.get_weights()
  91
  92     def get_weights(self):
  93         times_called = self.get_times_called()
  94         weights_dict = {}
  95         for student in self.students:
  96             try:
  97                 curr_tc = times_called[student]
  98             except KeyError:
  99                 curr_tc = 0
 100             student_weight = (1/self.weight) ** curr_tc
 101             weights_dict[student] = student_weight
 102         return weights_dict
 103
 104
 105     def get_times_called(self):
 106         try:
 107             df = pd.read_csv(self.fn)
 108             if len(df) > 0:
 109                 self.last_chosen = df.name.iloc[-1]
 110             df.date = pd.to_datetime(df.date).dt.date
 111             times_called = df[(df.answered.isin(['T','TRUE']))|(df.date==self.today)].groupby('name').size()
 112             self.absent_today = df.loc[(df.date==self.today) & (df.answered.isin(['F', 'FALSE'])), 'name']
 113         except FileNotFoundError or IndexError:
 114             times_called = pd.DataFrame()
 115         return times_called
 116
 117     def update_weight(self, student):
 118         self.weights_dict[student] /= self.weight
 119
 120     def get_random_student(self, can_repeat=False):
 121         if not can_repeat:
 122             curr_weights = {k:v for k,v in self.weights_dict.items() if k != self.last_chosen}
 123         else:
 124             curr_weights = self.weights_dict
 125         for student in set(self.absent_today):
 126             print(curr_weights.keys())
 127             print(student in curr_weights)
 128             if student != self.last_chosen:
 129                 del curr_weights[student]
 130         rand_student = choices(list(curr_weights.keys()), weights=list(curr_weights.values()), k=1)[0]
 131         print(f"Weight of {rand_student}: {curr_weights[rand_student]}")
 132         self.update_weight(rand_student)
 133         return(rand_student)
 134
 135 def write_to_file(student, fn, answered, assessment):
 136     if not os.path.exists(fn):
 137         with open(fn, 'w') as f:
 138             f.write(','.join(['name', 'date', 'answered', 'assessment']))
 139             f.write('\n')
 140     with open(fn, 'a') as f:
 141         out_csv = csv.writer(f)
 142         out_csv.writerow([student,datetime.now().date(),answered,assessment])
 143
 144