Ejemplo n.º 1
0
def main():
    #testing out the course class

    ACIT2515 = Course("ACIT2515", "12345", "Computing", "CIT")
    ACIT2515.add("A01048668")
    ACIT2515.add("A00000001")
    ACIT2515.add("A00000002")
    ACIT2515.remove("A01048668")
    if (ACIT2515.check("A01048668") == False):
        print("I should be enrolled in ACIT 2515")
    ACIT2515.details()

    ACIT2520 = Course("ACIT2520", "54321", "Computing", "CIT")
    ACIT2520.add("A01048668")
    ACIT2520.add("A00000001")
    ACIT2520.add("A00000002")
    ACIT2520.add("A00000003")
    ACIT2520.add("A00000004")
    ACIT2520.remove("A00000001")
    ACIT2520.remove("A00000002")
    ACIT2520.remove("A00000003")
    ACIT2520.add("A01048668")
    ACIT2520.details()

    MATH1350 = Course("MATH1350", "11111", "Mathematics", "CIT")
    MATH1350.details()
Ejemplo n.º 2
0
 def test_init_with_prereq(self):
     prereq1 = Course('CSC108')
     prereq2 = Course('CSC165')
     course = Course('CSC148', [prereq1, prereq2])
     self.assertEqual('CSC148', course.name)
     self.assertFalse(course.taken)
     self.assertEqual(course.prereqs, [prereq1, prereq2])
Ejemplo n.º 3
0
Archivo: main.py Proyecto: jtw10/T2
def main():
    """ Testing of the course class"""
    """ Creating an instance of the Course class for ACIT2515 """
    print('<--- ACIT 2515 --->')
    acit2515 = Course('ACIT 2515', 713456, 'BCIT School of Computing', 'CIT')
    acit2515.add_student('A01054709')
    acit2515.add_student('A01054938')
    acit2515.add_student('A00492893')
    acit2515.remove_student('A01054709')
    if acit2515.check_enrollment('A01054709') is False:
        print('I should be enrolled in ACIT2515!')
    print(acit2515.course_details())
    """ Creating an instance of the Course class for ACIT 1515 """
    print('<--- ACIT 1515 --->')
    acit1515 = Course('ACIT 1515', 340923, 'BCIT School of Computing', 'CIT')
    acit1515.add_student('A01054709')
    acit1515.add_student('A01054708')
    acit1515.add_student('A01054707')
    acit1515.add_student('A01054706')
    acit1515.add_student('A01054705')
    acit1515.remove_student('A01054707')
    acit1515.remove_student('A01054706')
    acit1515.remove_student('A01054705')
    acit1515.add_student('A01054709')
    print(acit1515.course_details())
    """ Creating an instance of the Course class for ACIT 1420 """
    print('<--- ACIT 1420 --->')
    acit1420 = Course('ACIT 1420', 348209, 'BCIT School of Computing', 'CIT')
    print(acit1420.course_details())
Ejemplo n.º 4
0
    def test_get_num_courses_in_program(self):
        """ 060A - Valid Get Number of Courses in Program """

        test_course_1 = Course("ACIT2515", "123456", "CIT")
        test_course_1.add_student("A01000056")

        test_course_2 = Course("COMP1409", "123444", "CSD")
        test_course_2.add_student("A01000056")

        test_course_3 = Course("COMP1510", "123555", "CSD")
        test_course_3.add_student("A01000045")

        test_course_4 = Course("COMP2530", "123667", "CSD")
        test_course_4.add_student("A01000034")

        test_school = School("Computing and Academic Studies")
        test_school.add_course(test_course_1)
        test_school.add_course(test_course_2)
        test_school.add_course(test_course_3)
        test_school.add_course(test_course_4)

        self.assertEqual(test_school.get_num_courses_in_program("CIT"), 1,
                         "Must be only 1 CIT course")
        self.assertEqual(test_school.get_num_courses_in_program("CSD"), 3,
                         "Must be 3 CSD courses")
        self.assertEqual(test_school.get_num_courses_in_program("SSD"), 0,
                         "Must be no SSD courses")
