Django 1.7 requires Python 2.7 or above, though we highly recommend
the latest minor release. Support for Python 2.6 has been dropped and support
for Python 3.4 has been added.

This change should affect only a small number of Django users, as most
operating-system vendors today are shipping Python 2.7 or newer as their default
version. If you’re still using Python 2.6, however, you’ll need to stick to
Django 1.6 until you can upgrade your Python version. Per our support
policy, Django 1.6 will continue to receive
security support until the release of Django 1.8.

Django now has built-in support for schema migrations. It allows models
to be updated, changed, and deleted by creating migration files that represent
the model changes and which can be run on any development, staging or production
database.

The allow_syncdb method on database routers is now called allow_migrate,
but still performs the same function. Routers with allow_syncdb methods
will still work, but that method name is deprecated and you should change
it as soon as possible (nothing more than renaming is required).

initial_data fixtures are no longer loaded for apps with migrations; if
you want to load initial data for an app, we suggest you create a migration for
your application and define a RunPython
or RunSQL operation in the operations section of the migration.

Test rollback behavior is different for apps with migrations; in particular,
Django will no longer emulate rollbacks on non-transactional databases or
inside TransactionTestCaseunless specifically requested.

If you are upgrading from South, see our Upgrading from South
documentation, and third-party app authors should read the
South 1.0 release notes
for details on how to support South and Django migrations simultaneously.

Historically, Django applications were tightly linked to models. A singleton
known as the “app cache” dealt with both installed applications and models.
The models module was used as an identifier for applications in many APIs.

As the concept of Django applications matured, this
code showed some shortcomings. It has been refactored into an “app registry”
where models modules no longer have a central role and where it’s possible to
attach configuration data to applications.

Improvements thus far include:

Applications can run code at startup, before Django does anything else, with
the ready() method of their configuration.

Application labels are assigned correctly to models even when they’re
defined outside of models.py. You don’t have to set
app_label explicitly any more.

It is possible to omit models.py entirely if an application doesn’t
have any models.

Applications can be relabeled with the label
attribute of application configurations, to work around label conflicts.

The name of applications can be customized in the admin with the
verbose_name of application configurations.

The admin automatically calls autodiscover()
when Django starts. You can consequently remove this line from your
URLconf.

Django imports all application configurations and models as soon as it
starts, through a deterministic and straightforward process. This should
make it easier to diagnose import issues such as import loops.

To help power both schema migrations and to enable easier addition of
composite keys in future releases of Django, the
Field API now has a new required method:
deconstruct().

This method takes no arguments, and returns a tuple of four items:

name: The field’s attribute name on its parent model, or None if it is not part of a model

path: A dotted, Python path to the class of this field, including the class 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
allowing the field to be copied safely, both essential parts of these new features.

This change should not affect you unless you write custom Field subclasses;
if you do, you may need to reimplement the deconstruct() method if your
subclass changes the method signature of __init__ in any way. If your
field just inherits from a built-in Django field and doesn’t override __init__,
no changes are necessary.

If you do need to override deconstruct(), a good place to start is the
built-in Django fields (django/db/models/fields/__init__.py) as several
fields, including DecimalField and DateField, override it and show how
to 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;
to see what we consider serializable, and to find out how to make your own
classes serializable, read the
migration serialization documentation.

Historically, the recommended way to make reusable model queries was to create
methods on a custom Manager class. The problem with this approach was that
after the first method call, you’d get back a QuerySet instance and
couldn’t call additional custom manager methods.

Though not documented, it was common to work around this issue by creating a
custom QuerySet so that custom methods could be chained; but the solution
had a number of drawbacks:

The custom QuerySet and its custom methods were lost after the first
call to values() or values_list().

Writing a custom Manager was still necessary to return the custom
QuerySet class and all methods that were desired on the Manager
had to be proxied to the QuerySet. The whole process went against
the DRY principle.

We’ve added a new System check framework for
detecting common problems (like invalid models) and providing hints for
resolving those problems. The framework is extensible so you can add your
own checks for your own apps and libraries.

To perform system checks, you use the check management command.
This command replaces the older validate management command.

You can specify the QuerySet used to traverse a given relation
or customize the storage location of prefetch results.

This enables things like filtering prefetched relations, calling
select_related() from a prefetched
relation, or prefetching the same relation multiple times with different
querysets. See prefetch_related()
for more details.

