ABSOLUTE_URL_OVERRIDES¶

Awalan: {} (Kamus kosong)

A dictionary mapping "app_label.model_name" strings to functions that take a model object and return its URL. This is a way of inserting or overriding get_absolute_url() methods on a per-installation basis. Example:

ABSOLUTE_URL_OVERRIDES = {
    "blogs.blog": lambda o: "/blogs/%s/" % o.slug,
    "news.story": lambda o: "/stories/%s/%s/" % (o.pub_year, o.slug),
}

The model name used in this setting should be all lowercase, regardless of the case of the actual model class name.

ADMINS¶

Awalan: {} (Daftar kosong)

A list of all the people who get code error notifications. When DEBUG=False and AdminEmailHandler is configured in LOGGING (done by default), Django emails these people the details of exceptions raised in the request/response cycle.

Setiap barang dalam daftar harus berupa tuple dari (Nama lengkap, alamat surel). Contoh:

[("John", "john@example.com"), ("Mary", "mary@example.com")]

ALLOWED_HOSTS¶

Awalan: {} (Daftar kosong)

A list of strings representing the host/domain names that this Django site can serve. This is a security measure to prevent HTTP Host header attacks, which are possible even under many seemingly-safe web server configurations.

Nilai-nilai dalam daftar ini dapat berupa sepenuhnya nama-nama berkualitas (misalnya 'www.example.com'), dalam kasus mereka akan cocok terhadap kepala Host permintaan tepatnya (kurang-peka-kasus, tidak termasuk port). Sebuah nilai dimulai dengan titik dapat digunakan sebagai wildcard subranah: '.example.com' akan cocok example.com, www.example.com, dan subranah lainnya dari example.com. Nilai dari '*' akan cocok apapun; dalam kasus ini anda bertanggung jawab untuk menyediakan pengesahan anda sendiri dari kepala Host (mungkin dalam sebuah middleware; jika demikian middleware ini harus didaftarkan dahulu dalam MIDDLEWARE).

Django also allows the fully qualified domain name (FQDN) of any entries. Some browsers include a trailing dot in the Host header which Django strips when performing host validation.

Jika kepala Host (atau X-Forwarded-Host jika USE_X_FORWARDED_HOST diadakan) tidak cocok nilai apapun dalam daftar ini, metode django.http.HttpRequest.get_host() akan memunculkan SuspiciousOperation.

When DEBUG is True and ALLOWED_HOSTS is empty, the host is validated against ['.localhost', '127.0.0.1', '[::1]'].

ALLOWED_HOSTS adalah juga checked when running tests.

This validation only applies via get_host(); if your code accesses the Host header directly from request.META you are bypassing this security protection.

APPEND_SLASH¶

Awal: True

Ketika disetel menjadi True, jika URL diminta tidak cocok salah satu dari pola dalam URLconf dan itu tidak berakhir dalam sebuah garis miring, sebuah pengalihan HTTP diterbitkan ke URL sama dengan sebuah garis miring ditambahkan. Catat bahwa pengalihan mungkin menyebabkan data apapun diajukan dalam sebuah permintaan POST menjadi hilang.

Pengaturan APPEND_SLASH hanya digunakan jika CommonMiddleware dipasang (lihat Middleware). Lihat juga PREPEND_WWW.

CACHES¶

Awal:

{
    "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 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.

def make_key(key, key_prefix, version):
    return ":".join([key_prefix, str(version), key])

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.filebased.FileBasedCache",
        "LOCATION": "/var/tmp/django_cache",
    }
}

CACHE_MIDDLEWARE_ALIAS¶

Awalan: 'default'

hubungan cache untuk digunakan untuk cache middleware.

CACHE_MIDDLEWARE_KEY_PREFIX¶

Awalan: '' (String kosong)

Sebuah string yang akan diawalan pada kunci penyimpanan sementara dibangkitkan oleh cache middleware. Awalan ini dipadukan dengan pengaturan KEY_PREFIX setting; itu tidak menggantinya.

Lihat Kerangka kerja penyimpanan Django.

CACHE_MIDDLEWARE_SECONDS¶

Awalan: 600

Jumlah detik untuk menyimpan sementara halaman untuk cache middleware.

Lihat Kerangka kerja penyimpanan Django.

CSRF_COOKIE_AGE¶

Awalan: 31449600 (maksimal 1 tahun, dalam detik)

Umur kue CSRF, dalam detik.

The reason for setting a long-lived expiration time is to avoid problems in the case of a user closing a browser or bookmarking a page and then loading that page from a browser cache. Without persistent cookies, the form submission would fail in this case.

Some browsers (specifically Internet Explorer) can disallow the use of persistent cookies or can have the indexes to the cookie jar corrupted on disk, thereby causing CSRF protection checks to (sometimes intermittently) fail. Change this setting to None to use session-based CSRF cookies, which keep the cookies in-memory instead of on persistent storage.

CSRF_COOKIE_DOMAIN¶

Awalan: 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 CSRF limitations section.

CSRF_COOKIE_HTTPONLY¶

Awal: False

Whether to use HttpOnly flag on the CSRF cookie. If this is set to True, client-side JavaScript will not be able to access the CSRF cookie.

Designating the CSRF cookie as HttpOnly doesn't offer any practical protection because CSRF is only to protect against cross-domain attacks. If an attacker can read the cookie via JavaScript, they're already on the same domain as far as the browser knows, so they can do anything they like anyway. (XSS is a much bigger hole than CSRF.)

Meskipun pengaturan menawarkan sedikit keuntungan praktik, itu terkadang dibutuhkan oleh pengaudit keamanan.

If you enable this and need to send the value of the CSRF token with an AJAX request, your JavaScript must pull the value from a hidden CSRF token form input instead of from the cookie.

Lihat SESSION_COOKIE_HTTPONLY untuk rincian pada HttpOnly.

CSRF_COOKIE_MASKED¶

Awal: False

Whether to mask the CSRF cookie. See release notes for usage details.

CSRF_COOKIE_NAME¶

Awalan: csrftoken

Nama dari kue untuk digunakan untuk token autentifikasi CSRF. Ini dapat apapu anda inginkan (selama itu berbeda dari nama kue lain dalam aplikasi anda). Lihat Perlindungan Cross Site Request Forgery.

CSRF_COOKIE_PATH¶

Awalan: '/'

Jalur disetel pada kue CSRF. Ini harus baik cocok jalur URL dari pemasangan Django anda atau berupa induk dari jalur itu.

Ini adalah berguna jika anda memiliki contoh Django banyak berjalan dibawah nama rumah sama. Mereka dapat menggunakan jalur kue berbeda, dan setiap contoh akan hanya melihat kue CSRF nya sendiri.

CSRF_COOKIE_SAMESITE¶

Awalan: 'Lax'

Nilai dari bendera SameSite pada kue CSRF. Bendera ini mencegah kue dari dikirim dalam permintaan lintas-situs.

Lihat SESSION_COOKIE_SAMESITE untuk rincian tentang SameSite.

CSRF_COOKIE_SECURE¶

Awal: 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 with an HTTPS connection.

CSRF_USE_SESSIONS¶

Awal: False

Apakah menyimpan token CSRF dalam sesi pengguna daripada dalam sebuah kue. Itu membutuhkan penggunaan django.contrib.sessions.

Menyimpan token CSRF dalam sebuah kue (awalan Django) adalah aman, tetapi menyimpan itu dalam sesi adalah praktik umum dalam kerangka kerja karingan lain dan oleh akrena itu terkadan diminta oleh pemeriksa keamanan.

Since the default error views require the CSRF token, SessionMiddleware must appear in MIDDLEWARE before any middleware that may raise an exception to trigger an error view (such as PermissionDenied) if you're using CSRF_USE_SESSIONS. See Pengurutan middleware.

CSRF_FAILURE_VIEW¶

Awalan: 'django.views.csrf.csrf_failure'

Sebuah jalur bertitik untuk melihat fungsi untuk digunakan ketika permintaan datang ditolak oleh CSRF protection. Fungsi harus memiliki tanda tangan ini:

