Chapter 8- Advanced Views and URLconfs

The
Django
Book
Chapter
8:
Advanced
Views
and
URLconfs
Speaker:
Vincent
Chien

advantage of this in several ways, as described in the sections that follow.
from django.conf.urls.defaults import *
from mysite.views import hello, current_datetime, hours_ahead
Streamlining
Function
Imports
9.1.1 Streamlining Function Imports
Consider this URLconf, which builds on the example in Chapter 3:
from mysite.views import hello, current_datetime, hours_ahead
urlpatterns = patterns(’’,
(r’^hello/$’, hello),
(r’^time/$’, current_datetime),
(r’^time/plus/(d{1,2})/$’, hours_ahead),
)
As urlpatterns explained in = Chapter patterns(’’,
3, each entry in the URLconf includes its associated view function, function (r’^object. hello/$’, This means hello),
it’s necessary to import the view functions at the top of the module.
But as (a r’^Django time/$’, application current_datetime),
(r’^time/plus/(d{grows 1,2})/$’, in complexity, hours_its ahead),
URLconf grows, too, and keeping those imports manage. (For each new view function, you have to remember to import it, and the import statement long if you use this approach.) It’s possible to avoid that tedium by importing the views module URLconf is equivalent to the previous one:
from mysite import views
)
As explained in Chapter 3, each entry in the URLconf includes its associated view function, function object. This means it’s necessary to import the view functions at the top of the module.
But as a Django application grows in complexity, its URLconf grows, too, and keeping those imports manage. (For each new view function, you have to remember to import it, and the import statement long if you use this approach.) It’s possible to avoid that tedium by importing the views module URLconf is equivalent to the previous one:
urlpatterns = patterns(‘’,
(r’^hello/$’, views.hello),
(r’^time/$’, views.current_datetime),
(r’^time/plus/(d{1,2})/$’, views.hours_ahead),
)

string containing the module name and function name rather than the function object itself. Continuing example:
DSjantgro Beooak Dmocumlienntatiionn, Rgel
eaFseu0.1nction
Imports
(r’^hello/$’, ‘mysite.views.hello’),
(r’^time/$’, ‘mysite.views.current_datetime’),
(r’^time/plus/(d{1,2})/$’, ‘mysite.views.hours_ahead’),
Django
offers
another
way
of
specifying
the
view
funcAon
for
a
parAcular
)
Note that you don’t put a trailing dot (".") in the prefix, nor do you put a leading dot in the view strings. Django paCern
offers in
the
another URLconf:
way of you
specifying can
pass
the a
view string
function containing
for a particular the
module
pattern name
in the URLconf: you can string and
funccontaining Aon
name
the module rather
name than
and the
function funcAon
name object
rather itself.
than the function object itself. Continuing the ongoing
example:
)
(Note the quotes around the view names. We’re using ’mysite.views.current_datetime’ instead of mysite.views.current_datetime.)
Using urlpatterns this technique, = patterns(‘’,
it’s no longer necessary to import the view functions; Django automatically (r’^hello/$’, ‘mysite.views.hello’),
(r’^view time/$’, function ‘the mysite.first time views.it’s needed, current_according datetime’),
to the string describing the name and path function.
(r’^time/plus/(d{1,2})/$’, ‘mysite.views.hours_ahead’),
A further shortcut you can take when using the string technique is to factor out a common “view URLconf example, each of the view strings starts with ’mysite.views’, which is redundant to factor out that common prefix and pass it as the first argument to patterns(), like this:
)
(Note the quotes around the view names. We’re using ’mysite.views.current_datetime’ – with quotes instead factor
of out
mysite.a
common
views.“view
current_prefix.”
datetime.)
Using this technique, it’s no longer necessary to import the view functions; Django automatically imports view function the first time it’s needed, according to the string describing the name and path of the function.
A further shortcut you can take when using the string technique is to factor out a common “view prefix.” URLconf example, each of the view strings starts with ’mysite.views’, which is redundant to type. We factor out that common prefix and pass it as the first argument to patterns(), like this:
urlpatterns = patterns(‘mysite.views’,
(r’^hello/$’, ‘hello’),
(r’^time/$’, ‘current_datetime’),
(r’^time/plus/(d{1,2})/$’, ‘hours_ahead’),

Using
Multiple
View
Pre>iDxjanegosB
ook Documentation, from django.conf.urls.defaults import *
= patterns(’’,
r’^hello/$’, ’mysite.views.hello’),
(r’^time/$’, ’mysite.views.current_datetime’),
(r’^time/plus/(d{1,2})/$’, ’mysite.views.hours_ahead’),
(r’^tag/(w+)/$’, ’weblog.views.tag’),
OLD
)
New:
NEW
urlpatterns = patterns(’mysite.views’,
(r’^hello/$’, ’hello’),
(r’^time/$’, ’current_datetime’),
(r’^time/plus/(d{1,2})/$’, ’hours_ahead’),
)
urlpatterns += patterns(’weblog.views’,
(r’^tag/(w+)/$’, ’tag’),
)
Django Book Documentation, Release conf.urls.defaults import *
(r’^hello/$’, ’mysite.views.hello’),
(r’^time/$’, ’mysite.views.current_datetime’),
(r’^time/plus/(d{1,2})/$’, ’mysite.views.hours_ahead’),
(r’^tag/(w+)/$’, ’weblog.views.tag’),
)
New:
urlpatterns = patterns(’mysite.views’,
(r’^hello/$’, ’hello’),
(r’^time/$’, ’current_datetime’),
(r’^time/plus/(d{1,2})/$’, ’hours_ahead’),
)
urlpatterns += patterns(’weblog.views’,
(r’^tag/(w+)/$’, ’tag’),
)

