Cache Arguments¶

Mako has two cache arguments available on tags that are available in all cases. The rest of the arguments available are specific to a backend.

The two generic tags arguments are:

• cached="True" - enable caching for this <%page>, <%def>, or <%block>.

• cache_key - the “key” used to uniquely identify this content in the cache. Usually, this key is chosen automatically based on the name of the rendering callable (i.e. body when used in <%page>, the name of the def when using <%def>, the explicit or internally-generated name when using <%block>). Using the cache_key parameter, the key can be overridden using a fixed or programmatically generated value.

  For example, here’s a page that caches any page which inherits from it, based on the filename of the calling template:

  <%page cached="True" cache_key="${self.filename}"/>
  
  ${next.body()}
  
  ## rest of template
  

On a Template or TemplateLookup, the caching can be configured using these arguments:

• cache_enabled - Setting this to False will disable all caching functionality when the template renders. Defaults to True. e.g.:

  lookup = TemplateLookup(
                  directories='/path/to/templates',
                  cache_enabled = False
                  )
  

• cache_impl - The string name of the cache backend to use. This defaults to 'beaker', which has historically been the only cache backend supported by Mako.

  New in version 0.6.0.

  For example, here’s how to use the upcoming dogpile.cache backend:

  lookup = TemplateLookup(
                  directories='/path/to/templates',
                  cache_impl = 'dogpile.cache',
                  cache_args = {'regions':my_dogpile_regions}
                  )
  

• cache_args - A dictionary of cache parameters that will be consumed by the cache backend. See Using the Beaker Cache Backend for examples.

  New in version 0.6.0.

from beaker.cache import CacheManager

manager = CacheManager(cache_regions={
    'short_term':{
        'type': 'memory',
        'expire': 60
    },
    'long_term':{
        'type': 'ext:memcached',
        'url': '127.0.0.1:11211',
        'expire': 300
    }
})

lookup = TemplateLookup(
                directories=['/path/to/templates'],
                module_directory='/path/to/modules',
                cache_impl='beaker',
                cache_args={
                    'manager':manager
                }
        )

<%page cached="True" cache_region="short_term">

## ...

<%block name="header" cached="True" cache_region="long_term">
    other text
</%block>

Programmatic Cache Access¶

The Template, as well as any template-derived Namespace, has an accessor called cache which returns the Cache object for that template. This object is a facade on top of the underlying CacheImpl object, and provides some very rudimental capabilities, such as the ability to get and put arbitrary values:

<%
    local.cache.set("somekey", type="memory", "somevalue")
%>

Above, the cache associated with the local namespace is accessed and a key is placed within a memory cache.

More commonly, the cache object is used to invalidate cached sections programmatically:

template = lookup.get_template('/sometemplate.html')

# invalidate the "body" of the template
template.cache.invalidate_body()

# invalidate an individual def
template.cache.invalidate_def('somedef')

# invalidate an arbitrary key
template.cache.invalidate('somekey')

You can access any special method or attribute of the CacheImpl itself using the impl attribute:

template.cache.impl.do_something_special()

Note that using implementation-specific methods will mean you can’t swap in a different kind of CacheImpl implementation at a later time.

Cache Plugins¶

The mechanism used by caching can be plugged in using a CacheImpl subclass. This class implements the rudimental methods Mako needs to implement the caching API. Mako includes the BeakerCacheImpl class to provide the default implementation. A CacheImpl class is acquired by Mako using a pkg_resources entrypoint, using the name given as the cache_impl argument to Template or TemplateLookup. This entry point can be installed via the standard setuptools/setup() procedure, underneath the EntryPoint group named "mako.cache". It can also be installed at runtime via a convenience installer register_plugin() which accomplishes essentially the same task.

An example plugin that implements a local dictionary cache:

from mako.cache import Cacheimpl, register_plugin

class SimpleCacheImpl(CacheImpl):
    def __init__(self, cache):
        super(SimpleCacheImpl, self).__init__(cache)
        self._cache = {}

    def get_or_create(self, key, creation_function, **kw):
        if key in self._cache:
            return self._cache[key]
        else:
            self._cache[key] = value = creation_function()
            return value

    def set(self, key, value, **kwargs):
        self._cache[key] = value

    def get(self, key, **kwargs):
        return self._cache.get(key)

    def invalidate(self, key, **kwargs):
        self._cache.pop(key, None)

