# HG changeset patch
# User Mitesh Patel <qed777@gmail.com>
# Date 1267756016 28800
# Node ID 229d0893f9923e5fef1ad51183ca0acd70321a17
# Parent  c49613dc3a07d8be9cd9ae50384e322cd010855c
#8316: Use Jinja2 instead of Jinja

diff --git a/sage/ext/gen_interpreters.py b/sage/ext/gen_interpreters.py
--- a/sage/ext/gen_interpreters.py
+++ b/sage/ext/gen_interpreters.py
@@ -98,8 +98,8 @@ from __future__ import with_statement
 
 import os
 import re
-from jinja import Environment
-from jinja.datastructure import ComplainingUndefined
+from jinja2 import Environment
+from jinja2.runtime import StrictUndefined
 from collections import defaultdict
 from distutils.extension import Extension
 
@@ -114,12 +114,12 @@ from distutils.extension import Extensio
 ##############################
 
 
-# We share a single jinja environment among all templating in this file.
-# We use trim_blocks=True (which means that we ignore white space after
-# "%}" jinja command endings), and set undefined_singleton to complain
-# if we use an undefined variable.
-jinja_env = Environment(trim_blocks=True,
-                        undefined_singleton=ComplainingUndefined)
+# We share a single jinja2 environment among all templating in this
+# file.  We use trim_blocks=True (which means that we ignore white
+# space after "%}" jinja2 command endings), and set undefined to
+# complain if we use an undefined variable.
+jinja_env = Environment(trim_blocks=True, undefined=StrictUndefined)
+
 # Allow 'i' as a shorter alias for the built-in 'indent' filter.
 jinja_env.filters['i'] = jinja_env.filters['indent']
 
@@ -169,7 +169,7 @@ def je(template, **kwargs):
     if len(template) > 0 and template[0] == '\n':
         template = template[1:]
 
-    # It looks like Jinja automatically removes one trailing newline?
+    # It looks like Jinja2 automatically removes one trailing newline?
     if len(template) > 0 and template[-1] == '\n':
         template = template + '\n'
 
@@ -424,8 +424,8 @@ class StorageType(object):
         return je("""
 {# XXX Variables here (and everywhere, really) should actually be Py_ssize_t #}
     cdef int _n_{{ name }}
-    cdef {{ self.cython_array_type() }} _{{ name }}
-""", self=self, name=name)
+    cdef {{ myself.cython_array_type() }} _{{ name }}
+""", myself=self, name=name)
 
     def alloc_chunk_data(self, name, len):
         r"""
@@ -444,13 +444,13 @@ class StorageType(object):
         """
         return je("""
         self._n_{{ name }} = {{ len }}
-        self._{{ name }} = <{{ self.c_ptr_type() }}>sage_malloc(sizeof({{ self.c_decl_type() }}) * {{ len }})
+        self._{{ name }} = <{{ myself.c_ptr_type() }}>sage_malloc(sizeof({{ myself.c_decl_type() }}) * {{ len }})
         if self._{{ name }} == NULL: raise MemoryError
-{% if self.needs_cython_init_clear() %}
+{% if myself.needs_cython_init_clear() %}
         for i in range({{ len }}):
-            {{ self.cython_init('self._%s[i]' % name) }}
+            {{ myself.cython_init('self._%s[i]' % name) }}
 {% endif %}
-""", self=self, name=name, len=len)
+""", myself=self, name=name, len=len)
 
     def dealloc_chunk_data(self, name):
         r"""
@@ -473,12 +473,12 @@ class StorageType(object):
         """
         return je("""
         if self._{{ name }}:
-{%     if self.needs_cython_init_clear() %}
+{%     if myself.needs_cython_init_clear() %}
             for i in range(self._n_{{ name }}):
-                {{ self.cython_clear('self._%s[i]' % name) }}
+                {{ myself.cython_clear('self._%s[i]' % name) }}
 {%     endif %}
             sage_free(self._{{ name }})
-""", self=self, name=name)
+""", myself=self, name=name)
 
 class StorageTypeAssignable(StorageType):
     r"""
