Splitting files into subdirectories in preparation for merge

djangoapps/courseware/modules/__init__.py

@@ -0,0 +1,69 @@
+import os
+import os.path
+
+from django.conf import settings
+
+import capa_module
+import html_module
+import schematic_module
+import seq_module
+import template_module
+import vertical_module
+import video_module
+
+from courseware import content_parser
+
+# Import all files in modules directory, excluding backups (# and . in name) 
+# and __init__
+#
+# Stick them in a list
+# modx_module_list = []
+
+# for f in os.listdir(os.path.dirname(__file__)):
+#     if f!='__init__.py' and \
+#             f[-3:] == ".py" and \
+#             "." not in f[:-3] \
+#             and '#' not in f:
+#         mod_path = 'courseware.modules.'+f[:-3]
+#         mod = __import__(mod_path, fromlist = "courseware.modules")
+#         if 'Module' in mod.__dict__:
+#             modx_module_list.append(mod)
+
+#print modx_module_list
+modx_module_list = [capa_module,  html_module,  schematic_module,  seq_module,  template_module,  vertical_module,  video_module]
+#print modx_module_list
+
+modx_modules = {}
+
+# Convert list to a dictionary for lookup by tag
+def update_modules():
+    global modx_modules
+    modx_modules = dict()
+    for module in modx_module_list:
+        for tag in module.Module.get_xml_tags():
+            modx_modules[tag] = module.Module
+
+update_modules()
+
+def get_module_class(tag):
+    ''' Given an XML tag (e.g. 'video'), return 
+    the associated module (e.g. video_module.Module). 
+    '''
+    if tag not in modx_modules:
+        update_modules()
+    return modx_modules[tag]
+
+def get_module_id(tag):
+    ''' Given an XML tag (e.g. 'video'), return 
+    the default ID for that module (e.g. 'youtube_id')
+    '''
+    return modx_modules[tag].id_attribute
+
+def get_valid_tags():
+    return modx_modules.keys()
+
+def get_default_ids():
+    tags = get_valid_tags()
+    ids = map(get_module_id, tags)
+    return dict(zip(tags, ids))
+

djangoapps/courseware/modules/capa_module.py