def csrf_failure(request, reason=""):
    ...

dimana reason adalah pesan pendek (diperuntukkan untuk pengembang atau pencatat, bukan untuk pengguna akhir) menunjukkan alasan permintaan telah ditolak. Itu harus mengembalikan sebuah HttpResponseForbidden.

django.views.csrf.csrf_failure() menerima sebuah tambahan parameter template_name yang awalan pada '403_csrf.html'. Jika sebuah cetakan dengan nama yang ada, itu akan digunakan membangun halaman.

CSRF_HEADER_NAME¶

Awalan: 'HTTP_X_CSRFTOKEN'

Nama dari kepala peminta digunakan untuk autentifikasi CSRF.

As with other HTTP headers in request.META, the header name received from the server is normalized by converting all characters to uppercase, replacing any hyphens with underscores, and adding an 'HTTP_' prefix to the name. For example, if your client sends a 'X-XSRF-TOKEN' header, the setting should be 'HTTP_X_XSRF_TOKEN'.

CSRF_TRUSTED_ORIGINS¶

Awalan: {} (Daftar kosong)

A list of trusted origins for unsafe requests (e.g. POST).

For requests that include the Origin header, Django's CSRF protection requires that header match the origin present in the Host header.

For a secure unsafe request that doesn't include the Origin header, the request must have a Referer header that matches the origin present in the Host header.

These checks prevent, for example, a POST request from subdomain.example.com from succeeding against api.example.com. If you need cross-origin unsafe requests, continuing the example, add 'https://subdomain.example.com' to this list (and/or http://... if requests originate from an insecure page).

The setting also supports subdomains, so you could add 'https://*.example.com', for example, to allow access from all subdomains of example.com.

DATABASES¶

Awalan: {} (Kamus kosong)

Sebuah dictionary mengandung pengaturan semua basisdata utnuk digunakan dengan Django. itu adalah dictionary bersarang yang isinya memetakan sebuah nama lain basisdata ke sebuah dictionary pilihan untuk sebuah basisdata sendiri.

Pengaturan DATABASES harus mengkonfigurasi sebuah basisdata default; angka apapun dari basisdata tambahan mungkin juga ditentukan.

Kemungkinan berkas pengaturan sederhana adalah untuk pengaturan basisdata-tunggal menggunakan SQLite. Ini dapat dikonfigurasi menggunakan berikut:

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.sqlite3",
        "NAME": "mydatabase",
    }
}

When connecting to other database backends, such as MariaDB, MySQL, Oracle, or PostgreSQL, additional connection parameters will be required. See the ENGINE setting below on how to specify other database types. This example is for PostgreSQL:

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql",
        "NAME": "mydatabase",
        "USER": "mydatabaseuser",
        "PASSWORD": "mypassword",
        "HOST": "127.0.0.1",
        "PORT": "5432",
    }
}

Pilihan paling dalam berikut yang mungkin dibutuhkan untuk konfigurasi lebih lengkap tersedia:

"HOST": "/var/run/mysql"

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql",
        "USER": "mydatabaseuser",
        "NAME": "mydatabase",
        "TEST": {
            "NAME": "mytestdatabase",
        },
    },
}

DATA_UPLOAD_MAX_MEMORY_SIZE¶

Awalan: 2621440 (yaitu 2.5 MB).

The maximum size in bytes that a request body may be before a SuspiciousOperation (RequestDataTooBig) is raised. The check is done when accessing request.body or request.POST and is calculated against the total request size excluding any file upload data. You can set this to None to disable the check. Applications that are expected to receive unusually large form posts should tune this setting.

The amount of request data is correlated to the amount of memory needed to process the request and populate the GET and POST dictionaries. Large requests could be used as a denial-of-service attack vector if left unchecked. Since web servers don't typically perform deep request inspection, it's not possible to perform a similar check at that level.

Lihat juga FILE_UPLOAD_MAX_MEMORY_SIZE.

DATA_UPLOAD_MAX_NUMBER_FIELDS¶

Awalan: 1000

The maximum number of parameters that may be received via GET or POST before a SuspiciousOperation (TooManyFields) is raised. You can set this to None to disable the check. Applications that are expected to receive an unusually large number of form fields should tune this setting.

The number of request parameters is correlated to the amount of time needed to process the request and populate the GET and POST dictionaries. Large requests could be used as a denial-of-service attack vector if left unchecked. Since web servers don't typically perform deep request inspection, it's not possible to perform a similar check at that level.

DATA_UPLOAD_MAX_NUMBER_FILES¶

Default: 100

The maximum number of files that may be received via POST in a multipart/form-data encoded request before a SuspiciousOperation (TooManyFiles) is raised. You can set this to None to disable the check. Applications that are expected to receive an unusually large number of file fields should tune this setting.

The number of accepted files is correlated to the amount of time and memory needed to process the request. Large requests could be used as a denial-of-service attack vector if left unchecked. Since web servers don't typically perform deep request inspection, it's not possible to perform a similar check at that level.

DATABASE_ROUTERS¶

Awalan: {} (Daftar kosong)

The list of routers that will be used to determine which database to use when performing a database query.

Lihat dokumentasi pada automatic database routing in multi database configurations.

DATE_FORMAT¶

Awalan: 'N j, Y' (misalnya Feb. 4, 2003)

The default formatting to use for displaying date fields in any part of the system. Note that if USE_L10N is set to True, then the locale-dictated format has higher precedence and will be applied instead. See allowed date format strings.

Lihat juga DATETIME_FORMAT, TIME_FORMAT dan SHORT_DATE_FORMAT.

DATE_INPUT_FORMATS¶

Awal:

[
    "%Y-%m-%d",  # '2006-10-25'
    "%m/%d/%Y",  # '10/25/2006'
    "%m/%d/%y",  # '10/25/06'
    "%b %d %Y",  # 'Oct 25 2006'
    "%b %d, %Y",  # 'Oct 25, 2006'
    "%d %b %Y",  # '25 Oct 2006'
    "%d %b, %Y",  # '25 Oct, 2006'
    "%B %d %Y",  # 'October 25 2006'
    "%B %d, %Y",  # 'October 25, 2006'
    "%d %B %Y",  # '25 October 2006'
    "%d %B, %Y",  # '25 October, 2006'
]

A list 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 template filter.

When USE_L10N is True, the locale-dictated format has higher precedence and will be applied instead.

Lihat juga DATETIME_INPUT_FORMATS dan TIME_INPUT_FORMATS.

DATETIME_FORMAT¶

Awalan: 'N j, Y, P' (misalnya Feb. 4, 2003, 4 p.m.)

The default formatting to use for displaying datetime fields in any part of the system. Note that if USE_L10N is set to True, then the locale-dictated format has higher precedence and will be applied instead. See allowed date format strings.

Lihat juga DATE_FORMAT, TIME_FORMAT dan SHORT_DATETIME_FORMAT.

DATETIME_INPUT_FORMATS¶

Awal:

[
    "%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'
    "%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 %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'
]

A list 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 template filter. Date-only formats are not included as datetime fields will automatically try DATE_INPUT_FORMATS in last resort.

When USE_L10N is True, the locale-dictated format has higher precedence and will be applied instead.

Lihat juga DATE_INPUT_FORMATS dan TIME_INPUT_FORMATS.

DEBUG¶

Awal: False

Boolean yang menyalakan/mematikan suasana mencari kesalahan.

Jangan pernah menyebarkan situs kedalam kedalam produksi dengan DEBUG menyala.

One of the main features of debug mode is the display of detailed error pages. If your app raises an exception when 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, such as SECRET_KEY. Specifically, it will exclude any setting whose name includes any of the following:

• 'API'
• 'KEY'
• 'PASS'
• '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 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 DEBUG is False, you also need to properly set the ALLOWED_HOSTS setting. Failing to do so will result in all requests being returned as "Bad Request (400)".

DEBUG_PROPAGATE_EXCEPTIONS¶

Awal: False

