Upload 31 files

algorithm/GeneticAlgorithm.py

@@ -0,0 +1,190 @@
+from model.Schedule import Schedule
+import random
+from random import randrange
+from time import time
+
+
+# Lakshmi, R. et al. “A New Biological Operator in Genetic Algorithm for Class Scheduling Problem.” 
+# International Journal of Computer Applications 60 (2012): 6-11.
+
+
+# Genetic algorithm
+class GeneticAlgorithm:
+    def initAlgorithm(self, prototype, numberOfChromosomes=100, replaceByGeneration=8, trackBest=5):
+        # Number of best chromosomes currently saved in best chromosome group
+        self._currentBestSize = 0
+        # Prototype of chromosomes in population
+        self._prototype = prototype
+
+        # there should be at least 2 chromosomes in population
+        if numberOfChromosomes < 2:
+            numberOfChromosomes = 2
+
+        # and algorithm should track at least on of best chromosomes
+        if trackBest < 1:
+            trackBest = 1
+
+        # Population of chromosomes
+        self._chromosomes = numberOfChromosomes * [None]
+        # Inidicates whether chromosome belongs to best chromosome group
+        self._bestFlags = numberOfChromosomes * [False]
+
+        # Indices of best chromosomes
+        self._bestChromosomes = trackBest * [0]
+        # Number of chromosomes which are replaced in each generation by offspring
+        self.set_replace_by_generation(replaceByGeneration)
+
+    # Initializes genetic algorithm
+    def __init__(self, configuration, numberOfCrossoverPoints=2, mutationSize=2, crossoverProbability=80,
+                 mutationProbability=3):
+        self.initAlgorithm(Schedule(configuration))
+        self._mutationSize = mutationSize
+        self._numberOfCrossoverPoints = numberOfCrossoverPoints
+        self._crossoverProbability = crossoverProbability
+        self._mutationProbability = mutationProbability
+
+    @property
+    # Returns pointer to best chromosomes in population
+    def result(self):
+        return self._chromosomes[self._bestChromosomes[0]]
+
+    def set_replace_by_generation(self, value):
+        numberOfChromosomes = len(self._chromosomes)
+        trackBest = len(self._bestChromosomes)
+        if (value > numberOfChromosomes - trackBest):
+            value = numberOfChromosomes - trackBest
+        self._replaceByGeneration = value
+
+    # Tries to add chromosomes in best chromosome group
+    def addToBest(self, chromosomeIndex):
+        bestChromosomes = self._bestChromosomes
+        length_best = len(bestChromosomes)
+        bestFlags = self._bestFlags
+        chromosomes = self._chromosomes
+
+        # don't add if new chromosome hasn't fitness big enough for best chromosome group
+        # or it is already in the group?
+        if (self._currentBestSize == length_best and chromosomes[bestChromosomes[self._currentBestSize - 1]].fitness >=
+            chromosomes[chromosomeIndex].fitness) or bestFlags[chromosomeIndex]:
+            return
+
+        # find place for new chromosome
+        j = self._currentBestSize
+        for i in range(j, -1, -1):
+            j = i
+            pos = bestChromosomes[i - 1]
+            # group is not full?
+            if i < length_best:
+                # position of new chromosomes is found?
+                if chromosomes[pos].fitness > chromosomes[chromosomeIndex].fitness:
+                    break
+
+                # move chromosomes to make room for new
+                bestChromosomes[i] = pos
+            else:
+                # group is full remove worst chromosomes in the group
+                bestFlags[pos] = False
+
+        # store chromosome in best chromosome group
+        bestChromosomes[j] = chromosomeIndex
+        bestFlags[chromosomeIndex] = True
+
+        # increase current size if it has not reached the limit yet
+        if self._currentBestSize < length_best:
+            self._currentBestSize += 1
+
+    # Returns TRUE if chromosome belongs to best chromosome group
+    def isInBest(self, chromosomeIndex) -> bool:
+        return self._bestFlags[chromosomeIndex]
+
+    # Clears best chromosome group
+    def clearBest(self):
+        self._bestFlags = len(self._bestFlags) * [False]
+        self._currentBestSize = 0
+
+    # initialize new population with chromosomes randomly built using prototype
+    def initialize(self, population):
+        # addToBest = self.addToBest
+        prototype = self._prototype
+        length_chromosomes = len(population)
+
+        for i in range(0, length_chromosomes):
+            # add new chromosome to population
+            population[i] = prototype.makeNewFromPrototype()
+            # addToBest(i)
+
+    def selection(self, population):
+        length_chromosomes = len(population)
+        return (population[randrange(32768) % length_chromosomes],  population[randrange(32768) % length_chromosomes])
+
+    def replacement(self, population, replaceByGeneration) -> []:
+        mutationSize = self._mutationSize
+        numberOfCrossoverPoints = self._numberOfCrossoverPoints
+        crossoverProbability = self._crossoverProbability
+        mutationProbability = self._mutationProbability
+        selection = self.selection
+        isInBest = self.isInBest
+        length_chromosomes = len(population)
+        # produce offspring
+        offspring = replaceByGeneration * [None]
+        for j in range(replaceByGeneration):
+            # selects parent randomly
+            parent = selection(population)
+
+            offspring[j] = parent[0].crossover(parent[1], numberOfCrossoverPoints, crossoverProbability)
+            offspring[j].mutation(mutationSize, mutationProbability)
+
+            # replace chromosomes of current operation with offspring
+            # select chromosome for replacement randomly
+            ci = randrange(32768) % length_chromosomes
+            while isInBest(ci):
+                ci = randrange(32768) % length_chromosomes
+
+            # replace chromosomes
+            population[ci] = offspring[j]
+
+            # try to add new chromosomes in best chromosome group
+            self.addToBest(ci)
+        return offspring
+
+    # Starts and executes algorithm
+    def run(self, maxRepeat=9999, minFitness=0.999):
+        # clear best chromosome group from previous execution
+        self.clearBest()
+        length_chromosomes = len(self._chromosomes)
+
+        self.initialize(self._chromosomes)
+        random.seed(round(time() * 1000))
+
+        # Current generation
+        currentGeneration = 0
+
+        repeat = 0
+        lastBestFit = 0.0
+
+        while 1:
+            best = self.result
+            print("Fitness:", "{:f}\t".format(best.fitness), "Generation:", currentGeneration, end="\r")
+
+            # algorithm has reached criteria?
+            if best.fitness > minFitness:
+                break
+
+            difference = abs(best.fitness - lastBestFit)
+            if difference <= 0.0000001:
+                repeat += 1
+            else:
+                repeat = 0
+
+            if repeat > (maxRepeat / 100):
+                random.seed(round(time() * 1000))
+                self.set_replace_by_generation(self._replaceByGeneration * 3)
+                self._crossoverProbability += 1
+
+            self.replacement(self._chromosomes, self._replaceByGeneration)
+
+            lastBestFit = best.fitness
+            currentGeneration += 1
+
+    def __str__(self):
+        return "Genetic Algorithm"

algorithm/NsgaII.py

