2823 lines
80 KiB
Plaintext
2823 lines
80 KiB
Plaintext
========
|
||
Settings
|
||
========
|
||
|
||
.. contents::
|
||
:local:
|
||
:depth: 1
|
||
|
||
.. warning::
|
||
|
||
Be careful when you override settings, especially when the default value
|
||
is a non-empty tuple or dictionary, such as :setting:`MIDDLEWARE_CLASSES`
|
||
and :setting:`TEMPLATE_CONTEXT_PROCESSORS`. Make sure you keep the
|
||
components required by the features of Django you wish to use.
|
||
|
||
Core settings
|
||
=============
|
||
|
||
Here's a list of settings available in Django core and their default values.
|
||
Settings provided by contrib apps are listed below, followed by a topical index
|
||
of the core settings.
|
||
|
||
.. setting:: ABSOLUTE_URL_OVERRIDES
|
||
|
||
ABSOLUTE_URL_OVERRIDES
|
||
----------------------
|
||
|
||
Default: ``{}`` (Empty dictionary)
|
||
|
||
A dictionary mapping ``"app_label.model_name"`` strings to functions that take
|
||
a model object and return its URL. This is a way of overriding
|
||
``get_absolute_url()`` methods on a per-installation basis. Example::
|
||
|
||
ABSOLUTE_URL_OVERRIDES = {
|
||
'blogs.weblog': lambda o: "/blogs/%s/" % o.slug,
|
||
'news.story': lambda o: "/stories/%s/%s/" % (o.pub_year, o.slug),
|
||
}
|
||
|
||
Note that the model name used in this setting should be all lower-case, regardless
|
||
of the case of the actual model class name.
|
||
|
||
.. setting:: ADMINS
|
||
|
||
ADMINS
|
||
------
|
||
|
||
Default: ``()`` (Empty tuple)
|
||
|
||
A tuple that lists people who get code error notifications. When
|
||
``DEBUG=False`` and a view raises an exception, Django will email these people
|
||
with the full exception information. Each member of the tuple should be a tuple
|
||
of (Full name, email address). Example::
|
||
|
||
(('John', 'john@example.com'), ('Mary', 'mary@example.com'))
|
||
|
||
Note that Django will email *all* of these people whenever an error happens.
|
||
See :doc:`/howto/error-reporting` for more information.
|
||
|
||
.. setting:: ALLOWED_HOSTS
|
||
|
||
ALLOWED_HOSTS
|
||
-------------
|
||
|
||
Default: ``[]`` (Empty list)
|
||
|
||
A list of strings representing the host/domain names that this Django site can
|
||
serve. This is a security measure to prevent an attacker from poisoning caches
|
||
and password reset emails with links to malicious hosts by submitting requests
|
||
with a fake HTTP ``Host`` header, which is possible even under many
|
||
seemingly-safe web server configurations.
|
||
|
||
Values in this list can be fully qualified names (e.g. ``'www.example.com'``),
|
||
in which case they will be matched against the request's ``Host`` header
|
||
exactly (case-insensitive, not including port). A value beginning with a period
|
||
can be used as a subdomain wildcard: ``'.example.com'`` will match
|
||
``example.com``, ``www.example.com``, and any other subdomain of
|
||
``example.com``. A value of ``'*'`` will match anything; in this case you are
|
||
responsible to provide your own validation of the ``Host`` header (perhaps in a
|
||
middleware; if so this middleware must be listed first in
|
||
:setting:`MIDDLEWARE_CLASSES`).
|
||
|
||
.. note::
|
||
|
||
If you want to also allow the `fully qualified domain name (FQDN)`_, which
|
||
some browsers can send in the Host header, you must explicitly add another
|
||
ALLOWED_HOSTS entry that includes a trailing period. This entry can also be
|
||
a subdomain wildcard::
|
||
|
||
ALLOWED_HOSTS = [
|
||
'.example.com', # Allow domain and subdomains
|
||
'.example.com.', # Also allow FQDN and subdomains
|
||
]
|
||
|
||
.. _`fully qualified domain name (FQDN)`: http://en.wikipedia.org/wiki/Fully_qualified_domain_name
|
||
|
||
If the ``Host`` header (or ``X-Forwarded-Host`` if
|
||
:setting:`USE_X_FORWARDED_HOST` is enabled) does not match any value in this
|
||
list, the :meth:`django.http.HttpRequest.get_host()` method will raise
|
||
:exc:`~django.core.exceptions.SuspiciousOperation`.
|
||
|
||
When :setting:`DEBUG` is ``True`` or when running tests, host validation is
|
||
disabled; any host will be accepted. Thus it's usually only necessary to set it
|
||
in production.
|
||
|
||
This validation only applies via :meth:`~django.http.HttpRequest.get_host()`;
|
||
if your code accesses the ``Host`` header directly from ``request.META`` you
|
||
are bypassing this security protection.
|
||
|
||
.. setting:: ALLOWED_INCLUDE_ROOTS
|
||
|
||
ALLOWED_INCLUDE_ROOTS
|
||
---------------------
|
||
|
||
Default: ``()`` (Empty tuple)
|
||
|
||
A tuple of strings representing allowed prefixes for the ``{% ssi %}`` template
|
||
tag. This is a security measure, so that template authors can't access files
|
||
that they shouldn't be accessing.
|
||
|
||
For example, if :setting:`ALLOWED_INCLUDE_ROOTS` is ``('/home/html', '/var/www')``,
|
||
then ``{% ssi /home/html/foo.txt %}`` would work, but ``{% ssi /etc/passwd %}``
|
||
wouldn't.
|
||
|
||
.. setting:: APPEND_SLASH
|
||
|
||
APPEND_SLASH
|
||
------------
|
||
|
||
Default: ``True``
|
||
|
||
When set to ``True``, if the request URL does not match any of the patterns
|
||
in the URLconf and it doesn't end in a slash, an HTTP redirect is issued to the
|
||
same URL with a slash appended. Note that the redirect may cause any data
|
||
submitted in a POST request to be lost.
|
||
|
||
The :setting:`APPEND_SLASH` setting is only used if
|
||
:class:`~django.middleware.common.CommonMiddleware` is installed
|
||
(see :doc:`/topics/http/middleware`). See also :setting:`PREPEND_WWW`.
|
||
|
||
.. setting:: CACHES
|
||
|
||
CACHES
|
||
------
|
||
|
||
Default::
|
||
|
||
{
|
||
'default': {
|
||
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
|
||
}
|
||
}
|
||
|
||
A dictionary containing the settings for all caches to be used with
|
||
Django. It is a nested dictionary whose contents maps cache aliases
|
||
to a dictionary containing the options for an individual cache.
|
||
|
||
The :setting:`CACHES` setting must configure a ``default`` cache;
|
||
any number of additional caches may also be specified. If you
|
||
are using a cache backend other than the local memory cache, or
|
||
you need to define multiple caches, other options will be required.
|
||
The following cache options are available.
|
||
|
||
.. setting:: CACHES-BACKEND
|
||
|
||
BACKEND
|
||
~~~~~~~
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
The cache backend to use. The built-in cache backends are:
|
||
|
||
* ``'django.core.cache.backends.db.DatabaseCache'``
|
||
* ``'django.core.cache.backends.dummy.DummyCache'``
|
||
* ``'django.core.cache.backends.filebased.FileBasedCache'``
|
||
* ``'django.core.cache.backends.locmem.LocMemCache'``
|
||
* ``'django.core.cache.backends.memcached.MemcachedCache'``
|
||
* ``'django.core.cache.backends.memcached.PyLibMCCache'``
|
||
|
||
You can use a cache backend that doesn't ship with Django by setting
|
||
:setting:`BACKEND <CACHES-BACKEND>` to a fully-qualified path of a cache
|
||
backend class (i.e. ``mypackage.backends.whatever.WhateverCache``).
|
||
Writing a whole new cache backend from scratch is left as an exercise
|
||
to the reader; see the other backends for examples.
|
||
|
||
.. setting:: CACHES-KEY_FUNCTION
|
||
|
||
KEY_FUNCTION
|
||
~~~~~~~~~~~~
|
||
|
||
A string containing a dotted path to a function that defines how to
|
||
compose a prefix, version and key into a final cache key. The default
|
||
implementation is equivalent to the function::
|
||
|
||
def make_key(key, key_prefix, version):
|
||
return ':'.join([key_prefix, str(version), key])
|
||
|
||
You may use any key function you want, as long as it has the same
|
||
argument signature.
|
||
|
||
See the :ref:`cache documentation <cache_key_transformation>` for more
|
||
information.
|
||
|
||
.. setting:: CACHES-KEY_PREFIX
|
||
|
||
KEY_PREFIX
|
||
~~~~~~~~~~
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
A string that will be automatically included (prepended by default) to
|
||
all cache keys used by the Django server.
|
||
|
||
See the :ref:`cache documentation <cache_key_prefixing>` for more information.
|
||
|
||
.. setting:: CACHES-LOCATION
|
||
|
||
LOCATION
|
||
~~~~~~~~
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
The location of the cache to use. This might be the directory for a
|
||
file system cache, a host and port for a memcache server, or simply an
|
||
identifying name for a local memory cache. e.g.::
|
||
|
||
CACHES = {
|
||
'default': {
|
||
'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
|
||
'LOCATION': '/var/tmp/django_cache',
|
||
}
|
||
}
|
||
|
||
.. setting:: CACHES-OPTIONS
|
||
|
||
OPTIONS
|
||
~~~~~~~
|
||
|
||
Default: None
|
||
|
||
Extra parameters to pass to the cache backend. Available parameters
|
||
vary depending on your cache backend.
|
||
|
||
Some information on available parameters can be found in the
|
||
:doc:`Cache Backends </topics/cache>` documentation. For more information,
|
||
consult your backend module's own documentation.
|
||
|
||
.. setting:: CACHES-TIMEOUT
|
||
|
||
TIMEOUT
|
||
~~~~~~~
|
||
|
||
Default: 300
|
||
|
||
The number of seconds before a cache entry is considered stale.
|
||
|
||
.. setting:: CACHES-VERSION
|
||
|
||
VERSION
|
||
~~~~~~~
|
||
|
||
Default: ``1``
|
||
|
||
The default version number for cache keys generated by the Django server.
|
||
|
||
See the :ref:`cache documentation <cache_versioning>` for more information.
|
||
|
||
.. setting:: CACHE_MIDDLEWARE_ALIAS
|
||
|
||
CACHE_MIDDLEWARE_ALIAS
|
||
----------------------
|
||
|
||
Default: ``default``
|
||
|
||
The cache connection to use for the cache middleware.
|
||
|
||
.. setting:: CACHE_MIDDLEWARE_ANONYMOUS_ONLY
|
||
|
||
CACHE_MIDDLEWARE_ANONYMOUS_ONLY
|
||
-------------------------------
|
||
|
||
Default: ``False``
|
||
|
||
.. deprecated:: 1.6
|
||
|
||
This setting was largely ineffective because of using cookies for sessions
|
||
and CSRF. See the :doc:`Django 1.6 release notes</releases/1.6>` for more
|
||
information.
|
||
|
||
If the value of this setting is ``True``, only anonymous requests (i.e., not
|
||
those made by a logged-in user) will be cached. Otherwise, the middleware
|
||
caches every page that doesn't have GET or POST parameters.
|
||
|
||
If you set the value of this setting to ``True``, you should make sure you've
|
||
activated ``AuthenticationMiddleware``.
|
||
|
||
.. setting:: CACHE_MIDDLEWARE_KEY_PREFIX
|
||
|
||
CACHE_MIDDLEWARE_KEY_PREFIX
|
||
---------------------------
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
The cache key prefix that the cache middleware should use.
|
||
|
||
See :doc:`/topics/cache`.
|
||
|
||
.. setting:: CACHE_MIDDLEWARE_SECONDS
|
||
|
||
CACHE_MIDDLEWARE_SECONDS
|
||
------------------------
|
||
|
||
Default: ``600``
|
||
|
||
The default number of seconds to cache a page when the caching middleware or
|
||
``cache_page()`` decorator is used.
|
||
|
||
See :doc:`/topics/cache`.
|
||
|
||
.. _settings-csrf:
|
||
|
||
.. setting:: CSRF_COOKIE_DOMAIN
|
||
|
||
CSRF_COOKIE_DOMAIN
|
||
------------------
|
||
|
||
Default: ``None``
|
||
|
||
The domain to be used when setting the CSRF cookie. This can be useful for
|
||
easily allowing cross-subdomain requests to be excluded from the normal cross
|
||
site request forgery protection. It should be set to a string such as
|
||
``".example.com"`` to allow a POST request from a form on one subdomain to be
|
||
accepted by a view served from another subdomain.
|
||
|
||
Please note that the presence of this setting does not imply that Django's CSRF
|
||
protection is safe from cross-subdomain attacks by default - please see the
|
||
:ref:`CSRF limitations <csrf-limitations>` section.
|
||
|
||
.. setting:: CSRF_COOKIE_HTTPONLY
|
||
|
||
CSRF_COOKIE_HTTPONLY
|
||
--------------------
|
||
|
||
.. versionadded:: 1.6
|
||
|
||
Default: ``False``
|
||
|
||
Whether to use ``HttpOnly`` flag on the CSRF cookie. If this is set to
|
||
``True``, client-side JavaScript will not to be able to access the CSRF cookie.
|
||
See :setting:`SESSION_COOKIE_HTTPONLY` for details on ``HttpOnly``.
|
||
|
||
.. setting:: CSRF_COOKIE_NAME
|
||
|
||
CSRF_COOKIE_NAME
|
||
----------------
|
||
|
||
Default: ``'csrftoken'``
|
||
|
||
The name of the cookie to use for the CSRF authentication token. This can be whatever you
|
||
want. See :doc:`/ref/contrib/csrf`.
|
||
|
||
.. setting:: CSRF_COOKIE_PATH
|
||
|
||
CSRF_COOKIE_PATH
|
||
----------------
|
||
|
||
Default: ``'/'``
|
||
|
||
The path set on the CSRF cookie. This should either match the URL path of your
|
||
Django installation or be a parent of that path.
|
||
|
||
This is useful if you have multiple Django instances running under the same
|
||
hostname. They can use different cookie paths, and each instance will only see
|
||
its own CSRF cookie.
|
||
|
||
.. setting:: CSRF_COOKIE_SECURE
|
||
|
||
CSRF_COOKIE_SECURE
|
||
------------------
|
||
|
||
Default: ``False``
|
||
|
||
Whether to use a secure cookie for the CSRF cookie. If this is set to ``True``,
|
||
the cookie will be marked as "secure," which means browsers may ensure that the
|
||
cookie is only sent under an HTTPS connection.
|
||
|
||
.. setting:: CSRF_FAILURE_VIEW
|
||
|
||
CSRF_FAILURE_VIEW
|
||
-----------------
|
||
|
||
Default: ``'django.views.csrf.csrf_failure'``
|
||
|
||
A dotted path to the view function to be used when an incoming request
|
||
is rejected by the CSRF protection. The function should have this signature::
|
||
|
||
def csrf_failure(request, reason="")
|
||
|
||
where ``reason`` is a short message (intended for developers or logging, not for
|
||
end users) indicating the reason the request was rejected. See
|
||
:doc:`/ref/contrib/csrf`.
|
||
|
||
.. setting:: DATABASES
|
||
|
||
DATABASES
|
||
---------
|
||
|
||
Default: ``{}`` (Empty dictionary)
|
||
|
||
A dictionary containing the settings for all databases to be used with
|
||
Django. It is a nested dictionary whose contents maps database aliases
|
||
to a dictionary containing the options for an individual database.
|
||
|
||
The :setting:`DATABASES` setting must configure a ``default`` database;
|
||
any number of additional databases may also be specified.
|
||
|
||
The simplest possible settings file is for a single-database setup using
|
||
SQLite. This can be configured using the following::
|
||
|
||
DATABASES = {
|
||
'default': {
|
||
'ENGINE': 'django.db.backends.sqlite3',
|
||
'NAME': 'mydatabase'
|
||
}
|
||
}
|
||
|
||
For other database backends, or more complex SQLite configurations, other options
|
||
will be required. The following inner options are available.
|
||
|
||
.. setting:: DATABASE-ATOMIC_REQUESTS
|
||
|
||
ATOMIC_REQUESTS
|
||
~~~~~~~~~~~~~~~
|
||
|
||
.. versionadded:: 1.6
|
||
|
||
Default: ``False``
|
||
|
||
Set this to ``True`` to wrap each HTTP request in a transaction on this
|
||
database. See :ref:`tying-transactions-to-http-requests`.
|
||
|
||
.. setting:: DATABASE-AUTOCOMMIT
|
||
|
||
AUTOCOMMIT
|
||
~~~~~~~~~~
|
||
|
||
.. versionadded:: 1.6
|
||
|
||
Default: ``True``
|
||
|
||
Set this to ``False`` if you want to :ref:`disable Django's transaction
|
||
management <deactivate-transaction-management>` and implement your own.
|
||
|
||
.. setting:: DATABASE-ENGINE
|
||
|
||
ENGINE
|
||
~~~~~~
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
The database backend to use. The built-in database backends are:
|
||
|
||
* ``'django.db.backends.postgresql_psycopg2'``
|
||
* ``'django.db.backends.mysql'``
|
||
* ``'django.db.backends.sqlite3'``
|
||
* ``'django.db.backends.oracle'``
|
||
|
||
You can use a database backend that doesn't ship with Django by setting
|
||
``ENGINE`` to a fully-qualified path (i.e.
|
||
``mypackage.backends.whatever``). Writing a whole new database backend from
|
||
scratch is left as an exercise to the reader; see the other backends for
|
||
examples.
|
||
|
||
.. setting:: HOST
|
||
|
||
HOST
|
||
~~~~
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
Which host to use when connecting to the database. An empty string means
|
||
localhost. Not used with SQLite.
|
||
|
||
If this value starts with a forward slash (``'/'``) and you're using MySQL,
|
||
MySQL will connect via a Unix socket to the specified socket. For example::
|
||
|
||
"HOST": '/var/run/mysql'
|
||
|
||
If you're using MySQL and this value *doesn't* start with a forward slash, then
|
||
this value is assumed to be the host.
|
||
|
||
If you're using PostgreSQL, by default (empty :setting:`HOST`), the connection
|
||
to the database is done through UNIX domain sockets ('local' lines in
|
||
``pg_hba.conf``). If you want to connect through TCP sockets, set
|
||
:setting:`HOST` to 'localhost' or '127.0.0.1' ('host' lines in ``pg_hba.conf``).
|
||
On Windows, you should always define :setting:`HOST`, as UNIX domain sockets
|
||
are not available.
|
||
|
||
.. setting:: NAME
|
||
|
||
NAME
|
||
~~~~
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
The name of the database to use. For SQLite, it's the full path to the database
|
||
file. When specifying the path, always use forward slashes, even on Windows
|
||
(e.g. ``C:/homes/user/mysite/sqlite3.db``).
|
||
|
||
.. setting:: CONN_MAX_AGE
|
||
|
||
CONN_MAX_AGE
|
||
~~~~~~~~~~~~
|
||
|
||
.. versionadded:: 1.6
|
||
|
||
Default: ``0``
|
||
|
||
The lifetime of a database connection, in seconds. Use ``0`` to close database
|
||
connections at the end of each request — Django's historical behavior — and
|
||
``None`` for unlimited persistent connections.
|
||
|
||
.. setting:: OPTIONS
|
||
|
||
OPTIONS
|
||
~~~~~~~
|
||
|
||
Default: ``{}`` (Empty dictionary)
|
||
|
||
Extra parameters to use when connecting to the database. Available parameters
|
||
vary depending on your database backend.
|
||
|
||
Some information on available parameters can be found in the
|
||
:doc:`Database Backends </ref/databases>` documentation. For more information,
|
||
consult your backend module's own documentation.
|
||
|
||
.. setting:: PASSWORD
|
||
|
||
PASSWORD
|
||
~~~~~~~~
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
The password to use when connecting to the database. Not used with SQLite.
|
||
|
||
.. setting:: PORT
|
||
|
||
PORT
|
||
~~~~
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
The port to use when connecting to the database. An empty string means the
|
||
default port. Not used with SQLite.
|
||
|
||
.. setting:: USER
|
||
|
||
USER
|
||
~~~~
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
The username to use when connecting to the database. Not used with SQLite.
|
||
|
||
.. setting:: TEST_CHARSET
|
||
|
||
TEST_CHARSET
|
||
~~~~~~~~~~~~
|
||
|
||
Default: ``None``
|
||
|
||
The character set encoding used to create the test database. The value of this
|
||
string is passed directly through to the database, so its format is
|
||
backend-specific.
|
||
|
||
Supported for the PostgreSQL_ (``postgresql_psycopg2``) and MySQL_ (``mysql``)
|
||
backends.
|
||
|
||
.. _PostgreSQL: http://www.postgresql.org/docs/current/static/multibyte.html
|
||
.. _MySQL: http://dev.mysql.com/doc/refman/5.0/en/charset-database.html
|
||
|
||
.. setting:: TEST_COLLATION
|
||
|
||
TEST_COLLATION
|
||
~~~~~~~~~~~~~~
|
||
|
||
Default: ``None``
|
||
|
||
The collation order to use when creating the test database. This value is
|
||
passed directly to the backend, so its format is backend-specific.
|
||
|
||
Only supported for the ``mysql`` backend (see the `MySQL manual`_ for details).
|
||
|
||
.. _MySQL manual: MySQL_
|
||
|
||
.. setting:: TEST_DEPENDENCIES
|
||
|
||
TEST_DEPENDENCIES
|
||
~~~~~~~~~~~~~~~~~
|
||
|
||
Default: ``['default']``, for all databases other than ``default``,
|
||
which has no dependencies.
|
||
|
||
The creation-order dependencies of the database. See the documentation
|
||
on :ref:`controlling the creation order of test databases
|
||
<topics-testing-creation-dependencies>` for details.
|
||
|
||
.. setting:: TEST_MIRROR
|
||
|
||
TEST_MIRROR
|
||
~~~~~~~~~~~
|
||
|
||
Default: ``None``
|
||
|
||
The alias of the database that this database should mirror during
|
||
testing.
|
||
|
||
This setting exists to allow for testing of master/slave
|
||
configurations of multiple databases. See the documentation on
|
||
:ref:`testing master/slave configurations
|
||
<topics-testing-masterslave>` for details.
|
||
|
||
.. setting:: TEST_NAME
|
||
|
||
TEST_NAME
|
||
~~~~~~~~~
|
||
|
||
Default: ``None``
|
||
|
||
The name of database to use when running the test suite.
|
||
|
||
If the default value (``None``) is used with the SQLite database engine, the
|
||
tests will use a memory resident database. For all other database engines the
|
||
test database will use the name ``'test_' + DATABASE_NAME``.
|
||
|
||
See :ref:`the-test-database`.
|
||
|
||
.. setting:: TEST_CREATE
|
||
|
||
TEST_CREATE
|
||
~~~~~~~~~~~
|
||
|
||
Default: ``True``
|
||
|
||
This is an Oracle-specific setting.
|
||
|
||
If it is set to ``False``, the test tablespaces won't be automatically created
|
||
at the beginning of the tests and dropped at the end.
|
||
|
||
.. setting:: TEST_USER
|
||
|
||
TEST_USER
|
||
~~~~~~~~~
|
||
|
||
Default: ``None``
|
||
|
||
This is an Oracle-specific setting.
|
||
|
||
The username to use when connecting to the Oracle database that will be used
|
||
when running tests. If not provided, Django will use ``'test_' + USER``.
|
||
|
||
.. setting:: TEST_USER_CREATE
|
||
|
||
TEST_USER_CREATE
|
||
~~~~~~~~~~~~~~~~
|
||
|
||
Default: ``True``
|
||
|
||
This is an Oracle-specific setting.
|
||
|
||
If it is set to ``False``, the test user won't be automatically created at the
|
||
beginning of the tests and dropped at the end.
|
||
|
||
.. setting:: TEST_PASSWD
|
||
|
||
TEST_PASSWD
|
||
~~~~~~~~~~~
|
||
|
||
Default: ``None``
|
||
|
||
This is an Oracle-specific setting.
|
||
|
||
The password to use when connecting to the Oracle database that will be used
|
||
when running tests. If not provided, Django will use a hardcoded default value.
|
||
|
||
.. setting:: TEST_TBLSPACE
|
||
|
||
TEST_TBLSPACE
|
||
~~~~~~~~~~~~~
|
||
|
||
Default: ``None``
|
||
|
||
This is an Oracle-specific setting.
|
||
|
||
The name of the tablespace that will be used when running tests. If not
|
||
provided, Django will use ``'test_' + NAME``.
|
||
|
||
.. setting:: TEST_TBLSPACE_TMP
|
||
|
||
TEST_TBLSPACE_TMP
|
||
~~~~~~~~~~~~~~~~~
|
||
|
||
Default: ``None``
|
||
|
||
This is an Oracle-specific setting.
|
||
|
||
The name of the temporary tablespace that will be used when running tests. If
|
||
not provided, Django will use ``'test_' + NAME + '_temp'``.
|
||
|
||
.. setting:: DATABASE_ROUTERS
|
||
|
||
DATABASE_ROUTERS
|
||
----------------
|
||
|
||
Default: ``[]`` (Empty list)
|
||
|
||
The list of routers that will be used to determine which database
|
||
to use when performing a database queries.
|
||
|
||
See the documentation on :ref:`automatic database routing in multi
|
||
database configurations <topics-db-multi-db-routing>`.
|
||
|
||
.. setting:: DATE_FORMAT
|
||
|
||
DATE_FORMAT
|
||
-----------
|
||
|
||
Default: ``'N j, Y'`` (e.g. ``Feb. 4, 2003``)
|
||
|
||
The default formatting to use for displaying date fields in any part of the
|
||
system. Note that if :setting:`USE_L10N` is set to ``True``, then the
|
||
locale-dictated format has higher precedence and will be applied instead. See
|
||
:tfilter:`allowed date format strings <date>`.
|
||
|
||
See also :setting:`DATETIME_FORMAT`, :setting:`TIME_FORMAT` and :setting:`SHORT_DATE_FORMAT`.
|
||
|
||
.. setting:: DATE_INPUT_FORMATS
|
||
|
||
DATE_INPUT_FORMATS
|
||
------------------
|
||
|
||
Default::
|
||
|
||
(
|
||
'%Y-%m-%d', '%m/%d/%Y', '%m/%d/%y', # '2006-10-25', '10/25/2006', '10/25/06'
|
||
'%b %d %Y', '%b %d, %Y', # 'Oct 25 2006', 'Oct 25, 2006'
|
||
'%d %b %Y', '%d %b, %Y', # '25 Oct 2006', '25 Oct, 2006'
|
||
'%B %d %Y', '%B %d, %Y', # 'October 25 2006', 'October 25, 2006'
|
||
'%d %B %Y', '%d %B, %Y', # '25 October 2006', '25 October, 2006'
|
||
)
|
||
|
||
A tuple of formats that will be accepted when inputting data on a date field.
|
||
Formats will be tried in order, using the first valid one. Note that these
|
||
format strings use Python's datetime_ module syntax, not the format strings
|
||
from the ``date`` Django template tag.
|
||
|
||
When :setting:`USE_L10N` is ``True``, the locale-dictated format has higher
|
||
precedence and will be applied instead.
|
||
|
||
See also :setting:`DATETIME_INPUT_FORMATS` and :setting:`TIME_INPUT_FORMATS`.
|
||
|
||
.. _datetime: http://docs.python.org/library/datetime.html#strftime-strptime-behavior
|
||
|
||
.. setting:: DATETIME_FORMAT
|
||
|
||
DATETIME_FORMAT
|
||
---------------
|
||
|
||
Default: ``'N j, Y, P'`` (e.g. ``Feb. 4, 2003, 4 p.m.``)
|
||
|
||
The default formatting to use for displaying datetime fields in any part of the
|
||
system. Note that if :setting:`USE_L10N` is set to ``True``, then the
|
||
locale-dictated format has higher precedence and will be applied instead. See
|
||
:tfilter:`allowed date format strings <date>`.
|
||
|
||
See also :setting:`DATE_FORMAT`, :setting:`TIME_FORMAT` and :setting:`SHORT_DATETIME_FORMAT`.
|
||
|
||
.. setting:: DATETIME_INPUT_FORMATS
|
||
|
||
DATETIME_INPUT_FORMATS
|
||
----------------------
|
||
|
||
Default::
|
||
|
||
(
|
||
'%Y-%m-%d %H:%M:%S', # '2006-10-25 14:30:59'
|
||
'%Y-%m-%d %H:%M:%S.%f', # '2006-10-25 14:30:59.000200'
|
||
'%Y-%m-%d %H:%M', # '2006-10-25 14:30'
|
||
'%Y-%m-%d', # '2006-10-25'
|
||
'%m/%d/%Y %H:%M:%S', # '10/25/2006 14:30:59'
|
||
'%m/%d/%Y %H:%M:%S.%f', # '10/25/2006 14:30:59.000200'
|
||
'%m/%d/%Y %H:%M', # '10/25/2006 14:30'
|
||
'%m/%d/%Y', # '10/25/2006'
|
||
'%m/%d/%y %H:%M:%S', # '10/25/06 14:30:59'
|
||
'%m/%d/%y %H:%M:%S.%f', # '10/25/06 14:30:59.000200'
|
||
'%m/%d/%y %H:%M', # '10/25/06 14:30'
|
||
'%m/%d/%y', # '10/25/06'
|
||
)
|
||
|
||
A tuple of formats that will be accepted when inputting data on a datetime
|
||
field. Formats will be tried in order, using the first valid one. Note that
|
||
these format strings use Python's datetime_ module syntax, not the format
|
||
strings from the ``date`` Django template tag.
|
||
|
||
When :setting:`USE_L10N` is ``True``, the locale-dictated format has higher
|
||
precedence and will be applied instead.
|
||
|
||
See also :setting:`DATE_INPUT_FORMATS` and :setting:`TIME_INPUT_FORMATS`.
|
||
|
||
.. _datetime: http://docs.python.org/library/datetime.html#strftime-strptime-behavior
|
||
|
||
.. setting:: DEBUG
|
||
|
||
DEBUG
|
||
-----
|
||
|
||
Default: ``False``
|
||
|
||
A boolean that turns on/off debug mode.
|
||
|
||
Never deploy a site into production with :setting:`DEBUG` turned on.
|
||
|
||
Did you catch that? NEVER deploy a site into production with :setting:`DEBUG`
|
||
turned on.
|
||
|
||
One of the main features of debug mode is the display of detailed error pages.
|
||
If your app raises an exception when :setting:`DEBUG` is ``True``, Django will
|
||
display a detailed traceback, including a lot of metadata about your
|
||
environment, such as all the currently defined Django settings (from
|
||
``settings.py``).
|
||
|
||
As a security measure, Django will *not* include settings that might be
|
||
sensitive (or offensive), such as :setting:`SECRET_KEY` or
|
||
:setting:`PROFANITIES_LIST`. Specifically, it will exclude any setting whose
|
||
name includes any of the following:
|
||
|
||
* ``'API'``
|
||
* ``'KEY'``
|
||
* ``'PASS'``
|
||
* ``'PROFANITIES_LIST'``
|
||
* ``'SECRET'``
|
||
* ``'SIGNATURE'``
|
||
* ``'TOKEN'``
|
||
|
||
Note that these are *partial* matches. ``'PASS'`` will also match PASSWORD,
|
||
just as ``'TOKEN'`` will also match TOKENIZED and so on.
|
||
|
||
Still, note that there are always going to be sections of your debug output
|
||
that are inappropriate for public consumption. File paths, configuration
|
||
options and the like all give attackers extra information about your server.
|
||
|
||
It is also important to remember that when running with :setting:`DEBUG`
|
||
turned on, Django will remember every SQL query it executes. This is useful
|
||
when you're debugging, but it'll rapidly consume memory on a production server.
|
||
|
||
Finally, if :setting:`DEBUG` is ``False``, you also need to properly set
|
||
the :setting:`ALLOWED_HOSTS` setting. Failing to do so will result in all
|
||
requests being returned as "Bad Request (400)".
|
||
|
||
.. _django/views/debug.py: https://github.com/django/django/blob/master/django/views/debug.py
|
||
|
||
.. setting:: DEBUG_PROPAGATE_EXCEPTIONS
|
||
|
||
DEBUG_PROPAGATE_EXCEPTIONS
|
||
--------------------------
|
||
|
||
Default: ``False``
|
||
|
||
If set to True, Django's normal exception handling of view functions
|
||
will be suppressed, and exceptions will propagate upwards. This can
|
||
be useful for some test setups, and should never be used on a live
|
||
site.
|
||
|
||
.. setting:: DECIMAL_SEPARATOR
|
||
|
||
DECIMAL_SEPARATOR
|
||
-----------------
|
||
|
||
Default: ``'.'`` (Dot)
|
||
|
||
Default decimal separator used when formatting decimal numbers.
|
||
|
||
Note that if :setting:`USE_L10N` is set to ``True``, then the locale-dictated
|
||
format has higher precedence and will be applied instead.
|
||
|
||
See also :setting:`NUMBER_GROUPING`, :setting:`THOUSAND_SEPARATOR` and
|
||
:setting:`USE_THOUSAND_SEPARATOR`.
|
||
|
||
|
||
.. setting:: DEFAULT_CHARSET
|
||
|
||
DEFAULT_CHARSET
|
||
---------------
|
||
|
||
Default: ``'utf-8'``
|
||
|
||
Default charset to use for all ``HttpResponse`` objects, if a MIME type isn't
|
||
manually specified. Used with :setting:`DEFAULT_CONTENT_TYPE` to construct the
|
||
``Content-Type`` header.
|
||
|
||
.. setting:: DEFAULT_CONTENT_TYPE
|
||
|
||
DEFAULT_CONTENT_TYPE
|
||
--------------------
|
||
|
||
Default: ``'text/html'``
|
||
|
||
Default content type to use for all ``HttpResponse`` objects, if a MIME type
|
||
isn't manually specified. Used with :setting:`DEFAULT_CHARSET` to construct
|
||
the ``Content-Type`` header.
|
||
|
||
.. setting:: DEFAULT_EXCEPTION_REPORTER_FILTER
|
||
|
||
DEFAULT_EXCEPTION_REPORTER_FILTER
|
||
---------------------------------
|
||
|
||
Default: :class:`django.views.debug.SafeExceptionReporterFilter`
|
||
|
||
Default exception reporter filter class to be used if none has been assigned to
|
||
the :class:`~django.http.HttpRequest` instance yet.
|
||
See :ref:`Filtering error reports<filtering-error-reports>`.
|
||
|
||
.. setting:: DEFAULT_FILE_STORAGE
|
||
|
||
DEFAULT_FILE_STORAGE
|
||
--------------------
|
||
|
||
Default: :class:`django.core.files.storage.FileSystemStorage`
|
||
|
||
Default file storage class to be used for any file-related operations that don't
|
||
specify a particular storage system. See :doc:`/topics/files`.
|
||
|
||
.. setting:: DEFAULT_FROM_EMAIL
|
||
|
||
DEFAULT_FROM_EMAIL
|
||
------------------
|
||
|
||
Default: ``'webmaster@localhost'``
|
||
|
||
Default email address to use for various automated correspondence from the
|
||
site manager(s).
|
||
|
||
.. setting:: DEFAULT_INDEX_TABLESPACE
|
||
|
||
DEFAULT_INDEX_TABLESPACE
|
||
------------------------
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
Default tablespace to use for indexes on fields that don't specify
|
||
one, if the backend supports it (see :doc:`/topics/db/tablespaces`).
|
||
|
||
.. setting:: DEFAULT_TABLESPACE
|
||
|
||
DEFAULT_TABLESPACE
|
||
------------------
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
Default tablespace to use for models that don't specify one, if the
|
||
backend supports it (see :doc:`/topics/db/tablespaces`).
|
||
|
||
.. setting:: DISALLOWED_USER_AGENTS
|
||
|
||
DISALLOWED_USER_AGENTS
|
||
----------------------
|
||
|
||
Default: ``()`` (Empty tuple)
|
||
|
||
List of compiled regular expression objects representing User-Agent strings that
|
||
are not allowed to visit any page, systemwide. Use this for bad robots/crawlers.
|
||
This is only used if ``CommonMiddleware`` is installed (see
|
||
:doc:`/topics/http/middleware`).
|
||
|
||
.. setting:: EMAIL_BACKEND
|
||
|
||
EMAIL_BACKEND
|
||
-------------
|
||
|
||
Default: ``'django.core.mail.backends.smtp.EmailBackend'``
|
||
|
||
The backend to use for sending emails. For the list of available backends see
|
||
:doc:`/topics/email`.
|
||
|
||
.. setting:: EMAIL_FILE_PATH
|
||
|
||
EMAIL_FILE_PATH
|
||
---------------
|
||
|
||
Default: Not defined
|
||
|
||
The directory used by the ``file`` email backend to store output files.
|
||
|
||
.. setting:: EMAIL_HOST
|
||
|
||
EMAIL_HOST
|
||
----------
|
||
|
||
Default: ``'localhost'``
|
||
|
||
The host to use for sending email.
|
||
|
||
See also :setting:`EMAIL_PORT`.
|
||
|
||
.. setting:: EMAIL_HOST_PASSWORD
|
||
|
||
EMAIL_HOST_PASSWORD
|
||
-------------------
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
Password to use for the SMTP server defined in :setting:`EMAIL_HOST`. This
|
||
setting is used in conjunction with :setting:`EMAIL_HOST_USER` when
|
||
authenticating to the SMTP server. If either of these settings is empty,
|
||
Django won't attempt authentication.
|
||
|
||
See also :setting:`EMAIL_HOST_USER`.
|
||
|
||
.. setting:: EMAIL_HOST_USER
|
||
|
||
EMAIL_HOST_USER
|
||
---------------
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
Username to use for the SMTP server defined in :setting:`EMAIL_HOST`.
|
||
If empty, Django won't attempt authentication.
|
||
|
||
See also :setting:`EMAIL_HOST_PASSWORD`.
|
||
|
||
.. setting:: EMAIL_PORT
|
||
|
||
EMAIL_PORT
|
||
----------
|
||
|
||
Default: ``25``
|
||
|
||
Port to use for the SMTP server defined in :setting:`EMAIL_HOST`.
|
||
|
||
.. setting:: EMAIL_SUBJECT_PREFIX
|
||
|
||
EMAIL_SUBJECT_PREFIX
|
||
--------------------
|
||
|
||
Default: ``'[Django] '``
|
||
|
||
Subject-line prefix for email messages sent with ``django.core.mail.mail_admins``
|
||
or ``django.core.mail.mail_managers``. You'll probably want to include the
|
||
trailing space.
|
||
|
||
.. setting:: EMAIL_USE_TLS
|
||
|
||
EMAIL_USE_TLS
|
||
-------------
|
||
|
||
Default: ``False``
|
||
|
||
Whether to use a TLS (secure) connection when talking to the SMTP server.
|
||
This is used for explicit TLS connections, generally on port 587. If you are
|
||
experiencing hanging connections, see the implicit TLS setting
|
||
:setting:`EMAIL_USE_SSL`.
|
||
|
||
.. setting:: EMAIL_USE_SSL
|
||
|
||
EMAIL_USE_SSL
|
||
-------------
|
||
|
||
.. versionadded:: 1.7
|
||
|
||
Default: ``False``
|
||
|
||
Whether to use an implicit TLS (secure) connection when talking to the SMTP
|
||
server. In most email documentation this type of TLS connection is referred
|
||
to as SSL. It is generally used on port 465. If you are experiencing problems,
|
||
see the explicit TLS setting :setting:`EMAIL_USE_TLS`.
|
||
|
||
Note that :setting:`EMAIL_USE_TLS`/:setting:`EMAIL_USE_SSL` are mutually
|
||
exclusive, so only set one of those settings to ``True``.
|
||
|
||
.. setting:: FILE_CHARSET
|
||
|
||
FILE_CHARSET
|
||
------------
|
||
|
||
Default: ``'utf-8'``
|
||
|
||
The character encoding used to decode any files read from disk. This includes
|
||
template files and initial SQL data files.
|
||
|
||
.. setting:: FILE_UPLOAD_HANDLERS
|
||
|
||
FILE_UPLOAD_HANDLERS
|
||
--------------------
|
||
|
||
Default::
|
||
|
||
("django.core.files.uploadhandler.MemoryFileUploadHandler",
|
||
"django.core.files.uploadhandler.TemporaryFileUploadHandler",)
|
||
|
||
A tuple of handlers to use for uploading. See :doc:`/topics/files` for details.
|
||
|
||
.. setting:: FILE_UPLOAD_MAX_MEMORY_SIZE
|
||
|
||
FILE_UPLOAD_MAX_MEMORY_SIZE
|
||
---------------------------
|
||
|
||
Default: ``2621440`` (i.e. 2.5 MB).
|
||
|
||
The maximum size (in bytes) that an upload will be before it gets streamed to
|
||
the file system. See :doc:`/topics/files` for details.
|
||
|
||
.. setting:: FILE_UPLOAD_DIRECTORY_PERMISSIONS
|
||
|
||
FILE_UPLOAD_DIRECTORY_PERMISSIONS
|
||
---------------------------------
|
||
|
||
.. versionadded:: 1.7
|
||
|
||
Default: ``None``
|
||
|
||
The numeric mode to apply to directories created in the process of
|
||
uploading files. This value mirrors the functionality and caveats of
|
||
the :setting:`FILE_UPLOAD_PERMISSIONS` setting.
|
||
|
||
.. setting:: FILE_UPLOAD_PERMISSIONS
|
||
|
||
FILE_UPLOAD_PERMISSIONS
|
||
-----------------------
|
||
|
||
Default: ``None``
|
||
|
||
The numeric mode (i.e. ``0644``) to set newly uploaded files to. For
|
||
more information about what these modes mean, see the documentation for
|
||
:func:`os.chmod`.
|
||
|
||
If this isn't given or is ``None``, you'll get operating-system
|
||
dependent behavior. On most platforms, temporary files will have a mode
|
||
of ``0600``, and files saved from memory will be saved using the
|
||
system's standard umask.
|
||
|
||
.. warning::
|
||
|
||
**Always prefix the mode with a 0.**
|
||
|
||
If you're not familiar with file modes, please note that the leading
|
||
``0`` is very important: it indicates an octal number, which is the
|
||
way that modes must be specified. If you try to use ``644``, you'll
|
||
get totally incorrect behavior.
|
||
|
||
|
||
.. setting:: FILE_UPLOAD_TEMP_DIR
|
||
|
||
FILE_UPLOAD_TEMP_DIR
|
||
--------------------
|
||
|
||
Default: ``None``
|
||
|
||
The directory to store data temporarily while uploading files. If ``None``,
|
||
Django will use the standard temporary directory for the operating system. For
|
||
example, this will default to '/tmp' on \*nix-style operating systems.
|
||
|
||
See :doc:`/topics/files` for details.
|
||
|
||
.. setting:: FIRST_DAY_OF_WEEK
|
||
|
||
FIRST_DAY_OF_WEEK
|
||
-----------------
|
||
|
||
Default: ``0`` (Sunday)
|
||
|
||
Number representing the first day of the week. This is especially useful
|
||
when displaying a calendar. This value is only used when not using
|
||
format internationalization, or when a format cannot be found for the
|
||
current locale.
|
||
|
||
The value must be an integer from 0 to 6, where 0 means Sunday, 1 means
|
||
Monday and so on.
|
||
|
||
.. setting:: FIXTURE_DIRS
|
||
|
||
FIXTURE_DIRS
|
||
-------------
|
||
|
||
Default: ``()`` (Empty tuple)
|
||
|
||
List of directories searched for fixture files, in addition to the
|
||
``fixtures`` directory of each application, in search order.
|
||
|
||
Note that these paths should use Unix-style forward slashes, even on Windows.
|
||
|
||
See :ref:`initial-data-via-fixtures` and :ref:`topics-testing-fixtures`.
|
||
|
||
.. setting:: FORCE_SCRIPT_NAME
|
||
|
||
FORCE_SCRIPT_NAME
|
||
------------------
|
||
|
||
Default: ``None``
|
||
|
||
If not ``None``, this will be used as the value of the ``SCRIPT_NAME``
|
||
environment variable in any HTTP request. This setting can be used to override
|
||
the server-provided value of ``SCRIPT_NAME``, which may be a rewritten version
|
||
of the preferred value or not supplied at all.
|
||
|
||
.. setting:: FORMAT_MODULE_PATH
|
||
|
||
FORMAT_MODULE_PATH
|
||
------------------
|
||
|
||
Default: ``None``
|
||
|
||
A full Python path to a Python package that contains format definitions for
|
||
project locales. If not ``None``, Django will check for a ``formats.py``
|
||
file, under the directory named as the current locale, and will use the
|
||
formats defined on this file.
|
||
|
||
For example, if :setting:`FORMAT_MODULE_PATH` is set to ``mysite.formats``,
|
||
and current language is ``en`` (English), Django will expect a directory tree
|
||
like::
|
||
|
||
mysite/
|
||
formats/
|
||
__init__.py
|
||
en/
|
||
__init__.py
|
||
formats.py
|
||
|
||
Available formats are :setting:`DATE_FORMAT`, :setting:`TIME_FORMAT`,
|
||
:setting:`DATETIME_FORMAT`, :setting:`YEAR_MONTH_FORMAT`,
|
||
:setting:`MONTH_DAY_FORMAT`, :setting:`SHORT_DATE_FORMAT`,
|
||
:setting:`SHORT_DATETIME_FORMAT`, :setting:`FIRST_DAY_OF_WEEK`,
|
||
:setting:`DECIMAL_SEPARATOR`, :setting:`THOUSAND_SEPARATOR` and
|
||
:setting:`NUMBER_GROUPING`.
|
||
|
||
.. setting:: IGNORABLE_404_URLS
|
||
|
||
IGNORABLE_404_URLS
|
||
------------------
|
||
|
||
Default: ``()``
|
||
|
||
List of compiled regular expression objects describing URLs that should be
|
||
ignored when reporting HTTP 404 errors via email (see
|
||
:doc:`/howto/error-reporting`). Regular expressions are matched against
|
||
:meth:`request's full paths <django.http.HttpRequest.get_full_path>` (including
|
||
query string, if any). Use this if your site does not provide a commonly
|
||
requested file such as ``favicon.ico`` or ``robots.txt``, or if it gets
|
||
hammered by script kiddies.
|
||
|
||
This is only used if
|
||
:class:`~django.middleware.common.BrokenLinkEmailsMiddleware` is enabled (see
|
||
:doc:`/topics/http/middleware`).
|
||
|
||
.. setting:: INSTALLED_APPS
|
||
|
||
INSTALLED_APPS
|
||
--------------
|
||
|
||
Default: ``()`` (Empty tuple)
|
||
|
||
A tuple of strings designating all applications that are enabled in this Django
|
||
installation. Each string should be a full Python path to a Python package that
|
||
contains a Django application, as created by :djadmin:`django-admin.py startapp
|
||
<startapp>`.
|
||
|
||
.. admonition:: App names must be unique
|
||
|
||
The application names (that is, the final dotted part of the
|
||
path to the module containing ``models.py``) defined in
|
||
:setting:`INSTALLED_APPS` *must* be unique. For example, you can't
|
||
include both ``django.contrib.auth`` and ``myproject.auth`` in
|
||
INSTALLED_APPS.
|
||
|
||
.. setting:: INTERNAL_IPS
|
||
|
||
INTERNAL_IPS
|
||
------------
|
||
|
||
Default: ``()`` (Empty tuple)
|
||
|
||
A tuple of IP addresses, as strings, that:
|
||
|
||
* See debug comments, when :setting:`DEBUG` is ``True``
|
||
* Receive X headers in admindocs if the ``XViewMiddleware`` is installed (see
|
||
:doc:`/topics/http/middleware`)
|
||
|
||
.. setting:: LANGUAGE_CODE
|
||
|
||
LANGUAGE_CODE
|
||
-------------
|
||
|
||
Default: ``'en-us'``
|
||
|
||
A string representing the language code for this installation. This should be in
|
||
standard :term:`language ID format <language code>`. For example, U.S. English
|
||
is ``"en-us"``. See also the `list of language identifiers`_ and
|
||
:doc:`/topics/i18n/index`.
|
||
|
||
:setting:`USE_I18N` must be active for this setting to have any effect.
|
||
|
||
It serves two purposes:
|
||
|
||
* If the locale middleware isn't in use, it decides which translation is served
|
||
to all users.
|
||
* If the locale middleware is active, it provides the fallback translation when
|
||
no translation exist for a given literal to the user's preferred language.
|
||
|
||
See :ref:`how-django-discovers-language-preference` for more details.
|
||
|
||
.. _list of language identifiers: http://www.i18nguy.com/unicode/language-identifiers.html
|
||
|
||
.. setting:: LANGUAGE_COOKIE_NAME
|
||
|
||
LANGUAGE_COOKIE_NAME
|
||
--------------------
|
||
|
||
Default: ``'django_language'``
|
||
|
||
The name of the cookie to use for the language cookie. This can be whatever
|
||
you want (but should be different from :setting:`SESSION_COOKIE_NAME`). See
|
||
:doc:`/topics/i18n/index`.
|
||
|
||
.. setting:: LANGUAGES
|
||
|
||
LANGUAGES
|
||
---------
|
||
|
||
Default: A tuple of all available languages. This list is continually growing
|
||
and including a copy here would inevitably become rapidly out of date. You can
|
||
see the current list of translated languages by looking in
|
||
``django/conf/global_settings.py`` (or view the `online source`_).
|
||
|
||
.. _online source: https://github.com/django/django/blob/master/django/conf/global_settings.py
|
||
|
||
The list is a tuple of two-tuples in the format
|
||
(:term:`language code<language code>`, ``language name``) -- for example,
|
||
``('ja', 'Japanese')``.
|
||
This specifies which languages are available for language selection. See
|
||
:doc:`/topics/i18n/index`.
|
||
|
||
Generally, the default value should suffice. Only set this setting if you want
|
||
to restrict language selection to a subset of the Django-provided languages.
|
||
|
||
If you define a custom :setting:`LANGUAGES` setting, it's OK to mark the
|
||
languages as translation strings (as in the default value referred to above)
|
||
-- but use a "dummy" ``gettext()`` function, not the one in
|
||
``django.utils.translation``. You should *never* import
|
||
``django.utils.translation`` from within your settings file, because that
|
||
module in itself depends on the settings, and that would cause a circular
|
||
import.
|
||
|
||
The solution is to use a "dummy" ``gettext()`` function. Here's a sample
|
||
settings file::
|
||
|
||
gettext = lambda s: s
|
||
|
||
LANGUAGES = (
|
||
('de', gettext('German')),
|
||
('en', gettext('English')),
|
||
)
|
||
|
||
With this arrangement, ``django-admin.py makemessages`` will still find and
|
||
mark these strings for translation, but the translation won't happen at
|
||
runtime -- so you'll have to remember to wrap the languages in the *real*
|
||
``gettext()`` in any code that uses :setting:`LANGUAGES` at runtime.
|
||
|
||
.. setting:: LOCALE_PATHS
|
||
|
||
LOCALE_PATHS
|
||
------------
|
||
|
||
Default: ``()`` (Empty tuple)
|
||
|
||
A tuple of directories where Django looks for translation files.
|
||
See :ref:`how-django-discovers-translations`.
|
||
|
||
Example::
|
||
|
||
LOCALE_PATHS = (
|
||
'/home/www/project/common_files/locale',
|
||
'/var/local/translations/locale'
|
||
)
|
||
|
||
Django will look within each of these paths for the ``<locale_code>/LC_MESSAGES``
|
||
directories containing the actual translation files.
|
||
|
||
.. setting:: LOGGING
|
||
|
||
LOGGING
|
||
-------
|
||
|
||
Default: A logging configuration dictionary.
|
||
|
||
A data structure containing configuration information. The contents of
|
||
this data structure will be passed as the argument to the
|
||
configuration method described in :setting:`LOGGING_CONFIG`.
|
||
|
||
Among other things, the default logging configuration passes HTTP 500 server
|
||
errors to an email log handler when :setting:`DEBUG` is ``False``. See also
|
||
:ref:`configuring-logging`.
|
||
|
||
You can see the default logging configuration by looking in
|
||
``django/utils/log.py`` (or view the `online source`__).
|
||
|
||
__ https://github.com/django/django/blob/master/django/utils/log.py
|
||
|
||
.. setting:: LOGGING_CONFIG
|
||
|
||
LOGGING_CONFIG
|
||
--------------
|
||
|
||
Default: ``'logging.config.dictConfig'``
|
||
|
||
A path to a callable that will be used to configure logging in the
|
||
Django project. Points at a instance of Python's `dictConfig`_
|
||
configuration method by default.
|
||
|
||
If you set :setting:`LOGGING_CONFIG` to ``None``, the logging
|
||
configuration process will be skipped.
|
||
|
||
.. versionchanged:: 1.7
|
||
|
||
Previously, the default value was ``'django.utils.log.dictConfig'``.
|
||
|
||
.. _dictConfig: http://docs.python.org/library/logging.config.html#configuration-dictionary-schema
|
||
|
||
.. setting:: MANAGERS
|
||
|
||
MANAGERS
|
||
--------
|
||
|
||
Default: ``()`` (Empty tuple)
|
||
|
||
A tuple in the same format as :setting:`ADMINS` that specifies who should get
|
||
broken link notifications when
|
||
:class:`~django.middleware.common.BrokenLinkEmailsMiddleware` is enabled.
|
||
|
||
.. setting:: MEDIA_ROOT
|
||
|
||
MEDIA_ROOT
|
||
----------
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
Absolute filesystem path to the directory that will hold :doc:`user-uploaded
|
||
files </topics/files>`.
|
||
|
||
Example: ``"/var/www/example.com/media/"``
|
||
|
||
See also :setting:`MEDIA_URL`.
|
||
|
||
.. warning::
|
||
|
||
:setting:`MEDIA_ROOT` and :setting:`STATIC_ROOT` must have different
|
||
values. Before :setting:`STATIC_ROOT` was introduced, it was common to
|
||
rely or fallback on :setting:`MEDIA_ROOT` to also serve static files;
|
||
however, since this can have serious security implications, there is a
|
||
validation check to prevent it.
|
||
|
||
.. setting:: MEDIA_URL
|
||
|
||
MEDIA_URL
|
||
---------
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
URL that handles the media served from :setting:`MEDIA_ROOT`, used
|
||
for :doc:`managing stored files </topics/files>`. It must end in a slash if set
|
||
to a non-empty value.
|
||
|
||
Example: ``"http://media.example.com/"``
|
||
|
||
.. warning::
|
||
|
||
:setting:`MEDIA_URL` and :setting:`STATIC_URL` must have different
|
||
values. See :setting:`MEDIA_ROOT` for more details.
|
||
|
||
.. setting:: MIDDLEWARE_CLASSES
|
||
|
||
MIDDLEWARE_CLASSES
|
||
------------------
|
||
|
||
Default::
|
||
|
||
('django.middleware.common.CommonMiddleware',
|
||
'django.contrib.sessions.middleware.SessionMiddleware',
|
||
'django.middleware.csrf.CsrfViewMiddleware',
|
||
'django.contrib.auth.middleware.AuthenticationMiddleware',
|
||
'django.contrib.messages.middleware.MessageMiddleware',)
|
||
|
||
A tuple of middleware classes to use. See :doc:`/topics/http/middleware`.
|
||
|
||
.. setting:: MONTH_DAY_FORMAT
|
||
|
||
MONTH_DAY_FORMAT
|
||
----------------
|
||
|
||
Default: ``'F j'``
|
||
|
||
The default formatting to use for date fields on Django admin change-list
|
||
pages -- and, possibly, by other parts of the system -- in cases when only the
|
||
month and day are displayed.
|
||
|
||
For example, when a Django admin change-list page is being filtered by a date
|
||
drilldown, the header for a given day displays the day and month. Different
|
||
locales have different formats. For example, U.S. English would say
|
||
"January 1," whereas Spanish might say "1 Enero."
|
||
|
||
See :tfilter:`allowed date format strings <date>`. See also
|
||
:setting:`DATE_FORMAT`, :setting:`DATETIME_FORMAT`,
|
||
:setting:`TIME_FORMAT` and :setting:`YEAR_MONTH_FORMAT`.
|
||
|
||
.. setting:: NUMBER_GROUPING
|
||
|
||
NUMBER_GROUPING
|
||
----------------
|
||
|
||
Default: ``0``
|
||
|
||
Number of digits grouped together on the integer part of a number.
|
||
|
||
Common use is to display a thousand separator. If this setting is ``0``, then
|
||
no grouping will be applied to the number. If this setting is greater than
|
||
``0``, then :setting:`THOUSAND_SEPARATOR` will be used as the separator between
|
||
those groups.
|
||
|
||
Note that if :setting:`USE_L10N` is set to ``True``, then the locale-dictated
|
||
format has higher precedence and will be applied instead.
|
||
|
||
See also :setting:`DECIMAL_SEPARATOR`, :setting:`THOUSAND_SEPARATOR` and
|
||
:setting:`USE_THOUSAND_SEPARATOR`.
|
||
|
||
.. setting:: PREPEND_WWW
|
||
|
||
PREPEND_WWW
|
||
-----------
|
||
|
||
Default: ``False``
|
||
|
||
Whether to prepend the "www." subdomain to URLs that don't have it. This is only
|
||
used if :class:`~django.middleware.common.CommonMiddleware` is installed
|
||
(see :doc:`/topics/http/middleware`). See also :setting:`APPEND_SLASH`.
|
||
|
||
.. setting:: ROOT_URLCONF
|
||
|
||
ROOT_URLCONF
|
||
------------
|
||
|
||
Default: Not defined
|
||
|
||
A string representing the full Python import path to your root URLconf. For example:
|
||
``"mydjangoapps.urls"``. Can be overridden on a per-request basis by
|
||
setting the attribute ``urlconf`` on the incoming ``HttpRequest``
|
||
object. See :ref:`how-django-processes-a-request` for details.
|
||
|
||
.. setting:: SECRET_KEY
|
||
|
||
SECRET_KEY
|
||
----------
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
A secret key for a particular Django installation. This is used to provide
|
||
:doc:`cryptographic signing </topics/signing>`, and should be set to a unique,
|
||
unpredictable value.
|
||
|
||
:djadmin:`django-admin.py startproject <startproject>` automatically adds a
|
||
randomly-generated ``SECRET_KEY`` to each new project.
|
||
|
||
Django will refuse to start if :setting:`SECRET_KEY` is not set.
|
||
|
||
.. warning::
|
||
|
||
**Keep this value secret.**
|
||
|
||
Running Django with a known :setting:`SECRET_KEY` defeats many of Django's
|
||
security protections, and can lead to privilege escalation and remote code
|
||
execution vulnerabilities.
|
||
|
||
.. setting:: SECURE_PROXY_SSL_HEADER
|
||
|
||
SECURE_PROXY_SSL_HEADER
|
||
-----------------------
|
||
|
||
Default: ``None``
|
||
|
||
A tuple representing a HTTP header/value combination that signifies a request
|
||
is secure. This controls the behavior of the request object's ``is_secure()``
|
||
method.
|
||
|
||
This takes some explanation. By default, ``is_secure()`` is able to determine
|
||
whether a request is secure by looking at whether the requested URL uses
|
||
"https://". This is important for Django's CSRF protection, and may be used
|
||
by your own code or third-party apps.
|
||
|
||
If your Django app is behind a proxy, though, the proxy may be "swallowing" the
|
||
fact that a request is HTTPS, using a non-HTTPS connection between the proxy
|
||
and Django. In this case, ``is_secure()`` would always return ``False`` -- even
|
||
for requests that were made via HTTPS by the end user.
|
||
|
||
In this situation, you'll want to configure your proxy to set a custom HTTP
|
||
header that tells Django whether the request came in via HTTPS, and you'll want
|
||
to set ``SECURE_PROXY_SSL_HEADER`` so that Django knows what header to look
|
||
for.
|
||
|
||
You'll need to set a tuple with two elements -- the name of the header to look
|
||
for and the required value. For example::
|
||
|
||
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
|
||
|
||
Here, we're telling Django that we trust the ``X-Forwarded-Proto`` header
|
||
that comes from our proxy, and any time its value is ``'https'``, then the
|
||
request is guaranteed to be secure (i.e., it originally came in via HTTPS).
|
||
Obviously, you should *only* set this setting if you control your proxy or
|
||
have some other guarantee that it sets/strips this header appropriately.
|
||
|
||
Note that the header needs to be in the format as used by ``request.META`` --
|
||
all caps and likely starting with ``HTTP_``. (Remember, Django automatically
|
||
adds ``'HTTP_'`` to the start of x-header names before making the header
|
||
available in ``request.META``.)
|
||
|
||
.. warning::
|
||
|
||
**You will probably open security holes in your site if you set this
|
||
without knowing what you're doing. And if you fail to set it when you
|
||
should. Seriously.**
|
||
|
||
Make sure ALL of the following are true before setting this (assuming the
|
||
values from the example above):
|
||
|
||
* Your Django app is behind a proxy.
|
||
* Your proxy strips the ``X-Forwarded-Proto`` header from all incoming
|
||
requests. In other words, if end users include that header in their
|
||
requests, the proxy will discard it.
|
||
* Your proxy sets the ``X-Forwarded-Proto`` header and sends it to Django,
|
||
but only for requests that originally come in via HTTPS.
|
||
|
||
If any of those are not true, you should keep this setting set to ``None``
|
||
and find another way of determining HTTPS, perhaps via custom middleware.
|
||
|
||
.. setting:: SEND_BROKEN_LINK_EMAILS
|
||
|
||
SEND_BROKEN_LINK_EMAILS
|
||
-----------------------
|
||
|
||
.. deprecated:: 1.6
|
||
Since :class:`~django.middleware.common.BrokenLinkEmailsMiddleware`
|
||
was split from :class:`~django.middleware.common.CommonMiddleware`,
|
||
this setting no longer serves a purpose.
|
||
|
||
Default: ``False``
|
||
|
||
Whether to send an email to the :setting:`MANAGERS` each time somebody visits
|
||
a Django-powered page that is 404ed with a non-empty referer (i.e., a broken
|
||
link). This is only used if ``CommonMiddleware`` is installed (see
|
||
:doc:`/topics/http/middleware`). See also :setting:`IGNORABLE_404_URLS` and
|
||
:doc:`/howto/error-reporting`.
|
||
|
||
.. setting:: SERIALIZATION_MODULES
|
||
|
||
SERIALIZATION_MODULES
|
||
---------------------
|
||
|
||
Default: Not defined.
|
||
|
||
A dictionary of modules containing serializer definitions (provided as
|
||
strings), keyed by a string identifier for that serialization type. For
|
||
example, to define a YAML serializer, use::
|
||
|
||
SERIALIZATION_MODULES = { 'yaml' : 'path.to.yaml_serializer' }
|
||
|
||
.. setting:: SERVER_EMAIL
|
||
|
||
SERVER_EMAIL
|
||
------------
|
||
|
||
Default: ``'root@localhost'``
|
||
|
||
The email address that error messages come from, such as those sent to
|
||
:setting:`ADMINS` and :setting:`MANAGERS`.
|
||
|
||
.. setting:: SHORT_DATE_FORMAT
|
||
|
||
SHORT_DATE_FORMAT
|
||
-----------------
|
||
|
||
Default: ``m/d/Y`` (e.g. ``12/31/2003``)
|
||
|
||
An available formatting that can be used for displaying date fields on
|
||
templates. Note that if :setting:`USE_L10N` is set to ``True``, then the
|
||
corresponding locale-dictated format has higher precedence and will be applied.
|
||
See :tfilter:`allowed date format strings <date>`.
|
||
|
||
See also :setting:`DATE_FORMAT` and :setting:`SHORT_DATETIME_FORMAT`.
|
||
|
||
.. setting:: SHORT_DATETIME_FORMAT
|
||
|
||
SHORT_DATETIME_FORMAT
|
||
---------------------
|
||
|
||
Default: ``m/d/Y P`` (e.g. ``12/31/2003 4 p.m.``)
|
||
|
||
An available formatting that can be used for displaying datetime fields on
|
||
templates. Note that if :setting:`USE_L10N` is set to ``True``, then the
|
||
corresponding locale-dictated format has higher precedence and will be applied.
|
||
See :tfilter:`allowed date format strings <date>`.
|
||
|
||
See also :setting:`DATE_FORMAT` and :setting:`SHORT_DATE_FORMAT`.
|
||
|
||
.. setting:: SIGNING_BACKEND
|
||
|
||
SIGNING_BACKEND
|
||
---------------
|
||
|
||
Default: 'django.core.signing.TimestampSigner'
|
||
|
||
The backend used for signing cookies and other data.
|
||
|
||
See also the :doc:`/topics/signing` documentation.
|
||
|
||
.. setting:: TEMPLATE_CONTEXT_PROCESSORS
|
||
|
||
TEMPLATE_CONTEXT_PROCESSORS
|
||
---------------------------
|
||
|
||
Default::
|
||
|
||
("django.contrib.auth.context_processors.auth",
|
||
"django.core.context_processors.debug",
|
||
"django.core.context_processors.i18n",
|
||
"django.core.context_processors.media",
|
||
"django.core.context_processors.static",
|
||
"django.core.context_processors.tz",
|
||
"django.contrib.messages.context_processors.messages")
|
||
|
||
A tuple of callables that are used to populate the context in ``RequestContext``.
|
||
These callables take a request object as their argument and return a dictionary
|
||
of items to be merged into the context.
|
||
|
||
.. setting:: TEMPLATE_DEBUG
|
||
|
||
TEMPLATE_DEBUG
|
||
--------------
|
||
|
||
Default: ``False``
|
||
|
||
A boolean that turns on/off template debug mode. If this is ``True``, the fancy
|
||
error page will display a detailed report for any exception raised during
|
||
template rendering. This report contains the relevant snippet of the template,
|
||
with the appropriate line highlighted.
|
||
|
||
Note that Django only displays fancy error pages if :setting:`DEBUG` is ``True``, so
|
||
you'll want to set that to take advantage of this setting.
|
||
|
||
See also :setting:`DEBUG`.
|
||
|
||
.. setting:: TEMPLATE_DIRS
|
||
|
||
TEMPLATE_DIRS
|
||
-------------
|
||
|
||
Default: ``()`` (Empty tuple)
|
||
|
||
List of locations of the template source files searched by
|
||
:class:`django.template.loaders.filesystem.Loader`, in search order.
|
||
|
||
Note that these paths should use Unix-style forward slashes, even on Windows.
|
||
|
||
See :doc:`/topics/templates`.
|
||
|
||
.. setting:: TEMPLATE_LOADERS
|
||
|
||
TEMPLATE_LOADERS
|
||
----------------
|
||
|
||
Default::
|
||
|
||
('django.template.loaders.filesystem.Loader',
|
||
'django.template.loaders.app_directories.Loader')
|
||
|
||
A tuple of template loader classes, specified as strings. Each ``Loader`` class
|
||
knows how to import templates from a particular source. Optionally, a tuple can be
|
||
used instead of a string. The first item in the tuple should be the ``Loader``’s
|
||
module, subsequent items are passed to the ``Loader`` during initialization. See
|
||
:doc:`/ref/templates/api`.
|
||
|
||
.. setting:: TEMPLATE_STRING_IF_INVALID
|
||
|
||
TEMPLATE_STRING_IF_INVALID
|
||
--------------------------
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
Output, as a string, that the template system should use for invalid (e.g.
|
||
misspelled) variables. See :ref:`invalid-template-variables`..
|
||
|
||
.. setting:: TEST_RUNNER
|
||
|
||
TEST_RUNNER
|
||
-----------
|
||
|
||
Default: ``'django.test.runner.DiscoverRunner'``
|
||
|
||
The name of the class to use for starting the test suite. See
|
||
:ref:`other-testing-frameworks`.
|
||
|
||
.. versionchanged:: 1.6
|
||
|
||
Previously the default ``TEST_RUNNER`` was
|
||
``django.test.simple.DjangoTestSuiteRunner``.
|
||
|
||
.. setting:: THOUSAND_SEPARATOR
|
||
|
||
THOUSAND_SEPARATOR
|
||
------------------
|
||
|
||
Default: ``,`` (Comma)
|
||
|
||
Default thousand separator used when formatting numbers. This setting is
|
||
used only when :setting:`USE_THOUSAND_SEPARATOR` is ``True`` and
|
||
:setting:`NUMBER_GROUPING` is greater than ``0``.
|
||
|
||
Note that if :setting:`USE_L10N` is set to ``True``, then the locale-dictated
|
||
format has higher precedence and will be applied instead.
|
||
|
||
See also :setting:`NUMBER_GROUPING`, :setting:`DECIMAL_SEPARATOR` and
|
||
:setting:`USE_THOUSAND_SEPARATOR`.
|
||
|
||
.. setting:: TIME_FORMAT
|
||
|
||
TIME_FORMAT
|
||
-----------
|
||
|
||
Default: ``'P'`` (e.g. ``4 p.m.``)
|
||
|
||
The default formatting to use for displaying time fields in any part of the
|
||
system. Note that if :setting:`USE_L10N` is set to ``True``, then the
|
||
locale-dictated format has higher precedence and will be applied instead. See
|
||
:tfilter:`allowed date format strings <date>`.
|
||
|
||
See also :setting:`DATE_FORMAT` and :setting:`DATETIME_FORMAT`.
|
||
|
||
.. setting:: TIME_INPUT_FORMATS
|
||
|
||
TIME_INPUT_FORMATS
|
||
------------------
|
||
|
||
Default::
|
||
|
||
(
|
||
'%H:%M:%S', # '14:30:59'
|
||
'%H:%M:%S.%f', # '14:30:59.000200'
|
||
'%H:%M', # '14:30'
|
||
)
|
||
|
||
A tuple of formats that will be accepted when inputting data on a time field.
|
||
Formats will be tried in order, using the first valid one. Note that these
|
||
format strings use Python's datetime_ module syntax, not the format strings
|
||
from the ``date`` Django template tag.
|
||
|
||
When :setting:`USE_L10N` is ``True``, the locale-dictated format has higher
|
||
precedence and will be applied instead.
|
||
|
||
See also :setting:`DATE_INPUT_FORMATS` and :setting:`DATETIME_INPUT_FORMATS`.
|
||
|
||
.. versionchanged:: 1.6
|
||
|
||
Input format with microseconds has been added.
|
||
|
||
.. _datetime: http://docs.python.org/library/datetime.html#strftime-strptime-behavior
|
||
|
||
.. setting:: TIME_ZONE
|
||
|
||
TIME_ZONE
|
||
---------
|
||
|
||
Default: ``'America/Chicago'``
|
||
|
||
A string representing the time zone for this installation, or ``None``. See
|
||
the `list of time zones`_.
|
||
|
||
.. note::
|
||
Since Django was first released with the :setting:`TIME_ZONE` set to
|
||
``'America/Chicago'``, the global setting (used if nothing is defined in
|
||
your project's ``settings.py``) remains ``'America/Chicago'`` for backwards
|
||
compatibility. New project templates default to ``'UTC'``.
|
||
|
||
Note that this isn't necessarily the time zone of the server. For example, one
|
||
server may serve multiple Django-powered sites, each with a separate time zone
|
||
setting.
|
||
|
||
When :setting:`USE_TZ` is ``False``, this is the time zone in which Django
|
||
will store all datetimes. When :setting:`USE_TZ` is ``True``, this is the
|
||
default time zone that Django will use to display datetimes in templates and
|
||
to interpret datetimes entered in forms.
|
||
|
||
Django sets the ``os.environ['TZ']`` variable to the time zone you specify in
|
||
the :setting:`TIME_ZONE` setting. Thus, all your views and models will
|
||
automatically operate in this time zone. However, Django won't set the ``TZ``
|
||
environment variable under the following conditions:
|
||
|
||
* If you're using the manual configuration option as described in
|
||
:ref:`manually configuring settings
|
||
<settings-without-django-settings-module>`, or
|
||
|
||
* If you specify ``TIME_ZONE = None``. This will cause Django to fall back to
|
||
using the system timezone. However, this is discouraged when :setting:`USE_TZ
|
||
= True <USE_TZ>`, because it makes conversions between local time and UTC
|
||
less reliable.
|
||
|
||
If Django doesn't set the ``TZ`` environment variable, it's up to you
|
||
to ensure your processes are running in the correct environment.
|
||
|
||
.. note::
|
||
Django cannot reliably use alternate time zones in a Windows environment.
|
||
If you're running Django on Windows, :setting:`TIME_ZONE` must be set to
|
||
match the system time zone.
|
||
|
||
.. _list of time zones: http://en.wikipedia.org/wiki/List_of_tz_database_time_zones
|
||
|
||
.. _pytz: http://pytz.sourceforge.net/
|
||
|
||
.. setting:: TRANSACTIONS_MANAGED
|
||
|
||
TRANSACTIONS_MANAGED
|
||
--------------------
|
||
|
||
.. deprecated:: 1.6
|
||
|
||
This setting was deprecated because its name is very misleading. Use the
|
||
:setting:`AUTOCOMMIT <DATABASE-AUTOCOMMIT>` key in :setting:`DATABASES`
|
||
entries instead.
|
||
|
||
Default: ``False``
|
||
|
||
Set this to ``True`` if you want to :ref:`disable Django's transaction
|
||
management <deactivate-transaction-management>` and implement your own.
|
||
|
||
.. setting:: USE_ETAGS
|
||
|
||
USE_ETAGS
|
||
---------
|
||
|
||
Default: ``False``
|
||
|
||
A boolean that specifies whether to output the "Etag" header. This saves
|
||
bandwidth but slows down performance. This is used by the ``CommonMiddleware``
|
||
(see :doc:`/topics/http/middleware`) and in the``Cache Framework``
|
||
(see :doc:`/topics/cache`).
|
||
|
||
.. setting:: USE_I18N
|
||
|
||
USE_I18N
|
||
--------
|
||
|
||
Default: ``True``
|
||
|
||
A boolean that specifies whether Django's translation system should be enabled.
|
||
This provides an easy way to turn it off, for performance. If this is set to
|
||
``False``, Django will make some optimizations so as not to load the
|
||
translation machinery.
|
||
|
||
See also :setting:`LANGUAGE_CODE`, :setting:`USE_L10N` and :setting:`USE_TZ`.
|
||
|
||
.. setting:: USE_L10N
|
||
|
||
USE_L10N
|
||
--------
|
||
|
||
Default: ``False``
|
||
|
||
A boolean that specifies if localized formatting of data will be enabled by
|
||
default or not. If this is set to ``True``, e.g. Django will display numbers and
|
||
dates using the format of the current locale.
|
||
|
||
See also :setting:`LANGUAGE_CODE`, :setting:`USE_I18N` and :setting:`USE_TZ`.
|
||
|
||
.. note::
|
||
|
||
The default :file:`settings.py` file created by :djadmin:`django-admin.py
|
||
startproject <startproject>` includes ``USE_L10N = True`` for convenience.
|
||
|
||
.. setting:: USE_THOUSAND_SEPARATOR
|
||
|
||
USE_THOUSAND_SEPARATOR
|
||
----------------------
|
||
|
||
Default: ``False``
|
||
|
||
A boolean that specifies whether to display numbers using a thousand separator.
|
||
When :setting:`USE_L10N` is set to ``True`` and if this is also set to
|
||
``True``, Django will use the values of :setting:`THOUSAND_SEPARATOR` and
|
||
:setting:`NUMBER_GROUPING` to format numbers.
|
||
|
||
See also :setting:`DECIMAL_SEPARATOR`, :setting:`NUMBER_GROUPING` and
|
||
:setting:`THOUSAND_SEPARATOR`.
|
||
|
||
.. setting:: USE_TZ
|
||
|
||
USE_TZ
|
||
------
|
||
|
||
Default: ``False``
|
||
|
||
A boolean that specifies if datetimes will be timezone-aware by default or not.
|
||
If this is set to ``True``, Django will use timezone-aware datetimes internally.
|
||
Otherwise, Django will use naive datetimes in local time.
|
||
|
||
See also :setting:`TIME_ZONE`, :setting:`USE_I18N` and :setting:`USE_L10N`.
|
||
|
||
.. note::
|
||
|
||
The default :file:`settings.py` file created by
|
||
:djadmin:`django-admin.py startproject <startproject>` includes
|
||
``USE_TZ = True`` for convenience.
|
||
|
||
.. setting:: USE_X_FORWARDED_HOST
|
||
|
||
USE_X_FORWARDED_HOST
|
||
--------------------
|
||
|
||
Default: ``False``
|
||
|
||
A boolean that specifies whether to use the X-Forwarded-Host header in
|
||
preference to the Host header. This should only be enabled if a proxy
|
||
which sets this header is in use.
|
||
|
||
.. setting:: WSGI_APPLICATION
|
||
|
||
WSGI_APPLICATION
|
||
----------------
|
||
|
||
Default: ``None``
|
||
|
||
The full Python path of the WSGI application object that Django's built-in
|
||
servers (e.g. :djadmin:`runserver`) will use. The :djadmin:`django-admin.py
|
||
startproject <startproject>` management command will create a simple
|
||
``wsgi.py`` file with an ``application`` callable in it, and point this setting
|
||
to that ``application``.
|
||
|
||
If not set, the return value of ``django.core.wsgi.get_wsgi_application()``
|
||
will be used. In this case, the behavior of :djadmin:`runserver` will be
|
||
identical to previous Django versions.
|
||
|
||
.. setting:: YEAR_MONTH_FORMAT
|
||
|
||
YEAR_MONTH_FORMAT
|
||
-----------------
|
||
|
||
Default: ``'F Y'``
|
||
|
||
The default formatting to use for date fields on Django admin change-list
|
||
pages -- and, possibly, by other parts of the system -- in cases when only the
|
||
year and month are displayed.
|
||
|
||
For example, when a Django admin change-list page is being filtered by a date
|
||
drilldown, the header for a given month displays the month and the year.
|
||
Different locales have different formats. For example, U.S. English would say
|
||
"January 2006," whereas another locale might say "2006/January."
|
||
|
||
See :tfilter:`allowed date format strings <date>`. See also
|
||
:setting:`DATE_FORMAT`, :setting:`DATETIME_FORMAT`, :setting:`TIME_FORMAT`
|
||
and :setting:`MONTH_DAY_FORMAT`.
|
||
|
||
.. setting:: X_FRAME_OPTIONS
|
||
|
||
X_FRAME_OPTIONS
|
||
---------------
|
||
|
||
Default: ``'SAMEORIGIN'``
|
||
|
||
The default value for the X-Frame-Options header used by
|
||
:class:`~django.middleware.clickjacking.XFrameOptionsMiddleware`. See the
|
||
:doc:`clickjacking protection </ref/clickjacking/>` documentation.
|
||
|
||
|
||
Admindocs
|
||
=========
|
||
|
||
Settings for :mod:`django.contrib.admindocs`.
|
||
|
||
.. setting:: ADMIN_FOR
|
||
|
||
ADMIN_FOR
|
||
---------
|
||
|
||
Default: ``()`` (Empty tuple)
|
||
|
||
Used for admin-site settings modules, this should be a tuple of settings
|
||
modules (in the format ``'foo.bar.baz'``) for which this site is an admin.
|
||
|
||
The admin site uses this in its automatically-introspected documentation of
|
||
models, views and template tags.
|
||
|
||
|
||
Auth
|
||
====
|
||
|
||
Settings for :mod:`django.contrib.auth`.
|
||
|
||
.. setting:: AUTHENTICATION_BACKENDS
|
||
|
||
AUTHENTICATION_BACKENDS
|
||
-----------------------
|
||
|
||
Default: ``('django.contrib.auth.backends.ModelBackend',)``
|
||
|
||
A tuple of authentication backend classes (as strings) to use when attempting to
|
||
authenticate a user. See the :ref:`authentication backends documentation
|
||
<authentication-backends>` for details.
|
||
|
||
.. setting:: AUTH_USER_MODEL
|
||
|
||
AUTH_USER_MODEL
|
||
---------------
|
||
|
||
Default: 'auth.User'
|
||
|
||
The model to use to represent a User. See :ref:`auth-custom-user`.
|
||
|
||
.. setting:: LOGIN_REDIRECT_URL
|
||
|
||
LOGIN_REDIRECT_URL
|
||
------------------
|
||
|
||
Default: ``'/accounts/profile/'``
|
||
|
||
The URL where requests are redirected after login when the
|
||
``contrib.auth.login`` view gets no ``next`` parameter.
|
||
|
||
This is used by the :func:`~django.contrib.auth.decorators.login_required`
|
||
decorator, for example.
|
||
|
||
This setting also accepts view function names and :ref:`named URL patterns
|
||
<naming-url-patterns>` which can be used to reduce configuration duplication
|
||
since you don't have to define the URL in two places (``settings`` and URLconf).
|
||
|
||
.. setting:: LOGIN_URL
|
||
|
||
LOGIN_URL
|
||
---------
|
||
|
||
Default: ``'/accounts/login/'``
|
||
|
||
The URL where requests are redirected for login, especially when using the
|
||
:func:`~django.contrib.auth.decorators.login_required` decorator.
|
||
|
||
This setting also accepts view function names and :ref:`named URL patterns
|
||
<naming-url-patterns>` which can be used to reduce configuration duplication
|
||
since you don't have to define the URL in two places (``settings`` and URLconf).
|
||
|
||
.. setting:: LOGOUT_URL
|
||
|
||
LOGOUT_URL
|
||
----------
|
||
|
||
Default: ``'/accounts/logout/'``
|
||
|
||
LOGIN_URL counterpart.
|
||
|
||
.. setting:: PASSWORD_RESET_TIMEOUT_DAYS
|
||
|
||
PASSWORD_RESET_TIMEOUT_DAYS
|
||
---------------------------
|
||
|
||
Default: ``3``
|
||
|
||
The number of days a password reset link is valid for. Used by the
|
||
:mod:`django.contrib.auth` password reset mechanism.
|
||
|
||
.. setting:: PASSWORD_HASHERS
|
||
|
||
PASSWORD_HASHERS
|
||
----------------
|
||
|
||
See :ref:`auth_password_storage`.
|
||
|
||
Default::
|
||
|
||
('django.contrib.auth.hashers.PBKDF2PasswordHasher',
|
||
'django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher',
|
||
'django.contrib.auth.hashers.BCryptPasswordHasher',
|
||
'django.contrib.auth.hashers.SHA1PasswordHasher',
|
||
'django.contrib.auth.hashers.MD5PasswordHasher',
|
||
'django.contrib.auth.hashers.UnsaltedMD5PasswordHasher',
|
||
'django.contrib.auth.hashers.CryptPasswordHasher',)
|
||
|
||
|
||
.. _settings-comments:
|
||
|
||
Comments
|
||
========
|
||
|
||
Settings for :mod:`django.contrib.comments`.
|
||
|
||
.. setting:: COMMENTS_HIDE_REMOVED
|
||
|
||
COMMENTS_HIDE_REMOVED
|
||
---------------------
|
||
|
||
If ``True`` (default), removed comments will be excluded from comment
|
||
lists/counts (as taken from template tags). Otherwise, the template author is
|
||
responsible for some sort of a "this comment has been removed by the site staff"
|
||
message.
|
||
|
||
.. setting:: COMMENT_MAX_LENGTH
|
||
|
||
COMMENT_MAX_LENGTH
|
||
------------------
|
||
|
||
The maximum length of the comment field, in characters. Comments longer than
|
||
this will be rejected. Defaults to 3000.
|
||
|
||
.. setting:: COMMENTS_APP
|
||
|
||
COMMENTS_APP
|
||
------------
|
||
|
||
An app which provides :doc:`customization of the comments framework
|
||
</ref/contrib/comments/custom>`. Use the same dotted-string notation
|
||
as in :setting:`INSTALLED_APPS`. Your custom :setting:`COMMENTS_APP`
|
||
must also be listed in :setting:`INSTALLED_APPS`.
|
||
|
||
.. setting:: PROFANITIES_LIST
|
||
|
||
PROFANITIES_LIST
|
||
----------------
|
||
|
||
Default: ``()`` (Empty tuple)
|
||
|
||
A tuple of profanities, as strings, that will be forbidden in comments when
|
||
``COMMENTS_ALLOW_PROFANITIES`` is ``False``.
|
||
|
||
|
||
.. _settings-messages:
|
||
|
||
Messages
|
||
========
|
||
|
||
Settings for :mod:`django.contrib.messages`.
|
||
|
||
.. setting:: MESSAGE_LEVEL
|
||
|
||
MESSAGE_LEVEL
|
||
-------------
|
||
|
||
Default: ``messages.INFO``
|
||
|
||
Sets the minimum message level that will be recorded by the messages
|
||
framework. See :ref:`message levels <message-level>` for more details.
|
||
|
||
.. admonition:: Important
|
||
|
||
If you override ``MESSAGE_LEVEL`` in your settings file and rely on any of
|
||
the built-in constants, you must import the constants module directly to
|
||
avoid the potential for circular imports, e.g.::
|
||
|
||
from django.contrib.messages import constants as message_constants
|
||
MESSAGE_LEVEL = message_constants.DEBUG
|
||
|
||
If desired, you may specify the numeric values for the constants directly
|
||
according to the values in the above :ref:`constants table
|
||
<message-level-constants>`.
|
||
|
||
.. setting:: MESSAGE_STORAGE
|
||
|
||
MESSAGE_STORAGE
|
||
---------------
|
||
|
||
Default: ``'django.contrib.messages.storage.fallback.FallbackStorage'``
|
||
|
||
Controls where Django stores message data. Valid values are:
|
||
|
||
* ``'django.contrib.messages.storage.fallback.FallbackStorage'``
|
||
* ``'django.contrib.messages.storage.session.SessionStorage'``
|
||
* ``'django.contrib.messages.storage.cookie.CookieStorage'``
|
||
|
||
See :ref:`message storage backends <message-storage-backends>` for more details.
|
||
|
||
The backends that use cookies --
|
||
:class:`~django.contrib.messages.storage.cookie.CookieStorage` and
|
||
:class:`~django.contrib.messages.storage.fallback.FallbackStorage` --
|
||
use the value of :setting:`SESSION_COOKIE_DOMAIN`, :setting:`SESSION_COOKIE_SECURE`
|
||
and :setting:`SESSION_COOKIE_HTTPONLY` when setting their cookies.
|
||
|
||
.. setting:: MESSAGE_TAGS
|
||
|
||
MESSAGE_TAGS
|
||
------------
|
||
|
||
Default::
|
||
|
||
{messages.DEBUG: 'debug',
|
||
messages.INFO: 'info',
|
||
messages.SUCCESS: 'success',
|
||
messages.WARNING: 'warning',
|
||
messages.ERROR: 'error',}
|
||
|
||
This sets the mapping of message level to message tag, which is typically
|
||
rendered as a CSS class in HTML. If you specify a value, it will extend
|
||
the default. This means you only have to specify those values which you need
|
||
to override. See :ref:`message-displaying` above for more details.
|
||
|
||
.. admonition:: Important
|
||
|
||
If you override ``MESSAGE_TAGS`` in your settings file and rely on any of
|
||
the built-in constants, you must import the ``constants`` module directly to
|
||
avoid the potential for circular imports, e.g.::
|
||
|
||
from django.contrib.messages import constants as message_constants
|
||
MESSAGE_TAGS = {message_constants.INFO: ''}
|
||
|
||
If desired, you may specify the numeric values for the constants directly
|
||
according to the values in the above :ref:`constants table
|
||
<message-level-constants>`.
|
||
|
||
.. _settings-sessions:
|
||
|
||
Sessions
|
||
========
|
||
|
||
Settings for :mod:`django.contrib.sessions`.
|
||
|
||
.. setting:: SESSION_CACHE_ALIAS
|
||
|
||
SESSION_CACHE_ALIAS
|
||
-------------------
|
||
|
||
Default: ``default``
|
||
|
||
If you're using :ref:`cache-based session storage <cached-sessions-backend>`,
|
||
this selects the cache to use.
|
||
|
||
.. setting:: SESSION_COOKIE_AGE
|
||
|
||
SESSION_COOKIE_AGE
|
||
------------------
|
||
|
||
Default: ``1209600`` (2 weeks, in seconds)
|
||
|
||
The age of session cookies, in seconds.
|
||
|
||
.. setting:: SESSION_COOKIE_DOMAIN
|
||
|
||
SESSION_COOKIE_DOMAIN
|
||
---------------------
|
||
|
||
Default: ``None``
|
||
|
||
The domain to use for session cookies. Set this to a string such as
|
||
``".example.com"`` (note the leading dot!) for cross-domain cookies, or use
|
||
``None`` for a standard domain cookie.
|
||
|
||
Be cautious when updating this setting on a production site. If you update
|
||
this setting to enable cross-domain cookies on a site that previously used
|
||
standard domain cookies, existing user cookies will be set to the old
|
||
domain. This may result in them being unable to log in as long as these cookies
|
||
persist.
|
||
|
||
This setting also affects cookies set by :mod:`django.contrib.messages`.
|
||
|
||
.. setting:: SESSION_COOKIE_HTTPONLY
|
||
|
||
SESSION_COOKIE_HTTPONLY
|
||
-----------------------
|
||
|
||
Default: ``True``
|
||
|
||
Whether to use ``HTTPOnly`` flag on the session cookie. If this is set to
|
||
``True``, client-side JavaScript will not to be able to access the
|
||
session cookie.
|
||
|
||
HTTPOnly_ is a flag included in a Set-Cookie HTTP response header. It
|
||
is not part of the :rfc:`2109` standard for cookies, and it isn't honored
|
||
consistently by all browsers. However, when it is honored, it can be a
|
||
useful way to mitigate the risk of client side script accessing the
|
||
protected cookie data.
|
||
|
||
.. versionadded:: 1.7
|
||
|
||
This setting also affects cookies set by :mod:`django.contrib.messages`.
|
||
|
||
.. _HTTPOnly: https://www.owasp.org/index.php/HTTPOnly
|
||
|
||
.. setting:: SESSION_COOKIE_NAME
|
||
|
||
SESSION_COOKIE_NAME
|
||
-------------------
|
||
|
||
Default: ``'sessionid'``
|
||
|
||
The name of the cookie to use for sessions. This can be whatever you want (but
|
||
should be different from :setting:`LANGUAGE_COOKIE_NAME`).
|
||
|
||
.. setting:: SESSION_COOKIE_PATH
|
||
|
||
SESSION_COOKIE_PATH
|
||
-------------------
|
||
|
||
Default: ``'/'``
|
||
|
||
The path set on the session cookie. This should either match the URL path of your
|
||
Django installation or be parent of that path.
|
||
|
||
This is useful if you have multiple Django instances running under the same
|
||
hostname. They can use different cookie paths, and each instance will only see
|
||
its own session cookie.
|
||
|
||
.. setting:: SESSION_COOKIE_SECURE
|
||
|
||
SESSION_COOKIE_SECURE
|
||
---------------------
|
||
|
||
Default: ``False``
|
||
|
||
Whether to use a secure cookie for the session cookie. If this is set to
|
||
``True``, the cookie will be marked as "secure," which means browsers may
|
||
ensure that the cookie is only sent under an HTTPS connection.
|
||
|
||
.. versionadded:: 1.7
|
||
|
||
This setting also affects cookies set by :mod:`django.contrib.messages`.
|
||
|
||
.. setting:: SESSION_ENGINE
|
||
|
||
SESSION_ENGINE
|
||
--------------
|
||
|
||
Default: ``django.contrib.sessions.backends.db``
|
||
|
||
Controls where Django stores session data. Included engines are:
|
||
|
||
* ``'django.contrib.sessions.backends.db'``
|
||
* ``'django.contrib.sessions.backends.file'``
|
||
* ``'django.contrib.sessions.backends.cache'``
|
||
* ``'django.contrib.sessions.backends.cached_db'``
|
||
* ``'django.contrib.sessions.backends.signed_cookies'``
|
||
|
||
See :ref:`configuring-sessions` for more details.
|
||
|
||
.. setting:: SESSION_EXPIRE_AT_BROWSER_CLOSE
|
||
|
||
SESSION_EXPIRE_AT_BROWSER_CLOSE
|
||
-------------------------------
|
||
|
||
Default: ``False``
|
||
|
||
Whether to expire the session when the user closes his or her browser. See
|
||
:ref:`browser-length-vs-persistent-sessions`.
|
||
|
||
.. setting:: SESSION_FILE_PATH
|
||
|
||
SESSION_FILE_PATH
|
||
-----------------
|
||
|
||
Default: ``None``
|
||
|
||
If you're using file-based session storage, this sets the directory in
|
||
which Django will store session data. When the default value (``None``) is
|
||
used, Django will use the standard temporary directory for the system.
|
||
|
||
|
||
.. setting:: SESSION_SAVE_EVERY_REQUEST
|
||
|
||
SESSION_SAVE_EVERY_REQUEST
|
||
--------------------------
|
||
|
||
Default: ``False``
|
||
|
||
Whether to save the session data on every request. If this is ``False``
|
||
(default), then the session data will only be saved if it has been modified --
|
||
that is, if any of its dictionary values have been assigned or deleted.
|
||
|
||
.. setting:: SESSION_SERIALIZER
|
||
|
||
SESSION_SERIALIZER
|
||
------------------
|
||
|
||
Default: ``'django.contrib.sessions.serializers.JSONSerializer'``
|
||
|
||
.. versionchanged:: 1.6
|
||
|
||
The default switched from
|
||
:class:`~django.contrib.sessions.serializers.PickleSerializer` to
|
||
:class:`~django.contrib.sessions.serializers.JSONSerializer` in Django 1.6.
|
||
|
||
Full import path of a serializer class to use for serializing session data.
|
||
Included serializers are:
|
||
|
||
* ``'django.contrib.sessions.serializers.PickleSerializer'``
|
||
* ``'django.contrib.sessions.serializers.JSONSerializer'``
|
||
|
||
See :ref:`session_serialization` for details, including a warning regarding
|
||
possible remote code execution when using
|
||
:class:`~django.contrib.sessions.serializers.PickleSerializer`.
|
||
|
||
Sites
|
||
=====
|
||
|
||
Settings for :mod:`django.contrib.sites`.
|
||
|
||
.. setting:: SITE_ID
|
||
|
||
SITE_ID
|
||
-------
|
||
|
||
Default: Not defined
|
||
|
||
The ID, as an integer, of the current site in the ``django_site`` database
|
||
table. This is used so that application data can hook into specific sites
|
||
and a single database can manage content for multiple sites.
|
||
|
||
|
||
.. _settings-staticfiles:
|
||
|
||
Static files
|
||
============
|
||
|
||
Settings for :mod:`django.contrib.staticfiles`.
|
||
|
||
.. setting:: STATIC_ROOT
|
||
|
||
STATIC_ROOT
|
||
-----------
|
||
|
||
Default: ``''`` (Empty string)
|
||
|
||
The absolute path to the directory where :djadmin:`collectstatic` will collect
|
||
static files for deployment.
|
||
|
||
Example: ``"/var/www/example.com/static/"``
|
||
|
||
If the :doc:`staticfiles</ref/contrib/staticfiles>` contrib app is enabled
|
||
(default) the :djadmin:`collectstatic` management command will collect static
|
||
files into this directory. See the howto on :doc:`managing static
|
||
files</howto/static-files/index>` for more details about usage.
|
||
|
||
.. warning::
|
||
|
||
This should be an (initially empty) destination directory for collecting
|
||
your static files from their permanent locations into one directory for
|
||
ease of deployment; it is **not** a place to store your static files
|
||
permanently. You should do that in directories that will be found by
|
||
:doc:`staticfiles</ref/contrib/staticfiles>`’s
|
||
:setting:`finders<STATICFILES_FINDERS>`, which by default, are
|
||
``'static/'`` app sub-directories and any directories you include in
|
||
:setting:`STATICFILES_DIRS`).
|
||
|
||
.. setting:: STATIC_URL
|
||
|
||
STATIC_URL
|
||
----------
|
||
|
||
Default: ``None``
|
||
|
||
URL to use when referring to static files located in :setting:`STATIC_ROOT`.
|
||
|
||
Example: ``"/static/"`` or ``"http://static.example.com/"``
|
||
|
||
If not ``None``, this will be used as the base path for
|
||
:ref:`asset definitions<form-asset-paths>` (the ``Media`` class) and the
|
||
:doc:`staticfiles app</ref/contrib/staticfiles>`.
|
||
|
||
It must end in a slash if set to a non-empty value.
|
||
|
||
.. setting:: STATICFILES_DIRS
|
||
|
||
STATICFILES_DIRS
|
||
----------------
|
||
|
||
Default: ``[]``
|
||
|
||
This setting defines the additional locations the staticfiles app will traverse
|
||
if the ``FileSystemFinder`` finder is enabled, e.g. if you use the
|
||
:djadmin:`collectstatic` or :djadmin:`findstatic` management command or use the
|
||
static file serving view.
|
||
|
||
This should be set to a list or tuple of strings that contain full paths to
|
||
your additional files directory(ies) e.g.::
|
||
|
||
STATICFILES_DIRS = (
|
||
"/home/special.polls.com/polls/static",
|
||
"/home/polls.com/polls/static",
|
||
"/opt/webfiles/common",
|
||
)
|
||
|
||
Prefixes (optional)
|
||
~~~~~~~~~~~~~~~~~~~
|
||
|
||
In case you want to refer to files in one of the locations with an additional
|
||
namespace, you can **optionally** provide a prefix as ``(prefix, path)``
|
||
tuples, e.g.::
|
||
|
||
STATICFILES_DIRS = (
|
||
# ...
|
||
("downloads", "/opt/webfiles/stats"),
|
||
)
|
||
|
||
Example:
|
||
|
||
Assuming you have :setting:`STATIC_URL` set ``'/static/'``, the
|
||
:djadmin:`collectstatic` management command would collect the "stats" files
|
||
in a ``'downloads'`` subdirectory of :setting:`STATIC_ROOT`.
|
||
|
||
This would allow you to refer to the local file
|
||
``'/opt/webfiles/stats/polls_20101022.tar.gz'`` with
|
||
``'/static/downloads/polls_20101022.tar.gz'`` in your templates, e.g.:
|
||
|
||
.. code-block:: html+django
|
||
|
||
<a href="{{ STATIC_URL }}downloads/polls_20101022.tar.gz">
|
||
|
||
.. setting:: STATICFILES_STORAGE
|
||
|
||
STATICFILES_STORAGE
|
||
-------------------
|
||
|
||
Default: ``'django.contrib.staticfiles.storage.StaticFilesStorage'``
|
||
|
||
The file storage engine to use when collecting static files with the
|
||
:djadmin:`collectstatic` management command.
|
||
|
||
A ready-to-use instance of the storage backend defined in this setting
|
||
can be found at ``django.contrib.staticfiles.storage.staticfiles_storage``.
|
||
|
||
For an example, see :ref:`staticfiles-from-cdn`.
|
||
|
||
.. setting:: STATICFILES_FINDERS
|
||
|
||
STATICFILES_FINDERS
|
||
-------------------
|
||
|
||
Default::
|
||
|
||
("django.contrib.staticfiles.finders.FileSystemFinder",
|
||
"django.contrib.staticfiles.finders.AppDirectoriesFinder")
|
||
|
||
The list of finder backends that know how to find static files in
|
||
various locations.
|
||
|
||
The default will find files stored in the :setting:`STATICFILES_DIRS` setting
|
||
(using ``django.contrib.staticfiles.finders.FileSystemFinder``) and in a
|
||
``static`` subdirectory of each app (using
|
||
``django.contrib.staticfiles.finders.AppDirectoriesFinder``). If multiple
|
||
files with the same name are present, the first file that is found will be
|
||
used.
|
||
|
||
One finder is disabled by default:
|
||
``django.contrib.staticfiles.finders.DefaultStorageFinder``. If added to
|
||
your :setting:`STATICFILES_FINDERS` setting, it will look for static files in
|
||
the default file storage as defined by the :setting:`DEFAULT_FILE_STORAGE`
|
||
setting.
|
||
|
||
.. note::
|
||
|
||
When using the ``AppDirectoriesFinder`` finder, make sure your apps
|
||
can be found by staticfiles. Simply add the app to the
|
||
:setting:`INSTALLED_APPS` setting of your site.
|
||
|
||
Static file finders are currently considered a private interface, and this
|
||
interface is thus undocumented.
|
||
|
||
Core Settings Topical Index
|
||
===========================
|
||
|
||
Cache
|
||
-----
|
||
* :setting:`CACHES`
|
||
* :setting:`CACHE_MIDDLEWARE_ALIAS`
|
||
* :setting:`CACHE_MIDDLEWARE_ANONYMOUS_ONLY`
|
||
* :setting:`CACHE_MIDDLEWARE_KEY_PREFIX`
|
||
* :setting:`CACHE_MIDDLEWARE_SECONDS`
|
||
|
||
Database
|
||
--------
|
||
* :setting:`DATABASES`
|
||
* :setting:`DATABASE_ROUTERS`
|
||
* :setting:`DEFAULT_INDEX_TABLESPACE`
|
||
* :setting:`DEFAULT_TABLESPACE`
|
||
* :setting:`TRANSACTIONS_MANAGED`
|
||
|
||
Debugging
|
||
---------
|
||
* :setting:`DEBUG`
|
||
* :setting:`DEBUG_PROPAGATE_EXCEPTIONS`
|
||
|
||
Email
|
||
-----
|
||
* :setting:`ADMINS`
|
||
* :setting:`DEFAULT_CHARSET`
|
||
* :setting:`DEFAULT_FROM_EMAIL`
|
||
* :setting:`EMAIL_BACKEND`
|
||
* :setting:`EMAIL_FILE_PATH`
|
||
* :setting:`EMAIL_HOST`
|
||
* :setting:`EMAIL_HOST_PASSWORD`
|
||
* :setting:`EMAIL_HOST_USER`
|
||
* :setting:`EMAIL_PORT`
|
||
* :setting:`EMAIL_SUBJECT_PREFIX`
|
||
* :setting:`EMAIL_USE_TLS`
|
||
* :setting:`MANAGERS`
|
||
* :setting:`SEND_BROKEN_LINK_EMAILS`
|
||
* :setting:`SERVER_EMAIL`
|
||
|
||
Error reporting
|
||
---------------
|
||
* :setting:`DEFAULT_EXCEPTION_REPORTER_FILTER`
|
||
* :setting:`IGNORABLE_404_URLS`
|
||
* :setting:`MANAGERS`
|
||
* :setting:`SEND_BROKEN_LINK_EMAILS`
|
||
|
||
File uploads
|
||
------------
|
||
* :setting:`DEFAULT_FILE_STORAGE`
|
||
* :setting:`FILE_CHARSET`
|
||
* :setting:`FILE_UPLOAD_HANDLERS`
|
||
* :setting:`FILE_UPLOAD_MAX_MEMORY_SIZE`
|
||
* :setting:`FILE_UPLOAD_PERMISSIONS`
|
||
* :setting:`FILE_UPLOAD_TEMP_DIR`
|
||
* :setting:`MEDIA_ROOT`
|
||
* :setting:`MEDIA_URL`
|
||
|
||
Globalization (i18n/l10n)
|
||
-------------------------
|
||
* :setting:`DATE_FORMAT`
|
||
* :setting:`DATE_INPUT_FORMATS`
|
||
* :setting:`DATETIME_FORMAT`
|
||
* :setting:`DATETIME_INPUT_FORMATS`
|
||
* :setting:`DECIMAL_SEPARATOR`
|
||
* :setting:`FIRST_DAY_OF_WEEK`
|
||
* :setting:`FORMAT_MODULE_PATH`
|
||
* :setting:`LANGUAGE_CODE`
|
||
* :setting:`LANGUAGE_COOKIE_NAME`
|
||
* :setting:`LANGUAGES`
|
||
* :setting:`LOCALE_PATHS`
|
||
* :setting:`MONTH_DAY_FORMAT`
|
||
* :setting:`NUMBER_GROUPING`
|
||
* :setting:`SHORT_DATE_FORMAT`
|
||
* :setting:`SHORT_DATETIME_FORMAT`
|
||
* :setting:`THOUSAND_SEPARATOR`
|
||
* :setting:`TIME_FORMAT`
|
||
* :setting:`TIME_INPUT_FORMATS`
|
||
* :setting:`TIME_ZONE`
|
||
* :setting:`USE_I18N`
|
||
* :setting:`USE_L10N`
|
||
* :setting:`USE_THOUSAND_SEPARATOR`
|
||
* :setting:`USE_TZ`
|
||
* :setting:`YEAR_MONTH_FORMAT`
|
||
|
||
HTTP
|
||
----
|
||
* :setting:`DEFAULT_CHARSET`
|
||
* :setting:`DEFAULT_CONTENT_TYPE`
|
||
* :setting:`DISALLOWED_USER_AGENTS`
|
||
* :setting:`FORCE_SCRIPT_NAME`
|
||
* :setting:`INTERNAL_IPS`
|
||
* :setting:`MIDDLEWARE_CLASSES`
|
||
* :setting:`SECURE_PROXY_SSL_HEADER`
|
||
* :setting:`SIGNING_BACKEND`
|
||
* :setting:`USE_ETAGS`
|
||
* :setting:`USE_X_FORWARDED_HOST`
|
||
* :setting:`WSGI_APPLICATION`
|
||
|
||
Logging
|
||
-------
|
||
* :setting:`LOGGING`
|
||
* :setting:`LOGGING_CONFIG`
|
||
|
||
Models
|
||
------
|
||
* :setting:`ABSOLUTE_URL_OVERRIDES`
|
||
* :setting:`FIXTURE_DIRS`
|
||
* :setting:`INSTALLED_APPS`
|
||
|
||
Security
|
||
--------
|
||
* Cross Site Request Forgery protection
|
||
|
||
* :setting:`CSRF_COOKIE_DOMAIN`
|
||
* :setting:`CSRF_COOKIE_NAME`
|
||
* :setting:`CSRF_COOKIE_PATH`
|
||
* :setting:`CSRF_COOKIE_SECURE`
|
||
* :setting:`CSRF_FAILURE_VIEW`
|
||
|
||
* :setting:`SECRET_KEY`
|
||
* :setting:`X_FRAME_OPTIONS`
|
||
|
||
Serialization
|
||
-------------
|
||
* :setting:`DEFAULT_CHARSET`
|
||
* :setting:`SERIALIZATION_MODULES`
|
||
|
||
Templates
|
||
---------
|
||
* :setting:`ALLOWED_INCLUDE_ROOTS`
|
||
* :setting:`TEMPLATE_CONTEXT_PROCESSORS`
|
||
* :setting:`TEMPLATE_DEBUG`
|
||
* :setting:`TEMPLATE_DIRS`
|
||
* :setting:`TEMPLATE_LOADERS`
|
||
* :setting:`TEMPLATE_STRING_IF_INVALID`
|
||
|
||
Testing
|
||
-------
|
||
* Database
|
||
|
||
* :setting:`TEST_CHARSET`
|
||
* :setting:`TEST_COLLATION`
|
||
* :setting:`TEST_DEPENDENCIES`
|
||
* :setting:`TEST_MIRROR`
|
||
* :setting:`TEST_NAME`
|
||
* :setting:`TEST_CREATE`
|
||
* :setting:`TEST_USER`
|
||
* :setting:`TEST_USER_CREATE`
|
||
* :setting:`TEST_PASSWD`
|
||
* :setting:`TEST_TBLSPACE`
|
||
* :setting:`TEST_TBLSPACE_TMP`
|
||
|
||
* :setting:`TEST_RUNNER`
|
||
|
||
URLs
|
||
----
|
||
* :setting:`APPEND_SLASH`
|
||
* :setting:`PREPEND_WWW`
|
||
* :setting:`ROOT_URLCONF`
|