Major refactor of infrastructure for grading problems

--HG--
rename : courseware/calc.py => courseware/capa/calc.py

courseware/capa/__init__.py

+

courseware/capa/capa_problem.py

+import random, numpy, math, scipy
+import struct, os
+import re
+from lxml import etree
+from lxml.etree import Element
+import copy
+from mako.template import Template
+from content_parser import xpath_remove
+
+from util import contextualize_text
+
+from inputtypes import textline, schematic
+from responsetypes import numericalresponse, formularesponse
+
+response_types = {'numericalresponse':numericalresponse, 
+                  'formularesponse':formularesponse,
+                  'customresponse':None}
+entry_types = ['textline', 'schematic']
+response_properties = ["responseparam", "answer"]
+# How to convert from original XML to HTML
+# We should do this with xlst later
+html_transforms = {'problem': {'tag':'div'},
+                   "numericalresponse": {'tag':'span'}, 
+                   "customresponse": {'tag':'span'}, 
+                   "formularesponse": {'tag':'span'}, 
+                   "text": {'tag':'span'}}
+
+global_context={'random':random,
+                'numpy':numpy,
+                'math':math,
+                'scipy':scipy}
+
+# These should be removed from HTML output, including all subelements
+html_problem_semantics = ["responseparam", "answer", "script"]
+# These should be removed from HTML output, but keeping subelements
+html_skip = ["numericalresponse", "customresponse", "formularesponse", "text"]
+# These should be transformed
+html_special_response = {"textline":textline.render,
+                         "schematic":schematic.render}
+
+class LoncapaProblem(object):
+    def __init__(self, filename, id=None, state=None):
+        ## Initialize class variables from state
+        self.seed = None
+        self.student_answers = dict()
+        self.correct_map = dict()
+        self.done = False
+        self.filename = filename
+
+        if id!=None:
+            self.problem_id = id
+        else:
+            self.problem_id = filename
+
+        if state!=None:
+            if 'seed' in state:
+                self.seed = state['seed']
+            if 'student_answers' in state:
+                self.student_answers = state['student_answers']
+            if 'correct_map' in state:
+                self.correct_map = state['correct_map']
+            if 'done' in state:
+                self.done = state['done']
+
+        # TODO: Does this deplete the Linux entropy pool? Is this fast enough?
+        if self.seed == None:
+            self.seed=struct.unpack('i', os.urandom(4))[0]
+
+        ## Parse XML file
+        file_text = open(filename).read()
+        # Convert startouttext and endouttext to proper <text></text>
+        # TODO: Do with XML operations
+        file_text = re.sub("startouttext\s*/","text",file_text)
+        file_text = re.sub("endouttext\s*/","/text",file_text)
+        self.tree = etree.XML(file_text)
+
+        self.preprocess_problem(self.tree, correct_map=self.correct_map, answer_map = self.student_answers)
+        self.context = self.extract_context(self.tree, seed=self.seed)
+
+    def get_state(self):
+        ''' Stored per-user session data neeeded to: 
+            1) Recreate the problem
+            2) Populate any student answers. '''
+        return {'seed':self.seed, 
+                'student_answers':self.student_answers,
+                'correct_map':self.correct_map, 
+                'done':self.done}
+
+    def get_max_score(self):
+        sum = 0 
+        for et in entry_types: 
+            sum = sum + self.tree.xpath('count(//'+et+')')
+        return int(sum)
+
+    def get_score(self):
+        correct=0
+        for key in self.correct_map:
+            if self.correct_map[key] == u'correct':
+                correct += 1
+        if self.student_answers == None or len(self.student_answers)==0:
+            return {'score':0,
+                    'total':self.get_max_score()}
+        else:
+            return {'score':correct,
+                    'total':self.get_max_score()}
+
+    def grade_answers(self, answers):
+        self.student_answers = answers
+        context=self.extract_context(self.tree)
+        self.correct_map = dict()
+        problems_simple = self.extract_problems(self.tree)
+        for response in problems_simple:
+            grader = response_types[response.tag](response, self.context)
+            results = grader.grade(answers)
+            self.correct_map.update(results)
+
+        return self.correct_map
+
+    def get_question_answers(self):
+        context=self.extract_context(self.tree)
+        answer_map = dict()
+        problems_simple = self.extract_problems(self.tree)
+        for response in problems_simple:
+            responder = response_types[response.tag](response, self.context)
+            results = responder.get_answers()
+            answer_map.update(results)
+        return answer_map
+
+    # ======= Private ========
+
+    def extract_context(self, tree, seed = struct.unpack('i', os.urandom(4))[0]):  # private
+        ''' Problem XML goes to Python execution context. Runs everything in script tags '''
+        random.seed(self.seed)
+        context = dict()
+        for script in tree.xpath('/problem/script'):
+            exec script.text in global_context, context
+        return context
+
+    def get_html(self):
+        return contextualize_text(etree.tostring(self.extract_html(self.tree)[0]), self.context)
+
+    def extract_html(self, problemtree):  # private
+        ''' Helper function for get_html. Recursively converts XML tree to HTML
+        '''
+        if problemtree.tag in html_problem_semantics:
+            return
+
+        if problemtree.tag in html_special_response:
+            status = "unsubmitted"
+            if problemtree.get('id') in self.correct_map:
+                status = self.correct_map[problemtree.get('id')]
+
+            value = ""
+            if self.student_answers != None and problemtree.get('id') in self.student_answers:
+                value = self.student_answers[problemtree.get('id')]
+
+            return html_special_response[problemtree.tag](problemtree, value, status) #TODO
+
+        tree=Element(problemtree.tag)
+        for item in problemtree:
+            subitems = self.extract_html(item)
+            if subitems != None: 
+                for subitem in subitems:
+                    tree.append(subitem)
+        for (key,value) in problemtree.items():
+            tree.set(key, value)
+
+        tree.text=problemtree.text
+        tree.tail=problemtree.tail
+
+        if problemtree.tag in html_transforms:
+            tree.tag=html_transforms[problemtree.tag]['tag']
+
+        # TODO: Fix. This loses Element().tail
+        #if problemtree.tag in html_skip:
+        #    return tree
+
+        return [tree]
+
+    def preprocess_problem(self, tree, correct_map=dict(), answer_map=dict()): # private
+        ''' Assign IDs to all the responses 
+        Assign sub-IDs to all entries (textline, schematic, etc.)
+        Annoted correctness and value
+        In-place transformation
+        '''
+        response_id = 1
+        for response in tree.xpath('//'+"|//".join(response_types)):
+            response_id_str=self.problem_id+"_"+str(response_id)
+            response.attrib['id']=response_id_str
+            if response_id not in correct_map:
+                correct = 'unsubmitted'
+            response.attrib['state'] = correct
+            response_id = response_id + 1
+            answer_id = 1
+            for entry in tree.xpath("|".join(['//'+response.tag+'[@id=$id]//'+x for x in entry_types]), 
+                                    id=response_id_str):
+                entry.attrib['response_id'] = str(response_id)
+                entry.attrib['answer_id'] = str(answer_id)
+                entry.attrib['id'] = "%s_%i_%i"%(self.problem_id, response_id, answer_id)
+                answer_id=answer_id+1
+
+    def extract_problems(self, problem_tree):
+        ''' Remove layout from the problem, and give a purified XML tree of just the problems '''
+        problem_tree=copy.deepcopy(problem_tree)
+        tree=Element('problem')
+        for response in problem_tree.xpath("//"+"|//".join(response_types)):
+            newresponse = copy.copy(response)
+            for e in newresponse: 
+                newresponse.remove(e)
+            # copy.copy is needed to make xpath work right. Otherwise, it starts at the root
+            # of the tree. We should figure out if there's some work-around
+            for e in copy.copy(response).xpath("//"+"|//".join(response_properties+entry_types)):
+                newresponse.append(e)
+                
+            tree.append(newresponse)
+        return tree
+
+if __name__=='__main__':
+    problem_id='simpleFormula'
+    filename = 'simpleFormula.xml'
+
+    problem_id='resistor'
+    filename = 'resistor.xml'
+
+    
+    lcp = LoncapaProblem(filename, problem_id)
+    
+    context = lcp.extract_context(lcp.tree)
+    problem = lcp.extract_problems(lcp.tree)
+    print lcp.grade_problems({'resistor_2_1':'1.0','resistor_3_1':'2.0'})
+    #print lcp.grade_problems({'simpleFormula_2_1':'3*x^3'})
+#numericalresponse(problem, context)
+    
+#print etree.tostring((lcp.tree))
+    print '============'
+    print
+#print etree.tostring(lcp.extract_problems(lcp.tree))
+    print lcp.get_html()
+#print extract_context(tree)
+    
+
+
+    # def handle_fr(self, element):
+    #     problem={"answer":self.contextualize_text(answer),
+    #              "type":"formularesponse",
+    #              "tolerance":evaluator({},{},self.contextualize_text(tolerance)),
+    #              "sample_range":dict(zip(variables, sranges)),
+    #              "samples_count": numsamples,
+    #              "id":id,
+    #     self.questions[self.lid]=problem        