@@ -671,8 +671,8 @@ class StorageTypePython(StorageTypeAssig
         return je("""
     cdef object _list_{{ name }}
     cdef int _n_{{ name }}
-    cdef {{ self.cython_array_type() }} _{{ name }}
-""", self=self, name=name)
+    cdef {{ myself.cython_array_type() }} _{{ name }}
+""", myself=self, name=name)
 
     def alloc_chunk_data(self, name, len):
         r"""
@@ -691,7 +691,7 @@ class StorageTypePython(StorageTypeAssig
         self._n_{{ name }} = {{ len }}
         self._list_{{ name }} = PyList_New(self._n_{{ name }})
         self._{{ name }} = (<PyListObject *>self._list_{{ name }}).ob_item
-""", self=self, name=name, len=len)
+""", myself=self, name=name, len=len)
 
     def dealloc_chunk_data(self, name):
         r"""
@@ -901,8 +901,8 @@ class StorageTypeMPFR(StorageTypeAutoRef
             sage: ty_mpfr.cython_init('foo[i]')
             u'mpfr_init2(foo[i], self.domain.prec())'
         """
-        return je("mpfr_init2({{ loc }}, self.domain{{ self.id }}.prec())",
-                  self=self, loc=loc)
+        return je("mpfr_init2({{ loc }}, self.domain{{ myself.id }}.prec())",
+                  myself=self, loc=loc)
 
     def cython_clear(self, loc):
         r"""
@@ -928,8 +928,8 @@ class StorageTypeMPFR(StorageTypeAutoRef
             u'rn = self.domain(bar[j])\nmpfr_set(foo[i], rn.value, GMP_RNDN)'
         """
         return je("""
-rn{{ self.id }} = self.domain({{ py }})
-mpfr_set({{ c }}, rn.value, GMP_RNDN)""", self=self, c=c, py=py)
+rn{{ myself.id }} = self.domain({{ py }})
+mpfr_set({{ c }}, rn.value, GMP_RNDN)""", myself=self, c=c, py=py)
 
 ty_mpfr = StorageTypeMPFR()
 
@@ -1184,9 +1184,9 @@ class MemoryChunkLonglivedArray(MemoryCh
             <BLANKLINE>
         """
         return je("""
-        count = args['{{ self.name }}']
-{% print self.storage_type.alloc_chunk_data(self.name, 'count') %}
-""", self=self)
+        count = args['{{ myself.name }}']
+{% print myself.storage_type.alloc_chunk_data(myself.name, 'count') %}
+""", myself=self)
 
     def dealloc_class_members(self):
         r"""
@@ -1249,11 +1249,11 @@ class MemoryChunkConstants(MemoryChunkLo
             <BLANKLINE>
         """
         return je("""
-        val = args['{{ self.name }}']
-{% print self.storage_type.alloc_chunk_data(self.name, 'len(val)') %}
+        val = args['{{ myself.name }}']
+{% print myself.storage_type.alloc_chunk_data(myself.name, 'len(val)') %}
         for i in range(len(val)):
-            {{ self.storage_type.assign_c_from_py('self._%s[i]' % self.name, 'val[i]') | i(12) }}
-""", self=self)
+            {{ myself.storage_type.assign_c_from_py('self._%s[i]' % myself.name, 'val[i]') | i(12) }}
+""", myself=self)
 
 class MemoryChunkArguments(MemoryChunkLonglivedArray):
     r"""
@@ -1282,11 +1282,11 @@ class MemoryChunkArguments(MemoryChunkLo
             <BLANKLINE>
         """
         return je("""
-cdef {{ self.storage_type.c_ptr_type() }} c_args = self._args
+cdef {{ myself.storage_type.c_ptr_type() }} c_args = self._args
 cdef int i
 for i from 0 <= i < len(args):
-    {{ self.storage_type.assign_c_from_py('self._args[i]', 'args[i]') | i(4) }}
-""", self=self)
+    {{ myself.storage_type.assign_c_from_py('self._args[i]', 'args[i]') | i(4) }}
+""", myself=self)
 
     def pass_argument(self):
         r"""
@@ -1383,9 +1383,9 @@ class MemoryChunkScratch(MemoryChunkLong
         # XXX This is a lot slower than it needs to be, because
         # we don't have a "cdef int i" in scope here.
         return je("""
-for i in range(self._n_{{ self.name }}):
-    Py_CLEAR(self._{{ self.name }}[i])
-""", self=self)
+for i in range(self._n_{{ myself.name }}):
+    Py_CLEAR(self._{{ myself.name }}[i])
+""", myself=self)
 
 class MemoryChunkRRRetval(MemoryChunk):
     r"""
@@ -1418,8 +1418,8 @@ class MemoryChunkRRRetval(MemoryChunk):
             u'        cdef RealNumber retval = (self.domain)()\n'
         """
         return je("""
-        cdef RealNumber {{ self.name }} = (self.domain)()
-""", self=self)
+        cdef RealNumber {{ myself.name }} = (self.domain)()
+""", myself=self)
         
     def pass_argument(self):
         r"""
@@ -1432,7 +1432,7 @@ class MemoryChunkRRRetval(MemoryChunk):
             sage: mc.pass_argument()
             u'&retval.value'
         """
-        return je("""&{{ self.name }}.value""", self=self)
+        return je("""&{{ myself.name }}.value""", myself=self)
 
     def pass_call_c_argument(self):
         r"""
@@ -1479,9 +1479,9 @@ class MemoryChunkPythonArguments(MemoryC
             u"        count = args['args']\n        self._n_args = count\n"
         """
         return je("""
-        count = args['{{ self.name }}']
+        count = args['{{ myself.name }}']
         self._n_args = count
-""", self=self)
+""", myself=self)
 
     def setup_args(self):
         r"""
@@ -1579,8 +1579,8 @@ class MemoryChunkPyConstant(MemoryChunk)
             u'    cdef object _domain\n'
         """
         return je("""
-    cdef object _{{ self.name }}
-""", self=self)
+    cdef object _{{ myself.name }}
+""", myself=self)
 
     def init_class_members(self):
         r"""
@@ -1595,8 +1595,8 @@ class MemoryChunkPyConstant(MemoryChunk)
             u"        self._domain = args['domain']\n"
         """
         return je("""
-        self._{{ self.name }} = args['{{ self.name }}']
-""", self=self)
+        self._{{ myself.name }} = args['{{ myself.name }}']
+""", myself=self)
 
     def declare_parameter(self):
         r"""