9.1.3 Special-Casing URLs in Debug Mode
Special-‐Casing
URLs
in
Debug
Speaking of constructing urlpatterns dynamically, you might want to take advantage your runtime, Mode
URLconf’s behavior while in Django’s debug mode. To do this, just check the like so:
from django.conf import settings
(r’^$’, views.homepage),
(r’^(d{4})/([a-z]{3})/$’, views.archive_month),
)
if settings.DEBUG:
urlpatterns += patterns(’’,
(r’^debuginfo/$’, views.debug),
)
In this example, the URL /debuginfo/ will only be available if your DEBUG setting 9.1.4 Using Named Groups

Keyword Arguments vs. Positional Arguments
A Python function can be called using keyword arguments or positional arguments – and, in some cases, both at same time. In a keyword argument call, you specify the names of the arguments along with the values you’re passing.
In a positional argument call, you simply pass the arguments without explicitly specifying which argument matches
which value; the association is implicit in the arguments’ order.
For example, consider this simple function:
def sell(item, price, quantity):
A Python function can be called using keyword arguments or positional arguments – and, in some cases, same time. In a keyword argument call, you specify the names of the arguments along with the values In a positional argument call, you simply pass the arguments without explicitly specifying which argument which value; the association is implicit in the arguments’ order.
same In a positional time. In a argument keyword argument call, you simply call, you pass specify the arguments the names without of the arguments explicitly specifying along with which the values argument In which a positional value; the argument association call, is you implicit simply in the pass arguments’ the arguments order.
without explicitly specifying which argument which For example, value; the consider association this simple is implicit function:
in the arguments’ order.
Using
Named
Groups
print "Selling %s unit(s) of %s at %s" % (quantity, item, price)
print "Selling %s unit(s) of %s at %s" % (quantity, item, price)
To call it with positional arguments, you specify the arguments in the order in which they’re listed definition:
sell(’Socks’, ’$2.50’, 6)
To call it with keyword arguments, you specify the names of the arguments along with the values. statements are equivalent:
sell(item=’Socks’, price=’$2.50’, quantity=6)
sell(item=’Socks’, quantity=6, price=’$2.50’)
sell(price=’$2.50’, item=’Socks’, quantity=6)
sell(price=’$2.50’, quantity=6, item=’Socks’)
sell(quantity=6, item=’Socks’, price=’$2.50’)
sell(quantity=6, price=’$2.50’, item=’Socks’)
Finally, you can mix keyword and positional arguments, as long as all positional arguments are listed arguments. The following statements are equivalent to the previous examples:
sell(’Socks’, ’$2.50’, quantity=6)
sell(’Socks’, price=’$2.50’, quantity=6)
sell(’Socks’, quantity=6, price=’$2.50’)
print print "Selling "Selling %s %unit(s unit(s) of s) %s of at %s %s" at % %(s" quantity, % (quantity, item, price)
item, price)
call it with positional arguments, you specify the arguments in the order in which they’re listed definition:
sell(’Socks’, ’$2.50’, 6)
To call it with positional arguments, you specify the arguments in the order in which they’re listed definition:
sell(’Socks’, ’$2.50’, 6)
To call it with positional arguments, you specify the arguments in the order in which they’re listed in the function
definition:
sell(’Socks’, ’$2.50’, 6)
To call it with keyword arguments, you specify the names of the arguments along with the values. The following
PosiAonal
Arguments
Keyword
Arguements
are equivalent:
sell(item=’item=’Socks’, Socks’, quantity=price=’$6, 2.50’, price=’$quantity=2.50’)
6)
Finally, you can mix keyword and positional arguments, as long as all positional arguments are listed before keyword
arguments. The following statements are equivalent to the previous examples:
Mix
In Python regular expressions, the syntax for named regular expression groups is (?P<name>pattern), where
In Python regular expressions, the syntax for named regular expression groups is (?P<name>pattern),