The “today” and “now” shortcuts next to date and time input widgets in the
admin are now operating in the current time zone. Previously, they used the browser time zone,
which could result in saving the wrong value when it didn’t match the current
time zone on the server.

In addition, the widgets now display a help message when the browser and
server time zone are different, to clarify how the value inserted in the field
will be interpreted.

Prior to Python 2.7, database cursors could be used as a context manager. The
specific backend’s cursor defined the behavior of the context manager. The
behavior of magic method lookups was changed with Python 2.7 and cursors were
no longer usable as context managers.

Django 1.7 allows a cursor to be used as a context manager. That is,
the following can be used:

It is now possible to write custom lookups and transforms for the ORM.
Custom lookups work just like Django’s inbuilt lookups (e.g. lte,
icontains) while transforms are a new concept.

The django.db.models.Lookup class provides a way to add lookup
operators for model fields. As an example it is possible to add day_lte
operator for DateFields.

The django.db.models.Transform class allows transformations of
database values prior to the final lookup. For example it is possible to
write a year transform that extracts year from the field’s value.
Transforms allow for chaining. After the year transform has been added
to DateField it is possible to filter on the transformed value, for
example qs.filter(author__birthdate__year__lte=1981).

For more information about both custom lookups and transforms refer to
the custom lookups documentation.

Raising a ValidationError from within certain
functions (e.g. Field.clean(), Form.clean_<fieldname>(), or
Form.clean() for non-field errors.)

Fiddling with Form._errors when targeting a specific field in
Form.clean() or adding errors from outside of a “clean” method
(e.g. directly from a view).

Using the former pattern was straightforward since the form can guess from the
context (i.e. which method raised the exception) where the errors belong and
automatically process them. This remains the canonical way of adding errors
when possible. However the latter was fiddly and error-prone, since the burden
of handling edge cases fell on the user.

The new add_error() method allows adding errors
to specific form fields from anywhere without having to worry about the details
such as creating instances of django.forms.utils.ErrorList or dealing with
Form.cleaned_data. This new API replaces manipulating Form._errors
which now becomes a private API.

The ValidationError constructor accepts metadata
such as error code or params which are then available for interpolating
into the error message (see Raising ValidationError for more details);
however, before Django 1.7 those metadata were discarded as soon as the errors
were added to Form.errors.

Form.errors and
django.forms.utils.ErrorList now store the ValidationError instances
so these metadata can be retrieved at any time through the new
Form.errors.as_data method.

The retrieved ValidationError instances can then be identified thanks to
their error code which enables things like rewriting the error’s message
or writing custom logic in a view when a given error is present. It can also
be used to serialize the errors in a custom format such as XML.

The new Form.errors.as_json()
method is a convenience method which returns error messages along with error
codes serialized as JSON. as_json() uses as_data() and gives an idea
of how the new system could be extended.

Heavy changes to the various error containers were necessary in order
to support the features above, specifically
Form.errors,
django.forms.utils.ErrorList, and the internal storages of
ValidationError. These containers which used
to store error strings now store ValidationError instances and public APIs
have been adapted to make this as transparent as possible, but if you’ve been
using private APIs, some of the changes are backwards incompatible; see
ValidationError constructor and internal storage for more details.

You can now implement site_header,
site_title, and
index_title attributes on a custom
AdminSite in order to easily change the admin
site’s page title and header text. No more needing to override templates!

Buttons in django.contrib.admin now use the border-radius CSS
property for rounded corners rather than GIF background images.

Some admin templates now have app-<app_name> and model-<model_name>
classes in their <body> tag to allow customizing the CSS per app or per
model.

The admin changelist cells now have a field-<field_name> class in the
HTML to enable style customizations.

The CachedStaticFilesStorage
backend gets a sibling class called
ManifestStaticFilesStorage
that doesn’t use the cache system at all but instead a JSON file called
staticfiles.json for storing the mapping between the original file name
(e.g. css/styles.css) and the hashed file name (e.g.
css/styles.55e7cbb9ba48.css). The staticfiles.json file is created
when running the collectstatic management command and should
be a less expensive alternative for remote storages such as Amazon S3.

If you instantiate cache backends directly, be aware that they aren’t
thread-safe any more, as django.core.cache.caches now yields
different instances per thread.

Defining the TIMEOUT argument of the
CACHES setting as None will set the cache keys as
“non-expiring” by default. Previously, it was only possible to pass
timeout=None to the cache backend’s set() method.

File locking on Windows previously depended on the PyWin32 package; if it
wasn’t installed, file locking failed silently. That dependency has been
removed, and file locking is now implemented natively on both Windows
and Unix.

The FileField.upload_to
attribute is now optional. If it is omitted or given None or an empty
string, a subdirectory won’t be used for storing the uploaded files.

Uploaded files are now explicitly closed before the response is delivered to
the client. Partially uploaded files are also closed as long as they are
named file in the upload handler.

Storage.get_available_name() now appends an
underscore plus a random 7 character alphanumeric string (e.g.
"_x3a1gho"), rather than iterating through an underscore followed by a
number (e.g. "_1", "_2", etc.) to prevent a denial-of-service attack.
This 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
RadioSelect and
CheckboxSelectMultiple when looping over the radio
buttons or checkboxes now include for and id attributes, respectively.
Each radio button or checkbox includes an id_for_label attribute to
output the element’s ID.

The <textarea> tags rendered by Textarea now
include a maxlength attribute if the TextField
model field has a max_length.

Field.choices now allows you to
customize the “empty choice” label by including a tuple with an empty string
or None for the key and the custom label as the value. The default blank
option "----------" will be omitted in this case.

MultiValueField allows optional subfields by setting
the require_all_fields argument to False. The required attribute
for each individual field will be respected, and a new incomplete
validation error will be raised when any required fields are empty.

The clean() method on a form no longer needs to
return self.cleaned_data. If it does return a changed dictionary then
that will still be used.

After a temporary regression in Django 1.6, it’s now possible again to make
TypedChoiceFieldcoerce method return an arbitrary
value.

The min_num and validate_min parameters were added to
formset_factory() to allow validating
a minimum number of submitted forms.

The metaclasses used by Form and ModelForm have been reworked to
support more inheritance scenarios. The previous limitation that prevented
inheriting from both Form and ModelForm simultaneously have been
removed as long as ModelForm appears first in the MRO.

It’s now possible to remove a field from a Form when subclassing by
setting the name to None.

It’s now possible to customize the error messages for ModelForm’s
unique, unique_for_date, and unique_together constraints.
In order to support unique_together or any other NON_FIELD_ERROR,
ModelForm now looks for the NON_FIELD_ERROR key in the
error_messages dictionary of the ModelForm’s inner Meta class.
See considerations regarding model’s error_messages for more details.

The LocaleMiddleware now stores the user’s
selected language with the session key _language. This should only be
accessed using the LANGUAGE_SESSION_KEY
constant. Previously it was stored with the key django_language and the
LANGUAGE_SESSION_KEY constant did not exist, but keys reserved for Django
should start with an underscore. For backwards compatibility django_language
is still read from in 1.7. Sessions will be migrated to the new key
as they are written.

The blocktrans tag now supports a trimmed option. This
option will remove newline characters from the beginning and the end of the
content of the {%blocktrans%} tag, replace any whitespace at the
beginning and end of a line and merge all lines into one using a space
character to separate them. This is quite useful for indenting the content of
a {%blocktrans%} tag without having the indentation characters end up
in the corresponding entry in the PO file, which makes the translation
process easier.

The --no-color option for django-admin.py allows you to
disable the colorization of management command output.

The new --natural-foreign and --natural-primary
options for dumpdata, and the new use_natural_foreign_keys and
use_natural_primary_keys arguments for serializers.serialize(), allow
the use of natural primary keys when serializing.

It is no longer necessary to provide the cache table name or the
--database option for the createcachetable command.
Django takes this information from your settings file. If you have configured
multiple caches or multiple databases, all cache tables are created.

On Linux systems, if pyinotify is installed, the development server will
reload immediately when a file is changed. Previously, it polled the
filesystem for changes every second. That caused a small delay before
reloads and reduced battery life on laptops.

In addition, the development server automatically reloads when a
translation file is updated, i.e. after running
compilemessages.

All HTTP requests are logged to the console, including requests for static
files or favicon.ico that used to be filtered out.

Management commands can now produce syntax colored output under Windows if
the ANSICON third-party tool is installed and active.

collectstatic command with symlink option is now supported on
Windows NT 6 (Windows Vista and newer).

The remove() and clear() methods of the related managers created by
ForeignKey and GenericForeignKey now accept the bulk keyword
argument to control whether or not to perform operations in bulk
(i.e. using QuerySet.update()). Defaults to True.

