Merge branch 'master' into feature/dave/email_bugfixes

common/djangoapps/external_auth/views.py

@@ -293,6 +293,8 @@ def add_openid_simple_registration(request, response, data):
                 sreg_data['email'] = data['email']
             elif field == 'fullname' and 'fullname' in data:
                 sreg_data['fullname'] = data['fullname']
+            elif field == 'nickname' and 'nickname' in data:
+                sreg_data['nickname'] = data['nickname']
 
         # construct sreg response
         sreg_response = sreg.SRegResponse.extractResponse(sreg_request,
@@ -486,13 +488,22 @@ def provider_login(request):
             url = endpoint + urlquote(user.username)
             response = openid_request.answer(True, None, url)
 
-            return provider_respond(server,
-                                    openid_request,
-                                    response,
-                                    {
-                                        'fullname': profile.name,
-                                        'email': user.email
-                                    })
+            # TODO: for CS50 we are forcibly returning the username
+            # instead of fullname. In the OpenID simple registration
+            # extension, we don't have to return any fields we don't
+            # want to, even if they were marked as required by the
+            # Consumer. The behavior of what to do when there are
+            # missing fields is up to the Consumer. The proper change
+            # should only return the username, however this will likely
+            # break the CS50 client. Temporarily we will be returning
+            # username filling in for fullname in addition to username 
+            # as sreg nickname.
+            results = {
+                'nickname': user.username,
+                'email': user.email,
+                'fullname': user.username
+                }
+            return provider_respond(server, openid_request, response, results)
 
         request.session['openid_error'] = True
         msg = "Login failed - Account not active for user {0}".format(username)

common/lib/capa/capa/capa_problem.py

@@ -30,6 +30,8 @@ import sys
 from lxml import etree
 from xml.sax.saxutils import unescape
 
+import chem
+import chem.chemcalc
 import calc
 from correctmap import CorrectMap
 import eia
@@ -53,7 +55,9 @@ entry_types = ['textline',
                'radiogroup',
                'checkboxgroup',
                'filesubmission',
-               'javascriptinput',]
+               'javascriptinput',
+               'crystallography',
+               'chemicalequationinput',]
 
 # extra things displayed after "show answers" is pressed
 solution_types = ['solution']
@@ -72,7 +76,8 @@ global_context = {'random': random,
                   'math': math,
                   'scipy': scipy,
                   'calc': calc,
-                  'eia': eia}
+                  'eia': eia,
+                  'chemcalc': chem.chemcalc}
 
 # These should be removed from HTML output, including all subelements
 html_problem_semantics = ["codeparam", "responseparam", "answer", "script", "hintgroup"]
@@ -436,7 +441,7 @@ class LoncapaProblem(object):
             sys.path = original_path + self._extract_system_path(script)
 
             stype = script.get('type')
-            
+
             if stype:
                 if 'javascript' in stype:
                     continue    # skip javascript
@@ -478,8 +483,8 @@ class LoncapaProblem(object):
 
         problemid = problemtree.get('id')    # my ID
 
-        if problemtree.tag in inputtypes.get_input_xml_tags():
-
+        if problemtree.tag in inputtypes.registered_input_tags():
+            # If this is an inputtype subtree, let it render itself.
             status = "unsubmitted"
             msg = ''
             hint = ''
@@ -496,20 +501,17 @@ class LoncapaProblem(object):
                 value = self.student_answers[problemid]
 
             # do the rendering
-            render_object = inputtypes.SimpleInput(system=self.system,
-                                                   xml=problemtree,
-                                                   state={'value': value,
-                                                          'status': status,
-                                                          'id': problemtree.get('id'),
-                                                          'feedback': {'message': msg,
-                                                                       'hint': hint,
-                                                                       'hintmode': hintmode,
-                                                                       }
-                                                          },
-                                                   use='capa_input')
-            # function(problemtree, value, status, msg)
-            # render the special response (textline, schematic,...)
-            return render_object.get_html()
+
+            state = {'value': value,
+                   'status': status,
+                   'id': problemtree.get('id'),
+                   'feedback': {'message': msg,
+                                'hint': hint,
+                                'hintmode': hintmode,}}
+
+            input_type_cls = inputtypes.get_class_for_tag(problemtree.tag)
+            the_input = input_type_cls(self.system, problemtree, state)
+            return the_input.get_html()
 
         # let each Response render itself
         if problemtree in self.responders:

common/lib/capa/capa/chem/__init__.py

+

common/lib/capa/capa/chem/chemcalc.py

+from __future__ import division
+import copy
+from fractions import Fraction
+import logging
+import math
+import operator
+import re
+import numpy
+import numbers
+import scipy.constants
+
+from pyparsing import (Literal, Keyword, Word, nums, StringEnd, Optional,
+                       Forward, OneOrMore, ParseException)
+import nltk
+from nltk.tree import Tree
+
+ARROWS = ('<->', '->')
+
+## Defines a simple pyparsing tokenizer for chemical equations
+elements = ['Ac','Ag','Al','Am','Ar','As','At','Au','B','Ba','Be',
+            'Bh','Bi','Bk','Br','C','Ca','Cd','Ce','Cf','Cl','Cm',
+            'Cn','Co','Cr','Cs','Cu','Db','Ds','Dy','Er','Es','Eu',
+            'F','Fe','Fl','Fm','Fr','Ga','Gd','Ge','H','He','Hf',
+            'Hg','Ho','Hs','I','In','Ir','K','Kr','La','Li','Lr',
+            'Lu','Lv','Md','Mg','Mn','Mo','Mt','N','Na','Nb','Nd',
+            'Ne','Ni','No','Np','O','Os','P','Pa','Pb','Pd','Pm',
+            'Po','Pr','Pt','Pu','Ra','Rb','Re','Rf','Rg','Rh','Rn',
+            'Ru','S','Sb','Sc','Se','Sg','Si','Sm','Sn','Sr','Ta',
+            'Tb','Tc','Te','Th','Ti','Tl','Tm','U','Uuo','Uup',
+            'Uus','Uut','V','W','Xe','Y','Yb','Zn','Zr']
+digits = map(str, range(10))
+symbols = list("[](){}^+-/")
+phases = ["(s)", "(l)", "(g)", "(aq)"]
+tokens = reduce(lambda a, b: a ^ b, map(Literal, elements + digits + symbols + phases))
+tokenizer = OneOrMore(tokens) + StringEnd()
+
+
+def _orjoin(l):
+    return "'" + "' | '".join(l) + "'"
+
+## Defines an NLTK parser for tokenized expressions
+grammar = """
+  S -> multimolecule | multimolecule '+' S
+  multimolecule -> count molecule | molecule
+  count -> number | number '/' number
+  molecule -> unphased | unphased phase
+  unphased -> group | paren_group_round | paren_group_square
+  element -> """ + _orjoin(elements) + """
+  digit -> """ + _orjoin(digits) + """
+  phase -> """ + _orjoin(phases) + """
+  number -> digit | digit number
+  group -> suffixed | suffixed group
+  paren_group_round -> '(' group ')'
+  paren_group_square -> '[' group ']'
+  plus_minus -> '+' | '-'
+  number_suffix -> number
+  ion_suffix -> '^' number plus_minus | '^' plus_minus
+  suffix -> number_suffix | number_suffix ion_suffix | ion_suffix
+  unsuffixed -> element | paren_group_round | paren_group_square
+
+  suffixed -> unsuffixed | unsuffixed suffix
+"""
+parser = nltk.ChartParser(nltk.parse_cfg(grammar))
+
+
+def _clean_parse_tree(tree):
+    ''' The parse tree contains a lot of redundant
+    nodes. E.g. paren_groups have groups as children, etc. This will
+    clean up the tree.
+    '''
+    def unparse_number(n):
+        ''' Go from a number parse tree to a number '''
+        if len(n) == 1:
+            rv = n[0][0]
+        else:
+            rv = n[0][0] + unparse_number(n[1])
+        return rv
+
+    def null_tag(n):
+        ''' Remove a tag '''
+        return n[0]
+
+    def ion_suffix(n):
+        '''1. "if" part handles special case
+           2. "else" part is general behaviour '''
+
+        if n[1:][0].node == 'number' and n[1:][0][0][0] == '1':
+            # if suffix is explicitly 1, like ^1-
+            # strip 1, leave only sign: ^-
+            return nltk.tree.Tree(n.node, n[2:])
+        else:
+            return nltk.tree.Tree(n.node, n[1:])
+
+    dispatch = {'number': lambda x: nltk.tree.Tree("number", [unparse_number(x)]),
+                'unphased': null_tag,
+                'unsuffixed': null_tag,
+                'number_suffix': lambda x: nltk.tree.Tree('number_suffix', [unparse_number(x[0])]),
+                'suffixed': lambda x: len(x) > 1 and x or x[0],
+                'ion_suffix': ion_suffix,
+                'paren_group_square': lambda x: nltk.tree.Tree(x.node, x[1]),
+                'paren_group_round': lambda x: nltk.tree.Tree(x.node, x[1])}
+
+    if type(tree) == str:
+        return tree
+
+    old_node = None
+    ## This loop means that if a node is processed, and returns a child,
+    ## the child will be processed.
+    while tree.node in dispatch and tree.node != old_node:
+        old_node = tree.node
+        tree = dispatch[tree.node](tree)
+
+    children = []
+    for child in tree:
+        child = _clean_parse_tree(child)
+        children.append(child)
+
+    tree = nltk.tree.Tree(tree.node, children)
+
+    return tree
+
+
+def _merge_children(tree, tags):
+    ''' nltk, by documentation, cannot do arbitrary length
+    groups. Instead of:
+    (group 1 2 3 4)
+    It has to handle this recursively:
+    (group 1 (group 2 (group 3 (group 4))))
+    We do the cleanup of converting from the latter to the former.
+    '''
+    if tree is None:
+        # There was a problem--shouldn't have empty trees (NOTE: see this with input e.g. 'H2O(', or 'Xe+').
+        # Haven't grokked the code to tell if this is indeed the right thing to do.
+        raise ParseException("Shouldn't have empty trees")
+
+    if type(tree) == str:
+        return tree
+
+    merged_children = []
+    done = False
+    #print '00000', tree
+    ## Merge current tag
+    while not done:
+        done = True
+        for child in tree:
+            if type(child) == nltk.tree.Tree and child.node == tree.node and tree.node in tags:
+                merged_children = merged_children + list(child)
+                done = False
+            else:
+                merged_children = merged_children + [child]
+        tree = nltk.tree.Tree(tree.node, merged_children)
+        merged_children = []
+    #print '======',tree
+
+    # And recurse
+    children = []
+    for child in tree:
+        children.append(_merge_children(child, tags))
+
+    #return tree
+    return nltk.tree.Tree(tree.node, children)
+
+
+def _render_to_html(tree):
+    ''' Renders a cleaned tree to HTML '''
+
+    def molecule_count(tree, children):
+        # If an integer, return that integer
+        if len(tree) == 1:
+            return tree[0][0]
+        # If a fraction, return the fraction
+        if len(tree) == 3:
+            return " <sup>{num}</sup>&frasl;<sub>{den}</sub> ".format(num=tree[0][0], den=tree[2][0])
+        return "Error"
+
+    def subscript(tree, children):
+        return "<sub>{sub}</sub>".format(sub=children)
+
+    def superscript(tree, children):
+        return "<sup>{sup}</sup>".format(sup=children)
+
+    def round_brackets(tree, children):
+        return "({insider})".format(insider=children)
+
+    def square_brackets(tree, children):
+        return "[{insider}]".format(insider=children)
+
+    dispatch = {'count': molecule_count,
+                'number_suffix': subscript,
+                'ion_suffix': superscript,
+                'paren_group_round': round_brackets,
+                'paren_group_square': square_brackets}
+
+    if type(tree) == str:
+        return tree
+    else:
+        children = "".join(map(_render_to_html, tree))
+        if tree.node in dispatch:
+            return dispatch[tree.node](tree, children)
+        else:
+            return children.replace(' ', '')
+
+
+
+def render_to_html(eq):
+    '''
+    Render a chemical equation string to html.
+
+    Renders each molecule separately, and returns invalid input wrapped in a <span>.
+    '''
+    def err(s):
+        "Render as an error span"
+        return '<span class="inline-error inline">{0}</span>'.format(s)
+
+    def render_arrow(arrow):
+        """Turn text arrows into pretty ones"""
+        if arrow == '->':
+            return u'\u2192'
+        if arrow == '<->':
+            return u'\u2194'
+
+        # this won't be reached unless we add more arrow types, but keep it to avoid explosions when
+        # that happens.
+        return arrow
+
+    def render_expression(ex):
+        """
+        Render a chemical expression--no arrows.
+        """
+        try:
+            return _render_to_html(_get_final_tree(ex))
+        except ParseException:
+            return err(ex)
+
+    def spanify(s):
+        return u'<span class="math">{0}</span>'.format(s)
+
+    left, arrow, right = split_on_arrow(eq)
+    if arrow == '':
+        # only one side
+        return spanify(render_expression(left))
+
+
+    return spanify(render_expression(left) + render_arrow(arrow) + render_expression(right))
+
+
+def _get_final_tree(s):
+    '''
+    Return final tree after merge and clean.
+
+    Raises pyparsing.ParseException if s is invalid.
+    '''
+    tokenized = tokenizer.parseString(s)
+    parsed = parser.parse(tokenized)
+    merged = _merge_children(parsed, {'S','group'})
+    final = _clean_parse_tree(merged)
+    return final
+
+
+def _check_equality(tuple1, tuple2):
+    ''' return True if tuples of multimolecules are equal '''
+    list1 = list(tuple1)
+    list2 = list(tuple2)
+
+    # Hypo: trees where are levels count+molecule vs just molecule
+    # cannot be sorted properly (tested on test_complex_additivity)
+    # But without factors and phases sorting seems to work.
+
+    # Also for lists of multimolecules without factors and phases
+    # sorting seems to work fine.
+    list1.sort()
+    list2.sort()
+    return list1 == list2
+
+
+def compare_chemical_expression(s1, s2, ignore_state=False):
+    ''' It does comparison between two expressions.
+        It uses divide_chemical_expression and check if division is 1
+    '''
+    return divide_chemical_expression(s1, s2, ignore_state) == 1
+
+
+def divide_chemical_expression(s1, s2, ignore_state=False):
+    '''Compare two chemical expressions for equivalence up to a multiplicative factor:
+
+    - If they are not the same chemicals, returns False.
+    - If they are the same, "divide" s1 by s2 to returns a factor x such that s1 / s2 == x as a Fraction object.
+    - if ignore_state is True, ignores phases when doing the comparison.
+
+    Examples:
+    divide_chemical_expression("H2O", "3H2O") -> Fraction(1,3)
+    divide_chemical_expression("3H2O", "H2O") -> 3  # actually Fraction(3, 1), but compares == to 3.
+    divide_chemical_expression("2H2O(s) + 2CO2", "H2O(s)+CO2") -> 2
+    divide_chemical_expression("H2O(s) + CO2", "3H2O(s)+2CO2") -> False
+
+    Implementation sketch:
+        - extract factors and phases to standalone lists,
+        - compare expressions without factors and phases,
+        - divide lists of factors for each other and check
+             for equality of every element in list,
+        - return result of factor division
+
+    '''
+
+    # parsed final trees
+    treedic = {}
+    treedic['1'] = _get_final_tree(s1)
+    treedic['2'] = _get_final_tree(s2)
+
+    # strip phases and factors
+    # collect factors in list
+    for i in ('1', '2'):
+        treedic[i + ' cleaned_mm_list'] = []
+        treedic[i + ' factors'] = []
+        treedic[i + ' phases'] = []
+        for el in treedic[i].subtrees(filter=lambda t: t.node == 'multimolecule'):
+            count_subtree = [t for t in el.subtrees() if t.node == 'count']
+            group_subtree = [t for t in el.subtrees() if t.node == 'group']
+            phase_subtree = [t for t in el.subtrees() if t.node == 'phase']
+            if count_subtree:
+                if len(count_subtree[0]) > 1:
+                    treedic[i + ' factors'].append(
+                        int(count_subtree[0][0][0]) /
+                        int(count_subtree[0][2][0]))
+                else:
+                    treedic[i + ' factors'].append(int(count_subtree[0][0][0]))
+            else:
+                treedic[i + ' factors'].append(1.0)
+            if phase_subtree:
+                treedic[i + ' phases'].append(phase_subtree[0][0])
+            else:
+                treedic[i + ' phases'].append(' ')
+            treedic[i + ' cleaned_mm_list'].append(
+                Tree('multimolecule', [Tree('molecule', group_subtree)]))
+
+    # order of factors and phases must mirror the order of multimolecules,
+    # use 'decorate, sort, undecorate' pattern
+    treedic['1 cleaned_mm_list'], treedic['1 factors'], treedic['1 phases'] = zip(
+        *sorted(zip(treedic['1 cleaned_mm_list'], treedic['1 factors'], treedic['1 phases'])))
+
+    treedic['2 cleaned_mm_list'], treedic['2 factors'], treedic['2 phases'] = zip(
+        *sorted(zip(treedic['2 cleaned_mm_list'], treedic['2 factors'], treedic['2 phases'])))
+
+    # check if expressions are correct without factors
+    if not _check_equality(treedic['1 cleaned_mm_list'], treedic['2 cleaned_mm_list']):
+        return False
+
+    # phases are ruled by ingore_state flag
+    if not ignore_state:  # phases matters
+        if treedic['1 phases'] != treedic['2 phases']:
+            return False
+
+    if any(map(lambda x, y: x / y - treedic['1 factors'][0] / treedic['2 factors'][0],
+                                         treedic['1 factors'], treedic['2 factors'])):
+        # factors are not proportional
+        return False
+    else:
+        # return ratio
+        return Fraction(treedic['1 factors'][0] / treedic['2 factors'][0])
+
+
+def split_on_arrow(eq):
+    """
+    Split a string on an arrow.  Returns left, arrow, right.  If there is no arrow, returns the
+    entire eq in left, and '' in arrow and right.
+
+    Return left, arrow, right.
+    """
+    # order matters -- need to try <-> first
+    for arrow in ARROWS:
+        left, a, right = eq.partition(arrow)
+        if a != '':
+            return left, a, right
+
+    return eq, '', ''
+
+
+def chemical_equations_equal(eq1, eq2, exact=False):
+    """
+    Check whether two chemical equations are the same.  (equations have arrows)
+
+    If exact is False, then they are considered equal if they differ by a
+    constant factor.
+
+    arrows matter: -> and <-> are different.
+
+    e.g.
+    chemical_equations_equal('H2 + O2 -> H2O2', 'O2 + H2 -> H2O2') -> True
+    chemical_equations_equal('H2 + O2 -> H2O2', 'O2 + 2H2 -> H2O2') -> False
+
+    chemical_equations_equal('H2 + O2 -> H2O2', 'O2 + H2 <-> H2O2') -> False
+
+    chemical_equations_equal('H2 + O2 -> H2O2', '2 H2 + 2 O2 -> 2 H2O2') -> True
+    chemical_equations_equal('H2 + O2 -> H2O2', '2 H2 + 2 O2 -> 2 H2O2', exact=True) -> False
+
+
+    If there's a syntax error, we return False.
+    """
+
+    left1, arrow1, right1 = split_on_arrow(eq1)
+    left2, arrow2, right2 = split_on_arrow(eq2)
+
+    if arrow1 == '' or arrow2 == '':
+        return False
+
+    # TODO: may want to be able to give student helpful feedback about why things didn't work.
+    if arrow1 != arrow2:
+        # arrows don't match
+        return False
+
+    try:
+        factor_left = divide_chemical_expression(left1, left2)
+        if not factor_left:
+            # left sides don't match
+            return False
+
+        factor_right = divide_chemical_expression(right1, right2)
+        if not factor_right:
+            # right sides don't match
+            return False
+
+        if factor_left != factor_right:
+            # factors don't match (molecule counts to add up)
+            return False
+
+        if exact and factor_left != 1:
+            # want an exact match.
+            return False
+
+        return True
+    except ParseException:
+        # Don't want external users to have to deal with parsing exceptions.  Just return False.
+        return False

common/lib/capa/capa/chem/tests.py