# optional - register the class locally
register_plugin("simple", __name__, "SimpleCacheImpl")

Enabling the above plugin in a template would look like:

t = Template("mytemplate",
             file="mytemplate.html",
             cache_impl='simple')

API Reference¶

class mako.cache.Cache(template, *args)¶

Bases: object

Represents a data content cache made available to the module space of a specific Template object.

New in version 0.6: Cache by itself is mostly a container for a CacheImpl object, which implements a fixed API to provide caching services; specific subclasses exist to implement different caching strategies. Mako includes a backend that works with the Beaker caching system. Beaker itself then supports a number of backends (i.e. file, memory, memcached, etc.)

The construction of a Cache is part of the mechanics of a Template, and programmatic access to this cache is typically via the Template.cache attribute.

get(key, **kw)¶

Retrieve a value from the cache.

Parameters:	key – the value’s key. **kw – cache configuration arguments. The backend is configured using these arguments upon first request. Subsequent requests that use the same series of configuration values will use that same backend.

get_or_create(key, creation_function, **kw)¶

Retrieve a value from the cache, using the given creation function to generate a new value.

id = None¶

Return the ‘id’ that identifies this cache.

This is a value that should be globally unique to the Template associated with this cache, and can be used by a caching system to name a local container for data specific to this template.

impl = None¶

Provide the CacheImpl in use by this Cache.

This accessor allows a CacheImpl with additional methods beyond that of Cache to be used programmatically.

invalidate(key, **kw)¶

Invalidate a value in the cache.

Parameters:	key – the value’s key. **kw – cache configuration arguments. The backend is configured using these arguments upon first request. Subsequent requests that use the same series of configuration values will use that same backend.

invalidate_body()¶

Invalidate the cached content of the “body” method for this template.

invalidate_closure(name)¶

Invalidate a nested <%def> within this template.

Caching of nested defs is a blunt tool as there is no management of scope – nested defs that use cache tags need to have names unique of all other nested defs in the template, else their content will be overwritten by each other.

invalidate_def(name)¶

Invalidate the cached content of a particular <%def> within this template.

put(key, value, **kw)¶

A synonym for Cache.set().

This is here for backwards compatibility.

set(key, value, **kw)¶

Place a value in the cache.

Parameters:	key – the value’s key. value – the value. **kw – cache configuration arguments.

starttime = None¶

Epochal time value for when the owning Template was first compiled.

A cache implementation may wish to invalidate data earlier than this timestamp; this has the effect of the cache for a specific Template starting clean any time the Template is recompiled, such as when the original template file changed on the filesystem.

class mako.cache.CacheImpl(cache)¶

Bases: object

Provide a cache implementation for use by Cache.

get(key, **kw)¶

Retrieve a value from the cache.

Parameters:	key – the value’s key. **kw – cache configuration arguments.

get_or_create(key, creation_function, **kw)¶

Retrieve a value from the cache, using the given creation function to generate a new value.

This function must return a value, either from the cache, or via the given creation function. If the creation function is called, the newly created value should be populated into the cache under the given key before being returned.

Parameters:	key – the value’s key. creation_function – function that when called generates a new value. **kw – cache configuration arguments.

invalidate(key, **kw)¶

Invalidate a value in the cache.

Parameters:	key – the value’s key. **kw – cache configuration arguments.

pass_context = False¶

If True, the Context will be passed to get_or_create as the name 'context'.

set(key, value, **kw)¶

Place a value in the cache.

Parameters:	key – the value’s key. value – the value. **kw – cache configuration arguments.

mako.cache.register_plugin(self, name, modulepath, objname)¶

class mako.ext.beaker_cache.BeakerCacheImpl(cache)¶

Bases: mako.cache.CacheImpl

A CacheImpl provided for the Beaker caching system.

This plugin is used by default, based on the default value of 'beaker' for the cache_impl parameter of the Template or TemplateLookup classes.