If set to True, Django's exception handling of view functions (handler500, or the debug view if DEBUG is True) and logging of 500 responses (django.request) is skipped and exceptions propagate upward.

This can be useful for some test setups. It shouldn't be used on a live site unless you want your web server (instead of Django) to generate "Internal Server Error" responses. In that case, make sure your server doesn't show the stack trace or other sensitive information in the response.

DECIMAL_SEPARATOR¶

Awalan: '.' (Titik)

Pemisah desimal awalan digunakan ketika membentuk angka desimal.

Note that if USE_L10N is set to True, then the locale-dictated format has higher precedence and will be applied instead.

Lihat juga NUMBER_GROUPING, THOUSAND_SEPARATOR dan USE_THOUSAND_SEPARATOR.

DEFAULT_AUTO_FIELD¶

Awalan: 'django.db.models.AutoField'

Default primary key field type to use for models that don't have a field with primary_key=True.

DEFAULT_CHARSET¶

Awalan: 'utf-8'

Default charset to use for all HttpResponse objects, if a MIME type isn't manually specified. Used when constructing the Content-Type header.

DEFAULT_EXCEPTION_REPORTER¶

Awalan: 'django.views.debug.ExceptionReporter'

Default exception reporter class to be used if none has been assigned to the HttpRequest instance yet. See Penyesuaian laporan kesalahan.

DEFAULT_EXCEPTION_REPORTER_FILTER¶

Awalan: 'django.views.debug.SafeExceptionReporterFilter'

Default exception reporter filter class to be used if none has been assigned to the HttpRequest instance yet. See Filtering error reports.

DEFAULT_FILE_STORAGE¶

Awalan: 'django.core.files.storage.FileSystemStorage'

Kelas penyimpanan berkas awalan untuk digunakan untuk tindakan terkait-berkas apapun yang tidak menentukan sistem penyimpanan tertentu. Lihat Mengelola berkas.

DEFAULT_FROM_EMAIL¶

Awalan: 'webmaster@localhost'

Default email address to use for various automated correspondence from the site manager(s). This doesn't include error messages sent to ADMINS and MANAGERS; for that, see SERVER_EMAIL.

DEFAULT_INDEX_TABLESPACE¶

Awalan: '' (String kosong)

Tablespace awalan digunakan untuk pengindeksan pada bidang yang belum ditentukan, jika backend mendukung itu (lihat Tablespaces).

DEFAULT_TABLESPACE¶

Awalan: '' (String kosong)

Tablespace awalan digunakan untuk model yang belum ditentukan, jika backend mendukung itu (lihat Tablespaces).

DISALLOWED_USER_AGENTS¶

Awalan: {} (Daftar kosong)

List of compiled regular expression objects representing User-Agent strings that are not allowed to visit any page, systemwide. Use this for bots/crawlers. This is only used if CommonMiddleware is installed (see Middleware).

EMAIL_BACKEND¶

Awalan: 'django.core.mail.backends.smtp.EmailBackend'

Backend digunakan untuk mengirim surel. Untuk daftar dari backend tersedia lihat Mengirim surel.

EMAIL_FILE_PATH¶

Awalan: Tidak ditentukan

The directory used by the file email backend to store output files.

EMAIL_HOST¶

Awalan: 'localhost'

Rumah digunakan untuk mengirim surel.

Lihat juga EMAIL_PORT.

EMAIL_HOST_PASSWORD¶

Awalan: '' (String kosong)

Password to use for the SMTP server defined in EMAIL_HOST. This setting is used in conjunction with EMAIL_HOST_USER when authenticating to the SMTP server. If either of these settings is empty, Django won't attempt authentication.

Lihat juga EMAIL_HOST_USER.

EMAIL_HOST_USER¶

Awalan: '' (String kosong)

Nama pengguna untuk digunakan pada peladen SMTP ditentukan dalam EMAIL_HOST. Jika kosong, Django tidak akan berusaha mengecek.

Lihat juga EMAIL_HOST_PASSWORD.

EMAIL_PORT¶

Awalan: 25

Port digunakan untuk peladen SMTP ditentukan dalam EMAIL_HOST.

EMAIL_SUBJECT_PREFIX¶

Awalan: '[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.

EMAIL_USE_LOCALTIME¶

Awal: False

Apakah mengirim kepala Date SMTP dari pesan surel dalam zona waktu lokal (True) atau dalam UTC (False).

EMAIL_USE_TLS¶

Awal: 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 EMAIL_USE_SSL.

EMAIL_USE_SSL¶

Awal: 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 EMAIL_USE_TLS.

Note that EMAIL_USE_TLS/EMAIL_USE_SSL are mutually exclusive, so only set one of those settings to True.

EMAIL_SSL_CERTFILE¶

Awalan: None

If EMAIL_USE_SSL or EMAIL_USE_TLS is True, you can optionally specify the path to a PEM-formatted certificate chain file to use for the SSL connection.

EMAIL_SSL_KEYFILE¶

Awalan: None

If EMAIL_USE_SSL or EMAIL_USE_TLS is True, you can optionally specify the path to a PEM-formatted private key file to use for the SSL connection.

Note that setting EMAIL_SSL_CERTFILE and EMAIL_SSL_KEYFILE doesn't result in any certificate checking. They're passed to the underlying SSL connection. Please refer to the documentation of Python's ssl.SSLContext.wrap_socket() function for details on how the certificate chain file and private key file are handled.

EMAIL_TIMEOUT¶

Awalan: None

Menentukan waktu habis dalam detik untuk memblok tindakan seperti usaha berhubungan.

FILE_UPLOAD_HANDLERS¶

Awal:

[
    "django.core.files.uploadhandler.MemoryFileUploadHandler",
    "django.core.files.uploadhandler.TemporaryFileUploadHandler",
]

A list of handlers to use for uploading. Changing this setting allows complete customization -- even replacement -- of Django's upload process.

Lihat Mengelola berkas untuk rincian.

FILE_UPLOAD_MAX_MEMORY_SIZE¶

Awalan: 2621440 (yaitu 2.5 MB).

The maximum size (in bytes) that an upload will be before it gets streamed to the file system. See Mengelola berkas for details.

Lihat juga DATA_UPLOAD_MAX_MEMORY_SIZE.

FILE_UPLOAD_DIRECTORY_PERMISSIONS¶

Awalan: None

The numeric mode to apply to directories created in the process of uploading files.

This setting also determines the default permissions for collected static directories when using the collectstatic management command. See collectstatic for details on overriding it.

This value mirrors the functionality and caveats of the FILE_UPLOAD_PERMISSIONS setting.

FILE_UPLOAD_PERMISSIONS¶

Awalan: 0o644

The numeric mode (i.e. 0o644) to set newly uploaded files to. For more information about what these modes mean, see the documentation for os.chmod().

If None, you'll get operating-system dependent behavior. On most platforms, temporary files will have a mode of 0o600, and files saved from memory will be saved using the system's standard umask.

For security reasons, these permissions aren't applied to the temporary files that are stored in FILE_UPLOAD_TEMP_DIR.

This setting also determines the default permissions for collected static files when using the collectstatic management command. See collectstatic for details on overriding it.

FILE_UPLOAD_TEMP_DIR¶

Awalan: None

The directory to store data to (typically files larger than FILE_UPLOAD_MAX_MEMORY_SIZE) 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.

Lihat Mengelola berkas untuk rincian.

FIRST_DAY_OF_WEEK¶

Awalan: 0 (Minggu)

A 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.

Nilai harus berupa integer 0 sampai 6, dimana 0 berarti Minggu, 1 berarti Senin dan seterusnya.

FIXTURE_DIRS¶

Awalan: {} (Daftar kosong)

List of directories searched for fixture files, in addition to the fixtures directory of each application, in search order.

Catat bahwa jalur-jalur ini harus menggunakan garis miring didepan gaya-Unix, bahkan pada Windows.

Lihat Provide data with fixtures dan Fixture loading.

FORCE_SCRIPT_NAME¶

Awalan: 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. It is also used by django.setup() to set the URL resolver script prefix outside of the request/response cycle (e.g. in management commands and standalone scripts) to generate correct URLs when SCRIPT_NAME is not /.