+import codecs
+from fractions import Fraction
+from pyparsing import ParseException
+import unittest
+
+from chemcalc import (compare_chemical_expression, divide_chemical_expression,
+                      render_to_html, chemical_equations_equal)
+
+local_debug = None
+
+def log(s, output_type=None):
+    if local_debug:
+        print s
+        if output_type == 'html':
+            f.write(s + '\n<br>\n')
+
+
+class Test_Compare_Equations(unittest.TestCase):
+    def test_simple_equation(self):
+        self.assertTrue(chemical_equations_equal('H2 + O2 -> H2O2',
+                                                 'O2 + H2 -> H2O2'))
+        # left sides don't match
+        self.assertFalse(chemical_equations_equal('H2 + O2 -> H2O2',
+                                                  'O2 + 2H2 -> H2O2'))
+        # right sides don't match
+        self.assertFalse(chemical_equations_equal('H2 + O2 -> H2O2',
+                                                  'O2 + H2 -> H2O'))
+
+        # factors don't match
+        self.assertFalse(chemical_equations_equal('H2 + O2 -> H2O2',
+                                                  'O2 + H2 -> 2H2O2'))
+
+    def test_different_factor(self):
+        self.assertTrue(chemical_equations_equal('H2 + O2 -> H2O2',
+                                                 '2O2 + 2H2 -> 2H2O2'))
+
+        self.assertFalse(chemical_equations_equal('2H2 + O2 -> H2O2',
+                                                 '2O2 + 2H2 -> 2H2O2'))
+
+
+    def test_different_arrows(self):
+        self.assertTrue(chemical_equations_equal('H2 + O2 -> H2O2',
+                                                 '2O2 + 2H2 -> 2H2O2'))
+
+        self.assertFalse(chemical_equations_equal('H2 + O2 -> H2O2',
+                                                  'O2 + H2 <-> 2H2O2'))
+
+    def test_exact_match(self):
+        self.assertTrue(chemical_equations_equal('H2 + O2 -> H2O2',
+                                                 '2O2 + 2H2 -> 2H2O2'))
+
+        self.assertFalse(chemical_equations_equal('H2 + O2 -> H2O2',
+                                                 '2O2 + 2H2 -> 2H2O2', exact=True))
+
+        # order still doesn't matter
+        self.assertTrue(chemical_equations_equal('H2 + O2 -> H2O2',
+                                                 'O2 + H2 -> H2O2', exact=True))
+
+
+    def test_syntax_errors(self):
+        self.assertFalse(chemical_equations_equal('H2 + O2 a-> H2O2',
+                                                  '2O2 + 2H2 -> 2H2O2'))
+
+        self.assertFalse(chemical_equations_equal('H2O( -> H2O2',
+                                                  'H2O -> H2O2'))
+
+
+        self.assertFalse(chemical_equations_equal('H2 + O2 ==> H2O2',   # strange arrow
+                                                  '2O2 + 2H2 -> 2H2O2'))
+
+
+class Test_Compare_Expressions(unittest.TestCase):
+
+    def test_compare_incorrect_order_of_atoms_in_molecule(self):
+        self.assertFalse(compare_chemical_expression("H2O + CO2", "O2C + OH2"))
+
+    def test_compare_same_order_no_phases_no_factors_no_ions(self):
+        self.assertTrue(compare_chemical_expression("H2O + CO2", "CO2+H2O"))
+
+    def test_compare_different_order_no_phases_no_factors_no_ions(self):
+        self.assertTrue(compare_chemical_expression("H2O + CO2", "CO2 + H2O"))
+
+    def test_compare_different_order_three_multimolecule(self):
+        self.assertTrue(compare_chemical_expression("H2O + Fe(OH)3 +  CO2", "CO2 + H2O + Fe(OH)3"))
+
+    def test_compare_same_factors(self):
+        self.assertTrue(compare_chemical_expression("3H2O +  2CO2", "2CO2 + 3H2O "))
+
+    def test_compare_different_factors(self):
+        self.assertFalse(compare_chemical_expression("2H2O +  3CO2", "2CO2 + 3H2O "))
+
+    def test_compare_correct_ions(self):
+        self.assertTrue(compare_chemical_expression("H^+ + OH^-", " OH^- + H^+ "))
+
+    def test_compare_wrong_ions(self):
+        self.assertFalse(compare_chemical_expression("H^+ + OH^-", " OH^- + H^- "))
+
+    def test_compare_parent_groups_ions(self):
+        self.assertTrue(compare_chemical_expression("Fe(OH)^2- + (OH)^-", " (OH)^- + Fe(OH)^2- "))
+
+    def test_compare_correct_factors_ions_and_one(self):
+        self.assertTrue(compare_chemical_expression("3H^+ + 2OH^-", " 2OH^- + 3H^+ "))
+
+    def test_compare_wrong_factors_ions(self):
+        self.assertFalse(compare_chemical_expression("2H^+ + 3OH^-", " 2OH^- + 3H^+ "))
+
+    def test_compare_float_factors(self):
+        self.assertTrue(compare_chemical_expression("7/2H^+ + 3/5OH^-", " 3/5OH^- + 7/2H^+ "))
+
+    # Phases tests
+    def test_compare_phases_ignored(self):
+        self.assertTrue(compare_chemical_expression(
+            "H2O(s) + CO2", "H2O+CO2", ignore_state=True))
+
+    def test_compare_phases_not_ignored_explicitly(self):
+        self.assertFalse(compare_chemical_expression(
+            "H2O(s) + CO2", "H2O+CO2", ignore_state=False))
+
+    def test_compare_phases_not_ignored(self):  # same as previous
+        self.assertFalse(compare_chemical_expression(
+            "H2O(s) + CO2", "H2O+CO2"))
+
+    def test_compare_phases_not_ignored_explicitly(self):
+        self.assertTrue(compare_chemical_expression(
+            "H2O(s) + CO2", "H2O(s)+CO2", ignore_state=False))
+
+    # all in one cases
+    def test_complex_additivity(self):
+        self.assertTrue(compare_chemical_expression(
+            "5(H1H212)^70010- + 2H20 + 7/2HCl + H2O",
+            "7/2HCl + 2H20 + H2O + 5(H1H212)^70010-"))
+
+    def test_complex_additivity_wrong(self):
+        self.assertFalse(compare_chemical_expression(
+            "5(H1H212)^70010- + 2H20 + 7/2HCl + H2O",
+            "2H20 + 7/2HCl + H2O + 5(H1H212)^70011-"))
+
+    def test_complex_all_grammar(self):
+        self.assertTrue(compare_chemical_expression(
+            "5[Ni(NH3)4]^2+ + 5/2SO4^2-",
+            "5/2SO4^2- + 5[Ni(NH3)4]^2+"))
+
+    # special cases
+
+    def test_compare_one_superscript_explicitly_set(self):
+        self.assertTrue(compare_chemical_expression("H^+ + OH^1-", " OH^- + H^+ "))
+
+    def test_compare_equal_factors_differently_set(self):
+        self.assertTrue(compare_chemical_expression("6/2H^+ + OH^-", " OH^- + 3H^+ "))
+
+    def test_compare_one_subscript_explicitly_set(self):
+        self.assertFalse(compare_chemical_expression("H2 + CO2", "H2 + C102"))
+
+
+class Test_Divide_Expressions(unittest.TestCase):
+    ''' as compare_ use divide_,
+    tests here must consider different
+    division (not equality) cases '''
+
+    def test_divide_by_zero(self):
+        self.assertFalse(divide_chemical_expression(
+            "0H2O", "H2O"))
+
+    def test_divide_wrong_factors(self):
+        self.assertFalse(divide_chemical_expression(
+            "5(H1H212)^70010- + 10H2O", "5H2O + 10(H1H212)^70010-"))
+
+    def test_divide_right(self):
+        self.assertEqual(divide_chemical_expression(
+            "5(H1H212)^70010- + 10H2O", "10H2O + 5(H1H212)^70010-"), 1)
+
+    def test_divide_wrong_reagents(self):
+        self.assertFalse(divide_chemical_expression(
+            "H2O + CO2", "CO2"))
+
+    def test_divide_right_simple(self):
+        self.assertEqual(divide_chemical_expression(
+            "H2O + CO2", "H2O+CO2"), 1)
+
+    def test_divide_right_phases(self):
+        self.assertEqual(divide_chemical_expression(
+            "H2O(s) + CO2", "2H2O(s)+2CO2"), Fraction(1, 2))
+
+    def test_divide_right_phases_other_order(self):
+        self.assertEqual(divide_chemical_expression(
+            "2H2O(s) + 2CO2", "H2O(s)+CO2"), 2)
+
+    def test_divide_wrong_phases(self):
+        self.assertFalse(divide_chemical_expression(
+            "H2O(s) + CO2", "2H2O+2CO2(s)"))
+
+    def test_divide_wrong_phases_but_phases_ignored(self):
+        self.assertEqual(divide_chemical_expression(
+            "H2O(s) + CO2", "2H2O+2CO2(s)", ignore_state=True), Fraction(1, 2))
+
+    def test_divide_order(self):
+        self.assertEqual(divide_chemical_expression(
+            "2CO2 + H2O", "2H2O+4CO2"), Fraction(1, 2))
+
+    def test_divide_fract_to_int(self):
+        self.assertEqual(divide_chemical_expression(
+            "3/2CO2 + H2O", "2H2O+3CO2"), Fraction(1, 2))
+
+    def test_divide_fract_to_frac(self):
+        self.assertEqual(divide_chemical_expression(
+            "3/4CO2 + H2O", "2H2O+9/6CO2"), Fraction(1, 2))
+
+    def test_divide_fract_to_frac_wrog(self):
+        self.assertFalse(divide_chemical_expression(
+            "6/2CO2 + H2O", "2H2O+9/6CO2"), 2)
+
+
+class Test_Render_Equations(unittest.TestCase):
+
+    def test_render1(self):
+        s = "H2O + CO2"
+        out = render_to_html(s)
+        correct = u'<span class="math">H<sub>2</sub>O+CO<sub>2</sub></span>'
+        log(out + ' ------- ' + correct, 'html')
+        self.assertEqual(out, correct)
+
+    def test_render_uncorrect_reaction(self):
+        s = "O2C + OH2"
+        out = render_to_html(s)
+        correct = u'<span class="math">O<sub>2</sub>C+OH<sub>2</sub></span>'
+        log(out + ' ------- ' + correct, 'html')
+        self.assertEqual(out, correct)
+
+    def test_render2(self):
+        s = "CO2 + H2O + Fe(OH)3"
+        out = render_to_html(s)
+        correct = u'<span class="math">CO<sub>2</sub>+H<sub>2</sub>O+Fe(OH)<sub>3</sub></span>'
+        log(out + ' ------- ' + correct, 'html')
+        self.assertEqual(out, correct)
+
+    def test_render3(self):
+        s = "3H2O + 2CO2"
+        out = render_to_html(s)
+        correct = u'<span class="math">3H<sub>2</sub>O+2CO<sub>2</sub></span>'
+        log(out + ' ------- ' + correct, 'html')
+        self.assertEqual(out, correct)
+
+    def test_render4(self):
+        s = "H^+ + OH^-"
+        out = render_to_html(s)
+        correct = u'<span class="math">H<sup>+</sup>+OH<sup>-</sup></span>'
+        log(out + ' ------- ' + correct, 'html')
+        self.assertEqual(out, correct)
+
+    def test_render5(self):
+        s = "Fe(OH)^2- + (OH)^-"
+        out = render_to_html(s)
+        correct = u'<span class="math">Fe(OH)<sup>2-</sup>+(OH)<sup>-</sup></span>'
+        log(out + ' ------- ' + correct, 'html')
+        self.assertEqual(out, correct)
+
+    def test_render6(self):
+        s = "7/2H^+ + 3/5OH^-"
+        out = render_to_html(s)
+        correct = u'<span class="math"><sup>7</sup>&frasl;<sub>2</sub>H<sup>+</sup>+<sup>3</sup>&frasl;<sub>5</sub>OH<sup>-</sup></span>'
+        log(out + ' ------- ' + correct, 'html')
+        self.assertEqual(out, correct)
+
+    def test_render7(self):
+        s = "5(H1H212)^70010- + 2H2O + 7/2HCl + H2O"
+        out = render_to_html(s)
+        correct = u'<span class="math">5(H<sub>1</sub>H<sub>212</sub>)<sup>70010-</sup>+2H<sub>2</sub>O+<sup>7</sup>&frasl;<sub>2</sub>HCl+H<sub>2</sub>O</span>'
+        log(out + ' ------- ' + correct, 'html')
+        self.assertEqual(out, correct)
+
+    def test_render8(self):
+        s = "H2O(s) + CO2"
+        out = render_to_html(s)
+        correct = u'<span class="math">H<sub>2</sub>O(s)+CO<sub>2</sub></span>'
+        log(out + ' ------- ' + correct, 'html')
+        self.assertEqual(out, correct)
+
+    def test_render9(self):
+        s = "5[Ni(NH3)4]^2+ + 5/2SO4^2-"
+        #import ipdb; ipdb.set_trace()
+        out = render_to_html(s)
+        correct = u'<span class="math">5[Ni(NH<sub>3</sub>)<sub>4</sub>]<sup>2+</sup>+<sup>5</sup>&frasl;<sub>2</sub>SO<sub>4</sub><sup>2-</sup></span>'
+        log(out + ' ------- ' + correct, 'html')
+        self.assertEqual(out, correct)
+
+    def test_render_error(self):
+        s = "5.2H20"
+        out = render_to_html(s)
+        correct = u'<span class="math"><span class="inline-error inline">5.2H20</span></span>'
+        log(out + ' ------- ' + correct, 'html')
+        self.assertEqual(out, correct)
+
+    def test_render_simple_brackets(self):
+        s = "(Ar)"
+        out = render_to_html(s)
+        correct = u'<span class="math">(Ar)</span>'
+        log(out + ' ------- ' + correct, 'html')
+        self.assertEqual(out, correct)
+
+    def test_render_eq1(self):
+        s = "H^+ + OH^- -> H2O"
+        out = render_to_html(s)
+        correct = u'<span class="math">H<sup>+</sup>+OH<sup>-</sup>\u2192H<sub>2</sub>O</span>'
+        log(out + ' ------- ' + correct, 'html')
+        self.assertEqual(out, correct)
+
+    def test_render_eq2(self):
+        s = "H^+ + OH^- <-> H2O"
+        out = render_to_html(s)
+        correct = u'<span class="math">H<sup>+</sup>+OH<sup>-</sup>\u2194H<sub>2</sub>O</span>'
+        log(out + ' ------- ' + correct, 'html')
+        self.assertEqual(out, correct)
+
+        
+    def test_render_eq3(self):
+        s = "H^+ + OH^- <= H2O"   # unsupported arrow
+        out = render_to_html(s)
+        correct = u'<span class="math"><span class="inline-error inline">H^+ + OH^- <= H2O</span></span>'
+        log(out + ' ------- ' + correct, 'html')
+        self.assertEqual(out, correct)
+
+
+
+def suite():
+
+    testcases = [Test_Compare_Expressions, Test_Divide_Expressions, Test_Render_Equations]
+    suites = []
+    for testcase in testcases:
+        suites.append(unittest.TestLoader().loadTestsFromTestCase(testcase))
+    return unittest.TestSuite(suites)
+
+if __name__ == "__main__":
+    local_debug = True
+    with codecs.open('render.html', 'w', encoding='utf-8') as f:
+        unittest.TextTestRunner(verbosity=2).run(suite())
+    # open render.html to look at rendered equations

common/lib/capa/capa/inputtypes.py

@@ -37,102 +37,174 @@ import xml.sax.saxutils as saxutils
 
 log = logging.getLogger('mitx.' + __name__)
 
+#########################################################################
 
-def get_input_xml_tags():
-    ''' Eventually, this will be for all registered input types '''
-    return SimpleInput.get_xml_tags()
+_TAGS_TO_CLASSES = {}
 
+def register_input_class(cls):
+    """
+    Register cls as a supported input type.  It is expected to have the same constructor as
+    InputTypeBase, and to define cls.tags as a list of tags that it implements.
 
-class SimpleInput():#  XModule
-    '''
-    Type for simple inputs -- plain HTML with a form element
-    '''
+    If an already-registered input type has claimed one of those tags, will raise ValueError.
+
+    If there are no tags in cls.tags, will also raise ValueError.
+    """
+
+    # Do all checks and complain before changing any state.
+    if len(cls.tags) == 0:
+        raise ValueError("No supported tags for class {0}".format(cls.__name__))
+
+    for t in cls.tags:
+        if t in _TAGS_TO_CLASSES:
+            other_cls = _TAGS_TO_CLASSES[t]
+            if cls == other_cls:
+                # registering the same class multiple times seems silly, but ok
+                continue
+            raise ValueError("Tag {0} already registered by class {1}. Can't register for class {2}"
+                             .format(t, other_cls.__name__, cls.__name__))
 
-    # Maps tags to functions
-    xml_tags = {}
+    # Ok, should be good to change state now.
+    for t in cls.tags:
+        _TAGS_TO_CLASSES[t] = cls
+
+def registered_input_tags():
+    """
+    Get a list of all the xml tags that map to known input types.
+    """
+    return _TAGS_TO_CLASSES.keys()
+
+
+def get_class_for_tag(tag):
+    """
+    For any tag in registered_input_tags(), return the corresponding class.  Otherwise, will raise KeyError.
+    """
+    return _TAGS_TO_CLASSES[tag]
 
-    def __init__(self, system, xml, item_id=None, track_url=None, state=None, use='capa_input'):
-        '''
-        Instantiate a SimpleInput class.  Arguments:
 
-        - system    : ModuleSystem instance which provides OS, rendering, and user context
+class InputTypeBase(object):
+    """
+    Abstract base class for input types.
+    """
+
+    template = None
+
+    def __init__(self, system, xml, state):
+        """
+        Instantiate an InputType class.  Arguments:
+
+        - system    : ModuleSystem instance which provides OS, rendering, and user context.  Specifically, must
+                      have a render_template function.
         - xml       : Element tree of this Input element
-        - item_id   : id for this input element (assigned by capa_problem.LoncapProblem) - string
-        - track_url : URL used for tracking - string
         - state     : a dictionary with optional keys:
-                      * Value
-                      * ID
-                      * Status (answered, unanswered, unsubmitted)
-                      * Feedback (dictionary containing keys for hints, errors, or other
-                        feedback from previous attempt)
-        - use        :
-        '''
+                      * 'value'
+                      * 'id'
+                      * 'status' (answered, unanswered, unsubmitted)
+                      * 'feedback' (dictionary containing keys for hints, errors, or other
+                         feedback from previous attempt.  Specifically 'message', 'hint', 'hintmode'.  If 'hintmode'
+                         is 'always', the hint is always displayed.)
+        """
 
         self.xml = xml
         self.tag = xml.tag
         self.system = system
-        if not state:
-            state = {}
-
-        ## NOTE: ID should only come from one place.
-        ## If it comes from multiple, we use state first, XML second, and parameter
-        ## third. Since we don't make this guarantee, we can swap this around in
-        ## the future if there's a more logical order.
-        if item_id:
-            self.id = item_id
 
-        if xml.get('id'):
-            self.id = xml.get('id')
+        ## NOTE: ID should only come from one place.  If it comes from multiple,
+        ## we use state first, XML second (in case the xml changed, but we have
+        ## existing state with an old id). Since we don't make this guarantee,
+        ## we can swap this around in the future if there's a more logical
+        ## order.
 
-        if 'id' in state:
-            self.id = state['id']
+        self.id = state.get('id', xml.get('id'))
+        if self.id is None:
+            raise ValueError("input id state is None. xml is {0}".format(etree.tostring(xml)))
 
         self.value = state.get('value', '')
 
-        self.msg = ''
-        feedback = state.get('feedback')
-        if feedback is not None:
-            self.msg = feedback.get('message', '')
-            self.hint = feedback.get('hint', '')
-            self.hintmode = feedback.get('hintmode', None)
+        feedback = state.get('feedback', {})
+        self.msg = feedback.get('message', '')
+        self.hint = feedback.get('hint', '')
+        self.hintmode = feedback.get('hintmode', None)
 
-            # put hint above msg if to be displayed
-            if self.hintmode == 'always':
-                # TODO: is the '.' in <br/.> below a bug?
-                self.msg = self.hint + ('<br/.>' if self.msg else '') + self.msg
+        # put hint above msg if it should be displayed
+        if self.hintmode == 'always':
+            self.msg = self.hint + ('<br/>' if self.msg else '') + self.msg
 
-        self.status = 'unanswered'
-        if 'status' in state:
-            self.status = state['status']
+        self.status = state.get('status', 'unanswered')
 
-    @classmethod
-    def get_xml_tags(c):
-        return c.xml_tags.keys()
+    def _get_render_context(self):
+        """
+        Abstract method.  Subclasses should implement to return the dictionary
+        of keys needed to render their template.
 
-    @classmethod
-    def get_uses(c):
-        return ['capa_input', 'capa_transform']
+        (Separate from get_html to faciliate testing of logic separately from the rendering)
+        """
+        raise NotImplementedError
 
     def get_html(self):
-        return self.xml_tags[self.tag](self.xml, self.value,
-                                       self.status, self.system.render_template, self.msg)
+        """
+        Return the html for this input, as an etree element.
+        """
+        if self.template is None:
+            raise NotImplementedError("no rendering template specified for class {0}".format(self.__class__))
 
+        html = self.system.render_template(self.template, self._get_render_context())
+        return etree.XML(html)
 
-def register_render_function(fn, names=None, cls=SimpleInput):
-    if names is None:
-        SimpleInput.xml_tags[fn.__name__] = fn
-    else:
-        raise NotImplementedError
 
-    def wrapped():
-        return fn
-    return wrapped
+## TODO: Remove once refactor is complete
+def make_class_for_render_function(fn):
+    """
+    Take an old-style render function, return a new-style input class.
+    """
+
+    class Impl(InputTypeBase):
+        """
+        Inherit all the constructor logic from InputTypeBase...
+        """
+        tags = [fn.__name__]
+        def get_html(self):
+            """...delegate to the render function to do the work"""
+            return fn(self.xml, self.value, self.status, self.system.render_template, self.msg)
+
+    # don't want all the classes to be called Impl (confuses register_input_class).
+    Impl.__name__ = fn.__name__.capitalize()
+    return Impl
+
+
+def _reg(fn):
+    """
+    Register an old-style inputtype render function as a new-style subclass of InputTypeBase.
+    This will go away once converting all input types to the new format is complete. (TODO)
+    """
+    register_input_class(make_class_for_render_function(fn))
+
 
 #-----------------------------------------------------------------------------
 
 
-@register_render_function
+class OptionInput(InputTypeBase):
+    """
+    Input type for selecting and Select option input type.
+
+    Example:
+
+    <optioninput options="('Up','Down')" correct="Up"/><text>The location of the sky</text>
+    """
+
+    template = "optioninput.html"
+    tags = ['optioninput']
+
+    def _get_render_context(self):
+        return _optioninput(self.xml, self.value, self.status, self.system.render_template, self.msg)
+
+
 def optioninput(element, value, status, render_template, msg=''):
+    context = _optioninput(element, value, status, render_template, msg)
+    html = render_template("optioninput.html", context)
+    return etree.XML(html)
+
+def _optioninput(element, value, status, render_template, msg=''):
     """
     Select option input type.
 
@@ -146,12 +218,14 @@ def optioninput(element, value, status, render_template, msg=''):
         raise Exception(
             "[courseware.capa.inputtypes.optioninput] Missing options specification in "
             + etree.tostring(element))
+
+    # parse the set of possible options
     oset = shlex.shlex(options[1:-1])
     oset.quotes = "'"
     oset.whitespace = ","
     oset = [x[1:-1] for x  in list(oset)]
 
-    # make ordered list with (key,value) same
+    # make ordered list with (key, value) same
     osetdict = [(oset[x], oset[x]) for x in range(len(oset))]
     # TODO: allow ordering to be randomized
 
@@ -162,16 +236,16 @@ def optioninput(element, value, status, render_template, msg=''):
              'options': osetdict,
              'inline': element.get('inline',''),
              }
+    return context
 
-    html = render_template("optioninput.html", context)
-    return etree.XML(html)
+register_input_class(OptionInput)
 
 #-----------------------------------------------------------------------------
 
 
 # TODO: consolidate choicegroup, radiogroup, checkboxgroup after discussion of
 # desired semantics.
-@register_render_function
+# @register_render_function
 def choicegroup(element, value, status, render_template, msg=''):
     '''
     Radio button inputs: multiple choice or true/false
@@ -208,6 +282,7 @@ def choicegroup(element, value, status, render_template, msg=''):
     html = render_template("choicegroup.html", context)
     return etree.XML(html)
 
+_reg(choicegroup)
 
 #-----------------------------------------------------------------------------
 def extract_choices(element):
@@ -235,7 +310,6 @@ def extract_choices(element):
 
 # TODO: consolidate choicegroup, radiogroup, checkboxgroup after discussion of
 # desired semantics.
-@register_render_function
 def radiogroup(element, value, status, render_template, msg=''):
     '''
     Radio button inputs: (multiple choice)
@@ -256,9 +330,10 @@ def radiogroup(element, value, status, render_template, msg=''):
     return etree.XML(html)
 
 
+_reg(radiogroup)
+
 # TODO: consolidate choicegroup, radiogroup, checkboxgroup after discussion of
 # desired semantics.
-@register_render_function
 def checkboxgroup(element, value, status, render_template, msg=''):
     '''
     Checkbox inputs: (select one or more choices)
@@ -278,7 +353,8 @@ def checkboxgroup(element, value, status, render_template, msg=''):
     html = render_template("choicegroup.html", context)
     return etree.XML(html)
 
-@register_render_function
+_reg(checkboxgroup)
+
 def javascriptinput(element, value, status, render_template, msg='null'):
     '''
     Hidden field for javascript to communicate via; also loads the required
@@ -309,16 +385,16 @@ def javascriptinput(element, value, status, render_template, msg='null'):
     html = render_template("javascriptinput.html", context)
     return etree.XML(html)
 
+_reg(javascriptinput)
+
 
-@register_render_function
 def textline(element, value, status, render_template, msg=""):
     '''
     Simple text line input, with optional size specification.
     '''
     # TODO: 'dojs' flag is temporary, for backwards compatibility with 8.02x
     if element.get('math') or element.get('dojs'):
-        return SimpleInput.xml_tags['textline_dynamath'](element, value, status,
-                                                         render_template, msg)
+        return textline_dynamath(element, value, status, render_template, msg)
     eid = element.get('id')
     if eid is None:
         msg = 'textline has no id: it probably appears outside of a known response type'
@@ -354,10 +430,11 @@ def textline(element, value, status, render_template, msg=""):
             raise
     return xhtml
 
+_reg(textline)
+
 #-----------------------------------------------------------------------------
 
 
-@register_render_function
 def textline_dynamath(element, value, status, render_template, msg=''):
     '''
     Text line input with dynamic math display (equation rendered on client in real time
@@ -399,7 +476,6 @@ def textline_dynamath(element, value, status, render_template, msg=''):
 
 
 #-----------------------------------------------------------------------------
-@register_render_function
 def filesubmission(element, value, status, render_template, msg=''):
     '''
     Upload a single file (e.g. for programming assignments)
@@ -429,10 +505,11 @@ def filesubmission(element, value, status, render_template, msg=''):
     html = render_template("filesubmission.html", context)
     return etree.XML(html)
 
+_reg(filesubmission)
+
 
 #-----------------------------------------------------------------------------
 ## TODO: Make a wrapper for <codeinput>
-@register_render_function
 def textbox(element, value, status, render_template, msg=''):
     '''
     The textbox is used for code input.  The message is the return HTML string from
@@ -491,8 +568,9 @@ def textbox(element, value, status, render_template, msg=''):
     return xhtml
 
 
+_reg(textbox)
+
 #-----------------------------------------------------------------------------
-@register_render_function
 def schematic(element, value, status, render_template, msg=''):
     eid = element.get('id')
     height = element.get('height')
@@ -515,10 +593,10 @@ def schematic(element, value, status, render_template, msg=''):
     html = render_template("schematicinput.html", context)
     return etree.XML(html)
 
+_reg(schematic)
 
 #-----------------------------------------------------------------------------
 ### TODO: Move out of inputtypes
-@register_render_function
 def math(element, value, status, render_template, msg=''):
     '''
     This is not really an input type.  It is a convention from Lon-CAPA, used for
@@ -563,16 +641,17 @@ def math(element, value, status, render_template, msg=''):
     # xhtml.tail = element.tail     # don't forget to include the tail!
     return xhtml
 
+_reg(math)
+
 #-----------------------------------------------------------------------------
 
 
-@register_render_function
 def solution(element, value, status, render_template, msg=''):
     '''
     This is not really an input type.  It is just a <span>...</span> which is given an ID,
     that is used for displaying an extended answer (a problem "solution") after "show answers"
     is pressed.  Note that the solution content is NOT sent with the HTML. It is obtained
-    by a JSON call.
+    by an ajax call.
     '''
     eid = element.get('id')
     size = element.get('size')