@@ -0,0 +1,382 @@
+import StringIO
+import datetime
+import dateutil
+import dateutil.parser
+import json
+import logging
+import math
+import numpy
+import os
+import random
+import scipy
+import struct
+import sys
+import traceback
+
+from lxml import etree
+
+## TODO: Abstract out from Django
+from django.conf import settings
+from mitxmako.shortcuts import render_to_response, render_to_string
+from django.http import Http404
+
+from x_module import XModule
+from courseware.capa.capa_problem import LoncapaProblem, StudentInputError
+import courseware.content_parser as content_parser
+
+log = logging.getLogger("mitx.courseware")
+
+class Module(XModule):
+    ''' Interface between capa_problem and x_module. Originally a hack
+    meant to be refactored out, but it seems to be serving a useful
+    prupose now. We can e.g .destroy and create the capa_problem on a
+    reset. 
+    '''
+
+    id_attribute = "filename"
+
+    @classmethod
+    def get_xml_tags(c):
+        return ["problem"]
+
+    def get_state(self):
+        state = self.lcp.get_state()
+        state['attempts'] = self.attempts
+        return json.dumps(state)
+
+    def get_score(self):
+        return self.lcp.get_score()
+
+    def max_score(self):
+        return self.lcp.get_max_score()
+
+    def get_html(self):
+        return render_to_string('problem_ajax.html', 
+                              {'id':self.item_id, 
+                               'ajax_url':self.ajax_url,
+                               })
+
+    def get_init_js(self):
+        return render_to_string('problem.js', 
+                              {'id':self.item_id, 
+                               'ajax_url':self.ajax_url,
+                               })
+
+    def get_problem_html(self, encapsulate=True):
+        html = self.lcp.get_html()
+        content={'name':self.name, 
+                 'html':html}
+        
+        check_button = True
+        reset_button = True
+        save_button = True
+
+        # If we're after deadline, or user has exhuasted attempts, 
+        # question is read-only. 
+        if self.closed():
+            check_button = False
+            reset_button = False
+            save_button = False
+            
+
+        # User submitted a problem, and hasn't reset. We don't want
+        # more submissions. 
+        if self.lcp.done and self.rerandomize == "always":
+            #print "!"
+            check_button = False
+            save_button = False
+        
+        # User hasn't submitted an answer yet -- we don't want resets
+        if not self.lcp.done:
+            reset_button = False
+
+        attempts_str = ""
+        if self.max_attempts != None: 
+            attempts_str = " ({a}/{m})".format(a=self.attempts, m=self.max_attempts)
+
+        # We don't need a "save" button if infinite number of attempts and non-randomized
+        if self.max_attempts == None and self.rerandomize != "always":
+            save_button = False
+
+        # Check if explanation is available, and if so, give a link
+        explain=""
+        if self.lcp.done and self.explain_available=='attempted':
+            explain=self.explanation
+        if self.closed() and self.explain_available=='closed':
+            explain=self.explanation
+        
+        if len(explain) == 0:
+            explain = False
+
+        html=render_to_string('problem.html', 
+                              {'problem' : content, 
+                               'id' : self.item_id, 
+                               'check_button' : check_button,
+                               'reset_button' : reset_button,
+                               'save_button' : save_button,
+                               'answer_available' : self.answer_available(),
+                               'ajax_url' : self.ajax_url,
+                               'attempts': attempts_str, 
+                               'explain': explain
+                               })
+        if encapsulate:
+            html = '<div id="main_{id}">'.format(id=self.item_id)+html+"</div>"
+            
+        return html
+
+    def __init__(self, xml, item_id, ajax_url=None, track_url=None, state=None, track_function=None, render_function = None, meta = None):
+        XModule.__init__(self, xml, item_id, ajax_url, track_url, state, track_function, render_function)
+
+        self.attempts = 0
+        self.max_attempts = None
+        
+        dom2 = etree.fromstring(xml)
+
+        self.explanation=content_parser.item(dom2.xpath('/problem/@explain'), default="closed")
+        self.explain_available=content_parser.item(dom2.xpath('/problem/@explain_available'))
+
+        display_due_date_string=content_parser.item(dom2.xpath('/problem/@due'))
+        if len(display_due_date_string)>0:
+            self.display_due_date=dateutil.parser.parse(display_due_date_string)
+            #log.debug("Parsed " + display_due_date_string + " to " + str(self.display_due_date))
+        else:
+            self.display_due_date=None
+        
+        
+        grace_period_string = content_parser.item(dom2.xpath('/problem/@graceperiod'))
+        if len(grace_period_string)>0 and self.display_due_date:
+            self.grace_period = content_parser.parse_timedelta(grace_period_string)
+            self.close_date = self.display_due_date + self.grace_period
+            #log.debug("Then parsed " + grace_period_string + " to closing date" + str(self.close_date))
+        else:
+            self.grace_period = None
+            self.close_date = self.display_due_date
+            
+        self.max_attempts=content_parser.item(dom2.xpath('/problem/@attempts'))
+        if len(self.max_attempts)>0:
+            self.max_attempts=int(self.max_attempts)
+        else:
+            self.max_attempts=None
+
+        self.show_answer=content_parser.item(dom2.xpath('/problem/@showanswer'))
+
+        if self.show_answer=="":
+            self.show_answer="closed"
+
+        self.rerandomize=content_parser.item(dom2.xpath('/problem/@rerandomize'))
+        if self.rerandomize=="" or self.rerandomize=="always" or self.rerandomize=="true":
+            self.rerandomize="always"
+        elif self.rerandomize=="false" or self.rerandomize=="per_student":
+            self.rerandomize="per_student"
+        elif self.rerandomize=="never":
+            self.rerandomize="never"
+        else:
+            raise Exception("Invalid rerandomize attribute "+self.rerandomize)
+
+        if state!=None:
+            state=json.loads(state)
+        if state!=None and 'attempts' in state:
+            self.attempts=state['attempts']
+
+        self.filename=content_parser.item(dom2.xpath('/problem/@filename'))
+        filename=settings.DATA_DIR+"/problems/"+self.filename+".xml"
+        self.name=content_parser.item(dom2.xpath('/problem/@name'))
+        if self.rerandomize == 'never':
+            seed = 1
+        else:
+            seed = None
+        self.lcp=LoncapaProblem(filename, self.item_id, state, seed = seed)
+
+    def handle_ajax(self, dispatch, get):
+        if dispatch=='problem_get':
+            response = self.get_problem(get)
+        elif False: #self.close_date > 
+            return json.dumps({"error":"Past due date"})
+        elif dispatch=='problem_check': 
+            response = self.check_problem(get)
+        elif dispatch=='problem_reset':
+            response = self.reset_problem(get)
+        elif dispatch=='problem_save':
+            response = self.save_problem(get)
+        elif dispatch=='problem_show':
+            response = self.get_answer(get)
+        else: 
+            return "Error"
+        return response
+
+    def closed(self):
+        ''' Is the student still allowed to submit answers? '''
+        if self.attempts == self.max_attempts:
+            return True
+        if self.close_date != None and datetime.datetime.utcnow() > self.close_date:
+            return True
+
+        return False
+        
+
+    def answer_available(self):
+        ''' Is the user allowed to see an answer? 
+        ''' 
+        if self.show_answer == '':
+            return False
+        if self.show_answer == "never":
+            return False
+        if self.show_answer == 'attempted' and self.attempts == 0:
+            return False
+        if self.show_answer == 'attempted' and self.attempts > 0:
+            return True
+        if self.show_answer == 'answered' and self.lcp.done:
+            return True
+        if self.show_answer == 'answered' and not self.lcp.done:
+            return False
+        if self.show_answer == 'closed' and self.closed():
+            return True
+        if self.show_answer == 'closed' and not self.closed():
+            return False
+        print "aa", self.show_answer
+        raise Http404
+
+    def get_answer(self, get):
+        if not self.answer_available():
+            raise Http404
+        else: 
+            return json.dumps(self.lcp.get_question_answers())
+
+
+    # Figure out if we should move these to capa_problem?
+    def get_problem(self, get):
+        ''' Same as get_problem_html -- if we want to reconfirm we
+            have the right thing e.g. after several AJAX calls.'''
+        return self.get_problem_html(encapsulate=False)        
+
+    def check_problem(self, get):
+        ''' Checks whether answers to a problem are correct, and
+            returns a map of correct/incorrect answers'''
+        event_info = dict()
+        event_info['state'] = self.lcp.get_state()
+        event_info['filename'] = self.filename
+
+        answers=dict()
+        # input_resistor_1 ==> resistor_1
+        for key in get:
+            answers['_'.join(key.split('_')[1:])]=get[key]
+
+#        print "XXX", answers, get
+
+        event_info['answers']=answers
+
+        # Too late. Cannot submit
+        if self.closed():
+            event_info['failure']='closed'
+            self.tracker('save_problem_check_fail', event_info)
+            print "cp"
+            raise Http404
+            
+        # Problem submitted. Student should reset before checking
+        # again.
+        if self.lcp.done and self.rerandomize == "always":
+            event_info['failure']='unreset'
+            self.tracker('save_problem_check_fail', event_info)
+            print "cpdr"
+            raise Http404
+
+        try:
+            old_state = self.lcp.get_state()
+            lcp_id = self.lcp.problem_id
+            filename = self.lcp.filename
+            correct_map = self.lcp.grade_answers(answers)
+        except StudentInputError as inst: 
+            self.lcp = LoncapaProblem(filename, id=lcp_id, state=old_state)
+            traceback.print_exc()
+#            print {'error':sys.exc_info(),
+#                   'answers':answers, 
+#                   'seed':self.lcp.seed, 
+#                   'filename':self.lcp.filename}
+            return json.dumps({'success':inst.message})
+        except: 
+            self.lcp = LoncapaProblem(filename, id=lcp_id, state=old_state)
+            traceback.print_exc()
+            return json.dumps({'success':'Unknown Error'})
+            
+
+        self.attempts = self.attempts + 1
+        self.lcp.done=True
+
+        success = 'correct'
+        for i in correct_map:
+            if correct_map[i]!='correct':
+                success = 'incorrect'
+
+        js=json.dumps({'correct_map' : correct_map,
+                       'success' : success})
+
+        event_info['correct_map']=correct_map
+        event_info['success']=success
+
+        self.tracker('save_problem_check', event_info)
+
+        return js
+
+    def save_problem(self, get):
+        event_info = dict()
+        event_info['state'] = self.lcp.get_state()
+        event_info['filename'] = self.filename
+
+        answers=dict()
+        for key in get:
+            answers['_'.join(key.split('_')[1:])]=get[key]
+        event_info['answers'] = answers
+
+        # Too late. Cannot submit
+        if self.closed():
+            event_info['failure']='closed'
+            self.tracker('save_problem_fail', event_info)
+            return "Problem is closed"
+            
+        # Problem submitted. Student should reset before saving
+        # again.
+        if self.lcp.done and self.rerandomize == "always":
+            event_info['failure']='done'
+            self.tracker('save_problem_fail', event_info)
+            return "Problem needs to be reset prior to save."
+
+        self.lcp.student_answers=answers
+
+        self.tracker('save_problem_fail', event_info)
+        return json.dumps({'success':True})
+
+    def reset_problem(self, get):
+        ''' Changes problem state to unfinished -- removes student answers, 
+            and causes problem to rerender itself. '''
+        event_info = dict()
+        event_info['old_state']=self.lcp.get_state()
+        event_info['filename']=self.filename
+
+        if self.closed():
+            event_info['failure']='closed'
+            self.tracker('reset_problem_fail', event_info)
+            return "Problem is closed"
+            
+        if not self.lcp.done:
+            event_info['failure']='not_done'
+            self.tracker('reset_problem_fail', event_info)
+            return "Refresh the page and make an attempt before resetting."
+
+        self.lcp.done=False
+        self.lcp.answers=dict()
+        self.lcp.correct_map=dict()
+        self.lcp.student_answers = dict()
+
+
+        if self.rerandomize == "always":
+            self.lcp.context=dict()
+            self.lcp.questions=dict() # Detailed info about questions in problem instance. TODO: Should be by id and not lid. 
+            self.lcp.seed=None
+
+        filename=settings.DATA_DIR+"problems/"+self.filename+".xml"
+        self.lcp=LoncapaProblem(filename, self.item_id, self.lcp.get_state())
+
+        event_info['new_state']=self.lcp.get_state()
+        self.tracker('reset_problem', event_info)
+
+        return json.dumps(self.get_problem_html(encapsulate=False))