It is now possible to use None as a query value for the iexact
lookup.

It is now possible to pass a callable as value for the attribute
limit_choices_to when defining a
ForeignKey or ManyToManyField.

Calling only() and
defer() on the result of
QuerySet.values() now raises
an error (before that, it would either result in a database error or
incorrect data).

You can use a single list for index_together
(rather than a list of lists) when specifying a single set of fields.

Custom intermediate models having more than one foreign key to any of the
models participating in a many-to-many relationship are now permitted,
provided you explicitly specify which foreign keys should be used by setting
the new ManyToManyField.through_fields
argument.

Assigning a model instance to a non-relation field will now throw an error.
Previously this used to work if the field accepted integers as input as it
took the primary key.

Integer fields are now validated against database backend specific min and
max values based on their internal_type.
Previously model field validation didn’t prevent values out of their associated
column data type range from being saved resulting in an integrity error.

It is now possible to explicitly order_by()
a relation _id field by using its attribute name.

The Context.push() method now returns
a context manager which automatically calls pop() upon exiting the with statement.
Additionally, push() now accepts
parameters that are passed to the dict constructor used to build the new
context level.

Context objects can now be compared for equality (internally, this
uses Context.flatten() so the
internal structure of each Context‘s stack doesn’t matter as long as their
flattened version is identical).

The widthratio template tag now accepts an "as" parameter to
capture the result in a variable.

The include template tag will now also accept anything with a
render() method (such as a Template) as an argument. String
arguments will be looked up using
get_template() as always.

The cache tag will now try to use the cache called
“template_fragments” if it exists and fall back to using the default cache
otherwise. It also now accepts an optional using keyword argument to
control which cache it uses.

The new truncatechars_html filter truncates a string to be no
longer than the specified number of characters, taking HTML into account.

The fetch_redirect_response argument was added to
assertRedirects(). Since the test
client can’t fetch externals URLs, this allows you to use assertRedirects
with redirects that aren’t part of your Django app.

RegexValidator now accepts the optional
flags and
Boolean inverse_match arguments.
The inverse_match attribute
determines if the ValidationError should
be raised when the regular expression pattern matches (True) or does not
match (False, by default) the provided value. The
flags attribute sets the flags
used when compiling a regular expression string.

URLValidator now accepts an optional
schemes argument which allows customization of the accepted URI schemes
(instead of the defaults http(s) and ftp(s)).

validate_email() now accepts addresses with
IPv6 literals, like example@[2001:db8::1], as specified in RFC 5321.

In addition to the changes outlined in this section, be sure to review the
deprecation plan for any features that
have been removed. If you haven’t updated your code within the
deprecation timeline for a given feature, its removal may appear as a
backwards incompatible change.

While Django will still look at allow_syncdb methods even though they
should be renamed to allow_migrate, there is a subtle difference in which
models get passed to these methods.

For apps with migrations, allow_migrate will now get passed
historical models, which are special versioned models
without custom attributes, methods or managers. Make sure your allow_migrate
methods are only referring to fields or other items in model._meta.

Apps with migrations will not load initial_data fixtures when they have
finished migrating. Apps without migrations will continue to load these fixtures
during the phase of migrate which emulates the old syncdb behavior,
but any new apps will not have this support.

Instead, you are encouraged to load initial data in migrations if you need it
(using the RunPython operation and your model classes);
this has the added advantage that your initial data will not need updating
every time you change the schema.

Additionally, like the rest of Django’s old syncdb code, initial_data
has been started down the deprecation path and will be removed in Django 1.9.

Django now requires all Field classes and all of their constructor arguments
to be serializable. If you modify the constructor signature in your custom
Field in any way, you’ll need to implement a deconstruct() method;
we’ve expanded the custom field documentation with instructions
on implementing this method.

The requirement for all field arguments to be
serializable means that any custom class
instances being passed into Field constructors - things like custom Storage
subclasses, for instance - need to have a deconstruct method defined on
them as well, though Django provides a handy
class decorator that will work for most applications.

Django 1.7 loads application configurations and models as soon as it starts.
While this behavior is more straightforward and is believed to be more robust,
regressions cannot be ruled out. See Troubleshooting for
solutions to some problems you may encounter.

If you’re using Django in a plain Python script — rather than a management
command — and you rely on the DJANGO_SETTINGS_MODULE environment
variable, you must now explicitly initialize Django at the beginning of your
script with:

It is no longer possible to have multiple installed applications with the same
label. In previous versions of Django, this didn’t always work correctly, but
didn’t crash outright either.

If you have two apps with the same label, you should create an
AppConfig for one of them and override its
label there. You should then adjust your code
wherever 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
more. As of Django 1.6, this may happen only if you’re manually putting a
directory and a subdirectory on PYTHONPATH. Refer to the section on
the new project layout in the 1.4 release notes for
migration instructions.

Models aren’t imported as a side-effect of loading their application.
Specifically, you shouldn’t import models in the root module of an
application nor in the module that define its configuration class.

Django will enforce these requirements as of version 1.9, after a deprecation
period.

Since INSTALLED_APPS now supports application configuration classes
in addition to application modules, you should review code that accesses this
setting directly and use the app registry (django.apps.apps) instead.

The app registry has preserved some features of the old app cache. Even though
the app cache was a private API, obsolete methods and arguments will be
removed through a standard deprecation path, with the exception of the
following changes that take effect immediately:

get_model raises LookupError instead of returning None when no
model is found.

The only_installed argument of get_model and get_models no
longer exists, nor does the seed_cache argument of get_model.

When several applications provide management commands with the same name,
Django loads the command from the application that comes first in
INSTALLED_APPS. Previous versions loaded the command from the
application that came last.

This brings discovery of management commands in line with other parts of
Django that rely on the order of INSTALLED_APPS, such as static
files, templates, and translations.

The behavior of the ValidationError constructor has changed when it
receives a container of errors as an argument (e.g. a list or an
ErrorList):

It converts any strings it finds to instances of ValidationError
before adding them to its internal storage.

It doesn’t store the given container but rather copies its content to its
own internal storage; previously the container itself was added to the
ValidationError instance and used as internal storage.

This means that if you access the ValidationError internal storages, such
as error_list; error_dict; or the return value of
update_error_dict() you may find instances of ValidationError where you
would have previously found strings.

Also if you directly assigned the return value of update_error_dict()
to Form._errors you may inadvertently add list instances where
ErrorList instances are expected. This is a problem because unlike a
simple list, an ErrorList knows how to handle instances of
ValidationError.

Most use-cases that warranted using these private APIs are now covered by
the newly introduced Form.add_error()
method:

If you need both Django <= 1.6 and 1.7 compatibility you can’t use
Form.add_error() since it
wasn’t available before Django 1.7, but you can use the following
workaround to convert any list into ErrorList:

An inconsistency existed in previous versions of Django regarding how pickle
errors are handled by different cache backends.
django.core.cache.backends.locmem.LocMemCache used to fail silently when
such an error occurs, which is inconsistent with other backends and leads to
cache-specific errors. This has been fixed in Django 1.7, see
Ticket #21200 for more details.

Previous versions of Django generated cache keys using a request’s path and
query string but not the scheme or host. If a Django application was serving
multiple subdomains or domains, cache keys could collide. In Django 1.7, cache
keys vary by the absolute URL of the request including scheme, host, path, and
query string. For example, the URL portion of a cache key is now generated from
http://www.example.com/path/to/?key=val rather than /path/to/?key=val.
The cache keys generated by Django 1.7 will be different from the keys
generated by older versions of Django. After upgrading to Django 1.7, the first
request to any previously cached URL will be a cache miss.

In previous versions of Django, it was possible to use
db_manager(using=None) on a model manager instance to obtain a manager
instance using default routing behavior, overriding any manually specified
database routing. In Django 1.7, a value of None passed to db_manager will
produce a router that retains any manually assigned database routing – the
manager will not be reset. This was necessary to resolve an inconsistency in
the way routing information cascaded over joins. See Ticket #13724 for more
details.

If your project handles datetimes before 1970 or after 2037 and Django raises
a ValueError when encountering them, you will have to install pytz. You
may be affected by this problem if you use Django’s time zone-related date
formats or django.contrib.syndication.

The remove() and clear() methods of the related managers created by
ForeignKey, GenericForeignKey, and ManyToManyField suffered from a
number of issues. Some operations ran multiple data modifying queries without
wrapping them in a transaction, and some operations didn’t respect default
filtering when it was present (i.e. when the default manager on the related
model implemented a custom get_queryset()).

Fixing the issues introduced some backward incompatible changes:

The default implementation of remove() for ForeignKey related managers
changed from a series of Model.save() calls to a single
QuerySet.update() call. The change means that pre_save and
post_save signals aren’t sent anymore. You can use the bulk=False
keyword argument to revert to the previous behavior.

