“If you take big, even reckless, bets and win, you have a great year and you get a great bonus—or in the case of hedge funds, 20% of the profits. If you lose money the following year, you lose your investors’ money rather than your own—and you don’t have to give back last year’s bonus. Heads, you win; tails, you lose someone else’s money.”
Month: April 2008
Django on Google App Engine: Templates and static files
In a previous tutorial we learned how to set up a simple Django project on the Google App Engine. We also saw how to use the App Engine datastore in place of the Django model API.
Now, let’s have a look at how to integrate Django templates. I will also show you how to serve static files.
Important: Remember to upgrade to the latest version of the App Engine SDK (version 1.0.1 at the time of writing). Otherwise, this tutorial will not work for you if you are developing on Windows.
Step 1: Set up an App Engine project—I am calling mine djangostatic. Follow steps 1 through 7 from the previous tutorial, remembering to substitute the project directory path and project name in main.py and app.yaml, and you will be all set.
Step 2: We will create a simple view that makes use of a template. First, let us define the template. Create a directory where you can store templates:
tmp/djangostatic$ cd djangostatic/main tmp/djangostatic/djangostatic/main$ mkdir -p templates/main
Then, add the file main.html to your new template directory:
# djangostatic/djangostatic/main/templates/main/main.html
<html>
<head>
<link href="/css/main.css" type="text/css"
rel="stylesheet"></link>
</head>
<body>
<p>
Hello world!
</p>
</body>
</html>
Note that the template refers to a style sheet file, main.css, which we will create later on.
Step 3: Django needs to be told where to search for template files: this is done in the settings.py file. The settings file is mostly pre-configured; we just have to modify the part that sets the TEMPLATE_DIRS variable:
# djangostatic/djangostatic/settings.py
import os
ROOT_PATH = os.path.dirname(__file__)
TEMPLATE_DIRS = (
ROOT_PATH + "/main/templates",
)
Step 4: After creating the template and telling Django where to find it, we have to write a view that does the actual rendering:
# djangostatic/djangostatic/main/views.py
from django.shortcuts import render_to_response
def main(request):
return render_to_response("main/main.html")
This tells Django to use the template main/main.html when rendering the response. The render_to_response method is a convenient shortcut for rendering a template and returning a response in one step.
Step 5: Finally, we need to map a URL to our view—this is done in urls.py:
# djangostatic/djangostatic/urls.py
from django.conf.urls.defaults import *
urlpatterns = patterns("",
(r"^$", "djangostatic.main.views.main"),
)
Start your development server (dev_appserver.py djangostatic), fire up your browser, and open the page at http://127.0.0.1:8080/. If you have done everything right so far, you should get the “hello world” message from the template.
Step 6: So what about the style sheet file, main.css? A style sheet file is a typical example of a static file. We use Django for rendering dynamic pages, so requests for static files should not be handled by the Django engine. In a regular Django application, we usually configure the web server to route such requests to a specific directory. On the App Engine, we achieve the same effect by adding a static handler to app.yaml:
# djangostatic/app.yaml application: djangostatic version: 1 runtime: python api_version: 1 handlers: - url: /css static_dir: media/css - url: /.* script: main.py
Here, we have added an entry that routes all requests beginning with /css to the directory media/css. Let us create this directory:
tmp/djangostatic$ mkdir -p media/css
Step 7: The link in our template specified /css/main.css as the full URL, so we have to add the main.css file to our new directory:
# djangostatic/media/css/main.css
p {
font-size: 48px;
}
Reload the application page; the browser should now be able to make use of the style sheet so that the message is displayed in a larger font. You can view the final results here.
Final notes: To learn more about how to serve static files on App Engine, have a look at the official documentation on how to configure an app. Django templates are very powerful—this tutorial has only shown you the absolute basics. Visit the Django template documentation to get the full story.
On the value of ignorance
“It is best for the author to be born away from literary centres, or to be excluded from their ruling set if he be born in them. It is best that he starts out with his thinking, not knowing how much has been thought and said about everything.
A certain amount of ignorance will insure his sincerity, will increase his boldness and shelter his genuineness, which is his hope of power.
Not ignorance of life, but life may be learned in any neighborhood;
—not ignorance of the greater laws which govern human affairs, but they may be learned without a library of historians and commentators, by imaginitive sense, by seeing better than by reading;
—not ignorance of the infinitudes of human circumstance, but knowledge of these may come to a man without the intervention of universities;
—not ignorance of one’s self and of one’s neighbor, but innocence of the sophistications of learning, its research without love, its knowledge without inspiration, its method without grace; freedom from its shame at trying to know many things as well as from its pride of trying to know but one thing; ignorance of that faith in small confounding facts which is contempt for large reassuring principles …”
(Woodrow Wilson, “How books become immortal”, 1891)
Django on Google App Engine in 13 simple steps
In this tutorial I will show you how to get a simple datastore-backed Django application up and running on the Google App Engine. I will assume that you are somewhat familiar with Django.
Update 1: You can download the full set of files from here. Make sure to fix the sys.path in main.py.
Update 2: There is now a Turkish translation of this tutorial, courtesy of Türker Sezer.
Update 3: Now in Russian as well.
Update 4: Brazilian Portuguese tranlation by Marcio Andrey Oliveira.
Step 1: Register an app name and install the development kit per the instructions.
Step 2: Create a directory for your application—for this tutorial my application is called mashname:
tmp$ mkdir mashname tmp$ cd mashname
Step 3: Add a file called main.py to your new directory:
# main.py
import os, sys
os.environ["DJANGO_SETTINGS_MODULE"] = "mashname.settings"
sys.path.append("/home/brox/tmp/mashname")
# Google App Engine imports.
from google.appengine.ext.webapp import util
# Force Django to reload its settings.
from django.conf import settings
settings._target = None
import django.core.handlers.wsgi
import django.core.signals
import django.db
import django.dispatch.dispatcher
# Log errors.
#django.dispatch.dispatcher.connect(
# log_exception, django.core.signals.got_request_exception)
# Unregister the rollback event handler.
django.dispatch.dispatcher.disconnect(
django.db._rollback_on_exception,
django.core.signals.got_request_exception)
def main():
# Create a Django application for WSGI.
application = django.core.handlers.wsgi.WSGIHandler()
# Run the WSGI CGI handler with that application.
util.run_wsgi_app(application)
if __name__ == "__main__":
main()
This is basically the same file as suggested here, except I had to set the Python path to be able to test locally. I also had to set the DJANGO_SETTINGS_MODULE—this might not be necessary when running on the App Engine. I had to disable the error logging which I was not able to get working.
Step 4: Add a file called app.yaml to the same directory:
application: mashname version: 1 runtime: python api_version: 1 handlers: - url: /.* script: main.py
Make sure to get the application name right.
Step 5: From your mashname directory, create a new Django project:
tmp/mashname$ django-admin.py startproject mashname
(I’m assuming that your current Django setup is working as it should.)
Step 6: You should now be able to test your application:
tmp/mashname$ cd .. tmp$ dev_appserver.py mashname INFO 2008-04-08 19:08:10,023 appcfg.py] Checking for updates to the SDK. INFO 2008-04-08 19:08:10,384 appcfg.py] The SDK is up to date. INFO 2008-04-08 19:08:10,404 dev_appserver_main.py] Running application mash name on port 8080: http://localhost:8080
Point your browser towards http://127.0.0.1:8080/ and you should get the standard Django It worked! message.
Step 7: Create a Django app within the project:
tmp$ cd mashname tmp/mashname$ python mashname/manage.py startapp main
Step 8: Now it is time to add a model. We will be creating a simple application that logs all visitors to the data store and displays their IP address and time of visit. Edit ~/mashname/mashname/main/models.py so that it looks like this:
# models.py
from google.appengine.ext import db
class Visitor(db.Model):
ip = db.StringProperty()
added_on = db.DateTimeProperty(auto_now_add=True)
There is no need to sync the database since we are not using regular Django models.
Step 9: Now we create a view that is responsible for both adding data to the Visitor model and showing the previous visitors. Edit views.py (in the same directory as models.py) so that it does what we want:
# views.py
from django.http import HttpResponse
from mashname.main.models import Visitor
def main(request):
visitor = Visitor()
visitor.ip = request.META["REMOTE_ADDR"]
visitor.put()
result = ""
visitors = Visitor.all()
visitors.order("-added_on")
for visitor in visitors.fetch(limit=40):
result += visitor.ip + u" visited on " + unicode(visitor.added_on) + u""
return HttpResponse(result)
Step 10: Finally, make your urls.py point towards the view:
# urls.py
from django.conf.urls.defaults import *
urlpatterns = patterns("",
(r"^$", "mashname.main.views.main"),
)
Step 11: Test your application (as in step 6) and everything should hopefully work. For each page reload a new entry is added to the Visitor model and shown in the view.
Step 12: Upload your application to the Google App Engine:
tmp$ appcfg.py update mashname
For the first upload you will have to provide the mail address and password for your Google account.
Step 13: Enjoy! To view the final results, go to http://mashname.appspot.com/.