def put(self, question_uuid):
"""
PUT handler
"""
edit_question = Question(**api.payload)
edit_question.uuid = question_uuid
edit_question.save()
def new(request, lang):
if request.method == 'POST':
participant_form = ParticipantForm(request.POST)
if participant_form.is_valid():
participant = participant_form.save(commit=False)
participant.ip = get_client_ip(request),
participant.ua = get_client_ua(request),
participant.save()
sequences = Sequence.objects.all()
pairs = Pair.objects.all()
if len(sequences) > len(pairs):
generate_pairs(len(sequences) - len(pairs) + 1)
pairs = Pair.objects.all()
send_email(template='email/pairs_empty.html')
pairs = pairs[:len(sequences)]
for sequence, pair in zip(sequences, pairs):
question = Question(participant=participant,
left=pair.left,
right=pair.right,
sequence=sequence,
answered=False)
question.save()
pair.delete()
request.session['participant_id'] = participant.id
#messages.add_message(request, messages.SUCCESS, u'Новый участник создан')
return redirect(reverse('core.views.index', kwargs={'lang': lang}))
#messages.add_message(request, messages.ERROR, u'Не удалось создать участника')
return redirect(reverse('core.views.index', kwargs={'lang': lang}))
def test_question_check_answer_with_numbers(self):
q = Question()
q['correct'] = u'90,000'
self.assertTrue(q.check_answer('90,000'))
self.assertTrue(not q.check_answer('60,000'))
q['correct'] = u'Terminator 2'
self.assertTrue(q.check_answer('Terminatur 2'))
def test_question_check_answer_with_numbers(self):
q = Question()
q['correct'] = u'90,000'
self.assertTrue(q.check_answer('90,000'))
self.assertTrue(not q.check_answer('60,000'))
q['correct'] = u'Terminator 2'
self.assertTrue(q.check_answer('Terminatur 2'))
def setUp(self):
"""Create questions for testing."""
grade_test = Grade(name="Grade Example")
grade_test.save()
subject_test = Subject(name="addition", grade=grade_test)
subject_test.save()
question1 = Question(question_content='what is 1 + 1?',
answer_content='This is an addition question',
subject=subject_test)
question1.save()
def save(self):
data = self.cleaned_data
str_title = data['title']
str_question = data['question']
str_tags= data['tags']
tags = str_tags.split(',')
q = Question(user = self.user,title=str_title,question=str_question)
q.save()
for t in tags:
Tag.objects.add_tag(q,t.strip())
return q
def question_create(request):
if request.method == 'POST':
form = QuestionForm(request.POST)
if form.is_valid():
question = Question(title=form.cleaned_data['title'],
body=form.cleaned_data['body'],
user=request.user)
question.save()
return HttpResponseRedirect(
reverse_lazy('question_detail', kwargs={'pk': question.pk}))
else:
form = QuestionForm()
context = {'form': form}
return render(request, 'core/question_create.html', context)
def create(self, data):
instance = Question()
instance.question = data.get('question')
instance.answer = data.get('answer')
instance.parameter = data.get('parameter')
instance.answer_text = data.get("answer_text")
instance.save()
return instance
def setUp(cls):
"""
Data setup for Feedback Question Unit test cases
"""
role = Role(role="organizer")
role.save()
user = User.objects.create_user(email="*****@*****.**",
password="******")
role_obj = Role.objects.get(role="organizer")
user_profile_obj = UserProfile.objects.create(
user=user,
name="*****@*****.**",
contact_number="9999911111",
organization="organization",
address="Bangalore",
role=role_obj)
user_profile_obj.save()
data = dict(email="*****@*****.**", password="******")
login_response = cls.client.post('/authentication/login',
json.dumps(data),
content_type='application/json')
cls.user_id = login_response.data['data']['user']['user_id']
cls.token = login_response.data['data']['access']
cls.end_point = "/core/feedback-questions/"
cls.question = Question(question="Demo question1 ?")
cls.question.save()
def dummy_questions(course: Course):
"""
Creates a collection of dummy questions
:param course: The course for which the questions will be generated
"""
return [
Question(uuid='50e46980-6c4e-450c-853e-efca2357a23a',
course=course,
question='2 + 2 ='),
Question(uuid='29f47817-350f-4893-9372-50db5185618c',
course=course,
question='3 + 3 ='),
Question(uuid='29f47817-350f-4893-9372-50db5185618c',
course=course,
question='4 + 4 =')
]
def get_question(self):
"""
Selects a question at random
"""
sample = {'$sample': {'size': 1}}
result = Question.objects(course=self.course).aggregate(sample)
document = next(result, None)
return Question.objects.get(uuid=document['_id']) if document else None
def setUp(cls):
"""
Data setup for Feedback Unit test cases
"""
role = Role(role="organizer")
role.save()
role2 = Role(role="subscriber")
role2.save()
user = User.objects.create_user(email="*****@*****.**",
password="******")
cls.role_obj = Role.objects.get(role="organizer")
user_profile_obj = UserProfile.objects.create(
user=user,
name="*****@*****.**",
contact_number="9999911111",
organization="organization",
address="Bangalore",
role=cls.role_obj)
user_profile_obj.save()
content2 = {
"email": "*****@*****.**",
"name": "user 20",
"password": "******",
"contact": "9999911111",
"address": "Bangalore",
"role": "subscriber",
"organization": "Eventhigh"
}
response = cls.client.post('/authentication/registration',
json.dumps(content2),
content_type='application/json')
cls.user_id = response.data['data']['user']['user_id']
cls.token = response.data['data']['access']
cls.end_point = "/core/feedback/"
cls.event_type = EventType(type="test")
cls.event_type.save()
cls.event = Event(name="test_event",
type=cls.event_type,
description="New Event",
date="2020-04-02",
time="12:38:00",
location="karnal",
subscription_fee=499,
no_of_tickets=250,
images="https://www.google.com/images",
sold_tickets=0,
external_links="google.com",
event_created_by_id=User.objects.filter()[0].id)
cls.event.save()
cls.question = Question(question="Demo question1 ?")
cls.question.save()
def test_score_single(self):
"""
Test for score() when only a single answer is correct
"""
answers = [
AnswerChoice(uuid=uuid4(), answer='0', checked=False),
AnswerChoice(uuid=uuid4(), answer='4', checked=True),
AnswerChoice(uuid=uuid4(), answer='5', checked=False)
]
question = Question(uuid=uuid4(),
question='2+2=?',
answers=answers,
multiple=False)
for answer in answers:
expected_score = 1.0 if answer.checked else 0.0
score = question.score([answer.uuid])
self.assertAlmostEqual
(expected_score, score)
def add_question(request):
"""adds a question authored by the pk of the user"""
# breakpoint()
if request.method == 'POST':
form = QuestionCreateForm(request.POST)
if form.is_valid():
title = form.cleaned_data['title']
content = form.cleaned_data['content']
content = markdown.markdown(content)
content = bleach.clean(content, markdown_tags, markdown_attrs)
new_question = Question(author=request.user,
content=content,
title=title)
new_question.save()
return redirect(to='home')
else:
form = QuestionCreateForm()
return render(request, 'new-question.html', {
'form': form,
})
def test_score_multiple(self):
"""
Test for score() in the multi-select scenario. Coursera-style scoring is expected.
"""
answers = [
AnswerChoice(uuid=uuid4(), answer='Panama', checked=True),
AnswerChoice(uuid=uuid4(), answer='Montreal', checked=False),
AnswerChoice(uuid=uuid4(), answer='Canada', checked=True),
AnswerChoice(uuid=uuid4(), answer='Overfitting', checked=False)
]
question = Question(question="Which of the following are countries?",
answers=answers,
multiple=True)
def get_uuids(*indexes):
return [answers[idx].uuid for idx in indexes]
score = question.score([])
self.assertAlmostEqual(0.5, score)
score = question.score(get_uuids(0, 2))
self.assertAlmostEqual(1.0, score)
score = question.score(get_uuids(0, 1, 3))
self.assertAlmostEqual(0.25, score)
score = question.score(get_uuids(0, 2, 3))
self.assertAlmostEqual(0.75, score)
def get_question(self):
"""
Selects the closest question to the student's current ability level
"""
if not self.level:
self._fetch_level()
# TODO: Avoid repetition
question = Question.objects(
course=self.course,
level__gte=self.level).order_by('level').first()
if not question:
question = Question.objects.order_by('-level').first()
return question
def new(request, lang):
if request.method == 'POST':
participant_form = ParticipantForm(request.POST)
if participant_form.is_valid():
participant = participant_form.save(commit=False)
participant.ip = get_client_ip(request),
participant.ua = get_client_ua(request),
participant.save()
sequences = Sequence.objects.all()
pairs = Pair.objects.all()
if len(sequences) > len(pairs):
generate_pairs(len(sequences) - len(pairs) + 1)
pairs = Pair.objects.all()
send_email(template='email/pairs_empty.html')
pairs = pairs[:len(sequences)]
for sequence, pair in zip(sequences, pairs):
question = Question(
participant=participant,
left=pair.left,
right=pair.right,
sequence=sequence,
answered=False
)
question.save()
pair.delete()
request.session['participant_id'] = participant.id
#messages.add_message(request, messages.SUCCESS, u'Новый участник создан')
return redirect(reverse('core.views.index', kwargs={'lang': lang}))
#messages.add_message(request, messages.ERROR, u'Не удалось создать участника')
return redirect(reverse('core.views.index', kwargs={'lang': lang}))
def create_questions(form):
""" Create a fake question for a form """
type_list = list(Type)
for _ in range(DEFAULT_NUMBER_QUESTIONS):
_type = random.choice(type_list)
question = Question(form=form, name=fake.profile()['username'],
question=fake.lexify(text='Random Question: ??????????'), input_type=_type.value)
question.full_clean()
question.save()
create_options(question)
def test_question_check_answer(self):
q = Question()
q['correct'] = u'Yes'
self.assertTrue(q.check_answer('yes'))
self.assertTrue(not q.check_answer('no'))
q['alternatives'] = [u'Maybe', u'Perhaps']
self.assertTrue(q.check_answer('yes', alternatives_are_correct=True))
self.assertTrue(q.check_answer('maybe', alternatives_are_correct=True))
self.assertTrue(q.check_answer('perhaps', alternatives_are_correct=True))
self.assertTrue(not q.check_answer('inte', alternatives_are_correct=True))
# now with edit distance
# too short
self.assertTrue(not q.check_answer('yeah'))
# sufficiently long
q['correct'] = u'Correct'
self.assertTrue(q.check_answer('corect'))
self.assertTrue(not q.check_answer('korecct'))
q['correct'] = u'Tupac Shakur'
self.assertTrue(q.check_answer('tupak Shacur'))
self.assertTrue(not q.check_answer('Toopack shakure')) # too wrong
def delete(self, question_uuid):
"""
DELETE handler
"""
Question.objects(uuid=question_uuid).delete()
def setup_assignment(vault_content_path, output_cabinet_path, board_id,
school_id, standard_number, subject_id, aql_chapter_id,
aql_metadata_file_number):
# first validate the arguments against the exiting database
board = Board.objects.get(pk=board_id)
school = School.objects.get(pk=school_id)
standard = Standard.objects.get(number=standard_number)
subject = Subject.objects.get(pk=subject_id)
aql_chapter = Chapter.objects.get(pk=aql_chapter_id)
# build path to aql data file
common_path = os.path.join(str(board_id), str(school_id),
str(standard_number), str(subject_id))
aql_data_file_dir = os.path.join(vault_content_path, common_path)
aql_data_file_path = os.path.join(
aql_data_file_dir,
str(aql_metadata_file_number) + DATA_FILE_EXT)
with open(aql_data_file_path, 'r') as f:
aql_data_raw = f.read().strip()
print 'Processing AQL data'
aql_data_raw = aql_data_raw_process(aql_data_raw)
aql_data = json.loads(aql_data_raw)
aql_data = aql_data_process(aql_data)
# aql data has revision, questions and description
# transfer the revision, put the description in db and then deal with the questions
print 'Creating new AQL in db'
new_aql = AssignmentQuestionsList(
school=school,
standard=standard,
subject=subject,
chapter=aql_chapter,
number=1, # this will be validated at the end
description=aql_data['description'])
new_aql.save()
print 'Putting AQL metadata into cabinet'
aql_output_dir = os.path.join(output_cabinet_path, 'aql_meta', common_path)
try:
os.makedirs(aql_output_dir)
except OSError:
# the output dir already exists, no need to do anything
pass
with open(os.path.join(aql_output_dir,
str(new_aql.pk) + DATA_FILE_EXT), 'w') as f:
f.write(dump_json_string(get_aql_data_for_cabinet(aql_data)))
# finally, copy over the img folder too - and apply watermarks
print 'Copying AQL images'
copy_img_folder(aql_data_file_dir, aql_output_dir)
# now lets grab the question data too
questions = aql_data['questions']
question_data_file_path_stub = os.path.join(vault_content_path,
common_path)
for chapter_block in questions:
chapter_id = chapter_block['chapter']
db_chapter_id = chapter_block.get('chapter_db', chapter_id)
print 'Encountered db chapter id:', db_chapter_id
chapter = Chapter.objects.get(pk=db_chapter_id)
question_data_file_path_stub_with_chapter = os.path.join(
question_data_file_path_stub, str(chapter_id))
question_container_data_file_path_stub = os.path.join(
question_data_file_path_stub_with_chapter, 'containers')
question_subpart_data_file_path_stub = os.path.join(
question_data_file_path_stub_with_chapter, 'subparts')
print 'Prepping output dirs in cabinet for question metadata files'
question_container_output_dir = os.path.join(output_cabinet_path,
'questions', 'containers',
common_path,
str(chapter.pk))
try:
os.makedirs(question_container_output_dir)
except OSError:
# the output dir already exists, no need to do anything
pass
question_subpart_output_dir = os.path.join(output_cabinet_path,
'questions',
'raw', common_path,
str(chapter.pk))
try:
os.makedirs(question_subpart_output_dir)
except OSError:
# the output dir already exists, no need to do anything
pass
for question in chapter_block['numbers']:
print 'Processing data for question:', question
is_removed = False
if ('removed' in chapter_block) and (question
in chapter_block['removed']):
print 'ALERT: This question is to be removed from the aql'
is_removed = True
question_container_data_file_path = os.path.join(
question_container_data_file_path_stub,
str(question) + DATA_FILE_EXT)
with open(question_container_data_file_path, 'r') as f:
question_container_data_raw = f.read().strip()
question_container_data_raw = question_container_data_raw_process(
question_container_data_raw)
question_container_data = json.loads(question_container_data_raw)
question_container_data = question_container_data_process(
question_container_data)
# question container data has subparts and tags (and other metadata which is to be carried over into cabinet)
print 'Creating new question in db'
new_question = Question(school=school,
standard=standard,
subject=subject,
chapter=chapter)
new_question.save()
add_question_tags(new_question, question_container_data['tags'])
reflect_subparts_in_db(new_question,
question_container_data['subparts'])
if not is_removed: # still want to preserve the question in the question bank, just dont want to include it in the aql
print "Adding newly created question to new AQL's question list"
new_aql.questions.add(new_question)
with open(
os.path.join(question_container_output_dir,
str(new_question.pk) + DATA_FILE_EXT),
'w') as f:
f.write(
dump_json_string(
get_question_container_data_for_cabinet(
question_container_data)))
# now lets handle the subparts for this question
subparts = question_container_data['subparts']
for subpart in subparts:
print 'Processing data for subpart:', subpart
question_subpart_data_file_path = os.path.join(
question_subpart_data_file_path_stub,
str(subpart) + DATA_FILE_EXT)
with open(question_subpart_data_file_path, 'r') as f:
question_subpart_data_raw = f.read().strip()
question_subpart_data_raw = question_subpart_data_raw_process(
question_subpart_data_raw)
question_subpart_data = json.loads(question_subpart_data_raw)
question_subpart_data = question_subpart_data_process(
question_subpart_data)
with open(
os.path.join(question_subpart_output_dir,
str(subpart) + DATA_FILE_EXT), 'w') as f:
f.write(
dump_json_string(
get_question_subpart_data_for_cabinet(
question_subpart_data)))
# finally, copy over the img folder too - and apply watermarks - do this at chapter level only to avoid repetition
print 'Copying container images'
copy_img_folder(question_container_data_file_path_stub,
question_container_output_dir)
print 'Copying subpart images'
copy_img_folder(question_subpart_data_file_path_stub,
question_subpart_output_dir)
# now validate the number of the aql we just created in the db
while True:
try:
check_duplicate_aql_identifiers(new_aql)
except DuplicateAqlIdentifierError:
new_aql.number += 1
new_aql.save()
continue
print 'Settled on number %s for new aql' % new_aql.number
break
return new_aql.pk
def get(self, question_uuid):
"""
GET handler
"""
return Question.objects(uuid=question_uuid).first()
def get(self, course_uuid):
"""
Retrieves the list of questions for the course
"""
return list(Question.objects(course=course_uuid).all())
def test_simple_question_update(self):
"""
Pass in a simple JSON file.
"""
question_id = 123
test_question = Question(id=question_id)
test_question.save()
related_options = Option.objects.filter(question=test_question)
assert (len(related_options) == 3)
user = User.objects.create(username='******')
user.set_password('password')
user.save()
self.client = Client()
logged_in = self.client.login(username='******', password='******')
assert (logged_in)
data = {
"name":
question_id,
"correct":
"option_content_2",
"question_content": [
{
"text": "This is a test question",
"inline": False
},
],
"option_content_1": [{
"text": "option 1",
"inline": False
}],
"option_content_2": [{
"text": "option 2",
"inline": False
}],
"option_content_3": [{
"text": "option 3",
"inline": False
}],
"additional_information": [],
"answer_explanation_content": [
{
"text": "This is the answer",
"inline": False
},
]
}
response = self.client.post('/question_content/',
json.dumps(data),
content_type="application/json")
assert (response.status_code == 200)
question = Question.objects.get(id=123)
assert (json.loads(
question.question_content_json) == data["question_content"])
assert (question.question_content == "<p>This is a test question</p>")
assert (json.loads(
question.answer_content_json) == data["answer_explanation_content"]
)
assert (question.answer_content == "<p>This is the answer</p>")
# fetch the associated options
options = Option.objects.filter(question=question)
# assumes questions are created in the order that is created
assert (len(options) == 3)
assert (json.loads(
options[0].content_json) == data["option_content_1"])
assert (options[0].content == "<p>option 1</p>")
assert (json.loads(
options[1].content_json) == data["option_content_2"])
assert (options[1].content == "<p>option 2</p>")
assert (json.loads(
options[2].content_json) == data["option_content_3"])
assert (options[2].content == "<p>option 3</p>")
new_data = {
"name":
question_id,
"correct":
"option_content_2",
"question_content": [
{
"text": "new question text",
"inline": False
},
],
"option_content_1": [{
"text": "new option 1",
"inline": False
}],
"option_content_2": [{
"text": "new option 2",
"inline": False
}],
"option_content_3": [{
"text": "new option 3",
"inline": False
}],
"additional_information": [],
"answer_explanation_content": [
{
"text": "new answer text",
"inline": False
},
]
}
response = self.client.post('/question_content/',
json.dumps(new_data),
content_type="application/json")
assert (response.status_code == 200)
question = Question.objects.get(id=123)
assert (json.loads(
question.question_content_json) == new_data["question_content"])
assert (question.question_content == "<p>new question text</p>")
assert (json.loads(question.answer_content_json) ==
new_data["answer_explanation_content"])
assert (question.answer_content == "<p>new answer text</p>")
# fetch the associated options
options = Option.objects.filter(question=question)
# assumes questions are created in the order that is created
assert (len(options) == 3)
assert (json.loads(
options[0].content_json) == new_data["option_content_1"])
assert (options[0].content == "<p>new option 1</p>")
assert (json.loads(
options[1].content_json) == new_data["option_content_2"])
assert (options[1].content == "<p>new option 2</p>")
assert (json.loads(
options[2].content_json) == new_data["option_content_3"])
assert (options[2].content == "<p>new option 3</p>")
def create_question(header, score, evaluation):
question = Question(question_text=header, score=score, evaluation=evaluation)
question.save()
def handle(self, *args, **options):
for current in options['tsv_file']:
with open(current) as input_file:
results = {}
parser_state = ""
current_question_id = 0
for row in input_file.readlines():
row = row.strip()
tokens = row.split("\t")
if tokens[0] == "##" or tokens[0] == "":
continue
elif parser_state == "" and tokens[0] == "Quiz":
results["quiz"] = tokens[1]
parser_state = "parsed_quiz"
elif parser_state == "parsed_quiz" and tokens[0] == "Timed":
results["timed"] = tokens[1]
parser_state = "parsed_timed"
elif parser_state == "parsed_timed" and tokens[
0] == "Max Time In Mins":
results["max_time_in_mins"] = tokens[1]
parser_state = "parsed_max_time"
elif parser_state == "parsed_max_time" and tokens[
0] == "Quiz Structure":
parser_state = "parse_quiz_structure"
elif parser_state == "parse_quiz_structure":
if "quiz_structure" not in results:
results["quiz_structure"] = []
# change state to parsing question bank
if tokens[0] == "Category":
parser_state = "parse_qb"
continue
# update quiz structure
current_qs = {}
k, v = tokens
current_qs[k] = int(v)
results["quiz_structure"].append(current_qs)
elif parser_state == "parse_qb":
# it is a question line
if len(tokens) > 2:
category, sub_category, question_type, point, question, choice = tokens[:
6]
correct = ""
if len(tokens) > 6 and tokens[6] != "":
correct = tokens[6]
if "questions" not in results:
results["questions"] = {}
results["questions"][current_question_id] = {}
results["questions"][current_question_id][
"category"] = category
results["questions"][current_question_id][
"sub_category"] = sub_category
results["questions"][current_question_id][
"question_type"] = question_type
results["questions"][current_question_id][
"point"] = point
results["questions"][current_question_id][
"question"] = question
results["questions"][current_question_id][
"choices"] = []
current_choice = {}
current_choice["caption"] = choice
if correct == "Y":
current_choice["correct"] = True
else:
current_choice["correct"] = False
results["questions"][current_question_id][
"choices"].append(current_choice)
current_question_id += 1
else:
# append to choices
current_choice = {}
current_choice["caption"] = tokens[0]
if len(tokens) > 1 and tokens[1] == "Y":
current_choice["correct"] = True
else:
current_choice["correct"] = False
results["questions"][current_question_id -
1]["choices"].append(
current_choice)
else:
print(f"At {parser_state}: Cannot parse {row}")
if self.DEBUG:
print("Parsed:")
print(json.dumps(results, indent=1))
uniq_categories = []
for current in results['questions']:
current_category = results['questions'][current][
'category']
if current_category not in uniq_categories:
uniq_categories.append(current_category)
# create categories
for current in uniq_categories:
if not Category.objects.filter(name=current).exists():
category = Category()
category.name = current
category.save()
# create sub-categories
for current in results['questions']:
current_category = results['questions'][current][
"category"]
category = Category.objects.get(name=current_category)
current_sub_category = results['questions'][current][
"sub_category"]
if not SubCategory.objects.filter(
name=current_sub_category).exists():
sub_category = SubCategory()
sub_category.category = category
sub_category.name = current_sub_category
sub_category.save()
# create quiz
quiz = None
if Quiz.objects.filter(name=results["quiz"]).exists():
raise CommandError(
f"Quiz {results['quiz']} already exists")
else:
quiz = Quiz()
quiz.name = results['quiz']
quiz.category = Category.objects.get(
name=uniq_categories[0])
quiz.sub_category = SubCategory.objects.filter(
category=quiz.category).first()
if results['timed'] == "Y":
quiz.timed = True
else:
quiz.timed = False
quiz.time_limit = int(results['max_time_in_mins'])
quiz.save()
# create quiz structure
for current in results['quiz_structure']:
quiz_structure = QuizStructure()
quiz_structure.quiz = quiz
quiz_structure.category = Category.objects.get(
name=uniq_categories[0])
sub_category, frequency = list(current.keys())[0], list(
current.values())[0]
quiz_structure.sub_category = SubCategory.objects.get(
name=sub_category, category=quiz_structure.category)
quiz_structure.frequency = frequency
quiz_structure.save()
# create question type
for current in results['questions']:
current_question_type = results['questions'][current][
"question_type"]
if not QuestionType.objects.filter(
name=current_question_type).exists():
question_type = QuestionType()
question_type.name = current_question_type
question_type.save()
# create question & choices
for current in results['questions']:
question = Question()
question.category = Category.objects.get(
name=results['questions'][current]["category"])
question.sub_category = SubCategory.objects.get(
name=results['questions'][current]["sub_category"],
category=category)
question.question_type = QuestionType.objects.get(
name=results['questions'][current]["question_type"])
question.point = results['questions'][current]["point"]
question.blurb = results['questions'][current]["question"]
question.save()
for current_choice in results['questions'][current][
"choices"]:
choice = Choice()
choice.question = question
choice.choice = current_choice['caption']
choice.correct = current_choice['correct']
choice.save()
def test_question_check_answer(self):
q = Question()
q['correct'] = u'Yes'
self.assertTrue(q.check_answer('yes'))
self.assertTrue(not q.check_answer('no'))
q['alternatives'] = [u'Maybe', u'Perhaps']
self.assertTrue(q.check_answer('yes', alternatives_are_correct=True))
self.assertTrue(q.check_answer('maybe', alternatives_are_correct=True))
self.assertTrue(
q.check_answer('perhaps', alternatives_are_correct=True))
self.assertTrue(
not q.check_answer('inte', alternatives_are_correct=True))
# now with edit distance
# too short
self.assertTrue(not q.check_answer('yeah'))
# sufficiently long
q['correct'] = u'Correct'
self.assertTrue(q.check_answer('corect'))
self.assertTrue(not q.check_answer('korecct'))
q['correct'] = u'Tupac Shakur'
self.assertTrue(q.check_answer('tupak Shacur'))
self.assertTrue(not q.check_answer('Toopack shakure')) # too wrong
def handle(self, *args, **options):
print 'Reset db started.'
Entity.objects.all().delete()
Question.objects.all().delete()
print 'db clear done.'
print 'Loading books...'
books_list = {}
with open(BOOKS_FILE, 'r') as f:
b_reader = csv.DictReader(f, delimiter=',')
for book in b_reader:
pk = int(book['id_b'])
name = book['name'].decode('utf8')
description = ''
db_book = Entity(name=name, description=description)
db_book.save()
books_list[pk] = db_book
print 'Done.'
print 'Loading questions...'
questions_list = {}
with open(QUESTIONS_FILE, 'rb') as f:
q_reader = csv.DictReader(f, delimiter=',')
for question in q_reader:
pk = int(question['id_q'])
text = question['question'].decode('utf8')
db_question = Question(text=text)
db_question.save()
questions_list[pk] = db_question
print 'Done.'
print 'Loading distributions...'
with open(DISTRIBUTION_FILE, 'rb') as f:
d_reader = csv.DictReader(f, delimiter=',')
for distribution in d_reader:
book_id = int(distribution['id_b'])
question_id = int(distribution['id_q'])
yes_count = int(
float(distribution['yes'].replace(',', '.')) * 100)
no_count = int(
float(distribution['no'].replace(',', '.')) * 100)
dm_count = int(
float(distribution['does not matter'].replace(',', '.')) *
100)
book = books_list[book_id]
question = questions_list[question_id]
db_distribution = AnswersDistribution(entity=book,
question=question,
yes_count=yes_count,
no_count=no_count,
dm_count=dm_count)
db_distribution.save()
print 'Done.'
def test_was_published_recently_with_future_question(self):
time = timezone.now() + datetime.timedelta(days=30)
future_question = Question(pub_date=time)
self.assertIs(future_question.was_published_recently(), False)
def test_was_published_recently_with_recent_question(self):
time = timezone.now() - datetime.timedelta(
hours=23, minutes=59, seconds=29)
recent_question = Question(pub_date=time)
self.assertIs(recent_question.was_published_recently(), True)