courseware/capa/content_parser.py

+try: 
+    from django.conf import settings
+    from auth.models import UserProfile
+except: 
+    settings = None 
+
+from xml.dom.minidom import parse, parseString
+
+from lxml import etree
+
+''' This file will eventually form an abstraction layer between the
+course XML file and the rest of the system. 
+
+TODO: Shift everything from xml.dom.minidom to XPath (or XQuery)
+'''
+
+def xpath(xml, query_string, **args):
+    ''' Safe xpath query into an xml tree:
+        * xml is the tree.
+        * query_string is the query
+        * args are the parameters. Substitute for {params}. 
+        We should remove this with the move to lxml. 
+        We should also use lxml argument passing. '''
+    doc = etree.fromstring(xml)
+    print type(doc)
+    def escape(x):
+        # TODO: This should escape the string. For now, we just assume it's made of valid characters. 
+        # Couldn't figure out how to escape for lxml in a few quick Googles
+        valid_chars="".join(map(chr, range(ord('a'),ord('z')+1)+range(ord('A'),ord('Z')+1)+range(ord('0'), ord('9')+1)))+"_ "
+        for e in x:
+            if e not in valid_chars:
+                raise Exception("Invalid char in xpath expression. TODO: Escape")
+        return x
+
+    args=dict( ((k, escape(args[k])) for k in args) )
+    print args
+    results = doc.xpath(query_string.format(**args))
+    return results
+
+def xpath_remove(tree, path):
+    ''' Remove all items matching path from lxml tree.  Works in
+        place.'''
+    items = tree.xpath(path)
+    for item in items: 
+        item.getparent().remove(item)
+    return tree
+
+if __name__=='__main__':
+    print xpath('<html><problem name="Bob"></problem></html>', '/{search}/problem[@name="{name}"]', search='html', name="Bob")
+
+def item(l, default="", process=lambda x:x):
+    if len(l)==0:
+        return default
+    elif len(l)==1:
+        return process(l[0])
+    else:
+        raise Exception('Malformed XML')
+    
+
+def course_file(user):
+    # TODO: Cache. Also, return the libxml2 object. 
+    return settings.DATA_DIR+UserProfile.objects.get(user=user).courseware
+
+def module_xml(coursefile, module, id_tag, module_id):
+    ''' Get XML for a module based on module and module_id. Assumes
+        module occurs once in courseware XML file.. '''
+    doc = etree.parse(coursefile)
+
+    # Sanitize input
+    if not module.isalnum():
+        raise Exception("Module is not alphanumeric")
+    if not module_id.isalnum():
+        raise Exception("Module ID is not alphanumeric")
+    xpath_search='//*/{module}[(@{id_tag} = "{id}") or (@id = "{id}")]'.format(module=module, 
+                                                           id_tag=id_tag,
+                                                           id=module_id)
+    #result_set=doc.xpathEval(xpath_search)
+    result_set=doc.xpath(xpath_search)
+    if len(result_set)>1:
+        print "WARNING: Potentially malformed course file", module, module_id
+    if len(result_set)==0:
+        return None
+    return etree.tostring(result_set[0])
+    #return result_set[0].serialize()
+
+def toc_from_xml(coursefile, active_chapter, active_section):
+    dom=parse(coursefile)
+
+    course = dom.getElementsByTagName('course')[0]
+    name=course.getAttribute("name")
+    chapters = course.getElementsByTagName('chapter')
+    ch=list()
+    for c in chapters:
+        if c.getAttribute("name") == 'hidden':
+            continue
+        sections=list()
+        for s in c.getElementsByTagName('section'):
+            sections.append({'name':s.getAttribute("name"), 
+                             'time':s.getAttribute("time"), 
+                             'format':s.getAttribute("format"), 
+                             'due':s.getAttribute("due"),
+                             'active':(c.getAttribute("name")==active_chapter and \
+                                           s.getAttribute("name")==active_section)})
+        ch.append({'name':c.getAttribute("name"), 
+                   'sections':sections,
+                   'active':(c.getAttribute("name")==active_chapter)})
+    return ch
+
+def dom_select(dom, element_type, element_name):
+    if dom==None:
+        return None
+    elements=dom.getElementsByTagName(element_type)
+    for e in elements:
+        if e.getAttribute("name")==element_name:
+            return e
+    return None
+

