def main():
group_id = get_group_id('Фт-340007')
schedule = get_group_schedule(group_id)
periods = extract_periods(schedule)
tt = Timetable()
tt.load_periods(periods)
print(tt)
def setUp(self):
#create an empty timetable of 5 days
classrooms = [
Classroom('LT ', 45, 'PBOO2'),
Classroom('PB001', 100, 'Petroleum building'),
Classroom('Main Library ', 60, 'Admiss'),
Classroom('Room C', 67, 'N1'),
Classroom(' A110', 300, 'Libary')
]
timeslots = [
TimeSlot('8:00', '9:00'),
TimeSlot('9:00', '10:00'),
TimeSlot('10:00', '11:00'),
TimeSlot('11:00', '12:00'),
TimeSlot('12:00', '13:00'),
TimeSlot('13:00', '14:00')
]
days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
day_tables = []
self.days = days
for day in days:
day_tables.append(DayTimetable(classrooms, timeslots, day))
self.timetable = Timetable(days, day_tables)
def parse(timetable_html):
soup = BeautifulSoup(timetable_html, 'html.parser')
results = soup.find_all('td', attrs={'valign': 'top'})
days = []
for day in results:
days.append(parse_days(day))
timetable = Timetable(days[0], days[1], days[2], days[3], days[4], days[5])
return timetable
def __init__(self):
super().__init__()
string_buffer = get_routes()
header_row = string_buffer.readline().lower().split(';')
_ = string_buffer.readline(), string_buffer.readline(
) # throw away unnecessary lines
fieldnames = [
field if (field not in self.key_translation) else
self.key_translation[field] for field in header_row
]
stops = MinibusStops()
last_route_number = None
for column_values, timetable in itertools.zip_longest(
*[string_buffer] * 2):
timetable = timetable.strip()
column_values = column_values.split(';')
route_data = dict(zip(fieldnames, column_values))
route_number = route_data['route_number']
route_type = route_data['route_type']
route_name = route_data['route_name']
route_stops = [
route_stop
for route_stop in route_data['route_stops'].split(',')
if len(route_stop) > 0
]
if len(route_number) == 0:
route_number = last_route_number
route_stops = [stops[route_stop] for route_stop in route_stops]
route_id = RouteID(route_number=route_number, type=route_type)
route = MinibusRoute(name=route_name,
stops=route_stops,
timetable=Timetable(timetable))
last_route_number = route_number
self[route_id] = route
def __init__(self, path, qtable):
self.timetable = Timetable(json_path=path)
self.resources = self.timetable.resources
self.trains = list(self.timetable.trains.values())
self.events = defaultdict(list)
self.qtable = qtable
self.current_time = 0
self.min_time = 9999999
self.max_time = 0
self.wait_time = 10.0
self.done = False
self.late_on_node = False
self.with_connections = True
self.max_delta = 60 * 30
self.priorities = {}
# self.blocked_trains = set()
self.assign_sections_to_resources()
def to_timetable(timetable_html):
html = BeautifulSoup(timetable_html)
# Find timetable table
tables = html.findAll(name='table')
calendar_table = None
for table in tables:
if table.find(name='center', text='Squash Belegungsplan'):
calendar_table = table
break
if not calendar_table:
raise Exception('Could not find timetable from response ' +
html_str)
# Get all "time" rows
all_rows = calendar_table.findAll(name='tr')
time_rows = []
for row in all_rows:
found = row.find(name='td', text=' ')
if found:
time_rows.append(row)
# Build availability map
timetable = {}
for time_row in time_rows:
key = time_row.find(name='td', attrs={'align': 'center'}).text
courts_availability = [False, False, False, False, False]
spots = []
for td in time_row.findAll(name='td'):
if td.text == ' ':
spots.append(td)
for i in range(0, 5):
if len(spots[i].attrs) == 1:
courts_availability[i] = spots[i].attrs[0][1].strip(
) == 'background:#ffffff;'
timetable[key] = courts_availability
return Timetable(timetable)
import datetime
import re
from bs4 import BeautifulSoup
from auth3 import Auth
from holiday import Holiday
from timetable import Timetable
timetable = Timetable()
holiday = Holiday()
def course_handler(cookies, xnxqid, start_date, output_dir='.'):
auth = Auth(cookies)
if not auth.ok:
raise Exception('登录失败，请检查用户名密码')
url = 'https://jwxt.sztu.edu.cn/jsxsd/xskb/xskb_list.do?xnxq01id=' + xnxqid
start_date = start_date.split('-')
r = auth.get(url)
soup = BeautifulSoup(r.text, features='html.parser')
tab = soup.findAll('table')[0]
i = 0
schedules = []
from timetable import Timetable
import argparse
import sys
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='List event_id for modules')
parser.add_argument('path',
metavar='path',
help='File path to timetable xlsx spreadsheet.')
parser.add_argument('modules',
metavar='module',
nargs='+',
help='List of modules.')
parser.add_argument('-o',
metavar='output file',
help='Output file location.')
args = parser.parse_args()
t = Timetable(args.path)
events = t.generate_event_list(args.modules)
if args.o:
with open(args.o, 'w') as f:
for event in events:
f.write(str(event) + '\n')
else:
for event in events:
print(event)
from tkinter import *
import random
import time
from Tramwaje import Tram
from timetable import Timetable
from tkinter.ttk import *
from table_times_source import table_times
from table_locations_source import table_locations
"""
Data for testing - basic timetable and Tram
"""
timetable = Timetable(table_times, table_locations, 100)
tram_1 = Tram(1, (0, 20, 40, 60, 80, 100, 120, 140, 160, 180),
(0, 1, 2, 3, 4, 5, 10, 15, 10, 5))
tram_2 = Tram(1, (5, 15, 25, 35, 45, 55, 65, 70, 80, 90), (4, 5, 6, 7, 8, 9))
tram_3 = Tram(1, (5, 15, 25, 35, 60, 70, 80, 90, 100, 110),
(11, 12, 13, 14, 15, 16))
tram_4 = Tram(1, (5, 15, 25, 35, 55, 77, 88, 91, 94, 101),
(21, 22, 23, 47, 63, 83))
tram_5 = Tram(1, (5, 15, 25, 35, 45, 55, 65, 75, 85, 95),
(60, 61, 41, 42, 22, 21))
tram_6 = Tram(1, (5, 15, 25, 35, 40, 45, 50, 60, 65, 70),
(33, 34, 54, 55, 54, 44, 43, 33))
tram_7 = Tram(1, (5, 15, 25, 35, 45, 50, 60, 70, 80, 90),
(81, 82, 62, 41, 20, 0))
tram_8 = Tram(1, (5, 15, 25, 35, 45, 50, 55, 60, 65, 70, 75),
(55, 56, 57, 58, 59, 60))
tram_9 = Tram(1, (5, 15, 25, 35, 50, 80, 100, 110, 120, 130),
(72, 71, 70, 49, 28, 9))
18 * 3600, 19 * 3600, 3, 3)
# # print(u.set_valid_timetables(u.get_valid_combinations()))
# # print(len(u.get_valid_combinations()))
a = u.get_valid_combinations()
print(len(a[0]), len(a[1]))
# # print(len(a[0]) * len(a[1]))
for h in range(0, 1):
try:
# Sampling
cm = CourseManager()
for i in cm._break_down_nested_list(a[0][h]):
print(i.get_code())
print(i.get_meeting_section())
# =====Testing Purposes=====
t = TimetableManager()
f = Timetable()
for i in cm._break_down_nested_list(a[0][0]):
f.add_course([i], u.get_first_semester_filter())
print(f.get_first_semester_table())
print(f.get_second_semester_table())
except (IndexError):
print("No Solutions Found")
#
# print(len(u._get_combinations()))
# for i in u._get_combinations():
# for b in i:
# print(b._get_meeting_section())
# print("----------------")
# print(u._second_semester_courses)
# print(u._first_semester_courses[0].get_meeting_sections())
# print(u.get_combinations())
csvFile.close()
with open('/home/kumbong/Desktop/Software Engineering/hex-backend/objects/rooms.csv', 'r') as csvFile:
reader = csv.DictReader(csvFile, dialect='myDialect')
for row in reader:
r = (dict(row))
room = Classroom(r['Name'].strip(),int(r['Capacity'].strip()),r['Building'].strip(),r['Allowance'].strip())
rooms.append(room)
csvFile.close()
days = ['Monday','Tuesday','Wednesday','Thursday','Friday']
day_tables = []
for day in days:
day_tables.append(DayTimetable(rooms,timeslots,day))
timetable = Timetable(days,day_tables)
generator = TimeTableGenerator(timetable,lectures)
# #print(generator.unscheduled)
import time
start_time = time.time()
generator.generate_timetable()
print(generator.timetable)
print(len(generator.scheduled))
print(len(generator.unscheduled))
#print(generator.scheduled)
def timetable():
u = User()
for course in list_of_courses:
if course + ".json" in os.listdir(
"/Users/chris/PycharmProjects/Timetable-Generator/another_one"
):
u.add_course(course)
# global courses_color
global courses_color
courses_color = assign_color_to_courses()
u.set_first_semester_filter(
(fall_start_time) * 3600, (fall_end_time) * 3600, days_excluded_fall,
fall_lunch_start_time, fall_lunch_end_time, first_semester_max_courses,
first_semester_tutorials_practicals)
u.set_second_semester_filter(
(winter_start_time) * 3600, (winter_end_time) * 3600,
days_excluded_winter, winter_lunch_start_time, winter_lunch_end_time,
second_semester_max_courses, second_semester_tutorials_practicals)
possible_timetables = u.get_valid_combinations()
cm = CourseManager()
fst = Timetable()
# print(str(len(possible_timetables[0])) + " timetables generated")
if len(possible_timetables[0]) != 0:
fs = random.randint(
0, (len(possible_timetables[0]) -
1)) # Can get a -1 error for no possible timetables
else:
fs = -1
if len(possible_timetables[1]) != 0:
ss = random.randint(0, (len(possible_timetables[1]) - 1))
else:
ss = -1
# print(str(a) + " is the timetable picked")
if fs != -1:
fst.add_course(cm._break_down_nested_list(possible_timetables[0][fs]),
u.get_first_semester_filter())
if ss != -1:
fst.add_course(cm._break_down_nested_list(possible_timetables[1][ss]),
u.get_second_semester_filter())
columns = ['MONDAY', 'TUESDAY', 'WEDNESDAY', 'THURSDAY', 'FRIDAY']
index = [
'8:00am', '8:30am', '9:00am', '9:30am', '10:00am', '10:30am',
'11:00am', '11:30am', '12:00pm', '12:30pm', '1:00pm', '1:30pm',
'2:00pm', '2:30pm', '3:00pm', '3:30pm', '4:00pm', '4:30pm', '5:00pm',
'5:30pm', '6:00pm', '6:30pm', '7:00pm', '7:30pm', '8:00pm', '8:30pm',
'9:00pm', '9:30pm'
]
# print(t.get_first_semester_table())
data_first_semester = fst.get_first_semester_table()
data_second_semester = fst.get_second_semester_table()
for i in range(len(data_first_semester)):
for h in range(len(data_first_semester[i])):
if data_first_semester[i][h] is None:
data_first_semester[i][h] = ''
else:
data_first_semester[i][h] = str(
data_first_semester[i][h].get_code() + " " +
data_first_semester[i][h].get_meeting_section_codes())
for i in range(len(data_second_semester)):
for h in range(len(data_second_semester[i])):
if data_second_semester[i][h] is None:
data_second_semester[i][h] = ''
else:
data_second_semester[i][h] = str(
data_second_semester[i][h].get_code() + " " +
data_second_semester[i][h].get_meeting_section_codes())
df1 = pd.DataFrame(data_first_semester, columns=columns, index=index)
th_props = [('text-align', 'center'), ('color', '#6d6d6d'),
('background-color', '#f7f7f9')]
td_props = [('font-size', '20px')]
styles = [
dict(selector="tr", props=th_props),
dict(selector="td", props=td_props)
]
# df1.style.applymap(highlight_courses)
test = dict(selector="th", props=[('text-align', 'center')])
df1.style.set_table_styles([test])
df1.style.set_table_styles(styles).render()
df2 = pd.DataFrame(data_second_semester, columns=columns, index=index)
df2.style.set_table_styles([test])
df2.style.set_table_styles(styles).render()
# print(df2.style.render())
# print(df1.style.render())
for day, content in df1.iteritems():
for item in content:
if item != '':
if item not in temp_dict[day]:
temp_dict[day][0][item] = False
# print(temp_dict)
# print(type(df1.iteritems()))
# df1.to_html(border=0, escape=False)
# print(courses_color)
return render_template(
"timetable.html",
data_frame=df1.style.applymap(highlight_courses_background,
subset=columns).render(),
data_frame2=df2.style.applymap(highlight_courses_background,
subset=columns).render())
tutors = args.tutors
eval_func_str = args.optimize
log.debug('config: %d. Test (in lab rooms) starts at %s.' % (args.test, start.strftime('%H:%M')))
log.debug('config: %d groups of students, %d rooms for computertest.' % (args.groups, len(rooms)))
log.debug('config: evaluation function of genetic optimization = %s' % (eval_func_str))
#
# Genetic algorithm
#
# Collects data about timetable.
t = Timetable(start, args.test, rooms, tutors, args.groups)
# Initialize evaluation functions if necessary.
if eval_func_str == 'fuzzy':
evaluation.fuzzy_init(t)
##
# Apply genome (map tutor to slot).
##
def apply_genome(genome):
# check if genome has equal size as total number of slots
if len(genome) != len(t._slots):
msg = 'Wrong length of genome (%d), must match total number of slots (%d).' % (len(genome), len(slots))
raise RuntimeError(msg)
# put tutors into slots
for s in range(len(t._slots)):
from timetable import Timetable
from building import *
import os
if __name__ == "__main__":
files = [
"Room List.xlsx", "Roomequip.xlsx", "Timetable2018-19.xlsx",
"buildings.csv"
]
paths = [os.path.join("Data", x) for x in files]
buildings = load_buildings(paths[3])
_rooms = load_rooms(paths[0], paths[1], buildings)
timetable = Timetable(paths[2])
rooms = set()
for row in timetable.timetable.iter_rows(min_row=2, values_only=True):
if row[8]:
rooms.update(row[8].split(','))
with open('capacitymissing.txt', 'w') as f:
for room in rooms:
if room not in _room:
f.write(str(room) + '\n')
from timetable import Timetable
from datetime import datetime
import time
if __name__ == "__main__":
# actual script of running the timetable
path = "E:/Textbook/4th Year/CSC148/tokyo trains/"
weekday ='weekday schedule.csv'
weekend = 'weekend schedule.csv'
train = Timetable()
# determine which version to use
if datetime.now().isoweekday() < 6:
train.add_arrival(path + weekday)
else:
train.add_arrival(path + weekend)
while True:
train.JumpToNow()
train.display()
time.sleep(20)
train.clear_table()
train.service_unavailable()