@@ -2967,22 +2967,22 @@ class InterpreterGenerator(object):
 /* Automatically generated by ext/gen_interpreters.py.  Do not edit! */
 #include <Python.h>
 {% print s.header %}
-{{ self.func_header() }} {
+{{ myself.func_header() }} {
   while (1) {
     switch (*code++) {
-""", s=s, self=self, i=indent_lines))
+""", s=s, myself=self, i=indent_lines))
         for instr_desc in s.instr_descs:
             self.gen_code(instr_desc, w)
         w(je("""
     }
   }
-{% if self.uses_error_handler %}
+{% if myself.uses_error_handler %}
 error:
   return {{ s.err_return }};
 {% endif %}
 }
 
-""", s=s, i=indent_lines, self=self))
+""", s=s, i=indent_lines, myself=self))
 
     def write_wrapper(self, write):
         r"""
@@ -3059,7 +3059,7 @@ cdef extern from "tupleobject.h":
 from sage.ext.fast_callable cimport Wrapper
 {% print s.pyx_header %}
 
-cdef extern {{ self.func_header(cython=true) -}}
+cdef extern {{ myself.func_header(cython=true) -}}
 {% if s.err_return != 'NULL' %}
  except? {{ s.err_return -}}
 {% endif %}
@@ -3146,7 +3146,7 @@ metadata = InterpreterMetadata(by_opname
 {% endfor %}
  ],
  ipow_range={{ s.ipow_range }})
-""", s=s, self=self, types=types, arg_ch=arg_ch, indent_lines=indent_lines, the_call=the_call, the_call_c=the_call_c, do_cleanup=do_cleanup))
+""", s=s, myself=self, types=types, arg_ch=arg_ch, indent_lines=indent_lines, the_call=the_call, the_call_c=the_call_c, do_cleanup=do_cleanup))
 
     def write_pxd(self, write):
         r"""
@@ -3199,7 +3199,7 @@ cdef class Wrapper_{{ s.name }}(Wrapper)
                      {{ arg_ch.storage_type.c_ptr_type() }} args,
                      {{ arg_ch.storage_type.c_ptr_type() }} result) except 0
 {% endif %}
-""", s=s, self=self, types=types, indent_lines=indent_lines, arg_ch=arg_ch))
+""", s=s, myself=self, types=types, indent_lines=indent_lines, arg_ch=arg_ch))
 
     def get_interpreter(self):
         r"""
diff --git a/sage/server/notebook/template.py b/sage/server/notebook/template.py
--- a/sage/server/notebook/template.py
+++ b/sage/server/notebook/template.py
@@ -28,12 +28,12 @@ AUTHORS:
 #  The full text of the GPL is available at:
 #                  http://www.gnu.org/licenses/
 #############################################################################
-import jinja
+import jinja2
 import sage.misc.misc
 from sage.version import version
 
 TEMPLATE_PATH = sage.misc.misc.SAGE_ROOT + '/devel/sage/sage/server/notebook/templates'
-env = jinja.Environment(loader=jinja.FileSystemLoader(TEMPLATE_PATH))
+env = jinja2.Environment(loader=jinja2.FileSystemLoader(TEMPLATE_PATH))
 
 def contained_in(container):
     """
@@ -100,7 +100,7 @@ def template(filename, **user_context):
     """
     try:
         tmpl = env.get_template(filename)
-    except jinja.exceptions.TemplateNotFound:
+    except jinja2.exceptions.TemplateNotFound:
         return template('template_error.html', template=filename)
     context = dict(default_context)
     context.update(user_context)