Python question.Question类代码示例

    def parse(self, string):
        re_index  = r'\**\s*(?:[A-Ea-e]\.|\(?[A-Ea-e]\))'
        re_body   = r'.+'
        re_option = r'({index}\s+{body})'.format(index=re_index, body=re_body)
        self._tokenize(string)

        # spin thru the input chunks two at a time, the first being the
        # stem, presumably, and the second being the option group
        for st_index in range(0, len(self._tokens), 2):
            op_index = st_index +1
            if op_index < len(self._tokens):
                question = Question()

                stem = re.search(r'[0-9]+(?:\.|\s).+$', self._tokens[st_index], re.DOTALL)
                #~ stem = re.search(r"\n*((?:[0-9]*\.*\s*).+)$", self._tokens[st_index], re.DOTALL)
                #~ stem = re.search(r"(?:[0-9]+\s+(?:.|\n)+$)+?|(?:\n*.+$)", self._tokens[st_index])
                question.stem = stem.group().strip() if stem else self._tokens[st_index] 

                options = [o.strip() for o in re.split(re_option, self._tokens[op_index]) if o.strip()]
                for option in options:
                    question.options.append(option)

                self._questions.append(question)

        return self

def loadSurvey(filename):
    from question import Question
    from answer import Answer
    survey = None
    f = open(filename, "r")
    if f is not None:
        s = ""
        b = f.read(512)
        while len(b):
            s += b
            b = f.read(512)
        f.close()
        sd = jsonpickle.decode(s)
        survey = Survey()
        survey.name = sd['name']
        survey.questions = {}
        for qd in sd['questions'].values():
            question = Question()
            question.id = qd['id']
            question.name = qd['name']
            question.answers = {}
            for ad in qd['answers'].values():
                answer = Answer()
                answer.id = ad['id']
                answer.value = ad['value']
                answer.selected = ad['selected']
                answer.editable = ad['editable']
                question.answers[answer.id] = answer
            survey.questions[question.id] = question
    return survey

 def test_creation(self):
     q = {'name': 'q1', 'text': 'Random question one, choose a.', 'answers': 
             [{'value': 'a', 'text': 'a'}, {'value': 'b', 'text': 'b'}, 
              {'value': 'c', 'text': 'c'},{'value': 'd', 'text': 'd'}]
         }
     question = Question(q)
     assert question.name == q['name'] and question.text == q['text'] and question.answers == q['answers']
     question.save()

 def test_blank_name(self):
     question = Question()
     question.text = 'Blank test question'
     question.answers = []
     try:
         question.save()
     except KeyError, e:
         print 'Adding blank question failed: %s' % e

def get_question(question_id):
    if Question.is_null() == False: 
    	rows = Question.query(Question.serial_no==question_id).fetch()
        if len(rows) == 1:
            return dict(total= Question.count(), detail = rows[0])
        else:
            return empty_question()
    else:
        return empty_question()

 def test_duplicate(self):
     q = {'name': 'q2', 'text': 'Random question one, choose a.', 'answers': 
             [{'value': 'a', 'text': 'a'}, {'value': 'b', 'text': 'b'}, 
              {'value': 'c', 'text': 'c'},{'value': 'd', 'text': 'd'}]
         }
     question = Question(q)
     assert question.name == q['name'] and question.text == q['text'] and question.answers == q['answers']
     question.save()
     try:
         question.save()
     except KeyError, e:
         print 'Trying to save duplicate: %s' % e

	def test_illegal_keys(self):
		self.assertFalse(Question.iskey("")[0], "Empty string")
		self.assertFalse(Question.iskey("   ")[0], "Whitespace only")
		self.assertFalse(Question.iskey("  key")[0], "Leading whitespace")
		self.assertFalse(Question.iskey("end\t")[0], "Traling tabulation")
		self.assertFalse(Question.iskey("*$/\\")[0], "Non-alphanumeric characters")
		self.assertFalse(Question.iskey("end")[0], "Reserved keyword")
		self.assertFalse(Question.iskey("photoVisible")[0], "Reserved keyword")
		self.assertFalse(Question.iskey(32768)[0], "Not a string")
		self.assertFalse(Question.iskey("\n")[0], "Illegal escape character")

