Add files using upload-large-folder tool

testbed/django__django/docs/ref/checks.txt

@@ -0,0 +1,907 @@
+======================
+System check framework
+======================
+
+.. currentmodule:: django.core.checks
+
+The system check framework is a set of static checks for validating Django
+projects. It detects common problems and provides hints for how to fix them.
+The framework is extensible so you can easily add your own checks.
+
+For details on how to add your own checks and integrate them with Django's
+system checks, see the :doc:`System check topic guide </topics/checks>`.
+
+API reference
+=============
+
+``CheckMessage``
+----------------
+
+.. class:: CheckMessage(level, msg, hint=None, obj=None, id=None)
+
+The warnings and errors raised by system checks must be instances of
+``CheckMessage``. An instance encapsulates a single reportable error or
+warning. It also provides context and hints applicable to the message, and a
+unique identifier that is used for filtering purposes.
+
+Constructor arguments are:
+
+``level``
+    The severity of the message. Use one of the predefined values: ``DEBUG``,
+    ``INFO``, ``WARNING``, ``ERROR``, ``CRITICAL``. If the level is greater or
+    equal to ``ERROR``, then Django will prevent management commands from
+    executing. Messages with level lower than ``ERROR`` (i.e. warnings) are
+    reported to the console, but can be silenced.
+
+``msg``
+    A short (less than 80 characters) string describing the problem. The string
+    should *not* contain newlines.
+
+``hint``
+    A single-line string providing a hint for fixing the problem. If no hint
+    can be provided, or the hint is self-evident from the error message, the
+    hint can be omitted, or a value of ``None`` can be used.
+
+``obj``
+    Optional. An object providing context for the message (for example, the
+    model where the problem was discovered). The object should be a model,
+    field, or manager or any other object that defines a ``__str__()`` method.
+    The method is used while reporting all messages and its result precedes the
+    message.
+
+``id``
+    Optional string. A unique identifier for the issue. Identifiers should
+    follow the pattern ``applabel.X001``, where ``X`` is one of the letters
+    ``CEWID``, indicating the message severity (``C`` for criticals, ``E`` for
+    errors and so). The number can be allocated by the application, but should
+    be unique within that application.
+
+There are subclasses to make creating messages with common levels easier. When
+using them you can omit the ``level`` argument because it is implied by the
+class name.
+
+.. class:: Debug(msg, hint=None, obj=None, id=None)
+.. class:: Info(msg, hint=None, obj=None, id=None)
+.. class:: Warning(msg, hint=None obj=None, id=None)
+.. class:: Error(msg, hint=None, obj=None, id=None)
+.. class:: Critical(msg, hint=None, obj=None, id=None)
+
+.. _system-check-builtin-tags:
+
+Builtin tags
+============
+
+Django's system checks are organized using the following tags:
+
+* ``admin``: Checks of any admin site declarations.
+* ``async_support``: Checks asynchronous-related configuration.
+* ``caches``: Checks cache related configuration.
+* ``compatibility``: Flags potential problems with version upgrades.
+* ``database``: Checks database-related configuration issues. Database checks
+  are not run by default because they do more than static code analysis as
+  regular checks do. They are only run by the :djadmin:`migrate` command or if
+  you specify configured database aliases using the ``--database`` option when
+  calling the :djadmin:`check` command.
+* ``files``: Checks files related configuration.
+* ``models``: Checks of model, field, and manager definitions.
+* ``security``: Checks security related configuration.
+* ``signals``: Checks on signal declarations and handler registrations.
+* ``sites``: Checks :mod:`django.contrib.sites` configuration.
+* ``staticfiles``: Checks :mod:`django.contrib.staticfiles` configuration.
+* ``templates``: Checks template related configuration.
+* ``translation``: Checks translation related configuration.
+* ``urls``: Checks URL configuration.
+
+Some checks may be registered with multiple tags.
+
+Core system checks
+==================
+
+Asynchronous support
+--------------------
+
+The following checks verify your setup for :doc:`/topics/async`:
+
+* **async.E001**: You should not set the :envvar:`DJANGO_ALLOW_ASYNC_UNSAFE`
+  environment variable in deployment. This disables :ref:`async safety
+  protection <async-safety>`.
+
+Backwards compatibility
+-----------------------
+
+Compatibility checks warn of potential problems that might occur after
+upgrading Django.
+
+* **2_0.W001**: Your URL pattern ``<pattern>`` has a ``route`` that contains
+  ``(?P<``, begins with a ``^``, or ends with a ``$``. This was likely an
+  oversight when migrating from ``url()`` to :func:`~django.urls.path`.
+* **4_0.E001**: As of Django 4.0, the values in the
+  :setting:`CSRF_TRUSTED_ORIGINS` setting must start with a scheme (usually
+  ``http://`` or ``https://``) but found ``<hostname>``.
+
+Caches
+------
+
+The following checks verify that your :setting:`CACHES` setting is correctly
+configured:
+
+* **caches.E001**: You must define a ``'default'`` cache in your
+  :setting:`CACHES` setting.
+* **caches.W002**: Your ``<cache>`` configuration might expose your cache or
+  lead to corruption of your data because its
+  :setting:`LOCATION <CACHES-LOCATION>` matches/is inside/contains
+  :setting:`MEDIA_ROOT`/:setting:`STATIC_ROOT`/:setting:`STATICFILES_DIRS`.
+* **caches.W003**: Your ``<cache>`` cache :setting:`LOCATION <CACHES-LOCATION>`
+  is relative. Use an absolute path instead.
+
+Database
+--------
+
+MySQL and MariaDB
+~~~~~~~~~~~~~~~~~
+
+If you're using MySQL or MariaDB, the following checks will be performed:
+
+* **mysql.E001**: MySQL/MariaDB does not allow unique ``CharField``\s to have a
+  ``max_length`` > 255. *This check was changed to* ``mysql.W003`` *in Django
+  3.1 as the real maximum size depends on many factors.*
+* **mysql.W002**: MySQL/MariaDB Strict Mode is not set for database connection
+  ``<alias>``. See also :ref:`mysql-sql-mode`.
+* **mysql.W003**: MySQL/MariaDB may not allow unique ``CharField``\s to have a
+  ``max_length`` > 255.
+
+Managing files
+--------------
+
+The following checks verify your setup for :doc:`/topics/files`:
+
+* **files.E001**: The :setting:`FILE_UPLOAD_TEMP_DIR` setting refers to the
+  nonexistent directory ``<path>``.
+
+Model fields
+------------
+
+* **fields.E001**: Field names must not end with an underscore.
+* **fields.E002**: Field names must not contain ``"__"``.
+* **fields.E003**: ``pk`` is a reserved word that cannot be used as a field
+  name.
+* **fields.E004**: ``choices`` must be an iterable (e.g., a list or tuple).
+* **fields.E005**: ``choices`` must be an iterable containing ``(actual value,
+  human readable name)`` tuples.
+* **fields.E006**: ``db_index`` must be ``None``, ``True`` or ``False``.
+* **fields.E007**: Primary keys must not have ``null=True``.
+* **fields.E008**: All ``validators`` must be callable.
+* **fields.E009**: ``max_length`` is too small to fit the longest value in
+  ``choices`` (``<count>`` characters).
+* **fields.E010**: ``<field>`` default should be a callable instead of an
+  instance so that it's not shared between all field instances.
+* **fields.E011**: ``<database>`` does not support default database values with
+  expressions (``db_default``).
+* **fields.E012**: ``<expression>`` cannot be used in ``db_default``.
+* **fields.E100**: ``AutoField``\s must set primary_key=True.
+* **fields.E110**: ``BooleanField``\s do not accept null values. *This check
+  appeared before support for null values was added in Django 2.1.*
+* **fields.E120**: ``CharField``\s must define a ``max_length`` attribute.
+* **fields.E121**: ``max_length`` must be a positive integer.
+* **fields.W122**: ``max_length`` is ignored when used with
+  ``<integer field type>``.
+* **fields.E130**: ``DecimalField``\s must define a ``decimal_places`` attribute.
+* **fields.E131**: ``decimal_places`` must be a non-negative integer.
+* **fields.E132**: ``DecimalField``\s must define a ``max_digits`` attribute.
+* **fields.E133**: ``max_digits`` must be a positive integer.
+* **fields.E134**: ``max_digits`` must be greater or equal to ``decimal_places``.
+* **fields.E140**: ``FilePathField``\s must have either ``allow_files`` or
+  ``allow_folders`` set to True.
+* **fields.E150**: ``GenericIPAddressField``\s cannot have ``blank=True`` if
+  ``null=False``, as blank values are stored as nulls.
+* **fields.E160**: The options ``auto_now``, ``auto_now_add``, and ``default``
+  are mutually exclusive. Only one of these options may be present.
+* **fields.W161**: Fixed default value provided.
+* **fields.W162**: ``<database>`` does not support a database index on
+  ``<field data type>`` columns.
+* **fields.W163**: ``<database>`` does not support comments on columns
+  (``db_comment``).
+* **fields.E170**: ``BinaryField``’s ``default`` cannot be a string. Use bytes
+  content instead.
+* **fields.E180**: ``<database>`` does not support ``JSONField``\s.
+* **fields.E190**: ``<database>`` does not support a database collation on
+  ``<field_type>``\s.
+* **fields.E900**: ``IPAddressField`` has been removed except for support in
+  historical migrations.
+* **fields.W900**: ``IPAddressField`` has been deprecated. Support for it
+  (except in historical migrations) will be removed in Django 1.9. *This check
+  appeared in Django 1.7 and 1.8*.
+* **fields.W901**: ``CommaSeparatedIntegerField`` has been deprecated. Support
+  for it (except in historical migrations) will be removed in Django 2.0. *This
+  check appeared in Django 1.10 and 1.11*.
+* **fields.E901**: ``CommaSeparatedIntegerField`` is removed except for support
+  in historical migrations.
+* **fields.W902**: ``FloatRangeField`` is deprecated and will be removed in
+  Django 3.1. *This check appeared in Django 2.2 and 3.0*.
+* **fields.W903**: ``NullBooleanField`` is deprecated. Support for it (except
+  in historical migrations) will be removed in Django 4.0. *This check appeared
+  in Django 3.1 and 3.2*.
+* **fields.E903**: ``NullBooleanField`` is removed except for support in
+  historical migrations.
+* **fields.W904**: ``django.contrib.postgres.fields.JSONField`` is deprecated.
+  Support for it (except in historical migrations) will be removed in Django
+  4.0. *This check appeared in Django 3.1 and 3.2*.
+* **fields.E904**: ``django.contrib.postgres.fields.JSONField`` is removed
+  except for support in historical migrations.
+* **fields.W905**: ``django.contrib.postgres.fields.CICharField`` is
+  deprecated. Support for it (except in historical migrations) will be removed
+  in Django 5.1.
+* **fields.W906**: ``django.contrib.postgres.fields.CIEmailField`` is
+  deprecated. Support for it (except in historical migrations) will be removed
+  in Django 5.1.
+* **fields.W907**: ``django.contrib.postgres.fields.CITextField`` is
+  deprecated. Support for it (except in historical migrations) will be removed
+  in Django 5.1.
+
+File fields
+~~~~~~~~~~~
+
+* **fields.E200**: ``unique`` is not a valid argument for a ``FileField``.
+  *This check is removed in Django 1.11*.
+* **fields.E201**: ``primary_key`` is not a valid argument for a ``FileField``.
+* **fields.E202**: ``FileField``’s ``upload_to`` argument must be a relative
+  path, not an absolute path.
+* **fields.E210**: Cannot use ``ImageField`` because Pillow is not installed.
+
+Related fields
+~~~~~~~~~~~~~~
+
+* **fields.E300**: Field defines a relation with model ``<model>``, which is
+  either not installed, or is abstract.
+* **fields.E301**: Field defines a relation with the model
+  ``<app_label>.<model>`` which has been swapped out.
+* **fields.E302**: Reverse accessor ``<related model>.<accessor name>`` for
+  ``<app_label>.<model>.<field name>`` clashes with field name
+  ``<app_label>.<model>.<field name>``.
+* **fields.E303**: Reverse query name for ``<app_label>.<model>.<field name>``
+  clashes with field name ``<app_label>.<model>.<field name>``.
+* **fields.E304**: Reverse accessor ``<related model>.<accessor name>`` for
+  ``<app_label>.<model>.<field name>`` clashes with reverse accessor for
+  ``<app_label>.<model>.<field name>``.
+* **fields.E305**: Reverse query name for ``<app_label>.<model>.<field name>``
+  clashes with reverse query name for ``<app_label>.<model>.<field name>``.
+* **fields.E306**: The name ``<name>`` is invalid ``related_name`` for field
+  ``<model>.<field name>``.
+* **fields.E307**: The field ``<app label>.<model>.<field name>`` was declared
+  with a lazy reference to ``<app label>.<model>``, but app ``<app label>``
+  isn't installed or doesn't provide model ``<model>``.
+* **fields.E308**: Reverse query name ``<related query name>`` must not end
+  with an underscore.
+* **fields.E309**: Reverse query name ``<related query name>`` must not contain
+  ``'__'``.
+* **fields.E310**: No subset of the fields ``<field1>``, ``<field2>``, ... on
+  model ``<model>`` is unique.
+* **fields.E311**: ``<model>.<field name>`` must be unique because it is
+  referenced by a ``ForeignKey``.
+* **fields.E312**: The ``to_field`` ``<field name>`` doesn't exist on the
+  related model ``<app label>.<model>``.
+* **fields.E320**: Field specifies ``on_delete=SET_NULL``, but cannot be null.
+* **fields.E321**: The field specifies ``on_delete=SET_DEFAULT``, but has no
+  default value.
+* **fields.E330**: ``ManyToManyField``\s cannot be unique.
+* **fields.E331**: Field specifies a many-to-many relation through model
+  ``<model>``, which has not been installed.
+* **fields.E332**: Many-to-many fields with intermediate tables must not be
+  symmetrical. *This check appeared before Django 3.0.*
+* **fields.E333**: The model is used as an intermediate model by ``<model>``,
+  but it has more than two foreign keys to ``<model>``, which is ambiguous.
+  You must specify which two foreign keys Django should use via the
+  ``through_fields`` keyword argument.
+* **fields.E334**: The model is used as an intermediate model by ``<model>``,
+  but it has more than one foreign key from ``<model>``, which is ambiguous.
+  You must specify which foreign key Django should use via the
+  ``through_fields`` keyword argument.
+* **fields.E335**: The model is used as an intermediate model by ``<model>``,
+  but it has more than one foreign key to ``<model>``, which is ambiguous.
+  You must specify which foreign key Django should use via the
+  ``through_fields`` keyword argument.
+* **fields.E336**: The model is used as an intermediary model by ``<model>``,
+  but it does not have foreign key to ``<model>`` or ``<model>``.
+* **fields.E337**: Field specifies ``through_fields`` but does not provide the
+  names of the two link fields that should be used for the relation through
+  ``<model>``.
+* **fields.E338**: The intermediary model ``<through model>`` has no field
+  ``<field name>``.
+* **fields.E339**: ``<model>.<field name>`` is not a foreign key to ``<model>``.
+* **fields.E340**: The field's intermediary table ``<table name>`` clashes with
+  the table name of ``<model>``/``<model>.<field name>``.
+* **fields.W340**: ``null`` has no effect on ``ManyToManyField``.
+* **fields.W341**: ``ManyToManyField`` does not support ``validators``.
+* **fields.W342**: Setting ``unique=True`` on a ``ForeignKey`` has the same
+  effect as using a ``OneToOneField``.
+* **fields.W343**: ``limit_choices_to`` has no effect on ``ManyToManyField``
+  with a ``through`` model. *This check appeared before Django 4.0.*
+* **fields.W344**: The field's intermediary table ``<table name>`` clashes with
+  the table name of ``<model>``/``<model>.<field name>``.
+* **fields.W345**: ``related_name`` has no effect on ``ManyToManyField`` with a
+  symmetrical relationship, e.g. to "self".
+* **fields.W346**: ``db_comment`` has no effect on ``ManyToManyField``.
+
+Models
+------
+
+* **models.E001**: ``<swappable>`` is not of the form ``app_label.app_name``.
+* **models.E002**: ``<SETTING>`` references ``<model>``, which has not been
+  installed, or is abstract.
+* **models.E003**: The model has two identical many-to-many relations through
+  the intermediate model ``<app_label>.<model>``.
+* **models.E004**: ``id`` can only be used as a field name if the field also
+  sets ``primary_key=True``.
+* **models.E005**: The field ``<field name>`` from parent model ``<model>``
+  clashes with the field ``<field name>`` from parent model ``<model>``.
+* **models.E006**: The field ``<field name>`` clashes with the field
+  ``<field name>`` from model ``<model>``.
+* **models.E007**: Field ``<field name>`` has column name ``<column name>``
+  that is used by another field.
+* **models.E008**: ``index_together`` must be a list or tuple.
+* **models.E009**: All ``index_together`` elements must be lists or tuples.
+* **models.E010**: ``unique_together`` must be a list or tuple.
+* **models.E011**: All ``unique_together`` elements must be lists or tuples.
+* **models.E012**: ``constraints/indexes/index_together/unique_together``
+  refers to the nonexistent field ``<field name>``.
+* **models.E013**: ``constraints/indexes/index_together/unique_together``
+  refers to a ``ManyToManyField`` ``<field name>``, but ``ManyToManyField``\s
+  are not supported for that option.
+* **models.E014**: ``ordering`` must be a tuple or list (even if you want to
+  order by only one field).
+* **models.E015**: ``ordering`` refers to the nonexistent field, related field,
+  or lookup ``<field name>``.
+* **models.E016**: ``constraints/indexes/index_together/unique_together``
+  refers to field ``<field_name>`` which is not local to model ``<model>``.
+* **models.E017**: Proxy model ``<model>`` contains model fields.
+* **models.E018**: Autogenerated column name too long for field ``<field>``.
+  Maximum length is ``<maximum length>`` for database ``<alias>``.
+* **models.E019**: Autogenerated column name too long for M2M field
+  ``<M2M field>``. Maximum length is ``<maximum length>`` for database
+  ``<alias>``.
+* **models.E020**: The ``<model>.check()`` class method is currently overridden.
+* **models.E021**: ``ordering`` and ``order_with_respect_to`` cannot be used
+  together.
+* **models.E022**: ``<function>`` contains a lazy reference to
+  ``<app label>.<model>``, but app ``<app label>`` isn't installed or
+  doesn't provide model ``<model>``.
+* **models.E023**: The model name ``<model>`` cannot start or end with an
+  underscore as it collides with the query lookup syntax.
+* **models.E024**: The model name ``<model>`` cannot contain double underscores
+  as it collides with the query lookup syntax.
+* **models.E025**: The property ``<property name>`` clashes with a related
+  field accessor.
+* **models.E026**: The model cannot have more than one field with
+  ``primary_key=True``.
+* **models.W027**: ``<database>`` does not support check constraints.
+* **models.E028**: ``db_table`` ``<db_table>`` is used by multiple models:
+  ``<model list>``.
+* **models.E029**: index name ``<index>`` is not unique for model ``<model>``.
+* **models.E030**: index name ``<index>`` is not unique among models:
+  ``<model list>``.
+* **models.E031**: constraint name ``<constraint>`` is not unique for model
+  ``<model>``.
+* **models.E032**: constraint name ``<constraint>`` is not unique among
+  models: ``<model list>``.
+* **models.E033**: The index name ``<index>`` cannot start with an underscore
+  or a number.
+* **models.E034**: The index name ``<index>`` cannot be longer than
+  ``<max_length>`` characters.
+* **models.W035**: ``db_table`` ``<db_table>`` is used by multiple models:
+  ``<model list>``.
+* **models.W036**: ``<database>`` does not support unique constraints with
+  conditions.
+* **models.W037**: ``<database>`` does not support indexes with conditions.
+* **models.W038**: ``<database>`` does not support deferrable unique
+  constraints.
+* **models.W039**: ``<database>`` does not support unique constraints with
+  non-key columns.
+* **models.W040**: ``<database>`` does not support indexes with non-key
+  columns.
+* **models.E041**: ``constraints`` refers to the joined field ``<field name>``.
+* **models.W042**: Auto-created primary key used when not defining a primary
+  key type, by default ``django.db.models.AutoField``.
+* **models.W043**: ``<database>`` does not support indexes on expressions.
+* **models.W044**: ``<database>`` does not support unique constraints on
+  expressions.
+* **models.W045**: Check constraint ``<constraint>`` contains ``RawSQL()``
+  expression and won't be validated during the model ``full_clean()``.
+* **models.W046**: ``<database>`` does not support comments on tables
+  (``db_table_comment``).
+
+Security
+--------
+
+The security checks do not make your site secure. They do not audit code, do
+intrusion detection, or do anything particularly complex. Rather, they help
+perform an automated, low-hanging-fruit checklist, that can help you to improve
+your site's security.
+
+Some of these checks may not be appropriate for your particular deployment
+configuration. For instance, if you do your HTTP to HTTPS redirection in a load
+balancer, it'd be irritating to be constantly warned about not having enabled
+:setting:`SECURE_SSL_REDIRECT`. Use :setting:`SILENCED_SYSTEM_CHECKS` to
+silence unneeded checks.
+
+The following checks are run if you use the :option:`check --deploy` option:
+
+* **security.W001**: You do not have
+  :class:`django.middleware.security.SecurityMiddleware` in your
+  :setting:`MIDDLEWARE` so the :setting:`SECURE_HSTS_SECONDS`,
+  :setting:`SECURE_CONTENT_TYPE_NOSNIFF`, :setting:`SECURE_REFERRER_POLICY`,
+  :setting:`SECURE_CROSS_ORIGIN_OPENER_POLICY`, and
+  :setting:`SECURE_SSL_REDIRECT` settings will have no effect.
+* **security.W002**: You do not have
+  :class:`django.middleware.clickjacking.XFrameOptionsMiddleware` in your
+  :setting:`MIDDLEWARE`, so your pages will not be served with an
+  ``'x-frame-options'`` header. Unless there is a good reason for your
+  site to be served in a frame, you should consider enabling this
+  header to help prevent clickjacking attacks.
+* **security.W003**: You don't appear to be using Django's built-in cross-site
+  request forgery protection via the middleware
+  (:class:`django.middleware.csrf.CsrfViewMiddleware` is not in your
+  :setting:`MIDDLEWARE`). Enabling the middleware is the safest
+  approach to ensure you don't leave any holes.
+* **security.W004**: You have not set a value for the
+  :setting:`SECURE_HSTS_SECONDS` setting. If your entire site is served only
+  over SSL, you may want to consider setting a value and enabling :ref:`HTTP
+  Strict Transport Security <http-strict-transport-security>`. Be sure to read
+  the documentation first; enabling HSTS carelessly can cause serious,
+  irreversible problems.
+* **security.W005**: You have not set the
+  :setting:`SECURE_HSTS_INCLUDE_SUBDOMAINS` setting to ``True``. Without this,
+  your site is potentially vulnerable to attack via an insecure connection to a
+  subdomain. Only set this to ``True`` if you are certain that all subdomains of
+  your domain should be served exclusively via SSL.
+* **security.W006**: Your :setting:`SECURE_CONTENT_TYPE_NOSNIFF` setting is not
+  set to ``True``, so your pages will not be served with an
+  ``'X-Content-Type-Options: nosniff'`` header. You should consider enabling
+  this header to prevent the browser from identifying content types incorrectly.
+* **security.W007**: Your ``SECURE_BROWSER_XSS_FILTER`` setting is not
+  set to ``True``, so your pages will not be served with an
+  ``'X-XSS-Protection: 1; mode=block'`` header. You should consider enabling
+  this header to activate the browser's XSS filtering and help prevent XSS
+  attacks. *This check is removed in Django 3.0 as the* ``X-XSS-Protection``
+  *header is no longer honored by modern browsers.*
+* **security.W008**: Your :setting:`SECURE_SSL_REDIRECT` setting is not set to
+  ``True``. Unless your site should be available over both SSL and non-SSL
+  connections, you may want to either set this setting to ``True`` or configure
+  a load balancer or reverse-proxy server  to redirect all connections to HTTPS.
+* **security.W009**: Your :setting:`SECRET_KEY` has less than 50 characters,
+  less than 5 unique characters, or it's prefixed with ``'django-insecure-'``
+  indicating that it was generated automatically by Django. Please generate a
+  long and random value, otherwise many of Django's security-critical features
+  will be vulnerable to attack.
+* **security.W010**: You have :mod:`django.contrib.sessions` in your
+  :setting:`INSTALLED_APPS` but you have not set
+  :setting:`SESSION_COOKIE_SECURE` to ``True``. Using a secure-only session
+  cookie makes it more difficult for network traffic sniffers to hijack user
+  sessions.
+* **security.W011**: You have
+  :class:`django.contrib.sessions.middleware.SessionMiddleware` in your
+  :setting:`MIDDLEWARE`, but you have not set :setting:`SESSION_COOKIE_SECURE`
+  to ``True``. Using a secure-only session cookie makes it more difficult for
+  network traffic sniffers to hijack user sessions.
+* **security.W012**: :setting:`SESSION_COOKIE_SECURE` is not set to ``True``.
+  Using a secure-only session cookie makes it more difficult for network traffic
+  sniffers to hijack user sessions.
+* **security.W013**: You have :mod:`django.contrib.sessions` in your
+  :setting:`INSTALLED_APPS`, but you have not set
+  :setting:`SESSION_COOKIE_HTTPONLY` to ``True``. Using an ``HttpOnly`` session
+  cookie makes it more difficult for cross-site scripting attacks to hijack user
+  sessions.
+* **security.W014**: You have
+  :class:`django.contrib.sessions.middleware.SessionMiddleware` in your
+  :setting:`MIDDLEWARE`, but you have not set :setting:`SESSION_COOKIE_HTTPONLY`
+  to ``True``. Using an ``HttpOnly`` session cookie makes it more difficult for
+  cross-site scripting attacks to hijack user sessions.
+* **security.W015**: :setting:`SESSION_COOKIE_HTTPONLY` is not set to ``True``.
+  Using an ``HttpOnly`` session cookie makes it more difficult for cross-site
+  scripting attacks to hijack user sessions.
+* **security.W016**: :setting:`CSRF_COOKIE_SECURE` is not set to ``True``.
+  Using a secure-only CSRF cookie makes it more difficult for network traffic
+  sniffers to steal the CSRF token.
+* **security.W017**: :setting:`CSRF_COOKIE_HTTPONLY` is not set to ``True``.
+  Using an ``HttpOnly`` CSRF cookie makes it more difficult for cross-site
+  scripting attacks to steal the CSRF token. *This check is removed in Django
+  1.11 as the* :setting:`CSRF_COOKIE_HTTPONLY` *setting offers no practical
+  benefit.*
+* **security.W018**: You should not have :setting:`DEBUG` set to ``True`` in
+  deployment.
+* **security.W019**: You have
+  :class:`django.middleware.clickjacking.XFrameOptionsMiddleware` in your
+  :setting:`MIDDLEWARE`, but :setting:`X_FRAME_OPTIONS` is not set to
+  ``'DENY'``. Unless there is a good reason for your site to serve other parts
+  of itself in a frame, you should change it to ``'DENY'``.
+* **security.W020**: :setting:`ALLOWED_HOSTS` must not be empty in deployment.
+* **security.W021**: You have not set the
+  :setting:`SECURE_HSTS_PRELOAD` setting to ``True``. Without this, your site
+  cannot be submitted to the browser preload list.
+* **security.W022**: You have not set the :setting:`SECURE_REFERRER_POLICY`
+  setting. Without this, your site will not send a Referrer-Policy header. You
+  should consider enabling this header to protect user privacy.
+* **security.E023**: You have set the :setting:`SECURE_REFERRER_POLICY` setting
+  to an invalid value.
+* **security.E024**: You have set the
+  :setting:`SECURE_CROSS_ORIGIN_OPENER_POLICY` setting to an invalid value.
+* **security.W025**: Your
+  :setting:`SECRET_KEY_FALLBACKS[n] <SECRET_KEY_FALLBACKS>` has less than 50
+  characters, less than 5 unique characters, or it's prefixed with
+  ``'django-insecure-'`` indicating that it was generated automatically by
+  Django. Please generate a long and random value, otherwise many of Django's
+  security-critical features will be vulnerable to attack.
+
+The following checks verify that your security-related settings are correctly
+configured:
+
+* **security.E100**: ``DEFAULT_HASHING_ALGORITHM`` must be ``'sha1'`` or
+  ``'sha256'``. *This check appeared in Django 3.1 and 3.2*.
+* **security.E101**: The CSRF failure view ``'path.to.view'`` does not take the
+  correct number of arguments.
+* **security.E102**: The CSRF failure view ``'path.to.view'`` could not be
+  imported.
+
+Signals
+-------
+
+* **signals.E001**: ``<handler>`` was connected to the ``<signal>`` signal with
+  a lazy reference to the sender ``<app label>.<model>``, but app ``<app label>``
+  isn't installed or doesn't provide model ``<model>``.
+
+Templates
+---------
+
+The following checks verify that your :setting:`TEMPLATES` setting is correctly
+configured:
+
+* **templates.E001**: You have ``'APP_DIRS': True`` in your
+  :setting:`TEMPLATES` but also specify ``'loaders'`` in ``OPTIONS``. Either
+  remove ``APP_DIRS`` or remove the ``'loaders'`` option.
+* **templates.E002**: ``string_if_invalid`` in :setting:`TEMPLATES`
+  :setting:`OPTIONS <TEMPLATES-OPTIONS>` must be a string but got: ``{value}``
+  (``{type}``).
+* **templates.E003**:``<name>`` is used for multiple template tag modules:
+  ``<module list>``. *This check was changed to* ``templates.W003`` *in Django
+  4.1.2*.
+* **templates.W003**:``<name>`` is used for multiple template tag modules:
+  ``<module list>``.
+
+Translation
+-----------
+
+The following checks are performed on your translation configuration:
+
+* **translation.E001**: You have provided an invalid value for the
+  :setting:`LANGUAGE_CODE` setting: ``<value>``.
+* **translation.E002**: You have provided an invalid language code in the
+  :setting:`LANGUAGES` setting: ``<value>``.
+* **translation.E003**: You have provided an invalid language code in the
+  :setting:`LANGUAGES_BIDI` setting: ``<value>``.
+* **translation.E004**: You have provided a value for the
+  :setting:`LANGUAGE_CODE` setting that is not in the :setting:`LANGUAGES`
+  setting.
+
+URLs
+----
+
+The following checks are performed on your URL configuration:
+
+* **urls.W001**: Your URL pattern ``<pattern>`` uses
+  :func:`~django.urls.include` with a ``route`` ending with a ``$``. Remove the
+  dollar from the ``route`` to avoid problems including URLs.
+* **urls.W002**: Your URL pattern ``<pattern>`` has a ``route`` beginning with
+  a ``/``. Remove this slash as it is unnecessary. If this pattern is targeted
+  in an :func:`~django.urls.include`, ensure the :func:`~django.urls.include`
+  pattern has a trailing ``/``.
+* **urls.W003**: Your URL pattern ``<pattern>`` has a ``name``
+  including a ``:``. Remove the colon, to avoid ambiguous namespace
+  references.
+* **urls.E004**: Your URL pattern ``<pattern>`` is invalid. Ensure that
+  ``urlpatterns`` is a list of :func:`~django.urls.path` and/or
+  :func:`~django.urls.re_path` instances.
+* **urls.W005**: URL namespace ``<namespace>`` isn't unique. You may not be
+  able to reverse all URLs in this namespace.
+* **urls.E006**: The :setting:`MEDIA_URL`/ :setting:`STATIC_URL` setting must
+  end with a slash.
+* **urls.E007**: The custom ``handlerXXX`` view ``'path.to.view'`` does not
+  take the correct number of arguments (…).
+* **urls.E008**: The custom ``handlerXXX`` view ``'path.to.view'`` could not be
+  imported.
+* **urls.E009**: Your URL pattern ``<pattern>`` has an invalid view, pass
+  ``<view>.as_view()`` instead of ``<view>``.
+
+``contrib`` app checks
+======================
+
+``admin``
+---------
+
+Admin checks are all performed as part of the ``admin`` tag.
+
+The following checks are performed on any
+:class:`~django.contrib.admin.ModelAdmin` (or subclass) that is registered
+with the admin site:
+
+* **admin.E001**: The value of ``raw_id_fields`` must be a list or tuple.
+* **admin.E002**: The value of ``raw_id_fields[n]`` refers to ``<field name>``,
+  which is not a field of ``<model>``.
+* **admin.E003**: The value of ``raw_id_fields[n]`` must be a foreign key or
+  a many-to-many field.
+* **admin.E004**: The value of ``fields`` must be a list or tuple.
+* **admin.E005**: Both ``fieldsets`` and ``fields`` are specified.
+* **admin.E006**: The value of ``fields`` contains duplicate field(s).
+* **admin.E007**: The value of ``fieldsets`` must be a list or tuple.
+* **admin.E008**: The value of ``fieldsets[n]`` must be a list or tuple.
+* **admin.E009**: The value of ``fieldsets[n]`` must be of length 2.
+* **admin.E010**: The value of ``fieldsets[n][1]`` must be a dictionary.
+* **admin.E011**: The value of ``fieldsets[n][1]`` must contain the key
+  ``fields``.
+* **admin.E012**: There are duplicate field(s) in ``fieldsets[n][1]``.
+* **admin.E013**: The value of
+  ``fields[n]/filter_horizontal[n]/filter_vertical[n]/fieldsets[n][m]`` cannot
+  include the ``ManyToManyField`` ``<field name>``, because that field manually
+  specifies a relationship model.
+* **admin.E014**: The value of ``exclude`` must be a list or tuple.
+* **admin.E015**: The value of ``exclude`` contains duplicate field(s).
+* **admin.E016**: The value of ``form`` must inherit from ``BaseModelForm``.
+* **admin.E017**: The value of ``filter_vertical`` must be a list or tuple.
+* **admin.E018**: The value of ``filter_horizontal`` must be a list or tuple.
+* **admin.E019**: The value of ``filter_vertical[n]/filter_horizontal[n]``
+  refers to ``<field name>``, which is not a field of ``<model>``.
+* **admin.E020**: The value of ``filter_vertical[n]/filter_horizontal[n]``
+  must be a many-to-many field.
+* **admin.E021**: The value of ``radio_fields`` must be a dictionary.
+* **admin.E022**: The value of ``radio_fields`` refers to ``<field name>``,
+  which is not a field of ``<model>``.
+* **admin.E023**: The value of ``radio_fields`` refers to ``<field name>``,
+  which is not an instance of ``ForeignKey``, and does not have a ``choices``
+  definition.
+* **admin.E024**: The value of ``radio_fields[<field name>]`` must be either
+  ``admin.HORIZONTAL`` or ``admin.VERTICAL``.
+* **admin.E025**: The value of ``view_on_site`` must be either a callable or a
+  boolean value.
+* **admin.E026**: The value of ``prepopulated_fields`` must be a dictionary.
+* **admin.E027**: The value of ``prepopulated_fields`` refers to
+  ``<field name>``, which is not a field of ``<model>``.
+* **admin.E028**: The value of ``prepopulated_fields`` refers to
+  ``<field name>``, which must not be a ``DateTimeField``, a ``ForeignKey``,
+  a ``OneToOneField``, or a ``ManyToManyField`` field.
+* **admin.E029**: The value of ``prepopulated_fields[<field name>]`` must be a
+  list or tuple.
+* **admin.E030**: The value of ``prepopulated_fields`` refers to
+  ``<field name>``, which is not a field of ``<model>``.
+* **admin.E031**: The value of ``ordering`` must be a list or tuple.
+* **admin.E032**: The value of ``ordering`` has the random ordering marker
+  ``?``, but contains other fields as well.
+* **admin.E033**: The value of ``ordering`` refers to ``<field name>``, which
+  is not a field of ``<model>``.
+* **admin.E034**: The value of ``readonly_fields`` must be a list or tuple.
+* **admin.E035**: The value of ``readonly_fields[n]`` refers to
+  ``<field_name>``, which is not a callable, an attribute of
+  ``<ModelAdmin class>``, or an attribute of ``<model>``.
+* **admin.E036**: The value of ``autocomplete_fields`` must be a list or tuple.
+* **admin.E037**: The value of ``autocomplete_fields[n]`` refers to
+  ``<field name>``, which is not a field of ``<model>``.
+* **admin.E038**: The value of ``autocomplete_fields[n]`` must be a foreign
+  key or a many-to-many field.
+* **admin.E039**: An admin for model ``<model>`` has to be registered to be
+  referenced by ``<modeladmin>.autocomplete_fields``.
+* **admin.E040**: ``<modeladmin>`` must define ``search_fields``, because
+  it's referenced by ``<other_modeladmin>.autocomplete_fields``.
+
+``ModelAdmin``
+~~~~~~~~~~~~~~
+
+The following checks are performed on any
+:class:`~django.contrib.admin.ModelAdmin` that is registered
+with the admin site:
+
+* **admin.E101**: The value of ``save_as`` must be a boolean.
+* **admin.E102**: The value of ``save_on_top`` must be a boolean.
+* **admin.E103**: The value of ``inlines`` must be a list or tuple.
+* **admin.E104**: ``<InlineModelAdmin class>`` must inherit from
+  ``InlineModelAdmin``.
+* **admin.E105**: ``<InlineModelAdmin class>`` must have a ``model`` attribute.
+* **admin.E106**: The value of ``<InlineModelAdmin class>.model`` must be a
+  ``Model``.
+* **admin.E107**: The value of ``list_display`` must be a list or tuple.
+* **admin.E108**: The value of ``list_display[n]`` refers to ``<label>``,
+  which is not a callable, an attribute of ``<ModelAdmin class>``, or an
+  attribute or method on ``<model>``.
+* **admin.E109**: The value of ``list_display[n]`` must not be a many-to-many
+  field or a reverse foreign key.
+* **admin.E110**: The value of ``list_display_links`` must be a list, a tuple,
+  or ``None``.
+* **admin.E111**: The value of ``list_display_links[n]`` refers to ``<label>``,
+  which is not defined in ``list_display``.
+* **admin.E112**: The value of ``list_filter`` must be a list or tuple.
+* **admin.E113**: The value of ``list_filter[n]`` must inherit from
+  ``ListFilter``.
+* **admin.E114**: The value of ``list_filter[n]`` must not inherit from
+  ``FieldListFilter``.
+* **admin.E115**: The value of ``list_filter[n][1]`` must inherit from
+  ``FieldListFilter``.
+* **admin.E116**: The value of ``list_filter[n]`` refers to ``<label>``,
+  which does not refer to a Field.
+* **admin.E117**: The value of ``list_select_related`` must be a boolean,
+  tuple or list.
+* **admin.E118**: The value of ``list_per_page`` must be an integer.
+* **admin.E119**: The value of ``list_max_show_all`` must be an integer.
+* **admin.E120**: The value of ``list_editable`` must be a list or tuple.
+* **admin.E121**: The value of ``list_editable[n]`` refers to ``<label>``,
+  which is not a field of ``<model>``.
+* **admin.E122**: The value of ``list_editable[n]`` refers to ``<label>``,
+  which is not contained in ``list_display``.
+* **admin.E123**: The value of ``list_editable[n]`` cannot be in both
+  ``list_editable`` and ``list_display_links``.
+* **admin.E124**: The value of ``list_editable[n]`` refers to the first field
+  in ``list_display`` (``<label>``), which cannot be used unless
+  ``list_display_links`` is set.
+* **admin.E125**: The value of ``list_editable[n]`` refers to ``<field name>``,
+  which is not editable through the admin.
+* **admin.E126**: The value of ``search_fields`` must be a list or tuple.
+* **admin.E127**: The value of ``date_hierarchy`` refers to ``<field name>``,
+  which does not refer to a Field.
+* **admin.E128**: The value of ``date_hierarchy`` must be a ``DateField`` or
+  ``DateTimeField``.
+* **admin.E129**: ``<modeladmin>`` must define a ``has_<foo>_permission()``
+  method for the ``<action>`` action.
+* **admin.E130**: ``__name__`` attributes of actions defined in
+  ``<modeladmin>`` must be unique. Name ``<name>`` is not unique.
+
+``InlineModelAdmin``
+~~~~~~~~~~~~~~~~~~~~
+
+The following checks are performed on any
+:class:`~django.contrib.admin.InlineModelAdmin` that is registered as an
+inline on a :class:`~django.contrib.admin.ModelAdmin`.
+
+* **admin.E201**: Cannot exclude the field ``<field name>``, because it is the
+  foreign key to the parent model ``<app_label>.<model>``.
+* **admin.E202**: ``<model>`` has no ``ForeignKey`` to ``<parent model>``./
+  ``<model>`` has more than one ``ForeignKey`` to ``<parent model>``. You must
+  specify a ``fk_name`` attribute.
+* **admin.E203**: The value of ``extra`` must be an integer.
+* **admin.E204**: The value of ``max_num`` must be an integer.
+* **admin.E205**: The value of ``min_num`` must be an integer.
+* **admin.E206**: The value of ``formset`` must inherit from
+  ``BaseModelFormSet``.
+
+``GenericInlineModelAdmin``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The following checks are performed on any
+:class:`~django.contrib.contenttypes.admin.GenericInlineModelAdmin` that is
+registered as an inline on a :class:`~django.contrib.admin.ModelAdmin`.
+
+* **admin.E301**: ``'ct_field'`` references ``<label>``, which is not a field
+  on ``<model>``.
+* **admin.E302**: ``'ct_fk_field'`` references ``<label>``, which is not a
+  field on ``<model>``.
+* **admin.E303**: ``<model>`` has no ``GenericForeignKey``.
+* **admin.E304**: ``<model>`` has no ``GenericForeignKey`` using content type
+  field ``<field name>`` and object ID field ``<field name>``.
+
+``AdminSite``
+~~~~~~~~~~~~~
+
+The following checks are performed on the default
+:class:`~django.contrib.admin.AdminSite`:
+
+* **admin.E401**: :mod:`django.contrib.contenttypes` must be in
+  :setting:`INSTALLED_APPS` in order to use the admin application.
+* **admin.E402**: :mod:`django.contrib.auth.context_processors.auth`
+  must be enabled in :class:`~django.template.backends.django.DjangoTemplates`
+  (:setting:`TEMPLATES`) if using the default auth backend in order to use the
+  admin application.
+* **admin.E403**: A :class:`django.template.backends.django.DjangoTemplates`
+  instance must be configured in :setting:`TEMPLATES` in order to use the
+  admin application.
+* **admin.E404**: ``django.contrib.messages.context_processors.messages``
+  must be enabled in :class:`~django.template.backends.django.DjangoTemplates`
+  (:setting:`TEMPLATES`) in order to use the admin application.
+* **admin.E405**: :mod:`django.contrib.auth` must be in
+  :setting:`INSTALLED_APPS` in order to use the admin application.
+* **admin.E406**: :mod:`django.contrib.messages` must be in
+  :setting:`INSTALLED_APPS` in order to use the admin application.
+* **admin.E408**:
+  :class:`django.contrib.auth.middleware.AuthenticationMiddleware` must be in
+  :setting:`MIDDLEWARE` in order to use the admin application.
+* **admin.E409**: :class:`django.contrib.messages.middleware.MessageMiddleware`
+  must be in :setting:`MIDDLEWARE` in order to use the admin application.
+* **admin.E410**: :class:`django.contrib.sessions.middleware.SessionMiddleware`
+  must be in :setting:`MIDDLEWARE` in order to use the admin application.
+* **admin.W411**: ``django.template.context_processors.request`` must be
+  enabled in :class:`~django.template.backends.django.DjangoTemplates`
+  (:setting:`TEMPLATES`) in order to use the admin navigation sidebar.
+
+``auth``
+--------
+
+* **auth.E001**: ``REQUIRED_FIELDS`` must be a list or tuple.
+* **auth.E002**: The field named as the ``USERNAME_FIELD`` for a custom user
+  model must not be included in ``REQUIRED_FIELDS``.
+* **auth.E003**: ``<field>`` must be unique because it is named as the
+  ``USERNAME_FIELD``.
+* **auth.W004**: ``<field>`` is named as the ``USERNAME_FIELD``, but it is not
+  unique.
+* **auth.E005**: The permission codenamed ``<codename>`` clashes with a builtin
+  permission for model ``<model>``.
+* **auth.E006**: The permission codenamed ``<codename>`` is duplicated for model
+  ``<model>``.
+* **auth.E007**: The :attr:`verbose_name
+  <django.db.models.Options.verbose_name>` of model ``<model>`` must be at most
+  244 characters for its builtin permission names
+  to be at most 255 characters.
+* **auth.E008**: The permission named ``<name>`` of model ``<model>`` is longer
+  than 255 characters.
+* **auth.C009**: ``<User model>.is_anonymous`` must be an attribute or property
+  rather than a method. Ignoring this is a security issue as anonymous users
+  will be treated as authenticated!
+* **auth.C010**: ``<User model>.is_authenticated`` must be an attribute or
+  property rather than a method. Ignoring this is a security issue as anonymous
+  users will be treated as authenticated!
+* **auth.E011**: The name of model ``<model>`` must be at most 93 characters
+  for its builtin permission names to be at most 100 characters.
+* **auth.E012**: The permission codenamed ``<codename>`` of model ``<model>``
+  is longer than 100 characters.
+
+``contenttypes``
+----------------
+
+The following checks are performed when a model contains a
+:class:`~django.contrib.contenttypes.fields.GenericForeignKey` or
+:class:`~django.contrib.contenttypes.fields.GenericRelation`:
+
+* **contenttypes.E001**: The ``GenericForeignKey`` object ID references the
+  nonexistent field ``<field>``.
+* **contenttypes.E002**: The ``GenericForeignKey`` content type references the
+  nonexistent field ``<field>``.
+* **contenttypes.E003**: ``<field>`` is not a ``ForeignKey``.
+* **contenttypes.E004**: ``<field>`` is not a ``ForeignKey`` to
+  ``contenttypes.ContentType``.
+* **contenttypes.E005**: Model names must be at most 100 characters.
+
+``postgres``
+------------
+
+The following checks are performed on :mod:`django.contrib.postgres` model
+fields:
+
+* **postgres.E001**: Base field for array has errors: ...
+* **postgres.E002**: Base field for array cannot be a related field.
+* **postgres.E003**: ``<field>`` default should be a callable instead of an
+  instance so that it's not shared between all field instances. *This check was
+  changed to* ``fields.E010`` *in Django 3.1*.
+* **postgres.W004**: Base field for array has warnings: ...
+
+``sites``
+---------
+
+The following checks are performed on any model using a
+:class:`~django.contrib.sites.managers.CurrentSiteManager`:
+
+* **sites.E001**: ``CurrentSiteManager`` could not find a field named
+  ``<field name>``.
+* **sites.E002**: ``CurrentSiteManager`` cannot use ``<field>`` as it is not a
+  foreign key or a many-to-many field.
+
+The following checks verify that :mod:`django.contrib.sites` is correctly
+configured:
+
+* **sites.E101**: The :setting:`SITE_ID` setting must be an integer.
+
+``staticfiles``
+---------------
+
+The following checks verify that :mod:`django.contrib.staticfiles` is correctly
+configured:
+
+* **staticfiles.E001**: The :setting:`STATICFILES_DIRS` setting is not a tuple
+  or list.
+* **staticfiles.E002**: The :setting:`STATICFILES_DIRS` setting should not
+  contain the :setting:`STATIC_ROOT` setting.
+* **staticfiles.E003**: The prefix ``<prefix>`` in the
+  :setting:`STATICFILES_DIRS` setting must not end with a slash.
+* **staticfiles.W004**: The directory ``<directory>`` in the
+  :setting:`STATICFILES_DIRS` does not exist.

testbed/django__django/docs/ref/clickjacking.txt

@@ -0,0 +1,149 @@
+========================
+Clickjacking Protection
+========================
+
+.. module:: django.middleware.clickjacking
+   :synopsis: Protects against Clickjacking
+
+The clickjacking middleware and decorators provide easy-to-use protection
+against `clickjacking`_.  This type of attack occurs when a malicious site
+tricks a user into clicking on a concealed element of another site which they
+have loaded in a hidden frame or iframe.
+
+.. _clickjacking: https://en.wikipedia.org/wiki/Clickjacking
+
+An example of clickjacking
+==========================
+
+Suppose an online store has a page where a logged in user can click "Buy Now" to
+purchase an item. A user has chosen to stay logged into the store all the time
+for convenience. An attacker site might create an "I Like Ponies" button on one
+of their own pages, and load the store's page in a transparent iframe such that
+the "Buy Now" button is invisibly overlaid on the "I Like Ponies" button. If the
+user visits the attacker's site, clicking "I Like Ponies" will cause an
+inadvertent click on the "Buy Now" button and an unknowing purchase of the item.
+
+.. _clickjacking-prevention:
+
+Preventing clickjacking
+=======================
+
+Modern browsers honor the `X-Frame-Options`_ HTTP header that indicates whether
+or not a resource is allowed to load within a frame or iframe. If the response
+contains the header with a value of ``SAMEORIGIN`` then the browser will only
+load the resource in a frame if the request originated from the same site. If
+the header is set to ``DENY`` then the browser will block the resource from
+loading in a frame no matter which site made the request.
+
+.. _X-Frame-Options: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options
+
+Django provides a few ways to include this header in responses from your site:
+
+#. A middleware that sets the header in all responses.
+
+#. A set of view decorators that can be used to override the middleware or to
+   only set the header for certain views.
+
+The ``X-Frame-Options`` HTTP header will only be set by the middleware or view
+decorators if it is not already present in the response.
+
+How to use it
+=============
+
+Setting ``X-Frame-Options`` for all responses
+---------------------------------------------
+
+To set the same ``X-Frame-Options`` value for all responses in your site, put
+``'django.middleware.clickjacking.XFrameOptionsMiddleware'`` to
+:setting:`MIDDLEWARE`::
+
+    MIDDLEWARE = [
+        ...,
+        "django.middleware.clickjacking.XFrameOptionsMiddleware",
+        ...,
+    ]
+
+This middleware is enabled in the settings file generated by
+:djadmin:`startproject`.
+
+By default, the middleware will set the ``X-Frame-Options`` header to
+``DENY`` for every outgoing ``HttpResponse``. If you want any other value for
+this header instead, set the :setting:`X_FRAME_OPTIONS` setting::
+
+    X_FRAME_OPTIONS = "SAMEORIGIN"
+
+When using the middleware there may be some views where you do **not** want the
+``X-Frame-Options`` header set. For those cases, you can use a view decorator
+that tells the middleware not to set the header::
+
+    from django.http import HttpResponse
+    from django.views.decorators.clickjacking import xframe_options_exempt
+
+
+    @xframe_options_exempt
+    def ok_to_load_in_a_frame(request):
+        return HttpResponse("This page is safe to load in a frame on any site.")
+
+.. note::
+
+    If you want to submit a form or access a session cookie within a frame or
+    iframe, you may need to modify the :setting:`CSRF_COOKIE_SAMESITE` or
+    :setting:`SESSION_COOKIE_SAMESITE` settings.
+
+.. versionchanged:: 5.0
+
+    Support for wrapping asynchronous view functions was added to the
+    ``@xframe_options_exempt`` decorator.
+
+Setting ``X-Frame-Options`` per view
+------------------------------------
+
+To set the ``X-Frame-Options`` header on a per view basis, Django provides these
+decorators::
+
+    from django.http import HttpResponse
+    from django.views.decorators.clickjacking import xframe_options_deny
+    from django.views.decorators.clickjacking import xframe_options_sameorigin
+
+
+    @xframe_options_deny
+    def view_one(request):
+        return HttpResponse("I won't display in any frame!")
+
+
+    @xframe_options_sameorigin
+    def view_two(request):
+        return HttpResponse("Display in a frame if it's from the same origin as me.")
+
+Note that you can use the decorators in conjunction with the middleware. Use of
+a decorator overrides the middleware.
+
+.. versionchanged:: 5.0
+
+    Support for wrapping asynchronous view functions was added to the
+    ``@xframe_options_deny`` and ``@xframe_options_sameorigin`` decorators.
+
+Limitations
+===========
+
+The ``X-Frame-Options`` header will only protect against clickjacking in a
+modern browser. Older browsers will quietly ignore the header and need `other
+clickjacking prevention techniques`_.
+
+Browsers that support ``X-Frame-Options``
+-----------------------------------------
+
+* Internet Explorer 8+
+* Edge
+* Firefox 3.6.9+
+* Opera 10.5+
+* Safari 4+
+* Chrome 4.1+
+
+See also
+--------
+
+A `complete list`_ of browsers supporting ``X-Frame-Options``.
+
+.. _complete list: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options#browser_compatibility
+.. _other clickjacking prevention techniques: https://en.wikipedia.org/wiki/Clickjacking#Prevention

testbed/django__django/docs/ref/databases.txt

@@ -0,0 +1,1193 @@
+=========
+Databases
+=========
+
+Django officially supports the following databases:
+
+* :ref:`PostgreSQL <postgresql-notes>`
+* :ref:`MariaDB <mariadb-notes>`
+* :ref:`MySQL <mysql-notes>`
+* :ref:`Oracle <oracle-notes>`
+* :ref:`SQLite <sqlite-notes>`
+
+There are also a number of :ref:`database backends provided by third parties
+<third-party-notes>`.
+
+Django attempts to support as many features as possible on all database
+backends. However, not all database backends are alike, and we've had to make
+design decisions on which features to support and which assumptions we can make
+safely.
+
+This file describes some of the features that might be relevant to Django
+usage. It is not intended as a replacement for server-specific documentation or
+reference manuals.
+
+General notes
+=============
+
+.. _persistent-database-connections:
+
+Persistent connections
+----------------------
+
+Persistent connections avoid the overhead of reestablishing a connection to
+the database in each HTTP request. They're controlled by the
+:setting:`CONN_MAX_AGE` parameter which defines the maximum lifetime of a
+connection. It can be set independently for each database.
+
+The default value is ``0``, preserving the historical behavior of closing the
+database connection at the end of each request. To enable persistent
+connections, set :setting:`CONN_MAX_AGE` to a positive integer of seconds. For
+unlimited persistent connections, set it to ``None``.
+
+Connection management
+~~~~~~~~~~~~~~~~~~~~~
+
+Django opens a connection to the database when it first makes a database
+query. It keeps this connection open and reuses it in subsequent requests.
+Django closes the connection once it exceeds the maximum age defined by
+:setting:`CONN_MAX_AGE` or when it isn't usable any longer.
+
+In detail, Django automatically opens a connection to the database whenever it
+needs one and doesn't have one already — either because this is the first
+connection, or because the previous connection was closed.
+
+At the beginning of each request, Django closes the connection if it has
+reached its maximum age. If your database terminates idle connections after
+some time, you should set :setting:`CONN_MAX_AGE` to a lower value, so that
+Django doesn't attempt to use a connection that has been terminated by the
+database server. (This problem may only affect very low traffic sites.)
+
+At the end of each request, Django closes the connection if it has reached its
+maximum age or if it is in an unrecoverable error state. If any database
+errors have occurred while processing the requests, Django checks whether the
+connection still works, and closes it if it doesn't. Thus, database errors
+affect at most one request per each application's worker thread; if the
+connection becomes unusable, the next request gets a fresh connection.
+
+Setting :setting:`CONN_HEALTH_CHECKS` to ``True`` can be used to improve the
+robustness of connection reuse and prevent errors when a connection has been
+closed by the database server which is now ready to accept and serve new
+connections, e.g. after database server restart. The health check is performed
+only once per request and only if the database is being accessed during the
+handling of the request.
+
+Caveats
+~~~~~~~
+
+Since each thread maintains its own connection, your database must support at
+least as many simultaneous connections as you have worker threads.
+
+Sometimes a database won't be accessed by the majority of your views, for
+example because it's the database of an external system, or thanks to caching.
+In such cases, you should set :setting:`CONN_MAX_AGE` to a low value or even
+``0``, because it doesn't make sense to maintain a connection that's unlikely
+to be reused. This will help keep the number of simultaneous connections to
+this database small.
+
+The development server creates a new thread for each request it handles,
+negating the effect of persistent connections. Don't enable them during
+development.
+
+When Django establishes a connection to the database, it sets up appropriate
+parameters, depending on the backend being used. If you enable persistent
+connections, this setup is no longer repeated every request. If you modify
+parameters such as the connection's isolation level or time zone, you should
+either restore Django's defaults at the end of each request, force an
+appropriate value at the beginning of each request, or disable persistent
+connections.
+
+If a connection is created in a long-running process, outside of Django’s
+request-response cycle, the connection will remain open until explicitly
+closed, or timeout occurs.
+
+Encoding
+--------
+
+Django assumes that all databases use UTF-8 encoding. Using other encodings may
+result in unexpected behavior such as "value too long" errors from your
+database for data that is valid in Django. See the database specific notes
+below for information on how to set up your database correctly.
+
+.. _postgresql-notes:
+
+PostgreSQL notes
+================
+
+Django supports PostgreSQL 12 and higher. `psycopg`_ 3.1.8+ or `psycopg2`_
+2.8.4+ is required, though the latest `psycopg`_ 3.1.8+ is recommended.
+
+.. note::
+
+    Support for ``psycopg2`` is likely to be deprecated and removed at some
+    point in the future.
+
+.. versionchanged:: 4.2
+
+    Support for ``psycopg`` 3.1.8+ was added.
+
+.. _postgresql-connection-settings:
+
+PostgreSQL connection settings
+-------------------------------
+
+See :setting:`HOST` for details.
+
+To connect using a service name from the `connection service file`_ and a
+password from the `password file`_, you must specify them in the
+:setting:`OPTIONS` part of your database configuration in :setting:`DATABASES`:
+
+.. code-block:: python
+    :caption: ``settings.py``
+
+    DATABASES = {
+        "default": {
+            "ENGINE": "django.db.backends.postgresql",
+            "OPTIONS": {
+                "service": "my_service",
+                "passfile": ".my_pgpass",
+            },
+        }
+    }
+
+.. code-block:: text
+    :caption: ``.pg_service.conf``
+
+    [my_service]
+    host=localhost
+    user=USER
+    dbname=NAME
+    port=5432
+
+.. code-block:: text
+    :caption: ``.my_pgpass``
+
+    localhost:5432:NAME:USER:PASSWORD
+
+.. _connection service file: https://www.postgresql.org/docs/current/libpq-pgservice.html
+.. _password file: https://www.postgresql.org/docs/current/libpq-pgpass.html
+
+.. warning::
+
+    Using a service name for testing purposes is not supported. This
+    :ticket:`may be implemented later <33685>`.
+
+Optimizing PostgreSQL's configuration
+-------------------------------------
+
+Django needs the following parameters for its database connections:
+
+- ``client_encoding``: ``'UTF8'``,
+- ``default_transaction_isolation``: ``'read committed'`` by default,
+  or the value set in the connection options (see below),
+- ``timezone``:
+    - when :setting:`USE_TZ` is ``True``, ``'UTC'`` by default, or the
+      :setting:`TIME_ZONE <DATABASE-TIME_ZONE>` value set for the connection,
+    - when :setting:`USE_TZ` is ``False``, the value of the global
+      :setting:`TIME_ZONE` setting.
+
+If these parameters already have the correct values, Django won't set them for
+every new connection, which improves performance slightly. You can configure
+them directly in :file:`postgresql.conf` or more conveniently per database
+user with `ALTER ROLE`_.
+
+Django will work just fine without this optimization, but each new connection
+will do some additional queries to set these parameters.
+
+.. _ALTER ROLE: https://www.postgresql.org/docs/current/sql-alterrole.html
+
+.. _database-isolation-level:
+
+Isolation level
+---------------
+
+Like PostgreSQL itself, Django defaults to the ``READ COMMITTED`` `isolation
+level`_. If you need a higher isolation level such as ``REPEATABLE READ`` or
+``SERIALIZABLE``, set it in the :setting:`OPTIONS` part of your database
+configuration in :setting:`DATABASES`::
+
+    from django.db.backends.postgresql.psycopg_any import IsolationLevel
+
+    DATABASES = {
+        # ...
+        "OPTIONS": {
+            "isolation_level": IsolationLevel.SERIALIZABLE,
+        },
+    }
+
+.. note::
+
+    Under higher isolation levels, your application should be prepared to
+    handle exceptions raised on serialization failures. This option is
+    designed for advanced uses.
+
+.. _isolation level: https://www.postgresql.org/docs/current/transaction-iso.html
+
+.. versionchanged:: 4.2
+
+    ``IsolationLevel`` was added.
+
+.. _database-role:
+
+Role
+----
+
+.. versionadded:: 4.2
+
+If you need to use a different role for database connections than the role use
+to establish the connection, set it in the :setting:`OPTIONS` part of your
+database configuration in :setting:`DATABASES`::
+
+    DATABASES = {
+        "default": {
+            "ENGINE": "django.db.backends.postgresql",
+            # ...
+            "OPTIONS": {
+                "assume_role": "my_application_role",
+            },
+        },
+    }
+
+.. _database-server-side-parameters-binding:
+
+Server-side parameters binding
+------------------------------
+
+.. versionadded:: 4.2
+
+With `psycopg`_ 3.1.8+, Django defaults to the :ref:`client-side binding
+cursors <psycopg:client-side-binding-cursors>`. If you want to use the
+:ref:`server-side binding <psycopg:server-side-binding>` set it in the
+:setting:`OPTIONS` part of your database configuration in
+:setting:`DATABASES`::
+
+    DATABASES = {
+        "default": {
+            "ENGINE": "django.db.backends.postgresql",
+            # ...
+            "OPTIONS": {
+                "server_side_binding": True,
+            },
+        },
+    }
+
+This option is ignored with ``psycopg2``.
+
+Indexes for ``varchar`` and ``text`` columns
+--------------------------------------------
+
+When specifying ``db_index=True`` on your model fields, Django typically
+outputs a single ``CREATE INDEX`` statement.  However, if the database type
+for the field is either ``varchar`` or ``text`` (e.g., used by ``CharField``,
+``FileField``, and ``TextField``), then Django will create
+an additional index that uses an appropriate `PostgreSQL operator class`_
+for the column.  The extra index is necessary to correctly perform
+lookups that use the ``LIKE`` operator in their SQL, as is done with the
+``contains`` and ``startswith`` lookup types.
+
+.. _PostgreSQL operator class: https://www.postgresql.org/docs/current/indexes-opclass.html
+
+Migration operation for adding extensions
+-----------------------------------------
+
+If you need to add a PostgreSQL extension (like ``hstore``, ``postgis``, etc.)
+using a migration, use the
+:class:`~django.contrib.postgres.operations.CreateExtension` operation.
+
+.. _postgresql-server-side-cursors:
+
+Server-side cursors
+-------------------
+
+When using :meth:`QuerySet.iterator()
+<django.db.models.query.QuerySet.iterator>`, Django opens a :ref:`server-side
+cursor <psycopg:server-side-cursors>`. By default, PostgreSQL assumes that
+only the first 10% of the results of cursor queries will be fetched. The query
+planner spends less time planning the query and starts returning results
+faster, but this could diminish performance if more than 10% of the results are
+retrieved. PostgreSQL's assumptions on the number of rows retrieved for a
+cursor query is controlled with the `cursor_tuple_fraction`_ option.
+
+.. _cursor_tuple_fraction: https://www.postgresql.org/docs/current/runtime-config-query.html#GUC-CURSOR-TUPLE-FRACTION
+
+.. _transaction-pooling-server-side-cursors:
+
+Transaction pooling and server-side cursors
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Using a connection pooler in transaction pooling mode (e.g. `PgBouncer`_)
+requires disabling server-side cursors for that connection.
+
+Server-side cursors are local to a connection and remain open at the end of a
+transaction when :setting:`AUTOCOMMIT <DATABASE-AUTOCOMMIT>` is ``True``. A
+subsequent transaction may attempt to fetch more results from a server-side
+cursor. In transaction pooling mode, there's no guarantee that subsequent
+transactions will use the same connection. If a different connection is used,
+an error is raised when the transaction references the server-side cursor,
+because server-side cursors are only accessible in the connection in which they
+were created.
+
+One solution is to disable server-side cursors for a connection in
+:setting:`DATABASES` by setting :setting:`DISABLE_SERVER_SIDE_CURSORS
+<DATABASE-DISABLE_SERVER_SIDE_CURSORS>` to ``True``.
+
+To benefit from server-side cursors in transaction pooling mode, you could set
+up :doc:`another connection to the database </topics/db/multi-db>` in order to
+perform queries that use server-side cursors. This connection needs to either
+be directly to the database or to a connection pooler in session pooling mode.
+
+Another option is to wrap each ``QuerySet`` using server-side cursors in an
+:func:`~django.db.transaction.atomic` block, because it disables ``autocommit``
+for the duration of the transaction. This way, the server-side cursor will only
+live for the duration of the transaction.
+
+.. _PgBouncer: https://www.pgbouncer.org/
+
+.. _manually-specified-autoincrement-pk:
+
+Manually-specifying values of auto-incrementing primary keys
+------------------------------------------------------------
+
+Django uses PostgreSQL's identity columns to store auto-incrementing primary
+keys. An identity column is populated with values from a `sequence`_ that keeps
+track of the next available value. Manually assigning a value to an
+auto-incrementing field doesn't update the field's sequence, which might later
+cause a conflict. For example:
+
+.. code-block:: pycon
+
+    >>> from django.contrib.auth.models import User
+    >>> User.objects.create(username="alice", pk=1)
+    <User: alice>
+    >>> # The sequence hasn't been updated; its next value is 1.
+    >>> User.objects.create(username="bob")
+    IntegrityError: duplicate key value violates unique constraint
+    "auth_user_pkey" DETAIL:  Key (id)=(1) already exists.
+
+If you need to specify such values, reset the sequence afterward to avoid
+reusing a value that's already in the table. The :djadmin:`sqlsequencereset`
+management command generates the SQL statements to do that.
+
+.. _sequence: https://www.postgresql.org/docs/current/sql-createsequence.html
+
+Test database templates
+-----------------------
+
+You can use the :setting:`TEST['TEMPLATE'] <TEST_TEMPLATE>` setting to specify
+a `template`_ (e.g. ``'template0'``) from which to create a test database.
+
+.. _template: https://www.postgresql.org/docs/current/sql-createdatabase.html
+
+Speeding up test execution with non-durable settings
+----------------------------------------------------
+
+You can speed up test execution times by `configuring PostgreSQL to be
+non-durable <https://www.postgresql.org/docs/current/non-durability.html>`_.
+
+.. warning::
+
+    This is dangerous: it will make your database more susceptible to data loss
+    or corruption in the case of a server crash or power loss. Only use this on
+    a development machine where you can easily restore the entire contents of
+    all databases in the cluster.
+
+.. _psycopg: https://www.psycopg.org/psycopg3/
+.. _psycopg2: https://www.psycopg.org/
+
+.. _mariadb-notes:
+
+MariaDB notes
+=============
+
+Django supports MariaDB 10.4 and higher.
+
+To use MariaDB, use the MySQL backend, which is shared between the two. See the
+:ref:`MySQL notes <mysql-notes>` for more details.
+
+.. _mysql-notes:
+
+MySQL notes
+===========
+
+Version support
+---------------
+
+Django supports MySQL 8 and higher.
+
+Django's ``inspectdb`` feature uses the ``information_schema`` database, which
+contains detailed data on all database schemas.
+
+Django expects the database to support Unicode (UTF-8 encoding) and delegates to
+it the task of enforcing transactions and referential integrity. It is important
+to be aware of the fact that the two latter ones aren't actually enforced by
+MySQL when using the MyISAM storage engine, see the next section.
+
+.. _mysql-storage-engines:
+
+Storage engines
+---------------
+
+MySQL has several `storage engines`_. You can change the default storage engine
+in the server configuration.
+
+MySQL's default storage engine is InnoDB_. This engine is fully transactional
+and supports foreign key references. It's the recommended choice. However, the
+InnoDB autoincrement counter is lost on a MySQL restart because it does not
+remember the ``AUTO_INCREMENT`` value, instead recreating it as "max(id)+1".
+This may result in an inadvertent reuse of :class:`~django.db.models.AutoField`
+values.
+
+The main drawbacks of MyISAM_ are that it doesn't support transactions or
+enforce foreign-key constraints.
+
+.. _storage engines: https://dev.mysql.com/doc/refman/en/storage-engines.html
+.. _MyISAM: https://dev.mysql.com/doc/refman/en/myisam-storage-engine.html
+.. _InnoDB: https://dev.mysql.com/doc/refman/en/innodb-storage-engine.html
+
+.. _mysql-db-api-drivers:
+
+MySQL DB API Drivers
+--------------------
+
+MySQL has a couple drivers that implement the Python Database API described in
+:pep:`249`:
+
+- :pypi:`mysqlclient` is a native driver. It's **the recommended choice**.
+- `MySQL Connector/Python`_ is a pure Python driver from Oracle that does not
+  require the MySQL client library or any Python modules outside the standard
+  library.
+
+.. _MySQL Connector/Python: https://dev.mysql.com/downloads/connector/python/
+
+These drivers are thread-safe and provide connection pooling.
+
+In addition to a DB API driver, Django needs an adapter to access the database
+drivers from its ORM. Django provides an adapter for mysqlclient while MySQL
+Connector/Python includes `its own`_.
+
+.. _its own: https://dev.mysql.com/doc/connector-python/en/connector-python-django-backend.html
+
+mysqlclient
+~~~~~~~~~~~
+
+Django requires `mysqlclient`_ 1.4.3 or later.
+
+MySQL Connector/Python
+~~~~~~~~~~~~~~~~~~~~~~
+
+MySQL Connector/Python is available from the `download page`_.
+The Django adapter is available in versions 1.1.X and later. It may not
+support the most recent releases of Django.
+
+.. _download page: https://dev.mysql.com/downloads/connector/python/
+
+.. _mysql-time-zone-definitions:
+
+Time zone definitions
+---------------------
+
+If you plan on using Django's :doc:`timezone support </topics/i18n/timezones>`,
+use `mysql_tzinfo_to_sql`_ to load time zone tables into the MySQL database.
+This needs to be done just once for your MySQL server, not per database.
+
+.. _mysql_tzinfo_to_sql: https://dev.mysql.com/doc/refman/en/mysql-tzinfo-to-sql.html
+
+Creating your database
+----------------------
+
+You can `create your database`_ using the command-line tools and this SQL:
+
+.. code-block:: sql
+
+  CREATE DATABASE <dbname> CHARACTER SET utf8;
+
+This ensures all tables and columns will use UTF-8 by default.
+
+.. _create your database: https://dev.mysql.com/doc/refman/en/create-database.html
+
+.. _mysql-collation:
+
+Collation settings
+~~~~~~~~~~~~~~~~~~
+
+The collation setting for a column controls the order in which data is sorted
+as well as what strings compare as equal. You can specify the ``db_collation``
+parameter to set the collation name of the column for
+:attr:`CharField <django.db.models.CharField.db_collation>` and
+:attr:`TextField <django.db.models.TextField.db_collation>`.
+
+The collation can also be set on a database-wide level and per-table. This is
+`documented thoroughly`_ in the MySQL documentation. In such cases, you must
+set the collation by directly manipulating the database settings or tables.
+Django doesn't provide an API to change them.
+
+.. _documented thoroughly: https://dev.mysql.com/doc/refman/en/charset.html
+
+By default, with a UTF-8 database, MySQL will use the
+``utf8_general_ci`` collation. This results in all string equality
+comparisons being done in a *case-insensitive* manner. That is, ``"Fred"`` and
+``"freD"`` are considered equal at the database level. If you have a unique
+constraint on a field, it would be illegal to try to insert both ``"aa"`` and
+``"AA"`` into the same column, since they compare as equal (and, hence,
+non-unique) with the default collation. If you want case-sensitive comparisons
+on a particular column or table, change the column or table to use the
+``utf8_bin`` collation.
+
+Please note that according to `MySQL Unicode Character Sets`_, comparisons for
+the ``utf8_general_ci`` collation are faster, but slightly less correct, than
+comparisons for ``utf8_unicode_ci``. If this is acceptable for your application,
+you should use ``utf8_general_ci`` because it is faster. If this is not acceptable
+(for example, if you require German dictionary order), use ``utf8_unicode_ci``
+because it is more accurate.
+
+.. _MySQL Unicode Character Sets: https://dev.mysql.com/doc/refman/en/charset-unicode-sets.html
+
+.. warning::
+
+    Model formsets validate unique fields in a case-sensitive manner. Thus when
+    using a case-insensitive collation, a formset with unique field values that
+    differ only by case will pass validation, but upon calling ``save()``, an
+    ``IntegrityError`` will be raised.
+
+Connecting to the database
+--------------------------
+
+Refer to the :doc:`settings documentation </ref/settings>`.
+
+Connection settings are used in this order:
+
+#. :setting:`OPTIONS`.
+#. :setting:`NAME`, :setting:`USER`, :setting:`PASSWORD`, :setting:`HOST`,
+   :setting:`PORT`
+#. MySQL option files.
+
+In other words, if you set the name of the database in :setting:`OPTIONS`,
+this will take precedence over :setting:`NAME`, which would override
+anything in a `MySQL option file`_.
+
+Here's a sample configuration which uses a MySQL option file::
+
+    # settings.py
+    DATABASES = {
+        "default": {
+            "ENGINE": "django.db.backends.mysql",
+            "OPTIONS": {
+                "read_default_file": "/path/to/my.cnf",
+            },
+        }
+    }
+
+.. code-block:: ini
+
+    # my.cnf
+    [client]
+    database = NAME
+    user = USER
+    password = PASSWORD
+    default-character-set = utf8
+
+Several other `MySQLdb connection options`_ may be useful, such as ``ssl``,
+``init_command``, and ``sql_mode``.
+
+.. _MySQL option file: https://dev.mysql.com/doc/refman/en/option-files.html
+.. _MySQLdb connection options: https://mysqlclient.readthedocs.io/user_guide.html#functions-and-attributes
+
+.. _mysql-sql-mode:
+
+Setting ``sql_mode``
+~~~~~~~~~~~~~~~~~~~~
+
+The default value of the ``sql_mode`` option contains ``STRICT_TRANS_TABLES``.
+That option escalates warnings into errors when data are truncated upon
+insertion, so Django highly recommends activating a `strict mode`_ for MySQL to
+prevent data loss (either ``STRICT_TRANS_TABLES`` or ``STRICT_ALL_TABLES``).
+
+.. _strict mode: https://dev.mysql.com/doc/refman/en/sql-mode.html#sql-mode-strict
+
+If you need to customize the SQL mode, you can set the ``sql_mode`` variable
+like other MySQL options: either in a config file or with the entry
+``'init_command': "SET sql_mode='STRICT_TRANS_TABLES'"`` in the
+:setting:`OPTIONS` part of your database configuration in :setting:`DATABASES`.
+
+.. _mysql-isolation-level:
+
+Isolation level
+~~~~~~~~~~~~~~~
+
+When running concurrent loads, database transactions from different sessions
+(say, separate threads handling different requests) may interact with each
+other. These interactions are affected by each session's `transaction isolation
+level`_. You can set a connection's isolation level with an
+``'isolation_level'`` entry in the :setting:`OPTIONS` part of your database
+configuration in :setting:`DATABASES`. Valid values for
+this entry are the four standard isolation levels:
+
+* ``'read uncommitted'``
+* ``'read committed'``
+* ``'repeatable read'``
+* ``'serializable'``
+
+or ``None`` to use the server's configured isolation level. However, Django
+works best with and defaults to read committed rather than MySQL's default,
+repeatable read. Data loss is possible with repeatable read. In particular,
+you may see cases where :meth:`~django.db.models.query.QuerySet.get_or_create`
+will raise an :exc:`~django.db.IntegrityError` but the object won't appear in
+a subsequent :meth:`~django.db.models.query.QuerySet.get` call.
+
+.. _transaction isolation level: https://dev.mysql.com/doc/refman/en/innodb-transaction-isolation-levels.html
+
+Creating your tables
+--------------------
+
+When Django generates the schema, it doesn't specify a storage engine, so
+tables will be created with whatever default storage engine your database
+server is configured for. The easiest solution is to set your database server's
+default storage engine to the desired engine.
+
+If you're using a hosting service and can't change your server's default
+storage engine, you have a couple of options.
+
+* After the tables are created, execute an ``ALTER TABLE`` statement to
+  convert a table to a new storage engine (such as InnoDB):
+
+  .. code-block:: sql
+
+      ALTER TABLE <tablename> ENGINE=INNODB;
+
+  This can be tedious if you have a lot of tables.
+
+* Another option is to use the ``init_command`` option for MySQLdb prior to
+  creating your tables::
+
+      "OPTIONS": {
+          "init_command": "SET default_storage_engine=INNODB",
+      }
+
+  This sets the default storage engine upon connecting to the database.
+  After your tables have been created, you should remove this option as it
+  adds a query that is only needed during table creation to each database
+  connection.
+
+Table names
+-----------
+
+There are `known issues`_ in even the latest versions of MySQL that can cause the
+case of a table name to be altered when certain SQL statements are executed
+under certain conditions. It is recommended that you use lowercase table
+names, if possible, to avoid any problems that might arise from this behavior.
+Django uses lowercase table names when it auto-generates table names from
+models, so this is mainly a consideration if you are overriding the table name
+via the :class:`~django.db.models.Options.db_table` parameter.
+
+.. _known issues: https://bugs.mysql.com/bug.php?id=48875
+
+Savepoints
+----------
+
+Both the Django ORM and MySQL (when using the InnoDB :ref:`storage engine
+<mysql-storage-engines>`) support database :ref:`savepoints
+<topics-db-transactions-savepoints>`.
+
+If you use the MyISAM storage engine please be aware of the fact that you will
+receive database-generated errors if you try to use the :ref:`savepoint-related
+methods of the transactions API <topics-db-transactions-savepoints>`. The reason
+for this is that detecting the storage engine of a MySQL database/table is an
+expensive operation so it was decided it isn't worth to dynamically convert
+these methods in no-op's based in the results of such detection.
+
+Notes on specific fields
+------------------------
+
+.. _mysql-character-fields:
+
+Character fields
+~~~~~~~~~~~~~~~~
+
+Any fields that are stored with ``VARCHAR`` column types may have their
+``max_length`` restricted to 255 characters if you are using ``unique=True``
+for the field. This affects :class:`~django.db.models.CharField`,
+:class:`~django.db.models.SlugField`. See `the MySQL documentation`_ for more
+details.
+
+.. _the MySQL documentation: https://dev.mysql.com/doc/refman/en/create-index.html#create-index-column-prefixes
+
+``TextField`` limitations
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+MySQL can index only the first N chars of a ``BLOB`` or ``TEXT`` column. Since
+``TextField`` doesn't have a defined length, you can't mark it as
+``unique=True``. MySQL will report: "BLOB/TEXT column '<db_column>' used in key
+specification without a key length".
+
+.. _mysql-fractional-seconds:
+
+Fractional seconds support for Time and DateTime fields
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+MySQL can store fractional seconds, provided that the column definition
+includes a fractional indication (e.g. ``DATETIME(6)``).
+
+Django will not upgrade existing columns to include fractional seconds if the
+database server supports it. If you want to enable them on an existing database,
+it's up to you to either manually update the column on the target database, by
+executing a command like:
+
+.. code-block:: sql
+
+    ALTER TABLE `your_table` MODIFY `your_datetime_column` DATETIME(6)
+
+or using a :class:`~django.db.migrations.operations.RunSQL` operation in a
+:ref:`data migration <data-migrations>`.
+
+``TIMESTAMP`` columns
+~~~~~~~~~~~~~~~~~~~~~
+
+If you are using a legacy database that contains ``TIMESTAMP`` columns, you must
+set :setting:`USE_TZ = False <USE_TZ>` to avoid data corruption.
+:djadmin:`inspectdb` maps these columns to
+:class:`~django.db.models.DateTimeField` and if you enable timezone support,
+both MySQL and Django will attempt to convert the values from UTC to local time.
+
+Row locking with ``QuerySet.select_for_update()``
+-------------------------------------------------
+
+MySQL and MariaDB do not support some options to the ``SELECT ... FOR UPDATE``
+statement. If ``select_for_update()`` is used with an unsupported option, then
+a :exc:`~django.db.NotSupportedError` is raised.
+
+=============== ========= ==========
+Option          MariaDB   MySQL
+=============== ========= ==========
+``SKIP LOCKED`` X (≥10.6) X (≥8.0.1)
+``NOWAIT``      X         X (≥8.0.1)
+``OF``                    X (≥8.0.1)
+``NO KEY``
+=============== ========= ==========
+
+When using ``select_for_update()`` on MySQL, make sure you filter a queryset
+against at least a set of fields contained in unique constraints or only
+against fields covered by indexes. Otherwise, an exclusive write lock will be
+acquired over the full table for the duration of the transaction.
+
+Automatic typecasting can cause unexpected results
+--------------------------------------------------
+
+When performing a query on a string type, but with an integer value, MySQL will
+coerce the types of all values in the table to an integer before performing the
+comparison. If your table contains the values ``'abc'``, ``'def'`` and you
+query for ``WHERE mycolumn=0``, both rows will match. Similarly, ``WHERE mycolumn=1``
+will match the value ``'abc1'``. Therefore, string type fields included in Django
+will always cast the value to a string before using it in a query.
+
+If you implement custom model fields that inherit from
+:class:`~django.db.models.Field` directly, are overriding
+:meth:`~django.db.models.Field.get_prep_value`, or use
+:class:`~django.db.models.expressions.RawSQL`,
+:meth:`~django.db.models.query.QuerySet.extra`, or
+:meth:`~django.db.models.Manager.raw`, you should ensure that you perform
+appropriate typecasting.
+
+.. _sqlite-notes:
+
+SQLite notes
+============
+
+Django supports SQLite 3.21.0 and later.
+
+SQLite_ provides an excellent development alternative for applications that
+are predominantly read-only or require a smaller installation footprint. As
+with all database servers, though, there are some differences that are
+specific to SQLite that you should be aware of.
+
+.. _SQLite: https://www.sqlite.org/
+
+.. _sqlite-string-matching:
+
+Substring matching and case sensitivity
+---------------------------------------
+
+For all SQLite versions, there is some slightly counter-intuitive behavior when
+attempting to match some types of strings.  These are triggered when using the
+:lookup:`iexact` or :lookup:`contains` filters in Querysets. The behavior
+splits into two cases:
+
+1. For substring matching, all matches are done case-insensitively. That is a
+filter such as ``filter(name__contains="aa")`` will match a name of ``"Aabb"``.
+
+2. For strings containing characters outside the ASCII range, all exact string
+matches are performed case-sensitively, even when the case-insensitive options
+are passed into the query. So the :lookup:`iexact` filter will behave exactly
+the same as the :lookup:`exact` filter in these cases.
+
+Some possible workarounds for this are `documented at sqlite.org`_, but they
+aren't utilized by the default SQLite backend in Django, as incorporating them
+would be fairly difficult to do robustly. Thus, Django exposes the default
+SQLite behavior and you should be aware of this when doing case-insensitive or
+substring filtering.
+
+.. _documented at sqlite.org: https://www.sqlite.org/faq.html#q18
+
+.. _sqlite-decimal-handling:
+
+Decimal handling
+----------------
+
+SQLite has no real decimal internal type. Decimal values are internally
+converted to the ``REAL`` data type (8-byte IEEE floating point number), as
+explained in the `SQLite datatypes documentation`__, so they don't support
+correctly-rounded decimal floating point arithmetic.
+
+__ https://www.sqlite.org/datatype3.html#storage_classes_and_datatypes
+
+"Database is locked" errors
+---------------------------
+
+SQLite is meant to be a lightweight database, and thus can't support a high
+level of concurrency. ``OperationalError: database is locked`` errors indicate
+that your application is experiencing more concurrency than ``sqlite`` can
+handle in default configuration. This error means that one thread or process has
+an exclusive lock on the database connection and another thread timed out
+waiting for the lock the be released.
+
+Python's SQLite wrapper has
+a default timeout value that determines how long the second thread is allowed to
+wait on the lock before it times out and raises the ``OperationalError: database
+is locked`` error.
+
+If you're getting this error, you can solve it by:
+
+* Switching to another database backend. At a certain point SQLite becomes
+  too "lite" for real-world applications, and these sorts of concurrency
+  errors indicate you've reached that point.
+
+* Rewriting your code to reduce concurrency and ensure that database
+  transactions are short-lived.
+
+* Increase the default timeout value by setting the ``timeout`` database
+  option::
+
+      "OPTIONS": {
+          # ...
+          "timeout": 20,
+          # ...
+      }
+
+  This will make SQLite wait a bit longer before throwing "database is locked"
+  errors; it won't really do anything to solve them.
+
+``QuerySet.select_for_update()`` not supported
+----------------------------------------------
+
+SQLite does not support the ``SELECT ... FOR UPDATE`` syntax. Calling it will
+have no effect.
+
+.. _sqlite-isolation:
+
+Isolation when using ``QuerySet.iterator()``
+--------------------------------------------
+
+There are special considerations described in `Isolation In SQLite`_ when
+modifying a table while iterating over it using :meth:`.QuerySet.iterator`. If
+a row is added, changed, or deleted within the loop, then that row may or may
+not appear, or may appear twice, in subsequent results fetched from the
+iterator. Your code must handle this.
+
+.. _`Isolation in SQLite`: https://www.sqlite.org/isolation.html
+
+.. _sqlite-json1:
+
+Enabling JSON1 extension on SQLite
+----------------------------------
+
+To use :class:`~django.db.models.JSONField` on SQLite, you need to enable the
+`JSON1 extension`_ on Python's :py:mod:`sqlite3` library. If the extension is
+not enabled on your installation, a system error (``fields.E180``) will be
+raised.
+
+To enable the JSON1 extension you can follow the instruction on
+`the wiki page`_.
+
+.. note::
+
+    The JSON1 extension is enabled by default on SQLite 3.38+.
+
+.. _JSON1 extension: https://www.sqlite.org/json1.html
+.. _the wiki page: https://code.djangoproject.com/wiki/JSON1Extension
+
+.. _oracle-notes:
+
+Oracle notes
+============
+
+Django supports `Oracle Database Server`_ versions 19c and higher. Version 7.0
+or higher of the `cx_Oracle`_ Python driver is required.
+
+.. _`Oracle Database Server`: https://www.oracle.com/
+.. _`cx_Oracle`: https://oracle.github.io/python-cx_Oracle/
+
+In order for the ``python manage.py migrate`` command to work, your Oracle
+database user must have privileges to run the following commands:
+
+* CREATE TABLE
+* CREATE SEQUENCE
+* CREATE PROCEDURE
+* CREATE TRIGGER
+
+To run a project's test suite, the user usually needs these *additional*
+privileges:
+
+* CREATE USER
+* ALTER USER
+* DROP USER
+* CREATE TABLESPACE
+* DROP TABLESPACE
+* CREATE SESSION WITH ADMIN OPTION
+* CREATE TABLE WITH ADMIN OPTION
+* CREATE SEQUENCE WITH ADMIN OPTION
+* CREATE PROCEDURE WITH ADMIN OPTION
+* CREATE TRIGGER WITH ADMIN OPTION
+
+While the ``RESOURCE`` role has the required ``CREATE TABLE``,
+``CREATE SEQUENCE``, ``CREATE PROCEDURE``, and ``CREATE TRIGGER`` privileges,
+and a user granted ``RESOURCE WITH ADMIN OPTION`` can grant ``RESOURCE``, such
+a user cannot grant the individual privileges (e.g. ``CREATE TABLE``), and thus
+``RESOURCE WITH ADMIN OPTION`` is not usually sufficient for running tests.
+
+Some test suites also create views or materialized views; to run these, the
+user also needs ``CREATE VIEW WITH ADMIN OPTION`` and
+``CREATE MATERIALIZED VIEW WITH ADMIN OPTION`` privileges. In particular, this
+is needed for Django's own test suite.
+
+All of these privileges are included in the DBA role, which is appropriate
+for use on a private developer's database.
+
+The Oracle database backend uses the ``SYS.DBMS_LOB`` and ``SYS.DBMS_RANDOM``
+packages, so your user will require execute permissions on it. It's normally
+accessible to all users by default, but in case it is not, you'll need to grant
+permissions like so:
+
+.. code-block:: sql
+
+    GRANT EXECUTE ON SYS.DBMS_LOB TO user;
+    GRANT EXECUTE ON SYS.DBMS_RANDOM TO user;
+
+Connecting to the database
+--------------------------
+
+To connect using the service name of your Oracle database, your ``settings.py``
+file should look something like this::
+
+    DATABASES = {
+        "default": {
+            "ENGINE": "django.db.backends.oracle",
+            "NAME": "xe",
+            "USER": "a_user",
+            "PASSWORD": "a_password",
+            "HOST": "",
+            "PORT": "",
+        }
+    }
+
+
+In this case, you should leave both :setting:`HOST` and :setting:`PORT` empty.
+However, if you don't use a ``tnsnames.ora`` file or a similar naming method
+and want to connect using the SID ("xe" in this example), then fill in both
+:setting:`HOST` and :setting:`PORT` like so::
+
+    DATABASES = {
+        "default": {
+            "ENGINE": "django.db.backends.oracle",
+            "NAME": "xe",
+            "USER": "a_user",
+            "PASSWORD": "a_password",
+            "HOST": "dbprod01ned.mycompany.com",
+            "PORT": "1540",
+        }
+    }
+
+You should either supply both :setting:`HOST` and :setting:`PORT`, or leave
+both as empty strings. Django will use a different connect descriptor depending
+on that choice.
+
+Full DSN and Easy Connect
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A Full DSN or Easy Connect string can be used in :setting:`NAME` if both
+:setting:`HOST` and :setting:`PORT` are empty. This format is required when
+using RAC or pluggable databases without ``tnsnames.ora``, for example.
+
+Example of an Easy Connect string::
+
+    "NAME": "localhost:1521/orclpdb1"
+
+Example of a full DSN string::
+
+    "NAME": (
+        "(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=localhost)(PORT=1521))"
+        "(CONNECT_DATA=(SERVICE_NAME=orclpdb1)))"
+    )
+
+Threaded option
+---------------
+
+If you plan to run Django in a multithreaded environment (e.g. Apache using the
+default MPM module on any modern operating system), then you **must** set
+the ``threaded`` option of your Oracle database configuration to ``True``::
+
+    "OPTIONS": {
+        "threaded": True,
+    }
+
+Failure to do this may result in crashes and other odd behavior.
+
+INSERT ... RETURNING INTO
+-------------------------
+
+By default, the Oracle backend uses a ``RETURNING INTO`` clause to efficiently
+retrieve the value of an ``AutoField`` when inserting new rows.  This behavior
+may result in a ``DatabaseError`` in certain unusual setups, such as when
+inserting into a remote table, or into a view with an ``INSTEAD OF`` trigger.
+The ``RETURNING INTO`` clause can be disabled by setting the
+``use_returning_into`` option of the database configuration to ``False``::
+
+    "OPTIONS": {
+        "use_returning_into": False,
+    }
+
+In this case, the Oracle backend will use a separate ``SELECT`` query to
+retrieve ``AutoField`` values.
+
+Naming issues
+-------------
+
+Oracle imposes a name length limit of 30 characters. To accommodate this, the
+backend truncates database identifiers to fit, replacing the final four
+characters of the truncated name with a repeatable MD5 hash value.
+Additionally, the backend turns database identifiers to all-uppercase.
+
+To prevent these transformations (this is usually required only when dealing
+with legacy databases or accessing tables which belong to other users), use
+a quoted name as the value for ``db_table``::
+
+    class LegacyModel(models.Model):
+        class Meta:
+            db_table = '"name_left_in_lowercase"'
+
+
+    class ForeignModel(models.Model):
+        class Meta:
+            db_table = '"OTHER_USER"."NAME_ONLY_SEEMS_OVER_30"'
+
+Quoted names can also be used with Django's other supported database
+backends; except for Oracle, however, the quotes have no effect.
+
+When running ``migrate``, an ``ORA-06552`` error may be encountered if
+certain Oracle keywords are used as the name of a model field or the
+value of a ``db_column`` option.  Django quotes all identifiers used
+in queries to prevent most such problems, but this error can still
+occur when an Oracle datatype is used as a column name.  In
+particular, take care to avoid using the names ``date``,
+``timestamp``, ``number`` or ``float`` as a field name.
+
+.. _oracle-null-empty-strings:
+
+NULL and empty strings
+----------------------
+
+Django generally prefers to use the empty string (``''``) rather than
+``NULL``, but Oracle treats both identically. To get around this, the
+Oracle backend ignores an explicit ``null`` option on fields that
+have the empty string as a possible value and generates DDL as if
+``null=True``. When fetching from the database, it is assumed that
+a ``NULL`` value in one of these fields really means the empty
+string, and the data is silently converted to reflect this assumption.
+
+``TextField`` limitations
+-------------------------
+
+The Oracle backend stores ``TextFields`` as ``NCLOB`` columns. Oracle imposes
+some limitations on the usage of such LOB columns in general:
+
+* LOB columns may not be used as primary keys.
+
+* LOB columns may not be used in indexes.
+
+* LOB columns may not be used in a ``SELECT DISTINCT`` list. This means that
+  attempting to use the ``QuerySet.distinct`` method on a model that
+  includes ``TextField`` columns will result in an ``ORA-00932`` error when
+  run against Oracle. As a workaround, use the ``QuerySet.defer`` method in
+  conjunction with ``distinct()`` to prevent ``TextField`` columns from being
+  included in the ``SELECT DISTINCT`` list.
+
+.. _subclassing-database-backends:
+
+Subclassing the built-in database backends
+==========================================
+
+Django comes with built-in database backends. You may subclass an existing
+database backends to modify its behavior, features, or configuration.
+
+Consider, for example, that you need to change a single database feature.
+First, you have to create a new directory with a ``base`` module in it. For
+example:
+
+.. code-block:: text
+
+    mysite/
+        ...
+        mydbengine/
+            __init__.py
+            base.py
+
+The ``base.py`` module must contain a class named ``DatabaseWrapper`` that
+subclasses an existing engine from the ``django.db.backends`` module. Here's an
+example of subclassing the PostgreSQL engine to change a feature class
+``allows_group_by_selected_pks_on_model``:
+
+.. code-block:: python
+    :caption: ``mysite/mydbengine/base.py``
+
+    from django.db.backends.postgresql import base, features
+
+
+    class DatabaseFeatures(features.DatabaseFeatures):
+        def allows_group_by_selected_pks_on_model(self, model):
+            return True
+
+
+    class DatabaseWrapper(base.DatabaseWrapper):
+        features_class = DatabaseFeatures
+
+Finally, you must specify a :setting:`DATABASE-ENGINE` in your ``settings.py``
+file::
+
+    DATABASES = {
+        "default": {
+            "ENGINE": "mydbengine",
+            # ...
+        },
+    }
+
+You can see the current list of database engines by looking in
+:source:`django/db/backends`.
+
+.. _third-party-notes:
+
+Using a 3rd-party database backend
+==================================
+
+In addition to the officially supported databases, there are backends provided
+by 3rd parties that allow you to use other databases with Django:
+
+* :pypi:`CockroachDB <django-cockroachdb>`
+* :pypi:`Firebird <django-firebird>`
+* :pypi:`Google Cloud Spanner <django-google-spanner>`
+* :pypi:`Microsoft SQL Server <mssql-django>`
+* :pypi:`Snowflake <django-snowflake>`
+* :pypi:`TiDB <django-tidb>`
+* :pypi:`YugabyteDB <django-yugabytedb>`
+
+The Django versions and ORM features supported by these unofficial backends
+vary considerably. Queries regarding the specific capabilities of these
+unofficial backends, along with any support queries, should be directed to
+the support channels provided by each 3rd party project.

testbed/django__django/docs/ref/exceptions.txt

@@ -0,0 +1,350 @@
+=================
+Django Exceptions
+=================
+
+Django raises some of its own exceptions as well as standard Python exceptions.
+
+Django Core Exceptions
+======================
+
+.. module:: django.core.exceptions
+    :synopsis: Django core exceptions
+
+Django core exception classes are defined in ``django.core.exceptions``.
+
+``AppRegistryNotReady``
+-----------------------
+
+.. exception:: AppRegistryNotReady
+
+    This exception is raised when attempting to use models before the :ref:`app
+    loading process <app-loading-process>`, which initializes the ORM, is
+    complete.
+
+``ObjectDoesNotExist``
+----------------------
+
+.. exception:: ObjectDoesNotExist
+
+    The base class for :exc:`Model.DoesNotExist
+    <django.db.models.Model.DoesNotExist>` exceptions. A ``try/except`` for
+    ``ObjectDoesNotExist`` will catch
+    :exc:`~django.db.models.Model.DoesNotExist` exceptions for all models.
+
+    See :meth:`~django.db.models.query.QuerySet.get()`.
+
+``EmptyResultSet``
+------------------
+
+.. exception:: EmptyResultSet
+
+    ``EmptyResultSet`` may be raised during query generation if a query won't
+    return any results. Most Django projects won't encounter this exception,
+    but it might be useful for implementing custom lookups and expressions.
+
+``FullResultSet``
+-----------------
+
+.. exception:: FullResultSet
+
+.. versionadded:: 4.2
+
+    ``FullResultSet`` may be raised during query generation if a query will
+    match everything. Most Django projects won't encounter this exception, but
+    it might be useful for implementing custom lookups and expressions.
+
+``FieldDoesNotExist``
+---------------------
+
+.. exception:: FieldDoesNotExist
+
+    The ``FieldDoesNotExist`` exception is raised by a model's
+    ``_meta.get_field()`` method when the requested field does not exist on the
+    model or on the model's parents.
+
+``MultipleObjectsReturned``
+---------------------------
+
+.. exception:: MultipleObjectsReturned
+
+    The base class for :exc:`Model.MultipleObjectsReturned
+    <django.db.models.Model.MultipleObjectsReturned>` exceptions. A
+    ``try/except`` for ``MultipleObjectsReturned`` will catch
+    :exc:`~django.db.models.Model.MultipleObjectsReturned` exceptions for all
+    models.
+
+    See :meth:`~django.db.models.query.QuerySet.get()`.
+
+``SuspiciousOperation``
+-----------------------
+
+.. exception:: SuspiciousOperation
+
+    The :exc:`SuspiciousOperation` exception is raised when a user has
+    performed an operation that should be considered suspicious from a security
+    perspective, such as tampering with a session cookie. Subclasses of
+    ``SuspiciousOperation`` include:
+
+    * ``DisallowedHost``
+    * ``DisallowedModelAdminLookup``
+    * ``DisallowedModelAdminToField``
+    * ``DisallowedRedirect``
+    * ``InvalidSessionKey``
+    * ``RequestDataTooBig``
+    * ``SuspiciousFileOperation``
+    * ``SuspiciousMultipartForm``
+    * ``SuspiciousSession``
+    * ``TooManyFieldsSent``
+    * ``TooManyFilesSent``
+
+    If a ``SuspiciousOperation`` exception reaches the ASGI/WSGI handler level
+    it is logged at the ``Error`` level and results in
+    a :class:`~django.http.HttpResponseBadRequest`. See the :doc:`logging
+    documentation </topics/logging/>` for more information.
+
+.. versionchanged:: 3.2.18
+
+    ``SuspiciousOperation`` is raised when too many files are submitted.
+
+``PermissionDenied``
+--------------------
+
+.. exception:: PermissionDenied
+
+    The :exc:`PermissionDenied` exception is raised when a user does not have
+    permission to perform the action requested.
+
+``ViewDoesNotExist``
+--------------------
+
+.. exception:: ViewDoesNotExist
+
+    The :exc:`ViewDoesNotExist` exception is raised by
+    :mod:`django.urls` when a requested view does not exist.
+
+``MiddlewareNotUsed``
+---------------------
+
+.. exception:: MiddlewareNotUsed
+
+    The :exc:`MiddlewareNotUsed` exception is raised when a middleware is not
+    used in the server configuration.
+
+``ImproperlyConfigured``
+------------------------
+
+.. exception:: ImproperlyConfigured
+
+    The :exc:`ImproperlyConfigured` exception is raised when Django is
+    somehow improperly configured -- for example, if a value in ``settings.py``
+    is incorrect or unparseable.
+
+``FieldError``
+--------------
+
+.. exception:: FieldError
+
+    The :exc:`FieldError` exception is raised when there is a problem with a
+    model field. This can happen for several reasons:
+
+    - A field in a model clashes with a field of the same name from an
+      abstract base class
+    - An infinite loop is caused by ordering
+    - A keyword cannot be parsed from the filter parameters
+    - A field cannot be determined from a keyword in the query
+      parameters
+    - A join is not permitted on the specified field
+    - A field name is invalid
+    - A query contains invalid order_by arguments
+
+``ValidationError``
+-------------------
+
+.. exception:: ValidationError
+
+    The :exc:`ValidationError` exception is raised when data fails form or
+    model field validation. For more information about validation, see
+    :doc:`Form and Field Validation </ref/forms/validation>`,
+    :ref:`Model Field Validation <validating-objects>` and the
+    :doc:`Validator Reference </ref/validators>`.
+
+``NON_FIELD_ERRORS``
+~~~~~~~~~~~~~~~~~~~~
+
+.. data:: NON_FIELD_ERRORS
+
+``ValidationError``\s that don't belong to a particular field in a form
+or model are classified as ``NON_FIELD_ERRORS``. This constant is used
+as a key in dictionaries that otherwise map fields to their respective
+list of errors.
+
+``BadRequest``
+--------------
+
+.. exception:: BadRequest
+
+    The :exc:`BadRequest` exception is raised when the request cannot be
+    processed due to a client error. If a ``BadRequest`` exception reaches the
+    ASGI/WSGI handler level it results in a
+    :class:`~django.http.HttpResponseBadRequest`.
+
+``RequestAborted``
+------------------
+
+.. exception:: RequestAborted
+
+    The :exc:`RequestAborted` exception is raised when an HTTP body being read
+    in by the handler is cut off midstream and the client connection closes,
+    or when the client does not send data and hits a timeout where the server
+    closes the connection.
+
+    It is internal to the HTTP handler modules and you are unlikely to see
+    it elsewhere. If you are modifying HTTP handling code, you should raise
+    this when you encounter an aborted request to make sure the socket is
+    closed cleanly.
+
+``SynchronousOnlyOperation``
+----------------------------
+
+.. exception:: SynchronousOnlyOperation
+
+    The :exc:`SynchronousOnlyOperation` exception is raised when code that
+    is only allowed in synchronous Python code is called from an asynchronous
+    context (a thread with a running asynchronous event loop). These parts of
+    Django are generally heavily reliant on thread-safety to function and don't
+    work correctly under coroutines sharing the same thread.
+
+    If you are trying to call code that is synchronous-only from an
+    asynchronous thread, then create a synchronous thread and call it in that.
+    You can accomplish this is with :func:`asgiref.sync.sync_to_async`.
+
+.. currentmodule:: django.urls
+
+URL Resolver exceptions
+=======================
+
+URL Resolver exceptions are defined in ``django.urls``.
+
+``Resolver404``
+---------------
+
+.. exception:: Resolver404
+
+    The :exc:`Resolver404` exception is raised by
+    :func:`~django.urls.resolve()` if the path passed to ``resolve()`` doesn't
+    map to a view. It's a subclass of :class:`django.http.Http404`.
+
+``NoReverseMatch``
+------------------
+
+.. exception:: NoReverseMatch
+
+    The :exc:`NoReverseMatch` exception is raised by :mod:`django.urls` when a
+    matching URL in your URLconf cannot be identified based on the parameters
+    supplied.
+
+.. currentmodule:: django.db
+
+Database Exceptions
+===================
+
+Database exceptions may be imported from ``django.db``.
+
+Django wraps the standard database exceptions so that your Django code has a
+guaranteed common implementation of these classes.
+
+.. exception:: Error
+.. exception:: InterfaceError
+.. exception:: DatabaseError
+.. exception:: DataError
+.. exception:: OperationalError
+.. exception:: IntegrityError
+.. exception:: InternalError
+.. exception:: ProgrammingError
+.. exception:: NotSupportedError
+
+The Django wrappers for database exceptions behave exactly the same as
+the underlying database exceptions. See :pep:`249`, the Python Database API
+Specification v2.0, for further information.
+
+As per :pep:`3134`, a ``__cause__`` attribute is set with the original
+(underlying) database exception, allowing access to any additional
+information provided.
+
+.. exception:: models.ProtectedError
+
+Raised to prevent deletion of referenced objects when using
+:attr:`django.db.models.PROTECT`. :exc:`models.ProtectedError` is a subclass
+of :exc:`IntegrityError`.
+
+.. exception:: models.RestrictedError
+
+Raised to prevent deletion of referenced objects when using
+:attr:`django.db.models.RESTRICT`. :exc:`models.RestrictedError` is a subclass
+of :exc:`IntegrityError`.
+
+.. currentmodule:: django.http
+
+HTTP Exceptions
+===============
+
+HTTP exceptions may be imported from ``django.http``.
+
+``UnreadablePostError``
+-----------------------
+
+.. exception:: UnreadablePostError
+
+    :exc:`UnreadablePostError` is raised when a user cancels an upload.
+
+.. currentmodule:: django.contrib.sessions.exceptions
+
+Sessions Exceptions
+===================
+
+Sessions exceptions are defined in ``django.contrib.sessions.exceptions``.
+
+``SessionInterrupted``
+----------------------
+
+.. exception:: SessionInterrupted
+
+    :exc:`SessionInterrupted` is raised when a session is destroyed in a
+    concurrent request. It's a subclass of
+    :exc:`~django.core.exceptions.BadRequest`.
+
+Transaction Exceptions
+======================
+
+.. currentmodule:: django.db.transaction
+
+Transaction exceptions are defined in ``django.db.transaction``.
+
+``TransactionManagementError``
+------------------------------
+
+.. exception:: TransactionManagementError
+
+    :exc:`TransactionManagementError` is raised for any and all problems
+    related to database transactions.
+
+.. currentmodule:: django.test
+
+Testing Framework Exceptions
+============================
+
+Exceptions provided by the ``django.test`` package.
+
+``RedirectCycleError``
+----------------------
+
+.. exception:: client.RedirectCycleError
+
+    :exc:`~client.RedirectCycleError` is raised when the test client detects a
+    loop or an overly long chain of redirects.
+
+Python Exceptions
+=================
+
+Django raises built-in Python exceptions when appropriate as well. See the
+Python documentation for further information on the :ref:`bltin-exceptions`.

testbed/django__django/docs/ref/index.txt

@@ -0,0 +1,35 @@
+=============
+API Reference
+=============
+
+.. toctree::
+   :maxdepth: 1
+
+   applications
+   checks
+   class-based-views/index
+   clickjacking
+   contrib/index
+   csrf
+   databases
+   django-admin
+   exceptions
+   files/index
+   forms/index
+   logging
+   middleware
+   migration-operations
+   models/index
+   paginator
+   request-response
+   schema-editor
+   settings
+   signals
+   templates/index
+   template-response
+   unicode
+   urlresolvers
+   urls
+   utils
+   validators
+   views

testbed/django__django/docs/ref/logging.txt

@@ -0,0 +1,408 @@
+.. _logging-ref:
+
+=======
+Logging
+=======
+
+.. seealso::
+
+    * :ref:`logging-how-to`
+    * :ref:`Django logging overview <logging-explanation>`
+
+.. module:: django.utils.log
+   :synopsis: Logging tools for Django applications
+
+Django's logging module extends Python's builtin :mod:`logging`.
+
+Logging is configured as part of the general Django :func:`django.setup`
+function, so it's always available unless explicitly disabled.
+
+.. _default-logging-configuration:
+
+Django's default logging configuration
+======================================
+
+By default, Django uses Python's :ref:`logging.config.dictConfig format
+<logging-config-dictschema>`.
+
+Default logging conditions
+--------------------------
+
+The full set of default logging conditions are:
+
+When :setting:`DEBUG` is ``True``:
+
+* The ``django`` logger sends messages in the ``django`` hierarchy (except
+  ``django.server``) at the ``INFO`` level or higher to the console.
+
+When :setting:`DEBUG` is ``False``:
+
+* The ``django`` logger sends messages in the ``django`` hierarchy (except
+  ``django.server``)  with ``ERROR`` or ``CRITICAL`` level to
+  :class:`AdminEmailHandler`.
+
+Independently of the value of :setting:`DEBUG`:
+
+* The :ref:`django-server-logger` logger sends messages at the ``INFO`` level
+  or higher to the console.
+
+All loggers except :ref:`django-server-logger` propagate logging to their
+parents, up to the root ``django`` logger. The ``console`` and ``mail_admins``
+handlers are attached to the root logger to provide the behavior described
+above.
+
+Python's own defaults send records of level ``WARNING`` and higher
+to the console.
+
+.. _default-logging-definition:
+
+Default logging definition
+--------------------------
+
+Django's default logging configuration inherits Python's defaults. It's
+available as ``django.utils.log.DEFAULT_LOGGING`` and defined in
+:source:`django/utils/log.py`::
+
+    {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "filters": {
+            "require_debug_false": {
+                "()": "django.utils.log.RequireDebugFalse",
+            },
+            "require_debug_true": {
+                "()": "django.utils.log.RequireDebugTrue",
+            },
+        },
+        "formatters": {
+            "django.server": {
+                "()": "django.utils.log.ServerFormatter",
+                "format": "[{server_time}] {message}",
+                "style": "{",
+            }
+        },
+        "handlers": {
+            "console": {
+                "level": "INFO",
+                "filters": ["require_debug_true"],
+                "class": "logging.StreamHandler",
+            },
+            "django.server": {
+                "level": "INFO",
+                "class": "logging.StreamHandler",
+                "formatter": "django.server",
+            },
+            "mail_admins": {
+                "level": "ERROR",
+                "filters": ["require_debug_false"],
+                "class": "django.utils.log.AdminEmailHandler",
+            },
+        },
+        "loggers": {
+            "django": {
+                "handlers": ["console", "mail_admins"],
+                "level": "INFO",
+            },
+            "django.server": {
+                "handlers": ["django.server"],
+                "level": "INFO",
+                "propagate": False,
+            },
+        },
+    }
+
+See :ref:`configuring-logging` on how to complement or replace this default
+logging configuration.
+
+Django logging extensions
+=========================
+
+Django provides a number of utilities to handle the particular requirements of
+logging in a web server environment.
+
+Loggers
+-------
+
+Django provides several built-in loggers.
+
+.. _django-logger:
+
+``django``
+~~~~~~~~~~
+
+The parent logger for messages in the ``django`` :ref:`named logger hierarchy
+<naming-loggers-hierarchy>`. Django does not post messages using this name.
+Instead, it uses one of the loggers below.
+
+.. _django-request-logger:
+
+``django.request``
+~~~~~~~~~~~~~~~~~~
+
+Log messages related to the handling of requests. 5XX responses are
+raised as ``ERROR`` messages; 4XX responses are raised as ``WARNING``
+messages. Requests that are logged to the ``django.security`` logger aren't
+logged to ``django.request``.
+
+Messages to this logger have the following extra context:
+
+* ``status_code``: The HTTP response code associated with the request.
+
+* ``request``: The request object that generated the logging message.
+
+.. _django-server-logger:
+
+``django.server``
+~~~~~~~~~~~~~~~~~
+
+Log messages related to the handling of requests received by the server invoked
+by the :djadmin:`runserver` command. HTTP 5XX responses are logged as ``ERROR``
+messages, 4XX responses are logged as ``WARNING`` messages, and everything else
+is logged as ``INFO``.
+
+Messages to this logger have the following extra context:
+
+* ``status_code``: The HTTP response code associated with the request.
+
+* ``request``: The request object that generated the logging message.
+
+.. _django-template-logger:
+
+``django.template``
+~~~~~~~~~~~~~~~~~~~
+
+Log messages related to the rendering of templates.
+
+* Missing context variables are logged as ``DEBUG`` messages.
+
+.. _django-db-logger:
+
+``django.db.backends``
+~~~~~~~~~~~~~~~~~~~~~~
+
+Messages relating to the interaction of code with the database. For example,
+every application-level SQL statement executed by a request is logged at the
+``DEBUG`` level to this logger.
+
+Messages to this logger have the following extra context:
+
+* ``duration``: The time taken to execute the SQL statement.
+* ``sql``: The SQL statement that was executed.
+* ``params``: The parameters that were used in the SQL call.
+* ``alias``: The alias of the database used in the SQL call.
+
+For performance reasons, SQL logging is only enabled when
+``settings.DEBUG`` is set to ``True``, regardless of the logging
+level or handlers that are installed.
+
+This logging does not include framework-level initialization (e.g.
+``SET TIMEZONE``). Turn on query logging in your database if you wish to view
+all database queries.
+
+.. versionchanged:: 4.2
+
+    Support for logging transaction management queries (``BEGIN``, ``COMMIT``,
+    and ``ROLLBACK``) was added.
+
+.. _django-security-logger:
+
+``django.security.*``
+~~~~~~~~~~~~~~~~~~~~~
+
+The security loggers will receive messages on any occurrence of
+:exc:`~django.core.exceptions.SuspiciousOperation` and other security-related
+errors. There is a sub-logger for each subtype of security error, including all
+``SuspiciousOperation``\s. The level of the log event depends on where the
+exception is handled.  Most occurrences are logged as a warning, while
+any ``SuspiciousOperation`` that reaches the WSGI handler will be logged as an
+error. For example, when an HTTP ``Host`` header is included in a request from
+a client that does not match :setting:`ALLOWED_HOSTS`, Django will return a 400
+response, and an error message will be logged to the
+``django.security.DisallowedHost`` logger.
+
+These log events will reach the ``django`` logger by default, which mails error
+events to admins when ``DEBUG=False``. Requests resulting in a 400 response due
+to a ``SuspiciousOperation`` will not be logged to the ``django.request``
+logger, but only to the ``django.security`` logger.
+
+To silence a particular type of ``SuspiciousOperation``, you can override that
+specific logger following this example::
+
+    LOGGING = {
+        # ...
+        "handlers": {
+            "null": {
+                "class": "logging.NullHandler",
+            },
+        },
+        "loggers": {
+            "django.security.DisallowedHost": {
+                "handlers": ["null"],
+                "propagate": False,
+            },
+        },
+        # ...
+    }
+
+Other ``django.security`` loggers not based on ``SuspiciousOperation`` are:
+
+* ``django.security.csrf``: For :ref:`CSRF failures <csrf-rejected-requests>`.
+
+``django.db.backends.schema``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Logs the SQL queries that are executed during schema changes to the database by
+the :doc:`migrations framework </topics/migrations>`. Note that it won't log the
+queries executed by :class:`~django.db.migrations.operations.RunPython`.
+Messages to this logger have ``params`` and ``sql`` in their extra context (but
+unlike ``django.db.backends``, not duration). The values have the same meaning
+as explained in :ref:`django-db-logger`.
+
+Handlers
+--------
+
+Django provides one log handler in addition to :mod:`those provided by the
+Python logging module <python:logging.handlers>`.
+
+.. class:: AdminEmailHandler(include_html=False, email_backend=None, reporter_class=None)
+
+    This handler sends an email to the site :setting:`ADMINS` for each log
+    message it receives.
+
+    If the log record contains a ``request`` attribute, the full details
+    of the request will be included in the email. The email subject will
+    include the phrase "internal IP" if the client's IP address is in the
+    :setting:`INTERNAL_IPS` setting; if not, it will include "EXTERNAL IP".
+
+    If the log record contains stack trace information, that stack
+    trace will be included in the email.
+
+    The ``include_html`` argument of ``AdminEmailHandler`` is used to
+    control whether the traceback email includes an HTML attachment
+    containing the full content of the debug web page that would have been
+    produced if :setting:`DEBUG` were ``True``. To set this value in your
+    configuration, include it in the handler definition for
+    ``django.utils.log.AdminEmailHandler``, like this::
+
+        "handlers": {
+            "mail_admins": {
+                "level": "ERROR",
+                "class": "django.utils.log.AdminEmailHandler",
+                "include_html": True,
+            },
+        }
+
+    Be aware of the :ref:`security implications of logging
+    <logging-security-implications>` when using the ``AdminEmailHandler``.
+
+    By setting the ``email_backend`` argument of ``AdminEmailHandler``, the
+    :ref:`email backend <topic-email-backends>` that is being used by the
+    handler can be overridden, like this::
+
+        "handlers": {
+            "mail_admins": {
+                "level": "ERROR",
+                "class": "django.utils.log.AdminEmailHandler",
+                "email_backend": "django.core.mail.backends.filebased.EmailBackend",
+            },
+        }
+
+    By default, an instance of the email backend specified in
+    :setting:`EMAIL_BACKEND` will be used.
+
+    The ``reporter_class`` argument of ``AdminEmailHandler`` allows providing
+    an ``django.views.debug.ExceptionReporter`` subclass to customize the
+    traceback text sent in the email body. You provide a string import path to
+    the class you wish to use, like this::
+
+        "handlers": {
+            "mail_admins": {
+                "level": "ERROR",
+                "class": "django.utils.log.AdminEmailHandler",
+                "include_html": True,
+                "reporter_class": "somepackage.error_reporter.CustomErrorReporter",
+            },
+        }
+
+    .. method:: send_mail(subject, message, *args, **kwargs)
+
+        Sends emails to admin users. To customize this behavior, you can
+        subclass the :class:`~django.utils.log.AdminEmailHandler` class and
+        override this method.
+
+Filters
+-------
+
+Django provides some log filters in addition to those provided by the Python
+logging module.
+
+.. class:: CallbackFilter(callback)
+
+    This filter accepts a callback function (which should accept a single
+    argument, the record to be logged), and calls it for each record that
+    passes through the filter. Handling of that record will not proceed if the
+    callback returns False.
+
+    For instance, to filter out :exc:`~django.http.UnreadablePostError`
+    (raised when a user cancels an upload) from the admin emails, you would
+    create a filter function::
+
+        from django.http import UnreadablePostError
+
+
+        def skip_unreadable_post(record):
+            if record.exc_info:
+                exc_type, exc_value = record.exc_info[:2]
+                if isinstance(exc_value, UnreadablePostError):
+                    return False
+            return True
+
+    and then add it to your logging config::
+
+        LOGGING = {
+            # ...
+            "filters": {
+                "skip_unreadable_posts": {
+                    "()": "django.utils.log.CallbackFilter",
+                    "callback": skip_unreadable_post,
+                },
+            },
+            "handlers": {
+                "mail_admins": {
+                    "level": "ERROR",
+                    "filters": ["skip_unreadable_posts"],
+                    "class": "django.utils.log.AdminEmailHandler",
+                },
+            },
+            # ...
+        }
+
+.. class:: RequireDebugFalse()
+
+    This filter will only pass on records when settings.DEBUG is False.
+
+    This filter is used as follows in the default :setting:`LOGGING`
+    configuration to ensure that the :class:`AdminEmailHandler` only sends
+    error emails to admins when :setting:`DEBUG` is ``False``::
+
+        LOGGING = {
+            # ...
+            "filters": {
+                "require_debug_false": {
+                    "()": "django.utils.log.RequireDebugFalse",
+                },
+            },
+            "handlers": {
+                "mail_admins": {
+                    "level": "ERROR",
+                    "filters": ["require_debug_false"],
+                    "class": "django.utils.log.AdminEmailHandler",
+                },
+            },
+            # ...
+        }
+
+.. class:: RequireDebugTrue()
+
+    This filter is similar to :class:`RequireDebugFalse`, except that records are
+    passed only when :setting:`DEBUG` is ``True``.

testbed/django__django/docs/ref/middleware.txt

@@ -0,0 +1,619 @@
+==========
+Middleware
+==========
+
+.. module:: django.middleware
+   :synopsis: Django's built-in middleware classes.
+
+This document explains all middleware components that come with Django. For
+information on how to use them and how to write your own middleware, see
+the :doc:`middleware usage guide </topics/http/middleware>`.
+
+Available middleware
+====================
+
+Cache middleware
+----------------
+
+.. module:: django.middleware.cache
+   :synopsis: Middleware for the site-wide cache.
+
+.. class:: UpdateCacheMiddleware
+
+.. class:: FetchFromCacheMiddleware
+
+Enable the site-wide cache. If these are enabled, each Django-powered page will
+be cached for as long as the :setting:`CACHE_MIDDLEWARE_SECONDS` setting
+defines. See the :doc:`cache documentation </topics/cache>`.
+
+"Common" middleware
+-------------------
+
+.. module:: django.middleware.common
+   :synopsis: Middleware adding "common" conveniences for perfectionists.
+
+.. class:: CommonMiddleware
+
+Adds a few conveniences for perfectionists:
+
+* Forbids access to user agents in the :setting:`DISALLOWED_USER_AGENTS`
+  setting, which should be a list of compiled regular expression objects.
+
+* Performs URL rewriting based on the :setting:`APPEND_SLASH` and
+  :setting:`PREPEND_WWW` settings.
+
+  If :setting:`APPEND_SLASH` is ``True`` and the initial URL doesn't end
+  with a slash, and it is not found in the URLconf, then a new URL is
+  formed by appending a slash at the end. If this new URL is found in the
+  URLconf, then Django redirects the request to this new URL. Otherwise,
+  the initial URL is processed as usual.
+
+  For example, ``foo.com/bar`` will be redirected to ``foo.com/bar/`` if
+  you don't have a valid URL pattern for ``foo.com/bar`` but *do* have a
+  valid pattern for ``foo.com/bar/``.
+
+  If :setting:`PREPEND_WWW` is ``True``, URLs that lack a leading "www."
+  will be redirected to the same URL with a leading "www."
+
+  Both of these options are meant to normalize URLs. The philosophy is that
+  each URL should exist in one, and only one, place. Technically a URL
+  ``foo.com/bar`` is distinct from ``foo.com/bar/`` -- a search-engine
+  indexer would treat them as separate URLs -- so it's best practice to
+  normalize URLs.
+
+  If necessary, individual views may be excluded from the ``APPEND_SLASH``
+  behavior using the :func:`~django.views.decorators.common.no_append_slash`
+  decorator::
+
+    from django.views.decorators.common import no_append_slash
+
+
+    @no_append_slash
+    def sensitive_fbv(request, *args, **kwargs):
+        """View to be excluded from APPEND_SLASH."""
+        return HttpResponse()
+
+* Sets the ``Content-Length`` header for non-streaming responses.
+
+.. attribute:: CommonMiddleware.response_redirect_class
+
+Defaults to :class:`~django.http.HttpResponsePermanentRedirect`. Subclass
+``CommonMiddleware`` and override the attribute to customize the redirects
+issued by the middleware.
+
+.. class:: BrokenLinkEmailsMiddleware
+
+* Sends broken link notification emails to :setting:`MANAGERS` (see
+  :doc:`/howto/error-reporting`).
+
+GZip middleware
+---------------
+
+.. module:: django.middleware.gzip
+   :synopsis: Middleware to serve GZipped content for performance.
+
+.. class:: GZipMiddleware
+
+    .. attribute:: max_random_bytes
+
+        Defaults to 100. Subclass ``GZipMiddleware`` and override the attribute
+        to change the maximum number of random bytes that is included with
+        compressed responses.
+
+.. note::
+
+    Security researchers revealed that when compression techniques (including
+    ``GZipMiddleware``) are used on a website, the site may become exposed to a
+    number of possible attacks.
+
+    To mitigate attacks, Django implements a technique called *Heal The Breach
+    (HTB)*. It adds up to 100 bytes (see
+    :attr:`.max_random_bytes`) of random bytes to each response
+    to make the attacks less effective.
+
+    For more details, see the `BREACH paper (PDF)`_, `breachattack.com`_, and
+    the `Heal The Breach (HTB) paper`_.
+
+    .. _BREACH paper (PDF): https://www.breachattack.com/resources/BREACH%20-%20SSL,%20gone%20in%2030%20seconds.pdf
+    .. _breachattack.com: https://www.breachattack.com/
+    .. _Heal The Breach (HTB) paper: https://ieeexplore.ieee.org/document/9754554
+
+.. versionchanged:: 4.2
+
+    Mitigation for the BREACH attack was added.
+
+The ``django.middleware.gzip.GZipMiddleware`` compresses content for browsers
+that understand GZip compression (all modern browsers).
+
+This middleware should be placed before any other middleware that need to
+read or write the response body so that compression happens afterward.
+
+It will NOT compress content if any of the following are true:
+
+* The content body is less than 200 bytes long.
+
+* The response has already set the ``Content-Encoding`` header.
+
+* The request (the browser) hasn't sent an ``Accept-Encoding`` header
+  containing ``gzip``.
+
+If the response has an ``ETag`` header, the ETag is made weak to comply with
+:rfc:`9110#section-8.8.1`.
+
+You can apply GZip compression to individual views using the
+:func:`~django.views.decorators.gzip.gzip_page()` decorator.
+
+Conditional GET middleware
+--------------------------
+
+.. module:: django.middleware.http
+   :synopsis: Middleware handling advanced HTTP features.
+
+.. class:: ConditionalGetMiddleware
+
+Handles conditional GET operations. If the response doesn't have an ``ETag``
+header, the middleware adds one if needed. If the response has an ``ETag`` or
+``Last-Modified`` header, and the request has ``If-None-Match`` or
+``If-Modified-Since``, the response is replaced by an
+:class:`~django.http.HttpResponseNotModified`.
+
+Locale middleware
+-----------------
+
+.. module:: django.middleware.locale
+   :synopsis: Middleware to enable language selection based on the request.
+
+.. class:: LocaleMiddleware
+
+Enables language selection based on data from the request. It customizes
+content for each user. See the :doc:`internationalization documentation
+</topics/i18n/translation>`.
+
+.. attribute:: LocaleMiddleware.response_redirect_class
+
+Defaults to :class:`~django.http.HttpResponseRedirect`. Subclass
+``LocaleMiddleware`` and override the attribute to customize the redirects
+issued by the middleware.
+
+Message middleware
+------------------
+
+.. module:: django.contrib.messages.middleware
+   :synopsis: Message middleware.
+
+.. class:: MessageMiddleware
+
+Enables cookie- and session-based message support. See the
+:doc:`messages documentation </ref/contrib/messages>`.
+
+.. _security-middleware:
+
+Security middleware
+-------------------
+
+.. module:: django.middleware.security
+    :synopsis: Security middleware.
+
+.. warning::
+    If your deployment situation allows, it's usually a good idea to have your
+    front-end web server perform the functionality provided by the
+    ``SecurityMiddleware``. That way, if there are requests that aren't served
+    by Django (such as static media or user-uploaded files), they will have
+    the same protections as requests to your Django application.
+
+.. class:: SecurityMiddleware
+
+The ``django.middleware.security.SecurityMiddleware`` provides several security
+enhancements to the request/response cycle. Each one can be independently
+enabled or disabled with a setting.
+
+* :setting:`SECURE_CONTENT_TYPE_NOSNIFF`
+* :setting:`SECURE_CROSS_ORIGIN_OPENER_POLICY`
+* :setting:`SECURE_HSTS_INCLUDE_SUBDOMAINS`
+* :setting:`SECURE_HSTS_PRELOAD`
+* :setting:`SECURE_HSTS_SECONDS`
+* :setting:`SECURE_REDIRECT_EXEMPT`
+* :setting:`SECURE_REFERRER_POLICY`
+* :setting:`SECURE_SSL_HOST`
+* :setting:`SECURE_SSL_REDIRECT`
+
+.. _http-strict-transport-security:
+
+HTTP Strict Transport Security
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+For sites that should only be accessed over HTTPS, you can instruct modern
+browsers to refuse to connect to your domain name via an insecure connection
+(for a given period of time) by setting the `"Strict-Transport-Security"
+header`__. This reduces your exposure to some SSL-stripping man-in-the-middle
+(MITM) attacks.
+
+``SecurityMiddleware`` will set this header for you on all HTTPS responses if
+you set the :setting:`SECURE_HSTS_SECONDS` setting to a non-zero integer value.
+
+When enabling HSTS, it's a good idea to first use a small value for testing,
+for example, :setting:`SECURE_HSTS_SECONDS = 3600<SECURE_HSTS_SECONDS>` for one
+hour. Each time a web browser sees the HSTS header from your site, it will
+refuse to communicate non-securely (using HTTP) with your domain for the given
+period of time. Once you confirm that all assets are served securely on your
+site (i.e. HSTS didn't break anything), it's a good idea to increase this value
+so that infrequent visitors will be protected (31536000 seconds, i.e. 1 year,
+is common).
+
+Additionally, if you set the :setting:`SECURE_HSTS_INCLUDE_SUBDOMAINS` setting
+to ``True``, ``SecurityMiddleware`` will add the ``includeSubDomains`` directive
+to the ``Strict-Transport-Security`` header. This is recommended (assuming all
+subdomains are served exclusively using HTTPS), otherwise your site may still
+be vulnerable via an insecure connection to a subdomain.
+
+If you wish to submit your site to the `browser preload list`_, set the
+:setting:`SECURE_HSTS_PRELOAD` setting to ``True``. That appends the
+``preload`` directive to the ``Strict-Transport-Security`` header.
+
+.. warning::
+    The HSTS policy applies to your entire domain, not just the URL of the
+    response that you set the header on. Therefore, you should only use it if
+    your entire domain is served via HTTPS only.
+
+    Browsers properly respecting the HSTS header will refuse to allow users to
+    bypass warnings and connect to a site with an expired, self-signed, or
+    otherwise invalid SSL certificate. If you use HSTS, make sure your
+    certificates are in good shape and stay that way!
+
+.. note::
+    If you are deployed behind a load-balancer or reverse-proxy server, and the
+    ``Strict-Transport-Security`` header is not being added to your responses,
+    it may be because Django doesn't realize that it's on a secure connection;
+    you may need to set the :setting:`SECURE_PROXY_SSL_HEADER` setting.
+
+__ https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Strict-Transport-Security
+.. _browser preload list: https://hstspreload.org/
+
+.. _referrer-policy:
+
+Referrer Policy
+~~~~~~~~~~~~~~~
+
+Browsers use `the Referer header`__ as a way to send information to a site
+about how users got there. When a user clicks a link, the browser will send the
+full URL of the linking page as the referrer. While this can be useful for some
+purposes -- like figuring out who's linking to your site -- it also can cause
+privacy concerns by informing one site that a user was visiting another site.
+
+__ https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referer
+
+Some browsers have the ability to accept hints about whether they should send
+the HTTP ``Referer`` header when a user clicks a link; this hint is provided
+via `the Referrer-Policy header`__. This header can suggest any of three
+behaviors to browsers:
+
+__ https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy
+
+* Full URL: send the entire URL in the ``Referer`` header. For example, if the
+  user is visiting ``https://example.com/page.html``, the ``Referer`` header
+  would contain ``"https://example.com/page.html"``.
+
+* Origin only: send only the "origin" in the referrer. The origin consists of
+  the scheme, host and (optionally) port number. For example, if the user is
+  visiting ``https://example.com/page.html``, the origin would be
+  ``https://example.com/``.
+
+* No referrer: do not send a ``Referer`` header at all.
+
+There are two types of conditions this header can tell a browser to watch out
+for:
+
+* Same-origin versus cross-origin: a link from ``https://example.com/1.html``
+  to ``https://example.com/2.html`` is same-origin. A link from
+  ``https://example.com/page.html`` to ``https://not.example.com/page.html`` is
+  cross-origin.
+
+* Protocol downgrade: a downgrade occurs if the page containing the link is
+  served via HTTPS, but the page being linked to is not served via HTTPS.
+
+.. warning::
+    When your site is served via HTTPS, :ref:`Django's CSRF protection system
+    <how-csrf-works>` requires the ``Referer`` header to be present, so
+    completely disabling the ``Referer`` header will interfere with CSRF
+    protection. To gain most of the benefits of disabling ``Referer`` headers
+    while also keeping CSRF protection, consider enabling only same-origin
+    referrers.
+
+``SecurityMiddleware`` can set the ``Referrer-Policy`` header for you, based on
+the :setting:`SECURE_REFERRER_POLICY` setting (note spelling: browsers send a
+``Referer`` header when a user clicks a link, but the header instructing a
+browser whether to do so is spelled ``Referrer-Policy``). The valid values for
+this setting are:
+
+``no-referrer``
+    Instructs the browser to send no referrer for links clicked on this site.
+
+``no-referrer-when-downgrade``
+    Instructs the browser to send a full URL as the referrer, but only when no
+    protocol downgrade occurs.
+
+``origin``
+    Instructs the browser to send only the origin, not the full URL, as the
+    referrer.
+
+``origin-when-cross-origin``
+    Instructs the browser to send the full URL as the referrer for same-origin
+    links, and only the origin for cross-origin links.
+
+``same-origin``
+    Instructs the browser to send a full URL, but only for same-origin links. No
+    referrer will be sent for cross-origin links.
+
+``strict-origin``
+    Instructs the browser to send only the origin, not the full URL, and to send
+    no referrer when a protocol downgrade occurs.
+
+``strict-origin-when-cross-origin``
+    Instructs the browser to send the full URL when the link is same-origin and
+    no protocol downgrade occurs; send only the origin when the link is
+    cross-origin and no protocol downgrade occurs; and no referrer when a
+    protocol downgrade occurs.
+
+``unsafe-url``
+    Instructs the browser to always send the full URL as the referrer.
+
+.. admonition:: Unknown Policy Values
+
+    Where a policy value is `unknown`__ by a user agent, it is possible to
+    specify multiple policy values to provide a fallback. The last specified
+    value that is understood takes precedence. To support this, an iterable or
+    comma-separated string can be used with :setting:`SECURE_REFERRER_POLICY`.
+
+    __ https://w3c.github.io/webappsec-referrer-policy/#unknown-policy-values
+
+.. _cross-origin-opener-policy:
+
+Cross-Origin Opener Policy
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Some browsers have the ability to isolate top-level windows from other
+documents by putting them in a separate browsing context group based on the
+value of the `Cross-Origin Opener Policy`__ (COOP) header. If a document that
+is isolated in this way opens a cross-origin popup window, the popup’s
+``window.opener`` property will be ``null``. Isolating windows using COOP is a
+defense-in-depth protection against cross-origin attacks, especially those like
+Spectre which allowed exfiltration of data loaded into a shared browsing
+context.
+
+__ https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cross-Origin-Opener-Policy
+
+``SecurityMiddleware`` can set the ``Cross-Origin-Opener-Policy`` header for
+you, based on the :setting:`SECURE_CROSS_ORIGIN_OPENER_POLICY` setting. The
+valid values for this setting are:
+
+``same-origin``
+    Isolates the browsing context exclusively to same-origin documents.
+    Cross-origin documents are not loaded in the same browsing context. This
+    is the default and most secure option.
+
+``same-origin-allow-popups``
+    Isolates the browsing context to same-origin documents or those which
+    either don't set COOP or which opt out of isolation by setting a COOP of
+    ``unsafe-none``.
+
+``unsafe-none``
+    Allows the document to be added to its opener's browsing context group
+    unless the opener itself has a COOP of ``same-origin`` or
+    ``same-origin-allow-popups``.
+
+.. _x-content-type-options:
+
+``X-Content-Type-Options: nosniff``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Some browsers will try to guess the content types of the assets that they
+fetch, overriding the ``Content-Type`` header. While this can help display
+sites with improperly configured servers, it can also pose a security
+risk.
+
+If your site serves user-uploaded files, a malicious user could upload a
+specially-crafted file that would be interpreted as HTML or JavaScript by
+the browser when you expected it to be something harmless.
+
+To prevent the browser from guessing the content type and force it to
+always use the type provided in the ``Content-Type`` header, you can pass
+the `X-Content-Type-Options: nosniff`__ header.  ``SecurityMiddleware`` will
+do this for all responses if the :setting:`SECURE_CONTENT_TYPE_NOSNIFF` setting
+is ``True``.
+
+Note that in most deployment situations where Django isn't involved in serving
+user-uploaded files, this setting won't help you. For example, if your
+:setting:`MEDIA_URL` is served directly by your front-end web server (nginx,
+Apache, etc.) then you'd want to set this header there. On the other hand, if
+you are using Django to do something like require authorization in order to
+download files and you cannot set the header using your web server, this
+setting will be useful.
+
+__ https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Content-Type-Options
+
+.. _ssl-redirect:
+
+SSL Redirect
+~~~~~~~~~~~~
+
+If your site offers both HTTP and HTTPS connections, most users will end up
+with an unsecured connection by default. For best security, you should redirect
+all HTTP connections to HTTPS.
+
+If you set the :setting:`SECURE_SSL_REDIRECT` setting to True,
+``SecurityMiddleware`` will permanently (HTTP 301) redirect all HTTP
+connections to HTTPS.
+
+.. note::
+
+    For performance reasons, it's preferable to do these redirects outside of
+    Django, in a front-end load balancer or reverse-proxy server such as
+    `nginx`_. :setting:`SECURE_SSL_REDIRECT` is intended for the deployment
+    situations where this isn't an option.
+
+If the :setting:`SECURE_SSL_HOST` setting has a value, all redirects will be
+sent to that host instead of the originally-requested host.
+
+If there are a few pages on your site that should be available over HTTP, and
+not redirected to HTTPS, you can list regular expressions to match those URLs
+in the :setting:`SECURE_REDIRECT_EXEMPT` setting.
+
+.. note::
+    If you are deployed behind a load-balancer or reverse-proxy server and
+    Django can't seem to tell when a request actually is already secure, you
+    may need to set the :setting:`SECURE_PROXY_SSL_HEADER` setting.
+
+.. _nginx: https://nginx.org/
+
+Session middleware
+------------------
+
+.. module:: django.contrib.sessions.middleware
+   :synopsis: Session middleware.
+
+.. class:: SessionMiddleware
+
+Enables session support. See the :doc:`session documentation
+</topics/http/sessions>`.
+
+Site middleware
+---------------
+
+.. module:: django.contrib.sites.middleware
+  :synopsis: Site middleware.
+
+.. class:: CurrentSiteMiddleware
+
+Adds the ``site`` attribute representing the current site to every incoming
+``HttpRequest`` object. See the :ref:`sites documentation <site-middleware>`.
+
+Authentication middleware
+-------------------------
+
+.. module:: django.contrib.auth.middleware
+  :synopsis: Authentication middleware.
+
+.. class:: AuthenticationMiddleware
+
+Adds the ``user`` attribute, representing the currently-logged-in user, to
+every incoming ``HttpRequest`` object. See :ref:`Authentication in web requests
+<auth-web-requests>`.
+
+.. class:: RemoteUserMiddleware
+
+Middleware for utilizing web server provided authentication. See
+:doc:`/howto/auth-remote-user` for usage details.
+
+.. class:: PersistentRemoteUserMiddleware
+
+Middleware for utilizing web server provided authentication when enabled only
+on the login page. See :ref:`persistent-remote-user-middleware-howto` for usage
+details.
+
+CSRF protection middleware
+--------------------------
+
+.. currentmodule:: django.middleware.csrf
+
+.. class:: CsrfViewMiddleware
+
+Adds protection against Cross Site Request Forgeries by adding hidden form
+fields to POST forms and checking requests for the correct value. See the
+:doc:`Cross Site Request Forgery protection documentation </ref/csrf>`.
+
+``X-Frame-Options`` middleware
+------------------------------
+
+.. currentmodule:: django.middleware.clickjacking
+
+.. class:: XFrameOptionsMiddleware
+
+Simple :doc:`clickjacking protection via the X-Frame-Options header </ref/clickjacking/>`.
+
+.. _middleware-ordering:
+
+Middleware ordering
+===================
+
+Here are some hints about the ordering of various Django middleware classes:
+
+#. :class:`~django.middleware.security.SecurityMiddleware`
+
+   It should go near the top of the list if you're going to turn on the SSL
+   redirect as that avoids running through a bunch of other unnecessary
+   middleware.
+
+#. :class:`~django.middleware.cache.UpdateCacheMiddleware`
+
+   Before those that modify the ``Vary`` header (``SessionMiddleware``,
+   ``GZipMiddleware``, ``LocaleMiddleware``).
+
+#. :class:`~django.middleware.gzip.GZipMiddleware`
+
+   Before any middleware that may change or use the response body.
+
+   After ``UpdateCacheMiddleware``: Modifies ``Vary`` header.
+
+#. :class:`~django.contrib.sessions.middleware.SessionMiddleware`
+
+   Before any middleware that may raise an exception to trigger an error
+   view (such as :exc:`~django.core.exceptions.PermissionDenied`) if you're
+   using :setting:`CSRF_USE_SESSIONS`.
+
+   After ``UpdateCacheMiddleware``: Modifies ``Vary`` header.
+
+#. :class:`~django.middleware.http.ConditionalGetMiddleware`
+
+   Before any middleware that may change the response (it sets the ``ETag``
+   header).
+
+   After ``GZipMiddleware`` so it won't calculate an ``ETag`` header on gzipped
+   contents.
+
+#. :class:`~django.middleware.locale.LocaleMiddleware`
+
+   One of the topmost, after ``SessionMiddleware`` (uses session data) and
+   ``UpdateCacheMiddleware`` (modifies ``Vary`` header).
+
+#. :class:`~django.middleware.common.CommonMiddleware`
+
+   Before any middleware that may change the response (it sets the
+   ``Content-Length`` header). A middleware that appears before
+   ``CommonMiddleware`` and changes the response must reset ``Content-Length``.
+
+   Close to the top: it redirects when :setting:`APPEND_SLASH` or
+   :setting:`PREPEND_WWW` are set to ``True``.
+
+   After ``SessionMiddleware`` if you're using :setting:`CSRF_USE_SESSIONS`.
+
+#. :class:`~django.middleware.csrf.CsrfViewMiddleware`
+
+   Before any view middleware that assumes that CSRF attacks have been dealt
+   with.
+
+   Before :class:`~django.contrib.auth.middleware.RemoteUserMiddleware`, or any
+   other authentication middleware that may perform a login, and hence rotate
+   the CSRF token, before calling down the middleware chain.
+
+   After ``SessionMiddleware`` if you're using :setting:`CSRF_USE_SESSIONS`.
+
+#. :class:`~django.contrib.auth.middleware.AuthenticationMiddleware`
+
+   After ``SessionMiddleware``: uses session storage.
+
+#. :class:`~django.contrib.messages.middleware.MessageMiddleware`
+
+   After ``SessionMiddleware``: can use session-based storage.
+
+#. :class:`~django.middleware.cache.FetchFromCacheMiddleware`
+
+   After any middleware that modifies the ``Vary`` header: that header is used
+   to pick a value for the cache hash-key.
+
+#. :class:`~django.contrib.flatpages.middleware.FlatpageFallbackMiddleware`
+
+   Should be near the bottom as it's a last-resort type of middleware.
+
+#. :class:`~django.contrib.redirects.middleware.RedirectFallbackMiddleware`
+
+   Should be near the bottom as it's a last-resort type of middleware.

testbed/django__django/docs/ref/models/lookups.txt

@@ -0,0 +1,234 @@
+====================
+Lookup API reference
+====================
+
+.. module:: django.db.models.lookups
+   :synopsis: Lookups API
+
+.. currentmodule:: django.db.models
+
+This document has the API references of lookups, the Django API for building
+the ``WHERE`` clause of a database query. To learn how to *use* lookups, see
+:doc:`/topics/db/queries`; to learn how to *create* new lookups, see
+:doc:`/howto/custom-lookups`.
+
+The lookup API has two components: a :class:`~lookups.RegisterLookupMixin` class
+that registers lookups, and the :ref:`Query Expression API <query-expression>`, a
+set of methods that a class has to implement to be registrable as a lookup.
+
+Django has two base classes that follow the query expression API and from where
+all Django builtin lookups are derived:
+
+* :class:`Lookup`: to lookup a field (e.g. the ``exact`` of ``field_name__exact``)
+* :class:`Transform`: to transform a field
+
+A lookup expression consists of three parts:
+
+* Fields part (e.g. ``Book.objects.filter(author__best_friends__first_name...``);
+* Transforms part (may be omitted) (e.g. ``__lower__first3chars__reversed``);
+* A lookup (e.g. ``__icontains``) that, if omitted, defaults to ``__exact``.
+
+.. _lookup-registration-api:
+
+Registration API
+================
+
+Django uses :class:`~lookups.RegisterLookupMixin` to give a class the interface to
+register lookups on itself or its instances. The two prominent examples are
+:class:`~django.db.models.Field`, the base class of all model fields, and
+:class:`Transform`, the base class of all Django transforms.
+
+.. class:: lookups.RegisterLookupMixin
+
+    A mixin that implements the lookup API on a class.
+
+    .. classmethod:: register_lookup(lookup, lookup_name=None)
+
+        Registers a new lookup in the class or class instance. For example::
+
+            DateField.register_lookup(YearExact)
+            User._meta.get_field("date_joined").register_lookup(MonthExact)
+
+        will register ``YearExact`` lookup on ``DateField`` and ``MonthExact``
+        lookup on the ``User.date_joined`` (you can use :ref:`Field Access API
+        <model-meta-field-api>` to retrieve a single field instance). It
+        overrides a lookup that already exists with the same name. Lookups
+        registered on field instances take precedence over the lookups
+        registered on classes. ``lookup_name`` will be used for this lookup if
+        provided, otherwise ``lookup.lookup_name`` will be used.
+
+    .. method:: get_lookup(lookup_name)
+
+        Returns the :class:`Lookup` named ``lookup_name`` registered in the
+        class or class instance depending on what calls it. The default
+        implementation looks recursively on all parent classes and checks if
+        any has a registered lookup named ``lookup_name``, returning the first
+        match. Instance lookups would override any class lookups with the same
+        ``lookup_name``.
+
+    .. method:: get_lookups()
+
+        Returns a dictionary of each lookup name registered in the class or
+        class instance mapped to the :class:`Lookup` class.
+
+    .. method:: get_transform(transform_name)
+
+        Returns a :class:`Transform` named ``transform_name`` registered in the
+        class or class instance. The default implementation looks recursively
+        on all parent classes to check if any has the registered transform
+        named ``transform_name``, returning the first match.
+
+For a class to be a lookup, it must follow the :ref:`Query Expression API
+<query-expression>`. :class:`~Lookup` and :class:`~Transform` naturally
+follow this API.
+
+.. versionchanged:: 4.2
+
+    Support for registering lookups on :class:`~django.db.models.Field`
+    instances was added.
+
+.. _query-expression:
+
+The Query Expression API
+========================
+
+The query expression API is a common set of methods that classes define to be
+usable in query expressions to translate themselves into SQL expressions. Direct
+field references, aggregates, and ``Transform`` are examples that follow this
+API. A class is said to follow the query expression API when it implements the
+following methods:
+
+.. method:: as_sql(compiler, connection)
+
+    Generates the SQL fragment for the expression. Returns a tuple
+    ``(sql, params)``, where ``sql`` is the SQL string, and ``params`` is the
+    list or tuple of query parameters. The ``compiler`` is an ``SQLCompiler``
+    object, which has a ``compile()`` method that can be used to compile other
+    expressions. The ``connection`` is the connection used to execute the
+    query.
+
+    Calling ``expression.as_sql()`` is usually incorrect - instead
+    ``compiler.compile(expression)`` should be used. The ``compiler.compile()``
+    method will take care of calling vendor-specific methods of the expression.
+
+    Custom keyword arguments may be defined on this method if it's likely that
+    ``as_vendorname()`` methods or subclasses will need to supply data to
+    override the generation of the SQL string. See :meth:`Func.as_sql` for
+    example usage.
+
+.. method:: as_vendorname(compiler, connection)
+
+    Works like ``as_sql()`` method. When an expression is compiled by
+    ``compiler.compile()``, Django will first try to call ``as_vendorname()``,
+    where ``vendorname`` is the vendor name of the backend used for executing
+    the query. The ``vendorname`` is one of ``postgresql``, ``oracle``,
+    ``sqlite``, or ``mysql`` for Django's built-in backends.
+
+.. method:: get_lookup(lookup_name)
+
+    Must return the lookup named ``lookup_name``. For instance, by returning
+    ``self.output_field.get_lookup(lookup_name)``.
+
+.. method:: get_transform(transform_name)
+
+    Must return the lookup named ``transform_name``. For instance, by returning
+    ``self.output_field.get_transform(transform_name)``.
+
+.. attribute:: output_field
+
+    Defines the type of class returned by the ``get_lookup()`` method. It must
+    be a :class:`~django.db.models.Field` instance.
+
+``Transform`` reference
+=======================
+
+.. class:: Transform
+
+    A ``Transform`` is a generic class to implement field transformations. A
+    prominent example is ``__year`` that transforms a ``DateField`` into a
+    ``IntegerField``.
+
+    The notation to use a ``Transform`` in a lookup expression is
+    ``<expression>__<transformation>`` (e.g. ``date__year``).
+
+    This class follows the :ref:`Query Expression API <query-expression>`, which
+    implies that you can use ``<expression>__<transform1>__<transform2>``. It's
+    a specialized :ref:`Func() expression <func-expressions>` that only accepts
+    one argument.  It can also be used on the right hand side of a filter or
+    directly as an annotation.
+
+    .. attribute:: bilateral
+
+        A boolean indicating whether this transformation should apply to both
+        ``lhs`` and ``rhs``. Bilateral transformations will be applied to ``rhs`` in
+        the same order as they appear in the lookup expression. By default it is set
+        to ``False``. For example usage, see :doc:`/howto/custom-lookups`.
+
+    .. attribute:: lhs
+
+        The left-hand side - what is being transformed. It must follow the
+        :ref:`Query Expression API <query-expression>`.
+
+    .. attribute:: lookup_name
+
+        The name of the lookup, used for identifying it on parsing query
+        expressions. It cannot contain the string ``"__"``.
+
+    .. attribute:: output_field
+
+        Defines the class this transformation outputs. It must be a
+        :class:`~django.db.models.Field` instance. By default is the same as
+        its ``lhs.output_field``.
+
+``Lookup`` reference
+====================
+
+.. class:: Lookup
+
+    A ``Lookup`` is a generic class to implement lookups. A lookup is a query
+    expression with a left-hand side, :attr:`lhs`; a right-hand side,
+    :attr:`rhs`; and a ``lookup_name`` that is used to produce a boolean
+    comparison between ``lhs`` and ``rhs`` such as ``lhs in rhs`` or
+    ``lhs > rhs``.
+
+    The primary notation to use a lookup in an expression is
+    ``<lhs>__<lookup_name>=<rhs>``. Lookups can also be used directly in
+    ``QuerySet`` filters::
+
+         Book.objects.filter(LessThan(F("word_count"), 7500))
+
+    …or annotations::
+
+         Book.objects.annotate(is_short_story=LessThan(F("word_count"), 7500))
+
+    .. attribute:: lhs
+
+        The left-hand side - what is being looked up. The object typically
+        follows the :ref:`Query Expression API <query-expression>`. It may also
+        be a plain value.
+
+    .. attribute:: rhs
+
+        The right-hand side - what ``lhs`` is being compared against. It can be
+        a plain value, or something that compiles into SQL, typically an
+        ``F()`` object or a ``QuerySet``.
+
+    .. attribute:: lookup_name
+
+        The name of this lookup, used to identify it on parsing query
+        expressions. It cannot contain the string ``"__"``.
+
+    .. method:: process_lhs(compiler, connection, lhs=None)
+
+        Returns a tuple ``(lhs_string, lhs_params)``, as returned by
+        ``compiler.compile(lhs)``. This method can be overridden to tune how
+        the ``lhs`` is processed.
+
+        ``compiler`` is an ``SQLCompiler`` object, to be used like
+        ``compiler.compile(lhs)`` for compiling ``lhs``. The ``connection``
+        can be used for compiling vendor specific SQL. If ``lhs`` is not
+        ``None``, use it as the processed ``lhs`` instead of ``self.lhs``.
+
+    .. method:: process_rhs(compiler, connection)
+
+        Behaves the same way as :meth:`process_lhs`, for the right-hand side.

testbed/django__django/docs/ref/models/meta.txt

@@ -0,0 +1,123 @@
+===================
+Model ``_meta`` API
+===================
+
+.. module:: django.db.models.options
+   :synopsis: Model meta-class layer
+
+.. class:: Options
+
+The model ``_meta`` API is at the core of the Django ORM. It enables other
+parts of the system such as lookups, queries, forms, and the admin to
+understand the capabilities of each model. The API is accessible through
+the ``_meta`` attribute of each model class, which is an instance of an
+``django.db.models.options.Options`` object.
+
+Methods that it provides can be used to:
+
+* Retrieve all field instances of a model
+* Retrieve a single field instance of a model by name
+
+.. _model-meta-field-api:
+
+Field access API
+================
+
+Retrieving a single field instance of a model by name
+-----------------------------------------------------
+
+.. method:: Options.get_field(field_name)
+
+    Returns the field instance given a name of a field.
+
+    ``field_name`` can be the name of a field on the model, a field
+    on an abstract or inherited model, or a field defined on another
+    model that points to the model. In the latter case, the ``field_name``
+    will be (in order of preference) the :attr:`~.ForeignKey.related_query_name`
+    set by the user, the :attr:`~.ForeignKey.related_name` set by the user, or
+    the name automatically generated by Django.
+
+    :attr:`Hidden fields <django.db.models.Field.hidden>` cannot be retrieved
+    by name.
+
+    If a field with the given name is not found a
+    :class:`~django.core.exceptions.FieldDoesNotExist` exception will be
+    raised.
+
+    .. code-block:: pycon
+
+        >>> from django.contrib.auth.models import User
+
+        # A field on the model
+        >>> User._meta.get_field("username")
+        <django.db.models.fields.CharField: username>
+
+        # A field from another model that has a relation with the current model
+        >>> User._meta.get_field("logentry")
+        <ManyToOneRel: admin.logentry>
+
+        # A non existent field
+        >>> User._meta.get_field("does_not_exist")
+        Traceback (most recent call last):
+            ...
+        FieldDoesNotExist: User has no field named 'does_not_exist'
+
+Retrieving all field instances of a model
+-----------------------------------------
+
+.. method:: Options.get_fields(include_parents=True, include_hidden=False)
+
+    Returns a tuple of fields associated with a model. ``get_fields()`` accepts
+    two parameters that can be used to control which fields are returned:
+
+    ``include_parents``
+        ``True`` by default. Recursively includes fields defined on parent
+        classes. If set to ``False``, ``get_fields()`` will only search for
+        fields declared directly on the current model. Fields from models that
+        directly inherit from abstract models or proxy classes are considered
+        to be local, not on the parent.
+
+    ``include_hidden``
+        ``False`` by default. If set to ``True``, ``get_fields()`` will include
+        fields that are used to back other field's functionality. This will
+        also include any fields that have a ``related_name`` (such
+        as :class:`~django.db.models.ManyToManyField`, or
+        :class:`~django.db.models.ForeignKey`) that start with a "+".
+
+    .. code-block:: pycon
+
+        >>> from django.contrib.auth.models import User
+        >>> User._meta.get_fields()
+        (<ManyToOneRel: admin.logentry>,
+         <django.db.models.fields.AutoField: id>,
+         <django.db.models.fields.CharField: password>,
+         <django.db.models.fields.DateTimeField: last_login>,
+         <django.db.models.fields.BooleanField: is_superuser>,
+         <django.db.models.fields.CharField: username>,
+         <django.db.models.fields.CharField: first_name>,
+         <django.db.models.fields.CharField: last_name>,
+         <django.db.models.fields.EmailField: email>,
+         <django.db.models.fields.BooleanField: is_staff>,
+         <django.db.models.fields.BooleanField: is_active>,
+         <django.db.models.fields.DateTimeField: date_joined>,
+         <django.db.models.fields.related.ManyToManyField: groups>,
+         <django.db.models.fields.related.ManyToManyField: user_permissions>)
+
+        # Also include hidden fields.
+        >>> User._meta.get_fields(include_hidden=True)
+        (<ManyToOneRel: auth.user_groups>,
+         <ManyToOneRel: auth.user_user_permissions>,
+         <ManyToOneRel: admin.logentry>,
+         <django.db.models.fields.AutoField: id>,
+         <django.db.models.fields.CharField: password>,
+         <django.db.models.fields.DateTimeField: last_login>,
+         <django.db.models.fields.BooleanField: is_superuser>,
+         <django.db.models.fields.CharField: username>,
+         <django.db.models.fields.CharField: first_name>,
+         <django.db.models.fields.CharField: last_name>,
+         <django.db.models.fields.EmailField: email>,
+         <django.db.models.fields.BooleanField: is_staff>,
+         <django.db.models.fields.BooleanField: is_active>,
+         <django.db.models.fields.DateTimeField: date_joined>,
+         <django.db.models.fields.related.ManyToManyField: groups>,
+         <django.db.models.fields.related.ManyToManyField: user_permissions>)

testbed/django__django/docs/ref/request-response.txt

@@ -0,0 +1,1347 @@
+============================
+Request and response objects
+============================
+
+.. module:: django.http
+   :synopsis: Classes dealing with HTTP requests and responses.
+
+Quick overview
+==============
+
+Django uses request and response objects to pass state through the system.
+
+When a page is requested, Django creates an :class:`HttpRequest` object that
+contains metadata about the request. Then Django loads the appropriate view,
+passing the :class:`HttpRequest` as the first argument to the view function.
+Each view is responsible for returning an :class:`HttpResponse` object.
+
+This document explains the APIs for :class:`HttpRequest` and
+:class:`HttpResponse` objects, which are defined in the :mod:`django.http`
+module.
+
+``HttpRequest`` objects
+=======================
+
+.. class:: HttpRequest
+
+.. _httprequest-attributes:
+
+Attributes
+----------
+
+All attributes should be considered read-only, unless stated otherwise.
+
+.. attribute:: HttpRequest.scheme
+
+    A string representing the scheme of the request (``http`` or ``https``
+    usually).
+
+.. attribute:: HttpRequest.body
+
+    The raw HTTP request body as a bytestring. This is useful for processing
+    data in different ways than conventional HTML forms: binary images,
+    XML payload etc. For processing conventional form data, use
+    :attr:`HttpRequest.POST`.
+
+    You can also read from an ``HttpRequest`` using a file-like interface with
+    :meth:`HttpRequest.read` or :meth:`HttpRequest.readline`. Accessing
+    the ``body`` attribute *after* reading the request with either of these I/O
+    stream methods will produce a ``RawPostDataException``.
+
+.. attribute:: HttpRequest.path
+
+    A string representing the full path to the requested page, not including
+    the scheme, domain, or query string.
+
+    Example: ``"/music/bands/the_beatles/"``
+
+.. attribute:: HttpRequest.path_info
+
+    Under some web server configurations, the portion of the URL after the
+    host name is split up into a script prefix portion and a path info
+    portion. The ``path_info`` attribute always contains the path info portion
+    of the path, no matter what web server is being used. Using this instead
+    of :attr:`~HttpRequest.path` can make your code easier to move between
+    test and deployment servers.
+
+    For example, if the ``WSGIScriptAlias`` for your application is set to
+    ``"/minfo"``, then ``path`` might be ``"/minfo/music/bands/the_beatles/"``
+    and ``path_info`` would be ``"/music/bands/the_beatles/"``.
+
+.. attribute:: HttpRequest.method
+
+    A string representing the HTTP method used in the request. This is
+    guaranteed to be uppercase. For example::
+
+        if request.method == "GET":
+            do_something()
+        elif request.method == "POST":
+            do_something_else()
+
+.. attribute:: HttpRequest.encoding
+
+    A string representing the current encoding used to decode form submission
+    data (or ``None``, which means the :setting:`DEFAULT_CHARSET` setting is
+    used). You can write to this attribute to change the encoding used when
+    accessing the form data. Any subsequent attribute accesses (such as reading
+    from :attr:`GET` or :attr:`POST`) will use the new ``encoding`` value.
+    Useful if you know the form data is not in the :setting:`DEFAULT_CHARSET`
+    encoding.
+
+.. attribute:: HttpRequest.content_type
+
+    A string representing the MIME type of the request, parsed from the
+    ``CONTENT_TYPE`` header.
+
+.. attribute:: HttpRequest.content_params
+
+    A dictionary of key/value parameters included in the ``CONTENT_TYPE``
+    header.
+
+.. attribute:: HttpRequest.GET
+
+    A dictionary-like object containing all given HTTP GET parameters. See the
+    :class:`QueryDict` documentation below.
+
+.. attribute:: HttpRequest.POST
+
+    A dictionary-like object containing all given HTTP POST parameters,
+    providing that the request contains form data. See the
+    :class:`QueryDict` documentation below. If you need to access raw or
+    non-form data posted in the request, access this through the
+    :attr:`HttpRequest.body` attribute instead.
+
+    It's possible that a request can come in via POST with an empty ``POST``
+    dictionary -- if, say, a form is requested via the POST HTTP method but
+    does not include form data. Therefore, you shouldn't use ``if request.POST``
+    to check for use of the POST method; instead, use ``if request.method ==
+    "POST"`` (see :attr:`HttpRequest.method`).
+
+    ``POST`` does *not* include file-upload information. See :attr:`FILES`.
+
+.. attribute:: HttpRequest.COOKIES
+
+    A dictionary containing all cookies. Keys and values are strings.
+
+.. attribute:: HttpRequest.FILES
+
+    A dictionary-like object containing all uploaded files. Each key in
+    ``FILES`` is the ``name`` from the ``<input type="file" name="">``. Each
+    value in ``FILES`` is an :class:`~django.core.files.uploadedfile.UploadedFile`.
+
+    See :doc:`/topics/files` for more information.
+
+    ``FILES`` will only contain data if the request method was POST and the
+    ``<form>`` that posted to the request had ``enctype="multipart/form-data"``.
+    Otherwise, ``FILES`` will be a blank dictionary-like object.
+
+.. attribute:: HttpRequest.META
+
+    A dictionary containing all available HTTP headers. Available headers
+    depend on the client and server, but here are some examples:
+
+    * ``CONTENT_LENGTH`` -- The length of the request body (as a string).
+    * ``CONTENT_TYPE`` -- The MIME type of the request body.
+    * ``HTTP_ACCEPT`` -- Acceptable content types for the response.
+    * ``HTTP_ACCEPT_ENCODING`` -- Acceptable encodings for the response.
+    * ``HTTP_ACCEPT_LANGUAGE`` -- Acceptable languages for the response.
+    * ``HTTP_HOST`` -- The HTTP Host header sent by the client.
+    * ``HTTP_REFERER`` -- The referring page, if any.
+    * ``HTTP_USER_AGENT`` -- The client's user-agent string.
+    * ``QUERY_STRING`` -- The query string, as a single (unparsed) string.
+    * ``REMOTE_ADDR`` -- The IP address of the client.
+    * ``REMOTE_HOST`` -- The hostname of the client.
+    * ``REMOTE_USER`` -- The user authenticated by the web server, if any.
+    * ``REQUEST_METHOD`` -- A string such as ``"GET"`` or ``"POST"``.
+    * ``SERVER_NAME`` -- The hostname of the server.
+    * ``SERVER_PORT`` -- The port of the server (as a string).
+
+    With the exception of ``CONTENT_LENGTH`` and ``CONTENT_TYPE``, as given
+    above, any HTTP headers in the request are converted to ``META`` keys by
+    converting all characters to uppercase, replacing any hyphens with
+    underscores and adding an ``HTTP_`` prefix to the name. So, for example, a
+    header called ``X-Bender`` would be mapped to the ``META`` key
+    ``HTTP_X_BENDER``.
+
+    Note that :djadmin:`runserver` strips all headers with underscores in the
+    name, so you won't see them in ``META``. This prevents header-spoofing
+    based on ambiguity between underscores and dashes both being normalizing to
+    underscores in WSGI environment variables. It matches the behavior of
+    web servers like Nginx and Apache 2.4+.
+
+    :attr:`HttpRequest.headers` is a simpler way to access all HTTP-prefixed
+    headers, plus ``CONTENT_LENGTH`` and ``CONTENT_TYPE``.
+
+.. attribute:: HttpRequest.headers
+
+    A case insensitive, dict-like object that provides access to all
+    HTTP-prefixed headers (plus ``Content-Length`` and ``Content-Type``) from
+    the request.
+
+    The name of each header is stylized with title-casing (e.g. ``User-Agent``)
+    when it's displayed. You can access headers case-insensitively:
+
+    .. code-block:: pycon
+
+        >>> request.headers
+        {'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6', ...}
+
+        >>> "User-Agent" in request.headers
+        True
+        >>> "user-agent" in request.headers
+        True
+
+        >>> request.headers["User-Agent"]
+        Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6)
+        >>> request.headers["user-agent"]
+        Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6)
+
+        >>> request.headers.get("User-Agent")
+        Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6)
+        >>> request.headers.get("user-agent")
+        Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6)
+
+    For use in, for example, Django templates, headers can also be looked up
+    using underscores in place of hyphens:
+
+    .. code-block:: html+django
+
+        {{ request.headers.user_agent }}
+
+.. attribute:: HttpRequest.resolver_match
+
+    An instance of :class:`~django.urls.ResolverMatch` representing the
+    resolved URL. This attribute is only set after URL resolving took place,
+    which means it's available in all views but not in middleware which are
+    executed before URL resolving takes place (you can use it in
+    :meth:`process_view` though).
+
+Attributes set by application code
+----------------------------------
+
+Django doesn't set these attributes itself but makes use of them if set by your
+application.
+
+.. attribute:: HttpRequest.current_app
+
+    The :ttag:`url` template tag will use its value as the ``current_app``
+    argument to :func:`~django.urls.reverse()`.
+
+.. attribute:: HttpRequest.urlconf
+
+    This will be used as the root URLconf for the current request, overriding
+    the :setting:`ROOT_URLCONF` setting. See
+    :ref:`how-django-processes-a-request` for details.
+
+    ``urlconf`` can be set to ``None`` to revert any changes made by previous
+    middleware and return to using the :setting:`ROOT_URLCONF`.
+
+.. attribute:: HttpRequest.exception_reporter_filter
+
+    This will be used instead of :setting:`DEFAULT_EXCEPTION_REPORTER_FILTER`
+    for the current request. See :ref:`custom-error-reports` for details.
+
+.. attribute:: HttpRequest.exception_reporter_class
+
+    This will be used instead of :setting:`DEFAULT_EXCEPTION_REPORTER` for the
+    current request. See :ref:`custom-error-reports` for details.
+
+Attributes set by middleware
+----------------------------
+
+Some of the middleware included in Django's contrib apps set attributes on the
+request. If you don't see the attribute on a request, be sure the appropriate
+middleware class is listed in :setting:`MIDDLEWARE`.
+
+.. attribute:: HttpRequest.session
+
+    From the :class:`~django.contrib.sessions.middleware.SessionMiddleware`: A
+    readable and writable, dictionary-like object that represents the current
+    session.
+
+.. attribute:: HttpRequest.site
+
+    From the :class:`~django.contrib.sites.middleware.CurrentSiteMiddleware`:
+    An instance of :class:`~django.contrib.sites.models.Site` or
+    :class:`~django.contrib.sites.requests.RequestSite` as returned by
+    :func:`~django.contrib.sites.shortcuts.get_current_site()`
+    representing the current site.
+
+.. attribute:: HttpRequest.user
+
+    From the :class:`~django.contrib.auth.middleware.AuthenticationMiddleware`:
+    An instance of :setting:`AUTH_USER_MODEL` representing the currently
+    logged-in user. If the user isn't currently logged in, ``user`` will be set
+    to an instance of :class:`~django.contrib.auth.models.AnonymousUser`. You
+    can tell them apart with
+    :attr:`~django.contrib.auth.models.User.is_authenticated`, like so::
+
+        if request.user.is_authenticated:
+            ...  # Do something for logged-in users.
+        else:
+            ...  # Do something for anonymous users.
+
+    The :meth:`auser` method does the same thing but can be used from async
+    contexts.
+
+Methods
+-------
+
+.. method:: HttpRequest.auser()
+
+    .. versionadded:: 5.0
+
+    From the :class:`~django.contrib.auth.middleware.AuthenticationMiddleware`:
+    Coroutine. Returns an instance of :setting:`AUTH_USER_MODEL` representing
+    the currently logged-in user. If the user isn't currently logged in,
+    ``auser`` will return an instance of
+    :class:`~django.contrib.auth.models.AnonymousUser`. This is similar to the
+    :attr:`user` attribute but it works in async contexts.
+
+.. method:: HttpRequest.get_host()
+
+    Returns the originating host of the request using information from the
+    ``HTTP_X_FORWARDED_HOST`` (if :setting:`USE_X_FORWARDED_HOST` is enabled)
+    and ``HTTP_HOST`` headers, in that order. If they don't provide a value,
+    the method uses a combination of ``SERVER_NAME`` and ``SERVER_PORT`` as
+    detailed in :pep:`3333`.
+
+    Example: ``"127.0.0.1:8000"``
+
+    Raises ``django.core.exceptions.DisallowedHost`` if the host is not in
+    :setting:`ALLOWED_HOSTS` or the domain name is invalid according to
+    :rfc:`1034`/:rfc:`1035 <1035>`.
+
+    .. note:: The :meth:`~HttpRequest.get_host()` method fails when the host is
+        behind multiple proxies. One solution is to use middleware to rewrite
+        the proxy headers, as in the following example::
+
+            class MultipleProxyMiddleware:
+                FORWARDED_FOR_FIELDS = [
+                    "HTTP_X_FORWARDED_FOR",
+                    "HTTP_X_FORWARDED_HOST",
+                    "HTTP_X_FORWARDED_SERVER",
+                ]
+
+                def __init__(self, get_response):
+                    self.get_response = get_response
+
+                def __call__(self, request):
+                    """
+                    Rewrites the proxy headers so that only the most
+                    recent proxy is used.
+                    """
+                    for field in self.FORWARDED_FOR_FIELDS:
+                        if field in request.META:
+                            if "," in request.META[field]:
+                                parts = request.META[field].split(",")
+                                request.META[field] = parts[-1].strip()
+                    return self.get_response(request)
+
+        This middleware should be positioned before any other middleware that
+        relies on the value of :meth:`~HttpRequest.get_host()` -- for instance,
+        :class:`~django.middleware.common.CommonMiddleware` or
+        :class:`~django.middleware.csrf.CsrfViewMiddleware`.
+
+.. method:: HttpRequest.get_port()
+
+    Returns the originating port of the request using information from the
+    ``HTTP_X_FORWARDED_PORT`` (if :setting:`USE_X_FORWARDED_PORT` is enabled)
+    and ``SERVER_PORT`` ``META`` variables, in that order.
+
+.. method:: HttpRequest.get_full_path()
+
+    Returns the ``path``, plus an appended query string, if applicable.
+
+    Example: ``"/music/bands/the_beatles/?print=true"``
+
+.. method:: HttpRequest.get_full_path_info()
+
+    Like :meth:`get_full_path`, but uses :attr:`path_info` instead of
+    :attr:`path`.
+
+    Example: ``"/minfo/music/bands/the_beatles/?print=true"``
+
+.. method:: HttpRequest.build_absolute_uri(location=None)
+
+    Returns the absolute URI form of ``location``. If no location is provided,
+    the location will be set to ``request.get_full_path()``.
+
+    If the location is already an absolute URI, it will not be altered.
+    Otherwise the absolute URI is built using the server variables available in
+    this request. For example:
+
+    >>> request.build_absolute_uri()
+    'https://example.com/music/bands/the_beatles/?print=true'
+    >>> request.build_absolute_uri('/bands/')
+    'https://example.com/bands/'
+    >>> request.build_absolute_uri('https://example2.com/bands/')
+    'https://example2.com/bands/'
+
+    .. note::
+
+        Mixing HTTP and HTTPS on the same site is discouraged, therefore
+        :meth:`~HttpRequest.build_absolute_uri()` will always generate an
+        absolute URI with the same scheme the current request has. If you need
+        to redirect users to HTTPS, it's best to let your web server redirect
+        all HTTP traffic to HTTPS.
+
+.. method:: HttpRequest.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)
+
+    Returns a cookie value for a signed cookie, or raises a
+    ``django.core.signing.BadSignature`` exception if the signature is
+    no longer valid. If you provide the ``default`` argument the exception
+    will be suppressed and that default value will be returned instead.
+
+    The optional ``salt`` argument can be used to provide extra protection
+    against brute force attacks on your secret key. If supplied, the
+    ``max_age`` argument will be checked against the signed timestamp
+    attached to the cookie value to ensure the cookie is not older than
+    ``max_age`` seconds.
+
+    For example:
+
+    .. code-block:: pycon
+
+        >>> request.get_signed_cookie("name")
+        'Tony'
+        >>> request.get_signed_cookie("name", salt="name-salt")
+        'Tony' # assuming cookie was set using the same salt
+        >>> request.get_signed_cookie("nonexistent-cookie")
+        KeyError: 'nonexistent-cookie'
+        >>> request.get_signed_cookie("nonexistent-cookie", False)
+        False
+        >>> request.get_signed_cookie("cookie-that-was-tampered-with")
+        BadSignature: ...
+        >>> request.get_signed_cookie("name", max_age=60)
+        SignatureExpired: Signature age 1677.3839159 > 60 seconds
+        >>> request.get_signed_cookie("name", False, max_age=60)
+        False
+
+    See :doc:`cryptographic signing </topics/signing>` for more information.
+
+.. method:: HttpRequest.is_secure()
+
+    Returns ``True`` if the request is secure; that is, if it was made with
+    HTTPS.
+
+.. method:: HttpRequest.accepts(mime_type)
+
+    Returns ``True`` if the request ``Accept`` header matches the ``mime_type``
+    argument:
+
+    .. code-block:: pycon
+
+        >>> request.accepts("text/html")
+        True
+
+    Most browsers send ``Accept: */*`` by default, so this would return
+    ``True`` for all content types. Setting an explicit ``Accept`` header in
+    API requests can be useful for returning a different content type for those
+    consumers only. See :ref:`content-negotiation-example` of using
+    ``accepts()`` to return different content to API consumers.
+
+    If a response varies depending on the content of the ``Accept`` header and
+    you are using some form of caching like Django's :mod:`cache middleware
+    <django.middleware.cache>`, you should decorate the view with
+    :func:`vary_on_headers('Accept')
+    <django.views.decorators.vary.vary_on_headers>` so that the responses are
+    properly cached.
+
+.. method:: HttpRequest.read(size=None)
+.. method:: HttpRequest.readline()
+.. method:: HttpRequest.readlines()
+.. method:: HttpRequest.__iter__()
+
+    Methods implementing a file-like interface for reading from an
+    ``HttpRequest`` instance. This makes it possible to consume an incoming
+    request in a streaming fashion. A common use-case would be to process a
+    big XML payload with an iterative parser without constructing a whole
+    XML tree in memory.
+
+    Given this standard interface, an ``HttpRequest`` instance can be
+    passed directly to an XML parser such as
+    :class:`~xml.etree.ElementTree.ElementTree`::
+
+        import xml.etree.ElementTree as ET
+
+        for element in ET.iterparse(request):
+            process(element)
+
+
+``QueryDict`` objects
+=====================
+
+.. class:: QueryDict
+
+In an :class:`HttpRequest` object, the :attr:`~HttpRequest.GET` and
+:attr:`~HttpRequest.POST` attributes are instances of ``django.http.QueryDict``,
+a dictionary-like class customized to deal with multiple values for the same
+key. This is necessary because some HTML form elements, notably
+``<select multiple>``, pass multiple values for the same key.
+
+The ``QueryDict``\ s at ``request.POST`` and ``request.GET`` will be immutable
+when accessed in a normal request/response cycle. To get a mutable version you
+need to use :meth:`QueryDict.copy`.
+
+Methods
+-------
+
+:class:`QueryDict` implements all the standard dictionary methods because it's
+a subclass of dictionary. Exceptions are outlined here:
+
+.. method:: QueryDict.__init__(query_string=None, mutable=False, encoding=None)
+
+    Instantiates a ``QueryDict`` object based on ``query_string``.
+
+    >>> QueryDict('a=1&a=2&c=3')
+    <QueryDict: {'a': ['1', '2'], 'c': ['3']}>
+
+    If ``query_string`` is not passed in, the resulting ``QueryDict`` will be
+    empty (it will have no keys or values).
+
+    Most ``QueryDict``\ s you encounter, and in particular those at
+    ``request.POST`` and ``request.GET``, will be immutable. If you are
+    instantiating one yourself, you can make it mutable by passing
+    ``mutable=True`` to its ``__init__()``.
+
+    Strings for setting both keys and values will be converted from ``encoding``
+    to ``str``. If ``encoding`` is not set, it defaults to
+    :setting:`DEFAULT_CHARSET`.
+
+.. classmethod:: QueryDict.fromkeys(iterable, value='', mutable=False, encoding=None)
+
+    Creates a new ``QueryDict`` with keys from ``iterable`` and each value
+    equal to ``value``. For example:
+
+    .. code-block:: pycon
+
+        >>> QueryDict.fromkeys(["a", "a", "b"], value="val")
+        <QueryDict: {'a': ['val', 'val'], 'b': ['val']}>
+
+.. method:: QueryDict.__getitem__(key)
+
+    Returns the value for the given key. If the key has more than one value,
+    it returns the last value. Raises
+    ``django.utils.datastructures.MultiValueDictKeyError`` if the key does not
+    exist. (This is a subclass of Python's standard :exc:`KeyError`, so you can
+    stick to catching ``KeyError``.)
+
+.. method:: QueryDict.__setitem__(key, value)
+
+    Sets the given key to ``[value]`` (a list whose single element is
+    ``value``). Note that this, as other dictionary functions that have side
+    effects, can only be called on a mutable ``QueryDict`` (such as one that
+    was created via :meth:`QueryDict.copy`).
+
+.. method:: QueryDict.__contains__(key)
+
+    Returns ``True`` if the given key is set. This lets you do, e.g., ``if "foo"
+    in request.GET``.
+
+.. method:: QueryDict.get(key, default=None)
+
+    Uses the same logic as :meth:`__getitem__`, with a hook for returning a
+    default value if the key doesn't exist.
+
+.. method:: QueryDict.setdefault(key, default=None)
+
+    Like :meth:`dict.setdefault`, except it uses :meth:`__setitem__` internally.
+
+.. method:: QueryDict.update(other_dict)
+
+    Takes either a ``QueryDict`` or a dictionary. Like :meth:`dict.update`,
+    except it *appends* to the current dictionary items rather than replacing
+    them. For example:
+
+    .. code-block:: pycon
+
+        >>> q = QueryDict("a=1", mutable=True)
+        >>> q.update({"a": "2"})
+        >>> q.getlist("a")
+        ['1', '2']
+        >>> q["a"]  # returns the last
+        '2'
+
+.. method:: QueryDict.items()
+
+    Like :meth:`dict.items`, except this uses the same last-value logic as
+    :meth:`__getitem__` and returns an iterator object instead of a view object.
+    For example:
+
+    .. code-block:: pycon
+
+        >>> q = QueryDict("a=1&a=2&a=3")
+        >>> list(q.items())
+        [('a', '3')]
+
+.. method:: QueryDict.values()
+
+    Like :meth:`dict.values`, except this uses the same last-value logic as
+    :meth:`__getitem__` and returns an iterator instead of a view object. For
+    example:
+
+    .. code-block:: pycon
+
+        >>> q = QueryDict("a=1&a=2&a=3")
+        >>> list(q.values())
+        ['3']
+
+In addition, ``QueryDict`` has the following methods:
+
+.. method:: QueryDict.copy()
+
+    Returns a copy of the object using :func:`copy.deepcopy`. This copy will
+    be mutable even if the original was not.
+
+.. method:: QueryDict.getlist(key, default=None)
+
+    Returns a list of the data with the requested key. Returns an empty list if
+    the key doesn't exist and ``default`` is ``None``. It's guaranteed to
+    return a list unless the default value provided isn't a list.
+
+.. method:: QueryDict.setlist(key, list_)
+
+    Sets the given key to ``list_`` (unlike :meth:`__setitem__`).
+
+.. method:: QueryDict.appendlist(key, item)
+
+    Appends an item to the internal list associated with key.
+
+.. method:: QueryDict.setlistdefault(key, default_list=None)
+
+    Like :meth:`setdefault`, except it takes a list of values instead of a
+    single value.
+
+.. method:: QueryDict.lists()
+
+    Like :meth:`items()`, except it includes all values, as a list, for each
+    member of the dictionary. For example:
+
+    .. code-block:: pycon
+
+        >>> q = QueryDict("a=1&a=2&a=3")
+        >>> q.lists()
+        [('a', ['1', '2', '3'])]
+
+.. method:: QueryDict.pop(key)
+
+    Returns a list of values for the given key and removes them from the
+    dictionary. Raises ``KeyError`` if the key does not exist. For example:
+
+    .. code-block:: pycon
+
+        >>> q = QueryDict("a=1&a=2&a=3", mutable=True)
+        >>> q.pop("a")
+        ['1', '2', '3']
+
+.. method:: QueryDict.popitem()
+
+    Removes an arbitrary member of the dictionary (since there's no concept
+    of ordering), and returns a two value tuple containing the key and a list
+    of all values for the key. Raises ``KeyError`` when called on an empty
+    dictionary. For example:
+
+    .. code-block:: pycon
+
+        >>> q = QueryDict("a=1&a=2&a=3", mutable=True)
+        >>> q.popitem()
+        ('a', ['1', '2', '3'])
+
+.. method:: QueryDict.dict()
+
+    Returns a ``dict`` representation of ``QueryDict``. For every (key, list)
+    pair in ``QueryDict``, ``dict`` will have (key, item), where item is one
+    element of the list, using the same logic as :meth:`QueryDict.__getitem__`:
+
+    .. code-block:: pycon
+
+        >>> q = QueryDict("a=1&a=3&a=5")
+        >>> q.dict()
+        {'a': '5'}
+
+.. method:: QueryDict.urlencode(safe=None)
+
+    Returns a string of the data in query string format. For example:
+
+    .. code-block:: pycon
+
+        >>> q = QueryDict("a=2&b=3&b=5")
+        >>> q.urlencode()
+        'a=2&b=3&b=5'
+
+    Use the ``safe`` parameter to pass characters which don't require encoding.
+    For example:
+
+    .. code-block:: pycon
+
+        >>> q = QueryDict(mutable=True)
+        >>> q["next"] = "/a&b/"
+        >>> q.urlencode(safe="/")
+        'next=/a%26b/'
+
+``HttpResponse`` objects
+========================
+
+.. class:: HttpResponse
+
+In contrast to :class:`HttpRequest` objects, which are created automatically by
+Django, :class:`HttpResponse` objects are your responsibility. Each view you
+write is responsible for instantiating, populating, and returning an
+:class:`HttpResponse`.
+
+The :class:`HttpResponse` class lives in the :mod:`django.http` module.
+
+Usage
+-----
+
+Passing strings
+~~~~~~~~~~~~~~~
+
+Typical usage is to pass the contents of the page, as a string, bytestring,
+or :class:`memoryview`, to the :class:`HttpResponse` constructor:
+
+.. code-block:: pycon
+
+    >>> from django.http import HttpResponse
+    >>> response = HttpResponse("Here's the text of the web page.")
+    >>> response = HttpResponse("Text only, please.", content_type="text/plain")
+    >>> response = HttpResponse(b"Bytestrings are also accepted.")
+    >>> response = HttpResponse(memoryview(b"Memoryview as well."))
+
+But if you want to add content incrementally, you can use ``response`` as a
+file-like object:
+
+.. code-block:: pycon
+
+    >>> response = HttpResponse()
+    >>> response.write("<p>Here's the text of the web page.</p>")
+    >>> response.write("<p>Here's another paragraph.</p>")
+
+Passing iterators
+~~~~~~~~~~~~~~~~~
+
+Finally, you can pass ``HttpResponse`` an iterator rather than strings.
+``HttpResponse`` will consume the iterator immediately, store its content as a
+string, and discard it. Objects with a ``close()`` method such as files and
+generators are immediately closed.
+
+If you need the response to be streamed from the iterator to the client, you
+must use the :class:`StreamingHttpResponse` class instead.
+
+.. _setting-header-fields:
+
+Setting header fields
+~~~~~~~~~~~~~~~~~~~~~
+
+To set or remove a header field in your response, use
+:attr:`HttpResponse.headers`:
+
+.. code-block:: pycon
+
+    >>> response = HttpResponse()
+    >>> response.headers["Age"] = 120
+    >>> del response.headers["Age"]
+
+You can also manipulate headers by treating your response like a dictionary:
+
+.. code-block:: pycon
+
+    >>> response = HttpResponse()
+    >>> response["Age"] = 120
+    >>> del response["Age"]
+
+This proxies to ``HttpResponse.headers``, and is the original interface offered
+by ``HttpResponse``.
+
+When using this interface, unlike a dictionary, ``del`` doesn't raise
+``KeyError`` if the header field doesn't exist.
+
+You can also set headers on instantiation:
+
+.. code-block:: pycon
+
+    >>> response = HttpResponse(headers={"Age": 120})
+
+For setting the ``Cache-Control`` and ``Vary`` header fields, it is recommended
+to use the :func:`~django.utils.cache.patch_cache_control` and
+:func:`~django.utils.cache.patch_vary_headers` methods from
+:mod:`django.utils.cache`, since these fields can have multiple, comma-separated
+values. The "patch" methods ensure that other values, e.g. added by a
+middleware, are not removed.
+
+HTTP header fields cannot contain newlines. An attempt to set a header field
+containing a newline character (CR or LF) will raise ``BadHeaderError``
+
+Telling the browser to treat the response as a file attachment
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To tell the browser to treat the response as a file attachment, set the
+``Content-Type`` and ``Content-Disposition`` headers. For example, this is how
+you might return a Microsoft Excel spreadsheet:
+
+.. code-block:: pycon
+
+    >>> response = HttpResponse(
+    ...     my_data,
+    ...     headers={
+    ...         "Content-Type": "application/vnd.ms-excel",
+    ...         "Content-Disposition": 'attachment; filename="foo.xls"',
+    ...     },
+    ... )
+
+There's nothing Django-specific about the ``Content-Disposition`` header, but
+it's easy to forget the syntax, so we've included it here.
+
+Attributes
+----------
+
+.. attribute:: HttpResponse.content
+
+    A bytestring representing the content, encoded from a string if necessary.
+
+.. attribute:: HttpResponse.headers
+
+    A case insensitive, dict-like object that provides an interface to all
+    HTTP headers on the response. See :ref:`setting-header-fields`.
+
+.. attribute:: HttpResponse.charset
+
+    A string denoting the charset in which the response will be encoded. If not
+    given at ``HttpResponse`` instantiation time, it will be extracted from
+    ``content_type`` and if that is unsuccessful, the
+    :setting:`DEFAULT_CHARSET` setting will be used.
+
+.. attribute:: HttpResponse.status_code
+
+    The :rfc:`HTTP status code <9110#section-15>` for the response.
+
+    Unless :attr:`reason_phrase` is explicitly set, modifying the value of
+    ``status_code`` outside the constructor will also modify the value of
+    ``reason_phrase``.
+
+.. attribute:: HttpResponse.reason_phrase
+
+    The HTTP reason phrase for the response. It uses the :rfc:`HTTP standard's
+    <9110#section-15.1>` default reason phrases.
+
+    Unless explicitly set, ``reason_phrase`` is determined by the value of
+    :attr:`status_code`.
+
+.. attribute:: HttpResponse.streaming
+
+    This is always ``False``.
+
+    This attribute exists so middleware can treat streaming responses
+    differently from regular responses.
+
+.. attribute:: HttpResponse.closed
+
+    ``True`` if the response has been closed.
+
+Methods
+-------
+
+.. method:: HttpResponse.__init__(content=b'', content_type=None, status=200, reason=None, charset=None, headers=None)
+
+    Instantiates an ``HttpResponse`` object with the given page content,
+    content type, and headers.
+
+    ``content`` is most commonly an iterator, bytestring, :class:`memoryview`,
+    or string. Other types will be converted to a bytestring by encoding their
+    string representation. Iterators should return strings or bytestrings and
+    those will be joined together to form the content of the response.
+
+    ``content_type`` is the MIME type optionally completed by a character set
+    encoding and is used to fill the HTTP ``Content-Type`` header. If not
+    specified, it is formed by ``'text/html'`` and the
+    :setting:`DEFAULT_CHARSET` settings, by default:
+    ``"text/html; charset=utf-8"``.
+
+    ``status`` is the :rfc:`HTTP status code <9110#section-15>` for the
+    response. You can use Python's :py:class:`http.HTTPStatus` for meaningful
+    aliases, such as ``HTTPStatus.NO_CONTENT``.
+
+    ``reason`` is the HTTP response phrase. If not provided, a default phrase
+    will be used.
+
+    ``charset`` is the charset in which the response will be encoded. If not
+    given it will be extracted from ``content_type``, and if that
+    is unsuccessful, the :setting:`DEFAULT_CHARSET` setting will be used.
+
+    ``headers`` is a :class:`dict` of HTTP headers for the response.
+
+.. method:: HttpResponse.__setitem__(header, value)
+
+    Sets the given header name to the given value. Both ``header`` and
+    ``value`` should be strings.
+
+.. method:: HttpResponse.__delitem__(header)
+
+    Deletes the header with the given name. Fails silently if the header
+    doesn't exist. Case-insensitive.
+
+.. method:: HttpResponse.__getitem__(header)
+
+    Returns the value for the given header name. Case-insensitive.
+
+.. method:: HttpResponse.get(header, alternate=None)
+
+    Returns the value for the given header, or an ``alternate`` if the header
+    doesn't exist.
+
+.. method:: HttpResponse.has_header(header)
+
+    Returns ``True`` or ``False`` based on a case-insensitive check for a
+    header with the given name.
+
+.. method:: HttpResponse.items()
+
+    Acts like :meth:`dict.items` for HTTP headers on the response.
+
+.. method:: HttpResponse.setdefault(header, value)
+
+    Sets a header unless it has already been set.
+
+.. method:: HttpResponse.set_cookie(key, value='', max_age=None, expires=None, path='/', domain=None, secure=False, httponly=False, samesite=None)
+
+    Sets a cookie. The parameters are the same as in the
+    :class:`~http.cookies.Morsel` cookie object in the Python standard library.
+
+    * ``max_age`` should be a :class:`~datetime.timedelta` object, an integer
+      number of seconds, or ``None`` (default) if the cookie should last only
+      as long as the client's browser session. If ``expires`` is not specified,
+      it will be calculated.
+    * ``expires`` should either be a string in the format
+      ``"Wdy, DD-Mon-YY HH:MM:SS GMT"`` or a ``datetime.datetime`` object
+      in UTC. If ``expires`` is a ``datetime`` object, the ``max_age``
+      will be calculated.
+    * Use ``domain`` if you want to set a cross-domain cookie. For example,
+      ``domain="example.com"`` will set a cookie that is readable by the
+      domains www.example.com, blog.example.com, etc. Otherwise, a cookie will
+      only be readable by the domain that set it.
+    * Use ``secure=True`` if you want the cookie to be only sent to the server
+      when a request is made with the ``https`` scheme.
+    * Use ``httponly=True`` if you want to prevent client-side
+      JavaScript from having access to the cookie.
+
+      HttpOnly_ is a flag included in a Set-Cookie HTTP response header. It's
+      part of the :rfc:`RFC 6265 <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.
+    * Use ``samesite='Strict'`` or ``samesite='Lax'`` to tell the browser not
+      to send this cookie when performing a cross-origin request. `SameSite`_
+      isn't supported by all browsers, so it's not a replacement for Django's
+      CSRF protection, but rather a defense in depth measure.
+
+      Use ``samesite='None'`` (string) to explicitly state that this cookie is
+      sent with all same-site and cross-site requests.
+
+    .. _HttpOnly: https://owasp.org/www-community/HttpOnly
+    .. _SameSite: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite
+
+    .. warning::
+
+        :rfc:`RFC 6265 <6265#section-6.1>` states that user agents should
+        support cookies of at least 4096 bytes. For many browsers this is also
+        the maximum size. Django will not raise an exception if there's an
+        attempt to store a cookie of more than 4096 bytes, but many browsers
+        will not set the cookie correctly.
+
+.. method:: HttpResponse.set_signed_cookie(key, value, salt='', max_age=None, expires=None, path='/', domain=None, secure=False, httponly=False, samesite=None)
+
+    Like :meth:`~HttpResponse.set_cookie()`, but
+    :doc:`cryptographic signing </topics/signing>` the cookie before setting
+    it. Use in conjunction with :meth:`HttpRequest.get_signed_cookie`.
+    You can use the optional ``salt`` argument for added key strength, but
+    you will need to remember to pass it to the corresponding
+    :meth:`HttpRequest.get_signed_cookie` call.
+
+.. method:: HttpResponse.delete_cookie(key, path='/', domain=None, samesite=None)
+
+    Deletes the cookie with the given key. Fails silently if the key doesn't
+    exist.
+
+    Due to the way cookies work, ``path`` and ``domain`` should be the same
+    values you used in ``set_cookie()`` -- otherwise the cookie may not be
+    deleted.
+
+.. method:: HttpResponse.close()
+
+    This method is called at the end of the request directly by the WSGI
+    server.
+
+.. method:: HttpResponse.write(content)
+
+    This method makes an :class:`HttpResponse` instance a file-like object.
+
+.. method:: HttpResponse.flush()
+
+    This method makes an :class:`HttpResponse` instance a file-like object.
+
+.. method:: HttpResponse.tell()
+
+    This method makes an :class:`HttpResponse` instance a file-like object.
+
+.. method:: HttpResponse.getvalue()
+
+    Returns the value of :attr:`HttpResponse.content`. This method makes
+    an :class:`HttpResponse` instance a stream-like object.
+
+.. method:: HttpResponse.readable()
+
+    Always ``False``. This method makes an :class:`HttpResponse` instance a
+    stream-like object.
+
+.. method:: HttpResponse.seekable()
+
+    Always ``False``. This method makes an :class:`HttpResponse` instance a
+    stream-like object.
+
+.. method:: HttpResponse.writable()
+
+    Always ``True``. This method makes an :class:`HttpResponse` instance a
+    stream-like object.
+
+.. method:: HttpResponse.writelines(lines)
+
+    Writes a list of lines to the response. Line separators are not added. This
+    method makes an :class:`HttpResponse` instance a stream-like object.
+
+.. _ref-httpresponse-subclasses:
+
+``HttpResponse`` subclasses
+---------------------------
+
+Django includes a number of ``HttpResponse`` subclasses that handle different
+types of HTTP responses. Like ``HttpResponse``, these subclasses live in
+:mod:`django.http`.
+
+.. class:: HttpResponseRedirect
+
+    The first argument to the constructor is required -- the path to redirect
+    to. This can be a fully qualified URL
+    (e.g. ``'https://www.yahoo.com/search/'``), an absolute path with no domain
+    (e.g. ``'/search/'``), or even a relative path (e.g. ``'search/'``). In that
+    last case, the client browser will reconstruct the full URL itself
+    according to the current path. See :class:`HttpResponse` for other optional
+    constructor arguments. Note that this returns an HTTP status code 302.
+
+    .. attribute:: HttpResponseRedirect.url
+
+        This read-only attribute represents the URL the response will redirect
+        to (equivalent to the ``Location`` response header).
+
+.. class:: HttpResponsePermanentRedirect
+
+    Like :class:`HttpResponseRedirect`, but it returns a permanent redirect
+    (HTTP status code 301) instead of a "found" redirect (status code 302).
+
+.. class:: HttpResponseNotModified
+
+    The constructor doesn't take any arguments and no content should be added
+    to this response. Use this to designate that a page hasn't been modified
+    since the user's last request (status code 304).
+
+.. class:: HttpResponseBadRequest
+
+    Acts just like :class:`HttpResponse` but uses a 400 status code.
+
+.. class:: HttpResponseNotFound
+
+    Acts just like :class:`HttpResponse` but uses a 404 status code.
+
+.. class:: HttpResponseForbidden
+
+    Acts just like :class:`HttpResponse` but uses a 403 status code.
+
+.. class:: HttpResponseNotAllowed
+
+    Like :class:`HttpResponse`, but uses a 405 status code. The first argument
+    to the constructor is required: a list of permitted methods (e.g.
+    ``['GET', 'POST']``).
+
+.. class:: HttpResponseGone
+
+    Acts just like :class:`HttpResponse` but uses a 410 status code.
+
+.. class:: HttpResponseServerError
+
+    Acts just like :class:`HttpResponse` but uses a 500 status code.
+
+.. note::
+
+    If a custom subclass of :class:`HttpResponse` implements a ``render``
+    method, Django will treat it as emulating a
+    :class:`~django.template.response.SimpleTemplateResponse`, and the
+    ``render`` method must itself return a valid response object.
+
+Custom response classes
+~~~~~~~~~~~~~~~~~~~~~~~
+
+If you find yourself needing a response class that Django doesn't provide, you
+can create it with the help of :py:class:`http.HTTPStatus`. For example:
+
+.. code-block:: pycon
+
+    from http import HTTPStatus
+    from django.http import HttpResponse
+
+    class HttpResponseNoContent(HttpResponse):
+        status_code = HTTPStatus.NO_CONTENT
+
+``JsonResponse`` objects
+========================
+
+.. class:: JsonResponse(data, encoder=DjangoJSONEncoder, safe=True, json_dumps_params=None, **kwargs)
+
+    An :class:`HttpResponse` subclass that helps to create a JSON-encoded
+    response. It inherits most behavior from its superclass with a couple
+    differences:
+
+    Its default ``Content-Type`` header is set to :mimetype:`application/json`.
+
+    The first parameter, ``data``, should be a ``dict`` instance. If the
+    ``safe`` parameter is set to ``False`` (see below) it can be any
+    JSON-serializable object.
+
+    The ``encoder``, which defaults to
+    :class:`django.core.serializers.json.DjangoJSONEncoder`, will be used to
+    serialize the data. See :ref:`JSON serialization
+    <serialization-formats-json>` for more details about this serializer.
+
+    The ``safe`` boolean parameter defaults to ``True``. If it's set to
+    ``False``, any object can be passed for serialization (otherwise only
+    ``dict`` instances are allowed). If ``safe`` is ``True`` and a non-``dict``
+    object is passed as the first argument, a :exc:`TypeError` will be raised.
+
+    The ``json_dumps_params`` parameter is a dictionary of keyword arguments
+    to pass to the ``json.dumps()`` call used to generate the response.
+
+Usage
+-----
+
+Typical usage could look like:
+
+.. code-block:: pycon
+
+    >>> from django.http import JsonResponse
+    >>> response = JsonResponse({"foo": "bar"})
+    >>> response.content
+    b'{"foo": "bar"}'
+
+Serializing non-dictionary objects
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In order to serialize objects other than ``dict`` you must set the ``safe``
+parameter to ``False``:
+
+.. code-block:: pycon
+
+    >>> response = JsonResponse([1, 2, 3], safe=False)
+
+Without passing ``safe=False``, a :exc:`TypeError` will be raised.
+
+Note that an API based on ``dict`` objects is more extensible, flexible, and
+makes it easier to maintain forwards compatibility. Therefore, you should avoid
+using non-dict objects in JSON-encoded response.
+
+.. warning::
+
+    Before the `5th edition of ECMAScript
+    <https://262.ecma-international.org/5.1/#sec-11.1.4>`_ it was possible to
+    poison the JavaScript ``Array`` constructor. For this reason, Django does
+    not allow passing non-dict objects to the
+    :class:`~django.http.JsonResponse` constructor by default.  However, most
+    modern browsers implement ECMAScript 5 which removes this attack vector.
+    Therefore it is possible to disable this security precaution.
+
+Changing the default JSON encoder
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If you need to use a different JSON encoder class you can pass the ``encoder``
+parameter to the constructor method:
+
+.. code-block:: pycon
+
+    >>> response = JsonResponse(data, encoder=MyJSONEncoder)
+
+.. _httpresponse-streaming:
+
+``StreamingHttpResponse`` objects
+=================================
+
+.. class:: StreamingHttpResponse
+
+The :class:`StreamingHttpResponse` class is used to stream a response from
+Django to the browser.
+
+.. admonition:: Advanced usage
+
+    :class:`StreamingHttpResponse` is somewhat advanced, in that it is
+    important to know whether you'll be serving your application synchronously
+    under WSGI or asynchronously under ASGI, and adjust your usage
+    appropriately.
+
+    Please read these notes with care.
+
+An example usage of :class:`StreamingHttpResponse` under WSGI is streaming
+content when generating the response would take too long or uses too much
+memory. For instance, it's useful for :ref:`generating large CSV files
+<streaming-csv-files>`.
+
+There are performance considerations when doing this, though. Django, under
+WSGI, is designed for short-lived requests. Streaming responses will tie a
+worker process for the entire duration of the response. This may result in poor
+performance.
+
+Generally speaking, you would perform expensive tasks outside of the
+request-response cycle, rather than resorting to a streamed response.
+
+When serving under ASGI, however, a :class:`StreamingHttpResponse` need not
+stop other requests from being served whilst waiting for I/O. This opens up
+the possibility of long-lived requests for streaming content and implementing
+patterns such as long-polling, and server-sent events.
+
+Even under ASGI note, :class:`StreamingHttpResponse` should only be used in
+situations where it is absolutely required that the whole content isn't
+iterated before transferring the data to the client. Because the content can't
+be accessed, many middleware can't function normally. For example the ``ETag``
+and ``Content-Length`` headers can't be generated for streaming responses.
+
+The :class:`StreamingHttpResponse` is not a subclass of :class:`HttpResponse`,
+because it features a slightly different API. However, it is almost identical,
+with the following notable differences:
+
+* It should be given an iterator that yields bytestrings, :class:`memoryview`,
+  or strings as content. When serving under WSGI, this should be a sync
+  iterator. When serving under ASGI, then it should be an async iterator.
+
+* You cannot access its content, except by iterating the response object
+  itself. This should only occur when the response is returned to the client:
+  you should not iterate the response yourself.
+
+  Under WSGI the response will be iterated synchronously. Under ASGI the
+  response will be iterated asynchronously. (This is why the iterator type must
+  match the protocol you're using.)
+
+  To avoid a crash, an incorrect iterator type will be mapped to the correct
+  type during iteration, and a warning will be raised, but in order to do this
+  the iterator must be fully-consumed, which defeats the purpose of using a
+  :class:`StreamingHttpResponse` at all.
+
+* It has no ``content`` attribute. Instead, it has a
+  :attr:`~StreamingHttpResponse.streaming_content` attribute. This can be used
+  in middleware to wrap the response iterable, but should not be consumed.
+
+* You cannot use the file-like object ``tell()`` or ``write()`` methods.
+  Doing so will raise an exception.
+
+The :class:`HttpResponseBase` base class is common between
+:class:`HttpResponse` and :class:`StreamingHttpResponse`.
+
+.. versionchanged:: 4.2
+
+    Support for asynchronous iteration was added.
+
+Attributes
+----------
+
+.. attribute:: StreamingHttpResponse.streaming_content
+
+    An iterator of the response content, bytestring encoded according to
+    :attr:`HttpResponse.charset`.
+
+.. attribute:: StreamingHttpResponse.status_code
+
+    The :rfc:`HTTP status code <9110#section-15>` for the response.
+
+    Unless :attr:`reason_phrase` is explicitly set, modifying the value of
+    ``status_code`` outside the constructor will also modify the value of
+    ``reason_phrase``.
+
+.. attribute:: StreamingHttpResponse.reason_phrase
+
+    The HTTP reason phrase for the response. It uses the :rfc:`HTTP standard's
+    <9110#section-15.1>` default reason phrases.
+
+    Unless explicitly set, ``reason_phrase`` is determined by the value of
+    :attr:`status_code`.
+
+.. attribute:: StreamingHttpResponse.streaming
+
+    This is always ``True``.
+
+.. attribute:: StreamingHttpResponse.is_async
+
+    .. versionadded:: 4.2
+
+    Boolean indicating whether :attr:`StreamingHttpResponse.streaming_content`
+    is an asynchronous iterator or not.
+
+    This is useful for middleware needing to wrap
+    :attr:`StreamingHttpResponse.streaming_content`.
+
+``FileResponse`` objects
+========================
+
+.. class:: FileResponse(open_file, as_attachment=False, filename='', **kwargs)
+
+    :class:`FileResponse` is a subclass of :class:`StreamingHttpResponse`
+    optimized for binary files. It uses :pep:`wsgi.file_wrapper
+    <3333#optional-platform-specific-file-handling>` if provided by the wsgi
+    server, otherwise it streams the file out in small chunks.
+
+    If ``as_attachment=True``, the ``Content-Disposition`` header is set to
+    ``attachment``, which asks the browser to offer the file to the user as a
+    download. Otherwise, a ``Content-Disposition`` header with a value of
+    ``inline`` (the browser default) will be set only if a filename is
+    available.
+
+    If ``open_file`` doesn't have a name or if the name of ``open_file`` isn't
+    appropriate, provide a custom file name using the ``filename``  parameter.
+    Note that if you pass a file-like object like ``io.BytesIO``, it's your
+    task to ``seek()`` it before passing it to ``FileResponse``.
+
+    The ``Content-Length`` header is automatically set when it can be guessed
+    from the content of ``open_file``.
+
+    The ``Content-Type`` header is automatically set when it can be guessed
+    from the ``filename``, or the name of ``open_file``.
+
+``FileResponse`` accepts any file-like object with binary content, for example
+a file open in binary mode like so:
+
+.. code-block:: pycon
+
+    >>> from django.http import FileResponse
+    >>> response = FileResponse(open("myfile.png", "rb"))
+
+The file will be closed automatically, so don't open it with a context manager.
+
+.. admonition:: Use under ASGI
+
+    Python's file API is synchronous. This means that the file must be fully
+    consumed in order to be served under ASGI.
+
+    In order to stream a file asynchronously you need to use a third-party
+    package that provides an asynchronous file API, such as `aiofiles
+    <https://github.com/Tinche/aiofiles>`_.
+
+Methods
+-------
+
+.. method:: FileResponse.set_headers(open_file)
+
+    This method is automatically called during the response initialization and
+    set various headers (``Content-Length``, ``Content-Type``, and
+    ``Content-Disposition``) depending on ``open_file``.
+
+``HttpResponseBase`` class
+==========================
+
+.. class:: HttpResponseBase
+
+The :class:`HttpResponseBase` class is common to all Django responses.
+It should not be used to create responses directly, but it can be
+useful for type-checking.

testbed/django__django/docs/ref/schema-editor.txt

@@ -0,0 +1,210 @@
+================
+``SchemaEditor``
+================
+
+.. module:: django.db.backends.base.schema
+
+.. class:: BaseDatabaseSchemaEditor
+
+Django's migration system is split into two parts; the logic for calculating
+and storing what operations should be run (``django.db.migrations``), and the
+database abstraction layer that turns things like "create a model" or
+"delete a field" into SQL - which is the job of the ``SchemaEditor``.
+
+It's unlikely that you will want to interact directly with ``SchemaEditor`` as
+a normal developer using Django, but if you want to write your own migration
+system, or have more advanced needs, it's a lot nicer than writing SQL.
+
+Each database backend in Django supplies its own version of ``SchemaEditor``,
+and it's always accessible via the ``connection.schema_editor()`` context
+manager::
+
+    with connection.schema_editor() as schema_editor:
+        schema_editor.delete_model(MyModel)
+
+It must be used via the context manager as this allows it to manage things
+like transactions and deferred SQL (like creating ``ForeignKey`` constraints).
+
+It exposes all possible operations as methods, that should be called in
+the order you wish changes to be applied. Some possible operations or types
+of change are not possible on all databases - for example, MyISAM does not
+support foreign key constraints.
+
+If you are writing or maintaining a third-party database backend for Django,
+you will need to provide a ``SchemaEditor`` implementation in order to work with
+Django's migration functionality - however, as long as your database is
+relatively standard in its use of SQL and relational design, you should be able
+to subclass one of the built-in Django ``SchemaEditor`` classes and tweak the
+syntax a little.
+
+Methods
+=======
+
+``execute()``
+-------------
+
+.. method:: BaseDatabaseSchemaEditor.execute(sql, params=())
+
+Executes the SQL statement passed in, with parameters if supplied. This
+is a wrapper around the normal database cursors that allows capture of the SQL
+to a ``.sql`` file if the user wishes.
+
+``create_model()``
+------------------
+
+.. method:: BaseDatabaseSchemaEditor.create_model(model)
+
+Creates a new table in the database for the provided model, along with any
+unique constraints or indexes it requires.
+
+``delete_model()``
+------------------
+
+.. method:: BaseDatabaseSchemaEditor.delete_model(model)
+
+Drops the model's table in the database along with any unique constraints
+or indexes it has.
+
+``add_index()``
+---------------
+
+.. method:: BaseDatabaseSchemaEditor.add_index(model, index)
+
+Adds ``index`` to ``model``’s table.
+
+``remove_index()``
+------------------
+
+.. method:: BaseDatabaseSchemaEditor.remove_index(model, index)
+
+Removes ``index`` from ``model``’s table.
+
+``rename_index()``
+------------------
+
+.. method:: BaseDatabaseSchemaEditor.rename_index(model, old_index, new_index)
+
+Renames ``old_index`` from ``model``’s table to ``new_index``.
+
+``add_constraint()``
+--------------------
+
+.. method:: BaseDatabaseSchemaEditor.add_constraint(model, constraint)
+
+Adds ``constraint`` to ``model``'s table.
+
+``remove_constraint()``
+-----------------------
+
+.. method:: BaseDatabaseSchemaEditor.remove_constraint(model, constraint)
+
+Removes ``constraint`` from ``model``'s table.
+
+``alter_unique_together()``
+---------------------------
+
+.. method:: BaseDatabaseSchemaEditor.alter_unique_together(model, old_unique_together, new_unique_together)
+
+Changes a model's :attr:`~django.db.models.Options.unique_together` value; this
+will add or remove unique constraints from the model's table until they match
+the new value.
+
+``alter_index_together()``
+--------------------------
+
+.. method:: BaseDatabaseSchemaEditor.alter_index_together(model, old_index_together, new_index_together)
+
+Changes a model's :attr:`~django.db.models.Options.index_together` value; this
+will add or remove indexes from the model's table until they match the new
+value.
+
+``alter_db_table()``
+--------------------
+
+.. method:: BaseDatabaseSchemaEditor.alter_db_table(model, old_db_table, new_db_table)
+
+Renames the model's table from ``old_db_table`` to ``new_db_table``.
+
+``alter_db_table_comment()``
+----------------------------
+
+.. versionadded:: 4.2
+
+.. method:: BaseDatabaseSchemaEditor.alter_db_table_comment(model, old_db_table_comment, new_db_table_comment)
+
+Change the ``model``’s table comment to ``new_db_table_comment``.
+
+``alter_db_tablespace()``
+-------------------------
+
+.. method:: BaseDatabaseSchemaEditor.alter_db_tablespace(model, old_db_tablespace, new_db_tablespace)
+
+Moves the model's table from one tablespace to another.
+
+``add_field()``
+---------------
+
+.. method:: BaseDatabaseSchemaEditor.add_field(model, field)
+
+Adds a column (or sometimes multiple) to the model's table to represent the
+field. This will also add indexes or a unique constraint
+if the field has ``db_index=True`` or ``unique=True``.
+
+If the field is a ``ManyToManyField`` without a value for ``through``, instead
+of creating a column, it will make a table to represent the relationship. If
+``through`` is provided, it is a no-op.
+
+If the field is a ``ForeignKey``, this will also add the foreign key
+constraint to the column.
+
+``remove_field()``
+------------------
+
+.. method:: BaseDatabaseSchemaEditor.remove_field(model, field)
+
+Removes the column(s) representing the field from the model's table, along
+with any unique constraints, foreign key constraints, or indexes caused by
+that field.
+
+If the field is a ManyToManyField without a value for ``through``, it will
+remove the table created to track the relationship. If
+``through`` is provided, it is a no-op.
+
+``alter_field()``
+-----------------
+
+.. method:: BaseDatabaseSchemaEditor.alter_field(model, old_field, new_field, strict=False)
+
+This transforms the field on the model from the old field to the new one. This
+includes changing the name of the column (the
+:attr:`~django.db.models.Field.db_column` attribute), changing the type of the
+field (if the field class changes), changing the ``NULL`` status of the field,
+adding or removing field-only unique constraints and indexes, changing primary
+key, and changing the destination of ``ForeignKey`` constraints.
+
+The most common transformation this cannot do is transforming a
+``ManyToManyField`` into a normal Field or vice-versa; Django cannot do this
+without losing data, and so it will refuse to do it. Instead,
+:meth:`.remove_field` and :meth:`.add_field` should be called separately.
+
+If the database has the ``supports_combined_alters``, Django will try and
+do as many of these in a single database call as possible; otherwise, it will
+issue a separate ALTER statement for each change, but will not issue ALTERs
+where no change is required.
+
+Attributes
+==========
+
+All attributes should be considered read-only unless stated otherwise.
+
+``connection``
+--------------
+
+.. attribute:: SchemaEditor.connection
+
+A connection object to the database. A useful attribute of the connection is
+``alias`` which can be used to determine the name of the database being
+accessed.
+
+This is useful when doing data migrations for :ref:`migrations with multiple
+databases <data-migrations-and-multiple-databases>`.

testbed/django__django/docs/ref/signals.txt

@@ -0,0 +1,705 @@
+=======
+Signals
+=======
+
+A list of all the signals that Django sends. All built-in signals are sent
+using the :meth:`~django.dispatch.Signal.send` method.
+
+.. seealso::
+
+    See the documentation on the :doc:`signal dispatcher </topics/signals>` for
+    information regarding how to register for and receive signals.
+
+    The :doc:`authentication framework </topics/auth/index>` sends :ref:`signals when
+    a user is logged in / out <topics-auth-signals>`.
+
+Model signals
+=============
+
+.. module:: django.db.models.signals
+   :synopsis: Signals sent by the model system.
+
+The :mod:`django.db.models.signals` module defines a set of signals sent by the
+model system.
+
+.. warning::
+
+    Signals can make your code harder to maintain. Consider implementing a
+    helper method on a :ref:`custom manager <custom-managers>`, to
+    both update your models and perform additional logic, or else
+    :ref:`overriding model methods <overriding-model-methods>` before using
+    model signals.
+
+.. warning::
+
+    Many of these signals are sent by various model methods like
+    ``__init__()`` or :meth:`~django.db.models.Model.save` that you can
+    override in your own code.
+
+    If you override these methods on your model, you must call the parent class'
+    methods for these signals to be sent.
+
+    Note also that Django stores signal handlers as weak references by default,
+    so if your handler is a local function, it may be garbage collected.  To
+    prevent this, pass ``weak=False`` when you call the signal's :meth:`~django.dispatch.Signal.connect`.
+
+.. note::
+
+    Model signals ``sender`` model can be lazily referenced when connecting a
+    receiver by specifying its full application label. For example, an
+    ``Question`` model defined in the ``polls`` application could be referenced
+    as ``'polls.Question'``. This sort of reference can be quite handy when
+    dealing with circular import dependencies and swappable models.
+
+``pre_init``
+------------
+
+.. attribute:: django.db.models.signals.pre_init
+   :module:
+
+.. ^^^^^^^ this :module: hack keeps Sphinx from prepending the module.
+
+Whenever you instantiate a Django model, this signal is sent at the beginning
+of the model's ``__init__()`` method.
+
+Arguments sent with this signal:
+
+``sender``
+    The model class that just had an instance created.
+
+``args``
+    A list of positional arguments passed to ``__init__()``.
+
+``kwargs``
+    A dictionary of keyword arguments passed to ``__init__()``.
+
+For example, the :doc:`tutorial </intro/tutorial02>` has this line::
+
+    q = Question(question_text="What's new?", pub_date=timezone.now())
+
+The arguments sent to a :data:`pre_init` handler would be:
+
+==========  ===============================================================
+Argument    Value
+==========  ===============================================================
+``sender``  ``Question`` (the class itself)
+
+``args``    ``[]`` (an empty list because there were no positional
+            arguments passed to ``__init__()``)
+
+``kwargs``  ``{'question_text': "What's new?",``
+            ``'pub_date': datetime.datetime(2012, 2, 26, 13, 0, 0, 775217, tzinfo=datetime.timezone.utc)}``
+==========  ===============================================================
+
+``post_init``
+-------------
+
+.. data:: django.db.models.signals.post_init
+   :module:
+
+Like pre_init, but this one is sent when the ``__init__()`` method finishes.
+
+Arguments sent with this signal:
+
+``sender``
+    As above: the model class that just had an instance created.
+
+``instance``
+    The actual instance of the model that's just been created.
+
+    .. note::
+
+        :attr:`instance._state <django.db.models.Model._state>` isn't set
+        before sending the ``post_init`` signal, so ``_state`` attributes
+        always have their default values. For example, ``_state.db`` is
+        ``None``.
+
+.. warning::
+
+    For performance reasons, you shouldn't perform queries in receivers of
+    ``pre_init`` or ``post_init`` signals because they would be executed for
+    each instance returned during queryset iteration.
+
+``pre_save``
+------------
+
+.. data:: django.db.models.signals.pre_save
+   :module:
+
+This is sent at the beginning of a model's :meth:`~django.db.models.Model.save`
+method.
+
+Arguments sent with this signal:
+
+``sender``
+    The model class.
+
+``instance``
+    The actual instance being saved.
+
+``raw``
+    A boolean; ``True`` if the model is saved exactly as presented
+    (i.e. when loading a :ref:`fixture <fixtures-explanation>`). One should not
+    query/modify other records in the database as the database might not be in
+    a consistent state yet.
+
+``using``
+    The database alias being used.
+
+``update_fields``
+    The set of fields to update as passed to :meth:`.Model.save`, or ``None``
+    if ``update_fields`` wasn't passed to ``save()``.
+
+``post_save``
+-------------
+
+.. data:: django.db.models.signals.post_save
+   :module:
+
+Like :data:`pre_save`, but sent at the end of the
+:meth:`~django.db.models.Model.save` method.
+
+Arguments sent with this signal:
+
+``sender``
+    The model class.
+
+``instance``
+    The actual instance being saved.
+
+``created``
+    A boolean; ``True`` if a new record was created.
+
+``raw``
+    A boolean; ``True`` if the model is saved exactly as presented
+    (i.e. when loading a :ref:`fixture <fixtures-explanation>`). One should not
+    query/modify other records in the database as the database might not be in
+    a consistent state yet.
+
+``using``
+    The database alias being used.
+
+``update_fields``
+    The set of fields to update as passed to :meth:`.Model.save`, or ``None``
+    if ``update_fields`` wasn't passed to ``save()``.
+
+``pre_delete``
+--------------
+
+.. data:: django.db.models.signals.pre_delete
+   :module:
+
+Sent at the beginning of a model's :meth:`~django.db.models.Model.delete`
+method and a queryset's :meth:`~django.db.models.query.QuerySet.delete` method.
+
+Arguments sent with this signal:
+
+``sender``
+    The model class.
+
+``instance``
+    The actual instance being deleted.
+
+``using``
+    The database alias being used.
+
+``origin``
+
+    The origin of the deletion being the instance of a ``Model`` or
+    ``QuerySet`` class.
+
+``post_delete``
+---------------
+
+.. data:: django.db.models.signals.post_delete
+   :module:
+
+Like :data:`pre_delete`, but sent at the end of a model's
+:meth:`~django.db.models.Model.delete` method and a queryset's
+:meth:`~django.db.models.query.QuerySet.delete` method.
+
+Arguments sent with this signal:
+
+``sender``
+    The model class.
+
+``instance``
+    The actual instance being deleted.
+
+    Note that the object will no longer be in the database, so be very
+    careful what you do with this instance.
+
+``using``
+    The database alias being used.
+
+``origin``
+
+    The origin of the deletion being the instance of a ``Model`` or
+    ``QuerySet`` class.
+
+``m2m_changed``
+---------------
+
+.. data:: django.db.models.signals.m2m_changed
+   :module:
+
+Sent when a :class:`~django.db.models.ManyToManyField` is changed on a model
+instance. Strictly speaking, this is not a model signal since it is sent by the
+:class:`~django.db.models.ManyToManyField`, but since it complements the
+:data:`pre_save`/:data:`post_save` and :data:`pre_delete`/:data:`post_delete`
+when it comes to tracking changes to models, it is included here.
+
+Arguments sent with this signal:
+
+``sender``
+    The intermediate model class describing the
+    :class:`~django.db.models.ManyToManyField`. This class is automatically
+    created when a many-to-many field is defined; you can access it using the
+    ``through`` attribute on the many-to-many field.
+
+``instance``
+    The instance whose many-to-many relation is updated. This can be an
+    instance of the ``sender``, or of the class the
+    :class:`~django.db.models.ManyToManyField` is related to.
+
+``action``
+    A string indicating the type of update that is done on the relation.
+    This can be one of the following:
+
+    ``"pre_add"``
+        Sent *before* one or more objects are added to the relation.
+    ``"post_add"``
+        Sent *after* one or more objects are added to the relation.
+    ``"pre_remove"``
+        Sent *before* one or more objects are removed from the relation.
+    ``"post_remove"``
+        Sent *after* one or more objects are removed from the relation.
+    ``"pre_clear"``
+        Sent *before* the relation is cleared.
+    ``"post_clear"``
+        Sent *after* the relation is cleared.
+
+``reverse``
+    Indicates which side of the relation is updated (i.e., if it is the
+    forward or reverse relation that is being modified).
+
+``model``
+    The class of the objects that are added to, removed from or cleared
+    from the relation.
+
+``pk_set``
+    For the ``pre_add`` and ``post_add`` actions, this is a set of primary key
+    values that will be, or have been, added to the relation. This may be a
+    subset of the values submitted to be added, since inserts must filter
+    existing values in order to avoid a database ``IntegrityError``.
+
+    For the ``pre_remove`` and ``post_remove`` actions, this is a set of
+    primary key values that was submitted to be removed from the relation. This
+    is not dependent on whether the values actually will be, or have been,
+    removed. In particular, non-existent values may be submitted, and will
+    appear in ``pk_set``, even though they have no effect on the database.
+
+    For the ``pre_clear`` and ``post_clear`` actions, this is ``None``.
+
+``using``
+    The database alias being used.
+
+For example, if a ``Pizza`` can have multiple ``Topping`` objects, modeled
+like this::
+
+    class Topping(models.Model):
+        # ...
+        pass
+
+
+    class Pizza(models.Model):
+        # ...
+        toppings = models.ManyToManyField(Topping)
+
+If we connected a handler like this::
+
+    from django.db.models.signals import m2m_changed
+
+
+    def toppings_changed(sender, **kwargs):
+        # Do something
+        pass
+
+
+    m2m_changed.connect(toppings_changed, sender=Pizza.toppings.through)
+
+and then did something like this:
+
+.. code-block:: pycon
+
+    >>> p = Pizza.objects.create(...)
+    >>> t = Topping.objects.create(...)
+    >>> p.toppings.add(t)
+
+the arguments sent to a :data:`m2m_changed` handler (``toppings_changed`` in
+the example above) would be:
+
+==============  ============================================================
+Argument        Value
+==============  ============================================================
+``sender``      ``Pizza.toppings.through`` (the intermediate m2m class)
+
+``instance``    ``p`` (the ``Pizza`` instance being modified)
+
+``action``      ``"pre_add"`` (followed by a separate signal with ``"post_add"``)
+
+``reverse``     ``False`` (``Pizza`` contains the
+                :class:`~django.db.models.ManyToManyField`, so this call
+                modifies the forward relation)
+
+``model``       ``Topping`` (the class of the objects added to the
+                ``Pizza``)
+
+``pk_set``      ``{t.id}`` (since only ``Topping t`` was added to the relation)
+
+``using``       ``"default"`` (since the default router sends writes here)
+==============  ============================================================
+
+And if we would then do something like this:
+
+.. code-block:: pycon
+
+    >>> t.pizza_set.remove(p)
+
+the arguments sent to a :data:`m2m_changed` handler would be:
+
+==============  ============================================================
+Argument        Value
+==============  ============================================================
+``sender``      ``Pizza.toppings.through`` (the intermediate m2m class)
+
+``instance``    ``t`` (the ``Topping`` instance being modified)
+
+``action``      ``"pre_remove"`` (followed by a separate signal with ``"post_remove"``)
+
+``reverse``     ``True`` (``Pizza`` contains the
+                :class:`~django.db.models.ManyToManyField`, so this call
+                modifies the reverse relation)
+
+``model``       ``Pizza`` (the class of the objects removed from the
+                ``Topping``)
+
+``pk_set``      ``{p.id}`` (since only ``Pizza p`` was removed from the
+                relation)
+
+``using``       ``"default"`` (since the default router sends writes here)
+==============  ============================================================
+
+``class_prepared``
+------------------
+
+.. data:: django.db.models.signals.class_prepared
+   :module:
+
+Sent whenever a model class has been "prepared" -- that is, once a model has
+been defined and registered with Django's model system. Django uses this
+signal internally; it's not generally used in third-party applications.
+
+Since this signal is sent during the app registry population process, and
+:meth:`AppConfig.ready() <django.apps.AppConfig.ready>` runs after the app
+registry is fully populated, receivers cannot be connected in that method.
+One possibility is to connect them ``AppConfig.__init__()`` instead, taking
+care not to import models or trigger calls to the app registry.
+
+Arguments that are sent with this signal:
+
+``sender``
+    The model class which was just prepared.
+
+Management signals
+==================
+
+Signals sent by :doc:`django-admin </ref/django-admin>`.
+
+``pre_migrate``
+---------------
+
+.. data:: django.db.models.signals.pre_migrate
+   :module:
+
+Sent by the :djadmin:`migrate` command before it starts to install an
+application. It's not emitted for applications that lack a ``models`` module.
+
+Arguments sent with this signal:
+
+``sender``
+    An :class:`~django.apps.AppConfig` instance for the application about to
+    be migrated/synced.
+
+``app_config``
+    Same as ``sender``.
+
+``verbosity``
+    Indicates how much information ``manage.py`` is printing on screen. See
+    the :option:`--verbosity` flag for details.
+
+    Functions which listen for :data:`pre_migrate` should adjust what they
+    output to the screen based on the value of this argument.
+
+``interactive``
+    If ``interactive`` is ``True``, it's safe to prompt the user to input
+    things on the command line. If ``interactive`` is ``False``, functions
+    which listen for this signal should not try to prompt for anything.
+
+    For example, the :mod:`django.contrib.auth` app only prompts to create a
+    superuser when ``interactive`` is ``True``.
+
+``stdout``
+    A stream-like object where verbose output should be redirected.
+
+``using``
+    The alias of database on which a command will operate.
+
+``plan``
+    The migration plan that is going to be used for the migration run. While
+    the plan is not public API, this allows for the rare cases when it is
+    necessary to know the plan. A plan is a list of 2-tuples with the first
+    item being the instance of a migration class and the second item showing
+    if the migration was rolled back (``True``) or applied (``False``).
+
+``apps``
+    An instance of :data:`Apps <django.apps>` containing the state of the
+    project before the migration run. It should be used instead of the global
+    :attr:`apps <django.apps.apps>` registry to retrieve the models you
+    want to perform operations on.
+
+``post_migrate``
+----------------
+
+.. data:: django.db.models.signals.post_migrate
+   :module:
+
+Sent at the end of the :djadmin:`migrate` (even if no migrations are run) and
+:djadmin:`flush` commands. It's not emitted for applications that lack a
+``models`` module.
+
+Handlers of this signal must not perform database schema alterations as doing
+so may cause the :djadmin:`flush` command to fail if it runs during the
+:djadmin:`migrate` command.
+
+Arguments sent with this signal:
+
+``sender``
+    An :class:`~django.apps.AppConfig` instance for the application that was
+    just installed.
+
+``app_config``
+    Same as ``sender``.
+
+``verbosity``
+    Indicates how much information ``manage.py`` is printing on screen. See
+    the :option:`--verbosity` flag for details.
+
+    Functions which listen for :data:`post_migrate` should adjust what they
+    output to the screen based on the value of this argument.
+
+``interactive``
+    If ``interactive`` is ``True``, it's safe to prompt the user to input
+    things on the command line. If ``interactive`` is ``False``, functions
+    which listen for this signal should not try to prompt for anything.
+
+    For example, the :mod:`django.contrib.auth` app only prompts to create a
+    superuser when ``interactive`` is ``True``.
+
+``stdout``
+    A stream-like object where verbose output should be redirected.
+
+``using``
+    The database alias used for synchronization. Defaults to the ``default``
+    database.
+
+``plan``
+    The migration plan that was used for the migration run. While the plan is
+    not public API, this allows for the rare cases when it is necessary to
+    know the plan. A plan is a list of 2-tuples with the first item being
+    the instance of a migration class and the second item showing if the
+    migration was rolled back (``True``) or applied (``False``).
+
+``apps``
+    An instance of :data:`Apps <django.apps.apps>` containing the state of the
+    project after the migration run. It should be used instead of the global
+    :attr:`apps <django.apps.apps>` registry to retrieve the models you
+    want to perform operations on.
+
+For example, you could register a callback in an
+:class:`~django.apps.AppConfig` like this::
+
+    from django.apps import AppConfig
+    from django.db.models.signals import post_migrate
+
+
+    def my_callback(sender, **kwargs):
+        # Your specific logic here
+        pass
+
+
+    class MyAppConfig(AppConfig):
+        ...
+
+        def ready(self):
+            post_migrate.connect(my_callback, sender=self)
+
+.. note::
+
+    If you provide an :class:`~django.apps.AppConfig` instance as the sender
+    argument, please ensure that the signal is registered in
+    :meth:`~django.apps.AppConfig.ready`. ``AppConfig``\s are recreated for
+    tests that run with a modified set of :setting:`INSTALLED_APPS` (such as
+    when settings are overridden) and such signals should be connected for each
+    new ``AppConfig`` instance.
+
+Request/response signals
+========================
+
+.. module:: django.core.signals
+   :synopsis: Core signals sent by the request/response system.
+
+Signals sent by the core framework when processing a request.
+
+.. warning::
+
+    Signals can make your code harder to maintain. Consider :doc:`using a
+    middleware </topics/http/middleware>` before using request/response
+    signals.
+
+``request_started``
+-------------------
+
+.. data:: django.core.signals.request_started
+   :module:
+
+Sent when Django begins processing an HTTP request.
+
+Arguments sent with this signal:
+
+``sender``
+    The handler class -- e.g. ``django.core.handlers.wsgi.WsgiHandler`` -- that
+    handled the request.
+``environ``
+    The ``environ`` dictionary provided to the request.
+
+``request_finished``
+--------------------
+
+.. data:: django.core.signals.request_finished
+   :module:
+
+Sent when Django finishes delivering an HTTP response to the client.
+
+Arguments sent with this signal:
+
+``sender``
+    The handler class, as above.
+
+``got_request_exception``
+-------------------------
+
+.. data:: django.core.signals.got_request_exception
+   :module:
+
+This signal is sent whenever Django encounters an exception while processing an incoming HTTP request.
+
+Arguments sent with this signal:
+
+``sender``
+    Unused (always ``None``).
+
+``request``
+    The :class:`~django.http.HttpRequest` object.
+
+Test signals
+============
+
+.. module:: django.test.signals
+   :synopsis: Signals sent during testing.
+
+Signals only sent when :ref:`running tests <running-tests>`.
+
+``setting_changed``
+-------------------
+
+.. data:: django.test.signals.setting_changed
+   :module:
+
+This signal is sent when the value of a setting is changed through the
+``django.test.TestCase.settings()`` context manager or the
+:func:`django.test.override_settings` decorator/context manager.
+
+It's actually sent twice: when the new value is applied ("setup") and when the
+original value is restored ("teardown"). Use the ``enter`` argument to
+distinguish between the two.
+
+You can also import this signal from ``django.core.signals`` to avoid importing
+from ``django.test`` in non-test situations.
+
+Arguments sent with this signal:
+
+``sender``
+    The settings handler.
+
+``setting``
+    The name of the setting.
+
+``value``
+    The value of the setting after the change. For settings that initially
+    don't exist, in the "teardown" phase, ``value`` is ``None``.
+
+``enter``
+    A boolean; ``True`` if the setting is applied, ``False`` if restored.
+
+``template_rendered``
+---------------------
+
+.. data:: django.test.signals.template_rendered
+   :module:
+
+Sent when the test system renders a template. This signal is not emitted during
+normal operation of a Django server -- it is only available during testing.
+
+Arguments sent with this signal:
+
+``sender``
+    The :class:`~django.template.Template` object which was rendered.
+
+``template``
+    Same as sender
+
+``context``
+    The :class:`~django.template.Context` with which the template was
+    rendered.
+
+Database Wrappers
+=================
+
+.. module:: django.db.backends
+   :synopsis: Core signals sent by the database wrapper.
+
+Signals sent by the database wrapper when a database connection is
+initiated.
+
+``connection_created``
+----------------------
+
+.. data:: django.db.backends.signals.connection_created
+   :module:
+
+Sent when the database wrapper makes the initial connection to the
+database.  This is particularly useful if you'd like to send any post
+connection commands to the SQL backend.
+
+Arguments sent with this signal:
+
+``sender``
+    The database wrapper class -- i.e.
+    ``django.db.backends.postgresql.DatabaseWrapper`` or
+    ``django.db.backends.mysql.DatabaseWrapper``, etc.
+
+``connection``
+    The database connection that was opened. This can be used in a
+    multiple-database configuration to differentiate connection signals
+    from different databases.

testbed/django__django/docs/ref/template-response.txt

@@ -0,0 +1,307 @@
+===================================================
+``TemplateResponse`` and ``SimpleTemplateResponse``
+===================================================
+
+.. module:: django.template.response
+   :synopsis: Classes dealing with lazy-rendered HTTP responses.
+
+Standard :class:`~django.http.HttpResponse` objects are static structures.
+They are provided with a block of pre-rendered content at time of
+construction, and while that content can be modified, it isn't in a form that
+makes it easy to perform modifications.
+
+However, it can sometimes be beneficial to allow decorators or
+middleware to modify a response *after* it has been constructed by the
+view. For example, you may want to change the template that is used,
+or put additional data into the context.
+
+TemplateResponse provides a way to do just that. Unlike basic
+:class:`~django.http.HttpResponse` objects, TemplateResponse objects retain
+the details of the template and context that was provided by the view to
+compute the response. The final output of the response is not computed until
+it is needed, later in the response process.
+
+``SimpleTemplateResponse`` objects
+==================================
+
+.. class:: SimpleTemplateResponse()
+
+Attributes
+----------
+
+.. attribute:: SimpleTemplateResponse.template_name
+
+    The name of the template to be rendered. Accepts a backend-dependent
+    template object (such as those returned by
+    :func:`~django.template.loader.get_template()`), the name of a template,
+    or a list of template names.
+
+    Example: ``['foo.html', 'path/to/bar.html']``
+
+.. attribute:: SimpleTemplateResponse.context_data
+
+    The context data to be used when rendering the template. It must be a
+    :class:`dict`.
+
+    Example: ``{'foo': 123}``
+
+.. attribute:: SimpleTemplateResponse.rendered_content
+
+    The current rendered value of the response content, using the current
+    template and context data.
+
+.. attribute:: SimpleTemplateResponse.is_rendered
+
+    A boolean indicating whether the response content has been rendered.
+
+Methods
+-------
+
+.. method:: SimpleTemplateResponse.__init__(template, context=None, content_type=None, status=None, charset=None, using=None, headers=None)
+
+    Instantiates a :class:`~django.template.response.SimpleTemplateResponse`
+    object with the given template, context, content type, HTTP status, and
+    charset.
+
+    ``template``
+        A backend-dependent template object (such as those returned by
+        :func:`~django.template.loader.get_template()`), the name of a template,
+        or a list of template names.
+
+    ``context``
+        A :class:`dict` of values to add to the template context. By default,
+        this is an empty dictionary.
+
+    ``content_type``
+        The value included in the HTTP ``Content-Type`` header, including the
+        MIME type specification and the character set encoding. If
+        ``content_type`` is specified, then its value is used. Otherwise,
+        ``'text/html'`` is used.
+
+    ``status``
+        The HTTP status code for the response.
+
+    ``charset``
+        The charset in which the response will be encoded. If not given it will
+        be extracted from ``content_type``, and if that is unsuccessful, the
+        :setting:`DEFAULT_CHARSET` setting will be used.
+
+    ``using``
+        The :setting:`NAME <TEMPLATES-NAME>` of a template engine to use for
+        loading the template.
+
+    ``headers``
+        A :class:`dict` of HTTP headers to add to the response.
+
+.. method:: SimpleTemplateResponse.resolve_context(context)
+
+    Preprocesses context data that will be used for rendering a template.
+    Accepts a :class:`dict` of context data. By default, returns the same
+    :class:`dict`.
+
+    Override this method in order to customize the context.
+
+.. method:: SimpleTemplateResponse.resolve_template(template)
+
+    Resolves the template instance to use for rendering. Accepts a
+    backend-dependent template object (such as those returned by
+    :func:`~django.template.loader.get_template()`), the name of a template,
+    or a list of template names.
+
+    Returns the backend-dependent template object instance to be rendered.
+
+    Override this method in order to customize template loading.
+
+.. method:: SimpleTemplateResponse.add_post_render_callback()
+
+    Add a callback that will be invoked after rendering has taken
+    place. This hook can be used to defer certain processing
+    operations (such as caching) until after rendering has occurred.
+
+    If the :class:`~django.template.response.SimpleTemplateResponse`
+    has already been rendered, the callback will be invoked
+    immediately.
+
+    When called, callbacks will be passed a single argument -- the
+    rendered :class:`~django.template.response.SimpleTemplateResponse`
+    instance.
+
+    If the callback returns a value that is not ``None``, this will be
+    used as the response instead of the original response object (and
+    will be passed to the next post rendering callback etc.)
+
+.. method:: SimpleTemplateResponse.render()
+
+    Sets ``response.content`` to the result obtained by
+    :attr:`SimpleTemplateResponse.rendered_content`, runs all post-rendering
+    callbacks, and returns the resulting response object.
+
+    ``render()`` will only have an effect the first time it is called. On
+    subsequent calls, it will return the result obtained from the first call.
+
+
+``TemplateResponse`` objects
+============================
+
+.. class:: TemplateResponse()
+
+    ``TemplateResponse`` is a subclass of
+    :class:`~django.template.response.SimpleTemplateResponse` that knows about
+    the current :class:`~django.http.HttpRequest`.
+
+Methods
+-------
+
+.. method:: TemplateResponse.__init__(request, template, context=None, content_type=None, status=None, charset=None, using=None, headers=None)
+
+    Instantiates a :class:`~django.template.response.TemplateResponse` object
+    with the given request, template, context, content type, HTTP status, and
+    charset.
+
+    ``request``
+        An :class:`~django.http.HttpRequest` instance.
+
+    ``template``
+        A backend-dependent template object (such as those returned by
+        :func:`~django.template.loader.get_template()`), the name of a template,
+        or a list of template names.
+
+    ``context``
+        A :class:`dict` of values to add to the template context. By default,
+        this is an empty dictionary.
+
+    ``content_type``
+        The value included in the HTTP ``Content-Type`` header, including the
+        MIME type specification and the character set encoding. If
+        ``content_type`` is specified, then its value is used. Otherwise,
+        ``'text/html'`` is used.
+
+    ``status``
+        The HTTP status code for the response.
+
+    ``charset``
+        The charset in which the response will be encoded. If not given it will
+        be extracted from ``content_type``, and if that is unsuccessful, the
+        :setting:`DEFAULT_CHARSET` setting will be used.
+
+    ``using``
+        The :setting:`NAME <TEMPLATES-NAME>` of a template engine to use for
+        loading the template.
+
+    ``headers``
+        A :class:`dict` of HTTP headers to add to the response.
+
+The rendering process
+=====================
+
+Before a :class:`~django.template.response.TemplateResponse` instance can be
+returned to the client, it must be rendered. The rendering process takes the
+intermediate representation of template and context, and turns it into the
+final byte stream that can be served to the client.
+
+There are three circumstances under which a ``TemplateResponse`` will be
+rendered:
+
+* When the ``TemplateResponse`` instance is explicitly rendered, using
+  the :meth:`SimpleTemplateResponse.render()` method.
+
+* When the content of the response is explicitly set by assigning
+  ``response.content``.
+
+* After passing through template response middleware, but before
+  passing through response middleware.
+
+A ``TemplateResponse`` can only be rendered once. The first call to
+:meth:`SimpleTemplateResponse.render` sets the content of the response;
+subsequent rendering calls do not change the response content.
+
+However, when ``response.content`` is explicitly assigned, the
+change is always applied. If you want to force the content to be
+re-rendered, you can reevaluate the rendered content, and assign
+the content of the response manually:
+
+.. code-block:: pycon
+
+    # Set up a rendered TemplateResponse
+    >>> from django.template.response import TemplateResponse
+    >>> t = TemplateResponse(request, "original.html", {})
+    >>> t.render()
+    >>> print(t.content)
+    Original content
+
+    # Re-rendering doesn't change content
+    >>> t.template_name = "new.html"
+    >>> t.render()
+    >>> print(t.content)
+    Original content
+
+    # Assigning content does change, no render() call required
+    >>> t.content = t.rendered_content
+    >>> print(t.content)
+    New content
+
+Post-render callbacks
+---------------------
+
+Some operations -- such as caching -- cannot be performed on an
+unrendered template. They must be performed on a fully complete and
+rendered response.
+
+If you're using middleware, you can do that. Middleware provides
+multiple opportunities to process a response on exit from a view. If
+you put behavior in the response middleware, it's guaranteed to execute
+after template rendering has taken place.
+
+However, if you're using a decorator, the same opportunities do not
+exist. Any behavior defined in a decorator is handled immediately.
+
+To compensate for this (and any other analogous use cases),
+:class:`TemplateResponse` allows you to register callbacks that will
+be invoked when rendering has completed. Using this callback, you can
+defer critical processing until a point where you can guarantee that
+rendered content will be available.
+
+To define a post-render callback, define a function that takes
+a single argument -- response -- and register that function with
+the template response::
+
+    from django.template.response import TemplateResponse
+
+
+    def my_render_callback(response):
+        # Do content-sensitive processing
+        do_post_processing()
+
+
+    def my_view(request):
+        # Create a response
+        response = TemplateResponse(request, "mytemplate.html", {})
+        # Register the callback
+        response.add_post_render_callback(my_render_callback)
+        # Return the response
+        return response
+
+``my_render_callback()`` will be invoked after the ``mytemplate.html``
+has been rendered, and will be provided the fully rendered
+:class:`TemplateResponse` instance as an argument.
+
+If the template has already been rendered, the callback will be
+invoked immediately.
+
+Using ``TemplateResponse`` and ``SimpleTemplateResponse``
+=========================================================
+
+A :class:`TemplateResponse` object can be used anywhere that a normal
+:class:`django.http.HttpResponse` can be used. It can also be used as an
+alternative to calling :func:`~django.shortcuts.render()`.
+
+For example, the following view returns a :class:`TemplateResponse` with a
+template and a context containing a queryset::
+
+    from django.template.response import TemplateResponse
+
+
+    def blog_index(request):
+        return TemplateResponse(
+            request, "entry_list.html", {"entries": Entry.objects.all()}
+        )

testbed/django__django/docs/ref/unicode.txt

@@ -0,0 +1,358 @@
+============
+Unicode data
+============
+
+Django supports Unicode data everywhere.
+
+This document tells you what you need to know if you're writing applications
+that use data or templates that are encoded in something other than ASCII.
+
+Creating the database
+=====================
+
+Make sure your database is configured to be able to store arbitrary string
+data. Normally, this means giving it an encoding of UTF-8 or UTF-16. If you use
+a more restrictive encoding -- for example, latin1 (iso8859-1) -- you won't be
+able to store certain characters in the database, and information will be lost.
+
+* MySQL users, refer to the `MySQL manual`_ for details on how to set or alter
+  the database character set encoding.
+
+* PostgreSQL users, refer to the `PostgreSQL manual`_ for details on creating
+  databases with the correct encoding.
+
+* Oracle users, refer to the `Oracle manual`_ for details on how to set
+  (`section 2`_) or alter (`section 11`_) the database character set encoding.
+
+* SQLite users, there is nothing you need to do. SQLite always uses UTF-8
+  for internal encoding.
+
+.. _MySQL manual: https://dev.mysql.com/doc/refman/en/charset-database.html
+.. _PostgreSQL manual: https://www.postgresql.org/docs/current/multibyte.html#id-1.6.11.5.6
+.. _Oracle manual: https://docs.oracle.com/en/database/oracle/oracle-database/21/nlspg/index.html
+.. _section 2: https://docs.oracle.com/en/database/oracle/oracle-database/21/nlspg/choosing-character-set.html
+.. _section 11: https://docs.oracle.com/en/database/oracle/oracle-database/21/nlspg/character-set-migration.html
+
+All of Django's database backends automatically convert strings into
+the appropriate encoding for talking to the database. They also automatically
+convert strings retrieved from the database into strings. You don't even need
+to tell Django what encoding your database uses: that is handled transparently.
+
+For more, see the section "The database API" below.
+
+General string handling
+=======================
+
+Whenever you use strings with Django -- e.g., in database lookups, template
+rendering or anywhere else -- you have two choices for encoding those strings.
+You can use normal strings or bytestrings (starting with a 'b').
+
+.. warning::
+
+    A bytestring does not carry any information with it about its encoding.
+    For that reason, we have to make an assumption, and Django assumes that all
+    bytestrings are in UTF-8.
+
+    If you pass a string to Django that has been encoded in some other format,
+    things will go wrong in interesting ways. Usually, Django will raise a
+    ``UnicodeDecodeError`` at some point.
+
+If your code only uses ASCII data, it's safe to use your normal strings,
+passing them around at will, because ASCII is a subset of UTF-8.
+
+Don't be fooled into thinking that if your :setting:`DEFAULT_CHARSET` setting is set
+to something other than ``'utf-8'`` you can use that other encoding in your
+bytestrings! :setting:`DEFAULT_CHARSET` only applies to the strings generated as
+the result of template rendering (and email). Django will always assume UTF-8
+encoding for internal bytestrings. The reason for this is that the
+:setting:`DEFAULT_CHARSET` setting is not actually under your control (if you are the
+application developer). It's under the control of the person installing and
+using your application -- and if that person chooses a different setting, your
+code must still continue to work. Ergo, it cannot rely on that setting.
+
+In most cases when Django is dealing with strings, it will convert them to
+strings before doing anything else. So, as a general rule, if you pass
+in a bytestring, be prepared to receive a string back in the result.
+
+Translated strings
+------------------
+
+Aside from strings and bytestrings, there's a third type of string-like
+object you may encounter when using Django. The framework's
+internationalization features introduce the concept of a "lazy translation" --
+a string that has been marked as translated but whose actual translation result
+isn't determined until the object is used in a string. This feature is useful
+in cases where the translation locale is unknown until the string is used, even
+though the string might have originally been created when the code was first
+imported.
+
+Normally, you won't have to worry about lazy translations. Just be aware that
+if you examine an object and it claims to be a
+``django.utils.functional.__proxy__`` object, it is a lazy translation.
+Calling ``str()`` with the lazy translation as the argument will generate a
+string in the current locale.
+
+For more details about lazy translation objects, refer to the
+:doc:`internationalization </topics/i18n/index>` documentation.
+
+Useful utility functions
+------------------------
+
+Because some string operations come up again and again, Django ships with a few
+useful functions that should make working with string and bytestring objects
+a bit easier.
+
+Conversion functions
+~~~~~~~~~~~~~~~~~~~~
+
+The ``django.utils.encoding`` module contains a few functions that are handy
+for converting back and forth between strings and bytestrings.
+
+* ``smart_str(s, encoding='utf-8', strings_only=False, errors='strict')``
+  converts its input to a string. The ``encoding`` parameter
+  specifies the input encoding. (For example, Django uses this internally
+  when processing form input data, which might not be UTF-8 encoded.) The
+  ``strings_only`` parameter, if set to True, will result in Python
+  numbers, booleans and ``None`` not being converted to a string (they keep
+  their original types). The ``errors`` parameter takes any of the values
+  that are accepted by Python's ``str()`` function for its error
+  handling.
+
+* ``force_str(s, encoding='utf-8', strings_only=False, errors='strict')`` is
+  identical to ``smart_str()`` in almost all cases. The difference is when the
+  first argument is a :ref:`lazy translation <lazy-translations>` instance.
+  While ``smart_str()`` preserves lazy translations, ``force_str()`` forces
+  those objects to a string (causing the translation to occur). Normally,
+  you'll want to use ``smart_str()``. However, ``force_str()`` is useful in
+  template tags and filters that absolutely *must* have a string to work with,
+  not just something that can be converted to a string.
+
+* ``smart_bytes(s, encoding='utf-8', strings_only=False, errors='strict')``
+  is essentially the opposite of ``smart_str()``. It forces the first
+  argument to a bytestring. The ``strings_only`` parameter has the same
+  behavior as for ``smart_str()`` and ``force_str()``. This is
+  slightly different semantics from Python's builtin ``str()`` function,
+  but the difference is needed in a few places within Django's internals.
+
+Normally, you'll only need to use ``force_str()``. Call it as early as
+possible on any input data that might be either a string or a bytestring, and
+from then on, you can treat the result as always being a string.
+
+.. _uri-and-iri-handling:
+
+URI and IRI handling
+~~~~~~~~~~~~~~~~~~~~
+
+Web frameworks have to deal with URLs (which are a type of IRI). One
+requirement of URLs is that they are encoded using only ASCII characters.
+However, in an international environment, you might need to construct a
+URL from an :rfc:`IRI <3987>` -- very loosely speaking, a :rfc:`URI <3986>`
+that can contain Unicode characters. Use these functions for quoting and
+converting an IRI to a URI:
+
+* The :func:`django.utils.encoding.iri_to_uri()` function, which implements the
+  conversion from IRI to URI as required by :rfc:`3987#section-3.1`.
+
+* The :func:`urllib.parse.quote` and :func:`urllib.parse.quote_plus`
+  functions from Python's standard library.
+
+These two groups of functions have slightly different purposes, and it's
+important to keep them straight. Normally, you would use ``quote()`` on the
+individual portions of the IRI or URI path so that any reserved characters
+such as '&' or '%' are correctly encoded. Then, you apply ``iri_to_uri()`` to
+the full IRI and it converts any non-ASCII characters to the correct encoded
+values.
+
+.. note::
+    Technically, it isn't correct to say that ``iri_to_uri()`` implements the
+    full algorithm in the IRI specification. It doesn't (yet) perform the
+    international domain name encoding portion of the algorithm.
+
+The ``iri_to_uri()`` function will not change ASCII characters that are
+otherwise permitted in a URL. So, for example, the character '%' is not
+further encoded when passed to ``iri_to_uri()``. This means you can pass a
+full URL to this function and it will not mess up the query string or anything
+like that.
+
+An example might clarify things here:
+
+.. code-block:: pycon
+
+    >>> from urllib.parse import quote
+    >>> from django.utils.encoding import iri_to_uri
+    >>> quote("Paris & Orléans")
+    'Paris%20%26%20Orl%C3%A9ans'
+    >>> iri_to_uri("/favorites/François/%s" % quote("Paris & Orléans"))
+    '/favorites/Fran%C3%A7ois/Paris%20%26%20Orl%C3%A9ans'
+
+If you look carefully, you can see that the portion that was generated by
+``quote()`` in the second example was not double-quoted when passed to
+``iri_to_uri()``. This is a very important and useful feature. It means that
+you can construct your IRI without worrying about whether it contains
+non-ASCII characters and then, right at the end, call ``iri_to_uri()`` on the
+result.
+
+Similarly, Django provides :func:`django.utils.encoding.uri_to_iri()` which
+implements the conversion from URI to IRI as per :rfc:`3987#section-3.2`.
+
+An example to demonstrate:
+
+.. code-block:: pycon
+
+    >>> from django.utils.encoding import uri_to_iri
+    >>> uri_to_iri("/%E2%99%A5%E2%99%A5/?utf8=%E2%9C%93")
+    '/♥♥/?utf8=✓'
+    >>> uri_to_iri("%A9hello%3Fworld")
+    '%A9hello%3Fworld'
+
+In the first example, the UTF-8 characters are unquoted. In the second, the
+percent-encodings remain unchanged because they lie outside the valid UTF-8
+range or represent a reserved character.
+
+Both ``iri_to_uri()`` and ``uri_to_iri()`` functions are idempotent, which means the
+following is always true::
+
+    iri_to_uri(iri_to_uri(some_string)) == iri_to_uri(some_string)
+    uri_to_iri(uri_to_iri(some_string)) == uri_to_iri(some_string)
+
+So you can safely call it multiple times on the same URI/IRI without risking
+double-quoting problems.
+
+Models
+======
+
+Because all strings are returned from the database as ``str`` objects, model
+fields that are character based (CharField, TextField, URLField, etc.) will
+contain Unicode values when Django retrieves data from the database. This
+is *always* the case, even if the data could fit into an ASCII bytestring.
+
+You can pass in bytestrings when creating a model or populating a field, and
+Django will convert it to strings when it needs to.
+
+Taking care in ``get_absolute_url()``
+-------------------------------------
+
+URLs can only contain ASCII characters. If you're constructing a URL from
+pieces of data that might be non-ASCII, be careful to encode the results in a
+way that is suitable for a URL. The :func:`~django.urls.reverse` function
+handles this for you automatically.
+
+If you're constructing a URL manually (i.e., *not* using the ``reverse()``
+function), you'll need to take care of the encoding yourself. In this case,
+use the ``iri_to_uri()`` and ``quote()`` functions that were documented
+above_. For example::
+
+    from urllib.parse import quote
+    from django.utils.encoding import iri_to_uri
+
+
+    def get_absolute_url(self):
+        url = "/person/%s/?x=0&y=0" % quote(self.location)
+        return iri_to_uri(url)
+
+This function returns a correctly encoded URL even if ``self.location`` is
+something like "Jack visited Paris & Orléans". (In fact, the ``iri_to_uri()``
+call isn't strictly necessary in the above example, because all the
+non-ASCII characters would have been removed in quoting in the first line.)
+
+.. _above: `URI and IRI handling`_
+
+Templates
+=========
+
+Use strings when creating templates manually::
+
+    from django.template import Template
+
+    t2 = Template("This is a string template.")
+
+But the common case is to read templates from the filesystem. If your template
+files are not stored with a UTF-8 encoding, adjust the :setting:`TEMPLATES`
+setting. The built-in :py:mod:`~django.template.backends.django` backend
+provides the ``'file_charset'`` option to change the encoding used to read
+files from disk.
+
+The :setting:`DEFAULT_CHARSET` setting controls the encoding of rendered templates.
+This is set to UTF-8 by default.
+
+Template tags and filters
+-------------------------
+
+A couple of tips to remember when writing your own template tags and filters:
+
+* Always return strings from a template tag's ``render()`` method
+  and from template filters.
+
+* Use ``force_str()`` in preference to ``smart_str()`` in these
+  places. Tag rendering and filter calls occur as the template is being
+  rendered, so there is no advantage to postponing the conversion of lazy
+  translation objects into strings. It's easier to work solely with
+  strings at that point.
+
+.. _unicode-files:
+
+Files
+=====
+
+If you intend to allow users to upload files, you must ensure that the
+environment used to run Django is configured to work with non-ASCII file names.
+If your environment isn't configured correctly, you'll encounter
+``UnicodeEncodeError`` exceptions when saving files with file names or content
+that contains non-ASCII characters.
+
+Filesystem support for UTF-8 file names varies and might depend on the
+environment. Check your current configuration in an interactive Python shell by
+running::
+
+    import sys
+
+    sys.getfilesystemencoding()
+
+This should output "UTF-8".
+
+The ``LANG`` environment variable is responsible for setting the expected
+encoding on Unix platforms. Consult the documentation for your operating system
+and application server for the appropriate syntax and location to set this
+variable. See the :doc:`/howto/deployment/wsgi/modwsgi` for examples.
+
+In your development environment, you might need to add a setting to your
+``~.bashrc`` analogous to:
+
+.. code-block:: shell
+
+    export LANG="en_US.UTF-8"
+
+Form submission
+===============
+
+HTML form submission is a tricky area. There's no guarantee that the
+submission will include encoding information, which means the framework might
+have to guess at the encoding of submitted data.
+
+Django adopts a "lazy" approach to decoding form data. The data in an
+``HttpRequest`` object is only decoded when you access it. In fact, most of
+the data is not decoded at all. Only the ``HttpRequest.GET`` and
+``HttpRequest.POST`` data structures have any decoding applied to them. Those
+two fields will return their members as Unicode data. All other attributes and
+methods of ``HttpRequest`` return data exactly as it was submitted by the
+client.
+
+By default, the :setting:`DEFAULT_CHARSET` setting is used as the assumed encoding
+for form data. If you need to change this for a particular form, you can set
+the ``encoding`` attribute on an ``HttpRequest`` instance. For example::
+
+    def some_view(request):
+        # We know that the data must be encoded as KOI8-R (for some reason).
+        request.encoding = "koi8-r"
+        ...
+
+You can even change the encoding after having accessed ``request.GET`` or
+``request.POST``, and all subsequent accesses will use the new encoding.
+
+Most developers won't need to worry about changing form encoding, but this is
+a useful feature for applications that talk to legacy systems whose encoding
+you cannot control.
+
+Django does not decode the data of file uploads, because that data is normally
+treated as collections of bytes, rather than strings. Any automatic decoding
+there would alter the meaning of the stream of bytes.

testbed/django__django/docs/ref/urlresolvers.txt

@@ -0,0 +1,243 @@
+=================================
+``django.urls`` utility functions
+=================================
+
+.. module:: django.urls
+
+``reverse()``
+=============
+
+If you need to use something similar to the :ttag:`url` template tag in
+your code, Django provides the following function:
+
+.. function:: reverse(viewname, urlconf=None, args=None, kwargs=None, current_app=None)
+
+``viewname`` can be a :ref:`URL pattern name <naming-url-patterns>` or the
+callable view object. For example, given the following ``url``::
+
+    from news import views
+
+    path("archive/", views.archive, name="news-archive")
+
+you can use any of the following to reverse the URL::
+
+    # using the named URL
+    reverse("news-archive")
+
+    # passing a callable object
+    # (This is discouraged because you can't reverse namespaced views this way.)
+    from news import views
+
+    reverse(views.archive)
+
+If the URL accepts arguments, you may pass them in ``args``. For example::
+
+    from django.urls import reverse
+
+
+    def myview(request):
+        return HttpResponseRedirect(reverse("arch-summary", args=[1945]))
+
+You can also pass ``kwargs`` instead of ``args``. For example:
+
+.. code-block:: pycon
+
+    >>> reverse("admin:app_list", kwargs={"app_label": "auth"})
+    '/admin/auth/'
+
+``args`` and ``kwargs`` cannot be passed to ``reverse()`` at the same time.
+
+If no match can be made, ``reverse()`` raises a
+:class:`~django.urls.NoReverseMatch` exception.
+
+The ``reverse()`` function can reverse a large variety of regular expression
+patterns for URLs, but not every possible one. The main restriction at the
+moment is that the pattern cannot contain alternative choices using the
+vertical bar (``"|"``) character. You can quite happily use such patterns for
+matching against incoming URLs and sending them off to views, but you cannot
+reverse such patterns.
+
+The ``current_app`` argument allows you to provide a hint to the resolver
+indicating the application to which the currently executing view belongs.
+This ``current_app`` argument is used as a hint to resolve application
+namespaces into URLs on specific application instances, according to the
+:ref:`namespaced URL resolution strategy <topics-http-reversing-url-namespaces>`.
+
+The ``urlconf`` argument is the URLconf module containing the URL patterns to
+use for reversing. By default, the root URLconf for the current thread is used.
+
+.. note::
+
+    The string returned by ``reverse()`` is already
+    :ref:`urlquoted <uri-and-iri-handling>`. For example:
+
+    .. code-block:: pycon
+
+        >>> reverse("cities", args=["Orléans"])
+        '.../Orl%C3%A9ans/'
+
+    Applying further encoding (such as :func:`urllib.parse.quote`) to the output
+    of ``reverse()`` may produce undesirable results.
+
+``reverse_lazy()``
+==================
+
+A lazily evaluated version of `reverse()`_.
+
+.. function:: reverse_lazy(viewname, urlconf=None, args=None, kwargs=None, current_app=None)
+
+It is useful for when you need to use a URL reversal before your project's
+URLConf is loaded. Some common cases where this function is necessary are:
+
+* providing a reversed URL as the ``url`` attribute of a generic class-based
+  view.
+
+* providing a reversed URL to a decorator (such as the ``login_url`` argument
+  for the :func:`django.contrib.auth.decorators.permission_required`
+  decorator).
+
+* providing a reversed URL as a default value for a parameter in a function's
+  signature.
+
+``resolve()``
+=============
+
+The ``resolve()`` function can be used for resolving URL paths to the
+corresponding view functions. It has the following signature:
+
+.. function:: resolve(path, urlconf=None)
+
+``path`` is the URL path you want to resolve. As with
+:func:`~django.urls.reverse`, you don't need to worry about the ``urlconf``
+parameter. The function returns a :class:`ResolverMatch` object that allows you
+to access various metadata about the resolved URL.
+
+If the URL does not resolve, the function raises a
+:exc:`~django.urls.Resolver404` exception (a subclass of
+:class:`~django.http.Http404`) .
+
+.. class:: ResolverMatch
+
+    .. attribute:: ResolverMatch.func
+
+        The view function that would be used to serve the URL
+
+    .. attribute:: ResolverMatch.args
+
+        The arguments that would be passed to the view function, as
+        parsed from the URL.
+
+    .. attribute:: ResolverMatch.kwargs
+
+        All keyword arguments that would be passed to the view function, i.e.
+        :attr:`~ResolverMatch.captured_kwargs` and
+        :attr:`~ResolverMatch.extra_kwargs`.
+
+    .. attribute:: ResolverMatch.captured_kwargs
+
+        The captured keyword arguments that would be passed to the view
+        function, as parsed from the URL.
+
+    .. attribute:: ResolverMatch.extra_kwargs
+
+        The additional keyword arguments that would be passed to the view
+        function.
+
+    .. attribute:: ResolverMatch.url_name
+
+        The name of the URL pattern that matches the URL.
+
+    .. attribute:: ResolverMatch.route
+
+        The route of the matching URL pattern.
+
+        For example, if ``path('users/<id>/', ...)`` is the matching pattern,
+        ``route`` will contain ``'users/<id>/'``.
+
+    .. attribute:: ResolverMatch.tried
+
+        The list of URL patterns tried before the URL either matched one or
+        exhausted available patterns.
+
+    .. attribute:: ResolverMatch.app_name
+
+        The application namespace for the URL pattern that matches the
+        URL.
+
+    .. attribute:: ResolverMatch.app_names
+
+        The list of individual namespace components in the full
+        application namespace for the URL pattern that matches the URL.
+        For example, if the ``app_name`` is ``'foo:bar'``, then ``app_names``
+        will be ``['foo', 'bar']``.
+
+    .. attribute:: ResolverMatch.namespace
+
+        The instance namespace for the URL pattern that matches the
+        URL.
+
+    .. attribute:: ResolverMatch.namespaces
+
+        The list of individual namespace components in the full
+        instance namespace for the URL pattern that matches the URL.
+        i.e., if the namespace is ``foo:bar``, then namespaces will be
+        ``['foo', 'bar']``.
+
+    .. attribute:: ResolverMatch.view_name
+
+        The name of the view that matches the URL, including the namespace if
+        there is one.
+
+A :class:`ResolverMatch` object can then be interrogated to provide
+information about the URL pattern that matches a URL::
+
+    # Resolve a URL
+    match = resolve("/some/path/")
+    # Print the URL pattern that matches the URL
+    print(match.url_name)
+
+A :class:`ResolverMatch` object can also be assigned to a triple::
+
+    func, args, kwargs = resolve("/some/path/")
+
+One possible use of :func:`~django.urls.resolve` would be to test whether a
+view would raise a ``Http404`` error before redirecting to it::
+
+    from urllib.parse import urlparse
+    from django.urls import resolve
+    from django.http import Http404, HttpResponseRedirect
+
+
+    def myview(request):
+        next = request.META.get("HTTP_REFERER", None) or "/"
+        response = HttpResponseRedirect(next)
+
+        # modify the request and response as required, e.g. change locale
+        # and set corresponding locale cookie
+
+        view, args, kwargs = resolve(urlparse(next)[2])
+        kwargs["request"] = request
+        try:
+            view(*args, **kwargs)
+        except Http404:
+            return HttpResponseRedirect("/")
+        return response
+
+``get_script_prefix()``
+=======================
+
+.. function:: get_script_prefix()
+
+Normally, you should always use :func:`~django.urls.reverse` to define URLs
+within your application. However, if your application constructs part of the
+URL hierarchy itself, you may occasionally need to generate URLs. In that
+case, you need to be able to find the base URL of the Django project within
+its web server (normally, :func:`~django.urls.reverse` takes care of this for
+you). In that case, you can call ``get_script_prefix()``, which will return
+the script prefix portion of the URL for your Django project. If your Django
+project is at the root of its web server, this is always ``"/"``.
+
+.. warning::
+
+    This function **cannot** be used outside of the request-response cycle
+    since it relies on values initialized during that cycle.

testbed/django__django/docs/ref/urls.txt

@@ -0,0 +1,197 @@
+=============================================
+``django.urls`` functions for use in URLconfs
+=============================================
+
+.. module:: django.urls.conf
+    :synopsis: Functions for use in URLconfs.
+
+.. currentmodule:: django.urls
+
+``path()``
+==========
+
+.. function:: path(route, view, kwargs=None, name=None)
+
+Returns an element for inclusion in ``urlpatterns``. For example::
+
+    from django.urls import include, path
+
+    urlpatterns = [
+        path("index/", views.index, name="main-view"),
+        path("bio/<username>/", views.bio, name="bio"),
+        path("articles/<slug:title>/", views.article, name="article-detail"),
+        path("articles/<slug:title>/<int:section>/", views.section, name="article-section"),
+        path("blog/", include("blog.urls")),
+        ...,
+    ]
+
+The ``route`` argument should be a string or
+:func:`~django.utils.translation.gettext_lazy()` (see
+:ref:`translating-urlpatterns`) that contains a URL pattern. The string
+may contain angle brackets (like ``<username>`` above) to capture part of the
+URL and send it as a keyword argument to the view. The angle brackets may
+include a converter specification (like the ``int`` part of ``<int:section>``)
+which limits the characters matched and may also change the type of the
+variable passed to the view. For example, ``<int:section>`` matches a string
+of decimal digits and converts the value to an ``int``. See
+:ref:`how-django-processes-a-request` for more details.
+
+The ``view`` argument is a view function or the result of
+:meth:`~django.views.generic.base.View.as_view` for class-based views. It can
+also be an :func:`django.urls.include`.
+
+The ``kwargs`` argument allows you to pass additional arguments to the view
+function or method. See :ref:`views-extra-options` for an example.
+
+See :ref:`Naming URL patterns <naming-url-patterns>` for why the ``name``
+argument is useful.
+
+``re_path()``
+=============
+
+.. function:: re_path(route, view, kwargs=None, name=None)
+
+Returns an element for inclusion in ``urlpatterns``. For example::
+
+    from django.urls import include, re_path
+
+    urlpatterns = [
+        re_path(r"^index/$", views.index, name="index"),
+        re_path(r"^bio/(?P<username>\w+)/$", views.bio, name="bio"),
+        re_path(r"^blog/", include("blog.urls")),
+        ...,
+    ]
+
+The ``route`` argument should be a string or
+:func:`~django.utils.translation.gettext_lazy()` (see
+:ref:`translating-urlpatterns`) that contains a regular expression compatible
+with Python's :py:mod:`re` module. Strings typically use raw string syntax
+(``r''``) so that they can contain sequences like ``\d`` without the need to
+escape the backslash with another backslash. When a match is made, captured
+groups from the regular expression are passed to the view -- as named arguments
+if the groups are named, and as positional arguments otherwise. The values are
+passed as strings, without any type conversion.
+
+When a ``route`` ends with ``$`` the whole requested URL, matching against
+:attr:`~django.http.HttpRequest.path_info`, must match the regular expression
+pattern (:py:func:`re.fullmatch` is used).
+
+The ``view``, ``kwargs`` and ``name`` arguments are the same as for
+:func:`~django.urls.path()`.
+
+.. versionchanged:: 2.2.25
+
+    In older versions, a full-match wasn't required for a ``route`` which ends
+    with ``$``.
+
+``include()``
+=============
+
+.. function:: include(module, namespace=None)
+              include(pattern_list)
+              include((pattern_list, app_namespace), namespace=None)
+
+    A function that takes a full Python import path to another URLconf module
+    that should be "included" in this place. Optionally, the :term:`application
+    namespace` and :term:`instance namespace` where the entries will be included
+    into can also be specified.
+
+    Usually, the application namespace should be specified by the included
+    module. If an application namespace is set, the ``namespace`` argument
+    can be used to set a different instance namespace.
+
+    ``include()`` also accepts as an argument either an iterable that returns
+    URL patterns or a 2-tuple containing such iterable plus the names of the
+    application namespaces.
+
+    :arg module: URLconf module (or module name)
+    :arg namespace: Instance namespace for the URL entries being included
+    :type namespace: str
+    :arg pattern_list: Iterable of :func:`~django.urls.path` and/or :func:`~django.urls.re_path` instances.
+    :arg app_namespace: Application namespace for the URL entries being included
+    :type app_namespace: str
+
+See :ref:`including-other-urlconfs` and :ref:`namespaces-and-include`.
+
+``register_converter()``
+========================
+
+.. function:: register_converter(converter, type_name)
+
+The function for registering a converter for use in :func:`~django.urls.path()`
+``route``\s.
+
+The ``converter`` argument is a converter class, and ``type_name`` is the
+converter name to use in path patterns. See
+:ref:`registering-custom-path-converters` for an example.
+
+==================================================
+``django.conf.urls`` functions for use in URLconfs
+==================================================
+
+.. module:: django.conf.urls
+
+``static()``
+============
+
+.. function:: static.static(prefix, view=django.views.static.serve, **kwargs)
+
+Helper function to return a URL pattern for serving files in debug mode::
+
+    from django.conf import settings
+    from django.conf.urls.static import static
+
+    urlpatterns = [
+        # ... the rest of your URLconf goes here ...
+    ] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
+
+``handler400``
+==============
+
+.. data:: handler400
+
+A callable, or a string representing the full Python import path to the view
+that should be called if the HTTP client has sent a request that caused an error
+condition and a response with a status code of 400.
+
+By default, this is :func:`django.views.defaults.bad_request`. If you
+implement a custom view, be sure it accepts ``request`` and ``exception``
+arguments and returns an :class:`~django.http.HttpResponseBadRequest`.
+
+``handler403``
+==============
+
+.. data:: handler403
+
+A callable, or a string representing the full Python import path to the view
+that should be called if the user doesn't have the permissions required to
+access a resource.
+
+By default, this is :func:`django.views.defaults.permission_denied`. If you
+implement a custom view, be sure it accepts ``request`` and ``exception``
+arguments and returns an :class:`~django.http.HttpResponseForbidden`.
+
+``handler404``
+==============
+
+.. data:: handler404
+
+A callable, or a string representing the full Python import path to the view
+that should be called if none of the URL patterns match.
+
+By default, this is :func:`django.views.defaults.page_not_found`. If you
+implement a custom view, be sure it accepts ``request`` and ``exception``
+arguments and returns an :class:`~django.http.HttpResponseNotFound`.
+
+``handler500``
+==============
+
+.. data:: handler500
+
+A callable, or a string representing the full Python import path to the view
+that should be called in case of server errors. Server errors happen when you
+have runtime errors in view code.
+
+By default, this is :func:`django.views.defaults.server_error`. If you
+implement a custom view, be sure it accepts a ``request`` argument and returns
+an :class:`~django.http.HttpResponseServerError`.

testbed/django__django/docs/ref/utils.txt

@@ -0,0 +1,1136 @@
+============
+Django Utils
+============
+
+.. module:: django.utils
+   :synopsis: Django's built-in utilities.
+
+This document covers all stable modules in ``django.utils``. Most of the
+modules in ``django.utils`` are designed for internal use and only the
+following parts can be considered stable and thus backwards compatible as per
+the :ref:`internal release deprecation policy <internal-release-deprecation-policy>`.
+
+``django.utils.cache``
+======================
+
+.. module:: django.utils.cache
+   :synopsis: Helper functions for controlling caching.
+
+This module contains helper functions for controlling HTTP caching. It does so
+by managing the ``Vary`` header of responses. It includes functions to patch
+the header of response objects directly and decorators that change functions to
+do that header-patching themselves.
+
+For information on the ``Vary`` header, see :rfc:`9110#section-12.5.5`.
+
+Essentially, the ``Vary`` HTTP header defines which headers a cache should take
+into account when building its cache key. Requests with the same path but
+different header content for headers named in ``Vary`` need to get different
+cache keys to prevent delivery of wrong content.
+
+For example, :doc:`internationalization </topics/i18n/index>` middleware would
+need to distinguish caches by the ``Accept-language`` header.
+
+.. function:: patch_cache_control(response, **kwargs)
+
+    This function patches the ``Cache-Control`` header by adding all keyword
+    arguments to it. The transformation is as follows:
+
+    * All keyword parameter names are turned to lowercase, and underscores
+      are converted to hyphens.
+    * If the value of a parameter is ``True`` (exactly ``True``, not just a
+      true value), only the parameter name is added to the header.
+    * All other parameters are added with their value, after applying
+      ``str()`` to it.
+
+.. function:: get_max_age(response)
+
+    Returns the max-age from the response Cache-Control header as an integer
+    (or ``None`` if it wasn't found or wasn't an integer).
+
+.. function:: patch_response_headers(response, cache_timeout=None)
+
+    Adds some useful headers to the given ``HttpResponse`` object:
+
+    * ``Expires``
+    * ``Cache-Control``
+
+    Each header is only added if it isn't already set.
+
+    ``cache_timeout`` is in seconds. The :setting:`CACHE_MIDDLEWARE_SECONDS`
+    setting is used by default.
+
+.. function:: add_never_cache_headers(response)
+
+    Adds an ``Expires`` header to the current date/time.
+
+    Adds a ``Cache-Control: max-age=0, no-cache, no-store, must-revalidate,
+    private`` header to a response to indicate that a page should never be
+    cached.
+
+    Each header is only added if it isn't already set.
+
+.. function:: patch_vary_headers(response, newheaders)
+
+    Adds (or updates) the ``Vary`` header in the given ``HttpResponse`` object.
+    ``newheaders`` is a list of header names that should be in ``Vary``. If
+    headers contains an asterisk, then ``Vary`` header will consist of a single
+    asterisk ``'*'``, according to :rfc:`9110#section-12.5.5`. Otherwise,
+    existing headers in ``Vary`` aren't removed.
+
+.. function:: get_cache_key(request, key_prefix=None, method='GET', cache=None)
+
+    Returns a cache key based on the request path. It can be used in the
+    request phase because it pulls the list of headers to take into account
+    from the global path registry and uses those to build a cache key to
+    check against.
+
+    If there is no headerlist stored, the page needs to be rebuilt, so this
+    function returns ``None``.
+
+.. function:: learn_cache_key(request, response, cache_timeout=None, key_prefix=None, cache=None)
+
+    Learns what headers to take into account for some request path from the
+    response object. It stores those headers in a global path registry so that
+    later access to that path will know what headers to take into account
+    without building the response object itself. The headers are named in
+    the ``Vary`` header of the response, but we want to prevent response
+    generation.
+
+    The list of headers to use for cache key generation is stored in the same
+    cache as the pages themselves. If the cache ages some data out of the
+    cache, this means that we have to build the response once to get at the
+    Vary header and so at the list of headers to use for the cache key.
+
+``django.utils.dateparse``
+==========================
+
+.. module:: django.utils.dateparse
+   :synopsis: Functions to parse strings to datetime objects.
+
+The functions defined in this module share the following properties:
+
+- They accept strings in ISO 8601 date/time formats (or some close
+  alternatives) and return objects from the corresponding classes in Python's
+  :mod:`datetime` module.
+- They raise :exc:`ValueError` if their input is well formatted but isn't a
+  valid date or time.
+- They return ``None`` if it isn't well formatted at all.
+- They accept up to picosecond resolution in input, but they truncate it to
+  microseconds, since that's what Python supports.
+
+.. function:: parse_date(value)
+
+    Parses a string and returns a :class:`datetime.date`.
+
+.. function:: parse_time(value)
+
+    Parses a string and returns a :class:`datetime.time`.
+
+    UTC offsets aren't supported; if ``value`` describes one, the result is
+    ``None``.
+
+.. function:: parse_datetime(value)
+
+    Parses a string and returns a :class:`datetime.datetime`.
+
+    UTC offsets are supported; if ``value`` describes one, the result's
+    ``tzinfo`` attribute is a :class:`datetime.timezone` instance.
+
+.. function:: parse_duration(value)
+
+    Parses a string and returns a :class:`datetime.timedelta`.
+
+    Expects data in the format ``"DD HH:MM:SS.uuuuuu"``,
+    ``"DD HH:MM:SS,uuuuuu"``,  or as specified by ISO 8601 (e.g.
+    ``P4DT1H15M20S`` which is equivalent to ``4 1:15:20``) or PostgreSQL's
+    day-time interval format (e.g. ``3 days 04:05:06``).
+
+``django.utils.decorators``
+===========================
+
+.. module:: django.utils.decorators
+    :synopsis: Functions that help with creating decorators for views.
+
+.. function:: method_decorator(decorator, name='')
+
+    Converts a function decorator into a method decorator. It can be used to
+    decorate methods or classes; in the latter case, ``name`` is the name
+    of the method to be decorated and is required.
+
+    ``decorator`` may also be a list or tuple of functions. They are wrapped
+    in reverse order so that the call order is the order in which the functions
+    appear in the list/tuple.
+
+    See :ref:`decorating class based views <decorating-class-based-views>` for
+    example usage.
+
+.. function:: decorator_from_middleware(middleware_class)
+
+    Given a middleware class, returns a view decorator. This lets you use
+    middleware functionality on a per-view basis. The middleware is created
+    with no params passed.
+
+    It assumes middleware that's compatible with the old style of Django 1.9
+    and earlier (having methods like ``process_request()``,
+    ``process_exception()``, and ``process_response()``).
+
+.. function:: decorator_from_middleware_with_args(middleware_class)
+
+    Like ``decorator_from_middleware``, but returns a function
+    that accepts the arguments to be passed to the middleware_class.
+    For example, the :func:`~django.views.decorators.cache.cache_page`
+    decorator is created from the ``CacheMiddleware`` like this::
+
+         cache_page = decorator_from_middleware_with_args(CacheMiddleware)
+
+
+         @cache_page(3600)
+         def my_view(request):
+             pass
+
+.. function:: sync_only_middleware(middleware)
+
+    Marks a middleware as :ref:`synchronous-only <async-middleware>`. (The
+    default in Django, but this allows you to future-proof if the default ever
+    changes in a future release.)
+
+.. function:: async_only_middleware(middleware)
+
+    Marks a middleware as :ref:`asynchronous-only <async-middleware>`. Django
+    will wrap it in an asynchronous event loop when it is called from the WSGI
+    request path.
+
+.. function:: sync_and_async_middleware(middleware)
+
+    Marks a middleware as :ref:`sync and async compatible <async-middleware>`,
+    this allows to avoid converting requests. You must implement detection of
+    the current request type to use this decorator. See :ref:`asynchronous
+    middleware documentation <async-middleware>` for details.
+
+``django.utils.encoding``
+=========================
+
+.. module:: django.utils.encoding
+   :synopsis: A series of helper functions to manage character encoding.
+
+.. function:: smart_str(s, encoding='utf-8', strings_only=False, errors='strict')
+
+    Returns a ``str`` object representing arbitrary object ``s``. Treats
+    bytestrings using the ``encoding`` codec.
+
+    If ``strings_only`` is ``True``, don't convert (some) non-string-like
+    objects.
+
+.. function:: is_protected_type(obj)
+
+    Determine if the object instance is of a protected type.
+
+    Objects of protected types are preserved as-is when passed to
+    ``force_str(strings_only=True)``.
+
+.. function:: force_str(s, encoding='utf-8', strings_only=False, errors='strict')
+
+    Similar to ``smart_str()``, except that lazy instances are resolved to
+    strings, rather than kept as lazy objects.
+
+    If ``strings_only`` is ``True``, don't convert (some) non-string-like
+    objects.
+
+.. function:: smart_bytes(s, encoding='utf-8', strings_only=False, errors='strict')
+
+    Returns a bytestring version of arbitrary object ``s``, encoded as
+    specified in ``encoding``.
+
+    If ``strings_only`` is ``True``, don't convert (some) non-string-like
+    objects.
+
+.. function:: force_bytes(s, encoding='utf-8', strings_only=False, errors='strict')
+
+    Similar to ``smart_bytes``, except that lazy instances are resolved to
+    bytestrings, rather than kept as lazy objects.
+
+    If ``strings_only`` is ``True``, don't convert (some) non-string-like
+    objects.
+
+.. function:: iri_to_uri(iri)
+
+    Convert an Internationalized Resource Identifier (IRI) portion to a URI
+    portion that is suitable for inclusion in a URL.
+
+    This is the algorithm from section 3.1 of :rfc:`3987#section-3.1`, slightly
+    simplified since the input is assumed to be a string rather than an
+    arbitrary byte stream.
+
+    Takes an IRI (string or UTF-8 bytes) and returns a string containing the
+    encoded result.
+
+.. function:: uri_to_iri(uri)
+
+    Converts a Uniform Resource Identifier into an Internationalized Resource
+    Identifier.
+
+    This is an algorithm from section 3.2 of :rfc:`3987#section-3.2`.
+
+    Takes a URI in ASCII bytes and returns a string containing the encoded
+    result.
+
+.. function:: filepath_to_uri(path)
+
+    Convert a file system path to a URI portion that is suitable for inclusion
+    in a URL. The path is assumed to be either UTF-8 bytes, string, or a
+    :class:`~pathlib.Path`.
+
+    This method will encode certain characters that would normally be
+    recognized as special characters for URIs.  Note that this method does not
+    encode the ' character, as it is a valid character within URIs. See
+    ``encodeURIComponent()`` JavaScript function for more details.
+
+    Returns an ASCII string containing the encoded result.
+
+.. function:: escape_uri_path(path)
+
+    Escapes the unsafe characters from the path portion of a Uniform Resource
+    Identifier (URI).
+
+``django.utils.feedgenerator``
+==============================
+
+.. module:: django.utils.feedgenerator
+   :synopsis: Syndication feed generation library -- used for generating RSS, etc.
+
+Sample usage:
+
+.. code-block:: pycon
+
+    >>> from django.utils import feedgenerator
+    >>> feed = feedgenerator.Rss201rev2Feed(
+    ...     title="Poynter E-Media Tidbits",
+    ...     link="http://www.poynter.org/column.asp?id=31",
+    ...     description="A group blog by the sharpest minds in online media/journalism/publishing.",
+    ...     language="en",
+    ... )
+    >>> feed.add_item(
+    ...     title="Hello",
+    ...     link="http://www.holovaty.com/test/",
+    ...     description="Testing.",
+    ... )
+    >>> with open("test.rss", "w") as fp:
+    ...     feed.write(fp, "utf-8")
+    ...
+
+For simplifying the selection of a generator use ``feedgenerator.DefaultFeed``
+which is currently ``Rss201rev2Feed``
+
+For definitions of the different versions of RSS, see:
+https://web.archive.org/web/20110718035220/http://diveintomark.org/archives/2004/02/04/incompatible-rss
+
+.. function:: get_tag_uri(url, date)
+
+    Creates a TagURI.
+
+    See https://web.archive.org/web/20110514113830/http://diveintomark.org/archives/2004/05/28/howto-atom-id
+
+``SyndicationFeed``
+-------------------
+
+.. class:: SyndicationFeed
+
+    Base class for all syndication feeds. Subclasses should provide
+    ``write()``.
+
+    .. method:: __init__(title, link, description, language=None, author_email=None, author_name=None, author_link=None, subtitle=None, categories=None, feed_url=None, feed_copyright=None, feed_guid=None, ttl=None, **kwargs)
+
+        Initialize the feed with the given dictionary of metadata, which applies
+        to the entire feed.
+
+        Any extra keyword arguments you pass to ``__init__`` will be stored in
+        ``self.feed``.
+
+        All parameters should be strings, except ``categories``, which should
+        be a sequence of strings.
+
+    .. method:: add_item(title, link, description, author_email=None, author_name=None, author_link=None, pubdate=None, comments=None, unique_id=None, categories=(), item_copyright=None, ttl=None, updateddate=None, enclosures=None, **kwargs)
+
+        Adds an item to the feed. All args are expected to be strings except
+        ``pubdate`` and ``updateddate``, which are ``datetime.datetime``
+        objects, and ``enclosures``, which is a list of ``Enclosure`` instances.
+
+    .. method:: num_items()
+
+    .. method:: root_attributes()
+
+        Return extra attributes to place on the root (i.e. feed/channel)
+        element. Called from ``write()``.
+
+    .. method:: add_root_elements(handler)
+
+        Add elements in the root (i.e. feed/channel) element.
+        Called from ``write()``.
+
+    .. method:: item_attributes(item)
+
+        Return extra attributes to place on each item (i.e. item/entry)
+        element.
+
+    .. method:: add_item_elements(handler, item)
+
+        Add elements on each item (i.e. item/entry) element.
+
+    .. method:: write(outfile, encoding)
+
+        Outputs the feed in the given encoding to ``outfile``, which is a
+        file-like object. Subclasses should override this.
+
+    .. method:: writeString(encoding)
+
+        Returns the feed in the given encoding as a string.
+
+    .. method:: latest_post_date()
+
+        Returns the latest ``pubdate`` or ``updateddate`` for all items in the
+        feed. If no items have either of these attributes this returns the
+        current UTC date/time.
+
+``Enclosure``
+-------------
+
+.. class:: Enclosure
+
+    Represents an RSS enclosure
+
+``RssFeed``
+-----------
+
+.. class:: RssFeed(SyndicationFeed)
+
+``Rss201rev2Feed``
+------------------
+
+.. class:: Rss201rev2Feed(RssFeed)
+
+    Spec: https://cyber.harvard.edu/rss/rss.html
+
+``RssUserland091Feed``
+----------------------
+
+.. class:: RssUserland091Feed(RssFeed)
+
+    Spec: http://backend.userland.com/rss091
+
+``Atom1Feed``
+-------------
+
+.. class:: Atom1Feed(SyndicationFeed)
+
+    Spec: :rfc:`4287`
+
+``django.utils.functional``
+===========================
+
+.. module:: django.utils.functional
+    :synopsis: Functional programming tools.
+
+.. class:: cached_property(func)
+
+    The ``@cached_property`` decorator caches the result of a method with a
+    single ``self`` argument as a property. The cached result will persist
+    as long as the instance does, so if the instance is passed around and the
+    function subsequently invoked, the cached result will be returned.
+
+    Consider a typical case, where a view might need to call a model's method
+    to perform some computation, before placing the model instance into the
+    context, where the template might invoke the method once more::
+
+        # the model
+        class Person(models.Model):
+            def friends(self):
+                # expensive computation
+                ...
+                return friends
+
+
+        # in the view:
+        if person.friends():
+            ...
+
+    And in the template you would have:
+
+    .. code-block:: html+django
+
+        {% for friend in person.friends %}
+
+    Here, ``friends()`` will be called twice. Since the instance ``person`` in
+    the view and the template are the same, decorating the ``friends()`` method
+    with ``@cached_property`` can avoid that::
+
+        from django.utils.functional import cached_property
+
+
+        class Person(models.Model):
+            @cached_property
+            def friends(self):
+                ...
+
+    Note that as the method is now a property, in Python code it will need to
+    be accessed appropriately::
+
+        # in the view:
+        if person.friends:
+            ...
+
+    The cached value can be treated like an ordinary attribute of the instance::
+
+        # clear it, requiring re-computation next time it's called
+        del person.friends  # or delattr(person, "friends")
+
+        # set a value manually, that will persist on the instance until cleared
+        person.friends = ["Huckleberry Finn", "Tom Sawyer"]
+
+    Because of the way the :py:ref:`descriptor protocol
+    <descriptor-invocation>` works, using ``del`` (or ``delattr``) on a
+    ``cached_property`` that hasn't been accessed raises ``AttributeError``.
+
+    As well as offering potential performance advantages, ``@cached_property``
+    can ensure that an attribute's value does not change unexpectedly over the
+    life of an instance. This could occur with a method whose computation is
+    based on ``datetime.now()``, or if a change were saved to the database by
+    some other process in the brief interval between subsequent invocations of
+    a method on the same instance.
+
+    You can make cached properties of methods. For example, if you had an
+    expensive ``get_friends()`` method and wanted to allow calling it without
+    retrieving the cached value, you could write::
+
+        friends = cached_property(get_friends)
+
+    While ``person.get_friends()`` will recompute the friends on each call, the
+    value of the cached property will persist until you delete it as described
+    above::
+
+        x = person.friends  # calls first time
+        y = person.get_friends()  # calls again
+        z = person.friends  # does not call
+        x is z  # is True
+
+.. class:: classproperty(method=None)
+
+    Similar to :py:func:`@classmethod <classmethod>`, the ``@classproperty``
+    decorator converts the result of a method with a single ``cls`` argument
+    into a property that can be accessed directly from the class.
+
+.. function:: keep_lazy(func, *resultclasses)
+
+    Django offers many utility functions (particularly in ``django.utils``)
+    that take a string as their first argument and do something to that string.
+    These functions are used by template filters as well as directly in other
+    code.
+
+    If you write your own similar functions and deal with translations, you'll
+    face the problem of what to do when the first argument is a lazy
+    translation object. You don't want to convert it to a string immediately,
+    because you might be using this function outside of a view (and hence the
+    current thread's locale setting will not be correct).
+
+    For cases like this, use the ``django.utils.functional.keep_lazy()``
+    decorator. It modifies the function so that *if* it's called with a lazy
+    translation as one of its arguments, the function evaluation is delayed
+    until it needs to be converted to a string.
+
+    For example::
+
+        from django.utils.functional import keep_lazy, keep_lazy_text
+
+
+        def fancy_utility_function(s, *args, **kwargs):
+            # Do some conversion on string 's'
+            ...
+
+
+        fancy_utility_function = keep_lazy(str)(fancy_utility_function)
+
+
+        # Or more succinctly:
+        @keep_lazy(str)
+        def fancy_utility_function(s, *args, **kwargs):
+            ...
+
+    The ``keep_lazy()`` decorator takes a number of extra arguments (``*args``)
+    specifying the type(s) that the original function can return. A common
+    use case is to have functions that return text. For these, you can pass the
+    ``str`` type to ``keep_lazy`` (or use the :func:`keep_lazy_text` decorator
+    described in the next section).
+
+    Using this decorator means you can write your function and assume that the
+    input is a proper string, then add support for lazy translation objects at
+    the end.
+
+.. function:: keep_lazy_text(func)
+
+    A shortcut for ``keep_lazy(str)(func)``.
+
+    If you have a function that returns text and you want to be able to take
+    lazy arguments while delaying their evaluation, you can use this
+    decorator::
+
+        from django.utils.functional import keep_lazy, keep_lazy_text
+
+
+        # Our previous example was:
+        @keep_lazy(str)
+        def fancy_utility_function(s, *args, **kwargs):
+            ...
+
+
+        # Which can be rewritten as:
+        @keep_lazy_text
+        def fancy_utility_function(s, *args, **kwargs):
+            ...
+
+``django.utils.html``
+=====================
+
+.. module:: django.utils.html
+   :synopsis: HTML helper functions
+
+Usually you should build up HTML using Django's templates to make use of its
+autoescape mechanism, using the utilities in :mod:`django.utils.safestring`
+where appropriate. This module provides some additional low level utilities for
+escaping HTML.
+
+.. function:: escape(text)
+
+    Returns the given text with ampersands, quotes and angle brackets encoded
+    for use in HTML. The input is first coerced to a string and the output has
+    :func:`~django.utils.safestring.mark_safe` applied.
+
+.. function:: conditional_escape(text)
+
+    Similar to ``escape()``, except that it doesn't operate on preescaped
+    strings, so it will not double escape.
+
+.. function:: format_html(format_string, *args, **kwargs)
+
+    This is similar to :meth:`str.format`, except that it is appropriate for
+    building up HTML fragments. The first argument ``format_string`` is not
+    escaped but all other args and kwargs are passed through
+    :func:`conditional_escape` before being passed to ``str.format()``.
+    Finally, the output has :func:`~django.utils.safestring.mark_safe` applied.
+
+    For the case of building up small HTML fragments, this function is to be
+    preferred over string interpolation using ``%`` or ``str.format()``
+    directly, because it applies escaping to all arguments - just like the
+    template system applies escaping by default.
+
+    So, instead of writing::
+
+        mark_safe(
+            "%s <b>%s</b> %s"
+            % (
+                some_html,
+                escape(some_text),
+                escape(some_other_text),
+            )
+        )
+
+    You should instead use::
+
+        format_html(
+            "{} <b>{}</b> {}",
+            mark_safe(some_html),
+            some_text,
+            some_other_text,
+        )
+
+    This has the advantage that you don't need to apply :func:`escape` to each
+    argument and risk a bug and an XSS vulnerability if you forget one.
+
+    Note that although this function uses ``str.format()`` to do the
+    interpolation, some of the formatting options provided by ``str.format()``
+    (e.g. number formatting) will not work, since all arguments are passed
+    through :func:`conditional_escape` which (ultimately) calls
+    :func:`~django.utils.encoding.force_str` on the values.
+
+    .. deprecated:: 5.0
+
+        Support for calling ``format_html()`` without passing args or kwargs is
+        deprecated.
+
+.. function:: format_html_join(sep, format_string, args_generator)
+
+    A wrapper of :func:`format_html`, for the common case of a group of
+    arguments that need to be formatted using the same format string, and then
+    joined using ``sep``. ``sep`` is also passed through
+    :func:`conditional_escape`.
+
+    ``args_generator`` should be an iterator that returns the sequence of
+    ``args`` that will be passed to :func:`format_html`. For example::
+
+        format_html_join("\n", "<li>{} {}</li>", ((u.first_name, u.last_name) for u in users))
+
+.. function:: json_script(value, element_id=None, encoder=None)
+
+    Escapes all HTML/XML special characters with their Unicode escapes, so
+    value is safe for use with JavaScript. Also wraps the escaped JSON in a
+    ``<script>`` tag. If the ``element_id`` parameter is not ``None``, the
+    ``<script>`` tag is given the passed id. For example:
+
+    .. code-block:: pycon
+
+        >>> json_script({"hello": "world"}, element_id="hello-data")
+        '<script id="hello-data" type="application/json">{"hello": "world"}</script>'
+
+    The ``encoder``, which defaults to
+    :class:`django.core.serializers.json.DjangoJSONEncoder`, will be used to
+    serialize the data. See :ref:`JSON serialization
+    <serialization-formats-json>` for more details about this serializer.
+
+    .. versionchanged:: 4.2
+
+        The ``encoder`` argument was added.
+
+.. function:: strip_tags(value)
+
+    Tries to remove anything that looks like an HTML tag from the string, that
+    is anything contained within ``<>``.
+
+    Absolutely NO guarantee is provided about the resulting string being
+    HTML safe. So NEVER mark safe the result of a ``strip_tag`` call without
+    escaping it first, for example with :func:`~django.utils.html.escape`.
+
+    For example::
+
+        strip_tags(value)
+
+    If ``value`` is ``"<b>Joel</b> <button>is</button> a <span>slug</span>"``
+    the return value will be ``"Joel is a slug"``.
+
+    If you are looking for a more robust solution, consider using a third-party
+    HTML sanitizing tool.
+
+.. function:: html_safe()
+
+    The ``__html__()`` method on a class helps non-Django templates detect
+    classes whose output doesn't require HTML escaping.
+
+    This decorator defines the ``__html__()`` method on the decorated class
+    by wrapping ``__str__()`` in :meth:`~django.utils.safestring.mark_safe`.
+    Ensure the ``__str__()`` method does indeed return text that doesn't
+    require HTML escaping.
+
+``django.utils.http``
+=====================
+
+.. module:: django.utils.http
+   :synopsis: HTTP helper functions. (URL encoding, cookie handling, ...)
+
+.. function:: urlencode(query, doseq=False)
+
+    A version of Python's :func:`urllib.parse.urlencode` function that can
+    operate on ``MultiValueDict`` and non-string values.
+
+.. function:: http_date(epoch_seconds=None)
+
+    Formats the time to match the :rfc:`1123#section-5.2.14` date format as
+    specified by HTTP :rfc:`9110#section-5.6.7`.
+
+    Accepts a floating point number expressed in seconds since the epoch in
+    UTC--such as that outputted by ``time.time()``. If set to ``None``,
+    defaults to the current time.
+
+    Outputs a string in the format ``Wdy, DD Mon YYYY HH:MM:SS GMT``.
+
+.. function:: content_disposition_header(as_attachment, filename)
+
+    .. versionadded:: 4.2
+
+    Constructs a ``Content-Disposition`` HTTP header value from the given
+    ``filename`` as specified by :rfc:`6266`. Returns ``None`` if
+    ``as_attachment`` is ``False`` and ``filename`` is ``None``, otherwise
+    returns a string suitable for the ``Content-Disposition`` HTTP header.
+
+.. function:: base36_to_int(s)
+
+    Converts a base 36 string to an integer.
+
+.. function:: int_to_base36(i)
+
+    Converts a positive integer to a base 36 string.
+
+.. function:: urlsafe_base64_encode(s)
+
+    Encodes a bytestring to a base64 string for use in URLs, stripping any
+    trailing equal signs.
+
+.. function::  urlsafe_base64_decode(s)
+
+    Decodes a base64 encoded string, adding back any trailing equal signs that
+    might have been stripped.
+
+``django.utils.module_loading``
+===============================
+
+.. module:: django.utils.module_loading
+   :synopsis: Functions for working with Python modules.
+
+Functions for working with Python modules.
+
+.. function:: import_string(dotted_path)
+
+    Imports a dotted module path and returns the attribute/class designated by
+    the last name in the path. Raises ``ImportError`` if the import failed. For
+    example::
+
+        from django.utils.module_loading import import_string
+
+        ValidationError = import_string("django.core.exceptions.ValidationError")
+
+    is equivalent to::
+
+        from django.core.exceptions import ValidationError
+
+``django.utils.safestring``
+===========================
+
+.. module:: django.utils.safestring
+   :synopsis: Functions and classes for working with strings that can be displayed safely without further escaping in HTML.
+
+Functions and classes for working with "safe strings": strings that can be
+displayed safely without further escaping in HTML. Marking something as a "safe
+string" means that the producer of the string has already turned characters
+that should not be interpreted by the HTML engine (e.g. '<') into the
+appropriate entities.
+
+.. class:: SafeString
+
+    A ``str`` subclass that has been specifically marked as "safe" (requires no
+    further escaping) for HTML output purposes.
+
+.. function:: mark_safe(s)
+
+    Explicitly mark a string as safe for (HTML) output purposes. The returned
+    object can be used everywhere a string is appropriate.
+
+    Can be called multiple times on a single string.
+
+    Can also be used as a decorator.
+
+    For building up fragments of HTML, you should normally be using
+    :func:`django.utils.html.format_html` instead.
+
+    String marked safe will become unsafe again if modified. For example:
+
+    .. code-block:: pycon
+
+        >>> mystr = "<b>Hello World</b>   "
+        >>> mystr = mark_safe(mystr)
+        >>> type(mystr)
+        <class 'django.utils.safestring.SafeString'>
+
+        >>> mystr = mystr.strip()  # removing whitespace
+        >>> type(mystr)
+        <type 'str'>
+
+``django.utils.text``
+=====================
+
+.. module:: django.utils.text
+    :synopsis: Text manipulation.
+
+.. function:: format_lazy(format_string, *args, **kwargs)
+
+    A version of :meth:`str.format` for when ``format_string``, ``args``,
+    and/or ``kwargs`` contain lazy objects. The first argument is the string to
+    be formatted. For example::
+
+        from django.utils.text import format_lazy
+        from django.utils.translation import pgettext_lazy
+
+        urlpatterns = [
+            path(
+                format_lazy("{person}/<int:pk>/", person=pgettext_lazy("URL", "person")),
+                PersonDetailView.as_view(),
+            ),
+        ]
+
+    This example allows translators to translate part of the URL. If "person"
+    is translated to "persona", the regular expression will match
+    ``persona/(?P<pk>\d+)/$``, e.g. ``persona/5/``.
+
+.. function:: slugify(value, allow_unicode=False)
+
+    Converts a string to a URL slug by:
+
+    #. Converting to ASCII if ``allow_unicode`` is ``False`` (the default).
+    #. Converting to lowercase.
+    #. Removing characters that aren't alphanumerics, underscores, hyphens, or
+       whitespace.
+    #. Replacing any whitespace or repeated dashes with single dashes.
+    #. Removing leading and trailing whitespace, dashes, and underscores.
+
+    For example:
+
+    .. code-block:: pycon
+
+        >>> slugify(" Joel is a slug ")
+        'joel-is-a-slug'
+
+    If you want to allow Unicode characters, pass ``allow_unicode=True``. For
+    example:
+
+    .. code-block:: pycon
+
+        >>> slugify("你好 World", allow_unicode=True)
+        '你好-world'
+
+.. _time-zone-selection-functions:
+
+``django.utils.timezone``
+=========================
+
+.. module:: django.utils.timezone
+    :synopsis: Timezone support.
+
+.. function:: get_fixed_timezone(offset)
+
+    Returns a :class:`~datetime.tzinfo` instance that represents a time zone
+    with a fixed offset from UTC.
+
+    ``offset`` is a :class:`datetime.timedelta` or an integer number of
+    minutes. Use positive values for time zones east of UTC and negative
+    values for west of UTC.
+
+.. function:: get_default_timezone()
+
+    Returns a :class:`~datetime.tzinfo` instance that represents the
+    :ref:`default time zone <default-current-time-zone>`.
+
+.. function:: get_default_timezone_name()
+
+    Returns the name of the :ref:`default time zone
+    <default-current-time-zone>`.
+
+.. function:: get_current_timezone()
+
+    Returns a :class:`~datetime.tzinfo` instance that represents the
+    :ref:`current time zone <default-current-time-zone>`.
+
+.. function:: get_current_timezone_name()
+
+    Returns the name of the :ref:`current time zone
+    <default-current-time-zone>`.
+
+.. function:: activate(timezone)
+
+    Sets the :ref:`current time zone <default-current-time-zone>`. The
+    ``timezone`` argument must be an instance of a :class:`~datetime.tzinfo`
+    subclass or a time zone name.
+
+.. function:: deactivate()
+
+    Unsets the :ref:`current time zone <default-current-time-zone>`.
+
+.. function:: override(timezone)
+
+    This is a Python context manager that sets the :ref:`current time zone
+    <default-current-time-zone>` on entry with :func:`activate()`, and restores
+    the previously active time zone on exit. If the ``timezone`` argument is
+    ``None``, the :ref:`current time zone <default-current-time-zone>` is unset
+    on entry with :func:`deactivate()` instead.
+
+    ``override`` is also usable as a function decorator.
+
+.. function:: localtime(value=None, timezone=None)
+
+    Converts an aware :class:`~datetime.datetime` to a different time zone,
+    by default the :ref:`current time zone <default-current-time-zone>`.
+
+    When ``value`` is omitted, it defaults to :func:`now`.
+
+    This function doesn't work on naive datetimes; use :func:`make_aware`
+    instead.
+
+.. function:: localdate(value=None, timezone=None)
+
+    Uses :func:`localtime` to convert an aware :class:`~datetime.datetime` to a
+    :meth:`~datetime.datetime.date` in a different time zone, by default the
+    :ref:`current time zone <default-current-time-zone>`.
+
+    When ``value`` is omitted, it defaults to :func:`now`.
+
+    This function doesn't work on naive datetimes.
+
+.. function:: now()
+
+    Returns a :class:`~datetime.datetime` that represents the
+    current point in time. Exactly what's returned depends on the value of
+    :setting:`USE_TZ`:
+
+    * If :setting:`USE_TZ` is ``False``, this will be a
+      :ref:`naive <naive_vs_aware_datetimes>` datetime (i.e. a datetime
+      without an associated timezone) that represents the current time
+      in the system's local timezone.
+
+    * If :setting:`USE_TZ` is ``True``, this will be an
+      :ref:`aware <naive_vs_aware_datetimes>` datetime representing the
+      current time in UTC. Note that :func:`now` will always return
+      times in UTC regardless of the value of :setting:`TIME_ZONE`;
+      you can use :func:`localtime` to get the time in the current time zone.
+
+.. function:: is_aware(value)
+
+    Returns ``True`` if ``value`` is aware, ``False`` if it is naive. This
+    function assumes that ``value`` is a :class:`~datetime.datetime`.
+
+.. function:: is_naive(value)
+
+    Returns ``True`` if ``value`` is naive, ``False`` if it is aware. This
+    function assumes that ``value`` is a :class:`~datetime.datetime`.
+
+.. function:: make_aware(value, timezone=None)
+
+    Returns an aware :class:`~datetime.datetime` that represents the same
+    point in time as ``value`` in ``timezone``, ``value`` being a naive
+    :class:`~datetime.datetime`. If ``timezone`` is set to ``None``, it
+    defaults to the :ref:`current time zone <default-current-time-zone>`.
+
+.. function:: make_naive(value, timezone=None)
+
+    Returns a naive :class:`~datetime.datetime` that represents in
+    ``timezone``  the same point in time as ``value``, ``value`` being an
+    aware :class:`~datetime.datetime`. If ``timezone`` is set to ``None``, it
+    defaults to the :ref:`current time zone <default-current-time-zone>`.
+
+``django.utils.translation``
+============================
+
+.. module:: django.utils.translation
+   :synopsis: Internationalization support.
+
+For a complete discussion on the usage of the following see the
+:doc:`translation documentation </topics/i18n/translation>`.
+
+.. function:: gettext(message)
+
+    Translates ``message`` and returns it as a string.
+
+.. function:: pgettext(context, message)
+
+    Translates ``message`` given the ``context`` and returns it as a string.
+
+    For more information, see :ref:`contextual-markers`.
+
+.. function:: gettext_lazy(message)
+.. function:: pgettext_lazy(context, message)
+
+    Same as the non-lazy versions above, but using lazy execution.
+
+    See :ref:`lazy translations documentation <lazy-translations>`.
+
+.. function:: gettext_noop(message)
+
+    Marks strings for translation but doesn't translate them now. This can be
+    used to store strings in global variables that should stay in the base
+    language (because they might be used externally) and will be translated
+    later.
+
+.. function:: ngettext(singular, plural, number)
+
+    Translates ``singular`` and ``plural`` and returns the appropriate string
+    based on ``number``.
+
+.. function:: npgettext(context, singular, plural, number)
+
+    Translates ``singular`` and ``plural`` and returns the appropriate string
+    based on ``number`` and the ``context``.
+
+.. function:: ngettext_lazy(singular, plural, number)
+.. function:: npgettext_lazy(context, singular, plural, number)
+
+    Same as the non-lazy versions above, but using lazy execution.
+
+    See :ref:`lazy translations documentation <lazy-translations>`.
+
+.. function:: activate(language)
+
+    Fetches the translation object for a given language and activates it as
+    the current translation object for the current thread.
+
+.. function:: deactivate()
+
+    Deactivates the currently active translation object so that further _ calls
+    will resolve against the default translation object, again.
+
+.. function:: deactivate_all()
+
+    Makes the active translation object a ``NullTranslations()`` instance.
+    This is useful when we want delayed translations to appear as the original
+    string for some reason.
+
+.. function:: override(language, deactivate=False)
+
+    A Python context manager that uses
+    :func:`django.utils.translation.activate` to fetch the translation object
+    for a given language, activates it as the translation object for the
+    current thread and reactivates the previous active language on exit.
+    Optionally, it can deactivate the temporary translation on exit with
+    :func:`django.utils.translation.deactivate` if the ``deactivate`` argument
+    is ``True``. If you pass ``None`` as the language argument, a
+    ``NullTranslations()`` instance is activated within the context.
+
+    ``override`` is also usable as a function decorator.
+
+.. function:: check_for_language(lang_code)
+
+    Checks whether there is a global language file for the given language
+    code (e.g. 'fr', 'pt_BR'). This is used to decide whether a user-provided
+    language is available.
+
+.. function:: get_language()
+
+    Returns the currently selected language code. Returns ``None`` if
+    translations are temporarily deactivated (by :func:`deactivate_all()` or
+    when ``None`` is passed to :func:`override()`).
+
+.. function:: get_language_bidi()
+
+    Returns selected language's BiDi layout:
+
+    * ``False`` = left-to-right layout
+    * ``True`` = right-to-left layout
+
+.. function:: get_language_from_request(request, check_path=False)
+
+    Analyzes the request to find what language the user wants the system to
+    show. Only languages listed in settings.LANGUAGES are taken into account.
+    If the user requests a sublanguage where we have a main language, we send
+    out the main language.
+
+    If ``check_path`` is ``True``, the function first checks the requested URL
+    for whether its path begins with a language code listed in the
+    :setting:`LANGUAGES` setting.
+
+.. function:: get_supported_language_variant(lang_code, strict=False)
+
+    Returns ``lang_code`` if it's in the :setting:`LANGUAGES` setting, possibly
+    selecting a more generic variant. For example, ``'es'`` is returned if
+    ``lang_code`` is ``'es-ar'`` and ``'es'`` is in :setting:`LANGUAGES` but
+    ``'es-ar'`` isn't.
+
+    If ``strict`` is ``False`` (the default), a country-specific variant may
+    be returned when neither the language code nor its generic variant is found.
+    For example, if only ``'es-co'`` is in :setting:`LANGUAGES`, that's
+    returned for ``lang_code``\s like ``'es'`` and ``'es-ar'``. Those matches
+    aren't returned if ``strict=True``.
+
+    Raises :exc:`LookupError` if nothing is found.
+
+.. function:: to_locale(language)
+
+    Turns a language name (en-us) into a locale name (en_US).
+
+.. function:: templatize(src)
+
+    Turns a Django template into something that is understood by ``xgettext``.
+    It does so by translating the Django translation tags into standard
+    ``gettext`` function invocations.

testbed/django__django/docs/ref/validators.txt

@@ -0,0 +1,378 @@
+==========
+Validators
+==========
+
+.. module:: django.core.validators
+    :synopsis: Validation utilities and base classes
+
+Writing validators
+==================
+
+A validator is a callable that takes a value and raises a
+:exc:`~django.core.exceptions.ValidationError` if it doesn't meet some
+criteria. Validators can be useful for reusing validation logic between
+different types of fields.
+
+For example, here's a validator that only allows even numbers::
+
+    from django.core.exceptions import ValidationError
+    from django.utils.translation import gettext_lazy as _
+
+
+    def validate_even(value):
+        if value % 2 != 0:
+            raise ValidationError(
+                _("%(value)s is not an even number"),
+                params={"value": value},
+            )
+
+You can add this to a model field via the field's :attr:`~django.db.models.Field.validators`
+argument::
+
+    from django.db import models
+
+
+    class MyModel(models.Model):
+        even_field = models.IntegerField(validators=[validate_even])
+
+Because values are converted to Python before validators are run, you can even
+use the same validator with forms::
+
+    from django import forms
+
+
+    class MyForm(forms.Form):
+        even_field = forms.IntegerField(validators=[validate_even])
+
+You can also use a class with a ``__call__()`` method for more complex or
+configurable validators. :class:`RegexValidator`, for example, uses this
+technique. If a class-based validator is used in the
+:attr:`~django.db.models.Field.validators` model field option, you should make
+sure it is :ref:`serializable by the migration framework
+<migration-serializing>` by adding :ref:`deconstruct()
+<custom-deconstruct-method>` and ``__eq__()`` methods.
+
+How validators are run
+======================
+
+See the :doc:`form validation </ref/forms/validation>` for more information on
+how validators are run in forms, and :ref:`Validating objects
+<validating-objects>` for how they're run in models. Note that validators will
+not be run automatically when you save a model, but if you are using a
+:class:`~django.forms.ModelForm`, it will run your validators on any fields
+that are included in your form. See the
+:doc:`ModelForm documentation </topics/forms/modelforms>` for information on
+how model validation interacts with forms.
+
+Built-in validators
+===================
+
+The :mod:`django.core.validators` module contains a collection of callable
+validators for use with model and form fields. They're used internally but
+are available for use with your own fields, too. They can be used in addition
+to, or in lieu of custom ``field.clean()`` methods.
+
+``RegexValidator``
+------------------
+
+.. class:: RegexValidator(regex=None, message=None, code=None, inverse_match=None, flags=0)
+
+    :param regex: If not ``None``, overrides :attr:`regex`. Can be a regular
+        expression string or a pre-compiled regular expression.
+    :param message: If not ``None``, overrides :attr:`.message`.
+    :param code: If not ``None``, overrides :attr:`code`.
+    :param inverse_match: If not ``None``, overrides :attr:`inverse_match`.
+    :param flags: If not ``None``, overrides :attr:`flags`. In that case,
+        :attr:`regex` must be a regular expression string, or
+        :exc:`TypeError` is raised.
+
+    A :class:`RegexValidator` searches the provided ``value`` for a given
+    regular expression with :func:`re.search`. By default, raises a
+    :exc:`~django.core.exceptions.ValidationError` with :attr:`message` and
+    :attr:`code` if a match **is not** found. Its behavior can be inverted by
+    setting :attr:`inverse_match` to ``True``, in which case the
+    :exc:`~django.core.exceptions.ValidationError` is raised when a match
+    **is** found.
+
+    .. attribute:: regex
+
+        The regular expression pattern to search for within the provided
+        ``value``, using :func:`re.search`. This may be a string or a
+        pre-compiled regular expression created with :func:`re.compile`.
+        Defaults to the empty string, which will be found in every possible
+        ``value``.
+
+    .. attribute:: message
+
+        The error message used by
+        :exc:`~django.core.exceptions.ValidationError` if validation fails.
+        Defaults to ``"Enter a valid value"``.
+
+    .. attribute:: code
+
+        The error code used by :exc:`~django.core.exceptions.ValidationError`
+        if validation fails. Defaults to ``"invalid"``.
+
+    .. attribute:: inverse_match
+
+        The match mode for :attr:`regex`. Defaults to ``False``.
+
+    .. attribute:: flags
+
+        The :ref:`regex flags <python:contents-of-module-re>` used when
+        compiling the regular expression string :attr:`regex`. If :attr:`regex`
+        is a pre-compiled regular expression, and :attr:`flags` is overridden,
+        :exc:`TypeError` is raised. Defaults to ``0``.
+
+``EmailValidator``
+------------------
+
+.. class:: EmailValidator(message=None, code=None, allowlist=None)
+
+    :param message: If not ``None``, overrides :attr:`.message`.
+    :param code: If not ``None``, overrides :attr:`code`.
+    :param allowlist: If not ``None``, overrides :attr:`allowlist`.
+
+    An :class:`EmailValidator` ensures that a value looks like an email, and
+    raises a :exc:`~django.core.exceptions.ValidationError` with
+    :attr:`message` and :attr:`code` if it doesn't. Values longer than 320
+    characters are always considered invalid.
+
+    .. attribute:: message
+
+        The error message used by
+        :exc:`~django.core.exceptions.ValidationError` if validation fails.
+        Defaults to ``"Enter a valid email address"``.
+
+    .. attribute:: code
+
+        The error code used by :exc:`~django.core.exceptions.ValidationError`
+        if validation fails. Defaults to ``"invalid"``.
+
+    .. attribute:: allowlist
+
+        Allowlist of email domains. By default, a regular expression (the
+        ``domain_regex`` attribute) is used to validate whatever appears after
+        the ``@`` sign. However, if that string appears in the ``allowlist``,
+        this validation is bypassed. If not provided, the default ``allowlist``
+        is ``['localhost']``. Other domains that don't contain a dot won't pass
+        validation, so you'd need to add them to the ``allowlist`` as
+        necessary.
+
+    .. versionchanged:: 3.2.20
+
+        In older versions, values longer than 320 characters could be
+        considered valid.
+
+``URLValidator``
+----------------
+
+.. class:: URLValidator(schemes=None, regex=None, message=None, code=None)
+
+    A :class:`RegexValidator` subclass that ensures a value looks like a URL,
+    and raises an error code of ``'invalid'`` if it doesn't. Values longer than
+    :attr:`max_length` characters are always considered invalid.
+
+    Loopback addresses and reserved IP spaces are considered valid. Literal
+    IPv6 addresses (:rfc:`3986#section-3.2.2`) and Unicode domains are both
+    supported.
+
+    In addition to the optional arguments of its parent :class:`RegexValidator`
+    class, ``URLValidator`` accepts an extra optional attribute:
+
+    .. attribute:: schemes
+
+        URL/URI scheme list to validate against. If not provided, the default
+        list is ``['http', 'https', 'ftp', 'ftps']``. As a reference, the IANA
+        website provides a full list of `valid URI schemes`_.
+
+        .. _valid URI schemes: https://www.iana.org/assignments/uri-schemes/uri-schemes.xhtml
+
+    .. attribute:: max_length
+
+        .. versionadded:: 3.2.20
+
+        The maximum length of values that could be considered valid. Defaults
+        to 2048 characters.
+
+    .. versionchanged:: 3.2.20
+
+        In older versions, values longer than 2048 characters could be
+        considered valid.
+
+``validate_email``
+------------------
+
+.. data:: validate_email
+
+    An :class:`EmailValidator` instance without any customizations.
+
+``validate_slug``
+-----------------
+
+.. data:: validate_slug
+
+    A :class:`RegexValidator` instance that ensures a value consists of only
+    letters, numbers, underscores or hyphens.
+
+``validate_unicode_slug``
+-------------------------
+
+.. data:: validate_unicode_slug
+
+    A :class:`RegexValidator` instance that ensures a value consists of only
+    Unicode letters, numbers, underscores, or hyphens.
+
+``validate_ipv4_address``
+-------------------------
+
+.. data:: validate_ipv4_address
+
+    A :class:`RegexValidator` instance that ensures a value looks like an IPv4
+    address.
+
+``validate_ipv6_address``
+-------------------------
+
+.. data:: validate_ipv6_address
+
+    Uses ``django.utils.ipv6`` to check the validity of an IPv6 address.
+
+``validate_ipv46_address``
+--------------------------
+
+.. data:: validate_ipv46_address
+
+    Uses both ``validate_ipv4_address`` and ``validate_ipv6_address`` to
+    ensure a value is either a valid IPv4 or IPv6 address.
+
+``validate_comma_separated_integer_list``
+-----------------------------------------
+
+.. data:: validate_comma_separated_integer_list
+
+    A :class:`RegexValidator` instance that ensures a value is a
+    comma-separated list of integers.
+
+``int_list_validator``
+----------------------
+
+.. function:: int_list_validator(sep=',', message=None, code='invalid', allow_negative=False)
+
+    Returns a :class:`RegexValidator` instance that ensures a string consists
+    of integers separated by ``sep``. It allows negative integers when
+    ``allow_negative`` is ``True``.
+
+``MaxValueValidator``
+---------------------
+
+.. class:: MaxValueValidator(limit_value, message=None)
+
+    Raises a :exc:`~django.core.exceptions.ValidationError` with a code of
+    ``'max_value'`` if ``value`` is greater than ``limit_value``, which may be
+    a callable.
+
+``MinValueValidator``
+---------------------
+
+.. class:: MinValueValidator(limit_value, message=None)
+
+    Raises a :exc:`~django.core.exceptions.ValidationError` with a code of
+    ``'min_value'`` if ``value`` is less than ``limit_value``, which may be a
+    callable.
+
+``MaxLengthValidator``
+----------------------
+
+.. class:: MaxLengthValidator(limit_value, message=None)
+
+    Raises a :exc:`~django.core.exceptions.ValidationError` with a code of
+    ``'max_length'`` if the length of ``value`` is greater than
+    ``limit_value``, which may be a callable.
+
+``MinLengthValidator``
+----------------------
+
+.. class:: MinLengthValidator(limit_value, message=None)
+
+    Raises a :exc:`~django.core.exceptions.ValidationError` with a code of
+    ``'min_length'`` if the length of ``value`` is less than ``limit_value``,
+    which may be a callable.
+
+``DecimalValidator``
+--------------------
+
+.. class:: DecimalValidator(max_digits, decimal_places)
+
+    Raises :exc:`~django.core.exceptions.ValidationError` with the following
+    codes:
+
+    - ``'max_digits'`` if the number of digits is larger than ``max_digits``.
+    - ``'max_decimal_places'`` if the number of decimals is larger than
+      ``decimal_places``.
+    - ``'max_whole_digits'`` if the number of whole digits is larger than
+      the difference between ``max_digits`` and ``decimal_places``.
+
+``FileExtensionValidator``
+--------------------------
+
+.. class:: FileExtensionValidator(allowed_extensions, message, code)
+
+    Raises a :exc:`~django.core.exceptions.ValidationError` with a code of
+    ``'invalid_extension'`` if the extension of ``value.name`` (``value`` is
+    a :class:`~django.core.files.File`) isn't found in ``allowed_extensions``.
+    The extension is compared case-insensitively with ``allowed_extensions``.
+
+    .. warning::
+
+        Don't rely on validation of the file extension to determine a file's
+        type. Files can be renamed to have any extension no matter what data
+        they contain.
+
+``validate_image_file_extension``
+---------------------------------
+
+.. data:: validate_image_file_extension
+
+    Uses Pillow to ensure that ``value.name`` (``value`` is a
+    :class:`~django.core.files.File`) has `a valid image extension
+    <https://pillow.readthedocs.io/en/latest/handbook/image-file-formats.html>`_.
+
+``ProhibitNullCharactersValidator``
+-----------------------------------
+
+.. class:: ProhibitNullCharactersValidator(message=None, code=None)
+
+    Raises a :exc:`~django.core.exceptions.ValidationError` if ``str(value)``
+    contains one or more null characters (``'\x00'``).
+
+    :param message: If not ``None``, overrides :attr:`.message`.
+    :param code: If not ``None``, overrides :attr:`code`.
+
+    .. attribute:: message
+
+        The error message used by
+        :exc:`~django.core.exceptions.ValidationError` if validation fails.
+        Defaults to ``"Null characters are not allowed."``.
+
+    .. attribute:: code
+
+        The error code used by :exc:`~django.core.exceptions.ValidationError`
+        if validation fails. Defaults to ``"null_characters_not_allowed"``.
+
+``StepValueValidator``
+----------------------
+
+.. class:: StepValueValidator(limit_value, message=None, offset=None)
+
+    Raises a :exc:`~django.core.exceptions.ValidationError` with a code of
+    ``'step_size'`` if ``value`` is not an integral multiple of
+    ``limit_value``, which can be a float, integer or decimal value or a
+    callable. When ``offset`` is set, the validation occurs against
+    ``limit_value`` plus ``offset``. For example, for
+    ``StepValueValidator(3, offset=1.4)`` valid values include ``1.4``,
+    ``4.4``, ``7.4``, ``10.4``, and so on.
+
+    .. versionchanged:: 5.0
+
+        The ``offset`` argument was added.

testbed/django__django/docs/releases/0.95.txt

@@ -0,0 +1,122 @@
+=================================
+Django version 0.95 release notes
+=================================
+
+Welcome to the Django 0.95 release.
+
+This represents a significant advance in Django development since the 0.91
+release in January 2006. The details of every change in this release would be
+too extensive to list in full, but a summary is presented below.
+
+Suitability and API stability
+=============================
+
+This release is intended to provide a stable reference point for developers
+wanting to work on production-level applications that use Django.
+
+However, it's not the 1.0 release, and we'll be introducing further changes
+before 1.0. For a clear look at which areas of the framework will change (and
+which ones will *not* change) before 1.0, see the ``api-stability.txt`` file,
+which lives in the docs/ directory of the distribution.
+
+You may have a need to use some of the features that are marked as
+"subject to API change" in that document, but that's OK with us as long as it's
+OK with you, and as long as you understand APIs may change in the future.
+
+Fortunately, most of Django's core APIs won't be changing before version 1.0.
+There likely won't be as big of a change between 0.95 and 1.0 versions as there
+was between 0.91 and 0.95.
+
+Changes and new features
+========================
+
+The major changes in this release (for developers currently using the 0.91
+release) are a result of merging the 'magic-removal' branch of development.
+This branch removed a number of constraints in the way Django code had to be
+written that were a consequence of decisions made in the early days of Django,
+prior to its open-source release. It's now possible to write more natural,
+Pythonic code that works as expected, and there's less "black magic" happening
+behind the scenes.
+
+Aside from that, another main theme of this release is a dramatic increase in
+usability. We've made countless improvements in error messages, documentation,
+etc., to improve developers' quality of life.
+
+The new features and changes introduced in 0.95 include:
+
+* Django now uses a more consistent and natural filtering interface for
+  retrieving objects from the database.
+
+* User-defined models, functions and constants now appear in the module
+  namespace they were defined in. (Previously everything was magically
+  transferred to the ``django.models.*`` namespace.)
+
+* Some optional applications, such as the FlatPage, Sites and Redirects
+  apps, have been decoupled and moved into ``django.contrib``. If you don't
+  want to use these applications, you no longer have to install their
+  database tables.
+
+* Django now has support for managing database transactions.
+
+* We've added the ability to write custom authentication and authorization
+  backends for authenticating users against alternate systems, such as
+  LDAP.
+
+* We've made it easier to add custom table-level functions to models,
+  through a new "Manager" API.
+
+* It's now possible to use Django without a database. This simply means
+  that the framework no longer requires you to have a working database set
+  up just to serve dynamic pages. In other words, you can just use
+  URLconfs/views on their own. Previously, the framework required that a
+  database be configured, regardless of whether you actually used it.
+
+* It's now more explicit and natural to override ``save()`` and ``delete()``
+  methods on models, rather than needing to hook into the ``pre_save()`` and
+  ``post_save()`` method hooks.
+
+* Individual pieces of the framework now can be configured without
+  requiring the setting of an environment variable. This permits use of,
+  for example, the Django templating system inside other applications.
+
+* More and more parts of the framework have been internationalized, as
+  we've expanded internationalization (i18n) support. The Django
+  codebase, including code and templates, has now been translated, at least
+  in part, into 31 languages. From Arabic to Chinese to Hungarian to Welsh,
+  it is now possible to use Django's admin site in your native language.
+
+The number of changes required to port from 0.91-compatible code to the 0.95
+code base are significant in some cases. However, they are, for the most part,
+reasonably routine and only need to be done once. A list of the necessary
+changes is described in the `Removing The Magic`_ wiki page. There is also an
+easy checklist_ for reference when undertaking the porting operation.
+
+.. _Removing The Magic: https://code.djangoproject.com/wiki/RemovingTheMagic
+.. _checklist: https://code.djangoproject.com/wiki/MagicRemovalCheatSheet
+
+Problem reports and getting help
+================================
+
+Need help resolving a problem with Django? The documentation in the
+distribution is also available :doc:`online </index>` at the `Django website`_.
+The :doc:`FAQ </faq/index>` document is especially recommended, as it contains
+a number of issues that come up time and again.
+
+For more personalized help, the `django-users`_ mailing list is a very active
+list, with more than 2,000 subscribers who can help you solve any sort of
+Django problem. We recommend you search the archives first, though, because
+many common questions appear with some regularity, and any particular problem
+may already have been answered.
+
+Finally, for those who prefer the more immediate feedback offered by IRC,
+there's a ``#django`` channel on ``irc.libera.chat`` that is regularly
+populated by Django users and developers from around the world. Friendly people
+are usually available at any hour of the day -- to help, or just to chat.
+
+.. _Django website: https://www.djangoproject.com/
+.. _django-users: https://groups.google.com/g/django-users
+
+Thanks for using Django!
+
+The Django Team
+July 2006

testbed/django__django/docs/releases/1.0.1.txt

@@ -0,0 +1,64 @@
+==========================
+Django 1.0.1 release notes
+==========================
+
+Welcome to Django 1.0.1!
+
+This is the first "bugfix" release in the Django 1.0 series, improving
+the stability and performance of the Django 1.0 codebase. As such,
+Django 1.0.1 contains no new features (and, pursuant to :doc:`our
+compatibility policy </misc/api-stability/>`, maintains backwards
+compatibility with Django 1.0), but does contain a number of fixes
+and other improvements. Django 1.0.1 is a recommended upgrade for any
+development or deployment currently using or targeting Django 1.0.
+
+
+Fixes and improvements in Django 1.0.1
+======================================
+
+Django 1.0.1 contains over two hundred fixes to the original Django
+1.0 codebase; full details of every fix are available in `the
+history of the 1.0.X branch`_, but here are some of the
+highlights:
+
+* Several fixes in ``django.contrib.comments``, pertaining to RSS
+  feeds of comments, default ordering of comments and the XHTML and
+  internationalization of the default templates for comments.
+
+* Multiple fixes for Django's support of Oracle databases, including
+  pagination support for GIS QuerySets, more efficient slicing of
+  results and improved introspection of existing databases.
+
+* Several fixes for query support in the Django object-relational
+  mapper, including repeated setting and resetting of ordering and
+  fixes for working with ``INSERT``-only queries.
+
+* Multiple fixes for inline forms in formsets.
+
+* Multiple fixes for ``unique`` and ``unique_together`` model
+  constraints in automatically-generated forms.
+
+* Fixed support for custom callable ``upload_to`` declarations when
+  handling file uploads through automatically-generated forms.
+
+* Fixed support for sorting an admin change list based on a callable
+  attributes in ``list_display``.
+
+* A fix to the application of autoescaping for literal strings passed
+  to the ``join`` template filter. Previously, literal strings passed
+  to ``join`` were automatically escaped, contrary to :ref:`the
+  documented behavior for autoescaping and literal strings
+  <string-literals-and-automatic-escaping>`. Literal strings
+  passed to ``join`` are no longer automatically escaped, meaning you
+  must now manually escape them; this is an incompatibility if you
+  were relying on this bug, but not if you were relying on escaping
+  behaving as documented.
+
+* Improved and expanded translation files for many of the languages
+  Django supports by default.
+
+* And as always, a large number of improvements to Django's
+  documentation, including both corrections to existing documents and
+  expanded and new documentation.
+
+.. _the history of the 1.0.X branch: https://github.com/django/django/commits/stable/1.0.x

testbed/django__django/docs/releases/1.1.3.txt

@@ -0,0 +1,50 @@
+==========================
+Django 1.1.3 release notes
+==========================
+
+Welcome to Django 1.1.3!
+
+This is the third "bugfix" release in the Django 1.1 series,
+improving the stability and performance of the Django 1.1 codebase.
+
+With one exception, Django 1.1.3 maintains backwards compatibility
+with Django 1.1.2. It also contains a number of fixes and other
+improvements. Django 1.1.2 is a recommended upgrade for any
+development or deployment currently using or targeting Django 1.1.
+
+For full details on the new features, backwards incompatibilities, and
+deprecated features in the 1.1 branch, see the :doc:`/releases/1.1`.
+
+Backwards incompatible changes
+==============================
+
+Restricted filters in admin interface
+-------------------------------------
+
+The Django administrative interface, ``django.contrib.admin``, supports
+filtering of displayed lists of objects by fields on the corresponding
+models, including across database-level relationships. This is
+implemented by passing lookup arguments in the querystring portion of
+the URL, and options on the ModelAdmin class allow developers to
+specify particular fields or relationships which will generate
+automatic links for filtering.
+
+One historically-undocumented and -unofficially-supported feature has
+been the ability for a user with sufficient knowledge of a model's
+structure and the format of these lookup arguments to invent useful
+new filters on the fly by manipulating the querystring.
+
+However, it has been demonstrated that this can be abused to gain
+access to information outside of an admin user's permissions; for
+example, an attacker with access to the admin and sufficient knowledge
+of model structure and relations could construct query strings which --
+with repeated use of regular-expression lookups supported by the
+Django database API -- expose sensitive information such as users'
+password hashes.
+
+To remedy this, ``django.contrib.admin`` will now validate that
+querystring lookup arguments either specify only fields on the model
+being viewed, or cross relations which have been explicitly
+allowed by the application developer using the preexisting
+mechanism mentioned above. This is backwards-incompatible for any
+users relying on the prior ability to insert arbitrary lookups.

testbed/django__django/docs/releases/1.1.4.txt

@@ -0,0 +1,68 @@
+==========================
+Django 1.1.4 release notes
+==========================
+
+Welcome to Django 1.1.4!
+
+This is the fourth "bugfix" release in the Django 1.1 series,
+improving the stability and performance of the Django 1.1 codebase.
+
+With one exception, Django 1.1.4 maintains backwards compatibility
+with Django 1.1.3. It also contains a number of fixes and other
+improvements. Django 1.1.4 is a recommended upgrade for any
+development or deployment currently using or targeting Django 1.1.
+
+For full details on the new features, backwards incompatibilities, and
+deprecated features in the 1.1 branch, see the :doc:`/releases/1.1`.
+
+Backwards incompatible changes
+==============================
+
+CSRF exception for AJAX requests
+--------------------------------
+
+Django includes a CSRF-protection mechanism, which makes use of a
+token inserted into outgoing forms. Middleware then checks for the
+token's presence on form submission, and validates it.
+
+Prior to Django 1.2.5, our CSRF protection made an exception for AJAX
+requests, on the following basis:
+
+* Many AJAX toolkits add an X-Requested-With header when using
+  XMLHttpRequest.
+
+* Browsers have strict same-origin policies regarding
+  XMLHttpRequest.
+
+* In the context of a browser, the only way that a custom header
+  of this nature can be added is with XMLHttpRequest.
+
+Therefore, for ease of use, we did not apply CSRF checks to requests
+that appeared to be AJAX on the basis of the X-Requested-With header.
+The Ruby on Rails web framework had a similar exemption.
+
+Recently, engineers at Google made members of the Ruby on Rails
+development team aware of a combination of browser plugins and
+redirects which can allow an attacker to provide custom HTTP headers
+on a request to any website. This can allow a forged request to appear
+to be an AJAX request, thereby defeating CSRF protection which trusts
+the same-origin nature of AJAX requests.
+
+Michael Koziarski of the Rails team brought this to our attention, and
+we were able to produce a proof-of-concept demonstrating the same
+vulnerability in Django's CSRF handling.
+
+To remedy this, Django will now apply full CSRF validation to all
+requests, regardless of apparent AJAX origin. This is technically
+backwards-incompatible, but the security risks have been judged to
+outweigh the compatibility concerns in this case.
+
+Additionally, Django will now accept the CSRF token in the custom HTTP
+header X-CSRFTOKEN, as well as in the form submission itself, for ease
+of use with popular JavaScript toolkits which allow insertion of
+custom headers into all AJAX requests.
+
+Please see the :ref:`CSRF docs for example jQuery code <csrf-ajax>`
+that demonstrates this technique, ensuring that you are looking at the
+documentation for your version of Django, as the exact code necessary
+is different for some older versions of Django.

testbed/django__django/docs/releases/1.10.1.txt

@@ -0,0 +1,86 @@
+===========================
+Django 1.10.1 release notes
+===========================
+
+*September 1, 2016*
+
+Django 1.10.1 fixes several bugs in 1.10.
+
+Bugfixes
+========
+
+* Fixed a crash in MySQL connections where ``SELECT @@SQL_AUTO_IS_NULL``
+  doesn't return a result (:ticket:`26991`).
+
+* Allowed ``User.is_authenticated`` and ``User.is_anonymous`` properties to be
+  compared using ``==``, ``!=``, and ``|`` (:ticket:`26988`, :ticket:`27154`).
+
+* Removed the broken ``BaseCommand.usage()`` method which was for
+  ``optparse`` support (:ticket:`27000`).
+
+* Fixed a checks framework crash with an empty ``Meta.default_permissions``
+  (:ticket:`26997`).
+
+* Fixed a regression in the number of queries when using ``RadioSelect`` with a
+  ``ModelChoiceField`` form field (:ticket:`27001`).
+
+* Fixed a crash if ``request.META['CONTENT_LENGTH']`` is an empty string
+  (:ticket:`27005`).
+
+* Fixed the ``isnull`` lookup on a ``ForeignKey`` with its ``to_field``
+  pointing to a ``CharField`` or pointing to a ``CharField`` defined with
+  ``primary_key=True`` (:ticket:`26983`).
+
+* Prevented the ``migrate`` command from raising
+  ``InconsistentMigrationHistory`` in the presence of unapplied squashed
+  migrations (:ticket:`27004`).
+
+* Fixed a regression in ``Client.force_login()`` which required specifying a
+  ``backend`` rather than automatically using the first one if multiple
+  backends are configured (:ticket:`27027`).
+
+* Made ``QuerySet.bulk_create()`` properly initialize model instances on
+  backends, such as PostgreSQL, that support returning the IDs of the created
+  records so that many-to-many relationships can be used on the new objects
+  (:ticket:`27026`).
+
+* Fixed crash of ``django.views.static.serve()`` with ``show_indexes`` enabled
+  (:ticket:`26973`).
+
+* Fixed ``ClearableFileInput`` to avoid the ``required`` HTML attribute when
+  initial data exists (:ticket:`27037`).
+
+* Fixed annotations with database functions when combined with lookups on
+  PostGIS (:ticket:`27014`).
+
+* Reallowed the ``{% for %}`` tag to unpack any iterable (:ticket:`27058`).
+
+* Made ``makemigrations`` skip inconsistent history checks on non-default
+  databases if database routers aren't in use or if no apps can be migrated
+  to the database (:ticket:`27054`, :ticket:`27110`, :ticket:`27142`).
+
+* Removed duplicated managers in ``Model._meta.managers`` (:ticket:`27073`).
+
+* Fixed ``contrib.admindocs`` crash when a view is in a class, such as some of
+  the admin views (:ticket:`27018`).
+
+* Reverted a few admin checks that checked ``field.many_to_many`` back to
+  ``isinstance(field, models.ManyToManyField)`` since it turned out the checks
+  weren't suitable to be generalized like that (:ticket:`26998`).
+
+* Added the database alias to the ``InconsistentMigrationHistory`` message
+  raised by ``makemigrations`` and ``migrate`` (:ticket:`27089`).
+
+* Fixed the creation of ``ContentType`` and ``Permission`` objects for models
+  of applications without migrations when calling the ``migrate`` command with
+  no migrations to apply (:ticket:`27044`).
+
+* Included the already applied migration state changes in the ``Apps`` instance
+  provided to the ``pre_migrate`` signal receivers to allow ``ContentType``
+  renaming to be performed on model rename (:ticket:`27100`).
+
+* Reallowed subclassing ``UserCreationForm`` without ``USERNAME_FIELD`` in
+  ``Meta.fields`` (:ticket:`27111`).
+
+* Fixed a regression in model forms where model fields with a ``default`` that
+  didn't appear in POST data no longer used the ``default`` (:ticket:`27039`).

testbed/django__django/docs/releases/1.10.2.txt

@@ -0,0 +1,30 @@
+===========================
+Django 1.10.2 release notes
+===========================
+
+*October 1, 2016*
+
+Django 1.10.2 fixes several bugs in 1.10.1.
+
+Bugfixes
+========
+
+* Fixed a crash in MySQL database validation where ``SELECT @@sql_mode``
+  doesn't return a result (:ticket:`27180`).
+
+* Allowed combining ``contrib.postgres.search.SearchQuery`` with more than one
+  ``&`` or ``|`` operators (:ticket:`27143`).
+
+* Disabled system check for URL patterns beginning with a '/' when
+  ``APPEND_SLASH=False`` (:ticket:`27238`).
+
+* Fixed model form ``default`` fallback for ``CheckboxSelectMultiple``,
+  ``MultiWidget``, ``FileInput``, ``SplitDateTimeWidget``, ``SelectDateWidget``,
+  and ``SplitArrayWidget`` (:ticket:`27186`). Custom widgets affected by this
+  issue should implement :meth:`~django.forms.Widget.value_omitted_from_data`.
+
+* Fixed a crash in ``runserver`` logging during a "Broken pipe" error
+  (:ticket:`27271`).
+
+* Fixed a regression where unchanged localized date/time fields were listed as
+  changed in the admin's model history messages (:ticket:`27302`).

testbed/django__django/docs/releases/1.10.4.txt

@@ -0,0 +1,31 @@
+===========================
+Django 1.10.4 release notes
+===========================
+
+*December 1, 2016*
+
+Django 1.10.4 fixes several bugs in 1.10.3.
+
+Bugfixes
+========
+
+* Quoted the Oracle test user's password in queries to fix the "ORA-00922:
+  missing or invalid option" error when the password starts with a number or
+  special character (:ticket:`27420`).
+
+* Fixed incorrect ``app_label`` / ``model_name`` arguments for
+  ``allow_migrate()`` in ``makemigrations`` migration consistency checks
+  (:ticket:`27461`).
+
+* Made ``Model.delete(keep_parents=True)`` preserve parent reverse
+  relationships in multi-table inheritance (:ticket:`27407`).
+
+* Fixed a ``QuerySet.update()`` crash on SQLite when updating a
+  ``DateTimeField`` with an ``F()`` expression and a ``timedelta``
+  (:ticket:`27544`).
+
+* Prevented ``LocaleMiddleware`` from redirecting on URLs that should return
+  404 when using ``prefix_default_language=False`` (:ticket:`27402`).
+
+* Prevented an unnecessary index from being created on an InnoDB ``ForeignKey``
+  when the field was added after the model was created (:ticket:`27558`).

testbed/django__django/docs/releases/1.10.5.txt

@@ -0,0 +1,22 @@
+===========================
+Django 1.10.5 release notes
+===========================
+
+*January 4, 2017*
+
+Django 1.10.5 fixes several bugs in 1.10.4.
+
+Bugfixes
+========
+
+* Fixed a crash in the debug view if ``request.user`` can't be retrieved, such
+  as if the database is unavailable (:ticket:`27567`).
+
+* Fixed occasional missing plural forms in ``JavaScriptCatalog``
+  (:ticket:`27418`).
+
+* Fixed a regression in the ``timesince`` and ``timeuntil`` filters that caused
+  incorrect results for dates in a leap year (:ticket:`27637`).
+
+* Fixed a regression where ``collectstatic`` overwrote newer files in remote
+  storages (:ticket:`27658`).

testbed/django__django/docs/releases/1.10.6.txt

@@ -0,0 +1,25 @@
+===========================
+Django 1.10.6 release notes
+===========================
+
+*March 1, 2017*
+
+Django 1.10.6 fixes several bugs in 1.10.5.
+
+Bugfixes
+========
+
+* Fixed ``ClearableFileInput``’s "Clear" checkbox on model form fields where
+  the model field has a ``default`` (:ticket:`27805`).
+
+* Fixed ``RequestDataTooBig`` and ``TooManyFieldsSent`` exceptions crashing
+  rather than generating a bad request response (:ticket:`27820`).
+
+* Fixed a crash on Oracle and PostgreSQL when subtracting ``DurationField``
+  or ``IntegerField`` from ``DateField`` (:ticket:`27828`).
+
+* Fixed query expression date subtraction accuracy on PostgreSQL for
+  differences larger than a month (:ticket:`27856`).
+
+* Fixed a ``GDALException`` raised by ``GDALClose`` on GDAL ≥ 2.0
+  (:ticket:`27479`).

testbed/django__django/docs/releases/1.10.7.txt

@@ -0,0 +1,39 @@
+===========================
+Django 1.10.7 release notes
+===========================
+
+*April 4, 2017*
+
+Django 1.10.7 fixes two security issues and a bug in 1.10.6.
+
+CVE-2017-7233: Open redirect and possible XSS attack via user-supplied numeric redirect URLs
+============================================================================================
+
+Django relies on user input in some cases  (e.g.
+``django.contrib.auth.views.login()`` and :doc:`i18n </topics/i18n/index>`)
+to redirect the user to an "on success" URL. The security check for these
+redirects (namely ``django.utils.http.is_safe_url()``) considered some numeric
+URLs (e.g. ``http:999999999``) "safe" when they shouldn't be.
+
+Also, if a developer relies on ``is_safe_url()`` to provide safe redirect
+targets and puts such a URL into a link, they could suffer from an XSS attack.
+
+CVE-2017-7234: Open redirect vulnerability in ``django.views.static.serve()``
+=============================================================================
+
+A maliciously crafted URL to a Django site using the
+:func:`~django.views.static.serve` view could redirect to any other domain. The
+view no longer does any redirects as they don't provide any known, useful
+functionality.
+
+Note, however, that this view has always carried a warning that it is not
+hardened for production use and should be used only as a development aid.
+
+Bugfixes
+========
+
+* Made admin's ``RelatedFieldWidgetWrapper`` use the wrapped widget's
+  ``value_omitted_from_data()`` method (:ticket:`27905`).
+
+* Fixed model form ``default`` fallback for ``SelectMultiple``
+  (:ticket:`27993`).

testbed/django__django/docs/releases/1.10.8.txt

@@ -0,0 +1,16 @@
+===========================
+Django 1.10.8 release notes
+===========================
+
+*September 5, 2017*
+
+Django 1.10.8 fixes a security issue in 1.10.7.
+
+CVE-2017-12794: Possible XSS in traceback section of technical 500 debug page
+=============================================================================
+
+In older versions, HTML autoescaping was disabled in a portion of the template
+for the technical 500 debug page. Given the right circumstances, this allowed
+a cross-site scripting attack. This vulnerability shouldn't affect most
+production sites since you shouldn't run with ``DEBUG = True`` (which makes
+this page accessible) in your production settings.

testbed/django__django/docs/releases/1.11.10.txt

@@ -0,0 +1,39 @@
+============================
+Django 1.11.10 release notes
+============================
+
+*February 1, 2018*
+
+Django 1.11.10 fixes a security issue and several bugs in 1.11.9.
+
+CVE-2018-6188: Information leakage in ``AuthenticationForm``
+============================================================
+
+A regression in Django 1.11.8 made
+:class:`~django.contrib.auth.forms.AuthenticationForm` run its
+``confirm_login_allowed()`` method even if an incorrect password is entered.
+This can leak information about a user, depending on what messages
+``confirm_login_allowed()`` raises. If ``confirm_login_allowed()`` isn't
+overridden, an attacker enter an arbitrary username and see if that user has
+been set to ``is_active=False``. If ``confirm_login_allowed()`` is overridden,
+more sensitive details could be leaked.
+
+This issue is fixed with the caveat that ``AuthenticationForm`` can no longer
+raise the "This account is inactive." error if the authentication backend
+rejects inactive users (the default authentication backend, ``ModelBackend``,
+has done that since Django 1.10). This issue will be revisited for Django 2.1
+as a fix to address the caveat will likely be too invasive for inclusion in
+older versions.
+
+Bugfixes
+========
+
+* Fixed incorrect foreign key nullification if a model has two foreign keys to
+  the same model and a target model is deleted (:ticket:`29016`).
+
+* Fixed a regression where ``contrib.auth.authenticate()`` crashes if an
+  authentication backend doesn't accept ``request`` and a later one does
+  (:ticket:`29071`).
+
+* Fixed crash when entering an invalid uuid in ``ModelAdmin.raw_id_fields``
+  (:ticket:`29094`).

testbed/django__django/docs/releases/1.11.11.txt

@@ -0,0 +1,30 @@
+============================
+Django 1.11.11 release notes
+============================
+
+*March 6, 2018*
+
+Django 1.11.11 fixes two security issues in 1.11.10.
+
+CVE-2018-7536: Denial-of-service possibility in ``urlize`` and ``urlizetrunc`` template filters
+===============================================================================================
+
+The ``django.utils.html.urlize()`` function was extremely slow to evaluate
+certain inputs due to catastrophic backtracking vulnerabilities in two regular
+expressions. The ``urlize()`` function is used to implement the ``urlize`` and
+``urlizetrunc`` template filters, which were thus vulnerable.
+
+The problematic regular expressions are replaced with parsing logic that
+behaves similarly.
+
+CVE-2018-7537: Denial-of-service possibility in ``truncatechars_html`` and ``truncatewords_html`` template filters
+==================================================================================================================
+
+If ``django.utils.text.Truncator``'s ``chars()`` and ``words()`` methods were
+passed the ``html=True`` argument, they were extremely slow to evaluate certain
+inputs due to a catastrophic backtracking vulnerability in a regular
+expression. The ``chars()`` and ``words()`` methods are used to implement the
+``truncatechars_html`` and ``truncatewords_html`` template filters, which were
+thus vulnerable.
+
+The backtracking problem in the regular expression is fixed.

testbed/django__django/docs/releases/1.11.12.txt

@@ -0,0 +1,18 @@
+============================
+Django 1.11.12 release notes
+============================
+
+*April 2, 2018*
+
+Django 1.11.12 fixes two bugs in 1.11.11.
+
+Bugfixes
+========
+
+* Fixed a regression in Django 1.11.8 where combining two annotated
+  ``values_list()`` querysets with ``union()``, ``difference()``, or
+  ``intersection()`` crashed due to mismatching columns (:ticket:`29229`).
+
+* Fixed a regression in Django 1.11 where an empty choice could be initially
+  selected for the ``SelectMultiple`` and ``CheckboxSelectMultiple`` widgets
+  (:ticket:`29273`).

testbed/django__django/docs/releases/1.11.14.txt

@@ -0,0 +1,16 @@
+============================
+Django 1.11.14 release notes
+============================
+
+*July 2, 2018*
+
+Django 1.11.14 fixes several bugs in 1.11.13.
+
+Bugfixes
+========
+
+* Fixed ``WKBWriter.write()`` and ``write_hex()`` for empty polygons on
+  GEOS 3.6.1+ (:ticket:`29460`).
+
+* Fixed a regression in Django 1.10 that could result in large memory usage
+  when making edits using ``ModelAdmin.list_editable`` (:ticket:`28462`).

testbed/django__django/docs/releases/1.11.15.txt

@@ -0,0 +1,20 @@
+============================
+Django 1.11.15 release notes
+============================
+
+*August 1, 2018*
+
+Django 1.11.15 fixes a security issue in 1.11.14.
+
+CVE-2018-14574: Open redirect possibility in ``CommonMiddleware``
+=================================================================
+
+If the :class:`~django.middleware.common.CommonMiddleware` and the
+:setting:`APPEND_SLASH` setting are both enabled, and if the project has a
+URL pattern that accepts any path ending in a slash (many content management
+systems have such a pattern), then a request to a maliciously crafted URL of
+that site could lead to a redirect to another site, enabling phishing and other
+attacks.
+
+``CommonMiddleware`` now escapes leading slashes to prevent redirects to other
+domains.

testbed/django__django/docs/releases/1.11.16.txt

@@ -0,0 +1,13 @@
+============================
+Django 1.11.16 release notes
+============================
+
+*October 1, 2018*
+
+Django 1.11.16 fixes a data loss bug in 1.11.15.
+
+Bugfixes
+========
+
+* Fixed a race condition in ``QuerySet.update_or_create()`` that could result
+  in data loss (:ticket:`29499`).

testbed/django__django/docs/releases/1.11.17.txt

@@ -0,0 +1,15 @@
+============================
+Django 1.11.17 release notes
+============================
+
+*December 3, 2018*
+
+Django 1.11.17 fixes several bugs in 1.11.16 and adds compatibility with
+Python 3.7.
+
+Bugfixes
+========
+
+* Prevented repetitive calls to ``geos_version_tuple()`` in the ``WKBWriter``
+  class in an attempt to fix a random crash involving ``LooseVersion`` since
+  Django 1.11.14 (:ticket:`29959`).

testbed/django__django/docs/releases/1.11.18.txt

@@ -0,0 +1,18 @@
+============================
+Django 1.11.18 release notes
+============================
+
+*January 4, 2019*
+
+Django 1.11.18 fixes a security issue in 1.11.17.
+
+CVE-2019-3498: Content spoofing possibility in the default 404 page
+-------------------------------------------------------------------
+
+An attacker could craft a malicious URL that could make spoofed content appear
+on the default page generated by the ``django.views.defaults.page_not_found()``
+view.
+
+The URL path is no longer displayed in the default 404 template and the
+``request_path`` context variable is now quoted to fix the issue for custom
+templates that use the path.

testbed/django__django/docs/releases/1.11.19.txt

@@ -0,0 +1,18 @@
+============================
+Django 1.11.19 release notes
+============================
+
+*February 11, 2019*
+
+Django 1.11.19 fixes a security issue in 1.11.18.
+
+CVE-2019-6975: Memory exhaustion in ``django.utils.numberformat.format()``
+--------------------------------------------------------------------------
+
+If ``django.utils.numberformat.format()`` -- used by ``contrib.admin`` as well
+as the ``floatformat``, ``filesizeformat``, and ``intcomma`` templates filters
+-- received a ``Decimal`` with a large number of digits or a large exponent, it
+could lead to significant memory usage due to a call to ``'{:f}'.format()``.
+
+To avoid this, decimals with more than 200 digits are now formatted using
+scientific notation.

testbed/django__django/docs/releases/1.11.2.txt

@@ -0,0 +1,64 @@
+===========================
+Django 1.11.2 release notes
+===========================
+
+*June 1, 2017*
+
+Django 1.11.2 adds a minor feature and fixes several bugs in 1.11.1. Also, the
+latest string translations from Transifex are incorporated.
+
+Minor feature
+=============
+
+The new ``LiveServerTestCase.port`` attribute reallows the use case of binding
+to a specific port following the :ref:`bind to port zero
+<liveservertestcase-port-zero-change>` change in Django 1.11.
+
+Bugfixes
+========
+
+* Added detection for GDAL 2.1 and 2.0, and removed detection for unsupported
+  versions 1.7 and 1.8 (:ticket:`28181`).
+
+* Changed ``contrib.gis`` to raise ``ImproperlyConfigured`` rather than
+  ``GDALException`` if ``gdal`` isn't installed, to allow third-party apps to
+  catch that exception (:ticket:`28178`).
+
+* Fixed ``django.utils.http.is_safe_url()`` crash on invalid IPv6 URLs
+  (:ticket:`28142`).
+
+* Fixed regression causing pickling of model fields to crash (:ticket:`28188`).
+
+* Fixed ``django.contrib.auth.authenticate()`` when multiple authentication
+  backends don't accept a positional ``request`` argument (:ticket:`28207`).
+
+* Fixed introspection of index field ordering on PostgreSQL (:ticket:`28197`).
+
+* Fixed a regression where ``Model._state.adding`` wasn't set correctly on
+  multi-table inheritance parent models after saving a child model
+  (:ticket:`28210`).
+
+* Allowed ``DjangoJSONEncoder`` to serialize
+  ``django.utils.deprecation.CallableBool`` (:ticket:`28230`).
+
+* Relaxed the validation added in Django 1.11 of the fields in the ``defaults``
+  argument of ``QuerySet.get_or_create()`` and ``update_or_create()`` to
+  reallow settable model properties (:ticket:`28222`).
+
+* Fixed ``MultipleObjectMixin.paginate_queryset()`` crash on Python 2 if the
+  ``InvalidPage`` message contains non-ASCII (:ticket:`28204`).
+
+* Prevented ``Subquery`` from adding an unnecessary ``CAST`` which resulted in
+  invalid SQL (:ticket:`28199`).
+
+* Corrected detection of GDAL 2.1 on Windows (:ticket:`28181`).
+
+* Made date-based generic views return a 404 rather than crash when given an
+  out of range date (:ticket:`28209`).
+
+* Fixed a regression where ``file_move_safe()`` crashed when moving files to a
+  CIFS mount (:ticket:`28170`).
+
+* Moved the ``ImageField`` file extension validation added in Django 1.11 from
+  the model field to the form field to reallow the use case of storing images
+  without an extension (:ticket:`28242`).

testbed/django__django/docs/releases/1.11.20.txt

@@ -0,0 +1,12 @@
+============================
+Django 1.11.20 release notes
+============================
+
+*February 11, 2019*
+
+Django 1.11.20 fixes a packaging error in 1.11.19.
+
+Bugfixes
+========
+
+* Corrected packaging error from 1.11.19 (:ticket:`30175`).

testbed/django__django/docs/releases/1.11.21.txt

@@ -0,0 +1,21 @@
+============================
+Django 1.11.21 release notes
+============================
+
+*June 3, 2019*
+
+Django 1.11.21 fixes a security issue in 1.11.20.
+
+CVE-2019-12308: AdminURLFieldWidget XSS
+---------------------------------------
+
+The clickable "Current URL" link generated by ``AdminURLFieldWidget`` displayed
+the provided value without validating it as a safe URL. Thus, an unvalidated
+value stored in the database, or a value provided as a URL query parameter
+payload, could result in an clickable JavaScript link.
+
+``AdminURLFieldWidget`` now validates the provided value using
+:class:`~django.core.validators.URLValidator` before displaying the clickable
+link. You may customize the validator by passing a ``validator_class`` kwarg to
+``AdminURLFieldWidget.__init__()``, e.g. when using
+:attr:`~django.contrib.admin.ModelAdmin.formfield_overrides`.

testbed/django__django/docs/releases/1.11.22.txt

@@ -0,0 +1,27 @@
+============================
+Django 1.11.22 release notes
+============================
+
+*July 1, 2019*
+
+Django 1.11.22 fixes a security issue in 1.11.21.
+
+CVE-2019-12781: Incorrect HTTP detection with reverse-proxy connecting via HTTPS
+--------------------------------------------------------------------------------
+
+When deployed behind a reverse-proxy connecting to Django via HTTPS,
+:attr:`django.http.HttpRequest.scheme` would incorrectly detect client
+requests made via HTTP as using HTTPS. This entails incorrect results for
+:meth:`~django.http.HttpRequest.is_secure`, and
+:meth:`~django.http.HttpRequest.build_absolute_uri`, and that HTTP
+requests would not be redirected to HTTPS in accordance with
+:setting:`SECURE_SSL_REDIRECT`.
+
+``HttpRequest.scheme`` now respects :setting:`SECURE_PROXY_SSL_HEADER`, if it
+is configured, and the appropriate header is set on the request, for both HTTP
+and HTTPS requests.
+
+If you deploy Django behind a reverse-proxy that forwards HTTP requests, and
+that connects to Django via HTTPS, be sure to verify that your application
+correctly handles code paths relying on ``scheme``, ``is_secure()``,
+``build_absolute_uri()``, and ``SECURE_SSL_REDIRECT``.

testbed/django__django/docs/releases/1.11.23.txt

@@ -0,0 +1,57 @@
+============================
+Django 1.11.23 release notes
+============================
+
+*August 1, 2019*
+
+Django 1.11.23 fixes security issues in 1.11.22.
+
+CVE-2019-14232: Denial-of-service possibility in ``django.utils.text.Truncator``
+================================================================================
+
+If ``django.utils.text.Truncator``'s ``chars()`` and ``words()`` methods
+were passed the ``html=True`` argument, they were extremely slow to evaluate
+certain inputs due to a catastrophic backtracking vulnerability in a regular
+expression. The ``chars()`` and ``words()`` methods are used to implement the
+:tfilter:`truncatechars_html` and :tfilter:`truncatewords_html` template
+filters, which were thus vulnerable.
+
+The regular expressions used by ``Truncator`` have been simplified in order to
+avoid potential backtracking issues. As a consequence, trailing punctuation may
+now at times be included in the truncated output.
+
+CVE-2019-14233: Denial-of-service possibility in ``strip_tags()``
+=================================================================
+
+Due to the behavior of the underlying ``HTMLParser``,
+:func:`django.utils.html.strip_tags` would be extremely slow to evaluate
+certain inputs containing large sequences of nested incomplete HTML entities.
+The ``strip_tags()`` method is used to implement the corresponding
+:tfilter:`striptags` template filter, which was thus also vulnerable.
+
+``strip_tags()`` now avoids recursive calls to ``HTMLParser`` when progress
+removing tags, but necessarily incomplete HTML entities, stops being made.
+
+Remember that absolutely NO guarantee is provided about the results of
+``strip_tags()`` being HTML safe. So NEVER mark safe the result of a
+``strip_tags()`` call without escaping it first, for example with
+:func:`django.utils.html.escape`.
+
+CVE-2019-14234: SQL injection possibility in key and index lookups for ``JSONField``/``HStoreField``
+====================================================================================================
+
+:lookup:`Key and index lookups <jsonfield.key>` for
+``django.contrib.postgres.fields.JSONField`` and :lookup:`key lookups
+<hstorefield.key>` for :class:`~django.contrib.postgres.fields.HStoreField`
+were subject to SQL injection, using a suitably crafted dictionary, with
+dictionary expansion, as the ``**kwargs`` passed to ``QuerySet.filter()``.
+
+CVE-2019-14235: Potential memory exhaustion in ``django.utils.encoding.uri_to_iri()``
+=====================================================================================
+
+If passed certain inputs, :func:`django.utils.encoding.uri_to_iri` could lead
+to significant memory usage due to excessive recursion when re-percent-encoding
+invalid UTF-8 octet sequences.
+
+``uri_to_iri()`` now avoids recursion when re-percent-encoding invalid UTF-8
+octet sequences.

testbed/django__django/docs/releases/1.11.24.txt

@@ -0,0 +1,15 @@
+============================
+Django 1.11.24 release notes
+============================
+
+*September 2, 2019*
+
+Django 1.11.24 fixes a regression in 1.11.23.
+
+Bugfixes
+========
+
+* Fixed crash of ``KeyTransform()`` for
+  ``django.contrib.postgres.fields.JSONField`` and
+  :class:`~django.contrib.postgres.fields.HStoreField` when using on
+  expressions with params (:ticket:`30672`).

testbed/django__django/docs/releases/1.11.25.txt

@@ -0,0 +1,14 @@
+============================
+Django 1.11.25 release notes
+============================
+
+*October 1, 2019*
+
+Django 1.11.25 fixes a regression in 1.11.23.
+
+Bugfixes
+========
+
+* Fixed a crash when filtering with a ``Subquery()`` annotation of a queryset
+  containing ``django.contrib.postgres.fields.JSONField`` or
+  :class:`~django.contrib.postgres.fields.HStoreField` (:ticket:`30769`).

testbed/django__django/docs/releases/1.11.26.txt

@@ -0,0 +1,15 @@
+============================
+Django 1.11.26 release notes
+============================
+
+*November 4, 2019*
+
+Django 1.11.26 fixes a regression in 1.11.25.
+
+Bugfixes
+========
+
+* Fixed a crash when using a ``contains``, ``contained_by``, ``has_key``,
+  ``has_keys``, or ``has_any_keys`` lookup on
+  ``django.contrib.postgres.fields.JSONField``, if the right or left hand
+  side of an expression is a key transform (:ticket:`30826`).

testbed/django__django/docs/releases/1.11.27.txt

@@ -0,0 +1,31 @@
+============================
+Django 1.11.27 release notes
+============================
+
+*December 18, 2019*
+
+Django 1.11.27 fixes a security issue and a data loss bug in 1.11.26.
+
+CVE-2019-19844: Potential account hijack via password reset form
+================================================================
+
+By submitting a suitably crafted email address making use of Unicode
+characters, that compared equal to an existing user email when lower-cased for
+comparison, an attacker could be sent a password reset token for the matched
+account.
+
+In order to avoid this vulnerability, password reset requests now compare the
+submitted email using the stricter, recommended algorithm for case-insensitive
+comparison of two identifiers from `Unicode Technical Report 36, section
+2.11.2(B)(2)`__. Upon a match, the email containing the reset token will be
+sent to the email address on record rather than the submitted address.
+
+.. __: https://www.unicode.org/reports/tr36/#Recommendations_General
+
+Bugfixes
+========
+
+* Fixed a data loss possibility in
+  :class:`~django.contrib.postgres.forms.SplitArrayField`. When using with
+  ``ArrayField(BooleanField())``, all values after the first ``True`` value
+  were marked as checked instead of preserving passed values (:ticket:`31073`).

testbed/django__django/docs/releases/1.11.28.txt

@@ -0,0 +1,13 @@
+============================
+Django 1.11.28 release notes
+============================
+
+*February 3, 2020*
+
+Django 1.11.28 fixes a security issue in 1.11.27.
+
+CVE-2020-7471: Potential SQL injection via ``StringAgg(delimiter)``
+===================================================================
+
+:class:`~django.contrib.postgres.aggregates.StringAgg` aggregation function was
+subject to SQL injection, using a suitably crafted ``delimiter``.

testbed/django__django/docs/releases/1.11.29.txt

@@ -0,0 +1,13 @@
+============================
+Django 1.11.29 release notes
+============================
+
+*March 4, 2020*
+
+Django 1.11.29 fixes a security issue in 1.11.28.
+
+CVE-2020-9402: Potential SQL injection via ``tolerance`` parameter in GIS functions and aggregates on Oracle
+============================================================================================================
+
+GIS functions and aggregates on Oracle were subject to SQL injection,
+using a suitably crafted ``tolerance``.