web2pyTM Examples

Examples: simple | session | template | layout | form | database | cache | testing | streaming | xmlrpc

Simple Examples

Here are some working and complete examples that explain the basic syntax of the framework.
You can click on the web2py keywords (in the highlighted code!) to get documentation.

Example 1

In controller: simple_examples.py 
1.
2.
def hello1():
    return "Hello World"

If the controller function returns a string, that is the body of the rendered page.
Try it here: hello1

Example 2

In controller: simple_examples.py 
1.
2.
def hello2():
    return T("Hello World")

The function T() marks strings that need to be translated. Translation dictionaries can be created at /admin/default/design
Try it here: hello2

Example 3

In controller: simple_examples.py 
1.
2.
def hello3():
    return dict(message=T("Hello World"))
and view: simple_examples/hello3.html 
1.
2.
3.
{{extend 'layout.html'}}
<h1>{{=message}}</h1>

If you return a dictionary, the variables defined in the dictionery are visible to the view (template).
Try it here: hello3

Example 4

In controller: simple_examples.py 
1.
2.
3.
def hello4():
    response.view='simple_examples/hello3.html'
    return dict(message=T("Hello World"))

You can change the view, but the default is /[controller]/[function].html. If the default is not found web2py tries to render the page using the generic.html view.
Try it here: hello4

Example 5

In controller: simple_examples.py 
1.
2.
def hello5():
    return HTML(BODY(H1(T('Hello World'),_style="color: red;"))).xml() # .xml to serialize

You can also generate HTML using helper objects HTML, BODY, H1, etc. Each of these tags is an class and the views know how to render the corresponding objects. The method .xml() serializes them and produce html/xml code for the page. Each tag, DIV for example, takes three types of arguments:

  • unnamed arguments, they correspond to nested tags
  • named arguments and name starts with '_'. These are mapped blindly into tag attributes and the '_' is removed. attributes without value like "READONLY" can be created with the argument "_readonly=ON".
  • named arguments and name does not start with '_'. They have a special meaning. See "value=" for INPUT, TEXTAREA, SELECT tags later.

Try it here: hello5

Example 6

In controller: simple_examples.py 
1.
2.
def status():
    return dict(request=request,session=session,response=response)

Here we are showing the request, session ad response objects using the generic.html template.
Try it here: status

Example 7

In controller: simple_examples.py 
1.
2.
def redirectme():
    redirect(URL(r=request,f='hello3'))

You can do redirect.
Try it here: redirectme

Example 8

In controller: simple_examples.py 
1.
2.
def raisehttp():
    raise HTTP(400,"internal error")

You can raise HTTP exceptions to return an error page.
Try it here: raisehttp

Example 9

In controller: simple_examples.py 
1.
2.
3.
def raiseexception():
    1/0
    return 'oops'

If an exception occurs (other than HTTP) a ticket is generated and the event is logged for the administrator. These tickets and logs can be accessed, reviewed and deleted and any later time.
Try it here: raiseexception

Example 10

In controller: simple_examples.py 
1.
2.
3.
4.
def servejs():
    import gluon.contenttype
    response.headers['Content-Type']=gluon.contenttype.contenttype('.js')
    return 'alert("This is a Javascript document, it is not supposed to run!");'

You can serve other than HTML pages by changing the contenttype via the response.headers. The gluon.contenttype module can help you figure the type of the file to be server. NOTICE: this is not necessary for static files unless you want to require authorization.
Try it here: servejs

Example 11

In controller: simple_examples.py 
1.
2.
3.
def makejson():
    import gluon.contrib.simplejson as sj    
    return sj.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])

If you are into Ajax, web2py includes gluon.contrib.simplejson, developed by Bob Ippolito. This module provides a fast and easy way to serve asynchronous content to your Ajax page. gluon.simplesjson.dumps(...) can serialize most Python types into JSON. gluon.contrib.simplejson.loads(...) performs the reverse operation.
Try it here: makejson

Example 12

In controller: simple_examples.py 
1.
2.
3.
4.
5.
6.
7.
8.
9.
def makertf():
    import gluon.contrib.pyrtf as q
    doc=q.Document()
    section=q.Section()
    doc.Sections.append(section)
    section.append('Section Title')
    section.append('web2py is great. '*100)
    response.headers['Content-Type']='text/rtf'
    return q.dumps(doc)