def init_lists(c_list, s_list, a_list):
    """
    This function adds elements to course_list, student_list and
    admin_list.  It makes testing and grading easier.  It has
    three parameters: c_list is the list of Course objects;
    s_list is the list of Student objects; a_list is the list of
    Admin objects.  This function has no return value.
    
    """

    course1 = Course("CSC121", 2)
    course1.add_student("1004")
    course1.add_student("1003")
    c_list.append(course1)
    course2 = Course("CSC122", 2)
    course2.add_student("1001")
    c_list.append(course2)
    course3 = Course("CSC221", 1)
    course3.add_student("1002")
    c_list.append(course3)

    student1 = Student("1001", "111")
    s_list.append(student1)
    student2 = Student("1002", "222")
    s_list.append(student2)
    student3 = Student("1003", "333")
    s_list.append(student3)
    student4 = Student("1004", "444")
    s_list.append(student4)

    admin1 = Admin("7001", "777")
    a_list.append(admin1)
    admin2 = Admin("8001", "888")
    a_list.append(admin2)
Ejemplo n.º 6
0
def main():

    # Create and Allocate Course Object Instances in Memory:
    course1 = Course("Data Structures")
    course2 = Course("SQL Programming")

    # Add Students to course1 Object Instance:
    course1.addStudent("Peter Jones")
    course1.addStudent("Brian Smith")
    course1.addStudent("Annie Kennedy")

    # Add Students to course2 Object Instance:
    course2.addStudent("Tom Jones")
    course2.addStudent("Lee Smith")
    course2.addStudent("Mary Jane")

    # Display course1 Object Instance List and Length of List:
    print("Number of students in course 1:", course1.getNumberOfStudents())
    for student in course1.getStudents():
        print(student, end=", ")
    print('\n')

    # Remove Student from course2 Object Instance:
    if "Tom Jones" in course2.getStudents():
        course2.dropStudent("Tom Jones")

    # Display course2 Object Instance List and Length of List:
    print("Number of students in course 2:", course2.getNumberOfStudents())
    for student in course2.getStudents():
        print(student, end=", ")
    print('\n')
Ejemplo n.º 7
0
    def login(self):
        username = input("What is your name? ")
        if username.lower() not in SystemInfo.users_info:
            print("You are not part of the system. Contact the admin.")
            sys.exit(0)

        else:
            if SystemInfo.users_info[username]["role"] == "student":
                course = input("What course is this for? ").upper()
                if course not in SystemInfo.users_info[username]["course"]:
                    print("You are not enrolled in this course.")
                    sys.exit(0)
                else:
                    join_this_course = Course(course, SystemInfo.course_info[course])
                    student = User(username, join_this_course)
                    student.startCollab(join_this_course)

            elif SystemInfo.users_info[username]["role"] == "professor":
                course = input("What course are you here for? ").upper()
                if course not in SystemInfo.users_info[username]["course"]:
                    print("You are not teaching this course.")
                    sys.exit(0)
                else:
                    join_this_course = Course(course, SystemInfo.course_info[course])
                    professor = Professor(username, join_this_course)
                    professor.uploadLectureOutline()
                    professor.startCollab(join_this_course)

            elif SystemInfo.users_info[username]["role"] == "admin":
                admin = Administrator(username)
                admin.maintainSystem()
