Here’s a list of settings available in Django core and their default values.\nSettings provided by contrib apps are listed below, followed by a topical index\nof the core settings. For introductory material, see the settings topic\nguide.
\nABSOLUTE_URL_OVERRIDESLink para este cabeçalho#Default: {} (Empty dictionary)
A dictionary mapping "app_label.model_name" strings to functions that take\na model object and return its URL. This is a way of inserting or overriding\nget_absolute_url() methods on a per-installation basis. Example:
ABSOLUTE_URL_OVERRIDES = {\n 'blogs.weblog': lambda o: "/blogs/%s/" % o.slug,\n 'news.story': lambda o: "/stories/%s/%s/" % (o.pub_year, o.slug),\n}\nNote that the model name used in this setting should be all lower-case, regardless\nof the case of the actual model class name.
\nADMINSLink para este cabeçalho#Default: [] (Empty list)
A list of all the people who get code error notifications. When\nDEBUG=False and AdminEmailHandler\nis configured in LOGGING (done by default), Django emails these\npeople the details of exceptions raised in the request/response cycle.
Each item in the list should be a tuple of (Full name, email address). Example:
\n[('John', 'john@example.com'), ('Mary', 'mary@example.com')]\nALLOWED_HOSTSLink para este cabeçalho#Default: [] (Empty list)
A list of strings representing the host/domain names that this Django site can\nserve. This is a security measure to prevent HTTP Host header attacks, which are possible even under many\nseemingly-safe web server configurations.
\nValues in this list can be fully qualified names (e.g. 'www.example.com'),\nin which case they will be matched against the request’s Host header\nexactly (case-insensitive, not including port). A value beginning with a period\ncan be used as a subdomain wildcard: '.example.com' will match\nexample.com, www.example.com, and any other subdomain of\nexample.com. A value of '*' will match anything; in this case you are\nresponsible to provide your own validation of the Host header (perhaps in a\nmiddleware; if so this middleware must be listed first in\nMIDDLEWARE).
Django also allows the fully qualified domain name (FQDN) of any entries.\nSome browsers include a trailing dot in the Host header which Django\nstrips when performing host validation.
If the Host header (or X-Forwarded-Host if\nUSE_X_FORWARDED_HOST is enabled) does not match any value in this\nlist, the django.http.HttpRequest.get_host() method will raise\nSuspiciousOperation.
When DEBUG is True and ALLOWED_HOSTS is empty, the host\nis validated against ['localhost', '127.0.0.1', '[::1]'].
ALLOWED_HOSTS is also checked when running tests.
Essa validação só é aplicada através do método get_host(); se o seu código acessa o cabeçalho Host diretamente do request.META você está contornando essa proteção de segurança.
APPEND_SLASHLink para este cabeçalho#Default: True
When set to True, if the request URL does not match any of the patterns\nin the URLconf and it doesn’t end in a slash, an HTTP redirect is issued to the\nsame URL with a slash appended. Note that the redirect may cause any data\nsubmitted in a POST request to be lost.
The APPEND_SLASH setting is only used if\nCommonMiddleware is installed\n(see Middleware). See also PREPEND_WWW.
CACHESLink para este cabeçalho#Padrão:
\n{\n 'default': {\n 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',\n }\n}\nA dictionary containing the settings for all caches to be used with\nDjango. It is a nested dictionary whose contents maps cache aliases\nto a dictionary containing the options for an individual cache.
\nThe CACHES setting must configure a default cache;\nany number of additional caches may also be specified. If you\nare using a cache backend other than the local memory cache, or\nyou need to define multiple caches, other options will be required.\nThe following cache options are available.
BACKENDLink para este cabeçalho#Default: '' (Empty string)
The cache backend to use. The built-in cache backends are:
\n'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\nBACKEND to a fully-qualified path of a cache\nbackend class (i.e. mypackage.backends.whatever.WhateverCache).
KEY_FUNCTIONLink para este cabeçalho#A string containing a dotted path to a function (or any callable) that defines how to\ncompose a prefix, version and key into a final cache key. The default\nimplementation is equivalent to the function:
\ndef make_key(key, key_prefix, version):\n return ':'.join([key_prefix, str(version), key])\nYou may use any key function you want, as long as it has the same\nargument signature.
\nSee the cache documentation for more\ninformation.
\nKEY_PREFIXLink para este cabeçalho#Default: '' (Empty string)
A string that will be automatically included (prepended by default) to\nall cache keys used by the Django server.
\nSee the cache documentation for more information.
\nLOCATIONLink para este cabeçalho#Default: '' (Empty string)
The location of the cache to use. This might be the directory for a\nfile system cache, a host and port for a memcache server, or simply an\nidentifying name for a local memory cache. e.g.:
\nCACHES = {\n 'default': {\n 'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',\n 'LOCATION': '/var/tmp/django_cache',\n }\n}\nOPTIONSLink para este cabeçalho#Default: None
Extra parameters to pass to the cache backend. Available parameters\nvary depending on your cache backend.
\nSome information on available parameters can be found in the\ncache arguments documentation. For more information,\nconsult your backend module’s own documentation.
\nTIMEOUTLink para este cabeçalho#Default: 300
The number of seconds before a cache entry is considered stale. If the value of\nthis settings is None, cache entries will not expire.
VERSIONLink para este cabeçalho#Default: 1
The default version number for cache keys generated by the Django server.
\nSee the cache documentation for more information.
\nCACHE_MIDDLEWARE_ALIASLink para este cabeçalho#Default: default
The cache connection to use for the cache middleware.
\nCACHE_MIDDLEWARE_KEY_PREFIXLink para este cabeçalho#Default: '' (Empty string)
A string which will be prefixed to the cache keys generated by the cache\nmiddleware. This prefix is combined with the\nKEY_PREFIX setting; it does not replace it.
CACHE_MIDDLEWARE_SECONDSLink para este cabeçalho#Default: 600
The default number of seconds to cache a page for the cache middleware.
\n\nCSRF_USE_SESSIONSLink para este cabeçalho#Default: False
Whether to store the CSRF token in the user’s session instead of in a cookie.\nIt requires the use of django.contrib.sessions.
Storing the CSRF token in a cookie (Django’s default) is safe, but storing it\nin the session is common practice in other web frameworks and therefore\nsometimes demanded by security auditors.
\nCSRF_FAILURE_VIEWLink para este cabeçalho#Default: 'django.views.csrf.csrf_failure'
A dotted path to the view function to be used when an incoming request is\nrejected by the CSRF protection. The function should have\nthis signature:
\ndef csrf_failure(request, reason=""):\n ...\nwhere reason is a short message (intended for developers or logging, not\nfor end users) indicating the reason the request was rejected. It should return\nan HttpResponseForbidden.
django.views.csrf.csrf_failure() accepts an additional template_name\nparameter that defaults to '403_csrf.html'. If a template with that name\nexists, it will be used to render the page.
CSRF_HEADER_NAMELink para este cabeçalho#Default: 'HTTP_X_CSRFTOKEN'
The name of the request header used for CSRF authentication.
\nAs with other HTTP headers in request.META, the header name received from\nthe server is normalized by converting all characters to uppercase, replacing\nany hyphens with underscores, and adding an 'HTTP_' prefix to the name.\nFor example, if your client sends a 'X-XSRF-TOKEN' header, the setting\nshould be 'HTTP_X_XSRF_TOKEN'.
CSRF_TRUSTED_ORIGINSLink para este cabeçalho#Default: [] (Empty list)
A list of hosts which are trusted origins for unsafe requests (e.g. POST).\nFor a secure unsafe\nrequest, Django’s CSRF protection requires that the request have a Referer\nheader that matches the origin present in the Host header. This prevents,\nfor example, a POST request from subdomain.example.com from succeeding\nagainst api.example.com. If you need cross-origin unsafe requests over\nHTTPS, continuing the example, add "subdomain.example.com" to this list.\nThe setting also supports subdomains, so you could add ".example.com", for\nexample, to allow access from all subdomains of example.com.
DATABASESLink para este cabeçalho#Default: {} (Empty dictionary)
A dictionary containing the settings for all databases to be used with\nDjango. It is a nested dictionary whose contents map a database alias\nto a dictionary containing the options for an individual database.
\nThe DATABASES setting must configure a default database;\nany number of additional databases may also be specified.
The simplest possible settings file is for a single-database setup using\nSQLite. This can be configured using the following:
\nDATABASES = {\n 'default': {\n 'ENGINE': 'django.db.backends.sqlite3',\n 'NAME': 'mydatabase',\n }\n}\nWhen connecting to other database backends, such as MySQL, Oracle, or\nPostgreSQL, additional connection parameters will be required. See\nthe ENGINE setting below on how to specify\nother database types. This example is for PostgreSQL:
DATABASES = {\n 'default': {\n 'ENGINE': 'django.db.backends.postgresql',\n 'NAME': 'mydatabase',\n 'USER': 'mydatabaseuser',\n 'PASSWORD': 'mypassword',\n 'HOST': '127.0.0.1',\n 'PORT': '5432',\n }\n}\nThe following inner options that may be required for more complex\nconfigurations are available:
\nATOMIC_REQUESTSLink para este cabeçalho#Default: False
Set this to True to wrap each view in a transaction on this database. See\nTying transactions to HTTP requests.
AUTOCOMMITLink para este cabeçalho#Default: True
Set this to False if you want to disable Django’s transaction\nmanagement and implement your own.
ENGINELink para este cabeçalho#Default: '' (Empty string)
The database backend to use. The built-in database backends are:
\n'django.db.backends.postgresql'
'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\nENGINE to a fully-qualified path (i.e. mypackage.backends.whatever).
HOSTLink para este cabeçalho#Default: '' (Empty string)
Which host to use when connecting to the database. An empty string means\nlocalhost. Not used with SQLite.
\nIf this value starts with a forward slash ('/') and you’re using MySQL,\nMySQL will connect via a Unix socket to the specified socket. For example:
"HOST": '/var/run/mysql'\nIf you’re using MySQL and this value doesn’t start with a forward slash, then\nthis value is assumed to be the host.
\nIf you’re using PostgreSQL, by default (empty HOST), the connection\nto the database is done through UNIX domain sockets (‘local’ lines in\npg_hba.conf). If your UNIX domain socket is not in the standard location,\nuse the same value of unix_socket_directory from postgresql.conf.\nIf you want to connect through TCP sockets, set HOST to ‘localhost’\nor ‘127.0.0.1’ (‘host’ lines in pg_hba.conf).\nOn Windows, you should always define HOST, as UNIX domain sockets\nare not available.
NAMELink para este cabeçalho#Default: '' (Empty string)
The name of the database to use. For SQLite, it’s the full path to the database\nfile. When specifying the path, always use forward slashes, even on Windows\n(e.g. C:/homes/user/mysite/sqlite3.db).
CONN_MAX_AGELink para este cabeçalho#Default: 0
The lifetime of a database connection, in seconds. Use 0 to close database\nconnections at the end of each request — Django’s historical behavior — and\nNone for unlimited persistent connections.
OPTIONSLink para este cabeçalho#Default: {} (Empty dictionary)
Extra parameters to use when connecting to the database. Available parameters\nvary depending on your database backend.
\nSome information on available parameters can be found in the\nDatabase Backends documentation. For more information,\nconsult your backend module’s own documentation.
\nPASSWORDLink para este cabeçalho#Default: '' (Empty string)
The password to use when connecting to the database. Not used with SQLite.
\nPORTLink para este cabeçalho#Default: '' (Empty string)
The port to use when connecting to the database. An empty string means the\ndefault port. Not used with SQLite.
\nTIME_ZONELink para este cabeçalho#Default: None
A string representing the time zone for datetimes stored in this database\n(assuming that it doesn’t support time zones) or None. This inner option of\nthe DATABASES setting accepts the same values as the general\nTIME_ZONE setting.
This allows interacting with third-party databases that store datetimes in\nlocal time rather than UTC. To avoid issues around DST changes, you shouldn’t\nset this option for databases managed by Django.
\nWhen USE_TZ is True and the database doesn’t support time zones\n(e.g. SQLite, MySQL, Oracle), Django reads and writes datetimes in local time\naccording to this option if it is set and in UTC if it isn’t.
When USE_TZ is True and the database supports time zones (e.g.\nPostgreSQL), it is an error to set this option.
When USE_TZ is False, it is an error to set this option.
DISABLE_SERVER_SIDE_CURSORSLink para este cabeçalho#Default: False
Set this to True if you want to disable the use of server-side cursors with\nQuerySet.iterator(). Transaction pooling and server-side cursors\ndescribes the use case.
This is a PostgreSQL-specific setting.
\nUSERLink para este cabeçalho#Default: '' (Empty string)
The username to use when connecting to the database. Not used with SQLite.
\nTESTLink para este cabeçalho#Default: {} (Empty dictionary)
A dictionary of settings for test databases; for more details about the\ncreation and use of test databases, see The test database.
\nHere’s an example with a test database configuration:
\nDATABASES = {\n 'default': {\n 'ENGINE': 'django.db.backends.postgresql',\n 'USER': 'mydatabaseuser',\n 'NAME': 'mydatabase',\n 'TEST': {\n 'NAME': 'mytestdatabase',\n },\n },\n}\nThe following keys in the TEST dictionary are available:
CHARSETLink para este cabeçalho#Default: None
The character set encoding used to create the test database. The value of this\nstring is passed directly through to the database, so its format is\nbackend-specific.
\nSupported by the PostgreSQL (postgresql) and MySQL (mysql) backends.
COLLATIONLink para este cabeçalho#Default: None
The collation order to use when creating the test database. This value is\npassed directly to the backend, so its format is backend-specific.
\nOnly supported for the mysql backend (see the MySQL manual for details).
DEPENDENCIESLink para este cabeçalho#Default: ['default'], for all databases other than default,\nwhich has no dependencies.
The creation-order dependencies of the database. See the documentation\non controlling the creation order of test databases for details.
\nMIRRORLink para este cabeçalho#Default: None
The alias of the database that this database should mirror during\ntesting.
\nThis setting exists to allow for testing of primary/replica\n(referred to as master/slave by some databases)\nconfigurations of multiple databases. See the documentation on\ntesting primary/replica configurations for details.
\nNAMELink para este cabeçalho#Default: None
The name of database to use when running the test suite.
\nIf the default value (None) is used with the SQLite database engine, the\ntests will use a memory resident database. For all other database engines the\ntest database will use the name 'test_' + DATABASE_NAME.
Veja The test database.
\nSERIALIZELink para este cabeçalho#Boolean value to control whether or not the default test runner serializes the\ndatabase into an in-memory JSON string before running tests (used to restore\nthe database state between tests if you don’t have transactions). You can set\nthis to False to speed up creation time if you don’t have any test classes\nwith serialized_rollback=True.
TEMPLATELink para este cabeçalho#This is a PostgreSQL-specific setting.
\nThe name of a template (e.g. 'template0') from which to create the test\ndatabase.
CREATE_DBLink para este cabeçalho#Default: True
This is an Oracle-specific setting.
\nIf it is set to False, the test tablespaces won’t be automatically created\nat the beginning of the tests or dropped at the end.
CREATE_USERLink para este cabeçalho#Default: True
This is an Oracle-specific setting.
\nIf it is set to False, the test user won’t be automatically created at the\nbeginning of the tests and dropped at the end.
USERLink para este cabeçalho#Default: None
This is an Oracle-specific setting.
\nThe username to use when connecting to the Oracle database that will be used\nwhen running tests. If not provided, Django will use 'test_' + USER.
PASSWORDLink para este cabeçalho#Default: None
This is an Oracle-specific setting.
\nThe password to use when connecting to the Oracle database that will be used\nwhen running tests. If not provided, Django will generate a random password.
\nTBLSPACELink para este cabeçalho#Default: None
This is an Oracle-specific setting.
\nThe name of the tablespace that will be used when running tests. If not\nprovided, Django will use 'test_' + USER.
TBLSPACE_TMPLink para este cabeçalho#Default: None
This is an Oracle-specific setting.
\nThe name of the temporary tablespace that will be used when running tests. If\nnot provided, Django will use 'test_' + USER + '_temp'.
DATAFILELink para este cabeçalho#Default: None
This is an Oracle-specific setting.
\nThe name of the datafile to use for the TBLSPACE. If not provided, Django will\nuse TBLSPACE + '.dbf'.
DATAFILE_TMPLink para este cabeçalho#Default: None
This is an Oracle-specific setting.
\nThe name of the datafile to use for the TBLSPACE_TMP. If not provided, Django\nwill use TBLSPACE_TMP + '.dbf'.
DATAFILE_MAXSIZELink para este cabeçalho#Padrão: '500M'
This is an Oracle-specific setting.
\nThe maximum size that the DATAFILE is allowed to grow to.
\nDATAFILE_TMP_MAXSIZELink para este cabeçalho#Padrão: '500M'
This is an Oracle-specific setting.
\nThe maximum size that the DATAFILE_TMP is allowed to grow to.
\nDATAFILE_SIZELink para este cabeçalho#Default: '50M'
This is an Oracle-specific setting.
\nThe initial size of the DATAFILE.
\nDATAFILE_TMP_SIZELink para este cabeçalho#Default: '50M'
This is an Oracle-specific setting.
\nThe initial size of the DATAFILE_TMP.
\nDATAFILE_EXTSIZELink para este cabeçalho#Default: '25M'
This is an Oracle-specific setting.
\nThe amount by which the DATAFILE is extended when more space is required.
\nDATAFILE_TMP_EXTSIZELink para este cabeçalho#Default: '25M'
This is an Oracle-specific setting.
\nThe amount by which the DATAFILE_TMP is extended when more space is required.
\nPadrão: 2621440 (i.e. 2.5 MB).
The maximum size in bytes that a request body may be before a\nSuspiciousOperation (RequestDataTooBig) is\nraised. The check is done when accessing request.body or request.POST\nand is calculated against the total request size excluding any file upload\ndata. You can set this to None to disable the check. Applications that are\nexpected to receive unusually large form posts should tune this setting.
The amount of request data is correlated to the amount of memory needed to\nprocess the request and populate the GET and POST dictionaries. Large requests\ncould be used as a denial-of-service attack vector if left unchecked. Since web\nservers don’t typically perform deep request inspection, it’s not possible to\nperform a similar check at that level.
\nSee also FILE_UPLOAD_MAX_MEMORY_SIZE.
Default: 1000
The maximum number of parameters that may be received via GET or POST before a\nSuspiciousOperation (TooManyFields) is\nraised. You can set this to None to disable the check. Applications that\nare expected to receive an unusually large number of form fields should tune\nthis setting.
The number of request parameters is correlated to the amount of time needed to\nprocess the request and populate the GET and POST dictionaries. Large requests\ncould be used as a denial-of-service attack vector if left unchecked. Since web\nservers don’t typically perform deep request inspection, it’s not possible to\nperform a similar check at that level.
\nDATABASE_ROUTERSLink para este cabeçalho#Default: [] (Empty list)
The list of routers that will be used to determine which database\nto use when performing a database query.
\nSee the documentation on automatic database routing in multi\ndatabase configurations.
\nDATE_FORMATLink para este cabeçalho#Padrão: 'N j, Y' (e.g. Feb. 4, 2003)
The default formatting to use for displaying date fields in any part of the\nsystem. Note that if USE_L10N is set to True, then the\nlocale-dictated format has higher precedence and will be applied instead. See\nallowed date format strings.
See also DATETIME_FORMAT, TIME_FORMAT and SHORT_DATE_FORMAT.
DATE_INPUT_FORMATSLink para este cabeçalho#Padrão:
\n[\n '%Y-%m-%d', '%m/%d/%Y', '%m/%d/%y', # '2006-10-25', '10/25/2006', '10/25/06'\n '%b %d %Y', '%b %d, %Y', # 'Oct 25 2006', 'Oct 25, 2006'\n '%d %b %Y', '%d %b, %Y', # '25 Oct 2006', '25 Oct, 2006'\n '%B %d %Y', '%B %d, %Y', # 'October 25 2006', 'October 25, 2006'\n '%d %B %Y', '%d %B, %Y', # '25 October 2006', '25 October, 2006'\n]\nA list of formats that will be accepted when inputting data on a date field.\nFormats will be tried in order, using the first valid one. Note that these\nformat strings use Python’s datetime module syntax, not the format strings from the date\ntemplate filter.
When USE_L10N is True, the locale-dictated format has higher\nprecedence and will be applied instead.
Veja também DATETIME_INPUT_FORMATS e TIME_INPUT_FORMATS.
DATETIME_FORMATLink para este cabeçalho#Padrão: '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\nsystem. Note that if USE_L10N is set to True, then the\nlocale-dictated format has higher precedence and will be applied instead. See\nallowed date format strings.
See also DATE_FORMAT, TIME_FORMAT and SHORT_DATETIME_FORMAT.
DATETIME_INPUT_FORMATSLink para este cabeçalho#Padrão:
\n[\n '%Y-%m-%d %H:%M:%S', # '2006-10-25 14:30:59'\n '%Y-%m-%d %H:%M:%S.%f', # '2006-10-25 14:30:59.000200'\n '%Y-%m-%d %H:%M', # '2006-10-25 14:30'\n '%Y-%m-%d', # '2006-10-25'\n '%m/%d/%Y %H:%M:%S', # '10/25/2006 14:30:59'\n '%m/%d/%Y %H:%M:%S.%f', # '10/25/2006 14:30:59.000200'\n '%m/%d/%Y %H:%M', # '10/25/2006 14:30'\n '%m/%d/%Y', # '10/25/2006'\n '%m/%d/%y %H:%M:%S', # '10/25/06 14:30:59'\n '%m/%d/%y %H:%M:%S.%f', # '10/25/06 14:30:59.000200'\n '%m/%d/%y %H:%M', # '10/25/06 14:30'\n '%m/%d/%y', # '10/25/06'\n]\nA list of formats that will be accepted when inputting data on a datetime\nfield. Formats will be tried in order, using the first valid one. Note that\nthese format strings use Python’s datetime module syntax, not the format strings from the date\ntemplate filter.
When USE_L10N is True, the locale-dictated format has higher\nprecedence and will be applied instead.
See also DATE_INPUT_FORMATS and TIME_INPUT_FORMATS.
DEBUGLink para este cabeçalho#Default: False
A boolean that turns on/off debug mode.
\nNunca faça o deploy de um site em produção com o DEBUG ativado.
One of the main features of debug mode is the display of detailed error pages.\nIf your app raises an exception when DEBUG is True, Django will\ndisplay a detailed traceback, including a lot of metadata about your\nenvironment, such as all the currently defined Django settings (from\nsettings.py).
As a security measure, Django will not include settings that might be\nsensitive, such as SECRET_KEY. Specifically, it will exclude any\nsetting whose name includes any of the following:
'API'
'KEY'
'PASS'
'SECRET'
'SIGNATURE'
'TOKEN'
Note that these are partial matches. 'PASS' will also match PASSWORD,\njust as 'TOKEN' will also match TOKENIZED and so on.
Still, note that there are always going to be sections of your debug output\nthat are inappropriate for public consumption. File paths, configuration\noptions and the like all give attackers extra information about your server.
\nIt is also important to remember that when running with DEBUG\nturned on, Django will remember every SQL query it executes. This is useful\nwhen you’re debugging, but it’ll rapidly consume memory on a production server.
Finally, if DEBUG is False, you also need to properly set\nthe ALLOWED_HOSTS setting. Failing to do so will result in all\nrequests being returned as “Bad Request (400)”.
DEBUG_PROPAGATE_EXCEPTIONSLink para este cabeçalho#Default: False
If set to True, Django’s exception handling of view functions\n(handler500, or the debug view if DEBUG\nis True) and logging of 500 responses (django.request) is\nskipped and exceptions propagate upwards.
This can be useful for some test setups. It shouldn’t be used on a live site\nunless you want your web server (instead of Django) to generate “Internal\nServer Error” responses. In that case, make sure your server doesn’t show the\nstack trace or other sensitive information in the response.
\nDECIMAL_SEPARATORLink para este cabeçalho#Padrão: '.' (.)
Default decimal separator used when formatting decimal numbers.
\nNote that if USE_L10N is set to True, then the locale-dictated\nformat has higher precedence and will be applied instead.
See also NUMBER_GROUPING, THOUSAND_SEPARATOR and\nUSE_THOUSAND_SEPARATOR.
DEFAULT_CHARSETLink para este cabeçalho#Padrão: 'utf-8'
Default charset to use for all HttpResponse objects, if a MIME type isn’t\nmanually specified. Used with DEFAULT_CONTENT_TYPE to construct the\nContent-Type header.
DEFAULT_CONTENT_TYPELink para este cabeçalho#Padrão: 'text/html'
Default content type to use for all HttpResponse objects, if a MIME type\nisn’t manually specified. Used with DEFAULT_CHARSET to construct\nthe Content-Type header.
DEFAULT_EXCEPTION_REPORTER_FILTERLink para este cabeçalho#Default: 'django.views.debug.SafeExceptionReporterFilter'
Default exception reporter filter class to be used if none has been assigned to\nthe HttpRequest instance yet.\nSee Filtering error reports.
DEFAULT_FILE_STORAGELink para este cabeçalho#Default: 'django.core.files.storage.FileSystemStorage'
Default file storage class to be used for any file-related operations that don’t\nspecify a particular storage system. See Managing files.
\nDEFAULT_FROM_EMAILLink para este cabeçalho#Padrão: 'webmaster@localhost'
Default email address to use for various automated correspondence from the\nsite manager(s). This doesn’t include error messages sent to ADMINS\nand MANAGERS; for that, see SERVER_EMAIL.
DEFAULT_INDEX_TABLESPACELink para este cabeçalho#Default: '' (Empty string)
Default tablespace to use for indexes on fields that don’t specify\none, if the backend supports it (see Tablespaces).
\nDEFAULT_TABLESPACELink para este cabeçalho#Default: '' (Empty string)
Default tablespace to use for models that don’t specify one, if the\nbackend supports it (see Tablespaces).
\nDISALLOWED_USER_AGENTSLink para este cabeçalho#Default: [] (Empty list)
List of compiled regular expression objects representing User-Agent strings\nthat are not allowed to visit any page, systemwide. Use this for bots/crawlers.\nThis is only used if CommonMiddleware is installed (see\nMiddleware).
EMAIL_BACKENDLink para este cabeçalho#Padrão: 'django.core.mail.backends.smtp.EmailBackend'
O “backend” para usar para enviar emails. Para a lista de “backends”disponíveis veja Enviando e-mail.
\nEMAIL_FILE_PATHLink para este cabeçalho#Default: Not defined
\nThe directory used by the file email backend to store output files.
EMAIL_HOSTLink para este cabeçalho#Padrão: 'localhost'
The host to use for sending email.
\nVeja também EMAIL_PORT.
EMAIL_HOST_PASSWORDLink para este cabeçalho#Default: '' (Empty string)
Password to use for the SMTP server defined in EMAIL_HOST. This\nsetting is used in conjunction with EMAIL_HOST_USER when\nauthenticating to the SMTP server. If either of these settings is empty,\nDjango won’t attempt authentication.
See also EMAIL_HOST_USER.
EMAIL_HOST_USERLink para este cabeçalho#Default: '' (Empty string)
Username to use for the SMTP server defined in EMAIL_HOST.\nIf empty, Django won’t attempt authentication.
Veja também EMAIL_HOST_PASSWORD.
EMAIL_PORTLink para este cabeçalho#Padrão: 25
Port to use for the SMTP server defined in EMAIL_HOST.
EMAIL_SUBJECT_PREFIXLink para este cabeçalho#Padrão: '[Django] '
Subject-line prefix for email messages sent with django.core.mail.mail_admins\nor django.core.mail.mail_managers. You’ll probably want to include the\ntrailing space.
EMAIL_USE_LOCALTIMELink para este cabeçalho#Default: False
Whether to send the SMTP Date header of email messages in the local time\nzone (True) or in UTC (False).
EMAIL_USE_TLSLink para este cabeçalho#Default: False
Whether to use a TLS (secure) connection when talking to the SMTP server.\nThis is used for explicit TLS connections, generally on port 587. If you are\nexperiencing hanging connections, see the implicit TLS setting\nEMAIL_USE_SSL.
EMAIL_USE_SSLLink para este cabeçalho#Default: False
Whether to use an implicit TLS (secure) connection when talking to the SMTP\nserver. In most email documentation this type of TLS connection is referred\nto as SSL. It is generally used on port 465. If you are experiencing problems,\nsee the explicit TLS setting EMAIL_USE_TLS.
Note that EMAIL_USE_TLS/EMAIL_USE_SSL are mutually\nexclusive, so only set one of those settings to True.
EMAIL_SSL_CERTFILELink para este cabeçalho#Default: None
If EMAIL_USE_SSL or EMAIL_USE_TLS is True, you can\noptionally specify the path to a PEM-formatted certificate chain file to use\nfor the SSL connection.
EMAIL_SSL_KEYFILELink para este cabeçalho#Default: None
If EMAIL_USE_SSL or EMAIL_USE_TLS is True, you can\noptionally specify the path to a PEM-formatted private key file to use for the\nSSL connection.
Note that setting EMAIL_SSL_CERTFILE and EMAIL_SSL_KEYFILE\ndoesn’t result in any certificate checking. They’re passed to the underlying SSL\nconnection. Please refer to the documentation of Python’s\npython:ssl.wrap_socket() function for details on how the certificate chain\nfile and private key file are handled.
EMAIL_TIMEOUTLink para este cabeçalho#Default: None
Specifies a timeout in seconds for blocking operations like the connection\nattempt.
\nFILE_CHARSETLink para este cabeçalho#Padrão: 'utf-8'
The character encoding used to decode any files read from disk. This includes\ntemplate files and initial SQL data files.
\nFILE_UPLOAD_HANDLERSLink para este cabeçalho#Padrão:
\n[\n 'django.core.files.uploadhandler.MemoryFileUploadHandler',\n 'django.core.files.uploadhandler.TemporaryFileUploadHandler',\n]\nA list of handlers to use for uploading. Changing this setting allows complete\ncustomization – even replacement – of Django’s upload process.
\nVeja Managing files para detalhes.
\nFILE_UPLOAD_MAX_MEMORY_SIZELink para este cabeçalho#Padrão: 2621440 (i.e. 2.5 MB).
The maximum size (in bytes) that an upload will be before it gets streamed to\nthe file system. See Managing files for details.
\nSee also DATA_UPLOAD_MAX_MEMORY_SIZE.
FILE_UPLOAD_DIRECTORY_PERMISSIONSLink para este cabeçalho#Default: None
The numeric mode to apply to directories created in the process of uploading\nfiles.
\nThis setting also determines the default permissions for collected static\ndirectories when using the collectstatic management command. See\ncollectstatic for details on overriding it.
This value mirrors the functionality and caveats of the\nFILE_UPLOAD_PERMISSIONS setting.
FILE_UPLOAD_PERMISSIONSLink para este cabeçalho#Default: None
The numeric mode (i.e. 0o644) to set newly uploaded files to. For\nmore information about what these modes mean, see the documentation for\nos.chmod().
If this isn’t given or is None, you’ll get operating-system\ndependent behavior. On most platforms, temporary files will have a mode\nof 0o600, and files saved from memory will be saved using the\nsystem’s standard umask.
For security reasons, these permissions aren’t applied to the temporary files\nthat are stored in FILE_UPLOAD_TEMP_DIR.
This setting also determines the default permissions for collected static files\nwhen using the collectstatic management command. See\ncollectstatic for details on overriding it.
FILE_UPLOAD_TEMP_DIRLink para este cabeçalho#Default: None
The directory to store data to (typically files larger than\nFILE_UPLOAD_MAX_MEMORY_SIZE) temporarily while uploading files.\nIf None, Django will use the standard temporary directory for the operating\nsystem. For example, this will default to /tmp on *nix-style operating\nsystems.
Veja Managing files para detalhes.
\nFIRST_DAY_OF_WEEKLink para este cabeçalho#Padrão: 0 (Domingo)
A number representing the first day of the week. This is especially useful\nwhen displaying a calendar. This value is only used when not using\nformat internationalization, or when a format cannot be found for the\ncurrent locale.
\nThe value must be an integer from 0 to 6, where 0 means Sunday, 1 means\nMonday and so on.
\nFIXTURE_DIRSLink para este cabeçalho#Default: [] (Empty list)
List of directories searched for fixture files, in addition to the\nfixtures directory of each application, in search order.
Note that these paths should use Unix-style forward slashes, even on Windows.
\n\nFORCE_SCRIPT_NAMELink para este cabeçalho#Default: None
If not None, this will be used as the value of the SCRIPT_NAME\nenvironment variable in any HTTP request. This setting can be used to override\nthe server-provided value of SCRIPT_NAME, which may be a rewritten version\nof the preferred value or not supplied at all. It is also used by\ndjango.setup() to set the URL resolver script prefix outside of the\nrequest/response cycle (e.g. in management commands and standalone scripts) to\ngenerate correct URLs when SCRIPT_NAME is not /.
FORM_RENDERERLink para este cabeçalho#Default: 'django.forms.renderers.DjangoTemplates'
The class that renders form widgets. It must implement the low-level\nrender API.
\nFORMAT_MODULE_PATHLink para este cabeçalho#Default: None
A full Python path to a Python package that contains custom format definitions\nfor project locales. If not None, Django will check for a formats.py\nfile, under the directory named as the current locale, and will use the\nformats defined in this file.
For example, if FORMAT_MODULE_PATH is set to mysite.formats,\nand current language is en (English), Django will expect a directory tree\nlike:
mysite/\n formats/\n __init__.py\n en/\n __init__.py\n formats.py\nYou can also set this setting to a list of Python paths, for example:
\nFORMAT_MODULE_PATH = [\n 'mysite.formats',\n 'some_app.formats',\n]\nWhen Django searches for a certain format, it will go through all given Python\npaths until it finds a module that actually defines the given format. This\nmeans that formats defined in packages farther up in the list will take\nprecedence over the same formats in packages farther down.
\nAvailable formats are:
\n\nIGNORABLE_404_URLSLink para este cabeçalho#Default: [] (Empty list)
List of compiled regular expression objects describing URLs that should be\nignored when reporting HTTP 404 errors via email (see\nRelatório de erro). Regular expressions are matched against\nrequest's full paths (including\nquery string, if any). Use this if your site does not provide a commonly\nrequested file such as favicon.ico or robots.txt.
This is only used if\nBrokenLinkEmailsMiddleware is enabled (see\nMiddleware).
INSTALLED_APPSLink para este cabeçalho#Default: [] (Empty list)
A list of strings designating all applications that are enabled in this\nDjango installation. Each string should be a dotted Python path to:
\nan application configuration class (preferred), or
a package containing an application.
Learn more about application configurations.
\n\n\nWhen several applications provide different versions of the same resource\n(template, static file, management command, translation), the application\nlisted first in INSTALLED_APPS has precedence.
INTERNAL_IPSLink para este cabeçalho#Default: [] (Empty list)
A list of IP addresses, as strings, that:
\nAllow the debug() context processor\nto add some variables to the template context.
Can use the admindocs bookmarklets even if\nnot logged in as a staff user.
Are marked as “internal” (as opposed to “EXTERNAL”) in\nAdminEmailHandler emails.
LANGUAGE_CODELink para este cabeçalho#Padrão: 'en-us'
A string representing the language code for this installation. This should be in\nstandard language ID format. For example, U.S. English\nis "en-us". See also the list of language identifiers and\nInternacionalização e localização.
USE_I18N must be active for this setting to have any effect.
It serves two purposes:
\nIf the locale middleware isn’t in use, it decides which translation is served\nto all users.
If the locale middleware is active, it provides a fallback language in case the\nuser’s preferred language can’t be determined or is not supported by the\nwebsite. It also provides the fallback translation when a translation for a\ngiven literal doesn’t exist for the user’s preferred language.
See How Django discovers language preference for more details.
\nLANGUAGESLink para este cabeçalho#Default: A list of all available languages. This list is continually growing\nand including a copy here would inevitably become rapidly out of date. You can\nsee the current list of translated languages by looking in\ndjango/conf/global_settings.py (or view the online source).
The list is a list of two-tuples in the format\n(language code, language name) – for example,\n('ja', 'Japanese').\nThis specifies which languages are available for language selection. See\nInternacionalização e localização.
Generally, the default value should suffice. Only set this setting if you want\nto restrict language selection to a subset of the Django-provided languages.
\nIf you define a custom LANGUAGES setting, you can mark the\nlanguage names as translation strings using the\ngettext_lazy() function.
Here’s a sample settings file:
\nfrom django.utils.translation import gettext_lazy as _\n\nLANGUAGES = [\n ('de', _('German')),\n ('en', _('English')),\n]\nLOCALE_PATHSLink para este cabeçalho#Default: [] (Empty list)
A list of directories where Django looks for translation files.\nSee How Django discovers translations.
\nExemplo
\nLOCALE_PATHS = [\n '/home/www/project/common_files/locale',\n '/var/local/translations/locale',\n]\nDjango will look within each of these paths for the <locale_code>/LC_MESSAGES\ndirectories containing the actual translation files.
LOGGINGLink para este cabeçalho#Default: A logging configuration dictionary.
\nA data structure containing configuration information. The contents of\nthis data structure will be passed as the argument to the\nconfiguration method described in LOGGING_CONFIG.
Among other things, the default logging configuration passes HTTP 500 server\nerrors to an email log handler when DEBUG is False. See also\nConfiguring logging.
You can see the default logging configuration by looking in\ndjango/utils/log.py (or view the online source).
LOGGING_CONFIGLink para este cabeçalho#Padrão: 'logging.config.dictConfig'
A path to a callable that will be used to configure logging in the\nDjango project. Points at an instance of Python’s dictConfig configuration method by default.
\nIf you set LOGGING_CONFIG to None, the logging\nconfiguration process will be skipped.
MANAGERSLink para este cabeçalho#Default: [] (Empty list)
A list in the same format as ADMINS that specifies who should get\nbroken link notifications when\nBrokenLinkEmailsMiddleware is enabled.
MEDIA_ROOTLink para este cabeçalho#Default: '' (Empty string)
Absolute filesystem path to the directory that will hold user-uploaded\nfiles.
\nExample: "/var/www/example.com/media/"
See also MEDIA_URL.
MEDIA_URLLink para este cabeçalho#Default: '' (Empty string)
URL that handles the media served from MEDIA_ROOT, used\nfor managing stored files. It must end in a slash if set\nto a non-empty value. You will need to configure these files to be served in both development and production\nenvironments.
If you want to use {{ MEDIA_URL }} in your templates, add\n'django.template.context_processors.media' in the 'context_processors'\noption of TEMPLATES.
Example: "http://media.example.com/"
MIDDLEWARELink para este cabeçalho#Default: None
A list of middleware to use. See Middleware.
\nMIGRATION_MODULESLink para este cabeçalho#Default: {} (Empty dictionary)
A dictionary specifying the package where migration modules can be found on a\nper-app basis. The default value of this setting is an empty dictionary, but\nthe default package name for migration modules is migrations.
Exemplo
\n{'blog': 'blog.db_migrations'}\nIn this case, migrations pertaining to the blog app will be contained in\nthe blog.db_migrations package.
If you provide the app_label argument, makemigrations will\nautomatically create the package if it doesn’t already exist.
When you supply None as a value for an app, Django will consider the app as\nan app without migrations regardless of an existing migrations submodule.\nThis can be used, for example, in a test settings file to skip migrations while\ntesting (tables will still be created for the apps’ models). If this is used in\nyour general project settings, remember to use the migrate\n--run-syncdb option if you want to create tables for the app.
MONTH_DAY_FORMATLink para este cabeçalho#Padrão: 'F j'
The default formatting to use for date fields on Django admin change-list\npages – and, possibly, by other parts of the system – in cases when only the\nmonth and day are displayed.
\nFor example, when a Django admin change-list page is being filtered by a date\ndrilldown, the header for a given day displays the day and month. Different\nlocales have different formats. For example, U.S. English would say\n“January 1,” whereas Spanish might say “1 Enero.”
\nNote that if USE_L10N is set to True, then the corresponding\nlocale-dictated format has higher precedence and will be applied.
See allowed date format strings. See also\nDATE_FORMAT, DATETIME_FORMAT,\nTIME_FORMAT and YEAR_MONTH_FORMAT.
NUMBER_GROUPINGLink para este cabeçalho#Default: 0
Number of digits grouped together on the integer part of a number.
\nCommon use is to display a thousand separator. If this setting is 0, then\nno grouping will be applied to the number. If this setting is greater than\n0, then THOUSAND_SEPARATOR will be used as the separator between\nthose groups.
Some locales use non-uniform digit grouping, e.g. 10,00,00,000 in\nen_IN. For this case, you can provide a sequence with the number of digit\ngroup sizes to be applied. The first number defines the size of the group\npreceding the decimal delimiter, and each number that follows defines the size\nof preceding groups. If the sequence is terminated with -1, no further\ngrouping is performed. If the sequence terminates with a 0, the last group\nsize is used for the remainder of the number.
Example tuple for en_IN:
NUMBER_GROUPING = (3, 2, 0)\nNote that if USE_L10N is set to True, then the locale-dictated\nformat has higher precedence and will be applied instead.
See also DECIMAL_SEPARATOR, THOUSAND_SEPARATOR and\nUSE_THOUSAND_SEPARATOR.
PREPEND_WWWLink para este cabeçalho#Default: False
Whether to prepend the “www.” subdomain to URLs that don’t have it. This is only\nused if CommonMiddleware is installed\n(see Middleware). See also APPEND_SLASH.
ROOT_URLCONFLink para este cabeçalho#Default: Not defined
\nA string representing the full Python import path to your root URLconf, for\nexample "mydjangoapps.urls". Can be overridden on a per-request basis by\nsetting the attribute urlconf on the incoming HttpRequest\nobject. See Como o Django processa uma requisição for details.
SECRET_KEYLink para este cabeçalho#Default: '' (Empty string)
A secret key for a particular Django installation. This is used to provide\ncryptographic signing, and should be set to a unique,\nunpredictable value.
\ndjango-admin startproject automatically adds a\nrandomly-generated SECRET_KEY to each new project.
Uses of the key shouldn’t assume that it’s text or bytes. Every use should go\nthrough force_text() or\nforce_bytes() to convert it to the desired type.
Django will refuse to start if SECRET_KEY is not set.
A chave secreta é usada para:
\nAll sessions if you are using\nany other session backend than django.contrib.sessions.backends.cache,\nor are using the default\nget_session_auth_hash().
All messages if you are using\nCookieStorage or\nFallbackStorage.
All PasswordResetView tokens.
Any usage of cryptographic signing, unless a\ndifferent key is provided.
If you rotate your secret key, all of the above will be invalidated.\nSecret keys are not used for passwords of users and key rotation will not\naffect them.
\n\nSECURE_BROWSER_XSS_FILTERLink para este cabeçalho#Default: False
If True, the SecurityMiddleware sets\nthe X-XSS-Protection: 1; mode=block header on all responses that do not already have it.
SECURE_CONTENT_TYPE_NOSNIFFLink para este cabeçalho#Default: False
If True, the SecurityMiddleware\nsets the X-Content-Type-Options: nosniff header on all responses that do not\nalready have it.
SECURE_HSTS_INCLUDE_SUBDOMAINSLink para este cabeçalho#Default: False
If True, the SecurityMiddleware adds\nthe includeSubDomains directive to the HTTP Strict Transport Security\nheader. It has no effect unless SECURE_HSTS_SECONDS is set to a\nnon-zero value.
SECURE_HSTS_PRELOADLink para este cabeçalho#Default: False
If True, the SecurityMiddleware adds\nthe preload directive to the HTTP Strict Transport Security\nheader. It has no effect unless SECURE_HSTS_SECONDS is set to a\nnon-zero value.
SECURE_HSTS_SECONDSLink para este cabeçalho#Default: 0
If set to a non-zero integer value, the\nSecurityMiddleware sets the\nHTTP Strict Transport Security header on all responses that do not\nalready have it.
SECURE_PROXY_SSL_HEADERLink para este cabeçalho#Default: None
A tuple representing a HTTP header/value combination that signifies a request\nis secure. This controls the behavior of the request object’s is_secure()\nmethod.
By default, is_secure() determines if a request is secure by confirming\nthat a requested URL uses https://. This method is important for Django’s\nCSRF protection, and it 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”\nwhether the original request uses HTTPS or not. If there is a non-HTTPS\nconnection between the proxy and Django then is_secure() would always\nreturn False – even for requests that were made via HTTPS by the end user.\nIn contrast, if there is an HTTPS connection between the proxy and Django then\nis_secure() would always return True – even for requests that were\nmade originally via HTTP.
In this situation, configure your proxy to set a custom HTTP header that tells\nDjango whether the request came in via HTTPS, and set\nSECURE_PROXY_SSL_HEADER so that Django knows what header to look for.
Set a tuple with two elements – the name of the header to look for and the\nrequired value. For example:
\nSECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')\nThis tells Django to trust the X-Forwarded-Proto header that comes from our\nproxy, and any time its value is 'https', then the request is guaranteed to\nbe secure (i.e., it originally came in via HTTPS).
You should only set this setting if you control your proxy or have some other\nguarantee that it sets/strips this header appropriately.
\nNote that the header needs to be in the format as used by request.META –\nall caps and likely starting with HTTP_. (Remember, Django automatically\nadds 'HTTP_' to the start of x-header names before making the header\navailable in request.META.)
SECURE_REDIRECT_EXEMPTLink para este cabeçalho#Default: [] (Empty list)
If a URL path matches a regular expression in this list, the request will not be\nredirected to HTTPS. If SECURE_SSL_REDIRECT is False, this\nsetting has no effect.
SECURE_SSL_HOSTLink para este cabeçalho#Default: None
If a string (e.g. secure.example.com), all SSL redirects will be directed\nto this host rather than the originally-requested host\n(e.g. www.example.com). If SECURE_SSL_REDIRECT is False, this\nsetting has no effect.
SECURE_SSL_REDIRECTLink para este cabeçalho#Default: False
If True, the SecurityMiddleware\nredirects all non-HTTPS requests to HTTPS (except for\nthose URLs matching a regular expression listed in\nSECURE_REDIRECT_EXEMPT).
SERIALIZATION_MODULESLink para este cabeçalho#Default: Not defined
\nA dictionary of modules containing serializer definitions (provided as\nstrings), keyed by a string identifier for that serialization type. For\nexample, to define a YAML serializer, use:
\nSERIALIZATION_MODULES = {'yaml': 'path.to.yaml_serializer'}\nSERVER_EMAILLink para este cabeçalho#Padrão: 'root@localhost'
The email address that error messages come from, such as those sent to\nADMINS and MANAGERS.
SHORT_DATE_FORMATLink para este cabeçalho#Padrão: 'm/d/Y' (e.g. 12/31/2003)
An available formatting that can be used for displaying date fields on\ntemplates. Note that if USE_L10N is set to True, then the\ncorresponding locale-dictated format has higher precedence and will be applied.\nSee allowed date format strings.
Veja também DATE_FORMAT e SHORT_DATETIME_FORMAT.
SHORT_DATETIME_FORMATLink para este cabeçalho#Padrão: 'm/d/Y P' (e.g. 12/31/2003 4 p.m.)
An available formatting that can be used for displaying datetime fields on\ntemplates. Note that if USE_L10N is set to True, then the\ncorresponding locale-dictated format has higher precedence and will be applied.\nSee allowed date format strings.
See also DATE_FORMAT and SHORT_DATE_FORMAT.
SIGNING_BACKENDLink para este cabeçalho#Default: 'django.core.signing.TimestampSigner'
The backend used for signing cookies and other data.
\nSee also the Cryptographic signing documentation.
\nSILENCED_SYSTEM_CHECKSLink para este cabeçalho#Default: [] (Empty list)
A list of identifiers of messages generated by the system check framework\n(i.e. ["models.W001"]) that you wish to permanently acknowledge and ignore.\nSilenced checks will not be output to the console.
Veja também a O framework de verificação do sistema. documentação.
\nTEMPLATESLink para este cabeçalho#Default: [] (Empty list)
A list containing the settings for all template engines to be used with\nDjango. Each item of the list is a dictionary containing the options for an\nindividual engine.
\nHere’s a simple setup that tells the Django template engine to load templates\nfrom the templates subdirectory inside each installed application:
TEMPLATES = [\n {\n 'BACKEND': 'django.template.backends.django.DjangoTemplates',\n 'APP_DIRS': True,\n },\n]\nThe following options are available for all backends.
\nBACKENDLink para este cabeçalho#Default: Not defined
\nThe template backend to use. The built-in template backends are:
\n'django.template.backends.django.DjangoTemplates'
'django.template.backends.jinja2.Jinja2'
You can use a template backend that doesn’t ship with Django by setting\nBACKEND to a fully-qualified path (i.e. 'mypackage.whatever.Backend').
NAMELink para este cabeçalho#Padrão: veja abaixo
\nThe alias for this particular template engine. It’s an identifier that allows\nselecting an engine for rendering. Aliases must be unique across all\nconfigured template engines.
\nIt defaults to the name of the module defining the engine class, i.e. the\nnext to last piece of BACKEND, when it isn’t\nprovided. For example if the backend is 'mypackage.whatever.Backend' then\nits default name is 'whatever'.
DIRSLink para este cabeçalho#Default: [] (Empty list)
Directories where the engine should look for template source files, in search\norder.
\nAPP_DIRSLink para este cabeçalho#Default: False
Whether the engine should look for template source files inside installed\napplications.
\n\nOPTIONSLink para este cabeçalho#Default: {} (Empty dict)
Extra parameters to pass to the template backend. Available parameters vary\ndepending on the template backend. See\nDjangoTemplates and\nJinja2 for the options of the\nbuilt-in backends.
TEST_RUNNERLink para este cabeçalho#Default: 'django.test.runner.DiscoverRunner'
The name of the class to use for starting the test suite. See\nUsing different testing frameworks.
\nTEST_NON_SERIALIZED_APPSLink para este cabeçalho#Default: [] (Empty list)
In order to restore the database state between tests for\nTransactionTestCases and database backends without transactions, Django\nwill serialize the contents of all apps\nwhen it starts the test run so it can then reload from that copy before running\ntests that need it.
This slows down the startup time of the test runner; if you have apps that\nyou know don’t need this feature, you can add their full names in here (e.g.\n'django.contrib.contenttypes') to exclude them from this serialization\nprocess.
THOUSAND_SEPARATORLink para este cabeçalho#Default: ',' (Comma)
Default thousand separator used when formatting numbers. This setting is\nused only when USE_THOUSAND_SEPARATOR is True and\nNUMBER_GROUPING is greater than 0.
Note that if USE_L10N is set to True, then the locale-dictated\nformat has higher precedence and will be applied instead.
See also NUMBER_GROUPING, DECIMAL_SEPARATOR and\nUSE_THOUSAND_SEPARATOR.
TIME_FORMATLink para este cabeçalho#Default: 'P' (e.g. 4 p.m.)
The default formatting to use for displaying time fields in any part of the\nsystem. Note that if USE_L10N is set to True, then the\nlocale-dictated format has higher precedence and will be applied instead. See\nallowed date format strings.
See also DATE_FORMAT and DATETIME_FORMAT.
TIME_INPUT_FORMATSLink para este cabeçalho#Padrão:
\n[\n '%H:%M:%S', # '14:30:59'\n '%H:%M:%S.%f', # '14:30:59.000200'\n '%H:%M', # '14:30'\n]\nA list of formats that will be accepted when inputting data on a time field.\nFormats will be tried in order, using the first valid one. Note that these\nformat strings use Python’s datetime module syntax, not the format strings from the date\ntemplate filter.
When USE_L10N is True, the locale-dictated format has higher\nprecedence and will be applied instead.
See also DATE_INPUT_FORMATS and DATETIME_INPUT_FORMATS.
TIME_ZONELink para este cabeçalho#Default: 'America/Chicago'
A string representing the time zone for this installation. See the list of\ntime zones.
\n\nNote that this isn’t necessarily the time zone of the server. For example, one\nserver may serve multiple Django-powered sites, each with a separate time zone\nsetting.
\nWhen USE_TZ is False, this is the time zone in which Django\nwill store all datetimes. When USE_TZ is True, this is the\ndefault time zone that Django will use to display datetimes in templates and\nto interpret datetimes entered in forms.
On Unix environments (where time.tzset() is implemented), Django sets the\nos.environ['TZ'] variable to the time zone you specify in the\nTIME_ZONE setting. Thus, all your views and models will\nautomatically operate in this time zone. However, Django won’t set the TZ\nenvironment variable if you’re using the manual configuration option as\ndescribed in manually configuring settings. If Django doesn’t set the TZ\nenvironment variable, it’s up to you to ensure your processes are running in\nthe correct environment.
USE_I18NLink para este cabeçalho#Default: True
A boolean that specifies whether Django’s translation system should be enabled.\nThis provides an easy way to turn it off, for performance. If this is set to\nFalse, Django will make some optimizations so as not to load the\ntranslation machinery.
See also LANGUAGE_CODE, USE_L10N and USE_TZ.
USE_L10NLink para este cabeçalho#Default: False
A boolean that specifies if localized formatting of data will be enabled by\ndefault or not. If this is set to True, e.g. Django will display numbers and\ndates using the format of the current locale.
See also LANGUAGE_CODE, USE_I18N and USE_TZ.
USE_THOUSAND_SEPARATORLink para este cabeçalho#Default: False
A boolean that specifies whether to display numbers using a thousand separator.\nWhen USE_L10N is set to True and if this is also set to\nTrue, Django will use the values of THOUSAND_SEPARATOR and\nNUMBER_GROUPING to format numbers unless the locale already has an\nexisting thousands separator. If there is a thousands separator in the locale\nformat, it will have higher precedence and will be applied instead.
See also DECIMAL_SEPARATOR, NUMBER_GROUPING and\nTHOUSAND_SEPARATOR.
USE_TZLink para este cabeçalho#Default: False
A boolean that specifies if datetimes will be timezone-aware by default or not.\nIf this is set to True, Django will use timezone-aware datetimes internally.\nOtherwise, Django will use naive datetimes in local time.
USE_X_FORWARDED_HOSTLink para este cabeçalho#Default: False
A boolean that specifies whether to use the X-Forwarded-Host header in\npreference to the Host header. This should only be enabled if a proxy\nwhich sets this header is in use.
This setting takes priority over USE_X_FORWARDED_PORT. Per\nRFC 7239 Page 7, the X-Forwarded-Host header can include the port\nnumber, in which case you shouldn’t use USE_X_FORWARDED_PORT.
USE_X_FORWARDED_PORTLink para este cabeçalho#Default: False
A boolean that specifies whether to use the X-Forwarded-Port header in\npreference to the SERVER_PORT META variable. This should only be\nenabled if a proxy which sets this header is in use.
USE_X_FORWARDED_HOST takes priority over this setting.
WSGI_APPLICATIONLink para este cabeçalho#Default: None
The full Python path of the WSGI application object that Django’s built-in\nservers (e.g. runserver) will use. The django-admin\nstartproject management command will create a simple\nwsgi.py file with an application callable in it, and point this setting\nto that application.
If not set, the return value of django.core.wsgi.get_wsgi_application()\nwill be used. In this case, the behavior of runserver will be\nidentical to previous Django versions.
YEAR_MONTH_FORMATLink para este cabeçalho#Padrão: 'F Y'
The default formatting to use for date fields on Django admin change-list\npages – and, possibly, by other parts of the system – in cases when only the\nyear and month are displayed.
\nFor example, when a Django admin change-list page is being filtered by a date\ndrilldown, the header for a given month displays the month and the year.\nDifferent locales have different formats. For example, U.S. English would say\n“January 2006,” whereas another locale might say “2006/January.”
\nNote that if USE_L10N is set to True, then the corresponding\nlocale-dictated format has higher precedence and will be applied.
See allowed date format strings. See also\nDATE_FORMAT, DATETIME_FORMAT, TIME_FORMAT\nand MONTH_DAY_FORMAT.
X_FRAME_OPTIONSLink para este cabeçalho#Padrão: 'SAMEORIGIN'
The default value for the X-Frame-Options header used by\nXFrameOptionsMiddleware. See the\nclickjacking protection documentation.
Configurações para django.contrib.auth.
AUTHENTICATION_BACKENDSLink para este cabeçalho#Default: ['django.contrib.auth.backends.ModelBackend']
A list of authentication backend classes (as strings) to use when attempting to\nauthenticate a user. See the authentication backends documentation for details.
\nAUTH_USER_MODELLink para este cabeçalho#Padrão: 'auth.User'
The model to use to represent a User. See Substituindo um modelo de Usuário personalizado.
\n\nLOGIN_REDIRECT_URLLink para este cabeçalho#Padrão: '/accounts/profile/'
The URL where requests are redirected after login when the\ncontrib.auth.login view gets no next parameter.
This is used by the login_required()\ndecorator, for example.
This setting also accepts named URL patterns which\ncan be used to reduce configuration duplication since you don’t have to define\nthe URL in two places (settings and URLconf).
LOGIN_URLLink para este cabeçalho#Padrão: '/accounts/login/'
The URL where requests are redirected for login, especially when using the\nlogin_required() decorator.
This setting also accepts named URL patterns which\ncan be used to reduce configuration duplication since you don’t have to define\nthe URL in two places (settings and URLconf).
LOGOUT_REDIRECT_URLLink para este cabeçalho#Default: None
The URL where requests are redirected after a user logs out using\nLogoutView (if the view doesn’t get a\nnext_page argument).
If None, no redirect will be performed and the logout view will be\nrendered.
This setting also accepts named URL patterns which\ncan be used to reduce configuration duplication since you don’t have to define\nthe URL in two places (settings and URLconf).
PASSWORD_RESET_TIMEOUT_DAYSLink para este cabeçalho#Padrão: 3
The minimum number of days a password reset link is valid for. Depending on\nwhen the link is generated, it will be valid for up to a day longer.
\nUsed by the PasswordResetConfirmView.
PASSWORD_HASHERSLink para este cabeçalho#Veja Como o Django armazena as senhas.
\nPadrão:
\n[\n 'django.contrib.auth.hashers.PBKDF2PasswordHasher',\n 'django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher',\n 'django.contrib.auth.hashers.Argon2PasswordHasher',\n 'django.contrib.auth.hashers.BCryptSHA256PasswordHasher',\n]\nAUTH_PASSWORD_VALIDATORSLink para este cabeçalho#Default: [] (Empty list)
The list of validators that are used to check the strength of user’s passwords.\nSee Validação de senha for more details. By default, no validation is\nperformed and all passwords are accepted.
\nConfigurações para django.contrib.messages.
MESSAGE_LEVELLink para este cabeçalho#Padrão: messages.INFO
Sets the minimum message level that will be recorded by the messages\nframework. See message levels for more details.
\n\nMESSAGE_STORAGELink para este cabeçalho#Default: 'django.contrib.messages.storage.fallback.FallbackStorage'
Controls where Django stores message data. Valid values are:
\n'django.contrib.messages.storage.fallback.FallbackStorage'
'django.contrib.messages.storage.session.SessionStorage'
'django.contrib.messages.storage.cookie.CookieStorage'
See message storage backends for more details.
\nThe backends that use cookies –\nCookieStorage and\nFallbackStorage –\nuse the value of SESSION_COOKIE_DOMAIN, SESSION_COOKIE_SECURE\nand SESSION_COOKIE_HTTPONLY when setting their cookies.
Configurações para django.contrib.sessions.
SESSION_CACHE_ALIASLink para este cabeçalho#Padrão: 'default'
If you’re using cache-based session storage,\nthis selects the cache to use.
\nSESSION_ENGINELink para este cabeçalho#Default: 'django.contrib.sessions.backends.db'
Controls where Django stores session data. Included engines are:
\n'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'
Veja Configuring the session engine para mais detalhes
\nSESSION_EXPIRE_AT_BROWSER_CLOSELink para este cabeçalho#Default: False
Whether to expire the session when the user closes their browser. See\nBrowser-length sessions vs. persistent sessions.
\nSESSION_FILE_PATHLink para este cabeçalho#Default: None
If you’re using file-based session storage, this sets the directory in\nwhich Django will store session data. When the default value (None) is\nused, Django will use the standard temporary directory for the system.
SESSION_SAVE_EVERY_REQUESTLink para este cabeçalho#Default: False
Whether to save the session data on every request. If this is False\n(default), then the session data will only be saved if it has been modified –\nthat is, if any of its dictionary values have been assigned or deleted. Empty\nsessions won’t be created, even if this setting is active.
SESSION_SERIALIZERLink para este cabeçalho#Default: 'django.contrib.sessions.serializers.JSONSerializer'
Full import path of a serializer class to use for serializing session data.\nIncluded serializers are:
\n'django.contrib.sessions.serializers.PickleSerializer'
'django.contrib.sessions.serializers.JSONSerializer'
See Session serialization for details, including a warning regarding\npossible remote code execution when using\nPickleSerializer.
Settings for django.contrib.sites.
SITE_IDLink para este cabeçalho#Default: Not defined
\nThe ID, as an integer, of the current site in the django_site database\ntable. This is used so that application data can hook into specific sites\nand a single database can manage content for multiple sites.
Settings for django.contrib.staticfiles.
STATIC_ROOTLink para este cabeçalho#Default: None
The absolute path to the directory where collectstatic will collect\nstatic files for deployment.
Example: "/var/www/example.com/static/"
If the staticfiles contrib app is enabled\n(as in the default project template), the collectstatic management\ncommand will collect static files into this directory. See the how-to on\nmanaging static files for more details about\nusage.
STATIC_URLLink para este cabeçalho#Default: None
URL to use when referring to static files located in STATIC_ROOT.
Example: "/static/" or "http://static.example.com/"
If not None, this will be used as the base path for\nasset definitions (the Media class) and the\nstaticfiles app.
It must end in a slash if set to a non-empty value.
\nYou may need to configure these files to be served in development and will definitely need to do so\nin production.
\nSTATICFILES_DIRSLink para este cabeçalho#Default: [] (Empty list)
This setting defines the additional locations the staticfiles app will traverse\nif the FileSystemFinder finder is enabled, e.g. if you use the\ncollectstatic or findstatic management command or use the\nstatic file serving view.
This should be set to a list of strings that contain full paths to\nyour additional files directory(ies) e.g.:
\nSTATICFILES_DIRS = [\n "/home/special.polls.com/polls/static",\n "/home/polls.com/polls/static",\n "/opt/webfiles/common",\n]\nNote that these paths should use Unix-style forward slashes, even on Windows\n(e.g. "C:/Users/user/mysite/extra_static_content").
In case you want to refer to files in one of the locations with an additional\nnamespace, you can optionally provide a prefix as (prefix, path)\ntuples, e.g.:
STATICFILES_DIRS = [\n # ...\n ("downloads", "/opt/webfiles/stats"),\n]\nFor example, assuming you have STATIC_URL set to '/static/', the\ncollectstatic management command would collect the “stats” files\nin a 'downloads' subdirectory of STATIC_ROOT.
This would allow you to refer to the local file\n'/opt/webfiles/stats/polls_20101022.tar.gz' with\n'/static/downloads/polls_20101022.tar.gz' in your templates, e.g.:
<a href="{% static "downloads/polls_20101022.tar.gz" %}">\nSTATICFILES_STORAGELink para este cabeçalho#Default: 'django.contrib.staticfiles.storage.StaticFilesStorage'
The file storage engine to use when collecting static files with the\ncollectstatic management command.
A ready-to-use instance of the storage backend defined in this setting\ncan be found at django.contrib.staticfiles.storage.staticfiles_storage.
For an example, see Servindo arquivos estáticos de um serviço em nuvem ou CDN.
\nSTATICFILES_FINDERSLink para este cabeçalho#Padrão:
\n[\n 'django.contrib.staticfiles.finders.FileSystemFinder',\n 'django.contrib.staticfiles.finders.AppDirectoriesFinder',\n]\nThe list of finder backends that know how to find static files in\nvarious locations.
\nThe default will find files stored in the STATICFILES_DIRS setting\n(using django.contrib.staticfiles.finders.FileSystemFinder) and in a\nstatic subdirectory of each app (using\ndjango.contrib.staticfiles.finders.AppDirectoriesFinder). If multiple\nfiles with the same name are present, the first file that is found will be\nused.
One finder is disabled by default:\ndjango.contrib.staticfiles.finders.DefaultStorageFinder. If added to\nyour STATICFILES_FINDERS setting, it will look for static files in\nthe default file storage as defined by the DEFAULT_FILE_STORAGE\nsetting.
Static file finders are currently considered a private interface, and this\ninterface is thus undocumented.
\ni18n/l10n)Link para este cabeçalho#Segurança
\n\nProteção contra “Cross Site Request Forgery”
\n\nBanco de dados: TEST