web2py also includes gluon.contrib.pyrtf, developed by Simon Cusack and revised by Grant Edwards. This module allows you to generate Rich Text Format documents including colored formatted text and pictures.
Try it here: makertf

Example 13

In controller: simple_examples.py 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
def rss_aggregator():
    import datetime
    import gluon.contrib.rss2 as rss2
    import gluon.contrib.feedparser as feedparser
    d = feedparser.parse("http://rss.slashdot.org/Slashdot/slashdot/to")

    rss = rss2.RSS2(title=d.channel.title,
       link = d.channel.link,
       description = d.channel.description,
       lastBuildDate = datetime.datetime.now(),
       items = [
          rss2.RSSItem(
            title = entry.title,
            link = entry.link,
            description = entry.description,
            # guid = rss2.Guid('unkown'),
            pubDate = datetime.datetime.now()) for entry in d.entries]
       )
    response.headers['Content-Type']='application/rss+xml'
    return rss2.dumps(rss)

web2py includes gluon.contrib.rss2, developed by Dalke Scientific Software, which generates RSS2 feeds, and gluon.contrib.feedparser, developed by Mark Pilgrim, which collects RSS and ATOM feeds. The above controller collects a slashdot feed and makes new one.
Try it here: rss_aggregator

Example 14

In controller: simple_examples.py 
1.
2.
3.
4.
5.
6.
7.
8.
9.
from gluon.contrib.markdown import WIKI

def ajaxwiki():
    form=FORM(TEXTAREA(_id='text'),INPUT(_type='button',_value='markdown',
              _onclick="ajax('ajaxwiki_onclick',['text'],'html')"))
    return dict(form=form,html=DIV(_id='html'))

def ajaxwiki_onclick():
    return WIKI(request.vars.text).xml()

web2py also includes gluon.contrib.markdown (markdown2) which converts WIKI markup to HTML following this syntax. In this example we added a fancy ajax effect.
Try it here: ajaxwiki

Session Examples

Example 15

In controller: session_examples.py 
1.
2.
3.
4.
def counter():
    if not session.counter: session.counter=0
    session.counter+=1
    return dict(counter=session.counter)
and view: session_examples/counter.html 
1.
2.
3.
4.
5.
6.
{{extend 'layout.html'}}
<h1>session counter</h1>

<h2>{{for i in range(counter):}}{{=i}}...{{pass}}</h2>

<a href="{{=URL(r=request)}}">click me to count</a>

Click to count. The session.counter is persistent for this user and application. Every applicaiton within the system has its own separate session management.
Try it here: counter

Template Examples

Example 16

In controller: template_examples.py 
1.
def variables(): return dict(a=10, b=20)
and view: template_examples/variables.html 
1.
2.
3.
4.
{{extend 'layout.html'}}
<h1>Your variables</h1>
<h2>a={{=a}}</h2>
<h2>a={{=b}}</h2>

A view (also known as template) is just an HTML file with {{...}} tags. You can put ANY python code into the tags, no need to indent but you must use pass to close blocks. The view is transformed into a python code and then executed. {{=a}} prints a.xml() or escape(str(a)).
Try it here: variables

Example 17

In controller: template_examples.py 
1.
def test_for(): return dict()
and view: template_examples/test_for.html 
1.
2.
3.
4.
5.
6.
{{extend 'layout.html'}}
<h1>For loop</h1>

{{for number in ['one','two','three']:}}
  <h2>{{=number.capitalize()}}<h2>
{{pass}}

You can do for and while loops.
Try it here: test_for

Example 18

In controller: template_examples.py 
1.
def test_if(): return dict()
and view: template_examples/test_if.html 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
{{extend 'layout.html'}}
<h1>If statement</h1>

{{
a=10
}}

{{if a%2==0:}}
<h2>{{=a}} is even</h2>
{{else:}}
<h2>{{=a}} is odd</h2>
{{pass}}

You can do if, elif, else.
Try it here: test_if

Example 19

In controller: template_examples.py 
1.
def test_try(): return dict()
and view: template_examples/test_try.html 
1.
2.
3.
4.
5.
6.
7.
8.
{{extend 'layout.html'}}
<h1>Try... except</h1>

