'Finds all the templates the loader can find, compiles them
and stores them in `target`.  If `zip` is `None`, instead of in a
zipfile, the templates will be stored in a directory.
By default a deflate zip algorithm is used. To switch to
the stored algorithm, `zip` can be set to ``\'stored\'``.
`extensions` and `filter_func` are passed to :meth:`list_templates`.
Each template returned will be compiled to the target folder or
zipfile.
By default template compilation errors are ignored.  In case a
log function is provided, errors are logged.  If you want template
syntax errors to abort the compilation you can set `ignore_errors`
to `False` and you will get an exception on syntax errors.
If `py_compile` is set to `True` .pyc files will be written to the
target instead of standard .py files.  This flag does not do anything
on pypy and Python 3 where pyc files are not picked up by itself and
don\'t give much benefit.
.. versionadded:: 2.4'

def compile_templates(self, target, extensions=None, filter_func=None, zip='deflated', log_function=None, ignore_errors=True, py_compile=False):

    from jinja2.loaders import ModuleLoader
    if (log_function is None):
        log_function = (lambda x: None)
    if py_compile:
        if ((not PY2) or PYPY):
            from warnings import warn
            warn(Warning('py_compile    has    no    effect    on    pypy    or    Python    3'))
            py_compile = False
        else:
            import imp
            import marshal
            py_header = (imp.get_magic() + u'\xff\xff\xff\xff'.encode('iso-8859-15'))
            if (sys.version_info >= (3, 3)):
                py_header += u'\x00\x00\x00\x00'.encode('iso-8859-15')
    def write_file(filename, data, mode):
        if zip:
            info = ZipInfo(filename)
            info.external_attr = (493 << 16)
            zip_file.writestr(info, data)
        else:
            f = open(os.path.join(target, filename), mode)
            try:
                f.write(data)
            finally:
                f.close()
    if (zip is not None):
        from zipfile import ZipFile, ZipInfo, ZIP_DEFLATED, ZIP_STORED
        zip_file = ZipFile(target, 'w', dict(deflated=ZIP_DEFLATED, stored=ZIP_STORED)[zip])
        log_function(('Compiling    into    Zip    archive    "%s"' % target))
    else:
        if (not os.path.isdir(target)):
            os.makedirs(target)
        log_function(('Compiling    into    folder    "%s"' % target))
    try:
        for name in self.list_templates(extensions, filter_func):
            (source, filename, _) = self.loader.get_source(self, name)
            try:
                code = self.compile(source, name, filename, True, True)
            except TemplateSyntaxError as e:
                if (not ignore_errors):
                    raise
                log_function(('Could    not    compile    "%s":    %s' % (name, e)))
                continue
            filename = ModuleLoader.get_module_filename(name)
            if py_compile:
                c = self._compile(code, encode_filename(filename))
                write_file((filename + 'c'), (py_header + marshal.dumps(c)), 'wb')
                log_function(('Byte-compiled    "%s"    as    %s' % (name, (filename + 'c'))))
            else:
                write_file(filename, code, 'w')
                log_function(('Compiled    "%s"    as    %s' % (name, filename)))
    finally:
        if zip:
            zip_file.close()
    log_function('Finished    compiling    templates')