courseware/capa/inputtypes.py

+from djangomako.shortcuts import render_to_response, render_to_string
+
+from lxml.etree import Element
+from lxml import etree
+
+class textline(object):
+    @staticmethod
+    def render(element, value, state):
+        eid=element.get('id')
+        context = {'id':eid, 'value':value, 'state':state}
+        html=render_to_string("textinput.html", context)
+        return etree.XML(html)
+
+class schematic(object):
+    @staticmethod
+    def render(element, value, state):
+        eid = element.get('id')
+        height = element.get('height')
+        width = element.get('width')
+        context = {'id':eid, 'value':value, 'state':state, 'width':width, 'height':height}
+        html=render_to_string("schematicinput.html", context)
+        return etree.XML(html)
+
+

courseware/capa/responsetypes.py

+from util import contextualize_text
+from calc import evaluator
+import random, math
+
+class numericalresponse(object):
+    def __init__(self, xml, context):
+        self.xml = xml
+        self.correct_answer = contextualize_text(xml.get('answer'), context)
+        self.correct_answer = float(self.correct_answer)
+        self.tolerance = xml.xpath('//*[@id=$id]//responseparam[@type="tolerance"]/@default',
+                                   id=xml.get('id'))[0]
+        self.tolerance = contextualize_text(self.tolerance, context)
+        self.tolerance = evaluator(dict(),dict(),self.tolerance)
+        self.answer_id = xml.xpath('//*[@id=$id]//textline/@id',
+                                   id=xml.get('id'))[0]
+
+    def grade(self, student_answers):
+        ''' Display HTML for a numeric response '''
+        student_answer = student_answers[self.answer_id]
+        error = abs(evaluator(dict(),dict(),student_answer) - self.correct_answer)
+        allowed_error = abs(self.correct_answer*self.tolerance)
+        if error <= allowed_error:
+            return {self.answer_id:'correct'}
+        else:
+            return {self.answer_id:'incorrect'}
+
+    def get_answers(self):
+        return {self.answer_id:self.correct_answer}
+
+class customresponse(object):
+    def __init__(self, xml, context):
+        self.xml = xml
+        self.answer_id = xml.xpath('//*[@id=$id]//textline/@id',
+                                   id=xml.get('id'))[0]
+        return {self.answer_id:'correct'}
+
+    def grade(self, student_answers):
+        return {self.answer_id:'correct'}
+
+    def get_answers(self):
+        return {self.answer_id:'correct'}
+
+
+class formularesponse(object):
+    def __init__(self, xml, context):
+        self.xml = xml
+        self.correct_answer = contextualize_text(xml.get('answer'), context)
+        self.samples = contextualize_text(xml.get('samples'), context)
+        self.tolerance = xml.xpath('//*[@id=$id]//responseparam[@type="tolerance"]/@default',
+                                   id=xml.get('id'))[0]
+        self.tolerance = contextualize_text(self.tolerance, context)
+        self.tolerance = evaluator(dict(),dict(),self.tolerance)
+        self.answer_id = xml.xpath('//*[@id=$id]//textline/@id',
+                                   id=xml.get('id'))[0]
+        self.context = context
+
+
+    def grade(self, student_answers):
+        variables=self.samples.split('@')[0].split(',')
+        numsamples=int(self.samples.split('@')[1].split('#')[1])
+        sranges=zip(*map(lambda x:map(float, x.split(",")), 
+                         self.samples.split('@')[1].split('#')[0].split(':')))
+
+        ranges=dict(zip(variables, sranges))
+        correct = True
+        for i in range(numsamples):
+            instructor_variables = self.strip_dict(dict(self.context))
+            student_variables = dict()
+            for var in ranges:
+                value = random.uniform(*ranges[var])
+                instructor_variables[str(var)] = value
+                student_variables[str(var)] = value
+            instructor_result = evaluator(instructor_variables,dict(),self.correct_answer)
+            student_result = evaluator(student_variables,dict(),student_answers[self.answer_id])
+            if math.isnan(student_result) or math.isinf(student_result):
+                return {self.answer_id:"incorrect"}
+            if abs( student_result - instructor_result ) > self.tolerance:
+                return {self.answer_id:"incorrect"}
+ 
+        return {self.answer_id:"correct"}
+
+    def strip_dict(self, d):
+        ''' Takes a dict. Returns an identical dict, with all non-word
+        keys and all non-numeric values stripped out. All values also
+        converted to float. Used so we can safely use Python contexts.
+        ''' 
+        d=dict([(k, float(d[k])) for k in d if type(k)==str and \
+                    k.isalnum() and \
+                    (type(d[k]) == float or type(d[k]) == int) ])
+        return d
+
+    def get_answers(self):
+        return {self.answer_id:self.correct_answer}

