Quixote: a Python-Centric Web Application Framework

If you need to create dynamic web sites and don't want to learn the syntax and arbitrary limitations of yet another templating language, you should give Quixote a serious look.

Quixote is a web application framework
for Python programmers. It was primarily developed by Andrew
Kuchling, Neil Schemenauer and myself (Greg Ward) at the MEMS
Exchange, in order to make our real job—the creation of a
web-driven network of semiconductor fabrication sites—easier. For
the development of our main web site
(www.mems-exchange.org),
we needed to concentrate on the complex business logic needed for
such a network and draw a clear line between the backend and the
user interface. We also wanted to use Python as much as possible,
because in our opinion it is the most appropriate language for such
a complex and rapidly changing application domain.

Quixote requires Python 2.0 or greater, a good understanding
of Python and a web server that implements the CGI protocol.
(Although your applications will be much happier using a mechanism,
such as FastCGI or SCGI, that allows long-running web
processes.)

Intended Audience

Quixote was written by and for Python programmers who need to
develop dynamic web sites while using as much of their existing
Python knowledge as possible. In particular, Quixote is not very
accommodating of the commonly made distinction between “web
designers” and “web developers”. If the web designers at your
organization are keen to try out a real programming language, then
Quixote might provide them with a good introduction to Python; but
anyone who doesn't understand what “import a module” or “call a
function” means isn't going to get very far with Quixote.
Similarly, anyone who expects to use a dedicated, WYSIWYG HTML
editor for creating web pages will be left out.

This, incidentally, is completely opposite to the stance
taken by most other web application frameworks, which is precisely
why we don't like most other web application frameworks. In our
limited experience, they all invent an HTML templating language
that embeds some sort of programming language in HTML, often with
deliberate limitations to prevent naive users from shooting
themselves in the feet. This usually ends up being painful and
frustrating for programmers who want power and flexibility and are
perfectly capable of aiming the gun away from their own
feet.

Specifically, Quixote's templating language, PTL (Python
Template Language), inverts the usual model by making it easier for
Python code to generate long text strings such as HTML documents,
rather than by embedding Python code in an HTML-like template
language. We'll cover PTL in more detail later.

Quixote might be the tool for you if:

you need to develop dynamic web sites with complex
programming needs, either in the backend or for presentation/user
interfaces;

you're more concerned with providing good content
and getting the logic behind the site right than you are with fancy
design tricks;

you want to use everything you already know about
Python (modules, packages, functions, classes and so forth) to
develop web sites

Using Quixote

Quixote is built on four core principles:

Publishing function results: Quixote's main job is
using a URL to look up a Python callable (e.g., a function or
method) and put its results on the web.

The URL is part of the user interface, and the
organization of source code and URL-space should roughly
correspond.

Embedding HTML in Python is cleaner and easier than
embedding Python in HTML.

No magic: when Quixote can't figure out what to do,
it refuses to guess the programmer's intent, preferring to raise an
exception instead.

The usual way to develop a Quixote application is to write a
set of classes that implement the fundamental logic of your
system—variously referred to as domain classes, domain objects,
business logic and so forth. Your domain classes ideally should
have nothing to do with the type of user interface you're going to
implement. Then you implement the web interface as a separate set
of PTL modules. The relationship between these two bodies of code
should be entirely one-way: the web interface will import and rely
heavily on the domain classes, but the domain classes will be
completely ignorant of the web interface.

As a real-world example, consider SPLAT!, a simple
bug-tracking tool I wrote as a sample Quixote application (and also
because we needed a simple bug tracker). SPLAT! (named for the
sound of a bug being squashed) consists of a Python package, splat,
with a sub-package called splat.web. The domain classes, SPLAT!'s
idea of what a bug is, what a user is, how its bugs are stored, are
in modules named things like splat.bug, splat.user, splat.database
and so on.

The web interface to SPLAT! is implemented in the splat.web
package, with the following modules: