def random_timetable(teachers, audiences, subjects, specialities):
current_timetable = []
for speciality in specialities:
days_in_week = []
for day in day_of_week:
lessons_in_day = []
num_of_lessons = random.choice(range(1, 7))
for numb in range(num_of_lessons):
num_of_lesson = random.choice(range(1, 7))
type_of_lesson = random.choice(l_or_p)
subject = random.choice(subjects)
teacher = random.choice(teachers)
audience = random.choice(audiences)
if type_of_lesson == 'practice':
group = random.choice([1, 2])
lesson = Lesson(num_of_lesson, type_of_lesson, subject,
teacher, audience, group)
else:
lesson = Lesson(num_of_lesson, type_of_lesson, subject,
teacher, audience)
lessons_in_day.append(lesson)
current_day = Day(day, lessons_in_day)
days_in_week.append(current_day)
current_week = Week(speciality, days_in_week)
current_timetable.append(current_week)
timetable = Timetable(current_timetable)
return timetable
def parse_table_body(self) -> None:
tr_tags = []
self.cell_text = []
self.times = []
for tr in self.table_body.find_all('tr'):
tr_tags.append(tr)
div_cell = tr.find('div', class_='cell')
self.cell_text.append(div_cell.text)
div_time = tr.find('th', class_='time').find('div')
div_time = str(div_time).replace('<div>', '').replace(
'<hr/>', '|').replace('<br/>', '|').replace('</div>', '|')
div_items = div_time.split('|')
if len(div_items) == 6:
del div_items[3:5]
self.times.append(div_time)
classroom = ''
title = ''
if div_cell.text != '':
classroom = div_cell.text.split(' | ')[0]
title = div_cell.text.split(' | ')[1]
self.days_schedule[self.days_names[0][0]].append(
Lesson(number=int(div_items[0][0]),
start_time=div_items[1],
end_time=div_items[2],
classroom=classroom,
title=title))
def readLessonsFromArchive(firstTime, rooms):
file = open(lessonsFileInputName)
lessons = []
# Não precisa ler a primeira linha, apenas definições
file.readline()
for currentLine in file:
data = currentLine.split()
# Se estiver faltando um costuma ser room, adiciono ela
if (len(data) != dataDefaultLen):
data.insert(9, -1)
# Se o tamanho não estiver correto ainda, está mal formatado
# logo não adiciono.
# TODO: Adicionar logging dos pedidos que estão falhos.
if (len(data) != dataDefaultLen):
continue
# Placeholder
day = int(data[5])
if (firstTime):
data[9] = -1
else:
for room in rooms:
if (int(room.uniqueId) == int(data[9])):
room.assignClass(int(data[5]), int(data[6]), int(data[0]))
lesson = Lesson(data[0], data[1], data[2], data[3], data[4], data[5],
data[6], data[7], data[8], data[9], data[10], data[11],
data[12], data[13])
lessons.append(lesson)
file.close()
return lessons
def txt2process(book_name, lesson_count=9999):
tp = TemParse()
lessons = []
file = open('Text/' + book_name + '.txt')
lesson_id = 0
flag = False
for line in file:
line = Utl.cleaned_line(line)
if line != '\n':
if not flag:
flag = True
lesson_id += 1
text = ''
text += line
else:
if flag:
lessons.append(Lesson(lesson_id, text))
flag = False
file.close()
if flag:
lessons.append(Lesson(lesson_id, text))
print 'Start parsing.'
os.chdir('Process')
file = open(book_name + '.txt', 'w')
for lid in range(1, min(lesson_count + 1, len(lessons) + 1)):
lid -= 1
lessons[lid].parse(tp)
for i in range(lessons[lid].numSentences):
p = lessons[lid].processes[i]
if p != '':
file.write(lessons[lid].processes[i] + '\n')
else:
file.write('NULL\n')
file.write('\n')
print 'Lesson', lessons[lid].lesson_id, 'end.'
file.close()
os.chdir('..')
pg = ProcessGraph()
#pg.add_lessons(Lessons,eid=2)
#pg.create_graph(book_name)
return lessons
def append_lesson(subject, empty_lesson: EmptyLesson):
audiences = []
for audience in rf.audiences:
if audience.capacity >= len(subject.enrolled_students):
audiences.append(audience)
i = random.choice(range(len(audiences)))
lesson = Lesson(empty_lesson.day, empty_lesson.num_of_lesson, subject,
audiences[i].number)
timetable.append(lesson)
return lesson
def lessons2process(book_name, begin_id=1, end_id=-1):
tp = TemParse()
lessons = []
file = open('Text/' + book_name + '.txt')
lesson_id = 0
flag = False
for line in file:
line = Utl.cleaned_line(line)
if line != '\n':
if not flag:
flag = True
lesson_id += 1
text = ''
text += line
else:
if flag:
lessons.append(Lesson(lesson_id, text))
flag = False
file.close()
if flag:
lessons.append(Lesson(lesson_id, text))
if end_id == -1:
end_id = begin_id
for lid in range(begin_id, end_id + 1):
print 'Lesson', lid, ':'
lid -= 1
lessons[lid].parse(tp)
for i in range(lessons[lid].numSentences):
print lessons[lid].sentences[i], lessons[lid].processes[i]
print 'Lesson', lessons[lid].lesson_id, 'end.'
print
pg = ProcessGraph()
#pg.add_lessons(Lessons,eid=2)
#pg.create_graph(book_name)
return lessons
def get_time_table(self, faculties):
for faculty in range(len(faculties)):
timetable = []
soup = pars(
self.main_url + "/view?y=" + self.get_academic_year_id() +
"&s=" + self.get_semester() + "&g="
"" + faculties[faculty] +
f"&f={self.monday}&t={self.monday + timedelta(days=12)}")
if not self.check_date(soup):
valid_table = additionally(soup, timetable, self.monday,
self.get_semester(),
self.get_academic_year_id(),
faculties[faculty])
continue
try:
table = soup.find("tbody").find_all("tr")
except AttributeError:
valid_table = additionally(soup, timetable, self.monday,
self.get_semester(),
self.get_academic_year_id(),
faculties[faculty])
continue
for tr in table:
try:
subject = word_check(
tr.find_all("td")[1].text.split("(")[0].strip())
except IndexError:
day = get_day(tr)
number_week = get_number_week(tr)
continue
auditory = get_auditory(tr)
extra = get_extra(tr)
start_time = get_start_time(tr)
number = get_number(tr, self.fix_schedule, start_time)
end_time = get_end_time(tr, self.fix_schedule, start_time)
interval = Interval(number, start_time, end_time)
typ = get_type(tr)
lesson = Lesson(number_week, day, interval, subject, auditory,
extra, typ)
self.addLessonToSchedule(timetable, lesson)
valid_table = additionally(soup, timetable, self.monday,
self.get_semester(),
self.get_academic_year_id(),
faculties[faculty])
self.sendEntityToDatabase(valid_table, faculty, len(faculties))
def create():
lesson = None
try:
code = input("Dersin kısa kodu: ").strip()
description = input("Ders açıklaması: ").strip()
lesson = Lesson(code, description)
except Exception as e:
print(f"Hata: {e}")
return lesson
def getSchedule(self, group): # выполняет основную функцию
# проходим по каждой группе
schedule = []
raspgroup = "http://kml.vvsu.ru/map/getTimeTable.php?group=%d" % int(
group.url.split('GroupID=')[1])
jsonSchedule = requests.get(raspgroup).json()
for jsonWeek in jsonSchedule['data']:
thisweek = jsonWeek['week']
if (getWeekForLessons(thisweek)):
weekforlesson = getWeekForLessons(thisweek)
weektable = jsonWeek['weektable']
for dayofweek in weektable:
dayOfweek = GetDayOf(dayofweek['dayofweek'], 'full')
dayTable = dayofweek['daytable']
numberles = 0
for numberLesson in range(len(dayTable)):
lessonbegin = GetLesBegin(
dayTable[numberLesson]
['TimePeriod']) # начало урока
lessonend = GetLesEnd(dayTable[numberLesson]
['TimePeriod']) # конец урока
numberles = numberles + 1 # номер урока
inteval = Interval(numberles, lessonbegin,
lessonend) #
typeL = getNametype(
dayTable[numberLesson]['subject']) # тип предмета
sybject = getNameLes(
dayTable[numberLesson]['subject']) # предмет
extra = dayTable[numberLesson]['teacher'] # учитель
auditory = dayTable[numberLesson]['room'] # кабинет
# Формируем рассписание на день
lesson = Lesson(weekforlesson, dayOfweek, inteval,
sybject, auditory, extra, typeL)
self.addLessonToSchedule(schedule, lesson)
return schedule
def load_all_words(self):
''' Loads words from all available lessons into a list.
Returns:
all_words (list of strings): list of all words
'''
all_words = []
# Load words from all lessons except lesson #0, which is
# practicing 10 random words
for lesson in self.lesson_menu[1:]:
lesson_words = Lesson(lesson).lesson_words
if not lesson_words:
continue
all_words += lesson_words
return all_words
def get_lessons(self, thisgroup):
# получаем все теги с парами
global number_week
massSchedule = []
# Получаем html
url = main_url + "/students/" + thisgroup.name[0] + thisgroup.name[
1] + "?date=" + str(get_two_week())
soup = pars(url)
thisgroup.name = self.get_name(soup)
thisgroup.url = url
table = self.get_table(soup)
if table != None:
for td in table.find_all("tr"):
# Если тэг блоком информации о дате и дне -> получаем, если нет, то это тэг с парами
try:
number_week = get_number_week(td)
day = self.get_day(td)
continue
except Exception:
pass
extra = self.get_extra(td)
subject = self.get_subject(td)
if subject == "":
subject = None
try:
number = int(self.get_number(td).strip())
except ValueError:
pass
auditory = self.get_auditory(td)
start_time = self.get_start_time(td)
end_time = self.get_end_time(td)
if start_time != "" and start_time != None and end_time != "" and end_time != None:
interval = Interval(number, start_time, end_time)
typ = self.get_type(td)
lesson = Lesson(number_week, day, interval, subject,
auditory, extra, typ)
if lesson.subject != None:
self.addLessonToSchedule(massSchedule, lesson)
return massSchedule
def get_timetable(email, start, end):
logger.info("Getting timetable for " + email)
try:
response = requests.get(__base_URL.format(start.strftime(__date_format),
end.strftime(__date_format),
email), timeout=3)
except requests.exceptions.Timeout:
return None
if response is None or response.status_code != 200:
logger.error("RUZ Server doesn't response correctly")
return None
logger.info("Got timetable " + email)
json = response.json()
try:
return Lesson.split_days(Lesson(lesson) for lesson in json)
except:
log = dumps(json, indent=' '*4, sort_keys=True, ensure_ascii=False)
logger.error("Got none from RUZ. Got: "+log)
BotLogic.send_admin_alert(got_wrong_from_ruz+log)
return None
def getSchedule(self, HTML):
soup = BS(HTML.content, 'html.parser')
massSchedule = []
for day in soup.select('.rasp-item'):
# День и месяц дня рассписания
today = day.find('span', {'class': 'rasp-day'}).text
dayOfWeek = day.find('div', {'class': 'rasp-week'}).text
dayOfWeek = GetDayOf(dayOfWeek, 'low')
for TimeTableThisDay in day.select('.rasp-para'):
schedule = TimeTableThisDay.find_all(text=True)
LessonBegin = GetLesBegin(schedule[1])
LessonEnd = GetLesEnd(schedule[1])
NumberLessons = GetNumLessons(LessonBegin, TimeLessonsBegin)
interval = Interval(NumberLessons, LessonBegin, LessonEnd)
subject = getSubjectName(schedule[4])
auditory = schedule[7]
podgroop = getPodgroop(schedule[6])
if int(podgroop) > 0:
typename = '%s (%s п.)' % (getTypeName(
subject, schedule[4]), podgroop)
elif getTypeName(subject, schedule[4]) == '':
typename = None
else:
typename = getTypeName(subject, schedule[4])
extra = getNameTeacher(schedule[8])
lesson = Lesson(week(today), dayOfWeek, interval, subject,
auditory, extra, typename)
self.addLessonToSchedule(massSchedule, lesson)
return massSchedule
def parse_all_schedule(group_name):
clean_schedule()
try:
my_json = requests.post('https://miet.ru/schedule/data?group=' + group_name).text
global ready_json
ready_json = json.loads(my_json)
except ValueError:
my_json = requests.post('https://miet.ru/schedule/data?group=МП-10').text
ready_json = json.loads(my_json)
curr_week = int((datetime.datetime.now() - (datetime.datetime.strptime("2016-08-29", "%Y-%m-%d"))).days / 7)
while curr_week > 4:
curr_week -= 4
mo = []
tu = []
we = []
th = []
fr = []
sa = []
for qu in ready_json['Data']:
if qu['Day'] == 1 and qu['DayNumber'] == curr_week:
mo.append(Lesson(qu['Class']['Name'], qu['Room']['Name'], qu['Time']['Time']))
if qu['Day'] == 2 and qu['DayNumber'] == curr_week:
tu.append(Lesson(qu['Class']['Name'], qu['Room']['Name'], qu['Time']['Time']))
if qu['Day'] == 3 and qu['DayNumber'] == curr_week:
we.append(Lesson(qu['Class']['Name'], qu['Room']['Name'], qu['Time']['Time']))
if qu['Day'] == 4 and qu['DayNumber'] == curr_week:
th.append(Lesson(qu['Class']['Name'], qu['Room']['Name'], qu['Time']['Time']))
if qu['Day'] == 5 and qu['DayNumber'] == curr_week:
fr.append(Lesson(qu['Class']['Name'], qu['Room']['Name'], qu['Time']['Time']))
if qu['Day'] == 6 and qu['DayNumber'] == curr_week:
sa.append(Lesson(qu['Class']['Name'], qu['Room']['Name'], qu['Time']['Time']))
week.append(mo)
week.append(tu)
week.append(we)
week.append(th)
week.append(fr)
week.append(sa)
return week
def getSchedule(self, group, typeP, entity):
url = "https://www.tsuab.ru/schedule/api/timetable.php"
schedule = []
querystring = {"q": group[1], "type": typeP, "dt": getNowWeek()[1], "df": getNowWeek()[0], "wid": "11",
"text": group[0]}
response = requests.request("GET", url, params=querystring)
soup = BS(response.content, 'html.parser')
lessons = soup.findAll('div', {'class': 'timetable-mobile__item'})
fio = None
for lesson in lessons:
timetableRow = lesson.findAll('div', {'class': 'timetable__row'})
if len(timetableRow) > 0:
day = getNameOfTheDayOfTheWeek(lesson.find('div', {'class': 'timetable__day'}).get('data-date'))
week = getNumberWeek(lesson.find('div', {'class': 'timetable__day'}).get('data-date'))
numberLesson=0
for el in timetableRow:
timeLesson = el.findAll('div', {'class': 'timetable-time__value'})
lessonBegin = timeLesson[0].text
lessonEnd = timeLesson[1].text
numberLesson = numberLesson+1
interval = Interval(numberLesson, lessonBegin, lessonEnd)
subject = el.find('div', {'class': 'timetable-lesson__title'}).text.replace('\n', '').strip()
if typeP == 'teacher':
extra = None
else:
extra = el.find('div', {'class': 'timetable-lesson__lecturer'}).text.replace('\n', '').strip()
if typeP == 'teacher':
fio = el.find('div', {'class': 'timetable-lesson__lecturer'}).text.replace('\n', '').strip()
auditory = el.find('div', {'class': 'timetable-lesson__lecture-room'}).text.replace('\n', '').strip()
Type = getNameType(
el.find('div', {'class': 'timetable-lesson__marker'}).get('class')[1].split('--')[1]) if len(
el.find('div', {'class': 'timetable-lesson__marker'}).get('class')) > 1 else None
lesson = Lesson(week, day, interval, subject, auditory, extra, Type)
self.addLessonToSchedule(schedule, lesson)
querystring = {"q": group[1], "type": typeP, "dt": getNextWeek()[1], "df": getNextWeek()[0], "wid": "11",
"text": group[0]}
response = requests.request("GET", url, params=querystring)
soup = BS(response.content, 'html.parser')
lessons = soup.findAll('div', {'class': 'timetable-mobile__item'})
for lesson in lessons:
timetableRow = lesson.findAll('div', {'class': 'timetable__row'})
if len(timetableRow) > 0:
day = getNameOfTheDayOfTheWeek(lesson.find('div', {'class': 'timetable__day'}).get('data-date'))
week = getNumberWeek(lesson.find('div', {'class': 'timetable__day'}).get('data-date'))
numberLesson = 0
for el in timetableRow:
timeLesson = el.findAll('div', {'class': 'timetable-time__value'})
lessonBegin = timeLesson[0].text
lessonEnd = timeLesson[1].text
numberLesson = numberLesson+1
interval = Interval(numberLesson, lessonBegin, lessonEnd)
subject = el.find('div', {'class': 'timetable-lesson__title'}).text.replace('\n', '').replace(' ', '').strip()
if typeP == 'teacher':
extra = None
else:
extra = el.find('div', {'class': 'timetable-lesson__lecturer'}).text.replace('\n', '').strip()
if typeP == 'teacher':
fio = el.find('div', {'class': 'timetable-lesson__lecturer'}).text.replace('\n', '').strip()
auditory = el.find('div', {'class': 'timetable-lesson__lecture-room'}).text.replace('\n', '').strip()
Type = getNameType(
el.find('div', {'class': 'timetable-lesson__marker'}).get('class')[1].split('--')[1]) if len(
el.find('div', {'class': 'timetable-lesson__marker'}).get('class')) > 1 else None
lesson = Lesson(week, day, interval, subject, auditory, extra, Type)
self.addLessonToSchedule(schedule, lesson)
if typeP == 'teacher':
if fio == None:
return []
else:
entity.name = fio.strip()
return schedule
else:
return schedule
def __parse_data(self, data):
b = bs4.BeautifulSoup(data.text, "html.parser")
content = b.select("table tbody tr td")
self.lessons = []
for (index, value) in enumerate(content, start=1):
res = value.select("div")
if len(res) > 1:
try:
lesson = Lesson()
lesson.set_number(index)
lesson.set_name(res[0].getText())
lesson.set_type(res[1].getText())
lesson.set_audience(res[2].getText())
lesson.set_professor(res[3].getText())
lesson.set_group(res[4].getText())
self.lessons.append(lesson)
except IndexError:
pass
def txt2pks(book_name, lesson_count=9999):
###################################################################################
###################################################################################
# Dynamic Vocabulary Dictionary (currently)
# Maybe we can use static Vocabulary Dictionary in the future
# Note that Grammar Templates are static, stored in '/Template'
wordDict = set([])
###################################################################################
###################################################################################
tp = TemParse()
dic = tp.tm.template_strings()
lessons = []
file = open('Text/' + book_name + '.txt')
lesson_id = 0
flag = False
for line in file:
# Always clean before put it into any lesson
line = Utl.cleaned_line(line)
if line != '\n':
if not flag:
flag = True
lesson_id += 1
text = ''
text += line
else:
if flag:
lessons.append(Lesson(lesson_id, text))
flag = False
file.close()
if flag:
lessons.append(Lesson(lesson_id, text))
print len(lessons), ' Lessons in total.'
# no blank line between lessons
os.chdir('Sentence')
file = open(book_name + '.txt', 'w')
for lid in range(1, min(lesson_count + 1, len(lessons) + 1)):
lid -= 1
for s in lessons[lid].sentences:
file.write(s + '\n')
file.close()
os.chdir('..')
cnt = 0
lesson_size = []
# with blank lines between lessons
print 'Start parsing.'
os.chdir('Process')
file = open(book_name + '.txt', 'w')
for lid in range(1, min(lesson_count + 1, len(lessons) + 1)):
lid -= 1
cnt += lessons[lid].numSentences
lesson_size.append(cnt)
lessons[lid].parse(tp)
for i in range(lessons[lid].numSentences):
p = lessons[lid].processes[i]
if p != '':
file.write(lessons[lid].processes[i] + '\n')
else:
file.write('NULL\n')
###########################################################################
wordDict |= set(lessons[lid].wordLists[i])
###########################################################################
file.write('\n')
print 'Lesson', lessons[lid].lesson_id, 'end.'
file.close()
os.chdir('..')
###################################################################################
wordDict = list(wordDict)
###################################################################################
# no blank line between lessons
#os.chdir('Knowledge')
os.chdir(
'KnowledgeGV') # ####################################################
file = open(book_name + '.txt', 'w')
write_list(file, lesson_size)
for lid in range(1, min(lesson_count + 1, len(lessons) + 1)):
lid -= 1
for i in range(lessons[lid].numSentences):
ps = Utl.split(lessons[lid].processes[i], '{}\n')
graList = [dic.index('{' + p + '}') for p in ps]
###########################################################################
vocList = [
10000 + wordDict.index(w) for w in lessons[lid].wordLists[i]
]
###########################################################################
# write_list(file, graList)
write_list(file, graList +
vocList) # ###################################
file.close()
os.chdir('..')
#pg = ProcessGraph()
#pg.add_lessons(Lessons,eid=2)
#pg.create_graph(book_name)
return lessons
# If the user chooses "E" or "e", exit the program
if user_input.lower() == "e":
print("Exiting the program...Bye!")
sys.exit()
# If the user input is valid, cast lesson number into integer
if sf.is_valid(user_input, len(lesson_menu)):
lesson_number = int(user_input)
# For practicing random words (lesson 1), create an instance
# of ShuffledLesson:
if lesson_number == 1:
current_lesson = ShuffledLesson(lesson_menu)
# For all other lessons, create and instance of Lesson:
else:
current_lesson = Lesson(lesson_menu[lesson_number - 1])
# If lesson words file is not found
if not current_lesson.lesson_words:
print('Sorry! '
f'Lesson "{lesson_menu[lesson_number - 1]}" is not found!\n')
# Go back to the main menu
sf.display_main_menu(lesson_menu)
continue
# If lesson file exists, start lesson practice loop
while True:
print(f"\nWelcome to LESSON {lesson_number}!"
f" {lesson_menu[lesson_number - 1]}")
sf.practice_lesson(current_lesson.lesson_words)
def lessons_data():
les = get_lessons_data()
res = []
for l in les:
res.append(Lesson(l).__dict__)
return json.dumps(res)
def __print_lessons(self, lessons, no_lessons_message=noLessonsMessage):
lessons = Lesson.get_printable_lessons(lessons)
User.bot.sendMessage(chat_id=self.__id,
text=lessons if lessons else no_lessons_message)
def getSchedule(self, HTML):
soup = BS(HTML.content.decode('cp1251'), 'html.parser')
select = soup.find('select', {
'name': 'cmbDayOfWeek'
}).findAll('option')
schedule = []
date = []
day = -1
interval = None
weeks = []
newDate = None
itsFix = False
for tableRow in soup.find('table', {
'id': 'tblGr'
}).findAll('tr', {'class': ''}):
if (tableRow != soup.find('table', {
'id': 'tblGr'
}).findAll('tr', {'class': ''})[0]) and len(tableRow) > 2:
elementsTd = tableRow.findAll('td')
if tableRow.text.replace(
'\n', '') == 'Расписание фиксированных занятий':
itsFix = True
if len(elementsTd) > 3:
if itsFix:
newDate = getDate(
elementsTd[0]) # день недели фиксированных занятий
if newDate != None:
date = newDate
week = date[0]
day = date[1]
del elementsTd[0]
newInterval = getInterval(elementsTd[0])
if newInterval != None:
interval = newInterval
del elementsTd[0]
subject = elementsTd[0].text
extra = elementsTd[1].text
auditory = elementsTd[2].text
typeL = '%s (%s.%s)'.format(
getTypeLes(subject.split(' ')[0]), date[2],
date[3])
subject = clearSubject(subject)
lesson = Lesson(week, day, interval, subject, auditory,
extra, typeL)
self.addLessonToSchedule(schedule, lesson)
else:
newDay = getDay(elementsTd[0].text)
if newDay != -1:
day = newDay
del elementsTd[0]
newInterval = getInterval(elementsTd[0])
if newInterval != None:
interval = newInterval
del elementsTd[0]
newWeeks = getWeeks(elementsTd[0])
weeks = newWeeks
if len(newWeeks) == 1:
del elementsTd[0]
subject = elementsTd[0].text
extra = elementsTd[1].text
auditory = elementsTd[2].text
typeL = getTypeLes(subject.split(' ')[0])
subject = clearSubject(subject)
for week in weeks:
lesson = Lesson(week, day, interval, subject,
auditory, extra, typeL)
self.addLessonToSchedule(schedule, lesson)
return schedule