Ignore:
Timestamp:
Mar 19, 2014, 11:31:01 PM (11 years ago)
Author:
dmik
Message:

python: Merge vendor 2.7.6 to trunk.

Location:
python/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • python/trunk

  • python/trunk/Doc/howto/webservers.rst

    r2 r391  
    77.. topic:: Abstract
    88
    9    This document shows how Python fits into the web.  It presents some ways on
    10    how to integrate Python with the web server and general practices useful for
     9   This document shows how Python fits into the web.  It presents some ways
     10   to integrate Python with a web server, and general practices useful for
    1111   developing web sites.
    1212
    1313
    14 Programming for the Web has become a hot topic since the raise of the "Web 2.0",
     14Programming for the Web has become a hot topic since the rise of "Web 2.0",
    1515which focuses on user-generated content on web sites.  It has always been
    1616possible to use Python for creating web sites, but it was a rather tedious task.
    17 Therefore, many so-called "frameworks" and helper tools were created to help
    18 developers creating sites faster and these sites being more robust.  This HOWTO
    19 describes some of the methods used to combine Python with a web server to create
    20 dynamic content.  It is not meant as a general introduction as this topic is far
    21 too broad to be covered in one single document.  However, a short overview of
    22 the most popular libraries is provided.
    23 
    24 .. seealso::
    25 
    26    While this HOWTO tries to give an overview over Python in the Web, it cannot
    27    always be as up to date as desired.  Web development in Python is moving
    28    forward rapidly, so the wiki page on `Web Programming
    29    <http://wiki.python.org/moin/WebProgramming>`_ might be more in sync with
     17Therefore, many frameworks and helper tools have been created to assist
     18developers in creating faster and more robust sites.  This HOWTO describes
     19some of the methods used to combine Python with a web server to create
     20dynamic content.  It is not meant as a complete introduction, as this topic is
     21far too broad to be covered in one single document.  However, a short overview
     22of the most popular libraries is provided.
     23
     24.. seealso::
     25
     26   While this HOWTO tries to give an overview of Python in the web, it cannot
     27   always be as up to date as desired.  Web development in Python is rapidly
     28   moving forward, so the wiki page on `Web Programming
     29   <http://wiki.python.org/moin/WebProgramming>`_ may be more in sync with
    3030   recent development.
    3131
    3232
    33 The low-level view
     33The Low-Level View
    3434==================
    3535
    36 .. .. image:: http.png
    37 
    38 When a user enters a web site, his browser makes a connection to the site's
    39 webserver (this is called the *request*).  The server looks up the file in the
     36When a user enters a web site, their browser makes a connection to the site's
     37web server (this is called the *request*).  The server looks up the file in the
    4038file system and sends it back to the user's browser, which displays it (this is
    41 the *response*).  This is roughly how the unterlying protocol, HTTP works.
    42 
    43 Now, dynamic web sites are not files in the file system, but rather programs
    44 which are run by the web server when a request comes in.  They can do all sorts
    45 of useful things, like display the postings of a bulletin board, show your
    46 mails, configurate software or just display the current time.  These programs
    47 can be written in about any programming language the server supports, so it is
    48 easy to use Python for creating dynamic web sites.
    49 
    50 As most of HTTP servers are written in C or C++, they cannot execute Python code
    51 in a simple way -- a bridge is needed between the server and the program.  These
    52 bridges or rather interfaces define how programs interact with the server.  In
    53 the past there have been numerous attempts to create the best possible
    54 interface, but there are only a few worth mentioning.
    55 
    56 Not every web server supports every interface.  Many web servers do support only
    57 old, now-obsolete interfaces.  But they can often be extended using some
    58 third-party modules to support new interfaces.
     39the *response*).  This is roughly how the underlying protocol, HTTP, works.
     40
     41Dynamic web sites are not based on files in the file system, but rather on
     42programs which are run by the web server when a request comes in, and which
     43*generate* the content that is returned to the user.  They can do all sorts of
     44useful things, like display the postings of a bulletin board, show your email,
     45configure software, or just display the current time.  These programs can be
     46written in any programming language the server supports.  Since most servers
     47support Python, it is easy to use Python to create dynamic web sites.
     48
     49Most HTTP servers are written in C or C++, so they cannot execute Python code
     50directly -- a bridge is needed between the server and the program.  These
     51bridges, or rather interfaces, define how programs interact with the server.
     52There have been numerous attempts to create the best possible interface, but
     53there are only a few worth mentioning.
     54
     55Not every web server supports every interface.  Many web servers only support
     56old, now-obsolete interfaces; however, they can often be extended using
     57third-party modules to support newer ones.
    5958
    6059
    … …  
    6261------------------------
    6362
    64 This interface is the oldest one, supported by nearly every web server out of
    65 the box.  Programs using CGI to communicate with their web server need to be
    66 started by the server for every request.  So, every request starts a new Python
    67 interpreter -- which takes some time to start up -- thus making the whole
    68 interface only usable for low load situations.
    69 
    70 The upside of CGI is that it is simple -- writing a program which uses CGI is a
    71 matter of about three lines of code.  But this simplicity comes at a price: it
    72 does very few things to help the developer.
    73 
    74 Writing CGI programs, while still possible, is not recommended anymore.  With
    75 WSGI (more on that later) it is possible to write programs that emulate CGI, so
    76 they can be run as CGI if no better option is available.
     63This interface, most commonly referred to as "CGI", is the oldest, and is
     64supported by nearly every web server out of the box.  Programs using CGI to
     65communicate with their web server need to be started by the server for every
     66request.  So, every request starts a new Python interpreter -- which takes some
     67time to start up -- thus making the whole interface only usable for low load
     68situations.
     69
     70The upside of CGI is that it is simple -- writing a Python program which uses
     71CGI is a matter of about three lines of code.  This simplicity comes at a
     72price: it does very few things to help the developer.
     73
     74Writing CGI programs, while still possible, is no longer recommended.  With
     75:ref:`WSGI <WSGI>`, a topic covered later in this document, it is possible to write
     76programs that emulate CGI, so they can be run as CGI if no better option is
     77available.
    7778
    7879.. seealso::
    … …  
    8283
    8384   * :mod:`cgi` -- Handling of user input in CGI scripts
    84    * :mod:`cgitb` -- Displays nice tracebacks when errors happen in of CGI
     85   * :mod:`cgitb` -- Displays nice tracebacks when errors happen in CGI
    8586     applications, instead of presenting a "500 Internal Server Error" message
    8687
    … …  
    108109    print "Hello World!"
    109110
    110 You need to write this code into a file with a ``.py`` or ``.cgi`` extension,
    111 this depends on your web server configuration.  Depending on your web server
    112 configuration, this file may also need to be in a ``cgi-bin`` folder, for
    113 security reasons.
     111Depending on your web server configuration, you may need to save this code with
     112a ``.py`` or ``.cgi`` extension.  Additionally, this file may also need to be
     113in a ``cgi-bin`` folder, for security reasons.
    114114
    115115You might wonder what the ``cgitb`` line is about.  This line makes it possible
    116116to display a nice traceback instead of just crashing and displaying an "Internal
    117117Server Error" in the user's browser.  This is useful for debugging, but it might
    118 risk exposing some confident data to the user.  Don't use it when the script is
    119 ready for production use.  Still, you should *always* catch exceptions, and
     118risk exposing some confidential data to the user.  You should not use ``cgitb``
     119in production code for this reason.  You should *always* catch exceptions, and
    120120display proper error pages -- end-users don't like to see nondescript "Internal
    121121Server Errors" in their browsers.
    … …  
    126126
    127127If you don't have your own web server, this does not apply to you.  You can
    128 check whether if works as-is and if not you need to talk to the administrator of
    129 your web server anyway. If it is a big hoster, you can try filing a ticket
    130 asking for Python support.
    131 
    132 If you're your own administrator or want to install it for testing purposes on
    133 your own computers, you have to configure it by yourself.  There is no one and
    134 single way on how to configure CGI, as there are many web servers with different
    135 configuration options.  The currently most widely used free web server is
    136 `Apache HTTPd <http://httpd.apache.org/>`_, Apache for short -- this is the one
    137 that most people use, it can be easily installed on nearly every system using
    138 the systems' package management.  But `lighttpd <http://www.lighttpd.net>`_ has
    139 been gaining attention since some time and is said to have a better performance.
    140 On many systems this server can also be installed using the package management,
    141 so manually compiling the web server is never needed.
    142 
    143 * On Apache you can take a look into the `Dynamic Content with CGI
     128check whether it works as-is, and if not you will need to talk to the
     129administrator of your web server. If it is a big host, you can try filing a
     130ticket asking for Python support.
     131
     132If you are your own administrator or want to set up CGI for testing purposes on
     133your own computers, you have to configure it by yourself.  There is no single
     134way to configure CGI, as there are many web servers with different
     135configuration options.  Currently the most widely used free web server is
     136`Apache HTTPd <http://httpd.apache.org/>`_, or Apache for short. Apache can be
     137easily installed on nearly every system using the system's package management
     138tool.  `lighttpd <http://www.lighttpd.net>`_ is another alternative and is
     139said to have better performance.  On many systems this server can also be
     140installed using the package management tool, so manually compiling the web
     141server may not be needed.
     142
     143* On Apache you can take a look at the `Dynamic Content with CGI
    144144  <http://httpd.apache.org/docs/2.2/howto/cgi.html>`_ tutorial, where everything
    145145  is described.  Most of the time it is enough just to set ``+ExecCGI``.  The
    146146  tutorial also describes the most common gotchas that might arise.
     147
    147148* On lighttpd you need to use the `CGI module
    148   <http://trac.lighttpd.net/trac/wiki/Docs%3AModCGI>`_ which can be configured
     149  <http://redmine.lighttpd.net/wiki/lighttpd/Docs:ModCGI>`_\ , which can be configured
    149150  in a straightforward way.  It boils down to setting ``cgi.assign`` properly.
    150151
    … …  
    153154^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    154155
    155 Trying to use CGI sometimes leads to small annoyances that one might experience
    156 while trying to get these scripts to run.  Sometimes it happens that a seemingly
    157 correct script does not work as expected, which is caused by some small hidden
    158 reason that's difficult to spot.
    159 
    160 Some of these reasons are:
    161 
    162 * The Python script is not marked executable.  When CGI scripts are not
    163   executable most of the web servers will let the user download it, instead of
     156Using CGI sometimes leads to small annoyances while trying to get these
     157scripts to run.  Sometimes a seemingly correct script does not work as
     158expected, the cause being some small hidden problem that's difficult to spot.
     159
     160Some of these potential problems are:
     161
     162* The Python script is not marked as executable.  When CGI scripts are not
     163  executable most web servers will let the user download it, instead of
    164164  running it and sending the output to the user.  For CGI scripts to run
    165   properly the ``+x`` bit needs to be set.  Using ``chmod a+x your_script.py``
    166   might already solve the problem.
    167 * The line endings must be of Unix-type.  This is important because the web
    168   server checks the first line of the script (called shebang) and tries to run
    169   the program specified there.  It gets easily confused by Windows line endings
    170   (Carriage Return & Line Feed, also called CRLF), so you have to convert the
    171   file to Unix line endings (only Line Feed, LF).  This can be done
    172   automatically by uploading the file via FTP in text mode instead of binary
    173   mode, but the preferred way is just telling your editor to save the files with
    174   Unix line endings.  Most proper editors support this.
    175 * Your web server must be able to read the file, you need to make sure the
    176   permissions are fine.  Often the server runs as user and group ``www-data``,
    177   so it might be worth a try to change the file ownership or making the file
    178   world readable by using ``chmod a+r your_script.py``.
    179 * The webserver must be able to know that the file you're trying to access is a
    180   CGI script.  Check the configuration of your web server, maybe there is some
    181   mistake.
    182 * The path to the interpreter in the shebang (``#!/usr/bin/env python``) must be
    183   currect.  This line calls ``/usr/bin/env`` to find Python, but it'll fail if
    184   there is no ``/usr/bin/env``.  If you know where your Python is installed, you
    185   can also use that path.  The commands ``whereis python`` and ``type -p
    186   python`` might also help to find where it is installed.  Once this is known,
    187   the shebang line can be changed accordingly: ``#!/usr/bin/python``.
     165  properly on Unix-like operating systems, the ``+x`` bit needs to be set.
     166  Using ``chmod a+x your_script.py`` may solve this problem.
     167
     168* On a Unix-like system, The line endings in the program file must be Unix
     169  style line endings.  This is important because the web server checks the
     170  first line of the script (called shebang) and tries to run the program
     171  specified there.  It gets easily confused by Windows line endings (Carriage
     172  Return & Line Feed, also called CRLF), so you have to convert the file to
     173  Unix line endings (only Line Feed, LF).  This can be done automatically by
     174  uploading the file via FTP in text mode instead of binary mode, but the
     175  preferred way is just telling your editor to save the files with Unix line
     176  endings.  Most editors support this.
     177
     178* Your web server must be able to read the file, and you need to make sure the
     179  permissions are correct.  On unix-like systems, the server often runs as user
     180  and group ``www-data``, so it might be worth a try to change the file
     181  ownership, or making the file world readable by using ``chmod a+r
     182  your_script.py``.
     183
     184* The web server must know that the file you're trying to access is a CGI script.
     185  Check the configuration of your web server, as it may be configured
     186  to expect a specific file extension for CGI scripts.
     187
     188* On Unix-like systems, the path to the interpreter in the shebang
     189  (``#!/usr/bin/env python``) must be correct.  This line calls
     190  ``/usr/bin/env`` to find Python, but it will fail if there is no
     191  ``/usr/bin/env``, or if Python is not in the web server's path.  If you know
     192  where your Python is installed, you can also use that full path.  The
     193  commands ``whereis python`` and ``type -p python`` could help you find
     194  where it is installed.  Once you know the path, you can change the shebang
     195  accordingly: ``#!/usr/bin/python``.
     196
    188197* The file must not contain a BOM (Byte Order Mark). The BOM is meant for
    189   determining the byte order of UTF-16 encodings, but some editors write this
    190   also into UTF-8 files.  The BOM interferes with the shebang line, so be sure
    191   to tell your editor not to write the BOM.
    192 * :ref:`mod-python` might be making problems.  mod_python is able to handle CGI
    193   scripts by itself, but it can also be a source for problems.  Be sure you
    194   disable it.
     198  determining the byte order of UTF-16 and UTF-32 encodings, but some editors
     199  write this also into UTF-8 files.  The BOM interferes with the shebang line,
     200  so be sure to tell your editor not to write the BOM.
     201
     202* If the web server is using :ref:`mod-python`, ``mod_python`` may be having
     203  problems.  ``mod_python`` is able to handle CGI scripts by itself, but it can
     204  also be a source of issues.
    195205
    196206
    … …  
    201211
    202212People coming from PHP often find it hard to grasp how to use Python in the web.
    203 Their first thought is mostly `mod_python <http://www.modpython.org/>`_ because
    204 they think that this is the equivalent to ``mod_php``.  Actually it is not
    205 really.  It does embed the interpreter into the Apache process, thus speeding up
    206 requests by not having to start a Python interpreter every request.  On the
    207 other hand, it is by far not "Python intermixed with HTML" as PHP often does.
    208 The Python equivalent of that is a template engine.  mod_python itself is much
    209 more powerful and gives more access to Apache internals.  It can emulate CGI, it
    210 can work an a "Python Server Pages" mode similar to JSP which is "HTML
    211 intermangled with Python" and it has a "Publisher" which destignates one file to
    212 accept all requests and decide on what to do then.
    213 
    214 But mod_python has some problems.  Unlike the PHP interpreter the Python
    215 interpreter uses caching when executing files, so when changing a file the whole
    216 web server needs to be re-started to update.  Another problem ist the basic
    217 concept -- Apache starts some child processes to handle the requests and
    218 unfortunately every child process needs to load the whole Python interpreter
    219 even if it does not use it.  This makes the whole web server slower.  Another
    220 problem is that as mod_python is linked against a specific version of
    221 ``libpython``, it is not possible to switch from an older version to a newer
    222 (e.g. 2.4 to 2.5) without recompiling mod_python.  mod_python is also bound to
    223 the Apache web server, so programs written for mod_python cannot easily run on
    224 other web servers.
    225 
    226 These are the reasons why mod_python should be avoided when writing new
    227 programs.  In some circumstances it might be still a good idea to use mod_python
    228 for deployment, but WSGI makes it possible to run WSGI programs under mod_python
    229 as well.
     213Their first thought is mostly `mod_python <http://www.modpython.org/>`_\ ,
     214because they think that this is the equivalent to ``mod_php``.  Actually, there
     215are many differences.  What ``mod_python`` does is embed the interpreter into
     216the Apache process, thus speeding up requests by not having to start a Python
     217interpreter for each request.  On the other hand, it is not "Python intermixed
     218with HTML" in the way that PHP is often intermixed with HTML. The Python
     219equivalent of that is a template engine.  ``mod_python`` itself is much more
     220powerful and provides more access to Apache internals.  It can emulate CGI,
     221work in a "Python Server Pages" mode (similar to JSP) which is "HTML
     222intermingled with Python", and it has a "Publisher" which designates one file
     223to accept all requests and decide what to do with them.
     224
     225``mod_python`` does have some problems.  Unlike the PHP interpreter, the Python
     226interpreter uses caching when executing files, so changes to a file will
     227require the web server to be restarted.  Another problem is the basic concept
     228-- Apache starts child processes to handle the requests, and unfortunately
     229every child process needs to load the whole Python interpreter even if it does
     230not use it.  This makes the whole web server slower.  Another problem is that,
     231because ``mod_python`` is linked against a specific version of ``libpython``,
     232it is not possible to switch from an older version to a newer (e.g. 2.4 to 2.5)
     233without recompiling ``mod_python``.  ``mod_python`` is also bound to the Apache
     234web server, so programs written for ``mod_python`` cannot easily run on other
     235web servers.
     236
     237These are the reasons why ``mod_python`` should be avoided when writing new
     238programs.  In some circumstances it still might be a good idea to use
     239``mod_python`` for deployment, but WSGI makes it possible to run WSGI programs
     240under ``mod_python`` as well.
    230241
    231242
    … …  
    235246FastCGI and SCGI try to solve the performance problem of CGI in another way.
    236247Instead of embedding the interpreter into the web server, they create
    237 long-running processes which run in the background. There still is some module
    238 in the web server which makes it possible for the web server to "speak" with the
    239 background process.  As the background process is independent from the server,
    240 it can be written in any language of course also in Python.  The language just
    241 needs to have a library which handles the communication with the web server.
     248long-running background processes. There is still a module in the web server
     249which makes it possible for the web server to "speak" with the background
     250process.  As the background process is independent of the server, it can be
     251written in any language, including Python.  The language just needs to have a
     252library which handles the communication with the webserver.
    242253
    243254The difference between FastCGI and SCGI is very small, as SCGI is essentially
    244 just a "simpler FastCGI".  But as the web server support for SCGI is limited
     255just a "simpler FastCGI".  As the web server support for SCGI is limited,
    245256most people use FastCGI instead, which works the same way.  Almost everything
    246 that applies to SCGI also applies to FastCGI as well, so we'll only write about
     257that applies to SCGI also applies to FastCGI as well, so we'll only cover
    247258the latter.
    248259
    249 These days, FastCGI is never used directly.  Just like ``mod_python`` it is only
     260These days, FastCGI is never used directly.  Just like ``mod_python``, it is only
    250261used for the deployment of WSGI applications.
    251262
    … …  
    254265   * `FastCGI, SCGI, and Apache: Background and Future
    255266     <http://www.vmunix.com/mark/blog/archives/2006/01/02/fastcgi-scgi-and-apache-background-and-future/>`_
    256      is a discussion on why the concept of FastCGI and SCGI is better that that
     267     is a discussion on why the concept of FastCGI and SCGI is better than that
    257268     of mod_python.
    258269
    … …  
    261272^^^^^^^^^^^^^^^^^^
    262273
    263 Depending on the web server you need to have a special module.
    264 
    265 * Apache has both `mod_fastcgi <http://www.fastcgi.com/>`_ and `mod_fcgid
    266   <http://fastcgi.coremail.cn/>`_.  ``mod_fastcgi`` is the original one, but it
    267   has some licensing issues that's why it is sometimes considered non-free.
    268   ``mod_fcgid`` is a smaller, compatible alternative. One of these modules needs
     274Each web server requires a specific module.
     275
     276* Apache has both `mod_fastcgi <http://www.fastcgi.com/drupal/>`_ and `mod_fcgid
     277  <http://httpd.apache.org/mod_fcgid/>`_.  ``mod_fastcgi`` is the original one, but it
     278  has some licensing issues, which is why it is sometimes considered non-free.
     279  ``mod_fcgid`` is a smaller, compatible alternative.  One of these modules needs
    269280  to be loaded by Apache.
     281
    270282* lighttpd ships its own `FastCGI module
    271   <http://trac.lighttpd.net/trac/wiki/Docs%3AModFastCGI>`_ as well as an `SCGI
    272   module <http://trac.lighttpd.net/trac/wiki/Docs%3AModSCGI>`_.
    273 * nginx also supports `FastCGI <http://wiki.nginx.org/NginxSimplePythonFCGI>`_.
     283  <http://redmine.lighttpd.net/wiki/lighttpd/Docs:ModFastCGI>`_ as well as an
     284  `SCGI module <http://redmine.lighttpd.net/wiki/lighttpd/Docs:ModSCGI>`_.
     285
     286* `nginx <http://nginx.org/>`_ also supports `FastCGI
     287  <http://wiki.nginx.org/NginxSimplePythonFCGI>`_.
    274288
    275289Once you have installed and configured the module, you can test it with the
    … …  
    301315
    302316   There is some documentation on `setting up Django with FastCGI
    303    <http://www.djangoproject.com/documentation/fastcgi/>`_, most of which can be
    304    reused for other WSGI-compliant frameworks and libraries.  Only the
    305    ``manage.py`` part has to be changed, the example used here can be used
    306    instead. Django does more or less the exact same thing.
     317   <http://docs.djangoproject.com/en/dev/howto/deployment/fastcgi/>`_, most of
     318   which can be reused for other WSGI-compliant frameworks and libraries.
     319   Only the ``manage.py`` part has to be changed, the example used here can be
     320   used instead. Django does more or less the exact same thing.
    307321
    308322
    … …  
    310324--------
    311325
    312 `mod_wsgi <http://www.modwsgi.org/>`_ is an attempt to get rid of the low level
    313 gateways.  As FastCGI, SCGI, mod_python are mostly used to deploy WSGI
    314 applications anyway, mod_wsgi was started to directly embed WSGI aplications
    315 into the Apache web server.  The benefit from this approach is that WSGI
    316 applications can be deployed much easier as is is specially designed to host
    317 WSGI applications -- unlike the other low level methods which have glue code to
    318 host WSGI applications (like flup which was mentioned before).  The downside is
    319 that mod_wsgi is limited to the Apache web server, other servers would need
     326`mod_wsgi <http://code.google.com/p/modwsgi/>`_ is an attempt to get rid of the
     327low level gateways.  Given that FastCGI, SCGI, and mod_python are mostly used to
     328deploy WSGI applications, mod_wsgi was started to directly embed WSGI applications
     329into the Apache web server. mod_wsgi is specifically designed to host WSGI
     330applications.  It makes the deployment of WSGI applications much easier than
     331deployment using other low level methods, which need glue code.  The downside
     332is that mod_wsgi is limited to the Apache web server; other servers would need
    320333their own implementations of mod_wsgi.
    321334
    322 It supports two modes: the embedded mode in which it integrates with the Apache
    323 process and the daemon mode which is more FastCGI-like.  Contrary to FastCGI,
    324 mod_wsgi handles the worker-processes by itself which makes administration
     335mod_wsgi supports two modes: embedded mode, in which it integrates with the
     336Apache process, and daemon mode, which is more FastCGI-like.  Unlike FastCGI,
     337mod_wsgi handles the worker-processes by itself, which makes administration
    325338easier.
    326339
    … …  
    331344===============
    332345
    333 WSGI was already mentioned several times so it has to be something important.
    334 In fact it really is, so now it's time to explain.
    335 
    336 The *Web Server Gateway Interface*, :pep:`333` or WSGI for short is currently
    337 the best possible way to Python web programming.  While it is great for
    338 programmers writing frameworks, the normal person does not need to get in direct
    339 contact with it.  But when choosing a framework for web development it is a good
    340 idea to take one which supports WSGI.
    341 
    342 The big profit from WSGI is the unification.  When your program is compatible
    343 with WSGI -- that means that your framework has support for WSGI, your program
    344 can be deployed on every web server interface for which there are WSGI wrappers.
    345 So you do not need to care about whether the user uses mod_python or FastCGI --
    346 with WSGI it just works on any gateway interface.  The Python standard library
    347 contains its own WSGI server :mod:`wsgiref`, which is a small web server that
    348 can be used for testing.
    349 
    350 A really great WSGI feature are the middlewares.  Middlewares are layers around
    351 your program which can add various functionality to it.  There is a `number of
    352 middlewares <http://wsgi.org/wsgi/Middleware_and_Utilities>`_ already available.
    353 For example, instead of writing your own session management (to identify a user
    354 in subsequent requests, as HTTP does not maintain state, so it does now know
    355 that the requests belong to the same user) you can just take one middleware,
    356 plug it in and you can rely an already existing functionality.  The same thing
    357 is compression -- say you want to compress your HTML using gzip, to save your
    358 server's bandwidth.  So you only need to plug-in a middleware and you're done.
    359 Authentication is also a problem easily solved using a middleware.
    360 
    361 So, generally -- although WSGI may seem complex, the initial phase of learning
    362 can be very rewarding as WSGI does already have solutions to many problems that
    363 might arise while writing web sites.
     346WSGI has already been mentioned several times, so it has to be something
     347important.  In fact it really is, and now it is time to explain it.
     348
     349The *Web Server Gateway Interface*,  or WSGI for short, is defined in
     350:pep:`333` and is currently the best way to do Python web programming.  While
     351it is great for programmers writing frameworks, a normal web developer does not
     352need to get in direct contact with it.  When choosing a framework for web
     353development it is a good idea to choose one which supports WSGI.
     354
     355The big benefit of WSGI is the unification of the application programming
     356interface.  When your program is compatible with WSGI -- which at the outer
     357level means that the framework you are using has support for WSGI -- your
     358program can be deployed via any web server interface for which there are WSGI
     359wrappers.  You do not need to care about whether the application user uses
     360mod_python or FastCGI or mod_wsgi -- with WSGI your application will work on
     361any gateway interface.  The Python standard library contains its own WSGI
     362server, :mod:`wsgiref`, which is a small web server that can be used for
     363testing.
     364
     365A really great WSGI feature is middleware.  Middleware is a layer around your
     366program which can add various functionality to it.  There is quite a bit of
     367`middleware <http://www.wsgi.org/en/latest/libraries.html>`_ already
     368available.  For example, instead of writing your own session management (HTTP
     369is a stateless protocol, so to associate multiple HTTP requests with a single
     370user your application must create and manage such state via a session), you can
     371just download middleware which does that, plug it in, and get on with coding
     372the unique parts of your application.  The same thing with compression -- there
     373is existing middleware which handles compressing your HTML using gzip to save
     374on your server's bandwidth.  Authentication is another a problem easily solved
     375using existing middleware.
     376
     377Although WSGI may seem complex, the initial phase of learning can be very
     378rewarding because WSGI and the associated middleware already have solutions to
     379many problems that might arise while developing web sites.
    364380
    365381
    … …  
    368384
    369385The code that is used to connect to various low level gateways like CGI or
    370 mod_python is called *WSGI server*.  One of these servers is ``flup`` which was
    371 already mentioned and supports FastCGI, SCGI as well as `AJP
     386mod_python is called a *WSGI server*.  One of these servers is ``flup``, which
     387supports FastCGI and SCGI, as well as `AJP
    372388<http://en.wikipedia.org/wiki/Apache_JServ_Protocol>`_.  Some of these servers
    373 are written in Python as ``flup`` is, but there also exist others which are
     389are written in Python, as ``flup`` is, but there also exist others which are
    374390written in C and can be used as drop-in replacements.
    375391
    376 There are quite a lot of servers already available, so a Python web application
    377 can be deployed nearly everywhere.  This is one big advantage that Python has
    378 compared with other web techniques.
    379 
    380 .. seealso::
    381 
    382    A good overview of all WSGI-related code can be found in the `WSGI wiki
    383    <http://wsgi.org/wsgi>`_, which contains an extensive list of `WSGI servers
    384    <http://wsgi.org/wsgi/Servers>`_, which can be used by *every* application
     392There are many servers already available, so a Python web application
     393can be deployed nearly anywhere.  This is one big advantage that Python has
     394compared with other web technologies.
     395
     396.. seealso::
     397
     398   A good overview of WSGI-related code can be found in the `WSGI homepage
     399   <http://www.wsgi.org/en/latest/index.html>`_, which contains an extensive list of `WSGI servers
     400   <http://www.wsgi.org/en/latest/servers.html>`_ which can be used by *any* application
    385401   supporting WSGI.
    386402
    … …  
    394410--------------------
    395411
    396 What does WSGI give the web application developer?  Let's take a look on one
    397 long existing web application written in Python without using WSGI.
    398 
    399 One of the most widely used wiki software is `MoinMoin <http://moinmo.in/>`_.
    400 It was created in 2000, so it predates WSGI by about three years.  While it now
    401 includes support for WSGI, older versions needed separate code to run on CGI,
    402 mod_python, FastCGI and standalone.  Now, this all is possible by using WSGI and
    403 the already-written gateways.  For running with on FastCGI ``flup`` can be used,
    404 for running a standalone server :mod:`wsgiref` is the way to go.
    405 
    406 
    407 Model-view-controller
     412What does WSGI give the web application developer?  Let's take a look at
     413an application that's been around for a while, which was written in
     414Python without using WSGI.
     415
     416One of the most widely used wiki software packages is `MoinMoin
     417<http://moinmo.in/>`_.  It was created in 2000, so it predates WSGI by about
     418three years.  Older versions needed separate code to run on CGI, mod_python,
     419FastCGI and standalone.
     420
     421It now includes support for WSGI.  Using WSGI, it is possible to deploy
     422MoinMoin on any WSGI compliant server, with no additional glue code.
     423Unlike the pre-WSGI versions, this could include WSGI servers that the
     424authors of MoinMoin know nothing about.
     425
     426
     427Model-View-Controller
    408428=====================
    409429
    410 The term *MVC* is often heard in statements like "framework *foo* supports MVC".
    411 While MVC is not really something technical but rather organisational, many web
    412 frameworks use this model to help the developer to bring structure into his
    413 program.  Bigger web applications can have lots of code so it is a good idea to
    414 have structure in the program right from the beginnings.  That way, even users
    415 of other frameworks (or even languages, as MVC is nothing Python-specific) can
    416 understand the existing code easier, as they are already familiar with the
    417 structure.
     430The term *MVC* is often encountered in statements such as "framework *foo*
     431supports MVC".  MVC is more about the overall organization of code, rather than
     432any particular API.  Many web frameworks use this model to help the developer
     433bring structure to their program.  Bigger web applications can have lots of
     434code, so it is a good idea to have an effective structure right from the beginning.
     435That way, even users of other frameworks (or even other languages, since MVC is
     436not Python-specific) can easily understand the code, given that they are
     437already familiar with the MVC structure.
    418438
    419439MVC stands for three components:
    420440
    421 * The *model*.  This is the data that is meant to modify.  In Python frameworks
    422   this component is often represented by the classes used by the
    423   object-relational mapper.  So, all declarations go here.
     441* The *model*.  This is the data that will be displayed and modified.  In
     442  Python frameworks, this component is often represented by the classes used by
     443  an object-relational mapper.
     444
    424445* The *view*.  This component's job is to display the data of the model to the
    425   user.  Typically this component is represented by the templates.
     446  user.  Typically this component is implemented via templates.
     447
    426448* The *controller*.  This is the layer between the user and the model.  The
    427   controller reacts on user actions (like opening some specific URL) and tells
    428   the model to modify the data if necessary.
     449  controller reacts to user actions (like opening some specific URL), tells
     450  the model to modify the data if necessary, and tells the view code what to
     451  display,
    429452
    430453While one might think that MVC is a complex design pattern, in fact it is not.
    … …  
    438461   (the model) from the user interaction logic (the controller) and the
    439462   templates (the view).  That's why it is important not to write unnecessary
    440    Python code in the templates -- it is against MVC and creates more chaos.
    441 
    442 .. seealso::
    443 
    444    The english Wikipedia has an article about the `Model-View-Controller pattern
    445    <http://en.wikipedia.org/wiki/Model-view-controller>`_, which includes a long
    446    list of web frameworks for different programming languages.
    447 
    448 
    449 Ingredients for web sites
    450 =========================
    451 
    452 Web sites are complex constructs, so tools were created to help the web site
    453 developer to make his work maintainable.  None of these tools are in any way
    454 Python specific, they also exist for other programming languages as well.  Of
    455 course, developers are not forced to use these tools and often there is no
    456 "best" tool, but it is worth informing yourself before choosing something
    457 because of the big number of helpers that the developer can use.
    458 
    459 
    460 .. seealso::
    461 
    462    People have written far more components that can be combined than these
    463    presented here.  The Python wiki has a page about these components, called
     463   Python code in the templates -- it works against the MVC model and creates
     464   chaos in the code base, making it harder to understand and modify.
     465
     466.. seealso::
     467
     468   The English Wikipedia has an article about the `Model-View-Controller pattern
     469   <http://en.wikipedia.org/wiki/Model-view-controller>`_.  It includes a long
     470   list of web frameworks for various programming languages.
     471
     472
     473Ingredients for Websites
     474========================
     475
     476Websites are complex constructs, so tools have been created to help web
     477developers make their code easier to write and more maintainable.  Tools like
     478these exist for all web frameworks in all languages.  Developers are not forced
     479to use these tools, and often there is no "best" tool.  It is worth learning
     480about the available tools because they can greatly simplify the process of
     481developing a web site.
     482
     483
     484.. seealso::
     485
     486   There are far more components than can be presented here.  The Python wiki
     487   has a page about these components, called
    464488   `Web Components <http://wiki.python.org/moin/WebComponents>`_.
    465489
    … …  
    468492---------
    469493
    470 Mixing of HTML and Python code is possible with some libraries.  While
     494Mixing of HTML and Python code is made possible by a few libraries.  While
    471495convenient at first, it leads to horribly unmaintainable code.  That's why
    472496templates exist.  Templates are, in the simplest case, just HTML files with
    473 placeholders.  The HTML is sent to the user's browser after filling out the
     497placeholders.  The HTML is sent to the user's browser after filling in the
    474498placeholders.
    475499
    476 Python already includes such simple templates::
    477 
    478     # a simple template
    479     template = "<html><body><h1>Hello %s!</h1></body></html>"
    480     print template % "Reader"
    481 
    482 The Python standard library also includes some more advanced templates usable
    483 through :class:`string.Template`, but in HTML templates it is needed to use
    484 conditional and looping contructs like Python's *for* and *if*.  So, some
    485 *template engine* is needed.
    486 
    487 Now, Python has a lot of template engines which can be used with or without a
    488 `framework`_.  Some of these are using a plain-text programming language which
    489 is very easy to learn as it is quite limited while others use XML so the
    490 template output is always guaranteed to be valid XML.  Some `frameworks`_ ship
    491 their own template engine or recommend one particular.  If one is not yet sure,
    492 using these is a good idea.
    493 
    494 .. note::
    495 
    496    While Python has quite a lot of different template engines it usually does
    497    not make sense to use a homebrewed template system.  The time needed to
    498    evaluate all templating systems is not really worth it, better invest the
    499    time in looking through the most popular ones.  Some frameworks have their
    500    own template engine or have a recommentation for one.  It's wise to use
    501    these.
    502 
    503    Popular template engines include:
    504 
    505    * Mako
    506    * Genshi
    507    * Jinja
    508 
    509 .. seealso::
    510 
    511    Lots of different template engines divide the attention between themselves
    512    because it's easy to create them in Python.  The page `Templating
     500Python already includes two ways to build simple templates::
     501
     502    >>> template = "<html><body><h1>Hello %s!</h1></body></html>"
     503    >>> print template % "Reader"
     504    <html><body><h1>Hello Reader!</h1></body></html>
     505
     506    >>> from string import Template
     507    >>> template = Template("<html><body><h1>Hello ${name}</h1></body></html>")
     508    >>> print template.substitute(dict(name='Dinsdale'))
     509    <html><body><h1>Hello Dinsdale!</h1></body></html>
     510
     511To generate complex HTML based on non-trivial model data, conditional
     512and looping constructs like Python's *for* and *if* are generally needed.
     513*Template engines* support templates of this complexity.
     514
     515There are a lot of template engines available for Python which can be used with
     516or without a `framework`_.  Some of these define a plain-text programming
     517language which is easy to learn, partly because it is limited in scope.
     518Others use XML, and the template output is guaranteed to be always be valid
     519XML.  There are many other variations.
     520
     521Some `frameworks`_ ship their own template engine or recommend one in
     522particular.  In the absence of a reason to use a different template engine,
     523using the one provided by or recommended by the framework is a good idea.
     524
     525Popular template engines include:
     526
     527   * `Mako <http://www.makotemplates.org/>`_
     528   * `Genshi <http://genshi.edgewall.org/>`_
     529   * `Jinja <http://jinja.pocoo.org/2/>`_
     530
     531.. seealso::
     532
     533   There are many template engines competing for attention, because it is
     534   pretty easy to create them in Python.  The page `Templating
    513535   <http://wiki.python.org/moin/Templating>`_ in the wiki lists a big,
    514    ever-growing number of these.
     536   ever-growing number of these.  The three listed above are considered "second
     537   generation" template engines and are a good place to start.
    515538
    516539
    … …  
    518541----------------
    519542
    520 *Data persistence*, while sounding very complicated is just about storing data.
    521 This data might be the text of blog entries, the postings of a bulletin board or
    522 the text of a wiki page.  As always, there are different ways to store
    523 informations on a web server.
    524 
    525 Often relational database engines like `MySQL <http://www.mysql.com/>`_ or
    526 `PostgreSQL <http://www.postgresql.org/>`_ are used due to their good
    527 performance handling very large databases consisting of up to millions of
    528 entries.  These are *queried* using a language called `SQL
    529 <http://en.wikipedia.org/wiki/SQL>`_.  Python programmers in general do not like
    530 SQL too much, they prefer to work with objects.  It is possible to save Python
    531 objects into a database using a technology called `ORM
    532 <http://en.wikipedia.org/wiki/Object-relational_mapping>`_.  ORM translates all
    533 object-oriented access into SQL code under the hood, the user does not need to
    534 think about it.  Most `frameworks`_ use ORMs and it works quite well.
    535 
    536 A second possibility is using files that are saved on the hard disk (sometimes
    537 called flatfiles).  This is very easy, but is not too fast.  There is even a
    538 small database engine called `SQLite <http://www.sqlite.org/>`_ which is bundled
    539 with Python in the :mod:`sqlite` module and uses only one file.  This database
    540 can be used to store objects via an ORM and has no other dependencies.  For
    541 smaller sites SQLite is just enough.  But it is not the only way in which data
    542 can be saved into the file systems.  Sometimes normal, plain text files are
    543 enough.
    544 
    545 The third and least used possibility are so-called object oriented databases.
    546 These databases store the *actual objects* instead of the relations that
    547 OR-mapping creates between rows in a database.  This has the advantage that
    548 nearly all objects can be saven in a straightforward way, unlike in relational
    549 databases where some objects are very hard to represent with ORMs.
    550 
    551 `Frameworks`_ often give the users hints on which method to choose, it is
    552 usually a good idea to stick to these unless there are some special requirements
    553 which require to use the one method and not the other.
     543*Data persistence*, while sounding very complicated, is just about storing data.
     544This data might be the text of blog entries, the postings on a bulletin board or
     545the text of a wiki page.  There are, of course, a number of different ways to store
     546information on a web server.
     547
     548Often, relational database engines like `MySQL <http://www.mysql.com/>`_ or
     549`PostgreSQL <http://www.postgresql.org/>`_ are used because of their good
     550performance when handling very large databases consisting of millions of
     551entries.  There is also a small database engine called `SQLite
     552<http://www.sqlite.org/>`_, which is bundled with Python in the :mod:`sqlite3`
     553module, and which uses only one file.  It has no other dependencies.  For
     554smaller sites SQLite is just enough.
     555
     556Relational databases are *queried* using a language called `SQL
     557<http://en.wikipedia.org/wiki/SQL>`_.  Python programmers in general do not
     558like SQL too much, as they prefer to work with objects.  It is possible to save
     559Python objects into a database using a technology called `ORM
     560<http://en.wikipedia.org/wiki/Object-relational_mapping>`_ (Object Relational
     561Mapping).  ORM translates all object-oriented access into SQL code under the
     562hood, so the developer does not need to think about it.  Most `frameworks`_ use
     563ORMs, and it works quite well.
     564
     565A second possibility is storing data in normal, plain text files (some
     566times called "flat files").  This is very easy for simple sites,
     567but can be difficult to get right if the web site is performing many
     568updates to the stored data.
     569
     570A third possibility are object oriented databases (also called "object
     571databases").  These databases store the object data in a form that closely
     572parallels the way the objects are structured in memory during program
     573execution.  (By contrast, ORMs store the object data as rows of data in tables
     574and relations between those rows.)  Storing the objects directly has the
     575advantage that nearly all objects can be saved in a straightforward way, unlike
     576in relational databases where some objects are very hard to represent.
     577
     578`Frameworks`_ often give hints on which data storage method to choose.  It is
     579usually a good idea to stick to the data store recommended by the framework
     580unless the application has special requirements better satisfied by an
     581alternate storage mechanism.
    554582
    555583.. seealso::
    556584
    557585   * `Persistence Tools <http://wiki.python.org/moin/PersistenceTools>`_ lists
    558      possibilities on how to save data in the file system, some of these modules
    559      are part of the standard library
     586     possibilities on how to save data in the file system.  Some of these
     587     modules are part of the standard library
     588
    560589   * `Database Programming <http://wiki.python.org/moin/DatabaseProgramming>`_
    561      helps on choosing a method on how to save the data
    562    * `SQLAlchemy <http://www.sqlalchemy.org/>`_, the most powerful OR-Mapper for
    563      Python and `Elixir <http://elixir.ematia.de/>`_ which makes it easier to
    564      use
     590     helps with choosing a method for saving data
     591
     592   * `SQLAlchemy <http://www.sqlalchemy.org/>`_, the most powerful OR-Mapper
     593     for Python, and `Elixir <http://elixir.ematia.de/>`_, which makes
     594     SQLAlchemy easier to use
     595
    565596   * `SQLObject <http://www.sqlobject.org/>`_, another popular OR-Mapper
     597
    566598   * `ZODB <https://launchpad.net/zodb>`_ and `Durus
    567599     <http://www.mems-exchange.org/software/durus/>`_, two object oriented
    … …  
    574606==========
    575607
    576 As web sites can easily become quite large, there are so-called frameworks which
    577 were created to help the developer with making these sites.  Although the most
    578 well-known framework is Ruby on Rails, Python does also have its own frameworks
    579 which are partly inspired by Rails or which were existing a long time before
    580 Rails.
    581 
    582 Two possible approaches to web frameworks exist: the minimalistic approach and
    583 the all-inclusive approach (somtimes called *full-stack*). Frameworks which are
    584 all-inclusive give you everything you need to start working, like a template
    585 engine, some way to save and access data in databases and many features more.
    586 Most users are best off using these as they are widely used by lots of other
    587 users and well documented in form of books and tutorials.  Other web frameworks
    588 go the minimalistic approach trying to be as flexible as possible leaving the
    589 user the freedom to choose what's best for him.
    590 
    591 The majority of users is best off with all-inclusive framewors.  They bring
    592 everything along so a user can just jump in and start to code.  While they do
    593 have some limitations they can fullfill 80% of what one will ever want to
    594 perfectly.  They consist of various components which are designed to work
    595 together as good as possible.
    596 
    597 The multitude of web frameworks written in Python demonstrates that it is really
    598 easy to write one.  One of the most well-known web applications written in
    599 Python is `Zope <http://www.zope.org/>`_ which can be regarded as some kind of
    600 big framework.  But Zope was not the only framework, there were some others
    601 which are by now nearly forgotten.  These do not need to be mentioned anymore,
    602 because most people that used them moved on to newer ones.
     608The process of creating code to run web sites involves writing code to provide
     609various services.  The code to provide a particular service often works the
     610same way regardless of the complexity or purpose of the web site in question.
     611Abstracting these common solutions into reusable code produces what are called
     612"frameworks" for web development.  Perhaps the most well-known framework for
     613web development is Ruby on Rails, but Python has its own frameworks.  Some of
     614these were partly inspired by Rails, or borrowed ideas from Rails, but many
     615existed a long time before Rails.
     616
     617Originally Python web frameworks tended to incorporate all of the services
     618needed to develop web sites as a giant, integrated set of tools.  No two web
     619frameworks were interoperable:  a program developed for one could not be
     620deployed on a different one without considerable re-engineering work.  This led
     621to the development of "minimalist" web frameworks that provided just the tools
     622to communicate between the Python code and the http protocol, with all other
     623services to be added on top via separate components.  Some ad hoc standards
     624were developed that allowed for limited interoperability between frameworks,
     625such as a standard that allowed different template engines to be used
     626interchangeably.
     627
     628Since the advent of WSGI, the Python web framework world has been evolving
     629toward interoperability based on the WSGI standard.  Now many web frameworks,
     630whether "full stack" (providing all the tools one needs to deploy the most
     631complex web sites) or minimalist, or anything in between, are built from
     632collections of reusable components that can be used with more than one
     633framework.
     634
     635The majority of users will probably want to select a "full stack" framework
     636that has an active community.  These frameworks tend to be well documented,
     637and provide the easiest path to producing a fully functional web site in
     638minimal time.
    603639
    604640
    … …  
    606642-----------------------
    607643
    608 There is an incredible number of frameworks, so there is no way to describe them
    609 all.  It is not even necessary, as most of these frameworks are nothing special
    610 and everything that can be done with these can also be done with one of the
    611 popular ones.
     644There are an incredible number of frameworks, so they cannot all be covered
     645here.  Instead we will briefly touch on some of the most popular.
    612646
    613647
    … …  
    617651`Django <http://www.djangoproject.com/>`_ is a framework consisting of several
    618652tightly coupled elements which were written from scratch and work together very
    619 well.  It includes an ORM which is quite powerful while being simple to use and
    620 has a great online administration interface which makes it possible to edit the
    621 data in the database with a browser.  The template engine is text-based and is
    622 designed to be usable for page designers who cannot write Python.  It supports
    623 so-called template inheritance and filters (which work like Unix pipes).  Django
    624 has many handy features bundled, like creation of RSS feeds or generic views
    625 which make it possible to write web sites nearly without any Python code.
    626 
    627 It has a big, international community which has created many sites using Django.
    628 There are also quite a lot of add-on projects which extend Django's normal
     653well.  It includes an ORM which is quite powerful while being simple to use,
     654and has a great online administration interface which makes it possible to edit
     655the data in the database with a browser.  The template engine is text-based and
     656is designed to be usable for page designers who cannot write Python.  It
     657supports template inheritance and filters (which work like Unix pipes).  Django
     658has many handy features bundled, such as creation of RSS feeds or generic views,
     659which make it possible to create web sites almost without writing any Python code.
     660
     661It has a big, international community, the members of which have created many
     662web sites.  There are also a lot of add-on projects which extend Django's normal
    629663functionality.  This is partly due to Django's well written `online
    630664documentation <http://docs.djangoproject.com/>`_ and the `Django book
    … …  
    634668.. note::
    635669
    636    Although Django is an MVC-style framework, it calls the components
     670   Although Django is an MVC-style framework, it names the elements
    637671   differently, which is described in the `Django FAQ
    638    <http://www.djangoproject.com/documentation/faq/#django-appears-to-be-a-mvc-framework-but-you-call-the-controller-the-view-and-the-view-the-template-how-come-you-don-t-use-the-standard-names>`_.
     672   <http://docs.djangoproject.com/en/dev/faq/general/#django-appears-to-be-a-mvc-framework-but-you-call-the-controller-the-view-and-the-view-the-template-how-come-you-don-t-use-the-standard-names>`_.
    639673
    640674
    … …  
    642676^^^^^^^^^^
    643677
    644 The other popular web framework in Python is `TurboGears
    645 <http://www.turbogears.org/>`_.  It takes the approach of using already existing
    646 components and combining them with glue code to create a seamless experience.
    647 TurboGears gives the user more flexibility on which components to choose, the
    648 ORM can be switched between some easy to use but limited and complex but very
    649 powerful.  Same goes for the template engine.  One strong point about TurboGears
    650 is that the components that it consists of can be used easily in other projects
    651 without depending on TurboGears, for example the underlying web server CherryPy.
     678Another popular web framework for Python is `TurboGears
     679<http://www.turbogears.org/>`_.  TurboGears takes the approach of using already
     680existing components and combining them with glue code to create a seamless
     681experience.  TurboGears gives the user flexibility in choosing components. For
     682example the ORM and template engine can be changed to use packages different
     683from those used by default.
    652684
    653685The documentation can be found in the `TurboGears wiki
    … …  
    657689published, which is a good starting point.
    658690
    659 The plan for the next major version of TurboGears, version 2.0 is to switch to a
    660 more flexible base provided by another very flexible web framework called
    661 `Pylons <http://pylonshq.com/>`_.
     691The newest version of TurboGears, version 2.0, moves even further in direction
     692of WSGI support and a component-based architecture.  TurboGears 2 is based on
     693the WSGI stack of another popular component-based web framework, `Pylons
     694<http://pylonshq.com/>`_.
     695
     696
     697Zope
     698^^^^
     699
     700The Zope framework is one of the "old original" frameworks.  Its current
     701incarnation in Zope2 is a tightly integrated full-stack framework.  One of its
     702most interesting feature is its tight integration with a powerful object
     703database called the `ZODB <https://launchpad.net/zodb>`_ (Zope Object Database).
     704Because of its highly integrated nature, Zope wound up in a somewhat isolated
     705ecosystem:  code written for Zope wasn't very usable outside of Zope, and
     706vice-versa.  To solve this problem the Zope 3 effort was started.  Zope 3
     707re-engineers Zope as a set of more cleanly isolated components.  This effort
     708was started before the advent of the WSGI standard, but there is WSGI support
     709for Zope 3 from the `Repoze <http://repoze.org/>`_ project.  Zope components
     710have many years of production use behind them, and the Zope 3 project gives
     711access to these components to the wider Python community.  There is even a
     712separate framework based on the Zope components: `Grok
     713<http://grok.zope.org/>`_.
     714
     715Zope is also the infrastructure used by the `Plone <http://plone.org/>`_ content
     716management system, one of the most powerful and popular content management
     717systems available.
    662718
    663719
    … …  
    665721^^^^^^^^^^^^^^^^^^^^^^^^
    666722
    667 These two are of course not the only frameworks that are available, there are
    668 also some less-popular frameworks worth mentioning.
    669 
    670 One of these is the already mentioned Zope, which has been around for quite a
    671 long time.  With Zope 2.x having been known as rather un-pythonic, the newer
    672 Zope 3.x tries to change that and therefore gets more acceptance from Python
    673 programmers.  These efforts already showed results, there is a project which
    674 connects Zope with WSGI called `Repoze <http://repoze.org/>`_ and another
    675 project called `Grok <http://grok.zope.org/>`_ which makes it possible for
    676 "normal" Python programmers use the very mature Zope components.
     723Of course these are not the only frameworks that are available.  There are
     724many other frameworks worth mentioning.
    677725
    678726Another framework that's already been mentioned is `Pylons`_.  Pylons is much
    679 like TurboGears with ab even stronger emphasis on flexibility, which is bought
     727like TurboGears, but with an even stronger emphasis on flexibility, which comes
    680728at the cost of being more difficult to use.  Nearly every component can be
    681729exchanged, which makes it necessary to use the documentation of every single
    682 component, because there are so many Pylons combinations possible that can
    683 satisfy every requirement.  Pylons builds upon `Paste
     730component, of which there are many.  Pylons builds upon `Paste
    684731<http://pythonpaste.org/>`_, an extensive set of tools which are handy for WSGI.
    685732
    … …  
    693740
    694741   Most frameworks also have their own mailing lists and IRC channels, look out
    695    for these on the projects' websites.  There is also a general "Python in the
     742   for these on the projects' web sites.  There is also a general "Python in the
    696743   Web" IRC channel on freenode called `#python.web
    697744   <http://wiki.python.org/moin/PoundPythonWeb>`_.
Note: See TracChangeset for help on using the changeset viewer.