system: You are an expert security code reviewer. You will be shown a source code file. Your task is to name the single function or class that contains the specified CWE vulnerability.

OUTPUT FORMAT: Respond with the exact function or class name (no parentheses, no qualifiers, no module prefixes), wrapped in \boxed{...}. Example: `\boxed{salted_hmac}`. Output the boxed name ONLY -- no explanation, no other text.

user: ```python
#!/usr/bin/env python3
#
# generate_docker_compose.py
#
# Generate configuration from Jinja template.
#
# usage: python3 ./script/generate_docker_compose.py
# (call only from root repository)
#
# Generate configuration with .env.values:
# - from docker-compose.yml.template (Jinja template) to docker-compose.yml
# - from ./build/**/*.template (Jinja template) to ./build/**/*

import configparser
import os
import sys
import re

import glob2
import jinja2

def read_context(file_path):
    """Read a configuration file (bash compatible with source).

    Parameters
    ----------
    file_path : string
        Configuration file (bash compatible with source).

    Returns
    -------
    dict
        Configuration under the shape of dictionnary (key, value).
    """
    with open(file_path, "r") as desc:
        _buffer = "[section]\n"
        _buffer += desc.read()
    config = configparser.RawConfigParser()
    # preserve case
    config.optionxform = str
    config.read_string(_buffer)
    return dict(config.items("section"))

def render(template_path, context, generate_file=True, begin_comment="#", end_comment=''):
    """From a template Jinja (with extension .template) and a context
    generate a configuration and create a file (without extension .template)
    if precised. Add a header to this configuration to mark the file as
    generated.

    Parameters
    ----------
    template_path : string
        Path file to Jinja template (with extension .template).

    context : dict
       (key, value) parameters to feed to JinJa template.

    generate_file : bool (optional, by default True)
        If true, persist generated configuration to a file in same directory
        than Jinja template (without extension .template).

    begin_comment : string (optional, by default #)
        begin token for inline comment in generated configuration

    end_comment : string (optional, by default empty)
        end token for inline comment in generated configuration

    Returns
    -------
    string
        Content of generated configuration file
    """
    path, filename = os.path.split(template_path)
    content = jinja2.Environment(
        loader=jinja2.FileSystemLoader(path)
    ).get_template(filename).render(context)
    # delete .template extension
    conf_filename, _ = os.path.splitext(filename)
    conf_path = os.path.join(path, conf_filename)
    content = "{} {}{}\n{} {}{}\n\n{}".format(
        begin_comment,
        "Generated from Jinja template",
        end_comment,
        begin_comment,
        "DO NOT EDIT THIS FILE BY HAND -- YOUR CHANGES WILL BE OVERWRITTEN",
        end_comment,
        content)
    if generate_file:
        with open(conf_path, "w") as desc:
            desc.write(content)
    return content

if __name__ == "__main__":
    print("=== generate docker compose configuration ===")
    if not os.path.isfile(".env.values"):
        print("ERROR: .env.values doesn't exist!", file=sys.stderr)
        sys.exit(1)
    if not os.path.isfile("docker-compose.yml.template"):
        print("ERROR: docker-compose.yml.template doesn't exist!", file=sys.stderr)
        sys.exit(1)
    context = read_context(".env.values")
    print("render docker-compose.yml.template")
    render("docker-compose.yml.template", context)
    print("...OK")
    print("=== generate template configuration for build ===")
    for template in glob2.glob('./build/**/*.template', recursive=True):
        if not os.path.isfile(template):
            continue
        print("render {}".format(template))
        begin_comment = '#'
        end_comment = ''
        basename = os.path.basename(template)
        basename = re.sub('.template$', '', basename)
        if basename == 'supervisord.conf':
            begin_comment = ';'
        elif basename.endswith('.html'):
            begin_comment = '<!--'
            end_comment = ' -->'
        render(template, context, begin_comment=begin_comment, end_comment=end_comment)    
    print("...OK")


```

Name the function or class in this code that contains a `CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')` vulnerability.
Answer: render