September 2, 2014
\nWelcome to Django 1.7!
\nThese release notes cover the new features, as well as\nsome backwards incompatible changes you’ll\nwant to be aware of when upgrading from Django 1.6 or older versions. We’ve\nbegun the deprecation process for some features, and some features have reached the end of their\ndeprecation process and have been removed.
\nDjango 1.7 requires Python 2.7, 3.2, 3.3, or 3.4. We highly recommend and\nonly officially support the latest release of each series.
\nThe Django 1.6 series is the last to support Python 2.6. Django 1.7 is the\nfirst release to support Python 3.4.
\nThis change should affect only a small number of Django users, as most\noperating-system vendors today are shipping Python 2.7 or newer as their\ndefault version. If you’re still using Python 2.6, however, you’ll need to\nstick to Django 1.6 until you can upgrade your Python version. Per our\nsupport policy, Django 1.6 will continue to\nreceive security support until the release of Django 1.8.
\nDjango now has built-in support for schema migrations. It allows models to be\nupdated, changed, and deleted by creating migration files that represent the\nmodel changes and which can be run on any development, staging or production\ndatabase.
\nMigrations are covered in their own documentation,\nbut a few of the key features are:
\nsyncdb has been deprecated and replaced by migrate. Don’t worry -\ncalls to syncdb will still work as before.
A new makemigrations command provides an easy way to autodetect changes\nto your models and make migrations for them.
django.db.models.signals.pre_syncdb and\ndjango.db.models.signals.post_syncdb have been deprecated,\nto be replaced by pre_migrate and\npost_migrate respectively. These\nnew signals have slightly different arguments. Check the\ndocumentation for details.
The allow_syncdb method on database routers is now called\nallow_migrate, but still performs the same function. Routers with\nallow_syncdb methods will still work, but that method name is deprecated\nand you should change it as soon as possible (nothing more than renaming is\nrequired).
initial_data fixtures are no longer loaded for apps with migrations; if\nyou want to load initial data for an app, we suggest you create a migration\nfor your application and define a\nRunPython or\nRunSQL operation in the\noperations section of the migration.
Test rollback behavior is different for apps with migrations; in particular,\nDjango will no longer emulate rollbacks on non-transactional databases or\ninside TransactionTestCase unless specifically requested.
It is not advised to have apps without migrations depend on (have a\nForeignKey or\nManyToManyField to) apps with migrations.
Historically, Django applications were tightly linked to models. A singleton\nknown as the “app cache” dealt with both installed applications and models.\nThe models module was used as an identifier for applications in many APIs.
\nAs the concept of Django applications matured, this\ncode showed some shortcomings. It has been refactored into an “app registry”\nwhere models modules no longer have a central role and where it’s possible to\nattach configuration data to applications.
\nImprovements thus far include:
\nApplications can run code at startup, before Django does anything else, with\nthe ready() method of their configuration.
Application labels are assigned correctly to models even when they’re\ndefined outside of models.py. You don’t have to set\napp_label explicitly any more.
It is possible to omit models.py entirely if an application doesn’t\nhave any models.
Applications can be relabeled with the label\nattribute of application configurations, to work around label conflicts.
The name of applications can be customized in the admin with the\nverbose_name of application configurations.
The admin automatically calls autodiscover()\nwhen Django starts. You can consequently remove this line from your\nURLconf.
Django imports all application configurations and models as soon as it\nstarts, through a deterministic and straightforward process. This should\nmake it easier to diagnose import issues such as import loops.
To help power both schema migrations and to enable easier addition of\ncomposite keys in future releases of Django, the\nField API now has a new required method:\ndeconstruct().
This method takes no arguments, and returns a tuple of four items:
\nname: The field’s attribute name on its parent model, or None if it\nis not part of a model
path: A dotted, Python path to the class of this field, including the\nclass name.
args: Positional arguments, as a list
kwargs: Keyword arguments, as a dict
These four values allow any field to be serialized into a file, as well as\nallowing the field to be copied safely, both essential parts of these new\nfeatures.
\nThis change should not affect you unless you write custom Field subclasses;\nif you do, you may need to reimplement the deconstruct() method if your\nsubclass changes the method signature of __init__ in any way. If your\nfield just inherits from a built-in Django field and doesn’t override\n__init__, no changes are necessary.
If you do need to override deconstruct(), a good place to start is the\nbuilt-in Django fields (django/db/models/fields/__init__.py) as several\nfields, including DecimalField and DateField, override it and show how\nto call the method on the superclass and simply add or remove extra arguments.
This also means that all arguments to fields must themselves be serializable;\nto see what we consider serializable, and to find out how to make your own\nclasses serializable, read the\nmigration serialization documentation.
\nQuerySet methods from the ManagerLink to this heading#Historically, the recommended way to make reusable model queries was to create\nmethods on a custom Manager class. The problem with this approach was that\nafter the first method call, you’d get back a QuerySet instance and\ncouldn’t call additional custom manager methods.
Though not documented, it was common to work around this issue by creating a\ncustom QuerySet so that custom methods could be chained; but the solution\nhad a number of drawbacks:
The custom QuerySet and its custom methods were lost after the first\ncall to values() or values_list().
Writing a custom Manager was still necessary to return the custom\nQuerySet class and all methods that were desired on the Manager\nhad to be proxied to the QuerySet. The whole process went against\nthe DRY principle.
The QuerySet.as_manager()\nclass method can now directly create Manager with QuerySet methods:
class FoodQuerySet(models.QuerySet):\n def pizzas(self):\n return self.filter(kind="pizza")\n\n def vegetarian(self):\n return self.filter(vegetarian=True)\n\n\nclass Food(models.Model):\n kind = models.CharField(max_length=50)\n vegetarian = models.BooleanField(default=False)\n objects = FoodQuerySet.as_manager()\n\n\nFood.objects.pizzas().vegetarian()\nIt is now possible to specify a custom manager when traversing a reverse relationship:
\nclass Blog(models.Model):\n pass\n\n\nclass Entry(models.Model):\n blog = models.ForeignKey(Blog)\n\n objects = models.Manager() # Default Manager\n entries = EntryManager() # Custom Manager\n\n\nb = Blog.objects.get(id=1)\nb.entry_set(manager="entries").all()\nWe’ve added a new System check framework for\ndetecting common problems (like invalid models) and providing hints for\nresolving those problems. The framework is extensible so you can add your\nown checks for your own apps and libraries.
\nTo perform system checks, you use the check management command.\nThis command replaces the older validate management command.
The “today” and “now” shortcuts next to date and time input widgets in the\nadmin are now operating in the current time zone. Previously, they used the browser time zone,\nwhich could result in saving the wrong value when it didn’t match the current\ntime zone on the server.
\nIn addition, the widgets now display a help message when the browser and\nserver time zone are different, to clarify how the value inserted in the field\nwill be interpreted.
\nPrior to Python 2.7, database cursors could be used as a context manager. The\nspecific backend’s cursor defined the behavior of the context manager. The\nbehavior of magic method lookups was changed with Python 2.7 and cursors were\nno longer usable as context managers.
\nDjango 1.7 allows a cursor to be used as a context manager. That is,\nthe following can be used:
\nwith connection.cursor() as c:\n c.execute(...)\ninstead of:
\nc = connection.cursor()\ntry:\n c.execute(...)\nfinally:\n c.close()\nIt is now possible to write custom lookups and transforms for the ORM.\nCustom lookups work just like Django’s built-in lookups (e.g. lte,\nicontains) while transforms are a new concept.
The django.db.models.Lookup class provides a way to add lookup\noperators for model fields. As an example it is possible to add day_lte\noperator for DateFields.
The django.db.models.Transform class allows transformations of\ndatabase values prior to the final lookup. For example it is possible to\nwrite a year transform that extracts year from the field’s value.\nTransforms allow for chaining. After the year transform has been added\nto DateField it is possible to filter on the transformed value, for\nexample qs.filter(author__birthdate__year__lte=1981).
For more information about both custom lookups and transforms refer to\nthe custom lookups documentation.
\nForm error handlingLink to this heading#Form.add_error()Link to this heading#Previously there were two main patterns for handling errors in forms:
\nRaising a ValidationError from within certain\nfunctions (e.g. Field.clean(), Form.clean_<fieldname>(), or\nForm.clean() for non-field errors.)
Fiddling with Form._errors when targeting a specific field in\nForm.clean() or adding errors from outside of a “clean” method\n(e.g. directly from a view).
Using the former pattern was straightforward since the form can guess from the\ncontext (i.e. which method raised the exception) where the errors belong and\nautomatically process them. This remains the canonical way of adding errors\nwhen possible. However the latter was fiddly and error-prone, since the burden\nof handling edge cases fell on the user.
\nThe new add_error() method allows adding errors\nto specific form fields from anywhere without having to worry about the details\nsuch as creating instances of django.forms.utils.ErrorList or dealing with\nForm.cleaned_data. This new API replaces manipulating Form._errors\nwhich now becomes a private API.
See Cleaning and validating fields that depend on each other for an example using\nForm.add_error().
The ValidationError constructor accepts metadata\nsuch as error code or params which are then available for interpolating\ninto the error message (see Raising ValidationError for more details);\nhowever, before Django 1.7 those metadata were discarded as soon as the errors\nwere added to Form.errors.
Form.errors and\ndjango.forms.utils.ErrorList now store the ValidationError instances\nso these metadata can be retrieved at any time through the new\nForm.errors.as_data method.
The retrieved ValidationError instances can then be identified thanks to\ntheir error code which enables things like rewriting the error’s message\nor writing custom logic in a view when a given error is present. It can also\nbe used to serialize the errors in a custom format such as XML.
The new Form.errors.as_json()\nmethod is a convenience method which returns error messages along with error\ncodes serialized as JSON. as_json() uses as_data() and gives an idea\nof how the new system could be extended.
Heavy changes to the various error containers were necessary in order\nto support the features above, specifically\nForm.errors,\ndjango.forms.utils.ErrorList, and the internal storages of\nValidationError. These containers which used\nto store error strings now store ValidationError instances and public APIs\nhave been adapted to make this as transparent as possible, but if you’ve been\nusing private APIs, some of the changes are backwards incompatible; see\nValidationError constructor and internal storage for more details.
django.contrib.adminLink to this heading#You can now implement site_header,\nsite_title, and\nindex_title attributes on a custom\nAdminSite in order to easily change the admin\nsite’s page title and header text. No more needing to override templates!
Buttons in django.contrib.admin now use the border-radius CSS\nproperty for rounded corners rather than GIF background images.
Some admin templates now have app-<app_name> and model-<model_name>\nclasses in their <body> tag to allow customizing the CSS per app or per\nmodel.
The admin changelist cells now have a field-<field_name> class in the\nHTML to enable style customizations.
The admin’s search fields can now be customized per-request thanks to the new\ndjango.contrib.admin.ModelAdmin.get_search_fields() method.
The ModelAdmin.get_fields() method may be overridden to\ncustomize the value of ModelAdmin.fields.
In addition to the existing admin.site.register syntax, you can use the\nnew register() decorator to register a\nModelAdmin.
You may specify ModelAdmin.list_display_links = None to disable\nlinks on the change list page grid.
You may now specify ModelAdmin.view_on_site to control whether or not to\ndisplay the “View on site” link.
You can specify a descending ordering for a ModelAdmin.list_display value by prefixing the\nadmin_order_field value with a hyphen.
The ModelAdmin.get_changeform_initial_data() method may be\noverridden to define custom behavior for setting initial change form data.
django.contrib.authLink to this heading#Any **kwargs passed to\nemail_user() are passed to the\nunderlying send_mail() call.
The permission_required() decorator can\ntake a list of permissions as well as a single permission.
You can override the new AuthenticationForm.confirm_login_allowed() method\nto more easily customize the login policy.
django.contrib.auth.views.password_reset() takes an optional\nhtml_email_template_name parameter used to send a multipart HTML email\nfor password resets.
The AbstractBaseUser.get_session_auth_hash()\nmethod was added and if your AUTH_USER_MODEL inherits from\nAbstractBaseUser, changing a user’s\npassword now invalidates old sessions if the\ndjango.contrib.auth.middleware.SessionAuthenticationMiddleware is\nenabled. See Session invalidation on password change for more details.
django.contrib.formtoolsLink to this heading#Calls to WizardView.done() now include a form_dict to allow easier\naccess to forms by their step name.
django.contrib.gisLink to this heading#The default OpenLayers library version included in widgets has been updated\nfrom 2.11 to 2.13.
Prepared geometries now also support the crosses, disjoint,\noverlaps, touches and within predicates, if GEOS 3.3 or later is\ninstalled.
django.contrib.messagesLink to this heading#The backends for django.contrib.messages that use cookies, will now\nfollow the SESSION_COOKIE_SECURE and\nSESSION_COOKIE_HTTPONLY settings.
The messages context processor now adds a\ndictionary of default levels under the name DEFAULT_MESSAGE_LEVELS.
Message objects now have a level_tag\nattribute that contains the string representation of the message level.
django.contrib.redirectsLink to this heading#RedirectFallbackMiddleware\nhas two new attributes\n(response_gone_class\nand\nresponse_redirect_class)\nthat specify the types of HttpResponse instances the\nmiddleware returns.
django.contrib.sessionsLink to this heading#The "django.contrib.sessions.backends.cached_db" session backend now\nrespects SESSION_CACHE_ALIAS. In previous versions, it always used\nthe default cache.
django.contrib.sitemapsLink to this heading#The sitemap framework now makes use of\nlastmod to set a Last-Modified\nheader in the response. This makes it possible for the\nConditionalGetMiddleware to handle\nconditional GET requests for sitemaps which set lastmod.
django.contrib.sitesLink to this heading#The new django.contrib.sites.middleware.CurrentSiteMiddleware allows\nsetting the current site on each request.
django.contrib.staticfilesLink to this heading#The static files storage classes may be\nsubclassed to override the permissions that collected static files and\ndirectories receive by setting the\nfile_permissions_mode\nand\ndirectory_permissions_mode\nparameters. See collectstatic for example usage.
The CachedStaticFilesStorage backend gets a sibling class called\nManifestStaticFilesStorage\nthat doesn’t use the cache system at all but instead a JSON file called\nstaticfiles.json for storing the mapping between the original file name\n(e.g. css/styles.css) and the hashed file name (e.g.\ncss/styles.55e7cbb9ba48.css). The staticfiles.json file is created\nwhen running the collectstatic management command and should\nbe a less expensive alternative for remote storages such as Amazon S3.
See the\nManifestStaticFilesStorage docs\nfor more information.
findstatic now accepts verbosity flag level 2, meaning it will\nshow the relative paths of the directories it searched. See\nfindstatic for example output.
Access to caches configured in CACHES is now available via\ndjango.core.cache.caches. This dict-like object provides a different\ninstance per thread. It supersedes django.core.cache.get_cache() which\nis now deprecated.
If you instantiate cache backends directly, be aware that they aren’t\nthread-safe any more, as django.core.cache.caches now yields\ndifferent instances per thread.
Defining the TIMEOUT argument of the\nCACHES setting as None will set the cache keys as\n“non-expiring” by default. Previously, it was only possible to pass\ntimeout=None to the cache backend’s set() method.
The CSRF_COOKIE_AGE setting facilitates the use of session-based\nCSRF cookies.
send_mail() now accepts an html_message\nparameter for sending a multipart text/plain and\ntext/html email.
The SMTP EmailBackend now accepts a\ntimeout parameter.
File locking on Windows previously depended on the PyWin32 package; if it\nwasn’t installed, file locking failed silently. That dependency has been\nremoved, and file locking is now implemented natively on both Windows\nand Unix.
The new UploadedFile.content_type_extra attribute\ncontains extra parameters passed to the content-type header on a file\nupload.
The new FILE_UPLOAD_DIRECTORY_PERMISSIONS setting controls\nthe file system permissions of directories created during file upload, like\nFILE_UPLOAD_PERMISSIONS does for the files themselves.
The FileField.upload_to\nattribute is now optional. If it is omitted or given None or an empty\nstring, a subdirectory won’t be used for storing the uploaded files.
Uploaded files are now explicitly closed before the response is delivered to\nthe client. Partially uploaded files are also closed as long as they are\nnamed file in the upload handler.
Storage.get_available_name() now appends an\nunderscore plus a random 7 character alphanumeric string (e.g.\n"_x3a1gho"), rather than iterating through an underscore followed by a\nnumber (e.g. "_1", "_2", etc.) to prevent a denial-of-service attack.\nThis change was also made in the 1.6.6, 1.5.9, and 1.4.14 security releases.
The <label> and <input> tags rendered by\nRadioSelect and\nCheckboxSelectMultiple when looping over the radio\nbuttons or checkboxes now include for and id attributes,\nrespectively. Each radio button or checkbox includes an id_for_label\nattribute to output the element’s ID.
The <textarea> tags rendered by Textarea now\ninclude a maxlength attribute if the TextField\nmodel field has a max_length.
Field.choices now allows you to\ncustomize the “empty choice” label by including a tuple with an empty string\nor None for the key and the custom label as the value. The default blank\noption "----------" will be omitted in this case.
MultiValueField allows optional subfields by setting\nthe require_all_fields argument to False. The required attribute\nfor each individual field will be respected, and a new incomplete\nvalidation error will be raised when any required fields are empty.
The clean() method on a form no longer needs to\nreturn self.cleaned_data. If it does return a changed dictionary then\nthat will still be used.
After a temporary regression in Django 1.6, it’s now possible again to make\nTypedChoiceField coerce method return an arbitrary\nvalue.
SelectDateWidget.months can be used to\ncustomize the wording of the months displayed in the select widget.
The min_num and validate_min parameters were added to\nformset_factory() to allow validating\na minimum number of submitted forms.
The metaclasses used by Form and ModelForm have been reworked to\nsupport more inheritance scenarios. The previous limitation that prevented\ninheriting from both Form and ModelForm simultaneously have been\nremoved as long as ModelForm appears first in the MRO.
It’s now possible to remove a field from a Form when subclassing by\nsetting the name to None.
It’s now possible to customize the error messages for ModelForm’s\nunique, unique_for_date, and unique_together constraints.\nIn order to support unique_together or any other NON_FIELD_ERROR,\nModelForm now looks for the NON_FIELD_ERROR key in the\nerror_messages dictionary of the ModelForm’s inner Meta class.\nSee considerations regarding model’s error_messages for more details.
The django.middleware.locale.LocaleMiddleware.response_redirect_class\nattribute allows you to customize the redirects issued by the middleware.
The LocaleMiddleware now stores the user’s\nselected language with the session key _language. This should only be\naccessed using the LANGUAGE_SESSION_KEY constant. Previously it was\nstored with the key django_language and the LANGUAGE_SESSION_KEY\nconstant did not exist, but keys reserved for Django should start with an\nunderscore. For backwards compatibility django_language is still read\nfrom in 1.7. Sessions will be migrated to the new key as they are written.
The blocktrans tag now supports a trimmed option. This\noption will remove newline characters from the beginning and the end of the\ncontent of the {% blocktrans %} tag, replace any whitespace at the\nbeginning and end of a line and merge all lines into one using a space\ncharacter to separate them. This is quite useful for indenting the content of\na {% blocktrans %} tag without having the indentation characters end up\nin the corresponding entry in the .po file, which makes the translation\nprocess easier.
When you run makemessages from the root directory of your project,\nany extracted strings will now be automatically distributed to the proper\napp or project message file. See Localization: how to create language files for\ndetails.
The makemessages command now always adds the --previous\ncommand line flag to the msgmerge command, keeping previously translated\nstrings in .po files for fuzzy strings.
The following settings to adjust the language cookie options were introduced:\nLANGUAGE_COOKIE_AGE, LANGUAGE_COOKIE_DOMAIN\nand LANGUAGE_COOKIE_PATH.
Added Format localization for Esperanto.
The new --no-color option for django-admin disables the\ncolorization of management command output.
The new dumpdata --natural-foreign and dumpdata\n--natural-primary options, and the new use_natural_foreign_keys and\nuse_natural_primary_keys arguments for serializers.serialize(), allow\nthe use of natural primary keys when serializing.
It is no longer necessary to provide the cache table name or the\n--database option for the createcachetable command.\nDjango takes this information from your settings file. If you have configured\nmultiple caches or multiple databases, all cache tables are created.
The runserver command received several improvements:
On Linux systems, if pyinotify is installed, the development server\nwill reload immediately when a file is changed. Previously, it polled the\nfilesystem for changes every second. That caused a small delay before\nreloads and reduced battery life on laptops.
In addition, the development server automatically reloads when a\ntranslation file is updated, i.e. after running\ncompilemessages.
All HTTP requests are logged to the console, including requests for static\nfiles or favicon.ico that used to be filtered out.
Management commands can now produce syntax colored output under Windows if\nthe ANSICON third-party tool is installed and active.
collectstatic command with symlink option is now supported on\nWindows NT 6 (Windows Vista and newer).
Initial SQL data now works better if the sqlparse Python library is\ninstalled.
\nNote that it’s deprecated in favor of the\nRunSQL operation of migrations,\nwhich benefits from the improved behavior.
The QuerySet.update_or_create() method was added.
The new default_permissions model\nMeta option allows you to customize (or disable) creation of the default\nadd, change, and delete permissions.
Explicit OneToOneField for\nMulti-table inheritance are now discovered in abstract classes.
It is now possible to avoid creating a backward relation for\nOneToOneField by setting its\nrelated_name to\n'+' or ending it with '+'.
F expressions support the power operator\n(**).
The remove() and clear() methods of the related managers created by\nForeignKey and GenericForeignKey now accept the bulk keyword\nargument to control whether or not to perform operations in bulk\n(i.e. using QuerySet.update()). Defaults to True.
It is now possible to use None as a query value for the iexact\nlookup.
It is now possible to pass a callable as value for the attribute\nlimit_choices_to when defining a\nForeignKey or ManyToManyField.
Calling only() and\ndefer() on the result of\nQuerySet.values() now raises\nan error (before that, it would either result in a database error or\nincorrect data).
You can use a single list for index_together (rather than a list of\nlists) when specifying a single set of fields.
Custom intermediate models having more than one foreign key to any of the\nmodels participating in a many-to-many relationship are now permitted,\nprovided you explicitly specify which foreign keys should be used by setting\nthe new ManyToManyField.through_fields argument.
Assigning a model instance to a non-relation field will now throw an error.\nPreviously this used to work if the field accepted integers as input as it\ntook the primary key.
Integer fields are now validated against database backend specific min and\nmax values based on their internal_type. Previously model field\nvalidation didn’t prevent values out of their associated column data type\nrange from being saved resulting in an integrity error.
It is now possible to explicitly\norder_by() a relation _id field by\nusing its attribute name.
The enter argument was added to the\nsetting_changed signal.
The model signals can be now be connected to using a str of the\n'app_label.ModelName' form – just like related fields – to lazily\nreference their senders.
The Context.push() method now returns\na context manager which automatically calls pop() upon exiting the with statement.\nAdditionally, push() now accepts\nparameters that are passed to the dict constructor used to build the new\ncontext level.
The new Context.flatten() method\nreturns a Context’s stack as one flat dictionary.
Context objects can now be compared for equality (internally, this\nuses Context.flatten() so the\ninternal structure of each Context’s stack doesn’t matter as long as\ntheir flattened version is identical).
The widthratio template tag now accepts an "as" parameter to\ncapture the result in a variable.
The include template tag will now also accept anything with a\nrender() method (such as a Template) as an argument. String\narguments will be looked up using\nget_template() as always.
It is now possible to include templates recursively.
Template objects now have an origin attribute set when\nTEMPLATE_DEBUG is True. This allows template origins to be\ninspected and logged outside of the django.template infrastructure.
TypeError exceptions are no longer silenced when raised during the\nrendering of a template.
The following functions now accept a dirs parameter which is a list or\ntuple to override TEMPLATE_DIRS:
django.shortcuts.render_to_response()
The time filter now accepts timezone-related format\nspecifiers 'e', 'O' , 'T'\nand 'Z' and is able to digest time-zone-aware datetime instances performing the expected\nrendering.
The cache tag will now try to use the cache called\n“template_fragments” if it exists and fall back to using the default cache\notherwise. It also now accepts an optional using keyword argument to\ncontrol which cache it uses.
The new truncatechars_html filter truncates a string to be no\nlonger than the specified number of characters, taking HTML into account.
The new HttpRequest.scheme attribute\nspecifies the scheme of the request (http or https normally).
The shortcut redirect() now supports\nrelative URLs.
The new JsonResponse subclass of\nHttpResponse helps easily create JSON-encoded\nresponses.
DiscoverRunner has two new attributes,\ntest_suite and\ntest_runner, which facilitate\noverriding the way tests are collected and run.
The fetch_redirect_response argument was added to\nassertRedirects(). Since the test\nclient can’t fetch externals URLs, this allows you to use assertRedirects\nwith redirects that aren’t part of your Django app.
Correct handling of scheme when making comparisons in\nassertRedirects().
The secure argument was added to all the request methods of\nClient. If True, the request will be made\nthrough HTTPS.
assertNumQueries() now prints\nout the list of executed queries if the assertion fails.
The WSGIRequest instance generated by the test handler is now attached to\nthe django.test.Response.wsgi_request attribute.
The database settings for testing have been collected into a dictionary\nnamed TEST.
Improved strip_tags() accuracy (but it still cannot\nguarantee an HTML-safe result, as stated in the documentation).
RegexValidator now accepts the optional\nflags and\nBoolean inverse_match\narguments. The inverse_match\nattribute determines if the ValidationError\nshould be raised when the regular expression pattern matches (True) or\ndoes not match (False, by default) the provided value. The\nflags attribute sets the flags\nused when compiling a regular expression string.
URLValidator now accepts an optional\nschemes argument which allows customization of the accepted URI schemes\n(instead of the defaults http(s) and ftp(s)).
validate_email() now accepts addresses with\nIPv6 literals, like example@[2001:db8::1], as specified in RFC 5321.
allow_syncdb / allow_migrateLink to this heading#While Django will still look at allow_syncdb methods even though they\nshould be renamed to allow_migrate, there is a subtle difference in which\nmodels get passed to these methods.
For apps with migrations, allow_migrate will now get passed\nhistorical models, which are special versioned\nmodels without custom attributes, methods or managers. Make sure your\nallow_migrate methods are only referring to fields or other items in\nmodel._meta.
Apps with migrations will not load initial_data fixtures when they have\nfinished migrating. Apps without migrations will continue to load these\nfixtures during the phase of migrate which emulates the old syncdb\nbehavior, but any new apps will not have this support.
Instead, you are encouraged to load initial data in migrations if you need it\n(using the RunPython operation and your model classes);\nthis has the added advantage that your initial data will not need updating\nevery time you change the schema.
Additionally, like the rest of Django’s old syncdb code, initial_data\nhas been started down the deprecation path and will be removed in Django 1.9.
deconstruct() and serializabilityLink to this heading#Django now requires all Field classes and all of their constructor arguments\nto be serializable. If you modify the constructor signature in your custom\nField in any way, you’ll need to implement a deconstruct() method;\nwe’ve expanded the custom field documentation with instructions\non implementing this method.
The requirement for all field arguments to be\nserializable means that any custom class\ninstances being passed into Field constructors - things like custom Storage\nsubclasses, for instance - need to have a deconstruct method defined on\nthem as well, though Django provides a handy\nclass decorator that will work for most applications.
\nDjango 1.7 loads application configurations and models as soon as it starts.\nWhile this behavior is more straightforward and is believed to be more robust,\nregressions cannot be ruled out. See Troubleshooting for\nsolutions to some problems you may encounter.
\nIf you’re using Django in a plain Python script — rather than a management\ncommand — and you rely on the DJANGO_SETTINGS_MODULE environment\nvariable, you must now explicitly initialize Django at the beginning of your\nscript with:
>>> import django\n>>> django.setup()\nOtherwise, you will hit an AppRegistryNotReady exception.
Until Django 1.3, the recommended way to create a WSGI application was:
\nimport django.core.handlers.wsgi\n\napplication = django.core.handlers.wsgi.WSGIHandler()\nIn Django 1.4, support for WSGI was improved and the API changed to:
\nfrom django.core.wsgi import get_wsgi_application\n\napplication = get_wsgi_application()\nIf you’re still using the former style in your WSGI script, you need to\nupgrade to the latter, or you will hit an AppRegistryNotReady exception.
It is no longer possible to have multiple installed applications with the same\nlabel. In previous versions of Django, this didn’t always work correctly, but\ndidn’t crash outright either.
\nIf you have two apps with the same label, you should create an\nAppConfig for one of them and override its\nlabel there. You should then adjust your code\nwherever it references this application or its models with the old label.
It isn’t possible to import the same model twice through different paths any\nmore. As of Django 1.6, this may happen only if you’re manually putting a\ndirectory and a subdirectory on PYTHONPATH. Refer to the section on\nthe new project layout in the 1.4 release notes for\nmigration instructions.
You should make sure that:
\nAll models are defined in applications that are listed in\nINSTALLED_APPS or have an explicit\napp_label.
Models aren’t imported as a side-effect of loading their application.\nSpecifically, you shouldn’t import models in the root module of an\napplication nor in the module that define its configuration class.
Django will enforce these requirements as of version 1.9, after a deprecation\nperiod.
\nSubclasses of AppCommand must now implement a\nhandle_app_config() method instead of\nhandle_app(). This method receives an AppConfig\ninstance instead of a models module.
Since INSTALLED_APPS now supports application configuration classes\nin addition to application modules, you should review code that accesses this\nsetting directly and use the app registry (django.apps.apps) instead.
The app registry has preserved some features of the old app cache. Even though\nthe app cache was a private API, obsolete methods and arguments will be\nremoved through a standard deprecation path, with the exception of the\nfollowing changes that take effect immediately:
\nget_model raises LookupError instead of returning None when no\nmodel is found.
The only_installed argument of get_model and get_models no\nlonger exists, nor does the seed_cache argument of get_model.
INSTALLED_APPSLink to this heading#When several applications provide management commands with the same name,\nDjango loads the command from the application that comes first in\nINSTALLED_APPS. Previous versions loaded the command from the\napplication that came last.
This brings discovery of management commands in line with other parts of\nDjango that rely on the order of INSTALLED_APPS, such as static\nfiles, templates, and translations.
ValidationError constructor and internal storageLink to this heading#The behavior of the ValidationError constructor has changed when it\nreceives a container of errors as an argument (e.g. a list or an\nErrorList):
It converts any strings it finds to instances of ValidationError\nbefore adding them to its internal storage.
It doesn’t store the given container but rather copies its content to its\nown internal storage; previously the container itself was added to the\nValidationError instance and used as internal storage.
This means that if you access the ValidationError internal storages, such\nas error_list; error_dict; or the return value of\nupdate_error_dict() you may find instances of ValidationError where you\nwould have previously found strings.
Also if you directly assigned the return value of update_error_dict()\nto Form._errors you may inadvertently add list instances where\nErrorList instances are expected. This is a problem because unlike a\nsimple list, an ErrorList knows how to handle instances of\nValidationError.
Most use-cases that warranted using these private APIs are now covered by\nthe newly introduced Form.add_error()\nmethod:
# Old pattern:\ntry:\n ...\nexcept ValidationError as e:\n self._errors = e.update_error_dict(self._errors)\n\n# New pattern:\ntry:\n ...\nexcept ValidationError as e:\n self.add_error(None, e)\nIf you need both Django <= 1.6 and 1.7 compatibility you can’t use\nForm.add_error() since it\nwasn’t available before Django 1.7, but you can use the following\nworkaround to convert any list into ErrorList:
try:\n ...\nexcept ValidationError as e:\n self._errors = e.update_error_dict(self._errors)\n\n# Additional code to ensure ``ErrorDict`` is exclusively\n# composed of ``ErrorList`` instances.\nfor field, error_list in self._errors.items():\n if not isinstance(error_list, self.error_class):\n self._errors[field] = self.error_class(error_list)\nLocMemCache regarding pickle errorsLink to this heading#An inconsistency existed in previous versions of Django regarding how pickle\nerrors are handled by different cache backends.\ndjango.core.cache.backends.locmem.LocMemCache used to fail silently when\nsuch an error occurs, which is inconsistent with other backends and leads to\ncache-specific errors. This has been fixed in Django 1.7, see\n#21200 for more details.
Previous versions of Django generated cache keys using a request’s path and\nquery string but not the scheme or host. If a Django application was serving\nmultiple subdomains or domains, cache keys could collide. In Django 1.7, cache\nkeys vary by the absolute URL of the request including scheme, host, path, and\nquery string. For example, the URL portion of a cache key is now generated from\nhttps://www.example.com/path/to/?key=val rather than /path/to/?key=val.\nThe cache keys generated by Django 1.7 will be different from the keys\ngenerated by older versions of Django. After upgrading to Django 1.7, the first\nrequest to any previously cached URL will be a cache miss.
None to Manager.db_manager()Link to this heading#In previous versions of Django, it was possible to use\ndb_manager(using=None) on a model manager instance to obtain a manager\ninstance using default routing behavior, overriding any manually specified\ndatabase routing. In Django 1.7, a value of None passed to db_manager will\nproduce a router that retains any manually assigned database routing – the\nmanager will not be reset. This was necessary to resolve an inconsistency in\nthe way routing information cascaded over joins. See #13724 for more\ndetails.
pytz may be requiredLink to this heading#If your project handles datetimes before 1970 or after 2037 and Django raises\na ValueError when encountering them, you will have to install\npytz. You may be affected by this problem if you use Django’s time\nzone-related date formats or django.contrib.syndication.
Historically, the Django admin site passed the request from an unauthorized or\nunauthenticated user directly to the login view, without HTTP redirection. In\nDjango 1.7, this behavior changed to conform to a more traditional workflow\nwhere any unauthorized request to an admin page will be redirected (by HTTP\nstatus code 302) to the login page, with the next parameter set to the\nreferring path. The user will be redirected there after a successful login.
Note also that the admin login form has been updated to not contain the\nthis_is_the_login_form field (now unused) and the ValidationError code\nhas been set to the more regular invalid_login key.
select_for_update() requires a transactionLink to this heading#Historically, queries that use\nselect_for_update() could be\nexecuted in autocommit mode, outside of a transaction. Before Django\n1.6, Django’s automatic transactions mode allowed this to be used to\nlock records until the next write operation. Django 1.6 introduced\ndatabase-level autocommit; since then, execution in such a context\nvoids the effect of select_for_update(). It is, therefore, assumed\nnow to be an error and raises an exception.
This change was made because such errors can be caused by including an\napp which expects global transactions (e.g. ATOMIC_REQUESTS set to True), or Django’s old autocommit\nbehavior, in a project which runs without them; and further, such\nerrors may manifest as data-corruption bugs. It was also made in\nDjango 1.6.3.
This change may cause test failures if you use select_for_update()\nin a test class which is a subclass of\nTransactionTestCase rather than\nTestCase.
MIDDLEWARE_CLASSESLink to this heading#The app-loading refactor\ndeprecated using models from apps which are not part of the\nINSTALLED_APPS setting. This exposed an incompatibility between\nthe default INSTALLED_APPS and MIDDLEWARE_CLASSES in the\nglobal defaults (django.conf.global_settings). To bring these settings in\nsync and prevent deprecation warnings when doing things like testing reusable\napps with minimal settings,\nSessionMiddleware,\nAuthenticationMiddleware, and\nMessageMiddleware were removed\nfrom the defaults. These classes will still be included in the default settings\ngenerated by startproject. Most projects will not be affected by\nthis change but if you were not previously declaring the\nMIDDLEWARE_CLASSES in your project settings and relying on the\nglobal default you should ensure that the new defaults are in line with your\nproject’s needs. You should also check for any code that accesses\ndjango.conf.global_settings.MIDDLEWARE_CLASSES directly.
The django.core.files.uploadhandler.FileUploadHandler.new_file()\nmethod is now passed an additional content_type_extra parameter. If you\nhave a custom FileUploadHandler\nthat implements new_file(), be sure it accepts this new parameter.
ModelFormSets no longer\ndelete instances when save(commit=False) is called. See\ncan_delete for instructions on how\nto manually delete objects from deleted forms.
Loading empty fixtures emits a RuntimeWarning rather than raising\nCommandError.
django.contrib.staticfiles.views.serve() will now raise an\nHttp404 exception instead of\nImproperlyConfigured when DEBUG\nis False. This change removes the need to conditionally add the view to\nyour root URLconf, which in turn makes it safe to reverse by name. It also\nremoves the ability for visitors to generate spurious HTTP 500 errors by\nrequesting static files that don’t exist or haven’t been collected yet.
The django.db.models.Model.__eq__() method is now defined in a\nway where instances of a proxy model and its base model are considered\nequal when primary keys match. Previously only instances of exact same\nclass were considered equal on primary key match.
The django.db.models.Model.__eq__() method has changed such that\ntwo Model instances without primary key values won’t be considered\nequal (unless they are the same instance).
The django.db.models.Model.__hash__() method will now raise\nTypeError when called on an instance without a primary key value. This is\ndone to avoid mutable __hash__ values in containers.
AutoField columns in SQLite databases will now be\ncreated using the AUTOINCREMENT option, which guarantees monotonic\nincrements. This will cause primary key numbering behavior to change on\nSQLite, becoming consistent with most other SQL databases. This will only\napply to newly created tables. If you have a database created with an older\nversion of Django, you will need to migrate it to take advantage of this\nfeature. For example, you could do the following:
django.contrib.auth.models.AbstractUser no longer defines a\nget_absolute_url() method. The old definition\nreturned "/users/%s/" % urlquote(self.username) which was arbitrary\nsince applications may or may not define such a url in urlpatterns.\nDefine a get_absolute_url() method on your own custom user object or use\nABSOLUTE_URL_OVERRIDES if you want a URL for your user.
The static asset-serving functionality of the\ndjango.test.LiveServerTestCase class has been simplified: Now it’s\nonly able to serve content already present in STATIC_ROOT when\ntests are run. The ability to transparently serve all the static assets\n(similarly to what one gets with DEBUG = True at\ndevelopment-time) has been moved to a new class that lives in the\nstaticfiles application (the one actually in charge of such feature):\ndjango.contrib.staticfiles.testing.StaticLiveServerTestCase. In\nother words, LiveServerTestCase itself is less powerful but at the same\ntime has less magic.
Rationale behind this is removal of dependency of non-contrib code on\ncontrib applications.
\nThe old cache URI syntax (e.g. "locmem://") is no longer supported. It\nstill worked, even though it was not documented or officially supported. If\nyou’re still using it, please update to the current CACHES syntax.
The default ordering of Form fields in case of inheritance has changed to\nfollow normal Python MRO. Fields are now discovered by iterating through the\nMRO in reverse with the topmost class coming last. This only affects you if\nyou relied on the default field ordering while having fields defined on both\nthe current class and on a parent Form.
The required argument of\nSelectDateWidget has been removed.\nThis widget now respects the form field’s is_required attribute like\nother widgets.
Widget.is_hidden is now a read-only property, getting its value by\nintrospecting the presence of input_type == 'hidden'.
select_related() now chains in the\nsame way as other similar calls like prefetch_related. That is,\nselect_related('foo', 'bar') is equivalent to\nselect_related('foo').select_related('bar'). Previously the latter would\nhave been equivalent to select_related('bar').
GeoDjango dropped support for GEOS < 3.1.
The init_connection_state method of database backends now executes in\nautocommit mode (unless you set AUTOCOMMIT\nto False). If you maintain a custom database backend, you should check\nthat method.
The django.db.backends.BaseDatabaseFeatures.allows_primary_key_0\nattribute has been renamed to allows_auto_pk_0 to better describe it.\nIt’s True for all database backends included with Django except MySQL\nwhich does allow primary keys with value 0. It only forbids autoincrement\nprimary keys with value 0.
Shadowing model fields defined in a parent model has been forbidden as this\ncreates ambiguity in the expected model behavior. In addition, clashing\nfields in the model inheritance hierarchy result in a system check error.\nFor example, if you use multi-inheritance, you need to define custom primary\nkey fields on parent models, otherwise the default id fields will clash.\nSee Multiple inheritance for details.
django.utils.translation.parse_accept_lang_header() now returns\nlowercase locales, instead of the case as it was provided. As locales should\nbe treated case-insensitive this allows us to speed up locale detection.
django.utils.translation.get_language_from_path() and\ndjango.utils.translation.trans_real.get_supported_language_variant()\nnow no longer have a supported argument.
The shortcut view in django.contrib.contenttypes.views now supports\nprotocol-relative URLs (e.g. //example.com).
GenericRelation now supports an\noptional related_query_name argument. Setting related_query_name adds\na relation from the related object back to the content type for filtering,\nordering and other query operations.
When running tests on PostgreSQL, the USER will need read access\nto the built-in postgres database. This is in lieu of the previous\nbehavior of connecting to the actual non-test database.
As part of the System check framework, fields,\nmodels, and model managers all implement a check()\nmethod that is registered with the check framework. If you have an existing\nmethod called check() on one of these objects, you will need to rename\nit.
As noted above in the “Cache” section of “Minor Features”, defining the\nTIMEOUT argument of the\nCACHES setting as None will set the cache keys as\n“non-expiring”. Previously, with the memcache backend, a\nTIMEOUT of 0 would set non-expiring keys,\nbut this was inconsistent with the set-and-expire (i.e. no caching) behavior\nof set("key", "value", timeout=0). If you want non-expiring keys,\nplease update your settings to use None instead of 0 as the latter\nnow designates set-and-expire in the settings as well.
The sql* management commands now respect the allow_migrate() method\nof DATABASE_ROUTERS. If you have models synced to non-default\ndatabases, use the --database flag to get SQL for those models\n(previously they would always be included in the output).
Decoding the query string from URLs now falls back to the ISO-8859-1 encoding\nwhen the input is not valid UTF-8.
With the addition of the\ndjango.contrib.auth.middleware.SessionAuthenticationMiddleware to\nthe default project template (pre-1.7.2 only), a database must be created\nbefore accessing a page using runserver.
The addition of the schemes argument to URLValidator will appear\nas a backwards-incompatible change if you were previously using a custom\nregular expression to validate schemes. Any scheme not listed in schemes\nwill fail validation, even if the regular expression matches the given URL.
django.core.cache.get_cacheLink to this heading#django.core.cache.get_cache has been supplanted by\ndjango.core.cache.caches.
django.utils.dictconfig/django.utils.importlibLink to this heading#django.utils.dictconfig and django.utils.importlib were copies of\nrespectively logging.config and importlib provided for Python\nversions prior to 2.7. They have been deprecated.
django.utils.module_loading.import_by_pathLink to this heading#The current django.utils.module_loading.import_by_path function\ncatches AttributeError, ImportError, and ValueError exceptions,\nand re-raises ImproperlyConfigured. Such\nexception masking makes it needlessly hard to diagnose circular import\nproblems, because it makes it look like the problem comes from inside Django.\nIt has been deprecated in favor of\nimport_string().
django.utils.tzinfoLink to this heading#django.utils.tzinfo provided two tzinfo subclasses,\nLocalTimezone and FixedOffset. They’ve been deprecated in favor of\nmore correct alternatives provided by django.utils.timezone,\ndjango.utils.timezone.get_default_timezone() and\ndjango.utils.timezone.get_fixed_timezone().
django.utils.unittestLink to this heading#django.utils.unittest provided uniform access to the unittest2 library\non all Python versions. Since unittest2 became the standard library’s\nunittest module in Python 2.7, and Django 1.7 drops support for older\nPython versions, this module isn’t useful anymore. It has been deprecated. Use\nunittest instead.
django.utils.datastructures.SortedDictLink to this heading#As OrderedDict was added to the standard library in\nPython 2.7, SortedDict is no longer needed and has been deprecated.
The two additional, deprecated methods provided by SortedDict (insert()\nand value_for_index()) have been removed. If you relied on these methods to\nalter structures like form fields, you should now treat these OrderedDicts\nas immutable objects and override them to change their content.
For example, you might want to override MyFormClass.base_fields (although\nthis attribute isn’t considered a public API) to change the ordering of fields\nfor all MyFormClass instances; or similarly, you could override\nself.fields from inside MyFormClass.__init__(), to change the fields\nfor a particular form instance. For example (from Django itself):
PasswordChangeForm.base_fields = OrderedDict(\n (k, PasswordChangeForm.base_fields[k])\n for k in ["old_password", "new_password1", "new_password2"]\n)\nPreviously, if models were organized in a package (myapp/models/) rather\nthan simply myapp/models.py, Django would look for initial SQL data in\nmyapp/models/sql/. This bug has been fixed so that Django will search\nmyapp/sql/ as documented. After this issue was fixed, migrations were added\nwhich deprecates initial SQL data. Thus, while this change still exists, the\ndeprecation is irrelevant as the entire feature will be removed in Django 1.9.
django.contrib.sitesLink to this heading#django.contrib.sites provides reduced functionality when it isn’t in\nINSTALLED_APPS. The app-loading refactor adds some constraints in\nthat situation. As a consequence, two objects were moved, and the old\nlocations are deprecated:
RequestSite now lives in\ndjango.contrib.sites.requests.
get_current_site() now lives in\ndjango.contrib.sites.shortcuts.
declared_fieldsets attribute on ModelAdminLink to this heading#ModelAdmin.declared_fieldsets has been deprecated. Despite being a private\nAPI, it will go through a regular deprecation path. This attribute was mostly\nused by methods that bypassed ModelAdmin.get_fieldsets() but this was\nconsidered a bug and has been addressed.
django.contrib.contenttypesLink to this heading#Since django.contrib.contenttypes.generic defined both admin and model\nrelated objects, an import of this module could trigger unexpected side\neffects. As a consequence, its contents were split into\ncontenttypes submodules and the\ndjango.contrib.contenttypes.generic module is deprecated:
GenericForeignKey and\nGenericRelation now live in\nfields.
BaseGenericInlineFormSet and\ngeneric_inlineformset_factory() now\nlive in forms.
GenericInlineModelAdmin,\nGenericStackedInline and\nGenericTabularInline now live in\nadmin.
syncdbLink to this heading#The syncdb command has been deprecated in favor of the new\nmigrate command. migrate takes the same arguments as syncdb\nused to plus a few more, so it’s safe to just change the name you’re calling\nand nothing else.
util modules renamed to utilsLink to this heading#The following instances of util.py in the Django codebase have been renamed\nto utils.py in an effort to unify all util and utils references:
django.contrib.admin.util
django.contrib.gis.db.backends.util
django.db.backends.util
django.forms.util
get_formsets method on ModelAdminLink to this heading#ModelAdmin.get_formsets has been deprecated in favor of the new\nget_formsets_with_inlines(), in order to\nbetter handle the case of selectively showing inlines on a ModelAdmin.
IPAddressFieldLink to this heading#The django.db.models.IPAddressField and django.forms.IPAddressField\nfields have been deprecated in favor of\ndjango.db.models.GenericIPAddressField and\ndjango.forms.GenericIPAddressField.
BaseMemcachedCache._get_memcache_timeout methodLink to this heading#The BaseMemcachedCache._get_memcache_timeout() method has been renamed to\nget_backend_timeout(). Despite being a private API, it will go through the\nnormal deprecation.
The --natural and -n options for dumpdata have been\ndeprecated. Use dumpdata --natural-foreign instead.
Similarly, the use_natural_keys argument for serializers.serialize()\nhas been deprecated. Use use_natural_foreign_keys instead.
POST and GET arguments into WSGIRequest.REQUESTLink to this heading#It was already strongly suggested that you use GET and POST instead of\nREQUEST, because the former are more explicit. The property REQUEST is\ndeprecated and will be removed in Django 1.9.
django.utils.datastructures.MergeDict classLink to this heading#MergeDict exists primarily to support merging POST and GET\narguments into a REQUEST property on WSGIRequest. To merge\ndictionaries, use dict.update() instead. The class MergeDict is\ndeprecated and will be removed in Django 1.9.
zh-cn, zh-tw and fy-nlLink to this heading#The currently used language codes for Simplified Chinese zh-cn,\nTraditional Chinese zh-tw and (Western) Frysian fy-nl are deprecated\nand should be replaced by the language codes zh-hans, zh-hant and\nfy respectively. If you use these language codes, you should rename the\nlocale directories and update your settings to reflect these changes. The\ndeprecated language codes will be removed in Django 1.9.
django.utils.functional.memoize functionLink to this heading#The function memoize is deprecated and should be replaced by the\nfunctools.lru_cache decorator (available from Python 3.2 onward).
Django ships a backport of this decorator for older Python versions and it’s\navailable at django.utils.lru_cache.lru_cache. The deprecated function will\nbe removed in Django 1.9.
Google has retired support for the Geo Sitemaps format. Hence Django support\nfor Geo Sitemaps is deprecated and will be removed in Django 1.8.
\nCallable arguments for querysets were an undocumented feature that was\nunreliable. It’s been deprecated and will be removed in Django 1.9.
\nCallable arguments were evaluated when a queryset was constructed rather than\nwhen it was evaluated, thus this feature didn’t offer any benefit compared to\nevaluating arguments before passing them to queryset and created confusion that\nthe arguments may have been evaluated at query time.
\nADMIN_FOR settingLink to this heading#The ADMIN_FOR feature, part of the admindocs, has been removed. You can\nremove the setting from your configuration at your convenience.
SplitDateTimeWidget with DateTimeFieldLink to this heading#SplitDateTimeWidget support in DateTimeField is\ndeprecated, use SplitDateTimeWidget with\nSplitDateTimeField instead.
validateLink to this heading#The validate management command is deprecated in favor of the\ncheck command.
django.core.management.BaseCommandLink to this heading#requires_model_validation is deprecated in favor of a new\nrequires_system_checks flag. If the latter flag is missing, then the\nvalue of the former flag is used. Defining both requires_system_checks and\nrequires_model_validation results in an error.
The check() method has replaced the old validate() method.
ModelAdmin validatorsLink to this heading#The ModelAdmin.validator_class and default_validator_class attributes\nare deprecated in favor of the new checks_class attribute.
The ModelAdmin.validate() method is deprecated in favor of\nModelAdmin.check().
The django.contrib.admin.validation module is deprecated.
django.db.backends.DatabaseValidation.validate_fieldLink to this heading#This method is deprecated in favor of a new check_field method. The\nfunctionality required by check_field() is the same as that provided by\nvalidate_field(), but the output format is different. Third-party database\nbackends needing this functionality should provide an implementation of\ncheck_field().
django.utils.text.javascript_quoteLink to this heading#javascript_quote() was an undocumented function present in\ndjango.utils.text. It was used internally in the javascript_catalog()\nview whose implementation was changed to make use of json.dumps() instead.\nIf you were relying on this function to provide safe output from untrusted\nstrings, you should use django.utils.html.escapejs or the\nescapejs template filter.\nIf all you need is to generate valid JavaScript strings, you can simply use\njson.dumps().
fix_ampersands utils method and template filterLink to this heading#The django.utils.html.fix_ampersands method and the fix_ampersands\ntemplate filter are deprecated, as the escaping of ampersands is already taken\ncare of by Django’s standard HTML escaping features. Combining this with\nfix_ampersands would either result in double escaping, or, if the output is\nassumed to be safe, a risk of introducing XSS vulnerabilities. Along with\nfix_ampersands, django.utils.html.clean_html is deprecated, an\nundocumented function that calls fix_ampersands. As this is an accelerated\ndeprecation, fix_ampersands and clean_html will be removed in Django\n1.8.
All database settings with a TEST_ prefix have been deprecated in favor of\nentries in a TEST dictionary in the database\nsettings. The old settings will be supported until Django 1.9. For backwards\ncompatibility with older versions of Django, you can define both versions of\nthe settings as long as they match.
FastCGI support via the runfcgi management command will be removed in\nDjango 1.9. Please deploy your project using WSGI.
contrib.sitesLink to this heading#Following the app-loading refactor, two objects in\ndjango.contrib.sites.models needed to be moved because they must be\navailable without importing django.contrib.sites.models when\ndjango.contrib.sites isn’t installed. Import RequestSite from\ndjango.contrib.sites.requests and get_current_site() from\ndjango.contrib.sites.shortcuts. The old import locations will work until\nDjango 1.9.
django.forms.forms.get_declared_fields()Link to this heading#Django no longer uses this functional internally. Even though it’s a private\nAPI, it’ll go through the normal deprecation cycle.
\nPrivate APIs django.db.models.sql.where.WhereNode.make_atom() and\ndjango.db.models.sql.where.Constraint are deprecated in favor of the new\ncustom lookups API.
These features have reached the end of their deprecation cycle and are removed\nin Django 1.7. See Features deprecated in 1.5 for details, including how to\nremove usage of these features.
\ndjango.utils.simplejson is removed.
django.utils.itercompat.product is removed.
INSTALLED_APPS and TEMPLATE_DIRS are no longer corrected from a plain\nstring into a tuple.
HttpResponse,\nSimpleTemplateResponse,\nTemplateResponse,\nrender_to_response(), index(), and\nsitemap() no longer take a mimetype\nargument
HttpResponse immediately consumes its content if it’s\nan iterator.
The AUTH_PROFILE_MODULE setting, and the get_profile() method on\nthe User model are removed.
The cleanup management command is removed.
The daily_cleanup.py script is removed.
select_related() no longer has a\ndepth keyword argument.
The get_warnings_state()/restore_warnings_state()\nfunctions from django.test.utils and the save_warnings_state()/\nrestore_warnings_state()\ndjango.test.*TestCase are removed.
The check_for_test_cookie method in\nAuthenticationForm is removed.
The version of django.contrib.auth.views.password_reset_confirm() that\nsupports base36 encoded user IDs\n(django.contrib.auth.views.password_reset_confirm_uidb36) is removed.
The django.utils.encoding.StrAndUnicode mix-in is removed.