def questions():
    form = NewQuestionForm(request.form)
    if request.method == 'POST' and form.validate():
        question = Question(form.category.data, form.question.data,
                            form.option_a.data, form.option_b.data,
                            form.option_c.data, form.option_d.data,
                            form.answer.data)
        question.save()
        flash('Question successfully created!', 'positive')
        return render_template('question_created.html', question=question, amount=Question.size())
    elif request.method == 'POST' and not form.validate():
        flash('Oops, your submitted question appears to be invalid.', 'negative')
        return render_template('question_new.html', form=form, amount=Question.size())
    else:
        return render_template('invalid_request.html')

def accept_input():
  content = request.args.get('content', '')
  number = request.args.get('from', '')
  # check for malicious URLs
  if url_check(content):
    print "This number is a spammer: %(number)s" % {"number": number}
    return
  if number == '447860033028':
    #no infinite loop 4 u
    return
  question = Question(content,number)
  question.ask()

  # debug statements below
  print("%(content)s from %(number)s." % {"content": question.message, "number": question.number})
  return "%(content)s from %(number)s." % {"content": question.message, "number": question.number} 

    def ask(self, question, answer_type = str, **configs):
        self.question = Question(question, answer_type)
        self.answer = ""
        for key, value in configs.iteritems():
            self.question.__dict__[key] = value

        if self.question.gather:
            return self.gather()

        self.say(self.question.question)
        # retry until the correct answer
        while True:
            try:
                self.answer = self.question.answer_or_default(self.get_response())
                self.answer = self.question.change_case(self.answer)
                self.__class__(self.input, self.output)
                self.question.update()
                if not self.question.valid_answer(self.answer):
                    self.explain_error("not_valid")
                    raise QuestionError()
                self.answer = self.question.convert(self.answer)
            except QuestionError:
                pass
            else:
                self.question = None
                break
        return self.answer

	def test_valid_keys(self):
		self.assertTrue(Question.iskey("A")[0], "Single-character")
		self.assertTrue(Question.iskey("thisIsALongKey")[0], "Multi-character")
		self.assertTrue(Question.iskey("--")[0], "Hyphens")
		self.assertTrue(Question.iskey("--key")[0], "Leading hyphens")
		self.assertTrue(Question.iskey("_")[0], "Underscores")
		self.assertTrue(Question.iskey("__key")[0], "Leading underscores")
		self.assertTrue(Question.iskey("_now-y0u_4re-pushing-1t")[0], "Mixed characters")
		self.assertTrue(Question.iskey("_end")[0], "Not a reserved keyword")

 def test_should_return_html_for_single_line_answer_question(self):
     actual = Question.single_line_answer("question")
     expected = '''\
         <div id="1">
             question <input type="text" id=1></input>
         </div>
     '''
     self.assertEquals(HTMLReader(expected).to_s(), HTMLReader(actual).to_s())

 def test_should_return_html_for_multi_line_answer_question(self):
     actual = Question.multi_line_answer("question")
     expected = '''\
         <div id="1">
             question <textarea rows=10 cols=30 id=1></textarea>
         </div>
     '''
     self.assertEquals(HTMLReader(expected).to_s(), HTMLReader(actual).to_s())

 def test_should_return_html_for_multi_choice_answer_question(self):
     actual = Question.multi_choice("question", "a1", "a2")
     expected = '''\
         <div id="1">
             question <input type=checkbox id="1_1">a1</input><input type=checkbox name="1_2">a2</input>
         </div>
     '''
     self.assertEquals(HTMLReader(expected).to_s(), HTMLReader(actual).to_s())

 def test_should_return_html_for_single_choice_question(self):
     actual = Question.single_choice("question", "a1", "a2")
     expected = '''\
         <div id="1">
             question <input type=radio name="1">a1</input><input type=radio name="1">a2</input>
         </div>
     '''
     self.assertEquals(HTMLReader(expected).to_s(), HTMLReader(actual).to_s())