In the last days I tried to get Jinja2 working with Django.
Here I want to explain a bit about the integration progress.
First we need to install django and jinja2, but I won’t explain it in here, just use easy_install.
After installing you can check if everything works by importing django and jinja2 inside a python shell.
If it works we need to create a django project and a example application. (Go for the django tutorial if you don’t know how to do this).
Now we need to tell django to use jinja2 to render templates.
The best way to do this is creating a little lib with function to do this which one can import into the views.
So we create inside our project root a directory called libs and there an empty __init__.py file and a file for the jinja2 things.
Lets call it jin.py.
Inside this file we want to create a render_to_response function for jinja2 templates which can be imported from any view.
So here we go:
from django.http import HttpResponse
from django.conf import settings
from django.utils import translation
from django.core.urlresolvers import get_callable
from jinja2 import FileSystemLoader, Environment, PackageLoader, ChoiceLoader
from functools import wraps
loader_array = []
for pth in getattr(settings, 'TEMPLATE_DIRS', ()):
loader_array.append(FileSystemLoader(pth))
for app in settings.INSTALLED_APPS:
loader_array.append(PackageLoader(app))
default_mimetype = getattr(settings, 'DEFAULT_CONTENT_TYPE')
global_exts = getattr(settings, 'JINJA_EXTS', ())
env = Environment(extensions=global_exts, loader=ChoiceLoader(loader_array))This creates the basic jinja2 environment. Notice that it automatically reads the TEMPLATE_DIRS from settings.py and furthermore you can declare inside the settings file which jinja2 extensions should be loaded.
if 'jinja2.ext.i18n' in global_exts:
env.install_gettext_translations(translation)
global_imports = getattr(settings, 'JINJA_GLOBALS', ())
for imp in global_imports:
method = get_callable(imp)
method_name = getattr(method,'jinja_name',None)
if not method_name == None:
env.globals[method_name] = method
else:
env.globals[method.__name__] = method
global_filters = getattr(settings, 'JINJA_FILTERS', ())
for imp in global_filters:
method = get_callable(imp)
method_name = getattr(method,'jinja_name',None)
if not method_name == None:
env.filters[method_name] = method
else:
env.filters[method.__name__] = method
global_tests = getattr(settings, 'JINJA_TESTS', ())
for imp in global_tests:
method = get_callable(imp)
method_name = getattr(method,'jinja_name',None)
if not method_name == None:
env.tests[method_name] = method
else:
env.tests[method.__name__] = methodWe can also declare the jinja2 globas, filters and tests inside the settings.py via adding:
JINJA_EXTS = (
'jinja2.ext.i18n',
)
JINJA_GLOBALS = (
)
JINJA_FILTERS = (
)
JINJA_TESTS = (
)to it.
So until now our jinja2 environment contains the i18n extension and all other things added in settings.py.
Time to create a render_to_response function.
def render_to_string(filename, context={}):
template = env.get_template(filename)
rendered = template.render(**context)
return rendered
def render_to_response(filename, context={}, request=None, mimetype=default_mimetype):
if request:
context['request'] = request
context['user'] = request.user
rendered = render_to_string(filename, context)
return HttpResponse(rendered,mimetype=mimetype)This function also adds the user object to the context if a request is available.
Inside a view we can to render a template with jinja2:
from libs.jin import render_to_response
def index(request):
return render_to_response('app_name/index.html')Wow. This wasn’t hard, was it?
But you might notice that the user object still isn’t available.
To get the user object back we would need to pass the request object every time to the render_to_response function. That’s really annoying and looks ugly:
return render_to_response('app_name/index.html',{},request)So we create a decorator with some more nice features inside our jin.py:
def jin_renderer(prefix=None):
def renderer(func):
@wraps(func)
def wrapper(request, *args, **kwargs):
global default_mimetype
response = func(request, *args, **kwargs)
if isinstance(response, HttpResponse):
return response
elif isinstance(response, basestring):
template_name = response
context_processors = {}
mimetype = default_mimetype
elif isinstance(response, (tuple, list)):
len_tuple = len(response)
if len_tuple == 2:
template_name, context_processors = response
mimetype = default_mimetype
elif len_tuple == 3:
template_name, context_processors, mimetype = response
if prefix:
if isinstance(template_name, (list, tuple)):
template_name = map(correct_path, template_name)
else:
template_name = correct_path(template_name)
return render_to_response(template_name,context_processors,request,mimetype)
return wrapper
def correct_path(template_name):
if template_name.startswith('/'):
return template_name[1:]
return '%s%s' % (prefix, template_name)
return rendererWhen using this renderer the request object is always available and we can also define a template prefix path.
Using this new renderer is very easy, too:
from libs.jin import jin_renderer
render_to_html = jin_renderer('app_name/')
@render_to_html
def index(request):
return 'index.html',{'test':'some context test'}Now the index.html side your templates/app_name/ will be rendered.
These sites helped me creating the code:
http://jinja.pocoo.org/2/documentation/
http://www.djangosnippets.org/snippets/1112/
http://www.djangosnippets.org/snippets/1061/
http://tinyurl.com/57mojt