@@ -585,10 +664,11 @@ def solution(element, value, status, render_template, msg=''):
     html = render_template("solutionspan.html", context)
     return etree.XML(html)
 
+_reg(solution)
+
 #-----------------------------------------------------------------------------
 
 
-@register_render_function
 def imageinput(element, value, status, render_template, msg=''):
     '''
     Clickable image as an input field.  Element should specify the image source, height,
@@ -624,3 +704,80 @@ def imageinput(element, value, status, render_template, msg=''):
         }
     html = render_template("imageinput.html", context)
     return etree.XML(html)
+
+_reg(imageinput)
+
+#-----------------------------------------------------------------------------
+def crystallography(element, value, status, render_template, msg=''):
+    eid = element.get('id')
+    if eid is None:
+        msg = 'cryst has no id: it probably appears outside of a known response type'
+        msg += "\nSee problem XML source line %s" % getattr(element, 'sourceline', '<unavailable>')
+        raise Exception(msg)
+    height = element.get('height')
+    width = element.get('width')
+    display_file = element.get('display_file')
+
+    count = int(eid.split('_')[-2]) - 1  # HACK
+    size = element.get('size')
+    # if specified, then textline is hidden and id is stored in div of name given by hidden
+    hidden = element.get('hidden', '')
+    # Escape answers with quotes, so they don't crash the system!
+    escapedict = {'"': '&quot;'}
+    value = saxutils.escape(value, escapedict)
+
+    context = {'id': eid,
+               'value': value,
+               'state': status,
+               'count': count,
+               'size': size,
+               'msg': msg,
+               'hidden': hidden,
+               'inline': element.get('inline', ''),
+               'width': width,
+               'height': height,
+               'display_file': display_file,
+               }
+
+    html = render_template("crystallography.html", context)
+    try:
+        xhtml = etree.XML(html)
+    except Exception as err:
+        # TODO: needs to be self.system.DEBUG - but can't access system
+        if True:
+            log.debug('[inputtypes.textline] failed to parse XML for:\n%s' % html)
+            raise
+    return xhtml
+
+_reg(crystallography)
+
+
+#--------------------------------------------------------------------------------
+
+
+class ChemicalEquationInput(InputTypeBase):
+    """
+    An input type for entering chemical equations.  Supports live preview.
+
+    Example:
+
+    <chemicalequationinput size="50"/>
+
+    options: size -- width of the textbox.
+    """
+
+    template = "chemicalequationinput.html"
+    tags = ['chemicalequationinput']
+
+    def _get_render_context(self):
+        size = self.xml.get('size', '20')
+        context = {
+            'id': self.id,
+            'value': self.value,
+            'status': self.status,
+            'size': size,
+            'previewer': '/static/js/capa/chemical_equation_preview.js',
+            }
+        return context
+
+register_input_class(ChemicalEquationInput)

common/lib/capa/capa/responsetypes.py

@@ -746,7 +746,7 @@ class NumericalResponse(LoncapaResponse):
                                            id=xml.get('id'))[0]
             self.tolerance = contextualize_text(self.tolerance_xml, context)
         except Exception:
-            self.tolerance = 0
+            self.tolerance = '0'
         try:
             self.answer_id = xml.xpath('//*[@id=$id]//textline/@id',
                                        id=xml.get('id'))[0]
@@ -756,15 +756,26 @@ class NumericalResponse(LoncapaResponse):
     def get_score(self, student_answers):
         '''Grade a numeric response '''
         student_answer = student_answers[self.answer_id]
+
+        try:
+            correct_ans = complex(self.correct_answer)
+        except ValueError:
+            log.debug("Content error--answer '{0}' is not a valid complex number".format(self.correct_answer))
+            raise StudentInputError("There was a problem with the staff answer to this problem")
+
         try:
             correct = compare_with_tolerance(evaluator(dict(), dict(), student_answer),
-                                             complex(self.correct_answer), self.tolerance)
+                                             correct_ans, self.tolerance)
         # We should catch this explicitly.
         # I think this is just pyparsing.ParseException, calc.UndefinedVariable:
         # But we'd need to confirm
         except:
-            raise StudentInputError("Invalid input: could not interpret '%s' as a number" %
-                                    cgi.escape(student_answer))
+            # Use the traceback-preserving version of re-raising with a different type
+            import sys
+            type, value, traceback = sys.exc_info()
+
+            raise StudentInputError, ("Invalid input: could not interpret '%s' as a number" %
+                                      cgi.escape(student_answer)), traceback
 
         if correct:
             return CorrectMap(self.answer_id, 'correct')
@@ -856,7 +867,7 @@ def sympy_check2():
   </customresponse>"""}]
 
     response_tag = 'customresponse'
-    allowed_inputfields = ['textline', 'textbox']
+    allowed_inputfields = ['textline', 'textbox', 'crystallography', 'chemicalequationinput']
 
     def setup_response(self):
         xml = self.xml

common/lib/capa/capa/templates/chemicalequationinput.html

+<section id="chemicalequationinput_${id}" class="chemicalequationinput">
+    <div class="script_placeholder" data-src="${previewer}"/>
+
+    % if status == 'unsubmitted':
+    <div class="unanswered" id="status_${id}">
+    % elif status == 'correct':
+    <div class="correct" id="status_${id}">
+    % elif status == 'incorrect':
+    <div class="incorrect" id="status_${id}">
+    % elif status == 'incomplete':
+    <div class="incorrect" id="status_${id}">
+    % endif
+
+  <input type="text" name="input_${id}" id="input_${id}" value="${value|h}"
+   % if size:
+   size="${size}"
+   % endif
+   />
+
+      <p class="status">
+        % if status == 'unsubmitted':
+        unanswered
+        % elif status == 'correct':
+        correct
+        % elif status == 'incorrect':
+        incorrect
+        % elif status == 'incomplete':
+        incomplete
+        % endif
+      </p>
+
+      <div id="input_${id}_preview" class="equation">
+      </div>
+      
+  <p id="answer_${id}" class="answer"></p>
+
+% if status in ['unsubmitted', 'correct', 'incorrect', 'incomplete']:
+</div>
+% endif
+</section>

common/lib/capa/capa/templates/crystallography.html

+<% doinline = "inline" if inline else "" %>
+
+<section id="textinput_${id}" class="textinput ${doinline}" >
+     <div id="holder" style="width:${width};height:${height}"></div>
+    <div class="script_placeholder" data-src="/static/js/raphael.js"></div><div class="script_placeholder" data-src="/static/js/sylvester.js"></div><div class="script_placeholder" data-src="/static/js/underscore-min.js"></div>
+    <div class="script_placeholder" data-src="/static/js/crystallography.js"></div>
+
+
+    % if state == 'unsubmitted':
+    <div class="unanswered ${doinline}" id="status_${id}">
+    % elif state == 'correct':
+    <div class="correct ${doinline}" id="status_${id}">
+    % elif state == 'incorrect':
+    <div class="incorrect ${doinline}" id="status_${id}">
+    % elif state == 'incomplete':
+    <div class="incorrect ${doinline}" id="status_${id}">
+    % endif
+    % if hidden:
+      <div style="display:none;" name="${hidden}" inputid="input_${id}" />
+    % endif
+
+  <input type="text" name="input_${id}" id="input_${id}" value="${value}"
+   % if size:
+   size="${size}"
+   % endif
+   % if hidden:
+    style="display:none;"
+   % endif
+   />
+
+      <p class="status">
+        % if state == 'unsubmitted':
+        unanswered
+        % elif state == 'correct':
+        correct
+        % elif state == 'incorrect':
+        incorrect
+        % elif state == 'incomplete':
+        incomplete
+        % endif
+      </p>
+
+  <p id="answer_${id}" class="answer"></p>
+
+  % if msg:
+      <span class="message">${msg|n}</span>
+  % endif
+% if state in ['unsubmitted', 'correct', 'incorrect', 'incomplete'] or hidden:
+</div>
+% endif
+</section>

common/lib/capa/capa/templates/textbox.html

@@ -5,8 +5,6 @@
        % endif
   >${value|h}</textarea>
 
-  <span id="answer_${id}"></span>
-
   <div class="grader-status">
     % if state == 'unsubmitted':
       <span class="unanswered" style="display:inline-block;" id="status_${id}">Unanswered</span>
@@ -26,6 +24,8 @@
     <p class="debug">${state}</p>
   </div>
 
+  <span id="answer_${id}"></span>
+
   <div class="external-grader-message">
     ${msg|n}
   </div>

common/lib/capa/capa/tests/__init__.py

+import fs
+import fs.osfs
+import os
+
+from mock import Mock
+
+TEST_DIR = os.path.dirname(os.path.realpath(__file__))
+
+test_system = Mock(
+    ajax_url='courses/course_id/modx/a_location',
+    track_function=Mock(),
+    get_module=Mock(),
+    render_template=Mock(),
+    replace_urls=Mock(),
+    user=Mock(),
+    filestore=fs.osfs.OSFS(os.path.join(TEST_DIR, "test_files")),
+    debug=True,
+    xqueue={'interface':None, 'callback_url':'/', 'default_queuename': 'testqueue', 'waittime': 10},
+    node_path=os.environ.get("NODE_PATH", "/usr/local/lib/node_modules"),
+    anonymous_student_id = 'student'
+)

common/lib/capa/capa/tests/test_inputtypes.py

+"""
+Tests of input types (and actually responsetypes too)
+"""
+
+from datetime import datetime
+import json
+from mock import Mock
+from nose.plugins.skip import SkipTest
+import os
+import unittest
+
+from . import test_system
+from capa import inputtypes
+
+from lxml import etree
+
+def tst_render_template(template, context):
+    """
+    A test version of render to template.  Renders to the repr of the context, completely ignoring the template name.
+    """
+    return repr(context)
+
+
+system = Mock(render_template=tst_render_template)
+
+class OptionInputTest(unittest.TestCase):
+    '''
+    Make sure option inputs work
+    '''
+    def test_rendering_new(self):
+        xml = """<optioninput options="('Up','Down')" id="sky_input" correct="Up"/>"""
+        element = etree.fromstring(xml)
+
+        value = 'Down'
+        status = 'answered'
+        context = inputtypes._optioninput(element, value, status, test_system.render_template)
+        print 'context: ', context
+
+        expected = {'value': 'Down',
+                    'options': [('Up', 'Up'), ('Down', 'Down')],
+                    'state': 'answered',
+                    'msg': '',
+                    'inline': '',
+                    'id': 'sky_input'}
+
+        self.assertEqual(context, expected)
+
+
+    def test_rendering(self):
+        xml_str = """<optioninput options="('Up','Down')" id="sky_input" correct="Up"/>"""
+        element = etree.fromstring(xml_str)
+
+        state = {'value': 'Down',
+                 'id': 'sky_input',
+                 'status': 'answered'}
+        option_input = inputtypes.OptionInput(system, element, state)
+
+        context = option_input._get_render_context()
+
+        expected = {'value': 'Down',
+                    'options': [('Up', 'Up'), ('Down', 'Down')],
+                    'state': 'answered',
+                    'msg': '',
+                    'inline': '',
+                    'id': 'sky_input'}
+
+        self.assertEqual(context, expected)
+

common/lib/capa/capa/tests/test_responsetypes.py

+"""
+Tests of responsetypes
+"""
+
+
+from datetime import datetime
+import json
+from nose.plugins.skip import SkipTest
+import os
+import unittest
+
+from . import test_system
+
+import capa.capa_problem as lcp
+from capa.correctmap import CorrectMap
+from capa.util import convert_files_to_filenames
+from capa.xqueue_interface import dateformat
+
+class MultiChoiceTest(unittest.TestCase):
+    def test_MC_grade(self):
+        multichoice_file = os.path.dirname(__file__) + "/test_files/multichoice.xml"
+        test_lcp = lcp.LoncapaProblem(open(multichoice_file).read(), '1', system=test_system)
+        correct_answers = {'1_2_1': 'choice_foil3'}
+        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
+        false_answers = {'1_2_1': 'choice_foil2'}
+        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
+
+    def test_MC_bare_grades(self):
+        multichoice_file = os.path.dirname(__file__) + "/test_files/multi_bare.xml"
+        test_lcp = lcp.LoncapaProblem(open(multichoice_file).read(), '1', system=test_system)
+        correct_answers = {'1_2_1': 'choice_2'}
+        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
+        false_answers = {'1_2_1': 'choice_1'}
+        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
+
+    def test_TF_grade(self):
+        truefalse_file = os.path.dirname(__file__) + "/test_files/truefalse.xml"
+        test_lcp = lcp.LoncapaProblem(open(truefalse_file).read(), '1', system=test_system)
+        correct_answers = {'1_2_1': ['choice_foil2', 'choice_foil1']}
+        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
+        false_answers = {'1_2_1': ['choice_foil1']}
+        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
+        false_answers = {'1_2_1': ['choice_foil1', 'choice_foil3']}
+        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
+        false_answers = {'1_2_1': ['choice_foil3']}
+        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
+        false_answers = {'1_2_1': ['choice_foil1', 'choice_foil2', 'choice_foil3']}
+        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
+
+
+class ImageResponseTest(unittest.TestCase):
+    def test_ir_grade(self):
+        imageresponse_file = os.path.dirname(__file__) + "/test_files/imageresponse.xml"
+        test_lcp = lcp.LoncapaProblem(open(imageresponse_file).read(), '1', system=test_system)
+        correct_answers = {'1_2_1': '(490,11)-(556,98)',
+                           '1_2_2': '(242,202)-(296,276)'}
+        test_answers = {'1_2_1': '[500,20]',
+                        '1_2_2': '[250,300]',
+                        }
+        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_1'), 'correct')
+        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_2'), 'incorrect')
+
+
+class SymbolicResponseTest(unittest.TestCase):
+    def test_sr_grade(self):
+        raise SkipTest()  # This test fails due to dependencies on a local copy of snuggletex-webapp. Until we have figured that out, we'll just skip this test
+        symbolicresponse_file = os.path.dirname(__file__) + "/test_files/symbolicresponse.xml"
+        test_lcp = lcp.LoncapaProblem(open(symbolicresponse_file).read(), '1', system=test_system)
+        correct_answers = {'1_2_1': 'cos(theta)*[[1,0],[0,1]] + i*sin(theta)*[[0,1],[1,0]]',
+                           '1_2_1_dynamath': '''
+<math xmlns="http://www.w3.org/1998/Math/MathML">
+  <mstyle displaystyle="true">
+    <mrow>
+      <mi>cos</mi>
+      <mrow>
+        <mo>(</mo>
+        <mi>&#x3B8;</mi>
+        <mo>)</mo>
+      </mrow>
+    </mrow>
+    <mo>&#x22C5;</mo>
+    <mrow>
+      <mo>[</mo>
+      <mtable>
+        <mtr>
+          <mtd>
+            <mn>1</mn>
+          </mtd>
+          <mtd>
+            <mn>0</mn>
+          </mtd>
+        </mtr>
+        <mtr>
+          <mtd>
+            <mn>0</mn>
+          </mtd>
+          <mtd>
+            <mn>1</mn>
+          </mtd>
+        </mtr>
+      </mtable>
+      <mo>]</mo>
+    </mrow>
+    <mo>+</mo>
+    <mi>i</mi>
+    <mo>&#x22C5;</mo>
+    <mrow>
+      <mi>sin</mi>
+      <mrow>
+        <mo>(</mo>
+        <mi>&#x3B8;</mi>
+        <mo>)</mo>
+      </mrow>
+    </mrow>
+    <mo>&#x22C5;</mo>
+    <mrow>
+      <mo>[</mo>
+      <mtable>
+        <mtr>
+          <mtd>
+            <mn>0</mn>
+          </mtd>
+          <mtd>
+            <mn>1</mn>
+          </mtd>
+        </mtr>
+        <mtr>
+          <mtd>
+            <mn>1</mn>
+          </mtd>
+          <mtd>
+            <mn>0</mn>
+          </mtd>
+        </mtr>
+      </mtable>
+      <mo>]</mo>
+    </mrow>
+  </mstyle>
+</math>
+''',
+                           }
+        wrong_answers = {'1_2_1': '2',
+                         '1_2_1_dynamath': '''
+                         <math xmlns="http://www.w3.org/1998/Math/MathML">
+  <mstyle displaystyle="true">
+    <mn>2</mn>
+  </mstyle>
+</math>''',
+                        }
+        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
+        self.assertEquals(test_lcp.grade_answers(wrong_answers).get_correctness('1_2_1'), 'incorrect')
+
+
+class OptionResponseTest(unittest.TestCase):
+    '''
+    Run this with
+
+    python manage.py test courseware.OptionResponseTest
+    '''
+    def test_or_grade(self):
+        optionresponse_file = os.path.dirname(__file__) + "/test_files/optionresponse.xml"
+        test_lcp = lcp.LoncapaProblem(open(optionresponse_file).read(), '1', system=test_system)
+        correct_answers = {'1_2_1': 'True',
+                           '1_2_2': 'False'}
+        test_answers = {'1_2_1': 'True',
+                        '1_2_2': 'True',
+                        }
+        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_1'), 'correct')
+        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_2'), 'incorrect')
+
+
+class FormulaResponseWithHintTest(unittest.TestCase):
+    '''
+    Test Formula response problem with a hint
+    This problem also uses calc.
+    '''
+    def test_or_grade(self):
+        problem_file = os.path.dirname(__file__) + "/test_files/formularesponse_with_hint.xml"
+        test_lcp = lcp.LoncapaProblem(open(problem_file).read(), '1', system=test_system)
+        correct_answers = {'1_2_1': '2.5*x-5.0'}
+        test_answers = {'1_2_1': '0.4*x-5.0'}
+        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
+        cmap = test_lcp.grade_answers(test_answers)
+        self.assertEquals(cmap.get_correctness('1_2_1'), 'incorrect')
+        self.assertTrue('You have inverted' in cmap.get_hint('1_2_1'))
+
+
+class StringResponseWithHintTest(unittest.TestCase):
+    '''
+    Test String response problem with a hint
+    '''
+    def test_or_grade(self):
+        problem_file = os.path.dirname(__file__) + "/test_files/stringresponse_with_hint.xml"
+        test_lcp = lcp.LoncapaProblem(open(problem_file).read(), '1', system=test_system)
+        correct_answers = {'1_2_1': 'Michigan'}
+        test_answers = {'1_2_1': 'Minnesota'}
+        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
+        cmap = test_lcp.grade_answers(test_answers)
+        self.assertEquals(cmap.get_correctness('1_2_1'), 'incorrect')
+        self.assertTrue('St. Paul' in cmap.get_hint('1_2_1'))
+
+
+class CodeResponseTest(unittest.TestCase):
+    '''
+    Test CodeResponse
+    TODO: Add tests for external grader messages
+    '''
+    @staticmethod
+    def make_queuestate(key, time):
+        timestr = datetime.strftime(time, dateformat)
+        return {'key': key, 'time': timestr}
+
+    def test_is_queued(self):
+        """
+        Simple test of whether LoncapaProblem knows when it's been queued
+        """
+        problem_file = os.path.join(os.path.dirname(__file__), "test_files/coderesponse.xml")
+        with open(problem_file) as input_file:
+            test_lcp = lcp.LoncapaProblem(input_file.read(), '1', system=test_system)
+
+            answer_ids = sorted(test_lcp.get_question_answers())
+
+            # CodeResponse requires internal CorrectMap state. Build it now in the unqueued state
+            cmap = CorrectMap()
+            for answer_id in answer_ids:
+                cmap.update(CorrectMap(answer_id=answer_id, queuestate=None))
+            test_lcp.correct_map.update(cmap)
+
+            self.assertEquals(test_lcp.is_queued(), False)
+
+            # Now we queue the LCP
+            cmap = CorrectMap()
+            for i, answer_id in enumerate(answer_ids):
+                queuestate = CodeResponseTest.make_queuestate(i, datetime.now())
+                cmap.update(CorrectMap(answer_id=answer_ids[i], queuestate=queuestate))
+            test_lcp.correct_map.update(cmap)
+
+            self.assertEquals(test_lcp.is_queued(), True)
+
+
+    def test_update_score(self):
+        '''
+        Test whether LoncapaProblem.update_score can deliver queued result to the right subproblem
+        '''
+        problem_file = os.path.join(os.path.dirname(__file__), "test_files/coderesponse.xml")
+        with open(problem_file) as input_file:
+            test_lcp = lcp.LoncapaProblem(input_file.read(), '1', system=test_system)
+
+            answer_ids = sorted(test_lcp.get_question_answers())
+
+            # CodeResponse requires internal CorrectMap state. Build it now in the queued state
+            old_cmap = CorrectMap()
+            for i, answer_id in enumerate(answer_ids):
+                queuekey = 1000 + i
+                queuestate = CodeResponseTest.make_queuestate(1000+i, datetime.now())
+                old_cmap.update(CorrectMap(answer_id=answer_ids[i], queuestate=queuestate))
+
+            # Message format common to external graders
+            grader_msg = '<span>MESSAGE</span>' # Must be valid XML
+            correct_score_msg = json.dumps({'correct':True, 'score':1, 'msg': grader_msg})
+            incorrect_score_msg = json.dumps({'correct':False, 'score':0, 'msg': grader_msg})
+
+            xserver_msgs = {'correct': correct_score_msg,
+                            'incorrect': incorrect_score_msg,}
+
+            # Incorrect queuekey, state should not be updated
+            for correctness in ['correct', 'incorrect']:
+                test_lcp.correct_map = CorrectMap()
+                test_lcp.correct_map.update(old_cmap)  # Deep copy
+
+                test_lcp.update_score(xserver_msgs[correctness], queuekey=0)
+                self.assertEquals(test_lcp.correct_map.get_dict(), old_cmap.get_dict())  # Deep comparison
+
+                for answer_id in answer_ids:
+                    self.assertTrue(test_lcp.correct_map.is_queued(answer_id))  # Should be still queued, since message undelivered
+
+            # Correct queuekey, state should be updated
+            for correctness in ['correct', 'incorrect']:
+                for i, answer_id in enumerate(answer_ids):
+                    test_lcp.correct_map = CorrectMap()
+                    test_lcp.correct_map.update(old_cmap)
+
+                    new_cmap = CorrectMap()
+                    new_cmap.update(old_cmap)
+                    npoints = 1 if correctness=='correct' else 0
+                    new_cmap.set(answer_id=answer_id, npoints=npoints, correctness=correctness, msg=grader_msg, queuestate=None)
+
+                    test_lcp.update_score(xserver_msgs[correctness], queuekey=1000 + i)
+                    self.assertEquals(test_lcp.correct_map.get_dict(), new_cmap.get_dict())
+
+                    for j, test_id in enumerate(answer_ids):
+                        if j == i:
+                            self.assertFalse(test_lcp.correct_map.is_queued(test_id))  # Should be dequeued, message delivered
+                        else:
+                            self.assertTrue(test_lcp.correct_map.is_queued(test_id))  # Should be queued, message undelivered
+
+
+    def test_recentmost_queuetime(self):
+        '''
+        Test whether the LoncapaProblem knows about the time of queue requests
+        '''
+        problem_file = os.path.join(os.path.dirname(__file__), "test_files/coderesponse.xml")
+        with open(problem_file) as input_file:
+            test_lcp = lcp.LoncapaProblem(input_file.read(), '1', system=test_system)
+
+            answer_ids = sorted(test_lcp.get_question_answers())
+
+            # CodeResponse requires internal CorrectMap state. Build it now in the unqueued state
+            cmap = CorrectMap()
+            for answer_id in answer_ids:
+                cmap.update(CorrectMap(answer_id=answer_id, queuestate=None))
+            test_lcp.correct_map.update(cmap)
+
+            self.assertEquals(test_lcp.get_recentmost_queuetime(), None)
+
+            # CodeResponse requires internal CorrectMap state. Build it now in the queued state
+            cmap = CorrectMap()
+            for i, answer_id in enumerate(answer_ids):
+                queuekey = 1000 + i
+                latest_timestamp = datetime.now()
+                queuestate = CodeResponseTest.make_queuestate(1000+i, latest_timestamp)
+                cmap.update(CorrectMap(answer_id=answer_id, queuestate=queuestate))
+            test_lcp.correct_map.update(cmap)
+
+            # Queue state only tracks up to second
+            latest_timestamp = datetime.strptime(datetime.strftime(latest_timestamp, dateformat), dateformat)
+
+            self.assertEquals(test_lcp.get_recentmost_queuetime(), latest_timestamp)
+
+        def test_convert_files_to_filenames(self):
+            '''
+            Test whether file objects are converted to filenames without altering other structures
+            '''
+            problem_file = os.path.join(os.path.dirname(__file__), "test_files/coderesponse.xml")
+            with open(problem_file) as fp:
+                answers_with_file = {'1_2_1': 'String-based answer',
+                                     '1_3_1': ['answer1', 'answer2', 'answer3'],
+                                     '1_4_1': [fp, fp]}
+                answers_converted = convert_files_to_filenames(answers_with_file)
+                self.assertEquals(answers_converted['1_2_1'], 'String-based answer')
+                self.assertEquals(answers_converted['1_3_1'], ['answer1', 'answer2', 'answer3'])
+                self.assertEquals(answers_converted['1_4_1'], [fp.name, fp.name])
+
+
+class ChoiceResponseTest(unittest.TestCase):
+
+    def test_cr_rb_grade(self):
+        problem_file = os.path.dirname(__file__) + "/test_files/choiceresponse_radio.xml"
+        test_lcp = lcp.LoncapaProblem(open(problem_file).read(), '1', system=test_system)
+        correct_answers = {'1_2_1': 'choice_2',
+                           '1_3_1': ['choice_2', 'choice_3']}
+        test_answers = {'1_2_1': 'choice_2',
+                        '1_3_1': 'choice_2',
+                        }
+        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_1'), 'correct')
+        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_3_1'), 'incorrect')
+
+    def test_cr_cb_grade(self):
+        problem_file = os.path.dirname(__file__) + "/test_files/choiceresponse_checkbox.xml"
+        test_lcp = lcp.LoncapaProblem(open(problem_file).read(), '1', system=test_system)
+        correct_answers = {'1_2_1': 'choice_2',
+                           '1_3_1': ['choice_2', 'choice_3'],
+                           '1_4_1': ['choice_2', 'choice_3']}
+        test_answers = {'1_2_1': 'choice_2',
+                        '1_3_1': 'choice_2',
+                        '1_4_1': ['choice_2', 'choice_3'],
+                        }
+        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_1'), 'correct')
+        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_3_1'), 'incorrect')
+        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_4_1'), 'correct')
+
+class JavascriptResponseTest(unittest.TestCase):
+
+    def test_jr_grade(self):
+        problem_file = os.path.dirname(__file__) + "/test_files/javascriptresponse.xml"
+        coffee_file_path = os.path.dirname(__file__) + "/test_files/js/*.coffee"
+        os.system("coffee -c %s" % (coffee_file_path))
+        test_lcp = lcp.LoncapaProblem(open(problem_file).read(), '1', system=test_system)
+        correct_answers = {'1_2_1': json.dumps({0: 4})}
+        incorrect_answers = {'1_2_1': json.dumps({0: 5})}
+
+        self.assertEquals(test_lcp.grade_answers(incorrect_answers).get_correctness('1_2_1'), 'incorrect')
+        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
+

common/lib/capa/capa/util.py

@@ -11,7 +11,7 @@ def compare_with_tolerance(v1, v2, tol):
 
      - v1    :  student result (number)
      - v2    :  instructor result (number)
-     - tol   :  tolerance (string or number)
+     - tol   :  tolerance (string representing a number)
 
     '''
     relative = tol.endswith('%')