djangoapps/courseware/modules/html_module.py

@@ -0,0 +1,38 @@
+import json
+
+## TODO: Abstract out from Django
+from django.conf import settings
+from mitxmako.shortcuts import render_to_response, render_to_string
+
+from x_module import XModule
+from lxml import etree
+
+class Module(XModule):
+    id_attribute = 'filename'
+
+    def get_state(self):
+        return json.dumps({ })
+
+    @classmethod
+    def get_xml_tags(c):
+        return ["html"]
+        
+    def get_html(self):
+        if self.filename==None:
+            xmltree=etree.fromstring(self.xml)
+            textlist=[xmltree.text]+[etree.tostring(i) for i in xmltree]+[xmltree.tail]
+            textlist=[i for i in textlist if type(i)==str]
+            return "".join(textlist)
+        try: 
+            filename=settings.DATA_DIR+"html/"+self.filename
+            return open(filename).read()
+        except: # For backwards compatibility. TODO: Remove
+            return render_to_string(self.filename, {'id': self.item_id})
+
+    def __init__(self, xml, item_id, ajax_url=None, track_url=None, state=None, track_function=None, render_function = None):
+        XModule.__init__(self, xml, item_id, ajax_url, track_url, state, track_function, render_function)
+        xmltree=etree.fromstring(xml)
+        self.filename = None
+        filename_l=xmltree.xpath("/html/@filename")
+        if len(filename_l)>0:
+            self.filename=str(filename_l[0])