courseware/capa/util.py

+def contextualize_text(text, context): # private
+    ''' Takes a string with variables. E.g. $a+$b. 
+    Does a substitution of those variables from the context '''
+    for key in sorted(context, lambda x,y:cmp(len(y),len(x))):
+        text=text.replace('$'+key, str(context[key]))
+    return text

courseware/capa_module.py

 import random, numpy, math, scipy, sys, StringIO, os, struct, json
 from x_module import XModule
+import sys
 
-from capa_problem import LoncapaProblem
+from capa.capa_problem import LoncapaProblem
 from django.http import Http404
 
 import dateutil
@@ -34,7 +35,7 @@ class LoncapaModule(XModule):
         return self.lcp.get_score()
 
     def max_score(self):
-        return len(self.lcp.questions)
+        return self.lcp.get_max_score()
 
     def get_html(self):
         return render_to_string('problem_ajax.html', 
@@ -162,7 +163,6 @@ class LoncapaModule(XModule):
             return json.dumps({"error":"Past due date"})
         elif dispatch=='problem_check': 
             response = self.check_problem(get)
-            print response
         elif dispatch=='problem_reset':
             response = self.reset_problem(get)
         elif dispatch=='problem_save':
@@ -238,16 +238,12 @@ class LoncapaModule(XModule):
             answers['_'.join(key.split('_')[1:])]=get[key]
 
         try:
-            print "A"
-            ocm = self.lcp.correct_map
-            print "."
-            oa = self.lcp.answers
-            print "."
+            old_state = self.lcp.get_state()
+            lcp_id = self.lcp.problem_id
+            filename = self.lcp.filename
             correct_map = self.lcp.grade_answers(answers)
-            print "."
         except: 
-            self.lcp.correct_map = ocm # HACK: Reset state
-            self.lcp.answers = oa
+            self.lcp = LoncapaProblem(filename, id=lcp_id, state=old_state)
             return json.dumps({'success':'syntax'})
 
         self.attempts = self.attempts + 1
@@ -279,7 +275,7 @@ class LoncapaModule(XModule):
         for key in get:
             answers['_'.join(key.split('_')[1:])]=get[key]
         
-        self.lcp.answers=answers
+        self.lcp.student_answers=answers
 
         return json.dumps({'success':True})
 

courseware/capa_problem.py

-import random, numpy, math, scipy, sys, StringIO, os, struct, json
-from dateutil import parser
-
-from xml.dom.minidom import parse, parseString
-
-from calc import evaluator
-
-def strip_dict(d):
-    ''' Takes a dict. Returns an identical dict, with all non-word
-    keys stripped out. ''' 
-    d=dict([(k, float(d[k])) for k in d if type(k)==str and \
-                                           k.isalnum() and \
-                                           (type(d[k]) == float or type(d[k]) == int) ])
-    return d
-
-class LoncapaProblem(object):
-    def get_state(self):
-        ''' Stored per-user session data neeeded to: 
-            1) Recreate the problem
-            2) Populate any student answers. '''
-        return {'seed':self.seed, 
-                'answers':self.answers,
-                'correct_map':self.correct_map, 
-                'done':self.done}
-
-    def get_score(self):
-        correct=0
-        for key in self.correct_map:
-            if self.correct_map[key] == u'correct':
-                correct += 1
-        if len(self.answers)==0:
-            return {'score':0,
-                    'total':len(self.questions)}
-        else:
-            return {'score':correct,
-                    'total':len(self.questions)}
-
-    def get_html(self):
-        ''' Return the HTML of the question '''
-        return self.text
-
-    def __init__(self, filename, id=None, state=None):
-        ''' Create a new problem of the type defined in filename. 
-            By default, this will generate a random problem. Passing 
-            seed will provide the random seed. Alternatively, passing
-            context will bypass all script execution, and use the 
-            given execution context.  '''
-        self.done=False
-        self.text=""
-        self.context=dict()   # Execution context from loncapa/python
-        self.questions=dict() # Detailed info about questions in problem instance. TODO: Should be by id and not lid. 
-        self.answers=dict()   # Student answers
-        self.correct_map=dict()
-        self.seed=None
-        self.gid="" # ID of the problem
-        self.lid=-1 # ID of the field within the problem
-
-
-        if state==None:
-            state=dict()
-        self.gid=id
-
-        if 'done' in state:
-            self.done=state['done']
-
-        if 'seed' in state and state['seed']!=None and state['seed']!="":
-            self.seed=state['seed']
-        else:
-            # TODO: Check performance of urandom -- depending on
-            # implementation, it may slow down to the point of causing
-            # performance issues if we deplete the kernel entropy
-            # pool.
-            self.seed=struct.unpack('i', os.urandom(4))[0] 
-
-        if 'answers' in state:
-            self.answers=state['answers']
-        if 'correct_map' in state:
-            self.correct_map=state['correct_map']
-
-        random.seed(self.seed)
-        dom=parse(filename)
-        for d in dom.childNodes:
-            if d.localName == 'problem':
-                dom = d
-                
-
-        g={'random':random,'numpy':numpy,'math':math,'scipy':scipy}
-
-        # Buffer stores HTML for problem
-        buf=StringIO.StringIO()
-        
-        ot=False ## Are we in an outtext context? 
-
-        #print "Here", dom
-
-        # Loop through the nodes of the problem, and 
-        for e in dom.childNodes:
-            #print e.localName
-            if e.localName=='script':
-                exec e.childNodes[0].data in g,self.context
-            elif e.localName=='endouttext':
-                ot=False
-            elif ot:
-                e.writexml(buf)
-            elif e.localName=='startouttext':
-                ot=True
-            elif e.localName in self.handlers:
-                problem=self.handlers[e.localName](self,e)
-                buf.write(problem)
-            elif e.localName==None:
-                pass
-            else: 
-                raise Exception("ERROR: UNRECOGNIZED XML"+e.localName)
-
-        self.text=buf.getvalue()
-        self.text=self.contextualize_text(self.text)
-        self.filename=filename
-
-    def get_context(self):
-        ''' Return the execution context '''
-        return self.context
-
-    def get_seed(self):
-        ''' Return the random seed used to generate the problem '''
-        return self.seed
-
-    def get_correct_map(self):
-        return self.correct_map
-
-    def set_answers(self, answers):
-        self.answers=answers
-
-    def get_question_answers(self):
-        rv = dict()
-        for key in self.questions:
-            rv[key]=str(self.questions[key]['answer'])
-        return rv
-
-    def grade_answers(self, answers):
-        ''' Takes a map of IDs to answers. Return which ones are correct '''
-        self.answers=answers
-        correct_map={}
-        for key in self.questions:
-           id=self.questions[key]['id']
-           if id not in answers:
-               correct_map[id]='incorrect' # Should always be there
-           else:
-               grader=self.graders[self.questions[key]['type']]
-               correct_map[id]=grader(self, self.questions[key],
-                                      self.answers[id])
-        self.correct_map=correct_map
-        return correct_map
-
-    def handle_schem(self, element):
-        height = element.getAttribute('height')
-        width = element.getAttribute('width')
-        if height=="":
-            height=480
-        if width=="":
-            width=640
-        self.lid+=1
-        id=str(self.gid)+'_'+str(self.lid)
-        
-        html='<input type="hidden" class="schematic" name="input_{id}" '+ \
-            'height="{height}" width="{width}" value="{value}" id="input_{id}">'
-        html = html.format(height=height, width=width, id=id, value="")
-
-        return html
-    
-    def grade_schem(self, element):
-        print element
-        return "correct"
-
-    def grade_nr(self, question, answer):
-        error = abs(evaluator({},{},answer) - question['answer'])
-        allowed_error = abs(question['answer']*question['tolerance'])
-        if error <= allowed_error:
-            return 'correct'
-        else:
-            return 'incorrect'
-
-    def handle_nr(self, element):
-        answer=element.getAttribute('answer')
-        for e in element.childNodes:
-            if e.nodeType==1 and e.getAttribute('type')=="tolerance":
-                tolerance=e.getAttribute('default')
-        self.lid+=1
-        id=str(self.gid)+'_'+str(self.lid)
-        problem={"answer":evaluator({},{},self.contextualize_text(answer)),
-                 "type":"numericalresponse",
-                 "tolerance":evaluator({},{},self.contextualize_text(tolerance)),
-                 "id":id,
-                 "lid":self.lid,
-                 }
-        self.questions[self.lid]=problem
-
-        if id in self.answers:
-            value=self.answers[id]
-        else:
-            value=""
-        icon='bullet'
-        if id in self.correct_map and self.correct_map[id]=='correct':
-            icon='check'
-        if id in self.correct_map and self.correct_map[id]=='incorrect':
-            icon='close'
-
-        html='<input type="text" name="input_{id}" id="input_{id}" value="{value}"><span id="answer_{id}"></span><span class="ui-icon ui-icon-{icon}" style="display:inline-block;" id="status_{id}"></span> '.format(id=id,value=value,icon=icon)
-        return html
-
-    def grade_fr(self, question, answer):
-        correct = True
-        for i in range(question['samples_count']):
-            instructor_variables = strip_dict(dict(self.context))
-            student_variables = dict()
-            for var in question['sample_range']:
-                value = random.uniform(*question['sample_range'][var])
-                instructor_variables[str(var)] = value
-                student_variables[str(var)] = value
-            instructor_result = evaluator(instructor_variables,{},str(question['answer']))
-            student_result = evaluator(student_variables,{},str(answer))
-            if math.isnan(student_result) or math.isinf(student_result):
-                return "incorrect"
-            if abs( student_result - instructor_result ) > question['tolerance']:
-                return "incorrect"
- 
-        return "correct"
-
-    def handle_fr(self, element):
-        ## Extract description from element
-        samples=element.getAttribute('samples')
-        variables=samples.split('@')[0].split(',')
-        numsamples=int(samples.split('@')[1].split('#')[1])
-        sranges=zip(*map(lambda x:map(float, x.split(",")), samples.split('@')[1].split('#')[0].split(':')))
-        answer=element.getAttribute('answer')
-        for e in element.childNodes:
-            if e.nodeType==1 and e.getAttribute('type')=="tolerance":
-                tolerance=e.getAttribute('default')
-
-        # Store element
-        self.lid+=1
-        id=str(self.gid)+'_'+str(self.lid)
-        problem={"answer":self.contextualize_text(answer),
-                 "type":"formularesponse",
-                 "tolerance":evaluator({},{},self.contextualize_text(tolerance)),
-                 "sample_range":dict(zip(variables, sranges)),
-                 "samples_count": numsamples,
-                 "id":id,
-                 "lid":self.lid,
-                 }
-        self.questions[self.lid]=problem        
-
-        # Generate HTML
-        if id in self.answers:
-            value=self.answers[id]
-        else:
-            value=""
-        icon='bullet'
-        if id in self.correct_map and self.correct_map[id]=='correct':
-            icon='check'
-        if id in self.correct_map and self.correct_map[id]=='incorrect':
-            icon='close'
-
-        html='<input type="text" name="input_{id}" id="input_{id}" value="{value}"><span id="answer_{id}"></span><span class="ui-icon ui-icon-{icon}" style="display:inline-block;" id="status_{id}"></span> '.format(id=id,value=value,icon=icon)
-        return html
-
-    graders={'numericalresponse':grade_nr,
-             'formularesponse':grade_fr, 
-             'schematicresponse':grade_schem}
-    handlers={'numericalresponse':handle_nr,
-              'formularesponse':handle_fr, 
-              'schematicresponse':handle_schem}
-
-    def contextualize_text(self, text):
-        ''' Takes a string with variables. E.g. $a+$b. 
-            Does a substitution of those variables from the context '''
-        for key in sorted(self.context, lambda x,y:cmp(len(y),len(x))):
-            text=text.replace('$'+key, str(self.context[key]))
-        return text
-
-if __name__=='__main__':  
-    p=LoncapaProblem('resistor.xml', seed=-1601461296)
-
-    print p.getHtml()
-    print p.getContext()
-    print p.getSeed()

util/views.py

@@ -6,7 +6,7 @@ import json
 from django.conf import settings
 from django.core.context_processors import csrf
 from django.http import Http404
-import courseware.calc
+import courseware.capa.calc
 from django.core.mail import send_mail
 from django.conf import settings
 import datetime