@@ -0,0 +1,221 @@
+from model.Schedule import Schedule
+import numpy as np
+import random
+import sys
+from time import time
+
+
+# K.Deb, A.Pratap, S.Agrawal, T.Meyarivan, A fast and elitist multiobjective genetic algorithm: 
+# NSGA-II, IEEE Transactions on Evolutionary Computation 6 (2002) 182–197.
+
+
+# NSGA II
+class NsgaII:
+    def initAlgorithm(self, prototype, numberOfChromosomes=100):
+        # Prototype of chromosomes in population
+        self._prototype = prototype
+
+        # there should be at least 2 chromosomes in population
+        if numberOfChromosomes < 2:
+            numberOfChromosomes = 2
+
+        # Population of chromosomes
+        self._chromosomes = []
+        self._populationSize = numberOfChromosomes
+        self._repeatRatio = .0
+
+    # Initializes genetic algorithm
+    def __init__(self, configuration, numberOfCrossoverPoints=2, mutationSize=2, crossoverProbability=80,
+                 mutationProbability=3):
+        self.initAlgorithm(Schedule(configuration))
+        self._mutationSize = mutationSize
+        self._numberOfCrossoverPoints = numberOfCrossoverPoints
+        self._crossoverProbability = crossoverProbability
+        self._mutationProbability = mutationProbability
+
+    @property
+    # Returns pointer to best chromosomes in population
+    def result(self):
+        return self._chromosomes[0]
+
+    # non-dominated sorting function
+    def nonDominatedSorting(self, totalChromosome):
+        doublePopulationSize = self._populationSize * 2
+        s = doublePopulationSize * [ set() ]
+        n = np.zeros(doublePopulationSize, dtype=int)
+        front = [ set() ]
+
+        for p in range(doublePopulationSize):
+            for q in range(doublePopulationSize):
+                if totalChromosome[p].fitness > totalChromosome[q].fitness:
+                    s[p].add(q)
+                elif totalChromosome[p].fitness < totalChromosome[q].fitness:
+                    n[p] += 1
+
+            if n[p] == 0:
+                front[0].add(p)
+    
+        i = 0
+        while front[i]:
+            Q = set()
+            for p in front[i]:
+                for q in s[p]:
+                    n[q] -= 1
+                    if n[q] == 0:
+                        Q.add(q)
+            i += 1
+            front.append(Q)
+
+        front.pop()
+        return front
+
+    # calculate crowding distance function
+    def calculateCrowdingDistance(self, front, totalChromosome):
+        distance, obj = {}, {}
+        for key in front:
+            distance[key] = 0
+            fitness = totalChromosome[key].fitness
+            if fitness not in obj.values():
+                obj[key] = fitness
+
+        sorted_keys = sorted(obj, key=obj.get)
+        size = len(obj)
+        distance[sorted_keys[0]] = distance[sorted_keys[-1]] = sys.float_info.max
+        
+        if size > 1:
+            diff2 = totalChromosome[sorted_keys[-1]].getDifference(totalChromosome[sorted_keys[0]])
+                
+            for i in range(1, size - 1):
+                diff = totalChromosome[sorted_keys[i + 1]].getDifference(totalChromosome[sorted_keys[i - 1]]) / diff2
+                distance[sorted_keys[i]] += diff
+
+        return distance
+
+    def selection(self, front, totalChromosome):
+        populationSize = self._populationSize
+        calculateCrowdingDistance = self.calculateCrowdingDistance
+        N = 0
+        newPop = []
+        while N < populationSize:
+            for row in front:
+                N += len(row)
+                if N > populationSize:
+                    distance = calculateCrowdingDistance(row, totalChromosome)
+                    sortedCdf = sorted(distance, key=distance.get, reverse=True)
+                    for j in sortedCdf:
+                        if len(newPop) >= populationSize:
+                            break
+                        newPop.append(j)
+                    break
+                newPop.extend(row)
+    
+        return [totalChromosome[n] for n in newPop]
+
+    def replacement(self, population):
+        populationSize = self._populationSize
+        numberOfCrossoverPoints = self._numberOfCrossoverPoints
+        crossoverProbability = self._crossoverProbability
+        offspring = []
+        # generate a random sequence to select the parent chromosome to crossover
+        S = np.arange(populationSize)
+        np.random.shuffle(S)
+
+        halfPopulationSize = populationSize // 2
+        for m in range(halfPopulationSize):
+            parent0 = population[S[2 * m]]
+            parent1 = population[S[2 * m + 1]]
+            child0 = parent0.crossover(parent1, numberOfCrossoverPoints, crossoverProbability)
+            child1 = parent1.crossover(parent0, numberOfCrossoverPoints, crossoverProbability)
+
+            # append child chromosome to offspring list
+            offspring.extend((child0, child1))
+            
+        return offspring
+                
+    # initialize new population with chromosomes randomly built using prototype
+    def initialize(self, population):
+        prototype = self._prototype
+
+        for i in range(len(population)):
+            # add new chromosome to population
+            population[i] = prototype.makeNewFromPrototype()
+
+    def reform(self):
+        random.seed(round(time() * 1000))
+        np.random.seed(int(time()))
+        if self._crossoverProbability < 95:
+            self._crossoverProbability += 1.0
+        elif self._mutationProbability < 30:
+            self._mutationProbability += 1.0
+
+    # Starts and executes algorithm
+    def run(self, maxRepeat=9999, minFitness=0.999):
+        mutationSize = self._mutationSize
+        mutationProbability = self._mutationProbability
+        nonDominatedSorting = self.nonDominatedSorting
+        selection = self.selection
+        populationSize = self._populationSize
+        population = populationSize * [None]
+
+        self.initialize(population)
+        random.seed(round(time() * 1000))
+        np.random.seed(int(time()))
+
+        # Current generation
+        currentGeneration = 0
+
+        repeat = 0
+        lastBestFit = 0.0
+
+        while 1:
+            if currentGeneration > 0:
+                best = self.result
+                print("Fitness:", "{:f}\t".format(best.fitness), "Generation:", currentGeneration, end="\r")
+
+                # algorithm has reached criteria?
+                if best.fitness > minFitness:
+                    break
+
+                difference = abs(best.fitness - lastBestFit)
+                if difference <= 0.0000001:
+                    repeat += 1
+                else:
+                    repeat = 0
+
+                self._repeatRatio = repeat * 100 / maxRepeat
+                if repeat > (maxRepeat / 100):
+                    self.reform()
+
+            # crossover
+            offspring = self.replacement(population)
+
+            # mutation
+            for child in offspring:
+                child.mutation(mutationSize, mutationProbability)
+
+            totalChromosome = population + offspring
+
+            # non-dominated sorting
+            front = nonDominatedSorting(totalChromosome)
+            if len(front) == 0:
+                break
+
+            # selection
+            population = selection(front, totalChromosome)
+            self._populationSize = populationSize = len(population)
+
+            # comparison
+            if currentGeneration == 0:
+                self._chromosomes = population
+            else:
+                totalChromosome = population + self._chromosomes
+                newBestFront = nonDominatedSorting(totalChromosome)
+                if len(newBestFront) == 0:
+                    break
+                self._chromosomes = selection(newBestFront, totalChromosome)
+                lastBestFit = best.fitness
+
+            currentGeneration += 1
+            
+    def __str__(self):
+        return "NSGA II"

model/Configuration.py

@@ -0,0 +1,236 @@
+import codecs
+import json
+
+from .Professor import Professor
+from .StudentsGroup import StudentsGroup
+from .Course import Course
+from .Room import Room
+from .CourseClass import CourseClass
+
+
+# Reads configuration file and stores parsed objects
+class Configuration:
+
+    # Initialize data
+    def __init__(self):
+        # Indicate that configuration is not parsed yet
+        self._isEmpty = True
+        # parsed professors
+        self._professors = {}
+        # parsed student groups
+        self._studentGroups = {}
+        # parsed courses
+        self._courses = {}
+        # parsed rooms
+        self._rooms = {}
+        # parsed classes
+        self._courseClasses = []
+
+    # Returns professor with specified ID
+    # If there is no professor with such ID method returns NULL
+    def getProfessorById(self, id) -> Professor:
+        if id in self._professors:
+            return self._professors[id]
+        return None
+
+    @property
+    # Returns number of parsed professors
+    def numberOfProfessors(self) -> int:
+        return len(self._professors)
+
+    # Returns student group with specified ID
+    # If there is no student group with such ID method returns NULL
+    def getStudentsGroupById(self, id) -> StudentsGroup:
+        if id in self._studentGroups:
+            return self._studentGroups[id]
+        return None
+
+    @property
+    # Returns number of parsed student groups
+    def numberOfStudentGroups(self) -> int:
+        return len(self._studentGroups)
+
+    # Returns course with specified ID
+    # If there is no course with such ID method returns NULL
+    def getCourseById(self, id) -> Course:
+        if id in self._courses:
+            return self._courses[id]
+        return None
+
+    @property
+    def numberOfCourses(self) -> int:
+        return len(self._courses)
+
+    # Returns room with specified ID
+    # If there is no room with such ID method returns NULL
+    def getRoomById(self, id) -> Room:
+        if id in self._rooms:
+            return self._rooms[id]
+        return None
+
+    @property
+    # Returns number of parsed rooms
+    def numberOfRooms(self) -> int:
+        return len(self._rooms)
+
+    @property
+    # Returns reference to list of parsed classes
+    def courseClasses(self) -> []:
+        return self._courseClasses
+
+    @property
+    # Returns number of parsed classes
+    def numberOfCourseClasses(self) -> int:
+        return len(self._courseClasses)
+
+    @property
+    # Returns TRUE if configuration is not parsed yet
+    def isEmpty(self) -> bool:
+        return self._isEmpty
+
+    # Reads professor's data from config file, makes object and returns
+    # Returns NULL if method cannot parse configuration data
+    @staticmethod
+    def __parseProfessor(dictConfig):
+        id = 0
+        name = ''
+
+        for key in dictConfig:
+            if key == 'id':
+                id = dictConfig[key]
+            elif key == 'name':
+                name = dictConfig[key]
+
+        if id == 0 or name == '':
+            return None
+        return Professor(id, name)
+
+    # Reads StudentsGroup's data from config file, makes object and returns
+    # Returns None if method cannot parse configuration data
+    @staticmethod
+    def __parseStudentsGroup(dictConfig):
+        id = 0
+        # name = ''
+        size = 0
+
+        for key in dictConfig:
+            if key == 'id':
+                id = dictConfig[key]
+            # elif key == 'name':
+            #     name = dictConfig[key]
+            elif key == 'size':
+                size = dictConfig[key]
+
+        if id == 0:
+            return None
+        return StudentsGroup(id, size)
+
+    # Reads course's data from config file, makes object and returns
+    # Returns None if method dictConfig parse configuration data
+    @staticmethod
+    def __parseCourse(dictConfig):
+        id = 0
+        name = ''
+
+        for key in dictConfig:
+            if key == 'id':
+                id = dictConfig[key]
+            elif key == 'name':
+                name = dictConfig[key]
+
+        if id == 0:
+            return None
+        return Course(id, name)
+
+    # Reads rooms's data from config file, makes object and returns
+    # Returns None if method cannot parse configuration data
+    @staticmethod
+    def __parseRoom(dictConfig):
+        lab = False
+        name = ''
+        size = 0
+
+        for key in dictConfig:
+            if key == 'lab':
+                lab = dictConfig[key]
+            elif key == 'name':
+                name = dictConfig[key]
+            elif key == 'size':
+                size = dictConfig[key]
+
+        if size == 0 or name == '':
+            return None
+        return Room(name, lab, size)
+
+    # Reads class' data from config file, makes object and returns pointer
+    # Returns None if method cannot parse configuration data
+    def __parseCourseClass(self, dictConfig):
+        pid = 0
+        cid = 0
+        dur = 1
+        lab = False
+        group_list = []
+
+        for key in dictConfig:
+            if key == 'professor':
+                pid = dictConfig[key]
+            elif key == 'course':
+                cid = dictConfig[key]
+            elif key == 'lab':
+                lab = dictConfig[key]
+            elif key == 'duration':
+                dur = dictConfig[key]
+            elif key == 'group' or key == 'groups':
+                groups = dictConfig[key]
+                if isinstance(groups, list):
+                    for grp in groups:
+                        g = self.getStudentsGroupById(grp)
+                        if g:
+                            group_list.append(g)
+                else:
+                    g = self.getStudentsGroupById(groups)
+                    if g:
+                        group_list.append(g)
+
+        # get professor who teaches class and course to which this class belongs
+        p = self.getProfessorById(pid)
+        c = self.getCourseById(cid)
+
+        # does professor and class exists
+        if not c or not p:
+            return None
+
+        # make object and return
+        return CourseClass(p, c, lab, dur, group_list)
+
+    # parse file and store parsed object
+    def parseFile(self, fileName):
+        # clear previously parsed objects
+        self._professors = {}
+        self._studentGroups = {}
+        self._courses = {}
+        self._rooms = {}
+        self._courseClasses = []
+        Room.restartIDs()
+        CourseClass.restartIDs()
+        with codecs.open(fileName, "r", "utf-8") as f:
+            # read file into a string and deserialize JSON to a type
+            data = json.load(f)
+        for dictConfig in data:
+            for key in dictConfig:
+                if key == 'prof':
+                    prof = self.__parseProfessor(dictConfig[key])
+                    self._professors[prof.Id] = prof
+                elif key == 'course':
+                    course = self.__parseCourse(dictConfig[key])
+                    self._courses[course.Id] = course
+                elif key == 'room':
+                    room = self.__parseRoom(dictConfig[key])
+                    self._rooms[room.Id] = room
+                elif key == 'group':
+                    group = self.__parseStudentsGroup(dictConfig[key])
+                    self._studentGroups[group.Id] = group
+                elif key == 'class':
+                    courseClass = self.__parseCourseClass(dictConfig[key])
+                    self._courseClasses.append(courseClass)
+        self._isEmpty = False

model/Constant.py

@@ -0,0 +1,5 @@
+class Constant:
+    # Number of days in week
+    DAYS_NUM = 6
+    # Number of working hours per day
+    DAY_HOURS = 11

model/Course.py

@@ -0,0 +1,11 @@
+# Stores data about course
+class Course:
+    # Initializes course
+    def __init__(self, id, name):
+        # Returns course ID
+        self.Id = id                                                                  
+        # Returns course name
+        self.Name = name
+
+
+        

model/CourseClass.py

@@ -0,0 +1,53 @@
+class CourseClass:
+    # ID counter used to assign IDs automatically
+    _next_class_id = 0
+
+    # Initializes class object
+    def __init__(self, professor, course, requires_lab, duration, groups):
+        self.Id = CourseClass._next_class_id
+        CourseClass._next_class_id += 1
+        # Return pointer to professor who teaches
+        self.Professor = professor
+        # Return pointer to course to which class belongs
+        self.Course = course
+        # Returns number of seats (students) required in room
+        self.NumberOfSeats = 0
+        # Returns TRUE if class requires computers in room.
+        self.LabRequired = requires_lab
+        # Returns duration of class in hours
+        self.Duration = duration
+        # Returns reference to list of student groups who attend class
+        self.Groups = set(groups)
+        # bind professor to class
+        self.Professor.addCourseClass(self)
+
+        # bind student groups to class
+        for grp in self.Groups:  # self.groups:
+            grp.addClass(self)
+            self.NumberOfSeats += grp.NumberOfStudents
+
+    # Returns TRUE if another class has one or overlapping student groups.
+    def groupsOverlap(self, c):
+        return len(self.Groups & c.Groups) > 0
+
+    # Returns TRUE if another class has same professor.
+    def professorOverlaps(self, c):
+        return self.Professor == c.Professor
+
+    def __hash__(self):
+        return hash(self.Id)
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        return hash(self) == hash(other)
+
+    def __ne__(self, other):
+        # Not strictly necessary, but to avoid having both x==y and x!=y
+        # True at the same time
+        return not (self == other)
+
+    # Restarts ID assigments
+    @staticmethod
+    def restartIDs() -> None:
+        CourseClass._next_class_id = 0

model/Criteria.py

@@ -0,0 +1,49 @@
+from .Constant import Constant
+
+
+# Reads configuration file and stores parsed objects
+class Criteria:
+    weights = [0, 0.5, 0.5, 0, 0]
+
+    # check for room overlapping of classes
+    @staticmethod
+    def isRoomOverlapped(slots, reservation, dur):
+        reservation_index = hash(reservation)
+        cls = slots[reservation_index: reservation_index + dur]
+        return any(True for slot in cls if len(slot) > 1)
+
+    # does current room have enough seats
+    @staticmethod
+    def isSeatEnough(r, cc):
+        return r.NumberOfSeats >= cc.NumberOfSeats
+
+    # does current room have computers if they are required
+    @staticmethod
+    def isComputerEnough(r, cc):
+        # return (not cc.LabRequired) or (cc.LabRequired and r.Lab)
+        return cc.LabRequired == r.Lab
+
+    # check overlapping of classes for professors and student groups (size of course)
+    @staticmethod
+    def isOverlappedProfStudentGrp(slots, cc, numberOfRooms, timeId):
+        po = go = False
+
+        dur = cc.Duration
+        for i in range(numberOfRooms, 0, -1):
+            # for each hour of class
+            for j in range(timeId, timeId + dur):
+                cl = slots[j]
+                for cc1 in cl:
+                    if cc != cc1:
+                        # professor overlaps?
+                        if not po and cc.professorOverlaps(cc1):
+                            po = True
+                        # student group enough?
+                        if not go and cc.groupsOverlap(cc1):
+                            go = True
+                        # both type of overlapping? no need to check more
+                        if po and go:
+                            return po, go
+
+            timeId += Constant.DAY_HOURS
+        return po, go

model/Professor.py

@@ -0,0 +1,25 @@
+# Stores data about professor
+class Professor:
+    # Initializes professor data
+    def __init__(self, id, name):
+        self.Id = id
+        self.Name = name
+        self.CourseClasses = []
+
+    # Bind professor to course
+    def addCourseClass(self, courseClass):
+        self.CourseClasses.append(courseClass)
+
+    def __hash__(self):
+        return hash(self.Id)
+
+    # Compares ID's of two objects which represent professors
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        return hash(self) == hash(other)
+
+    def __ne__(self, other):
+        # Not strictly necessary, but to avoid having both x==y and x!=y
+        # True at the same time
+        return not (self == other)

model/Reservation.py

@@ -0,0 +1,57 @@
+from .Constant import Constant
+
+
+class Reservation:
+    NR = -1
+    _reservationPool = {}
+
+
+    def __init__(self, day: int, time: int, room: int):
+        self.Day = day
+        self.Time = time
+        self.Room = room
+
+    @staticmethod
+    def parse(hashCode):
+        reservation = Reservation._reservationPool.get(hashCode)
+        if reservation is None:
+            day = hashCode // (Constant.DAY_HOURS * Reservation.NR)
+            hashCode2 = hashCode - (day * Constant.DAY_HOURS * Reservation.NR)
+            room = hashCode2 // Constant.DAY_HOURS
+            time = hashCode2 % Constant.DAY_HOURS
+            reservation = Reservation(day, time, room)
+            Reservation._reservationPool[hashCode] = reservation
+        return reservation
+
+    @staticmethod
+    def getHashCode(day: int, time: int, room: int) -> int:
+            return day * Reservation.NR * Constant.DAY_HOURS + room * Constant.DAY_HOURS + time
+
+    @staticmethod
+    def getReservation(nr: int, day: int, time: int, room: int):
+        if nr != Reservation.NR and nr > 0:
+            Reservation.NR = nr
+            Reservation._reservationPool.clear()
+
+        hashCode = Reservation.getHashCode(day, time, room)
+        reservation = Reservation.parse(hashCode)
+
+        if reservation is None:
+            reservation = Reservation(day, time, room)
+            Reservation._reservationPool[hashCode] = reservation
+        return reservation
+
+    def __hash__(self) -> int:
+        return Reservation.getHashCode(self.Day, self.Time, self.Room)
+
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        return hash(self) == hash(other)
+            
+    def __ne__(self, other):
+        return not self.__eq__(other)
+        
+    def __str__(self):
+        return "Day: " + str(self.Day) + ", " + "Room: " + str(self.Room) + ", Time: " + str(self.Time)

model/Room.py

@@ -0,0 +1,35 @@
+# Stores data about classroom
+class Room:
+    # ID counter used to assign IDs automatically
+    _next_room_id = 0
+
+    # Initializes room data and assign ID to room
+    def __init__(self, name, lab, number_of_seats):
+        # Returns room ID - automatically assigned
+        self.Id = Room._next_room_id
+        Room._next_room_id += 1
+        # Returns name        
+        self.Name = name
+        # Returns TRUE if room has computers otherwise it returns FALSE
+        self.Lab = lab
+        # Returns number of seats in room
+        self.NumberOfSeats = number_of_seats
+
+    def __hash__(self):
+        return hash(self.Id)
+
+    # Compares ID's of two objects which represent rooms
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        return hash(self) == hash(other)
+
+    def __ne__(self, other):
+        # Not strictly necessary, but to avoid having both x==y and x!=y
+        # True at the same time
+        return not (self == other)
+
+    # Restarts ID assigments
+    @staticmethod
+    def restartIDs() -> None:
+        Room._next_room_id = 0

model/Schedule.py