djangoapps/courseware/modules/schematic_module.py

@@ -0,0 +1,24 @@
+import json
+
+## TODO: Abstract out from Django
+from django.conf import settings
+from mitxmako.shortcuts import render_to_response, render_to_string
+
+from x_module import XModule
+
+class Module(XModule):
+    id_attribute = 'id'
+
+    def get_state(self):
+        return json.dumps({ })
+
+    @classmethod
+    def get_xml_tags(c):
+        return ["schematic"]
+        
+    def get_html(self):
+        return '<input type="hidden" class="schematic" name="{item_id}" height="480" width="640">'.format(item_id=self.item_id)
+
+    def __init__(self, xml, item_id, ajax_url=None, track_url=None, state=None, render_function = None):
+        XModule.__init__(self, xml, item_id, ajax_url, track_url, state, render_function)
+

djangoapps/courseware/modules/seq_module.py

@@ -0,0 +1,121 @@
+import json
+
+from lxml import etree
+
+## TODO: Abstract out from Django
+from django.http import Http404
+from django.conf import settings
+from mitxmako.shortcuts import render_to_response, render_to_string
+
+from x_module import XModule
+
+# HACK: This shouldn't be hard-coded to two types
+# OBSOLETE: This obsoletes 'type'
+class_priority = ['video', 'problem']
+
+class Module(XModule):
+    ''' Layout module which lays out content in a temporal sequence
+    '''
+    id_attribute = 'id'
+
+    def get_state(self):
+        return json.dumps({ 'position':self.position })
+
+    @classmethod
+    def get_xml_tags(c):
+        return ["sequential", 'tab']
+        
+    def get_html(self):
+        self.render()
+        return self.content
+
+    def get_init_js(self):
+        self.render()
+        return self.init_js
+
+    def get_destroy_js(self):
+        self.render()
+        return self.destroy_js
+
+    def handle_ajax(self, dispatch, get):
+        print "GET", get
+        print "DISPATCH", dispatch
+        if dispatch=='goto_position':
+            self.position = int(get['position'])
+            return json.dumps({'success':True})
+        raise Http404()
+
+    def render(self):
+        if self.rendered:
+            return
+        def j(m): 
+            ''' jsonify contents so it can be embedded in a js array
+            We also need to split </script> tags so they don't break
+            mid-string'''
+            if 'init_js' not in m: m['init_js']=""
+            if 'type' not in m: m['init_js']=""
+            content=json.dumps(m['content']) 
+            content=content.replace('</script>', '<"+"/script>') 
+
+            return {'content':content, 
+                    "destroy_js":m['destroy_js'], 
+                    'init_js':m['init_js'], 
+                    'type': m['type']}
+
+
+        ## Returns a set of all types of all sub-children
+        child_classes = [set([i.tag for i in e.iter()]) for e in self.xmltree]
+
+        self.titles = json.dumps(["\n".join([i.get("name").strip() for i in e.iter() if i.get("name") != None]) \
+                           for e in self.xmltree])
+
+        self.contents = [j(self.render_function(e)) \
+                             for e in self.xmltree]
+
+        print self.titles
+
+        for (content, element_class) in zip(self.contents, child_classes):
+            new_class = 'other'
+            for c in class_priority:
+                if c in element_class: 
+                    new_class = c
+            content['type'] = new_class
+     
+        js=""
+
+        params={'items':self.contents,
+                'id':self.item_id,
+                'position': self.position,
+                'titles':self.titles}
+
+        # TODO/BUG: Destroy JavaScript should only be called for the active view
+        # This calls it for all the views
+        # 
+        # To fix this, we'd probably want to have some way of assigning unique
+        # IDs to sequences. 
+        destroy_js="".join([e['destroy_js'] for e in self.contents if 'destroy_js' in e])
+
+        if self.xmltree.tag == 'sequential':
+            self.init_js=js+render_to_string('seq_module.js',params)
+            self.destroy_js=destroy_js
+            self.content=render_to_string('seq_module.html',params)
+        if self.xmltree.tag == 'tab':
+            params['id'] = 'tab'
+            self.init_js=js+render_to_string('tab_module.js',params)
+            self.destroy_js=destroy_js
+            self.content=render_to_string('tab_module.html',params)
+        self.rendered = True
+        
+
+
+    def __init__(self, xml, item_id, ajax_url=None, track_url=None, state=None, track_function=None, render_function = None):
+        XModule.__init__(self, xml, item_id, ajax_url, track_url, state, track_function, render_function)
+        self.xmltree=etree.fromstring(xml)
+
+        self.position = 1
+
+        if state!=None:
+            state = json.loads(state)
+            if 'position' in state: self.position = int(state['position'])
+
+        self.rendered = False

