Ticket #9502: xref-markup-settings-r9435.diff

File xref-markup-settings-r9435.diff, 47.4 KB (added by Ramiro Morales, 16 years ago)

Patch updated to apply cleanly to trunk as of r9435

  • docs/faq/admin.txt

    diff --git a/docs/faq/admin.txt b/docs/faq/admin.txt
    a b  
    1010sent out by Django doesn't match the domain in your browser. Try these two
    1111things:
    1212
    13     * Set the ``SESSION_COOKIE_DOMAIN`` setting in your admin config file
     13    * Set the :setting:`SESSION_COOKIE_DOMAIN` setting in your admin config file
    1414      to match your domain. For example, if you're going to
    1515      "http://www.example.com/admin/" in your browser, in
    1616      "myproject.settings" you should set ``SESSION_COOKIE_DOMAIN = 'www.example.com'``.
     
    1919      don't have dots in them. If you're running the admin site on "localhost"
    2020      or another domain that doesn't have a dot in it, try going to
    2121      "localhost.localdomain" or "127.0.0.1". And set
    22       ``SESSION_COOKIE_DOMAIN`` accordingly.
     22      :setting:`SESSION_COOKIE_DOMAIN` accordingly.
    2323
    2424I can't log in. When I enter a valid username and password, it brings up the login page again, with a "Please enter a correct username and password" error.
    2525-----------------------------------------------------------------------------------------------------------------------------------------------------------
  • docs/faq/models.txt

    diff --git a/docs/faq/models.txt b/docs/faq/models.txt
    a b  
    66How can I see the raw SQL queries Django is running?
    77----------------------------------------------------
    88
    9 Make sure your Django ``DEBUG`` setting is set to ``True``. Then, just do
     9Make sure your Django :setting:`DEBUG` setting is set to ``True``. Then, just do
    1010this::
    1111
    1212    >>> from django.db import connection
     
    1414    [{'sql': 'SELECT polls_polls.id,polls_polls.question,polls_polls.pub_date FROM polls_polls',
    1515    'time': '0.002'}]
    1616
    17 ``connection.queries`` is only available if ``DEBUG`` is ``True``. It's a list
     17``connection.queries`` is only available if :setting:`DEBUG` is ``True``. It's a list
    1818of dictionaries in order of query execution. Each dictionary has the following::
    1919
    2020    ``sql`` -- The raw SQL statement
     
    7979
    8080Django isn't known to leak memory. If you find your Django processes are
    8181allocating more and more memory, with no sign of releasing it, check to make
    82 sure your ``DEBUG`` setting is set to ``False``. If ``DEBUG`` is ``True``, then
     82sure your :setting:`DEBUG` setting is set to ``False``. If ``DEBUG`` is ``True``, then
    8383Django saves a copy of every SQL statement it has executed.
    8484
    8585(The queries are saved in ``django.db.connection.queries``. See
    8686`How can I see the raw SQL queries Django is running?`_.)
    8787
    88 To fix the problem, set ``DEBUG`` to ``False``.
     88To fix the problem, set :setting:`DEBUG` to ``False``.
    8989
    9090If you need to clear the query list manually at any point in your functions,
    9191just call ``reset_queries()``, like this::
  • docs/howto/deployment/fastcgi.txt

    diff --git a/docs/howto/deployment/fastcgi.txt b/docs/howto/deployment/fastcgi.txt
    a b  
    371371
    372372In the cases where Django cannot work out the prefix correctly and where you
    373373want the original value to be used in URLs, you can set the
    374 ``FORCE_SCRIPT_NAME`` setting in your main ``settings`` file. This sets the
     374:setting:`FORCE_SCRIPT_NAME` setting in your main ``settings`` file. This sets the
    375375script name uniformly for every URL served via that settings file. Thus you'll
    376376need to use different settings files if you want different sets of URLs to
    377377have different script names in this case, but that is a rare situation.
  • docs/internals/contributing.txt

    diff --git a/docs/internals/contributing.txt b/docs/internals/contributing.txt
    a b  
    752752    ./runtests.py --settings=path.to.django.settings
    753753
    754754Yes, the unit tests need a settings module, but only for database connection
    755 info, with the ``DATABASE_ENGINE`` setting.
     755info, with the :setting:`DATABASE_ENGINE` setting.
    756756
    757757If you're using the ``sqlite3`` database backend, no further settings are
    758758needed. A temporary database will be created in memory when running the tests.
     
    771771
    772772You will also need to ensure that your database uses UTF-8 as the default
    773773character set. If your database server doesn't use UTF-8 as a default charset,
    774 you will need to include a value for ``TEST_DATABASE_CHARSET`` in your settings
     774you will need to include a value for :setting:`TEST_DATABASE_CHARSET` in your settings
    775775file.
    776776
    777777If you want to run the full suite of tests, you'll need to install a number of
  • docs/intro/tutorial01.txt

    diff --git a/docs/intro/tutorial01.txt b/docs/intro/tutorial01.txt
    a b  
    158158     
    159159    * :setting:`DATABASE_NAME` -- The name of your database. If you're using
    160160      SQLite, the database will be a file on your computer; in that case,
    161       ``DATABASE_NAME`` should be the full absolute path, including filename, of
     161      :setting:`DATABASE_NAME` should be the full absolute path, including filename, of
    162162      that file. If the file doesn't exist, it will automatically be created
    163163      when you synchronize the database for the first time (see below).
    164164     
  • docs/ref/contrib/admin.txt

    diff --git a/docs/ref/contrib/admin.txt b/docs/ref/contrib/admin.txt
    a b  
    2525
    2626There are five steps in activating the Django admin site:
    2727
    28     1. Add ``django.contrib.admin`` to your ``INSTALLED_APPS`` setting.
     28    1. Add ``django.contrib.admin`` to your :setting:`INSTALLED_APPS` setting.
    2929
    3030    2. Determine which of your application's models should be editable in the
    3131       admin interface.
     
    646646            }
    647647            js = ("my_code.js",)
    648648
    649 Keep in mind that this will be prepended with ``MEDIA_URL``. The same rules
     649Keep in mind that this will be prepended with :setting:`MEDIA_URL`. The same rules
    650650apply as :ref:`regular media definitions on forms <topics-forms-media>`.
    651651
    652652Adding custom validation to the admin
     
    909909
    910910In order to override one or more of them, first create an ``admin`` directory in
    911911your project's ``templates`` directory. This can be any of the directories you
    912 specified in ``TEMPLATE_DIRS``.
     912specified in :setting:`TEMPLATE_DIRS`.
    913913
    914914Within this ``admin`` directory, create sub-directories named after your app.
    915915Within these app subdirectories create sub-directories named after your models.
     
    10311031    )
    10321032
    10331033Above we used ``admin.autodiscover()`` to automatically load the
    1034 ``INSTALLED_APPS`` admin.py modules.
     1034:setting:`INSTALLED_APPS` admin.py modules.
    10351035
    10361036In this example, we register the ``AdminSite`` instance
    10371037``myproject.admin.admin_site`` at the URL ``/myadmin/`` ::
  • docs/ref/contrib/comments/settings.txt

    diff --git a/docs/ref/contrib/comments/settings.txt b/docs/ref/contrib/comments/settings.txt
    a b  
    2929COMMENTS_APP
    3030------------
    3131
    32 The app (i.e. entry in ``INSTALLED_APPS``) responsible for all "business logic."
     32The app (i.e. entry in :setting:`INSTALLED_APPS`) responsible for all "business logic."
    3333You can change this to provide custom comment models and forms, though this is
    3434currently undocumented.
  • docs/ref/contrib/index.txt

    diff --git a/docs/ref/contrib/index.txt b/docs/ref/contrib/index.txt
    a b  
    1616
    1717    For most of these add-ons -- specifically, the add-ons that include either
    1818    models or template tags -- you'll need to add the package name (e.g.,
    19     ``'django.contrib.admin'``) to your ``INSTALLED_APPS`` setting and re-run
     19    ``'django.contrib.admin'``) to your :setting:`INSTALLED_APPS` setting and re-run
    2020    ``manage.py syncdb``.
    2121
    2222.. _"batteries included" philosophy: http://docs.python.org/tut/node12.html#batteries-included
  • docs/ref/databases.txt

    diff --git a/docs/ref/databases.txt b/docs/ref/databases.txt
    a b  
    173173       :setting:`DATABASE_PORT`
    174174    3. MySQL option files.
    175175
    176 In other words, if you set the name of the database in ``DATABASE_OPTIONS``,
    177 this will take precedence over ``DATABASE_NAME``, which would override
     176In other words, if you set the name of the database in :setting:`DATABASE_OPTIONS`,
     177this will take precedence over :setting:`DATABASE_NAME`, which would override
    178178anything in a `MySQL option file`_.
    179179
    180180Here's a sample configuration which uses a MySQL option file::
  • docs/ref/django-admin.txt

    diff --git a/docs/ref/django-admin.txt b/docs/ref/django-admin.txt
    a b  
    6363---------
    6464
    6565Many subcommands take a list of "app names." An "app name" is the basename of
    66 the package containing your models. For example, if your ``INSTALLED_APPS``
     66the package containing your models. For example, if your :setting:`INSTALLED_APPS`
    6767contains the string ``'mysite.blog'``, the app name is ``blog``.
    6868
    6969Determining the version
     
    160160.. django-admin:: dbshell
    161161
    162162Runs the command-line client for the database engine specified in your
    163 ``DATABASE_ENGINE`` setting, with the connection parameters specified in your
    164 ``DATABASE_USER``, ``DATABASE_PASSWORD``, etc., settings.
     163:setting:`DATABASE_ENGINE` setting, with the connection parameters specified in your
     164:setting:`DATABASE_USER`, :setting:`DATABASE_PASSWORD`, etc., settings.
    165165
    166166    * For PostgreSQL, this runs the ``psql`` command-line client.
    167167    * For MySQL, this runs the ``mysql`` command-line client.
     
    181181settings.
    182182
    183183Settings that don't appear in the defaults are followed by ``"###"``. For
    184 example, the default settings don't define ``ROOT_URLCONF``, so
     184example, the default settings don't define :setting:`ROOT_URLCONF`, so
    185185``ROOT_URLCONF`` is followed by ``"###"`` in the output of ``diffsettings``.
    186186
    187187Note that Django's default settings live in ``django/conf/global_settings.py``,
     
    245245The behavior of this command has changed in the Django development version.
    246246Previously, this command cleared *every* table in the database, including any
    247247table that Django didn't know about (i.e., tables that didn't have associated
    248 models and/or weren't in ``INSTALLED_APPS``). Now, the command only clears
     248models and/or weren't in :setting:`INSTALLED_APPS`). Now, the command only clears
    249249tables that are represented by Django models and are activated in
    250250``INSTALLED_APPS``.
    251251
     
    259259---------
    260260
    261261Introspects the database tables in the database pointed-to by the
    262 ``DATABASE_NAME`` setting and outputs a Django model module (a ``models.py``
     262:setting:`DATABASE_NAME` setting and outputs a Django model module (a ``models.py``
    263263file) to standard output.
    264264
    265265Use this if you have a legacy database with which you'd like to use Django.
     
    308308Django will search in three locations for fixtures:
    309309
    310310   1. In the ``fixtures`` directory of every installed application
    311    2. In any directory named in the ``FIXTURE_DIRS`` setting
     311   2. In any directory named in the :setting:`FIXTURE_DIRS` setting
    312312   3. In the literal path named by the fixture
    313313
    314314Django will load any and all fixtures it finds in these locations that match
     
    343343
    344344would search ``<appname>/fixtures/foo/bar/mydata.json`` for each installed
    345345application,  ``<dirname>/foo/bar/mydata.json`` for each directory in
    346 ``FIXTURE_DIRS``, and the literal path ``foo/bar/mydata.json``.
     346:setting:`FIXTURE_DIRS`, and the literal path ``foo/bar/mydata.json``.
    347347
    348348Note that the order in which fixture files are processed is undefined. However,
    349349all fixture data is installed as a single transaction, so data in
     
    520520~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    521521
    522522By default, the development server doesn't serve any static files for your site
    523 (such as CSS files, images, things under ``MEDIA_URL`` and so forth). If
     523(such as CSS files, images, things under :setting:`MEDIA_URL` and so forth). If
    524524you want to configure Django to serve static media, read :ref:`howto-static-files`.
    525525
    526526Turning off auto-reload
     
    624624syncdb
    625625------
    626626
    627 Creates the database tables for all apps in ``INSTALLED_APPS`` whose tables
     627Creates the database tables for all apps in :setting:`INSTALLED_APPS` whose tables
    628628have not already been created.
    629629
    630630Use this command when you've added new applications to your project and want to
    631631install them in the database. This includes any apps shipped with Django that
    632 might be in ``INSTALLED_APPS`` by default. When you start a new project, run
     632might be in :setting:`INSTALLED_APPS` by default. When you start a new project, run
    633633this command to install the default apps.
    634634
    635635.. admonition:: Syncdb will not alter existing tables
     
    736736validate
    737737--------
    738738
    739 Validates all installed models (according to the ``INSTALLED_APPS`` setting)
     739Validates all installed models (according to the :setting:`INSTALLED_APPS` setting)
    740740and prints validation errors to standard output.
    741741
    742742Default options
  • docs/ref/forms/fields.txt

    diff --git a/docs/ref/forms/fields.txt b/docs/ref/forms/fields.txt
    a b  
    724724.. attribute:: URLField.validator_user_agent
    725725
    726726    String used as the user-agent used when checking for a URL's existence.
    727     Defaults to the value of the ``URL_VALIDATOR_USER_AGENT`` setting.
     727    Defaults to the value of the :setting:`URL_VALIDATOR_USER_AGENT` setting.
    728728
    729729Slightly complex built-in ``Field`` classes
    730730-------------------------------------------
  • docs/ref/generic-views.txt

    diff --git a/docs/ref/generic-views.txt b/docs/ref/generic-views.txt
    a b  
    9797      just before rendering the template.
    9898
    9999    * ``mimetype``: The MIME type to use for the resulting document. Defaults
    100       to the value of the ``DEFAULT_CONTENT_TYPE`` setting.
     100      to the value of the :setting:`DEFAULT_CONTENT_TYPE` setting.
    101101
    102102**Example:**
    103103
     
    191191      the view's template.
    192192
    193193    * ``mimetype``: The MIME type to use for the resulting document. Defaults
    194       to the value of the ``DEFAULT_CONTENT_TYPE`` setting.
     194      to the value of the :setting:`DEFAULT_CONTENT_TYPE` setting.
    195195
    196196    * ``allow_future``: A boolean specifying whether to include "future"
    197197      objects on this page, where "future" means objects in which the field
     
    288288      this is ``False``.
    289289
    290290    * ``mimetype``: The MIME type to use for the resulting document. Defaults
    291       to the value of the ``DEFAULT_CONTENT_TYPE`` setting.
     291      to the value of the :setting:`DEFAULT_CONTENT_TYPE` setting.
    292292
    293293    * ``allow_future``: A boolean specifying whether to include "future"
    294294      objects on this page, where "future" means objects in which the field
     
    375375      determining the variable's name.
    376376
    377377    * ``mimetype``: The MIME type to use for the resulting document. Defaults
    378       to the value of the ``DEFAULT_CONTENT_TYPE`` setting.
     378      to the value of the :setting:`DEFAULT_CONTENT_TYPE` setting.
    379379
    380380    * ``allow_future``: A boolean specifying whether to include "future"
    381381      objects on this page, where "future" means objects in which the field
     
    456456      determining the variable's name.
    457457
    458458    * ``mimetype``: The MIME type to use for the resulting document. Defaults
    459       to the value of the ``DEFAULT_CONTENT_TYPE`` setting.
     459      to the value of the :setting:`DEFAULT_CONTENT_TYPE` setting.
    460460
    461461    * ``allow_future``: A boolean specifying whether to include "future"
    462462      objects on this page, where "future" means objects in which the field
     
    541541      determining the variable's name.
    542542
    543543    * ``mimetype``: The MIME type to use for the resulting document. Defaults
    544       to the value of the ``DEFAULT_CONTENT_TYPE`` setting.
     544      to the value of the :setting:`DEFAULT_CONTENT_TYPE` setting.
    545545
    546546    * ``allow_future``: A boolean specifying whether to include "future"
    547547      objects on this page, where "future" means objects in which the field
     
    651651      to use in the template context. By default, this is ``'object'``.
    652652
    653653    * ``mimetype``: The MIME type to use for the resulting document. Defaults
    654       to the value of the ``DEFAULT_CONTENT_TYPE`` setting.
     654      to the value of the :setting:`DEFAULT_CONTENT_TYPE` setting.
    655655
    656656    * ``allow_future``: A boolean specifying whether to include "future"
    657657      objects on this page, where "future" means objects in which the field
     
    727727      determining the variable's name.
    728728
    729729    * ``mimetype``: The MIME type to use for the resulting document. Defaults
    730       to the value of the ``DEFAULT_CONTENT_TYPE`` setting.
     730      to the value of the :setting:`DEFAULT_CONTENT_TYPE` setting.
    731731
    732732**Template name:**
    733733
     
    846846      to use in the template context. By default, this is ``'object'``.
    847847
    848848    * ``mimetype``: The MIME type to use for the resulting document. Defaults
    849       to the value of the ``DEFAULT_CONTENT_TYPE`` setting.
     849      to the value of the :setting:`DEFAULT_CONTENT_TYPE` setting.
    850850
    851851**Template name:**
    852852
  • docs/ref/request-response.txt

    diff --git a/docs/ref/request-response.txt b/docs/ref/request-response.txt
    a b  
    5252    .. versionadded:: 1.0
    5353
    5454    A string representing the current encoding used to decode form submission
    55     data (or ``None``, which means the ``DEFAULT_CHARSET`` setting is used).
     55    data (or ``None``, which means the :setting:`DEFAULT_CHARSET` setting is used).
    5656    You can write to this attribute to change the encoding used when accessing
    5757    the form data. Any subsequent attribute accesses (such as reading from
    5858    ``GET`` or ``POST``) will use the new ``encoding`` value.  Useful if you
     
    174174
    175175    Not defined by Django itself, but will be read if other code (e.g., a custom
    176176    middleware class) sets it. When present, this will be used as the root
    177     URLconf for the current request, overriding the ``ROOT_URLCONF`` setting.
     177    URLconf for the current request, overriding the :setting:`ROOT_URLCONF` setting.
    178178    See :ref:`how-django-processes-a-request` for details.
    179179
    180180Methods
     
    287287    Just like the standard dictionary ``setdefault()`` method, except it uses
    288288    ``__setitem__`` internally.
    289289
    290 .. method:: QueryDict.update(other_dict) 
     290.. method:: QueryDict.update(other_dict)
    291291
    292292    Takes either a ``QueryDict`` or standard dictionary. Just like the standard
    293293    dictionary ``update()`` method, except it *appends* to the current
     
    350350
    351351    Like :meth:`items()`, except it includes all values, as a list, for each
    352352    member of the dictionary. For example::
    353    
     353
    354354         >>> q = QueryDict('a=1&a=2&a=3')
    355355         >>> q.lists()
    356356         [('a', ['1', '2', '3'])]
    357    
     357
    358358.. method:: QueryDict.urlencode()
    359359
    360360    Returns a string of the data in query-string format.
     
    445445-------
    446446
    447447.. method:: HttpResponse.__init__(content='', mimetype=None, status=200, content_type=DEFAULT_CONTENT_TYPE)
    448    
     448
    449449    Instantiates an ``HttpResponse`` object with the given page content (a
    450     string) and MIME type. The ``DEFAULT_CONTENT_TYPE`` is ``'text/html'``.
     450    string) and MIME type. The :setting:`DEFAULT_CONTENT_TYPE` is ``'text/html'``.
    451451
    452452    ``content`` can be an iterator or a string. If it's an iterator, it should
    453453    return strings, and those strings will be joined together to form the
     
    463463    encoding, which makes it more than just a MIME type specification.
    464464    If ``mimetype`` is specified (not ``None``), that value is used.
    465465    Otherwise, ``content_type`` is used. If neither is given, the
    466     ``DEFAULT_CONTENT_TYPE`` setting is used.
     466    :setting:`DEFAULT_CONTENT_TYPE` setting is used.
    467467
    468468.. method:: HttpResponse.__setitem__(header, value)
    469469
  • docs/ref/settings.txt

    diff --git a/docs/ref/settings.txt b/docs/ref/settings.txt
    a b  
    4747
    4848The URL prefix for admin media -- CSS, JavaScript and images used by
    4949the Django administrative interface. Make sure to use a trailing
    50 slash, and to have this be different from the ``MEDIA_URL`` setting
     50slash, and to have this be different from the :setting:`MEDIA_URL` setting
    5151(since the same URL cannot be mapped onto two different sets of
    5252files).
    5353
     
    9292
    9393Whether to append trailing slashes to URLs. This is only used if
    9494``CommonMiddleware`` is installed (see :ref:`topics-http-middleware`). See also
    95 ``PREPEND_WWW``.
     95:setting:`PREPEND_WWW`.
    9696
    9797.. setting:: AUTHENTICATION_BACKENDS
    9898
     
    192192Default: ``''`` (Empty string)
    193193
    194194The name of the database to use. For SQLite, it's the full path to the database
    195 file. When specifying the path, always use forward slashes, even on Windows 
     195file. When specifying the path, always use forward slashes, even on Windows
    196196(e.g. ``C:/homes/user/mysite/sqlite3.db``).
    197197
    198198.. setting:: DATABASE_OPTIONS
     
    225225default port. Not used with SQLite.
    226226
    227227.. setting:: DATABASE_USER
    228    
     228
    229229DATABASE_USER
    230230-------------
    231231
     
    248248and ``MONTH_DAY_FORMAT``.
    249249
    250250.. setting:: DATETIME_FORMAT
    251    
     251
    252252DATETIME_FORMAT
    253253---------------
    254254
     
    516516.. warning::
    517517
    518518    **Always prefix the mode with a 0.**
    519    
     519
    520520    If you're not familiar with file modes, please note that the leading
    521521    ``0`` is very important: it indicates an octal number, which is the
    522522    way that modes must be specified. If you try to use ``644``, you'll
    523523    get totally incorrect behavior.
    524    
    525524
    526 .. _documentation for os.chmod: http://docs.python.org/lib/os-file-dir.html
     525
     526.. _documentation for os.chmod: http://docs.python.org/lib/os-file-dir.html
    527527
    528528.. setting:: FIXTURE_DIRS
    529529
     
    11621162    Django cannot reliably use alternate time zones in a Windows environment.
    11631163    If you're running Django on Windows, this variable must be set to match the
    11641164    system timezone.
    1165    
     1165
    11661166.. _See available choices: http://www.postgresql.org/docs/8.1/static/datetime-keywords.html#DATETIME-TIMEZONE-SET-TABLE
    11671167
    11681168.. setting:: URL_VALIDATOR_USER_AGENT
  • docs/ref/templates/builtins.txt

    diff --git a/docs/ref/templates/builtins.txt b/docs/ref/templates/builtins.txt
    a b  
    15871587===============================
    15881588
    15891589Django comes with a couple of other template-tag libraries that you have to
    1590 enable explicitly in your ``INSTALLED_APPS`` setting and enable in your
     1590enable explicitly in your :setting:`INSTALLED_APPS` setting and enable in your
    15911591template with the ``{% load %}`` tag.
    15921592
    15931593django.contrib.humanize
  • docs/topics/cache.txt

    diff --git a/docs/topics/cache.txt b/docs/topics/cache.txt
    a b  
    4949or directly in memory. This is an important decision that affects your cache's
    5050performance; yes, some cache types are faster than others.
    5151
    52 Your cache preference goes in the ``CACHE_BACKEND`` setting in your settings
     52Your cache preference goes in the :setting:`CACHE_BACKEND` setting in your settings
    5353file. Here's an explanation of all available values for CACHE_BACKEND.
    5454
    5555Memcached
     
    8484    The ``cmemcache`` option is new in 1.0. Previously, only
    8585    ``python-memcached`` was supported.
    8686
    87 To use Memcached with Django, set ``CACHE_BACKEND`` to
     87To use Memcached with Django, set :setting:`CACHE_BACKEND` to
    8888``memcached://ip:port/``, where ``ip`` is the IP address of the Memcached
    8989daemon and ``port`` is the port on which Memcached is running.
    9090
     
    9494
    9595One excellent feature of Memcached is its ability to share cache over multiple
    9696servers. To take advantage of this feature, include all server addresses in
    97 ``CACHE_BACKEND``, separated by semicolons. In this example, the cache is
     97:setting:`CACHE_BACKEND`, separated by semicolons. In this example, the cache is
    9898shared over Memcached instances running on IP address 172.19.26.240 and
    9999172.19.26.242, both on port 11211::
    100100
     
    122122in your database that is in the proper format that Django's database-cache
    123123system expects.
    124124
    125 Once you've created that database table, set your ``CACHE_BACKEND`` setting to
     125Once you've created that database table, set your :setting:`CACHE_BACKEND` setting to
    126126``"db://tablename"``, where ``tablename`` is the name of the database table.
    127127In this example, the cache table's name is ``my_cache_table``::
    128128
     
    134134------------------
    135135
    136136To store cached items on a filesystem, use the ``"file://"`` cache type for
    137 ``CACHE_BACKEND``. For example, to store cached data in ``/var/tmp/django_cache``,
     137:setting:`CACHE_BACKEND`. For example, to store cached data in ``/var/tmp/django_cache``,
    138138use this setting::
    139139
    140140    CACHE_BACKEND = 'file:///var/tmp/django_cache'
     
    158158
    159159If you want the speed advantages of in-memory caching but don't have the
    160160capability of running Memcached, consider the local-memory cache backend. This
    161 cache is multi-process and thread-safe. To use it, set ``CACHE_BACKEND`` to
     161cache is multi-process and thread-safe. To use it, set :setting:`CACHE_BACKEND` to
    162162``"locmem:///"``. For example::
    163163
    164164    CACHE_BACKEND = 'locmem:///'
     
    178178various places but a development/test environment on which you don't want to
    179179cache. As a result, your development environment won't use caching and your
    180180production environment still will. To activate dummy caching, set
    181 ``CACHE_BACKEND`` like so::
     181:setting:`CACHE_BACKEND` like so::
    182182
    183183    CACHE_BACKEND = 'dummy:///'
    184184
     
    190190While Django includes support for a number of cache backends out-of-the-box,
    191191sometimes you might want to use a customized cache backend. To use an external
    192192cache backend with Django, use a Python import path as the scheme portion (the
    193 part before the initial colon) of the ``CACHE_BACKEND`` URI, like so::
     193part before the initial colon) of the :setting:`CACHE_BACKEND` URI, like so::
    194194
    195195    CACHE_BACKEND = 'path.to.backend://'
    196196
     
    206206-----------------------
    207207
    208208All caches may take arguments. They're given in query-string style on the
    209 ``CACHE_BACKEND`` setting. Valid arguments are:
     209:setting:`CACHE_BACKEND` setting. Valid arguments are:
    210210
    211211    timeout
    212212        Default timeout, in seconds, to use for the cache. Defaults to 5
     
    247247entire site. You'll need to add
    248248``'django.middleware.cache.UpdateCacheMiddleware'`` and
    249249``'django.middleware.cache.FetchFromCacheMiddleware'`` to your
    250 ``MIDDLEWARE_CLASSES`` setting, as in this example::
     250:setting:`MIDDLEWARE_CLASSES` setting, as in this example::
    251251
    252252    MIDDLEWARE_CLASSES = (
    253253        'django.middleware.cache.UpdateCacheMiddleware',
     
    263263
    264264Then, add the following required settings to your Django settings file:
    265265
    266 * ``CACHE_MIDDLEWARE_SECONDS`` -- The number of seconds each page should be
     266* :setting:`CACHE_MIDDLEWARE_SECONDS` -- The number of seconds each page should be
    267267  cached.
    268 * ``CACHE_MIDDLEWARE_KEY_PREFIX`` -- If the cache is shared across multiple
     268* :setting:`CACHE_MIDDLEWARE_KEY_PREFIX` -- If the cache is shared across multiple
    269269  sites using the same Django installation, set this to the name of the site,
    270270  or some other string that is unique to this Django instance, to prevent key
    271271  collisions. Use an empty string if you don't care.
    272272
    273273The cache middleware caches every page that doesn't have GET or POST
    274 parameters. Optionally, if the ``CACHE_MIDDLEWARE_ANONYMOUS_ONLY`` setting is
     274parameters. Optionally, if the :setting:`CACHE_MIDDLEWARE_ANONYMOUS_ONLY` setting is
    275275``True``, only anonymous requests (i.e., not those made by a logged-in user)
    276276will be cached. This is a simple and effective way of disabling caching for any
    277277user-specific pages (include Django's admin interface). Note that if you use
    278 ``CACHE_MIDDLEWARE_ANONYMOUS_ONLY``, you should make sure you've activated
     278:setting:`CACHE_MIDDLEWARE_ANONYMOUS_ONLY`, you should make sure you've activated
    279279``AuthenticationMiddleware``.
    280280
    281281Additionally, the cache middleware automatically sets a few headers in each
     
    284284* Sets the ``Last-Modified`` header to the current date/time when a fresh
    285285  (uncached) version of the page is requested.
    286286* Sets the ``Expires`` header to the current date/time plus the defined
    287   ``CACHE_MIDDLEWARE_SECONDS``.
     287  :setting:`CACHE_MIDDLEWARE_SECONDS`.
    288288* Sets the ``Cache-Control`` header to give a max age for the page -- again,
    289   from the ``CACHE_MIDDLEWARE_SECONDS`` setting.
     289  from the :setting:`CACHE_MIDDLEWARE_SECONDS` setting.
    290290
    291291See :ref:`topics-http-middleware` for more on middleware.
    292292
     
    294294
    295295If a view sets its own cache expiry time (i.e. it has a ``max-age`` section in
    296296its ``Cache-Control`` header) then the page will be cached until the expiry
    297 time, rather than ``CACHE_MIDDLEWARE_SECONDS``. Using the decorators in
     297time, rather than :setting:`CACHE_MIDDLEWARE_SECONDS`. Using the decorators in
    298298``django.views.decorators.cache`` you can easily set a view's expiry time
    299299(using the ``cache_control`` decorator) or disable caching for a view (using
    300300the ``never_cache`` decorator). See the `using other headers`__ section for
     
    379379API to store objects in the cache with any level of granularity you like.
    380380
    381381The cache API is simple. The cache module, ``django.core.cache``, exports a
    382 ``cache`` object that's automatically created from the ``CACHE_BACKEND``
     382``cache`` object that's automatically created from the :setting:`CACHE_BACKEND`
    383383setting::
    384384
    385385    >>> from django.core.cache import cache
     
    391391    'hello, world!'
    392392
    393393The ``timeout_seconds`` argument is optional and defaults to the ``timeout``
    394 argument in the ``CACHE_BACKEND`` setting (explained above).
     394argument in the :setting:`CACHE_BACKEND` setting (explained above).
    395395
    396396If the object doesn't exist in the cache, ``cache.get()`` returns ``None``::
    397397
     
    617617For explanation of Cache-Control HTTP directives, see the `Cache-Control spec`_.
    618618
    619619(Note that the caching middleware already sets the cache header's max-age with
    620 the value of the ``CACHE_MIDDLEWARE_SETTINGS`` setting. If you use a custom
     620the value of the :setting:`CACHE_MIDDLEWARE_SETTINGS` setting. If you use a custom
    621621``max_age`` in a ``cache_control`` decorator, the decorator will take
    622622precedence, and the header values will be merged correctly.)
    623623
     
    649649===========================
    650650
    651651If you use caching middleware, it's important to put each half in the right
    652 place within the ``MIDDLEWARE_CLASSES`` setting. That's because the cache
     652place within the :setting:`MIDDLEWARE_CLASSES` setting. That's because the cache
    653653middleware needs to know which headers by which to vary the cache storage.
    654654Middleware always adds something to the ``Vary`` response header when it can.
    655655
  • docs/topics/db/transactions.txt

    diff --git a/docs/topics/db/transactions.txt b/docs/topics/db/transactions.txt
    a b  
    3232transactions.
    3333
    3434To activate this feature, just add the ``TransactionMiddleware`` middleware to
    35 your ``MIDDLEWARE_CLASSES`` setting::
     35your :setting:`MIDDLEWARE_CLASSES` setting::
    3636
    3737    MIDDLEWARE_CLASSES = (
    3838        'django.contrib.sessions.middleware.SessionMiddleware',
     
    136136=================================================
    137137
    138138Control freaks can totally disable all transaction management by setting
    139 ``DISABLE_TRANSACTION_MANAGEMENT`` to ``True`` in the Django settings file.
     139:setting:`DISABLE_TRANSACTION_MANAGEMENT` to ``True`` in the Django settings file.
    140140
    141141If you do this, Django won't provide any automatic transaction management
    142142whatsoever. Middleware will no longer implicitly commit transactions, and
  • docs/topics/email.txt

    diff --git a/docs/topics/email.txt b/docs/topics/email.txt
    a b  
    5858      possible exceptions, all of which are subclasses of ``SMTPException``.
    5959    * ``auth_user``: The optional username to use to authenticate to the SMTP
    6060      server. If this isn't provided, Django will use the value of the
    61       ``EMAIL_HOST_USER`` setting.
     61      :setting:`EMAIL_HOST_USER` setting.
    6262    * ``auth_password``: The optional password to use to authenticate to the
    6363      SMTP server. If this isn't provided, Django will use the value of the
    64       ``EMAIL_HOST_PASSWORD`` setting.
     64      :setting:`EMAIL_HOST_PASSWORD` setting.
    6565
    6666.. _smtplib docs: http://docs.python.org/library/smtplib.html
    6767
  • docs/topics/files.txt

    diff --git a/docs/topics/files.txt b/docs/topics/files.txt
    a b  
    125125======================  ===================================================
    126126``location``            Optional. Absolute path to the directory that will
    127127                        hold the files. If omitted, it will be set to the
    128                         value of your ``MEDIA_ROOT`` setting.
     128                        value of your :setting:`MEDIA_ROOT` setting.
    129129``base_url``            Optional. URL that serves the files stored at this
    130130                        location. If omitted, it will default to the value
    131                         of your ``MEDIA_URL`` setting.
     131                        of your :setting:`MEDIA_URL` setting.
    132132======================  ===================================================
    133133
    134134For example, the following code will store uploaded files under
    135 ``/media/photos`` regardless of what your ``MEDIA_ROOT`` setting is::
     135``/media/photos`` regardless of what your :setting:`MEDIA_ROOT` setting is::
    136136
    137137    from django.db import models
    138138    from django.core.files.storage import FileSystemStorage
  • docs/topics/http/file-uploads.txt

    diff --git a/docs/topics/http/file-uploads.txt b/docs/topics/http/file-uploads.txt
    a b  
    214214
    215215When a user uploads a file, Django passes off the file data to an *upload
    216216handler* -- a small class that handles file data as it gets uploaded. Upload
    217 handlers are initially defined in the ``FILE_UPLOAD_HANDLERS`` setting, which
     217handlers are initially defined in the :setting:`FILE_UPLOAD_HANDLERS` setting, which
    218218defaults to::
    219219
    220220    ("django.core.files.uploadhandler.MemoryFileUploadHandler",
     
    235235Sometimes particular views require different upload behavior. In these cases,
    236236you can override upload handlers on a per-request basis by modifying
    237237``request.upload_handlers``. By default, this list will contain the upload
    238 handlers given by ``FILE_UPLOAD_HANDLERS``, but you can modify the list as you
     238handlers given by :setting:`FILE_UPLOAD_HANDLERS`, but you can modify the list as you
    239239would any other list.
    240240
    241241For instance, suppose you've written a ``ProgressBarUploadHandler`` that
  • docs/topics/http/sessions.txt

    diff --git a/docs/topics/http/sessions.txt b/docs/topics/http/sessions.txt
    a b  
    1616
    1717To enable session functionality, do the following:
    1818
    19     * Edit the ``MIDDLEWARE_CLASSES`` setting and make sure
    20       ``MIDDLEWARE_CLASSES`` contains ``'django.contrib.sessions.middleware.SessionMiddleware'``.
     19    * Edit the :setting:`MIDDLEWARE_CLASSES` setting and make sure
     20      :setting:`MIDDLEWARE_CLASSES` contains ``'django.contrib.sessions.middleware.SessionMiddleware'``.
    2121      The default ``settings.py`` created by ``django-admin.py startproject`` has
    2222      ``SessionMiddleware`` activated.
    2323
    24     * Add ``'django.contrib.sessions'`` to your ``INSTALLED_APPS`` setting,
     24    * Add ``'django.contrib.sessions'`` to your :setting:`INSTALLED_APPS` setting,
    2525      and run ``manage.py syncdb`` to install the single database table
    2626      that stores session data.
    2727
     
    3030   see `configuring the session engine`_.
    3131
    3232If you don't want to use sessions, you might as well remove the
    33 ``SessionMiddleware`` line from ``MIDDLEWARE_CLASSES`` and ``'django.contrib.sessions'``
    34 from your ``INSTALLED_APPS``. It'll save you a small bit of overhead.
     33``SessionMiddleware`` line from :setting:`MIDDLEWARE_CLASSES` and ``'django.contrib.sessions'``
     34from your :setting:`INSTALLED_APPS`. It'll save you a small bit of overhead.
    3535
    3636Configuring the session engine
    3737==============================
     
    4646Using file-based sessions
    4747-------------------------
    4848
    49 To use file-based sessions, set the ``SESSION_ENGINE`` setting to
     49To use file-based sessions, set the :setting:`SESSION_ENGINE` setting to
    5050``"django.contrib.sessions.backends.file"``.
    5151
    52 You might also want to set the ``SESSION_FILE_PATH`` setting (which defaults
     52You might also want to set the :setting:`SESSION_FILE_PATH` setting (which defaults
    5353to output from ``tempfile.gettempdir()``, most likely ``/tmp``) to control
    5454where Django stores session files. Be sure to check that your Web server has
    5555permissions to read and write to this location.
     
    5757Using cache-based sessions
    5858--------------------------
    5959
    60 To store session data using Django's cache system, set ``SESSION_ENGINE``
     60To store session data using Django's cache system, set :setting:`SESSION_ENGINE`
    6161to ``"django.contrib.sessions.backends.cache"``. You'll want to make sure
    6262you've configured your cache; see the :ref:`cache documentation <topics-cache>` for details.
    6363
     
    324324
    325325    request.session.modified = True
    326326
    327 To change this default behavior, set the ``SESSION_SAVE_EVERY_REQUEST`` setting
     327To change this default behavior, set the :setting:`SESSION_SAVE_EVERY_REQUEST` setting
    328328to ``True``. If ``SESSION_SAVE_EVERY_REQUEST`` is ``True``, Django will save
    329329the session to the database on every single request.
    330330
     
    339339===============================================
    340340
    341341You can control whether the session framework uses browser-length sessions vs.
    342 persistent sessions with the ``SESSION_EXPIRE_AT_BROWSER_CLOSE`` setting.
     342persistent sessions with the :setting:`SESSION_EXPIRE_AT_BROWSER_CLOSE` setting.
    343343
    344344By default, ``SESSION_EXPIRE_AT_BROWSER_CLOSE`` is set to ``False``, which
    345345means session cookies will be stored in users' browsers for as long as
    346 ``SESSION_COOKIE_AGE``. Use this if you don't want people to have to log in
     346:setting:`SESSION_COOKIE_AGE`. Use this if you don't want people to have to log in
    347347every time they open a browser.
    348348
    349349If ``SESSION_EXPIRE_AT_BROWSER_CLOSE`` is set to ``True``, Django will use
  • docs/topics/http/urls.txt

    diff --git a/docs/topics/http/urls.txt b/docs/topics/http/urls.txt
    a b  
    3737algorithm the system follows to determine which Python code to execute:
    3838
    3939    1. Django determines the root URLconf module to use. Ordinarily,
    40        this is the value of the ``ROOT_URLCONF`` setting, but if the incoming
     40       this is the value of the :setting:`ROOT_URLCONF` setting, but if the incoming
    4141       ``HttpRequest`` object has an attribute called ``urlconf``, its value
    4242       will be used in place of the ``ROOT_URLCONF`` setting.
    43    
     43
    4444    2. Django loads that Python module and looks for the variable
    4545       ``urlpatterns``. This should be a Python list, in the format returned by
    4646       the function ``django.conf.urls.defaults.patterns()``.
    47    
     47
    4848    3. Django runs through each URL pattern, in order, and stops at the first
    4949       one that matches the requested URL.
    50    
     50
    5151    4. Once one of the regexes matches, Django imports and calls the given
    5252       view, which is a simple Python function. The view gets passed an
    5353       :class:`~django.http.HttpRequest` as its first argument and any values
  • docs/topics/http/views.txt

    diff --git a/docs/topics/http/views.txt b/docs/topics/http/views.txt
    a b  
    5050
    5151.. admonition:: Django's Time Zone
    5252   
    53     Django includes a ``TIME_ZONE`` setting that defaults to
     53    Django includes a :setting:`TIME_ZONE` setting that defaults to
    5454    ``America/Chicago``. This probably isn't where you live, so you might want
    5555    to change it in your settings file.
    5656
     
    165165      in the 404.
    166166
    167167    * The 404 view is passed a ``RequestContext`` and will have access to
    168       variables supplied by your ``TEMPLATE_CONTEXT_PROCESSORS`` setting (e.g.,
    169       ``MEDIA_URL``).
     168      variables supplied by your :setting:`TEMPLATE_CONTEXT_PROCESSORS` setting (e.g.,
     169      :setting:`MEDIA_URL`).
    170170
    171     * If ``DEBUG`` is set to ``True`` (in your settings module), then your 404
     171    * If :setting:`DEBUG` is set to ``True`` (in your settings module), then your 404
    172172      view will never be used, and the traceback will be displayed instead.
    173173
    174174The 500 (server error) view
  • docs/topics/i18n.txt

    diff --git a/docs/topics/i18n.txt b/docs/topics/i18n.txt
    a b  
    4040optimizations so as not to load the internationalization machinery.
    4141
    4242You'll probably also want to remove ``'django.core.context_processors.i18n'``
    43 from your ``TEMPLATE_CONTEXT_PROCESSORS`` setting.
     43from your :setting:`TEMPLATE_CONTEXT_PROCESSORS` setting.
    4444
    4545If you do need internationalization: three steps
    4646================================================
     
    293293
    294294Each ``RequestContext`` has access to three translation-specific variables:
    295295
    296     * ``LANGUAGES`` is a list of tuples in which the first element is the
     296    * :setting:`LANGUAGES` is a list of tuples in which the first element is the
    297297      language code and the second is the language name (translated into the
    298298      currently active locale).
    299299
     
    592592selection based on data from the request. It customizes content for each user.
    593593
    594594To use ``LocaleMiddleware``, add ``'django.middleware.locale.LocaleMiddleware'``
    595 to your ``MIDDLEWARE_CLASSES`` setting. Because middleware order matters, you
     595to your :setting:`MIDDLEWARE_CLASSES` setting. Because middleware order matters, you
    596596should follow these guidelines:
    597597
    598598    * Make sure it's one of the first middlewares installed.
     
    600600      makes use of session data.
    601601    * If you use ``CacheMiddleware``, put ``LocaleMiddleware`` after it.
    602602
    603 For example, your ``MIDDLEWARE_CLASSES`` might look like this::
     603For example, your :setting:`MIDDLEWARE_CLASSES` might look like this::
    604604
    605605    MIDDLEWARE_CLASSES = (
    606606       'django.contrib.sessions.middleware.SessionMiddleware',
     
    623623
    624624      In Django version 0.96 and before, the cookie's name is hard-coded to
    625625      ``django_language``. In Django 1,0, The cookie name is set by the
    626       ``LANGUAGE_COOKIE_NAME`` setting. (The default name is
     626      :setting:`LANGUAGE_COOKIE_NAME` setting. (The default name is
    627627      ``django_language``.)
    628628
    629629    * Failing that, it looks at the ``Accept-Language`` HTTP header. This
     
    631631      prefer, in order by priority. Django tries each language in the header
    632632      until it finds one with available translations.
    633633
    634     * Failing that, it uses the global ``LANGUAGE_CODE`` setting.
     634    * Failing that, it uses the global :setting:`LANGUAGE_CODE` setting.
    635635
    636636.. _locale-middleware-notes:
    637637
     
    649649    * Only languages listed in the :setting:`LANGUAGES` setting can be selected.
    650650      If you want to restrict the language selection to a subset of provided
    651651      languages (because your application doesn't provide all those languages),
    652       set ``LANGUAGES`` to a list of languages. For example::
     652      set :setting:`LANGUAGES` to a list of languages. For example::
    653653
    654654          LANGUAGES = (
    655655            ('de', _('German')),
     
    662662
    663663      .. _LANGUAGES setting: ../settings/#languages
    664664
    665     * If you define a custom ``LANGUAGES`` setting, as explained in the
     665    * If you define a custom :setting:`LANGUAGES` setting, as explained in the
    666666      previous bullet, it's OK to mark the languages as translation strings
    667667      -- but use a "dummy" ``ugettext()`` function, not the one in
    668668      ``django.utils.translation``. You should *never* import
     
    683683      With this arrangement, ``django-admin.py makemessages`` will still find
    684684      and mark these strings for translation, but the translation won't happen
    685685      at runtime -- so you'll have to remember to wrap the languages in the
    686       *real* ``ugettext()`` in any code that uses ``LANGUAGES`` at runtime.
     686      *real* ``ugettext()`` in any code that uses :setting:`LANGUAGES` at runtime.
    687687
    688688    * The ``LocaleMiddleware`` can only select languages for which there is a
    689689      Django-provided base translation. If you want to provide translations
     
    700700      Technical message IDs are easily recognized; they're all upper case. You
    701701      don't translate the message ID as with other messages, you provide the
    702702      correct local variant on the provided English value. For example, with
    703       ``DATETIME_FORMAT`` (or ``DATE_FORMAT`` or ``TIME_FORMAT``), this would
     703      :setting:`DATETIME_FORMAT` (or :setting:`DATE_FORMAT` or :setting:`TIME_FORMAT`), this would
    704704      be the format string that you want to use in your language. The format
    705705      is identical to the format strings used by the ``now`` template tag.
    706706
     
    757757
    758758    * ``$APPPATH/locale/<language>/LC_MESSAGES/django.(po|mo)``
    759759    * ``$PROJECTPATH/locale/<language>/LC_MESSAGES/django.(po|mo)``
    760     * All paths listed in ``LOCALE_PATHS`` in your settings file are
     760    * All paths listed in :setting:`LOCALE_PATHS` in your settings file are
    761761      searched in that order for ``<language>/LC_MESSAGES/django.(po|mo)``
    762762    * ``$PYTHONPATH/django/conf/locale/<language>/LC_MESSAGES/django.(po|mo)``
    763763
     
    769769to produce the binary ``django.mo`` files that are used by ``gettext``.
    770770
    771771You can also run ``django-admin.py compilemessages --settings=path.to.settings``
    772 to make the compiler process all the directories in your ``LOCALE_PATHS``
     772to make the compiler process all the directories in your :setting:`LOCALE_PATHS`
    773773setting.
    774774
    775775Application message files are a bit complicated to discover -- they need the
     
    806806parameter set in request. If session support is enabled, the view
    807807saves the language choice in the user's session. Otherwise, it saves the
    808808language choice in a cookie that is by default named ``django_language``.
    809 (The name can be changed through the ``LANGUAGE_COOKIE_NAME`` setting if you're
     809(The name can be changed through the :setting:`LANGUAGE_COOKIE_NAME` setting if you're
    810810using the Django development version.)
    811811
    812812After setting the language choice, Django redirects the user, following this
     
    869869    )
    870870
    871871Each string in ``packages`` should be in Python dotted-package syntax (the
    872 same format as the strings in ``INSTALLED_APPS``) and should refer to a package
     872same format as the strings in :setting:`INSTALLED_APPS`) and should refer to a package
    873873that contains a ``locale`` directory. If you specify multiple packages, all
    874874those catalogs are merged into one catalog. This is useful if you have
    875875JavaScript that uses strings from different applications.
     
    884884signs in the URL. This is especially useful if your pages use code from
    885885different apps and this changes often and you don't want to pull in one big
    886886catalog file. As a security measure, these values can only be either
    887 ``django.conf`` or any package from the ``INSTALLED_APPS`` setting.
     887``django.conf`` or any package from the :setting:`INSTALLED_APPS` setting.
    888888
    889889Using the JavaScript translation catalog
    890890----------------------------------------
  • docs/topics/templates.txt

    diff --git a/docs/topics/templates.txt b/docs/topics/templates.txt
    a b  
    9999``title`` attribute of the ``section`` object.
    100100
    101101If you use a variable that doesn't exist, the template system will insert
    102 the value of the ``TEMPLATE_STRING_IF_INVALID`` setting, which is set to ``''``
     102the value of the :setting:`TEMPLATE_STRING_IF_INVALID` setting, which is set to ``''``
    103103(the empty string) by default.
    104104
    105105See `Using the built-in reference`_, below, for help on finding what variables
  • docs/topics/testing.txt

    diff --git a/docs/topics/testing.txt b/docs/topics/testing.txt
    a b  
    903903``django.test.TestCase`` provides the ability to customize the URLconf
    904904configuration for the duration of the execution of a test suite. If your
    905905``TestCase`` instance defines an ``urls`` attribute, the ``TestCase`` will use
    906 the value of that attribute as the ``ROOT_URLCONF`` for the duration of that
     906the value of that attribute as the :setting:`ROOT_URLCONF` for the duration of that
    907907test.
    908908
    909909For example::
Back to Top