FORM_RENDERER¶

Awalan: 'django.forms.renderers.DjangoTemplates'

The class that renders forms and form widgets. It must implement the low-level render API. Included form renderers are:

• 'django.forms.renderers.DjangoTemplates'
• 'django.forms.renderers.Jinja2'
• 'django.forms.renderers.TemplatesSetting'

FORMAT_MODULE_PATH¶

Awalan: None

A full Python path to a Python package that contains custom 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 in this file.

For example, if 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

Anda dapat juga mensetel pengaturan ini pada daftar jalur Python, sebagai contoh:

FORMAT_MODULE_PATH = [
    "mysite.formats",
    "some_app.formats",
]

When Django searches for a certain format, it will go through all given Python paths until it finds a module that actually defines the given format. This means that formats defined in packages farther up in the list will take precedence over the same formats in packages farther down.

Bentuk tersedia adalah:

• DATE_FORMAT
• DATE_INPUT_FORMATS
• DATETIME_FORMAT,
• DATETIME_INPUT_FORMATS
• DECIMAL_SEPARATOR
• FIRST_DAY_OF_WEEK
• MONTH_DAY_FORMAT
• NUMBER_GROUPING
• SHORT_DATE_FORMAT
• SHORT_DATETIME_FORMAT
• THOUSAND_SEPARATOR
• TIME_FORMAT
• TIME_INPUT_FORMATS
• YEAR_MONTH_FORMAT

IGNORABLE_404_URLS¶

Awalan: {} (Daftar kosong)

List of compiled regular expression objects describing URLs that should be ignored when reporting HTTP 404 errors via email (see Bagaimana mengelola pelaporan kesalahan). Regular expressions are matched against request's full paths (including query string, if any). Use this if your site does not provide a commonly requested file such as favicon.ico or robots.txt.

Ini hanya digunakan jika BrokenLinkEmailsMiddleware diadakan (lihat Middleware).

INSTALLED_APPS¶

Awalan: {} (Daftar kosong)

A list of strings designating all applications that are enabled in this Django installation. Each string should be a dotted Python path to:

• sebuah kelas konfigurasi aplikasi (disukai), atau
• paket mengandung sebuah aplikasi.

Learn more about application configurations.

When several applications provide different versions of the same resource (template, static file, management command, translation), the application listed first in INSTALLED_APPS has precedence.

INTERNAL_IPS¶

Awalan: {} (Daftar kosong)

Daftar dari alamat IP, sebagai string, yaitu:

• Mengijinkan debug() pengolah konteks untuk menambah beberapa variabel pada konteks cetakan.
• Dapat menggunakan admindocs bookmarklets bahkan jika tidak masuk sebagai pengguna staf.
• Ditandai sebagai "internal" (berlawanan dengan "EXTERNAL") dalam surel AdminEmailHandler.

LANGUAGE_CODE¶

Awalan: 'en-us'

Strign mewakili kode bahasa untuk pemasangan ini. Ini harus berupa language ID format. Sebagai contoh, U.S. English adalah "en-us". Lihat juga list of language identifiers dan Internasionalisasi dan lokalisasi.

USE_I18N harus aktif untuk pengaturan ini untuk memberikan pengaruh.

Itu melayani dua tujuan:

• Jika middleware lokal tidak digunakan, itu memutuskan terjemahan mana dilayani ke semua pengguna.
• If the locale middleware is active, it provides a fallback language in case the user's preferred language can't be determined or is not supported by the website. It also provides the fallback translation when a translation for a given literal doesn't exist for the user's preferred language.

Lihat Bagaimana Django menemukan pilihan bahasa untuk rincian lebih.

LANGUAGE_COOKIE_AGE¶

Awalan: None (berakhir ketika peramban tutup)

Umur dari kue bahasa, dalam detik.

LANGUAGE_COOKIE_DOMAIN¶

Awalan: None

The domain to use for the language cookie. Set this to a string such as "example.com" 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 that have the old domain will not be updated. This will result in site users being unable to switch the language as long as these cookies persist. The only safe and reliable option to perform the switch is to change the language cookie name permanently (via the LANGUAGE_COOKIE_NAME setting) and to add a middleware that copies the value from the old cookie to a new one and then deletes the old one.

LANGUAGE_COOKIE_HTTPONLY¶

Awal: False

Whether to use HttpOnly flag on the language cookie. If this is set to True, client-side JavaScript will not be able to access the language cookie.

Lihat SESSION_COOKIE_HTTPONLY untuk rincian pada HttpOnly.

LANGUAGE_COOKIE_NAME¶

Awalan: 'django_language'