djangoapps/courseware/modules/template_module.py

@@ -0,0 +1,29 @@
+import json
+import os
+
+## TODO: Abstract out from Django
+from django.conf import settings
+from mitxmako.shortcuts import render_to_response, render_to_string
+
+from x_module import XModule
+from lxml import etree
+
+class Module(XModule):
+    def get_state(self):
+        return json.dumps({ })
+
+    @classmethod
+    def get_xml_tags(c):
+        tags = os.listdir(settings.DATA_DIR+'/custom_tags')
+        return tags
+
+    def get_html(self):
+        return self.html
+
+    def __init__(self, xml, item_id, ajax_url=None, track_url=None, state=None, track_function=None, render_function = None):
+        XModule.__init__(self, xml, item_id, ajax_url, track_url, state, track_function, render_function)
+        xmltree = etree.fromstring(xml)
+        filename = xmltree.tag
+        params = dict(xmltree.items())
+#        print params
+        self.html = render_to_string(filename, params, namespace = 'custom_tags')

djangoapps/courseware/modules/vertical_module.py

@@ -0,0 +1,35 @@
+import json
+
+## TODO: Abstract out from Django
+from django.conf import settings
+from mitxmako.shortcuts import render_to_response, render_to_string
+
+from x_module import XModule
+from lxml import etree
+
+class Module(XModule):
+    id_attribute = 'id'
+
+    def get_state(self):
+        return json.dumps({ })
+
+    @classmethod
+    def get_xml_tags(c):
+        return ["vertical"]
+        
+    def get_html(self):
+        return render_to_string('vert_module.html',{'items':self.contents})
+
+    def get_init_js(self):
+        return self.init_js_text
+
+    def get_destroy_js(self):
+        return self.destroy_js_text
+
+    def __init__(self, xml, item_id, ajax_url=None, track_url=None, state=None, track_function=None, render_function = None):
+        XModule.__init__(self, xml, item_id, ajax_url, track_url, state, track_function, render_function)
+        xmltree=etree.fromstring(xml)
+        self.contents=[(e.get("name"),self.render_function(e)) \
+                      for e in xmltree]
+        self.init_js_text="".join([e[1]['init_js'] for e in self.contents if 'init_js' in e[1]])
+        self.destroy_js_text="".join([e[1]['destroy_js'] for e in self.contents if 'destroy_js' in e[1]])