The remove() and clear() methods for GenericForeignKey related
managers now perform bulk delete. The Model.delete() method isn’t called
on each instance anymore. You can use the bulk=False keyword argument to
revert to the previous behavior.

The remove() and clear() methods for ManyToManyField related
managers perform nested queries when filtering is involved, which may or
may not be an issue depending on your database and your data itself.
See this note for more details.

Historically, the Django admin site passed the request from an unauthorized or
unauthenticated user directly to the login view, without HTTP redirection. In
Django 1.7, this behavior changed to conform to a more traditional workflow
where any unauthorized request to an admin page will be redirected (by HTTP
status code 302) to the login page, with the next parameter set to the
referring 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
this_is_the_login_form field (now unused) and the ValidationError code
has been set to the more regular invalid_login key.

Historically, queries that use
select_for_update() could be
executed in autocommit mode, outside of a transaction. Before Django
1.6, Django’s automatic transactions mode allowed this to be used to
lock records until the next write operation. Django 1.6 introduced
database-level autocommit; since then, execution in such a context
voids the effect of select_for_update(). It is, therefore, assumed
now to be an error and raises an exception.

This change was made because such errors can be caused by including an
app which expects global transactions (e.g. ATOMIC_REQUESTS set to True), or Django’s old autocommit
behavior, in a project which runs without them; and further, such
errors may manifest as data-corruption bugs. It was also made in
Django 1.6.3.

This change may cause test failures if you use select_for_update()
in a test class which is a subclass of
TransactionTestCase rather than
TestCase.

The app-loading refactor
deprecated using models from apps which are not part of the
INSTALLED_APPS setting. This exposed an incompatibility between
the default INSTALLED_APPS and MIDDLEWARE_CLASSES in the
global defaults (django.conf.global_settings). To bring these settings in
sync and prevent deprecation warnings when doing things like testing reusable
apps with minimal settings,
SessionMiddleware,
AuthenticationMiddleware, and
MessageMiddleware were removed
from the defaults. These classes will still be included in the default settings
generated by startproject. Most projects will not be affected by
this change but if you were not previously declaring the
MIDDLEWARE_CLASSES in your project settings and relying on the
global default you should ensure that the new defaults are in line with your
project’s needs. You should also check for any code that accesses
django.conf.global_settings.MIDDLEWARE_CLASSES directly.

ModelFormSets no longer
delete instances when save(commit=False) is called. See
can_delete for instructions on how
to manually delete objects from deleted forms.

Loading empty fixtures emits a RuntimeWarning rather than raising
CommandError.

django.contrib.staticfiles.views.serve() will now raise an
Http404 exception instead of
ImproperlyConfigured when DEBUG
is False. This change removes the need to conditionally add the view to
your root URLconf, which in turn makes it safe to reverse by name. It also
removes the ability for visitors to generate spurious HTTP 500 errors by
requesting static files that don’t exist or haven’t been collected yet.

The django.db.models.Model.__eq__() method is now defined in a
way where instances of a proxy model and its base model are considered
equal when primary keys match. Previously only instances of exact same
class were considered equal on primary key match.

The django.db.models.Model.__eq__() method has changed such that
two Model instances without primary key values won’t be considered
equal (unless they are the same instance).

The django.db.models.Model.__hash__() method will now raise TypeError
when called on an instance without a primary key value. This is done to
avoid mutable __hash__ values in containers.

AutoField columns in SQLite databases will now be
created using the AUTOINCREMENT option, which guarantees monotonic
increments. This will cause primary key numbering behavior to change on
SQLite, becoming consistent with most other SQL databases. This will only
apply to newly created tables. If you have a database created with an older
version of Django, you will need to migrate it to take advantage of this
feature. For example, you could do the following:

django.contrib.auth.models.AbstractUser no longer defines a
get_absolute_url() method. The old definition
returned "/users/%s/"%urlquote(self.username) which was arbitrary
since applications may or may not define such a url in urlpatterns.
Define a get_absolute_url() method on your own custom user object or use
ABSOLUTE_URL_OVERRIDES if you want a URL for your user.