Ejemplo n.º 8
0
 def set_courses(self) -> None:
     for section in self._meeting_sections:
         # print(section) # Debugging only
         temp_lst = []
         if "T" not in section["code"][0] and "P" not in section["code"][0]:
             for time in section['times']:
                 temp_lst.append((self._filter.get_start_time() <= time['start'] <= self._filter.get_end_time()) \
                                 and (self._filter.get_start_time() <= time['end'] <= self._filter.get_end_time()) \
                                 and time['day'] not in self._filter.get_days_excluded() \
                                 and not (self._filter.get_lunch_time_start() <= time[
                     'start'] <= self._filter.get_lunch_time_end())
                                 and not (self._filter.get_lunch_time_start() <= time[
                     'end'] <= self._filter.get_lunch_time_end()))
             if all(temp_lst):
                 self._lectures_list.append(
                     Course(self._id, self._code, self._name, self._description, self._division, self._department,
                            self._prerequisites, self._exclusions, self._level, self._campus, self._term,
                            self._breadths, section))
         else:
             for time in section['times']:
                 temp_lst.append((self._filter.get_start_time() <= time['start'] <= self._filter.get_end_time()) \
                                 and (self._filter.get_start_time() <= time['end'] <= self._filter.get_end_time()) \
                                 and time['day'] not in self._filter.get_days_excluded() \
                                 and not (self._filter.get_lunch_time_start() <= time[
                     'start'] < self._filter.get_lunch_time_end())
                                 and not (
                         self._filter.get_lunch_time_start() < time['end'] < self._filter.get_lunch_time_end()))
             if all(temp_lst):
                 self._tutorials_practicals_list.append(
                     Course(self._id, self._code, self._name, self._description, self._division, self._department,
                            self._prerequisites, self._exclusions, self._level, self._campus, self._term,
                            self._breadths, section))
Ejemplo n.º 9
0
def parse_course_data(filename):
    """ (str) -> Course

    Read in prerequisite data from the file called filename,
    create the Course data structures for the data,
    and then return the root (top-most) course.

    See assignment handout for details.
    """
    courses = {}
    with open(filename, 'r') as source:
        for line in source:
            classes = line.split()
            if classes[0] not in courses:
                courses[classes[0]] = Course(classes[0])
            if classes[1] not in courses:
                courses[classes[1]] = Course(classes[1])
            if courses[classes[0]] not in courses[classes[1]].prereqs:
                courses[classes[1]].add_prereq(courses[classes[0]])
    top = None
    for cour in courses:
        boo = True
        for compare in courses:
            if courses[cour] in courses[compare].prereqs:
                boo = False
        if boo:
            return courses[cour]
Ejemplo n.º 10
0
def init_lists(c_list, s_list, a_list):

    course1 = Course("CSC227", 2)
    course1.add_student("1003")
    course1.add_student("1004")
    c_list.append(course1)
    course2 = Course("CTI115", 2)
    course2.add_student("1001")
    c_list.append(course2)
    course3 = Course("DBA130", 1)
    course3.add_student("1002")
    c_list.append(course3)

    student1 = Student("1001", "111")
    s_list.append(student1)
    student2 = Student("1002", "222")
    s_list.append(student2)
    student3 = Student("1003", "333")
    s_list.append(student3)
    student4 = Student("1004", "444")
    s_list.append(student4)

    admin1 = Admin("8001", "888")
    a_list.append(admin1)
    admin2 = Admin("9001", "999")
    a_list.append(admin2)
Ejemplo n.º 11
0
    def test_get_courses_by_crn(self):
        # Timeslot can be empty for this
        c1 = Course("CSCI2121", None)
        c2 = Course("CSCI2121", None)
        c3 = Course("CSCI2121", None)
        c4 = Course("CSCI2122", None)

        self.assertEquals(3, len(Course.get_all_by_crn("CSCI2121")))
Ejemplo n.º 12
0
 def test_iterate_list(self):
     cl = CourseList()
     cl.insert(Course(1000))
     for _ in range(20):
         cl.insert(Course(1200))
     totalCourses = 0
     for _ in cl:
         totalCourses += 1
     self.assertEqual(totalCourses, 21)
    def test_get_all(self):
        with patch('fileSystemCourseDaoImpl.open',
                   mock_open(read_data=self.mocked_course_data),
                   create=True) as m:
            expected_courses = [Course(), Course()]

            actual_courses = self.courseDao.get_all()

            self.assertEqual(expected_courses, actual_courses)
Ejemplo n.º 14
0
def test_remove_all():
    cl = CourseList()
    cl.insert(Course(1000, "", 0.0, 0.0))
    for _ in range(20):
        cl.insert(Course(1200, "", 0.0, 0.0))
    cl.insert(Course(1800, "", 0.0, 0.0))
    assert cl.size() == 22
    cl.remove_all(1200)
    assert cl.size() == 2
Ejemplo n.º 15
0
def test_iterate_list():
    cl = CourseList()
    cl.insert(Course(1000, "", 0.0, 0.0))
    for _ in range(20):
        cl.insert(Course(1200, "", 0.0, 0.0))
    totalCourses = 0
    for _ in cl:
        totalCourses += 1
    assert totalCourses == 21
Ejemplo n.º 16
0
 def test_remove_all(self):
     cl = CourseList()
     cl.insert(Course(1000))
     for _ in range(20):
         cl.insert(Course(1200))
     cl.insert(Course(1800))
     self.assertEqual(cl.size(), 22)
     cl.remove_all(1200)
     self.assertEqual(cl.size(), 2)
Ejemplo n.º 17
0
 def test_takeable_many_prereqs_satisfied(self):
     self.c1 = Course('CSC108')
     self.c2 = Course('CSC148', [self.c1])
     self.c3 = Course('CSC165', [self.c1])
     self.c4 = Course('CSC207', [self.c1, self.c2, self.c3])
     self.c1.taken = True
     self.assertTrue(self.c2.is_takeable())
     self.assertTrue(self.c3.is_takeable())
     self.c2.taken = True
     self.c3.taken = True
     self.assertTrue(self.c4.is_takeable())
Ejemplo n.º 18
0
def main ():

    filePath = "data.txt" # path of file to access.
    file = open(filePath) # opens file.
    lines = len(file.readlines()) # accesses number of lines in data file.
    file = open(filePath) # reopens data file.
    number = 0 # temporary variable for class number.
    name = " " # temporary variable for class name.
    credit = 0 # temporary variable for credit hours.
    grade = 0.0 # temporary variable for grades.
    schedule = CourseList(None) # empty CourseList object.

    for x in range(lines - 1): # for loop parsing each line of data file.
        firstLine = file.readline()
        comma = firstLine.index(',')
        number = firstLine[0:comma] # accesses class number.
        firstLine = firstLine[comma + 1:len(firstLine)]
        comma = firstLine.index(',')
        name = firstLine[0:comma] # accesses class name.
        firstLine = firstLine[comma + 1:len(firstLine)]
        comma = firstLine.index(',')
        credit = firstLine[0:comma] # accesses credit hours.
        firstLine = firstLine[comma + 1:len(firstLine)]
        grade = firstLine # accesses grade.
        

        schedule.insert(Course(int(number), name, float(credit), float(grade), None)) # inserts a Course object into the CourseList object using parsed data.

    firstLine = file.readline() # repeats parsing process for last line of the data file.
    comma = firstLine.index(',')
    number = firstLine[0:comma]
    firstLine = firstLine[comma + 1:len(firstLine)]
    comma = firstLine.index(',')
    name = firstLine[0:comma]
    firstLine = firstLine[comma + 1:len(firstLine)]
    comma = firstLine.index(',')
    credit = firstLine[0:comma]
    firstLine = firstLine[comma + 1:len(firstLine)]
    grade = firstLine

    schedule.insert(Course(int(number), name, int(credit), float(grade), None)) # inserts last Course object.
    print("Current List: (", schedule.size(), ")") # prints out current CourseList object size.
    print("\n")


    print(schedule) # prints current CourseList with inserted courses.


    print("\n\n\n")
    print("Cumulative GPA: ", schedule.calculate_gpa()) # prints out cumulative GPA.
Ejemplo n.º 19
0
class GradingQuestion(QuestionTemplate):
    """
        Ex: "How is the grading for cmpe 273"
        Ex: "What is the grading for cmpe 273"
    """
    grading = Group(Lemma("grading"), "grading")
    regex = Lemmas("How be") + Question(Pos("DT")) + grading + Pos("IN") + Course() + Question(Pos(".")) | \
    Lemmas("what be") + Question(Pos("DT")) + Lemma("grading") + Pos("IN") + Course() + Question(Pos("."))

    def interpret(self, match):
        answer = "%s has %s ."
        grading = IsClassRelated() + match.course + HasFields('grading'.decode('utf-8')) \
                       + HasAnswer(answer.decode('utf-8'))
        return grading