common/lib/xmodule/xmodule/capa_module.py

@@ -133,6 +133,11 @@ class CapaModule(XModule):
         if self.rerandomize == 'never':
             self.seed = 1
         elif self.rerandomize == "per_student" and hasattr(self.system, 'id'):
+            # TODO: This line is badly broken:
+            # (1) We're passing student ID to xmodule.
+            # (2) There aren't bins of students.  -- we only want 10 or 20 randomizations, and want to assign students
+            # to these bins, and may not want cohorts.  So e.g. hash(your-id, problem_id) % num_bins.
+            #     - analytics really needs small number of bins.
             self.seed = system.id
         else:
             self.seed = None
@@ -619,12 +624,14 @@ class CapaModule(XModule):
         if self.closed():
             event_info['failure'] = 'closed'
             self.system.track_function('reset_problem_fail', event_info)
-            return "Problem is closed"
+            return {'success': False,
+                    'error': "Problem is closed"}
 
         if not self.lcp.done:
             event_info['failure'] = 'not_done'
             self.system.track_function('reset_problem_fail', event_info)
-            return "Refresh the page and make an attempt before resetting."
+            return {'success': False,
+                    'error': "Refresh the page and make an attempt before resetting."}
 
         self.lcp.do_reset()
         if self.rerandomize in ["always", "onreset"]:

common/lib/xmodule/xmodule/css/capa/display.scss

@@ -572,7 +572,7 @@ section.problem {
         }
       }
 
-      section {
+      > section {
         padding: 9px;
       }
     }

common/lib/xmodule/xmodule/js/src/capa/display.coffee

@@ -334,10 +334,13 @@ class @Problem
   inputtypeShowAnswerMethods:
     choicegroup: (element, display, answers) =>
       element = $(element)
-      for key, value of answers
-        element.find('input').attr('disabled', 'disabled')
-        for choice in value
-          element.find("label[for='input_#{key}_#{choice}']").addClass 'choicegroup_correct'
+
+      element.find('input').attr('disabled', 'disabled')
+
+      input_id = element.attr('id').replace(/inputtype_/,'')
+      answer = answers[input_id]
+      for choice in answer
+        element.find("label[for='input_#{input_id}_#{choice}']").addClass 'choicegroup_correct'
 
     javascriptinput: (element, display, answers) =>
       answer_id = $(element).attr('id').split("_")[1...].join("_")

common/lib/xmodule/xmodule/js/src/collapsible.coffee

@@ -11,11 +11,12 @@ class @Collapsible
     ###
     el.find('.longform').hide()
     el.find('.shortform').append('<a href="#" class="full">See full output</a>')
-    el.find('.collapsible section').hide()
+    el.find('.collapsible header + section').hide()
     el.find('.full').click @toggleFull
     el.find('.collapsible header a').click @toggleHint
 
   @toggleFull: (event) =>
+    event.preventDefault()
     $(event.target).parent().siblings().slideToggle()
     $(event.target).parent().parent().toggleClass('open')
     if $(event.target).text() == 'See full output'

common/lib/xmodule/xmodule/js/src/javascript_loader.coffee

@@ -41,20 +41,30 @@ class @JavascriptLoader
           callbackCalled = true
           callback() if callback?
 
+    # Keep a map of what sources we're loaded from, and don't do it twice.
+    loaded = {}
     placeholders.each (index, placeholder) ->
       # TODO: Check if the script already exists in DOM. If so, (1) copy it
       #         into memory; (2) delete the DOM script element; (3) reappend it.
       #       This would prevent memory bloat and save a network request.
-      s = document.createElement('script')
-      s.setAttribute('src', $(placeholder).attr("data-src"))
-      s.setAttribute('type', "text/javascript")
+      src = $(placeholder).attr("data-src")
+      if src not of loaded
+        loaded[src] = true
+        s = document.createElement('script')
+        s.setAttribute('src', src)
+        s.setAttribute('type', "text/javascript")
+  
+        s.onload             = completionHandlerGenerator(index)
 
-      s.onload             = completionHandlerGenerator(index)
+        # s.onload does not fire in IE8; this does.
+        s.onreadystatechange = completionHandlerGeneratorIE(index)
 
-      # s.onload does not fire in IE8; this does.
-      s.onreadystatechange = completionHandlerGeneratorIE(index)
-
-      # Need to use the DOM elements directly or the scripts won't execute
-      # properly.
-      $('head')[0].appendChild(s)
+        # Need to use the DOM elements directly or the scripts won't execute
+        # properly.
+        $('head')[0].appendChild(s)
+      else
+        # just call the completion callback directly, without reloading the file
+        completionHandlerGenerator(index)()
       $(placeholder).remove()
+        
+      

common/lib/xmodule/xmodule/tests/__init__.py

-#
-# unittests for xmodule (and capa)
-#
-# Note: run this using a like like this:
-#
-# django-admin.py test --settings=lms.envs.test_ike --pythonpath=. common/lib/xmodule
+"""
+unittests for xmodule
+
+Run like this:
+
+    rake test_common/lib/xmodule
+    
+"""
 
 import unittest
 import os
 import fs
 import fs.osfs
-import json
 
-import json
 import numpy
 
-import xmodule
 import capa.calc as calc
-import capa.capa_problem as lcp
-from capa.correctmap import CorrectMap
-from capa.util import convert_files_to_filenames
-from capa.xqueue_interface import dateformat
-from datetime import datetime
-from xmodule import graders, x_module
+import xmodule
 from xmodule.x_module import ModuleSystem