The static asset-serving functionality of the
django.test.LiveServerTestCase class has been simplified: Now it’s
only able to serve content already present in STATIC_ROOT when
tests are run. The ability to transparently serve all the static assets
(similarly to what one gets with DEBUG=True at
development-time) has been moved to a new class that lives in the
staticfiles application (the one actually in charge of such feature):
django.contrib.staticfiles.testing.StaticLiveServerTestCase. In other
words, LiveServerTestCase itself is less powerful but at the same time
has less magic.

Rationale behind this is removal of dependency of non-contrib code on
contrib applications.

The old cache URI syntax (e.g. "locmem://") is no longer supported. It
still worked, even though it was not documented or officially supported. If
you’re still using it, please update to the current CACHES syntax.

The default ordering of Form fields in case of inheritance has changed to
follow normal Python MRO. Fields are now discovered by iterating through the
MRO in reverse with the topmost class coming last. This only affects you if
you relied on the default field ordering while having fields defined on both
the current class and on a parent Form.

The required argument of
SelectDateWidget has been removed.
This widget now respects the form field’s is_required attribute like
other widgets.

Widget.is_hidden is now a read-only property, getting its value by
introspecting the presence of input_type=='hidden'.

select_related() now chains in the
same way as other similar calls like prefetch_related. That is,
select_related('foo','bar') is equivalent to
select_related('foo').select_related('bar'). Previously the latter would
have been equivalent to select_related('bar').

GeoDjango dropped support for GEOS < 3.1.

The init_connection_state method of database backends now executes in
autocommit mode (unless you set AUTOCOMMIT
to False). If you maintain a custom database backend, you should check
that method.

The django.db.backends.BaseDatabaseFeatures.allows_primary_key_0
attribute has been renamed to allows_auto_pk_0 to better describe it.
It’s True for all database backends included with Django except MySQL
which does allow primary keys with value 0. It only forbids autoincrement
primary keys with value 0.

Shadowing model fields defined in a parent model has been forbidden as this
creates ambiguity in the expected model behavior. In addition, clashing
fields in the model inheritance hierarchy result in a system check error.
For example, if you use multi-inheritance, you need to define custom primary
key fields on parent models, otherwise the default id fields will clash.
See Multiple inheritance for details.

django.utils.translation.parse_accept_lang_header() now returns
lowercase locales, instead of the case as it was provided. As locales should
be treated case-insensitive this allows us to speed up locale detection.

django.utils.translation.get_language_from_path() and
django.utils.translation.trans_real.get_supported_language_variant()
now no longer have a supported argument.

GenericRelation now supports an
optional related_query_name argument. Setting related_query_name adds
a relation from the related object back to the content type for filtering,
ordering and other query operations.

When running tests on PostgreSQL, the USER will need read access
to the built-in postgres database. This is in lieu of the previous
behavior of connecting to the actual non-test database.

As noted above in the “Cache” section of “Minor Features”, defining the
TIMEOUT argument of the
CACHES setting as None will set the cache keys as
“non-expiring”. Previously, with the memcache backend, a
TIMEOUT of 0 would set non-expiring keys,
but this was inconsistent with the set-and-expire (i.e. no caching) behavior
of set("key","value",timeout=0). If you want non-expiring keys,
please update your settings to use None instead of 0 as the latter
now designates set-and-expire in the settings as well.

The sql* management commands now respect the allow_migrate() method
of DATABASE_ROUTERS. If you have models synced to non-default
databases, use the --database flag to get SQL for those
models (previously they would always be included in the output).

Decoding the query string from URLs now falls back to the ISO-8859-1 encoding
when the input is not valid UTF-8.

The current import_by_path() function
catches AttributeError, ImportError and ValueError exceptions,
and re-raises ImproperlyConfigured. Such
exception masking makes it needlessly hard to diagnose circular import
problems, because it makes it look like the problem comes from inside Django.
It has been deprecated in favor of
import_string().

django.utils.unittest provided uniform access to the unittest2 library
on all Python versions. Since unittest2 became the standard library’s
unittest module in Python 2.7, and Django 1.7 drops support for older
Python versions, this module isn’t useful anymore. It has been deprecated. Use
unittest instead.

As OrderedDict was added to the standard library in
Python 2.7, SortedDict is no longer
needed and has been deprecated.

The two additional, deprecated methods provided by SortedDict (insert()
and value_for_index()) have been removed. If you relied on these methods to
alter structures like form fields, you should now treat these OrderedDicts
as immutable objects and override them to change their content.

