def test_input_separator_string(self):
def micro1_question(self):
return random.choice(string.ascii_lowercase + ' '), string.ascii_lowercase + ' '
tasker = TaskGenerator(micro1_question, 'now speak')
question, answer = tasker.get_task_instance()
self.assertTrue(question.endswith('now speak'))
def test_feedback_false(self):
def micro1_question(self):
return random.choice(string.ascii_lowercase + ' '), string.ascii_lowercase + ' '
tasker = TaskGenerator(micro1_question, '', False)
question, answer = tasker.get_task_instance()
feedback_text = tasker.get_feedback_text(True)
self.assertEqual(feedback_text, '')
def test_show_feedback_sep_false(self):
def micro1_question(self):
return random.choice(string.ascii_lowercase + ' '), string.ascii_lowercase + ' '
tasker = TaskGenerator(micro1_question, '', "awesome", '!', False)
question, answer = tasker.get_task_instance()
feedback_text = tasker.get_feedback_text(True)
self.assertTrue(feedback_text.endswith('awesome'))
def test_feedback_true_iterable(self):
def micro1_question(self):
return random.choice(string.ascii_lowercase + ' '), string.ascii_lowercase + ' '
tasker = TaskGenerator(micro1_question, '', True)
question, answer = tasker.get_task_instance()
feedback_text = tasker.get_feedback_text(True)
for _ in range(10):
self.assertTrue(feedback_text in answer)
def test_feedback_iterable(self):
def micro1_question(self):
return random.choice(string.ascii_lowercase + ' '), string.ascii_lowercase + ' '
valid_feedbacks = ['great', 'nice', 'awesome']
tasker = TaskGenerator(micro1_question, '', valid_feedbacks)
question, answer = tasker.get_task_instance()
feedback_text = tasker.get_feedback_text(True)
self.assertIn(feedback_text, valid_feedbacks)
def test_feedback_true_function(self):
def micro1_question(self):
def micro1_answer(answer, question=None):
return answer in string.ascii_lowercase + ' '
return random.choice(string.ascii_lowercase + ' '), micro1_answer
tasker = TaskGenerator(micro1_question, '', True)
question, answer = tasker.get_task_instance()
feedback_text = tasker.get_feedback_text(True)
self.assertEqual(feedback_text, '')
def test_instancer_feedback_override(self):
def micro1_question(self):
def micro1_feedback(correct, question):
return "nice" if correct else "bad :("
return random.choice(string.ascii_lowercase + ' '), string.ascii_lowercase + ' ', micro1_feedback
tasker = TaskGenerator(micro1_question, '', None)
question, answer = tasker.get_task_instance()
feedback_text_correct = tasker.get_feedback_text(True)
feedback_text_incorrect = tasker.get_feedback_text(False)
self.assertEqual(feedback_text_correct, 'nice')
self.assertEqual(feedback_text_incorrect, 'bad :(')
def test_instancer_iterable(self):
def micro1_question(self):
return random.choice(string.ascii_lowercase + ' '), string.ascii_lowercase
tasker = TaskGenerator(micro1_question)
question, answer = tasker.get_task_instance()
check_correct_answer = tasker.check_answer('a')
check_normal_answer = tasker.check_answer(' ')
check_wrong_answer = tasker.check_answer('/')
self.assertTrue(check_correct_answer[1])
self.assertEqual(check_correct_answer[2], 1)
self.assertFalse(check_normal_answer[1])
self.assertEqual(check_normal_answer[2], -1)
self.assertFalse(check_wrong_answer[1])
self.assertEqual(check_wrong_answer[2], -1)
def get_task_generator(self):
def micro8_question(self):
alphabet = string.ascii_lowercase
sentence = "{}{}{}{}{}.".format(' ' * random.randint(0, 6), random.choice(alphabet), ' ' * random.randint(0, 6),
random.choice(alphabet), ' ' * random.randint(0, 6))
question = "say: {}".format(sentence)
sentence = re.sub(' +', ' ', sentence).strip()
def micro8_feedback(is_correct, question):
reaction = "correct" if is_correct else "false"
return reaction + '!' + sentence
return question, [sentence], micro8_feedback
return TaskGenerator(micro8_question, '', None, ';')
def get_task_generator(self):
def micro9_1_question(self):
valid_words = string.ascii_lowercase
word = random.choice(valid_words) + '.'
question = "spell: {}".format(word)
sentence = " ".join(word)
def micro9_1_feedback(is_correct, question):
reaction = "good job" if is_correct else "wrong"
return reaction + '! ' + sentence
return question, [sentence], micro9_1_feedback
return TaskGenerator(micro9_1_question, '', None, ';')
def test_instancer_function(self):
def micro1_question(self):
def micro1_reward(answer, question=''):
if answer in string.ascii_lowercase:
return True, 1
elif answer == ' ':
return None, 0
else:
return False, -1
return random.choice(string.ascii_lowercase + ' '), micro1_reward
tasker = TaskGenerator(micro1_question)
question, answer = tasker.get_task_instance()
check_correct_answer = tasker.check_answer('a')
check_normal_answer = tasker.check_answer(' ')
check_wrong_answer = tasker.check_answer('/')
self.assertTrue(check_correct_answer[1])
self.assertEqual(check_correct_answer[2], 1)
self.assertFalse(check_normal_answer[1])
self.assertEqual(check_normal_answer[2], 0)
self.assertFalse(check_wrong_answer[1])
self.assertEqual(check_wrong_answer[2], -1)
def get_task_generator(self):
valid_words = load_dictionary(DICTIONARY_FILE)
def micro7_2_question(self):
word = random.choice(valid_words) + '.'
question = "say: {}".format(word)
def micro7_2_feedback(is_correct, question):
reaction = "correct" if is_correct else "false"
return reaction + '! ' + word
return question, [word], micro7_2_feedback
return TaskGenerator(micro7_2_question, '', None, ';')
def get_task_generator(self):
def micro9_2_question(self):
valid_words = load_dictionary(DICTIONARY_FILE)
word = random.choice(valid_words) + '.'
question = "spell: {}".format(word)
sentence = " ".join(word)
def micro9_2_feedback(is_correct, question):
reaction = "good job" if is_correct else "wrong"
return reaction + '! ' + sentence
return question, [sentence], micro9_2_feedback
return TaskGenerator(micro9_2_question, '', None, ';')
def get_task_generator(self):
def micro9_3_question(self):
valid_words = load_dictionary(DICTIONARY_FILE)
word = random.choice(valid_words)
joint = random.choice(['-', '#', ','])
question = "interleave: " + word + ' by ' + joint + '.'
sentence = joint.join(word) + '.'
def micro9_3_feedback(is_correct, question):
reaction = "good job" if is_correct else "wrong"
return reaction + '! ' + sentence
return question, [sentence], micro9_3_feedback
return TaskGenerator(micro9_3_question, '', None, ';')
def get_task_generator(self):
def micro14_question(self):
alphabet = string.ascii_lowercase
idx = random.randint(0, len(alphabet) - 2)
question = 'after {} comes what:.'.format(alphabet[idx])
sentence = alphabet[idx + 1]
sentence += '.'
def micro14_feedback(is_correct, question):
reaction = "good job" if is_correct else "wrong"
if not is_correct:
return reaction + '! ' + sentence
else:
return reaction + '! '
return question, [sentence], micro14_feedback
return TaskGenerator(micro14_question, '', None, ';')
def get_task_generator(self):
def micro10_question(self):
valid_words = load_dictionary(DICTIONARY_FILE)
n = random.randint(2, 3)
questions = []
words = []
for i in range(0, n):
word = random.choice(valid_words)
words.append(word)
questions.append('say: {}'.format(word))
question = ' '.join(questions) + '.'
sentence = ' '.join(words) + '.'
def micro10_feedback(is_correct, question):
reaction = "good job" if is_correct else "wrong"
if not is_correct:
return reaction + '! ' + sentence
else:
return reaction + '! '
return question, [sentence], micro10_feedback
return TaskGenerator(micro10_question, '', None, ';')
def get_task_generator(self):
sequence1 = [
'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven',
'eight', 'nine'
]
sequence2 = [
'first', 'second', 'third', 'fourth', 'fifth', 'sixth', 'seventh',
'eighth', 'ninth'
]
sequence3 = [
'ten', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy',
'eighty', 'ninety'
]
sequence4 = [
'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen',
'sixteen', 'seventeen', 'eighteen', 'nineteen'
]
chosen_sequence = random.choice(
[sequence1, sequence2, sequence3, sequence4])
if random.randint(0, 2) > 0:
chosen_sequence.reverse()
self.mapping_check = {key: False for key in chosen_sequence[0:-1]}
def micro15_question(self):
def micro15_feedback(is_correct, question):
reaction = "good job" if is_correct else "wrong"
if not is_correct:
return reaction + '! ' + sentence
else:
return reaction + '! '
idx = random.randint(0, len(chosen_sequence) - 2)
word = chosen_sequence[idx]
question = 'say next after: ' + word + '.'
sentence = chosen_sequence[idx + 1] + '.'
return question, [sentence], micro15_feedback
return TaskGenerator(micro15_question, '', None, ';')
def get_task_generator(self):
def micro12_question(self):
actions = ['union', 'exclude']
action = random.choice(actions)
valid_words = ["abc", "acd", "adc", "bcd", "bda", "cdb"]
valid_second_words = ["a", "b", "c", "d"]
word = random.choice(valid_words)
second_word = random.choice(valid_second_words)
question = 'say: {} say: {} {}:.'.format(word, second_word, action)
if action == 'union':
sentence = Micro12Task.string_special_union(word, second_word)
else:
sentence = Micro12Task.string_special_exclude(word, second_word)
sentence += '.'
def micro12_feedback(is_correct, question):
reaction = "good job" if is_correct else "wrong"
if not is_correct:
return reaction + '! ' + sentence
else:
return reaction + '! '
return question, [sentence], micro12_feedback
return TaskGenerator(micro12_question, '', None, ';')
def get_task_generator(self):
content = load_dictionary(DICTIONARY_FILE)
vocabulary = content[:200]
mapping = dict(zip(random.sample(vocabulary, self.MAPPING_SIZE),
random.sample(vocabulary, self.MAPPING_SIZE)))
keys = list(mapping.keys())
self.mapping_check = {key: False for key in keys}
def micro6_question(self):
def micro6_feedback(is_correct, question):
reaction = "good job" if is_correct else "wrong"
if not is_correct:
return reaction + '! ' + sentence
else:
return reaction + '! '
self.key_idx = random.randint(0, len(keys) - 1)
word1 = keys[self.key_idx]
word2 = mapping[word1]
question = 'random_map: ' + word1 + '.'
sentence = word2 + '.'
return question, [sentence], micro6_feedback
return TaskGenerator(micro6_question, '', None, ';')
def test_instancer_iterable(self):
def micro1_question(self):
return random.choice(string.ascii_lowercase +
' '), string.ascii_lowercase
tasker = TaskGenerator(micro1_question)
question, answer = tasker.get_task_instance()
check_correct_answer = tasker.check_answer('a')
check_normal_answer = tasker.check_answer(' ')
check_wrong_answer = tasker.check_answer('/')
self.assertTrue(check_correct_answer[1])
self.assertEqual(check_correct_answer[2], 1)
self.assertFalse(check_normal_answer[1])
self.assertEqual(check_normal_answer[2], -1)
self.assertFalse(check_wrong_answer[1])
self.assertEqual(check_wrong_answer[2], -1)
def get_task_generator(self):
mapping = self._get_mapping()
self.known_mapping = self._get_mapping_options(mapping)
self.should_know = False
def multigen(d):
while True:
k = list(d.keys()) * len(d.keys())
random.shuffle(k)
for i in k:
yield i
gen = multigen(mapping)
def micro_mapping_question(self):
def micro_mapping_reward(answer, question):
key = self.get_original_question(question)
if len(answer) > 0 and MicroBase.is_prefix(answer, mapping[key]):
return None, 0
if len(answer) < len(mapping[key]):
return None, 0
correct = answer == mapping[key]
return correct, 1 if correct else -1
return next(gen), micro_mapping_reward
return TaskGenerator(micro_mapping_question, **self.task_gen_kwargs)
def get_task_generator(self):
def micro13_1_question(self):
def micro13_1_feedback(is_correct, question):
reaction = "good job" if is_correct else "wrong"
if not is_correct:
return reaction + '! ' + sentence
else:
return reaction + '! '
action = random.randint(1, 4)
words = list('abcde')
# and
if action == 1:
word1 = random.choice(words)
word2 = random.choice(words)
question = ' say: {} and {}.'.format(word1, word2)
sentence = '{}{}.'.format(word1, word2)
return question, sentence, micro13_1_feedback
# or
elif action == 2:
word1 = random.choice(words)
word2 = random.choice(words)
question = ' say: {} or {}.'.format(word1, word2)
sentence = '{}.'.format(random.choice([word1, word2]))
def or_reward(answer, question=''):
answer_ = answer[:-1]
correct = answer_ == word1 or answer_ == word2 or answer_ == word1 + word2 or answer_ == word2 + word1
return correct, 1 if correct else -1
return question, or_reward, micro13_1_feedback
# anything and not
elif action == 3:
word1 = 'anything'
word2 = random.choice(words)
words.remove(word2)
question = ' say: {} and not {}.'.format(word1, word2)
sentence = random.choice(words)
def anything_and_not_reward(answer, question=''):
correct = answer.find(word2) < 0 and len(answer) > 1
return correct, 1 if correct else -1
return question, anything_and_not_reward, micro13_1_feedback
# or but not
else:
word1 = random.choice(words)
words.remove(word1)
word2 = random.choice(words)
words.remove(word2)
word3 = random.choice([word1, word2, random.choice(words)])
question = ' say: {} or {} but not {}.'.format(word1, word2, word3)
correct_word = [word1, word2]
if word3 in correct_word:
correct_word.remove(word3)
sentence = random.choice(correct_word)
def or_but_not_reward(answer, question=''):
answer_ = answer[:-1]
correct = answer_ == word1 or answer_ == word2 or answer_ == word1 + word2 or answer_ == word2 + word1
correct = correct and (answer.find(word3) < 0)
return correct, 1 if correct else -1
return question, or_but_not_reward, micro13_1_feedback
return TaskGenerator(micro13_1_question, '', None, ';')