Socks’, quantity=6, price=’$2.50’)
Using
Named
Groups
In Python regular expressions, the syntax for named regular expression groups is (?P<name>name is the name of the group and pattern is some pattern to match.
In Python regular expressions, the syntax for named regular expression groups is (?P<name>pattern), name is the name of the group and pattern is some pattern to match.
Here’s an example URLconf that uses non-named groups:
Here’s an example URLconf that uses non-named groups:
(r’ârticles/(d{4})/$’, views.year_archive),
(r’ârticles/(d{4})/(d{2})/$’, views.month_archive),
(r’ârticles/(d{4})/$’, views.year_archive),
(r’ârticles/(d{4})/(d{2})/$’, views.month_archive),
)
Here’s the same URLconf, rewritten to use named groups:
)
Here’s the same URLconf, rewritten to use named groups:
(r’ârticles/(?P<year>d{4})/$’, views.year_archive),
(r’ârticles/(?P<year>d{4})/(?P<month>d{2})/$’, views.month_archive),
(r’ârticles/(?P<year>d{4})/$’, views.year_archive),
(r’ârticles/(?P<year>d{4})/(?P<month>d{2})/$’, views.month_archive),
)
This accomplishes exactly the same thing as the previous example, with one subtle difference: the captured passed to view functions as keyword arguments rather than positional arguments.
)
This accomplishes exactly the same thing as the previous example, with one subtle difference: passed to view functions as keyword arguments rather than positional arguments.

Using
Named
Groups
• For
example,
with
non-‐named
groups,
a
request
to
/arAcles/
2006/03/
would
result
in
a
funcAon
call
equivalent
to
this:
month_archive(request,
'2006',
'03')
• With
named
groups,
though,
the
same
request
would
result
in
this
funcAon
call:
month_archive(request,
year='2006',
month='03')

Understanding
the
Matching/
Grouping
Algorithm
• If
there
are
any
named
arguments,
it
will
use
those,
ignoring
non-‐named
arguments.
• Otherwise,
it
will
pass
all
non-‐named
arguments
as
posiAonal
arguments.
• In
both
cases,
it
will
pass
any
extra
opAons
as
keyword
arguments.
See
the
next
secAon
for
more
informaAon.

• Otherwise, it will pass all non-named arguments as positional arguments.
• In both cases, it will pass any extra options as keyword arguments. See the next section for more information.
Passing
Extra
Options
to
View
Functions
9.1.6 Passing Extra Options to View Functions
Sometimes you’ll find yourself writing view functions that are quite similar, with only a few small differences. example, say you have two views whose contents are identical except for the template they use:
# urls.py
(r’^foo/$’, views.foo_view),
(r’^bar/$’, views.bar_view),
)
# views.py
from django.shortcuts import render
from mysite.models import MyModel
9.1. URLconf Tricks Django Book Documentation, Release 0.1
def foo_view(request):
m_list = MyModel.objects.filter(is_new=True)
return render(request, ’template1.html’, {’m_list’: m_list})
def bar_view(request):
We’re repeating ourselves in this code, and that’s inelegant. At first, you may think to remove the redundancy by the same view for both URLs, putting parentheses around the URL to capture it, and checking the URL within

