def calculate_idr_average(param): """ A function to get the average idr of the items: It gets a list of each item's idr, and then calculates the average. :param: a json in the Reliabilty Measures standard json format :return: a float: the average idr """ service_key = get_service_config(11) catch_error = get_error(param) if catch_error[0]: return {service_key: catch_error[1]} inp = update_input(param) idr_dict = list(calculate_idr(inp).values())[0] if idr_dict == get_keyword_value("bad_mean"): return {service_key: get_keyword_value("bad_mean")} idr_list = list(list(idr_dict.values())) num_items = len(idr_list) idr_avg = sum(idr_list) / num_items idr_avg = round(idr_avg, 3) return {service_key: idr_avg}
def get_group_list(param): """ A function to get all the groups of students taking the exam: It iterates through every student's information adding their group to a list if it exists and isnt already in the list. :param: a json in the Reliabilty Measures standard json format :return: list of strings: a list containing all listed groups """ catch_error = get_error(param) if catch_error[0]: return catch_error[1] inp = update_input(param) student_list = get_student_list(inp) group_list = [] for i in student_list: curr_group = i[get_keyword_value("group")] for k in curr_group: if k not in group_list: group_list.append(k) if len(group_list) == 1: return get_keyword_value("no_group") group_list.sort() return group_list
def get_item_ids(param): """ A function to get a list of all the item ids used in the exam: It iterates through a list of all the items a student responded to, and then adds that item's id to the id list if it isn't already in it. :param: a json in the Reliabilty Measures standard json format :return: list of strings: a list containing all item ids """ catch_error = get_error(param) if catch_error[0]: return catch_error[1] inp = update_input(param) student_list = get_student_list(inp) id_list = [] response_list = [] for i in student_list: response_list.append(i[get_keyword_value("item_responses")]) for i in response_list: for k in i: curr_id = k[get_keyword_value("item_id")] if curr_id not in id_list: id_list.append(curr_id) id_list.sort() return id_list
def get_sorted_responses(param): """ A function to sort every student's response to an item based on its item id: It calls the get_item_ids function and then creates a dictionary with the item ids as keys. Then it iterates through every students' responses adding each item response to its corresponding key in the dictionary. It then creates a now sorted list of each student's responses based on its index in the dictionary. :param: a json in the Reliabilty Measures standard json format :return: list of lists of ints: a list containing all students' responses in order of item id """ catch_error = get_error(param) if catch_error[0]: return catch_error[1] inp = update_input(param) student_list = get_student_list(inp) num_students = len(student_list) id_list = get_item_ids(inp) response_list = [] responses = {} for i in student_list: response_list.append(i[get_keyword_value("item_responses")]) for i in id_list: # Create a dictionary with the item IDs as keys responses[i] = [] for i in response_list: # For each student response list i checklist = id_list.copy() for k in i: # For each question k for j in responses: # For each item ID j # If item IDs match, add response to dictionary if k[get_keyword_value("item_id")] == j: responses[j].append(k[get_keyword_value("response")]) checklist.remove(j) if len(checklist) != 0: for i in checklist: responses[i].append(0) sorted_resp = [] for i in range(0, num_students): # For each student student_responses = [] for k in responses: # For every item ID # Create a list of the students responses sorted by item ID student_responses.append(responses[k][i]) sorted_resp.append(student_responses) return sorted_resp
def calculate_weighted_scores(param): """ A function to get the weighted score of each student: For each student, it gets the weight of every item they got correct by getting its difficulty and dividing it by the sum of all items' difficulties. :param: a json in the Reliabilty Measures standard json format :return: a dictionary of floats: a dictionary with student ids as keys and their weighted score as values """ service_key = get_service_config(7) catch_error = get_error(param) if catch_error[0]: return {service_key: catch_error[1]} inp = update_input(param) student_ids = get_student_ids(inp) sorted_resp = get_sorted_responses(inp) scoring_method = get_scoring_method(inp) num_items = len(sorted_resp[0]) difficulty_list = list( list(calculate_difficulty(inp).values())[0].values()) difficulty_sum = sum(difficulty_list) weighted_scores_dict = {} for curr_id in student_ids: weighted_scores_dict[curr_id] = None j = 0 for i in weighted_scores_dict: weighted = 0 for k in range(0, num_items): if sorted_resp[j][k] == 1: weighted += difficulty_list[k] weighted /= difficulty_sum if scoring_method[0] == get_keyword_value("percentage"): weighted = round(weighted * 100, 3) elif scoring_method[0] == get_keyword_value("absolute"): weighted = round(weighted * num_items, 3) elif scoring_method[0] == get_keyword_value("scaled"): weighted = round(weighted * scoring_method[1], 3) else: weighted = round(weighted, 3) weighted_scores_dict[i] = weighted j += 1 return {service_key: weighted_scores_dict}
def get_assumptions(param): """ A function to get the items for which a student was assumed to have a response of 0: It gets a list of all item ids listed from every student's responses, then iterates through every student. If a student doesn't have a response for an item in the id list, then that item is assumed to have a response of 0 for that student. :param: a json in the Reliabilty Measures standard json format :return: a dictionary of dictionaries: a dictionary with student ids as keys and a list of item ids as values """ service_key = get_service_config(13) catch_error = get_error(param) if catch_error[0]: return {service_key: catch_error[1]} inp = update_input(param) student_list = get_student_list(inp) id_list = get_item_ids(inp) assumptions_dict = {} for i in student_list: # For each student i checklist = id_list.copy() dupes = [] for k in i[get_keyword_value("item_responses")]: # For each question k for j in id_list: # For each item ID j if k[get_keyword_value("item_id")] == j: # If item IDs match if j in checklist: checklist.remove(j) else: dupes.append(j) if dupes: assumptions_dict[i[get_keyword_value("id")]] = {} assumptions_dict[i[get_keyword_value("id")]][get_keyword_value( "dupes")] = dupes if len(checklist) != 0: assumptions_dict[i[get_keyword_value("id")]] = {} assumptions_dict[i[get_keyword_value("id")]][get_keyword_value( "assumed")] = checklist.copy() if not assumptions_dict: return {service_key: get_keyword_value("no_assumptions")} return {service_key: assumptions_dict}
def calculate_topic_rights(param): """ A function to calculate the number of correct responses in every topic for each student: It gets a list of every topic with its corresponding item id. If a student gets that item correct, then the number of right responses for that topic increases. :param: a json in the Reliability Measures standard json format :return: a dictionary of dictionaries: a dictionary with student ids as keys and a list of topics and their number of right responses """ service_key = get_service_config(15) catch_error = get_error(param) if catch_error[0]: return {service_key: catch_error[1]} inp = update_input(param) student_list = get_student_list(inp) check_topics = get_item_topics(inp) topic_rights = {} if check_topics == get_keyword_value("no_topics"): return {service_key: get_keyword_value("no_topics")} for i in student_list: topic_trees = get_item_topics(inp) stud_id = i[get_keyword_value("id")] responses = i[get_keyword_value("item_responses")] for k in responses: item_id = k[get_keyword_value("item_id")] item_resp = k[get_keyword_value("response")] for j in range(0, len(topic_trees)): topic_ids = topic_trees[j][get_keyword_value("topic_ids")] if item_resp == 1 and item_id in topic_ids: topic_trees[j][get_keyword_value("topic_rights")] += 1 for k in range(0, len(topic_trees)): del topic_trees[k][get_keyword_value("topic_ids")] topic_rights[stud_id] = topic_trees return {service_key: topic_rights}
def get_scoring_method(param): """ A function to get the scoring method of an exam: Returns the "scoring_method" object from the json and its factor for scaled scoring. :param: a json in the Reliabilty Measures standard json format :return: a string: containing the scoring method. """ catch_error = get_error(param) if catch_error[0]: return catch_error[1] inp = update_input(param) scoring_method = inp[get_keyword_value("exam")][get_keyword_value( "scoring_method")] factor = inp[get_keyword_value("exam")][get_keyword_value("scaled_factor")] return (scoring_method, factor)
def calculate_scores(param): """ A function to get the score of each student: For each student, it gets the number of correct responses and divides it by the number of questions. :param: a json in the Reliability Measures standard json format :return: a dictionary of floats: a dictionary with student ids as keys and their score as values """ service_key = get_service_config(4) catch_error = get_error(param) if catch_error[0]: return {service_key: catch_error[1]} inp = update_input(param) sorted_resp = get_sorted_responses(inp) student_ids = get_student_ids(inp) scoring_method = get_scoring_method(inp) num_items = len(sorted_resp[0]) score_dict = {} for curr_id in student_ids: score_dict[curr_id] = None k = 0 for i in score_dict: num_right = sum(sorted_resp[k]) score = num_right / num_items if scoring_method[0] == get_keyword_value("percentage"): score = round(score * 100, 3) elif scoring_method[0] == get_keyword_value("absolute"): score = round(score * num_items, 3) elif scoring_method[0] == get_keyword_value("scaled"): score = round(score * scoring_method[1], 3) else: score = round(score, 3) score_dict[i] = score k += 1 return {service_key: score_dict}
def calculate_topic_averages(param): """ A function to calculate the average number of correct responses in every topic: It gets the total number of right responses per topic and then divides them by the total number of students. :param: a json in the Reliability Measures standard json format :return: a list of dictionaries, a list of each topic and its average number of right responses """ service_key = get_service_config(16) catch_error = get_error(param) if catch_error[0]: return {service_key: catch_error[1]} inp = update_input(param) topic_avgs = get_item_topics(inp) topic_responses = calculate_topic_rights(inp)[get_service_config(15)] num_topics = len(topic_avgs) num_students = len(topic_responses) check_topics = get_item_topics(inp) if check_topics == get_keyword_value("no_topics"): return {service_key: get_keyword_value("no_topics")} for i in range(0, num_topics): avg_rights = 0 for k in topic_responses: rights = topic_responses[k][i][get_keyword_value("topic_rights")] avg_rights += rights avg_rights /= num_students avg_rights = round(avg_rights, 3) topic_avgs[i][get_keyword_value("topic_rights")] = avg_rights for i in range(0, num_topics): del topic_avgs[i][get_keyword_value("topic_ids")] return {service_key: topic_avgs}
def get_error(param): """ A function to get the errors from an input: It checks whether the param is already an error message (from a previous update_input() call). If not, then it calls update_input() and checks again. :param: a json in the Reliabilty Measures standard json format :return: a tuple with the first value a bool of whether or not there was an error, and the second value the error message. """ if param == get_keyword_value("bad_data") or param == get_keyword_value( "bad_num_items"): return (True, param) inp = update_input(param) if inp == get_keyword_value("bad_data") or inp == get_keyword_value( "bad_num_items"): return (True, inp) return (False, inp)
def get_exclude_recos(param): """ A function to get a recommendation of items to exclude from the exam based on their idr values: It get every item's idr, and if it's less than 0.09, it adds it to the exclude recommendations. If the number of recommendations is greater than half the number of items, only recommend items with idr values less than 0. :param: a json in the Reliabilty Measures standard json format :return: a list of strings: a list of item ids """ service_key = get_service_config(9) catch_error = get_error(param) if catch_error[0]: return {service_key: catch_error[1]} inp = update_input(param) idr_dict = list(calculate_idr(inp).values())[0] if idr_dict == get_keyword_value("bad_mean"): return {service_key: get_keyword_value("bad_mean")} exclude_list = [] for i in idr_dict: if idr_dict[i] <= get_keyword_value("exclude_threshold_1"): exclude_list.append(i) if len(exclude_list) >= len(idr_dict)*get_keyword_value("exclude_length_1"): exclude_list = [] for i in idr_dict: if idr_dict[i] < get_keyword_value("exclude_threshold_2"): exclude_list.append(i) # if len(exclude_list) >= len(idr_dict)*get_keyword_value("exclude_length_2"): # return {service_key: get_keyword_value("bad_exam")} return {service_key: exclude_list}
def get_student_list(param): """ A function to get the list of students from the Reliabilty Measures standard json format. :param: a json in the Reliabilty Measures standard json format :return: list of student information: a list containing every student's item responses, id, and group if given """ catch_error = get_error(param) if catch_error[0]: return catch_error[1] inp = update_input(param) student_list = list(inp[get_keyword_value("student_list")]) return student_list
def calculate_kr20(param): """ A function to get the kr20 value of an exam: First it get the number of items divided by the number of items - 1. Then it multiplies that by 1 - the summation of the product of the proportion of those who got an item right by the proportion of those who got it wrong divided by the variance of the students' scores. :param: a json in the Reliabilty Measures standard json format :return: a float: the kr20 """ service_key = get_service_config(1) catch_error = get_error(param) if catch_error[0]: return {service_key: catch_error[1]} inp = update_input(param) sorted_resp = get_sorted_responses(inp) num_students = len(sorted_resp) num_items = len (sorted_resp[0]) pq_list = [] score_std = get_score_std(inp) if score_std <= 0: return {service_key: get_keyword_value("bad_std")} for i in range(0, num_items): p = 0 for k in range(0, num_students): p += sorted_resp[k][i] p /= num_students q = 1 - p pq_list.append(p * q) pq_sum = sum(pq_list) kr20_value = (num_items /(num_items - 1)) * (1 - (pq_sum / (score_std ** 2))) kr20_value = round(kr20_value, 3) return {service_key: kr20_value}
def get_student_ids(param): """ A function to get a list of all the student ids: It iterates through every student and adds their id to a list. :param: a json in the Reliabilty Measures standard json format :return: list of strings: a list containing all student ids """ catch_error = get_error(param) if catch_error[0]: return catch_error[1] inp = update_input(param) student_list = get_student_list(inp) student_ids = [] for i in student_list: curr_id = i[get_keyword_value('id')] student_ids.append(curr_id) return student_ids
def analyze_groups(param): """ A function to get an exam's analysis by students' group: It groups all students by group and then iterates over the groups, calling every service used to analyze an exam. :param: a json in the Reliabilty Measures standard json format :return: a dictionary of nested dictionaries: a dictionary with groups as keys and the exam analysis as values """ service_key = get_service_config(14) catch_error = get_error(param) if catch_error[0]: return {service_key: catch_error[1]} inp = update_input(param) assumptions_key = get_service_config(13) assumptions = get_assumptions(inp)[assumptions_key] students_dict = sort_students_by_group(inp) group_list = get_group_list(inp) group_analysis = {} if group_list == get_keyword_value("no_group"): return {service_key: get_keyword_value("no_group")} for i in students_dict: curr_students = students_dict[i] catch_error = get_error(curr_students) if catch_error[0]: group_analysis[i] = catch_error[1] continue student_list = get_student_list(curr_students) val_kr20 = calculate_kr20(curr_students) val_idr = calculate_idr(curr_students) val_difficulty = calculate_difficulty(curr_students) val_scores = calculate_scores(curr_students) val_average = calculate_average(curr_students) val_weighted_s = calculate_weighted_scores(curr_students) val_weighted_avg = calculate_weighted_average(curr_students) val_excludes = get_exclude_recos(curr_students) val_diff_avg = calculate_difficulty_average(curr_students) val_idr_avg = calculate_idr_average(curr_students) val_num_correct = calculate_num_correct(curr_students) val_topic_rights = calculate_topic_rights(curr_students) val_topic_avgs = calculate_topic_averages(curr_students) curr_assumptions = {} for k in assumptions: for j in student_list: if k == j[get_keyword_value("id")]: curr_assumptions[k] = assumptions[k] val_assumptions = {assumptions_key: curr_assumptions} result = { 'overall_quiz': { 'average': val_average['average'], 'kr20': val_kr20['kr20'], 'weighted_avg': val_weighted_avg['weighted_avg'] }, 'overall_items': { 'diff_avg': val_diff_avg['diff_avg'], 'idr_avg': val_idr_avg['idr_avg'] }, 'item_analysis': [], 'student_scores': [] } for k in val_difficulty['difficulty']: curr_idr = val_idr['idr'] if curr_idr is not str: curr_idr = val_idr['idr'][k] result['item_analysis'].append({ 'item_id': k, 'difficulty': val_difficulty['difficulty'][k], 'idr': curr_idr, 'num_correct': val_num_correct['num_correct'][k] }) for k in val_scores['scores']: result['student_scores'].append({ 'student': k, 'score': val_scores['scores'][k], 'weighted_score': val_weighted_s['weighted_scores'][k] }) items = [ val_excludes, val_assumptions, val_topic_rights, val_topic_avgs ] for item in items: result.update(item) group_analysis[i] = result return {service_key: group_analysis}
def sort_students_by_group(param): """ A function to sort students into a dictionary with the groups as keys: It calls the get_group_list function and then creates a dictionary with the years as keys. Then it iterates through every student and adds their responses to the dictionary of their corresponding year. :param: a json in the Reliabilty Measures standard json format :return: dictionary of responses: a dictionary with groups as keys and student responses as values in the Reliabilty Measures standard json format """ catch_error = get_error(param) if catch_error[0]: return catch_error[1] inp = update_input(param) student_list = get_student_list(inp) group_list = get_group_list(inp) id_list = get_item_ids(inp) responses_by_group = {} if group_list == get_keyword_value("no_group"): return get_keyword_value("no_group") for i in group_list: responses_by_group[i] = { (get_keyword_value("student_list")): [], get_keyword_value("item_topics"): inp.get(get_keyword_value("item_topics")) } for i in group_list: for k in range(0, len(student_list)): curr_item_ids = [] curr_responses = student_list[k][get_keyword_value( "item_responses")] curr_group = student_list[k][get_keyword_value("group")] for j in curr_responses: curr_item_ids.append(j[get_keyword_value("item_id")]) for j in id_list: if j not in curr_item_ids: student_list[k][get_keyword_value( "item_responses")].append({ get_keyword_value("item_id"): j, get_keyword_value("response"): 0 }) for j in curr_group: if j == i: responses_by_group[i][get_keyword_value( "student_list")].append(student_list[k]) return responses_by_group
def calculate_idr(param): """ A function to get the idr of each item: For every item, it calculates the mean score of students who got the answer right and subtracts it by the mean score of those who got it wrong. Then it multiplies that by the square root of the number of students who got the item right multiplied by the total of those who got it wrong. Then it divides that by the number of students multiplied by the std of the students' scores. :param: a json in the Reliabilty Measures standard json format :return: a dictionary of floats: a dictionary with item ids as keys and idr as values """ service_key = get_service_config(2) catch_error = get_error(param) if catch_error[0]: return {service_key: catch_error[1]} inp = update_input(param) sorted_resp = get_sorted_responses(inp) num_students = len(sorted_resp) num_items = len(sorted_resp[0]) id_list = get_item_ids(inp) score_std = get_score_std(inp) idr_list = [] idr_dict = {} if score_std < 0: return {service_key: get_keyword_value("bad_std")} for i in range(0, num_items): # For each question i right_list = [] wrong_list = [] num_right = 0 num_wrong = 0 for k in range(0, num_students): # For each student k if sorted_resp[k][i] == 1: # If student k gets question i correct score = sum(sorted_resp[k]) / num_items right_list.append( score) # Then add their score to the "right" list num_right += 1 elif sorted_resp[k][i] == 0: # If student k gets question i wrong score = sum(sorted_resp[k]) / num_items wrong_list.append( score) # Then add their score to the "wrong" list num_wrong += 1 if num_right == num_students or num_wrong == num_students: idr_list.append(0) continue if len(right_list) == 1: right_mean = right_list[0] elif len(right_list) > 1: right_mean = mean(right_list) if len(wrong_list) == 1: wrong_mean = wrong_list[0] elif len(wrong_list) > 1: wrong_mean = mean(wrong_list) if not right_mean or not wrong_mean: return {service_key: get_keyword_value("bad_mean")} idr = ((right_mean - wrong_mean) * sqrt(num_right * num_wrong)) / num_students * score_std idr = round(idr, 3) idr_list.append(idr) k = 0 for i in id_list: idr_dict[i] = idr_list[k] k += 1 return {service_key: idr_dict}
def get_item_topics(param): """ A function to get the hierarchy of all topics per item: It iterates through every items topic info and creates a hierarchy for each item's topics. :param: a json in the Reliabilty Measures standard json format :return: a list of dictionaries: a list of dictionaries containing a topic hierarchy, its corresponding item id, and a placeholder number of rights. """ catch_error = get_error(param) if catch_error[0]: return catch_error[1] inp = inp = update_input(param) topics = inp.get(get_keyword_value("item_topics")) if not topics: return get_keyword_value("no_topics") item_ids = [] for i in topics: item = i.get(get_keyword_value("item_id")) if item: if item not in item_ids: item_ids.append(item) tree_dict = {} index = 1 for i in topics: item = i.get(get_keyword_value("item_id")) if not item: while str(index) in item_ids: index += 1 item = str(index) item_ids.append(str(index)) tree_dict[item] = [] tags = i.get(get_keyword_value("tags")) if tags: for k in tags: if k.get(get_keyword_value("scored"), "Y") != "Y": continue curr_tree = k.get( get_keyword_value("topic_tree"), inp[get_keyword_value("exam")][get_keyword_value("name")]) curr_levels = k.get( get_keyword_value("topic_branch_hierarchy")) curr_topic = k.get(get_keyword_value("topic_tagged"), get_keyword_value("unknown")) level_list = [] if curr_levels: for i in curr_levels: level_list.append(int(i)) level_list.sort(reverse=True) hier_level = {} hier_level[0] = curr_tree if curr_levels: for i in range(1, level_list[0] + 2): hier_level[i] = curr_levels.get( str(i - 1), get_keyword_value("unknown")) hier_level[level_list[0] + 2] = curr_topic else: hier_level[1] = curr_topic tree_dict[item].append(hier_level) tree_list = [] for i in tree_dict: for k in tree_dict[i]: if k not in tree_list: tree_list.append(k) tree_tuple = {} for i in tree_list: tree = tuple(sorted(i.items())) tree_tuple[tree] = [] for k in tree_dict: for j in tree_dict[k]: if j == i: tree_tuple[tree].append(k) tree_tuple = tuple(tree_tuple.items()) final_trees = [] for i in tree_tuple: tree_object = {} ids = i[1] tree = i[0] tree_object[get_keyword_value("topic_ids")] = ids tree_object[get_keyword_value("topic_hierarchy")] = tree tree_object[get_keyword_value("topic_rights")] = 0 final_trees.append(tree_object) return final_trees
def update_input(param): """ A function to update the information of a json in the Reliabilty Measures standard json format: If the json does not contain student ids, a default of 1-n is used. If no item ids are given. a default of 1-n is used. If a student or item is included in an exclude list, they are removed from the json. :param: a json in the Reliabilty Measures standard json format :return: a json in the Reliabilty Measures standard json format """ inp = param exclude_students = list( param.get(get_keyword_value("exclude_students"), [])) exclude_items = list(param.get(get_keyword_value("exclude_items"), [])) student_list = list(param.get(get_keyword_value("student_list"), [])) # If no student data was given, return with message if not student_list or len(student_list) <= 1: return get_keyword_value("bad_data") # If a student does not have responses, give him an empty response list for i in range(0, len(student_list)): curr_responses = student_list[i].get( get_keyword_value("item_responses")) if not curr_responses: student_list[i][get_keyword_value("item_responses")] = [] # If all response lists are empty or only has one item, return with message valid_items = False for i in student_list: curr_responses = i[get_keyword_value("item_responses")] if len(curr_responses) > 1: valid_items = True if not valid_items: return get_keyword_value("bad_num_items") # If no exam object is given or it does not contain any info, update it with "unknown" exam_info = param.get(get_keyword_value("exam")) if not exam_info: inp[get_keyword_value("exam")] = { get_keyword_value("name"): get_keyword_value("unknown"), get_keyword_value("scoring_method"): get_keyword_value("unknown") } else: exam_name = exam_info.get(get_keyword_value("name")) scoring_method = exam_info.get(get_keyword_value("scoring_method")) factor = exam_info.get(get_keyword_value("scaled_factor")) if not exam_name: inp[get_keyword_value("exam")][get_keyword_value( "name")] = get_keyword_value("unknown") if not scoring_method: inp[get_keyword_value("exam")][get_keyword_value( "scoring_method")] = get_keyword_value("unknown") if not factor: inp[get_keyword_value("exam")][get_keyword_value( "scaled_factor")] = 1 # If a student does not have an id, assign it a new id # If the student is given a group, assign it the group "unknown" student_ids = [] for i in student_list: curr_stud = i.get(get_keyword_value("group")) if curr_stud: if curr_stud not in student_ids: student_ids.append(curr_stud) for i in range(0, len(student_list)): curr_stud = student_list[i].get(get_keyword_value("id")) curr_group = student_list[i].get(get_keyword_value("group")) new_id = 1 if not curr_stud: while str(new_id) in student_ids: new_id += 1 student_list[i][(get_keyword_value("id"))] = str(new_id) student_ids.append(str(new_id)) if not curr_group: student_list[i][(get_keyword_value("group"))] = [ get_keyword_value("unknown") ] # If an item in a student's response list does not have an id, assign it a new id # If an item in a student's response list does not have a response, assign it a value of 0 item_ids = [] for i in range(0, len(student_list)): curr_responses = student_list[i][get_keyword_value("item_responses")] for k in range(0, len(curr_responses)): curr_item_id = curr_responses[k].get(get_keyword_value("item_id")) if curr_item_id: if curr_item_id not in item_ids: item_ids.append(curr_item_id) for i in range(0, len(student_list)): curr_responses = student_list[i][get_keyword_value("item_responses")] new_id = 1 curr_new_ids = [] for k in range(0, len(curr_responses)): curr_item_id = curr_responses[k].get(get_keyword_value("item_id")) curr_item = curr_responses[k].get(get_keyword_value("response")) if not curr_item_id: while str(new_id) in item_ids or str(new_id) in curr_new_ids: new_id += 1 student_list[i][get_keyword_value("item_responses")][k][ get_keyword_value("item_id")] = str(new_id) curr_new_ids.append(str(new_id)) if not curr_item: student_list[i][get_keyword_value("item_responses")][k][ get_keyword_value("response")] = 0 # If a student's id is in the exclude list, exclude them from the data remove_students = [] for i in student_list: if i[get_keyword_value("id")] in exclude_students: remove_students.append(i) for i in remove_students: student_list.remove(i) # If an item's id is in the exclue list, exclude it from the data for i in range(0, len(student_list)): remove_items = [] curr_responses = student_list[i][get_keyword_value("item_responses")] for k in curr_responses: curr_item = k[get_keyword_value("item_id")] if curr_item in exclude_items: remove_items.append(k) for k in remove_items: curr_responses.remove(k) student_list[i][get_keyword_value("item_responses")] = curr_responses inp[get_keyword_value("student_list")] = student_list # Re-check data student_list = list(inp.get(get_keyword_value("student_list"), [])) if not student_list or len(student_list) <= 1: return get_keyword_value("bad_data") valid_items = False for i in student_list: curr_responses = i[get_keyword_value("item_responses")] if len(curr_responses) > 1: valid_items = True if not valid_items: return get_keyword_value("bad_num_items") return inp