djangoapps/courseware/modules/video_module.py

@@ -0,0 +1,70 @@
+import json
+import logging
+
+from lxml import etree
+
+## TODO: Abstract out from Django
+from django.conf import settings
+from mitxmako.shortcuts import render_to_response, render_to_string
+
+from x_module import XModule
+
+log = logging.getLogger("mitx.courseware.modules")
+
+class Module(XModule):
+    id_attribute = 'youtube'
+    video_time = 0
+
+    def handle_ajax(self, dispatch, get):
+        log.debug(u"GET {0}".format(get))
+        log.debug(u"DISPATCH {0}".format(dispatch))
+        if dispatch == 'goto_position':
+            self.position = int(float(get['position']))
+            log.debug(u"NEW POSITION {0}".format(self.position))
+            return json.dumps({'success':True})
+        raise Http404()
+
+    def get_state(self):
+        log.debug(u"STATE POSITION {0}".format(self.position))
+        return json.dumps({ 'position':self.position })
+
+    @classmethod
+    def get_xml_tags(c):
+        '''Tags in the courseware file guaranteed to correspond to the module'''
+        return ["video"]
+        
+    def video_list(self):
+        l = self.youtube.split(',')
+        l = [i.split(":") for i in l]
+        return json.dumps(dict(l))
+    
+    def get_html(self):
+        return render_to_string('video.html',{'streams':self.video_list(),
+                                              'id':self.item_id,
+                                              'position':self.position, 
+                                              'name':self.name})
+
+    def get_init_js(self):
+        '''JavaScript code to be run when problem is shown. Be aware
+        that this may happen several times on the same page
+        (e.g. student switching tabs). Common functions should be put
+        in the main course .js files for now. ''' 
+        log.debug(u"INIT POSITION {0}".format(self.position))
+        return render_to_string('video_init.js',{'streams':self.video_list(),
+                                                 'id':self.item_id,
+                                                 'position':self.position})
+
+    def get_destroy_js(self):
+        return "videoDestroy(\"{0}\");".format(self.item_id)
+
+    def __init__(self, xml, item_id, ajax_url=None, track_url=None, state=None, track_function=None, render_function = None):
+        XModule.__init__(self, xml, item_id, ajax_url, track_url, state, track_function, render_function)
+        self.youtube = etree.XML(xml).get('youtube')
+        self.name = etree.XML(xml).get('name')
+        self.position = 0
+        if state != None:
+            state = json.loads(state)
+            if 'position' in state:
+                self.position = int(float(state['position']))
+            #log.debug("POSITION IN STATE")
+        #log.debug(u"LOAD POSITION {0}".format(self.position))