def bar_view(request):
Passing
Extra
Options
to
View
Functions
We’re repeating ourselves in this code, and that’s inelegant. At first, you may think to remove the redundancy by using
the same view for both URLs, putting parentheses around the URL to capture it, and checking the URL within the
view to determine the template, like so:
# urls.py
(r’^(foo)/$’, views.foobar_view),
(r’^(bar)/$’, views.foobar_view),
)
# views.py
def foobar_view(request, url):
if url == ’foo’:
template_name = ’template1.html’
elif url == ’bar’:
template_name = ’template2.html’
return render(request, template_name, {’m_list’: m_list})
The problem with that solution, though, is that it couples your URLs to your code. If you decide to rename /foo/ to
/fooey/, you’ll have to remember to change the view code.
The elegant solution involves an optional URLconf parameter. Each pattern in a URLconf may include a third item: a
dictionary of keyword arguments to pass to the view function.
With this in mind, we can rewrite our ongoing example like this:
The
problem
with
that
soluAon,
though,
is
that
it
couples
your
URLs
to
your
code.
If
you
decide
to
rename
/foo/
to
/fooey/,
you’ll
have
to
remember
to
change
the
view
code.

The /Passing
problem with that solution, though, is that it couples your URLs to your code. If you decide to rename /fooey/, you’ll have to Extra
remember to change Options
the view code.
to
View
The elegant solution involves an optional URLconf parameter. Each pattern in a URLconf may include a third dictionary Functions
of keyword arguments to pass to the view function.
With this in mind, we can rewrite our ongoing example like this:
# urls.py
(r’^foo/$’, views.foobar_view, {’template_name’: ’template1.html’}),
(r’^bar/$’, views.foobar_view, {’template_name’: ’template2.html’}),
)
# views.py
def foobar_view(request, template_name):
return render(request, template_name, {’m_list’: m_list})
As you can see, the URLconf in this example specifies template_name in the URLconf. The view function 128 Chapter 9. Chapter 8: Advanced Views and URLconfs

)
And the view function signature would look like this:
def my_view(request, month, day):
Faking
Captured
URLconf
Values
# ....
This approach is straightforward – it’s nothing you haven’t seen before. The trick comes in when you want another URL that uses my_view but whose URL doesn’t include a month and/or day.
For example, you might want to add another URL, /mydata/birthday/, which would be equivalent /mydata/jan/06/. You can take advantage of extra URLconf options like so:
(r’^mydata/birthday/$’, views.my_view, {’month’: ’jan’, ’day’: ’06’}),
(r’^mydata/(?P<month>w{3})/(?P<day>dd)/$’, views.my_view),
)
The cool thing here is that you don’t have to change your view function at all. The view function only cares that month and day parameters – it doesn’t matter whether they come from the URL capturing itself or extra parameters.
Making a View Generic
It’s good programming practice to “factor out” commonalities in code. For example, with these two Python functions:
def say_hello(person_name):
print ’Hello, %s’ % person_name
def say_goodbye(person_name):
print ’Goodbye, %s’ % person_name

def greet(person_name, greeting):
print ’%s, %s’ % (greeting, person_name)
Making
a
View
Generic
You can apply this same philosophy to your Django views by using extra URLconf parameters.
With this in mind, you can start making higher-level abstractions of your views. Instead of thinking to yourself, “This
view displays a list of Event objects,” and “That view displays a list of BlogEntry objects,” realize they’re both
specific cases of “A view that displays a list of objects, where the type of object is variable.”
Take Original
this code, for example:
# urls.py
(r’^events/$’, views.event_list),
(r’^blog/entries/$’, views.entry_list),
)
# views.py
from mysite.models import Event, BlogEntry
def event_list(request):
obj_list = Event.objects.all()
return render(request, ’mysite/event_list.html’, {’event_list’: obj_list})
def entry_list(request):
obj_list = BlogEntry.objects.all()
return render(request, ’mysite/blogentry_list.html’, {’entry_list’: obj_list})
The two views do essentially the same thing: they display a list of objects. So let’s factor out the type of object they’re
displaying:

obj_list = Event.objects.all()
return render(request, ’mysite/event_list.html’, {’event_list’: obj_list})
def entry_list(request):
Making
a
View
Generic
obj_list = BlogEntry.objects.all()
return render(request, ’mysite/blogentry_list.html’, {’entry_list’: obj_list})
The two views do essentially the same thing: they display a list of objects. So let’s factor out the type of object displaying:
# urls.py
BeCer
from mysite import models, views
(r’^events/$’, views.object_list, {’model’: models.Event}),
(r’^blog/entries/$’, views.object_list, {’model’: models.BlogEntry}),
)
# views.py
def object_list(request, model):
obj_list = model.objects.all()
template_name = ’mysite/%s_list.html’ % model.__name__.lower()
return render(request, template_name, {’object_list’: obj_list})
With those small changes, we suddenly have a reusable, model-agnostic view! From now on, anytime we need that Every
lists Python
a set of class
objects, has
we a
can __name__
simply reuse aCribute
this object_that
returns
list the
view class
rather name.
than writing view code. Here

var = do_something()
return render(request, template_name, {’var’: var})
Understanding
Precedence
of
Captured
Values
vs.
Extra
Options
Understanding Precedence of Captured Values vs. Extra Options
When there’s a conflict, extra URLconf parameters get precedence over captured parameters. URLconf if
your
URLconf
captures captures
a named-a
named-‐group group
variable variable
and an and
extra an
extra
URLconf URLconf
parameter includes a variable the parameter
extra URLconf includes
parameter a
variable
value with
the
will same
be used.
name,
the
extra
URLconf
parameter
value
will
be
used.
For example, consider this URLconf:
(r’^mydata/(?P<id>d+)/$’, views.my_view, {’id’: 3}),
)
Here, both the regular expression and the extra dictionary include an id. The hard-coded means any request (e.g., /mydata/2/ or /mydata/432432/) will be treated as if id value id
captured will
be
3.
in the URL.
Astute readers will note that in this case, it’s a waste of time and typing to capture the id because its value will always be overridden by the dictionary’s value. That’s correct; we bring avoid making the mistake.

9.1.7 Using Default View Arguments
Another convenient trick is to specify default parameters use Using
for a parameter Default
by default if none is View
specified.
Arguments
for a view’s arguments. This tells the view An example:
# urls.py
(r’^blog/$’, views.page),
(r’^blog/page(?P<num>d+)/$’, views.page),
)
# views.py
def page(request, num=’1’):
# Output the appropriate page of blog entries, according to num.
# ...
Here, both URL patterns point to the same view – views.page – but the first pattern doesn’t capture the URL. If the first pattern matches, the page() function will use its default argument for num, ’1’. pattern matches, page() will use whatever num value was captured by the regular expression.
(Note that we’ve been careful to set the default argument’s value to the string ’1’, not the integer consistency, because any captured value for num will always be a string.)
It’s common to use this technique in conjunction with configuration options, as explained earlier. This example

Special-‐Casing
Views
Django Book else:
SomeAmes
you’ll
have
a
paCern
in
your
URLconf
that
handles
a
large
set
of
URLs,
but
you’ll
need
to
special-‐case
one
of
them.
In
this
case,
take
advantage
of
the
linear
way
a
# URLconf
do normal is
processed
code
and
put
the
special
case
first.
but that’s inelegant for a reason we’ve touched on multiple times in this chapter: it more elegant solution, we can take advantage of the fact that URLconfs are processed urlpatterns = patterns(’’,
# ...
(’^auth/user/add/$’, views.user_add_stage),
(’^([^/]+)/([^/]+)/add/$’, views.add_stage),
# ...
)
With this in place, a request to /auth/user/add/ will be handled by the user_add_URL matches the second pattern, it matches the top one first. (This is short-circuit logic.)
9.1.9 Capturing Text in URLs

