API Reference

Application Object

class nereid.Nereid(**config)[source]


Unlike typical web frameworks and their APIs, nereid depends more on configuration and not direct python modules written along the APIs Most of the functional code will remain on the modules installed on Tryton, and the database configurations.



The default timeout to use if the timeout is not explicitly specified in the set or set many argument


The directory where cache files are stored if FileSystemCache is used


If a custom cache backend unknown to Nereid is used, then the arguments that are needed for the initialisation of the cache could be passed here as a dict


a prefix that is added before all keys. This makes it possible to use the same memcached server for different applications. Applies for: MecachedCache, GAEMemcachedCache If key_prefix is none the value of site is used as key


a list or tuple of server addresses or alternatively a memcache.Client or a compatible client.


the maximum number of items the cache stores before it starts deleting some items. Applies for: SimpleCache, FileSystemCache


The type of cache to use. The type must be a full specification of the module so that an import can be made. Examples for werkzeug backends are given below

NullCache - werkzeug.contrib.cache.NullCache (default) SimpleCache - werkzeug.contrib.cache.SimpleCache MemcachedCache - werkzeug.contrib.cache.MemcachedCache GAEMemcachedCache - werkzeug.contrib.cache.GAEMemcachedCache FileSystemCache - werkzeug.contrib.cache.FileSystemCache

Extend the default jinja environment that is created. Also the environment returned here should be specific to the current website.

create_url_adapter(*args, **kwargs)[source]

Creates a URL adapter for the given request. The URL adapter is created at a point where the request context is not yet set up so the request is passed explicitly.


Return connection to Database backend of tryton


The name of the database to connect to on initialisation


Does the request dispatching. Matches the URL and returns the return value of the view or error handler. This does not have to be a response object.


Load the template eagerly. This would render the template immediately and still return a LazyRenderer. This is useful in debugging issues that may be hard to debug with lazy rendering

get_context_processors(*args, **kwargs)[source]

Returns the method object which wraps context processor methods formed by decorating methods with the context_processor() decorator.

This method goes through all the models and their methods in the pool of the loaded database and looks for the _context_processor attribute in them and adds to context_processor dict.

get_template_filters(*args, **kwargs)[source]

Returns a list of name, function pairs for template filters registered in the models using template_filter() decorator.


Return the URL rules for routes formed by decorating methods with the route() decorator.

This method goes through all the models and their methods in the pool of the loaded database and looks for the _url_rules attribute in them. If there are URLs defined, it is added to the url map.


The application needs initialisation to load the database connection etc. In previous versions this was done with the initialisation of the class in the __init__ method. This is now separated into this function.

initialised = False

boolean attribute to indicate if the initialisation of backend connection and other nereid support features are loaded. The application can work only after the initialisation is done. It is not advisable to set this manually, instead call the initialise()


Creates the loader for the Jinja2 Environment


This method loads the configuration file if specified and also connects to the backend, initialising the pool on the go


Load the cache and assign the Cache interface to


A proxy to the _pool


The class that is used for request objects. See Request for more information.

alias of Request


The class that is used for response objects. See Response for more information.

alias of Response


Returns True if autoescaping should be active for the given template name.

session_interface = <nereid.sessions.NereidSessionInterface object>

the session interface to use. By default an instance of NereidSessionInterface is used here.


Prefix the name of the website to the template name sutomatically This feature would be deprecated in future in lieu of writing Jinja2 Loaders which could offer this behavior. This is set to False by default. For backward compatibility of loading templates from a template folder which has website names as subfolders, set this to True

New in version


Time in seconds for which the token is valid.


The location where the translations of the template are stored


Configuration file for Tryton. The path to the configuration file can be specified and will be loaded when the application is initialised


The rule object to use for URL rules created. This is used by add_url_rule(). Defaults to nereid.routing.Rule.

New in version

alias of Rule


class nereid.templating.LazyRenderer(template_name_or_list, context, headers=None, eager=False)[source]

A Lazy Rendering object which when called renders the template with the current context.

>>> lazy_render_object = LazyRenderer('template.html', {'a': 1})

You can change the context by setting values to the contex dictionary

>>> lazy_render_object.context['a'] = 100

You can also change the template(s) that should be rendered

>>> lazy_render_object.template_name_or_list = "another-template.html"

or even, change it into an iterable of templates