{{try:}}
   <h2>a={{=1/0}}</h2>
{{except:}}
   infinity</h2>
{{pass}}

You can do try, except, finally.
Try it here: test_try

Example 20

In controller: template_examples.py 
1.
def test_def(): return dict()
and view: template_examples/test_def.html 
1.
2.
3.
4.
5.
6.
7.
{{extend 'layout.html'}}
{{def itemlink(name):}}<li>{{=A(name,_href=name)}}</li>{{return}}
<ul>
{{itemlink('http://www.google.com')}}
{{itemlink('http://www.yahoo.com')}}
{{itemlink('http://www.nyt.com')}}
</ul>

You can write functions in HTML too.
Try it here: test_def

Example 21

In controller: template_examples.py 
1.
def escape(): return dict(message='<h1>text is scaped</h1>')
and view: template_examples/escape.html 
1.
2.
3.
4.
5.
{{extend 'layout.html'}}
<h1>Strings are automatically escaped</h1>

<h2>Message is</h2>
{{=message}}

The argument of {{=...}} is always escaped unless it is an object with a .xml() method such as link, A(...), a FORM(...), a XML(...) block, etc.
Try it here: escape

Example 22

In controller: template_examples.py 
1.
2.
def xml():
    return dict(message=XML('<h1>text is not escaped</h1>'))
and view: template_examples/xml.html 
1.
2.
3.
4.
5.
{{extend 'layout.html'}}
<h1>XML</h1>

<h2>Message is</h2>
{{=message}}

If you do not want to esacpe the argument of {{=...}} mark it as XML.
Try it here: xml

Example 23

In controller: template_examples.py 
1.
def beautify(): return dict(message=BEAUTIFY(request))
and view: template_examples/beautify.html 
1.
2.
3.
4.
5.
{{extend 'layout.html'}}
<h1>BEAUTIFY</h1>

<h2>Message is</h2>
{{=message}}

You can use BEUTIFY to turn lists and dictionaries into organized HTML.
Try it here: beautify

Layout Examples

Example 24

In controller: layout_examples.py 
1.
2.
3.
4.
5.
6.
def civilized():
    response.menu=[['civilized',True,URL(r=request,f='civilized')],
                   ['slick',False,URL(r=request,f='slick')],
                   ['basic',False,URL(r=request,f='basic')]]
    response.flash='you clicked on civilized'
    return dict(message="you clicked on civilized")
and view: layout_examples/civilized.html 
1.
2.
3.
{{extend 'layout_examples/layout_civilized.html'}}
   <h2>{{=message}}</h2>
<p>{{for i in range(1000):}}bla {{pass}} </p>

You can specify the layout file at the top of your view. civilized Layout file is a view that somewhere in the body contains {{include}}.
Try it here: civilized

Example 25

In controller: layout_examples.py 
1.
2.
3.
4.
5.
6.
def slick():
    response.menu=[['civilized',False,URL(r=request,f='civilized')],
                   ['slick',True,URL(r=request,f='slick')],
                   ['basic',False,URL(r=request,f='basic')]]
    response.flash='you clicked on slick'
    return dict(message="you clicked on slick")
and view: layout_examples/slick.html 
1.
2.
3.
{{extend 'layout_examples/layout_sleek.html'}}  
<h2>{{=message}}</h2> 
{{for i in range(1000):}}bla {{pass}}

Same here, but using a different template.
Try it here: slick

Example 26

In controller: layout_examples.py 
1.
2.
3.
4.
5.
6.
def basic():
    response.menu=[['civilized',False,URL(r=request,f='civilized')],
                   ['slick',False,URL(r=request,f='slick')],
                   ['basic',True,URL(r=request,f='basic')]]
    response.flash='you clicked on basic'
    return dict(message="you clicked on basic")
and view: layout_examples/basic.html 
1.
2.
3.
{{extend 'layout.html'}}  
<h2>{{=message}}</h2> 
{{for i in range(1000):}}bla {{pass}}

'layout.html' is the default template, every applicaiton has a copy of it.
Try it here: basic

Form Examples

Example 27