so) about accepting only objects of a certain type. A common error is to attempt to create a datetime.date
object with string values instead of integer values:
>>> import datetime
>>> datetime.date(’1993’, ’7’, ’9’)
Traceback (most recent call last):
Capturing
Text
in
URLs
...
Each
captured
argument
is
sent
to
the
view
as
a
plain
Python
Unicode
string,
regardless
of
what
sort
of
match
the
regular
expression
makes.
TypeError: an integer is required
>>> datetime.date(1993, 7, 9)
datetime.date(1993, 7, 9)
Translated Wrong
to a URLconf and view, the error looks like this:
# urls.py
(r’^articles/(d{4})/(d{2})/(d{2})/$’, views.day_archive),
)
# views.py
import datetime
def day_archive(request, year, month, day):
# The following statement raises a TypeError!
date = datetime.date(year, month, day)
Django Book Documentation, Release 0.1
Instead, Correct
day_archive() can be written correctly like this:
def day_archive(request, year, month, day):
date = datetime.date(int(year), int(month), int(day))
9.1. URLconf Tricks 133
Note that int() itself raises a ValueError when you pass it a string that is not composed solely of digits, but

9.1.11 Higher-Level Abstractions of View Functions
And speaking of branching based on request method, let’s take a look at how we might build a nice way of doing Consider this URLconf/view layout:
# urls.py
Higher-‐level
Abstractions
of
View
Functions(Original)
# ...
(r’^somepage/$’, views.some_page),
# ...
)
# views.py
from django.http import Http404, HttpResponseRedirect
def some_page(request):
if request.method == ’POST’:
do_something_for_post()
return HttpResponseRedirect(’/someurl/’)
elif request.method == ’GET’:
do_something_for_get()
return render(request, ’page.html’)
else:
raise Http404()
In this example, the some_page() view’s handling of POST vs. GET requests is quite different. The only thing

Higher-‐level
Abstractions
of
View
Functions(no
args
and
kwargs)
We can do that by writing a view function that delegates to other views, either before or after executing some custom
logic. Here’s an example of how this technique could help simplify our some_page() view:
# views.py
from django.http import Http404, HttpResponseRedirect
def method_splitter(request, GET=None, POST=None):
if request.method == ’GET’ and GET is not None:
return GET(request)
elif request.method == ’POST’ and POST is not None:
return POST(request)
raise Http404
def some_page_get(request):
assert request.method == ’GET’
do_something_for_get()
return render(request, ’page.html’)
def some_page_post(request):
assert request.method == ’POST’
do_something_for_post()
return HttpResponseRedirect(’/someurl/’)
# urls.py
# ...
(r’^somepage/$’, views.method_splitter, {’GET’: views.some_page_get, ’POST’: views.some_page_post}),
# ...

Higher-‐level
Abstractions
of
View
Functions(args
and
kwargs)
GET and POST views take no arguments other than request. What if we wanted to use method_with views that, for example, capture text from URLs, or take optional keyword arguments themselves?
To do that, we can use a nice Python feature: variable arguments with asterisks. We’ll show the example explain it:
def method_splitter(request, *args, **kwargs):
get_view = kwargs.pop(’GET’, None)
post_view = kwargs.pop(’POST’, None)
if request.method == ’GET’ and get_view is not None:
return get_view(request, *args, **kwargs)
elif request.method == ’POST’ and post_view is not None:
return post_view(request, *args, **kwargs)
raise Http404
Here, we’ve refactored method_splitter() to remove the GET and POST keyword arguments, in and **kwargs (note the asterisks). This is a Python feature that allows a function to accept a dynamic, number of arguments whose names aren’t known until runtime. If you put a single asterisk in front of a function definition, any positional arguments to that function will be rolled up into a single tuple. asterisks in front of a parameter in a function definition, any keyword arguments to that function will a single dictionary.
For example, with this function:
def foo(*args, **kwargs):

Wrapping
View
Functions
(Original)
Django Book Documentation, def my_view2(request):
if not request.user.is_authenticated():
return HttpResponseRedirect(’/accounts/login/’)
# ...
return render(request, ’template2.html’)
def my_view3(request):
# ...
return render(request, ’template3.html’)
Here, each view starts by checking that request.user is authenticated – that is, the logged into the site – and redirects to /accounts/login/ if not. (Note that request.user – Chapter 14 does – but, as you might imagine, request.user either logged-in or anonymous.)
It would be nice if we could remove that bit of repetitive code from each of these views and

