def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] backup = qs.API(schoolcode, 'backup') live = qs.API(schoolcode) for section_dict in qs.bar(backup.get_sections()): section_id = section_dict['id'] backup_enrollment = backup.get_section_enrollment(section_id) backup_enrollment = backup_enrollment['students'] enrolled_ids = [i['smsStudentStubId'] for i in backup_enrollment] if enrolled_ids: live.post_section_enrollment(section_id, enrolled_ids)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] q = qs.API(schoolcode) for section_dict in qs.bar(q.get_sections()): q.delete_all_section_enrollments_for_section(section_dict['id'])
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] filename = sys.argv[2] q = qs.API(schoolcode) csv_assignments = qs.CSV(filename) # Check for missing columns missing_columns = [] if 'Section ID' not in csv_assignments.cols: missing_columns.append('Section ID') if 'Assignment ID' not in csv_assignments.cols: missing_columns.append('Assignment ID') if missing_columns: for missing_column in missing_columns: qs.logger.info('Missing columns: ', missing_columns, cc_print=True) sys.tracebacklimit = 0 raise ValueError("Columns Missing. See above for details.") # Delete Assignments for assign in qs.bar(csv_assignments): assignment = assign['Assignment ID'] section = assign['Section ID'] q.delete_assignment(section, assignment) qs.logger.info('Assignments deleted', cc_print=True)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] filename = sys.argv[2] q = qs.API(schoolcode) csv = qs.CSV(filename) # {student_id: StudentRC} student_rcs = {} for row in csv: student_id = row['Student ID'] section_id = row['Section ID'] identifier = row['Identifier'] value = row['Value'] if student_id not in student_rcs: student_rcs[student_id] = StudentRC() rc = student_rcs[student_id] rc.add_section_data(section_id, identifier, value) report_cycle_id = q.get_active_report_cycle()['id'] for student_id, rc in student_rcs.iteritems(): rc_data = rc.full_report_card_data() q.post_report_card_section_level(student_id, report_cycle_id, rc_data)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] filename = sys.argv[2] csv_sections = qs.CSV(filename) q = qs.API(schoolcode) sections = {} qs.logger.info('Retrieving section info from CSV...', cc_print=True) for section in csv_sections: section_name = section['Section Name'] section_code = section['Section Code'] class_id = section['Class ID'] teacher_id = section['Teacher ID'] sections[section_code] = { 'section_name': section_name, 'section_code': section_code, 'class_id': class_id, 'teacher_id': teacher_id } if 'Credit Hours' in section: credit_hours = section['Credit Hours'] sections[section_code]['credit_hours'] = credit_hours qs.logger.info('POSTing sections...', cc_print=True) new_sections = q.post_sections(sections_dict=sections)
def setup(): global q, posted_section q = qs.API() for section in q.get_sections(): if 'temp' in section['sectionName']: q.delete_section(section['id']) posted_section = q.post_section('temp 1', 'temp 1', CLASS_ID, TEACHER_ID)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] identifier = sys.argv[2] filename = sys.argv[3] q = qs.API(schoolcode) csv_report_card_data = qs.CSV(filename) student_report_card_data = {} if 'Student ID' not in csv_report_card_data.cols: raise ValueError("'Student ID' column is required.") if 'Report Cycle ID' not in csv_report_card_data.cols: raise ValueError("'Report Cycle ID' column is required.") qs.logger.info( 'GETting all report card data for each student enrollment...', cc_print=True) for csv_student in qs.bar(csv_report_card_data): student_id = csv_student['Student ID'] section_id = csv_student['Section ID'] report_cycle_id = csv_student['Report Cycle ID'] report_card_data = q.get_report_card(student_id, report_cycle_id)['sectionLevel'] csv_student[identifier] = report_card_data[section_id][identifier] qs.logger.info('Values retrieved for identifier:', identifier, cc_print=True) filepath = qs.unique_path(csv_report_card_data.filepath, suffix="-values") csv_report_card_data.save(filepath)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] filename = sys.argv[2] ignore_case = bool(sys.argv[3]) if len(sys.argv) > 3 else True enrolled_only = bool(sys.argv[4]) if len(sys.argv) > 4 else False csv_students = qs.CSV(filename) q = qs.API(schoolcode) if not ('Full Name' in csv_students.cols or ('First' in csv_students.cols and 'Last' in csv_students.cols)): raise ValueError('"Full Name" or "First" and "Last" columns required.') if enrolled_only is True: db_students = q.get_students() elif enrolled_only is False: db_students = q.get_students(show_has_left=True, show_deleted=True, ignore_deleted_duplicates=True) db_duplicates = qs.find_dups_in_dict_list(db_students, 'fullName') if db_duplicates: qs.logger.critical('Student names are not unique in DB, duplicates:', db_duplicates) else: qs.logger.info('Student names are unique.') if ignore_case is True: for student in db_students: student['fullName'] = student['fullName'].lower() db_by_name = qs.dict_list_to_dict(db_students, 'fullName') student_names_not_matched = set() for csv_student in csv_students: if 'Full Name' in csv_student: csv_full_name = csv_student['Full Name'] else: csv_full_name = '{}, {}'.format(csv_student['Last'], csv_student['First']) csv_original_full_name = csv_full_name if ignore_case: csv_full_name = csv_full_name.lower() db_match = db_by_name.get(csv_full_name) if db_match: csv_student['Student ID'] = db_match['id'] else: student_names_not_matched.add(csv_original_full_name) if student_names_not_matched: qs.logger.warning(('{} students in the file were not found in the db' ''.format(len(student_names_not_matched))), student_names_not_matched) else: qs.logger.info('All students were matched in the db.', cc_print=True) filepath = qs.unique_path(csv_students.filepath, suffix="with student IDs") csv_students.save(filepath)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] server = sys.argv[2] q = qs.API(schoolcode, server) for section in qs.bar(q.get_sections()): q.delete_section(section['id'])
def test_get_assignment(): assignment = q.get_assignment(ASSIGNMENT_ID) assert_equals(assignment['name'], ASSIGNMENT_NAME) other_cache = qs.API() assignment = other_cache.get_assignment(ASSIGNMENT_ID) assert_equals(assignment['name'], ASSIGNMENT_NAME) assert_in('sectionId', assignment)
def test_make_request(): request = qs.QSRequest('Testing', '/students') q = qs.API() data = q._make_request(request, critical=True) assert_is_instance(data, list) assert_equals(request.api_key, q.api_key) assert_in('apiKey', request.params) assert_equals(request.params['apiKey'], q.api_key) assert_true(request.critical)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] q = qs.API(schoolcode) data = json.load(open('rolling_migration.json')) for section_id, section_dict in qs.bar(data.iteritems()): to_delete = section_dict['enrolled_no_valid_grades'] if to_delete: q.delete_section_enrollments(section_id, to_delete)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] filename = sys.argv[2] attendance = qs.CSV(filename) q = qs.API(schoolcode) for row in qs.bar(attendance): q.post_attendance(row['Student ID'], row['Teacher ID'], row['Date'], row['Status'], row['Remarks'], row['Description'])
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] filename = sys.argv[2] ignore_case = bool(sys.argv[3]) if len(sys.argv) > 3 else True csv_classes = qs.CSV(filename) q = qs.API(schoolcode) if not ('Class Name' in csv_classes.cols or ('Grade' in csv_classes.cols) or ('Grade Level' in csv_classes.cols)): raise ValueError('Class Name, Grade Level, or Grade column required.') db_classes = q.get_classes() db_duplicates = qs.find_dups_in_dict_list(db_classes, 'name') if db_duplicates: qs.logger.critical('Class Names are not unique in DB, duplicates:', db_duplicates) else: qs.logger.info('class names are unique.') if ignore_case is True: for class_name in db_classes: class_name['name'] = class_name['name'].lower() db_by_name = qs.dict_list_to_dict(db_classes, 'name') class_names_not_matched = set() for csv_class in csv_classes: if 'Class Name' in csv_class: csv_class_name = csv_class['Class Name'] elif 'Grade' in csv_class: csv_class_name = csv_class['Grade'] else: csv_class_name = csv_class['Grade Level'] csv_orginal_class_name = csv_class_name if ignore_case: csv_class_name = csv_class_name.lower() db_match = db_by_name.get(csv_class_name) if db_match: csv_class['Class ID'] = db_match['id'] else: class_names_not_matched.add(csv_orginal_class_name) if class_names_not_matched: qs.logger.warning(('{} classes in the file were not found in the db' ''.format(len(class_names_not_matched))), class_names_not_matched) else: qs.logger.info('All classes were matched in the db.', cc_print=True) filepath = qs.unique_path(csv_classes.filepath, suffix="with student IDs") csv_classes.save(filepath)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] q = qs.API(schoolcode) for section in qs.bar(q.get_sections()): section_id = section['id'] assignments = q.get_assignments(section_id, include_final_grades=True) if assignments: for assignment in assignments: q.delete_assignment(section_id, assignment['id'])
def test_adding_api_key(): fake_schoolcode = 'fakeschool' fake_api_key = '{}.fakeapikey'.format(fake_schoolcode) q = qs.API(fake_api_key) q.api_key = API_KEY q.get_students() if q.get_students(): assert_equals(q.schoolcode, fake_schoolcode) assert_equals(qs.api_keys.get(['qs', 'live', fake_schoolcode]), API_KEY) qs.api_keys.remove(['qs', 'live', 'fakeschool'])
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] server = sys.argv[2] identifier = sys.argv[3] level = sys.argv[4] filename = sys.argv[5] q = qs.API(schoolcode, server) csv_transcript_data = qs.CSV(filename) student_transcript_data = {} if 'Student ID' not in csv_transcript_data.cols: raise ValueError("'Student ID' column is required.") if not (len(sys.argv) == 6): raise ValueError("Incorrect number of params. Please review.") if ('Section ID' not in csv_transcript_data.cols and level == "section"): raise ValueError("'Section ID' column is required.") if (level != "transcript" and level != "section"): raise ValueError( "'Level' param not defined properly. Please chose 'section' or 'transcript'." ) qs.logger.info( 'GETting all transcript data for each student enrollment...', cc_print=True) for csv_student in qs.bar(csv_transcript_data): student_id = csv_student['Student ID'] if level == "section": section_id = csv_student['Section ID'] transcript_data = q.get_transcript(student_id)['sectionLevel'] if section_id in transcript_data: if identifier in transcript_data[section_id]: csv_student[identifier] = transcript_data[section_id][ identifier] else: csv_student[identifier] = None if level == "transcript": transcript_data = q.get_transcript(student_id)['transcriptLevel'] if identifier in transcript_data: csv_student[identifier] = transcript_data[identifier] else: csv_student[identifier] = None else: qs.logger.critical('Transcript level param incorrect.') qs.logger.info('Values retrieved for identifier:', identifier, cc_print=True) filepath = qs.unique_path(csv_transcript_data.filepath, suffix="-values") csv_transcript_data.save(filepath)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] section_id = sys.argv[2] filename = sys.argv[3] q = qs.API(schoolcode) csv_grades = qs.CSV(filename) section_name = q.get_section(section_id)['sectionName'] matched_categories = list() unmatched_categories = list() if section_name is None: raise ValueError("Section doesn't exist") if not ('Category Name') in csv_grades.cols: raise ValueError("'Category Name' column required") qs.logger.info( "GETting grading categories based of the gradebook in section: " + section_name, cc_print=True) categories = q.get_grade_category_ids(section_id) for csv_grade in qs.bar(csv_grades): category_name = csv_grade['Category Name'] if category_name in categories: csv_grade['Category ID'] = categories[category_name] matched_categories.append(category_name) else: unmatched_categories.append(category_name) # Return new csv if successful if 'Category ID' in csv_grade: qs.logger.info( "Completed getting category ids. {} categories matched.".format( len(matched_categories)), cc_print=True) qs.logger.info("{} outstanding unmatched categories\n".format( len(unmatched_categories)), cc_print=True) filepath = qs.unique_path(csv_grades.filepath, suffix="w category IDs") csv_grades.save(filepath) else: qs.logger.info("Outstanding categories ({}) are unmatched\n".format( len(unmatched_categories)), cc_print=True) for unmatched_category in unmatched_categories: qs.logger.info(unmatched_category, cc_print=True)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] filename = sys.argv[2] q = qs.API(schoolcode) fees = qs.CSV(filename) for fee in qs.bar(fees): q.post_fee( fee['Student ID'], fee['Category ID'], fee['Amount'], fee['Date'], fee['Description'])
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] filename = sys.argv[2] q = qs.API(schoolcode) csv_semesters = qs.CSV(filename) # Check CSV for proper columns and verify unique semester names in db if not ("Semester" in csv_semesters.cols): raise ValueError("'Semester' column required") db_semesters = q.get_semesters() db_duplicates = qs.find_dups_in_dict_list(db_semesters, "semesterName") if db_duplicates: qs.logger.critical('Semester names are not unique in DB. Duplicates:', db_duplicates) else: qs.logger.info('Semester names are unique. Matching...', cc_print=True) db_semesters_by_name = qs.dict_list_to_dict(db_semesters, "semesterName") # Check for semesters in CSV that are not in db semester_names_not_matched = set() for csv_semester in csv_semesters: csv_semester_name = csv_semester['Semester'] csv_original_semester_name = csv_semester_name db_match = db_semesters_by_name.get(csv_semester_name) if db_match: csv_semester['Semester ID'] = db_match['id'] else: semester_names_not_matched.add(csv_original_semester_name) # Match semesters if all are matched if semester_names_not_matched: qs.logger.info('Semester Names do not match DB:', semester_names_not_matched, cc_print=True) else: qs.logger.info('All semester names matched', cc_print=True) filepath = qs.unique_path(csv_semesters.filepath) csv_semesters.save(filepath)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] filename = sys.argv[2] ignore_case = bool(sys.argv[3]) if len(sys.argv) > 3 else True csv_teachers = qs.CSV(filename) q = qs.API(schoolcode) if not ('Teacher Name' in csv_teachers.cols): raise ValueError('Teacher Name column required.') db_teachers = q.get_teachers() db_duplicates = qs.find_dups_in_dict_list(db_teachers, 'fullName') if db_duplicates: qs.logger.critical('Teacher names are not unique in DB, duplicates:', db_duplicates) else: qs.logger.info('Teacher names are unique.') if ignore_case is True: for teacher in db_teachers: teacher['fullName'] = teacher['fullName'].lower() db_by_name = qs.dict_list_to_dict(db_teachers, 'fullName') teacher_names_not_matched = set() for csv_teacher in csv_teachers: csv_full_name = csv_teacher['Teacher Name'] if ignore_case: csv_full_name = csv_full_name.lower() db_match = db_by_name.get(csv_full_name) if db_match: csv_teacher['Teacher ID'] = db_match['id'] else: teacher_names_not_matched.add(csv_full_name) if teacher_names_not_matched: qs.logger.warning(('{} Teachers in the file were not found in the db' ''.format(len(teacher_names_not_matched))), teacher_names_not_matched) else: qs.logger.info('All teachers were matched in the db.', cc_print=True) filepath = qs.unique_path(csv_teachers.filepath, suffix="with teacher IDs") csv_teachers.save(filepath)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] q = qs.API(schoolcode) section1 = sys.argv[2] section2 = sys.argv[3] discrepancies = q.check_section_enrollment_match(section_1_id=section1, section_2_id=section2) qs.pp({ "section1": section1, "section2": section2, "discrepancies": discrepancies })
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] filename = sys.argv[2] q = qs.API(schoolcode) csv_enrollments = qs.CSV(filename) section_info = {} student_enrollments = {} # Get Section Info if 'Section ID' not in csv_enrollments.cols: qs.logger.critical('"Section ID" column required. Current columns: ', csv_enrollments.cols) if 'Student ID' not in csv_enrollments.cols: qs.logger.critical('"Student ID" column required. Current columns: ', csv_enrollments.cols) qs.logger.info('Setting up enrollment info from csv data...', cc_print=True) for enrollment in csv_enrollments: section_name = enrollment['Section Name'] section_id = enrollment['Section ID'] student_id = enrollment['Student ID'] if 'Section Code' in enrollment: section_code = enrollment['Section Code'] else: section_code = enrollment['Section Name'] if section_id not in student_enrollments: student_enrollments[section_id] = list() student_enrollments[section_id].append(student_id) section_info[section_id] = { 'section_name': section_name, 'section_id': section_id, 'section_code': section_code, 'student_ids': student_enrollments[section_id] } qs.logger.info('POSTing section enrollments...', cc_print=True) for section in qs.bar(section_info): section_id = section_info[section]['section_id'] students = section_info[section]['student_ids'] new_enrollment = q.post_section_enrollment(section_id, students)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] filename = sys.argv[2] q = qs.API(schoolcode) csv_report_cycles = qs.CSV(filename) if 'Report Cycle' not in csv_report_cycles.cols: raise ValueError("'Report Cycle' column required") db_report_cycles = q.get_report_cycles() db_duplicates = qs.find_dups_in_dict_list(db_report_cycles, 'name') db_by_name = qs.dict_list_to_dict(db_report_cycles, 'name') if db_duplicates: qs.logger.info('Report Cycle names are not unique', cc_print=True) else: qs.logger.info('Report Cycle names are unique', cc_print=True) report_cycle_names_not_matched = set() for csv_report_cycle in csv_report_cycles: csv_report_cycle_name = csv_report_cycle['Report Cycle'] if csv_report_cycle_name in db_duplicates: qs.logger.info('Report Cycle name has multiple matches', cc_print=True) db_match = db_by_name.get(csv_report_cycle_name) if db_match: csv_report_cycle['Report Cycle ID'] = db_match['id'] else: report_cycle_names_not_matched.add(csv_report_cycle_name) if report_cycle_names_not_matched: qs.logger.warning( ('{} Report Cycles in the file were not found in the db' ''.format(len(report_cycle_names_not_matched))), report_cycle_names_not_matched) else: qs.logger.info('All Report Cycles were matched in the db.', cc_print=True) filepath = qs.unique_path(csv_report_cycles.filepath, suffix="with-report-cycle-IDs") csv_report_cycles.save(filepath)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] q = qs.API(schoolcode) student = sys.argv[2] assign_name = sys.argv[3] assign_date = sys.argv[4] total_possible = sys.argv[5] category_id = sys.argv[6] marks = sys.argv[7] grading_scale_id = sys.argv[8] section = sys.argv[9] new_grade = q.post_assignment_with_grades(section, assign_name, assign_date, total_possible, category_id, grading_scale_id, grades_date) qs.logger.info({"section": section, "grade": section_data['grades_data']})
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] from_identifier = sys.argv[2] to_identifier = sys.argv[3] filename = sys.argv[4] q = qs.API(schoolcode) csv_section_values = qs.CSV(filename) sections = dict() empty_sections = list() if 'Student ID' not in csv_section_values.cols: raise ValueError("'Student ID' column required") elif 'Section ID' not in csv_section_values.cols: raise ValueError("'Section ID' column required") elif from_identifier not in csv_section_values.cols: raise ValueError("Identifier '{}'column is required" .format(from_identifier)) qs.logger.info("Retrieving section information and identifier values...", cc_print=True) for section in qs.bar(csv_section_values): student_id = section['Student ID'] section_id = section['Section ID'] identifier_values = section[from_identifier] if identifier_values is not None: if student_id not in sections: sections[student_id] = dict() sections[student_id][section_id] = {'values': {to_identifier: identifier_values}} else: if 'Full Name' in csv_section_values.cols and 'Section Name' in csv_section_values.cols: student_name = section['Student Name'] section_name = section['Section Name'] empty_sections.append({student_id: section_id, student_name: section_name}) else: empty_sections.append({student_id: section_id}) qs.logger.info("POSTing data to transcripts' sections...", cc_print=True) for student in qs.bar(sections): student_id = student transcript_data = sections[student] q.post_transcript_section_level(student_id, transcript_data)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] q = qs.API(schoolcode) data = json.load(open('rolling_migration.json')) for old_section_id, old_section_dict in qs.bar(data.iteritems()): new_section = q.match_section(old_section_id) new_section_id = new_section['id'] enrolled_no_valid_grades = old_section_dict['enrolled_no_valid_grades'] invalid_grades = old_section_dict['invalid_grades'] if not enrolled_no_valid_grades: continue q.post_section_enrollment(new_section_id, enrolled_no_valid_grades) invalid_by_assignment = {i['assignmentId']: [] for i in invalid_grades} for grade in invalid_grades: if grade['isFinalGrade'] is False: invalid_by_assignment[grade['assignmentId']].append(grade) for assignment_id, grades in invalid_by_assignment.iteritems(): old_assignment = q.get_assignment(assignment_id) new_assignment = q.post_assignment( new_section_id, old_assignment.get('name'), old_assignment.get('date'), old_assignment.get('totalMarksPossible'), old_assignment.get('categoryId'), old_assignment.get('gradingScaleId')) grades_to_upload = [] for grade in grades: student_id = grade['studentId'] if student_id in enrolled_no_valid_grades: grades_to_upload.append(grade) else: warning = ("student {} has some, but not all valid grades " "for section {}").format( student_id, old_section_id) qs.logger.warning(warning) q.post_grades(new_section_id, new_assignment['id'], grades_to_upload)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] server = sys.argv[2] filename = sys.argv[3] q = qs.API(schoolcode, server) csv_student_report_cycles = qs.CSV(filename) tr_enrollments = list() if 'Student ID' not in csv_student_report_cycles.cols: raise ValueError("'Student ID' column required.") for csv_student in qs.bar(csv_student_report_cycles): student_id = csv_student['Student ID'] if 'Full Name' in csv_student: full_name = csv_student['Full Name'] else: full_name = None tr_data = q.get_transcript(student_id)['sectionLevel'] for section in tr_data: section_id = section if full_name: tr_enrollments.append({'Student ID': student_id, 'Full Name': full_name, 'Section ID': section_id}) else: tr_enrollments.append({'Student ID': student_id, 'Section ID': section_id}) if tr_enrollments: qs.logger.info('Transcript section enrollment retrieved', cc_print=True) filepath = qs.unique_path(csv_student_report_cycles.filepath) qs.write_csv(tr_enrollments, filepath) else: qs.logger.info('No enrollments found for these students', cc_print=True)
def main(): qs.logger.config(__file__) schoolcode = sys.argv[1] filename = sys.argv[2] silent = bool(sys.argv[3]) if len(sys.argv) > 3 else False csv_sections = qs.CSV(filename) q = qs.API(schoolcode) row_num = 1 if 'Semester ID' in csv_sections.cols: qs.logger.info('Matching with db by Semester ID...', cc_print=True) for csv_section_info in qs.bar(csv_sections): section_name = csv_section_info['Section Name'] semester_id = csv_section_info['Semester ID'] if 'Section Code' in csv_sections.cols: section_code = csv_section_info['Section Code'] section = {'sectionCode': section_code} matched_section = q.match_section( section, fail_silent=silent, match_code=True, target_semester_id=semester_id) else: matched_section = q.match_section( identifier=section_name, fail_silent=silent, target_semester_id=semester_id) if matched_section is "FALSE": section_id = "FALSE" else: section_id = matched_section['id'] csv_section_info['Section ID'] = section_id elif 'Student ID' in csv_sections.cols: qs.logger.info('Matching with db by Student ID...', cc_print=True) for csv_section_info in qs.bar(csv_sections): section_name = csv_section_info['Section Name'] student = csv_section_info['Student ID'] row_num += 1 section = q.match_section(identifier=section_name, student_id=student, match_name=True) section_id = section['id'] csv_section_info['Section ID'] = section_id elif 'Section Code' in csv_sections.cols: qs.logger.info('Matching with db by Section Code...', cc_print=True) sections = {} sections_with_id = {} row_num = 1 for csv_section_info in csv_sections: section_name = csv_section_info['Section Name'] section_code = csv_section_info['Section Code'] row_num += 1 if section_code not in sections: sections[section_code] = {'sectionCode': section_code} qs.logger.info('GETting matching section ids by Section Code...', cc_print=True) for section_code in sections: matched_section = q.match_section(sections[section_code], match_code=True) section_id = matched_section['id'] if section_id not in sections_with_id: sections[section_code] = {'section_id': section_id} qs.logger.info('Matching section ids to csv section data...', cc_print=True) for csv_section_info in csv_sections: section_code = csv_section_info['Section Code'] csv_section_info['Section ID'] = sections[section_code][ 'section_id'] else: qs.logger.critical( '"Student ID", "Semester ID", or "Section Code" columns required. Current columns:', csv_sections.cols) # Make CSV only if successful if 'Section ID' in csv_section_info: filepath = qs.unique_path(csv_sections.filepath, suffix="with section IDs") csv_sections.save(filepath)
def setup(): global q q = qs.API()