>>> lazy_render_object.template_name_or_list = ['t1.html', 't2.html']

The template can be rendered and serialized to unicode by calling

>>> unicode(lazy_render_object)

The status code or header can also be set on the lazy renderer

>>> lazy_render_object.sattus = 201
>>> lazy_render_object.headers['X-Some-Header'] = 'header value'


If the template renders objects which depend on the application, request or a tryton transaction context (like an active record), the call must be made within those contexts.


Return the rendered template with the current context


Return the rendered template with the current context

class nereid.templating.ModuleTemplateLoader(database_name=None, searchpath=None)[source]

This loader works like the ChoiceLoader and loads templates from a filesystem path (optional) followed by the template folders in the tryton module path. The template folders are ordered by the same order in which Tryton arranges modules based on the dependencies.

The optional keyword argument searchpath could be used to specify local folder which contains templates which may override the templates bundled into nereid modules.

  • database_name – The name of the Tryton database. This is required since the modules installed in a database is what matters and not the modules in the site-packages
  • searchpath – Optional filesystem path where templates that override templates bundled with nereid are located.

New in version

Changed in version Does not accept prefixing of site name anymore


Lazy load the loaders

nereid.templating.render_template(template_name_or_list, **context)[source]

Returns a lazy renderer object which renders a template from the template folder with the given context. The returned object is an instance of LazyRenderer which has all magic methods implemented to make the object look as close as possible to an unicode object.

LazyRenderer objects are automatically converted into response objects by the WSGI dispatcher into a rendered string by the make_response method.

  • template_name_or_list – the name of the template to be rendered, or an iterable with template names the first one existing will be rendered
  • context – the variables that should be available in the context of the template.
nereid.templating.render_email(from_email, to, subject, text_template=None, html_template=None, cc=None, attachments=None, **context)[source]

Read the templates for email messages, format them, construct the email from them and return the corresponding email message object.

  • from_email – Email From
  • to – Email IDs of direct recepients
  • subject – Email subject
  • text_template – <Text email template path>
  • html_template – <HTML email template path>
  • cc – Email IDs of Cc recepients
  • attachments – A dict of filename:string as key value pair [preferable file buffer streams]
  • context – Context to be sent to template rendering

Email multipart instance or Text/HTML part


nereid.helpers.url_for(endpoint, **values)[source]

Generates a URL to the given endpoint with the method provided. The endpoint is relative to the active module if modules are in use.

The functionality is documented in flask.helpers.url_for

In addition to the arguments provided by flask, nereid allows the locale of the url to be generated to be specified using the locale attribute. The default value of locale is the locale of the current request.

For example:

url_for('nereid.website.home', locale='en-us')
nereid.helpers.route(rule, **options)[source]

Like Flask.route() but for nereid.

New in version

Unlike the implementation in flask and flask.blueprint route decorator does not require an existing nereid application or a blueprint instance. Instead the decorator adds an attribute to the method called _url_rules.

from nereid import route

class Product:
    __name__ = 'product.product'

    def render_product(cls, uri):
        return 'Product Information'

Makes method available in template context. By default method will be registered by its name.

Decorator adds an attribute to the method called _context_processor.

from nereid import context_processor

class Product:
    __name__ = 'product.product'

    def get_sale_price(cls):
        return 'Product sale price'

If you want to register your own filters in Jinja2 you have two ways to do that. You can either put them by hand into the jinja_env of the application or use the template_filter() decorator.

The two following examples work the same and both reverse an object:

from nereid import template_filter

class MyModel:
    __name__ = 'product.product'

    def reverse_filter(cls, s):
        return s[::-1]

Alternatively you can inject it into the jinja environment in your application.py:

def reverse_filter(s):
    return s[::-1]
app.jinja_env.filters['reverse'] = reverse_filter

In case of the decorator the argument is optional if you want to use the function name as name of the filter. Once registered, you can use the filter in your templates in the same way as Jinja2’s builtin filters, for example if you have a Python list in context called mylist:

{% for x in mylist | reverse %}
{% endfor %}

Testing Helpers

class nereid.testing.NereidTestApp(**config)[source]

A Nereid app which works by removing transaction handling around the wsgi app


Skip the transaction handling and call the _dispatch_request


Just reuse the pool and DB already loaded by the tryton test loader


There is no need of a separate root transaction as everything could be loaded in the transaction context provided in the test case