request.user – Chapter 14 does – but, as you might imagine, request.user represents the current either logged-in or anonymous.)
It would be nice if we could remove that bit of repetitive code from each of these views and just mark them as requiring
authentication. We can do that by making a view wrapper. Take a moment to study this:
def requires_login(view):
logged into the site – and redirects to /accounts/login/ if not. (Note that we request.user – Chapter 14 does – but, as you might imagine, request.user represents either Wrapping
logged-in or anonymous.)
View
Functions
(elegant)
It would be nice if we could remove that bit of repetitive code from each of these views and just authentication. def new_view(We request, can do that *args, by making **kwargs):
a view wrapper. Take a moment to study this:
def requires_login(view):
def return new_view(view(request, request, *args, *args, **kwargs)
**kwargs):
return new_view
This function, return requires_login, takes a view function (view) and returns a new view function (The new function, view(request, args, kwargs)
new_new_view is defined *within requires_**login and handles the logic of checking
request.return user.new_is_authenticated() view
and delegating to the original view (view).
Now, we can remove the if not request.user.is_authenticated() checks from our views and wrap them with requires_login in our URLconf:
from mysite.views import requires_login, my_view1, my_view2, my_view3
This function, requires_login, takes a view function (view) and returns a new view The new function, new_view is defined within requires_login and handles request.user.is_authenticated() and delegating to the original view (view).
Now, we can remove the if not request.user.is_authenticated() checks from wrap them with requires_login in our URLconf:
from mysite.views import requires_login, my_view1, my_view2, my_view3
(r’^view1/$’, requires_login(my_view1)),
)
This urlpatterns has the same effect = patterns(’’,
as before, but with less code redundancy. Now we’ve created a nice, generic function requires_login() that we can wrap around any view in order to make it require login.

If you intend your code to be used on multiple Django-based sites, you should consider arranging such At Including
a way that allows for “including.”
any point, your URLconf Other
can “include” URLconfs
other URLconf modules. This essentially “roots” other ones. For example, this URLconf includes other URLconfs:
9.2. Including Other URLconfs Django Book Documentation, Release 0.1
(r’^weblog/’, include(’mysite.blog.urls’)),
(r’^photos/’, include(’mysite.photos.urls’)),
(r’^about/$’, ’mysite.views.about’),
)
(We saw this before in Chapter 6, when we introduced the Django admin site. The admin site that you merely include() within yours.)
There’s an important gotcha here: the regular expressions in this example that point to an include() $ (end-of-string match character) but do include a trailing slash. Whenever Django encounters off whatever part of the URL matched up to that point and sends the remaining string to the further processing.
Continuing this example, here’s the URLconf mysite.blog.urls:
(r’^(dddd)/$’, ’mysite.blog.views.year_detail’),

• /about/: This matches the view mysite.views.about in the first URLconf, demonstrating mix include() patterns with non-include() patterns.
How
Captured
Parameters
Work
with
include()
9.2.1 How Captured Parameters Work with include()
An included URLconf receives any captured parameters from parent URLconfs, for example:
# root urls.py
(r’^(?P<username>w+)/blog/’, include(’foo.urls.blog’)),
)
# foo/urls/blog.py
(r’^$’, ’foo.views.blog_index’),
(r’^archive/$’, ’foo.views.blog_archive’),
)
In this example, the captured username variable is passed to the included URLconf and, function within that URLconf.

9.2.2 How Extra URLconf Options Work with include()
Similarly, you can pass extra URLconf options to include(), just as you can pass extra normal view – as a dictionary. When you do this, each line in the included URLconf will be For example, the following two URLconf sets are functionally identical.
Set one:
# urls.py
How
Extra
URLconf
Options
Work
with
include()
(r’^blog/’, include(’inner’), {’blogid’: 3}),
)
# inner.py
(r’^archive/$’, ’mysite.views.archive’),
(r’^about/$’, ’mysite.views.about’),
(r’^rss/$’, ’mysite.views.rss’),
)
Set two:

Chapter 8- Advanced Views and URLconfs

More Related Content

What's hot (20)

Viewers also liked (13)

Similar to Chapter 8- Advanced Views and URLconfs (20)

Recently uploaded (20)

Chapter 8- Advanced Views and URLconfs