-from xmodule.graders import Score, aggregate_scores
-from xmodule.progress import Progress
-from nose.plugins.skip import SkipTest
 from mock import Mock
 
 i4xs = ModuleSystem(
@@ -35,7 +26,7 @@ i4xs = ModuleSystem(
     render_template=Mock(),
     replace_urls=Mock(),
     user=Mock(),
-    filestore=fs.osfs.OSFS(os.path.dirname(os.path.realpath(__file__))+"/test_files"),
+    filestore=Mock(),
     debug=True,
     xqueue={'interface':None, 'callback_url':'/', 'default_queuename': 'testqueue', 'waittime': 10},
     node_path=os.environ.get("NODE_PATH", "/usr/local/lib/node_modules"),
@@ -94,719 +85,3 @@ class ModelsTest(unittest.TestCase):
             exception_happened = True
         self.assertTrue(exception_happened)
 
-#-----------------------------------------------------------------------------
-# tests of capa_problem inputtypes
-
-
-class MultiChoiceTest(unittest.TestCase):
-    def test_MC_grade(self):
-        multichoice_file = os.path.dirname(__file__) + "/test_files/multichoice.xml"
-        test_lcp = lcp.LoncapaProblem(open(multichoice_file).read(), '1', system=i4xs)
-        correct_answers = {'1_2_1': 'choice_foil3'}
-        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
-        false_answers = {'1_2_1': 'choice_foil2'}
-        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
-
-    def test_MC_bare_grades(self):
-        multichoice_file = os.path.dirname(__file__) + "/test_files/multi_bare.xml"
-        test_lcp = lcp.LoncapaProblem(open(multichoice_file).read(), '1', system=i4xs)
-        correct_answers = {'1_2_1': 'choice_2'}
-        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
-        false_answers = {'1_2_1': 'choice_1'}
-        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
-
-    def test_TF_grade(self):
-        truefalse_file = os.path.dirname(__file__) + "/test_files/truefalse.xml"
-        test_lcp = lcp.LoncapaProblem(open(truefalse_file).read(), '1', system=i4xs)
-        correct_answers = {'1_2_1': ['choice_foil2', 'choice_foil1']}
-        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
-        false_answers = {'1_2_1': ['choice_foil1']}
-        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
-        false_answers = {'1_2_1': ['choice_foil1', 'choice_foil3']}
-        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
-        false_answers = {'1_2_1': ['choice_foil3']}
-        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
-        false_answers = {'1_2_1': ['choice_foil1', 'choice_foil2', 'choice_foil3']}
-        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
-
-
-class ImageResponseTest(unittest.TestCase):
-    def test_ir_grade(self):
-        imageresponse_file = os.path.dirname(__file__) + "/test_files/imageresponse.xml"
-        test_lcp = lcp.LoncapaProblem(open(imageresponse_file).read(), '1', system=i4xs)
-        correct_answers = {'1_2_1': '(490,11)-(556,98)',
-                           '1_2_2': '(242,202)-(296,276)'}
-        test_answers = {'1_2_1': '[500,20]',
-                        '1_2_2': '[250,300]',
-                        }
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_1'), 'correct')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_2'), 'incorrect')
-
-
-class SymbolicResponseTest(unittest.TestCase):
-    def test_sr_grade(self):
-        raise SkipTest()  # This test fails due to dependencies on a local copy of snuggletex-webapp. Until we have figured that out, we'll just skip this test
-        symbolicresponse_file = os.path.dirname(__file__) + "/test_files/symbolicresponse.xml"
-        test_lcp = lcp.LoncapaProblem(open(symbolicresponse_file).read(), '1', system=i4xs)
-        correct_answers = {'1_2_1': 'cos(theta)*[[1,0],[0,1]] + i*sin(theta)*[[0,1],[1,0]]',
-                           '1_2_1_dynamath': '''
-<math xmlns="http://www.w3.org/1998/Math/MathML">
-  <mstyle displaystyle="true">
-    <mrow>
-      <mi>cos</mi>
-      <mrow>
-        <mo>(</mo>
-        <mi>&#x3B8;</mi>
-        <mo>)</mo>
-      </mrow>
-    </mrow>
-    <mo>&#x22C5;</mo>
-    <mrow>
-      <mo>[</mo>
-      <mtable>
-        <mtr>
-          <mtd>
-            <mn>1</mn>
-          </mtd>
-          <mtd>
-            <mn>0</mn>
-          </mtd>
-        </mtr>
-        <mtr>
-          <mtd>
-            <mn>0</mn>
-          </mtd>
-          <mtd>
-            <mn>1</mn>
-          </mtd>
-        </mtr>
-      </mtable>
-      <mo>]</mo>
-    </mrow>
-    <mo>+</mo>
-    <mi>i</mi>
-    <mo>&#x22C5;</mo>
-    <mrow>
-      <mi>sin</mi>
-      <mrow>
-        <mo>(</mo>
-        <mi>&#x3B8;</mi>
-        <mo>)</mo>
-      </mrow>
-    </mrow>
-    <mo>&#x22C5;</mo>
-    <mrow>
-      <mo>[</mo>
-      <mtable>
-        <mtr>
-          <mtd>
-            <mn>0</mn>
-          </mtd>
-          <mtd>
-            <mn>1</mn>
-          </mtd>
-        </mtr>
-        <mtr>
-          <mtd>
-            <mn>1</mn>
-          </mtd>
-          <mtd>
-            <mn>0</mn>
-          </mtd>
-        </mtr>
-      </mtable>
-      <mo>]</mo>
-    </mrow>
-  </mstyle>
-</math>
-''',
-                           }
-        wrong_answers = {'1_2_1': '2',
-                         '1_2_1_dynamath': '''
-                         <math xmlns="http://www.w3.org/1998/Math/MathML">
-  <mstyle displaystyle="true">
-    <mn>2</mn>
-  </mstyle>
-</math>''',
-                        }
-        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
-        self.assertEquals(test_lcp.grade_answers(wrong_answers).get_correctness('1_2_1'), 'incorrect')
-
-
-class OptionResponseTest(unittest.TestCase):
-    '''
-    Run this with
-
-    python manage.py test courseware.OptionResponseTest
-    '''
-    def test_or_grade(self):
-        optionresponse_file = os.path.dirname(__file__) + "/test_files/optionresponse.xml"
-        test_lcp = lcp.LoncapaProblem(open(optionresponse_file).read(), '1', system=i4xs)
-        correct_answers = {'1_2_1': 'True',
-                           '1_2_2': 'False'}
-        test_answers = {'1_2_1': 'True',
-                        '1_2_2': 'True',
-                        }
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_1'), 'correct')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_2'), 'incorrect')
-
-
-class FormulaResponseWithHintTest(unittest.TestCase):
-    '''
-    Test Formula response problem with a hint
-    This problem also uses calc.
-    '''
-    def test_or_grade(self):
-        problem_file = os.path.dirname(__file__) + "/test_files/formularesponse_with_hint.xml"
-        test_lcp = lcp.LoncapaProblem(open(problem_file).read(), '1', system=i4xs)
-        correct_answers = {'1_2_1': '2.5*x-5.0'}
-        test_answers = {'1_2_1': '0.4*x-5.0'}
-        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
-        cmap = test_lcp.grade_answers(test_answers)
-        self.assertEquals(cmap.get_correctness('1_2_1'), 'incorrect')
-        self.assertTrue('You have inverted' in cmap.get_hint('1_2_1'))
-
-
-class StringResponseWithHintTest(unittest.TestCase):
-    '''
-    Test String response problem with a hint
-    '''
-    def test_or_grade(self):
-        problem_file = os.path.dirname(__file__) + "/test_files/stringresponse_with_hint.xml"
-        test_lcp = lcp.LoncapaProblem(open(problem_file).read(), '1', system=i4xs)
-        correct_answers = {'1_2_1': 'Michigan'}
-        test_answers = {'1_2_1': 'Minnesota'}
-        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
-        cmap = test_lcp.grade_answers(test_answers)
-        self.assertEquals(cmap.get_correctness('1_2_1'), 'incorrect')
-        self.assertTrue('St. Paul' in cmap.get_hint('1_2_1'))
-
-
-class CodeResponseTest(unittest.TestCase):
-    '''
-    Test CodeResponse
-    TODO: Add tests for external grader messages
-    '''
-    @staticmethod
-    def make_queuestate(key, time):
-        timestr = datetime.strftime(time, dateformat)
-        return {'key': key, 'time': timestr}
-
-    def test_is_queued(self):
-        ''' 
-        Simple test of whether LoncapaProblem knows when it's been queued
-        '''
-        problem_file = os.path.join(os.path.dirname(__file__), "test_files/coderesponse.xml")
-        with open(problem_file) as input_file:
-            test_lcp = lcp.LoncapaProblem(input_file.read(), '1', system=i4xs)
-            
-            answer_ids = sorted(test_lcp.get_question_answers())
-
-            # CodeResponse requires internal CorrectMap state. Build it now in the unqueued state
-            cmap = CorrectMap()
-            for answer_id in answer_ids:
-                cmap.update(CorrectMap(answer_id=answer_id, queuestate=None))
-            test_lcp.correct_map.update(cmap)
-
-            self.assertEquals(test_lcp.is_queued(), False)
-
-            # Now we queue the LCP
-            cmap = CorrectMap()
-            for i, answer_id in enumerate(answer_ids): 
-                queuestate = CodeResponseTest.make_queuestate(i, datetime.now())
-                cmap.update(CorrectMap(answer_id=answer_ids[i], queuestate=queuestate))
-            test_lcp.correct_map.update(cmap)
-
-            self.assertEquals(test_lcp.is_queued(), True)
-
-
-    def test_update_score(self):
-        '''
-        Test whether LoncapaProblem.update_score can deliver queued result to the right subproblem
-        '''
-        problem_file = os.path.join(os.path.dirname(__file__), "test_files/coderesponse.xml")
-        with open(problem_file) as input_file:
-            test_lcp = lcp.LoncapaProblem(input_file.read(), '1', system=i4xs)
-
-            answer_ids = sorted(test_lcp.get_question_answers())
-
-            # CodeResponse requires internal CorrectMap state. Build it now in the queued state
-            old_cmap = CorrectMap()
-            for i, answer_id in enumerate(answer_ids):
-                queuekey = 1000 + i
-                queuestate = CodeResponseTest.make_queuestate(1000+i, datetime.now())
-                old_cmap.update(CorrectMap(answer_id=answer_ids[i], queuestate=queuestate))
-
-            # Message format common to external graders
-            grader_msg = '<span>MESSAGE</span>' # Must be valid XML
-            correct_score_msg = json.dumps({'correct':True, 'score':1, 'msg': grader_msg})
-            incorrect_score_msg = json.dumps({'correct':False, 'score':0, 'msg': grader_msg})
-
-            xserver_msgs = {'correct': correct_score_msg,
-                            'incorrect': incorrect_score_msg,}
-
-            # Incorrect queuekey, state should not be updated
-            for correctness in ['correct', 'incorrect']:
-                test_lcp.correct_map = CorrectMap()
-                test_lcp.correct_map.update(old_cmap)  # Deep copy
-
-                test_lcp.update_score(xserver_msgs[correctness], queuekey=0)
-                self.assertEquals(test_lcp.correct_map.get_dict(), old_cmap.get_dict())  # Deep comparison
-
-                for answer_id in answer_ids:
-                    self.assertTrue(test_lcp.correct_map.is_queued(answer_id))  # Should be still queued, since message undelivered
-
-            # Correct queuekey, state should be updated
-            for correctness in ['correct', 'incorrect']:
-                for i, answer_id in enumerate(answer_ids):
-                    test_lcp.correct_map = CorrectMap()
-                    test_lcp.correct_map.update(old_cmap)
-
-                    new_cmap = CorrectMap()
-                    new_cmap.update(old_cmap)
-                    npoints = 1 if correctness=='correct' else 0
-                    new_cmap.set(answer_id=answer_id, npoints=npoints, correctness=correctness, msg=grader_msg, queuestate=None)
-
-                    test_lcp.update_score(xserver_msgs[correctness], queuekey=1000 + i)
-                    self.assertEquals(test_lcp.correct_map.get_dict(), new_cmap.get_dict())
-
-                    for j, test_id in enumerate(answer_ids):
-                        if j == i:
-                            self.assertFalse(test_lcp.correct_map.is_queued(test_id))  # Should be dequeued, message delivered
-                        else:
-                            self.assertTrue(test_lcp.correct_map.is_queued(test_id))  # Should be queued, message undelivered
-    
-
-    def test_recentmost_queuetime(self):
-        '''
-        Test whether the LoncapaProblem knows about the time of queue requests
-        '''
-        problem_file = os.path.join(os.path.dirname(__file__), "test_files/coderesponse.xml")
-        with open(problem_file) as input_file:
-            test_lcp = lcp.LoncapaProblem(input_file.read(), '1', system=i4xs)
-
-            answer_ids = sorted(test_lcp.get_question_answers())
-
-            # CodeResponse requires internal CorrectMap state. Build it now in the unqueued state
-            cmap = CorrectMap()
-            for answer_id in answer_ids:
-                cmap.update(CorrectMap(answer_id=answer_id, queuestate=None))
-            test_lcp.correct_map.update(cmap)
-            
-            self.assertEquals(test_lcp.get_recentmost_queuetime(), None)
-
-            # CodeResponse requires internal CorrectMap state. Build it now in the queued state
-            cmap = CorrectMap()
-            for i, answer_id in enumerate(answer_ids):
-                queuekey = 1000 + i
-                latest_timestamp = datetime.now()
-                queuestate = CodeResponseTest.make_queuestate(1000+i, latest_timestamp)
-                cmap.update(CorrectMap(answer_id=answer_id, queuestate=queuestate))
-            test_lcp.correct_map.update(cmap)
-
-            # Queue state only tracks up to second
-            latest_timestamp = datetime.strptime(datetime.strftime(latest_timestamp, dateformat), dateformat)
-
-            self.assertEquals(test_lcp.get_recentmost_queuetime(), latest_timestamp)
-
-        def test_convert_files_to_filenames(self):
-            '''
-            Test whether file objects are converted to filenames without altering other structures
-            '''
-            problem_file = os.path.join(os.path.dirname(__file__), "test_files/coderesponse.xml")
-            with open(problem_file) as fp:
-                answers_with_file = {'1_2_1': 'String-based answer',
-                                     '1_3_1': ['answer1', 'answer2', 'answer3'],
-                                     '1_4_1': [fp, fp]}
-                answers_converted = convert_files_to_filenames(answers_with_file)
-                self.assertEquals(answers_converted['1_2_1'], 'String-based answer')
-                self.assertEquals(answers_converted['1_3_1'], ['answer1', 'answer2', 'answer3'])
-                self.assertEquals(answers_converted['1_4_1'], [fp.name, fp.name])
-
-
-class ChoiceResponseTest(unittest.TestCase):
-
-    def test_cr_rb_grade(self):
-        problem_file = os.path.dirname(__file__) + "/test_files/choiceresponse_radio.xml"
-        test_lcp = lcp.LoncapaProblem(open(problem_file).read(), '1', system=i4xs)
-        correct_answers = {'1_2_1': 'choice_2',
-                           '1_3_1': ['choice_2', 'choice_3']}
-        test_answers = {'1_2_1': 'choice_2',
-                        '1_3_1': 'choice_2',
-                        }
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_1'), 'correct')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_3_1'), 'incorrect')
-
-    def test_cr_cb_grade(self):
-        problem_file = os.path.dirname(__file__) + "/test_files/choiceresponse_checkbox.xml"
-        test_lcp = lcp.LoncapaProblem(open(problem_file).read(), '1', system=i4xs)
-        correct_answers = {'1_2_1': 'choice_2',
-                           '1_3_1': ['choice_2', 'choice_3'],
-                           '1_4_1': ['choice_2', 'choice_3']}
-        test_answers = {'1_2_1': 'choice_2',
-                        '1_3_1': 'choice_2',
-                        '1_4_1': ['choice_2', 'choice_3'],
-                        }
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_1'), 'correct')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_3_1'), 'incorrect')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_4_1'), 'correct')
-
-class JavascriptResponseTest(unittest.TestCase):
-
-    def test_jr_grade(self):
-        problem_file = os.path.dirname(__file__) + "/test_files/javascriptresponse.xml"
-        coffee_file_path = os.path.dirname(__file__) + "/test_files/js/*.coffee"
-        os.system("coffee -c %s" % (coffee_file_path))
-        test_lcp = lcp.LoncapaProblem(open(problem_file).read(), '1', system=i4xs)
-        correct_answers = {'1_2_1': json.dumps({0: 4})}
-        incorrect_answers = {'1_2_1': json.dumps({0: 5})}
-
-        self.assertEquals(test_lcp.grade_answers(incorrect_answers).get_correctness('1_2_1'), 'incorrect')
-        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
-
-#-----------------------------------------------------------------------------
-# Grading tests
-
-
-class GradesheetTest(unittest.TestCase):
-
-    def test_weighted_grading(self):
-        scores = []
-        Score.__sub__ = lambda me, other: (me.earned - other.earned) + (me.possible - other.possible)
-
-        all, graded = aggregate_scores(scores)
-        self.assertEqual(all, Score(earned=0, possible=0, graded=False, section="summary"))
-        self.assertEqual(graded, Score(earned=0, possible=0, graded=True, section="summary"))
-
-        scores.append(Score(earned=0, possible=5, graded=False, section="summary"))
-        all, graded = aggregate_scores(scores)
-        self.assertEqual(all, Score(earned=0, possible=5, graded=False, section="summary"))
-        self.assertEqual(graded, Score(earned=0, possible=0, graded=True, section="summary"))
-
-        scores.append(Score(earned=3, possible=5, graded=True, section="summary"))
-        all, graded = aggregate_scores(scores)
-        self.assertAlmostEqual(all, Score(earned=3, possible=10, graded=False, section="summary"))
-        self.assertAlmostEqual(graded, Score(earned=3, possible=5, graded=True, section="summary"))
-
-        scores.append(Score(earned=2, possible=5, graded=True, section="summary"))
-        all, graded = aggregate_scores(scores)
-        self.assertAlmostEqual(all, Score(earned=5, possible=15, graded=False, section="summary"))
-        self.assertAlmostEqual(graded, Score(earned=5, possible=10, graded=True, section="summary"))
-
-
-class GraderTest(unittest.TestCase):
-
-    empty_gradesheet = {
-    }
-
-    incomplete_gradesheet = {
-        'Homework': [],
-        'Lab': [],
-        'Midterm': [],
-    }
-
-    test_gradesheet = {
-        'Homework': [Score(earned=2, possible=20.0, graded=True, section='hw1'),
-              Score(earned=16, possible=16.0, graded=True, section='hw2')],
-              #The dropped scores should be from the assignments that don't exist yet
-
-        'Lab': [Score(earned=1, possible=2.0, graded=True, section='lab1'),  # Dropped
-             Score(earned=1, possible=1.0, graded=True, section='lab2'),
-             Score(earned=1, possible=1.0, graded=True, section='lab3'),
-             Score(earned=5, possible=25.0, graded=True, section='lab4'),  # Dropped
-             Score(earned=3, possible=4.0, graded=True, section='lab5'),  # Dropped
-             Score(earned=6, possible=7.0, graded=True, section='lab6'),
-             Score(earned=5, possible=6.0, graded=True, section='lab7')],
-
-        'Midterm': [Score(earned=50.5, possible=100, graded=True, section="Midterm Exam"), ],
-    }
-
-    def test_SingleSectionGrader(self):
-        midtermGrader = graders.SingleSectionGrader("Midterm", "Midterm Exam")
-        lab4Grader = graders.SingleSectionGrader("Lab", "lab4")
-        badLabGrader = graders.SingleSectionGrader("Lab", "lab42")
-
-        for graded in [midtermGrader.grade(self.empty_gradesheet),
-                        midtermGrader.grade(self.incomplete_gradesheet),
-                        badLabGrader.grade(self.test_gradesheet)]:
-            self.assertEqual(len(graded['section_breakdown']), 1)
-            self.assertEqual(graded['percent'], 0.0)
-
-        graded = midtermGrader.grade(self.test_gradesheet)
-        self.assertAlmostEqual(graded['percent'], 0.505)
-        self.assertEqual(len(graded['section_breakdown']), 1)
-
-        graded = lab4Grader.grade(self.test_gradesheet)
-        self.assertAlmostEqual(graded['percent'], 0.2)
-        self.assertEqual(len(graded['section_breakdown']), 1)
-
-    def test_AssignmentFormatGrader(self):
-        homeworkGrader = graders.AssignmentFormatGrader("Homework", 12, 2)
-        noDropGrader = graders.AssignmentFormatGrader("Homework", 12, 0)
-        #Even though the minimum number is 3, this should grade correctly when 7 assignments are found
-        overflowGrader = graders.AssignmentFormatGrader("Lab", 3, 2)
-        labGrader = graders.AssignmentFormatGrader("Lab", 7, 3)
-
-        #Test the grading of an empty gradesheet
-        for graded in [homeworkGrader.grade(self.empty_gradesheet),
-                        noDropGrader.grade(self.empty_gradesheet),
-                        homeworkGrader.grade(self.incomplete_gradesheet),
-                        noDropGrader.grade(self.incomplete_gradesheet)]:
-            self.assertAlmostEqual(graded['percent'], 0.0)
-            #Make sure the breakdown includes 12 sections, plus one summary
-            self.assertEqual(len(graded['section_breakdown']), 12 + 1)
-
-        graded = homeworkGrader.grade(self.test_gradesheet)
-        self.assertAlmostEqual(graded['percent'], 0.11)  # 100% + 10% / 10 assignments
-        self.assertEqual(len(graded['section_breakdown']), 12 + 1)
-
-        graded = noDropGrader.grade(self.test_gradesheet)
-        self.assertAlmostEqual(graded['percent'], 0.0916666666666666)  # 100% + 10% / 12 assignments
-        self.assertEqual(len(graded['section_breakdown']), 12 + 1)
-
-        graded = overflowGrader.grade(self.test_gradesheet)
-        self.assertAlmostEqual(graded['percent'], 0.8880952380952382)  # 100% + 10% / 5 assignments
-        self.assertEqual(len(graded['section_breakdown']), 7 + 1)
-
-        graded = labGrader.grade(self.test_gradesheet)
-        self.assertAlmostEqual(graded['percent'], 0.9226190476190477)
-        self.assertEqual(len(graded['section_breakdown']), 7 + 1)
-
-    def test_WeightedSubsectionsGrader(self):
-        #First, a few sub graders
-        homeworkGrader = graders.AssignmentFormatGrader("Homework", 12, 2)
-        labGrader = graders.AssignmentFormatGrader("Lab", 7, 3)
-        midtermGrader = graders.SingleSectionGrader("Midterm", "Midterm Exam")
-
-        weightedGrader = graders.WeightedSubsectionsGrader([(homeworkGrader, homeworkGrader.category, 0.25), (labGrader, labGrader.category, 0.25),
-        (midtermGrader, midtermGrader.category, 0.5)])
-
-        overOneWeightsGrader = graders.WeightedSubsectionsGrader([(homeworkGrader, homeworkGrader.category, 0.5), (labGrader, labGrader.category, 0.5),
-        (midtermGrader, midtermGrader.category, 0.5)])
-
-        #The midterm should have all weight on this one
-        zeroWeightsGrader = graders.WeightedSubsectionsGrader([(homeworkGrader, homeworkGrader.category, 0.0), (labGrader, labGrader.category, 0.0),
-        (midtermGrader, midtermGrader.category, 0.5)])
-
-        #This should always have a final percent of zero
-        allZeroWeightsGrader = graders.WeightedSubsectionsGrader([(homeworkGrader, homeworkGrader.category, 0.0), (labGrader, labGrader.category, 0.0),
-        (midtermGrader, midtermGrader.category, 0.0)])
-
-        emptyGrader = graders.WeightedSubsectionsGrader([])
-
-        graded = weightedGrader.grade(self.test_gradesheet)
-        self.assertAlmostEqual(graded['percent'], 0.5106547619047619)
-        self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
-        self.assertEqual(len(graded['grade_breakdown']), 3)
-
-        graded = overOneWeightsGrader.grade(self.test_gradesheet)
-        self.assertAlmostEqual(graded['percent'], 0.7688095238095238)
-        self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
-        self.assertEqual(len(graded['grade_breakdown']), 3)
-
-        graded = zeroWeightsGrader.grade(self.test_gradesheet)
-        self.assertAlmostEqual(graded['percent'], 0.2525)
-        self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
-        self.assertEqual(len(graded['grade_breakdown']), 3)
-
-        graded = allZeroWeightsGrader.grade(self.test_gradesheet)
-        self.assertAlmostEqual(graded['percent'], 0.0)
-        self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
-        self.assertEqual(len(graded['grade_breakdown']), 3)
-
-        for graded in [weightedGrader.grade(self.empty_gradesheet),
-                        weightedGrader.grade(self.incomplete_gradesheet),
-                        zeroWeightsGrader.grade(self.empty_gradesheet),
-                        allZeroWeightsGrader.grade(self.empty_gradesheet)]:
-            self.assertAlmostEqual(graded['percent'], 0.0)
-            self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
-            self.assertEqual(len(graded['grade_breakdown']), 3)
-
-        graded = emptyGrader.grade(self.test_gradesheet)
-        self.assertAlmostEqual(graded['percent'], 0.0)
-        self.assertEqual(len(graded['section_breakdown']), 0)
-        self.assertEqual(len(graded['grade_breakdown']), 0)
-
-    def test_graderFromConf(self):
-
-        #Confs always produce a graders.WeightedSubsectionsGrader, so we test this by repeating the test
-        #in test_graders.WeightedSubsectionsGrader, but generate the graders with confs.
-
-        weightedGrader = graders.grader_from_conf([
-            {
-                'type': "Homework",
-                'min_count': 12,
-                'drop_count': 2,
-                'short_label': "HW",
-                'weight': 0.25,
-            },
-            {
-                'type': "Lab",
-                'min_count': 7,
-                'drop_count': 3,
-                'category': "Labs",
-                'weight': 0.25
-            },
-            {
-                'type': "Midterm",
-                'name': "Midterm Exam",
-                'short_label': "Midterm",
-                'weight': 0.5,
-            },
-        ])
-
-        emptyGrader = graders.grader_from_conf([])
-
-        graded = weightedGrader.grade(self.test_gradesheet)
-        self.assertAlmostEqual(graded['percent'], 0.5106547619047619)
-        self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
-        self.assertEqual(len(graded['grade_breakdown']), 3)
-
-        graded = emptyGrader.grade(self.test_gradesheet)
-        self.assertAlmostEqual(graded['percent'], 0.0)
-        self.assertEqual(len(graded['section_breakdown']), 0)
-        self.assertEqual(len(graded['grade_breakdown']), 0)
-
-        #Test that graders can also be used instead of lists of dictionaries
-        homeworkGrader = graders.AssignmentFormatGrader("Homework", 12, 2)
-        homeworkGrader2 = graders.grader_from_conf(homeworkGrader)
-
-        graded = homeworkGrader2.grade(self.test_gradesheet)
-        self.assertAlmostEqual(graded['percent'], 0.11)
-        self.assertEqual(len(graded['section_breakdown']), 12 + 1)
-
-        #TODO: How do we test failure cases? The parser only logs an error when it can't parse something. Maybe it should throw exceptions?
-
-# --------------------------------------------------------------------------
-# Module progress tests
-
-
-class ProgressTest(unittest.TestCase):
-    ''' Test that basic Progress objects work.  A Progress represents a
-    fraction between 0 and 1.
-    '''
-    not_started = Progress(0, 17)
-    part_done = Progress(2, 6)
-    half_done = Progress(3, 6)
-    also_half_done = Progress(1, 2)
-    done = Progress(7, 7)
-
-    def test_create_object(self):
-        # These should work:
-        p = Progress(0, 2)
-        p = Progress(1, 2)
-        p = Progress(2, 2)
-
-        p = Progress(2.5, 5.0)
-        p = Progress(3.7, 12.3333)
-
-        # These shouldn't
-        self.assertRaises(ValueError, Progress, 0, 0)
-        self.assertRaises(ValueError, Progress, 2, 0)
-        self.assertRaises(ValueError, Progress, 1, -2)
-
-        self.assertRaises(TypeError, Progress, 0, "all")
-        # check complex numbers just for the heck of it :)
-        self.assertRaises(TypeError, Progress, 2j, 3)
-
-    def test_clamp(self):
-        self.assertEqual((2, 2), Progress(3, 2).frac())
-        self.assertEqual((0, 2), Progress(-2, 2).frac())
-
-    def test_frac(self):
-        p = Progress(1, 2)
-        (a, b) = p.frac()
-        self.assertEqual(a, 1)
-        self.assertEqual(b, 2)
-
-    def test_percent(self):
-        self.assertEqual(self.not_started.percent(), 0)
-        self.assertAlmostEqual(self.part_done.percent(), 33.33333333333333)
-        self.assertEqual(self.half_done.percent(), 50)
-        self.assertEqual(self.done.percent(), 100)
-
-        self.assertEqual(self.half_done.percent(), self.also_half_done.percent())
-
-    def test_started(self):
-        self.assertFalse(self.not_started.started())
-
-        self.assertTrue(self.part_done.started())
-        self.assertTrue(self.half_done.started())
-        self.assertTrue(self.done.started())
-
-    def test_inprogress(self):
-        # only true if working on it
-        self.assertFalse(self.done.inprogress())
-        self.assertFalse(self.not_started.inprogress())
-
-        self.assertTrue(self.part_done.inprogress())
-        self.assertTrue(self.half_done.inprogress())
-
-    def test_done(self):
-        self.assertTrue(self.done.done())
-        self.assertFalse(self.half_done.done())
-        self.assertFalse(self.not_started.done())
-
-    def test_str(self):
-        self.assertEqual(str(self.not_started), "0/17")
-        self.assertEqual(str(self.part_done), "2/6")
-        self.assertEqual(str(self.done), "7/7")
-
-    def test_ternary_str(self):
-        self.assertEqual(self.not_started.ternary_str(), "none")
-        self.assertEqual(self.half_done.ternary_str(), "in_progress")
-        self.assertEqual(self.done.ternary_str(), "done")
-
-    def test_to_js_status(self):
-        '''Test the Progress.to_js_status_str() method'''
-
-        self.assertEqual(Progress.to_js_status_str(self.not_started), "none")
-        self.assertEqual(Progress.to_js_status_str(self.half_done), "in_progress")
-        self.assertEqual(Progress.to_js_status_str(self.done), "done")
-        self.assertEqual(Progress.to_js_status_str(None), "NA")
-
-    def test_to_js_detail_str(self):
-        '''Test the Progress.to_js_detail_str() method'''
-        f = Progress.to_js_detail_str
-        for p in (self.not_started, self.half_done, self.done):
-            self.assertEqual(f(p), str(p))
-        # But None should be encoded as NA
-        self.assertEqual(f(None), "NA")
-
-    def test_add(self):
-        '''Test the Progress.add_counts() method'''
-        p = Progress(0, 2)
-        p2 = Progress(1, 3)
-        p3 = Progress(2, 5)
-        pNone = None
-        add = lambda a, b: Progress.add_counts(a, b).frac()
-
-        self.assertEqual(add(p, p), (0, 4))
-        self.assertEqual(add(p, p2), (1, 5))
-        self.assertEqual(add(p2, p3), (3, 8))
-
-        self.assertEqual(add(p2, pNone), p2.frac())
-        self.assertEqual(add(pNone, p2), p2.frac())
-
-    def test_equality(self):
-        '''Test that comparing Progress objects for equality
-        works correctly.'''
-        p = Progress(1, 2)
-        p2 = Progress(2, 4)
-        p3 = Progress(1, 2)
-        self.assertTrue(p == p3)
-        self.assertFalse(p == p2)
-
-        # Check != while we're at it
-        self.assertTrue(p != p2)
-        self.assertFalse(p != p3)
-
-
-class ModuleProgressTest(unittest.TestCase):
-    ''' Test that get_progress() does the right thing for the different modules
-    '''
-    def test_xmodule_default(self):
-        '''Make sure default get_progress exists, returns None'''
-        xm = x_module.XModule(i4xs, 'a://b/c/d/e', None, {})
-        p = xm.get_progress()
-        self.assertEqual(p, None)

common/lib/xmodule/xmodule/tests/test_graders.py

+"""Grading tests"""
+import unittest
+
+from xmodule import graders
+from xmodule.graders import Score, aggregate_scores
+
+class GradesheetTest(unittest.TestCase):
+
+    def test_weighted_grading(self):
+        scores = []
+        Score.__sub__ = lambda me, other: (me.earned - other.earned) + (me.possible - other.possible)
+
+        all, graded = aggregate_scores(scores)
+        self.assertEqual(all, Score(earned=0, possible=0, graded=False, section="summary"))
+        self.assertEqual(graded, Score(earned=0, possible=0, graded=True, section="summary"))
+
+        scores.append(Score(earned=0, possible=5, graded=False, section="summary"))
+        all, graded = aggregate_scores(scores)
+        self.assertEqual(all, Score(earned=0, possible=5, graded=False, section="summary"))
+        self.assertEqual(graded, Score(earned=0, possible=0, graded=True, section="summary"))
+
+        scores.append(Score(earned=3, possible=5, graded=True, section="summary"))
+        all, graded = aggregate_scores(scores)
+        self.assertAlmostEqual(all, Score(earned=3, possible=10, graded=False, section="summary"))
+        self.assertAlmostEqual(graded, Score(earned=3, possible=5, graded=True, section="summary"))
+
+        scores.append(Score(earned=2, possible=5, graded=True, section="summary"))
+        all, graded = aggregate_scores(scores)
+        self.assertAlmostEqual(all, Score(earned=5, possible=15, graded=False, section="summary"))
+        self.assertAlmostEqual(graded, Score(earned=5, possible=10, graded=True, section="summary"))
+
+
+class GraderTest(unittest.TestCase):
+
+    empty_gradesheet = {
+    }
+
+    incomplete_gradesheet = {
+        'Homework': [],
+        'Lab': [],
+        'Midterm': [],
+    }
+
+    test_gradesheet = {
+        'Homework': [Score(earned=2, possible=20.0, graded=True, section='hw1'),
+              Score(earned=16, possible=16.0, graded=True, section='hw2')],
+              #The dropped scores should be from the assignments that don't exist yet
+
+        'Lab': [Score(earned=1, possible=2.0, graded=True, section='lab1'),  # Dropped
+             Score(earned=1, possible=1.0, graded=True, section='lab2'),
+             Score(earned=1, possible=1.0, graded=True, section='lab3'),
+             Score(earned=5, possible=25.0, graded=True, section='lab4'),  # Dropped
+             Score(earned=3, possible=4.0, graded=True, section='lab5'),  # Dropped
+             Score(earned=6, possible=7.0, graded=True, section='lab6'),
+             Score(earned=5, possible=6.0, graded=True, section='lab7')],
+
+        'Midterm': [Score(earned=50.5, possible=100, graded=True, section="Midterm Exam"), ],
+    }
+
+    def test_SingleSectionGrader(self):
+        midtermGrader = graders.SingleSectionGrader("Midterm", "Midterm Exam")
+        lab4Grader = graders.SingleSectionGrader("Lab", "lab4")
+        badLabGrader = graders.SingleSectionGrader("Lab", "lab42")
+
+        for graded in [midtermGrader.grade(self.empty_gradesheet),
+                        midtermGrader.grade(self.incomplete_gradesheet),
+                        badLabGrader.grade(self.test_gradesheet)]:
+            self.assertEqual(len(graded['section_breakdown']), 1)
+            self.assertEqual(graded['percent'], 0.0)
+
+        graded = midtermGrader.grade(self.test_gradesheet)
+        self.assertAlmostEqual(graded['percent'], 0.505)
+        self.assertEqual(len(graded['section_breakdown']), 1)
+
+        graded = lab4Grader.grade(self.test_gradesheet)
+        self.assertAlmostEqual(graded['percent'], 0.2)
+        self.assertEqual(len(graded['section_breakdown']), 1)
+
+    def test_AssignmentFormatGrader(self):
+        homeworkGrader = graders.AssignmentFormatGrader("Homework", 12, 2)
+        noDropGrader = graders.AssignmentFormatGrader("Homework", 12, 0)
+        #Even though the minimum number is 3, this should grade correctly when 7 assignments are found
+        overflowGrader = graders.AssignmentFormatGrader("Lab", 3, 2)
+        labGrader = graders.AssignmentFormatGrader("Lab", 7, 3)
+
+        #Test the grading of an empty gradesheet
+        for graded in [homeworkGrader.grade(self.empty_gradesheet),
+                        noDropGrader.grade(self.empty_gradesheet),
+                        homeworkGrader.grade(self.incomplete_gradesheet),
+                        noDropGrader.grade(self.incomplete_gradesheet)]:
+            self.assertAlmostEqual(graded['percent'], 0.0)
+            #Make sure the breakdown includes 12 sections, plus one summary
+            self.assertEqual(len(graded['section_breakdown']), 12 + 1)
+
+        graded = homeworkGrader.grade(self.test_gradesheet)
+        self.assertAlmostEqual(graded['percent'], 0.11)  # 100% + 10% / 10 assignments
+        self.assertEqual(len(graded['section_breakdown']), 12 + 1)
+
+        graded = noDropGrader.grade(self.test_gradesheet)
+        self.assertAlmostEqual(graded['percent'], 0.0916666666666666)  # 100% + 10% / 12 assignments
+        self.assertEqual(len(graded['section_breakdown']), 12 + 1)
+
+        graded = overflowGrader.grade(self.test_gradesheet)
+        self.assertAlmostEqual(graded['percent'], 0.8880952380952382)  # 100% + 10% / 5 assignments
+        self.assertEqual(len(graded['section_breakdown']), 7 + 1)
+
+        graded = labGrader.grade(self.test_gradesheet)
+        self.assertAlmostEqual(graded['percent'], 0.9226190476190477)
+        self.assertEqual(len(graded['section_breakdown']), 7 + 1)
+
+    def test_WeightedSubsectionsGrader(self):
+        #First, a few sub graders
+        homeworkGrader = graders.AssignmentFormatGrader("Homework", 12, 2)
+        labGrader = graders.AssignmentFormatGrader("Lab", 7, 3)
+        midtermGrader = graders.SingleSectionGrader("Midterm", "Midterm Exam")
+
+        weightedGrader = graders.WeightedSubsectionsGrader([(homeworkGrader, homeworkGrader.category, 0.25),
+                                                            (labGrader, labGrader.category, 0.25),
+        (midtermGrader, midtermGrader.category, 0.5)])
+
+        overOneWeightsGrader = graders.WeightedSubsectionsGrader([(homeworkGrader, homeworkGrader.category, 0.5),
+                                                                  (labGrader, labGrader.category, 0.5),
+        (midtermGrader, midtermGrader.category, 0.5)])
+
+        #The midterm should have all weight on this one
+        zeroWeightsGrader = graders.WeightedSubsectionsGrader([(homeworkGrader, homeworkGrader.category, 0.0),
+                                                               (labGrader, labGrader.category, 0.0),
+        (midtermGrader, midtermGrader.category, 0.5)])
+
+        #This should always have a final percent of zero
+        allZeroWeightsGrader = graders.WeightedSubsectionsGrader([(homeworkGrader, homeworkGrader.category, 0.0),
+                                                                  (labGrader, labGrader.category, 0.0),
+        (midtermGrader, midtermGrader.category, 0.0)])
+
+        emptyGrader = graders.WeightedSubsectionsGrader([])
+
+        graded = weightedGrader.grade(self.test_gradesheet)
+        self.assertAlmostEqual(graded['percent'], 0.5106547619047619)
+        self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
+        self.assertEqual(len(graded['grade_breakdown']), 3)
+
+        graded = overOneWeightsGrader.grade(self.test_gradesheet)
+        self.assertAlmostEqual(graded['percent'], 0.7688095238095238)
+        self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
+        self.assertEqual(len(graded['grade_breakdown']), 3)
+
+        graded = zeroWeightsGrader.grade(self.test_gradesheet)
+        self.assertAlmostEqual(graded['percent'], 0.2525)
+        self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
+        self.assertEqual(len(graded['grade_breakdown']), 3)
+
+        graded = allZeroWeightsGrader.grade(self.test_gradesheet)
+        self.assertAlmostEqual(graded['percent'], 0.0)
+        self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
+        self.assertEqual(len(graded['grade_breakdown']), 3)
+
+        for graded in [weightedGrader.grade(self.empty_gradesheet),
+                        weightedGrader.grade(self.incomplete_gradesheet),
+                        zeroWeightsGrader.grade(self.empty_gradesheet),
+                        allZeroWeightsGrader.grade(self.empty_gradesheet)]:
+            self.assertAlmostEqual(graded['percent'], 0.0)
+            self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
+            self.assertEqual(len(graded['grade_breakdown']), 3)
+
+        graded = emptyGrader.grade(self.test_gradesheet)
+        self.assertAlmostEqual(graded['percent'], 0.0)
+        self.assertEqual(len(graded['section_breakdown']), 0)
+        self.assertEqual(len(graded['grade_breakdown']), 0)
+
+    def test_graderFromConf(self):
+
+        #Confs always produce a graders.WeightedSubsectionsGrader, so we test this by repeating the test
+        #in test_graders.WeightedSubsectionsGrader, but generate the graders with confs.
+
+        weightedGrader = graders.grader_from_conf([
+            {
+                'type': "Homework",
+                'min_count': 12,
+                'drop_count': 2,
+                'short_label': "HW",
+                'weight': 0.25,
+            },
+            {
+                'type': "Lab",
+                'min_count': 7,
+                'drop_count': 3,
+                'category': "Labs",
+                'weight': 0.25
+            },
+            {
+                'type': "Midterm",
+                'name': "Midterm Exam",
+                'short_label': "Midterm",
+                'weight': 0.5,
+            },
+        ])
+
+        emptyGrader = graders.grader_from_conf([])
+
+        graded = weightedGrader.grade(self.test_gradesheet)
+        self.assertAlmostEqual(graded['percent'], 0.5106547619047619)
+        self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
+        self.assertEqual(len(graded['grade_breakdown']), 3)
+
+        graded = emptyGrader.grade(self.test_gradesheet)
+        self.assertAlmostEqual(graded['percent'], 0.0)
+        self.assertEqual(len(graded['section_breakdown']), 0)
+        self.assertEqual(len(graded['grade_breakdown']), 0)
+
+        #Test that graders can also be used instead of lists of dictionaries
+        homeworkGrader = graders.AssignmentFormatGrader("Homework", 12, 2)
+        homeworkGrader2 = graders.grader_from_conf(homeworkGrader)
+
+        graded = homeworkGrader2.grade(self.test_gradesheet)
+        self.assertAlmostEqual(graded['percent'], 0.11)
+        self.assertEqual(len(graded['section_breakdown']), 12 + 1)
+
+        #TODO: How do we test failure cases? The parser only logs an error when
+        #it can't parse something. Maybe it should throw exceptions?
+