djangoapps/courseware/modules/x_module.py

@@ -0,0 +1,57 @@
+import courseware.progress
+
+def dummy_track(event_type, event):
+    pass
+
+class XModule(object):
+    ''' Implements a generic learning module. 
+        Initialized on access with __init__, first time with state=None, and
+        then with state
+    '''
+    id_attribute='id' # An attribute guaranteed to be unique
+
+    @classmethod
+    def get_xml_tags(c):
+        ''' Tags in the courseware file guaranteed to correspond to the module '''
+        return []
+        
+    def get_completion(self):
+        return courseware.progress.completion()
+    
+    def get_state(self):
+        return ""
+
+    def get_score(self):
+        return None
+
+    def max_score(self):
+        return None
+
+    def get_html(self):
+        return "Unimplemented"
+
+    def get_init_js(self):
+        ''' JavaScript code to be run when problem is shown. Be aware
+        that this may happen several times on the same page
+        (e.g. student switching tabs). Common functions should be put
+        in the main course .js files for now. ''' 
+        return ""
+
+    def get_destroy_js(self):
+        return ""
+
+    def handle_ajax(self, dispatch, get):
+        ''' dispatch is last part of the URL. 
+            get is a dictionary-like object ''' 
+        return ""
+
+    def __init__(self, xml, item_id, ajax_url=None, track_url=None, state=None, track_function=None, render_function = None):
+        ''' In most cases, you must pass state or xml'''
+        self.xml = xml
+        self.item_id = item_id
+        self.ajax_url = ajax_url
+        self.track_url = track_url
+        self.state = state
+        self.tracker = track_function
+        self.render_function = render_function
+