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())

 def onQuestion(self, msg):
     """
     Gets called when a new question is received.
     The received question is then displayed in the GUI.
     """
     self._answerLocked = False
     self.activeQuestion = Question.fromMsg(msg)
     self.ui.updateQuestion(self.activeQuestion)

def question(id):
    form = AnswerForm(request.form)
    question = Question.find(id)

    if not question:
        return random_question()

    if request.method == 'GET' or (request.method == 'POST' and not form.validate()):
        return render_template('question.html', question=question, form=form, amount=Question.size())
    elif request.method == 'POST' and form.validate():
        if request.form['answer'] == question.answer:
            flash('Correct!', 'positive')
            return random_question()
        else:
            flash('Wrong Answer!', 'negative')
            return render_template('question.html', question=question, form=form, amount=Question.size())
    else:
        return render_template('invalid_request.html')

 def __call__(self, qid):
     self.question = Question(qid)
     self.qid = int(qid)
     self.qtext = self.question.text
     #self.answer = self.question.answer
     #self.category = self.question.category
     #self.sentences = self.question.get_sentences()
     #self.tokens = self.question.tokenize()
     self.features = defaultdict(dict)

def jsubmit(question_id):

    hs = Historysession.get_current_history_session_by_user_id_quiz_id(current_user.id)
    session_id = hs.hsid

    current_app.logger.debug("jsubmit - " + str(question_id) + ", session_id - " + str(session_id))
    current_app.logger.debug("json in jsubmit - " + str(request.json))
    
    question = Question.get_active_question_by_id(question_id)

    if question:
        if current_user.id == question.user_id:
            schema = {
                    "type" : "object",
                    "properties" : {            
                        "id" : {"type" : "integer", "maxLength" : 8, "optional" : False},
                        "answers" : {"type": "array", "items": { "type" : "object", "properties": {
                                                                  "id" : {"type": "integer", "maxLength": 8, "optional": False},
                                                                  "value" : {"type" : "string", "enum" : ["T", "F", "N"], "optional" : False}
                                                                  }}, "maxItems" : 25, "optional" : True}
                        }
                    }

            v = Draft4Validator(schema)
            errors = sorted(v.iter_errors(request.json), key=lambda e: e.path)
            
            if len(errors) > 0:
                msg = u"Error in json format"
                current_app.logger.warning(msg)
                return jsonify({"status" : "ERROR", "message" : msg})
            else:            
                qid = request.json['id']
                received_answers = request.json['answers']

                correct = True
                for i in range(0, len(received_answers)):
                    item = received_answers[i]
                    aid = item['id']
                    value = item['value']

                    AnswerResult.add_answer_result(session_id, aid, question.revision_id, value)
        
                    correct = correct and (value == question.answers[i].correct)                    
                    
                    current_app.logger.debug("a# = " + str(i) + ", value = " + str(value) + ", answer = " + str(question.answers[i].correct) + ", correct = " + str(correct))

                QuestionResult.add_question_result(session_id, question.qid, question.revision_id, correct)
                db.session.commit()
                
                result = {'jstaus':'OK'}
                return jsonify(result)
        else:
            msg = auth_failure_message + u"submit this question"
            current_app.logger.warning(msg)
            return jsonify({"status" : "ERROR", "message" : msg})
    else:
        return jsonify({"status" : "ERROR"})

def markdown_questionlist(qlist):
    qlist.formatted_questions = []
    for q in qlist.questions:
        if isinstance(q,Question):
            question = q
        else:
            question = Question.get(q)
        if question:
            question.formatted_text = mymarkdown(question.text)
            qlist.formatted_questions.append(question)