common/lib/xmodule/xmodule/tests/test_progress.py

+"""Module progress tests"""
+
+import unittest
+
+from xmodule.progress import Progress
+from xmodule import x_module
+
+from . import i4xs
+
+class ProgressTest(unittest.TestCase):
+    ''' Test that basic Progress objects work.  A Progress represents a
+    fraction between 0 and 1.
+    '''
+    not_started = Progress(0, 17)
+    part_done = Progress(2, 6)
+    half_done = Progress(3, 6)
+    also_half_done = Progress(1, 2)
+    done = Progress(7, 7)
+
+    def test_create_object(self):
+        # These should work:
+        p = Progress(0, 2)
+        p = Progress(1, 2)
+        p = Progress(2, 2)
+
+        p = Progress(2.5, 5.0)
+        p = Progress(3.7, 12.3333)
+
+        # These shouldn't
+        self.assertRaises(ValueError, Progress, 0, 0)
+        self.assertRaises(ValueError, Progress, 2, 0)
+        self.assertRaises(ValueError, Progress, 1, -2)
+
+        self.assertRaises(TypeError, Progress, 0, "all")
+        # check complex numbers just for the heck of it :)
+        self.assertRaises(TypeError, Progress, 2j, 3)
+
+    def test_clamp(self):
+        self.assertEqual((2, 2), Progress(3, 2).frac())
+        self.assertEqual((0, 2), Progress(-2, 2).frac())
+
+    def test_frac(self):
+        p = Progress(1, 2)
+        (a, b) = p.frac()
+        self.assertEqual(a, 1)
+        self.assertEqual(b, 2)
+
+    def test_percent(self):
+        self.assertEqual(self.not_started.percent(), 0)
+        self.assertAlmostEqual(self.part_done.percent(), 33.33333333333333)
+        self.assertEqual(self.half_done.percent(), 50)
+        self.assertEqual(self.done.percent(), 100)
+
+        self.assertEqual(self.half_done.percent(), self.also_half_done.percent())
+
+    def test_started(self):
+        self.assertFalse(self.not_started.started())
+
+        self.assertTrue(self.part_done.started())
+        self.assertTrue(self.half_done.started())
+        self.assertTrue(self.done.started())
+
+    def test_inprogress(self):
+        # only true if working on it
+        self.assertFalse(self.done.inprogress())
+        self.assertFalse(self.not_started.inprogress())
+
+        self.assertTrue(self.part_done.inprogress())
+        self.assertTrue(self.half_done.inprogress())
+
+    def test_done(self):
+        self.assertTrue(self.done.done())
+        self.assertFalse(self.half_done.done())
+        self.assertFalse(self.not_started.done())
+
+    def test_str(self):
+        self.assertEqual(str(self.not_started), "0/17")
+        self.assertEqual(str(self.part_done), "2/6")
+        self.assertEqual(str(self.done), "7/7")
+
+    def test_ternary_str(self):
+        self.assertEqual(self.not_started.ternary_str(), "none")
+        self.assertEqual(self.half_done.ternary_str(), "in_progress")
+        self.assertEqual(self.done.ternary_str(), "done")
+
+    def test_to_js_status(self):
+        '''Test the Progress.to_js_status_str() method'''
+
+        self.assertEqual(Progress.to_js_status_str(self.not_started), "none")
+        self.assertEqual(Progress.to_js_status_str(self.half_done), "in_progress")
+        self.assertEqual(Progress.to_js_status_str(self.done), "done")
+        self.assertEqual(Progress.to_js_status_str(None), "NA")
+
+    def test_to_js_detail_str(self):
+        '''Test the Progress.to_js_detail_str() method'''
+        f = Progress.to_js_detail_str
+        for p in (self.not_started, self.half_done, self.done):
+            self.assertEqual(f(p), str(p))
+        # But None should be encoded as NA
+        self.assertEqual(f(None), "NA")
+
+    def test_add(self):
+        '''Test the Progress.add_counts() method'''
+        p = Progress(0, 2)
+        p2 = Progress(1, 3)
+        p3 = Progress(2, 5)
+        pNone = None
+        add = lambda a, b: Progress.add_counts(a, b).frac()
+
+        self.assertEqual(add(p, p), (0, 4))
+        self.assertEqual(add(p, p2), (1, 5))
+        self.assertEqual(add(p2, p3), (3, 8))
+
+        self.assertEqual(add(p2, pNone), p2.frac())
+        self.assertEqual(add(pNone, p2), p2.frac())
+
+    def test_equality(self):
+        '''Test that comparing Progress objects for equality
+        works correctly.'''
+        p = Progress(1, 2)
+        p2 = Progress(2, 4)
+        p3 = Progress(1, 2)
+        self.assertTrue(p == p3)
+        self.assertFalse(p == p2)
+
+        # Check != while we're at it
+        self.assertTrue(p != p2)
+        self.assertFalse(p != p3)
+
+
+class ModuleProgressTest(unittest.TestCase):
+    ''' Test that get_progress() does the right thing for the different modules
+    '''
+    def test_xmodule_default(self):
+        '''Make sure default get_progress exists, returns None'''
+        xm = x_module.XModule(i4xs, 'a://b/c/d/e', None, {})
+        p = xm.get_progress()
+        self.assertEqual(p, None)

common/static/js/capa/README

+These files really should be in the capa module, but we don't have a way to load js from there at the moment.  (TODO)

common/static/js/capa/chemical_equation_preview.js

+(function () {
+    update = function() {
+        function create_handler(saved_div) {
+            return (function(response) {
+                if (response.error) {
+                    saved_div.html("<span class='error'>" + response.error + "</span>");
+                } else {
+                    saved_div.html(response.preview);
+                }
+            });
+        }
+
+        prev_id = "#" + this.id + "_preview";
+        preview_div = $(prev_id)
+
+        $.get("/preview/chemcalc/", {"formula" : this.value}, create_handler(preview_div));
+    }
+
+    inputs = $('.chemicalequationinput input');
+    // update on load
+    inputs.each(update); 
+    // and on every change
+    inputs.bind("input", update);
+}).call(this);

lms/djangoapps/courseware/grades.py

@@ -329,9 +329,15 @@ def progress_summary(student, request, course, student_module_cache):
 def get_score(course_id, user, problem_descriptor, module_creator, student_module_cache):
     """
     Return the score for a user on a problem, as a tuple (correct, total).
+    e.g. (5,7) if you got 5 out of 7 points.
+
+    If this problem doesn't have a score, or we couldn't load it, returns (None,
+    None).
 
     user: a Student object
-    problem: an XModule
+    problem_descriptor: an XModuleDescriptor
+    module_creator: a function that takes a descriptor, and returns the corresponding XModule for this user.
+           Can return None if user doesn't have access, or if something else went wrong.
     cache: A StudentModuleCache
     """
     if not (problem_descriptor.stores_state and problem_descriptor.has_score):