In controller: form_examples.py 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
def form():
    form=FORM(TABLE(TR("Your name:",INPUT(_type="text",_name="name",requires=IS_NOT_EMPTY())),
                    TR("Your email:",INPUT(_type="text",_name="email",requires=IS_EMAIL())),
                    TR("Admin",INPUT(_type="checkbox",_name="admin")),
                    TR("Sure?",SELECT('yes','no',_name="sure",requires=IS_IN_SET(['yes','no']))),
                    TR("Profile",TEXTAREA(_name="profile",value="write something here")),
                    TR("",INPUT(_type="submit",_value="SUBMIT"))))
    if form.accepts(request.vars,session):
        response.flash="form accepted"
    elif form.errors:
        response.flash="form is invalid"
    else:
        response.flash="please fill the form"
    return dict(form=form,vars=form.vars)

You can use HTML helpers like FORM, INPUT, TEXTAREA, OPTION, SELECT to build forms. the "value=" attribute sets the initial value of the field (works for TEXTAREA and OPTION/SELECT too) and the requires attribute sets the validators. FORM.accepts(..) trys to validate the form and, on success, stores vars into form.vars. On failure the error messages are stored into form.errors and shown in the form.
Try it here: form

Database Examples

You can find more examples of the web2py ORM here

Let's create a simple model with users, dogs, products and purchases (the database of an animal store). Users can have many dogs (ONE TO MANY), can buy many producs and every product can have many buyers (MANY TO MANY).

Example 28

in model: dba.py 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
dba=SQLDB('sqlite://tests.db')

dba.define_table('users',
                SQLField('name'),
                SQLField('email'))

# ONE (users) TO MANY (dogs)
dba.define_table('dogs',
                SQLField('owner_id',dba.users),
                SQLField('name'),                
                SQLField('type'),
                SQLField('vaccinated','boolean',default=False),
                SQLField('picture','upload',default=''))

dba.define_table('products',
                SQLField('name'),
                SQLField('description','text'))

# MANY (users) TO MANY (products)
dba.define_table('purchases',
                SQLField('buyer_id',dba.users),
                SQLField('product_id',dba.products),
                SQLField('quantity','integer'))

purchased=((dba.users.id==dba.purchases.buyer_id)&(dba.products.id==dba.purchases.product_id))

dba.users.name.requires=IS_NOT_EMPTY()
dba.users.email.requires=[IS_EMAIL(), IS_NOT_IN_DB(dba,'users.email')]
dba.dogs.owner_id.requires=IS_IN_DB(dba,'users.id','users.name')
dba.dogs.name.requires=IS_NOT_EMPTY()
dba.dogs.type.requires=IS_IN_SET(['small','medium','large'])
dba.purchases.buyer_id.requires=IS_IN_DB(dba,'users.id','users.name')
dba.purchases.product_id.requires=IS_IN_DB(dba,'products.id','products.name')
dba.purchases.quantity.requires=IS_INT_IN_RANGE(0,10)

Tables are created if they do not exist (try... except). Here "purchased" is an SQLQuery object, "dba(purchased)" would be a SQLSet obejcts. A SQLSet object can be selected, updated, deleted. SQLSets can also be intersected. Allowed field types are string, integer, password, text, blob, upload, date, time, datetime, references(*), and id(*). The id field is there by default and must not be declared. references are for one to many and many to many as in the example above. For strings you should specify a length or you get length=32.

You can use dba.tablename.fieldname.requires= to set restrictions on the field values. These restrictions are automatically converted into widgets when generating forms from the table with SQLFORM(dba.tablename).

define_tables creates the table and attempts a migration if table has changed or if database name has changed since last time. If you know you already have the table in the database and you do not want to attemt a migration add one last argument to define_table migrate=False.

Example 29

In controller: database_examples.py 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
response.menu=[['Register User',False,URL(r=request,f='register_user')],
               ['Register Dog',False,URL(r=request,f='register_dog')],
               ['Register Product',False,URL(r=request,f='register_product')],
               ['Buy product',False,URL(r=request,f='buy')]]

def register_user():
    ### create an insert form from the table
    form=SQLFORM(dba.users)
    ### if form correct perform the insert
    if form.accepts(request.vars,session):
        response.flash='new record inserted'
    ### and get a list of all users
    records=SQLTABLE(dba().select(dba.users.ALL))
    return dict(form=form,records=records)
and view: database_examples/register_user.html 
1.
2.
3.
4.
5.
6.
7.
8.
9.
{{extend 'layout_examples/layout_civilized.html'}}

