def quiz_map_edit(quiz_id): current_app.logger.debug("quiz_edit. quiz_id - " + str(quiz_id)) quizes = Quiz.get_quizes_by_user_id(current_user.id) for q in quizes: q.quiz_results = QuizResult.get_quiz_results_only_by_quiz_id(q.qid) quiz = Quiz.get_quiz_by_id(quiz_id) quiz_results = QuizResult.get_quiz_results_only_by_quiz_id(quiz_id) def serialize_for_left_menu(q): return { "quiz_results": [qr.serialize_for_statistics for qr in q.quiz_results], "quiz": q.serialize_for_result } jsdata = { "quiz_results": [i.serialize_for_statistics for i in quiz_results], "quizes": [serialize_for_left_menu(q) for q in quizes] } if quiz: if current_user.id == quiz.user_id: return render_template("quiz_map_edit.html", quiz=quiz, quizes=quizes, \ active_page='quiz_edit', jsdata=jsdata, showTour=(not current_user.isTrained())) else: return render_template("auth_failure.html") else: current_app.logger.warning("No quiz found") return render_template("404.html")
def __init__(self): #Create a window and give it a title. self.window = Tk() self.window.title('Simple Quiz') #Create an instance of the quiz class. self.quiz = Quiz() #Labels for the question to appear on the screen. self.question_text = Text(self.window, font="arial 16", width = 40, height = 4, wrap = WORD) self.question_text.insert(1.0, self.quiz.ask_current_question()) self.question_text.pack() #Variable and entry for the user to put in his or her answer. self.answer = StringVar() self.answerEntry = Entry (self.window, textvariable = self.answer) self.answerEntry.pack(side = LEFT) #Bind the return key to enter the answer in the entry. self.answerEntry.focus_set() self.answerEntry.bind("<Return>", self.check_answer) #Label for the instructions for the quiz. self.instructions = StringVar() self.instructions.set('\u21D0 Enter your answer here') self.instrLabel = Label(self.window, textvariable = self.instructions) self.instrLabel.pack(side = LEFT) #Main loop to loop through the initialization method. self.window.mainloop()
def __init__(self): self.window = Tk() self.window.title('Simple Quiz') self.quiz = Quiz() #setting the text box self.question_text = Text(self.window, font="arial 16", width=40, height=4, wrap=WORD) self.question_text.insert(1.0, self.quiz.ask_current_question()) self.question_text.pack() #making the text entry and binding the 'enter' button to it self.answer = StringVar() self.answerEntry = Entry(self.window, textvariable=self.answer) self.answerEntry.pack(side=LEFT) self.answerEntry.focus_set() self.answerEntry.bind("<Return>", self.check_answer) #label self.instructions = StringVar() self.instructions.set('\u21D0 Enter your answer here') self.instrLabel = Label(self.window, textvariable=self.instructions) self.instrLabel.pack(side=LEFT) self.window.mainloop()
def test_init(self): with self.assertRaises(AssertionError): Quiz(["Player1"]) players = ["Player1", "Player2"] quiz = Quiz(players) self.assertEqual(quiz.players, players) self.assertEqual(quiz.current_round, 1)
def update_player_score(quiz: Quiz, player: str, round_num: int) -> None: """Updates the leaderboard with the score for a given player and round_number.""" s = input(f"Enter {player}'s score for round {round_num}: ") try: score = int(s) quiz.add_score(player, score) except ValueError: print(f"Error adding score '{s}' for {player}. Please try again") update_player_score(quiz, player, round_num)
def main(): print( "Would you like to have the pokemon's type displayed? (makes the game easier)" ) show_types = validate_input() print( "Would you like to have to guess all correct answers? (makes the game harder)" ) all_answers = validate_input() quiz = Quiz(show_types, all_answers) quiz.run()
def jupdate(quiz_id): current_app.logger.debug("jupdate. quiz_id - " + str(quiz_id)) quiz = Quiz.get_quiz_by_id(quiz_id) if quiz: if current_user.id == quiz.user_id: schema = { "type": "object", "properties": { "title": {"type": "string", "minLength": 4, "maxLength": 55, "optional": False}, "is_private": {"type": "string", "minLength": 1, "maxLength": 1, "optional": False}, } } v = Draft4Validator(schema) errors = sorted(v.iter_errors(request.json), key = lambda e: e.path) if len(errors) > 0: msg = u"Error : " if len(request.json['title']) < 4 or len(request.json['title']) > 55: msg = u"Title length should be greater than 3 and less than 55 symbols" else: for e in errors: msg = msg + e.message.decode("UTF-8") result = {"status": "ERROR", "message": msg} current_app.logger.warning(result) return jsonify(result) else: title = request.json['title'] is_private = request.json['is_private'] if is_private == 'T': Quiz.update_quiz_by_id(quiz_id, title, None, 'private') else: Quiz.update_quiz_by_id(quiz_id, title, None, 'public') db.session.commit() current_app.logger.debug('Quiz updated. quiz.id - ' + str(quiz_id) + ', title - ' + title) return jsonify({"status" : "OK", "quizid": quiz_id}) else: msg = auth_failure_message + u"update this quiz(id = " + str(quiz_id).decode("UTF-8")+")" current_app.logger.warning(msg) return jsonify({"status" : "ERROR", "message": msg}) else: msg = u"No quiz found with such quiz_id" + str(quiz_id).decode("UTF-8") current_app.logger.warning(msg) return jsonify({"status": "ERROR", "message": msg})
def quiz_list(): current_app.logger.debug("quiz_list") quizes = Quiz.get_quizes_by_user_id(current_user.id) for q in quizes: q.quiz_results = QuizResult.get_quiz_results_only_by_quiz_id(q.qid) lat = 37.4419 lon = -122.1419 if len(quizes) > 0: lat = quizes[0].latitude lon = quizes[0].longitude def serialize_for_left_menu(q): return { "quiz_results": [qr.serialize_for_statistics for qr in q.quiz_results], "quiz": q.serialize_for_result } jsdata = { "latitude": lat, "longitude": lon, "quizes": [serialize_for_left_menu(q) for q in quizes] } return render_template("quiz_list.html", quizes=quizes, jsdata=jsdata, \ active_page="quiz_list", showTour=(not current_user.isTrained()))
def __init__(self): self.user = User() self.course = Course() self.category = Category() self.quiz = Quiz() self.announcement = Announcement() self.discussion = Discussion()
def quiz(quiz_id): current_app.logger.debug("quiz. quiz_id - " + str(quiz_id)) quiz = Quiz.get_quiz_by_id(quiz_id) if quiz: if current_user.id == quiz.user_id: jsdata = { "questions": [i.serialize for i in quiz.questions], "show_private_page": True } if (len(quiz.questions) > 0): QuizResult.start_session(quiz_id, current_user.id) db.session.commit() return render_template('quiz.html', quiz=quiz, jsdata=jsdata) elif quiz.permission == 'public': jsdata = { "questions": [i.serialize_with_answers for i in quiz.questions], "show_private_page": False } return render_template('quiz_public.html', quiz=quiz, jsdata=jsdata) else: return render_template('auth_failure.html') else: current_app.logger.warning("No quiz found") return render_template('404.html')
def select_dir(self): self.timer.stop() self.directory = str(QFileDialog.getExistingDirectory(self, "Select Directory")) self.widget_pubquiz_dir.setText(self.directory) self.pubquiz = Quiz.load_dir_with_ini(self.directory) self.refresh() self.timer.start(3000)
def initQuizInfo(input_file, sectionDict): quizList = [{} for _ in range(len(sectionDict))] with open(input_file, newline = '', encoding = 'utf-8') as csvfile: rows = csv.reader(csvfile) for row in rows: idx = sectionDict[row[1]] quizList[idx][row[0]] = Quiz(quizId = row[0], sectionId = idx, difficulty = row[2]) return quizList
def ask(): quiz = Quiz( initiator=ANONYMOUS_USER_ID, category_id=SPA_GAME_CATEGORY_ID, room_id=SPA_ROOM_ID, backend=BACKEND ) img, answers, question_id, question = quiz.ask_image_type() try: image = Image(img, quiz.room_id, question_id, convert_svg=False) image = str(image).split('/')[-1] return jsonify(url=f'/media/{image}', question_id=question_id, question=question) except (FileTypeError, NotFoundError) as e: return e.msg, e.code except AttributeError: return "Image not found", 404
def get_quiz_result_by_quiz_id_user_id(quiz_id, user_id): hs = Historysession.get_current_history_session_by_user_id_quiz_id(user_id) if hs: qr = QuizResult.query.filter_by(session_id=hs.hsid).first() if qr: qr.quiz = Quiz.get_quiz_only_by_id(qr.quiz_id) return qr else: return None
def jcreate(): current_app.logger.debug("jcreate") quiz = Quiz.create_quiz(current_user.id) db.session.commit() current_app.logger.debug('Quiz created. quiz.id - ' + str(quiz.qid)) return jsonify({"status": "OK", "quizid": quiz.qid})
def create(): current_app.logger.debug("create") quiz = Quiz.create_quiz(current_user.id) db.session.commit() current_app.logger.debug('Quiz created. quiz.id - ' + str(quiz.qid)) return redirect("/quiz/" + str(quiz.qid) + "/#edit")
def check(): data = request.json result = data.get('answer') question_id = data.get('questionId') if result: if result in Quiz.get_answers(question_id=question_id): return jsonify(result='OK') else: return jsonify(result='FAIL')
def __init__(self, window): ''' Create a quiz and GUI frontend for that quiz ''' self.quiz = Quiz() self.question_text = Text(window, font="arial 16", width = 40, height = 4, wrap = WORD) self.question_text.insert(1.0, self.quiz.ask_current_question()) self.question_text.pack() self.answer = StringVar() self.answerEntry = Entry (window, textvariable = self.answer) self.answerEntry.pack(side = LEFT) self.answerEntry.focus_set() self.answerEntry.bind("<Return>", self.check_answer) self.instructions = StringVar() self.instructions.set('\u21D0 Enter your answer here') self.instrLabel = Label(window, textvariable = self.instructions) self.instrLabel.pack(side = LEFT)
def test_remove_quizzes_not_from_multiple_choices(self): """ Removing questions NOT in the list of multiple choices shouldn't change multiple choice list. """ self.mock_listener.expects(never()).question_changed() self.quiz = Quiz(self.QUIZ_POOL[:]) old_multi_choices = self.quiz.multi_choices[:] old_question = self.quiz.question[:] quiz_list = self.QUIZ_POOL[:] for quiz in old_multi_choices: quiz_list.remove(quiz) for quiz in quiz_list: self.quiz.remove_quizzes([quiz]) assert self.quiz.multi_choices == old_multi_choices, \ "Multiple choice options changed after removing other "\ "quizzes. " "New: %s; Old: %s; Removed: %s." % \ (self.quiz.multi_choices, old_multi_choices, quiz) self.mock_listener.verify()
def start_session(quiz_id, user_id): hs = Historysession.start_history_session(user_id) qr = QuizResult.query.filter_by(session_id=hs.hsid).first() if not qr: nquestion = Quiz.get_number_of_active_questions_by_id(quiz_id) qr = QuizResult(hs.hsid, quiz_id, nquestion, None) db.session.add(qr) qr.historysession = hs return qr
def quizes(): result = Quiz() print result print type(result) print len(result) if len(result) > 0: return render_template('quizes.html', quizes=result) else: msg = "No quizes found right now" return render_template('quizes.html', msg=msg)
def main(): init(autoreset=True) # file_path = os.path.join(os.getcwd(), 'src', 'day_17', 'data.txt') quiz_data = get_questions_data_from( "https://opentdb.com/api.php?amount=48&category=18") question_objects = get_questions_from(quiz_data) remove_unreadable_parts_from_list(question_objects) quiz = Quiz(question_objects) run_quiz(quiz)
def setup(base, conf_fn): print '\n**** service initialization ****\n' global room, courseobj, categoryobj, userobj, announcementobj, discussionobj, quizobj, messageobj room = Room(base, conf_fn) courseobj = Course() categoryobj = Category() userobj = Users() announcementobj = Announcement() discussionobj = Discussion() quizobj = Quiz() messageobj = Message()
def quiz(id): print colored(id, 'white', 'on_red') id = int(id) quizes = Quiz() for quiz in quizes: if (quiz.get('id') == id): result = quiz questions = result['question'] break # return redirect(url_for('index')) return render_template('quiz.html', quiz=result, question=questions)
class StartQuiz(web.RequestHandler): quizList = Quiz.get_quiz_list() quizId = None def data_received(self, chunk): pass def get(self): self.render("templates/start.html", quizes=self.quizList) def post(self): pass
def jdelete(quiz_id): current_app.logger.debug("jdelete. quiz_id - " + str(quiz_id)) quiz = Quiz.get_quiz_only_by_id(quiz_id) if quiz: if current_user.id == quiz.user_id: QuizResult.delete_quiz_results_by_quiz_id(quiz_id) Quiz.delete_quiz_by_id(quiz_id) db.session.commit() current_app.logger.debug("Quiz deleted") return jsonify({"status": "OK"}) else: msg = auth_failure_message + u"delete this quiz(id = " + str(quiz_id).decode("UTF-8")+")" current_app.logger.warning(msg) return jsonify({"status": "ERROR", "message" : msg}) else: msg = u"No quiz found with such quiz_id" + str(quiz_id).decode("UTF-8") current_app.logger.warning(msg) return jsonify({"status": "ERROR", "message": msg})
class Controller: #Constructor to create the window and its features. def __init__(self): #Create a window and give it a title. self.window = Tk() self.window.title('Simple Quiz') #Create an instance of the quiz class. self.quiz = Quiz() #Labels for the question to appear on the screen. self.question_text = Text(self.window, font="arial 16", width = 40, height = 4, wrap = WORD) self.question_text.insert(1.0, self.quiz.ask_current_question()) self.question_text.pack() #Variable and entry for the user to put in his or her answer. self.answer = StringVar() self.answerEntry = Entry (self.window, textvariable = self.answer) self.answerEntry.pack(side = LEFT) #Bind the return key to enter the answer in the entry. self.answerEntry.focus_set() self.answerEntry.bind("<Return>", self.check_answer) #Label for the instructions for the quiz. self.instructions = StringVar() self.instructions.set('\u21D0 Enter your answer here') self.instrLabel = Label(self.window, textvariable = self.instructions) self.instrLabel.pack(side = LEFT) #Main loop to loop through the initialization method. self.window.mainloop() #Method that checks if the user was correct or incorrect. def check_answer(self, event): if self.quiz.check_current_answer(self.answer.get()): #Got it right!! self.instructions.set("Good job! Next question ...") else: self.instructions.set("Sorry, the answer was " + self.quiz.get_current_answer()) self.answer.set('') #Go to the next question if it exists self.question_text.delete(1.0, END) if (self.quiz.has_next()): self.quiz.next() self.question_text.insert(1.0, self.quiz.ask_current_question()) else: self.question_text.insert(1.0, 'Sorry, there are no more questions.') self.answerEntry.configure(state='disabled')
class Admin(object): db = None ''' classdocs ''' #constructor def __init__(self): self.user = User() self.course = Course() self.category = Category() self.quiz = Quiz() self.announcement = Announcement() self.discussion = Discussion() def resetDB(self): self.user.reset() self.course.reset() self.category.reset() self.quiz.reset() self.announcement.reset() self.discussion.reset()
def run(): flashcard_loader = FlashcardLoader() flashcard_loader.load_flashcards('data') quiz = Quiz() user_continuing = True while quiz.get_next_flashcard(True) or user_continuing: next_card = quiz.get_next_flashcard() correct_choice = raw_input() quiz.answer_question(next_card, correct_choice)
def initialise_quiz() -> Quiz: """Retrieves quiz parameters from the user and returns a Quiz object based on those parameters.""" try: num_players = int(input("Enter number of players: ")) players = [] for i in range(num_players): player_name = input(f"Enter player {i+1} name: ") players.append(player_name) num_rounds = int(input("Enter number of rounds: ")) round_length = int(input("Enter number of questions in each round: ")) quiz = Quiz(players, num_rounds, round_length) except Exception: print("Got an error trying to initialise the quiz. Please try again.") return initialise_quiz() else: return quiz
class Controller: def __init__(self): self.window = Tk() self.window.title('Simple Quiz') self.quiz = Quiz() #setting the text box self.question_text = Text(self.window, font="arial 16", width=40, height=4, wrap=WORD) self.question_text.insert(1.0, self.quiz.ask_current_question()) self.question_text.pack() #making the text entry and binding the 'enter' button to it self.answer = StringVar() self.answerEntry = Entry(self.window, textvariable=self.answer) self.answerEntry.pack(side=LEFT) self.answerEntry.focus_set() self.answerEntry.bind("<Return>", self.check_answer) #label self.instructions = StringVar() self.instructions.set('\u21D0 Enter your answer here') self.instrLabel = Label(self.window, textvariable=self.instructions) self.instrLabel.pack(side=LEFT) self.window.mainloop() def check_answer(self, event): if self.quiz.check_current_answer(self.answer.get()): #Got it right!! self.instructions.set("Good job! Next question ...") else: self.instructions.set("Sorry, the answer was " + self.quiz.get_current_answer()) self.answer.set('') #Go to the next question if it exists self.question_text.delete(1.0, END) if (self.quiz.has_next()): self.quiz.next() self.question_text.insert(1.0, self.quiz.ask_current_question()) else: self.question_text.insert( 1.0, 'Sorry, there are no more questions.' ) #when there are no more questions to be asked self.answerEntry.configure(state='disabled')
class Controller: ''' Drive an interactive quiz GUI ''' def __init__(self, window): ''' Create a quiz and GUI frontend for that quiz ''' self.quiz = Quiz() self.question_text = Text(window, font="arial 16", width=40, height=4, wrap=WORD) self.question_text.insert(1.0, self.quiz.ask_current_question()) self.question_text.pack() self.answer = StringVar() self.answerEntry = Entry(window, textvariable=self.answer) self.answerEntry.pack(side=LEFT) self.answerEntry.focus_set() self.answerEntry.bind("<Return>", self.check_answer) self.instructions = StringVar() self.instructions.set('\u21D0 Enter your answer here') self.instrLabel = Label(window, textvariable=self.instructions) self.instrLabel.pack(side=LEFT) def check_answer(self, event): ''' Check if the user's current answer is correct ''' if self.quiz.check_current_answer(self.answer.get()): #Got it right!! self.instructions.set("Good job! Next question ...") else: self.instructions.set("Sorry, the answer was " + self.quiz.get_current_answer()) self.answer.set('') #Go to the next question if it exists self.question_text.delete(1.0, END) if (self.quiz.has_next()): self.quiz.next() self.question_text.insert(1.0, self.quiz.ask_current_question()) else: self.question_text.insert(1.0, 'Sorry, there are no more questions.') self.answerEntry.configure(state='disabled')
def jget(quiz_id): current_app.logger.debug("jget. quiz_id - " + str(quiz_id)) quiz = Quiz.get_quiz_by_id(quiz_id) if quiz: if current_user.id == quiz.userid: result = {'status': 'OK'} result.update(quiz.serialize) return jsonify(result) else: msg = auth_failure_message + u"view this quiz(id = " + str(quiz_id).decode("UTF-8")+")" current_app.logger.warning(msg) return jsonify({"status": "ERROR", "message": msg}) else: msg = u"No quiz found with such quiz_id" + str(quiz_id).decode("UTF-8") current_app.logger.warning(msg) return jsonify({"status" : "ERROR", "message": msg})
def test_remove_quizzes_not_from_multiple_choices(self): """ Removing questions NOT in the list of multiple choices shouldn't change multiple choice list. """ self.mock_listener.expects(never()).question_changed() self.quiz = Quiz(self.QUIZ_POOL[:]) old_multi_choices = self.quiz.multi_choices[:] old_question = self.quiz.question[:] quiz_list = self.QUIZ_POOL[:] for quiz in old_multi_choices: quiz_list.remove(quiz) for quiz in quiz_list: self.quiz.remove_quizzes([quiz]) assert self.quiz.multi_choices == old_multi_choices, ( "Multiple choice options changed after removing other " "quizzes. " "New: %s; Old: %s; Removed: %s." % (self.quiz.multi_choices, old_multi_choices, quiz) ) self.mock_listener.verify()
def get_quiz_result_by_id(session_id): quiz_result = QuizResult.query.filter_by(session_id=session_id).first() if quiz_result: quiz_result.quiz = Quiz.get_quiz_only_by_id(quiz_result.quiz_id) quiz_result.question_results = QuestionResult.get_question_results_by_id(session_id) return quiz_result
self.exam.answers.append(answer) print "Fin de l'examen." def get_score(self): """ Correct the exam and print the score. """ self.exam.correct() print u"Ton score est de %d sur %d" % (self.exam.score, self.quiz.length) if self.exam.score != self.quiz.length: print u"Tu t'es trompé sur les mots suivants:" for index in self.exam.mistakes: answer = self.exam.answers[index] word = self.quiz.words[index].word print "%25s --> %s" % (word, answer) else: print u"Magnifique %s!" % self.exam.student if __name__ == "__main__": import os from lesson import Lesson quiz = Quiz("test", 15) lesson = Lesson('mots17', os.path.normpath(os.getcwdu()+'/../mots17')) quiz.add_lesson(lesson) quiz.generate() exam_runner = ExamRunner(u"Eléa", quiz) exam_runner.do_exam() exam_runner.get_score()
class Test_Quiz(unittest.TestCase): """ Unittest for the class Quiz. """ CLASS_TO_TEST = Quiz QUIZ_POOL = [[str(i), str(i * 10)] for i in range(10)] def setUp(self): self.quiz = self.CLASS_TO_TEST(self.QUIZ_POOL[:]) self.mock_listener = Mock() self.quiz.connect("break_time", self.mock_listener.break_time) self.quiz.connect("question_changed", self.mock_listener.question_changed) ## Test add_quizzes and remove_quizzes ## def test_add_and_remove_quizzes(self): """ Check that adding and removing quizzes come back to status quo. """ old_quiz_pool = self.quiz.quiz_pool[:] new_quizzes = [[i, i * 100] for i in range(10, 20)] self.quiz.add_quizzes(new_quizzes) self.quiz.remove_quizzes(new_quizzes) assert old_quiz_pool == self.quiz.quiz_pool, ( "quiz_pool changed after adding then removing " "%s from %s to %s" % (new_quizzes, old_quiz_pool, self.quiz.quiz_pool) ) def test_remove_and_add_quizzes(self): """ Removing all questions and then adding them again. """ old_quiz_pool = self.quiz.quiz_pool[:] # Removing all questions # self.mock_listener.expects(once()).question_changed() self.quiz.remove_quizzes(self.quiz.quiz_pool[:]) self.mock_listener.verify() assert self.quiz.quiz_pool == [], "quiz_pool still has %s after removing all quizzes" % self.quiz.quiz_pool assert self.quiz.question == ["", ""], "Non-empty question left though empty quiz_pool." # Adding original quizzes back. # self.mock_listener.expects(once()).question_changed() self.quiz.add_quizzes(old_quiz_pool[:]) self.mock_listener.verify() assert self.quiz.quiz_pool == old_quiz_pool, "Adding %s to an empty quiz_pool leads to %s." % ( old_quiz_pool, self.quiz.quiz_pool, ) def test_remove_quizzes_from_multiple_choices(self): """ Removing questions in the list of multiple choices. """ self.mock_listener.expects(once()).question_changed() self.quiz.remove_quizzes([self.quiz.multi_choices[0]]) self.mock_listener.verify() self.mock_listener.expects(once()).question_changed() self.quiz.remove_quizzes([self.quiz.multi_choices[-1]]) self.mock_listener.verify() self.mock_listener.expects(once()).question_changed() self.quiz.remove_quizzes([self.quiz.question]) self.mock_listener.verify() assert self.quiz.question in self.quiz.quiz_pool, "Question not in quiz_pool." def test_remove_quizzes_not_from_multiple_choices(self): """ Removing questions NOT in the list of multiple choices shouldn't change multiple choice list. """ self.mock_listener.expects(never()).question_changed() self.quiz = Quiz(self.QUIZ_POOL[:]) old_multi_choices = self.quiz.multi_choices[:] old_question = self.quiz.question[:] quiz_list = self.QUIZ_POOL[:] for quiz in old_multi_choices: quiz_list.remove(quiz) for quiz in quiz_list: self.quiz.remove_quizzes([quiz]) assert self.quiz.multi_choices == old_multi_choices, ( "Multiple choice options changed after removing other " "quizzes. " "New: %s; Old: %s; Removed: %s." % (self.quiz.multi_choices, old_multi_choices, quiz) ) self.mock_listener.verify() ## Single Method Tests ## hint_place_holder = "-" def test_first_hint_should_be_blank(self): """ Test that hint() starts with letters replaced by the place_holder. """ solution = self.quiz.question[self.quiz.answer_to] first_hint = self.quiz.hint() assert first_hint == re.sub("\w", self.hint_place_holder, solution) def test_hint_adds_two_lettres_each_time(self): """ Test that hint starts with letters replaced by underscores and gives two letters each next hint. """ solution = self.quiz.question[self.quiz.answer_to] first_hint = self.quiz.hint() next_hint = first_hint for hint_num in range((first_hint.count(self.hint_place_holder) + 1) // 2): assert next_hint.count(self.hint_place_holder) + hint_num * 2 == first_hint.count(self.hint_place_holder), ( "Hint no. %s gives %s letters, but %s should have been " + "given." ) % ( hint_num, first_hint.count(self.hint_place_holder) - next_hint.count(self.hint_place_holder), hint_num * 2, ) next_hint = self.quiz.hint(next_hint) assert next_hint == solution, 'Final hint ("%s") is not the solution ("%s").' % (next_hint, solution) def test_hint_with_double_lettres(self): """ Run previous test (test_hint_adds_two_lettres_each_time) with '0000' as double letters make comparison of solution and hint non-trivial. """ test_question = ["0000", "0000"] self.quiz.add_quizzes([test_question]) self.quiz.question = test_question self.test_hint_adds_two_lettres_each_time() def test_invalid_previous_hint(self): """ Test that a string which wasn't a hint still gives a valid hint. """ solution = self.quiz.question[self.quiz.answer_to] for first_hint in [self.quiz.hint("a completely wrong answer"), self.quiz.hint("!" + solution[1:])]: for hint_letter, solution_letter in zip(first_hint, solution): assert ( hint_letter == self.hint_place_holder or hint_letter == solution_letter ), 'Hint ("%s") does not match solution ("%s").' % (first_hint, solution) def test_hint_increments_tries(self): """ Test that a hint counts as a try. """ assert self.quiz.tries == 0 self.quiz.hint() assert self.quiz.tries == 1 self.quiz.hint() assert self.quiz.tries == 2 def test_hint_does_not_change_correct_answer(self): assert self.quiz.hint(self.quiz.question[self.quiz.answer_to]) == self.quiz.question[self.quiz.answer_to] def test_check(self): self.mock_listener.expects(once()).question_changed() assert self.quiz.check(self.quiz.question[self.quiz.answer_to]) self.mock_listener.verify() self.mock_listener.expects(once()).question_changed() assert not self.quiz.check("a wrong answer") assert self.quiz.check(self.quiz.question[self.quiz.answer_to]) self.mock_listener.verify() def test__gen_multi_choices(self): multi_choices = self.quiz._gen_multi_choices() assert self.quiz.question in multi_choices, "Question %s not in multiple choice options %s." % ( self.quiz.question, multi_choices, ) def test__gen_multi_choices_has_no_answers_double(self): """Test that no answers are double in multi_choices.""" multi_choices = self.quiz._gen_multi_choices() for i, choice in enumerate(multi_choices): assert not choice in multi_choices[i + 1 :], '"%s" is double in multi_choices ("%s").' % ( choice, multi_choices, ) def test__refit_multichoice_len(self): """ Test length of multi_choices """ self.mock_listener.expects(at_least_once()).question_changed() assert len(self.quiz.multi_choices) == self.quiz.DEFAULT_MULTICHOICE_LEN self.quiz.remove_quizzes(self.quiz.quiz_pool[self.quiz.DEFAULT_MULTICHOICE_LEN :]) assert len(self.quiz.multi_choices) == self.quiz.DEFAULT_MULTICHOICE_LEN, ( "self.quiz.multi_choices has wrong length: %s instead of %s." % (len(self.quiz.multi_choices), self.quiz.DEFAULT_MULTICHOICE_LEN) ) self.quiz.remove_quizzes(self.quiz.quiz_pool[3 : self.quiz.DEFAULT_MULTICHOICE_LEN]) assert len(self.quiz.multi_choices) == 3, "self.quiz.multi_choices has wrong length: %s instead of 3." % len( self.quiz.multi_choices ) self.quiz.remove_quizzes(self.quiz.quiz_pool[:3]) assert len(self.quiz.multi_choices) == 1 self.mock_listener.verify() def test_get_answer_to_question(self): answer_to = self.quiz.answer_to ask_from = self.quiz.ask_from for question_pair in self.QUIZ_POOL: assert question_pair[answer_to] == self.quiz.get_answer_to_question( question_pair[ask_from] ), "%s should be answer to question %s." % (question_pair[answer_to], question_pair[ask_from]) assert ( self.quiz.get_answer_to_question("asdfasdf") == None ), "Non-existant question 'asdfasdf' should return 'None'." def test_get_question_to_answer_from_multichoices(self): answer_to = self.quiz.answer_to ask_from = self.quiz.ask_from for question_pair in self.quiz.multi_choices: assert question_pair[ask_from] == self.quiz.get_question_to_answer_from_multichoices( question_pair[answer_to] ), "%s should be question to answer %s." % (question_pair[ask_from], question_pair[answer_to]) assert ( self.quiz.get_question_to_answer_from_multichoices("asdfasdf") == None ), "Non-existant answer 'asdfasdf' should return 'None'." def test_get_question_to_answer(self): answer_to = self.quiz.answer_to ask_from = self.quiz.ask_from for question_pair in self.quiz.multi_choices: assert question_pair[ask_from] == self.quiz.get_question_to_answer( question_pair[answer_to] ), "%s should be question to answer %s." % (question_pair[ask_from], question_pair[answer_to]) assert ( self.quiz.get_question_to_answer("asdfasdf") == None ), "Non-existant answer 'asdfasdf' should return 'None'." def test_notify(self): """ Tests that new_question and next notify properly. """ # test_new_question # for i in range(self.quiz.session_length * 2): self.mock_listener.expects(once()).question_changed() self.quiz.new_question() self.mock_listener.verify() # test_next # for i in range(self.quiz.session_length - 1): self.mock_listener.expects(once()).question_changed() self.quiz.next() self.mock_listener.verify() self.mock_listener.expects(once()).question_changed() self.mock_listener.expects(once()).break_time() self.quiz.next() self.mock_listener.verify() def test_set_question_direction(self): self.quiz.set_question_direction(0) assert self.quiz.ask_from == 0 and self.quiz.answer_to == 1 self.quiz.set_question_direction(0) assert self.quiz.ask_from == 0 and self.quiz.answer_to == 1 self.quiz.set_question_direction(1) assert self.quiz.ask_from == 1 and self.quiz.answer_to == 0
def run_quiz(quiz: Quiz): clear_console() print(quiz) while True: question_object = quiz.get_user_a_question() correct_answer = question_object.correct_answer # question = question_object.question incorrect_answers = question_object.incorrect_answers quiz.display_list_of_possible_answers(incorrect_answers, correct_answer) user_answer = quiz.ask_user_an_answer("Answer: ") result = quiz.get_result_from_user_answer(user_answer, correct_answer) string_false_answer = f"{Fore.RED}False!\n{Fore.WHITE}The correct answer is:{Fore.GREEN} {correct_answer}\n" string_correct_answer = f"{Fore.GREEN}Correct!\n" if result: clear_console() print("*" * 55) print(string_correct_answer) quiz.player_score += 1 else: clear_console() print(string_false_answer) quiz.player_lives -= 1 print("*" * 55) if quiz.check_user_has_done_every_question(): clear_console() print( f"{Fore.BLUE} Congratulations! You finished the whole Quiz without losing!!" ) quiz.print_player_score() break if not quiz.player_lives: quiz.print_player_score() print( f"{Fore.RED}No more lives left...{Fore.RESET} Do you want to try again? (y/n)" ) play_again() quiz.print_player_score()
from quiz import Quiz questions_prompt = [ "What color are apples?\n(a) Red/Green\n(b) Purple\n(c) Orange\n\n", "What color are Bananas?\n(a) Teal\n(b) Magenta\n(c) Yellow\n\n", "What color are strawberries?\n(a) Yellow\n(b) Red\n(c) blue\n\n" ] questions = [ Quiz(questions_prompt[0], "a"), Quiz(questions_prompt[1], "c"), Quiz(questions_prompt[2], "b"), ] def run_test(questions): score = 0 for question in questions: answer = input(question.prompt) if answer == question.answer: score += 1 print("You got " + str(score) + "/" + str(len(questions)) + "correct") run_test(questions)
from question import Question from quiz import Quiz if __name__ == '__main__': q1 = Question('En iyi programlama dili?',['C#','Python','Java','Javascript'],'Python') q2 = Question('En sevilen programlama dil?',['C#','Python','Java','Javascript'],'Java') q3 = Question('En kolay programlama dil?',['C#','Python','Java','Javascript'],'C#') questions = [q1,q2,q3] quiz = Quiz(questions) quiz.load_question()
def play_quiz(): play = True while play: question_count, max_number = get_quiz_preference() new_quiz = Quiz(0, 0) if (not question_count) and (not max_number): new_quiz = Quiz() elif question_count and max_number: new_quiz = Quiz(question_count=question_count, max_num=max_number) else: new_quiz = Quiz( question_count=question_count) if question_count else Quiz( max_num=max_number) new_quiz.take_quiz() if input("Play again? <Enter> to play again, QUIT to exit: ").upper( ) == "QUIT": print("Bye now!") play = False else: clear_screen()
def ask_quiz(name): result = Quiz.fromDict(quizes.find_one({'name': name})).questions() return app.response_class(response=json.dumps(result, default=toJSON), status=200, mimetype='application/json')
from quiz import Quiz from database import Question as DBQ if __name__ == '__main__': quiz = Quiz() for q in quiz.get_all_quiz(): qdb = DBQ.get_or_none(DBQ.json_file == q.short_filepath) if qdb is None: quiz.publish(q) else: if q.checksum != qdb.last_checksum: # Удаляем сообщения из канала quiz.delete_messages(qdb.message_id) # Удаляем запись из БД qdb.delete_instance() quiz.publish(q)
def new_quiz(): quiz = Quiz.fromDict(request.get_json()) quizes.insert_one(json.loads(json.dumps(quiz, default=toJSON))) return app.response_class(status=201, headers=[('location', '/quiz/' + quiz.name)])
master_gui = tk.Tk() master_gui.title("VQM") master_gui.geometry("800x600") gui = OperatorGUI(master_gui, show) gui.pack() master_gui.mainloop() print("--Volani Quiz Master: Main Menu--") quizzes = [] quizzes.append( Quiz("Test Quiz", [ Question("Test Question, B is Correct?", ["Incorrect", "Correct", "Inccorect"], 2, 10) ], r"^[1-3]$")) while True: choice = present_menu_get_response(["Create Quiz", "Run Show"]) if choice == 1: print("Enter quiz title: ") title = input() print("Enter answer regex: ") answer_regex = input() input_valid = False questions = []
class UserLogged(User): def __init__(self, user: User, dbID, username): super().__init__(user.socket, user.address) self.uuid = user.uuid self.dbID = dbID self.username = username self.quiz = None def __repr__(self): return str(self.address) + ' ' + str(self.uuid) + ' ' + self.username def handle(self): r = self.socket.recv(3) if r != b'': headerType, size = HeaderParser.decode(r) data = Protocol.decode(self.socket.recv(size)) h, p = None, None if headerType == Header.DIS: raise socket.error('Disconnect') elif headerType == Header.ALI: r = requests.get(URL.local + 'quizzes-categories') if r.status_code == 200: j = r.json() l = [] for x in j: l.append(x['category_name']) h, p = Protocol.encode(Header.LIS, quizes=l) Logger.log('Category request') else: h, p = Protocol.encode(Header.ERR, msg='Cant get categories') Logger.log('Category request failed') elif headerType == Header.STR: if data['category'] == []: r = requests.get(URL.local + 'quizzes-categories') r2 = requests.get(URL.local + 'stats', params={'userid': self.dbID}) if r.status_code == 200 and r2.status_code == 200: cat = r.json() stat = r2.json() ret = [] for x in stat: for y in cat: if x['quizid'] == y['id']: print('abc') ret.append({ 'category': y['category_name'], 'score': x['score'] }) break if ret != []: h, p = Protocol.encode(Header.STA, stats=ret) else: h, p = Protocol.encode(Header.ERR, msg='empty') Logger.log('Stats request ' + str(self.dbID)) else: Logger.log('Stats request failed' + str(self.dbID)) else: r = requests.get(URL.local + 'top-stats', params={'category': data['category']}) if r.status_code == 200: stat = r.json() if stat != []: h, p = Protocol.encode(Header.STA, stats=stat) else: h, p = Protocol.encode(Header.ERR, msg='empty') Logger.log('Stats request ' + str(self.dbID)) else: Logger.log('Stats request failed' + str(self.dbID)) elif headerType == Header.QUI: r = requests.get(URL.local + 'quizzes', params={'category_name': data['category']}) if r.status_code == 200 and self.quiz == None: j = r.json() qq = [] for x in j: q = x['Question']['question'] cor = None a = x['Answers'] for y in a: if y['id'] == x['Question']['correct_answer']: cor = y['answer'] b = [] for i in range(4): b.append(str(a[i]['answer'])) qq.append(Question(q, b, str(cor))) self.quiz = Quiz(qq, j[0]['Question']['quizid']) question = self.quiz.next() h, p = Protocol.encode(Header.QUE, question=question.question, answers=question.answers, correct=question.correct) Logger.log('Quiz begin' + str(self.dbID)) else: h, p = Protocol.encode(Header.ERR, msg='Cant begin quiz') Logger.log('Quiz request fail ' + str(self.dbID)) elif headerType == Header.NXT: if self.quiz != None: question = self.quiz.next() h, p = Protocol.encode(Header.QUE, question=question.question, answers=question.answers, correct=question.correct) Logger.log('next question ' + str(self.dbID)) else: h, p = Protocol.encode(Header.ERR, msg='Invalid request') Logger.log('next question fail ' + str(self.dbID)) elif headerType == Header.END: if self.quiz != None: r = requests.patch(URL.local + 'stats', json={ 'userid': self.dbID, 'quizid': self.quiz.quizid, 'score': data['score'] }) self.quiz = None h, p = Protocol.encode(Header.ACK, msg='Quiz completed') Logger.log('Quiz end ' + str(self.dbID)) else: h, p = Protocol.encode(Header.ERR, msg='Invalid end request') Logger.log('Quiz end request fail ' + str(self.dbID)) if h != None and p != None: self.transfer(h, p) return None