Ejemplo n.º 20
0
class InstructorQuestion(QuestionTemplate):
    """
        Ex: "Who is the instructor of cmpe 273?"
            "Who teaches cmpe 273?"
            "By whom is cmpe 273 taught?"
    """
    regex = Lemmas("who be") + Question(Pos("DT")) + Lemma("instructor") + Pos("IN") + Course() + Question(Pos(".")) | \
            Lemma("who") + Lemma("teach") + Course() + Question(Pos("."))| \
            Pos("IN") + Lemmas("whom be") + Course() + Lemma("taught") + Question(Pos("."))

    def interpret(self, match):
        answer = "The instructor for %s is %s"
        instructor = IsInstructorInfoRelated() + match.course + HasFields(
            'name'.decode('utf-8')) + HasAnswer(answer.decode('utf-8'))
        return instructor
Ejemplo n.º 21
0
    def test_get_non_existent_course(self):
        """ 050C - Invalid Get Course Non-Existent """

        test_course_1 = Course("ACIT2515", "123456", "CIT")
        test_course_1.add_student("A010000056")

        test_course_2 = Course("COMP1510", "456321", "CST")
        test_course_2.add_student("A010000056")
        test_course_2.add_student("A010450012")

        test_school = School("Computing and Academic Studies")
        test_school.add_course(test_course_1)
        test_school.add_course(test_course_2)

        self.assertIsNone(test_school.get_course("ACIT1234"), "No course should exists for ACIT1234")
Ejemplo n.º 22
0
def parse_csv(csv_file):
    crn = []

    for row in csv_file:
        # If meridian is not 'AM' or 'PM' set to 'AM'
        m = row['meridian']
        if m != 'AM' and m != 'PM':
            m = 'AM'

        # Read in start and end time
        try:
            st = check_time(row['start_time'])
            et = check_time(row['end_time'])
        except Exception as e:
            print row
            raise e

        # Give start time correct meridian
        st, et = decide_am_pm(st, et, m)

        # Create a timeslot
        ts = parse_time(row['days'], st, et)

        # Create course
        # Initialize with no prereqs (need database with prereqs)
        try:
            c = Course(row['crn?'], ts, None, **row)
        except Exception as e:
            print row
            raise e

        crn.append(c)

    return crn
Ejemplo n.º 23
0
def readAndCreateSet():
    f = open('course-list.txt', 'r')
    set = LinkedSet()
    for line in f:
        course = None
        if line != '\n':
            # Split into two halves
            splitted = line.split('\'')
            # splitted[1] has course name which spaces
            # and cannot be parsed normally.
            name = splitted[1]

            splitAgain = splitted[0].split(' ')
            term = splitAgain[0]
            section = splitAgain[1]
            available = splitAgain[2]
            capacity = splitAgain[3]
            subject = splitAgain[4]
            course_number = splitAgain[5]
            course = Course(term, subject, course_number, section, name,
                            available, capacity)
            set.add(course)
    #print(set)
    return set
    f.close()
Ejemplo n.º 24
0
def prompt_course() -> Course:
    '''
    prompts user to enter info of a course

    returns:
        Course object with the info inputter by user
    '''
    name = ""
    cred = 0
    grade = .0
    _type = 'mandatory'
    name = input("名(串):")
    print("学分(整):")
    cred = utils.promptint()
    while True:
        grade = input("绩点(字母):").upper()
        if utils.isgrade(grade):
            break
    while True:
        inp = input("类(必选:0,限选:1,任选:2):")
        if inp == '0' or inp == 'mandatory' or inp == '必修':
            _type = '必修'
        elif inp == '1' or inp == 'limited' or inp == '限选':
            _type = '限选'
        elif inp == '2' or inp == 'free' or inp == '任选':
            _type = '任选'
        else:
            continue  # 重新请求输入
        break
    return Course(name=name, credit=cred, grade=grade, _type=_type)