<h1>User registration form</h1>

{{=form}}

<h2>Current users</h2>

{{=records}}

This is a simple user registration form. SQLFORM takes a table and returns the corresponding entry form with validators, etc. SQLFORM.accepts is similar to FORM.accepts but, if form is validated, the corresponding insert is also performed. SQLFORM can also do update and edit if a record is passed as its second argument. SQLTABLE instead turns a set of records (result of a select) into an HTML table with links as specified by its optional parameters. The response.menu on top is just a variable used by the layout to make the navigation menu for all functions in this controller.
Try it here: register_user

Example 30

In controller: database_examples.py 
1.
2.
3.
4.
5.
6.
7.
def register_dog():
    form=SQLFORM(dba.dogs)
    if form.accepts(request.vars,session):
        response.flash='new record inserted'
    download=URL(r=request,f='download') # to see the picture
    records=SQLTABLE(dba().select(dba.dogs.ALL),upload=download)
    return dict(form=form,records=records)
and view: database_examples/register_dog.html 
1.
2.
3.
4.
5.
6.
7.
8.
9.
{{extend 'layout_examples/layout_civilized.html'}}

<h1>Dog registration form</h1>

{{=form}}

<h2>Current dogs</h2>

{{=records}}

Here is a dog registration form. Notice that the "image" (type "upload") field is rendered into a <INPUT type="file"> html tag. SQLFORM.accepts(...) handles the upload of the file into the uploads/ folder.
Try it here: register_dog

Example 31

In controller: database_examples.py 
1.
2.
3.
4.
5.
6.
def register_product():
    form=SQLFORM(dba.products)
    if form.accepts(request.vars,session):
        response.flash='new record inserted'
    records=SQLTABLE(dba().select(dba.products.ALL))
    return dict(form=form,records=records)
and view: database_examples/register_product.html 
1.
2.
3.
4.
5.
6.
7.
8.
9.
{{extend 'layout_examples/layout_civilized.html'}}

<h1>Product registration form</h1>

{{=form}}

<h2>Current products</h2>

{{=records}}

Nothing new here.
Try it here: register_product

Example 32

In controller: database_examples.py 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
def buy():
    form=FORM(TABLE(TR("Buyer id:",INPUT(_type="text",_name="buyer_id",requires=IS_NOT_EMPTY())),
           TR("Product id:",INPUT(_type="text",_name="product_id",requires=IS_NOT_EMPTY())),
           TR("Quantity:",INPUT(_type="text",_name="quantity",requires=IS_INT_IN_RANGE(1,100))),
           TR("",INPUT(_type="submit",_value="Order"))))
    if form.accepts(request.vars,session):
        ### check if user is in the database
        if len(dba(dba.users.id==form.vars.buyer_id).select())==0:
            form.errors.buyer_id="buyer not in database"
        ### check if product is in the database
        if len(dba(dba.products.id==form.vars.product_id).select())==0:
            form.errors.product_id="product not in database"
        ### if no errors
        if len(form.errors)==0:
            ### get a list of same purchases by same user
            purchases=dba((dba.purchases.buyer_id==form.vars.buyer_id)&
                         (dba.purchases.product_id==form.vars.product_id)).select()
            ### if list contains a record, update that record
            if len(purchases)>0:
                purchases[0].update_record(quantity=purchases[0].quantity+form.vars.quantity)
            ### or insert a new record in table
            else:
                dba.purchases.insert(buyer_id=form.vars.buyer_id,
                                    product_id=form.vars.product_id,
                                    quantity=form.vars.quantity)
            response.flash="product purchased!"
    if len(form.errors): response.flash="invalid valus in form!"
    ### now get a list of all purchases
    records=dba(purchased).select(dba.users.name,dba.purchases.quantity,dba.products.name)
    return dict(form=form,records=SQLTABLE(records),vars=form.vars,vars2=request.vars)
and view: database_examples/buy.html 
1.
2.
3.
4.
5.
6.
7.
{{extend 'layout_examples/layout_civilized.html'}}
  <h1>Purchase form</h1>
  {{=form}}
  [ {{=A('reset purchased',_href=URL(r=request,f='reset_purchased'))}} |
    {{=A('delete purchased',_href=URL(r=request,f='delete_purchased'))