ram imports: String list of Python statements, typically individual
 "import" lines, which will be placed into the module level
 preamble of all generated Python modules. See the example
 in :ref:`filtering_default_filters`.

:param future_imports: String list of names to import from `__future__`.
 These will be concatenated into a comma-separated string and inserted
 into the beginning of the template, e.g. ``futures_imports=['FOO',
 'BAR']`` results in ``from __future__ import FOO, BAR``.

:param include_error_handler: An error handler that runs when this template
 is included within another one via the ``<%include>`` tag, and raises an
 error.  Compare to the :paramref:`.Template.error_handler` option.

 .. versionadded:: 1.0.6

 .. seealso::

    :paramref:`.Template.error_handler` - top-level error handler function

:param input_encoding: Encoding of the template's source code.  Can
 be used in lieu of the coding comment. See
 :ref:`usage_unicode` as well as :ref:`unicode_toplevel` for
 details on source encoding.

:param lookup: a :class:`.TemplateLookup` instance that will be used
 for all file lookups via the ``<%namespace>``,
 ``<%include>``, and ``<%inherit>`` tags. See
 :ref:`usage_templatelookup`.

:param module_directory: Filesystem location where generated
 Python module files will be placed.

:param module_filename: Overrides the filename of the generated
 Python module file. For advanced usage only.

:param module_writer: A callable which overrides how the Python
 module is written entirely.  The callable is passed the
 encoded source content of the module and the destination
 path to be written to.   The default behavior of module writing
 uses a tempfile in conjunction with a file move in order
 to make the operation atomic.   So a user-defined module
 writing function that mimics the default behavior would be:

 .. sourcecode:: python

     import tempfile
     import os
     import shutil

     def module_writer(source, outputpath):
         (dest, name) = \\
             tempfile.mkstemp(
                 dir=os.path.dirname(outputpath)
             )

         os.write(dest, source)
         os.close(dest)
         shutil.move(name, outputpath)

     from mako.template import Template
     mytemplate = Template(
                     filename="index.html",
                     module_directory="/path/to/modules",
                     module_writer=module_writer
                 )

 The function is provided for unusual configurations where
 certain platform-specific permissions or other special
 steps are needed.

:param output_encoding: The encoding to use when :meth:`.render`
 is called.
 See :ref:`usage_unicode` as well as :ref:`unicode_toplevel`.

:param preprocessor: Python callable which will be passed
 the full template source before it is parsed. The return
 result of the callable will be used as the template source
 code.

:param lexer_cls: A :class:`.Lexer` class used to parse
 the template.   The :class:`.Lexer` class is used by
 default.

 .. versionadded:: 0.7.4

:param strict_undefined: Replaces the automatic usage of
 ``UNDEFINED`` for any undeclared variables not located in
 the :class:`.Context` with an immediate raise of
 ``NameError``. The advantage is immediate reporting of
 missing variables which include the name.

 .. versionadded:: 0.3.6

:param uri: string URI or other identifier for this template.
 If not provided, the ``uri`` is generated from the filesystem
 path, or from the in-memory identity of a non-file-based
 template. The primary usage of the ``uri`` is to provide a key
 within :class:`.TemplateLookup`, as well as to generate the
 file path of the generated Python module file, if
 ``module_directory`` is specified.

Nc