How to force Jinja2 templates to recompile?
Question: I'm trying to switch Jinja2 template in the django app without restarting the
application.

Has anyone done this? Basically I need to force jinja2 to reload the templates
once the skin selection change is applied.

I've tried to re-create cache object on the template environment object with
no effect.

myskin_utils.py:

    
    
    from jinja2.environment import create_cache
    ENV_OBJECT.cache = create_cache(50)
    

I've also tried to reload the module that contains my ENV_OBJECT with

    
    
    reload(myskin) #also no effect on the output
    

Another thing I'd like to change on the fly is language, but I guess it's a
separate question.

Thanks for any advice.

**edit:** I don't have cache set up with jinja2, but I do see a speed up from
using Jinja after switching from Django templates, I suspect that template
bytecode lives in the compiled code of my view functions but I did not look
into details of jinja.

I have ENV (an instance of `CoffinEnvironment` which subclasses Jinja's
`Environment`) imported in the global namespace of a view module and calls
`ENV.get_template()` inside view functions (Django+Coffin+Jinja2).

Found that if I call python's `reload()` builtin on my environment module
**within** the view function the template does switch, but I would not like to
stick that code into every function.


Answer: Per default Jinja2 doesn't use any caching at all, but it's recommended to
configure a caching backend to speed things up a little bit. So that jinja2
doesn't have to parse and compile every template on every requests. Jinja2
supports currently 2 different cache types out of the box:

One of them is `FileSystemBytecodeCache` which is (like the name suggests)
file based. So all compiled templates are stored on the file system and
retrieved from there. If you look closely at the implementation, you will also
find a `cache.clear()` method there which simply deletes all files in this
temporary folder. Causing all templates to be parsed/compiled again.

The other cache type is a called `MemcachedBytecodeCache` which is just a thin
wrapper for Memcache. This method is recommended, because Memcache stores
everything in memory, so it's a little bit faster than hitting the disk, and
you can use the same cache from different hosts (which is useful if you are
running some kind of cluster).

The underlying Memcache client (either werkzeug.contrib.cache, python-
memcached or cmemcache) does also provide a `clear()` method which will delete
everything inside the cache. But because you probably use the cache for other
things too (e.g. storing the result of expensive database queries there), the
`clear()` method isn't exposed in jinja, because it will affect everything
(and not just the templates).

So, to summarize your options are:

  * Use Jinja2 without a Cache
  * Use Jinja2 with a `FileSystemBytecodeCache` and call `cache.clear()`
  * Use Jinja2 with a `MemcachedBytecodeCache` and call `memcache_client.clear()` (which will also clear everything else in the cache).
  * Run a separate memcached process on another port which is only used with Jinja2. Then call `memcache_client.clear()` and all templates will be cleared.