@@ -0,0 +1,438 @@
+from .Constant import Constant
+from .CourseClass import CourseClass
+from .Reservation import Reservation
+from .Criteria import Criteria
+from collections import deque
+from random import randrange
+
+import numpy as np
+
+# Schedule chromosome
+class Schedule:
+    # Initializes chromosomes with configuration block (setup of chromosome)
+    def __init__(self, configuration):
+        self._configuration = configuration
+        # Fitness value of chromosome
+        self._fitness = 0
+
+        # Time-space slots, one entry represent one hour in one classroom
+        slots_length = Constant.DAYS_NUM * Constant.DAY_HOURS * self._configuration.numberOfRooms
+        self._slots = [[] for _ in range(slots_length)]
+
+        # Class table for chromosome
+        # Used to determine first time-space slot used by class
+        self._classes = {}
+
+        # Flags of class requirements satisfaction
+        self._criteria = np.zeros(self._configuration.numberOfCourseClasses * len(Criteria.weights), dtype=bool)
+
+        self._diversity = 0.0
+        self._rank = 0
+
+        self._convertedObjectives = []
+        self._objectives = []
+
+    def copy(self, c, setup_only):
+        if not setup_only:
+            self._configuration = c.configuration
+            # copy code
+            self._slots, self._classes = [row[:] for row in c.slots], {key: value for key, value in c.classes.items()}
+
+            # copy flags of class requirements
+            self._criteria = c.criteria[:]
+
+            # copy fitness
+            self._fitness = c.fitness
+            return self
+
+        return Schedule(c.configuration)
+
+    # Makes new chromosome with same setup but with randomly chosen code
+    def makeNewFromPrototype(self, positions = None):
+        # make new chromosome, copy chromosome setup
+        new_chromosome = self.copy(self, True)
+        new_chromosome_slots, new_chromosome_classes = new_chromosome._slots, new_chromosome._classes
+
+        # place classes at random position
+        classes = self._configuration.courseClasses
+        nr = self._configuration.numberOfRooms
+        DAYS_NUM, DAY_HOURS = Constant.DAYS_NUM, Constant.DAY_HOURS
+        for c in classes:
+            # determine random position of class
+            dur = c.Duration
+
+            day = randrange(DAYS_NUM)
+            room = randrange(nr)
+            time = randrange(DAY_HOURS - dur)
+            reservation = Reservation.getReservation(nr, day, time, room)
+
+            if positions is not None:
+                positions.append(day)
+                positions.append(room)
+                positions.append(time)
+            reservation_index = hash(reservation)
+
+            # fill time-space slots, for each hour of class
+            for i in range(dur - 1, -1, -1):
+                new_chromosome_slots[reservation_index + i].append(c)
+
+            # insert in class table of chromosome
+            new_chromosome_classes[c] = reservation_index
+
+        new_chromosome.calculateFitness()
+        return new_chromosome
+
+    # Performs crossover operation using to chromosomes and returns pointer to offspring
+    def crossover(self, parent, numberOfCrossoverPoints, crossoverProbability):
+        # check probability of crossover operation
+        if randrange(100) > crossoverProbability:
+            # no crossover, just copy first parent
+            return self.copy(self, False)
+
+        # new chromosome object, copy chromosome setup
+        n = self.copy(self, True)
+        n_classes, n_slots = n._classes, n._slots
+
+        classes = self._classes
+        course_classes = tuple(classes.keys())
+        parent_classes = parent.classes
+        parent_course_classes = tuple(parent.classes.keys())
+
+        # number of classes
+        size = len(classes)
+
+        cp = size * [False]
+
+        # determine crossover point (randomly)
+        for i in range(numberOfCrossoverPoints, 0, -1):
+            check_point = False
+            while not check_point:
+                p = randrange(size)
+                if not cp[p]:
+                    cp[p] = check_point = True
+
+        # make new code by combining parent codes
+        first = randrange(2) == 0
+        
+        for i in range(size):
+            if first:
+                course_class = course_classes[i]
+                dur = course_class.Duration
+                reservation_index = classes[course_class]
+                # insert class from first parent into new chromosome's class table
+                n_classes[course_class] = reservation_index
+                # all time-space slots of class are copied
+                for j in range(dur - 1, -1, -1):
+                    n_slots[reservation_index + j].append(course_class)
+            else:
+                course_class = parent_course_classes[i]
+                dur = course_class.Duration
+                reservation_index = parent_classes[course_class]
+                # insert class from second parent into new chromosome's class table
+                n_classes[course_class] = reservation_index
+                # all time-space slots of class are copied
+                for j in range(dur - 1, -1, -1):
+                    n_slots[reservation_index + j].append(course_class)
+
+            # crossover point
+            if cp[i]:
+                # change source chromosome
+                first = not first
+
+        n.calculateFitness()
+
+        # return smart pointer to offspring
+        return n
+        
+    # Performs crossover operation using to chromosomes and returns pointer to offspring
+    def crossovers(self, parent, r1, r2, r3, etaCross, crossoverProbability):
+        # number of classes
+        size = len(self._classes)
+        jrand = randrange(size)
+        
+        nr = self._configuration.numberOfRooms
+        DAY_HOURS, DAYS_NUM = Constant.DAY_HOURS, Constant.DAYS_NUM
+
+        # make new chromosome, copy chromosome setup
+        new_chromosome = self.copy(self, True)
+        new_chromosome_slots, new_chromosome_classes = new_chromosome._slots, new_chromosome._classes
+        classes = self._classes
+        course_classes = tuple(classes.keys())
+        parent_classes = parent.classes
+        parent_course_classes = tuple(parent.classes.keys())
+        for i in range(size):
+            if randrange(100) > crossoverProbability or i == jrand:
+                course_class = course_classes[i]
+                reservation1, reservation2 = Reservation.parse(r1.classes[course_class]), Reservation.parse(r2.classes[course_class])
+                reservation3 = Reservation.parse(r3.classes[course_class])
+                
+                dur = course_class.Duration
+                day = int(reservation3.Day + etaCross * (reservation1.Day - reservation2.Day))
+                if day < 0:
+                    day = 0
+                elif day >= DAYS_NUM:
+                    day = DAYS_NUM - 1
+
+                room = int(reservation3.Room + etaCross * (reservation1.Room - reservation2.Room))
+                if room < 0:
+                    room = 0
+                elif room >= nr:
+                    room = nr - 1
+
+                time = int(reservation3.Time + etaCross * (reservation1.Time - reservation2.Time))
+                if time < 0:
+                    time = 0
+                elif time >= (DAY_HOURS - dur):
+                    time = DAY_HOURS - 1 - dur
+
+                reservation = Reservation.getReservation(nr, day, time, room)
+                reservation_index = hash(reservation)
+
+                # fill time-space slots, for each hour of class
+                for j in range(dur - 1, -1, -1):
+                    new_chromosome_slots[reservation_index + j].append(course_class)
+
+                # insert in class table of chromosome
+                new_chromosome_classes[course_class] = reservation_index
+            else:
+                course_class = parent_course_classes[i]
+                dur = course_class.Duration
+                reservation = parent_classes[course_class]
+                reservation_index = hash(reservation)
+                
+                # all time-space slots of class are copied
+                for j in range(dur - 1, -1, -1):
+                    new_chromosome_slots[reservation_index + j].append(course_class)
+                
+                # insert class from second parent into new chromosome's class table
+                new_chromosome_classes[course_class] = reservation_index
+
+        new_chromosome.calculateFitness()
+
+        # return smart pointer to offspring
+        return new_chromosome
+
+    def repair(self, cc1: CourseClass, reservation1_index: int, reservation2: Reservation):
+        nr = self._configuration.numberOfRooms
+        DAY_HOURS, DAYS_NUM = Constant.DAY_HOURS, Constant.DAYS_NUM
+        slots = self._slots
+        dur = cc1.Duration
+
+        for j in range(dur):
+            # remove class hour from current time-space slot
+            cl = slots[reservation1_index + j]
+            while cc1 in cl:
+                cl.remove(cc1)
+
+        # determine position of class randomly
+        if reservation2 is None:
+            day = randrange(DAYS_NUM)
+            room = randrange(nr)
+            time = randrange(DAY_HOURS - dur)
+            reservation2 = Reservation.getReservation(nr, day, time, room)
+
+        reservation2_index = hash(reservation2)
+        for j in range(dur):
+            # move class hour to new time-space slot
+            slots[reservation2_index + j].append(cc1)
+
+        # change entry of class table to point to new time-space slots
+        self._classes[cc1] = reservation2_index
+
+    # Performs mutation on chromosome
+    def mutation(self, mutationSize, mutationProbability):
+        # check probability of mutation operation
+        if randrange(100) > mutationProbability:
+            return
+
+        classes = self._classes
+        # number of classes
+        numberOfClasses = len(classes)
+        course_classes = tuple(classes.keys())
+        configuration = self._configuration
+        nr = configuration.numberOfRooms
+
+        # move selected number of classes at random position
+        for i in range(mutationSize, 0, -1):
+            # select ranom chromosome for movement
+            mpos = randrange(numberOfClasses)
+
+            # current time-space slot used by class
+            cc1 = course_classes[mpos]
+            reservation1_index = classes[cc1]
+
+            self.repair(cc1, reservation1_index, None)
+
+        self.calculateFitness()
+
+    # Calculates fitness value of chromosome
+    def calculateFitness(self):
+        
+        # increment value when criteria violation occurs
+        self._objectives = np.zeros(len(Criteria.weights))
+
+        # chromosome's score
+        score = 0
+
+        criteria, configuration = self._criteria, self._configuration
+        items, slots = self._classes.items(), self._slots
+        numberOfRooms = configuration.numberOfRooms
+        DAY_HOURS, DAYS_NUM = Constant.DAY_HOURS, Constant.DAYS_NUM
+        daySize = DAY_HOURS * numberOfRooms
+
+        ci = 0
+        getRoomById = configuration.getRoomById
+
+        # check criteria and calculate scores for each class in schedule
+        for cc, reservation_index in items:
+            reservation = Reservation.parse(reservation_index)
+
+            # coordinate of time-space slot
+            day, time, room = reservation.Day, reservation.Time, reservation.Room
+
+            dur = cc.Duration
+
+            ro = Criteria.isRoomOverlapped(slots, reservation, dur)
+
+            # on room overlapping
+            criteria[ci + 0] = not ro
+
+            r = getRoomById(room)
+
+            # does current room have enough seats
+            criteria[ci + 1] = Criteria.isSeatEnough(r, cc)
+
+            # does current room have computers if they are required
+            criteria[ci + 2] = Criteria.isComputerEnough(r, cc)
+
+            # check overlapping of classes for professors
+            timeId = day * daySize + time
+            po, go = Criteria.isOverlappedProfStudentGrp(slots, cc, numberOfRooms, timeId)
+
+            # professors have no overlapping classes?
+            criteria[ci + 3] = not po
+
+            # student groups has no overlapping classes?
+            criteria[ci + 4] = not go
+
+            for i in range(len(self._objectives)):
+                if criteria[ci + i]:
+                    score += 1
+                else:
+                    score += Criteria.weights[i]
+                    self._objectives[i] += 1 if Criteria.weights[i] > 0 else 2
+
+            ci += len(Criteria.weights)
+
+        # calculate fitness value based on score
+        self._fitness = score / len(criteria)
+
+    def getDifference(self, other):
+        return (self._criteria ^ other.criteria).sum()
+
+
+    def extractPositions(self, positions):
+        i = 0
+        items = self._classes.items()
+        for cc, reservation_index in items:
+            reservation = Reservation.parse(reservation_index)
+
+            positions[i] = reservation.Day
+            i += 1
+            positions[i] = reservation.Room
+            i += 1
+            positions[i] = reservation.Time
+            i += 1
+
+
+    def updatePositions(self, positions):
+        DAYS_NUM, DAY_HOURS = Constant.DAYS_NUM, Constant.DAY_HOURS
+        nr = self._configuration.numberOfRooms
+        i = 0
+        items = self._classes.items()
+        for cc, reservation1_index in items:
+            dur = cc.Duration
+            day = abs(int(positions[i]) % DAYS_NUM)
+            room = abs(int(positions[i + 1]) % nr)
+            time = abs(int(positions[i + 2]) % (DAY_HOURS - dur))
+
+            reservation2 = Reservation.getReservation(nr, day, time, room)
+            self.repair(cc, reservation1_index, reservation2)
+
+            positions[i] = reservation2.Day
+            i += 1
+            
+            positions[i] = reservation2.Room
+            i += 1
+            
+            positions[i] = reservation2.Time
+            i += 1
+            
+
+        self.calculateFitness()
+
+
+    # Returns fitness value of chromosome
+    @property
+    def fitness(self):
+        return self._fitness
+
+    @property
+    def configuration(self):
+        return self._configuration
+
+    @property
+    # Returns reference to table of classes
+    def classes(self):
+        return self._classes
+
+    @property
+    # Returns array of flags of class requirements satisfaction
+    def criteria(self):
+        return self._criteria
+
+    @property
+    # Return reference to array of time-space slots
+    def slots(self):
+        return self._slots
+
+    @property
+    def diversity(self):
+        return self._diversity
+
+    @diversity.setter
+    def diversity(self, new_diversity):
+        self._diversity = new_diversity
+        
+    @property
+    def rank(self):
+        return self._rank
+
+    @rank.setter
+    def rank(self, new_rank):
+        self._rank = new_rank
+
+    @property
+    def convertedObjectives(self):
+        return self._convertedObjectives
+
+    @property
+    def objectives(self):
+        return self._objectives
+
+    def resizeConvertedObjectives(self, numObj):
+        self._convertedObjectives = numObj * [0]
+
+    def clone(self):
+        return self.copy(self, False)
+
+    def dominates(self, other):
+        better = False
+        for f, obj in enumerate(self.objectives):
+            if obj > other.objectives[f]:
+                return False
+
+            if obj < other.objectives[f]:
+                better = True
+
+        return better

