Transcript Django - Pitt Department of Biomedical Informatics

Department of Biomedical Informatics
University of Pittsburgh School of Medicine
http://www.dbmi.pitt.edu
Web Frameworks: Django
The Purpose of the Lecture
Introduce the basic steps for web programming
using Django.
This is done by walking you though the steps that
takes to create an web blog: “jiangblog”
“jiangblog” is designed to allow a user to make
comments online about some topics such as a
presidential debate, and save these comments in a
database.
Python and SQLite has to be installed
before installing django!
Download and Install Django
1. Download Django 1.4.2 from the following
website:
https://www.djangoproject.com/download/.
2. Install Django:
tar xzvf Django-1.4.2.tar.gz
cd Django-1.4.2
sudo python setup.py install
Create a Django Project
Django provides a utility called django-admin.py
that can streamline the tasks for you when you
create a django project. (Note that I use red
color for the terminal output.)
xjiang-lp:django xij6$ django-admin.py startproject
jiangblog
xjiang-lp:django xij6$ ls -l
total 0
drwxr-xr-x 4 xij6 PITT\domain users 136 Nov 8 11:28
jiangblog
drwxr-xr-x 7 xij6 PITT\domain users 238 Nov 8 11:05
mysite
Check What have been Created in
jiangblog
xjiang-lp:django xij6$ cd jiangblog
xjiang-lp:jiangblog xij6$ ls -l
total 8
drwxr-xr-x 6 xij6 PITT\domain users 204 Nov 8
11:28 jiangblog
-rwxr-xr-x 1 xij6 PITT\domain users 252 Nov 8
11:28 manage.py
xjiang-lp:jiangblog xij6$
Check What have been Created in
jiangblog
xjiang-lp:jiangblog xij6$ ls -l jiangblog
total 32
-rw-r--r-- 1 xij6 PITT\domain users 0 Nov 8
11:28 __init__.py
-rw-r--r-- 1 xij6 PITT\domain users 5221 Nov 8
11:28 settings.py
-rw-r--r-- 1 xij6 PITT\domain users 565 Nov 8
11:28 urls.py
-rw-r--r-- 1 xij6 PITT\domain users 1140 Nov 8
11:28 wsgi.py
The Files Created by Django-Admin.py
startproject
manage.py: Command-line interface for
applications.
__init__.py: Specifies to Python that this is a
package.
urls.py: Global URL configuration (“URLconf”).
settings.py: Project-specific configuration
wsgi.py: ???
The “pure Python” philosophy
Note that every file created by the startproject
command is Python code with an extension .py
Django tries to stay with Python code wherever
possible. This certainly reduces the complexity to
the framework for a python programmer.
Running the Development Server
The development server is a server designed for
the development phase that runs on your local
computer.
xjiang-lp:jiangblog xij6$ python ./manage.py runserver
Validating models…
0 errors found
Django version 1.4.2, using settings 'jiangblog.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CONTROL-C.
Error: [Errno 48] Address already in use
Running the Development Server
Note that if you want to run your server on a
different port, you can specify that on the
command line:
python ./manage.py runserver
xjiang-lp:jiangblog xij6$ ./manage.py runserver
8080
Validating models...
0 errors found
Django version 1.4.2, using settings
'jiangblog.settings'
Development server is running at
http://127.0.0.1:8080/
Quit the server with CONTROL-C.
DBMIAdmins-MacBook-Pro:jiangblog xij6$ ./manage.py
startapp presdebate
DBMIAdmins-MacBook-Pro:jiangblog xij6$ ls -l
total 8
drwxr-xr-x 10 xij6 PITT\domain users 340 Nov 8 12:32
jiangblog
-rwxr-xr-x 1 xij6 PITT\domain users 252 Nov 8 11:28
manage.py
drwxr-xr-x 6 xij6 PITT\domain users 204 Nov 8 13:33
presdebate
DBMIAdmins-MacBook-Pro:jiangblog xij6$
Create an Application within a Project
We want to create an application named as
“presdebate”, which can be used to collect
comments from web users about a presidential
debate.
./manage.py startapp presdebate
Again, we want to know what files have been created for
our application.
DBMIAdmins-MacBook-Pro:jiangblog xij6$ ls -l presdebate
total 24
-rw-r--r-- 1 xij6 PITT\domain users 0 Nov 8 13:33
__init__.py
-rw-r--r-- 1 xij6 PITT\domain users 57 Nov 8 13:33
models.py
-rw-r--r-- 1 xij6 PITT\domain users 383 Nov 8 13:33
tests.py
-rw-r--r-- 1 xij6 PITT\domain users 26 Nov 8 13:33
views.py
DBMIAdmins-MacBook-Pro:jiangblog xij6$
The Files Created for our Application
“presdebate”
__init__.py: Specifies to Python that this is a
package
models.py: Data models
views.py: view functions
tests.py: unit tests
What is missing?
urls.py: The app’s URL configuration (“URLconf”).
This is not automatically created.
To inform Django that the new app “presdebate” is part of
our project, we need to edit settings.py.
We need to open the settings.py with an editor and find the
INSTALLED_APPS tuple near the bottom, then add our
application name (presdebate) as a member of that tuple.
In Mac I typically use either textmate or coda2 to do the
editing work.
NSTALLED_APPS after editing
Creating a Data Model
We need to create a data model via editing the file called
models.py, which is automatically generated for application
presdebate.
This data model defines the data structures of presdebate.
Django provides a variety of fields that map to our
application data.
In application presdebate, we will use three different field
types.
Models.py before editing
Models.py after editing
The newly created class, PresDebate, is a
subclass of django.db.models.Model.
That’s Django standard base class for data
models, which is the core of Django’s powerful
ORM.
The fields are defined like regular class attributes,
with each one being an instance of a particular
field class.
A CharField is appropriate for short, single lines of text.
A TextField type is good for a large chunk of text, such as a
large paragraph of comments we may collect from a user.
A DateTimeField is represented by a Python
datetime.datetime object.
For a list of field types provided by Django, refer to the
documentation at:
https://docs.djangoproject.com/en/dev/ref/models/fields/#fie
ld-types
Setting Up the Database
Using SQLite with the local host, you only need to
do two things:
1. Update the engine.
2. Specify the name (use full pathname to avoid
confusion) of the database that will be created
in the settings.py file.
DATABASES entry in settings.py
before editing
“DATABASES”entry in settings.py after
editing
Setting Up the Database
Now we need to tell Django to use the information
(the pathname of our database) you’ve given it
to connect to the database and set up tables that
our application needs.
We use the syncdb command of manage.py to do
this.
Setting Up the Database
When the syncdb command is issued, Django
looks for a models.py file in each of the
INSTALLED_APPS entry.
For each model it finds, it creates a database
table.
Adding a super user is useful, especially when we
add the Django’s automatic admin application
later.
Creating the predebate’s User Interface
With Django, a Web page has the following typical
components:
1. A template that defines how it looks, and
displays information passed to it.
2. A view function that performs the core logic for a
request, fetch the information to be displayed
from a database, and store new information
entered by a users to the database.
Creating the Predebate’s User
Interface
3. A URL pattern that matches an incoming
request with the corresponding view.
We will build our application according to the
following order:
1. Build a template.
2. Design an Url Pattern.
3. Develop the view function.
Creating a Django Template
We will introduce two constructs of django’s templating
language:
1. A variable tag that is delimited by pairs of curly braces: {{
… }}.
A variable tag displays the contents of the object within the
braces, which can be pure data or callables.
Inside a variable tag, you can use Python-style dotnotation to access attributes of the tag variables.
Creating a Django Template
2. A block tag that is delimited by curly braces and percent
symbols : {% … %}.
A block tag is used to embed logic such as loops and
conditions into a django html template.
A Preliminary Template Created for
presdebate Application
Creating a Django Template
Save the HTML template code shown in the previous slide
into a directory called templates inside the application
folder, which we need to create.
So the path to the template we just created is:
/users/xij6/django/jiangblog/presdebate/templates/mytempl
ate.html
Note that the name of the template is arbitrary, but the
name of the templates directory is mandatory.
Creating a URL Pattern
The pathnames of an URL in a users’ browsers are
mapped to various parts of an applicaton.
The IP address will be mapped to an Internet host (server),
and the port number will be mapped to a port on the
server.
Once the message arrives at the Internet host, the serve
will match the remainder of the URL to the
corresponding project. Then the remainder of the URL
(with the project name excluded) will be passed to the
project url configuration file.
Creating a URL Pattern
In our case in which we use a local host as the
server, the type of request and the remainder of
the URL (with the IP and port number excluded)
will be passed to a django project URLconf
(jiangblog/urls.py).
We therefore need to edit the URLconf so that
when a valid pattern (regular expression) matches
to the remainder of the URL received, the request
will be further passed to the next receiver, which is
the application URLconf we shell create later.
jiangblog/urls.py before editing
jiangblog/urls.py after editing
Creating a URL Pattern
The patterns() function takes as input a tuple (URL
regular expression, destination).
The destination is either a view function that is
called for URLs that match the pattern, or it’s a call
to another URLconf file via include() function.
When include() is used, the current URL path head
is removed and the remainder of the path is
passed to the another URLconf file.
Creating a URL Pattern
For example, for
http://localhost:8080/presdebate/xxx/yyy/zzz, the
xxx/yyy/zzz will be passed to presdebate/urls.py as
specified by include (“presdebate.urls”), by
excluding the matching regex presdebate/
Creating a URL Pattern
The added line in the urlpattens entry of the project
URLconf says that we are catching requests that
begin with presdebate/ and passing them on to the
presdebate/urls.py.
Recall that the presdebate does not contain a
urls.py, thus we need to create this file from
scratch.
presdebate/urls.py
Creating a View Function-Create a
Fake View First
The purpose of creating a fake view is to test
quickly whether we’ve done so fast are correct.
To do this, we need to edit the
jiangblog/presdebate/view.py file.
jiangblog/presdebate/view.py before
editing
jiangblog/presdebate/view.py after
editing
Creating Our Real View Function
Now we will create a view function that will fetch all
of the comments stored in the database
(mydb.db)and display them to users via our
template.
jiangblog/presdebate/view.py after
editing
Creating Our Real View Function
If there is no records in mydb.db, we will receive
an error. Thus, we need to initialize the mydb.db.
This can be done in several ways. One way is to
add a review function in the view.py file called
initializingdb()
jiangblog/presdebate/view.py after
editing
Working with User Input
Major Steps:
1. Adding an HTML form to our template.
2. Editing the application URLconf.
3. Adding a new view function that processes user
input.
Adding an HTML Form to Our
Template.
Adding an HTML Form to Our
Template.
Cross-Site Request Forgery
Django comes with a data-preserving feature that
disallows POSTs which are not secure against
cross-site request forgery (CSRF) attacks.
You can read more about CSRF at the following
website:
https://docs.djangoproject.com/en/dev/ref/contrib/c
srf/
Cross-Site Request Forgery
For our simple application, two fixes:
1. Add a CSFR token ({% csrf_token %} to forms
that POST back to your site
2. Send the request context instance to the token
via the template.
Editing the Application URLconf.
Adding a New View Function that
Processes User Input
Adding a New View Function that
Processes User Input
Adding a New View Function that
Processes User Input
Trying Out the Django Admin
Django provides a automatic back-end
administration application, or Admin for short.
Why do we need the Admin?
1. Testing during the development stage, even
before the UI has been developed.
2. Manage the site easily.
Steps to Set up the Admin for a Django
Project
1. Update the settings.py. Note that the Admin is
also an application.
2. Run syncdb.
3. Editing the project URLconf file.
4. Register the PresDebate model with Admin.
Update the settings.py
Run syncdb
Editing the Project URLconf File.
Editing the Project URLconf File.
Register the PresDebate Model with
the Admin
We need to inform Django which models should
show up for editing in the Admin screens.
To do this, we will create a file named as admin.py
in the presdebate directory.
Admin.py
This Time the Admin Worked!
We can also Edit/Add Comments Using
the Admin
Editing Admin.py to Fix the “Display
Issue”
Using Python Shell with Django
Application
1. Run ./manage.py shell
This will bring up Ipython, which can be
downloaded at: http://ipython.org/download.html
2. Run ./manage.py shell --plain
This will bring up python.