@@ -339,14 +345,16 @@ def get_score(course_id, user, problem_descriptor, module_creator, student_modul
         return (None, None)
 
     correct = 0.0
-    
+
     instance_module = student_module_cache.lookup(
         course_id, problem_descriptor.category, problem_descriptor.location.url())
-    
+
     if not instance_module:
         # If the problem was not in the cache, we need to instantiate the problem.
-        # Otherwise, the max score (cached in instance_module) won't be available 
+        # Otherwise, the max score (cached in instance_module) won't be available
         problem = module_creator(problem_descriptor)
+        if problem is None:
+            return (None, None)
         instance_module = get_instance_module(course_id, user, problem, student_module_cache)
 
     # If this problem is ungraded/ungradable, bail
@@ -361,7 +369,7 @@ def get_score(course_id, user, problem_descriptor, module_creator, student_modul
         weight = getattr(problem_descriptor, 'weight', None)
         if weight is not None:
             if total == 0:
-                log.exception("Cannot reweight a problem with zero weight. Problem: " + str(instance_module))
+                log.exception("Cannot reweight a problem with zero total points. Problem: " + str(instance_module))
                 return (correct, total)
             correct = correct * weight / total
             total = weight

lms/djangoapps/courseware/module_render.py

 import hashlib
 import json
 import logging
+import pyparsing
 import sys
 
 from django.conf import settings
@@ -13,6 +14,7 @@ from django.views.decorators.csrf import csrf_exempt
 from requests.auth import HTTPBasicAuth
 
 from capa.xqueue_interface import XQueueInterface
+from capa.chem import chemcalc
 from courseware.access import has_access
 from mitxmako.shortcuts import render_to_string
 from models import StudentModule, StudentModuleCache
@@ -471,3 +473,42 @@ def modx_dispatch(request, dispatch, location, course_id):
 
     # Return whatever the module wanted to return to the client/caller
     return HttpResponse(ajax_return)
+
+def preview_chemcalc(request):
+    """
+    Render an html preview of a chemical formula or equation.  The fact that
+    this is here is a bit of hack.  See the note in lms/urls.py about why it's
+    here. (Victor is to blame.)
+
+    request should be a GET, with a key 'formula' and value 'some formula string'.
+
+    Returns a json dictionary:
+    {
+       'preview' : 'the-preview-html' or ''
+       'error' : 'the-error' or ''
+    }
+    """
+    if request.method != "GET":
+        raise Http404
+
+    result = {'preview': '',
+              'error': '' }
+    formula = request.GET.get('formula')
+    if formula is None:
+        result['error'] = "No formula specified."
+
+        return HttpResponse(json.dumps(result))
+
+    try:
+        result['preview'] = chemcalc.render_to_html(formula)
+    except pyparsing.ParseException as p:
+        result['error'] = "Couldn't parse formula: {0}".format(p)
+    except Exception:
+        # this is unexpected, so log
+        log.warning("Error while previewing chemical formula", exc_info=True)
+        result['error'] = "Error while rendering preview"
+
+    return HttpResponse(json.dumps(result))
+
+
+

lms/djangoapps/courseware/tabs.py

@@ -15,6 +15,8 @@ import logging
 from django.conf import settings
 from django.core.urlresolvers import reverse
 
+from fs.errors import ResourceNotFoundError
+
 from courseware.access import has_access
 from static_replace import replace_urls
 
@@ -266,7 +268,8 @@ def get_static_tab_contents(course, tab):
             try:
                 with fs.open(p) as tabfile:
                     # TODO: redundant with module_render.py.  Want to be helper methods in static_replace or something.
-                    contents = replace_urls(tabfile.read(), course.metadata['data_dir'])
+                    text = tabfile.read().decode('utf-8')
+                    contents = replace_urls(text, course.metadata['data_dir'])
                     return replace_urls(contents, staticfiles_prefix='/courses/'+course.id, replace_prefix='/course/')
             except (ResourceNotFoundError) as err:
                 log.exception("Couldn't load tab contents from '{0}': {1}".format(p, err))

lms/djangoapps/courseware/views.py

@@ -356,7 +356,7 @@ def static_tab(request, course_id, tab_slug):
     tab = tabs.get_static_tab_by_slug(course, tab_slug)
     if tab is None:
         raise Http404
-    
+
     contents = tabs.get_static_tab_contents(course, tab)
     if contents is None:
         raise Http404
@@ -415,6 +415,16 @@ def course_about(request, course_id):
 
 @ensure_csrf_cookie
 @cache_if_anonymous
+def static_university_profile(request, org_id):
+    """
+    Return the profile for the particular org_id that does not have any courses.
+    """
+    template_file = "university_profile/{0}.html".format(org_id).lower()
+    context = dict(courses=[], org_id=org_id)
+    return render_to_response(template_file, context)
+
+@ensure_csrf_cookie
+@cache_if_anonymous
 def university_profile(request, org_id):
     """
     Return the profile for the particular org_id.  404 if it's not valid.
@@ -485,7 +495,7 @@ def progress(request, course_id, student_id=None):
     courseware_summary = grades.progress_summary(student, request, course,
                                                  student_module_cache)
     grade_summary = grades.grade(student, request, course, student_module_cache)
-    
+
     if courseware_summary is None:
         #This means the student didn't have access to the course (which the instructor requested)
         raise Http404
@@ -498,4 +508,3 @@ def progress(request, course_id, student_id=None):
     context.update()
 
     return render_to_response('courseware/progress.html', context)
-

lms/djangoapps/django_comment_client/management/commands/seed_permissions_roles.py

@@ -14,6 +14,7 @@ class Command(BaseCommand):
         course_id = args[0]
         administrator_role = Role.objects.get_or_create(name="Administrator", course_id=course_id)[0]
         moderator_role = Role.objects.get_or_create(name="Moderator", course_id=course_id)[0]
+        community_ta_role = Role.objects.get_or_create(name="Community TA", course_id=course_id)[0]
         student_role = Role.objects.get_or_create(name="Student", course_id=course_id)[0]
 
         for per in ["vote", "update_thread", "follow_thread", "unfollow_thread",
@@ -30,4 +31,7 @@ class Command(BaseCommand):
 
         moderator_role.inherit_permissions(student_role)
 
+        # For now, Community TA == Moderator, except for the styling.
+        community_ta_role.inherit_permissions(moderator_role)
+
         administrator_role.inherit_permissions(moderator_role)

lms/djangoapps/instructor/management/commands/dump_grades.py

+#!/usr/bin/python
+#
+# django management command: dump grades to csv files
+# for use by batch processes
+
+import os, sys, string
+import datetime
+import json
+
+from instructor.views import *
+from courseware.courses import get_course_by_id
+from xmodule.modulestore.django import modulestore
+
+from django.conf import settings
+from django.core.management.base import BaseCommand
+
+class Command(BaseCommand):
+    help = "dump grades to CSV file.  Usage: dump_grades course_id_or_dir filename dump_type\n"
+    help += "   course_id_or_dir: either course_id or course_dir\n"
+    help += "   filename: where the output CSV is to be stored\n"
+    # help += "   start_date: end date as M/D/Y H:M (defaults to end of available data)"
+    help += "   dump_type: 'all' or 'raw' (see instructor dashboard)"
+
+    def handle(self, *args, **options):
+
+        # current grading logic and data schema doesn't handle dates
+        # datetime.strptime("21/11/06 16:30", "%m/%d/%y %H:%M")
+
+        print "args = ", args
+
+        course_id = 'MITx/8.01rq_MW/Classical_Mechanics_Reading_Questions_Fall_2012_MW_Section'
+        fn = "grades.csv"
+        get_raw_scores = False
+
+        if len(args)>0:
+            course_id = args[0]
+        if len(args)>1:
+            fn = args[1]
+        if len(args)>2:
+            get_raw_scores = args[2].lower()=='raw'
+
+        request = self.DummyRequest()
+        try:
+            course = get_course_by_id(course_id)
+        except Exception as err:
+            if course_id in modulestore().courses:
+                course = modulestore().courses[course_id]
+            else:
+                print "-----------------------------------------------------------------------------"
+                print "Sorry, cannot find course %s" % course_id
+                print "Please provide a course ID or course data directory name, eg content-mit-801rq"
+                return
+
+        print "-----------------------------------------------------------------------------"
+        print "Dumping grades from %s to file %s (get_raw_scores=%s)" % (course.id, fn, get_raw_scores)
+        datatable = get_student_grade_summary_data(request, course, course.id, get_raw_scores=get_raw_scores)
+    
+        fp = open(fn,'w')
+    
+        writer = csv.writer(fp, dialect='excel', quotechar='"', quoting=csv.QUOTE_ALL)
+        writer.writerow(datatable['header'])
+        for datarow in datatable['data']:
+            encoded_row = [unicode(s).encode('utf-8') for s in datarow]
+            writer.writerow(encoded_row)
+    
+        fp.close()
+        print "Done: %d records dumped" % len(datatable['data'])
+
+    class DummyRequest(object):
+        META = {}
+        def __init__(self):
+            return
+        def get_host(self):
+            return 'edx.mit.edu'
+        def is_secure(self):
+            return False
+
+    
+        

lms/djangoapps/licenses/management/commands/generate_serial_numbers.py

+import os.path
+from uuid import uuid4
+from optparse import make_option
+
+from django.utils.html import escape
+from django.core.management.base import BaseCommand, CommandError
+
+from xmodule.modulestore.django import modulestore
+
+from licenses.models import CourseSoftware, UserLicense
+
+
+class Command(BaseCommand):
+    help = """Generate random serial numbers for software used in a course.
+
+    Usage: generate_serial_numbers <course_id> <software_name> <count>
+
+    <count> is the number of numbers to generate.
+
+    Example:
+
+       import_serial_numbers MITx/6.002x/2012_Fall matlab 100
+
+    """
+    args = "course_id software_id count"
+
+    def handle(self, *args, **options):
+        """
+        """
+        course_id, software_name, count = self._parse_arguments(args)
+
+        software, _ = CourseSoftware.objects.get_or_create(course_id=course_id,
+                                                           name=software_name)
+        self._generate_serials(software, count)
+
+    def _parse_arguments(self, args):
+        if len(args) != 3:
+            raise CommandError("Incorrect number of arguments")
+
+        course_id = args[0]
+        courses = modulestore().get_courses()
+        known_course_ids = set(c.id for c in courses)
+
+        if course_id not in known_course_ids:
+            raise CommandError("Unknown course_id")
+
+        software_name = escape(args[1].lower())
+
+        try:
+            count = int(args[2])
+        except ValueError:
+            raise CommandError("Invalid <count> argument.")
+
+        return course_id, software_name, count
+
+    def _generate_serials(self, software, count):
+        print "Generating {0} serials".format(count)
+
+        # add serial numbers them to the database
+        for _ in xrange(count):
+            serial = str(uuid4())
+            license = UserLicense(software=software, serial=serial)
+            license.save()
+
+        print "{0} new serial numbers generated.".format(count)

lms/djangoapps/licenses/management/commands/import_serial_numbers.py

+import os.path
+from optparse import make_option
+
+from django.utils.html import escape
+from django.core.management.base import BaseCommand, CommandError
+
+from xmodule.modulestore.django import modulestore
+
+from licenses.models import CourseSoftware, UserLicense
+
+
+class Command(BaseCommand):
+    help = """Imports serial numbers for software used in a course.
+
+    Usage: import_serial_numbers <course_id> <software_name> <file>
+
+    <file> is a text file that list one available serial number per line.
+
+    Example:
+
+       import_serial_numbers MITx/6.002x/2012_Fall matlab serials.txt
+
+    """
+    args = "course_id software_id serial_file"
+
+    def handle(self, *args, **options):
+        """
+        """
+        course_id, software_name, filename = self._parse_arguments(args)
+
+        software, _ = CourseSoftware.objects.get_or_create(course_id=course_id,
+                                                           name=software_name)
+        self._import_serials(software, filename)
+
+    def _parse_arguments(self, args):
+        if len(args) != 3:
+            raise CommandError("Incorrect number of arguments")
+
+        course_id = args[0]
+        courses = modulestore().get_courses()
+        known_course_ids = set(c.id for c in courses)
+
+        if course_id not in known_course_ids:
+            raise CommandError("Unknown course_id")
+
+        software_name = escape(args[1].lower())
+
+        filename = os.path.abspath(args[2])
+        if not os.path.exists(filename):
+            raise CommandError("Cannot find filename {0}".format(filename))
+
+        return course_id, software_name, filename
+
+    def _import_serials(self, software, filename):
+        print "Importing serial numbers for {0}.".format(software)
+
+        serials = set(unicode(l.strip()) for l in open(filename))
+
+        # remove serial numbers we already have
+        licenses = UserLicense.objects.filter(software=software)
+        known_serials = set(l.serial for l in licenses)
+        if known_serials:
+            serials = serials.difference(known_serials)
+
+        # add serial numbers them to the database
+        for serial in serials:
+            license = UserLicense(software=software, serial=serial)
+            license.save()
+
+        print "{0} new serial numbers imported.".format(len(serials))

lms/djangoapps/licenses/migrations/0001_initial.py

+# -*- coding: utf-8 -*-
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding model 'CourseSoftware'
+        db.create_table('licenses_coursesoftware', (
+            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('name', self.gf('django.db.models.fields.CharField')(max_length=255)),
+            ('full_name', self.gf('django.db.models.fields.CharField')(max_length=255)),
+            ('url', self.gf('django.db.models.fields.CharField')(max_length=255)),
+            ('course_id', self.gf('django.db.models.fields.CharField')(max_length=255)),
+        ))
+        db.send_create_signal('licenses', ['CourseSoftware'])
+
+        # Adding model 'UserLicense'
+        db.create_table('licenses_userlicense', (
+            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('software', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['licenses.CourseSoftware'])),
+            ('user', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['auth.User'], null=True)),
+            ('serial', self.gf('django.db.models.fields.CharField')(max_length=255)),
+        ))
+        db.send_create_signal('licenses', ['UserLicense'])
+
+
+    def backwards(self, orm):
+        # Deleting model 'CourseSoftware'
+        db.delete_table('licenses_coursesoftware')
+
+        # Deleting model 'UserLicense'
+        db.delete_table('licenses_userlicense')
+
+
+    models = {
+        'auth.group': {
+            'Meta': {'object_name': 'Group'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
+            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
+        },
+        'auth.permission': {
+            'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
+            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        },
+        'auth.user': {
+            'Meta': {'object_name': 'User'},
+            'about': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'avatar_type': ('django.db.models.fields.CharField', [], {'default': "'n'", 'max_length': '1'}),
+            'bronze': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
+            'consecutive_days_visit_count': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'country': ('django_countries.fields.CountryField', [], {'max_length': '2', 'blank': 'True'}),
+            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'date_of_birth': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
+            'display_tag_filter_strategy': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
+            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
+            'email_isvalid': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'email_key': ('django.db.models.fields.CharField', [], {'max_length': '32', 'null': 'True'}),
+            'email_tag_filter_strategy': ('django.db.models.fields.SmallIntegerField', [], {'default': '1'}),
+            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'gold': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
+            'gravatar': ('django.db.models.fields.CharField', [], {'max_length': '32'}),
+            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'ignored_tags': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'interesting_tags': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'last_seen': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'location': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
+            'new_response_count': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
+            'questions_per_page': ('django.db.models.fields.SmallIntegerField', [], {'default': '10'}),
+            'real_name': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
+            'reputation': ('django.db.models.fields.PositiveIntegerField', [], {'default': '1'}),
+            'seen_response_count': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'show_country': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'silver': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
+            'status': ('django.db.models.fields.CharField', [], {'default': "'w'", 'max_length': '2'}),
+            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
+            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'}),
+            'website': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'})
+        },
+        'contenttypes.contenttype': {
+            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
+            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
+        },
+        'licenses.coursesoftware': {
+            'Meta': {'object_name': 'CourseSoftware'},
+            'course_id': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'full_name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'url': ('django.db.models.fields.CharField', [], {'max_length': '255'})
+        },
+        'licenses.userlicense': {
+            'Meta': {'object_name': 'UserLicense'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'serial': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'software': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['licenses.CourseSoftware']"}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'null': 'True'})
+        }
+    }
+
+    complete_apps = ['licenses']
\ No newline at end of file

lms/djangoapps/licenses/models.py

+import logging
+
+from django.db import models, transaction
+
+from student.models import User
+
+log = logging.getLogger("mitx.licenses")
+
+
+class CourseSoftware(models.Model):
+    name = models.CharField(max_length=255)
+    full_name = models.CharField(max_length=255)
+    url = models.CharField(max_length=255)
+    course_id = models.CharField(max_length=255)
+
+    def __unicode__(self):
+        return u'{0} for {1}'.format(self.name, self.course_id)
+
+
+class UserLicense(models.Model):
+    software = models.ForeignKey(CourseSoftware, db_index=True)
+    user = models.ForeignKey(User, null=True)
+    serial = models.CharField(max_length=255)
+
+
+def get_courses_licenses(user, courses):
+    course_ids = set(course.id for course in courses)
+    all_software = CourseSoftware.objects.filter(course_id__in=course_ids)
+
+    assigned_licenses = UserLicense.objects.filter(software__in=all_software,
+                                                   user=user)
+
+    licenses = dict.fromkeys(all_software, None)
+    for license in assigned_licenses:
+        licenses[license.software] = license
+
+    log.info(assigned_licenses)
+    log.info(licenses)
+
+    return licenses
+
+
+def get_license(user, software):
+    try:
+        license = UserLicense.objects.get(user=user, software=software)
+    except UserLicense.DoesNotExist:
+        license = None
+
+    return license
+
+
+def get_or_create_license(user, software):
+    license = get_license(user, software)
+    if license is None:
+        license = _create_license(user, software)
+
+    return license
+
+
+def _create_license(user, software):
+    license = None
+
+    try:
+        # find one license that has not been assigned, locking the
+        # table/rows with select_for_update to prevent race conditions
+        with transaction.commit_on_success():
+            selected = UserLicense.objects.select_for_update()
+            license = selected.filter(user__isnull=True, software=software)[0]
+            license.user = user
+            license.save()
+    except IndexError:
+        # there are no free licenses
+        log.error('No serial numbers available for {0}', software)
+        license = None
+        # TODO [rocha]look if someone has unenrolled from the class
+        # and already has a serial number
+
+    return license

lms/djangoapps/licenses/tests.py

+import logging
+from uuid import uuid4
+from random import shuffle
+from tempfile import NamedTemporaryFile
+
+from django.test import TestCase
+from django.core.management import call_command
+
+from models import CourseSoftware, UserLicense
+
+COURSE_1 = 'MITx/6.002x/2012_Fall'
+
+SOFTWARE_1 = 'matlab'
+SOFTWARE_2 = 'stata'
+
+log = logging.getLogger(__name__)
+
+
+class CommandTest(TestCase):
+    def test_import_serial_numbers(self):
+        size = 20
+
+        log.debug('Adding one set of serials for {0}'.format(SOFTWARE_1))
+        with generate_serials_file(size) as temp_file:
+            args = [COURSE_1, SOFTWARE_1, temp_file.name]
+            call_command('import_serial_numbers', *args)
+
+        log.debug('Adding one set of serials for {0}'.format(SOFTWARE_2))
+        with generate_serials_file(size) as temp_file:
+            args = [COURSE_1, SOFTWARE_2, temp_file.name]
+            call_command('import_serial_numbers', *args)
+
+        log.debug('There should be only 2 course-software entries')
+        software_count = CourseSoftware.objects.all().count()
+        self.assertEqual(2, software_count)
+
+        log.debug('We added two sets of {0} serials'.format(size))
+        licenses_count = UserLicense.objects.all().count()
+        self.assertEqual(2 * size, licenses_count)
+
+        log.debug('Adding more serial numbers to {0}'.format(SOFTWARE_1))
+        with generate_serials_file(size) as temp_file:
+            args = [COURSE_1, SOFTWARE_1, temp_file.name]
+            call_command('import_serial_numbers', *args)
+
+        log.debug('There should be still only 2 course-software entries')
+        software_count = CourseSoftware.objects.all().count()
+        self.assertEqual(2, software_count)
+
+        log.debug('Now we should have 3 sets of 20 serials'.format(size))
+        licenses_count = UserLicense.objects.all().count()
+        self.assertEqual(3 * size, licenses_count)
+
+        cs = CourseSoftware.objects.get(pk=1)
+
+        lics = UserLicense.objects.filter(software=cs)[:size]
+        known_serials = list(l.serial for l in lics)
+        known_serials.extend(generate_serials(10))
+
+        shuffle(known_serials)
+
+        log.debug('Adding some new and old serials to {0}'.format(SOFTWARE_1))
+        with NamedTemporaryFile() as f:
+            f.write('\n'.join(known_serials))
+            f.flush()
+            args = [COURSE_1, SOFTWARE_1, f.name]
+            call_command('import_serial_numbers', *args)
+
+        log.debug('Check if we added only the new ones')
+        licenses_count = UserLicense.objects.filter(software=cs).count()
+        self.assertEqual((2 * size) + 10, licenses_count)
+
+
+def generate_serials(size=20):
+    return [str(uuid4()) for _ in range(size)]
+
+
+def generate_serials_file(size=20):
+    serials = generate_serials(size)
+
+    temp_file = NamedTemporaryFile()
+    temp_file.write('\n'.join(serials))
+    temp_file.flush()
+
+    return temp_file

lms/djangoapps/licenses/views.py

+import logging
+import json
+import re
+from urlparse import urlparse
+from collections import namedtuple, defaultdict
+
+
+from mitxmako.shortcuts import render_to_string
+
+from django.contrib.auth.models import User
+from django.http import HttpResponse, Http404
+from django.views.decorators.csrf import requires_csrf_token, csrf_protect
+
+from models import CourseSoftware
+from models import get_courses_licenses, get_or_create_license, get_license
+
+
+log = logging.getLogger("mitx.licenses")
+
+
+License = namedtuple('License', 'software serial')
+
+
+def get_licenses_by_course(user, courses):
+    licenses = get_courses_licenses(user, courses)
+    licenses_by_course = defaultdict(list)
+
+    # create missing licenses and group by course_id
+    for software, license in licenses.iteritems():
+        if license is None:
+            licenses[software] = get_or_create_license(user, software)
+
+        course_id = software.course_id
+        serial = license.serial if license else None
+        licenses_by_course[course_id].append(License(software, serial))
+
+    # render elements
+    data_by_course = {}
+    for course_id, licenses in licenses_by_course.iteritems():
+        context = {'licenses': licenses}
+        template = 'licenses/serial_numbers.html'
+        data_by_course[course_id] = render_to_string(template, context)
+
+    return data_by_course
+
+
+@requires_csrf_token
+def user_software_license(request):
+    if request.method != 'POST' or not request.is_ajax():
+        raise Http404
+
+    # get the course id from the referer
+    url_path = urlparse(request.META.get('HTTP_REFERER', '')).path
+    pattern = re.compile('^/courses/(?P<id>[^/]+/[^/]+/[^/]+)/.*/?$')
+    match = re.match(pattern, url_path)
+
+    if not match:
+        raise Http404
+    course_id = match.groupdict().get('id', '')
+
+    user_id = request.session.get('_auth_user_id')
+    software_name = request.POST.get('software')
+    generate = request.POST.get('generate', False) == 'true'
+
+    try:
+        software = CourseSoftware.objects.get(name=software_name,
+                                              course_id=course_id)
+        print software
+    except CourseSoftware.DoesNotExist:
+        raise Http404
+
+    user = User.objects.get(id=user_id)
+
+    if generate:
+        license = get_or_create_license(user, software)
+    else:
+        license = get_license(user, software)
+
+    if license:
+        response = {'serial': license.serial}
+    else:
+        response = {'error': 'No serial number found'}
+
+    return HttpResponse(json.dumps(response), mimetype='application/json')

lms/envs/common.py

@@ -626,6 +626,7 @@ INSTALLED_APPS = (
     'certificates',
     'instructor',
     'psychometrics',
+    'licenses',
 
     #For the wiki
     'wiki', # The new django-wiki from benjaoming

lms/static/coffee/src/discussion/utils.coffee

@@ -25,6 +25,10 @@ class @DiscussionUtil
     staff = _.union(@roleIds['Staff'], @roleIds['Moderator'], @roleIds['Administrator'])
     _.include(staff, parseInt(user_id))
 
+  @isTA: (user_id) ->
+    ta = _.union(@roleIds['Community TA'])
+    _.include(ta, parseInt(user_id))
+
   @bulkUpdateContentInfo: (infos) ->
     for id, info of infos
       Content.getContent(id).updateInfo(info)
@@ -157,7 +161,7 @@ class @DiscussionUtil
   @makeWmdEditor: ($content, $local, cls_identifier) ->
     elem = $local(".#{cls_identifier}")
     placeholder = elem.data('placeholder')
-    id = elem.data("id")
+    id = elem.attr("data-id") # use attr instead of data because we want to avoid type coercion
     appended_id = "-#{cls_identifier}-#{id}"
     imageUploadUrl = @urlFor('upload')
     _processor = (_this) ->
@@ -170,12 +174,12 @@ class @DiscussionUtil
 
   @getWmdEditor: ($content, $local, cls_identifier) ->
     elem = $local(".#{cls_identifier}")
-    id = elem.data("id")
+    id = elem.attr("data-id") # use attr instead of data because we want to avoid type coercion
     @wmdEditors["#{cls_identifier}-#{id}"]
 
   @getWmdInput: ($content, $local, cls_identifier) ->
     elem = $local(".#{cls_identifier}")
-    id = elem.data("id")
+    id = elem.attr("data-id") # use attr instead of data because we want to avoid type coercion
     $local("#wmd-input-#{cls_identifier}-#{id}")
 
   @getWmdContent: ($content, $local, cls_identifier) ->

lms/static/coffee/src/discussion/views/discussion_thread_list_view.coffee

@@ -156,7 +156,11 @@ if Backbone?
       @$(".post-list").append(view.el)
 
     threadSelected: (e) =>
-      thread_id = $(e.target).closest("a").data("id")
+      # Use .attr('data-id') rather than .data('id') because .data does type
+      # coercion. Usually, this is fine, but when Mongo gives an object id with
+      # no letters, it casts it to a Number.
+
+      thread_id = $(e.target).closest("a").attr("data-id")
       @setActiveThread(thread_id)
       @trigger("thread:selected", thread_id)  # This triggers a callback in the DiscussionRouter which calls the line above...
       false

lms/static/coffee/src/discussion/views/response_comment_show_view.coffee

@@ -32,3 +32,5 @@ if Backbone?
     markAsStaff: ->
       if DiscussionUtil.isStaff(@model.get("user_id"))
         @$el.find("a.profile-link").after('<span class="staff-label">staff</span>')
+      else if DiscussionUtil.isTA(@model.get("user_id"))
+        @$el.find("a.profile-link").after('<span class="community-ta-label">Community&nbsp;&nbsp;TA</span>')

lms/static/coffee/src/discussion/views/thread_response_show_view.coffee

@@ -37,6 +37,9 @@ if Backbone?
       if DiscussionUtil.isStaff(@model.get("user_id"))
         @$el.addClass("staff")
         @$el.prepend('<div class="staff-banner">staff</div>')
+      else if DiscussionUtil.isTA(@model.get("user_id"))
+        @$el.addClass("community-ta")
+        @$el.prepend('<div class="community-ta-banner">Community TA</div>')
 
     toggleVote: (event) ->
       event.preventDefault()

lms/static/sass/_discussion.scss

@@ -1376,6 +1376,11 @@ body.discussion {
         border-color: #009fe2;
       }
 
+      &.community-ta{
+        padding-top: 38px;
+        border-color: #449944;
+      }
+
       .staff-banner {
         position: absolute;
         top: 0;
@@ -1392,6 +1397,23 @@ body.discussion {
         text-transform: uppercase;
       }
 
+      .community-ta-banner{
+        position: absolute;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 14px;
+        padding: 1px 5px;
+        @include box-sizing(border-box);
+        border-radius: 2px 2px 0 0;
+        background: #449944;
+        font-size: 9px;
+        font-weight: 700;
+        color: #fff;
+        text-transform: uppercase;
+      }
+
+
       &.loading {
         height: 0;
         margin: 0;
@@ -1556,11 +1578,11 @@ body.discussion {
     }
   }
 
-  .moderator-label {
+  .community-ta-label{
     margin-left: 2px;
     padding: 0 4px;
     border-radius: 2px;
-    background: #55dc9e;
+    background: #449944;
     font-size: 9px;
     font-weight: 700;
     font-style: normal;   

lms/templates/courseware/progress.html

@@ -65,16 +65,19 @@ ${progress_graph.body(grade_summary, course.grade_cutoffs, "grade-detail-graph")
                 %endif
               </p>
 
-              %if len(section['scores']) > 0:
-                <section class="scores">
+              <section class="scores">
+                %if len(section['scores']) > 0:
                   <h3> ${ "Problem Scores: " if section['graded'] else "Practice Scores: "} </h3>
                   <ol>
                     %for score in section['scores']:
                     <li>${"{0:.3n}/{1:.3n}".format(float(score.earned),float(score.possible))}</li>
                     %endfor
                   </ol>
-                </section>
-              %endif
+                %else:
+                  <h3 class="no-scores"> No problem scores in this section </h3>
+                %endif
+              </section>
+
 
             </li> <!--End section-->
             %endfor

lms/templates/feed.rss

@@ -6,16 +6,25 @@
   <link type="text/html" rel="alternate" href="http://blog.edx.org/"/>
   ##<link type="application/atom+xml" rel="self" href="https://github.com/blog.atom"/>
   <title>EdX Blog</title>
-  <updated>2012-07-16T14:08:12-07:00</updated>
+  <updated>2012-10-14T14:08:12-07:00</updated>
   <entry>
-    <id>tag:www.edx.org,2012:Post/5</id>
-    <published>2012-09-25T14:00:00-07:00</published>
-    <updated>2012-09-25T14:00:00-07:00</updated>
-    <link type="text/html" rel="alternate" href="${reverse('press/elsevier-collaborates-with-edx')}"/>
-    <title>Elsevier collaborates with edX</title>
-    <content type="html">&lt;img src=&quot;${static.url('images/press/foundations-of-analog-109x84.jpg')}&quot; /&gt;
-      &lt;p&gt;Free course textbook made available to edX students&lt;/p&gt;</content>
+    <id>tag:www.edx.org,2012:Post/6</id>
+    <published>2012-10-15T14:00:00-07:00</published>
+    <updated>2012-10-14T14:00:00-07:00</updated>
+    <link type="text/html" rel="alternate" href="${reverse('press/ut-joins-edx')}"/>
+    <title>The University of Texas System joins edX</title>
+    <content type="html">&lt;img src=&quot;${static.url('images/press/uts-seal_109x84.jpg')}&quot; /&gt;
+         &lt;p&gt;Nine universities and six health institutions&lt;/p&gt;</content>
   </entry>
+  <!-- <entry> -->
+  <!--   <id>tag:www.edx.org,2012:Post/5</id> -->
+  <!--   <published>2012-09-25T14:00:00-07:00</published> -->
+  <!--   <updated>2012-09-25T14:00:00-07:00</updated> -->
+  <!--   <link type="text/html" rel="alternate" href="${reverse('press/elsevier-collaborates-with-edx')}"/> -->
+  <!--   <title>Elsevier collaborates with edX</title> -->
+  <!--   <content type="html">&lt;img src=&quot;${static.url('images/press/foundations-of-analog-109x84.jpg')}&quot; /&gt; -->
+  <!--     &lt;p&gt;Free course textbook made available to edX students&lt;/p&gt;</content> -->
+  <!-- </entry> -->
   <entry>
     <id>tag:www.edx.org,2012:Post/4</id>
     <published>2012-09-06T14:00:00-07:00</published>

lms/templates/index.html

@@ -65,7 +65,7 @@
               </div>
             </a>
           </li>
-          <li class="partner last">
+          <li class="partner">
             <a href="${reverse('university_profile', args=['BerkeleyX'])}">
               <img src="${static.url('images/university/berkeley/berkeley.png')}" />
               <div class="name">
@@ -73,6 +73,14 @@
               </div>
             </a>
           </li>
+          <li class="partner last">
+            <a href="${reverse('university_profile', args=['UTx'])}">
+              <img src="${static.url('images/university/ut/ut-rollover_160x90.png')}" />
+              <div class="name">
+                <span>UTx</span>
+              </div>
+            </a>
+          </li>
         </ol>
       </section>
 

lms/templates/licenses/serial_numbers.html

+<dl>
+% for license in licenses:
+  <dt> ${license.software.name}: </dt>
+  % if license.serial:
+    <dd> ${license.serial} </dd>
+  % else:
+    <dd> None Available </dd>
+  % endif
+% endfor
+</dl>

lms/templates/static_templates/faq.html

-<%! from django.core.urlresolvers import reverse %>
-<%namespace name='static' file='../static_content.html'/>
-
-<%inherit file="../main.html" />
-
-<%block name="title"><title>FAQ</title></%block>
-
-<section class="container about">
-  <nav>
-    <a href="${reverse('about_edx')}">Vision</a>
-    <a href="${reverse('faq_edx')}" class="active">Faq</a>
-    <a href="${reverse('press')}">Press</a>
-    <a href="${reverse('contact')}">Contact</a>
-  </nav>
-  <section class="faq">
-    <section class="responses">
-      <section id="the-organization" class="category">
-        <h2>Organization</h2>
-        <article class="response">
-            <h3>What is edX?</h3>
-            <p>EdX is a not-for-profit enterprise of its founding partners, the Massachusetts Institute of Technology (MIT) and Harvard University that offers online learning to on-campus students and to millions of people around the world. To do so, edX is building an open-source online learning platform and hosts an online web portal at <a href="http://www.edx.org">www.edx.org</a> for online education.</p>
-            <p>EdX currently offers HarvardX, <em>MITx</em> and BerkeleyX classes online for free. These institutions aim to extend their collective reach to build a global community of online students. Along with offering online courses, the three universities undertake research on how students learn and how technology can transform learning – both on-campus and online throughout the world.</p>
-        </article>
-        <article class="response">
-            <h3>What are "X Universities"?</h3>
-            <p>Harvard, MIT and UC Berkeley, as the first universities whose courses are delivered on the edX website, are "X Universities." The three institutions will work collaboratively to establish the "X University" Consortium, whose membership will expand to include additional "X Universities" as soon as possible. Each member of the consortium will offer courses on the edX platform as an "X University." The gathering of many universities’ educational content together on one site will enable learners worldwide to access the course content of any participating university from a single website, and to use a set of online educational tools shared by all participating universities. </p>
-        </article>
-        <article class="response">
-            <h3>Why is UC Berkeley joining edX?</h3>
-            <p>Like Harvard and MIT, UC Berkeley seeks to transform education in quality, efficiency and scale through technology and research, for the benefit of campus-based students and the global community of online learners. </p>
-            <p>UC Berkeley also shares the edX commitment to the not-for-profit and open-platform model as a way to enhance human fulfillment worldwide. </p>
-        </article>
-        <article class="response">
-            <h3>What will UC Berkeley's direct participation entail?</h3>
-            <p>UC Berkeley will begin by offering two courses on edX in Fall 2012, and will collaborate on the development of the technology platform. We will explore, experiment and innovate together.</p>
-            <p>UC Berkeley will also serve as the inaugural chair of the "X University" Consortium for an initial 5 year period.  As Chair, UC Berkeley will participate on the edX Board on behalf of the X Universities.</p>
-        </article>
-        <article class="response">
-            <h3>Why is edX only adding one X University?</h3>
-            <p>More than 120 universities from around the world have expressed interest in collaborating with edX since Harvard and MIT announced its creation in May.  EdX is focused above all on quality and developing the best non-profit model for online education.  In addition to providing online courses on the edX platform, the "X University" Consortium will be a forum in which members can share experiences around online learning. </p>
-            <p>EdX will actively explore the addition of other institutions from around the world to the edX platform, and we look forward to adding more "X Universities" as capacity increases. </p>
-        </article>
-      </section>
-
-      <section id="students" class="category">
-        <h2>Students</h2>
-        <article class="response">
-            <h3>Who can take edX courses? Will there be an admissions process?</h3>
-            <p>EdX will be available to anyone in the world with an internet connection, and in general, there will not be an admissions process.</p>
-        </article>
-        <article class="response">
-            <h3>Will certificates be awarded?</h3>
-            <p>Yes. Online learners who demonstrate mastery of subjects can earn a certificate of completion. Certificates will be issued by edX under the name of the underlying "X University" from where the course originated, i.e. HarvardX, <em>MITx</em> or BerkeleyX.  For the courses in Fall 2012, those certificates will be free.  There is a plan to charge a modest fee for certificates in the future.</p>
-        </article>
-        <article class="response">
-            <h3>What will the scope of the online courses be? How many? Which faculty?</h3>
-            <p>Our goal is to offer a wide variety of courses across disciplines. There are currently <a href="${reverse('courses')}">seven courses</a> offered for Fall 2012.</p>
-        </article>
-        <article class="response">
-            <h3>Who is the learner? Domestic or international? Age range?</h3>
-            <p>Improving teaching and learning for students on our campuses is one of our primary goals. Beyond that, we don’t have a target group of potential learners, as the goal is to make these courses available to anyone in the world – from any demographic – who has interest in advancing their own knowledge. The only requirement is to have a computer with an internet connection. More than 150,000 students from over 160 countries registered for MITx's first course, 6.002x: Circuits and Electronics. The age range of students certified in this course was from 14 to 74 years-old.</p>
-        </article>
-        <article class="response">
-            <h3>Will participating universities’ standards apply to all courses offered on the edX platform?</h3>
-            <p>Yes: the reach changes exponentially, but the rigor remains the same.</p>
-        </article>
-        <article class="response">
-            <h3>How do you intend to test whether this approach is improving learning?</h3>
-            <p>Edx institutions have assembled faculty members who will collect and analyze data to assess results and the impact edX is having on learning.</p>
-        </article>
-        <article class="response">
-            <h3>How may I apply to study with edX?</h3>
-            <p>Simply complete the online <a href="#signup-modal" rel="leanModal">signup form</a>.  Enrolling will create your unique student record in the edX database, allow you to register for classes, and to receive a certificate on successful completion.</p>
-        </article>
-        <article class="response">
-            <h3>How may another university participate in edX? </h3>
-            <p>If you are from a university interested in discussing edX, please email <a href="mailto:university@edx.org">university@edx.org</a></p>
-        </article>
-      </section>
-
-      <section id="technology-platform" class="category">
-        <h2>Technology Platform</h2>
-        <article class="response">
-            <h3>What technology will edX use?</h3>
-            <p>The edX open-source online learning platform will feature interactive learning designed specifically for the web. Features will include: self-paced learning, online discussion groups, wiki-based collaborative learning, assessment of learning as a student progresses through a course, and online laboratories and other interactive learning tools. The platform will also serve as a laboratory from which data will be gathered to better understand how students learn. Because it is open source, the platform will be continuously improved by a worldwide community of collaborators, with new features added as needs arise.</p>
-            <p>The first version of the technology was used in the first <em>MITx</em> course, 6.002x Circuits and Electronics, which launched in Spring, 2012.</p>
-        </article>
-        <article class="response">
-            <h3>How is this different from what other universities are doing online?</h3>
-            <p>EdX is a not-for-profit enterprise built upon the shared educational missions of its founding partners, Harvard University and MIT. The edX platform will be available as open source. Also, a primary goal of edX is to improve teaching and learning on campus by experimenting with blended models of learning and by supporting faculty in conducting significant research on how students learn.</p>
-        </article>
-      </section>
-
-    </section>
-
-    <nav class="categories">
-      <a href="#organization">Organization</a>
-      ##<a href="#objectives">Objectives</a>
-      <a href="#students">Students</a>
-      <a href="#technology-platform">Technology Platform</a>
-    </nav>
-  </section>
-</section>
-
-%if user.is_authenticated():
-  <%include file="../signup_modal.html" />
-%endif
+<%! from django.core.urlresolvers import reverse %>
+<%namespace name='static' file='../static_content.html'/>
+
+<%inherit file="../main.html" />
+
+<%block name="title"><title>FAQ</title></%block>
+
+<section class="container about">
+  <nav>
+    <a href="${reverse('about_edx')}">Vision</a>
+    <a href="${reverse('faq_edx')}" class="active">Faq</a>
+    <a href="${reverse('press')}">Press</a>
+    <a href="${reverse('contact')}">Contact</a>
+  </nav>
+  <section class="faq">
+    <section class="responses">
+      <section id="the-organization" class="category">
+        <h2>Organization</h2>
+        <article class="response">
+            <h3>What is edX?</h3>
+            <p>edX is a not-for-profit enterprise of its founding partners, the Massachusetts Institute of Technology (MIT) and Harvard University that offers online learning to on-campus students and to millions of people around the world. To do so, edX is building an open-source online learning platform and hosts an online web portal at <a href="http://www.edx.org">www.edx.org</a> for online education.</p>
+            <p>EdX currently offers HarvardX, <em>MITx</em> and BerkeleyX classes online for free. Beginning in Summer 2013, edX will also offer UTx (University of Texas) classes online for free. The University of Texas System includes nine universities and six health institutions. The edX institutions aim to extend their collective reach to build a global community of online students. Along with offering online courses, the three universities undertake research on how students learn and how technology can transform learning – both on-campus and online throughout the world.</p>
+        </article>
+        <article class="response">
+            <h3>Why is The University of Texas System joining edX?</h3>
+            <p>Joining edX not only allows UT faculty to showcase their work on a global stage, but also provides UT students the opportunity to take classes from their choice of UT institutions, as well as MIT, Harvard, UC Berkeley and future &ldquo;X&rdquo; Universities.</p>
+            <p>The UT System closely examined all the alternatives and determined that edX offered the best fit in terms of alignment of mission, platform and revenue model. The strength and reputation of the partner institutions – MIT, Harvard and UC Berkeley – was also a huge consideration. EdX is committed to both blended and online learning and to a non-profit, open source model. It is also governed by a board of academics with a commitment to excellence in learning.</p>
+        </article>
+        <article class="response">
+            <h3>What will The UT System’s direct participation entail?</h3>
+            <p>The UT System will begin by offering one course on edX from The University of Texas at Austin in Summer 2013, and four courses in Fall 2013, likely at least one of those courses from one of its health institutions. The UT System is also making a $5 million investment in the edX platform. We will explore, experiment and innovate together.</p>
+        </article>
+        <article class="response">
+            <h3>Will edX be adding additional X Universities?</h3>
+            <p>More than 140 institutions from around the world have expressed interest in collaborating with edX since Harvard and MIT announced its creation in May. EdX is focused above all on quality and developing the best not-for-profit model for online education. In addition to providing online courses on the edX platform, the &ldquo;X University&rdquo; Consortium will be a forum in which members can share experiences around online learning. Harvard, MIT, UC Berkeley and the UT System will work collaboratively to establish the &ldquo;X University&rdquo; Consortium, whose membership will expand to include additional &ldquo;X Universities&rdquo; as soon as possible. Each member of the consortium will offer courses on the edX platform as an &ldquo;X University.&rdquo; The gathering of many universities’ educational content together on one site will enable learners worldwide to access the course content of any participating university from a single website, and to use a set of online educational tools shared by all participating universities.</p>
+            <p>EdX will actively explore the addition of other institutions from around the world to the edX platform, and we look forward to adding more &ldquo;X Universities&rdquo; as capacity increases. </p>
+        </article>
+      </section>
+
+      <section id="students" class="category">
+        <h2>Students</h2>
+        <article class="response">
+            <h3>Who can take edX courses? Will there be an admissions process?</h3>
+            <p>EdX will be available to anyone in the world with an internet connection, and in general, there will not be an admissions process.</p>
+        </article>
+        <article class="response">
+            <h3>Will certificates be awarded?</h3>
+            <p>Yes. Online learners who demonstrate mastery of subjects can earn a certificate of completion. Certificates will be issued by edX under the name of the underlying "X University" from where the course originated, i.e. HarvardX, <em>MITx</em> or BerkeleyX.  For the courses in Fall 2012, those certificates will be free.  There is a plan to charge a modest fee for certificates in the future.</p>
+        </article>
+        <article class="response">
+            <h3>What will the scope of the online courses be? How many? Which faculty?</h3>
+            <p>Our goal is to offer a wide variety of courses across disciplines. There are currently <a href="${reverse('courses')}">seven courses</a> offered for Fall 2012.</p>
+        </article>
+        <article class="response">
+            <h3>Who is the learner? Domestic or international? Age range?</h3>
+            <p>Improving teaching and learning for students on our campuses is one of our primary goals. Beyond that, we don’t have a target group of potential learners, as the goal is to make these courses available to anyone in the world – from any demographic – who has interest in advancing their own knowledge. The only requirement is to have a computer with an internet connection. More than 150,000 students from over 160 countries registered for MITx's first course, 6.002x: Circuits and Electronics. The age range of students certified in this course was from 14 to 74 years-old.</p>
+        </article>
+        <article class="response">
+            <h3>Will participating universities’ standards apply to all courses offered on the edX platform?</h3>
+            <p>Yes: the reach changes exponentially, but the rigor remains the same.</p>
+        </article>
+        <article class="response">
+            <h3>How do you intend to test whether this approach is improving learning?</h3>
+            <p>Edx institutions have assembled faculty members who will collect and analyze data to assess results and the impact edX is having on learning.</p>
+        </article>
+        <article class="response">
+            <h3>How may I apply to study with edX?</h3>
+            <p>Simply complete the online <a href="#signup-modal" rel="leanModal">signup form</a>.  Enrolling will create your unique student record in the edX database, allow you to register for classes, and to receive a certificate on successful completion.</p>
+        </article>
+        <article class="response">
+            <h3>How may another university participate in edX? </h3>
+            <p>If you are from a university interested in discussing edX, please email <a href="mailto:university@edx.org">university@edx.org</a></p>
+        </article>
+      </section>
+
+      <section id="technology-platform" class="category">
+        <h2>Technology Platform</h2>
+        <article class="response">
+            <h3>What technology will edX use?</h3>
+            <p>The edX open-source online learning platform will feature interactive learning designed specifically for the web. Features will include: self-paced learning, online discussion groups, wiki-based collaborative learning, assessment of learning as a student progresses through a course, and online laboratories and other interactive learning tools. The platform will also serve as a laboratory from which data will be gathered to better understand how students learn. Because it is open source, the platform will be continuously improved by a worldwide community of collaborators, with new features added as needs arise.</p>
+            <p>The first version of the technology was used in the first <em>MITx</em> course, 6.002x Circuits and Electronics, which launched in Spring, 2012.</p>
+        </article>
+        <article class="response">
+            <h3>How is this different from what other universities are doing online?</h3>
+            <p>EdX is a not-for-profit enterprise built upon the shared educational missions of its founding partners, Harvard University and MIT. The edX platform will be available as open source. Also, a primary goal of edX is to improve teaching and learning on campus by experimenting with blended models of learning and by supporting faculty in conducting significant research on how students learn.</p>
+        </article>
+      </section>
+
+    </section>
+
+    <nav class="categories">
+      <a href="#organization">Organization</a>
+      ##<a href="#objectives">Objectives</a>
+      <a href="#students">Students</a>
+      <a href="#technology-platform">Technology Platform</a>
+    </nav>
+  </section>
+</section>
+
+%if user.is_authenticated():
+  <%include file="../signup_modal.html" />
+%endif

lms/templates/static_templates/press_releases/UT_joins_edX.html

+<%! from django.core.urlresolvers import reverse %>
+<%inherit file="../../main.html" />
+
+<%namespace name='static' file='../../static_content.html'/>
+
+<%block name="title"><title>The University of Texas System joins edX</title></%block>
+<div id="fb-root"></div>
+<script>(function(d, s, id) {
+  var js, fjs = d.getElementsByTagName(s)[0];
+  if (d.getElementById(id)) return;
+  js = d.createElement(s); js.id = id;
+  js.src = "//connect.facebook.net/en_US/all.js#xfbml=1";
+  fjs.parentNode.insertBefore(js, fjs);
+}(document, 'script', 'facebook-jssdk'));</script>
+
+<section class="pressrelease">
+  <section class="container">
+    <h1>The University of Texas System joins edX</h1>
+    <hr class="horizontal-divider">
+      <article>
+        <h2>The University of Texas System joins Harvard, MIT and UC Berkeley in not-for-profit online learning collaborative </h2>
+
+        <p><strong>CAMBRIDGE, MA/AUSTIN, TX &ndash; October 15, 2012</strong> &mdash; edX, the online non-profit learning initiative founded by Harvard University (Harvard) and the Massachusetts Institute of Technology (MIT) and launched in May, announced today the addition of The University of Texas (UT) System to its platform.  The UT System, one of the largest public university systems in the United States with nine academic universities and six health institutions, will collaborate with edX to expand the group of participating &ldquo;X Universities&rdquo; – universities offering their courses on the edX platform. </p>
+
+        <p>The UT System includes the University of Texas at Austin, ranked 25th in the 2012-2013 Times Higher Education World University Rankings, UT Southwestern Medical Center, home to one of the nation's top 25 medical schools, and UT MD Anderson Cancer Center, the nation's No. 1-ranked cancer center. The system's institutions serve 212,000 students and employ 19,000 faculty members.</p>
+
+        <p>Through edX, the &ldquo;X Universities&rdquo; provide online interactive education wherever there is access to the Internet, with a goal to enhance teaching and learning through research about how students learn, and how technologies can facilitate effective teaching both on campus and online. The University of California, Berkeley (UC Berkeley) joined edX in July 2012. edX plans to add other &ldquo;X Universities&rdquo; from around the world to the edX platform in the coming months. </p>
+
+        <p>Francisco G. Cigarroa, Chancellor of The University of Texas System announced the partnership following a unanimous vote of approval by the UT System's Board of Regents on Monday.</p>
+
+        <p>&ldquo;New technologies are positively impacting how professors teach and how course content is delivered,&rdquo; Chancellor Cigarroa said. &ldquo;The University of Texas System will help lead this revolution and fundamentally alter the direction of online education. We are excited about this partnership with edX and honored to be in the company of such exceptional institutions as MIT, Harvard and Berkeley. The mission of edX aligns perfectly with that of the UT System and keeps the learner as its central focus.&rdquo;</p>
+
+        <p>The University of Texas System plans to offer at least four courses on edX within the next year.</p>
+
+        <p>In addition to serving a global community of online students, the UT System plans to redesign general education courses and traditional entry-level courses that are too often made up of several hundred students. Through its Institute for Transformational Learning, the UT System plans to give students more options by offering courses that are customized to student needs. For example, the UT System plans to offer courses that use a combination of technology and face-to-face interaction, courses that allow students to manage their own time by accelerating through sections they have already mastered or spending more time on areas they find challenging, and fully online courses so students are not limited by their location.</p>
+
+        <p>&ldquo;As Texas' flagship university, UT Austin is committed not only to embracing breakthroughs in education, but helping create them,&rdquo; said William Powers, Jr., President of UT Austin. &ldquo;We're proud to be partnering with these top peer universities on edX.&rdquo;</p>
+
+        <p>As part of a bold and innovative plan, the UT System also plans to offer courses through edX that will allow students to earn college credits toward a degree. &ldquo;Our goal through our partnership with edX is to better meet the learning needs of a wide range of students, raise graduation rates and cut the cost of higher education, all while maintaining our commitment to education of the highest quality,&rdquo; said Gene Powell, chairman of the UT System Board of Regents. </p>
+
+        <p>The UT System brings a large and diverse student body to the edX family. Its six health institutions offer a unique opportunity to provide groundbreaking health and medical courses via edX in the near future. The UT System also brings special expertise in analytics – assessing student learning, online course design and creating interactive learning environments.</p>
+
+        <p>edX courses are designed to provide students with a wealth of innovative resources, including interactive laboratories, virtual reality environments and access to online tutors and tutorials. Students who take UT System courses through edX won't work in isolation, but will have the opportunity to participate in online forums, network with instructors and fellow students and take part in exciting collaborative projects. &ldquo;We are excited that The University of Texas System is joining edX's efforts to revolutionize learning,&rdquo; said Anant Agarwal, President of edX. &ldquo;The institutions within The University of Texas System bring a wide range of expertise to the edX mission, and with them edX is now positioned to continue to increase our offering of high-quality, online courses.&rdquo;</p>
+
+        <p>edX was created by Harvard and MIT in May, with each university committing to contribute $30 million toward the online partnership.</p>
+
+        <p>&ldquo;Today's announcement is another important step toward our shared objectives of expanding access to high quality educational content while enhancing teaching and learning online and in the classroom,&rdquo; said Harvard President Drew Faust.  &ldquo;The addition of The University of Texas System to the edX platform will allow us to deepen our understanding of  learning, develop new approaches to teaching that build on that knowledge, and strengthen both the on-campus and online learning experience.&rdquo;
+
+        <p>&ldquo;At MIT, we are energetically exploring the ways that online instruction can help us reimagine our campus residential education even as it allows us to reach an unprecedented number of learners around the world,&rdquo; said MIT President L. Rafael Reif. &ldquo;It is thrilling to be joined by The University of Texas System in the pursuit of that dual goal.&rdquo;</p>
+
+        <p>The edX classes to be offered by the UT System will be announced soon and will join other new edX courses planned for Spring, Summer and Fall 2013.  As with all edX courses, online learners who obtain a passing grade in the UT System courses will receive a certificate of mastery.  edX will also offer the option of proctored examinations for the UT System courses.</p>
+
+
+        <h2>About edX</h2>
+
+        <p>edX is a not-for-profit enterprise of its founding partners Harvard University and the Massachusetts Institute of Technology that features learning designed specifically for interactive study via the web. Based on a long history of collaboration and their shared educational missions the founders are creating a new online-learning experience. Anant Agarwal, former Director of MIT's Computer Science and Artificial Intelligence Laboratory, serves as the first president of edX. Along with offering online courses, the institutions will use edX to research how students learn and how technology can transform learning—both on-campus and worldwide.  edX is based in Cambridge, Massachusetts and is governed by MIT and Harvard.</p>
+
+        <h2>About Harvard University</h2>
+
+        <p>Harvard University is devoted to excellence in teaching, learning and research, and to developing leaders in many disciplines who make a difference globally.  Harvard Faculty are engaged with teaching and research to push the boundaries of human knowledge. The University has twelve degree-granting Schools in addition to the Radcliffe Institute for Advanced Study.</p>
+
+        <p>Established in 1636, Harvard is the oldest institution of higher education in the United States. The University, which is based in Cambridge and Boston, Massachusetts, has an enrollment of over 20,000 degree candidates, including undergraduate, graduate and professional students. Harvard has more than 360,000 alumni around the world.</p>
+
+        <h2>About MIT</h2>
+        <p>The Massachusetts Institute of Technology — a coeducational, privately endowed research university founded in 1861 — is dedicated to advancing knowledge and educating students in science, technology and other areas of scholarship that will best serve the nation and the world in the 21st century. The Institute has close to 1,000 faculty and 10,000 undergraduate and graduate students. It is organized into five Schools: Architecture and Urban Planning; Engineering; Humanities, Arts, and Social Sciences; Sloan School of Management; and Science.</p>
+
+        <p>MIT's commitment to innovation has led to a host of scientific breakthroughs and technological advances. Achievements of the Institute's faculty and graduates have included the first chemical synthesis of penicillin and vitamin A, the development of inertial guidance systems, modern technologies for artificial limbs and the magnetic core memory that made possible the development of digital computers. Seventy-eight alumni, faculty, researchers and staff have won Nobel Prizes.</p>
+
+        <p>Current areas of research and education include neuroscience and the study of the brain and mind, bioengineering, cancer, energy, the environment and sustainable development, information sciences and technology, new media, financial technology and entrepreneurship.</p>
+
+        <h2>About the University of California, Berkeley</h2>
+
+        <p>The University of California, Berkeley is the world's premier public university with a mission to excel in teaching, research and public service. This longstanding mission has led to the university's distinguished record of Nobel-level scholarship, constant innovation, a concern for the betterment of our world, and consistently high rankings of its schools and departments. The campus offers superior, high value education for extraordinarily talented students from all walks of life; operational excellence and a commitment to the competitiveness and prosperity of California and the nation. </p>
+
+        <p>The University of California was chartered in 1868 and its flagship campus in Berkeley, on San Francisco Bay, was envisioned as a &ldquo;City of Learning.&rdquo; Today, there are more than 1,500 fulltime and 500 part-time faculty members dispersed among more than 130 academic departments and more than 80 interdisciplinary research units. Twenty-two Nobel Prizes have been garnered by faculty and 28 by UC Berkeley alumni. There are 9 Nobel Laureates, 32 MacArthur Fellows, and 4 Pulitzer Prize winners among the current faculty.</p>
+
+        <h2>About The University of Texas System</h2>
+
+        <p>Educating students, providing care for patients, conducting groundbreaking research and serving the needs of Texans and the nation for more than 130 years, The University of Texas System is one of the largest public university systems in the United States, with nine academic universities and six health science centers. Student enrollment exceeded 215,000 in the 2011 academic year. The UT System confers more than one-third of the state's undergraduate degrees and educates nearly three-fourths of the state's health care professionals annually. The UT System has an annual operating budget of $13.1 billion (FY 2012) including $2.3 billion in sponsored programs funded by federal, state, local and private sources. With roughly 87,000 employees, the UT System is one of the largest employers in the state. www.utsystem.edu</p>
+
+      <section class="contact">
+        <p><strong>edX Contact: </strong>Dan O’Connell</p>
+        <p>oconnell@edx.org</p>
+        <p>617-480-6585</p>
+        <br/>
+        <p><strong>UT System Contact: </strong>Jenny LaCoste-Caputo</p>
+        <p>jcaputo@utsystem.edu</p>
+        <p>512-499-4361</p>
+      </section>
+
+      <section class="footer">
+        <hr class="horizontal-divider">
+        <div class="logo"></div><h3 class="date">10 - 15 - 2012</h3>
+        <div class="social-sharing">
+        <hr class="horizontal-divider">
+          <p>Share with friends and family:</p>
+          <a href="http://twitter.com/intent/tweet?text=The+University+of+Texas+System+joins+Harvard,+MIT+and+UC+Berkeley+in+not-for-profit+online+learning+collaborative:+http://www.edx.org/press/ut-joins-edx" class="share">
+            <img src="${static.url('images/social/twitter-sharing.png')}">
+          </a>
+        </a>
+        <a href="mailto:?subject=The%20University%20of%20Texas%20System%20joins%20Harvard,%20MIT%20and%20UC%20Berkeley%20in%20not-for-profit%20online%20learning%20collaborative.…http://edx.org/press/ut-joins-edx" class="share">
+          <img src="${static.url('images/social/email-sharing.png')}">
+        </a>
+        <div class="fb-like" data-href="http://edx.org/press/ut-joins-edx" data-send="true" data-width="450" data-show-faces="true"></div>
+      </div>
+
+      </section>
+    </article>
+  </section>
+</section>

lms/templates/university_profile/utx.html

+<%inherit file="base.html" />
+<%namespace name='static' file='../static_content.html'/>
+
+<%block name="title"><title>UTx</title></%block>
+
+<%block name="university_header">
+  <header class="search" style="background: url('/static/images/university/ut/ut-cover_2025x550.jpg')">
+    <div class="inner-wrapper university-search">
+      <hgroup>
+        <div class="logo">
+           <img src="${static.url('images/university/ut/ut-standalone_187x80.png')}" />
+        </div>
+        <h1>UTx</h1>
+      </hgroup>
+    </div>
+  </header>
+
+</%block>
+
+<%block name="university_description">
+    <p>Educating students, providing care for patients, conducting groundbreaking research and serving the needs of Texans and the nation for more than 130 years, The University of Texas System is one of the largest public university systems in the United States, with nine academic universities and six health science centers. Student enrollment exceeded 215,000 in the 2011 academic year. The UT System confers more than one-third of the state’s undergraduate degrees and educates nearly three-fourths of the state’s health care professionals annually. The UT System has an annual operating budget of $13.1 billion (FY 2012) including $2.3 billion in sponsored programs funded by federal, state, local and private sources. With roughly 87,000 employees, the UT System is one of the largest employers in the state.</p>
+</%block>
+
+${parent.body()}

lms/urls.py

@@ -52,6 +52,7 @@ urlpatterns = ('',
 
     url(r'^heartbeat$', include('heartbeat.urls')),
 
+    url(r'^university_profile/UTx$', 'courseware.views.static_university_profile', name="static_university_profile", kwargs={'org_id':'UTx'}),
     url(r'^university_profile/(?P<org_id>[^/]+)$', 'courseware.views.university_profile', name="university_profile"),
 
     #Semi-static views (these need to be rendered and have the login bar, but don't change)
@@ -88,6 +89,8 @@ urlpatterns = ('',
         {'template': 'press_releases/edX_announces_proctored_exam_testing.html'}, name="press/edX-announces-proctored-exam-testing"),
     url(r'^press/elsevier-collaborates-with-edx$', 'static_template_view.views.render',
         {'template': 'press_releases/Elsevier_collaborates_with_edX.html'}, name="press/elsevier-collaborates-with-edx"),
+    url(r'^press/ut-joins-edx$', 'static_template_view.views.render',
+        {'template': 'press_releases/UT_joins_edX.html'}, name="press/ut-joins-edx"),
 
 
     # Should this always update to point to the latest press release?
@@ -141,6 +144,24 @@ if settings.COURSEWARE_ENABLED:
         url(r'^courses/(?P<course_id>[^/]+/[^/]+/[^/]+)/modx/(?P<location>.*?)/(?P<dispatch>[^/]*)$',
             'courseware.module_render.modx_dispatch',
             name='modx_dispatch'),
+
+        # TODO (vshnayder): This is a hack.  It creates a direct connection from
+        # the LMS to capa functionality, and really wants to go through the
+        # input types system so that previews can be context-specific.
+        # Unfortunately, we don't have time to think through the right way to do
+        # that (and implement it), and it's not a terrible thing to provide a
+        # generic chemican-equation rendering service.
+        url(r'^preview/chemcalc', 'courseware.module_render.preview_chemcalc',
+            name='preview_chemcalc'),
+
+        # Software Licenses
+
+        # TODO: for now, this is the endpoint of an ajax replay
+        # service that retrieve and assigns license numbers for
+        # software assigned to a course. The numbers have to be loaded
+        # into the database.
+        url(r'^software-licenses$', 'licenses.views.user_software_license', name="user_software_license"),
+
         url(r'^courses/(?P<course_id>[^/]+/[^/]+/[^/]+)/xqueue/(?P<userid>[^/]*)/(?P<id>.*?)/(?P<dispatch>[^/]*)$',
             'courseware.module_render.xqueue_callback',
             name='xqueue_callback'),
@@ -244,7 +265,7 @@ if settings.MITX_FEATURES.get('AUTH_USE_OPENID'):
 if settings.MITX_FEATURES.get('AUTH_USE_OPENID_PROVIDER'):
     urlpatterns += (
         url(r'^openid/provider/login/$', 'external_auth.views.provider_login', name='openid-provider-login'),
-        url(r'^openid/provider/login/(?:[\w%\. ]+)$', 'external_auth.views.provider_identity', name='openid-provider-login-identity'),
+        url(r'^openid/provider/login/(?:.+)$', 'external_auth.views.provider_identity', name='openid-provider-login-identity'),
         url(r'^openid/provider/identity/$', 'external_auth.views.provider_identity', name='openid-provider-identity'),
         url(r'^openid/provider/xrds/$', 'external_auth.views.provider_xrds', name='openid-provider-xrds')
     )

requirements.txt

@@ -16,7 +16,7 @@ beautifulsoup
 beautifulsoup4
 feedparser
 requests
-sympy
+http://sympy.googlecode.com/files/sympy-0.7.1.tar.gz
 newrelic
 glob2
 pymongo
@@ -49,3 +49,4 @@ networkx
 pygraphviz
 -r repo-requirements.txt
 pil
+nltk