model/StudentsGroup.py

@@ -0,0 +1,26 @@
+# Stores data about student group
+class StudentsGroup:
+    # Initializes student group data
+    def __init__(self, id, numberOfStudents):
+        self.Id = id
+        # self.Name = name
+        self.NumberOfStudents = numberOfStudents
+        self.CourseClasses = []
+
+    # Bind group to class
+    def addClass(self, course_class):
+        self.CourseClasses.append(course_class)
+
+    def __hash__(self):
+        return hash(self.Id)
+
+    # Compares ID's of two objects which represent student groups
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        return hash(self) == hash(other)
+
+    def __ne__(self, other):
+        # Not strictly necessary, but to avoid having both x==y and x!=y
+        # True at the same time
+        return not (self == other)

processing data/GaSchedule3.json

@@ -0,0 +1 @@
+[{"prof": {"id": 174, "name": "Dao Tran Hoang Chau"}}, {"course": {"id": 1, "name": "Functional Programming"}}, {"group": {"id": 1, "size": 10}}, {"class": {"professor": 174, "course": 1, "duration": 3, "group": 1, "lab": false}}, {"prof": {"id": 119, "name": "Tran Manh Ha"}}, {"course": {"id": 2, "name": "Operating Systems"}}, {"group": {"id": 2, "size": 90}}, {"class": {"professor": 119, "course": 2, "duration": 3, "group": 2, "lab": false}}, {"group": {"id": 3, "size": 30}}, {"class": {"professor": 119, "course": 2, "duration": 4, "group": 3, "lab": true}}, {"prof": {"id": 213, "name": "Nguyen Tien Dung"}}, {"group": {"id": 4, "size": 30}}, {"class": {"professor": 213, "course": 2, "duration": 4, "group": 4, "lab": true}}, {"group": {"id": 5, "size": 30}}, {"class": {"professor": 213, "course": 2, "duration": 4, "group": 5, "lab": true}}, {"prof": {"id": 74, "name": "Nguyen Van Sinh"}}, {"course": {"id": 3, "name": "IT Project Management"}}, {"group": {"id": 6, "size": 35}}, {"class": {"professor": 74, "course": 3, "duration": 3, "group": 6, "lab": false}}, {"group": {"id": 7, "size": 35}}, {"class": {"professor": 74, "course": 3, "duration": 4, "group": 7, "lab": true}}, {"prof": {"id": 84, "name": "Le Hai Duong"}}, {"course": {"id": 4, "name": "Introduction to Computing"}}, {"group": {"id": 8, "size": 35}}, {"class": {"professor": 84, "course": 4, "duration": 3, "group": 8, "lab": false}}, {"prof": {"id": 19, "name": "Huynh Kha Tu"}}, {"course": {"id": 5, "name": "Digital Logic Design"}}, {"group": {"id": 9, "size": 90}}, {"class": {"professor": 19, "course": 5, "duration": 3, "group": 9, "lab": false}}, {"prof": {"id": 182, "name": "Tran Thanh Tung"}}, {"course": {"id": 6, "name": "Object-Oriented Programming"}}, {"group": {"id": 10, "size": 90}}, {"class": {"professor": 182, "course": 6, "duration": 3, "group": 10, "lab": false}}, {"group": {"id": 11, "size": 30}}, {"class": {"professor": 213, "course": 6, "duration": 4, "group": 11, "lab": true}}, {"group": {"id": 12, "size": 30}}, {"class": {"professor": 213, "course": 6, "duration": 4, "group": 12, "lab": true}}, {"group": {"id": 13, "size": 30}}, {"class": {"professor": 213, "course": 6, "duration": 4, "group": 13, "lab": true}}, {"prof": {"id": 349, "name": "Nguyen Thi Thanh Sang"}}, {"course": {"id": 7, "name": "Software Engineering"}}, {"group": {"id": 14, "size": 70}}, {"class": {"professor": 349, "course": 7, "duration": 3, "group": 14, "lab": false}}, {"group": {"id": 15, "size": 35}}, {"class": {"professor": 349, "course": 7, "duration": 4, "group": 15, "lab": true}}, {"group": {"id": 16, "size": 35}}, {"class": {"professor": 349, "course": 7, "duration": 4, "group": 16, "lab": true}}, {"prof": {"id": 62, "name": "Vo Thi Luu Phuong"}}, {"course": {"id": 8, "name": "Computer Networks"}}, {"group": {"id": 17, "size": 70}}, {"class": {"professor": 62, "course": 8, "duration": 3, "group": 17, "lab": false}}, {"group": {"id": 18, "size": 35}}, {"class": {"professor": 62, "course": 8, "duration": 4, "group": 18, "lab": true}}, {"group": {"id": 19, "size": 35}}, {"class": {"professor": 62, "course": 8, "duration": 4, "group": 19, "lab": true}}, {"prof": {"id": 60, "name": "Ly Tu Nga"}}, {"group": {"id": 20, "size": 20}}, {"class": {"professor": 60, "course": 8, "duration": 4, "group": 20, "lab": true}}, {"course": {"id": 9, "name": "Web Application Development"}}, {"group": {"id": 21, "size": 15}}, {"class": {"professor": 74, "course": 9, "duration": 3, "group": 21, "lab": false}}, {"group": {"id": 22, "size": 15}}, {"class": {"professor": 74, "course": 9, "duration": 4, "group": 22, "lab": true}}, {"group": {"id": 23, "size": 20}}, {"class": {"professor": 213, "course": 9, "duration": 4, "group": 23, "lab": true}}, {"prof": {"id": 36, "name": "Le Thanh Son"}}, {"course": {"id": 10, "name": "Net-Centric Programming"}}, {"group": {"id": 24, "size": 17}}, {"class": {"professor": 36, "course": 10, "duration": 3, "group": 24, "lab": false}}, {"group": {"id": 25, "size": 17}}, {"class": {"professor": 36, "course": 10, "duration": 4, "group": 25, "lab": true}}, {"course": {"id": 11, "name": "Digital Logic Design Laboratory"}}, {"group": {"id": 26, "size": 15}}, {"class": {"professor": 60, "course": 11, "duration": 4, "group": 26, "lab": false}}, {"group": {"id": 27, "size": 15}}, {"class": {"professor": 60, "course": 11, "duration": 4, "group": 27, "lab": false}}, {"group": {"id": 28, "size": 15}}, {"class": {"professor": 60, "course": 11, "duration": 4, "group": 28, "lab": false}}, {"group": {"id": 29, "size": 15}}, {"class": {"professor": 60, "course": 11, "duration": 4, "group": 29, "lab": false}}, {"group": {"id": 30, "size": 15}}, {"class": {"professor": 60, "course": 11, "duration": 4, "group": 30, "lab": false}}, {"course": {"id": 12, "name": "Entrepreneurship"}}, {"group": {"id": 31, "size": 80}}, {"class": {"professor": 174, "course": 12, "duration": 3, "group": 31, "lab": false}}, {"course": {"id": 13, "name": "System & Network Administration"}}, {"group": {"id": 32, "size": 35}}, {"class": {"professor": 36, "course": 13, "duration": 3, "group": 32, "lab": false}}, {"group": {"id": 33, "size": 35}}, {"class": {"professor": 36, "course": 13, "duration": 4, "group": 33, "lab": true}}, {"prof": {"id": 184, "name": "Ha Viet Uyen Synh"}}, {"course": {"id": 14, "name": "Theoretical Models in Computing"}}, {"group": {"id": 34, "size": 80}}, {"class": {"professor": 184, "course": 14, "duration": 3, "group": 34, "lab": false}}, {"group": {"id": 35, "size": 26}}, {"class": {"professor": 184, "course": 14, "duration": 4, "group": 35, "lab": true}}, {"group": {"id": 36, "size": 28}}, {"class": {"professor": 184, "course": 14, "duration": 4, "group": 36, "lab": true}}, {"course": {"id": 15, "name": "Discrete Mathematics"}}, {"group": {"id": 37, "size": 80}}, {"class": {"professor": 74, "course": 15, "duration": 3, "group": 37, "lab": false}}, {"room": {"name": "A1.309", "lab": false, "size": 90}}, {"room": {"name": "L107", "lab": false, "size": 40}}, {"room": {"name": "LA1.605", "lab": true, "size": 35}}, {"room": {"name": "LA1.607", "lab": true, "size": 35}}]