Ejemplo n.º 25
0
def main():
    course_code = input("Enter course code: ")
    quota = int(input("Enter course quota: "))
    course1 = Course(course_code, quota)

    user_input = 5
    while user_input != 0:
        user_input = int(
            input("Enter 1 for add student, 2 for drop student,"
                  "3 for course info, 0 for exit: "))

        if user_input == 1:
            course1.add_student()
            print("Enrollment: ", course1.getEnrollment())
            print()
        elif user_input == 2:
            course1.drop_student()
            print("Enrollment: ", course1.getEnrollment())
            print()
        elif user_input == 3:
            print("Course code: ", course1.getCourse_code())
            print("Quota: ", course1.getQuota())
            print("Enrollment: ", course1.getEnrollment())
            print()
        elif user_input == 4:
            new_quota = int(input("Enter new quota: "))
            course1.setQuota(new_quota)
Ejemplo n.º 26
0
def create_Courses(starting_time, ending_time, time_slot_index, number_of_class_to_be_created):
    for i in range(number_of_class_to_be_created):
        #     starting_time = 8.75*60
        #     ending_time = 10.75*60
        #

        # institution_is_availiable = {1:False,2:False,3:False}

        array_of_institution_index = na.array((1, 2, 3))

        #UNCOMMENT
        rand.shuffle(array_of_institution_index)
        for i in array_of_institution_index:
            done = False
            selected_institution_number = i
            classroom_list = INSTITUTION_INT_MAP[i].classrooms

            classroom_index = na.array(range(len(classroom_list)))

            #UC
            rand.shuffle(classroom_index)

            for j in classroom_index:
                if classroom_list[j].open[time_slot_index - 1] == True:
                    INSTITUTION_INT_MAP[i].classrooms[j].open[time_slot_index - 1] = False
                    selected_classroom_number = j
                    classroom = classroom_list[selected_classroom_number]
                    course = Course(starting_time, ending_time, selected_institution_number, classroom)
                    all_courses[time_slot_index].append(course)
                    done = True
                    break
            if done:
                break
Ejemplo n.º 27
0
    def test_course_exists_not_existent_course(self):
        """ 030C - Valid Course Does Not Exist """

        test_course_1 = Course("ACIT2515", "123456", "CIT")
        test_course_1.add_student("A010000056")

        test_course_2 = Course("COMP1510", "456321", "CST")
        test_course_2.add_student("A010000056")
        test_course_2.add_student("A010450012")

        test_school = School("Computing and Academic Studies")
        test_school.add_course(test_course_1)
        test_school.add_course(test_course_2)

        self.assertFalse(test_school.course_exists("ACIT1234"), "Course ACIT1234 must NOT exist")
        self.assertFalse(test_school.course_exists("COMP4321"), "Course4321 must NOT exist")
Ejemplo n.º 28
0
    def test_course_exists(self):
        """ 030A - Valid Course Exists """

        test_course_1 = Course("ACIT2515", "123456", "CIT")
        test_course_1.add_student("A010000056")

        test_course_2 = Course("COMP1510", "456321", "CST")
        test_course_2.add_student("A010000056")
        test_course_2.add_student("A010450012")

        test_school = School("Computing and Academic Studies")
        test_school.add_course(test_course_1)
        test_school.add_course(test_course_2)

        self.assertTrue(test_school.course_exists("ACIT2515"), "Course ACIT2515 must exist")
        self.assertTrue(test_school.course_exists("COMP1510"), "Course COMP1510 must exist")
Ejemplo n.º 29
0
 def test_remove_recursion(self):
     cl = CourseList()
     for i in range(1000, 1010):
         cl.insert(Course(i, "Test", 1.0, 1.0))
     RecursionCounter.recursion_count = 0
     cl.remove(1005)
     self.assertGreater(RecursionCounter.recursion_count, 4)
Ejemplo n.º 30
0
 def test_sorted_recursion(self):
     cl = CourseList()
     for i in range(1000, 1010):
         cl.insert(Course(i, "Test", 1.0, 1.0))
     RecursionCounter.recursion_count = 0
     cl.is_sorted()
     self.assertGreater(RecursionCounter.recursion_count, 9)