The name of the cookie to use for the language cookie. This can be whatever you want (as long as it's different from the other cookie names in your application). See Internasionalisasi dan lokalisasi.

LANGUAGE_COOKIE_PATH¶

Awalan: '/'

Jalur disetel pada kue bahasa. Ini harus baik cocok dengan jalur URL dari pemasangan Django anda atau berupa induk dari jalur itu.

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 language cookie.

Be cautious when updating this setting on a production site. If you update this setting to use a deeper path than it previously used, existing user cookies that have the old path will not be updated. This will result in site users being unable to switch the language as long as these cookies persist. The only safe and reliable option to perform the switch is to change the language cookie name permanently (via the LANGUAGE_COOKIE_NAME setting), and to add a middleware that copies the value from the old cookie to a new one and then deletes the one.

LANGUAGE_COOKIE_SAMESITE¶

Awalan: None

The value of the SameSite flag on the language cookie. This flag prevents the cookie from being sent in cross-site requests.

Lihat SESSION_COOKIE_SAMESITE untuk rincian tentang SameSite.

LANGUAGE_COOKIE_SECURE¶

Awal: False

Whether to use a secure cookie for the language 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.

LANGUAGES¶

Default: A list 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.

The list is a list of two-tuples in the format (language code, language name) -- for example, ('ja', 'Japanese'). This specifies which languages are available for language selection. See Internasionalisasi dan lokalisasi.

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.

Jika anda menentukan sebuah penyesuaian pengaturan LANGUAGES, anda dapat menandai nama-nama bahasa sebagari string terjemahan menggunakan fungsi gettext_lazy().

Ini adalah contoh sebuah berkas pengaturan:

from django.utils.translation import gettext_lazy as _

LANGUAGES = [
    ("de", _("German")),
    ("en", _("English")),
]

LANGUAGES_BIDI¶

Default: A list of all language codes that are written right-to-left. You can see the current list of these languages by looking in django/conf/global_settings.py.

Daftar mengandung language codes untuk bahasa yang ditulis dari kiri-ke-kanan.

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 LANGUAGES setting, the list of bidirectional languages may contain language codes which are not enabled on a given site.

LOCALE_PATHS¶

Awalan: {} (Daftar kosong)

Sebuah daftar direktori dimana Django mencari berkas terjemahan. Lihat Bagaimana Django menemukan terjemahan.

Contoh:

LOCALE_PATHS = [
    "/home/www/project/common_files/locale",
    "/var/local/translations/locale",
]

Django akan mencari dalam setiap jalur ini untuk direktori <locale_code>/LC_MESSAGES mengandung berkas terjemahan sebenarnya.

LOGGING¶

Awalan Sebuah dictionary konfigurasi pencatatan

A data structure containing configuration information. When not-empty, the contents of this data structure will be passed as the argument to the configuration method described in LOGGING_CONFIG.

Among other things, the default logging configuration passes HTTP 500 server errors to an email log handler when DEBUG is False. See also Mengkonfigurasi catatan.

Anda dapat melihat konfigurasi pencatatan awalan dengan mencari dalam django/utils/log.py.

LOGGING_CONFIG¶

Awalan: 'logging.config.dictConfig'

A path to a callable that will be used to configure logging in the Django project. Points at an instance of Python's dictConfig configuration method by default.

Jika anda tidak mensetel LOGGING_CONFIG menjadi None, pengolahan konfigurasi pencatatan akan dilewatkan.

MANAGERS¶

Awalan: {} (Daftar kosong)

A list in the same format as ADMINS that specifies who should get broken link notifications when BrokenLinkEmailsMiddleware is enabled.

MEDIA_ROOT¶

Awalan: '' (String kosong)

Jalur sistem berkas mutlak pada direktori yang akan menahan user-uploaded files.

Contoh: "/var/www/example.com/media/"

Lihat juga MEDIA_URL.

MEDIA_URL¶

Awalan: '' (String kosong)

URL yang menangani media dilayani dari MEDIA_ROOT, digunakan untuk managing stored files 1. Itu harus berakhir dalam sebuah garis miring jika menyetel ke nilai bukan-kosong. Anda akan butuh configure these files to be served 2 dalam kedua lingkungan pengembangan dan produksi.

Jika anda ingin menggunakan {{ MEDIA_URL }} dalam cetakan-cetakan anda, tambah 'django.template.context_processors.media' dalam pilihan 'context_processors' dari TEMPLATES.

Contoh: "http://media.example.com/"

MIDDLEWARE¶

Awalan: None

daftar dari middleware untuk digunakan. Lihat Middleware.

MIGRATION_MODULES¶

Awalan: {} (Kamus kosong)

A dictionary specifying the package where migration modules can be found on a per-app basis. The default value of this setting is an empty dictionary, but the default package name for migration modules is migrations.

Contoh:

{"blog": "blog.db_migrations"}

In this case, migrations pertaining to the blog app will be contained in the blog.db_migrations package.

Jika anda menyediakan argumen app_label, makemigrations akan otomatis membuat paket jika itu belum ada.

When you supply None as a value for an app, Django will consider the app as an app without migrations regardless of an existing migrations submodule. This can be used, for example, in a test settings file to skip migrations while testing (tables will still be created for the apps' models). To disable migrations for all apps during tests, you can set the MIGRATE to False instead. If MIGRATION_MODULES is used in your general project settings, remember to use the migrate --run-syncdb option if you want to create tables for the app.

MONTH_DAY_FORMAT¶

Awalan: '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."

Catat bahwa jika USE_L10N disetel menjadi True, kemudian bentuk sesuai lokal-yang-ditentukan memiliki hak lebih tinggi dan akan diberlakukan.

Lihat allowed date format strings. Lihat juga DATE_FORMAT, DATETIME_FORMAT, TIME_FORMAT dan YEAR_MONTH_FORMAT.

NUMBER_GROUPING¶

Awal: 0

Sejumlah angka dikelompokkan bersama-sama pada bagian integer dari sebuah angka.

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 THOUSAND_SEPARATOR will be used as the separator between those groups.

Some locales use non-uniform digit grouping, e.g. 10,00,00,000 in en_IN. For this case, you can provide a sequence with the number of digit group sizes to be applied. The first number defines the size of the group preceding the decimal delimiter, and each number that follows defines the size of preceding groups. If the sequence is terminated with -1, no further grouping is performed. If the sequence terminates with a 0, the last group size is used for the remainder of the number.

Contoh tuple untuk en_IN:

NUMBER_GROUPING = (3, 2, 0)

Note that if USE_L10N is set to True, then the locale-dictated format has higher precedence and will be applied instead.

Lihat juga DECIMAL_SEPARATOR, THOUSAND_SEPARATOR dan USE_THOUSAND_SEPARATOR.

PREPEND_WWW¶

Awal: False

Apakah untuk menambahkan subranah "www." ke URL yang tidak memilikinya. Ini hanya digunakan jika CommonMiddleware terpasang (lihat Middleware). Lihat juga APPEND_SLASH.

ROOT_URLCONF¶

Awalan: Tidak ditentukan

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 Bagaimana Django mengolah permintaan for details.

SECRET_KEY¶

Awalan: '' (String kosong)

A secret key for a particular Django installation. This is used to provide cryptographic signing, and should be set to a unique, unpredictable value.

django-admin startproject otomatis menambah SECRET_KEY dibangkitkan-acak ke setiap proyek baru.

Uses of the key shouldn't assume that it's text or bytes. Every use should go through force_str() or force_bytes() to convert it to the desired type.

Django akan menolak dimulai jika SECRET_KEY tidak disetel.

Kunci rahasia digunakan untuk:

• All sessions if you are using any other session backend than django.contrib.sessions.backends.cache, or are using the default get_session_auth_hash().
• All messages if you are using CookieStorage or FallbackStorage.
• Semua token PasswordResetView .
• Penggunaan apapun dari cryptographic signing, meskipun kunci berbeda disediakan.

When a secret key is no longer set as SECRET_KEY or contained within SECRET_KEY_FALLBACKS all of the above will be invalidated. When rotating your secret key, you should move the old key to SECRET_KEY_FALLBACKS temporarily. Secret keys are not used for passwords of users and key rotation will not affect them.

SECRET_KEY_FALLBACKS¶

Default: []

A list of fallback secret keys for a particular Django installation. These are used to allow rotation of the SECRET_KEY.

In order to rotate your secret keys, set a new SECRET_KEY and move the previous value to the beginning of SECRET_KEY_FALLBACKS. Then remove the old values from the end of the SECRET_KEY_FALLBACKS when you are ready to expire the sessions, password reset tokens, and so on, that make use of them.

Uses of the secret key values shouldn't assume that they are text or bytes. Every use should go through force_str() or force_bytes() to convert it to the desired type.

SECURE_CONTENT_TYPE_NOSNIFF¶

Awal: True

Jika True, SecurityMiddleware mesetel kepala X-Content-Type-Options: nosniff pada semua tanggapan yang belum memiliki itu.

SECURE_CROSS_ORIGIN_OPENER_POLICY¶

Awalan: 'same-origin'

Unless set to None, the SecurityMiddleware sets the Cross-Origin Opener Policy header on all responses that do not already have it to the value provided.

SECURE_HSTS_INCLUDE_SUBDOMAINS¶

Awal: False

If True, the SecurityMiddleware adds the includeSubDomains directive to the HTTP Strict Transport Security header. It has no effect unless SECURE_HSTS_SECONDS is set to a non-zero value.

SECURE_HSTS_PRELOAD¶

Awal: False

If True, the SecurityMiddleware adds the preload directive to the HTTP Strict Transport Security header. It has no effect unless SECURE_HSTS_SECONDS is set to a non-zero value.

SECURE_HSTS_SECONDS¶

Awal: 0

If set to a non-zero integer value, the SecurityMiddleware sets the HTTP Strict Transport Security header on all responses that do not already have it.

SECURE_PROXY_SSL_HEADER¶

Awalan: None

A tuple representing an HTTP header/value combination that signifies a request is secure. This controls the behavior of the request object's is_secure() method.

By default, is_secure() determines if a request is secure by confirming that a requested URL uses https://. This method is important for Django's CSRF 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" whether the original request uses HTTPS or not. If there is a non-HTTPS connection between the proxy and Django then is_secure() would always return False -- even for requests that were made via HTTPS by the end user. In contrast, if there is an HTTPS connection between the proxy and Django then is_secure() would always return True -- even for requests that were made originally via HTTP.

In this situation, configure your proxy to set a custom HTTP header that tells Django whether the request came in via HTTPS, and set SECURE_PROXY_SSL_HEADER so that Django knows what header to look for.

Setel sebuah tuple dengan dua unsur -- nama dari kepala untuk mencari dan nilai diwajibkan. Sebagai contoh:

SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")

This tells Django to trust the X-Forwarded-Proto header that comes from our proxy and that the request is guaranteed to be secure (i.e., it originally came in via HTTPS) when:

• the header value is 'https', or
• its initial, leftmost value is 'https' in the case of a comma-separated list of protocols (e.g. 'https,http,http').

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.)

SECURE_REDIRECT_EXEMPT¶

Awalan: {} (Daftar kosong)

If a URL path matches a regular expression in this list, the request will not be redirected to HTTPS. The SecurityMiddleware strips leading slashes from URL paths, so patterns shouldn't include them, e.g. SECURE_REDIRECT_EXEMPT = [r'^no-ssl/$', …]. If SECURE_SSL_REDIRECT is False, this setting has no effect.

SECURE_REFERRER_POLICY¶

Awalan: 'same-origin'

If configured, the SecurityMiddleware sets the Referrer Policy header on all responses that do not already have it to the value provided.

SECURE_SSL_HOST¶

Awalan: None

If a string (e.g. secure.example.com), all SSL redirects will be directed to this host rather than the originally-requested host (e.g. www.example.com). If SECURE_SSL_REDIRECT is False, this setting has no effect.

SECURE_SSL_REDIRECT¶

Awal: False

If True, the SecurityMiddleware redirects all non-HTTPS requests to HTTPS (except for those URLs matching a regular expression listed in SECURE_REDIRECT_EXEMPT).

SERIALIZATION_MODULES¶

Awalan: Tidak ditentukan

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"}

SERVER_EMAIL¶

Awal: 'root@localhost'

The email address that error messages come from, such as those sent to ADMINS and MANAGERS.

SHORT_DATE_FORMAT¶

Awalan: 'm/d/Y' (misalnya 12/31/2003)

An available formatting that can be used for displaying date fields on templates. Note that if USE_L10N is set to True, then the corresponding locale-dictated format has higher precedence and will be applied. See allowed date format strings.

Lihat juga DATE_FORMAT dan SHORT_DATETIME_FORMAT.

SHORT_DATETIME_FORMAT¶

Awalan: 'm/d/Y P' (misalnya 12/31/2003 4 p.m.)

An available formatting that can be used for displaying datetime fields on templates. Note that if USE_L10N is set to True, then the corresponding locale-dictated format has higher precedence and will be applied. See allowed date format strings.

Lihat juga DATE_FORMAT dan SHORT_DATE_FORMAT.

SIGNING_BACKEND¶

Awalan: 'django.core.signing.TimestampSigner'

Backend digunakan unntuk tandatangan kue dan data lain.

Lihat juga dokumentasi Penandatanganan Kriptrograpi.

SILENCED_SYSTEM_CHECKS¶

Awalan: {} (Daftar kosong)

Sebuah daftar penciri dari pesan-pesan dibangkitkan oleh kerangka sistem pemeriksaan (yaitu ["models.W001"]`) yang anda harapkan secara tetap mengakui dan mengabaikan. Pemeriksaan diam-diam tidak akan dikeluarkan ke konsol.

Lihat juga dokumentasi Kerangka pemeriksaan sistem.

STORAGES¶

Awal:

{
    "default": {
        "BACKEND": "django.core.files.storage.FileSystemStorage",
    },
    "staticfiles": {
        "BACKEND": "django.contrib.staticfiles.storage.StaticFilesStorage",
    },
}

A dictionary containing the settings for all storages to be used with Django. It is a nested dictionary whose contents map a storage alias to a dictionary containing the options for an individual storage.

Storages can have any alias you choose. However, there are two aliases with special significance:

• default for managing files. 'django.core.files.storage.FileSystemStorage' is the default storage engine.
• staticfiles for managing static files. 'django.contrib.staticfiles.storage.StaticFilesStorage' is the default storage engine.

The following is an example settings.py snippet defining a custom file storage called example:

STORAGES = {
    # ...
    "example": {
        "BACKEND": "django.core.files.storage.FileSystemStorage",
        "OPTIONS": {
            "location": "/example",
            "base_url": "/example/",
        },
    },
}

OPTIONS are passed to the BACKEND on initialization in **kwargs.

A ready-to-use instance of the storage backends can be retrieved from django.core.files.storage.storages. Use a key corresponding to the backend definition in STORAGES.

TEMPLATES¶

Awalan: {} (Daftar kosong)

A list containing the settings for all template engines to be used with Django. Each item of the list is a dictionary containing the options for an individual engine.

Here's a setup that tells the Django template engine to load templates from the templates subdirectory inside each installed application:

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "APP_DIRS": True,
    },
]

Pilihan berikut tersedia untuk semua backend.

TEST_RUNNER¶

Awalan: 'django.test.runner.DiscoverRunner'

Nama dari kelas untuk digunakan untuk memulai antrian percobaan. Lihat Menggunakan kerangka percobaan berbeda.

TEST_NON_SERIALIZED_APPS¶

Awalan: {} (Daftar kosong)

In order to restore the database state between tests for TransactionTestCases and database backends without transactions, Django will serialize the contents of all apps when it starts the test run so it can then reload from that copy before running tests that need it.

This slows down the startup time of the test runner; if you have apps that you know don't need this feature, you can add their full names in here (e.g. 'django.contrib.contenttypes') to exclude them from this serialization process.

THOUSAND_SEPARATOR¶

Awalan: ',' (Koma)

Default thousand separator used when formatting numbers. This setting is used only when USE_THOUSAND_SEPARATOR is True and NUMBER_GROUPING is greater than 0.

Note that if USE_L10N is set to True, then the locale-dictated format has higher precedence and will be applied instead.

Lihat juga NUMBER_GROUPING, DECIMAL_SEPARATOR dan USE_THOUSAND_SEPARATOR.

TIME_FORMAT¶

Awalan: 'P' (misalnya 4 p.m.)

The default formatting to use for displaying time fields in any part of the system. Note that if USE_L10N is set to True, then the locale-dictated format has higher precedence and will be applied instead. See allowed date format strings.

Lihat juga DATE_FORMAT dan DATETIME_FORMAT.

TIME_INPUT_FORMATS¶

Awal:

[
    "%H:%M:%S",  # '14:30:59'
    "%H:%M:%S.%f",  # '14:30:59.000200'
    "%H:%M",  # '14:30'
]

A list 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 template filter.

When USE_L10N is True, the locale-dictated format has higher precedence and will be applied instead.

Lihat juga DATE_INPUT_FORMATS dan DATETIME_INPUT_FORMATS.

TIME_ZONE¶

Awalan: 'America/Chicago'

Sebuah string mewakili zona waktu untuk pemasangan ini. Lihat list of time zones.

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 USE_TZ is False, this is the time zone in which Django will store all datetimes. When 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.

On Unix environments (where time.tzset() is implemented), Django sets the os.environ['TZ'] variable to the time zone you specify in the 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 if you're using the manual configuration option as described in manually configuring settings. If Django doesn't set the TZ environment variable, it's up to you to ensure your processes are running in the correct environment.

USE_DEPRECATED_PYTZ¶

Awal: False

A boolean that specifies whether to use pytz, rather than zoneinfo, as the default time zone implementation.

USE_I18N¶

Awal: True

A boolean that specifies whether Django's translation system should be enabled. This provides a 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.

Lihat juga LANGUAGE_CODE, USE_L10N dan USE_TZ.

USE_L10N¶

Awal: True

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.

Lihat juga LANGUAGE_CODE, USE_I18N dan USE_TZ.

USE_THOUSAND_SEPARATOR¶

Awal: False

A boolean that specifies whether to display numbers using a thousand separator. When set to True and USE_L10N is also True, Django will format numbers using the NUMBER_GROUPING and THOUSAND_SEPARATOR settings. The latter two settings may also be dictated by the locale, which takes precedence.

Lihat juga DECIMAL_SEPARATOR, NUMBER_GROUPING dan THOUSAND_SEPARATOR.

USE_TZ¶

Awal: 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.

When USE_TZ is False, Django will use naive datetimes in local time, except when parsing ISO 8601 formatted strings, where timezone information will always be retained if present.

Lihat juga TIME_ZONE, USE_I18N dan USE_L10N.

USE_X_FORWARDED_HOST¶

Awal: 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.

This setting takes priority over USE_X_FORWARDED_PORT. Per RFC 7239#section-5.3, the X-Forwarded-Host header can include the port number, in which case you shouldn't use USE_X_FORWARDED_PORT.

USE_X_FORWARDED_PORT¶

Awal: False

A boolean that specifies whether to use the X-Forwarded-Port header in preference to the SERVER_PORT META variable. This should only be enabled if a proxy which sets this header is in use.

USE_X_FORWARDED_HOST mengambil prioritas terhadap pengaturan ini.

WSGI_APPLICATION¶

Awalan: None

The full Python path of the WSGI application object that Django's built-in servers (e.g. runserver) will use. The django-admin startproject management command will create a standard 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 runserver will be identical to previous Django versions.

YEAR_MONTH_FORMAT¶

Awalan: '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."

Catat bahwa jika USE_L10N disetel menjadi True, kemudian bentuk sesuai lokal-yang-ditentukan memiliki hak lebih tinggi dan akan diberlakukan.

Lihat allowed date format strings. Lihat juga DATE_FORMAT, DATETIME_FORMAT, TIME_FORMAT dan MONTH_DAY_FORMAT.

X_FRAME_OPTIONS¶

Awalan: 'DENY'

Nilai awalan untuk kepala X-Frame-Options digunakan oleh XFrameOptionsMiddleware. Lihat dokumentasi clickjacking protection.

AUTHENTICATION_BACKENDS¶

Awalan: ['django.contrib.auth.backends.ModelBackend']

A list of authentication backend classes (as strings) to use when attempting to authenticate a user. See the authentication backends documentation for details.

AUTH_USER_MODEL¶

Awalan: 'auth.User'

Model digunakan untuk mewakili User. Lihat Mengganti model User penyesuaian.

LOGIN_REDIRECT_URL¶

Awalan: '/accounts/profile/'

The URL or named URL pattern where requests are redirected after login when the LoginView doesn't get a next GET parameter.

LOGIN_URL¶

Awalan: '/accounts/login/'

URL atau named URL pattern dimana permintaan dialihkan untuk masuk ketika menggunakan penghias login_required(), LoginRequiredMixin, atau AccessMixin.

LOGOUT_REDIRECT_URL¶

Awalan: None

The URL or named URL pattern where requests are redirected after logout if LogoutView doesn't have a next_page attribute.

Jika None, pengalihan tidak akan dilakukan dan tampilan keluar akan dibangun.

PASSWORD_RESET_TIMEOUT¶

Awalan: 259200 (3 hari, dalam detik)

Jumlah detik dari tautan setel kembali sandi yang sah.

Digunakan oleh PasswordResetConfirmView.

PASSWORD_HASHERS¶

Lihat Bagaimana Django menyimpan sandi.

Awal:

[
    "django.contrib.auth.hashers.PBKDF2PasswordHasher",
    "django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher",
    "django.contrib.auth.hashers.Argon2PasswordHasher",
    "django.contrib.auth.hashers.BCryptSHA256PasswordHasher",
    "django.contrib.auth.hashers.ScryptPasswordHasher",
]

AUTH_PASSWORD_VALIDATORS¶

Awalan: {} (Daftar kosong)

The list of validators that are used to check the strength of user's passwords. See Pengesahan sandi for more details. By default, no validation is performed and all passwords are accepted.

MESSAGE_LEVEL¶

Awalan: messages.INFO

Setel tingkatan pesan minimal yang akan direkam oleh kerangka kerja pesan. Lihat message levels untuk rincian lebih.

from django.contrib.messages import constants as message_constants

MESSAGE_LEVEL = message_constants.DEBUG

MESSAGE_STORAGE¶

Awalan: 'django.contrib.messages.storage.fallback.FallbackStorage'

Mengendalikan dimana Django menyimpan data pesan. Nilai sah adalah:

• 'django.contrib.messages.storage.fallback.FallbackStorage'
• 'django.contrib.messages.storage.session.SessionStorage'
• 'django.contrib.messages.storage.cookie.CookieStorage'

Lihat message storage backends untuk lebih rinci.

Backend yang menggunakan kue -- CookieStorage dan FallbackStorage -- menggunakan nilai dari SESSION_COOKIE_DOMAIN, SESSION_COOKIE_SECURE dan SESSION_COOKIE_HTTPONLY ketika menyetel kue mereka.

MESSAGE_TAGS¶

Awal:

{
    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 Menampilkan pesan above for more details.

from django.contrib.messages import constants as message_constants

MESSAGE_TAGS = {message_constants.INFO: ""}

SESSION_CACHE_ALIAS¶

Awalan: 'default'

Jika anda sedang menggunakan cache-based session storage, ini memilih cache untuk digunakan.

SESSION_COOKIE_AGE¶

Awalan: 1209600 (2 minggu, dalam detik)

Umur sesi kue, dalam detik.

SESSION_COOKIE_DOMAIN¶

Awalan: None

The domain to use for session cookies. Set this to a string such as "example.com" for cross-domain cookies, or use None for a standard domain cookie.

To use cross-domain cookies with CSRF_USE_SESSIONS, you must include a leading dot (e.g. ".example.com") to accommodate the CSRF middleware's referer checking.

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.

Pengaturan ini juga mempengaruhi kue-kue disetel oleh django.contrib.messages.

SESSION_COOKIE_HTTPONLY¶

Awal: True

Whether to use HttpOnly flag on the session cookie. If this is set to True, client-side JavaScript will not be able to access the session cookie.

HttpOnly is a flag included in a Set-Cookie HTTP response header. It's part of the RFC 6265#section-4.1.2.6 standard for cookies and can be a useful way to mitigate the risk of a client-side script accessing the protected cookie data.

This makes it less trivial for an attacker to escalate a cross-site scripting vulnerability into full hijacking of a user's session. There aren't many good reasons for turning this off. Your code shouldn't read session cookies from JavaScript.

SESSION_COOKIE_NAME¶

Awalan: 'sessionid'

The name of the cookie to use for sessions. This can be whatever you want (as long as it's different from the other cookie names in your application).

SESSION_COOKIE_PATH¶

Awalan: '/'

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.

SESSION_COOKIE_SAMESITE¶

Awalan: 'Lax'

The value of the SameSite flag on the session cookie. This flag prevents the cookie from being sent in cross-site requests thus preventing CSRF attacks and making some methods of stealing session cookie impossible.

Kemungkinan nilai-nilai untuk pengaturan adalah:

• 'Strict': prevents the cookie from being sent by the browser to the target site in all cross-site browsing context, even when following a regular link.

  For example, for a GitHub-like website this would mean that if a logged-in user follows a link to a private GitHub project posted on a corporate discussion forum or email, GitHub will not receive the session cookie and the user won't be able to access the project. A bank website, however, most likely doesn't want to allow any transactional pages to be linked from external sites so the 'Strict' flag would be appropriate.

• 'Lax' (default): provides a balance between security and usability for websites that want to maintain user's logged-in session after the user arrives from an external link.

  In the GitHub scenario, the session cookie would be allowed when following a regular link from an external website and be blocked in CSRF-prone request methods (e.g. POST).

• 'None' (string): the session cookie will be sent with all same-site and cross-site requests.

• False: disables the flag.

SESSION_COOKIE_SECURE¶

Awal: 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.

Leaving this setting off isn't a good idea because an attacker could capture an unencrypted session cookie with a packet sniffer and use the cookie to hijack the user's session.

SESSION_ENGINE¶

Awalan: 'django.contrib.sessions.backends.db'

Mengendalikan dimana Django menyimpan data sesi. Mesin yang disertakan adalah:

• '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'

Lihat Konfigurasi mesin sesi untuk rincian lebih.

SESSION_EXPIRE_AT_BROWSER_CLOSE¶

Awal: False

Whether to expire the session when the user closes their browser. See Browser-length sessions vs. persistent sessions.

SESSION_FILE_PATH¶

Awalan: 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.

SESSION_SAVE_EVERY_REQUEST¶

Awal: 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. Empty sessions won't be created, even if this setting is active.

SESSION_SERIALIZER¶

Awalan: 'django.contrib.sessions.serializers.JSONSerializer'

Full import path of a serializer class to use for serializing session data. Included serializer is:

• 'django.contrib.sessions.serializers.JSONSerializer'

See Serialisasi sesi for details.

SITE_ID¶

Awalan: Tidak ditentukan

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.

STATIC_ROOT¶

Awalan: None

Jalur mutlak ke direktori dimana collectstatic akan mengumpulkan berkas-berkas tetap untuk pengembangan.

Contoh: "/var/www/example.com/static/"

If the staticfiles contrib app is enabled (as in the default project template), the collectstatic management command will collect static files into this directory. See the how-to on managing static files for more details about usage.

STATIC_URL¶

Awalan: None

URL digunakan ketika mengacu ke berkas-berkas tetap bertempat dalam STATIC_ROOT.

Example: "static/" or "http://static.example.com/"

Jika bukan None, ini akan digunakan sebagai jalur dasar untuk asset definitions (kelas Media) dan staticfiles app.

Itu harus berakhir dalam sebuah garis miring jika disetel ke nilai bukan-kosong.

Anda mungkin butuh untuk configure these files to be served in development dan akan sangat perlu melakukan itu in production.

STATICFILES_DIRS¶

Awalan: {} (Daftar kosong)

This setting defines the additional locations the staticfiles app will traverse if the FileSystemFinder finder is enabled, e.g. if you use the collectstatic or findstatic management command or use the static file serving view.

Ini harus berupa kumpulan dari daftar string yang mengandung jalur penuh ke berkas-berkas tambahan anda misalnya:

STATICFILES_DIRS = [
    "/home/special.polls.com/polls/static",
    "/home/polls.com/polls/static",
    "/opt/webfiles/common",
]

Catat bahwa jalur-jalur ini harus menggunakan garis miring depan gaya-Unix, bahkan pada Windows (misalnya "C:/Users/user/mysite/extra_static_content").

STATICFILES_DIRS = [
    # ...
    ("downloads", "/opt/webfiles/stats"),
]

<a href="{% static 'downloads/polls_20101022.tar.gz' %}">

STATICFILES_STORAGE¶

Awalan: 'django.contrib.staticfiles.storage.StaticFilesStorage'

Mesin penyimpanan berkas digunakan ketika mengumpulkan berkas-berkas statis dengan perintah pengelolaan collectstatic.

A ready-to-use instance of the storage backend defined in this setting can be found under staticfiles key in django.core.files.storage.storages.

Sebagai sebuah contoh, lihat Melayani berkas statis dari layanan cloud atau CDN.

STATICFILES_FINDERS¶

Awal:

[
    "django.contrib.staticfiles.finders.FileSystemFinder",
    "django.contrib.staticfiles.finders.AppDirectoriesFinder",
]

Daftar dari penemu backend yang mengetahui bagaimana menemukan berkas-berkas statis dalam beragam tempat.

The default will find files stored in the 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 STATICFILES_FINDERS setting, it will look for static files in the default file storage as defined by the default key in the STORAGES setting.

Penemu berkas statis saat ini dianggap antarmuka pribadi, dan antarmuka ini dengan demikian tidak terdokumentasi.

Tembolok¶

• CACHES
• CACHE_MIDDLEWARE_ALIAS
• CACHE_MIDDLEWARE_KEY_PREFIX
• CACHE_MIDDLEWARE_SECONDS

Basisdata¶

• DATABASES
• DATABASE_ROUTERS
• DEFAULT_INDEX_TABLESPACE
• DEFAULT_TABLESPACE

Mencari kesalahan¶

• DEBUG
• DEBUG_PROPAGATE_EXCEPTIONS

Surel¶

• ADMINS
• DEFAULT_CHARSET
• DEFAULT_FROM_EMAIL
• EMAIL_BACKEND
• EMAIL_FILE_PATH
• EMAIL_HOST
• EMAIL_HOST_PASSWORD
• EMAIL_HOST_USER
• EMAIL_PORT
• EMAIL_SSL_CERTFILE
• EMAIL_SSL_KEYFILE
• EMAIL_SUBJECT_PREFIX
• EMAIL_TIMEOUT
• EMAIL_USE_LOCALTIME
• EMAIL_USE_TLS
• MANAGERS
• SERVER_EMAIL

Pelaporan kesalahan¶

• DEFAULT_EXCEPTION_REPORTER
• DEFAULT_EXCEPTION_REPORTER_FILTER
• IGNORABLE_404_URLS
• MANAGERS
• SILENCED_SYSTEM_CHECKS

Unggah berkas¶

• DEFAULT_FILE_STORAGE
• FILE_UPLOAD_HANDLERS
• FILE_UPLOAD_MAX_MEMORY_SIZE
• FILE_UPLOAD_PERMISSIONS
• FILE_UPLOAD_TEMP_DIR
• MEDIA_ROOT
• MEDIA_URL
• STORAGES

Formulir¶

• FORM_RENDERER

Globalisasi (i18n/l10n)¶

• DATE_FORMAT
• DATE_INPUT_FORMATS
• DATETIME_FORMAT
• DATETIME_INPUT_FORMATS
• DECIMAL_SEPARATOR
• FIRST_DAY_OF_WEEK
• FORMAT_MODULE_PATH
• LANGUAGE_CODE
• LANGUAGE_COOKIE_AGE
• LANGUAGE_COOKIE_DOMAIN
• LANGUAGE_COOKIE_HTTPONLY
• LANGUAGE_COOKIE_NAME
• LANGUAGE_COOKIE_PATH
• LANGUAGE_COOKIE_SAMESITE
• LANGUAGE_COOKIE_SECURE
• LANGUAGES
• LANGUAGES_BIDI
• LOCALE_PATHS
• MONTH_DAY_FORMAT
• NUMBER_GROUPING
• SHORT_DATE_FORMAT
• SHORT_DATETIME_FORMAT
• THOUSAND_SEPARATOR
• TIME_FORMAT
• TIME_INPUT_FORMATS
• TIME_ZONE
• USE_I18N
• USE_L10N
• USE_THOUSAND_SEPARATOR
• USE_TZ
• YEAR_MONTH_FORMAT

HTTP¶

• DATA_UPLOAD_MAX_MEMORY_SIZE
• DATA_UPLOAD_MAX_NUMBER_FIELDS
• DATA_UPLOAD_MAX_NUMBER_FILES
• DEFAULT_CHARSET
• DISALLOWED_USER_AGENTS
• FORCE_SCRIPT_NAME
• INTERNAL_IPS
• MIDDLEWARE
• Keamanan
  • SECURE_CONTENT_TYPE_NOSNIFF
  • SECURE_CROSS_ORIGIN_OPENER_POLICY
  • SECURE_HSTS_INCLUDE_SUBDOMAINS
  • SECURE_HSTS_PRELOAD
  • SECURE_HSTS_SECONDS
  • SECURE_PROXY_SSL_HEADER
  • SECURE_REDIRECT_EXEMPT
  • SECURE_REFERRER_POLICY
  • SECURE_SSL_HOST
  • SECURE_SSL_REDIRECT
• SIGNING_BACKEND
• USE_X_FORWARDED_HOST
• USE_X_FORWARDED_PORT
• WSGI_APPLICATION

Pencatatan¶

• LOGGING
• LOGGING_CONFIG

Model¶

• ABSOLUTE_URL_OVERRIDES
• FIXTURE_DIRS
• INSTALLED_APPS

Keamanan¶

• Cross Site Request Forgery Protection
  • CSRF_COOKIE_DOMAIN
  • CSRF_COOKIE_NAME
  • CSRF_COOKIE_PATH
  • CSRF_COOKIE_SAMESITE
  • CSRF_COOKIE_SECURE
  • CSRF_FAILURE_VIEW
  • CSRF_HEADER_NAME
  • CSRF_TRUSTED_ORIGINS
  • CSRF_USE_SESSIONS
• SECRET_KEY
• SECRET_KEY_FALLBACKS
• X_FRAME_OPTIONS

Serialisasi¶

• DEFAULT_CHARSET
• SERIALIZATION_MODULES

Templat¶

• TEMPLATES

Pengujian¶

• Basisdata: TEST
• TEST_NON_SERIALIZED_APPS
• TEST_RUNNER

URL¶

• APPEND_SLASH
• PREPEND_WWW
• ROOT_URLCONF