processing data/data.json

@@ -0,0 +1 @@
+{'class': {'course': 15, 'duration': 3, 'professor': 1}}{'room': {'lab': False, 'name': 'A1', 'size': 60}}{'prof': {'id': 1, 'name': 'Tran Tien Khoa'}}{'course': {'id': 26, 'name': 'Financial Accounting (2)'}}{'course': {'id': 15, 'name': 'Principles of Marketing (1)'}}{'class': {'course': 15, 'duration': 4, 'professor': 1}}{'class': {'course': 26, 'duration': 4, 'professor': 2}}{'class': {'course': 26, 'duration': 3, 'professor': 2}}{'room': {'lab': True, 'name': 'A2', 'size': 24}}{'prof': {'id': 2, 'name': 'Le Ngoc Anh Khoa'}}

processing data/reprocessing.ipynb

@@ -0,0 +1,589 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "3745035b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>MaMH</th>\n",
+       "      <th>TenMH</th>\n",
+       "      <th>NhomTo</th>\n",
+       "      <th>ToTH</th>\n",
+       "      <th>TenLop</th>\n",
+       "      <th>TongSoSV</th>\n",
+       "      <th>ThuKieuSo</th>\n",
+       "      <th>TietBD</th>\n",
+       "      <th>SoTiet</th>\n",
+       "      <th>MaPH</th>\n",
+       "      <th>DSTuanHoc</th>\n",
+       "      <th>MaNV</th>\n",
+       "      <th>TenDayDuNV</th>\n",
+       "      <th>IsTKBDaXep</th>\n",
+       "      <th>MaDV</th>\n",
+       "      <th>TenDV</th>\n",
+       "      <th>TenDVEg</th>\n",
+       "      <th>NgayBD</th>\n",
+       "      <th>NgayKT</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>Functional Programming</td>\n",
+       "      <td>1</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>ITIT16UN11, ITIT16UN21</td>\n",
+       "      <td>10</td>\n",
+       "      <td>2</td>\n",
+       "      <td>1</td>\n",
+       "      <td>3</td>\n",
+       "      <td>LA1.605</td>\n",
+       "      <td>-2345678901234567---</td>\n",
+       "      <td>174</td>\n",
+       "      <td>Dao Tran Hoang Chau</td>\n",
+       "      <td>0</td>\n",
+       "      <td>IT IT</td>\n",
+       "      <td>Computer Science &amp; Engineering</td>\n",
+       "      <td>Computer Science &amp; Engineering</td>\n",
+       "      <td>42989</td>\n",
+       "      <td>43094</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>Operating Systems</td>\n",
+       "      <td>1</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>ITIT15CS1, ITIT15IU11, ITIT15IU21, ITIT15IU31</td>\n",
+       "      <td>90</td>\n",
+       "      <td>6</td>\n",
+       "      <td>6</td>\n",
+       "      <td>3</td>\n",
+       "      <td>A1.309</td>\n",
+       "      <td>-2345678901234567---</td>\n",
+       "      <td>119</td>\n",
+       "      <td>Tran Manh Ha</td>\n",
+       "      <td>0</td>\n",
+       "      <td>IT IT</td>\n",
+       "      <td>Computer Science &amp; Engineering</td>\n",
+       "      <td>Computer Science &amp; Engineering</td>\n",
+       "      <td>42993</td>\n",
+       "      <td>43098</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2</td>\n",
+       "      <td>Operating Systems</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>ITIT15CS1, ITIT15IU11, ITIT15IU21, ITIT15IU31</td>\n",
+       "      <td>30</td>\n",
+       "      <td>2</td>\n",
+       "      <td>6</td>\n",
+       "      <td>4</td>\n",
+       "      <td>LA1.605</td>\n",
+       "      <td>-----678901234------</td>\n",
+       "      <td>119</td>\n",
+       "      <td>Tran Manh Ha</td>\n",
+       "      <td>0</td>\n",
+       "      <td>IT IT</td>\n",
+       "      <td>Computer Science &amp; Engineering</td>\n",
+       "      <td>Computer Science &amp; Engineering</td>\n",
+       "      <td>43017</td>\n",
+       "      <td>43073</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>2</td>\n",
+       "      <td>Operating Systems</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>ITIT15CS1, ITIT15IU11, ITIT15IU21, ITIT15IU31</td>\n",
+       "      <td>30</td>\n",
+       "      <td>2</td>\n",
+       "      <td>1</td>\n",
+       "      <td>4</td>\n",
+       "      <td>LA1.608</td>\n",
+       "      <td>-----678901234------</td>\n",
+       "      <td>213</td>\n",
+       "      <td>Nguyen Tien Dung</td>\n",
+       "      <td>0</td>\n",
+       "      <td>IT IT</td>\n",
+       "      <td>Computer Science &amp; Engineering</td>\n",
+       "      <td>Computer Science &amp; Engineering</td>\n",
+       "      <td>43017</td>\n",
+       "      <td>43073</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2</td>\n",
+       "      <td>Operating Systems</td>\n",
+       "      <td>1</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>ITIT15CS1, ITIT15IU11, ITIT15IU21, ITIT15IU31</td>\n",
+       "      <td>30</td>\n",
+       "      <td>2</td>\n",
+       "      <td>6</td>\n",
+       "      <td>4</td>\n",
+       "      <td>LA1.607</td>\n",
+       "      <td>-----678901234------</td>\n",
+       "      <td>213</td>\n",
+       "      <td>Nguyen Tien Dung</td>\n",
+       "      <td>0</td>\n",
+       "      <td>IT IT</td>\n",
+       "      <td>Computer Science &amp; Engineering</td>\n",
+       "      <td>Computer Science &amp; Engineering</td>\n",
+       "      <td>43017</td>\n",
+       "      <td>43073</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   MaMH                   TenMH  NhomTo  ToTH  \\\n",
+       "0     1  Functional Programming       1   NaN   \n",
+       "1     2       Operating Systems       1   NaN   \n",
+       "2     2       Operating Systems       1   1.0   \n",
+       "3     2       Operating Systems       1   2.0   \n",
+       "4     2       Operating Systems       1   3.0   \n",
+       "\n",
+       "                                          TenLop  TongSoSV  ThuKieuSo  TietBD  \\\n",
+       "0                         ITIT16UN11, ITIT16UN21        10          2       1   \n",
+       "1  ITIT15CS1, ITIT15IU11, ITIT15IU21, ITIT15IU31        90          6       6   \n",
+       "2  ITIT15CS1, ITIT15IU11, ITIT15IU21, ITIT15IU31        30          2       6   \n",
+       "3  ITIT15CS1, ITIT15IU11, ITIT15IU21, ITIT15IU31        30          2       1   \n",
+       "4  ITIT15CS1, ITIT15IU11, ITIT15IU21, ITIT15IU31        30          2       6   \n",
+       "\n",
+       "   SoTiet     MaPH             DSTuanHoc  MaNV           TenDayDuNV  \\\n",
+       "0       3  LA1.605  -2345678901234567---   174  Dao Tran Hoang Chau   \n",
+       "1       3   A1.309  -2345678901234567---   119         Tran Manh Ha   \n",
+       "2       4  LA1.605  -----678901234------   119         Tran Manh Ha   \n",
+       "3       4  LA1.608  -----678901234------   213     Nguyen Tien Dung   \n",
+       "4       4  LA1.607  -----678901234------   213     Nguyen Tien Dung   \n",
+       "\n",
+       "   IsTKBDaXep   MaDV                           TenDV  \\\n",
+       "0           0  IT IT  Computer Science & Engineering   \n",
+       "1           0  IT IT  Computer Science & Engineering   \n",
+       "2           0  IT IT  Computer Science & Engineering   \n",
+       "3           0  IT IT  Computer Science & Engineering   \n",
+       "4           0  IT IT  Computer Science & Engineering   \n",
+       "\n",
+       "                          TenDVEg  NgayBD  NgayKT  \n",
+       "0  Computer Science & Engineering   42989   43094  \n",
+       "1  Computer Science & Engineering   42993   43098  \n",
+       "2  Computer Science & Engineering   43017   43073  \n",
+       "3  Computer Science & Engineering   43017   43073  \n",
+       "4  Computer Science & Engineering   43017   43073  "
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "df = pd.read_csv(\"TKB HKI 2017-2018.csv\")\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "a605911f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>group_id</th>\n",
+       "      <th>course_id</th>\n",
+       "      <th>course_name</th>\n",
+       "      <th>Lab</th>\n",
+       "      <th>size</th>\n",
+       "      <th>duration</th>\n",
+       "      <th>room</th>\n",
+       "      <th>prof_id</th>\n",
+       "      <th>prof_name</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>Functional Programming</td>\n",
+       "      <td>False</td>\n",
+       "      <td>10</td>\n",
+       "      <td>3</td>\n",
+       "      <td>LA1.605</td>\n",
+       "      <td>174</td>\n",
+       "      <td>Dao Tran Hoang Chau</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Operating Systems</td>\n",
+       "      <td>False</td>\n",
+       "      <td>90</td>\n",
+       "      <td>3</td>\n",
+       "      <td>A1.309</td>\n",
+       "      <td>119</td>\n",
+       "      <td>Tran Manh Ha</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>3</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Operating Systems</td>\n",
+       "      <td>True</td>\n",
+       "      <td>30</td>\n",
+       "      <td>4</td>\n",
+       "      <td>LA1.605</td>\n",
+       "      <td>119</td>\n",
+       "      <td>Tran Manh Ha</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>4</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Operating Systems</td>\n",
+       "      <td>True</td>\n",
+       "      <td>30</td>\n",
+       "      <td>4</td>\n",
+       "      <td>LA1.608</td>\n",
+       "      <td>213</td>\n",
+       "      <td>Nguyen Tien Dung</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>5</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Operating Systems</td>\n",
+       "      <td>True</td>\n",
+       "      <td>30</td>\n",
+       "      <td>4</td>\n",
+       "      <td>LA1.607</td>\n",
+       "      <td>213</td>\n",
+       "      <td>Nguyen Tien Dung</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   group_id  course_id             course_name    Lab  size  duration  \\\n",
+       "0         1          1  Functional Programming  False    10         3   \n",
+       "1         2          2       Operating Systems  False    90         3   \n",
+       "2         3          2       Operating Systems   True    30         4   \n",
+       "3         4          2       Operating Systems   True    30         4   \n",
+       "4         5          2       Operating Systems   True    30         4   \n",
+       "\n",
+       "      room  prof_id            prof_name  \n",
+       "0  LA1.605      174  Dao Tran Hoang Chau  \n",
+       "1   A1.309      119         Tran Manh Ha  \n",
+       "2  LA1.605      119         Tran Manh Ha  \n",
+       "3  LA1.608      213     Nguyen Tien Dung  \n",
+       "4  LA1.607      213     Nguyen Tien Dung  "
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df = pd.DataFrame(df)\n",
+    "df1 = df[['MaMH', 'TenMH', 'ToTH', 'TongSoSV', 'SoTiet', 'MaPH','MaNV', 'TenDayDuNV']]\n",
+    "df1 = df1.rename(columns={'MaMH': 'course_id', 'TenMH': 'course_name','ToTH': 'Lab', 'TongSoSV': 'size', 'SoTiet': 'duration', 'MaPH': 'room', 'MaNV': 'prof_id', 'TenDayDuNV': 'prof_name' })\n",
+    "df1['Lab'] = df1['Lab'].fillna(0)\n",
+    "df1['Lab'] = df1['Lab'].astype(str)\n",
+    "df1['prof_id'] = df1['prof_id'].astype(int)\n",
+    "df1['course_id'] = df1['course_id'].astype(int)\n",
+    "\n",
+    "for index, row in df1.iterrows():\n",
+    "    if row['Lab'] == '1.0' or row['Lab'] == '2.0' or row['Lab'] == '3.0' or row['Lab'] == '4.0':\n",
+    "        df1.at[index, 'Lab'] = 'True'\n",
+    "    else:\n",
+    "        df1.at[index, 'Lab'] = ''\n",
+    "        \n",
+    "df1['Lab'] = df1['Lab'].astype(bool)\n",
+    "df1.reset_index(inplace=True)\n",
+    "df1 = df1.rename(columns={'index': 'group_id'})\n",
+    "df1['group_id'] = np.arange(1, len(df) + 1)\n",
+    "df1.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "80f6ef63",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>room</th>\n",
+       "      <th>size</th>\n",
+       "      <th>Lab</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>A1.309</td>\n",
+       "      <td>90</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>L107</td>\n",
+       "      <td>40</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>LA1.605</td>\n",
+       "      <td>35</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>LA1.607</td>\n",
+       "      <td>35</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      room  size    Lab\n",
+       "0   A1.309    90  False\n",
+       "1     L107    40  False\n",
+       "2  LA1.605    35   True\n",
+       "3  LA1.607    35   True"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "room_default = [['A1.309', 90, 0],\n",
+    "                ['L107', 40, 0],\n",
+    "                ['LA1.605', 35, 1],\n",
+    "                ['LA1.607', 35, 1],\n",
+    "]\n",
+    "room_columns = ['room', 'size', 'Lab']\n",
+    "df_room = pd.DataFrame(room_default, columns=room_columns)\n",
+    "df_room['Lab'] = df_room['Lab'].astype(str)\n",
+    "for index, row in df_room.iterrows():\n",
+    "    if row['Lab'] == '1':\n",
+    "        df_room.at[index, 'Lab'] = 'True'\n",
+    "    else:\n",
+    "        df_room.at[index, 'Lab'] = ''\n",
+    "df_room['Lab'] = df_room['Lab'].astype(bool)\n",
+    "df_room"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "d6b5b6a2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "\n",
+    "# create list of dictionaries representing each object in the JSON file\n",
+    "objects = []\n",
+    "\n",
+    "for index, row in df1.iterrows():\n",
+    "    if row['prof_id'] != '':\n",
+    "        # create professor object\n",
+    "        prof = {\n",
+    "            \"prof\": {\n",
+    "                \"id\": row['prof_id'],\n",
+    "                \"name\": row['prof_name']\n",
+    "            }\n",
+    "        }\n",
+    "        if prof not in objects:\n",
+    "            objects.append(prof)\n",
+    "\n",
+    "    if row['course_id'] != '':\n",
+    "        # create course object\n",
+    "        course = {\n",
+    "            \"course\": {\n",
+    "                \"id\": row['course_id'],\n",
+    "                \"name\": row['course_name']\n",
+    "            }\n",
+    "        }\n",
+    "        if course not in objects:\n",
+    "            objects.append(course)\n",
+    "\n",
+    "    if row['group_id'] != '':\n",
+    "        # create room object\n",
+    "        group = {\n",
+    "            \"group\": {\n",
+    "                \"id\": row['group_id'],\n",
+    "                \"size\": row['size']\n",
+    "            }\n",
+    "        }\n",
+    "        if group not in objects:\n",
+    "            objects.append(group)\n",
+    "            \n",
+    "    if row['prof_id'] != '' and row['course_id'] != '':\n",
+    "        # create class object\n",
+    "        class_ = {\n",
+    "            \"class\": {\n",
+    "                \"professor\": row['prof_id'],\n",
+    "                \"course\": row['course_id'],\n",
+    "                \"duration\": row['duration'],\n",
+    "                \"group\": row['group_id'],\n",
+    "                \"lab\": row['Lab']\n",
+    "            }\n",
+    "        }\n",
+    "        if class_ not in objects:\n",
+    "            objects.append(class_)\n",
+    "        \n",
+    "for index, row in df_room.iterrows():\n",
+    "    if row['room'] != '':\n",
+    "        # create room object\n",
+    "        room = {\n",
+    "            \"room\": {\n",
+    "                \"name\": row['room'],\n",
+    "                \"lab\": row['Lab'],\n",
+    "                \"size\": row['size']\n",
+    "            }\n",
+    "        }\n",
+    "        objects.append(room)    \n",
+    "        \n",
+    "# create JSON object with list of objects\n",
+    "json_data = json.dumps(objects, sort_keys=False)\n",
+    "\n",
+    "# write JSON object to file\n",
+    "with open('GaSchedule3.json', 'w') as f:\n",
+    "    f.write(json_data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "f7a33b15",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'[{\"prof\": {\"id\": 174, \"name\": \"Dao Tran Hoang Chau\"}}, {\"course\": {\"id\": 1, \"name\": \"Functional Programming\"}}, {\"group\": {\"id\": 1, \"size\": 10}}, {\"class\": {\"professor\": 174, \"course\": 1, \"duration\": 3, \"group\": 1, \"lab\": false}}, {\"prof\": {\"id\": 119, \"name\": \"Tran Manh Ha\"}}, {\"course\": {\"id\": 2, \"name\": \"Operating Systems\"}}, {\"group\": {\"id\": 2, \"size\": 90}}, {\"class\": {\"professor\": 119, \"course\": 2, \"duration\": 3, \"group\": 2, \"lab\": false}}, {\"group\": {\"id\": 3, \"size\": 30}}, {\"class\": {\"professor\": 119, \"course\": 2, \"duration\": 4, \"group\": 3, \"lab\": true}}, {\"prof\": {\"id\": 213, \"name\": \"Nguyen Tien Dung\"}}, {\"group\": {\"id\": 4, \"size\": 30}}, {\"class\": {\"professor\": 213, \"course\": 2, \"duration\": 4, \"group\": 4, \"lab\": true}}, {\"group\": {\"id\": 5, \"size\": 30}}, {\"class\": {\"professor\": 213, \"course\": 2, \"duration\": 4, \"group\": 5, \"lab\": true}}, {\"prof\": {\"id\": 74, \"name\": \"Nguyen Van Sinh\"}}, {\"course\": {\"id\": 3, \"name\": \"IT Project Management\"}}, {\"group\": {\"id\": 6, \"size\": 35}}, {\"class\": {\"professor\": 74, \"course\": 3, \"duration\": 3, \"group\": 6, \"lab\": false}}, {\"group\": {\"id\": 7, \"size\": 35}}, {\"class\": {\"professor\": 74, \"course\": 3, \"duration\": 4, \"group\": 7, \"lab\": true}}, {\"prof\": {\"id\": 84, \"name\": \"Le Hai Duong\"}}, {\"course\": {\"id\": 4, \"name\": \"Introduction to Computing\"}}, {\"group\": {\"id\": 8, \"size\": 35}}, {\"class\": {\"professor\": 84, \"course\": 4, \"duration\": 3, \"group\": 8, \"lab\": false}}, {\"prof\": {\"id\": 19, \"name\": \"Huynh Kha Tu\"}}, {\"course\": {\"id\": 5, \"name\": \"Digital Logic Design\"}}, {\"group\": {\"id\": 9, \"size\": 90}}, {\"class\": {\"professor\": 19, \"course\": 5, \"duration\": 3, \"group\": 9, \"lab\": false}}, {\"prof\": {\"id\": 182, \"name\": \"Tran Thanh Tung\"}}, {\"course\": {\"id\": 6, \"name\": \"Object-Oriented Programming\"}}, {\"group\": {\"id\": 10, \"size\": 90}}, {\"class\": {\"professor\": 182, \"course\": 6, \"duration\": 3, \"group\": 10, \"lab\": false}}, {\"group\": {\"id\": 11, \"size\": 30}}, {\"class\": {\"professor\": 213, \"course\": 6, \"duration\": 4, \"group\": 11, \"lab\": true}}, {\"group\": {\"id\": 12, \"size\": 30}}, {\"class\": {\"professor\": 213, \"course\": 6, \"duration\": 4, \"group\": 12, \"lab\": true}}, {\"group\": {\"id\": 13, \"size\": 30}}, {\"class\": {\"professor\": 213, \"course\": 6, \"duration\": 4, \"group\": 13, \"lab\": true}}, {\"prof\": {\"id\": 349, \"name\": \"Nguyen Thi Thanh Sang\"}}, {\"course\": {\"id\": 7, \"name\": \"Software Engineering\"}}, {\"group\": {\"id\": 14, \"size\": 70}}, {\"class\": {\"professor\": 349, \"course\": 7, \"duration\": 3, \"group\": 14, \"lab\": false}}, {\"group\": {\"id\": 15, \"size\": 35}}, {\"class\": {\"professor\": 349, \"course\": 7, \"duration\": 4, \"group\": 15, \"lab\": true}}, {\"group\": {\"id\": 16, \"size\": 35}}, {\"class\": {\"professor\": 349, \"course\": 7, \"duration\": 4, \"group\": 16, \"lab\": true}}, {\"prof\": {\"id\": 62, \"name\": \"Vo Thi Luu Phuong\"}}, {\"course\": {\"id\": 8, \"name\": \"Computer Networks\"}}, {\"group\": {\"id\": 17, \"size\": 70}}, {\"class\": {\"professor\": 62, \"course\": 8, \"duration\": 3, \"group\": 17, \"lab\": false}}, {\"group\": {\"id\": 18, \"size\": 35}}, {\"class\": {\"professor\": 62, \"course\": 8, \"duration\": 4, \"group\": 18, \"lab\": true}}, {\"group\": {\"id\": 19, \"size\": 35}}, {\"class\": {\"professor\": 62, \"course\": 8, \"duration\": 4, \"group\": 19, \"lab\": true}}, {\"prof\": {\"id\": 60, \"name\": \"Ly Tu Nga\"}}, {\"group\": {\"id\": 20, \"size\": 20}}, {\"class\": {\"professor\": 60, \"course\": 8, \"duration\": 4, \"group\": 20, \"lab\": true}}, {\"course\": {\"id\": 9, \"name\": \"Web Application Development\"}}, {\"group\": {\"id\": 21, \"size\": 15}}, {\"class\": {\"professor\": 74, \"course\": 9, \"duration\": 3, \"group\": 21, \"lab\": false}}, {\"group\": {\"id\": 22, \"size\": 15}}, {\"class\": {\"professor\": 74, \"course\": 9, \"duration\": 4, \"group\": 22, \"lab\": true}}, {\"group\": {\"id\": 23, \"size\": 20}}, {\"class\": {\"professor\": 213, \"course\": 9, \"duration\": 4, \"group\": 23, \"lab\": true}}, {\"prof\": {\"id\": 36, \"name\": \"Le Thanh Son\"}}, {\"course\": {\"id\": 10, \"name\": \"Net-Centric Programming\"}}, {\"group\": {\"id\": 24, \"size\": 17}}, {\"class\": {\"professor\": 36, \"course\": 10, \"duration\": 3, \"group\": 24, \"lab\": false}}, {\"group\": {\"id\": 25, \"size\": 17}}, {\"class\": {\"professor\": 36, \"course\": 10, \"duration\": 4, \"group\": 25, \"lab\": true}}, {\"course\": {\"id\": 11, \"name\": \"Digital Logic Design Laboratory\"}}, {\"group\": {\"id\": 26, \"size\": 15}}, {\"class\": {\"professor\": 60, \"course\": 11, \"duration\": 4, \"group\": 26, \"lab\": false}}, {\"group\": {\"id\": 27, \"size\": 15}}, {\"class\": {\"professor\": 60, \"course\": 11, \"duration\": 4, \"group\": 27, \"lab\": false}}, {\"group\": {\"id\": 28, \"size\": 15}}, {\"class\": {\"professor\": 60, \"course\": 11, \"duration\": 4, \"group\": 28, \"lab\": false}}, {\"group\": {\"id\": 29, \"size\": 15}}, {\"class\": {\"professor\": 60, \"course\": 11, \"duration\": 4, \"group\": 29, \"lab\": false}}, {\"group\": {\"id\": 30, \"size\": 15}}, {\"class\": {\"professor\": 60, \"course\": 11, \"duration\": 4, \"group\": 30, \"lab\": false}}, {\"course\": {\"id\": 12, \"name\": \"Entrepreneurship\"}}, {\"group\": {\"id\": 31, \"size\": 80}}, {\"class\": {\"professor\": 174, \"course\": 12, \"duration\": 3, \"group\": 31, \"lab\": false}}, {\"course\": {\"id\": 13, \"name\": \"System & Network Administration\"}}, {\"group\": {\"id\": 32, \"size\": 35}}, {\"class\": {\"professor\": 36, \"course\": 13, \"duration\": 3, \"group\": 32, \"lab\": false}}, {\"group\": {\"id\": 33, \"size\": 35}}, {\"class\": {\"professor\": 36, \"course\": 13, \"duration\": 4, \"group\": 33, \"lab\": true}}, {\"prof\": {\"id\": 184, \"name\": \"Ha Viet Uyen Synh\"}}, {\"course\": {\"id\": 14, \"name\": \"Theoretical Models in Computing\"}}, {\"group\": {\"id\": 34, \"size\": 80}}, {\"class\": {\"professor\": 184, \"course\": 14, \"duration\": 3, \"group\": 34, \"lab\": false}}, {\"group\": {\"id\": 35, \"size\": 26}}, {\"class\": {\"professor\": 184, \"course\": 14, \"duration\": 4, \"group\": 35, \"lab\": true}}, {\"group\": {\"id\": 36, \"size\": 28}}, {\"class\": {\"professor\": 184, \"course\": 14, \"duration\": 4, \"group\": 36, \"lab\": true}}, {\"course\": {\"id\": 15, \"name\": \"Discrete Mathematics\"}}, {\"group\": {\"id\": 37, \"size\": 80}}, {\"class\": {\"professor\": 74, \"course\": 15, \"duration\": 3, \"group\": 37, \"lab\": false}}, {\"room\": {\"name\": \"A1.309\", \"lab\": false, \"size\": 90}}, {\"room\": {\"name\": \"L107\", \"lab\": false, \"size\": 40}}, {\"room\": {\"name\": \"LA1.605\", \"lab\": true, \"size\": 35}}, {\"room\": {\"name\": \"LA1.607\", \"lab\": true, \"size\": 35}}]'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "json_data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ac354530",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.7"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "9510137371fb582fb03f4a48cfea1312dabd94192ffed7cc50b24473a7d892dd"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}