For example, you might want to override MyFormClass.base_fields (although
this attribute isn’t considered a public API) to change the ordering of fields
for all MyFormClass instances; or similarly, you could override
self.fields from inside MyFormClass.__init__(), to change the fields
for a particular form instance. For example (from Django itself):

Previously, if models were organized in a package (myapp/models/) rather
than simply myapp/models.py, Django would look for initial SQL data in myapp/models/sql/. This bug has been fixed so that Django
will search myapp/sql/ as documented. After this issue was fixed, migrations
were added which deprecates initial SQL data. Thus, while this change still
exists, the deprecation is irrelevant as the entire feature will be removed in
Django 1.9.

django.contrib.sites provides reduced functionality when it isn’t in
INSTALLED_APPS. The app-loading refactor adds some constraints in
that situation. As a consequence, two objects were moved, and the old
locations are deprecated:

ModelAdmin.declared_fieldsets has been deprecated. Despite being a private
API, it will go through a regular deprecation path. This attribute was mostly
used by methods that bypassed ModelAdmin.get_fieldsets() but this was
considered a bug and has been addressed.

Since django.contrib.contenttypes.generic defined both admin and model
related objects, an import of this module could trigger unexpected side effects.
As a consequence, its contents were split into contenttypes
submodules and the django.contrib.contenttypes.generic module is deprecated:

The syncdb command has been deprecated in favor of the new migrate
command. migrate takes the same arguments as syncdb used to plus a few
more, so it’s safe to just change the name you’re calling and nothing else.

MergeDict exists primarily to support merging POST and GET
arguments into a REQUEST property on WSGIRequest. To merge
dictionaries, use dict.update() instead. The class MergeDict is
deprecated and will be removed in Django 1.9.

The currently used language codes for Simplified Chinese zh-cn,
Traditional Chinese zh-tw and (Western) Frysian fy-nl are deprecated
and should be replaced by the language codes zh-hans, zh-hant and
fy respectively. If you use these language codes, you should rename the
locale directories and update your settings to reflect these changes. The
deprecated language codes will be removed in Django 1.9.

Callable arguments for querysets were an undocumented feature that was
unreliable. It’s been deprecated and will be removed in Django 1.9.

Callable arguments were evaluated when a queryset was constructed rather than
when it was evaluated, thus this feature didn’t offer any benefit compared to
evaluating arguments before passing them to queryset and created confusion that
the arguments may have been evaluated at query time.

requires_model_validation is deprecated in favor of a new
requires_system_checks flag. If the latter flag is missing, then the
value of the former flag is used. Defining both requires_system_checks and
requires_model_validation results in an error.

This method is deprecated in favor of a new check_field method.
The functionality required by check_field() is the same as that provided
by validate_field(), but the output format is different. Third-party database
backends needing this functionality should provide an implementation of
check_field().

Django 1.3 introduced {%loadssifromfuture%} and
{%loadurlfromfuture%} syntax for forward compatibility of the
ssi and url template tags. This syntax is now deprecated and
will be removed in Django 1.9. You can simply remove the
{%load...fromfuture%} tags.

javascript_quote() was an undocumented function present in django.utils.text.
It was used internally in the javascript_catalog view
whose implementation was changed to make use of json.dumps() instead.
If you were relying on this function to provide safe output from untrusted
strings, you should use django.utils.html.escapejs or the
escapejs template filter.
If all you need is to generate valid javascript strings, you can simply use
json.dumps().

The django.utils.html.fix_ampersands method and the fix_ampersands
template filter are deprecated, as the escaping of ampersands is already taken care
of by Django’s standard HTML escaping features. Combining this with fix_ampersands
would either result in double escaping, or, if the output is assumed to be safe,
a risk of introducing XSS vulnerabilities. Along with fix_ampersands,
django.utils.html.clean_html is deprecated, an undocumented function that calls
fix_ampersands.
As this is an accelerated deprecation, fix_ampersands and clean_html
will be removed in Django 1.8.

All database settings with a TEST_ prefix have been deprecated in favor of
entries in a TEST dictionary in the database
settings. The old settings will be supported until Django 1.9. For backwards
compatibility with older versions of Django, you can define both versions of
the settings as long as they match.

Following the app-loading refactor, two objects in
django.contrib.sites.models needed to be moved because they must be
available without importing django.contrib.sites.models when
django.contrib.sites isn’t installed. Import RequestSite from
django.contrib.sites.requests and get_current_site() from
django.contrib.sites.shortcuts. The old import locations will work until
Django 1.9.