English ▼
Skip to page content Skip to main navigation
e.g. "templates" or "datastore"

# Using Templates

HTML embedded in code is messy and difficult to maintain. It's better to use a templating system, where the HTML is kept in a separate file with special syntax to indicate where the data from the application appears. There are many templating systems for Python: EZT, Cheetah, ClearSilver, Quixote, Django, and Jinja2 are just a few. You can use your template engine of choice by bundling it with your application code.

For your convenience, App Engine includes the Django and Jinja2 templating engines.

## Using Jinja2 Templates

First add the following to the bottom of `helloworld/app.yaml`:

    libraries:
    - name: jinja2
      version: latest

This configuration makes the newest supported version of Jinja2 available to your application. To avoid possible compatibility issues, serious applications should use an actual version number rather than `latest`.

Now add the following statements at the top of `helloworld/helloworld.py`:

    import jinja2
    import os

    jinja_environment = jinja2.Environment(
        loader=jinja2.FileSystemLoader(os.path.dirname(__file__)))

Replace the `MainPage` handler with code that resembles the following:

    class MainPage(webapp2.RequestHandler):
        def get(self):
            guestbook_name=self.request.get('guestbook_name')
            greetings_query = Greeting.all().ancestor(
                guestbook_key(guestbook_name)).order('-date')
            greetings = greetings_query.fetch(10)

            if users.get_current_user():
                url = users.create_logout_url(self.request.uri)
                url_linktext = 'Logout'
            else:
                url = users.create_login_url(self.request.uri)
                url_linktext = 'Login'

            template_values = {
                'greetings': greetings,
                'url': url,
                'url_linktext': url_linktext,
            }

            template = jinja_environment.get_template('index.html')
            self.response.out.write(template.render(template_values))

Finally, create a new file in the `helloworld` directory named `index.html`, with the following contents:

    <html>
      <body>
        {% for greeting in greetings %}
          {% if greeting.author %}
            <b>{{ greeting.author.nickname() }}</b> wrote:
          {% else %}
            An anonymous person wrote:
          {% endif %}
          <blockquote>{{ greeting.content|escape }}</blockquote>
        {% endfor %}

        <form action="/sign" method="post">
          <div><textarea name="content" rows="3" cols="60"></textarea></div>
          <div><input type="submit" value="Sign Guestbook"></div>
        </form>

        <a href="{{ url }}">{{ url_linktext }}</a>

      </body>
    </html>

Reload the page, and try it out.

`jinja_environment.get_template(name)` takes the name of a template file, and returns a template object. `template.render(template_values)` takes a dictionary of values, and returns the rendered text. The template uses Jinja2 templating syntax to access and iterate over the values, and can refer to properties of those values. In many cases, you can pass datastore model objects directly as values, and access their properties from templates.

Tip: An App Engine application has read-only access to all of the files uploaded with the project, the library modules, and no other files. The current working directory is the application root directory, so the path to `index.html` is simply `"index.html"`.

## Next...

Every web application returns dynamically generated HTML from the application code, via templates or some other mechanism. Most web applications also need to serve static content, such as images, CSS stylesheets, or JavaScript files. For efficiency, App Engine treats static files differently from application source and data files. You can use App Engine's static files feature to serve a CSS stylesheet for this application.

Continue to Using Static Files.