From 4129201c3e0fa057c198bdefcb34686a23b4a93c Mon Sep 17 00:00:00 2001
From: Florian Apolloner <florian@apolloner.eu>
Date: Mon, 30 Jul 2012 22:01:50 +0200
Subject: Fixed a security issue in http redirects. Disclosure and new release
 forthcoming.

---
 tests/regressiontests/httpwrappers/tests.py | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

(limited to 'tests')

diff --git a/tests/regressiontests/httpwrappers/tests.py b/tests/regressiontests/httpwrappers/tests.py
index 9b599db6d0..0f61c2d840 100644
--- a/tests/regressiontests/httpwrappers/tests.py
+++ b/tests/regressiontests/httpwrappers/tests.py
@@ -4,8 +4,11 @@ from __future__ import unicode_literals
 import copy
 import pickle
 
-from django.http import (QueryDict, HttpResponse, SimpleCookie, BadHeaderError,
-        parse_cookie)
+from django.core.exceptions import SuspiciousOperation
+from django.http import (QueryDict, HttpResponse, HttpResponseRedirect,
+                         HttpResponsePermanentRedirect,
+                         SimpleCookie, BadHeaderError,
+                         parse_cookie)
 from django.utils import unittest
 
 
@@ -309,6 +312,18 @@ class HttpResponseTests(unittest.TestCase):
         r = HttpResponse(['abc'])
         self.assertRaises(Exception, r.write, 'def')
 
+    def test_unsafe_redirect(self):
+        bad_urls = [
+            'data:text/html,<script>window.alert("xss")</script>',
+            'mailto:test@example.com',
+            'file:///etc/passwd',
+        ]
+        for url in bad_urls:
+            self.assertRaises(SuspiciousOperation,
+                              HttpResponseRedirect, url)
+            self.assertRaises(SuspiciousOperation,
+                              HttpResponsePermanentRedirect, url)
+
 
 class CookieTests(unittest.TestCase):
     def test_encode(self):
-- 
cgit v1.3


From d01eaf7104e96b2fcf373ddfbc80ef4568bd0387 Mon Sep 17 00:00:00 2001
From: Aymeric Augustin <aymeric.augustin@m4x.org>
Date: Fri, 3 Aug 2012 18:46:30 +0200
Subject: [py3] Removed uses of sys.maxint under Python 3.

Also fixed #18706: improved exceptions raised by int_to_base36.
---
 django/utils/http.py                | 14 ++++++++++----
 docs/ref/utils.txt                  |  6 ++++--
 docs/releases/1.5.txt               |  3 +++
 tests/regressiontests/utils/http.py | 26 ++++++++++++++------------
 4 files changed, 31 insertions(+), 18 deletions(-)

(limited to 'tests')

diff --git a/django/utils/http.py b/django/utils/http.py
index f3a3dce58c..272e73f190 100644
--- a/django/utils/http.py
+++ b/django/utils/http.py
@@ -167,8 +167,9 @@ def base36_to_int(s):
     if len(s) > 13:
         raise ValueError("Base36 input too large")
     value = int(s, 36)
-    # ... then do a final check that the value will fit into an int.
-    if value > sys.maxint:
+    # ... then do a final check that the value will fit into an int to avoid
+    # returning a long (#15067). The long type was removed in Python 3.
+    if not six.PY3 and value > sys.maxint:
         raise ValueError("Base36 input too large")
     return value
 
@@ -178,8 +179,13 @@ def int_to_base36(i):
     """
     digits = "0123456789abcdefghijklmnopqrstuvwxyz"
     factor = 0
-    if not 0 <= i <= sys.maxint:
-        raise ValueError("Base36 conversion input too large or incorrect type.")
+    if i < 0:
+        raise ValueError("Negative base36 conversion input.")
+    if not six.PY3:
+        if not isinstance(i, six.integer_types):
+            raise TypeError("Non-integer base36 conversion input.")
+        if i > sys.maxint:
+            raise ValueError("Base36 conversion input too large.")
     # Find starting factor
     while True:
         factor += 1
diff --git a/docs/ref/utils.txt b/docs/ref/utils.txt
index c2f2025bc3..5157c399da 100644
--- a/docs/ref/utils.txt
+++ b/docs/ref/utils.txt
@@ -504,11 +504,13 @@ escaping HTML.
 
 .. function:: base36_to_int(s)
 
-    Converts a base 36 string to an integer.
+    Converts a base 36 string to an integer. On Python 2 the output is
+    guaranteed to be an :class:`int` and not a :class:`long`.
 
 .. function:: int_to_base36(i)
 
-    Converts a positive integer less than sys.maxint to a base 36 string.
+    Converts a positive integer to a base 36 string. On Python 2 ``i`` must be
+    smaller than :attr:`sys.maxint`.
 
 ``django.utils.safestring``
 ===========================
diff --git a/docs/releases/1.5.txt b/docs/releases/1.5.txt
index aae8b25e07..968d63e1f3 100644
--- a/docs/releases/1.5.txt
+++ b/docs/releases/1.5.txt
@@ -244,6 +244,9 @@ Miscellaneous
 
 * GeoDjango dropped support for GDAL < 1.5
 
+* :func:`~django.utils.http.int_to_base36` properly raises a :exc:`TypeError`
+  instead of :exc:`ValueError` for non-integer inputs.
+
 Features deprecated in 1.5
 ==========================
 
diff --git a/tests/regressiontests/utils/http.py b/tests/regressiontests/utils/http.py
index 67dcd7af89..f22e05496d 100644
--- a/tests/regressiontests/utils/http.py
+++ b/tests/regressiontests/utils/http.py
@@ -1,10 +1,11 @@
 import sys
 
-from django.utils import http
-from django.utils import unittest
-from django.utils.datastructures import MultiValueDict
 from django.http import HttpResponse, utils
 from django.test import RequestFactory
+from django.utils.datastructures import MultiValueDict
+from django.utils import http
+from django.utils import six
+from django.utils import unittest
 
 class TestUtilsHttp(unittest.TestCase):
 
@@ -110,22 +111,23 @@ class TestUtilsHttp(unittest.TestCase):
 
     def test_base36(self):
         # reciprocity works
-        for n in [0, 1, 1000, 1000000, sys.maxint]:
+        for n in [0, 1, 1000, 1000000]:
             self.assertEqual(n, http.base36_to_int(http.int_to_base36(n)))
+        if not six.PY3:
+            self.assertEqual(sys.maxint, http.base36_to_int(http.int_to_base36(sys.maxint)))
 
         # bad input
-        for n in [-1, sys.maxint+1, '1', 'foo', {1:2}, (1,2,3)]:
-            self.assertRaises(ValueError, http.int_to_base36, n)
-        
+        self.assertRaises(ValueError, http.int_to_base36, -1)
+        if not six.PY3:
+            self.assertRaises(ValueError, http.int_to_base36, sys.maxint + 1)
+        for n in ['1', 'foo', {1: 2}, (1, 2, 3), 3.141]:
+            self.assertRaises(TypeError, http.int_to_base36, n)
+
         for n in ['#', ' ']:
             self.assertRaises(ValueError, http.base36_to_int, n)
-
-        for n in [123, {1:2}, (1,2,3)]:
+        for n in [123, {1: 2}, (1, 2, 3), 3.141]:
             self.assertRaises(TypeError, http.base36_to_int, n)
 
-        # non-integer input
-        self.assertRaises(TypeError, http.int_to_base36, 3.141)
-        
         # more explicit output testing
         for n, b36 in [(0, '0'), (1, '1'), (42, '16'), (818469960, 'django')]:
             self.assertEqual(http.int_to_base36(n), b36)
-- 
cgit v1.3


From 10f979fd92000de1ac9713351f5cb749e2cbca03 Mon Sep 17 00:00:00 2001
From: Simon Meers <simon@simonmeers.com>
Date: Fri, 3 Aug 2012 10:03:52 +1000
Subject: Fixed #18700 -- Added URL reversal for i18n set_language view.

---
 django/conf/urls/i18n.py                  | 4 ++--
 docs/topics/i18n/translation.txt          | 2 +-
 tests/regressiontests/views/tests/i18n.py | 4 ++++
 3 files changed, 7 insertions(+), 3 deletions(-)

(limited to 'tests')

diff --git a/django/conf/urls/i18n.py b/django/conf/urls/i18n.py
index 6e56af8271..426c2b2d30 100644
--- a/django/conf/urls/i18n.py
+++ b/django/conf/urls/i18n.py
@@ -1,5 +1,5 @@
 from django.conf import settings
-from django.conf.urls import patterns
+from django.conf.urls import patterns, url
 from django.core.urlresolvers import LocaleRegexURLResolver
 
 def i18n_patterns(prefix, *args):
@@ -16,5 +16,5 @@ def i18n_patterns(prefix, *args):
 
 
 urlpatterns = patterns('',
-    (r'^setlang/$', 'django.views.i18n.set_language'),
+    url(r'^setlang/$', 'django.views.i18n.set_language', name='set_language'),
 )
diff --git a/docs/topics/i18n/translation.txt b/docs/topics/i18n/translation.txt
index 988948e259..bdbb04823d 100644
--- a/docs/topics/i18n/translation.txt
+++ b/docs/topics/i18n/translation.txt
@@ -1272,7 +1272,7 @@ Here's example HTML template code:
 
 .. code-block:: html+django
 
-    <form action="/i18n/setlang/" method="post">
+    <form action="{% url 'set_language' %}" method="post">
     {% csrf_token %}
     <input name="next" type="hidden" value="{{ redirect_to }}" />
     <select name="language">
diff --git a/tests/regressiontests/views/tests/i18n.py b/tests/regressiontests/views/tests/i18n.py
index 9993ae959c..cb580267d2 100644
--- a/tests/regressiontests/views/tests/i18n.py
+++ b/tests/regressiontests/views/tests/i18n.py
@@ -5,6 +5,7 @@ import gettext
 from os import path
 
 from django.conf import settings
+from django.core.urlresolvers import reverse
 from django.test import TestCase
 from django.utils.translation import override, activate, get_language
 from django.utils.text import javascript_quote
@@ -23,6 +24,9 @@ class I18NTests(TestCase):
             self.assertRedirects(response, 'http://testserver/views/')
             self.assertEqual(self.client.session['django_language'], lang_code)
 
+    def test_setlang_reversal(self):
+        self.assertEqual(reverse('set_language'), '/views/i18n/setlang/')
+
     def test_jsi18n(self):
         """The javascript_catalog can be deployed with language settings"""
         saved_lang = get_language()
-- 
cgit v1.3


From 121fd109de09ece4e263e508f9034df9b583da46 Mon Sep 17 00:00:00 2001
From: Claude Paroz <claude@2xlibre.net>
Date: Sat, 4 Aug 2012 14:17:02 +0200
Subject: Fixed #5524 -- Do not remove cleaned_data when a form fails
 validation

cleaned_data is no longer deleted when form validation fails but only
contains the data that did validate.
Thanks to the various contributors to this patch (see ticket).
---
 django/contrib/formtools/tests/__init__.py |  2 +-
 django/forms/forms.py                      |  2 --
 django/forms/models.py                     | 25 ++++++++++++-------------
 docs/ref/forms/api.txt                     | 21 ++++++++++++---------
 docs/ref/forms/validation.txt              | 10 ++++++----
 docs/releases/1.5.txt                      | 10 ++++++++++
 tests/modeltests/model_forms/tests.py      |  3 +--
 tests/regressiontests/forms/tests/forms.py | 24 ++++--------------------
 8 files changed, 46 insertions(+), 51 deletions(-)

(limited to 'tests')

diff --git a/django/contrib/formtools/tests/__init__.py b/django/contrib/formtools/tests/__init__.py
index 3bccb55034..ee93479cbd 100644
--- a/django/contrib/formtools/tests/__init__.py
+++ b/django/contrib/formtools/tests/__init__.py
@@ -317,7 +317,7 @@ class WizardTests(TestCase):
 
         class WizardWithProcessStep(TestWizardClass):
             def process_step(self, request, form, step):
-                that.assertTrue(hasattr(form, 'cleaned_data'))
+                that.assertTrue(form.is_valid())
                 reached[0] = True
 
         wizard = WizardWithProcessStep([WizardPageOneForm,
diff --git a/django/forms/forms.py b/django/forms/forms.py
index 4bc3ee9d26..4d4cdbe3db 100644
--- a/django/forms/forms.py
+++ b/django/forms/forms.py
@@ -271,8 +271,6 @@ class BaseForm(StrAndUnicode):
         self._clean_fields()
         self._clean_form()
         self._post_clean()
-        if self._errors:
-            del self.cleaned_data
 
     def _clean_fields(self):
         for name, field in self.fields.items():
diff --git a/django/forms/models.py b/django/forms/models.py
index b5939b6be3..e6ae357d19 100644
--- a/django/forms/models.py
+++ b/django/forms/models.py
@@ -506,7 +506,7 @@ class BaseModelFormSet(BaseFormSet):
         all_unique_checks = set()
         all_date_checks = set()
         for form in self.forms:
-            if not hasattr(form, 'cleaned_data'):
+            if not form.is_valid():
                 continue
             exclude = form._get_validation_exclusions()
             unique_checks, date_checks = form.instance._get_unique_checks(exclude=exclude)
@@ -518,21 +518,21 @@ class BaseModelFormSet(BaseFormSet):
         for uclass, unique_check in all_unique_checks:
             seen_data = set()
             for form in self.forms:
-                # if the form doesn't have cleaned_data then we ignore it,
-                # it's already invalid
-                if not hasattr(form, "cleaned_data"):
+                if not form.is_valid():
                     continue
                 # get data for each field of each of unique_check
                 row_data = tuple([form.cleaned_data[field] for field in unique_check if field in form.cleaned_data])
                 if row_data and not None in row_data:
-                    # if we've aready seen it then we have a uniqueness failure
+                    # if we've already seen it then we have a uniqueness failure
                     if row_data in seen_data:
                         # poke error messages into the right places and mark
                         # the form as invalid
                         errors.append(self.get_unique_error_message(unique_check))
                         form._errors[NON_FIELD_ERRORS] = self.error_class([self.get_form_error()])
-                        del form.cleaned_data
-                        break
+                        # remove the data from the cleaned_data dict since it was invalid
+                        for field in unique_check:
+                            if field in form.cleaned_data:
+                                del form.cleaned_data[field]
                     # mark the data as seen
                     seen_data.add(row_data)
         # iterate over each of the date checks now
@@ -540,9 +540,7 @@ class BaseModelFormSet(BaseFormSet):
             seen_data = set()
             uclass, lookup, field, unique_for = date_check
             for form in self.forms:
-                # if the form doesn't have cleaned_data then we ignore it,
-                # it's already invalid
-                if not hasattr(self, 'cleaned_data'):
+                if not form.is_valid():
                     continue
                 # see if we have data for both fields
                 if (form.cleaned_data and form.cleaned_data[field] is not None
@@ -556,14 +554,15 @@ class BaseModelFormSet(BaseFormSet):
                     else:
                         date_data = (getattr(form.cleaned_data[unique_for], lookup),)
                     data = (form.cleaned_data[field],) + date_data
-                    # if we've aready seen it then we have a uniqueness failure
+                    # if we've already seen it then we have a uniqueness failure
                     if data in seen_data:
                         # poke error messages into the right places and mark
                         # the form as invalid
                         errors.append(self.get_date_error_message(date_check))
                         form._errors[NON_FIELD_ERRORS] = self.error_class([self.get_form_error()])
-                        del form.cleaned_data
-                        break
+                        # remove the data from the cleaned_data dict since it was invalid
+                        del form.cleaned_data[field]
+                    # mark the data as seen
                     seen_data.add(data)
         if errors:
             raise ValidationError(errors)
diff --git a/docs/ref/forms/api.txt b/docs/ref/forms/api.txt
index 50488b026a..777d73e015 100644
--- a/docs/ref/forms/api.txt
+++ b/docs/ref/forms/api.txt
@@ -199,8 +199,8 @@ Note that any text-based field -- such as ``CharField`` or ``EmailField`` --
 always cleans the input into a Unicode string. We'll cover the encoding
 implications later in this document.
 
-If your data does *not* validate, your ``Form`` instance will not have a
-``cleaned_data`` attribute::
+If your data does *not* validate, the ``cleaned_data`` dictionary contains
+only the valid fields::
 
     >>> data = {'subject': '',
     ...         'message': 'Hi there',
@@ -210,9 +210,12 @@ If your data does *not* validate, your ``Form`` instance will not have a
     >>> f.is_valid()
     False
     >>> f.cleaned_data
-    Traceback (most recent call last):
-    ...
-    AttributeError: 'ContactForm' object has no attribute 'cleaned_data'
+    {'cc_myself': True, 'message': u'Hi there'}
+
+.. versionchanged:: 1.5
+
+Until Django 1.5, the ``cleaned_data`` attribute wasn't defined at all when
+the ``Form`` didn't validate.
 
 ``cleaned_data`` will always *only* contain a key for fields defined in the
 ``Form``, even if you pass extra data when you define the ``Form``. In this
@@ -232,9 +235,9 @@ but ``cleaned_data`` contains only the form's fields::
     >>> f.cleaned_data # Doesn't contain extra_field_1, etc.
     {'cc_myself': True, 'message': u'Hi there', 'sender': u'foo@example.com', 'subject': u'hello'}
 
-``cleaned_data`` will include a key and value for *all* fields defined in the
-``Form``, even if the data didn't include a value for fields that are not
-required. In this example, the data dictionary doesn't include a value for the
+When the ``Form`` is valid, ``cleaned_data`` will include a key and value for
+*all* its fields, even if the data didn't include a value for some optional
+fields. In this example, the data dictionary doesn't include a value for the
 ``nick_name`` field, but ``cleaned_data`` includes it, with an empty value::
 
     >>> class OptionalPersonForm(Form):
@@ -583,7 +586,7 @@ lazy developers -- they're not the only way a form object can be displayed.
 
    Used to display HTML or access attributes for a single field of a
    :class:`Form` instance.
-   
+
    The :meth:`__unicode__` and :meth:`__str__` methods of this object displays
    the HTML for this field.
 
diff --git a/docs/ref/forms/validation.txt b/docs/ref/forms/validation.txt
index 97883d7880..95424d0cd0 100644
--- a/docs/ref/forms/validation.txt
+++ b/docs/ref/forms/validation.txt
@@ -362,7 +362,9 @@ Secondly, once we have decided that the combined data in the two fields we are
 considering aren't valid, we must remember to remove them from the
 ``cleaned_data``.
 
-In fact, Django will currently completely wipe out the ``cleaned_data``
-dictionary if there are any errors in the form. However, this behavior may
-change in the future, so it's not a bad idea to clean up after yourself in the
-first place.
+.. versionchanged:: 1.5
+
+Django used to remove the ``cleaned_data`` attribute entirely if there were
+any errors in the form. Since version 1.5, ``cleaned_data`` is present even if
+the form doesn't validate, but it contains only field values that did
+validate.
diff --git a/docs/releases/1.5.txt b/docs/releases/1.5.txt
index 968d63e1f3..3a9b2d859a 100644
--- a/docs/releases/1.5.txt
+++ b/docs/releases/1.5.txt
@@ -239,6 +239,16 @@ database state behind or unit tests that rely on some form of state being
 preserved after the execution of other tests. Such tests are already very
 fragile, and must now be changed to be able to run independently.
 
+`cleaned_data` dictionary kept for invalid forms
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The :attr:`~django.forms.Form.cleaned_data` dictionary is now always present
+after form validation. When the form doesn't validate, it contains only the
+fields that passed validation. You should test the success of the validation
+with the :meth:`~django.forms.Form.is_valid()` method and not with the
+presence or absence of the :attr:`~django.forms.Form.cleaned_data` attribute
+on the form.
+
 Miscellaneous
 ~~~~~~~~~~~~~
 
diff --git a/tests/modeltests/model_forms/tests.py b/tests/modeltests/model_forms/tests.py
index fc37a25872..1da7f583be 100644
--- a/tests/modeltests/model_forms/tests.py
+++ b/tests/modeltests/model_forms/tests.py
@@ -638,8 +638,7 @@ class OldFormForXTests(TestCase):
         f = BaseCategoryForm({'name': '', 'slug': 'not a slug!', 'url': 'foo'})
         self.assertEqual(f.errors['name'], ['This field is required.'])
         self.assertEqual(f.errors['slug'], ["Enter a valid 'slug' consisting of letters, numbers, underscores or hyphens."])
-        with self.assertRaises(AttributeError):
-            f.cleaned_data
+        self.assertEqual(f.cleaned_data, {'url': 'foo'})
         with self.assertRaises(ValueError):
             f.save()
         f = BaseCategoryForm({'name': '', 'slug': '', 'url': 'foo'})
diff --git a/tests/regressiontests/forms/tests/forms.py b/tests/regressiontests/forms/tests/forms.py
index 7e1c8384a0..a8a28ba806 100644
--- a/tests/regressiontests/forms/tests/forms.py
+++ b/tests/regressiontests/forms/tests/forms.py
@@ -82,11 +82,7 @@ class FormsTestCase(TestCase):
         self.assertEqual(p.errors['last_name'], ['This field is required.'])
         self.assertEqual(p.errors['birthday'], ['This field is required.'])
         self.assertFalse(p.is_valid())
-        try:
-            p.cleaned_data
-            self.fail('Attempts to access cleaned_data when validation fails should fail.')
-        except AttributeError:
-            pass
+        self.assertEqual(p.cleaned_data, {})
         self.assertHTMLEqual(str(p), """<tr><th><label for="id_first_name">First name:</label></th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="text" name="first_name" id="id_first_name" /></td></tr>
 <tr><th><label for="id_last_name">Last name:</label></th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="text" name="last_name" id="id_last_name" /></td></tr>
 <tr><th><label for="id_birthday">Birthday:</label></th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="text" name="birthday" id="id_birthday" /></td></tr>""")
@@ -145,11 +141,7 @@ class FormsTestCase(TestCase):
   * This field is required.
 * birthday
   * This field is required.""")
-        try:
-            p.cleaned_data
-            self.fail('Attempts to access cleaned_data when validation fails should fail.')
-        except AttributeError:
-            pass
+        self.assertEqual(p.cleaned_data, {'last_name': 'Lennon'})
         self.assertEqual(p['first_name'].errors, ['This field is required.'])
         self.assertHTMLEqual(p['first_name'].errors.as_ul(), '<ul class="errorlist"><li>This field is required.</li></ul>')
         self.assertEqual(p['first_name'].errors.as_text(), '* This field is required.')
@@ -1678,11 +1670,7 @@ class FormsTestCase(TestCase):
         form = SongForm(data, empty_permitted=False)
         self.assertFalse(form.is_valid())
         self.assertEqual(form.errors, {'name': ['This field is required.'], 'artist': ['This field is required.']})
-        try:
-            form.cleaned_data
-            self.fail('Attempts to access cleaned_data when validation fails should fail.')
-        except AttributeError:
-            pass
+        self.assertEqual(form.cleaned_data, {})
 
         # Now let's show what happens when empty_permitted=True and the form is empty.
         form = SongForm(data, empty_permitted=True)
@@ -1696,11 +1684,7 @@ class FormsTestCase(TestCase):
         form = SongForm(data, empty_permitted=False)
         self.assertFalse(form.is_valid())
         self.assertEqual(form.errors, {'name': ['This field is required.']})
-        try:
-            form.cleaned_data
-            self.fail('Attempts to access cleaned_data when validation fails should fail.')
-        except AttributeError:
-            pass
+        self.assertEqual(form.cleaned_data, {'artist': 'The Doors'})
 
         # If a field is not given in the data then None is returned for its data. Lets
         # make sure that when checking for empty_permitted that None is treated
-- 
cgit v1.3


From ad237fb72f769bbd99b5ed6e3292bead614e1c94 Mon Sep 17 00:00:00 2001
From: Brendan MacDonell <brendan@macdonell.net>
Date: Mon, 6 Aug 2012 10:42:21 +0200
Subject: Fixed #18724 -- Fixed IntegerField validation with value 0

---
 django/db/models/fields/__init__.py         | 3 ++-
 tests/regressiontests/model_fields/tests.py | 4 ++++
 2 files changed, 6 insertions(+), 1 deletion(-)

(limited to 'tests')

diff --git a/django/db/models/fields/__init__.py b/django/db/models/fields/__init__.py
index 9606b1b843..de24a24ed1 100644
--- a/django/db/models/fields/__init__.py
+++ b/django/db/models/fields/__init__.py
@@ -179,7 +179,8 @@ class Field(object):
         if not self.editable:
             # Skip validation for non-editable fields.
             return
-        if self._choices and value:
+
+        if self._choices and value not in validators.EMPTY_VALUES:
             for option_key, option_value in self.choices:
                 if isinstance(option_value, (list, tuple)):
                     # This is an optgroup, so look inside the group for
diff --git a/tests/regressiontests/model_fields/tests.py b/tests/regressiontests/model_fields/tests.py
index e86159463d..7d6071accc 100644
--- a/tests/regressiontests/model_fields/tests.py
+++ b/tests/regressiontests/model_fields/tests.py
@@ -274,6 +274,10 @@ class ValidationTest(test.TestCase):
         self.assertRaises(ValidationError, f.clean, None, None)
         self.assertRaises(ValidationError, f.clean, '', None)
 
+    def test_integerfield_validates_zero_against_choices(self):
+        f = models.IntegerField(choices=((1, 1),))
+        self.assertRaises(ValidationError, f.clean, '0', None)
+
     def test_charfield_raises_error_on_empty_input(self):
         f = models.CharField(null=False)
         self.assertRaises(ValidationError, f.clean, None, None)
-- 
cgit v1.3


From ee191715eae73362768184aa95206cf61bac5d38 Mon Sep 17 00:00:00 2001
From: Aymeric Augustin <aymeric.augustin@m4x.org>
Date: Fri, 20 Jul 2012 21:14:27 +0200
Subject: [py3] Fixed access to dict keys/values/items.

---
 django/conf/__init__.py                            |  2 +-
 django/contrib/admin/helpers.py                    |  4 ++--
 django/contrib/admin/options.py                    |  6 +++---
 django/contrib/admin/sites.py                      |  7 +++---
 django/contrib/admin/templatetags/admin_list.py    |  3 ++-
 django/contrib/admindocs/views.py                  |  5 +++--
 django/contrib/auth/admin.py                       |  3 ++-
 django/contrib/auth/tests/forms.py                 |  3 ++-
 django/contrib/contenttypes/management.py          |  5 +++--
 django/contrib/databrowse/datastructures.py        |  8 +++----
 django/contrib/databrowse/plugins/calendars.py     |  2 +-
 django/contrib/databrowse/plugins/fieldchoices.py  |  2 +-
 django/contrib/formtools/wizard/storage/base.py    |  7 +++---
 django/contrib/formtools/wizard/views.py           |  8 +++----
 django/contrib/gis/db/backends/mysql/operations.py |  4 +++-
 .../contrib/gis/db/backends/oracle/operations.py   |  2 +-
 .../contrib/gis/db/backends/postgis/operations.py  |  4 ++--
 .../gis/db/backends/spatialite/operations.py       |  2 +-
 django/contrib/gis/db/models/query.py              |  5 +++--
 django/contrib/gis/db/models/sql/compiler.py       |  5 +++--
 django/contrib/gis/geometry/test_data.py           |  3 ++-
 django/contrib/gis/measure.py                      |  2 +-
 django/contrib/gis/sitemaps/views.py               |  3 ++-
 django/contrib/messages/storage/cookie.py          |  3 ++-
 django/contrib/sessions/tests.py                   | 19 ++++++++--------
 django/contrib/sitemaps/views.py                   |  3 ++-
 django/contrib/staticfiles/finders.py              |  3 ++-
 django/core/management/__init__.py                 |  5 +++--
 django/core/management/commands/diffsettings.py    |  4 +---
 django/core/serializers/__init__.py                |  5 +++--
 django/core/serializers/python.py                  |  3 ++-
 django/core/urlresolvers.py                        |  2 +-
 django/core/validators.py                          |  2 +-
 django/db/backends/mysql/introspection.py          |  3 ++-
 django/db/models/base.py                           |  4 ++--
 django/db/models/deletion.py                       | 25 +++++++++++-----------
 django/db/models/fields/related.py                 |  8 +++----
 django/db/models/loading.py                        |  5 +++--
 django/db/models/options.py                        | 17 +++++++--------
 django/db/models/query.py                          | 20 ++++++++---------
 django/db/models/query_utils.py                    |  5 +++--
 django/db/models/sql/compiler.py                   |  7 +++---
 django/db/models/sql/query.py                      | 25 +++++++++++-----------
 django/db/models/sql/subqueries.py                 |  5 +++--
 django/forms/extras/widgets.py                     |  2 +-
 django/forms/forms.py                              |  6 +++---
 django/forms/models.py                             |  3 ++-
 django/forms/widgets.py                            |  3 +--
 django/template/base.py                            |  2 +-
 django/template/defaulttags.py                     |  5 +++--
 django/template/loader_tags.py                     |  5 +++--
 django/templatetags/i18n.py                        |  2 +-
 django/utils/dateparse.py                          |  7 +++---
 django/utils/dictconfig.py                         |  2 +-
 django/utils/functional.py                         |  2 +-
 django/utils/html.py                               |  2 +-
 django/utils/termcolors.py                         |  4 +++-
 django/views/debug.py                              |  2 +-
 django/views/generic/base.py                       |  3 ++-
 tests/modeltests/timezones/tests.py                |  9 ++++----
 tests/regressiontests/aggregation_regress/tests.py |  3 ++-
 tests/regressiontests/db_typecasts/tests.py        |  3 ++-
 .../templates/templatetags/custom.py               |  6 +++---
 tests/regressiontests/templates/tests.py           |  3 ++-
 64 files changed, 187 insertions(+), 155 deletions(-)

(limited to 'tests')

diff --git a/django/conf/__init__.py b/django/conf/__init__.py
index 77454b3fb9..6325ccb1a9 100644
--- a/django/conf/__init__.py
+++ b/django/conf/__init__.py
@@ -158,7 +158,7 @@ class UserSettingsHolder(BaseSettings):
         return getattr(self.default_settings, name)
 
     def __dir__(self):
-        return self.__dict__.keys() + dir(self.default_settings)
+        return list(six.iterkeys(self.__dict__)) + dir(self.default_settings)
 
     # For Python < 2.6:
     __members__ = property(lambda self: self.__dir__())
diff --git a/django/contrib/admin/helpers.py b/django/contrib/admin/helpers.py
index 1bc843cdf9..4fc78784f4 100644
--- a/django/contrib/admin/helpers.py
+++ b/django/contrib/admin/helpers.py
@@ -325,11 +325,11 @@ class AdminErrorList(forms.util.ErrorList):
     """
     def __init__(self, form, inline_formsets):
         if form.is_bound:
-            self.extend(form.errors.values())
+            self.extend(list(six.itervalues(form.errors)))
             for inline_formset in inline_formsets:
                 self.extend(inline_formset.non_form_errors())
                 for errors_in_inline_form in inline_formset.errors:
-                    self.extend(errors_in_inline_form.values())
+                    self.extend(list(six.itervalues(errors_in_inline_form)))
 
 def normalize_fieldsets(fieldsets):
     """
diff --git a/django/contrib/admin/options.py b/django/contrib/admin/options.py
index c13a6bc5cc..ea28125a5f 100644
--- a/django/contrib/admin/options.py
+++ b/django/contrib/admin/options.py
@@ -425,7 +425,7 @@ class ModelAdmin(BaseModelAdmin):
         if self.declared_fieldsets:
             return self.declared_fieldsets
         form = self.get_form(request, obj)
-        fields = form.base_fields.keys() + list(self.get_readonly_fields(request, obj))
+        fields = list(six.iterkeys(form.base_fields)) + list(self.get_readonly_fields(request, obj))
         return [(None, {'fields': fields})]
 
     def get_form(self, request, obj=None, **kwargs):
@@ -608,7 +608,7 @@ class ModelAdmin(BaseModelAdmin):
         tuple (name, description).
         """
         choices = [] + default_choices
-        for func, name, description in self.get_actions(request).itervalues():
+        for func, name, description in six.itervalues(self.get_actions(request)):
             choice = (name, description % model_format_dict(self.opts))
             choices.append(choice)
         return choices
@@ -1415,7 +1415,7 @@ class InlineModelAdmin(BaseModelAdmin):
         if self.declared_fieldsets:
             return self.declared_fieldsets
         form = self.get_formset(request, obj).form
-        fields = form.base_fields.keys() + list(self.get_readonly_fields(request, obj))
+        fields = list(six.iterkeys(form.base_fields)) + list(self.get_readonly_fields(request, obj))
         return [(None, {'fields': fields})]
 
     def queryset(self, request):
diff --git a/django/contrib/admin/sites.py b/django/contrib/admin/sites.py
index 515cc33eca..05773ceac0 100644
--- a/django/contrib/admin/sites.py
+++ b/django/contrib/admin/sites.py
@@ -10,6 +10,7 @@ from django.core.exceptions import ImproperlyConfigured
 from django.core.urlresolvers import reverse, NoReverseMatch
 from django.template.response import TemplateResponse
 from django.utils.safestring import mark_safe
+from django.utils import six
 from django.utils.text import capfirst
 from django.utils.translation import ugettext as _
 from django.views.decorators.cache import never_cache
@@ -133,7 +134,7 @@ class AdminSite(object):
         """
         Get all the enabled actions as an iterable of (name, func).
         """
-        return self._actions.iteritems()
+        return six.iteritems(self._actions)
 
     def has_permission(self, request):
         """
@@ -239,7 +240,7 @@ class AdminSite(object):
         )
 
         # Add in each model's views.
-        for model, model_admin in self._registry.iteritems():
+        for model, model_admin in six.iteritems(self._registry):
             urlpatterns += patterns('',
                 url(r'^%s/%s/' % (model._meta.app_label, model._meta.module_name),
                     include(model_admin.urls))
@@ -370,7 +371,7 @@ class AdminSite(object):
                         }
 
         # Sort the apps alphabetically.
-        app_list = app_dict.values()
+        app_list = list(six.itervalues(app_dict))
         app_list.sort(key=lambda x: x['name'])
 
         # Sort the models alphabetically within each app.
diff --git a/django/contrib/admin/templatetags/admin_list.py b/django/contrib/admin/templatetags/admin_list.py
index 0f15781fa9..a16226a70e 100644
--- a/django/contrib/admin/templatetags/admin_list.py
+++ b/django/contrib/admin/templatetags/admin_list.py
@@ -12,6 +12,7 @@ from django.db import models
 from django.utils import formats
 from django.utils.html import format_html
 from django.utils.safestring import mark_safe
+from django.utils import six
 from django.utils.text import capfirst
 from django.utils.translation import ugettext as _
 from django.utils.encoding import smart_unicode, force_unicode
@@ -125,7 +126,7 @@ def result_headers(cl):
         if i in ordering_field_columns:
             sorted = True
             order_type = ordering_field_columns.get(i).lower()
-            sort_priority = ordering_field_columns.keys().index(i) + 1
+            sort_priority = list(six.iterkeys(ordering_field_columns)).index(i) + 1
             th_classes.append('sorted %sending' % order_type)
             new_order_type = {'asc': 'desc', 'desc': 'asc'}[order_type]
 
diff --git a/django/contrib/admindocs/views.py b/django/contrib/admindocs/views.py
index 5649398cc8..94963b4d39 100644
--- a/django/contrib/admindocs/views.py
+++ b/django/contrib/admindocs/views.py
@@ -14,6 +14,7 @@ from django.core import urlresolvers
 from django.contrib.admindocs import utils
 from django.contrib.sites.models import Site
 from django.utils.importlib import import_module
+from django.utils import six
 from django.utils.translation import ugettext as _
 from django.utils.safestring import mark_safe
 
@@ -48,7 +49,7 @@ def template_tag_index(request):
     load_all_installed_template_libraries()
 
     tags = []
-    app_libs = template.libraries.items()
+    app_libs = list(six.iteritems(template.libraries))
     builtin_libs = [(None, lib) for lib in template.builtins]
     for module_name, library in builtin_libs + app_libs:
         for tag_name, tag_func in library.tags.items():
@@ -83,7 +84,7 @@ def template_filter_index(request):
     load_all_installed_template_libraries()
 
     filters = []
-    app_libs = template.libraries.items()
+    app_libs = list(six.iteritems(template.libraries))
     builtin_libs = [(None, lib) for lib in template.builtins]
     for module_name, library in builtin_libs + app_libs:
         for filter_name, filter_func in library.filters.items():
diff --git a/django/contrib/auth/admin.py b/django/contrib/auth/admin.py
index ad61904041..cb09822f52 100644
--- a/django/contrib/auth/admin.py
+++ b/django/contrib/auth/admin.py
@@ -12,6 +12,7 @@ from django.template.response import TemplateResponse
 from django.utils.html import escape
 from django.utils.decorators import method_decorator
 from django.utils.safestring import mark_safe
+from django.utils import six
 from django.utils.translation import ugettext, ugettext_lazy as _
 from django.views.decorators.csrf import csrf_protect
 from django.views.decorators.debug import sensitive_post_parameters
@@ -128,7 +129,7 @@ class UserAdmin(admin.ModelAdmin):
         else:
             form = self.change_password_form(user)
 
-        fieldsets = [(None, {'fields': form.base_fields.keys()})]
+        fieldsets = [(None, {'fields': list(six.iterkeys(form.base_fields))})]
         adminForm = admin.helpers.AdminForm(form, fieldsets, {})
 
         context = {
diff --git a/django/contrib/auth/tests/forms.py b/django/contrib/auth/tests/forms.py
index 13b8dd1216..2bfe35ac88 100644
--- a/django/contrib/auth/tests/forms.py
+++ b/django/contrib/auth/tests/forms.py
@@ -9,6 +9,7 @@ from django.forms.fields import Field, EmailField
 from django.test import TestCase
 from django.test.utils import override_settings
 from django.utils.encoding import force_unicode
+from django.utils import six
 from django.utils import translation
 from django.utils.translation import ugettext as _
 
@@ -203,7 +204,7 @@ class PasswordChangeFormTest(TestCase):
     def test_field_order(self):
         # Regression test - check the order of fields:
         user = User.objects.get(username='testclient')
-        self.assertEqual(PasswordChangeForm(user, {}).fields.keys(),
+        self.assertEqual(list(six.iterkeys(PasswordChangeForm(user, {}).fields)),
                          ['old_password', 'new_password1', 'new_password2'])
 
 
diff --git a/django/contrib/contenttypes/management.py b/django/contrib/contenttypes/management.py
index 6a23ef5287..1b1c9c8562 100644
--- a/django/contrib/contenttypes/management.py
+++ b/django/contrib/contenttypes/management.py
@@ -1,6 +1,7 @@
 from django.contrib.contenttypes.models import ContentType
 from django.db.models import get_apps, get_models, signals
 from django.utils.encoding import smart_unicode
+from django.utils import six
 
 def update_contenttypes(app, created_models, verbosity=2, **kwargs):
     """
@@ -24,7 +25,7 @@ def update_contenttypes(app, created_models, verbosity=2, **kwargs):
     )
     to_remove = [
         ct
-        for (model_name, ct) in content_types.iteritems()
+        for (model_name, ct) in six.iteritems(content_types)
         if model_name not in app_models
     ]
 
@@ -34,7 +35,7 @@ def update_contenttypes(app, created_models, verbosity=2, **kwargs):
             app_label=app_label,
             model=model_name,
         )
-        for (model_name, model) in app_models.iteritems()
+        for (model_name, model) in six.iteritems(app_models)
         if model_name not in content_types
     ])
     if verbosity >= 2:
diff --git a/django/contrib/databrowse/datastructures.py b/django/contrib/databrowse/datastructures.py
index 687aa87f03..95d347cac0 100644
--- a/django/contrib/databrowse/datastructures.py
+++ b/django/contrib/databrowse/datastructures.py
@@ -17,7 +17,7 @@ class EasyModel(object):
     def __init__(self, site, model):
         self.site = site
         self.model = model
-        self.model_list = site.registry.keys()
+        self.model_list = list(site.registry.keys())
         self.verbose_name = model._meta.verbose_name
         self.verbose_name_plural = model._meta.verbose_name_plural
 
@@ -176,8 +176,6 @@ class EasyInstanceField(object):
         for plugin_name, plugin in self.model.model_databrowse().plugins.items():
             urls = plugin.urls(plugin_name, self)
             if urls is not None:
-                #plugin_urls.append(urls)
-                values = self.values()
                 return zip(self.values(), urls)
         if self.field.rel:
             m = EasyModel(self.model.site, self.field.rel.to)
@@ -196,10 +194,10 @@ class EasyInstanceField(object):
                 url = '%s%s/%s/fields/%s/%s/' % (self.model.site.root_url, self.model.model._meta.app_label, self.model.model._meta.module_name, self.field.name, iri_to_uri(self.raw_value))
                 lst.append((value, url))
         elif isinstance(self.field, models.URLField):
-            val = self.values()[0]
+            val = list(self.values())[0]
             lst = [(val, iri_to_uri(val))]
         else:
-            lst = [(self.values()[0], None)]
+            lst = [(list(self.values())[0], None)]
         return lst
 
 class EasyQuerySet(QuerySet):
diff --git a/django/contrib/databrowse/plugins/calendars.py b/django/contrib/databrowse/plugins/calendars.py
index 7bdd1e0032..923adb90f6 100644
--- a/django/contrib/databrowse/plugins/calendars.py
+++ b/django/contrib/databrowse/plugins/calendars.py
@@ -96,7 +96,7 @@ class CalendarPlugin(DatabrowsePlugin):
 
     def homepage_view(self, request):
         easy_model = EasyModel(self.site, self.model)
-        field_list = self.fields.values()
+        field_list = list(self.fields.values())
         field_list.sort(key=lambda k:k.verbose_name)
         return render_to_response('databrowse/calendar_homepage.html', {
                 'root_url': self.site.root_url,
diff --git a/django/contrib/databrowse/plugins/fieldchoices.py b/django/contrib/databrowse/plugins/fieldchoices.py
index c016385ffb..73298b8d56 100644
--- a/django/contrib/databrowse/plugins/fieldchoices.py
+++ b/django/contrib/databrowse/plugins/fieldchoices.py
@@ -63,7 +63,7 @@ class FieldChoicePlugin(DatabrowsePlugin):
 
     def homepage_view(self, request):
         easy_model = EasyModel(self.site, self.model)
-        field_list = self.fields.values()
+        field_list = list(self.fields.values())
         field_list.sort(key=lambda k: k.verbose_name)
         return render_to_response('databrowse/fieldchoice_homepage.html', {'root_url': self.site.root_url, 'model': easy_model, 'field_list': field_list})
 
diff --git a/django/contrib/formtools/wizard/storage/base.py b/django/contrib/formtools/wizard/storage/base.py
index 274e07ffbe..7c802712c1 100644
--- a/django/contrib/formtools/wizard/storage/base.py
+++ b/django/contrib/formtools/wizard/storage/base.py
@@ -2,6 +2,7 @@ from django.core.files.uploadedfile import UploadedFile
 from django.utils.datastructures import MultiValueDict
 from django.utils.encoding import smart_str
 from django.utils.functional import lazy_property
+from django.utils import six
 
 from django.contrib.formtools.wizard.storage.exceptions import NoFileStorageConfigured
 
@@ -72,9 +73,9 @@ class BaseStorage(object):
             raise NoFileStorageConfigured
 
         files = {}
-        for field, field_dict in wizard_files.iteritems():
+        for field, field_dict in six.iteritems(wizard_files):
             field_dict = dict((smart_str(k), v)
-                              for k, v in field_dict.iteritems())
+                              for k, v in six.iteritems(field_dict))
             tmp_name = field_dict.pop('tmp_name')
             files[field] = UploadedFile(
                 file=self.file_storage.open(tmp_name), **field_dict)
@@ -87,7 +88,7 @@ class BaseStorage(object):
         if step not in self.data[self.step_files_key]:
             self.data[self.step_files_key][step] = {}
 
-        for field, field_file in (files or {}).iteritems():
+        for field, field_file in six.iteritems(files or {}):
             tmp_filename = self.file_storage.save(field_file.name, field_file)
             file_dict = {
                 'tmp_name': tmp_filename,
diff --git a/django/contrib/formtools/wizard/views.py b/django/contrib/formtools/wizard/views.py
index 466af1cac9..741b7e52b6 100644
--- a/django/contrib/formtools/wizard/views.py
+++ b/django/contrib/formtools/wizard/views.py
@@ -44,7 +44,7 @@ class StepsHelper(object):
     @property
     def all(self):
         "Returns the names of all steps/forms."
-        return self._wizard.get_form_list().keys()
+        return list(six.iterkeys(self._wizard.get_form_list()))
 
     @property
     def count(self):
@@ -164,14 +164,14 @@ class WizardView(TemplateView):
                 init_form_list[six.text_type(i)] = form
 
         # walk through the new created list of forms
-        for form in init_form_list.itervalues():
+        for form in six.itervalues(init_form_list):
             if issubclass(form, formsets.BaseFormSet):
                 # if the element is based on BaseFormSet (FormSet/ModelFormSet)
                 # we need to override the form variable.
                 form = form.form
             # check if any form contains a FileField, if yes, we need a
             # file_storage added to the wizardview (by subclassing).
-            for field in form.base_fields.itervalues():
+            for field in six.itervalues(form.base_fields):
                 if (isinstance(field, forms.FileField) and
                         not hasattr(cls, 'file_storage')):
                     raise NoFileStorageConfigured
@@ -196,7 +196,7 @@ class WizardView(TemplateView):
         could use data from other (maybe previous forms).
         """
         form_list = SortedDict()
-        for form_key, form_class in self.form_list.iteritems():
+        for form_key, form_class in six.iteritems(self.form_list):
             # try to fetch the value from condition list, by default, the form
             # gets passed to the new list.
             condition = self.condition_dict.get(form_key, True)
diff --git a/django/contrib/gis/db/backends/mysql/operations.py b/django/contrib/gis/db/backends/mysql/operations.py
index c0e5aa6691..277b764810 100644
--- a/django/contrib/gis/db/backends/mysql/operations.py
+++ b/django/contrib/gis/db/backends/mysql/operations.py
@@ -3,6 +3,8 @@ from django.db.backends.mysql.base import DatabaseOperations
 from django.contrib.gis.db.backends.adapter import WKTAdapter
 from django.contrib.gis.db.backends.base import BaseSpatialOperations
 
+from django.utils import six
+
 class MySQLOperations(DatabaseOperations, BaseSpatialOperations):
 
     compiler_module = 'django.contrib.gis.db.backends.mysql.compiler'
@@ -30,7 +32,7 @@ class MySQLOperations(DatabaseOperations, BaseSpatialOperations):
         'within' : 'MBRWithin',
         }
 
-    gis_terms = dict([(term, None) for term in geometry_functions.keys() + ['isnull']])
+    gis_terms = dict([(term, None) for term in list(six.iterkeys(geometry_functions)) + ['isnull']])
 
     def geo_db_type(self, f):
         return f.geom_type
diff --git a/django/contrib/gis/db/backends/oracle/operations.py b/django/contrib/gis/db/backends/oracle/operations.py
index 4e33942f7a..5db30e6fc6 100644
--- a/django/contrib/gis/db/backends/oracle/operations.py
+++ b/django/contrib/gis/db/backends/oracle/operations.py
@@ -128,7 +128,7 @@ class OracleOperations(DatabaseOperations, BaseSpatialOperations):
     geometry_functions.update(distance_functions)
 
     gis_terms = ['isnull']
-    gis_terms += geometry_functions.keys()
+    gis_terms += list(six.iterkeys(geometry_functions))
     gis_terms = dict([(term, None) for term in gis_terms])
 
     truncate_params = {'relate' : None}
diff --git a/django/contrib/gis/db/backends/postgis/operations.py b/django/contrib/gis/db/backends/postgis/operations.py
index bd249df179..92f8925a7d 100644
--- a/django/contrib/gis/db/backends/postgis/operations.py
+++ b/django/contrib/gis/db/backends/postgis/operations.py
@@ -217,8 +217,8 @@ class PostGISOperations(DatabaseOperations, BaseSpatialOperations):
 
         # Creating a dictionary lookup of all GIS terms for PostGIS.
         gis_terms = ['isnull']
-        gis_terms += self.geometry_operators.keys()
-        gis_terms += self.geometry_functions.keys()
+        gis_terms += list(six.iterkeys(self.geometry_operators))
+        gis_terms += list(six.iterkeys(self.geometry_functions))
         self.gis_terms = dict([(term, None) for term in gis_terms])
 
         self.area = prefix + 'Area'
diff --git a/django/contrib/gis/db/backends/spatialite/operations.py b/django/contrib/gis/db/backends/spatialite/operations.py
index 1d7c4fab52..31c98212e9 100644
--- a/django/contrib/gis/db/backends/spatialite/operations.py
+++ b/django/contrib/gis/db/backends/spatialite/operations.py
@@ -131,7 +131,7 @@ class SpatiaLiteOperations(DatabaseOperations, BaseSpatialOperations):
 
         # Creating the GIS terms dictionary.
         gis_terms = ['isnull']
-        gis_terms += self.geometry_functions.keys()
+        gis_terms += list(six.iterkeys(self.geometry_functions))
         self.gis_terms = dict([(term, None) for term in gis_terms])
 
         if version >= (2, 4, 0):
diff --git a/django/contrib/gis/db/models/query.py b/django/contrib/gis/db/models/query.py
index dd2983aecc..6dc36d6ab8 100644
--- a/django/contrib/gis/db/models/query.py
+++ b/django/contrib/gis/db/models/query.py
@@ -1,5 +1,6 @@
 from django.db import connections
 from django.db.models.query import QuerySet, ValuesQuerySet, ValuesListQuerySet
+from django.utils import six
 
 from django.contrib.gis.db.models import aggregates
 from django.contrib.gis.db.models.fields import get_srid_info, PointField, LineStringField
@@ -25,7 +26,7 @@ class GeoQuerySet(QuerySet):
         flat = kwargs.pop('flat', False)
         if kwargs:
             raise TypeError('Unexpected keyword arguments to values_list: %s'
-                    % (kwargs.keys(),))
+                    % (list(six.iterkeys(kwargs)),))
         if flat and len(fields) > 1:
             raise TypeError("'flat' is not valid when values_list is called with more than one field.")
         return self._clone(klass=GeoValuesListQuerySet, setup=True, flat=flat,
@@ -531,7 +532,7 @@ class GeoQuerySet(QuerySet):
         if settings.get('setup', True):
             default_args, geo_field = self._spatial_setup(att, desc=settings['desc'], field_name=field_name,
                                                           geo_field_type=settings.get('geo_field_type', None))
-            for k, v in default_args.iteritems(): settings['procedure_args'].setdefault(k, v)
+            for k, v in six.iteritems(default_args): settings['procedure_args'].setdefault(k, v)
         else:
             geo_field = settings['geo_field']
 
diff --git a/django/contrib/gis/db/models/sql/compiler.py b/django/contrib/gis/db/models/sql/compiler.py
index d016357f1b..64d1a4d869 100644
--- a/django/contrib/gis/db/models/sql/compiler.py
+++ b/django/contrib/gis/db/models/sql/compiler.py
@@ -3,6 +3,7 @@ from django.utils.six.moves import zip
 from django.db.backends.util import truncate_name, typecast_timestamp
 from django.db.models.sql import compiler
 from django.db.models.sql.constants import MULTI
+from django.utils import six
 
 SQLCompiler = compiler.SQLCompiler
 
@@ -24,7 +25,7 @@ class GeoSQLCompiler(compiler.SQLCompiler):
         qn = self.quote_name_unless_alias
         qn2 = self.connection.ops.quote_name
         result = ['(%s) AS %s' % (self.get_extra_select_format(alias) % col[0], qn2(alias))
-                  for alias, col in self.query.extra_select.iteritems()]
+                  for alias, col in six.iteritems(self.query.extra_select)]
         aliases = set(self.query.extra_select.keys())
         if with_aliases:
             col_aliases = aliases.copy()
@@ -170,7 +171,7 @@ class GeoSQLCompiler(compiler.SQLCompiler):
         objects.
         """
         values = []
-        aliases = self.query.extra_select.keys()
+        aliases = list(six.iterkeys(self.query.extra_select))
 
         # Have to set a starting row number offset that is used for
         # determining the correct starting row index -- needed for
diff --git a/django/contrib/gis/geometry/test_data.py b/django/contrib/gis/geometry/test_data.py
index f92740248e..505f0e4f4b 100644
--- a/django/contrib/gis/geometry/test_data.py
+++ b/django/contrib/gis/geometry/test_data.py
@@ -7,6 +7,7 @@ import json
 import os
 
 from django.contrib import gis
+from django.utils import six
 
 
 # This global used to store reference geometry data.
@@ -25,7 +26,7 @@ def tuplize(seq):
 
 def strconvert(d):
     "Converts all keys in dictionary to str type."
-    return dict([(str(k), v) for k, v in d.iteritems()])
+    return dict([(str(k), v) for k, v in six.iteritems(d)])
 
 
 def get_ds_file(name, ext):
diff --git a/django/contrib/gis/measure.py b/django/contrib/gis/measure.py
index ba7817e51c..fa8bab1340 100644
--- a/django/contrib/gis/measure.py
+++ b/django/contrib/gis/measure.py
@@ -169,7 +169,7 @@ class MeasureBase(object):
         """
         val = 0.0
         default_unit = self.STANDARD_UNIT
-        for unit, value in kwargs.iteritems():
+        for unit, value in six.iteritems(kwargs):
             if not isinstance(value, float): value = float(value)
             if unit in self.UNITS:
                 val += self.UNITS[unit] * value
diff --git a/django/contrib/gis/sitemaps/views.py b/django/contrib/gis/sitemaps/views.py
index eb42d0cae8..6753b9e34a 100644
--- a/django/contrib/gis/sitemaps/views.py
+++ b/django/contrib/gis/sitemaps/views.py
@@ -9,6 +9,7 @@ from django.contrib.gis.db.models.fields import GeometryField
 from django.db import connections, DEFAULT_DB_ALIAS
 from django.db.models import get_model
 from django.utils.encoding import smart_str
+from django.utils import six
 from django.utils.translation import ugettext as _
 
 from django.contrib.gis.shortcuts import render_to_kml, render_to_kmz
@@ -46,7 +47,7 @@ def sitemap(request, sitemaps, section=None):
             raise Http404(_("No sitemap available for section: %r") % section)
         maps.append(sitemaps[section])
     else:
-        maps = sitemaps.values()
+        maps = list(six.itervalues(sitemaps))
 
     page = request.GET.get("p", 1)
     current_site = get_current_site(request)
diff --git a/django/contrib/messages/storage/cookie.py b/django/contrib/messages/storage/cookie.py
index 07620050c7..5f64ccd0c5 100644
--- a/django/contrib/messages/storage/cookie.py
+++ b/django/contrib/messages/storage/cookie.py
@@ -4,6 +4,7 @@ from django.conf import settings
 from django.contrib.messages.storage.base import BaseStorage, Message
 from django.http import SimpleCookie
 from django.utils.crypto import salted_hmac, constant_time_compare
+from django.utils import six
 
 
 class MessageEncoder(json.JSONEncoder):
@@ -33,7 +34,7 @@ class MessageDecoder(json.JSONDecoder):
             return [self.process_messages(item) for item in obj]
         if isinstance(obj, dict):
             return dict([(key, self.process_messages(value))
-                         for key, value in obj.iteritems()])
+                         for key, value in six.iteritems(obj)])
         return obj
 
     def decode(self, s, **kwargs):
diff --git a/django/contrib/sessions/tests.py b/django/contrib/sessions/tests.py
index 328b085f1e..7de2941122 100644
--- a/django/contrib/sessions/tests.py
+++ b/django/contrib/sessions/tests.py
@@ -16,6 +16,7 @@ from django.core.exceptions import ImproperlyConfigured, SuspiciousOperation
 from django.http import HttpResponse
 from django.test import TestCase, RequestFactory
 from django.test.utils import override_settings
+from django.utils import six
 from django.utils import timezone
 from django.utils import unittest
 
@@ -86,16 +87,16 @@ class SessionTestsMixin(object):
         self.assertFalse(self.session.modified)
 
     def test_values(self):
-        self.assertEqual(self.session.values(), [])
+        self.assertEqual(list(self.session.values()), [])
         self.assertTrue(self.session.accessed)
         self.session['some key'] = 1
-        self.assertEqual(self.session.values(), [1])
+        self.assertEqual(list(self.session.values()), [1])
 
     def test_iterkeys(self):
         self.session['x'] = 1
         self.session.modified = False
         self.session.accessed = False
-        i = self.session.iterkeys()
+        i = six.iterkeys(self.session)
         self.assertTrue(hasattr(i, '__iter__'))
         self.assertTrue(self.session.accessed)
         self.assertFalse(self.session.modified)
@@ -105,7 +106,7 @@ class SessionTestsMixin(object):
         self.session['x'] = 1
         self.session.modified = False
         self.session.accessed = False
-        i = self.session.itervalues()
+        i = six.itervalues(self.session)
         self.assertTrue(hasattr(i, '__iter__'))
         self.assertTrue(self.session.accessed)
         self.assertFalse(self.session.modified)
@@ -115,7 +116,7 @@ class SessionTestsMixin(object):
         self.session['x'] = 1
         self.session.modified = False
         self.session.accessed = False
-        i = self.session.iteritems()
+        i = six.iteritems(self.session)
         self.assertTrue(hasattr(i, '__iter__'))
         self.assertTrue(self.session.accessed)
         self.assertFalse(self.session.modified)
@@ -125,9 +126,9 @@ class SessionTestsMixin(object):
         self.session['x'] = 1
         self.session.modified = False
         self.session.accessed = False
-        self.assertEqual(self.session.items(), [('x', 1)])
+        self.assertEqual(list(self.session.items()), [('x', 1)])
         self.session.clear()
-        self.assertEqual(self.session.items(), [])
+        self.assertEqual(list(self.session.items()), [])
         self.assertTrue(self.session.accessed)
         self.assertTrue(self.session.modified)
 
@@ -154,10 +155,10 @@ class SessionTestsMixin(object):
         self.session['a'], self.session['b'] = 'c', 'd'
         self.session.save()
         prev_key = self.session.session_key
-        prev_data = self.session.items()
+        prev_data = list(self.session.items())
         self.session.cycle_key()
         self.assertNotEqual(self.session.session_key, prev_key)
-        self.assertEqual(self.session.items(), prev_data)
+        self.assertEqual(list(self.session.items()), prev_data)
 
     def test_invalid_key(self):
         # Submitting an invalid session key (either by guessing, or if the db has
diff --git a/django/contrib/sitemaps/views.py b/django/contrib/sitemaps/views.py
index b90a39e954..cfe3aa66a9 100644
--- a/django/contrib/sitemaps/views.py
+++ b/django/contrib/sitemaps/views.py
@@ -3,6 +3,7 @@ from django.core import urlresolvers
 from django.core.paginator import EmptyPage, PageNotAnInteger
 from django.http import Http404
 from django.template.response import TemplateResponse
+from django.utils import six
 
 def index(request, sitemaps,
           template_name='sitemap_index.xml', mimetype='application/xml',
@@ -35,7 +36,7 @@ def sitemap(request, sitemaps, section=None,
             raise Http404("No sitemap available for section: %r" % section)
         maps = [sitemaps[section]]
     else:
-        maps = sitemaps.values()
+        maps = list(six.itervalues(sitemaps))
     page = request.GET.get("p", 1)
 
     urls = []
diff --git a/django/contrib/staticfiles/finders.py b/django/contrib/staticfiles/finders.py
index 766687cf7d..9b06c2cf60 100644
--- a/django/contrib/staticfiles/finders.py
+++ b/django/contrib/staticfiles/finders.py
@@ -6,6 +6,7 @@ from django.utils.datastructures import SortedDict
 from django.utils.functional import empty, memoize, LazyObject
 from django.utils.importlib import import_module
 from django.utils._os import safe_join
+from django.utils import six
 
 from django.contrib.staticfiles import utils
 from django.contrib.staticfiles.storage import AppStaticStorage
@@ -132,7 +133,7 @@ class AppDirectoriesFinder(BaseFinder):
         """
         List all files in all app storages.
         """
-        for storage in self.storages.itervalues():
+        for storage in six.itervalues(self.storages):
             if storage.exists(''):  # check if storage location exists
                 for path in utils.get_files(storage, ignore_patterns):
                     yield path, storage
diff --git a/django/core/management/__init__.py b/django/core/management/__init__.py
index 68048e5672..e2f9798dcd 100644
--- a/django/core/management/__init__.py
+++ b/django/core/management/__init__.py
@@ -8,6 +8,7 @@ import warnings
 from django.core.management.base import BaseCommand, CommandError, handle_default_options
 from django.core.management.color import color_style
 from django.utils.importlib import import_module
+from django.utils import six
 
 # For backwards compatibility: get_version() used to be in this module.
 from django import get_version
@@ -228,7 +229,7 @@ class ManagementUtility(object):
                 "Available subcommands:",
             ]
             commands_dict = collections.defaultdict(lambda: [])
-            for name, app in get_commands().iteritems():
+            for name, app in six.iteritems(get_commands()):
                 if app == 'django.core':
                     app = 'django'
                 else:
@@ -294,7 +295,7 @@ class ManagementUtility(object):
         except IndexError:
             curr = ''
 
-        subcommands = get_commands().keys() + ['help']
+        subcommands = list(six.iterkeys(get_commands())) + ['help']
         options = [('--help', None)]
 
         # subcommand
diff --git a/django/core/management/commands/diffsettings.py b/django/core/management/commands/diffsettings.py
index 98b53b405d..aa7395e5ee 100644
--- a/django/core/management/commands/diffsettings.py
+++ b/django/core/management/commands/diffsettings.py
@@ -22,9 +22,7 @@ class Command(NoArgsCommand):
         default_settings = module_to_dict(global_settings)
 
         output = []
-        keys = user_settings.keys()
-        keys.sort()
-        for key in keys:
+        for key in sorted(user_settings.keys()):
             if key not in default_settings:
                 output.append("%s = %s  ###" % (key, user_settings[key]))
             elif user_settings[key] != default_settings[key]:
diff --git a/django/core/serializers/__init__.py b/django/core/serializers/__init__.py
index 09bcb651d5..2d5e7624a4 100644
--- a/django/core/serializers/__init__.py
+++ b/django/core/serializers/__init__.py
@@ -18,6 +18,7 @@ To add your own serializers, use the SERIALIZATION_MODULES setting::
 
 from django.conf import settings
 from django.utils import importlib
+from django.utils import six
 from django.core.serializers.base import SerializerDoesNotExist
 
 # Built-in serializers
@@ -75,12 +76,12 @@ def get_serializer(format):
 def get_serializer_formats():
     if not _serializers:
         _load_serializers()
-    return _serializers.keys()
+    return list(six.iterkeys(_serializers))
 
 def get_public_serializer_formats():
     if not _serializers:
         _load_serializers()
-    return [k for k, v in _serializers.iteritems() if not v.Serializer.internal_use_only]
+    return [k for k, v in six.iteritems(_serializers) if not v.Serializer.internal_use_only]
 
 def get_deserializer(format):
     if not _serializers:
diff --git a/django/core/serializers/python.py b/django/core/serializers/python.py
index 333161c929..83c6eb6739 100644
--- a/django/core/serializers/python.py
+++ b/django/core/serializers/python.py
@@ -9,6 +9,7 @@ from django.conf import settings
 from django.core.serializers import base
 from django.db import models, DEFAULT_DB_ALIAS
 from django.utils.encoding import smart_unicode, is_protected_type
+from django.utils import six
 
 class Serializer(base.Serializer):
     """
@@ -87,7 +88,7 @@ def Deserializer(object_list, **options):
         m2m_data = {}
 
         # Handle each field
-        for (field_name, field_value) in d["fields"].iteritems():
+        for (field_name, field_value) in six.iteritems(d["fields"]):
             if isinstance(field_value, str):
                 field_value = smart_unicode(field_value, options.get("encoding", settings.DEFAULT_CHARSET), strings_only=True)
 
diff --git a/django/core/urlresolvers.py b/django/core/urlresolvers.py
index 7397cf3b3d..c17168f8cb 100644
--- a/django/core/urlresolvers.py
+++ b/django/core/urlresolvers.py
@@ -376,7 +376,7 @@ class RegexURLResolver(LocaleRegexProvider):
                     unicode_args = [force_unicode(val) for val in args]
                     candidate =  (prefix_norm + result) % dict(zip(prefix_args + params, unicode_args))
                 else:
-                    if set(kwargs.keys() + defaults.keys()) != set(params + defaults.keys() + prefix_args):
+                    if set(kwargs.keys()) | set(defaults.keys()) != set(params) | set(defaults.keys()) | set(prefix_args):
                         continue
                     matches = True
                     for k, v in defaults.items():
diff --git a/django/core/validators.py b/django/core/validators.py
index 03ff8be3bc..91d6f62dcf 100644
--- a/django/core/validators.py
+++ b/django/core/validators.py
@@ -138,7 +138,7 @@ def ip_address_validators(protocol, unpack_ipv4):
         return ip_address_validator_map[protocol.lower()]
     except KeyError:
         raise ValueError("The protocol '%s' is unknown. Supported: %s"
-                         % (protocol, ip_address_validator_map.keys()))
+                         % (protocol, list(six.iterkeys(ip_address_validator_map))))
 
 comma_separated_int_list_re = re.compile('^[\d,]+$')
 validate_comma_separated_integer_list = RegexValidator(comma_separated_int_list_re, _('Enter only digits separated by commas.'), 'invalid')
diff --git a/django/db/backends/mysql/introspection.py b/django/db/backends/mysql/introspection.py
index e6f18b819f..6aab0b99ab 100644
--- a/django/db/backends/mysql/introspection.py
+++ b/django/db/backends/mysql/introspection.py
@@ -1,4 +1,5 @@
 from django.db.backends import BaseDatabaseIntrospection
+from django.utils import six
 from MySQLdb import ProgrammingError, OperationalError
 from MySQLdb.constants import FIELD_TYPE
 import re
@@ -79,7 +80,7 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
         """
         Returns the name of the primary key column for the given table
         """
-        for column in self.get_indexes(cursor, table_name).iteritems():
+        for column in six.iteritems(self.get_indexes(cursor, table_name)):
             if column[1]['primary_key']:
                 return column[0]
         return None
diff --git a/django/db/models/base.py b/django/db/models/base.py
index 8dd5bf864f..a25c106290 100644
--- a/django/db/models/base.py
+++ b/django/db/models/base.py
@@ -364,14 +364,14 @@ class Model(six.with_metaclass(ModelBase, object)):
                 setattr(self, field.attname, val)
 
         if kwargs:
-            for prop in kwargs.keys():
+            for prop in list(six.iterkeys(kwargs)):
                 try:
                     if isinstance(getattr(self.__class__, prop), property):
                         setattr(self, prop, kwargs.pop(prop))
                 except AttributeError:
                     pass
             if kwargs:
-                raise TypeError("'%s' is an invalid keyword argument for this function" % kwargs.keys()[0])
+                raise TypeError("'%s' is an invalid keyword argument for this function" % list(six.iterkeys(kwargs))[0])
         super(Model, self).__init__()
         signals.post_init.send(sender=self.__class__, instance=self)
 
diff --git a/django/db/models/deletion.py b/django/db/models/deletion.py
index d8bb8f2e66..2e5ed53e63 100644
--- a/django/db/models/deletion.py
+++ b/django/db/models/deletion.py
@@ -4,6 +4,7 @@ from operator import attrgetter
 from django.db import connections, transaction, IntegrityError
 from django.db.models import signals, sql
 from django.utils.datastructures import SortedDict
+from django.utils import six
 
 
 class ProtectedError(IntegrityError):
@@ -157,7 +158,7 @@ class Collector(object):
         # Recursively collect concrete model's parent models, but not their
         # related objects. These will be found by meta.get_all_related_objects()
         concrete_model = model._meta.concrete_model
-        for ptr in concrete_model._meta.parents.itervalues():
+        for ptr in six.itervalues(concrete_model._meta.parents):
             if ptr:
                 parent_objs = [getattr(obj, ptr.name) for obj in new_objs]
                 self.collect(parent_objs, source=model,
@@ -199,14 +200,14 @@ class Collector(object):
         )
 
     def instances_with_model(self):
-        for model, instances in self.data.iteritems():
+        for model, instances in six.iteritems(self.data):
             for obj in instances:
                 yield model, obj
 
     def sort(self):
         sorted_models = []
         concrete_models = set()
-        models = self.data.keys()
+        models = list(six.iterkeys(self.data))
         while len(sorted_models) < len(models):
             found = False
             for model in models:
@@ -241,24 +242,24 @@ class Collector(object):
                 )
 
         # update fields
-        for model, instances_for_fieldvalues in self.field_updates.iteritems():
+        for model, instances_for_fieldvalues in six.iteritems(self.field_updates):
             query = sql.UpdateQuery(model)
-            for (field, value), instances in instances_for_fieldvalues.iteritems():
+            for (field, value), instances in six.iteritems(instances_for_fieldvalues):
                 query.update_batch([obj.pk for obj in instances],
                                    {field.name: value}, self.using)
 
         # reverse instance collections
-        for instances in self.data.itervalues():
+        for instances in six.itervalues(self.data):
             instances.reverse()
 
         # delete batches
-        for model, batches in self.batches.iteritems():
+        for model, batches in six.iteritems(self.batches):
             query = sql.DeleteQuery(model)
-            for field, instances in batches.iteritems():
+            for field, instances in six.iteritems(batches):
                 query.delete_batch([obj.pk for obj in instances], self.using, field)
 
         # delete instances
-        for model, instances in self.data.iteritems():
+        for model, instances in six.iteritems(self.data):
             query = sql.DeleteQuery(model)
             pk_list = [obj.pk for obj in instances]
             query.delete_batch(pk_list, self.using)
@@ -271,10 +272,10 @@ class Collector(object):
                 )
 
         # update collected instances
-        for model, instances_for_fieldvalues in self.field_updates.iteritems():
-            for (field, value), instances in instances_for_fieldvalues.iteritems():
+        for model, instances_for_fieldvalues in six.iteritems(self.field_updates):
+            for (field, value), instances in six.iteritems(instances_for_fieldvalues):
                 for obj in instances:
                     setattr(obj, field.attname, value)
-        for model, instances in self.data.iteritems():
+        for model, instances in six.iteritems(self.data):
             for instance in instances:
                 setattr(instance, model._meta.pk.attname, None)
diff --git a/django/db/models/fields/related.py b/django/db/models/fields/related.py
index 2a2502b54f..bfa8feee9f 100644
--- a/django/db/models/fields/related.py
+++ b/django/db/models/fields/related.py
@@ -241,7 +241,7 @@ class SingleRelatedObjectDescriptor(object):
         rel_obj_attr = attrgetter(self.related.field.attname)
         instance_attr = lambda obj: obj._get_pk_val()
         instances_dict = dict((instance_attr(inst), inst) for inst in instances)
-        params = {'%s__pk__in' % self.related.field.name: instances_dict.keys()}
+        params = {'%s__pk__in' % self.related.field.name: list(six.iterkeys(instances_dict))}
         qs = self.get_query_set(instance=instances[0]).filter(**params)
         # Since we're going to assign directly in the cache,
         # we must manage the reverse relation cache manually.
@@ -335,9 +335,9 @@ class ReverseSingleRelatedObjectDescriptor(object):
         instance_attr = attrgetter(self.field.attname)
         instances_dict = dict((instance_attr(inst), inst) for inst in instances)
         if other_field.rel:
-            params = {'%s__pk__in' % self.field.rel.field_name: instances_dict.keys()}
+            params = {'%s__pk__in' % self.field.rel.field_name: list(six.iterkeys(instances_dict))}
         else:
-            params = {'%s__in' % self.field.rel.field_name: instances_dict.keys()}
+            params = {'%s__in' % self.field.rel.field_name: list(six.iterkeys(instances_dict))}
         qs = self.get_query_set(instance=instances[0]).filter(**params)
         # Since we're going to assign directly in the cache,
         # we must manage the reverse relation cache manually.
@@ -488,7 +488,7 @@ class ForeignRelatedObjectsDescriptor(object):
                 instance_attr = attrgetter(attname)
                 instances_dict = dict((instance_attr(inst), inst) for inst in instances)
                 db = self._db or router.db_for_read(self.model, instance=instances[0])
-                query = {'%s__%s__in' % (rel_field.name, attname): instances_dict.keys()}
+                query = {'%s__%s__in' % (rel_field.name, attname): list(six.iterkeys(instances_dict))}
                 qs = super(RelatedManager, self).get_query_set().using(db).filter(**query)
                 # Since we just bypassed this class' get_query_set(), we must manage
                 # the reverse relation manually.
diff --git a/django/db/models/loading.py b/django/db/models/loading.py
index d651584e7a..7a9cb2cb41 100644
--- a/django/db/models/loading.py
+++ b/django/db/models/loading.py
@@ -5,6 +5,7 @@ from django.core.exceptions import ImproperlyConfigured
 from django.utils.datastructures import SortedDict
 from django.utils.importlib import import_module
 from django.utils.module_loading import module_has_submodule
+from django.utils import six
 
 import imp
 import sys
@@ -193,9 +194,9 @@ class AppCache(object):
         else:
             if only_installed:
                 app_list = [self.app_models.get(app_label, SortedDict())
-                            for app_label in self.app_labels.iterkeys()]
+                            for app_label in six.iterkeys(self.app_labels)]
             else:
-                app_list = self.app_models.itervalues()
+                app_list = six.itervalues(self.app_models)
         model_list = []
         for app in app_list:
             model_list.extend(
diff --git a/django/db/models/options.py b/django/db/models/options.py
index 7308a15c6b..9e8d4120e9 100644
--- a/django/db/models/options.py
+++ b/django/db/models/options.py
@@ -127,7 +127,7 @@ class Options(object):
             if self.parents:
                 # Promote the first parent link in lieu of adding yet another
                 # field.
-                field = next(self.parents.itervalues())
+                field = next(six.itervalues(self.parents))
                 # Look for a local field with the same name as the
                 # first parent link. If a local field has already been
                 # created, use it instead of promoting the parent
@@ -147,13 +147,13 @@ class Options(object):
         # self.duplicate_targets will map each duplicate field column to the
         # columns it duplicates.
         collections = {}
-        for column, target in self.duplicate_targets.iteritems():
+        for column, target in six.iteritems(self.duplicate_targets):
             try:
                 collections[target].add(column)
             except KeyError:
                 collections[target] = set([column])
         self.duplicate_targets = {}
-        for elt in collections.itervalues():
+        for elt in six.itervalues(collections):
             if len(elt) == 1:
                 continue
             for column in elt:
@@ -258,7 +258,7 @@ class Options(object):
             self._m2m_cache
         except AttributeError:
             self._fill_m2m_cache()
-        return self._m2m_cache.keys()
+        return list(six.iterkeys(self._m2m_cache))
     many_to_many = property(_many_to_many)
 
     def get_m2m_with_model(self):
@@ -269,7 +269,7 @@ class Options(object):
             self._m2m_cache
         except AttributeError:
             self._fill_m2m_cache()
-        return self._m2m_cache.items()
+        return list(six.iteritems(self._m2m_cache))
 
     def _fill_m2m_cache(self):
         cache = SortedDict()
@@ -326,8 +326,7 @@ class Options(object):
             cache = self._name_map
         except AttributeError:
             cache = self.init_name_map()
-        names = cache.keys()
-        names.sort()
+        names = sorted(cache.keys())
         # Internal-only names end with "+" (symmetrical m2m related names being
         # the main example). Trim them.
         return [val for val in names if not val.endswith('+')]
@@ -417,7 +416,7 @@ class Options(object):
             cache = self._fill_related_many_to_many_cache()
         if local_only:
             return [k for k, v in cache.items() if not v]
-        return cache.keys()
+        return list(six.iterkeys(cache))
 
     def get_all_related_m2m_objects_with_model(self):
         """
@@ -428,7 +427,7 @@ class Options(object):
             cache = self._related_many_to_many_cache
         except AttributeError:
             cache = self._fill_related_many_to_many_cache()
-        return cache.items()
+        return list(six.iteritems(cache))
 
     def _fill_related_many_to_many_cache(self):
         cache = SortedDict()
diff --git a/django/db/models/query.py b/django/db/models/query.py
index 8b6b42b7b1..6013233a0f 100644
--- a/django/db/models/query.py
+++ b/django/db/models/query.py
@@ -245,8 +245,8 @@ class QuerySet(object):
             requested = None
         max_depth = self.query.max_depth
 
-        extra_select = self.query.extra_select.keys()
-        aggregate_select = self.query.aggregate_select.keys()
+        extra_select = list(six.iterkeys(self.query.extra_select))
+        aggregate_select = list(six.iterkeys(self.query.aggregate_select))
 
         only_load = self.query.get_loaded_field_names()
         if not fill_cache:
@@ -593,7 +593,7 @@ class QuerySet(object):
         flat = kwargs.pop('flat', False)
         if kwargs:
             raise TypeError('Unexpected keyword arguments to values_list: %s'
-                    % (kwargs.keys(),))
+                    % (list(six.iterkeys(kwargs)),))
         if flat and len(fields) > 1:
             raise TypeError("'flat' is not valid when values_list is called with more than one field.")
         return self._clone(klass=ValuesListQuerySet, setup=True, flat=flat,
@@ -693,7 +693,7 @@ class QuerySet(object):
         depth = kwargs.pop('depth', 0)
         if kwargs:
             raise TypeError('Unexpected keyword arguments to select_related: %s'
-                    % (kwargs.keys(),))
+                    % (list(six.iterkeys(kwargs)),))
         obj = self._clone()
         if fields:
             if depth:
@@ -751,7 +751,7 @@ class QuerySet(object):
 
         obj = self._clone()
 
-        obj._setup_aggregate_query(kwargs.keys())
+        obj._setup_aggregate_query(list(six.iterkeys(kwargs)))
 
         # Add the aggregates to the query
         for (alias, aggregate_expr) in kwargs.items():
@@ -966,9 +966,9 @@ class ValuesQuerySet(QuerySet):
 
     def iterator(self):
         # Purge any extra columns that haven't been explicitly asked for
-        extra_names = self.query.extra_select.keys()
+        extra_names = list(six.iterkeys(self.query.extra_select))
         field_names = self.field_names
-        aggregate_names = self.query.aggregate_select.keys()
+        aggregate_names = list(six.iterkeys(self.query.aggregate_select))
 
         names = extra_names + field_names + aggregate_names
 
@@ -1097,9 +1097,9 @@ class ValuesListQuerySet(ValuesQuerySet):
             # When extra(select=...) or an annotation is involved, the extra
             # cols are always at the start of the row, and we need to reorder
             # the fields to match the order in self._fields.
-            extra_names = self.query.extra_select.keys()
+            extra_names = list(six.iterkeys(self.query.extra_select))
             field_names = self.field_names
-            aggregate_names = self.query.aggregate_select.keys()
+            aggregate_names = list(six.iterkeys(self.query.aggregate_select))
 
             names = extra_names + field_names + aggregate_names
 
@@ -1527,7 +1527,7 @@ class RawQuerySet(object):
             # Associate fields to values
             if skip:
                 model_init_kwargs = {}
-                for attname, pos in model_init_field_names.iteritems():
+                for attname, pos in six.iteritems(model_init_field_names):
                     model_init_kwargs[attname] = values[pos]
                 instance = model_cls(**model_init_kwargs)
             else:
diff --git a/django/db/models/query_utils.py b/django/db/models/query_utils.py
index 60bdb2bcb4..c1a690a524 100644
--- a/django/db/models/query_utils.py
+++ b/django/db/models/query_utils.py
@@ -8,6 +8,7 @@ circular import difficulties.
 from __future__ import unicode_literals
 
 from django.db.backends import util
+from django.utils import six
 from django.utils import tree
 
 
@@ -40,7 +41,7 @@ class Q(tree.Node):
     default = AND
 
     def __init__(self, *args, **kwargs):
-        super(Q, self).__init__(children=list(args) + kwargs.items())
+        super(Q, self).__init__(children=list(args) + list(six.iteritems(kwargs)))
 
     def _combine(self, other, conn):
         if not isinstance(other, Q):
@@ -114,7 +115,7 @@ class DeferredAttribute(object):
 
     def _check_parent_chain(self, instance, name):
         """
-        Check if the field value can be fetched from a parent field already 
+        Check if the field value can be fetched from a parent field already
         loaded in the instance. This can be done if the to-be fetched
         field is a primary key field.
         """
diff --git a/django/db/models/sql/compiler.py b/django/db/models/sql/compiler.py
index 7a0afa349d..1311ea546c 100644
--- a/django/db/models/sql/compiler.py
+++ b/django/db/models/sql/compiler.py
@@ -9,6 +9,7 @@ from django.db.models.sql.datastructures import EmptyResultSet
 from django.db.models.sql.expressions import SQLEvaluator
 from django.db.models.sql.query import get_order_dir, Query
 from django.db.utils import DatabaseError
+from django.utils import six
 
 
 class SQLCompiler(object):
@@ -82,7 +83,7 @@ class SQLCompiler(object):
         where, w_params = self.query.where.as_sql(qn=qn, connection=self.connection)
         having, h_params = self.query.having.as_sql(qn=qn, connection=self.connection)
         params = []
-        for val in self.query.extra_select.itervalues():
+        for val in six.itervalues(self.query.extra_select):
             params.extend(val[1])
 
         result = ['SELECT']
@@ -177,7 +178,7 @@ class SQLCompiler(object):
         """
         qn = self.quote_name_unless_alias
         qn2 = self.connection.ops.quote_name
-        result = ['(%s) AS %s' % (col[0], qn2(alias)) for alias, col in self.query.extra_select.iteritems()]
+        result = ['(%s) AS %s' % (col[0], qn2(alias)) for alias, col in six.iteritems(self.query.extra_select)]
         aliases = set(self.query.extra_select.keys())
         if with_aliases:
             col_aliases = aliases.copy()
@@ -553,7 +554,7 @@ class SQLCompiler(object):
             group_by = self.query.group_by or []
 
             extra_selects = []
-            for extra_select, extra_params in self.query.extra_select.itervalues():
+            for extra_select, extra_params in six.itervalues(self.query.extra_select):
                 extra_selects.append(extra_select)
                 params.extend(extra_params)
             cols = (group_by + self.query.select +
diff --git a/django/db/models/sql/query.py b/django/db/models/sql/query.py
index 53dad608bf..9cf732f263 100644
--- a/django/db/models/sql/query.py
+++ b/django/db/models/sql/query.py
@@ -12,6 +12,7 @@ import copy
 from django.utils.datastructures import SortedDict
 from django.utils.encoding import force_unicode
 from django.utils.tree import Node
+from django.utils import six
 from django.db import connections, DEFAULT_DB_ALIAS
 from django.db.models import signals
 from django.db.models.expressions import ExpressionNode
@@ -602,22 +603,22 @@ class Query(object):
             # slight complexity here is handling fields that exist on parent
             # models.
             workset = {}
-            for model, values in seen.iteritems():
+            for model, values in six.iteritems(seen):
                 for field, m in model._meta.get_fields_with_model():
                     if field in values:
                         continue
                     add_to_dict(workset, m or model, field)
-            for model, values in must_include.iteritems():
+            for model, values in six.iteritems(must_include):
                 # If we haven't included a model in workset, we don't add the
                 # corresponding must_include fields for that model, since an
                 # empty set means "include all fields". That's why there's no
                 # "else" branch here.
                 if model in workset:
                     workset[model].update(values)
-            for model, values in workset.iteritems():
+            for model, values in six.iteritems(workset):
                 callback(target, model, values)
         else:
-            for model, values in must_include.iteritems():
+            for model, values in six.iteritems(must_include):
                 if model in seen:
                     seen[model].update(values)
                 else:
@@ -631,7 +632,7 @@ class Query(object):
             for model in orig_opts.get_parent_list():
                 if model not in seen:
                     seen[model] = set()
-            for model, values in seen.iteritems():
+            for model, values in six.iteritems(seen):
                 callback(target, model, values)
 
 
@@ -770,7 +771,7 @@ class Query(object):
         for k, aliases in self.join_map.items():
             aliases = tuple([change_map.get(a, a) for a in aliases])
             self.join_map[k] = aliases
-        for old_alias, new_alias in change_map.iteritems():
+        for old_alias, new_alias in six.iteritems(change_map):
             alias_data = self.alias_map[old_alias]
             alias_data = alias_data._replace(rhs_alias=new_alias)
             self.alias_refcount[new_alias] = self.alias_refcount[old_alias]
@@ -792,7 +793,7 @@ class Query(object):
                 self.included_inherited_models[key] = change_map[alias]
 
         # 3. Update any joins that refer to the old alias.
-        for alias, data in self.alias_map.iteritems():
+        for alias, data in six.iteritems(self.alias_map):
             lhs = data.lhs_alias
             if lhs in change_map:
                 data = data._replace(lhs_alias=change_map[lhs])
@@ -842,7 +843,7 @@ class Query(object):
         count. Note that after execution, the reference counts are zeroed, so
         tables added in compiler will not be seen by this method.
         """
-        return len([1 for count in self.alias_refcount.itervalues() if count])
+        return len([1 for count in six.itervalues(self.alias_refcount) if count])
 
     def join(self, connection, always_create=False, exclusions=(),
             promote=False, outer_if_first=False, nullable=False, reuse=None):
@@ -1302,7 +1303,7 @@ class Query(object):
                         field, model, direct, m2m = opts.get_field_by_name(f.name)
                         break
                 else:
-                    names = opts.get_all_field_names() + self.aggregate_select.keys()
+                    names = opts.get_all_field_names() + list(six.iterkeys(self.aggregate_select))
                     raise FieldError("Cannot resolve keyword %r into field. "
                             "Choices are: %s" % (name, ", ".join(names)))
 
@@ -1571,7 +1572,7 @@ class Query(object):
         # Tag.objects.exclude(parent__parent__name='t1'), a tag with no parent
         # would otherwise be overlooked).
         active_positions = [pos for (pos, count) in
-                enumerate(query.alias_refcount.itervalues()) if count]
+                enumerate(six.itervalues(query.alias_refcount)) if count]
         if active_positions[-1] > 1:
             self.add_filter(('%s__isnull' % prefix, False), negate=True,
                     trim=True, can_reuse=can_reuse)
@@ -1660,8 +1661,8 @@ class Query(object):
                 # from the model on which the lookup failed.
                 raise
             else:
-                names = sorted(opts.get_all_field_names() + self.extra.keys()
-                               + self.aggregate_select.keys())
+                names = sorted(opts.get_all_field_names() + list(six.iterkeys(self.extra))
+                               + list(six.iterkeys(self.aggregate_select)))
                 raise FieldError("Cannot resolve keyword %r into field. "
                                  "Choices are: %s" % (name, ", ".join(names)))
         self.remove_inherited_models()
diff --git a/django/db/models/sql/subqueries.py b/django/db/models/sql/subqueries.py
index 7b92394e90..cc7da0eeaf 100644
--- a/django/db/models/sql/subqueries.py
+++ b/django/db/models/sql/subqueries.py
@@ -11,6 +11,7 @@ from django.db.models.sql.where import AND, Constraint
 from django.utils.datastructures import SortedDict
 from django.utils.functional import Promise
 from django.utils.encoding import force_unicode
+from django.utils import six
 
 
 __all__ = ['DeleteQuery', 'UpdateQuery', 'InsertQuery', 'DateQuery',
@@ -87,7 +88,7 @@ class UpdateQuery(Query):
         querysets.
         """
         values_seq = []
-        for name, val in values.iteritems():
+        for name, val in six.iteritems(values):
             field, model, direct, m2m = self.model._meta.get_field_by_name(name)
             if not direct or m2m:
                 raise FieldError('Cannot update model field %r (only non-relations and foreign keys permitted).' % field)
@@ -129,7 +130,7 @@ class UpdateQuery(Query):
         if not self.related_updates:
             return []
         result = []
-        for model, values in self.related_updates.iteritems():
+        for model, values in six.iteritems(self.related_updates):
             query = UpdateQuery(model)
             query.values = values
             if self.related_ids is not None:
diff --git a/django/forms/extras/widgets.py b/django/forms/extras/widgets.py
index 4e11a4ee06..c5ca1424c8 100644
--- a/django/forms/extras/widgets.py
+++ b/django/forms/extras/widgets.py
@@ -79,7 +79,7 @@ class SelectDateWidget(Widget):
                         year_val, month_val, day_val = [int(v) for v in match.groups()]
         choices = [(i, i) for i in self.years]
         year_html = self.create_select(name, self.year_field, value, year_val, choices)
-        choices = MONTHS.items()
+        choices = list(six.iteritems(MONTHS))
         month_html = self.create_select(name, self.month_field, value, month_val, choices)
         choices = [(i, i) for i in range(1, 32)]
         day_html = self.create_select(name, self.day_field, value, day_val,  choices)
diff --git a/django/forms/forms.py b/django/forms/forms.py
index 4d4cdbe3db..0f3fdb2e40 100644
--- a/django/forms/forms.py
+++ b/django/forms/forms.py
@@ -38,7 +38,7 @@ def get_declared_fields(bases, attrs, with_base_fields=True):
     used. The distinction is useful in ModelForm subclassing.
     Also integrates any additional media definitions
     """
-    fields = [(field_name, attrs.pop(field_name)) for field_name, obj in attrs.items() if isinstance(obj, Field)]
+    fields = [(field_name, attrs.pop(field_name)) for field_name, obj in list(six.iteritems(attrs)) if isinstance(obj, Field)]
     fields.sort(key=lambda x: x[1].creation_counter)
 
     # If this class is subclassing another Form, add that Form's fields.
@@ -47,11 +47,11 @@ def get_declared_fields(bases, attrs, with_base_fields=True):
     if with_base_fields:
         for base in bases[::-1]:
             if hasattr(base, 'base_fields'):
-                fields = base.base_fields.items() + fields
+                fields = list(six.iteritems(base.base_fields)) + fields
     else:
         for base in bases[::-1]:
             if hasattr(base, 'declared_fields'):
-                fields = base.declared_fields.items() + fields
+                fields = list(six.iteritems(base.declared_fields)) + fields
 
     return SortedDict(fields)
 
diff --git a/django/forms/models.py b/django/forms/models.py
index e6ae357d19..a2b5448b14 100644
--- a/django/forms/models.py
+++ b/django/forms/models.py
@@ -18,6 +18,7 @@ from django.utils.datastructures import SortedDict
 from django.utils import six
 from django.utils.text import get_text_list, capfirst
 from django.utils.translation import ugettext_lazy as _, ugettext
+from django.utils import six
 
 
 __all__ = (
@@ -206,7 +207,7 @@ class ModelFormMetaclass(type):
             fields = fields_for_model(opts.model, opts.fields,
                                       opts.exclude, opts.widgets, formfield_callback)
             # make sure opts.fields doesn't specify an invalid field
-            none_model_fields = [k for k, v in fields.iteritems() if not v]
+            none_model_fields = [k for k, v in six.iteritems(fields) if not v]
             missing_fields = set(none_model_fields) - \
                              set(declared_fields.keys())
             if missing_fields:
diff --git a/django/forms/widgets.py b/django/forms/widgets.py
index 3c4da2444d..13b7d8e7f6 100644
--- a/django/forms/widgets.py
+++ b/django/forms/widgets.py
@@ -63,8 +63,7 @@ class Media(StrAndUnicode):
     def render_css(self):
         # To keep rendering order consistent, we can't just iterate over items().
         # We need to sort the keys, and iterate over the sorted list.
-        media = self._css.keys()
-        media.sort()
+        media = sorted(self._css.keys())
         return chain(*[
                 [format_html('<link href="{0}" type="text/css" media="{1}" rel="stylesheet" />', self.absolute_path(path), medium)
                     for path in self._css[medium]]
diff --git a/django/template/base.py b/django/template/base.py
index 489b1681e0..d5c2438500 100644
--- a/django/template/base.py
+++ b/django/template/base.py
@@ -961,7 +961,7 @@ def parse_bits(parser, bits, params, varargs, varkw, defaults,
         kwarg = token_kwargs([bit], parser)
         if kwarg:
             # The kwarg was successfully extracted
-            param, value = kwarg.items()[0]
+            param, value = list(six.iteritems(kwarg))[0]
             if param not in params and varkw is None:
                 # An unexpected keyword argument was supplied
                 raise TemplateSyntaxError(
diff --git a/django/template/defaulttags.py b/django/template/defaulttags.py
index fb45fe722e..7a00d60361 100644
--- a/django/template/defaulttags.py
+++ b/django/template/defaulttags.py
@@ -17,6 +17,7 @@ from django.template.defaultfilters import date
 from django.utils.encoding import smart_unicode
 from django.utils.safestring import mark_safe
 from django.utils.html import format_html
+from django.utils import six
 from django.utils import timezone
 
 register = Library()
@@ -473,7 +474,7 @@ class WithNode(Node):
 
     def render(self, context):
         values = dict([(key, val.resolve(context)) for key, val in
-                       self.extra_context.iteritems()])
+                       six.iteritems(self.extra_context)])
         context.update(values)
         output = self.nodelist.render(context)
         context.pop()
@@ -1188,7 +1189,7 @@ def templatetag(parser, token):
     if tag not in TemplateTagNode.mapping:
         raise TemplateSyntaxError("Invalid templatetag argument: '%s'."
                                   " Must be one of: %s" %
-                                  (tag, TemplateTagNode.mapping.keys()))
+                                  (tag, list(six.iterkeys(TemplateTagNode.mapping))))
     return TemplateTagNode(tag)
 
 @register.tag
diff --git a/django/template/loader_tags.py b/django/template/loader_tags.py
index b63938abb0..d295d058d0 100644
--- a/django/template/loader_tags.py
+++ b/django/template/loader_tags.py
@@ -3,6 +3,7 @@ from django.template.base import TemplateSyntaxError, Library, Node, TextNode,\
     token_kwargs, Variable
 from django.template.loader import get_template
 from django.utils.safestring import mark_safe
+from django.utils import six
 
 register = Library()
 
@@ -17,7 +18,7 @@ class BlockContext(object):
         self.blocks = {}
 
     def add_blocks(self, blocks):
-        for name, block in blocks.iteritems():
+        for name, block in six.iteritems(blocks):
             if name in self.blocks:
                 self.blocks[name].insert(0, block)
             else:
@@ -130,7 +131,7 @@ class BaseIncludeNode(Node):
 
     def render_template(self, template, context):
         values = dict([(name, var.resolve(context)) for name, var
-                       in self.extra_context.iteritems()])
+                       in six.iteritems(self.extra_context)])
         if self.isolated_context:
             return template.render(context.new(values))
         context.update(values)
diff --git a/django/templatetags/i18n.py b/django/templatetags/i18n.py
index 509ab6707d..30eb6b5f76 100644
--- a/django/templatetags/i18n.py
+++ b/django/templatetags/i18n.py
@@ -425,7 +425,7 @@ def do_block_translate(parser, token):
         options[option] = value
 
     if 'count' in options:
-        countervar, counter = options['count'].items()[0]
+        countervar, counter = list(six.iteritems(options['count']))[0]
     else:
         countervar, counter = None, None
     if 'context' in options:
diff --git a/django/utils/dateparse.py b/django/utils/dateparse.py
index 532bb259c3..032eb493b6 100644
--- a/django/utils/dateparse.py
+++ b/django/utils/dateparse.py
@@ -7,6 +7,7 @@
 
 import datetime
 import re
+from django.utils import six
 from django.utils.timezone import utc
 from django.utils.tzinfo import FixedOffset
 
@@ -34,7 +35,7 @@ def parse_date(value):
     """
     match = date_re.match(value)
     if match:
-        kw = dict((k, int(v)) for k, v in match.groupdict().iteritems())
+        kw = dict((k, int(v)) for k, v in six.iteritems(match.groupdict()))
         return datetime.date(**kw)
 
 def parse_time(value):
@@ -53,7 +54,7 @@ def parse_time(value):
         kw = match.groupdict()
         if kw['microsecond']:
             kw['microsecond'] = kw['microsecond'].ljust(6, '0')
-        kw = dict((k, int(v)) for k, v in kw.iteritems() if v is not None)
+        kw = dict((k, int(v)) for k, v in six.iteritems(kw) if v is not None)
         return datetime.time(**kw)
 
 def parse_datetime(value):
@@ -80,6 +81,6 @@ def parse_datetime(value):
             if tzinfo[0] == '-':
                 offset = -offset
             tzinfo = FixedOffset(offset)
-        kw = dict((k, int(v)) for k, v in kw.iteritems() if v is not None)
+        kw = dict((k, int(v)) for k, v in six.iteritems(kw) if v is not None)
         kw['tzinfo'] = tzinfo
         return datetime.datetime(**kw)
diff --git a/django/utils/dictconfig.py b/django/utils/dictconfig.py
index b4d6d66b3c..f8d6eebf89 100644
--- a/django/utils/dictconfig.py
+++ b/django/utils/dictconfig.py
@@ -363,7 +363,7 @@ class DictConfigurator(BaseConfigurator):
                 #which were in the previous configuration but
                 #which are not in the new configuration.
                 root = logging.root
-                existing = root.manager.loggerDict.keys()
+                existing = list(six.iterkeys(root.manager.loggerDict))
                 #The list needs to be sorted so that we can
                 #avoid disabling child loggers of explicitly
                 #named loggers. With a sorted list it is easier
diff --git a/django/utils/functional.py b/django/utils/functional.py
index 69aae09887..177325dfb6 100644
--- a/django/utils/functional.py
+++ b/django/utils/functional.py
@@ -178,7 +178,7 @@ def allow_lazy(func, *resultclasses):
     """
     @wraps(func)
     def wrapper(*args, **kwargs):
-        for arg in list(args) + kwargs.values():
+        for arg in list(args) + list(six.itervalues(kwargs)):
             if isinstance(arg, Promise):
                 break
         else:
diff --git a/django/utils/html.py b/django/utils/html.py
index e1263fbd66..4e888fc59b 100644
--- a/django/utils/html.py
+++ b/django/utils/html.py
@@ -84,7 +84,7 @@ def format_html(format_string, *args, **kwargs):
     """
     args_safe = map(conditional_escape, args)
     kwargs_safe = dict([(k, conditional_escape(v)) for (k, v) in
-                        kwargs.iteritems()])
+                        six.iteritems(kwargs)])
     return mark_safe(format_string.format(*args_safe, **kwargs_safe))
 
 def format_html_join(sep, format_string, args_generator):
diff --git a/django/utils/termcolors.py b/django/utils/termcolors.py
index 1eebaa2316..4f74b564a5 100644
--- a/django/utils/termcolors.py
+++ b/django/utils/termcolors.py
@@ -2,6 +2,8 @@
 termcolors.py
 """
 
+from django.utils import six
+
 color_names = ('black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white')
 foreground = dict([(color_names[x], '3%s' % x) for x in range(8)])
 background = dict([(color_names[x], '4%s' % x) for x in range(8)])
@@ -41,7 +43,7 @@ def colorize(text='', opts=(), **kwargs):
     code_list = []
     if text == '' and len(opts) == 1 and opts[0] == 'reset':
         return '\x1b[%sm' % RESET
-    for k, v in kwargs.iteritems():
+    for k, v in six.iteritems(kwargs):
         if k == 'fg':
             code_list.append(foreground[v])
         elif k == 'bg':
diff --git a/django/views/debug.py b/django/views/debug.py
index 8e81b8239b..08341fe145 100644
--- a/django/views/debug.py
+++ b/django/views/debug.py
@@ -111,7 +111,7 @@ class ExceptionReporterFilter(object):
             return request.POST
 
     def get_traceback_frame_variables(self, request, tb_frame):
-        return tb_frame.f_locals.items()
+        return list(six.iteritems(tb_frame.f_locals))
 
 class SafeExceptionReporterFilter(ExceptionReporterFilter):
     """
diff --git a/django/views/generic/base.py b/django/views/generic/base.py
index 69751727bb..6554e898ca 100644
--- a/django/views/generic/base.py
+++ b/django/views/generic/base.py
@@ -6,6 +6,7 @@ from django.core.exceptions import ImproperlyConfigured
 from django.template.response import TemplateResponse
 from django.utils.log import getLogger
 from django.utils.decorators import classonlymethod
+from django.utils import six
 
 logger = getLogger('django.request')
 
@@ -35,7 +36,7 @@ class View(object):
         """
         # Go through keyword arguments, and either save their values to our
         # instance, or raise an error.
-        for key, value in kwargs.iteritems():
+        for key, value in six.iteritems(kwargs):
             setattr(self, key, value)
 
     @classonlymethod
diff --git a/tests/modeltests/timezones/tests.py b/tests/modeltests/timezones/tests.py
index aadb8ba842..a38e4b3f75 100644
--- a/tests/modeltests/timezones/tests.py
+++ b/tests/modeltests/timezones/tests.py
@@ -20,6 +20,7 @@ from django.http import HttpRequest
 from django.template import Context, RequestContext, Template, TemplateSyntaxError
 from django.test import TestCase, skipIfDBFeature, skipUnlessDBFeature
 from django.test.utils import override_settings
+from django.utils import six
 from django.utils import timezone
 from django.utils.tzinfo import FixedOffset
 from django.utils.unittest import skipIf, skipUnless
@@ -690,8 +691,8 @@ class TemplateTests(TestCase):
             }
         }
 
-        for k1, dt in datetimes.iteritems():
-            for k2, tpl in templates.iteritems():
+        for k1, dt in six.iteritems(datetimes):
+            for k2, tpl in six.iteritems(templates):
                 ctx = Context({'dt': dt, 'ICT': ICT})
                 actual = tpl.render(ctx)
                 expected = results[k1][k2]
@@ -703,8 +704,8 @@ class TemplateTests(TestCase):
         results['ict']['notag'] = t('ict', 'eat', 'utc', 'ict')
 
         with self.settings(USE_TZ=False):
-            for k1, dt in datetimes.iteritems():
-                for k2, tpl in templates.iteritems():
+            for k1, dt in six.iteritems(datetimes):
+                for k2, tpl in six.iteritems(templates):
                     ctx = Context({'dt': dt, 'ICT': ICT})
                     actual = tpl.render(ctx)
                     expected = results[k1][k2]
diff --git a/tests/regressiontests/aggregation_regress/tests.py b/tests/regressiontests/aggregation_regress/tests.py
index e5f12e5781..e24eb43b87 100644
--- a/tests/regressiontests/aggregation_regress/tests.py
+++ b/tests/regressiontests/aggregation_regress/tests.py
@@ -8,6 +8,7 @@ from operator import attrgetter
 from django.core.exceptions import FieldError
 from django.db.models import Count, Max, Avg, Sum, StdDev, Variance, F, Q
 from django.test import TestCase, Approximate, skipUnlessDBFeature
+from django.utils import six
 
 from .models import Author, Book, Publisher, Clues, Entries, HardbackBook
 
@@ -16,7 +17,7 @@ class AggregationTests(TestCase):
     fixtures = ["aggregation_regress.json"]
 
     def assertObjectAttrs(self, obj, **kwargs):
-        for attr, value in kwargs.iteritems():
+        for attr, value in six.iteritems(kwargs):
             self.assertEqual(getattr(obj, attr), value)
 
     def test_aggregates_in_where_clause(self):
diff --git a/tests/regressiontests/db_typecasts/tests.py b/tests/regressiontests/db_typecasts/tests.py
index 83bd1e6851..2cf835d94e 100644
--- a/tests/regressiontests/db_typecasts/tests.py
+++ b/tests/regressiontests/db_typecasts/tests.py
@@ -3,6 +3,7 @@
 import datetime
 
 from django.db.backends import util as typecasts
+from django.utils import six
 from django.utils import unittest
 
 
@@ -49,7 +50,7 @@ TEST_CASES = {
 
 class DBTypeCasts(unittest.TestCase):
     def test_typeCasts(self):
-        for k, v in TEST_CASES.iteritems():
+        for k, v in six.iteritems(TEST_CASES):
             for inpt, expected in v:
                 got = getattr(typecasts, k)(inpt)
                 self.assertEqual(got, expected, "In %s: %r doesn't match %r. Got %r instead." % (k, inpt, expected, got))
diff --git a/tests/regressiontests/templates/templatetags/custom.py b/tests/regressiontests/templates/templatetags/custom.py
index 95fcd551de..3f51353880 100644
--- a/tests/regressiontests/templates/templatetags/custom.py
+++ b/tests/regressiontests/templates/templatetags/custom.py
@@ -70,7 +70,7 @@ simple_only_unlimited_args.anything = "Expected simple_only_unlimited_args __dic
 def simple_unlimited_args_kwargs(one, two='hi', *args, **kwargs):
     """Expected simple_unlimited_args_kwargs __doc__"""
     # Sort the dictionary by key to guarantee the order for testing.
-    sorted_kwarg = sorted(kwargs.iteritems(), key=operator.itemgetter(0))
+    sorted_kwarg = sorted(six.iteritems(kwargs), key=operator.itemgetter(0))
     return "simple_unlimited_args_kwargs - Expected result: %s / %s" % (
         ', '.join([six.text_type(arg) for arg in [one, two] + list(args)]),
         ', '.join(['%s=%s' % (k, v) for (k, v) in sorted_kwarg])
@@ -221,7 +221,7 @@ inclusion_tag_use_l10n.anything = "Expected inclusion_tag_use_l10n __dict__"
 def inclusion_unlimited_args_kwargs(one, two='hi', *args, **kwargs):
     """Expected inclusion_unlimited_args_kwargs __doc__"""
     # Sort the dictionary by key to guarantee the order for testing.
-    sorted_kwarg = sorted(kwargs.iteritems(), key=operator.itemgetter(0))
+    sorted_kwarg = sorted(six.iteritems(kwargs), key=operator.itemgetter(0))
     return {"result": "inclusion_unlimited_args_kwargs - Expected result: %s / %s" % (
         ', '.join([six.text_type(arg) for arg in [one, two] + list(args)]),
         ', '.join(['%s=%s' % (k, v) for (k, v) in sorted_kwarg])
@@ -292,7 +292,7 @@ assignment_only_unlimited_args.anything = "Expected assignment_only_unlimited_ar
 def assignment_unlimited_args_kwargs(one, two='hi', *args, **kwargs):
     """Expected assignment_unlimited_args_kwargs __doc__"""
     # Sort the dictionary by key to guarantee the order for testing.
-    sorted_kwarg = sorted(kwargs.iteritems(), key=operator.itemgetter(0))
+    sorted_kwarg = sorted(six.iteritems(kwargs), key=operator.itemgetter(0))
     return "assignment_unlimited_args_kwargs - Expected result: %s / %s" % (
         ', '.join([six.text_type(arg) for arg in [one, two] + list(args)]),
         ', '.join(['%s=%s' % (k, v) for (k, v) in sorted_kwarg])
diff --git a/tests/regressiontests/templates/tests.py b/tests/regressiontests/templates/tests.py
index 402cbb19d2..edbb21b6bd 100644
--- a/tests/regressiontests/templates/tests.py
+++ b/tests/regressiontests/templates/tests.py
@@ -30,6 +30,7 @@ from django.utils import unittest
 from django.utils.formats import date_format
 from django.utils.translation import activate, deactivate, ugettext as _
 from django.utils.safestring import mark_safe
+from django.utils import six
 from django.utils.tzinfo import LocalTimezone
 
 from .callables import CallableVariablesTests
@@ -402,7 +403,7 @@ class Templates(unittest.TestCase):
         template_tests.update(filter_tests)
 
         cache_loader = setup_test_template_loader(
-            dict([(name, t[0]) for name, t in template_tests.iteritems()]),
+            dict([(name, t[0]) for name, t in six.iteritems(template_tests)]),
             use_cached_loader=True,
         )
 
-- 
cgit v1.3


From c5ef65bcf324f4c90b53be90f4aec069a68e8c59 Mon Sep 17 00:00:00 2001
From: Aymeric Augustin <aymeric.augustin@m4x.org>
Date: Sat, 21 Jul 2012 10:00:10 +0200
Subject: [py3] Ported django.utils.encoding.

* Renamed smart_unicode to smart_text (but kept the old name under
  Python 2 for backwards compatibility).
* Renamed smart_str to smart_bytes.
* Re-introduced smart_str as an alias for smart_text under Python 3
  and smart_bytes under Python 2 (which is backwards compatible).
  Thus smart_str always returns a str objects.
* Used the new smart_str in a few places where both Python 2 and 3
  want a str.
---
 django/contrib/admin/actions.py                    |  8 +--
 django/contrib/admin/filters.py                    |  8 +--
 django/contrib/admin/helpers.py                    |  8 +--
 django/contrib/admin/models.py                     |  6 +-
 django/contrib/admin/options.py                    | 58 +++++++++----------
 django/contrib/admin/templatetags/admin_list.py    | 12 ++--
 django/contrib/admin/util.py                       | 18 +++---
 django/contrib/admin/views/main.py                 |  6 +-
 django/contrib/admin/widgets.py                    |  8 +--
 django/contrib/admindocs/utils.py                  |  4 +-
 django/contrib/auth/hashers.py                     |  8 +--
 django/contrib/auth/tests/forms.py                 | 28 ++++-----
 django/contrib/auth/tests/views.py                 |  4 +-
 django/contrib/comments/forms.py                   |  4 +-
 django/contrib/comments/managers.py                |  4 +-
 django/contrib/comments/templatetags/comments.py   |  4 +-
 django/contrib/contenttypes/generic.py             |  4 +-
 django/contrib/contenttypes/management.py          |  4 +-
 django/contrib/contenttypes/models.py              | 10 ++--
 django/contrib/databrowse/datastructures.py        | 16 +++---
 django/contrib/databrowse/plugins/calendars.py     |  4 +-
 django/contrib/databrowse/plugins/fieldchoices.py  |  4 +-
 django/contrib/formtools/wizard/storage/base.py    |  4 +-
 django/contrib/gis/sitemaps/views.py               |  4 +-
 django/contrib/humanize/templatetags/humanize.py   |  4 +-
 django/contrib/localflavor/au/forms.py             |  4 +-
 django/contrib/localflavor/br/forms.py             |  8 +--
 django/contrib/localflavor/ca/forms.py             |  4 +-
 django/contrib/localflavor/ch/forms.py             |  4 +-
 django/contrib/localflavor/cl/forms.py             |  4 +-
 django/contrib/localflavor/fr/forms.py             |  4 +-
 django/contrib/localflavor/hk/forms.py             |  4 +-
 django/contrib/localflavor/hr/forms.py             |  6 +-
 django/contrib/localflavor/id/forms.py             | 10 ++--
 django/contrib/localflavor/in_/forms.py            |  6 +-
 django/contrib/localflavor/is_/forms.py            |  4 +-
 django/contrib/localflavor/it/forms.py             |  4 +-
 django/contrib/localflavor/it/util.py              |  6 +-
 django/contrib/localflavor/nl/forms.py             |  4 +-
 django/contrib/localflavor/pt/forms.py             |  6 +-
 django/contrib/localflavor/tr/forms.py             |  4 +-
 django/contrib/localflavor/us/forms.py             |  4 +-
 django/contrib/markup/templatetags/markup.py       | 20 +++----
 django/contrib/messages/storage/base.py            | 14 ++---
 django/contrib/sessions/backends/db.py             |  4 +-
 .../management/commands/collectstatic.py           |  6 +-
 .../staticfiles/management/commands/findstatic.py  |  6 +-
 django/contrib/staticfiles/storage.py              | 10 ++--
 django/contrib/syndication/views.py                | 12 ++--
 django/core/cache/backends/base.py                 |  6 +-
 django/core/context_processors.py                  |  4 +-
 django/core/exceptions.py                          |  6 +-
 django/core/files/base.py                          |  6 +-
 django/core/files/storage.py                       |  4 +-
 django/core/files/uploadedfile.py                  |  4 +-
 django/core/handlers/base.py                       |  8 +--
 django/core/handlers/wsgi.py                       |  6 +-
 django/core/mail/message.py                        | 12 ++--
 .../core/management/commands/createcachetable.py   |  4 +-
 django/core/management/commands/loaddata.py        |  4 +-
 django/core/serializers/base.py                    |  2 +-
 django/core/serializers/json.py                    |  2 +-
 django/core/serializers/python.py                  | 14 ++---
 django/core/serializers/pyyaml.py                  |  2 +-
 django/core/serializers/xml_serializer.py          | 18 +++---
 django/core/signing.py                             | 12 ++--
 django/core/urlresolvers.py                        | 12 ++--
 django/core/validators.py                          |  6 +-
 django/db/backends/__init__.py                     | 10 ++--
 django/db/backends/oracle/base.py                  | 18 +++---
 django/db/models/base.py                           | 10 ++--
 django/db/models/fields/__init__.py                | 14 ++---
 django/db/models/fields/files.py                   |  4 +-
 django/db/models/fields/related.py                 |  6 +-
 django/db/models/options.py                        |  6 +-
 django/db/models/related.py                        |  6 +-
 django/db/models/sql/query.py                      |  4 +-
 django/db/models/sql/subqueries.py                 |  6 +-
 django/forms/fields.py                             | 20 +++----
 django/forms/forms.py                              | 20 +++----
 django/forms/models.py                             | 10 ++--
 django/forms/util.py                               | 12 ++--
 django/forms/widgets.py                            | 42 +++++++-------
 django/http/__init__.py                            | 24 ++++----
 django/http/multipartparser.py                     | 10 ++--
 django/template/base.py                            | 12 ++--
 django/template/debug.py                           |  4 +-
 django/template/defaultfilters.py                  | 18 +++---
 django/template/defaulttags.py                     |  6 +-
 django/templatetags/l10n.py                        |  6 +-
 django/test/client.py                              | 10 ++--
 django/test/html.py                                |  4 +-
 django/test/testcases.py                           |  8 +--
 django/utils/_os.py                                |  6 +-
 django/utils/cache.py                              |  4 +-
 django/utils/crypto.py                             |  8 +--
 django/utils/dateformat.py                         |  6 +-
 django/utils/encoding.py                           | 66 ++++++++++++++--------
 django/utils/feedgenerator.py                      | 12 ++--
 django/utils/html.py                               | 22 ++++----
 django/utils/http.py                               | 10 ++--
 django/utils/text.py                               | 24 ++++----
 django/utils/translation/__init__.py               |  4 +-
 django/utils/translation/trans_null.py             |  6 +-
 django/utils/tzinfo.py                             |  6 +-
 django/views/debug.py                              |  8 +--
 django/views/generic/dates.py                      |  6 +-
 django/views/i18n.py                               |  6 +-
 docs/howto/custom-model-fields.txt                 |  2 +-
 docs/ref/databases.txt                             |  2 +-
 docs/ref/models/instances.txt                      |  4 +-
 docs/ref/settings.txt                              |  2 +-
 docs/ref/unicode.txt                               | 24 ++++----
 docs/ref/utils.txt                                 | 50 ++++++++++++----
 docs/releases/1.5.txt                              |  2 +-
 docs/topics/cache.txt                              |  2 +-
 docs/topics/serialization.txt                      |  4 +-
 tests/modeltests/field_subclassing/fields.py       |  8 +--
 tests/modeltests/field_subclassing/models.py       |  4 +-
 tests/regressiontests/admin_filters/tests.py       | 60 ++++++++++----------
 tests/regressiontests/admin_views/admin.py         |  2 +-
 tests/regressiontests/cache/tests.py               |  6 +-
 tests/regressiontests/forms/tests/extra.py         | 14 ++---
 tests/regressiontests/signing/tests.py             |  4 +-
 tests/regressiontests/staticfiles_tests/tests.py   |  6 +-
 125 files changed, 629 insertions(+), 583 deletions(-)

(limited to 'tests')

diff --git a/django/contrib/admin/actions.py b/django/contrib/admin/actions.py
index 5b56402428..201101736e 100644
--- a/django/contrib/admin/actions.py
+++ b/django/contrib/admin/actions.py
@@ -7,7 +7,7 @@ from django.contrib.admin import helpers
 from django.contrib.admin.util import get_deleted_objects, model_ngettext
 from django.db import router
 from django.template.response import TemplateResponse
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils.translation import ugettext_lazy, ugettext as _
 
 def delete_selected(modeladmin, request, queryset):
@@ -42,7 +42,7 @@ def delete_selected(modeladmin, request, queryset):
         n = queryset.count()
         if n:
             for obj in queryset:
-                obj_display = force_unicode(obj)
+                obj_display = force_text(obj)
                 modeladmin.log_deletion(request, obj, obj_display)
             queryset.delete()
             modeladmin.message_user(request, _("Successfully deleted %(count)d %(items)s.") % {
@@ -52,9 +52,9 @@ def delete_selected(modeladmin, request, queryset):
         return None
 
     if len(queryset) == 1:
-        objects_name = force_unicode(opts.verbose_name)
+        objects_name = force_text(opts.verbose_name)
     else:
-        objects_name = force_unicode(opts.verbose_name_plural)
+        objects_name = force_text(opts.verbose_name_plural)
 
     if perms_needed or protected:
         title = _("Cannot delete %(name)s") % {"name": objects_name}
diff --git a/django/contrib/admin/filters.py b/django/contrib/admin/filters.py
index 538bf54df9..cecae216c0 100644
--- a/django/contrib/admin/filters.py
+++ b/django/contrib/admin/filters.py
@@ -9,7 +9,7 @@ import datetime
 
 from django.db import models
 from django.core.exceptions import ImproperlyConfigured
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.translation import ugettext_lazy as _
 from django.utils import timezone
 
@@ -195,7 +195,7 @@ class RelatedFieldListFilter(FieldListFilter):
         }
         for pk_val, val in self.lookup_choices:
             yield {
-                'selected': self.lookup_val == smart_unicode(pk_val),
+                'selected': self.lookup_val == smart_text(pk_val),
                 'query_string': cl.get_query_string({
                     self.lookup_kwarg: pk_val,
                 }, [self.lookup_kwarg_isnull]),
@@ -272,7 +272,7 @@ class ChoicesFieldListFilter(FieldListFilter):
         }
         for lookup, title in self.field.flatchoices:
             yield {
-                'selected': smart_unicode(lookup) == self.lookup_val,
+                'selected': smart_text(lookup) == self.lookup_val,
                 'query_string': cl.get_query_string({
                                     self.lookup_kwarg: lookup}),
                 'display': title,
@@ -381,7 +381,7 @@ class AllValuesFieldListFilter(FieldListFilter):
             if val is None:
                 include_none = True
                 continue
-            val = smart_unicode(val)
+            val = smart_text(val)
             yield {
                 'selected': self.lookup_val == val,
                 'query_string': cl.get_query_string({
diff --git a/django/contrib/admin/helpers.py b/django/contrib/admin/helpers.py
index 4fc78784f4..aeacd234a3 100644
--- a/django/contrib/admin/helpers.py
+++ b/django/contrib/admin/helpers.py
@@ -9,7 +9,7 @@ from django.core.exceptions import ObjectDoesNotExist
 from django.db.models.fields.related import ManyToManyRel
 from django.forms.util import flatatt
 from django.template.defaultfilters import capfirst
-from django.utils.encoding import force_unicode, smart_unicode
+from django.utils.encoding import force_text, smart_text
 from django.utils.html import conditional_escape, format_html
 from django.utils.safestring import mark_safe
 from django.utils import six
@@ -122,7 +122,7 @@ class AdminField(object):
 
     def label_tag(self):
         classes = []
-        contents = conditional_escape(force_unicode(self.field.label))
+        contents = conditional_escape(force_text(self.field.label))
         if self.is_checkbox:
             classes.append('vCheckboxLabel')
         else:
@@ -166,7 +166,7 @@ class AdminReadonlyField(object):
         label = self.field['label']
         return format_html('<label{0}>{1}:</label>',
                            flatatt(attrs),
-                           capfirst(force_unicode(label)))
+                           capfirst(force_text(label)))
 
     def contents(self):
         from django.contrib.admin.templatetags.admin_list import _boolean_icon
@@ -182,7 +182,7 @@ class AdminReadonlyField(object):
                 if boolean:
                     result_repr = _boolean_icon(value)
                 else:
-                    result_repr = smart_unicode(value)
+                    result_repr = smart_text(value)
                     if getattr(attr, "allow_tags", False):
                         result_repr = mark_safe(result_repr)
             else:
diff --git a/django/contrib/admin/models.py b/django/contrib/admin/models.py
index 58bbbabfdf..e31c6d84ed 100644
--- a/django/contrib/admin/models.py
+++ b/django/contrib/admin/models.py
@@ -5,7 +5,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.contrib.auth.models import User
 from django.contrib.admin.util import quote
 from django.utils.translation import ugettext_lazy as _
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 
 ADDITION = 1
 CHANGE = 2
@@ -13,7 +13,7 @@ DELETION = 3
 
 class LogEntryManager(models.Manager):
     def log_action(self, user_id, content_type_id, object_id, object_repr, action_flag, change_message=''):
-        e = self.model(None, None, user_id, content_type_id, smart_unicode(object_id), object_repr[:200], action_flag, change_message)
+        e = self.model(None, None, user_id, content_type_id, smart_text(object_id), object_repr[:200], action_flag, change_message)
         e.save()
 
 class LogEntry(models.Model):
@@ -34,7 +34,7 @@ class LogEntry(models.Model):
         ordering = ('-action_time',)
 
     def __repr__(self):
-        return smart_unicode(self.action_time)
+        return smart_text(self.action_time)
 
     def __unicode__(self):
         if self.action_flag == ADDITION:
diff --git a/django/contrib/admin/options.py b/django/contrib/admin/options.py
index ea28125a5f..7708050e6f 100644
--- a/django/contrib/admin/options.py
+++ b/django/contrib/admin/options.py
@@ -28,7 +28,7 @@ from django.utils import six
 from django.utils.text import capfirst, get_text_list
 from django.utils.translation import ugettext as _
 from django.utils.translation import ungettext
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 
 HORIZONTAL, VERTICAL = 1, 2
 # returns the <ul> class for a given radio_admin field
@@ -520,7 +520,7 @@ class ModelAdmin(BaseModelAdmin):
             user_id         = request.user.pk,
             content_type_id = ContentType.objects.get_for_model(object).pk,
             object_id       = object.pk,
-            object_repr     = force_unicode(object),
+            object_repr     = force_text(object),
             action_flag     = ADDITION
         )
 
@@ -535,7 +535,7 @@ class ModelAdmin(BaseModelAdmin):
             user_id         = request.user.pk,
             content_type_id = ContentType.objects.get_for_model(object).pk,
             object_id       = object.pk,
-            object_repr     = force_unicode(object),
+            object_repr     = force_text(object),
             action_flag     = CHANGE,
             change_message  = message
         )
@@ -560,7 +560,7 @@ class ModelAdmin(BaseModelAdmin):
         """
         A list_display column containing a checkbox widget.
         """
-        return helpers.checkbox.render(helpers.ACTION_CHECKBOX_NAME, force_unicode(obj.pk))
+        return helpers.checkbox.render(helpers.ACTION_CHECKBOX_NAME, force_text(obj.pk))
     action_checkbox.short_description = mark_safe('<input type="checkbox" id="action-toggle" />')
     action_checkbox.allow_tags = True
 
@@ -674,17 +674,17 @@ class ModelAdmin(BaseModelAdmin):
             for formset in formsets:
                 for added_object in formset.new_objects:
                     change_message.append(_('Added %(name)s "%(object)s".')
-                                          % {'name': force_unicode(added_object._meta.verbose_name),
-                                             'object': force_unicode(added_object)})
+                                          % {'name': force_text(added_object._meta.verbose_name),
+                                             'object': force_text(added_object)})
                 for changed_object, changed_fields in formset.changed_objects:
                     change_message.append(_('Changed %(list)s for %(name)s "%(object)s".')
                                           % {'list': get_text_list(changed_fields, _('and')),
-                                             'name': force_unicode(changed_object._meta.verbose_name),
-                                             'object': force_unicode(changed_object)})
+                                             'name': force_text(changed_object._meta.verbose_name),
+                                             'object': force_text(changed_object)})
                 for deleted_object in formset.deleted_objects:
                     change_message.append(_('Deleted %(name)s "%(object)s".')
-                                          % {'name': force_unicode(deleted_object._meta.verbose_name),
-                                             'object': force_unicode(deleted_object)})
+                                          % {'name': force_text(deleted_object._meta.verbose_name),
+                                             'object': force_text(deleted_object)})
         change_message = ' '.join(change_message)
         return change_message or _('No fields changed.')
 
@@ -769,7 +769,7 @@ class ModelAdmin(BaseModelAdmin):
         opts = obj._meta
         pk_value = obj._get_pk_val()
 
-        msg = _('The %(name)s "%(obj)s" was added successfully.') % {'name': force_unicode(opts.verbose_name), 'obj': force_unicode(obj)}
+        msg = _('The %(name)s "%(obj)s" was added successfully.') % {'name': force_text(opts.verbose_name), 'obj': force_text(obj)}
         # Here, we distinguish between different save types by checking for
         # the presence of keys in request.POST.
         if "_continue" in request.POST:
@@ -782,10 +782,10 @@ class ModelAdmin(BaseModelAdmin):
             return HttpResponse(
                 '<!DOCTYPE html><html><head><title></title></head><body>'
                 '<script type="text/javascript">opener.dismissAddAnotherPopup(window, "%s", "%s");</script></body></html>' % \
-                # escape() calls force_unicode.
+                # escape() calls force_text.
                 (escape(pk_value), escapejs(obj)))
         elif "_addanother" in request.POST:
-            self.message_user(request, msg + ' ' + (_("You may add another %s below.") % force_unicode(opts.verbose_name)))
+            self.message_user(request, msg + ' ' + (_("You may add another %s below.") % force_text(opts.verbose_name)))
             return HttpResponseRedirect(request.path)
         else:
             self.message_user(request, msg)
@@ -819,7 +819,7 @@ class ModelAdmin(BaseModelAdmin):
 
         pk_value = obj._get_pk_val()
 
-        msg = _('The %(name)s "%(obj)s" was changed successfully.') % {'name': force_unicode(verbose_name), 'obj': force_unicode(obj)}
+        msg = _('The %(name)s "%(obj)s" was changed successfully.') % {'name': force_text(verbose_name), 'obj': force_text(obj)}
         if "_continue" in request.POST:
             self.message_user(request, msg + ' ' + _("You may edit it again below."))
             if "_popup" in request.REQUEST:
@@ -827,14 +827,14 @@ class ModelAdmin(BaseModelAdmin):
             else:
                 return HttpResponseRedirect(request.path)
         elif "_saveasnew" in request.POST:
-            msg = _('The %(name)s "%(obj)s" was added successfully. You may edit it again below.') % {'name': force_unicode(verbose_name), 'obj': obj}
+            msg = _('The %(name)s "%(obj)s" was added successfully. You may edit it again below.') % {'name': force_text(verbose_name), 'obj': obj}
             self.message_user(request, msg)
             return HttpResponseRedirect(reverse('admin:%s_%s_change' %
                                         (opts.app_label, module_name),
                                         args=(pk_value,),
                                         current_app=self.admin_site.name))
         elif "_addanother" in request.POST:
-            self.message_user(request, msg + ' ' + (_("You may add another %s below.") % force_unicode(verbose_name)))
+            self.message_user(request, msg + ' ' + (_("You may add another %s below.") % force_text(verbose_name)))
             return HttpResponseRedirect(reverse('admin:%s_%s_add' %
                                         (opts.app_label, module_name),
                                         current_app=self.admin_site.name))
@@ -995,7 +995,7 @@ class ModelAdmin(BaseModelAdmin):
             media = media + inline_admin_formset.media
 
         context = {
-            'title': _('Add %s') % force_unicode(opts.verbose_name),
+            'title': _('Add %s') % force_text(opts.verbose_name),
             'adminform': adminForm,
             'is_popup': "_popup" in request.REQUEST,
             'media': media,
@@ -1019,7 +1019,7 @@ class ModelAdmin(BaseModelAdmin):
             raise PermissionDenied
 
         if obj is None:
-            raise Http404(_('%(name)s object with primary key %(key)r does not exist.') % {'name': force_unicode(opts.verbose_name), 'key': escape(object_id)})
+            raise Http404(_('%(name)s object with primary key %(key)r does not exist.') % {'name': force_text(opts.verbose_name), 'key': escape(object_id)})
 
         if request.method == 'POST' and "_saveasnew" in request.POST:
             return self.add_view(request, form_url=reverse('admin:%s_%s_add' %
@@ -1085,7 +1085,7 @@ class ModelAdmin(BaseModelAdmin):
             media = media + inline_admin_formset.media
 
         context = {
-            'title': _('Change %s') % force_unicode(opts.verbose_name),
+            'title': _('Change %s') % force_text(opts.verbose_name),
             'adminform': adminForm,
             'object_id': object_id,
             'original': obj,
@@ -1194,14 +1194,14 @@ class ModelAdmin(BaseModelAdmin):
 
                 if changecount:
                     if changecount == 1:
-                        name = force_unicode(opts.verbose_name)
+                        name = force_text(opts.verbose_name)
                     else:
-                        name = force_unicode(opts.verbose_name_plural)
+                        name = force_text(opts.verbose_name_plural)
                     msg = ungettext("%(count)s %(name)s was changed successfully.",
                                     "%(count)s %(name)s were changed successfully.",
                                     changecount) % {'count': changecount,
                                                     'name': name,
-                                                    'obj': force_unicode(obj)}
+                                                    'obj': force_text(obj)}
                     self.message_user(request, msg)
 
                 return HttpResponseRedirect(request.get_full_path())
@@ -1228,7 +1228,7 @@ class ModelAdmin(BaseModelAdmin):
             'All %(total_count)s selected', cl.result_count)
 
         context = {
-            'module_name': force_unicode(opts.verbose_name_plural),
+            'module_name': force_text(opts.verbose_name_plural),
             'selection_note': _('0 of %(cnt)s selected') % {'cnt': len(cl.result_list)},
             'selection_note_all': selection_note_all % {'total_count': cl.result_count},
             'title': cl.title,
@@ -1263,7 +1263,7 @@ class ModelAdmin(BaseModelAdmin):
             raise PermissionDenied
 
         if obj is None:
-            raise Http404(_('%(name)s object with primary key %(key)r does not exist.') % {'name': force_unicode(opts.verbose_name), 'key': escape(object_id)})
+            raise Http404(_('%(name)s object with primary key %(key)r does not exist.') % {'name': force_text(opts.verbose_name), 'key': escape(object_id)})
 
         using = router.db_for_write(self.model)
 
@@ -1275,11 +1275,11 @@ class ModelAdmin(BaseModelAdmin):
         if request.POST: # The user has already confirmed the deletion.
             if perms_needed:
                 raise PermissionDenied
-            obj_display = force_unicode(obj)
+            obj_display = force_text(obj)
             self.log_deletion(request, obj, obj_display)
             self.delete_model(request, obj)
 
-            self.message_user(request, _('The %(name)s "%(obj)s" was deleted successfully.') % {'name': force_unicode(opts.verbose_name), 'obj': force_unicode(obj_display)})
+            self.message_user(request, _('The %(name)s "%(obj)s" was deleted successfully.') % {'name': force_text(opts.verbose_name), 'obj': force_text(obj_display)})
 
             if not self.has_change_permission(request, None):
                 return HttpResponseRedirect(reverse('admin:index',
@@ -1288,7 +1288,7 @@ class ModelAdmin(BaseModelAdmin):
                                         (opts.app_label, opts.module_name),
                                         current_app=self.admin_site.name))
 
-        object_name = force_unicode(opts.verbose_name)
+        object_name = force_text(opts.verbose_name)
 
         if perms_needed or protected:
             title = _("Cannot delete %(name)s") % {"name": object_name}
@@ -1326,9 +1326,9 @@ class ModelAdmin(BaseModelAdmin):
         # If no history was found, see whether this object even exists.
         obj = get_object_or_404(model, pk=unquote(object_id))
         context = {
-            'title': _('Change history: %s') % force_unicode(obj),
+            'title': _('Change history: %s') % force_text(obj),
             'action_list': action_list,
-            'module_name': capfirst(force_unicode(opts.verbose_name_plural)),
+            'module_name': capfirst(force_text(opts.verbose_name_plural)),
             'object': obj,
             'app_label': app_label,
             'opts': opts,
diff --git a/django/contrib/admin/templatetags/admin_list.py b/django/contrib/admin/templatetags/admin_list.py
index a16226a70e..b8b64d032f 100644
--- a/django/contrib/admin/templatetags/admin_list.py
+++ b/django/contrib/admin/templatetags/admin_list.py
@@ -15,7 +15,7 @@ from django.utils.safestring import mark_safe
 from django.utils import six
 from django.utils.text import capfirst
 from django.utils.translation import ugettext as _
-from django.utils.encoding import smart_unicode, force_unicode
+from django.utils.encoding import smart_text, force_text
 from django.template import Library
 from django.template.loader import get_template
 from django.template.context import Context
@@ -210,7 +210,7 @@ def items_for_result(cl, result, form):
                     result_repr = display_for_field(value, f)
                 if isinstance(f, (models.DateField, models.TimeField, models.ForeignKey)):
                     row_class = mark_safe(' class="nowrap"')
-        if force_unicode(result_repr) == '':
+        if force_text(result_repr) == '':
             result_repr = mark_safe('&nbsp;')
         # If list_display_links not defined, add the link tag to the first field
         if (first and not cl.list_display_links) or field_name in cl.list_display_links:
@@ -224,7 +224,7 @@ def items_for_result(cl, result, form):
             else:
                 attr = pk
             value = result.serializable_value(attr)
-            result_id = repr(force_unicode(value))[1:]
+            result_id = repr(force_text(value))[1:]
             yield format_html('<{0}{1}><a href="{2}"{3}>{4}</a></{5}>',
                               table_tag,
                               row_class,
@@ -241,10 +241,10 @@ def items_for_result(cl, result, form):
                     field_name == cl.model._meta.pk.name and
                         form[cl.model._meta.pk.name].is_hidden)):
                 bf = form[field_name]
-                result_repr = mark_safe(force_unicode(bf.errors) + force_unicode(bf))
+                result_repr = mark_safe(force_text(bf.errors) + force_text(bf))
             yield format_html('<td{0}>{1}</td>', row_class, result_repr)
     if form and not form[cl.model._meta.pk.name].is_hidden:
-        yield format_html('<td>{0}</td>', force_unicode(form[cl.model._meta.pk.name]))
+        yield format_html('<td>{0}</td>', force_text(form[cl.model._meta.pk.name]))
 
 class ResultList(list):
     # Wrapper class used to return items in a list_editable
@@ -267,7 +267,7 @@ def result_hidden_fields(cl):
     if cl.formset:
         for res, form in zip(cl.result_list, cl.formset.forms):
             if form[cl.model._meta.pk.name].is_hidden:
-                yield mark_safe(force_unicode(form[cl.model._meta.pk.name]))
+                yield mark_safe(force_text(form[cl.model._meta.pk.name]))
 
 @register.inclusion_tag("admin/change_list_results.html")
 def result_list(cl):
diff --git a/django/contrib/admin/util.py b/django/contrib/admin/util.py
index 16bdfe0566..ff90e1d007 100644
--- a/django/contrib/admin/util.py
+++ b/django/contrib/admin/util.py
@@ -12,7 +12,7 @@ from django.utils import formats
 from django.utils.html import format_html
 from django.utils.text import capfirst
 from django.utils import timezone
-from django.utils.encoding import force_unicode, smart_unicode, smart_str
+from django.utils.encoding import force_text, smart_text, smart_bytes
 from django.utils import six
 from django.utils.translation import ungettext
 from django.core.urlresolvers import reverse
@@ -132,7 +132,7 @@ def get_deleted_objects(objs, opts, user, admin_site, using):
             # Don't display link to edit, because it either has no
             # admin or is edited inline.
             return '%s: %s' % (capfirst(opts.verbose_name),
-                                force_unicode(obj))
+                                force_text(obj))
 
     to_delete = collector.nested(format_callback)
 
@@ -207,8 +207,8 @@ def model_format_dict(obj):
     else:
         opts = obj
     return {
-        'verbose_name': force_unicode(opts.verbose_name),
-        'verbose_name_plural': force_unicode(opts.verbose_name_plural)
+        'verbose_name': force_text(opts.verbose_name),
+        'verbose_name_plural': force_text(opts.verbose_name_plural)
     }
 
 
@@ -274,10 +274,10 @@ def label_for_field(name, model, model_admin=None, return_attr=False):
             label = field.verbose_name
     except models.FieldDoesNotExist:
         if name == "__unicode__":
-            label = force_unicode(model._meta.verbose_name)
+            label = force_text(model._meta.verbose_name)
             attr = six.text_type
         elif name == "__str__":
-            label = smart_str(model._meta.verbose_name)
+            label = smart_bytes(model._meta.verbose_name)
             attr = bytes
         else:
             if callable(name):
@@ -311,7 +311,7 @@ def help_text_for_field(name, model):
         help_text = model._meta.get_field_by_name(name)[0].help_text
     except models.FieldDoesNotExist:
         help_text = ""
-    return smart_unicode(help_text)
+    return smart_text(help_text)
 
 
 def display_for_field(value, field):
@@ -335,7 +335,7 @@ def display_for_field(value, field):
     elif isinstance(field, models.FloatField):
         return formats.number_format(value)
     else:
-        return smart_unicode(value)
+        return smart_text(value)
 
 
 def display_for_value(value, boolean=False):
@@ -353,7 +353,7 @@ def display_for_value(value, boolean=False):
     elif isinstance(value, six.integer_types + (decimal.Decimal, float)):
         return formats.number_format(value)
     else:
-        return smart_unicode(value)
+        return smart_text(value)
 
 
 class NotRelationField(Exception):
diff --git a/django/contrib/admin/views/main.py b/django/contrib/admin/views/main.py
index 85e03f3b75..3eabf3dbeb 100644
--- a/django/contrib/admin/views/main.py
+++ b/django/contrib/admin/views/main.py
@@ -6,7 +6,7 @@ from django.core.paginator import InvalidPage
 from django.db import models
 from django.db.models.fields import FieldDoesNotExist
 from django.utils.datastructures import SortedDict
-from django.utils.encoding import force_unicode, smart_str
+from django.utils.encoding import force_text, smart_bytes
 from django.utils.translation import ugettext, ugettext_lazy
 from django.utils.http import urlencode
 
@@ -75,7 +75,7 @@ class ChangeList(object):
             title = ugettext('Select %s')
         else:
             title = ugettext('Select %s to change')
-        self.title = title % force_unicode(self.opts.verbose_name)
+        self.title = title % force_text(self.opts.verbose_name)
         self.pk_attname = self.lookup_opts.pk.attname
 
     def get_filters(self, request):
@@ -94,7 +94,7 @@ class ChangeList(object):
                 # 'key' will be used as a keyword argument later, so Python
                 # requires it to be a string.
                 del lookup_params[key]
-                lookup_params[smart_str(key)] = value
+                lookup_params[smart_bytes(key)] = value
 
             if not self.model_admin.lookup_allowed(key, value):
                 raise SuspiciousOperation("Filtering by %s not allowed" % key)
diff --git a/django/contrib/admin/widgets.py b/django/contrib/admin/widgets.py
index 550ed0f7e2..1e0bc2d366 100644
--- a/django/contrib/admin/widgets.py
+++ b/django/contrib/admin/widgets.py
@@ -14,7 +14,7 @@ from django.utils.html import escape, format_html, format_html_join
 from django.utils.text import Truncator
 from django.utils.translation import ugettext as _
 from django.utils.safestring import mark_safe
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils import six
 
 
@@ -96,7 +96,7 @@ class AdminRadioFieldRenderer(RadioFieldRenderer):
         return format_html('<ul{0}>\n{1}\n</ul>',
                            flatatt(self.attrs),
                            format_html_join('\n', '<li>{0}</li>',
-                                            ((force_unicode(w),) for w in self)))
+                                            ((force_text(w),) for w in self)))
 
 class AdminRadioSelect(forms.RadioSelect):
     renderer = AdminRadioFieldRenderer
@@ -197,7 +197,7 @@ class ManyToManyRawIdWidget(ForeignKeyRawIdWidget):
             # The related object is registered with the same AdminSite
             attrs['class'] = 'vManyToManyRawIdAdminField'
         if value:
-            value = ','.join([force_unicode(v) for v in value])
+            value = ','.join([force_text(v) for v in value])
         else:
             value = ''
         return super(ManyToManyRawIdWidget, self).render(name, value, attrs)
@@ -221,7 +221,7 @@ class ManyToManyRawIdWidget(ForeignKeyRawIdWidget):
         if len(initial) != len(data):
             return True
         for pk1, pk2 in zip(initial, data):
-            if force_unicode(pk1) != force_unicode(pk2):
+            if force_text(pk1) != force_text(pk2):
                 return True
         return False
 
diff --git a/django/contrib/admindocs/utils.py b/django/contrib/admindocs/utils.py
index 4bf1250ac6..0e10eb4fa3 100644
--- a/django/contrib/admindocs/utils.py
+++ b/django/contrib/admindocs/utils.py
@@ -6,7 +6,7 @@ from email.errors import HeaderParseError
 
 from django.utils.safestring import mark_safe
 from django.core.urlresolvers import reverse
-from django.utils.encoding import smart_str
+from django.utils.encoding import smart_bytes
 try:
     import docutils.core
     import docutils.nodes
@@ -66,7 +66,7 @@ def parse_rst(text, default_reference_context, thing_being_parsed=None):
         "link_base" : reverse('django-admindocs-docroot').rstrip('/')
     }
     if thing_being_parsed:
-        thing_being_parsed = smart_str("<%s>" % thing_being_parsed)
+        thing_being_parsed = smart_bytes("<%s>" % thing_being_parsed)
     parts = docutils.core.publish_parts(text, source_path=thing_being_parsed,
                 destination_path=None, writer_name='html',
                 settings_overrides=overrides)
diff --git a/django/contrib/auth/hashers.py b/django/contrib/auth/hashers.py
index 96ec40ba60..c676cf84db 100644
--- a/django/contrib/auth/hashers.py
+++ b/django/contrib/auth/hashers.py
@@ -7,7 +7,7 @@ from django.conf import settings
 from django.test.signals import setting_changed
 from django.utils import importlib
 from django.utils.datastructures import SortedDict
-from django.utils.encoding import smart_str
+from django.utils.encoding import smart_bytes
 from django.core.exceptions import ImproperlyConfigured
 from django.utils.crypto import (
     pbkdf2, constant_time_compare, get_random_string)
@@ -298,7 +298,7 @@ class SHA1PasswordHasher(BasePasswordHasher):
     def encode(self, password, salt):
         assert password
         assert salt and '$' not in salt
-        hash = hashlib.sha1(smart_str(salt + password)).hexdigest()
+        hash = hashlib.sha1(smart_bytes(salt + password)).hexdigest()
         return "%s$%s$%s" % (self.algorithm, salt, hash)
 
     def verify(self, password, encoded):
@@ -326,7 +326,7 @@ class MD5PasswordHasher(BasePasswordHasher):
     def encode(self, password, salt):
         assert password
         assert salt and '$' not in salt
-        hash = hashlib.md5(smart_str(salt + password)).hexdigest()
+        hash = hashlib.md5(smart_bytes(salt + password)).hexdigest()
         return "%s$%s$%s" % (self.algorithm, salt, hash)
 
     def verify(self, password, encoded):
@@ -360,7 +360,7 @@ class UnsaltedMD5PasswordHasher(BasePasswordHasher):
         return ''
 
     def encode(self, password, salt):
-        return hashlib.md5(smart_str(password)).hexdigest()
+        return hashlib.md5(smart_bytes(password)).hexdigest()
 
     def verify(self, password, encoded):
         encoded_2 = self.encode(password, '')
diff --git a/django/contrib/auth/tests/forms.py b/django/contrib/auth/tests/forms.py
index 2bfe35ac88..f917ea2601 100644
--- a/django/contrib/auth/tests/forms.py
+++ b/django/contrib/auth/tests/forms.py
@@ -8,7 +8,7 @@ from django.core import mail
 from django.forms.fields import Field, EmailField
 from django.test import TestCase
 from django.test.utils import override_settings
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils import six
 from django.utils import translation
 from django.utils.translation import ugettext as _
@@ -28,7 +28,7 @@ class UserCreationFormTest(TestCase):
         form = UserCreationForm(data)
         self.assertFalse(form.is_valid())
         self.assertEqual(form["username"].errors,
-                         [force_unicode(form.error_messages['duplicate_username'])])
+                         [force_text(form.error_messages['duplicate_username'])])
 
     def test_invalid_data(self):
         data = {
@@ -39,7 +39,7 @@ class UserCreationFormTest(TestCase):
         form = UserCreationForm(data)
         self.assertFalse(form.is_valid())
         self.assertEqual(form["username"].errors,
-                         [force_unicode(form.fields['username'].error_messages['invalid'])])
+                         [force_text(form.fields['username'].error_messages['invalid'])])
 
     def test_password_verification(self):
         # The verification password is incorrect.
@@ -51,13 +51,13 @@ class UserCreationFormTest(TestCase):
         form = UserCreationForm(data)
         self.assertFalse(form.is_valid())
         self.assertEqual(form["password2"].errors,
-                         [force_unicode(form.error_messages['password_mismatch'])])
+                         [force_text(form.error_messages['password_mismatch'])])
 
     def test_both_passwords(self):
         # One (or both) passwords weren't given
         data = {'username': 'jsmith'}
         form = UserCreationForm(data)
-        required_error = [force_unicode(Field.default_error_messages['required'])]
+        required_error = [force_text(Field.default_error_messages['required'])]
         self.assertFalse(form.is_valid())
         self.assertEqual(form['password1'].errors, required_error)
         self.assertEqual(form['password2'].errors, required_error)
@@ -96,7 +96,7 @@ class AuthenticationFormTest(TestCase):
         form = AuthenticationForm(None, data)
         self.assertFalse(form.is_valid())
         self.assertEqual(form.non_field_errors(),
-                         [force_unicode(form.error_messages['invalid_login'])])
+                         [force_text(form.error_messages['invalid_login'])])
 
     def test_inactive_user(self):
         # The user is inactive.
@@ -107,7 +107,7 @@ class AuthenticationFormTest(TestCase):
         form = AuthenticationForm(None, data)
         self.assertFalse(form.is_valid())
         self.assertEqual(form.non_field_errors(),
-                         [force_unicode(form.error_messages['inactive'])])
+                         [force_text(form.error_messages['inactive'])])
 
     def test_inactive_user_i18n(self):
         with self.settings(USE_I18N=True):
@@ -120,7 +120,7 @@ class AuthenticationFormTest(TestCase):
                 form = AuthenticationForm(None, data)
                 self.assertFalse(form.is_valid())
                 self.assertEqual(form.non_field_errors(),
-                                 [force_unicode(form.error_messages['inactive'])])
+                                 [force_text(form.error_messages['inactive'])])
 
     def test_success(self):
         # The success case
@@ -148,7 +148,7 @@ class SetPasswordFormTest(TestCase):
         form = SetPasswordForm(user, data)
         self.assertFalse(form.is_valid())
         self.assertEqual(form["new_password2"].errors,
-                         [force_unicode(form.error_messages['password_mismatch'])])
+                         [force_text(form.error_messages['password_mismatch'])])
 
     def test_success(self):
         user = User.objects.get(username='testclient')
@@ -175,7 +175,7 @@ class PasswordChangeFormTest(TestCase):
         form = PasswordChangeForm(user, data)
         self.assertFalse(form.is_valid())
         self.assertEqual(form["old_password"].errors,
-                         [force_unicode(form.error_messages['password_incorrect'])])
+                         [force_text(form.error_messages['password_incorrect'])])
 
     def test_password_verification(self):
         # The two new passwords do not match.
@@ -188,7 +188,7 @@ class PasswordChangeFormTest(TestCase):
         form = PasswordChangeForm(user, data)
         self.assertFalse(form.is_valid())
         self.assertEqual(form["new_password2"].errors,
-                         [force_unicode(form.error_messages['password_mismatch'])])
+                         [force_text(form.error_messages['password_mismatch'])])
 
     def test_success(self):
         # The success case.
@@ -219,7 +219,7 @@ class UserChangeFormTest(TestCase):
         form = UserChangeForm(data, instance=user)
         self.assertFalse(form.is_valid())
         self.assertEqual(form['username'].errors,
-                         [force_unicode(form.fields['username'].error_messages['invalid'])])
+                         [force_text(form.fields['username'].error_messages['invalid'])])
 
     def test_bug_14242(self):
         # A regression test, introduce by adding an optimization for the
@@ -274,7 +274,7 @@ class PasswordResetFormTest(TestCase):
         form = PasswordResetForm(data)
         self.assertFalse(form.is_valid())
         self.assertEqual(form['email'].errors,
-                         [force_unicode(EmailField.default_error_messages['invalid'])])
+                         [force_text(EmailField.default_error_messages['invalid'])])
 
     def test_nonexistant_email(self):
         # Test nonexistant email address
@@ -282,7 +282,7 @@ class PasswordResetFormTest(TestCase):
         form = PasswordResetForm(data)
         self.assertFalse(form.is_valid())
         self.assertEqual(form.errors,
-                         {'email': [force_unicode(form.error_messages['unknown'])]})
+                         {'email': [force_text(form.error_messages['unknown'])]})
 
     def test_cleaned_data(self):
         # Regression test
diff --git a/django/contrib/auth/tests/views.py b/django/contrib/auth/tests/views.py
index e76e7dd10f..3c847f456a 100644
--- a/django/contrib/auth/tests/views.py
+++ b/django/contrib/auth/tests/views.py
@@ -7,7 +7,7 @@ from django.contrib.auth.models import User
 from django.core import mail
 from django.core.urlresolvers import reverse, NoReverseMatch
 from django.http import QueryDict
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils.html import escape
 from django.utils.http import urlquote
 from django.test import TestCase
@@ -46,7 +46,7 @@ class AuthViewsTestCase(TestCase):
         self.assertTrue(SESSION_KEY in self.client.session)
 
     def assertContainsEscaped(self, response, text, **kwargs):
-        return self.assertContains(response, escape(force_unicode(text)), **kwargs)
+        return self.assertContains(response, escape(force_text(text)), **kwargs)
 
 
 class AuthViewNamedURLTests(AuthViewsTestCase):
diff --git a/django/contrib/comments/forms.py b/django/contrib/comments/forms.py
index 830e24bca9..bd254d2733 100644
--- a/django/contrib/comments/forms.py
+++ b/django/contrib/comments/forms.py
@@ -5,7 +5,7 @@ from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.comments.models import Comment
 from django.utils.crypto import salted_hmac, constant_time_compare
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils.text import get_text_list
 from django.utils import timezone
 from django.utils.translation import ungettext, ugettext, ugettext_lazy as _
@@ -133,7 +133,7 @@ class CommentDetailsForm(CommentSecurityForm):
         """
         return dict(
             content_type = ContentType.objects.get_for_model(self.target_object),
-            object_pk    = force_unicode(self.target_object._get_pk_val()),
+            object_pk    = force_text(self.target_object._get_pk_val()),
             user_name    = self.cleaned_data["name"],
             user_email   = self.cleaned_data["email"],
             user_url     = self.cleaned_data["url"],
diff --git a/django/contrib/comments/managers.py b/django/contrib/comments/managers.py
index 499feee6c3..bc0fc5f332 100644
--- a/django/contrib/comments/managers.py
+++ b/django/contrib/comments/managers.py
@@ -1,6 +1,6 @@
 from django.db import models
 from django.contrib.contenttypes.models import ContentType
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 
 class CommentManager(models.Manager):
 
@@ -18,5 +18,5 @@ class CommentManager(models.Manager):
         ct = ContentType.objects.get_for_model(model)
         qs = self.get_query_set().filter(content_type=ct)
         if isinstance(model, models.Model):
-            qs = qs.filter(object_pk=force_unicode(model._get_pk_val()))
+            qs = qs.filter(object_pk=force_text(model._get_pk_val()))
         return qs
diff --git a/django/contrib/comments/templatetags/comments.py b/django/contrib/comments/templatetags/comments.py
index ce1825e529..4d4eb2322f 100644
--- a/django/contrib/comments/templatetags/comments.py
+++ b/django/contrib/comments/templatetags/comments.py
@@ -3,7 +3,7 @@ from django.template.loader import render_to_string
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.contrib import comments
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 
 register = template.Library()
 
@@ -75,7 +75,7 @@ class BaseCommentNode(template.Node):
 
         qs = self.comment_model.objects.filter(
             content_type = ctype,
-            object_pk    = smart_unicode(object_pk),
+            object_pk    = smart_text(object_pk),
             site__pk     = settings.SITE_ID,
         )
 
diff --git a/django/contrib/contenttypes/generic.py b/django/contrib/contenttypes/generic.py
index d5062cabf3..29e93eefe7 100644
--- a/django/contrib/contenttypes/generic.py
+++ b/django/contrib/contenttypes/generic.py
@@ -17,7 +17,7 @@ from django.forms import ModelForm
 from django.forms.models import BaseModelFormSet, modelformset_factory, save_instance
 from django.contrib.admin.options import InlineModelAdmin, flatten_fieldsets
 from django.contrib.contenttypes.models import ContentType
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 
 class GenericForeignKey(object):
     """
@@ -169,7 +169,7 @@ class GenericRelation(RelatedField, Field):
 
     def value_to_string(self, obj):
         qs = getattr(obj, self.name).all()
-        return smart_unicode([instance._get_pk_val() for instance in qs])
+        return smart_text([instance._get_pk_val() for instance in qs])
 
     def m2m_db_table(self):
         return self.rel.to._meta.db_table
diff --git a/django/contrib/contenttypes/management.py b/django/contrib/contenttypes/management.py
index 1b1c9c8562..11ca7e4763 100644
--- a/django/contrib/contenttypes/management.py
+++ b/django/contrib/contenttypes/management.py
@@ -1,6 +1,6 @@
 from django.contrib.contenttypes.models import ContentType
 from django.db.models import get_apps, get_models, signals
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils import six
 
 def update_contenttypes(app, created_models, verbosity=2, **kwargs):
@@ -31,7 +31,7 @@ def update_contenttypes(app, created_models, verbosity=2, **kwargs):
 
     cts = ContentType.objects.bulk_create([
         ContentType(
-            name=smart_unicode(model._meta.verbose_name_raw),
+            name=smart_text(model._meta.verbose_name_raw),
             app_label=app_label,
             model=model_name,
         )
diff --git a/django/contrib/contenttypes/models.py b/django/contrib/contenttypes/models.py
index 867351f6c8..e6d547a491 100644
--- a/django/contrib/contenttypes/models.py
+++ b/django/contrib/contenttypes/models.py
@@ -1,6 +1,6 @@
 from django.db import models
 from django.utils.translation import ugettext_lazy as _
-from django.utils.encoding import smart_unicode, force_unicode
+from django.utils.encoding import smart_text, force_text
 
 class ContentTypeManager(models.Manager):
 
@@ -37,13 +37,13 @@ class ContentTypeManager(models.Manager):
         try:
             ct = self._get_from_cache(opts)
         except KeyError:
-            # Load or create the ContentType entry. The smart_unicode() is
+            # Load or create the ContentType entry. The smart_text() is
             # needed around opts.verbose_name_raw because name_raw might be a
             # django.utils.functional.__proxy__ object.
             ct, created = self.get_or_create(
                 app_label = opts.app_label,
                 model = opts.object_name.lower(),
-                defaults = {'name': smart_unicode(opts.verbose_name_raw)},
+                defaults = {'name': smart_text(opts.verbose_name_raw)},
             )
             self._add_to_cache(self.db, ct)
 
@@ -86,7 +86,7 @@ class ContentTypeManager(models.Manager):
             ct = self.create(
                 app_label=opts.app_label,
                 model=opts.object_name.lower(),
-                name=smart_unicode(opts.verbose_name_raw),
+                name=smart_text(opts.verbose_name_raw),
             )
             self._add_to_cache(self.db, ct)
             results[ct.model_class()] = ct
@@ -147,7 +147,7 @@ class ContentType(models.Model):
         if not model or self.name != model._meta.verbose_name_raw:
             return self.name
         else:
-            return force_unicode(model._meta.verbose_name)
+            return force_text(model._meta.verbose_name)
 
     def model_class(self):
         "Returns the Python model class for this type of content."
diff --git a/django/contrib/databrowse/datastructures.py b/django/contrib/databrowse/datastructures.py
index 95d347cac0..810e039894 100644
--- a/django/contrib/databrowse/datastructures.py
+++ b/django/contrib/databrowse/datastructures.py
@@ -7,7 +7,7 @@ from __future__ import unicode_literals
 from django.db import models
 from django.utils import formats
 from django.utils.text import capfirst
-from django.utils.encoding import smart_unicode, smart_str, iri_to_uri
+from django.utils.encoding import smart_text, smart_bytes, iri_to_uri
 from django.db.models.query import QuerySet
 
 EMPTY_VALUE = '(None)'
@@ -22,7 +22,7 @@ class EasyModel(object):
         self.verbose_name_plural = model._meta.verbose_name_plural
 
     def __repr__(self):
-        return '<EasyModel for %s>' % smart_str(self.model._meta.object_name)
+        return '<EasyModel for %s>' % smart_bytes(self.model._meta.object_name)
 
     def model_databrowse(self):
         "Returns the ModelDatabrowse class for this model."
@@ -61,7 +61,7 @@ class EasyField(object):
         self.model, self.field = easy_model, field
 
     def __repr__(self):
-        return smart_str('<EasyField for %s.%s>' % (self.model.model._meta.object_name, self.field.name))
+        return smart_bytes('<EasyField for %s.%s>' % (self.model.model._meta.object_name, self.field.name))
 
     def choices(self):
         for value, label in self.field.choices:
@@ -79,7 +79,7 @@ class EasyChoice(object):
         self.value, self.label = value, label
 
     def __repr__(self):
-        return smart_str('<EasyChoice for %s.%s>' % (self.model.model._meta.object_name, self.field.name))
+        return smart_bytes('<EasyChoice for %s.%s>' % (self.model.model._meta.object_name, self.field.name))
 
     def url(self):
         return '%s%s/%s/%s/%s/' % (self.model.site.root_url, self.model.model._meta.app_label, self.model.model._meta.module_name, self.field.field.name, iri_to_uri(self.value))
@@ -89,10 +89,10 @@ class EasyInstance(object):
         self.model, self.instance = easy_model, instance
 
     def __repr__(self):
-        return smart_str('<EasyInstance for %s (%s)>' % (self.model.model._meta.object_name, self.instance._get_pk_val()))
+        return smart_bytes('<EasyInstance for %s (%s)>' % (self.model.model._meta.object_name, self.instance._get_pk_val()))
 
     def __unicode__(self):
-        val = smart_unicode(self.instance)
+        val = smart_text(self.instance)
         if len(val) > DISPLAY_SIZE:
             return val[:DISPLAY_SIZE] + '...'
         return val
@@ -136,7 +136,7 @@ class EasyInstanceField(object):
         self.raw_value = getattr(instance.instance, field.name)
 
     def __repr__(self):
-        return smart_str('<EasyInstanceField for %s.%s>' % (self.model.model._meta.object_name, self.field.name))
+        return smart_bytes('<EasyInstanceField for %s.%s>' % (self.model.model._meta.object_name, self.field.name))
 
     def values(self):
         """
@@ -185,7 +185,7 @@ class EasyInstanceField(object):
                     if value is None:
                         continue
                     url = '%s%s/%s/objects/%s/' % (self.model.site.root_url, m.model._meta.app_label, m.model._meta.module_name, iri_to_uri(value._get_pk_val()))
-                    lst.append((smart_unicode(value), url))
+                    lst.append((smart_text(value), url))
             else:
                 lst = [(value, None) for value in self.values()]
         elif self.field.choices:
diff --git a/django/contrib/databrowse/plugins/calendars.py b/django/contrib/databrowse/plugins/calendars.py
index 923adb90f6..a548c33c8f 100644
--- a/django/contrib/databrowse/plugins/calendars.py
+++ b/django/contrib/databrowse/plugins/calendars.py
@@ -7,7 +7,7 @@ from django.contrib.databrowse.sites import DatabrowsePlugin
 from django.shortcuts import render_to_response
 from django.utils.html import format_html, format_html_join
 from django.utils.text import capfirst
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.views.generic import dates
 from django.utils import datetime_safe
 
@@ -66,7 +66,7 @@ class CalendarPlugin(DatabrowsePlugin):
             return ''
         return format_html('<p class="filter"><strong>View calendar by:</strong> {0}</p>',
                            format_html_join(', ', '<a href="calendars/{0}/">{1}</a>',
-                                            ((f.name, force_unicode(capfirst(f.verbose_name))) for f in fields.values())))
+                                            ((f.name, force_text(capfirst(f.verbose_name))) for f in fields.values())))
 
     def urls(self, plugin_name, easy_instance_field):
         if isinstance(easy_instance_field.field, models.DateField):
diff --git a/django/contrib/databrowse/plugins/fieldchoices.py b/django/contrib/databrowse/plugins/fieldchoices.py
index 73298b8d56..dc5e9aef14 100644
--- a/django/contrib/databrowse/plugins/fieldchoices.py
+++ b/django/contrib/databrowse/plugins/fieldchoices.py
@@ -8,7 +8,7 @@ from django.shortcuts import render_to_response
 from django.utils.html import format_html, format_html_join
 from django.utils.http import urlquote
 from django.utils.text import capfirst
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 
 
 class FieldChoicePlugin(DatabrowsePlugin):
@@ -35,7 +35,7 @@ class FieldChoicePlugin(DatabrowsePlugin):
             return ''
         return format_html('<p class="filter"><strong>View by:</strong> {0}</p>',
                            format_html_join(', ', '<a href="fields/{0}/">{1}</a>',
-                                            ((f.name, force_unicode(capfirst(f.verbose_name))) for f in fields.values())))
+                                            ((f.name, force_text(capfirst(f.verbose_name))) for f in fields.values())))
 
     def urls(self, plugin_name, easy_instance_field):
         if easy_instance_field.field in self.field_dict(easy_instance_field.model.model).values():
diff --git a/django/contrib/formtools/wizard/storage/base.py b/django/contrib/formtools/wizard/storage/base.py
index 7c802712c1..05c9f6f121 100644
--- a/django/contrib/formtools/wizard/storage/base.py
+++ b/django/contrib/formtools/wizard/storage/base.py
@@ -1,6 +1,6 @@
 from django.core.files.uploadedfile import UploadedFile
 from django.utils.datastructures import MultiValueDict
-from django.utils.encoding import smart_str
+from django.utils.encoding import smart_bytes
 from django.utils.functional import lazy_property
 from django.utils import six
 
@@ -74,7 +74,7 @@ class BaseStorage(object):
 
         files = {}
         for field, field_dict in six.iteritems(wizard_files):
-            field_dict = dict((smart_str(k), v)
+            field_dict = dict((smart_bytes(k), v)
                               for k, v in six.iteritems(field_dict))
             tmp_name = field_dict.pop('tmp_name')
             files[field] = UploadedFile(
diff --git a/django/contrib/gis/sitemaps/views.py b/django/contrib/gis/sitemaps/views.py
index 6753b9e34a..8bcdba1b44 100644
--- a/django/contrib/gis/sitemaps/views.py
+++ b/django/contrib/gis/sitemaps/views.py
@@ -8,7 +8,7 @@ from django.core.paginator import EmptyPage, PageNotAnInteger
 from django.contrib.gis.db.models.fields import GeometryField
 from django.db import connections, DEFAULT_DB_ALIAS
 from django.db.models import get_model
-from django.utils.encoding import smart_str
+from django.utils.encoding import smart_bytes
 from django.utils import six
 from django.utils.translation import ugettext as _
 
@@ -61,7 +61,7 @@ def sitemap(request, sitemaps, section=None):
             raise Http404(_("Page %s empty") % page)
         except PageNotAnInteger:
             raise Http404(_("No page '%s'") % page)
-    xml = smart_str(loader.render_to_string('gis/sitemaps/geo_sitemap.xml', {'urlset': urls}))
+    xml = smart_bytes(loader.render_to_string('gis/sitemaps/geo_sitemap.xml', {'urlset': urls}))
     return HttpResponse(xml, content_type='application/xml')
 
 def kml(request, label, model, field_name=None, compress=False, using=DEFAULT_DB_ALIAS):
diff --git a/django/contrib/humanize/templatetags/humanize.py b/django/contrib/humanize/templatetags/humanize.py
index 8f6c2602c9..7e8f163174 100644
--- a/django/contrib/humanize/templatetags/humanize.py
+++ b/django/contrib/humanize/templatetags/humanize.py
@@ -5,7 +5,7 @@ from datetime import date, datetime
 from django import template
 from django.conf import settings
 from django.template import defaultfilters
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils.formats import number_format
 from django.utils.translation import pgettext, ungettext, ugettext as _
 from django.utils.timezone import is_aware, utc
@@ -41,7 +41,7 @@ def intcomma(value, use_l10n=True):
             return intcomma(value, False)
         else:
             return number_format(value, force_grouping=True)
-    orig = force_unicode(value)
+    orig = force_text(value)
     new = re.sub("^(-?\d+)(\d{3})", '\g<1>,\g<2>', orig)
     if orig == new:
         return new
diff --git a/django/contrib/localflavor/au/forms.py b/django/contrib/localflavor/au/forms.py
index 34170fabc8..d3a00e200c 100644
--- a/django/contrib/localflavor/au/forms.py
+++ b/django/contrib/localflavor/au/forms.py
@@ -10,7 +10,7 @@ from django.contrib.localflavor.au.au_states import STATE_CHOICES
 from django.core.validators import EMPTY_VALUES
 from django.forms import ValidationError
 from django.forms.fields import Field, RegexField, Select
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.translation import ugettext_lazy as _
 
 
@@ -44,7 +44,7 @@ class AUPhoneNumberField(Field):
         super(AUPhoneNumberField, self).clean(value)
         if value in EMPTY_VALUES:
             return ''
-        value = re.sub('(\(|\)|\s+|-)', '', smart_unicode(value))
+        value = re.sub('(\(|\)|\s+|-)', '', smart_text(value))
         phone_match = PHONE_DIGITS_RE.search(value)
         if phone_match:
             return '%s' % phone_match.group(1)
diff --git a/django/contrib/localflavor/br/forms.py b/django/contrib/localflavor/br/forms.py
index f287d46a9a..4d0d6815ba 100644
--- a/django/contrib/localflavor/br/forms.py
+++ b/django/contrib/localflavor/br/forms.py
@@ -11,7 +11,7 @@ from django.contrib.localflavor.br.br_states import STATE_CHOICES
 from django.core.validators import EMPTY_VALUES
 from django.forms import ValidationError
 from django.forms.fields import Field, RegexField, CharField, Select
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.translation import ugettext_lazy as _
 
 
@@ -35,7 +35,7 @@ class BRPhoneNumberField(Field):
         super(BRPhoneNumberField, self).clean(value)
         if value in EMPTY_VALUES:
             return ''
-        value = re.sub('(\(|\)|\s+)', '', smart_unicode(value))
+        value = re.sub('(\(|\)|\s+)', '', smart_text(value))
         m = phone_digits_re.search(value)
         if m:
             return '%s-%s-%s' % (m.group(1), m.group(2), m.group(3))
@@ -68,10 +68,10 @@ class BRStateChoiceField(Field):
         value = super(BRStateChoiceField, self).clean(value)
         if value in EMPTY_VALUES:
             value = ''
-        value = smart_unicode(value)
+        value = smart_text(value)
         if value == '':
             return value
-        valid_values = set([smart_unicode(k) for k, v in self.widget.choices])
+        valid_values = set([smart_text(k) for k, v in self.widget.choices])
         if value not in valid_values:
             raise ValidationError(self.error_messages['invalid'])
         return value
diff --git a/django/contrib/localflavor/ca/forms.py b/django/contrib/localflavor/ca/forms.py
index daa40044f9..4ebfb06c2b 100644
--- a/django/contrib/localflavor/ca/forms.py
+++ b/django/contrib/localflavor/ca/forms.py
@@ -9,7 +9,7 @@ import re
 from django.core.validators import EMPTY_VALUES
 from django.forms import ValidationError
 from django.forms.fields import Field, CharField, Select
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.translation import ugettext_lazy as _
 
 
@@ -53,7 +53,7 @@ class CAPhoneNumberField(Field):
         super(CAPhoneNumberField, self).clean(value)
         if value in EMPTY_VALUES:
             return ''
-        value = re.sub('(\(|\)|\s+)', '', smart_unicode(value))
+        value = re.sub('(\(|\)|\s+)', '', smart_text(value))
         m = phone_digits_re.search(value)
         if m:
             return '%s-%s-%s' % (m.group(1), m.group(2), m.group(3))
diff --git a/django/contrib/localflavor/ch/forms.py b/django/contrib/localflavor/ch/forms.py
index e844a3c57c..bf71eeea32 100644
--- a/django/contrib/localflavor/ch/forms.py
+++ b/django/contrib/localflavor/ch/forms.py
@@ -10,7 +10,7 @@ from django.contrib.localflavor.ch.ch_states import STATE_CHOICES
 from django.core.validators import EMPTY_VALUES
 from django.forms import ValidationError
 from django.forms.fields import Field, RegexField, Select
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.translation import ugettext_lazy as _
 
 
@@ -41,7 +41,7 @@ class CHPhoneNumberField(Field):
         super(CHPhoneNumberField, self).clean(value)
         if value in EMPTY_VALUES:
             return ''
-        value = re.sub('(\.|\s|/|-)', '', smart_unicode(value))
+        value = re.sub('(\.|\s|/|-)', '', smart_text(value))
         m = phone_digits_re.search(value)
         if m:
             return '%s %s %s %s' % (value[0:3], value[3:6], value[6:8], value[8:10])
diff --git a/django/contrib/localflavor/cl/forms.py b/django/contrib/localflavor/cl/forms.py
index 5991176382..a5340141ce 100644
--- a/django/contrib/localflavor/cl/forms.py
+++ b/django/contrib/localflavor/cl/forms.py
@@ -8,7 +8,7 @@ from django.core.validators import EMPTY_VALUES
 from django.forms import ValidationError
 from django.forms.fields import RegexField, Select
 from django.utils.translation import ugettext_lazy as _
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 
 from .cl_regions import REGION_CHOICES
 
@@ -75,7 +75,7 @@ class CLRutField(RegexField):
         Turns the RUT into one normalized format. Returns a (rut, verifier)
         tuple.
         """
-        rut = smart_unicode(rut).replace(' ', '').replace('.', '').replace('-', '')
+        rut = smart_text(rut).replace(' ', '').replace('.', '').replace('-', '')
         return rut[:-1], rut[-1].upper()
 
     def _format(self, code, verifier=None):
diff --git a/django/contrib/localflavor/fr/forms.py b/django/contrib/localflavor/fr/forms.py
index d836dd6397..8b841fff5f 100644
--- a/django/contrib/localflavor/fr/forms.py
+++ b/django/contrib/localflavor/fr/forms.py
@@ -9,7 +9,7 @@ from django.contrib.localflavor.fr.fr_department import DEPARTMENT_CHOICES
 from django.core.validators import EMPTY_VALUES
 from django.forms import ValidationError
 from django.forms.fields import CharField, RegexField, Select
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.translation import ugettext_lazy as _
 
 
@@ -43,7 +43,7 @@ class FRPhoneNumberField(CharField):
         super(FRPhoneNumberField, self).clean(value)
         if value in EMPTY_VALUES:
             return ''
-        value = re.sub('(\.|\s)', '', smart_unicode(value))
+        value = re.sub('(\.|\s)', '', smart_text(value))
         m = phone_digits_re.search(value)
         if m:
             return '%s %s %s %s %s' % (value[0:2], value[2:4], value[4:6], value[6:8], value[8:10])
diff --git a/django/contrib/localflavor/hk/forms.py b/django/contrib/localflavor/hk/forms.py
index 8cf9360e19..ab4f70f193 100644
--- a/django/contrib/localflavor/hk/forms.py
+++ b/django/contrib/localflavor/hk/forms.py
@@ -8,7 +8,7 @@ import re
 from django.core.validators import EMPTY_VALUES
 from django.forms import CharField
 from django.forms import ValidationError
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.translation import ugettext_lazy as _
 
 
@@ -53,7 +53,7 @@ class HKPhoneNumberField(CharField):
         if value in EMPTY_VALUES:
             return ''
 
-        value = re.sub('(\(|\)|\s+|\+)', '', smart_unicode(value))
+        value = re.sub('(\(|\)|\s+|\+)', '', smart_text(value))
         m = hk_phone_digits_re.search(value)
         if not m:
             raise ValidationError(self.error_messages['invalid'])
diff --git a/django/contrib/localflavor/hr/forms.py b/django/contrib/localflavor/hr/forms.py
index eb4436a78c..b935fd8a3a 100644
--- a/django/contrib/localflavor/hr/forms.py
+++ b/django/contrib/localflavor/hr/forms.py
@@ -12,7 +12,7 @@ from django.contrib.localflavor.hr.hr_choices import (
 from django.core.validators import EMPTY_VALUES
 from django.forms import ValidationError
 from django.forms.fields import Field, Select, RegexField
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.translation import ugettext_lazy as _
 
 
@@ -159,7 +159,7 @@ class HRLicensePlateField(Field):
         if value in EMPTY_VALUES:
             return ''
 
-        value = re.sub(r'[\s\-]+', '', smart_unicode(value.strip())).upper()
+        value = re.sub(r'[\s\-]+', '', smart_text(value.strip())).upper()
 
         matches = plate_re.search(value)
         if matches is None:
@@ -225,7 +225,7 @@ class HRPhoneNumberField(Field):
         if value in EMPTY_VALUES:
             return ''
 
-        value = re.sub(r'[\-\s\(\)]', '', smart_unicode(value))
+        value = re.sub(r'[\-\s\(\)]', '', smart_text(value))
 
         matches = phone_re.search(value)
         if matches is None:
diff --git a/django/contrib/localflavor/id/forms.py b/django/contrib/localflavor/id/forms.py
index f22b06134e..2005dbc75c 100644
--- a/django/contrib/localflavor/id/forms.py
+++ b/django/contrib/localflavor/id/forms.py
@@ -11,7 +11,7 @@ from django.core.validators import EMPTY_VALUES
 from django.forms import ValidationError
 from django.forms.fields import Field, Select
 from django.utils.translation import ugettext_lazy as _
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 
 
 postcode_re = re.compile(r'^[1-9]\d{4}$')
@@ -77,10 +77,10 @@ class IDPhoneNumberField(Field):
         if value in EMPTY_VALUES:
             return ''
 
-        phone_number = re.sub(r'[\-\s\(\)]', '', smart_unicode(value))
+        phone_number = re.sub(r'[\-\s\(\)]', '', smart_text(value))
 
         if phone_re.search(phone_number):
-            return smart_unicode(value)
+            return smart_text(value)
 
         raise ValidationError(self.error_messages['invalid'])
 
@@ -120,7 +120,7 @@ class IDLicensePlateField(Field):
             return ''
 
         plate_number = re.sub(r'\s+', ' ',
-            smart_unicode(value.strip())).upper()
+            smart_text(value.strip())).upper()
 
         matches = plate_re.search(plate_number)
         if matches is None:
@@ -181,7 +181,7 @@ class IDNationalIdentityNumberField(Field):
         if value in EMPTY_VALUES:
             return ''
 
-        value = re.sub(r'[\s.]', '', smart_unicode(value))
+        value = re.sub(r'[\s.]', '', smart_text(value))
 
         if not nik_re.search(value):
             raise ValidationError(self.error_messages['invalid'])
diff --git a/django/contrib/localflavor/in_/forms.py b/django/contrib/localflavor/in_/forms.py
index b62ec7bdb2..5c1d009ef4 100644
--- a/django/contrib/localflavor/in_/forms.py
+++ b/django/contrib/localflavor/in_/forms.py
@@ -10,7 +10,7 @@ from django.contrib.localflavor.in_.in_states import STATES_NORMALIZED, STATE_CH
 from django.core.validators import EMPTY_VALUES
 from django.forms import ValidationError
 from django.forms.fields import Field, RegexField, CharField, Select
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.translation import ugettext_lazy as _
 
 
@@ -74,7 +74,7 @@ class INStateField(Field):
             pass
         else:
             try:
-                return smart_unicode(STATES_NORMALIZED[value.strip().lower()])
+                return smart_text(STATES_NORMALIZED[value.strip().lower()])
             except KeyError:
                 pass
         raise ValidationError(self.error_messages['invalid'])
@@ -107,7 +107,7 @@ class INPhoneNumberField(CharField):
         super(INPhoneNumberField, self).clean(value)
         if value in EMPTY_VALUES:
             return ''
-        value = smart_unicode(value)
+        value = smart_text(value)
         m = phone_digits_re.match(value)
         if m:
             return '%s' % (value)
diff --git a/django/contrib/localflavor/is_/forms.py b/django/contrib/localflavor/is_/forms.py
index 7af9f51cfb..1ae3e012a1 100644
--- a/django/contrib/localflavor/is_/forms.py
+++ b/django/contrib/localflavor/is_/forms.py
@@ -9,7 +9,7 @@ from django.core.validators import EMPTY_VALUES
 from django.forms import ValidationError
 from django.forms.fields import RegexField
 from django.forms.widgets import Select
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.translation import ugettext_lazy as _
 
 
@@ -58,7 +58,7 @@ class ISIdNumberField(RegexField):
         Takes in the value in canonical form and returns it in the common
         display format.
         """
-        return smart_unicode(value[:6]+'-'+value[6:])
+        return smart_text(value[:6]+'-'+value[6:])
 
 class ISPhoneNumberField(RegexField):
     """
diff --git a/django/contrib/localflavor/it/forms.py b/django/contrib/localflavor/it/forms.py
index 60b1eff951..916ce9bb3d 100644
--- a/django/contrib/localflavor/it/forms.py
+++ b/django/contrib/localflavor/it/forms.py
@@ -13,7 +13,7 @@ from django.core.validators import EMPTY_VALUES
 from django.forms import ValidationError
 from django.forms.fields import Field, RegexField, Select
 from django.utils.translation import ugettext_lazy as _
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 
 
 class ITZipCodeField(RegexField):
@@ -85,4 +85,4 @@ class ITVatNumberField(Field):
         check_digit = vat_number_check_digit(vat_number[0:10])
         if not vat_number[10] == check_digit:
             raise ValidationError(self.error_messages['invalid'])
-        return smart_unicode(vat_number)
+        return smart_text(vat_number)
diff --git a/django/contrib/localflavor/it/util.py b/django/contrib/localflavor/it/util.py
index ec1b7e3f83..e1aa9c0419 100644
--- a/django/contrib/localflavor/it/util.py
+++ b/django/contrib/localflavor/it/util.py
@@ -1,4 +1,4 @@
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 
 def ssn_check_digit(value):
     "Calculate Italian social security number check digit."
@@ -34,11 +34,11 @@ def ssn_check_digit(value):
 
 def vat_number_check_digit(vat_number):
     "Calculate Italian VAT number check digit."
-    normalized_vat_number = smart_unicode(vat_number).zfill(10)
+    normalized_vat_number = smart_text(vat_number).zfill(10)
     total = 0
     for i in range(0, 10, 2):
         total += int(normalized_vat_number[i])
     for i in range(1, 11, 2):
         quotient , remainder = divmod(int(normalized_vat_number[i]) * 2, 10)
         total += quotient + remainder
-    return smart_unicode((10 - total % 10) % 10)
+    return smart_text((10 - total % 10) % 10)
diff --git a/django/contrib/localflavor/nl/forms.py b/django/contrib/localflavor/nl/forms.py
index bdd769bd39..a05dd38f7f 100644
--- a/django/contrib/localflavor/nl/forms.py
+++ b/django/contrib/localflavor/nl/forms.py
@@ -10,7 +10,7 @@ from django.contrib.localflavor.nl.nl_provinces import PROVINCE_CHOICES
 from django.core.validators import EMPTY_VALUES
 from django.forms import ValidationError
 from django.forms.fields import Field, Select
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.translation import ugettext_lazy as _
 
 
@@ -61,7 +61,7 @@ class NLPhoneNumberField(Field):
         if value in EMPTY_VALUES:
             return ''
 
-        phone_nr = re.sub('[\-\s\(\)]', '', smart_unicode(value))
+        phone_nr = re.sub('[\-\s\(\)]', '', smart_text(value))
 
         if len(phone_nr) == 10 and numeric_re.search(phone_nr):
             return value
diff --git a/django/contrib/localflavor/pt/forms.py b/django/contrib/localflavor/pt/forms.py
index b27fb577bd..01cdd101b2 100644
--- a/django/contrib/localflavor/pt/forms.py
+++ b/django/contrib/localflavor/pt/forms.py
@@ -8,7 +8,7 @@ import re
 from django.core.validators import EMPTY_VALUES
 from django.forms import ValidationError
 from django.forms.fields import Field, RegexField
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.translation import ugettext_lazy as _
 
 phone_digits_re = re.compile(r'^(\d{9}|(00|\+)\d*)$')
@@ -29,7 +29,7 @@ class PTZipCodeField(RegexField):
            return '%s-%s' % (cleaned[:4],cleaned[4:])
         else:
            return cleaned
-        
+
 class PTPhoneNumberField(Field):
     """
     Validate local Portuguese phone number (including international ones)
@@ -43,7 +43,7 @@ class PTPhoneNumberField(Field):
         super(PTPhoneNumberField, self).clean(value)
         if value in EMPTY_VALUES:
             return ''
-        value = re.sub('(\.|\s)', '', smart_unicode(value))
+        value = re.sub('(\.|\s)', '', smart_text(value))
         m = phone_digits_re.search(value)
         if m:
             return '%s' % value
diff --git a/django/contrib/localflavor/tr/forms.py b/django/contrib/localflavor/tr/forms.py
index 15bc1f99bb..c4f928e670 100644
--- a/django/contrib/localflavor/tr/forms.py
+++ b/django/contrib/localflavor/tr/forms.py
@@ -10,7 +10,7 @@ from django.contrib.localflavor.tr.tr_provinces import PROVINCE_CHOICES
 from django.core.validators import EMPTY_VALUES
 from django.forms import ValidationError
 from django.forms.fields import Field, RegexField, Select, CharField
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.translation import ugettext_lazy as _
 
 
@@ -46,7 +46,7 @@ class TRPhoneNumberField(CharField):
         super(TRPhoneNumberField, self).clean(value)
         if value in EMPTY_VALUES:
             return ''
-        value = re.sub('(\(|\)|\s+)', '', smart_unicode(value))
+        value = re.sub('(\(|\)|\s+)', '', smart_text(value))
         m = phone_digits_re.search(value)
         if m:
             return '%s%s' % (m.group(2), m.group(4))
diff --git a/django/contrib/localflavor/us/forms.py b/django/contrib/localflavor/us/forms.py
index ef565163cd..437bb7c466 100644
--- a/django/contrib/localflavor/us/forms.py
+++ b/django/contrib/localflavor/us/forms.py
@@ -9,7 +9,7 @@ import re
 from django.core.validators import EMPTY_VALUES
 from django.forms import ValidationError
 from django.forms.fields import Field, RegexField, Select, CharField
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.translation import ugettext_lazy as _
 
 
@@ -34,7 +34,7 @@ class USPhoneNumberField(CharField):
         super(USPhoneNumberField, self).clean(value)
         if value in EMPTY_VALUES:
             return ''
-        value = re.sub('(\(|\)|\s+)', '', smart_unicode(value))
+        value = re.sub('(\(|\)|\s+)', '', smart_text(value))
         m = phone_digits_re.search(value)
         if m:
             return '%s-%s-%s' % (m.group(1), m.group(2), m.group(3))
diff --git a/django/contrib/markup/templatetags/markup.py b/django/contrib/markup/templatetags/markup.py
index 84251cf30a..af9c842f42 100644
--- a/django/contrib/markup/templatetags/markup.py
+++ b/django/contrib/markup/templatetags/markup.py
@@ -13,7 +13,7 @@ markup syntaxes to HTML; currently there is support for:
 
 from django import template
 from django.conf import settings
-from django.utils.encoding import smart_str, force_unicode
+from django.utils.encoding import smart_bytes, force_text
 from django.utils.safestring import mark_safe
 
 register = template.Library()
@@ -25,9 +25,9 @@ def textile(value):
     except ImportError:
         if settings.DEBUG:
             raise template.TemplateSyntaxError("Error in 'textile' filter: The Python textile library isn't installed.")
-        return force_unicode(value)
+        return force_text(value)
     else:
-        return mark_safe(force_unicode(textile.textile(smart_str(value), encoding='utf-8', output='utf-8')))
+        return mark_safe(force_text(textile.textile(smart_bytes(value), encoding='utf-8', output='utf-8')))
 
 @register.filter(is_safe=True)
 def markdown(value, arg=''):
@@ -52,23 +52,23 @@ def markdown(value, arg=''):
     except ImportError:
         if settings.DEBUG:
             raise template.TemplateSyntaxError("Error in 'markdown' filter: The Python markdown library isn't installed.")
-        return force_unicode(value)
+        return force_text(value)
     else:
         markdown_vers = getattr(markdown, "version_info", 0)
         if markdown_vers < (2, 1):
             if settings.DEBUG:
                 raise template.TemplateSyntaxError(
                     "Error in 'markdown' filter: Django does not support versions of the Python markdown library < 2.1.")
-            return force_unicode(value)
+            return force_text(value)
         else:
             extensions = [e for e in arg.split(",") if e]
             if extensions and extensions[0] == "safe":
                 extensions = extensions[1:]
                 return mark_safe(markdown.markdown(
-                    force_unicode(value), extensions, safe_mode=True, enable_attributes=False))
+                    force_text(value), extensions, safe_mode=True, enable_attributes=False))
             else:
                 return mark_safe(markdown.markdown(
-                    force_unicode(value), extensions, safe_mode=False))
+                    force_text(value), extensions, safe_mode=False))
 
 @register.filter(is_safe=True)
 def restructuredtext(value):
@@ -77,8 +77,8 @@ def restructuredtext(value):
     except ImportError:
         if settings.DEBUG:
             raise template.TemplateSyntaxError("Error in 'restructuredtext' filter: The Python docutils library isn't installed.")
-        return force_unicode(value)
+        return force_text(value)
     else:
         docutils_settings = getattr(settings, "RESTRUCTUREDTEXT_FILTER_SETTINGS", {})
-        parts = publish_parts(source=smart_str(value), writer_name="html4css1", settings_overrides=docutils_settings)
-        return mark_safe(force_unicode(parts["fragment"]))
+        parts = publish_parts(source=smart_bytes(value), writer_name="html4css1", settings_overrides=docutils_settings)
+        return mark_safe(force_text(parts["fragment"]))
diff --git a/django/contrib/messages/storage/base.py b/django/contrib/messages/storage/base.py
index e80818e84e..5433bbff28 100644
--- a/django/contrib/messages/storage/base.py
+++ b/django/contrib/messages/storage/base.py
@@ -1,7 +1,7 @@
 from __future__ import unicode_literals
 
 from django.conf import settings
-from django.utils.encoding import force_unicode, StrAndUnicode
+from django.utils.encoding import force_text, StrAndUnicode
 from django.contrib.messages import constants, utils
 
 
@@ -26,22 +26,22 @@ class Message(StrAndUnicode):
         and ``extra_tags`` to unicode in case they are lazy translations.
 
         Known "safe" types (None, int, etc.) are not converted (see Django's
-        ``force_unicode`` implementation for details).
+        ``force_text`` implementation for details).
         """
-        self.message = force_unicode(self.message, strings_only=True)
-        self.extra_tags = force_unicode(self.extra_tags, strings_only=True)
+        self.message = force_text(self.message, strings_only=True)
+        self.extra_tags = force_text(self.extra_tags, strings_only=True)
 
     def __eq__(self, other):
         return isinstance(other, Message) and self.level == other.level and \
                                               self.message == other.message
 
     def __unicode__(self):
-        return force_unicode(self.message)
+        return force_text(self.message)
 
     def _get_tags(self):
-        label_tag = force_unicode(LEVEL_TAGS.get(self.level, ''),
+        label_tag = force_text(LEVEL_TAGS.get(self.level, ''),
                                   strings_only=True)
-        extra_tags = force_unicode(self.extra_tags, strings_only=True)
+        extra_tags = force_text(self.extra_tags, strings_only=True)
         if extra_tags and label_tag:
             return ' '.join([extra_tags, label_tag])
         elif extra_tags:
diff --git a/django/contrib/sessions/backends/db.py b/django/contrib/sessions/backends/db.py
index 3dd0d9516c..0cc17b44c3 100644
--- a/django/contrib/sessions/backends/db.py
+++ b/django/contrib/sessions/backends/db.py
@@ -1,7 +1,7 @@
 from django.contrib.sessions.backends.base import SessionBase, CreateError
 from django.core.exceptions import SuspiciousOperation
 from django.db import IntegrityError, transaction, router
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils import timezone
 
 
@@ -18,7 +18,7 @@ class SessionStore(SessionBase):
                 session_key = self.session_key,
                 expire_date__gt=timezone.now()
             )
-            return self.decode(force_unicode(s.session_data))
+            return self.decode(force_text(s.session_data))
         except (Session.DoesNotExist, SuspiciousOperation):
             self.create()
             return {}
diff --git a/django/contrib/staticfiles/management/commands/collectstatic.py b/django/contrib/staticfiles/management/commands/collectstatic.py
index d3977213a9..45c5ecfe1f 100644
--- a/django/contrib/staticfiles/management/commands/collectstatic.py
+++ b/django/contrib/staticfiles/management/commands/collectstatic.py
@@ -6,7 +6,7 @@ from optparse import make_option
 
 from django.core.files.storage import FileSystemStorage
 from django.core.management.base import CommandError, NoArgsCommand
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.datastructures import SortedDict
 
 from django.contrib.staticfiles import finders, storage
@@ -198,9 +198,9 @@ Type 'yes' to continue, or 'no' to cancel: """
             fpath = os.path.join(path, f)
             if self.dry_run:
                 self.log("Pretending to delete '%s'" %
-                         smart_unicode(fpath), level=1)
+                         smart_text(fpath), level=1)
             else:
-                self.log("Deleting '%s'" % smart_unicode(fpath), level=1)
+                self.log("Deleting '%s'" % smart_text(fpath), level=1)
                 self.storage.delete(fpath)
         for d in dirs:
             self.clear_dir(os.path.join(path, d))
diff --git a/django/contrib/staticfiles/management/commands/findstatic.py b/django/contrib/staticfiles/management/commands/findstatic.py
index 772220b342..dc1e88d778 100644
--- a/django/contrib/staticfiles/management/commands/findstatic.py
+++ b/django/contrib/staticfiles/management/commands/findstatic.py
@@ -3,7 +3,7 @@ from __future__ import unicode_literals
 import os
 from optparse import make_option
 from django.core.management.base import LabelCommand
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 
 from django.contrib.staticfiles import finders
 
@@ -19,12 +19,12 @@ class Command(LabelCommand):
     def handle_label(self, path, **options):
         verbosity = int(options.get('verbosity', 1))
         result = finders.find(path, all=options['all'])
-        path = smart_unicode(path)
+        path = smart_text(path)
         if result:
             if not isinstance(result, (list, tuple)):
                 result = [result]
             output = '\n  '.join(
-                (smart_unicode(os.path.realpath(path)) for path in result))
+                (smart_text(os.path.realpath(path)) for path in result))
             self.stdout.write("Found '%s' here:\n  %s" % (path, output))
         else:
             if verbosity >= 1:
diff --git a/django/contrib/staticfiles/storage.py b/django/contrib/staticfiles/storage.py
index a0133e1c6a..2ca54dde71 100644
--- a/django/contrib/staticfiles/storage.py
+++ b/django/contrib/staticfiles/storage.py
@@ -16,7 +16,7 @@ from django.core.exceptions import ImproperlyConfigured
 from django.core.files.base import ContentFile
 from django.core.files.storage import FileSystemStorage, get_storage_class
 from django.utils.datastructures import SortedDict
-from django.utils.encoding import force_unicode, smart_str
+from django.utils.encoding import force_text, smart_bytes
 from django.utils.functional import LazyObject
 from django.utils.importlib import import_module
 
@@ -112,7 +112,7 @@ class CachedFilesMixin(object):
         return urlunsplit(unparsed_name)
 
     def cache_key(self, name):
-        return 'staticfiles:%s' % hashlib.md5(smart_str(name)).hexdigest()
+        return 'staticfiles:%s' % hashlib.md5(smart_bytes(name)).hexdigest()
 
     def url(self, name, force=False):
         """
@@ -248,9 +248,9 @@ class CachedFilesMixin(object):
                     if hashed_file_exists:
                         self.delete(hashed_name)
                     # then save the processed result
-                    content_file = ContentFile(smart_str(content))
+                    content_file = ContentFile(smart_bytes(content))
                     saved_name = self._save(hashed_name, content_file)
-                    hashed_name = force_unicode(saved_name.replace('\\', '/'))
+                    hashed_name = force_text(saved_name.replace('\\', '/'))
                     processed = True
                 else:
                     # or handle the case in which neither processing nor
@@ -258,7 +258,7 @@ class CachedFilesMixin(object):
                     if not hashed_file_exists:
                         processed = True
                         saved_name = self._save(hashed_name, original_file)
-                        hashed_name = force_unicode(saved_name.replace('\\', '/'))
+                        hashed_name = force_text(saved_name.replace('\\', '/'))
 
                 # and then set the cache accordingly
                 hashed_paths[self.cache_key(name)] = hashed_name
diff --git a/django/contrib/syndication/views.py b/django/contrib/syndication/views.py
index 3c84f1f60c..bce7ef7cfb 100644
--- a/django/contrib/syndication/views.py
+++ b/django/contrib/syndication/views.py
@@ -6,7 +6,7 @@ from django.core.exceptions import ImproperlyConfigured, ObjectDoesNotExist
 from django.http import HttpResponse, Http404
 from django.template import loader, TemplateDoesNotExist, RequestContext
 from django.utils import feedgenerator, tzinfo
-from django.utils.encoding import force_unicode, iri_to_uri, smart_unicode
+from django.utils.encoding import force_text, iri_to_uri, smart_text
 from django.utils.html import escape
 from django.utils.timezone import is_naive
 
@@ -43,10 +43,10 @@ class Feed(object):
 
     def item_title(self, item):
         # Titles should be double escaped by default (see #6533)
-        return escape(force_unicode(item))
+        return escape(force_text(item))
 
     def item_description(self, item):
-        return force_unicode(item)
+        return force_text(item)
 
     def item_link(self, item):
         try:
@@ -154,9 +154,9 @@ class Feed(object):
             enc_url = self.__get_dynamic_attr('item_enclosure_url', item)
             if enc_url:
                 enc = feedgenerator.Enclosure(
-                    url = smart_unicode(enc_url),
-                    length = smart_unicode(self.__get_dynamic_attr('item_enclosure_length', item)),
-                    mime_type = smart_unicode(self.__get_dynamic_attr('item_enclosure_mime_type', item))
+                    url = smart_text(enc_url),
+                    length = smart_text(self.__get_dynamic_attr('item_enclosure_length', item)),
+                    mime_type = smart_text(self.__get_dynamic_attr('item_enclosure_mime_type', item))
                 )
             author_name = self.__get_dynamic_attr('item_author_name', item)
             if author_name is not None:
diff --git a/django/core/cache/backends/base.py b/django/core/cache/backends/base.py
index f7573b2e31..d527e44d8b 100644
--- a/django/core/cache/backends/base.py
+++ b/django/core/cache/backends/base.py
@@ -3,7 +3,7 @@
 import warnings
 
 from django.core.exceptions import ImproperlyConfigured, DjangoRuntimeWarning
-from django.utils.encoding import smart_str
+from django.utils.encoding import smart_bytes
 from django.utils.importlib import import_module
 
 class InvalidCacheBackendError(ImproperlyConfigured):
@@ -23,7 +23,7 @@ def default_key_func(key, key_prefix, version):
     the `key_prefix'. KEY_FUNCTION can be used to specify an alternate
     function with custom key making behavior.
     """
-    return ':'.join([key_prefix, str(version), smart_str(key)])
+    return ':'.join([key_prefix, str(version), smart_bytes(key)])
 
 def get_key_func(key_func):
     """
@@ -62,7 +62,7 @@ class BaseCache(object):
         except (ValueError, TypeError):
             self._cull_frequency = 3
 
-        self.key_prefix = smart_str(params.get('KEY_PREFIX', ''))
+        self.key_prefix = smart_bytes(params.get('KEY_PREFIX', ''))
         self.version = params.get('VERSION', 1)
         self.key_func = get_key_func(params.get('KEY_FUNCTION', None))
 
diff --git a/django/core/context_processors.py b/django/core/context_processors.py
index 325f64d224..a503270cf4 100644
--- a/django/core/context_processors.py
+++ b/django/core/context_processors.py
@@ -9,7 +9,7 @@ RequestContext.
 
 from django.conf import settings
 from django.middleware.csrf import get_token
-from django.utils.encoding import smart_str
+from django.utils.encoding import smart_bytes
 from django.utils.functional import lazy
 
 def csrf(request):
@@ -25,7 +25,7 @@ def csrf(request):
             # instead of returning an empty dict.
             return b'NOTPROVIDED'
         else:
-            return smart_str(token)
+            return smart_bytes(token)
     _get_val = lazy(_get_val, str)
 
     return {'csrf_token': _get_val() }
diff --git a/django/core/exceptions.py b/django/core/exceptions.py
index e3d1dc9c7e..f0f14cffda 100644
--- a/django/core/exceptions.py
+++ b/django/core/exceptions.py
@@ -43,7 +43,7 @@ class ValidationError(Exception):
     """An error while validating data."""
     def __init__(self, message, code=None, params=None):
         import operator
-        from django.utils.encoding import force_unicode
+        from django.utils.encoding import force_text
         """
         ValidationError can be passed any object that can be printed (usually
         a string), a list of objects or a dictionary.
@@ -54,11 +54,11 @@ class ValidationError(Exception):
             message = reduce(operator.add, message.values())
 
         if isinstance(message, list):
-            self.messages = [force_unicode(msg) for msg in message]
+            self.messages = [force_text(msg) for msg in message]
         else:
             self.code = code
             self.params = params
-            message = force_unicode(message)
+            message = force_text(message)
             self.messages = [message]
 
     def __str__(self):
diff --git a/django/core/files/base.py b/django/core/files/base.py
index 04853fad0c..37b1be89b3 100644
--- a/django/core/files/base.py
+++ b/django/core/files/base.py
@@ -3,7 +3,7 @@ from __future__ import unicode_literals
 import os
 from io import BytesIO
 
-from django.utils.encoding import smart_str, smart_unicode
+from django.utils.encoding import smart_bytes, smart_text
 from django.core.files.utils import FileProxyMixin
 
 class File(FileProxyMixin):
@@ -18,10 +18,10 @@ class File(FileProxyMixin):
             self.mode = file.mode
 
     def __str__(self):
-        return smart_str(self.name or '')
+        return smart_bytes(self.name or '')
 
     def __unicode__(self):
-        return smart_unicode(self.name or '')
+        return smart_text(self.name or '')
 
     def __repr__(self):
         return "<%s: %s>" % (self.__class__.__name__, self or "None")
diff --git a/django/core/files/storage.py b/django/core/files/storage.py
index 5179980513..7542dcda46 100644
--- a/django/core/files/storage.py
+++ b/django/core/files/storage.py
@@ -11,7 +11,7 @@ from django.conf import settings
 from django.core.exceptions import ImproperlyConfigured, SuspiciousOperation
 from django.core.files import locks, File
 from django.core.files.move import file_move_safe
-from django.utils.encoding import force_unicode, filepath_to_uri
+from django.utils.encoding import force_text, filepath_to_uri
 from django.utils.functional import LazyObject
 from django.utils.importlib import import_module
 from django.utils.text import get_valid_filename
@@ -48,7 +48,7 @@ class Storage(object):
         name = self._save(name, content)
 
         # Store filenames with forward slashes, even on Windows
-        return force_unicode(name.replace('\\', '/'))
+        return force_text(name.replace('\\', '/'))
 
     # These methods are part of the public API, with default implementations.
 
diff --git a/django/core/files/uploadedfile.py b/django/core/files/uploadedfile.py
index 97d53482e4..3a6c632975 100644
--- a/django/core/files/uploadedfile.py
+++ b/django/core/files/uploadedfile.py
@@ -8,7 +8,7 @@ from io import BytesIO
 from django.conf import settings
 from django.core.files.base import File
 from django.core.files import temp as tempfile
-from django.utils.encoding import smart_str
+from django.utils.encoding import smart_bytes
 
 __all__ = ('UploadedFile', 'TemporaryUploadedFile', 'InMemoryUploadedFile',
            'SimpleUploadedFile')
@@ -30,7 +30,7 @@ class UploadedFile(File):
         self.charset = charset
 
     def __repr__(self):
-        return smart_str("<%s: %s (%s)>" % (
+        return smart_bytes("<%s: %s (%s)>" % (
             self.__class__.__name__, self.name, self.content_type))
 
     def _get_name(self):
diff --git a/django/core/handlers/base.py b/django/core/handlers/base.py
index 7fd7d19c4a..5a6825f0a7 100644
--- a/django/core/handlers/base.py
+++ b/django/core/handlers/base.py
@@ -4,7 +4,7 @@ import sys
 
 from django import http
 from django.core import signals
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils.importlib import import_module
 from django.utils.log import getLogger
 from django.utils import six
@@ -250,7 +250,7 @@ def get_script_name(environ):
     """
     from django.conf import settings
     if settings.FORCE_SCRIPT_NAME is not None:
-        return force_unicode(settings.FORCE_SCRIPT_NAME)
+        return force_text(settings.FORCE_SCRIPT_NAME)
 
     # If Apache's mod_rewrite had a whack at the URL, Apache set either
     # SCRIPT_URL or REDIRECT_URL to the full resource URL before applying any
@@ -261,5 +261,5 @@ def get_script_name(environ):
     if not script_url:
         script_url = environ.get('REDIRECT_URL', '')
     if script_url:
-        return force_unicode(script_url[:-len(environ.get('PATH_INFO', ''))])
-    return force_unicode(environ.get('SCRIPT_NAME', ''))
+        return force_text(script_url[:-len(environ.get('PATH_INFO', ''))])
+    return force_text(environ.get('SCRIPT_NAME', ''))
diff --git a/django/core/handlers/wsgi.py b/django/core/handlers/wsgi.py
index 51ad2be002..70b23f8515 100644
--- a/django/core/handlers/wsgi.py
+++ b/django/core/handlers/wsgi.py
@@ -9,7 +9,7 @@ from django.core import signals
 from django.core.handlers import base
 from django.core.urlresolvers import set_script_prefix
 from django.utils import datastructures
-from django.utils.encoding import force_unicode, smart_str, iri_to_uri
+from django.utils.encoding import force_text, smart_bytes, iri_to_uri
 from django.utils.log import getLogger
 
 logger = getLogger('django.request')
@@ -127,7 +127,7 @@ class LimitedStream(object):
 class WSGIRequest(http.HttpRequest):
     def __init__(self, environ):
         script_name = base.get_script_name(environ)
-        path_info = force_unicode(environ.get('PATH_INFO', '/'))
+        path_info = force_text(environ.get('PATH_INFO', '/'))
         if not path_info or path_info == script_name:
             # Sometimes PATH_INFO exists, but is empty (e.g. accessing
             # the SCRIPT_NAME URL without a trailing slash). We really need to
@@ -246,5 +246,5 @@ class WSGIHandler(base.BaseHandler):
         response_headers = [(str(k), str(v)) for k, v in response.items()]
         for c in response.cookies.values():
             response_headers.append((str('Set-Cookie'), str(c.output(header=''))))
-        start_response(smart_str(status), response_headers)
+        start_response(smart_bytes(status), response_headers)
         return response
diff --git a/django/core/mail/message.py b/django/core/mail/message.py
index 629ad464f9..8f589ae33d 100644
--- a/django/core/mail/message.py
+++ b/django/core/mail/message.py
@@ -15,7 +15,7 @@ from io import BytesIO
 
 from django.conf import settings
 from django.core.mail.utils import DNS_NAME
-from django.utils.encoding import smart_str, force_unicode
+from django.utils.encoding import smart_bytes, force_text
 from django.utils import six
 
 
@@ -79,7 +79,7 @@ ADDRESS_HEADERS = set([
 def forbid_multi_line_headers(name, val, encoding):
     """Forbids multi-line headers, to prevent header injection."""
     encoding = encoding or settings.DEFAULT_CHARSET
-    val = force_unicode(val)
+    val = force_text(val)
     if '\n' in val or '\r' in val:
         raise BadHeaderError("Header values can't contain newlines (got %r for header %r)" % (val, name))
     try:
@@ -93,12 +93,12 @@ def forbid_multi_line_headers(name, val, encoding):
     else:
         if name.lower() == 'subject':
             val = Header(val)
-    return smart_str(name), val
+    return smart_bytes(name), val
 
 
 def sanitize_address(addr, encoding):
     if isinstance(addr, six.string_types):
-        addr = parseaddr(force_unicode(addr))
+        addr = parseaddr(force_text(addr))
     nm, addr = addr
     nm = str(Header(nm, encoding))
     try:
@@ -210,7 +210,7 @@ class EmailMessage(object):
 
     def message(self):
         encoding = self.encoding or settings.DEFAULT_CHARSET
-        msg = SafeMIMEText(smart_str(self.body, encoding),
+        msg = SafeMIMEText(smart_bytes(self.body, encoding),
                            self.content_subtype, encoding)
         msg = self._create_message(msg)
         msg['Subject'] = self.subject
@@ -293,7 +293,7 @@ class EmailMessage(object):
         basetype, subtype = mimetype.split('/', 1)
         if basetype == 'text':
             encoding = self.encoding or settings.DEFAULT_CHARSET
-            attachment = SafeMIMEText(smart_str(content, encoding), subtype, encoding)
+            attachment = SafeMIMEText(smart_bytes(content, encoding), subtype, encoding)
         else:
             # Encode non-text attachments with base64.
             attachment = MIMEBase(basetype, subtype)
diff --git a/django/core/management/commands/createcachetable.py b/django/core/management/commands/createcachetable.py
index fd6dbbbd2c..411042ee76 100644
--- a/django/core/management/commands/createcachetable.py
+++ b/django/core/management/commands/createcachetable.py
@@ -4,7 +4,7 @@ from django.core.cache.backends.db import BaseDatabaseCache
 from django.core.management.base import LabelCommand, CommandError
 from django.db import connections, router, transaction, models, DEFAULT_DB_ALIAS
 from django.db.utils import DatabaseError
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 
 
 class Command(LabelCommand):
@@ -60,7 +60,7 @@ class Command(LabelCommand):
             transaction.rollback_unless_managed(using=db)
             raise CommandError(
                 "Cache table '%s' could not be created.\nThe error was: %s." %
-                    (tablename, force_unicode(e)))
+                    (tablename, force_text(e)))
         for statement in index_output:
             curs.execute(statement)
         transaction.commit_unless_managed(using=db)
diff --git a/django/core/management/commands/loaddata.py b/django/core/management/commands/loaddata.py
index 34f8041d33..1896e53cee 100644
--- a/django/core/management/commands/loaddata.py
+++ b/django/core/management/commands/loaddata.py
@@ -14,7 +14,7 @@ from django.core.management.color import no_style
 from django.db import (connections, router, transaction, DEFAULT_DB_ALIAS,
       IntegrityError, DatabaseError)
 from django.db.models import get_apps
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from itertools import product
 
 try:
@@ -189,7 +189,7 @@ class Command(BaseCommand):
                                                         'app_label': obj.object._meta.app_label,
                                                         'object_name': obj.object._meta.object_name,
                                                         'pk': obj.object.pk,
-                                                        'error_msg': force_unicode(e)
+                                                        'error_msg': force_text(e)
                                                     },)
                                                 raise
 
diff --git a/django/core/serializers/base.py b/django/core/serializers/base.py
index 19886f7d53..78a01c7098 100644
--- a/django/core/serializers/base.py
+++ b/django/core/serializers/base.py
@@ -5,7 +5,7 @@ Module for abstract serializer/unserializer base classes.
 from io import BytesIO
 
 from django.db import models
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils import six
 
 class SerializerDoesNotExist(KeyError):
diff --git a/django/core/serializers/json.py b/django/core/serializers/json.py
index 8b56d0e7b8..3bac24d33a 100644
--- a/django/core/serializers/json.py
+++ b/django/core/serializers/json.py
@@ -12,7 +12,7 @@ import json
 from django.core.serializers.base import DeserializationError
 from django.core.serializers.python import Serializer as PythonSerializer
 from django.core.serializers.python import Deserializer as PythonDeserializer
-from django.utils.encoding import smart_str
+from django.utils.encoding import smart_bytes
 from django.utils import six
 from django.utils.timezone import is_aware
 
diff --git a/django/core/serializers/python.py b/django/core/serializers/python.py
index 83c6eb6739..348ff1dada 100644
--- a/django/core/serializers/python.py
+++ b/django/core/serializers/python.py
@@ -8,7 +8,7 @@ from __future__ import unicode_literals
 from django.conf import settings
 from django.core.serializers import base
 from django.db import models, DEFAULT_DB_ALIAS
-from django.utils.encoding import smart_unicode, is_protected_type
+from django.utils.encoding import smart_text, is_protected_type
 from django.utils import six
 
 class Serializer(base.Serializer):
@@ -34,8 +34,8 @@ class Serializer(base.Serializer):
 
     def get_dump_object(self, obj):
         return {
-            "pk": smart_unicode(obj._get_pk_val(), strings_only=True),
-            "model": smart_unicode(obj._meta),
+            "pk": smart_text(obj._get_pk_val(), strings_only=True),
+            "model": smart_text(obj._meta),
             "fields": self._current
         }
 
@@ -65,7 +65,7 @@ class Serializer(base.Serializer):
             if self.use_natural_keys and hasattr(field.rel.to, 'natural_key'):
                 m2m_value = lambda value: value.natural_key()
             else:
-                m2m_value = lambda value: smart_unicode(value._get_pk_val(), strings_only=True)
+                m2m_value = lambda value: smart_text(value._get_pk_val(), strings_only=True)
             self._current[field.name] = [m2m_value(related)
                                for related in getattr(obj, field.name).iterator()]
 
@@ -90,7 +90,7 @@ def Deserializer(object_list, **options):
         # Handle each field
         for (field_name, field_value) in six.iteritems(d["fields"]):
             if isinstance(field_value, str):
-                field_value = smart_unicode(field_value, options.get("encoding", settings.DEFAULT_CHARSET), strings_only=True)
+                field_value = smart_text(field_value, options.get("encoding", settings.DEFAULT_CHARSET), strings_only=True)
 
             field = Model._meta.get_field(field_name)
 
@@ -101,9 +101,9 @@ def Deserializer(object_list, **options):
                         if hasattr(value, '__iter__'):
                             return field.rel.to._default_manager.db_manager(db).get_by_natural_key(*value).pk
                         else:
-                            return smart_unicode(field.rel.to._meta.pk.to_python(value))
+                            return smart_text(field.rel.to._meta.pk.to_python(value))
                 else:
-                    m2m_convert = lambda v: smart_unicode(field.rel.to._meta.pk.to_python(v))
+                    m2m_convert = lambda v: smart_text(field.rel.to._meta.pk.to_python(v))
                 m2m_data[field.name] = [m2m_convert(pk) for pk in field_value]
 
             # Handle FK fields
diff --git a/django/core/serializers/pyyaml.py b/django/core/serializers/pyyaml.py
index ac0e6cf82d..9be1ea4492 100644
--- a/django/core/serializers/pyyaml.py
+++ b/django/core/serializers/pyyaml.py
@@ -12,7 +12,7 @@ from django.db import models
 from django.core.serializers.base import DeserializationError
 from django.core.serializers.python import Serializer as PythonSerializer
 from django.core.serializers.python import Deserializer as PythonDeserializer
-from django.utils.encoding import smart_str
+from django.utils.encoding import smart_bytes
 from django.utils import six
 
 
diff --git a/django/core/serializers/xml_serializer.py b/django/core/serializers/xml_serializer.py
index 9d9c023b64..c4e4dd189e 100644
--- a/django/core/serializers/xml_serializer.py
+++ b/django/core/serializers/xml_serializer.py
@@ -8,7 +8,7 @@ from django.conf import settings
 from django.core.serializers import base
 from django.db import models, DEFAULT_DB_ALIAS
 from django.utils.xmlutils import SimplerXMLGenerator
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from xml.dom import pulldom
 
 class Serializer(base.Serializer):
@@ -46,11 +46,11 @@ class Serializer(base.Serializer):
         self.indent(1)
         obj_pk = obj._get_pk_val()
         if obj_pk is None:
-            attrs = {"model": smart_unicode(obj._meta),}
+            attrs = {"model": smart_text(obj._meta),}
         else:
             attrs = {
-                "pk": smart_unicode(obj._get_pk_val()),
-                "model": smart_unicode(obj._meta),
+                "pk": smart_text(obj._get_pk_val()),
+                "model": smart_text(obj._meta),
             }
 
         self.xml.startElement("object", attrs)
@@ -96,10 +96,10 @@ class Serializer(base.Serializer):
                 # Iterable natural keys are rolled out as subelements
                 for key_value in related:
                     self.xml.startElement("natural", {})
-                    self.xml.characters(smart_unicode(key_value))
+                    self.xml.characters(smart_text(key_value))
                     self.xml.endElement("natural")
             else:
-                self.xml.characters(smart_unicode(related_att))
+                self.xml.characters(smart_text(related_att))
         else:
             self.xml.addQuickElement("None")
         self.xml.endElement("field")
@@ -120,13 +120,13 @@ class Serializer(base.Serializer):
                     self.xml.startElement("object", {})
                     for key_value in natural:
                         self.xml.startElement("natural", {})
-                        self.xml.characters(smart_unicode(key_value))
+                        self.xml.characters(smart_text(key_value))
                         self.xml.endElement("natural")
                     self.xml.endElement("object")
             else:
                 def handle_m2m(value):
                     self.xml.addQuickElement("object", attrs={
-                        'pk' : smart_unicode(value._get_pk_val())
+                        'pk' : smart_text(value._get_pk_val())
                     })
             for relobj in getattr(obj, field.name).iterator():
                 handle_m2m(relobj)
@@ -141,7 +141,7 @@ class Serializer(base.Serializer):
         self.xml.startElement("field", {
             "name" : field.name,
             "rel"  : field.rel.__class__.__name__,
-            "to"   : smart_unicode(field.rel.to._meta),
+            "to"   : smart_text(field.rel.to._meta),
         })
 
 class Deserializer(base.Deserializer):
diff --git a/django/core/signing.py b/django/core/signing.py
index cd9759e536..9ab8c5b8b0 100644
--- a/django/core/signing.py
+++ b/django/core/signing.py
@@ -41,7 +41,7 @@ from django.conf import settings
 from django.core.exceptions import ImproperlyConfigured
 from django.utils import baseconv
 from django.utils.crypto import constant_time_compare, salted_hmac
-from django.utils.encoding import force_unicode, smart_str
+from django.utils.encoding import force_text, smart_bytes
 from django.utils.importlib import import_module
 
 
@@ -135,7 +135,7 @@ def loads(s, key=None, salt='django.core.signing', serializer=JSONSerializer, ma
     """
     Reverse of dumps(), raises BadSignature if signature fails
     """
-    base64d = smart_str(
+    base64d = smart_bytes(
         TimestampSigner(key, salt=salt).unsign(s, max_age=max_age))
     decompress = False
     if base64d[0] == '.':
@@ -159,16 +159,16 @@ class Signer(object):
         return base64_hmac(self.salt + 'signer', value, self.key)
 
     def sign(self, value):
-        value = smart_str(value)
+        value = smart_bytes(value)
         return '%s%s%s' % (value, self.sep, self.signature(value))
 
     def unsign(self, signed_value):
-        signed_value = smart_str(signed_value)
+        signed_value = smart_bytes(signed_value)
         if not self.sep in signed_value:
             raise BadSignature('No "%s" found in value' % self.sep)
         value, sig = signed_value.rsplit(self.sep, 1)
         if constant_time_compare(sig, self.signature(value)):
-            return force_unicode(value)
+            return force_text(value)
         raise BadSignature('Signature "%s" does not match' % sig)
 
 
@@ -178,7 +178,7 @@ class TimestampSigner(Signer):
         return baseconv.base62.encode(int(time.time()))
 
     def sign(self, value):
-        value = smart_str('%s%s%s' % (value, self.sep, self.timestamp()))
+        value = smart_bytes('%s%s%s' % (value, self.sep, self.timestamp()))
         return '%s%s%s' % (value, self.sep, self.signature(value))
 
     def unsign(self, value, max_age=None):
diff --git a/django/core/urlresolvers.py b/django/core/urlresolvers.py
index c17168f8cb..2fe744e8eb 100644
--- a/django/core/urlresolvers.py
+++ b/django/core/urlresolvers.py
@@ -14,7 +14,7 @@ from threading import local
 from django.http import Http404
 from django.core.exceptions import ImproperlyConfigured, ViewDoesNotExist
 from django.utils.datastructures import MultiValueDict
-from django.utils.encoding import iri_to_uri, force_unicode, smart_str
+from django.utils.encoding import iri_to_uri, force_text, smart_bytes
 from django.utils.functional import memoize, lazy
 from django.utils.importlib import import_module
 from django.utils.module_loading import module_has_submodule
@@ -163,7 +163,7 @@ class LocaleRegexProvider(object):
             if isinstance(self._regex, six.string_types):
                 regex = self._regex
             else:
-                regex = force_unicode(self._regex)
+                regex = force_text(self._regex)
             try:
                 compiled_regex = re.compile(regex, re.UNICODE)
             except re.error as e:
@@ -190,7 +190,7 @@ class RegexURLPattern(LocaleRegexProvider):
         self.name = name
 
     def __repr__(self):
-        return smart_str('<%s %s %s>' % (self.__class__.__name__, self.name, self.regex.pattern))
+        return smart_bytes('<%s %s %s>' % (self.__class__.__name__, self.name, self.regex.pattern))
 
     def add_prefix(self, prefix):
         """
@@ -240,7 +240,7 @@ class RegexURLResolver(LocaleRegexProvider):
         self._app_dict = {}
 
     def __repr__(self):
-        return smart_str('<%s %s (%s:%s) %s>' % (self.__class__.__name__, self.urlconf_name, self.app_name, self.namespace, self.regex.pattern))
+        return smart_bytes('<%s %s (%s:%s) %s>' % (self.__class__.__name__, self.urlconf_name, self.app_name, self.namespace, self.regex.pattern))
 
     def _populate(self):
         lookups = MultiValueDict()
@@ -373,7 +373,7 @@ class RegexURLResolver(LocaleRegexProvider):
                 if args:
                     if len(args) != len(params) + len(prefix_args):
                         continue
-                    unicode_args = [force_unicode(val) for val in args]
+                    unicode_args = [force_text(val) for val in args]
                     candidate =  (prefix_norm + result) % dict(zip(prefix_args + params, unicode_args))
                 else:
                     if set(kwargs.keys()) | set(defaults.keys()) != set(params) | set(defaults.keys()) | set(prefix_args):
@@ -385,7 +385,7 @@ class RegexURLResolver(LocaleRegexProvider):
                             break
                     if not matches:
                         continue
-                    unicode_kwargs = dict([(k, force_unicode(v)) for (k, v) in kwargs.items()])
+                    unicode_kwargs = dict([(k, force_text(v)) for (k, v) in kwargs.items()])
                     candidate = (prefix_norm + result) % unicode_kwargs
                 if re.search('^%s%s' % (_prefix, pattern), candidate, re.UNICODE):
                     return candidate
diff --git a/django/core/validators.py b/django/core/validators.py
index 91d6f62dcf..fd5dfa28d6 100644
--- a/django/core/validators.py
+++ b/django/core/validators.py
@@ -8,7 +8,7 @@ except ImportError:     # Python 2
 
 from django.core.exceptions import ValidationError
 from django.utils.translation import ugettext_lazy as _
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.ipv6 import is_valid_ipv6_address
 from django.utils import six
 
@@ -36,7 +36,7 @@ class RegexValidator(object):
         """
         Validates that the input matches the regular expression.
         """
-        if not self.regex.search(smart_unicode(value)):
+        if not self.regex.search(smart_text(value)):
             raise ValidationError(self.message, code=self.code)
 
 class URLValidator(RegexValidator):
@@ -54,7 +54,7 @@ class URLValidator(RegexValidator):
         except ValidationError as e:
             # Trivial case failed. Try for possible IDN domain
             if value:
-                value = smart_unicode(value)
+                value = smart_text(value)
                 scheme, netloc, path, query, fragment = urlsplit(value)
                 try:
                     netloc = netloc.encode('idna') # IDN -> ACE
diff --git a/django/db/backends/__init__.py b/django/db/backends/__init__.py
index 6e23ad5bb5..9606245162 100644
--- a/django/db/backends/__init__.py
+++ b/django/db/backends/__init__.py
@@ -607,16 +607,16 @@ class BaseDatabaseOperations(object):
         exists for database backends to provide a better implementation
         according to their own quoting schemes.
         """
-        from django.utils.encoding import smart_unicode, force_unicode
+        from django.utils.encoding import smart_text, force_text
 
         # Convert params to contain Unicode values.
-        to_unicode = lambda s: force_unicode(s, strings_only=True, errors='replace')
+        to_unicode = lambda s: force_text(s, strings_only=True, errors='replace')
         if isinstance(params, (list, tuple)):
             u_params = tuple([to_unicode(val) for val in params])
         else:
             u_params = dict([(to_unicode(k), to_unicode(v)) for k, v in params.items()])
 
-        return smart_unicode(sql) % u_params
+        return smart_text(sql) % u_params
 
     def last_insert_id(self, cursor, table_name, pk_name):
         """
@@ -800,8 +800,8 @@ class BaseDatabaseOperations(object):
 
     def prep_for_like_query(self, x):
         """Prepares a value for use in a LIKE query."""
-        from django.utils.encoding import smart_unicode
-        return smart_unicode(x).replace("\\", "\\\\").replace("%", "\%").replace("_", "\_")
+        from django.utils.encoding import smart_text
+        return smart_text(x).replace("\\", "\\\\").replace("%", "\%").replace("_", "\_")
 
     # Same as prep_for_like_query(), but called for "iexact" matches, which
     # need not necessarily be implemented using "LIKE" in the backend.
diff --git a/django/db/backends/oracle/base.py b/django/db/backends/oracle/base.py
index b08113fed7..0f16130477 100644
--- a/django/db/backends/oracle/base.py
+++ b/django/db/backends/oracle/base.py
@@ -53,7 +53,7 @@ from django.db.backends.signals import connection_created
 from django.db.backends.oracle.client import DatabaseClient
 from django.db.backends.oracle.creation import DatabaseCreation
 from django.db.backends.oracle.introspection import DatabaseIntrospection
-from django.utils.encoding import smart_str, force_unicode
+from django.utils.encoding import smart_bytes, force_text
 from django.utils import six
 from django.utils import timezone
 
@@ -64,9 +64,9 @@ IntegrityError = Database.IntegrityError
 # Check whether cx_Oracle was compiled with the WITH_UNICODE option.  This will
 # also be True in Python 3.0.
 if int(Database.version.split('.', 1)[0]) >= 5 and not hasattr(Database, 'UNICODE'):
-    convert_unicode = force_unicode
+    convert_unicode = force_text
 else:
-    convert_unicode = smart_str
+    convert_unicode = smart_bytes
 
 
 class DatabaseFeatures(BaseDatabaseFeatures):
@@ -162,7 +162,7 @@ WHEN (new.%(col_name)s IS NULL)
         if isinstance(value, Database.LOB):
             value = value.read()
             if field and field.get_internal_type() == 'TextField':
-                value = force_unicode(value)
+                value = force_text(value)
 
         # Oracle stores empty strings as null. We need to undo this in
         # order to adhere to the Django convention of using the empty
@@ -245,7 +245,7 @@ WHEN (new.%(col_name)s IS NULL)
     def process_clob(self, value):
         if value is None:
             return ''
-        return force_unicode(value.read())
+        return force_text(value.read())
 
     def quote_name(self, name):
         # SQL92 requires delimited (quoted) names to be case-sensitive.  When
@@ -595,9 +595,9 @@ class OracleParam(object):
             param = param.astimezone(timezone.utc).replace(tzinfo=None)
 
         if hasattr(param, 'bind_parameter'):
-            self.smart_str = param.bind_parameter(cursor)
+            self.smart_bytes = param.bind_parameter(cursor)
         else:
-            self.smart_str = convert_unicode(param, cursor.charset,
+            self.smart_bytes = convert_unicode(param, cursor.charset,
                                              strings_only)
         if hasattr(param, 'input_size'):
             # If parameter has `input_size` attribute, use that.
@@ -676,7 +676,7 @@ class FormatStylePlaceholderCursor(object):
         self.setinputsizes(*sizes)
 
     def _param_generator(self, params):
-        return [p.smart_str for p in params]
+        return [p.smart_bytes for p in params]
 
     def execute(self, query, params=None):
         if params is None:
@@ -831,7 +831,7 @@ def to_unicode(s):
     unchanged).
     """
     if isinstance(s, six.string_types):
-        return force_unicode(s)
+        return force_text(s)
     return s
 
 
diff --git a/django/db/models/base.py b/django/db/models/base.py
index a25c106290..4568430bfa 100644
--- a/django/db/models/base.py
+++ b/django/db/models/base.py
@@ -23,7 +23,7 @@ from django.db.models import signals
 from django.db.models.loading import register_models, get_model
 from django.utils.translation import ugettext_lazy as _
 from django.utils.functional import curry
-from django.utils.encoding import smart_str, force_unicode
+from django.utils.encoding import smart_bytes, force_text
 from django.utils import six
 from django.utils.text import get_text_list, capfirst
 
@@ -380,11 +380,11 @@ class Model(six.with_metaclass(ModelBase, object)):
             u = six.text_type(self)
         except (UnicodeEncodeError, UnicodeDecodeError):
             u = '[Bad Unicode data]'
-        return smart_str('<%s: %s>' % (self.__class__.__name__, u))
+        return smart_bytes('<%s: %s>' % (self.__class__.__name__, u))
 
     def __str__(self):
         if hasattr(self, '__unicode__'):
-            return force_unicode(self).encode('utf-8')
+            return force_text(self).encode('utf-8')
         return '%s object' % self.__class__.__name__
 
     def __eq__(self, other):
@@ -605,14 +605,14 @@ class Model(six.with_metaclass(ModelBase, object)):
 
     def _get_FIELD_display(self, field):
         value = getattr(self, field.attname)
-        return force_unicode(dict(field.flatchoices).get(value, value), strings_only=True)
+        return force_text(dict(field.flatchoices).get(value, value), strings_only=True)
 
     def _get_next_or_previous_by_FIELD(self, field, is_next, **kwargs):
         if not self.pk:
             raise ValueError("get_next/get_previous cannot be used on unsaved objects.")
         op = is_next and 'gt' or 'lt'
         order = not is_next and '-' or ''
-        param = smart_str(getattr(self, field.attname))
+        param = smart_bytes(getattr(self, field.attname))
         q = Q(**{'%s__%s' % (field.name, op): param})
         q = q|Q(**{field.name: param, 'pk__%s' % op: self.pk})
         qs = self.__class__._default_manager.using(self._state.db).filter(**kwargs).filter(q).order_by('%s%s' % (order, field.name), '%spk' % order)
diff --git a/django/db/models/fields/__init__.py b/django/db/models/fields/__init__.py
index de24a24ed1..2c738d6a20 100644
--- a/django/db/models/fields/__init__.py
+++ b/django/db/models/fields/__init__.py
@@ -19,7 +19,7 @@ from django.utils.functional import curry, total_ordering
 from django.utils.text import capfirst
 from django.utils import timezone
 from django.utils.translation import ugettext_lazy as _
-from django.utils.encoding import smart_unicode, force_unicode
+from django.utils.encoding import smart_text, force_text
 from django.utils.ipv6 import clean_ipv6_address
 from django.utils import six
 
@@ -386,7 +386,7 @@ class Field(object):
         if self.has_default():
             if callable(self.default):
                 return self.default()
-            return force_unicode(self.default, strings_only=True)
+            return force_text(self.default, strings_only=True)
         if (not self.empty_strings_allowed or (self.null and
                    not connection.features.interprets_empty_strings_as_nulls)):
             return None
@@ -404,11 +404,11 @@ class Field(object):
         rel_model = self.rel.to
         if hasattr(self.rel, 'get_related_field'):
             lst = [(getattr(x, self.rel.get_related_field().attname),
-                        smart_unicode(x))
+                        smart_text(x))
                    for x in rel_model._default_manager.complex_filter(
                        self.rel.limit_choices_to)]
         else:
-            lst = [(x._get_pk_val(), smart_unicode(x))
+            lst = [(x._get_pk_val(), smart_text(x))
                    for x in rel_model._default_manager.complex_filter(
                        self.rel.limit_choices_to)]
         return first_choice + lst
@@ -435,7 +435,7 @@ class Field(object):
         Returns a string value of this field from the passed obj.
         This is used by the serialization framework.
         """
-        return smart_unicode(self._get_val_from_obj(obj))
+        return smart_text(self._get_val_from_obj(obj))
 
     def bind(self, fieldmapping, original, bound_field_class):
         return bound_field_class(self, fieldmapping, original)
@@ -629,7 +629,7 @@ class CharField(Field):
     def to_python(self, value):
         if isinstance(value, six.string_types) or value is None:
             return value
-        return smart_unicode(value)
+        return smart_text(value)
 
     def get_prep_value(self, value):
         return self.to_python(value)
@@ -1189,7 +1189,7 @@ class TextField(Field):
     def get_prep_value(self, value):
         if isinstance(value, six.string_types) or value is None:
             return value
-        return smart_unicode(value)
+        return smart_text(value)
 
     def formfield(self, **kwargs):
         defaults = {'widget': forms.Textarea}
diff --git a/django/db/models/fields/files.py b/django/db/models/fields/files.py
index b51ef1d5d6..ad4c36ca0d 100644
--- a/django/db/models/fields/files.py
+++ b/django/db/models/fields/files.py
@@ -8,7 +8,7 @@ from django.core.files.base import File
 from django.core.files.storage import default_storage
 from django.core.files.images import ImageFile
 from django.db.models import signals
-from django.utils.encoding import force_unicode, smart_str
+from django.utils.encoding import force_text, smart_bytes
 from django.utils import six
 from django.utils.translation import ugettext_lazy as _
 
@@ -280,7 +280,7 @@ class FileField(Field):
         setattr(cls, self.name, self.descriptor_class(self))
 
     def get_directory_name(self):
-        return os.path.normpath(force_unicode(datetime.datetime.now().strftime(smart_str(self.upload_to))))
+        return os.path.normpath(force_text(datetime.datetime.now().strftime(smart_bytes(self.upload_to))))
 
     def get_filename(self, filename):
         return os.path.normpath(self.storage.get_valid_name(os.path.basename(filename)))
diff --git a/django/db/models/fields/related.py b/django/db/models/fields/related.py
index bfa8feee9f..eaa62c6061 100644
--- a/django/db/models/fields/related.py
+++ b/django/db/models/fields/related.py
@@ -9,7 +9,7 @@ from django.db.models.related import RelatedObject
 from django.db.models.query import QuerySet
 from django.db.models.query_utils import QueryWrapper
 from django.db.models.deletion import CASCADE
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils import six
 from django.utils.translation import ugettext_lazy as _, string_concat
 from django.utils.functional import curry, cached_property
@@ -999,7 +999,7 @@ class ForeignKey(RelatedField, Field):
             if not self.blank and self.choices:
                 choice_list = self.get_choices_default()
                 if len(choice_list) == 2:
-                    return smart_unicode(choice_list[1][0])
+                    return smart_text(choice_list[1][0])
         return Field.value_to_string(self, obj)
 
     def contribute_to_class(self, cls, name):
@@ -1205,7 +1205,7 @@ class ManyToManyField(RelatedField, Field):
                 choices_list = self.get_choices_default()
                 if len(choices_list) == 1:
                     data = [choices_list[0][0]]
-        return smart_unicode(data)
+        return smart_text(data)
 
     def contribute_to_class(self, cls, name):
         # To support multiple relations to self, it's useful to have a non-None
diff --git a/django/db/models/options.py b/django/db/models/options.py
index 9e8d4120e9..239ad30b06 100644
--- a/django/db/models/options.py
+++ b/django/db/models/options.py
@@ -8,7 +8,7 @@ from django.db.models.fields import AutoField, FieldDoesNotExist
 from django.db.models.fields.proxy import OrderWrt
 from django.db.models.loading import get_models, app_cache_ready
 from django.utils.translation import activate, deactivate_all, get_language, string_concat
-from django.utils.encoding import force_unicode, smart_str
+from django.utils.encoding import force_text, smart_bytes
 from django.utils.datastructures import SortedDict
 from django.utils import six
 
@@ -199,7 +199,7 @@ class Options(object):
         return '<Options for %s>' % self.object_name
 
     def __str__(self):
-        return "%s.%s" % (smart_str(self.app_label), smart_str(self.module_name))
+        return "%s.%s" % (smart_bytes(self.app_label), smart_bytes(self.module_name))
 
     def verbose_name_raw(self):
         """
@@ -209,7 +209,7 @@ class Options(object):
         """
         lang = get_language()
         deactivate_all()
-        raw = force_unicode(self.verbose_name)
+        raw = force_text(self.verbose_name)
         activate(lang)
         return raw
     verbose_name_raw = property(verbose_name_raw)
diff --git a/django/db/models/related.py b/django/db/models/related.py
index 90995d749f..a0dcec7132 100644
--- a/django/db/models/related.py
+++ b/django/db/models/related.py
@@ -1,4 +1,4 @@
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.db.models.fields import BLANK_CHOICE_DASH
 
 class BoundRelatedObject(object):
@@ -34,9 +34,9 @@ class RelatedObject(object):
         if limit_to_currently_related:
             queryset = queryset.complex_filter(
                 {'%s__isnull' % self.parent_model._meta.module_name: False})
-        lst = [(x._get_pk_val(), smart_unicode(x)) for x in queryset]
+        lst = [(x._get_pk_val(), smart_text(x)) for x in queryset]
         return first_choice + lst
-        
+
     def get_db_prep_lookup(self, lookup_type, value, connection, prepared=False):
         # Defer to the actual field definition for db prep
         return self.field.get_db_prep_lookup(lookup_type, value,
diff --git a/django/db/models/sql/query.py b/django/db/models/sql/query.py
index 9cf732f263..69dda228bd 100644
--- a/django/db/models/sql/query.py
+++ b/django/db/models/sql/query.py
@@ -10,7 +10,7 @@ all about the internals of models in order to get the information it needs.
 import copy
 
 from django.utils.datastructures import SortedDict
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils.tree import Node
 from django.utils import six
 from django.db import connections, DEFAULT_DB_ALIAS
@@ -1776,7 +1776,7 @@ class Query(object):
             else:
                 param_iter = iter([])
             for name, entry in select.items():
-                entry = force_unicode(entry)
+                entry = force_text(entry)
                 entry_params = []
                 pos = entry.find("%s")
                 while pos != -1:
diff --git a/django/db/models/sql/subqueries.py b/django/db/models/sql/subqueries.py
index cc7da0eeaf..937505b9b0 100644
--- a/django/db/models/sql/subqueries.py
+++ b/django/db/models/sql/subqueries.py
@@ -10,7 +10,7 @@ from django.db.models.sql.query import Query
 from django.db.models.sql.where import AND, Constraint
 from django.utils.datastructures import SortedDict
 from django.utils.functional import Promise
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils import six
 
 
@@ -105,7 +105,7 @@ class UpdateQuery(Query):
         saving models.
         """
         # Check that no Promise object passes to the query. Refs #10498.
-        values_seq = [(value[0], value[1], force_unicode(value[2]))
+        values_seq = [(value[0], value[1], force_text(value[2]))
                       if isinstance(value[2], Promise) else value
                       for value in values_seq]
         self.values.extend(values_seq)
@@ -171,7 +171,7 @@ class InsertQuery(Query):
             for obj in objs:
                 value = getattr(obj, field.attname)
                 if isinstance(value, Promise):
-                    setattr(obj, field.attname, force_unicode(value))
+                    setattr(obj, field.attname, force_text(value))
         self.objs = objs
         self.raw = raw
 
diff --git a/django/forms/fields.py b/django/forms/fields.py
index cdb1d7be67..7f0d26d1aa 100644
--- a/django/forms/fields.py
+++ b/django/forms/fields.py
@@ -23,7 +23,7 @@ from django.forms.widgets import (TextInput, PasswordInput, HiddenInput,
     NullBooleanSelect, SelectMultiple, DateInput, DateTimeInput, TimeInput,
     SplitDateTimeWidget, SplitHiddenDateTimeWidget, FILE_INPUT_CONTRADICTION)
 from django.utils import formats
-from django.utils.encoding import smart_unicode, force_unicode
+from django.utils.encoding import smart_text, force_text
 from django.utils.ipv6 import clean_ipv6_address
 from django.utils import six
 from django.utils.translation import ugettext_lazy as _
@@ -78,13 +78,13 @@ class Field(object):
         # validators -- List of addtional validators to use
         # localize -- Boolean that specifies if the field should be localized.
         if label is not None:
-            label = smart_unicode(label)
+            label = smart_text(label)
         self.required, self.label, self.initial = required, label, initial
         self.show_hidden_initial = show_hidden_initial
         if help_text is None:
             self.help_text = ''
         else:
-            self.help_text = smart_unicode(help_text)
+            self.help_text = smart_text(help_text)
         widget = widget or self.widget
         if isinstance(widget, type):
             widget = widget()
@@ -195,7 +195,7 @@ class CharField(Field):
         "Returns a Unicode object."
         if value in validators.EMPTY_VALUES:
             return ''
-        return smart_unicode(value)
+        return smart_text(value)
 
     def widget_attrs(self, widget):
         attrs = super(CharField, self).widget_attrs(widget)
@@ -288,7 +288,7 @@ class DecimalField(Field):
             return None
         if self.localize:
             value = formats.sanitize_separators(value)
-        value = smart_unicode(value).strip()
+        value = smart_text(value).strip()
         try:
             value = Decimal(value)
         except DecimalException:
@@ -333,7 +333,7 @@ class BaseTemporalField(Field):
 
     def to_python(self, value):
         # Try to coerce the value to unicode.
-        unicode_value = force_unicode(value, strings_only=True)
+        unicode_value = force_text(value, strings_only=True)
         if isinstance(unicode_value, six.text_type):
             value = unicode_value.strip()
         # If unicode, try to strptime against each input format.
@@ -692,7 +692,7 @@ class ChoiceField(Field):
         "Returns a Unicode object."
         if value in validators.EMPTY_VALUES:
             return ''
-        return smart_unicode(value)
+        return smart_text(value)
 
     def validate(self, value):
         """
@@ -708,10 +708,10 @@ class ChoiceField(Field):
             if isinstance(v, (list, tuple)):
                 # This is an optgroup, so look inside the group for options
                 for k2, v2 in v:
-                    if value == smart_unicode(k2):
+                    if value == smart_text(k2):
                         return True
             else:
-                if value == smart_unicode(k):
+                if value == smart_text(k):
                     return True
         return False
 
@@ -752,7 +752,7 @@ class MultipleChoiceField(ChoiceField):
             return []
         elif not isinstance(value, (list, tuple)):
             raise ValidationError(self.error_messages['invalid_list'])
-        return [smart_unicode(val) for val in value]
+        return [smart_text(val) for val in value]
 
     def validate(self, value):
         """
diff --git a/django/forms/forms.py b/django/forms/forms.py
index 0f3fdb2e40..45b758202a 100644
--- a/django/forms/forms.py
+++ b/django/forms/forms.py
@@ -12,7 +12,7 @@ from django.forms.util import flatatt, ErrorDict, ErrorList
 from django.forms.widgets import Media, media_property, TextInput, Textarea
 from django.utils.datastructures import SortedDict
 from django.utils.html import conditional_escape, format_html
-from django.utils.encoding import StrAndUnicode, smart_unicode, force_unicode
+from django.utils.encoding import StrAndUnicode, smart_text, force_text
 from django.utils.safestring import mark_safe
 from django.utils import six
 
@@ -150,7 +150,7 @@ class BaseForm(StrAndUnicode):
             bf_errors = self.error_class([conditional_escape(error) for error in bf.errors]) # Escape and cache in local variable.
             if bf.is_hidden:
                 if bf_errors:
-                    top_errors.extend(['(Hidden field %s) %s' % (name, force_unicode(e)) for e in bf_errors])
+                    top_errors.extend(['(Hidden field %s) %s' % (name, force_text(e)) for e in bf_errors])
                 hidden_fields.append(six.text_type(bf))
             else:
                 # Create a 'class="..."' atribute if the row should have any
@@ -160,10 +160,10 @@ class BaseForm(StrAndUnicode):
                     html_class_attr = ' class="%s"' % css_classes
 
                 if errors_on_separate_row and bf_errors:
-                    output.append(error_row % force_unicode(bf_errors))
+                    output.append(error_row % force_text(bf_errors))
 
                 if bf.label:
-                    label = conditional_escape(force_unicode(bf.label))
+                    label = conditional_escape(force_text(bf.label))
                     # Only add the suffix if the label does not end in
                     # punctuation.
                     if self.label_suffix:
@@ -174,20 +174,20 @@ class BaseForm(StrAndUnicode):
                     label = ''
 
                 if field.help_text:
-                    help_text = help_text_html % force_unicode(field.help_text)
+                    help_text = help_text_html % force_text(field.help_text)
                 else:
                     help_text = ''
 
                 output.append(normal_row % {
-                    'errors': force_unicode(bf_errors),
-                    'label': force_unicode(label),
+                    'errors': force_text(bf_errors),
+                    'label': force_text(label),
                     'field': six.text_type(bf),
                     'help_text': help_text,
                     'html_class_attr': html_class_attr
                 })
 
         if top_errors:
-            output.insert(0, error_row % force_unicode(top_errors))
+            output.insert(0, error_row % force_text(top_errors))
 
         if hidden_fields: # Insert any hidden fields in the last row.
             str_hidden = ''.join(hidden_fields)
@@ -535,8 +535,8 @@ class BoundField(StrAndUnicode):
         associated Form has specified auto_id. Returns an empty string otherwise.
         """
         auto_id = self.form.auto_id
-        if auto_id and '%s' in smart_unicode(auto_id):
-            return smart_unicode(auto_id) % self.html_name
+        if auto_id and '%s' in smart_text(auto_id):
+            return smart_text(auto_id) % self.html_name
         elif auto_id:
             return self.html_name
         return ''
diff --git a/django/forms/models.py b/django/forms/models.py
index a2b5448b14..80d2a6536f 100644
--- a/django/forms/models.py
+++ b/django/forms/models.py
@@ -13,7 +13,7 @@ from django.forms.formsets import BaseFormSet, formset_factory
 from django.forms.util import ErrorList
 from django.forms.widgets import (SelectMultiple, HiddenInput,
     MultipleHiddenInput, media_property)
-from django.utils.encoding import smart_unicode, force_unicode
+from django.utils.encoding import smart_text, force_text
 from django.utils.datastructures import SortedDict
 from django.utils import six
 from django.utils.text import get_text_list, capfirst
@@ -875,7 +875,7 @@ class InlineForeignKeyField(Field):
             orig = getattr(self.parent_instance, self.to_field)
         else:
             orig = self.parent_instance.pk
-        if force_unicode(value) != force_unicode(orig):
+        if force_text(value) != force_text(orig):
             raise ValidationError(self.error_messages['invalid_choice'])
         return self.parent_instance
 
@@ -953,7 +953,7 @@ class ModelChoiceField(ChoiceField):
         generate the labels for the choices presented by this object. Subclasses
         can override this method to customize the display of the choices.
         """
-        return smart_unicode(obj)
+        return smart_text(obj)
 
     def _get_choices(self):
         # If self._choices is set, then somebody must have manually set
@@ -1025,9 +1025,9 @@ class ModelMultipleChoiceField(ModelChoiceField):
             except ValueError:
                 raise ValidationError(self.error_messages['invalid_pk_value'] % pk)
         qs = self.queryset.filter(**{'%s__in' % key: value})
-        pks = set([force_unicode(getattr(o, key)) for o in qs])
+        pks = set([force_text(getattr(o, key)) for o in qs])
         for val in value:
-            if force_unicode(val) not in pks:
+            if force_text(val) not in pks:
                 raise ValidationError(self.error_messages['invalid_choice'] % val)
         # Since this overrides the inherited ModelChoiceField.clean
         # we run custom validators here
diff --git a/django/forms/util.py b/django/forms/util.py
index 8cf03d38af..cd6b52df6f 100644
--- a/django/forms/util.py
+++ b/django/forms/util.py
@@ -2,7 +2,7 @@ from __future__ import unicode_literals
 
 from django.conf import settings
 from django.utils.html import format_html, format_html_join
-from django.utils.encoding import StrAndUnicode, force_unicode
+from django.utils.encoding import StrAndUnicode, force_text
 from django.utils.safestring import mark_safe
 from django.utils import timezone
 from django.utils.translation import ugettext_lazy as _
@@ -35,12 +35,12 @@ class ErrorDict(dict, StrAndUnicode):
         if not self: return ''
         return format_html('<ul class="errorlist">{0}</ul>',
                            format_html_join('', '<li>{0}{1}</li>',
-                                            ((k, force_unicode(v))
+                                            ((k, force_text(v))
                                              for k, v in self.items())
                            ))
 
     def as_text(self):
-        return '\n'.join(['* %s\n%s' % (k, '\n'.join(['  * %s' % force_unicode(i) for i in v])) for k, v in self.items()])
+        return '\n'.join(['* %s\n%s' % (k, '\n'.join(['  * %s' % force_text(i) for i in v])) for k, v in self.items()])
 
 class ErrorList(list, StrAndUnicode):
     """
@@ -53,16 +53,16 @@ class ErrorList(list, StrAndUnicode):
         if not self: return ''
         return format_html('<ul class="errorlist">{0}</ul>',
                            format_html_join('', '<li>{0}</li>',
-                                            ((force_unicode(e),) for e in self)
+                                            ((force_text(e),) for e in self)
                                             )
                            )
 
     def as_text(self):
         if not self: return ''
-        return '\n'.join(['* %s' % force_unicode(e) for e in self])
+        return '\n'.join(['* %s' % force_text(e) for e in self])
 
     def __repr__(self):
-        return repr([force_unicode(e) for e in self])
+        return repr([force_text(e) for e in self])
 
 # Utilities for time zone support in DateTimeField et al.
 
diff --git a/django/forms/widgets.py b/django/forms/widgets.py
index 13b7d8e7f6..be9ac8eb8f 100644
--- a/django/forms/widgets.py
+++ b/django/forms/widgets.py
@@ -17,7 +17,7 @@ from django.forms.util import flatatt, to_current_timezone
 from django.utils.datastructures import MultiValueDict, MergeDict
 from django.utils.html import conditional_escape, format_html, format_html_join
 from django.utils.translation import ugettext, ugettext_lazy
-from django.utils.encoding import StrAndUnicode, force_unicode
+from django.utils.encoding import StrAndUnicode, force_text
 from django.utils.safestring import mark_safe
 from django.utils import six
 from django.utils import datetime_safe, formats
@@ -223,7 +223,7 @@ class Widget(six.with_metaclass(MediaDefiningClass)):
             initial_value = ''
         else:
             initial_value = initial
-        if force_unicode(initial_value) != force_unicode(data_value):
+        if force_text(initial_value) != force_text(data_value):
             return True
         return False
 
@@ -257,7 +257,7 @@ class Input(Widget):
         final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
         if value != '':
             # Only add the 'value' attribute if a value is non-empty.
-            final_attrs['value'] = force_unicode(self._format_value(value))
+            final_attrs['value'] = force_text(self._format_value(value))
         return format_html('<input{0} />', flatatt(final_attrs))
 
 class TextInput(Input):
@@ -294,7 +294,7 @@ class MultipleHiddenInput(HiddenInput):
         id_ = final_attrs.get('id', None)
         inputs = []
         for i, v in enumerate(value):
-            input_attrs = dict(value=force_unicode(v), **final_attrs)
+            input_attrs = dict(value=force_text(v), **final_attrs)
             if id_:
                 # An ID attribute was given. Add a numeric index as a suffix
                 # so that the inputs don't all have the same ID attribute.
@@ -361,7 +361,7 @@ class ClearableFileInput(FileInput):
             template = self.template_with_initial
             substitutions['initial'] = format_html('<a href="{0}">{1}</a>',
                                                    value.url,
-                                                   force_unicode(value))
+                                                   force_text(value))
             if not self.is_required:
                 checkbox_name = self.clear_checkbox_name(name)
                 checkbox_id = self.clear_checkbox_id(checkbox_name)
@@ -398,7 +398,7 @@ class Textarea(Widget):
         final_attrs = self.build_attrs(attrs, name=name)
         return format_html('<textarea{0}>{1}</textarea>',
                            flatatt(final_attrs),
-                           force_unicode(value))
+                           force_text(value))
 
 class DateInput(Input):
     input_type = 'text'
@@ -515,7 +515,7 @@ class CheckboxInput(Widget):
             final_attrs['checked'] = 'checked'
         if not (value is True or value is False or value is None or value == ''):
             # Only add the 'value' attribute if a value is non-empty.
-            final_attrs['value'] = force_unicode(value)
+            final_attrs['value'] = force_text(value)
         return format_html('<input{0} />', flatatt(final_attrs))
 
     def value_from_datadict(self, data, files, name):
@@ -556,7 +556,7 @@ class Select(Widget):
         return mark_safe('\n'.join(output))
 
     def render_option(self, selected_choices, option_value, option_label):
-        option_value = force_unicode(option_value)
+        option_value = force_text(option_value)
         if option_value in selected_choices:
             selected_html = mark_safe(' selected="selected"')
             if not self.allow_multiple_selected:
@@ -567,15 +567,15 @@ class Select(Widget):
         return format_html('<option value="{0}"{1}>{2}</option>',
                            option_value,
                            selected_html,
-                           force_unicode(option_label))
+                           force_text(option_label))
 
     def render_options(self, choices, selected_choices):
         # Normalize to strings.
-        selected_choices = set(force_unicode(v) for v in selected_choices)
+        selected_choices = set(force_text(v) for v in selected_choices)
         output = []
         for option_value, option_label in chain(self.choices, choices):
             if isinstance(option_label, (list, tuple)):
-                output.append(format_html('<optgroup label="{0}">', force_unicode(option_value)))
+                output.append(format_html('<optgroup label="{0}">', force_text(option_value)))
                 for option in option_label:
                     output.append(self.render_option(selected_choices, *option))
                 output.append('</optgroup>')
@@ -643,8 +643,8 @@ class SelectMultiple(Select):
             data = []
         if len(initial) != len(data):
             return True
-        initial_set = set([force_unicode(value) for value in initial])
-        data_set = set([force_unicode(value) for value in data])
+        initial_set = set([force_text(value) for value in initial])
+        data_set = set([force_text(value) for value in data])
         return data_set != initial_set
 
 class RadioInput(SubWidget):
@@ -656,8 +656,8 @@ class RadioInput(SubWidget):
     def __init__(self, name, value, attrs, choice, index):
         self.name, self.value = name, value
         self.attrs = attrs
-        self.choice_value = force_unicode(choice[0])
-        self.choice_label = force_unicode(choice[1])
+        self.choice_value = force_text(choice[0])
+        self.choice_label = force_text(choice[1])
         self.index = index
 
     def __unicode__(self):
@@ -671,7 +671,7 @@ class RadioInput(SubWidget):
             label_for = format_html(' for="{0}_{1}"', self.attrs['id'], self.index)
         else:
             label_for = ''
-        choice_label = force_unicode(self.choice_label)
+        choice_label = force_text(self.choice_label)
         return format_html('<label{0}>{1} {2}</label>', label_for, self.tag(), choice_label)
 
     def is_checked(self):
@@ -709,7 +709,7 @@ class RadioFieldRenderer(StrAndUnicode):
         """Outputs a <ul> for this set of radio fields."""
         return format_html('<ul>\n{0}\n</ul>',
                            format_html_join('\n', '<li>{0}</li>',
-                                            [(force_unicode(w),) for w in self]
+                                            [(force_text(w),) for w in self]
                                             ))
 
 class RadioSelect(Select):
@@ -729,7 +729,7 @@ class RadioSelect(Select):
     def get_renderer(self, name, value, attrs=None, choices=()):
         """Returns an instance of the renderer."""
         if value is None: value = ''
-        str_value = force_unicode(value) # Normalize to string.
+        str_value = force_text(value) # Normalize to string.
         final_attrs = self.build_attrs(attrs)
         choices = list(chain(self.choices, choices))
         return self.renderer(name, str_value, final_attrs, choices)
@@ -753,7 +753,7 @@ class CheckboxSelectMultiple(SelectMultiple):
         final_attrs = self.build_attrs(attrs, name=name)
         output = ['<ul>']
         # Normalize to strings
-        str_values = set([force_unicode(v) for v in value])
+        str_values = set([force_text(v) for v in value])
         for i, (option_value, option_label) in enumerate(chain(self.choices, choices)):
             # If an ID attribute was given, add a numeric index as a suffix,
             # so that the checkboxes don't all have the same ID attribute.
@@ -764,9 +764,9 @@ class CheckboxSelectMultiple(SelectMultiple):
                 label_for = ''
 
             cb = CheckboxInput(final_attrs, check_test=lambda value: value in str_values)
-            option_value = force_unicode(option_value)
+            option_value = force_text(option_value)
             rendered_cb = cb.render(name, option_value)
-            option_label = force_unicode(option_label)
+            option_label = force_text(option_label)
             output.append(format_html('<li><label{0}>{1} {2}</label></li>',
                                       label_for, rendered_cb, option_label))
         output.append('</ul>')
diff --git a/django/http/__init__.py b/django/http/__init__.py
index 4c2db74890..b23304f346 100644
--- a/django/http/__init__.py
+++ b/django/http/__init__.py
@@ -61,14 +61,14 @@ else:
         if not _cookie_allows_colon_in_names:
             def load(self, rawdata):
                 self.bad_cookies = set()
-                super(SimpleCookie, self).load(smart_str(rawdata))
+                super(SimpleCookie, self).load(smart_bytes(rawdata))
                 for key in self.bad_cookies:
                     del self[key]
 
             # override private __set() method:
             # (needed for using our Morsel, and for laxness with CookieError
             def _BaseCookie__set(self, key, real_value, coded_value):
-                key = smart_str(key)
+                key = smart_bytes(key)
                 try:
                     M = self.get(key, Morsel())
                     M.set(key, real_value, coded_value)
@@ -85,7 +85,7 @@ from django.core.files import uploadhandler
 from django.http.multipartparser import MultiPartParser
 from django.http.utils import *
 from django.utils.datastructures import MultiValueDict, ImmutableList
-from django.utils.encoding import smart_str, iri_to_uri, force_unicode
+from django.utils.encoding import smart_bytes, iri_to_uri, force_text
 from django.utils.http import cookie_date
 from django.utils import six
 from django.utils import timezone
@@ -137,7 +137,7 @@ def build_request_repr(request, path_override=None, GET_override=None,
     except:
         meta = '<could not parse>'
     path = path_override if path_override is not None else request.path
-    return smart_str('<%s\npath:%s,\nGET:%s,\nPOST:%s,\nCOOKIES:%s,\nMETA:%s>' %
+    return smart_bytes('<%s\npath:%s,\nGET:%s,\nPOST:%s,\nCOOKIES:%s,\nMETA:%s>' %
                      (request.__class__.__name__,
                       path,
                       six.text_type(get),
@@ -385,8 +385,8 @@ class QueryDict(MultiValueDict):
             encoding = settings.DEFAULT_CHARSET
         self.encoding = encoding
         for key, value in parse_qsl((query_string or ''), True): # keep_blank_values=True
-            self.appendlist(force_unicode(key, encoding, errors='replace'),
-                            force_unicode(value, encoding, errors='replace'))
+            self.appendlist(force_text(key, encoding, errors='replace'),
+                            force_text(value, encoding, errors='replace'))
         self._mutable = mutable
 
     def _get_encoding(self):
@@ -481,13 +481,13 @@ class QueryDict(MultiValueDict):
         """
         output = []
         if safe:
-            safe = smart_str(safe, self.encoding)
+            safe = smart_bytes(safe, self.encoding)
             encode = lambda k, v: '%s=%s' % ((quote(k, safe), quote(v, safe)))
         else:
             encode = lambda k, v: urlencode({k: v})
         for k, list_ in self.lists():
-            k = smart_str(k, self.encoding)
-            output.extend([encode(k, smart_str(v, self.encoding))
+            k = smart_bytes(k, self.encoding)
+            output.extend([encode(k, smart_bytes(v, self.encoding))
                            for v in list_])
         return '&'.join(output)
 
@@ -648,7 +648,7 @@ class HttpResponse(object):
     def _get_content(self):
         if self.has_header('Content-Encoding'):
             return b''.join([str(e) for e in self._container])
-        return b''.join([smart_str(e, self._charset) for e in self._container])
+        return b''.join([smart_bytes(e, self._charset) for e in self._container])
 
     def _set_content(self, value):
         if hasattr(value, '__iter__'):
@@ -698,7 +698,7 @@ class HttpResponseRedirectBase(HttpResponse):
             raise SuspiciousOperation("Unsafe redirect to URL with protocol '%s'" % parsed.scheme)
         super(HttpResponseRedirectBase, self).__init__()
         self['Location'] = iri_to_uri(redirect_to)
-    
+
 class HttpResponseRedirect(HttpResponseRedirectBase):
     status_code = 302
 
@@ -735,7 +735,7 @@ def get_host(request):
     return request.get_host()
 
 # It's neither necessary nor appropriate to use
-# django.utils.encoding.smart_unicode for parsing URLs and form inputs. Thus,
+# django.utils.encoding.smart_text for parsing URLs and form inputs. Thus,
 # this slightly more restricted function.
 def str_to_unicode(s, encoding):
     """
diff --git a/django/http/multipartparser.py b/django/http/multipartparser.py
index 0e28a55c3a..1987ee53bc 100644
--- a/django/http/multipartparser.py
+++ b/django/http/multipartparser.py
@@ -10,7 +10,7 @@ import cgi
 from django.conf import settings
 from django.core.exceptions import SuspiciousOperation
 from django.utils.datastructures import MultiValueDict
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils import six
 from django.utils.text import unescape_entities
 from django.core.files.uploadhandler import StopUpload, SkipFile, StopFutureHandlers
@@ -151,7 +151,7 @@ class MultiPartParser(object):
                 transfer_encoding = meta_data.get('content-transfer-encoding')
                 if transfer_encoding is not None:
                     transfer_encoding = transfer_encoding[0].strip()
-                field_name = force_unicode(field_name, encoding, errors='replace')
+                field_name = force_text(field_name, encoding, errors='replace')
 
                 if item_type == FIELD:
                     # This is a post field, we can just set it in the post
@@ -165,13 +165,13 @@ class MultiPartParser(object):
                         data = field_stream.read()
 
                     self._post.appendlist(field_name,
-                                          force_unicode(data, encoding, errors='replace'))
+                                          force_text(data, encoding, errors='replace'))
                 elif item_type == FILE:
                     # This is a file, use the handler...
                     file_name = disposition.get('filename')
                     if not file_name:
                         continue
-                    file_name = force_unicode(file_name, encoding, errors='replace')
+                    file_name = force_text(file_name, encoding, errors='replace')
                     file_name = self.IE_sanitize(unescape_entities(file_name))
 
                     content_type = meta_data.get('content-type', ('',))[0].strip()
@@ -245,7 +245,7 @@ class MultiPartParser(object):
             file_obj = handler.file_complete(counters[i])
             if file_obj:
                 # If it returns a file object, then set the files dict.
-                self._files.appendlist(force_unicode(old_field_name,
+                self._files.appendlist(force_text(old_field_name,
                                                      self._encoding,
                                                      errors='replace'),
                                        file_obj)
diff --git a/django/template/base.py b/django/template/base.py
index d5c2438500..661d8c092a 100644
--- a/django/template/base.py
+++ b/django/template/base.py
@@ -11,7 +11,7 @@ from django.utils.importlib import import_module
 from django.utils.itercompat import is_iterable
 from django.utils.text import (smart_split, unescape_string_literal,
     get_text_list)
-from django.utils.encoding import smart_unicode, force_unicode, smart_str
+from django.utils.encoding import smart_text, force_text, smart_bytes
 from django.utils.translation import ugettext_lazy, pgettext_lazy
 from django.utils.safestring import (SafeData, EscapeData, mark_safe,
     mark_for_escaping)
@@ -89,7 +89,7 @@ class VariableDoesNotExist(Exception):
         return six.text_type(self).encode('utf-8')
 
     def __unicode__(self):
-        return self.msg % tuple([force_unicode(p, errors='replace')
+        return self.msg % tuple([force_text(p, errors='replace')
                                  for p in self.params])
 
 class InvalidTemplateLibrary(Exception):
@@ -117,7 +117,7 @@ class Template(object):
     def __init__(self, template_string, origin=None,
                  name='<Unknown Template>'):
         try:
-            template_string = smart_unicode(template_string)
+            template_string = smart_text(template_string)
         except UnicodeDecodeError:
             raise TemplateEncodingError("Templates can only be constructed "
                                         "from unicode or UTF-8 strings.")
@@ -831,7 +831,7 @@ class NodeList(list):
                 bit = self.render_node(node, context)
             else:
                 bit = node
-            bits.append(force_unicode(bit))
+            bits.append(force_text(bit))
         return mark_safe(''.join(bits))
 
     def get_nodes_by_type(self, nodetype):
@@ -849,7 +849,7 @@ class TextNode(Node):
         self.s = s
 
     def __repr__(self):
-        return "<Text Node: '%s'>" % smart_str(self.s[:25], 'ascii',
+        return "<Text Node: '%s'>" % smart_bytes(self.s[:25], 'ascii',
                 errors='replace')
 
     def render(self, context):
@@ -863,7 +863,7 @@ def _render_value_in_context(value, context):
     """
     value = template_localtime(value, use_tz=context.use_tz)
     value = localize(value, use_l10n=context.use_l10n)
-    value = force_unicode(value)
+    value = force_text(value)
     if ((context.autoescape and not isinstance(value, SafeData)) or
             isinstance(value, EscapeData)):
         return escape(value)
diff --git a/django/template/debug.py b/django/template/debug.py
index 61674034d6..c7ac007b48 100644
--- a/django/template/debug.py
+++ b/django/template/debug.py
@@ -1,5 +1,5 @@
 from django.template.base import Lexer, Parser, tag_re, NodeList, VariableNode, TemplateSyntaxError
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils.html import escape
 from django.utils.safestring import SafeData, EscapeData
 from django.utils.formats import localize
@@ -84,7 +84,7 @@ class DebugVariableNode(VariableNode):
             output = self.filter_expression.resolve(context)
             output = template_localtime(output, use_tz=context.use_tz)
             output = localize(output, use_l10n=context.use_l10n)
-            output = force_unicode(output)
+            output = force_text(output)
         except UnicodeDecodeError:
             return ''
         except Exception as e:
diff --git a/django/template/defaultfilters.py b/django/template/defaultfilters.py
index fa799cd46f..16801fd573 100644
--- a/django/template/defaultfilters.py
+++ b/django/template/defaultfilters.py
@@ -12,7 +12,7 @@ from django.template.base import Variable, Library, VariableDoesNotExist
 from django.conf import settings
 from django.utils import formats
 from django.utils.dateformat import format, time_format
-from django.utils.encoding import force_unicode, iri_to_uri
+from django.utils.encoding import force_text, iri_to_uri
 from django.utils.html import (conditional_escape, escapejs, fix_ampersands,
     escape, urlize as urlize_impl, linebreaks, strip_tags)
 from django.utils.http import urlquote
@@ -38,7 +38,7 @@ def stringfilter(func):
     def _dec(*args, **kwargs):
         if args:
             args = list(args)
-            args[0] = force_unicode(args[0])
+            args[0] = force_text(args[0])
             if (isinstance(args[0], SafeData) and
                 getattr(_dec._decorated_function, 'is_safe', False)):
                 return mark_safe(func(*args, **kwargs))
@@ -139,7 +139,7 @@ def floatformat(text, arg=-1):
     """
 
     try:
-        input_val = force_unicode(text)
+        input_val = force_text(text)
         d = Decimal(input_val)
     except UnicodeEncodeError:
         return ''
@@ -147,7 +147,7 @@ def floatformat(text, arg=-1):
         if input_val in special_floats:
             return input_val
         try:
-            d = Decimal(force_unicode(float(text)))
+            d = Decimal(force_text(float(text)))
         except (ValueError, InvalidOperation, TypeError, UnicodeEncodeError):
             return ''
     try:
@@ -192,7 +192,7 @@ def floatformat(text, arg=-1):
 @stringfilter
 def iriencode(value):
     """Escapes an IRI value for use in a URL."""
-    return force_unicode(iri_to_uri(value))
+    return force_text(iri_to_uri(value))
 
 @register.filter(is_safe=True, needs_autoescape=True)
 @stringfilter
@@ -462,7 +462,7 @@ def safeseq(value):
     individually, as safe, after converting them to unicode. Returns a list
     with the results.
     """
-    return [mark_safe(force_unicode(obj)) for obj in value]
+    return [mark_safe(force_text(obj)) for obj in value]
 
 @register.filter(is_safe=True)
 @stringfilter
@@ -521,7 +521,7 @@ def join(value, arg, autoescape=None):
     """
     Joins a list with a string, like Python's ``str.join(list)``.
     """
-    value = map(force_unicode, value)
+    value = map(force_text, value)
     if autoescape:
         value = [conditional_escape(v) for v in value]
     try:
@@ -661,7 +661,7 @@ def unordered_list(value, autoescape=None):
                 sublist = '\n%s<ul>\n%s\n%s</ul>\n%s' % (indent, sublist,
                                                          indent, indent)
             output.append('%s<li>%s%s</li>' % (indent,
-                    escaper(force_unicode(title)), sublist))
+                    escaper(force_text(title)), sublist))
             i += 1
         return '\n'.join(output)
     value, converted = convert_old_style_list(value)
@@ -901,4 +901,4 @@ def pprint(value):
     try:
         return pformat(value)
     except Exception as e:
-        return "Error in formatting: %s" % force_unicode(e, errors="replace")
+        return "Error in formatting: %s" % force_text(e, errors="replace")
diff --git a/django/template/defaulttags.py b/django/template/defaulttags.py
index 7a00d60361..dca47a3da8 100644
--- a/django/template/defaulttags.py
+++ b/django/template/defaulttags.py
@@ -14,7 +14,7 @@ from django.template.base import (Node, NodeList, Template, Context, Library,
     VARIABLE_ATTRIBUTE_SEPARATOR, get_library, token_kwargs, kwarg_re)
 from django.template.smartif import IfParser, Literal
 from django.template.defaultfilters import date
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.safestring import mark_safe
 from django.utils.html import format_html
 from django.utils import six
@@ -104,7 +104,7 @@ class FirstOfNode(Node):
         for var in self.vars:
             value = var.resolve(context, True)
             if value:
-                return smart_unicode(value)
+                return smart_text(value)
         return ''
 
 class ForNode(Node):
@@ -393,7 +393,7 @@ class URLNode(Node):
     def render(self, context):
         from django.core.urlresolvers import reverse, NoReverseMatch
         args = [arg.resolve(context) for arg in self.args]
-        kwargs = dict([(smart_unicode(k, 'ascii'), v.resolve(context))
+        kwargs = dict([(smart_text(k, 'ascii'), v.resolve(context))
                        for k, v in self.kwargs.items()])
 
         view_name = self.view_name.resolve(context)
diff --git a/django/templatetags/l10n.py b/django/templatetags/l10n.py
index 1eac1de071..667de2470e 100644
--- a/django/templatetags/l10n.py
+++ b/django/templatetags/l10n.py
@@ -1,7 +1,7 @@
 from django.template import Node
 from django.template import TemplateSyntaxError, Library
 from django.utils import formats
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 
 register = Library()
 
@@ -11,7 +11,7 @@ def localize(value):
     Forces a value to be rendered as a localized value,
     regardless of the value of ``settings.USE_L10N``.
     """
-    return force_unicode(formats.localize(value, use_l10n=True))
+    return force_text(formats.localize(value, use_l10n=True))
 
 @register.filter(is_safe=False)
 def unlocalize(value):
@@ -19,7 +19,7 @@ def unlocalize(value):
     Forces a value to be rendered as a non-localized value,
     regardless of the value of ``settings.USE_L10N``.
     """
-    return force_unicode(value)
+    return force_text(value)
 
 class LocalizeNode(Node):
     def __init__(self, nodelist, use_l10n):
diff --git a/django/test/client.py b/django/test/client.py
index a18b7f8853..ef80a7129a 100644
--- a/django/test/client.py
+++ b/django/test/client.py
@@ -19,7 +19,7 @@ from django.http import SimpleCookie, HttpRequest, QueryDict
 from django.template import TemplateDoesNotExist
 from django.test import signals
 from django.utils.functional import curry
-from django.utils.encoding import smart_str
+from django.utils.encoding import smart_bytes
 from django.utils.http import urlencode
 from django.utils.importlib import import_module
 from django.utils.itercompat import is_iterable
@@ -108,7 +108,7 @@ def encode_multipart(boundary, data):
     as an application/octet-stream; otherwise, str(value) will be sent.
     """
     lines = []
-    to_str = lambda s: smart_str(s, settings.DEFAULT_CHARSET)
+    to_str = lambda s: smart_bytes(s, settings.DEFAULT_CHARSET)
 
     # Not by any means perfect, but good enough for our purposes.
     is_file = lambda thing: hasattr(thing, "read") and callable(thing.read)
@@ -145,7 +145,7 @@ def encode_multipart(boundary, data):
     return '\r\n'.join(lines)
 
 def encode_file(boundary, key, file):
-    to_str = lambda s: smart_str(s, settings.DEFAULT_CHARSET)
+    to_str = lambda s: smart_bytes(s, settings.DEFAULT_CHARSET)
     content_type = mimetypes.guess_type(file.name)[0]
     if content_type is None:
         content_type = 'application/octet-stream'
@@ -220,7 +220,7 @@ class RequestFactory(object):
                 charset = match.group(1)
             else:
                 charset = settings.DEFAULT_CHARSET
-            return smart_str(data, encoding=charset)
+            return smart_bytes(data, encoding=charset)
 
     def _get_path(self, parsed):
         # If there are parameters, add them
@@ -291,7 +291,7 @@ class RequestFactory(object):
     def generic(self, method, path,
                 data='', content_type='application/octet-stream', **extra):
         parsed = urlparse(path)
-        data = smart_str(data, settings.DEFAULT_CHARSET)
+        data = smart_bytes(data, settings.DEFAULT_CHARSET)
         r = {
             'PATH_INFO':      self._get_path(parsed),
             'QUERY_STRING':   parsed[4],
diff --git a/django/test/html.py b/django/test/html.py
index 2a1421bf17..143c3728be 100644
--- a/django/test/html.py
+++ b/django/test/html.py
@@ -5,7 +5,7 @@ Comparing two html documents.
 from __future__ import unicode_literals
 
 import re
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils.html_parser import HTMLParser, HTMLParseError
 from django.utils import six
 
@@ -25,7 +25,7 @@ class Element(object):
 
     def append(self, element):
         if isinstance(element, six.string_types):
-            element = force_unicode(element)
+            element = force_text(element)
             element = normalize_whitespace(element)
             if self.children:
                 if isinstance(self.children[-1], six.string_types):
diff --git a/django/test/testcases.py b/django/test/testcases.py
index b60188bf30..3a0dc760c6 100644
--- a/django/test/testcases.py
+++ b/django/test/testcases.py
@@ -41,7 +41,7 @@ from django.test.utils import (get_warnings_state, restore_warnings_state,
     override_settings)
 from django.test.utils import ContextList
 from django.utils import unittest as ut2
-from django.utils.encoding import smart_str, force_unicode
+from django.utils.encoding import smart_bytes, force_text
 from django.utils import six
 from django.utils.unittest.util import safe_repr
 from django.views.static import serve
@@ -398,7 +398,7 @@ class SimpleTestCase(ut2.TestCase):
                 optional.clean(input)
             self.assertEqual(context_manager.exception.messages, errors)
         # test required inputs
-        error_required = [force_unicode(required.error_messages['required'])]
+        error_required = [force_text(required.error_messages['required'])]
         for e in EMPTY_VALUES:
             with self.assertRaises(ValidationError) as context_manager:
                 required.clean(e)
@@ -647,7 +647,7 @@ class TransactionTestCase(SimpleTestCase):
         self.assertEqual(response.status_code, status_code,
             msg_prefix + "Couldn't retrieve content: Response code was %d"
             " (expected %d)" % (response.status_code, status_code))
-        enc_text = smart_str(text, response._charset)
+        enc_text = smart_bytes(text, response._charset)
         content = response.content
         if html:
             content = assert_and_parse_html(self, content, None,
@@ -683,7 +683,7 @@ class TransactionTestCase(SimpleTestCase):
         self.assertEqual(response.status_code, status_code,
             msg_prefix + "Couldn't retrieve content: Response code was %d"
             " (expected %d)" % (response.status_code, status_code))
-        enc_text = smart_str(text, response._charset)
+        enc_text = smart_bytes(text, response._charset)
         content = response.content
         if html:
             content = assert_and_parse_html(self, content, None,
diff --git a/django/utils/_os.py b/django/utils/_os.py
index 884689fefc..82dccd0efe 100644
--- a/django/utils/_os.py
+++ b/django/utils/_os.py
@@ -1,7 +1,7 @@
 import os
 import stat
 from os.path import join, normcase, normpath, abspath, isabs, sep
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 
 try:
     WindowsError = WindowsError
@@ -37,8 +37,8 @@ def safe_join(base, *paths):
     The final path must be located inside of the base path component (otherwise
     a ValueError is raised).
     """
-    base = force_unicode(base)
-    paths = [force_unicode(p) for p in paths]
+    base = force_text(base)
+    paths = [force_text(p) for p in paths]
     final_path = abspathu(join(base, *paths))
     base_path = abspathu(base)
     base_path_len = len(base_path)
diff --git a/django/utils/cache.py b/django/utils/cache.py
index 8b81a2ffa2..42b0de4ce6 100644
--- a/django/utils/cache.py
+++ b/django/utils/cache.py
@@ -23,7 +23,7 @@ import time
 
 from django.conf import settings
 from django.core.cache import get_cache
-from django.utils.encoding import iri_to_uri, force_unicode
+from django.utils.encoding import iri_to_uri, force_text
 from django.utils.http import http_date
 from django.utils.timezone import get_current_timezone_name
 from django.utils.translation import get_language
@@ -169,7 +169,7 @@ def _i18n_cache_key_suffix(request, cache_key):
         # Windows is known to use non-standard, locale-dependant names.
         # User-defined tzinfo classes may return absolutely anything.
         # Hence this paranoid conversion to create a valid cache key.
-        tz_name = force_unicode(get_current_timezone_name(), errors='ignore')
+        tz_name = force_text(get_current_timezone_name(), errors='ignore')
         cache_key += '.%s' % tz_name.encode('ascii', 'ignore').replace(' ', '_')
     return cache_key
 
diff --git a/django/utils/crypto.py b/django/utils/crypto.py
index 9d46bdd793..1edbb43eb3 100644
--- a/django/utils/crypto.py
+++ b/django/utils/crypto.py
@@ -23,7 +23,7 @@ except NotImplementedError:
     using_sysrandom = False
 
 from django.conf import settings
-from django.utils.encoding import smart_str
+from django.utils.encoding import smart_bytes
 from django.utils.six.moves import xrange
 
 
@@ -115,7 +115,7 @@ def _fast_hmac(key, msg, digest):
     A trimmed down version of Python's HMAC implementation
     """
     dig1, dig2 = digest(), digest()
-    key = smart_str(key)
+    key = smart_bytes(key)
     if len(key) > dig1.block_size:
         key = digest(key).digest()
     key += chr(0) * (dig1.block_size - len(key))
@@ -141,8 +141,8 @@ def pbkdf2(password, salt, iterations, dklen=0, digest=None):
     assert iterations > 0
     if not digest:
         digest = hashlib.sha256
-    password = smart_str(password)
-    salt = smart_str(salt)
+    password = smart_bytes(password)
+    salt = smart_bytes(salt)
     hlen = digest().digest_size
     if not dklen:
         dklen = hlen
diff --git a/django/utils/dateformat.py b/django/utils/dateformat.py
index c9a6138aed..6a91a370e5 100644
--- a/django/utils/dateformat.py
+++ b/django/utils/dateformat.py
@@ -20,7 +20,7 @@ import datetime
 from django.utils.dates import MONTHS, MONTHS_3, MONTHS_ALT, MONTHS_AP, WEEKDAYS, WEEKDAYS_ABBR
 from django.utils.tzinfo import LocalTimezone
 from django.utils.translation import ugettext as _
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils import six
 from django.utils.timezone import is_aware, is_naive
 
@@ -30,9 +30,9 @@ re_escaped = re.compile(r'\\(.)')
 class Formatter(object):
     def format(self, formatstr):
         pieces = []
-        for i, piece in enumerate(re_formatchars.split(force_unicode(formatstr))):
+        for i, piece in enumerate(re_formatchars.split(force_text(formatstr))):
             if i % 2:
-                pieces.append(force_unicode(getattr(self, piece)()))
+                pieces.append(force_text(getattr(self, piece)()))
             elif piece:
                 pieces.append(re_escaped.sub(r'\1', piece))
         return ''.join(pieces)
diff --git a/django/utils/encoding.py b/django/utils/encoding.py
index b5f4b76507..eb60cfde8b 100644
--- a/django/utils/encoding.py
+++ b/django/utils/encoding.py
@@ -24,9 +24,13 @@ class DjangoUnicodeDecodeError(UnicodeDecodeError):
 
 class StrAndUnicode(object):
     """
-    A class whose __str__ returns its __unicode__ as a UTF-8 bytestring.
+    A class that derives __str__ from __unicode__.
 
-    Useful as a mix-in.
+    On Python 2, __str__ returns the output of __unicode__ encoded as a UTF-8
+    bytestring. On Python 3, __str__ returns the output of __unicode__.
+
+    Useful as a mix-in. If you support Python 2 and 3 with a single code base,
+    you can inherit this mix-in and just define __unicode__.
     """
     if six.PY3:
         def __str__(self):
@@ -35,37 +39,36 @@ class StrAndUnicode(object):
         def __str__(self):
             return self.__unicode__().encode('utf-8')
 
-def smart_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):
+def smart_text(s, encoding='utf-8', strings_only=False, errors='strict'):
     """
-    Returns a unicode object representing 's'. Treats bytestrings using the
-    'encoding' codec.
+    Returns a text object representing 's' -- unicode on Python 2 and str on
+    Python 3. Treats bytestrings using the 'encoding' codec.
 
     If strings_only is True, don't convert (some) non-string-like objects.
     """
     if isinstance(s, Promise):
         # The input is the result of a gettext_lazy() call.
         return s
-    return force_unicode(s, encoding, strings_only, errors)
+    return force_text(s, encoding, strings_only, errors)
 
 def is_protected_type(obj):
     """Determine if the object instance is of a protected type.
 
     Objects of protected types are preserved as-is when passed to
-    force_unicode(strings_only=True).
+    force_text(strings_only=True).
     """
     return isinstance(obj, six.integer_types + (type(None), float, Decimal,
         datetime.datetime, datetime.date, datetime.time))
 
-def force_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):
+def force_text(s, encoding='utf-8', strings_only=False, errors='strict'):
     """
-    Similar to smart_unicode, except that lazy instances are resolved to
+    Similar to smart_text, except that lazy instances are resolved to
     strings, rather than kept as lazy objects.
 
     If strings_only is True, don't convert (some) non-string-like objects.
     """
-    # Handle the common case first, saves 30-40% in performance when s
-    # is an instance of unicode. This function gets called often in that
-    # setting.
+    # Handle the common case first, saves 30-40% when s is an instance of
+    # six.text_type. This function gets called often in that setting.
     if isinstance(s, six.text_type):
         return s
     if strings_only and is_protected_type(s):
@@ -92,7 +95,7 @@ def force_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):
                     # without raising a further exception. We do an
                     # approximation to what the Exception's standard str()
                     # output should be.
-                    s = ' '.join([force_unicode(arg, encoding, strings_only,
+                    s = ' '.join([force_text(arg, encoding, strings_only,
                             errors) for arg in s])
         else:
             # Note: We use .decode() here, instead of six.text_type(s, encoding,
@@ -108,21 +111,26 @@ def force_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):
             # working unicode method. Try to handle this without raising a
             # further exception by individually forcing the exception args
             # to unicode.
-            s = ' '.join([force_unicode(arg, encoding, strings_only,
+            s = ' '.join([force_text(arg, encoding, strings_only,
                     errors) for arg in s])
     return s
 
-def smart_str(s, encoding='utf-8', strings_only=False, errors='strict'):
+def smart_bytes(s, encoding='utf-8', strings_only=False, errors='strict'):
     """
     Returns a bytestring version of 's', encoded as specified in 'encoding'.
 
     If strings_only is True, don't convert (some) non-string-like objects.
     """
+    if isinstance(s, bytes):
+        if encoding == 'utf-8':
+            return s
+        else:
+            return s.decode('utf-8', errors).encode(encoding, errors)
     if strings_only and (s is None or isinstance(s, int)):
         return s
     if isinstance(s, Promise):
         return six.text_type(s).encode(encoding, errors)
-    elif not isinstance(s, six.string_types):
+    if not isinstance(s, six.string_types):
         try:
             if six.PY3:
                 return six.text_type(s).encode(encoding)
@@ -133,15 +141,25 @@ def smart_str(s, encoding='utf-8', strings_only=False, errors='strict'):
                 # An Exception subclass containing non-ASCII data that doesn't
                 # know how to print itself properly. We shouldn't raise a
                 # further exception.
-                return ' '.join([smart_str(arg, encoding, strings_only,
+                return ' '.join([smart_bytes(arg, encoding, strings_only,
                         errors) for arg in s])
             return six.text_type(s).encode(encoding, errors)
-    elif isinstance(s, six.text_type):
-        return s.encode(encoding, errors)
-    elif s and encoding != 'utf-8':
-        return s.decode('utf-8', errors).encode(encoding, errors)
     else:
-        return s
+        return s.encode(encoding, errors)
+
+if six.PY3:
+    smart_str = smart_text
+else:
+    smart_str = smart_bytes
+    # backwards compatibility for Python 2
+    smart_unicode = smart_text
+    force_unicode = force_text
+
+smart_str.__doc__ = """\
+Apply smart_text in Python 3 and smart_bytes in Python 2.
+
+This is suitable for writing to sys.stdout (for instance).
+"""
 
 def iri_to_uri(iri):
     """
@@ -168,7 +186,7 @@ def iri_to_uri(iri):
     # converted.
     if iri is None:
         return iri
-    return quote(smart_str(iri), safe=b"/#%[]=:;$&()+,!?*@'~")
+    return quote(smart_bytes(iri), safe=b"/#%[]=:;$&()+,!?*@'~")
 
 def filepath_to_uri(path):
     """Convert an file system path to a URI portion that is suitable for
@@ -187,7 +205,7 @@ def filepath_to_uri(path):
         return path
     # I know about `os.sep` and `os.altsep` but I want to leave
     # some flexibility for hardcoding separators.
-    return quote(smart_str(path).replace("\\", "/"), safe=b"/~!*()'")
+    return quote(smart_bytes(path).replace("\\", "/"), safe=b"/~!*()'")
 
 # The encoding of the default system locale but falls back to the
 # given fallback encoding if the encoding is unsupported by python or could
diff --git a/django/utils/feedgenerator.py b/django/utils/feedgenerator.py
index 6498aaf57c..1bf43bf0a7 100644
--- a/django/utils/feedgenerator.py
+++ b/django/utils/feedgenerator.py
@@ -29,7 +29,7 @@ try:
 except ImportError:     # Python 2
     from urlparse import urlparse
 from django.utils.xmlutils import SimplerXMLGenerator
-from django.utils.encoding import force_unicode, iri_to_uri
+from django.utils.encoding import force_text, iri_to_uri
 from django.utils import datetime_safe
 from django.utils.timezone import is_aware
 
@@ -81,12 +81,12 @@ class SyndicationFeed(object):
     def __init__(self, title, link, description, language=None, author_email=None,
             author_name=None, author_link=None, subtitle=None, categories=None,
             feed_url=None, feed_copyright=None, feed_guid=None, ttl=None, **kwargs):
-        to_unicode = lambda s: force_unicode(s, strings_only=True)
+        to_unicode = lambda s: force_text(s, strings_only=True)
         if categories:
-            categories = [force_unicode(c) for c in categories]
+            categories = [force_text(c) for c in categories]
         if ttl is not None:
             # Force ints to unicode
-            ttl = force_unicode(ttl)
+            ttl = force_text(ttl)
         self.feed = {
             'title': to_unicode(title),
             'link': iri_to_uri(link),
@@ -114,12 +114,12 @@ class SyndicationFeed(object):
         objects except pubdate, which is a datetime.datetime object, and
         enclosure, which is an instance of the Enclosure class.
         """
-        to_unicode = lambda s: force_unicode(s, strings_only=True)
+        to_unicode = lambda s: force_text(s, strings_only=True)
         if categories:
             categories = [to_unicode(c) for c in categories]
         if ttl is not None:
             # Force ints to unicode
-            ttl = force_unicode(ttl)
+            ttl = force_text(ttl)
         item = {
             'title': to_unicode(title),
             'link': iri_to_uri(link),
diff --git a/django/utils/html.py b/django/utils/html.py
index 4e888fc59b..7dd53a1353 100644
--- a/django/utils/html.py
+++ b/django/utils/html.py
@@ -11,7 +11,7 @@ except ImportError:     # Python 2
     from urlparse import urlsplit, urlunsplit
 
 from django.utils.safestring import SafeData, mark_safe
-from django.utils.encoding import smart_str, force_unicode
+from django.utils.encoding import smart_bytes, force_text
 from django.utils.functional import allow_lazy
 from django.utils import six
 from django.utils.text import normalize_newlines
@@ -39,7 +39,7 @@ def escape(text):
     """
     Returns the given text with ampersands, quotes and angle brackets encoded for use in HTML.
     """
-    return mark_safe(force_unicode(text).replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;').replace('"', '&quot;').replace("'", '&#39;'))
+    return mark_safe(force_text(text).replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;').replace('"', '&quot;').replace("'", '&#39;'))
 escape = allow_lazy(escape, six.text_type)
 
 _base_js_escapes = (
@@ -63,7 +63,7 @@ _js_escapes = (_base_js_escapes +
 def escapejs(value):
     """Hex encodes characters for use in JavaScript strings."""
     for bad, good in _js_escapes:
-        value = mark_safe(force_unicode(value).replace(bad, good))
+        value = mark_safe(force_text(value).replace(bad, good))
     return value
 escapejs = allow_lazy(escapejs, six.text_type)
 
@@ -120,22 +120,22 @@ linebreaks = allow_lazy(linebreaks, six.text_type)
 
 def strip_tags(value):
     """Returns the given HTML with all tags stripped."""
-    return re.sub(r'<[^>]*?>', '', force_unicode(value))
+    return re.sub(r'<[^>]*?>', '', force_text(value))
 strip_tags = allow_lazy(strip_tags)
 
 def strip_spaces_between_tags(value):
     """Returns the given HTML with spaces between tags removed."""
-    return re.sub(r'>\s+<', '><', force_unicode(value))
+    return re.sub(r'>\s+<', '><', force_text(value))
 strip_spaces_between_tags = allow_lazy(strip_spaces_between_tags, six.text_type)
 
 def strip_entities(value):
     """Returns the given HTML with all entities (&something;) stripped."""
-    return re.sub(r'&(?:\w+|#\d+);', '', force_unicode(value))
+    return re.sub(r'&(?:\w+|#\d+);', '', force_text(value))
 strip_entities = allow_lazy(strip_entities, six.text_type)
 
 def fix_ampersands(value):
     """Returns the given HTML with all unencoded ampersands encoded correctly."""
-    return unencoded_ampersands_re.sub('&amp;', force_unicode(value))
+    return unencoded_ampersands_re.sub('&amp;', force_text(value))
 fix_ampersands = allow_lazy(fix_ampersands, six.text_type)
 
 def smart_urlquote(url):
@@ -153,9 +153,9 @@ def smart_urlquote(url):
     # contains a % not followed by two hexadecimal digits. See #9655.
     if '%' not in url or unquoted_percents_re.search(url):
         # See http://bugs.python.org/issue2637
-        url = quote(smart_str(url), safe=b'!*\'();:@&=+$,/?#[]~')
+        url = quote(smart_bytes(url), safe=b'!*\'();:@&=+$,/?#[]~')
 
-    return force_unicode(url)
+    return force_text(url)
 
 def urlize(text, trim_url_limit=None, nofollow=False, autoescape=False):
     """
@@ -176,7 +176,7 @@ def urlize(text, trim_url_limit=None, nofollow=False, autoescape=False):
     """
     trim_url = lambda x, limit=trim_url_limit: limit is not None and (len(x) > limit and ('%s...' % x[:max(0, limit - 3)])) or x
     safe_input = isinstance(text, SafeData)
-    words = word_split_re.split(force_unicode(text))
+    words = word_split_re.split(force_text(text))
     for i, word in enumerate(words):
         match = None
         if '.' in word or '@' in word or ':' in word:
@@ -245,7 +245,7 @@ def clean_html(text):
           bottom of the text.
     """
     from django.utils.text import normalize_newlines
-    text = normalize_newlines(force_unicode(text))
+    text = normalize_newlines(force_text(text))
     text = re.sub(r'<(/?)\s*b\s*>', '<\\1strong>', text)
     text = re.sub(r'<(/?)\s*i\s*>', '<\\1em>', text)
     text = fix_ampersands(text)
diff --git a/django/utils/http.py b/django/utils/http.py
index 272e73f190..22e81a33d7 100644
--- a/django/utils/http.py
+++ b/django/utils/http.py
@@ -13,7 +13,7 @@ except ImportError:     # Python 2
 from email.utils import formatdate
 
 from django.utils.datastructures import MultiValueDict
-from django.utils.encoding import smart_str, force_unicode
+from django.utils.encoding import force_text, smart_str
 from django.utils.functional import allow_lazy
 from django.utils import six
 
@@ -37,7 +37,7 @@ def urlquote(url, safe='/'):
     can safely be used as part of an argument to a subsequent iri_to_uri() call
     without double-quoting occurring.
     """
-    return force_unicode(urllib_parse.quote(smart_str(url), smart_str(safe)))
+    return force_text(urllib_parse.quote(smart_str(url), smart_str(safe)))
 urlquote = allow_lazy(urlquote, six.text_type)
 
 def urlquote_plus(url, safe=''):
@@ -47,7 +47,7 @@ def urlquote_plus(url, safe=''):
     returned string can safely be used as part of an argument to a subsequent
     iri_to_uri() call without double-quoting occurring.
     """
-    return force_unicode(urllib_parse.quote_plus(smart_str(url), smart_str(safe)))
+    return force_text(urllib_parse.quote_plus(smart_str(url), smart_str(safe)))
 urlquote_plus = allow_lazy(urlquote_plus, six.text_type)
 
 def urlunquote(quoted_url):
@@ -55,7 +55,7 @@ def urlunquote(quoted_url):
     A wrapper for Python's urllib.unquote() function that can operate on
     the result of django.utils.http.urlquote().
     """
-    return force_unicode(urllib_parse.unquote(smart_str(quoted_url)))
+    return force_text(urllib_parse.unquote(smart_str(quoted_url)))
 urlunquote = allow_lazy(urlunquote, six.text_type)
 
 def urlunquote_plus(quoted_url):
@@ -63,7 +63,7 @@ def urlunquote_plus(quoted_url):
     A wrapper for Python's urllib.unquote_plus() function that can operate on
     the result of django.utils.http.urlquote_plus().
     """
-    return force_unicode(urllib_parse.unquote_plus(smart_str(quoted_url)))
+    return force_text(urllib_parse.unquote_plus(smart_str(quoted_url)))
 urlunquote_plus = allow_lazy(urlunquote_plus, six.text_type)
 
 def urlencode(query, doseq=0):
diff --git a/django/utils/text.py b/django/utils/text.py
index 43056aa634..0838d79c65 100644
--- a/django/utils/text.py
+++ b/django/utils/text.py
@@ -7,13 +7,13 @@ from gzip import GzipFile
 from django.utils.six.moves import html_entities
 from io import BytesIO
 
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils.functional import allow_lazy, SimpleLazyObject
 from django.utils import six
 from django.utils.translation import ugettext_lazy, ugettext as _, pgettext
 
 # Capitalizes the first letter of a string.
-capfirst = lambda x: x and force_unicode(x)[0].upper() + force_unicode(x)[1:]
+capfirst = lambda x: x and force_text(x)[0].upper() + force_text(x)[1:]
 capfirst = allow_lazy(capfirst, six.text_type)
 
 # Set up regular expressions
@@ -26,7 +26,7 @@ def wrap(text, width):
     A word-wrap function that preserves existing line breaks and most spaces in
     the text. Expects that existing line breaks are posix newlines.
     """
-    text = force_unicode(text)
+    text = force_text(text)
     def _generator():
         it = iter(text.split(' '))
         word = next(it)
@@ -55,14 +55,14 @@ class Truncator(SimpleLazyObject):
     An object used to truncate text, either by characters or words.
     """
     def __init__(self, text):
-        super(Truncator, self).__init__(lambda: force_unicode(text))
+        super(Truncator, self).__init__(lambda: force_text(text))
 
     def add_truncation_text(self, text, truncate=None):
         if truncate is None:
             truncate = pgettext(
                 'String to return when truncating text',
                 '%(truncated_text)s...')
-        truncate = force_unicode(truncate)
+        truncate = force_text(truncate)
         if '%(truncated_text)s' in truncate:
             return truncate % {'truncated_text': text}
         # The truncation text didn't contain the %(truncated_text)s string
@@ -226,7 +226,7 @@ def get_valid_filename(s):
     >>> get_valid_filename("john's portrait in 2004.jpg")
     'johns_portrait_in_2004.jpg'
     """
-    s = force_unicode(s).strip().replace(' ', '_')
+    s = force_text(s).strip().replace(' ', '_')
     return re.sub(r'(?u)[^-\w.]', '', s)
 get_valid_filename = allow_lazy(get_valid_filename, six.text_type)
 
@@ -244,20 +244,20 @@ def get_text_list(list_, last_word=ugettext_lazy('or')):
     ''
     """
     if len(list_) == 0: return ''
-    if len(list_) == 1: return force_unicode(list_[0])
+    if len(list_) == 1: return force_text(list_[0])
     return '%s %s %s' % (
         # Translators: This string is used as a separator between list elements
-        _(', ').join([force_unicode(i) for i in list_][:-1]),
-        force_unicode(last_word), force_unicode(list_[-1]))
+        _(', ').join([force_text(i) for i in list_][:-1]),
+        force_text(last_word), force_text(list_[-1]))
 get_text_list = allow_lazy(get_text_list, six.text_type)
 
 def normalize_newlines(text):
-    return force_unicode(re.sub(r'\r\n|\r|\n', '\n', text))
+    return force_text(re.sub(r'\r\n|\r|\n', '\n', text))
 normalize_newlines = allow_lazy(normalize_newlines, six.text_type)
 
 def recapitalize(text):
     "Recapitalizes text, placing caps after end-of-sentence punctuation."
-    text = force_unicode(text).lower()
+    text = force_text(text).lower()
     capsRE = re.compile(r'(?:^|(?<=[\.\?\!] ))([a-z])')
     text = capsRE.sub(lambda x: x.group(1).upper(), text)
     return text
@@ -330,7 +330,7 @@ def smart_split(text):
     >>> list(smart_split(r'A "\"funky\" style" test.'))
     ['A', '"\\"funky\\" style"', 'test.']
     """
-    text = force_unicode(text)
+    text = force_text(text)
     for bit in smart_split_re.finditer(text):
         yield bit.group(0)
 smart_split = allow_lazy(smart_split, six.text_type)
diff --git a/django/utils/translation/__init__.py b/django/utils/translation/__init__.py
index d31a7aebf1..febde404a5 100644
--- a/django/utils/translation/__init__.py
+++ b/django/utils/translation/__init__.py
@@ -3,7 +3,7 @@ Internationalization support.
 """
 from __future__ import unicode_literals
 
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils.functional import lazy
 from django.utils import six
 
@@ -139,7 +139,7 @@ def _string_concat(*strings):
     Lazy variant of string concatenation, needed for translations that are
     constructed from multiple parts.
     """
-    return ''.join([force_unicode(s) for s in strings])
+    return ''.join([force_text(s) for s in strings])
 string_concat = lazy(_string_concat, six.text_type)
 
 def get_language_info(lang_code):
diff --git a/django/utils/translation/trans_null.py b/django/utils/translation/trans_null.py
index 0fabc707ce..5c51468204 100644
--- a/django/utils/translation/trans_null.py
+++ b/django/utils/translation/trans_null.py
@@ -3,7 +3,7 @@
 # settings.USE_I18N = False can use this module rather than trans_real.py.
 
 from django.conf import settings
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils.safestring import mark_safe, SafeData
 
 def ngettext(singular, plural, number):
@@ -12,7 +12,7 @@ def ngettext(singular, plural, number):
 ngettext_lazy = ngettext
 
 def ungettext(singular, plural, number):
-    return force_unicode(ngettext(singular, plural, number))
+    return force_text(ngettext(singular, plural, number))
 
 def pgettext(context, message):
     return ugettext(message)
@@ -44,7 +44,7 @@ def gettext(message):
     return result
 
 def ugettext(message):
-    return force_unicode(gettext(message))
+    return force_text(gettext(message))
 
 gettext_noop = gettext_lazy = _ = gettext
 
diff --git a/django/utils/tzinfo.py b/django/utils/tzinfo.py
index 05f4aa6d2f..c40b430411 100644
--- a/django/utils/tzinfo.py
+++ b/django/utils/tzinfo.py
@@ -5,7 +5,7 @@ from __future__ import unicode_literals
 import time
 from datetime import timedelta, tzinfo
 
-from django.utils.encoding import smart_unicode, smart_str, DEFAULT_LOCALE_ENCODING
+from django.utils.encoding import smart_text, smart_bytes, DEFAULT_LOCALE_ENCODING
 
 # Python's doc say: "A tzinfo subclass must have an __init__() method that can
 # be called with no arguments". FixedOffset and LocalTimezone don't honor this
@@ -53,7 +53,7 @@ class LocalTimezone(tzinfo):
         self._tzname = self.tzname(dt)
 
     def __repr__(self):
-        return smart_str(self._tzname)
+        return smart_bytes(self._tzname)
 
     def __getinitargs__(self):
         return self.__dt,
@@ -72,7 +72,7 @@ class LocalTimezone(tzinfo):
 
     def tzname(self, dt):
         try:
-            return smart_unicode(time.tzname[self._isdst(dt)],
+            return smart_text(time.tzname[self._isdst(dt)],
                                  DEFAULT_LOCALE_ENCODING)
         except UnicodeDecodeError:
             return None
diff --git a/django/views/debug.py b/django/views/debug.py
index 08341fe145..b275ef9e73 100644
--- a/django/views/debug.py
+++ b/django/views/debug.py
@@ -14,7 +14,7 @@ from django.template import Template, Context, TemplateDoesNotExist
 from django.template.defaultfilters import force_escape, pprint
 from django.utils.html import escape
 from django.utils.importlib import import_module
-from django.utils.encoding import smart_unicode, smart_str
+from django.utils.encoding import smart_text, smart_bytes
 from django.utils import six
 
 HIDDEN_SETTINGS = re.compile('API|TOKEN|KEY|SECRET|PASS|PROFANITIES_LIST|SIGNATURE')
@@ -256,7 +256,7 @@ class ExceptionReporter(object):
             end = getattr(self.exc_value, 'end', None)
             if start is not None and end is not None:
                 unicode_str = self.exc_value.args[1]
-                unicode_hint = smart_unicode(unicode_str[max(start-5, 0):min(end+5, len(unicode_str))], 'ascii', errors='replace')
+                unicode_hint = smart_text(unicode_str[max(start-5, 0):min(end+5, len(unicode_str))], 'ascii', errors='replace')
         from django import get_version
         c = {
             'is_email': self.is_email,
@@ -278,7 +278,7 @@ class ExceptionReporter(object):
         if self.exc_type:
             c['exception_type'] = self.exc_type.__name__
         if self.exc_value:
-            c['exception_value'] = smart_unicode(self.exc_value, errors='replace')
+            c['exception_value'] = smart_text(self.exc_value, errors='replace')
         if frames:
             c['lastframe'] = frames[-1]
         return c
@@ -440,7 +440,7 @@ def technical_404_response(request, exception):
         'root_urlconf': settings.ROOT_URLCONF,
         'request_path': request.path_info[1:], # Trim leading slash
         'urlpatterns': tried,
-        'reason': smart_str(exception, errors='replace'),
+        'reason': smart_bytes(exception, errors='replace'),
         'request': request,
         'settings': get_safe_settings(),
     })
diff --git a/django/views/generic/dates.py b/django/views/generic/dates.py
index 22a72bc433..08b7318738 100644
--- a/django/views/generic/dates.py
+++ b/django/views/generic/dates.py
@@ -5,7 +5,7 @@ from django.conf import settings
 from django.db import models
 from django.core.exceptions import ImproperlyConfigured
 from django.http import Http404
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils.functional import cached_property
 from django.utils.translation import ugettext as _
 from django.utils import timezone
@@ -365,7 +365,7 @@ class BaseDateListView(MultipleObjectMixin, DateMixin, View):
             is_empty = len(qs) == 0 if paginate_by is None else not qs.exists()
             if is_empty:
                 raise Http404(_("No %(verbose_name_plural)s available") % {
-                        'verbose_name_plural': force_unicode(qs.model._meta.verbose_name_plural)
+                        'verbose_name_plural': force_text(qs.model._meta.verbose_name_plural)
                 })
 
         return qs
@@ -380,7 +380,7 @@ class BaseDateListView(MultipleObjectMixin, DateMixin, View):
 
         date_list = queryset.dates(date_field, date_type)[::-1]
         if date_list is not None and not date_list and not allow_empty:
-            name = force_unicode(queryset.model._meta.verbose_name_plural)
+            name = force_text(queryset.model._meta.verbose_name_plural)
             raise Http404(_("No %(verbose_name_plural)s available") %
                           {'verbose_name_plural': name})
 
diff --git a/django/views/i18n.py b/django/views/i18n.py
index b0f64f4902..00ef224254 100644
--- a/django/views/i18n.py
+++ b/django/views/i18n.py
@@ -6,7 +6,7 @@ from django.conf import settings
 from django.utils import importlib
 from django.utils.translation import check_for_language, activate, to_locale, get_language
 from django.utils.text import javascript_quote
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.formats import get_format_modules, get_format
 from django.utils import six
 
@@ -54,9 +54,9 @@ def get_formats():
     src = []
     for k, v in result.items():
         if isinstance(v, (six.string_types, int)):
-            src.append("formats['%s'] = '%s';\n" % (javascript_quote(k), javascript_quote(smart_unicode(v))))
+            src.append("formats['%s'] = '%s';\n" % (javascript_quote(k), javascript_quote(smart_text(v))))
         elif isinstance(v, (tuple, list)):
-            v = [javascript_quote(smart_unicode(value)) for value in v]
+            v = [javascript_quote(smart_text(value)) for value in v]
             src.append("formats['%s'] = ['%s'];\n" % (javascript_quote(k), "', '".join(v)))
     return ''.join(src)
 
diff --git a/docs/howto/custom-model-fields.txt b/docs/howto/custom-model-fields.txt
index 706cc25129..e73ef9aa42 100644
--- a/docs/howto/custom-model-fields.txt
+++ b/docs/howto/custom-model-fields.txt
@@ -688,7 +688,7 @@ smoothly:
 2. Put a :meth:`__str__` or :meth:`__unicode__` method on the class you're
    wrapping up as a field. There are a lot of places where the default
    behavior of the field code is to call
-   :func:`~django.utils.encoding.force_unicode` on the value. (In our
+   :func:`~django.utils.encoding.force_text` on the value. (In our
    examples in this document, ``value`` would be a ``Hand`` instance, not a
    ``HandField``). So if your :meth:`__unicode__` method automatically
    converts to the string form of your Python object, you can save yourself
diff --git a/docs/ref/databases.txt b/docs/ref/databases.txt
index 74e6b48f07..92b5665bea 100644
--- a/docs/ref/databases.txt
+++ b/docs/ref/databases.txt
@@ -238,7 +238,7 @@ to you, the developer, to handle the fact that you will receive bytestrings if
 you configure your table(s) to use ``utf8_bin`` collation. Django itself should
 mostly work smoothly with such columns (except for the ``contrib.sessions``
 ``Session`` and ``contrib.admin`` ``LogEntry`` tables described below), but
-your code must be prepared to call ``django.utils.encoding.smart_unicode()`` at
+your code must be prepared to call ``django.utils.encoding.smart_text()`` at
 times if it really wants to work with consistent data -- Django will not do
 this for you (the database backend layer and the model population layer are
 separated internally so the database layer doesn't know it needs to make this
diff --git a/docs/ref/models/instances.txt b/docs/ref/models/instances.txt
index 509ea9d30e..14541ad0d1 100644
--- a/docs/ref/models/instances.txt
+++ b/docs/ref/models/instances.txt
@@ -453,9 +453,9 @@ using ``__str__()`` like this::
         last_name = models.CharField(max_length=50)
 
         def __str__(self):
-            # Note use of django.utils.encoding.smart_str() here because
+            # Note use of django.utils.encoding.smart_bytes() here because
             # first_name and last_name will be unicode strings.
-            return smart_str('%s %s' % (self.first_name, self.last_name))
+            return smart_bytes('%s %s' % (self.first_name, self.last_name))
 
 ``get_absolute_url``
 --------------------
diff --git a/docs/ref/settings.txt b/docs/ref/settings.txt
index 72d60453c3..531ff33da2 100644
--- a/docs/ref/settings.txt
+++ b/docs/ref/settings.txt
@@ -183,7 +183,7 @@ compose a prefix, version and key into a final cache key. The default
 implementation is equivalent to the function::
 
     def make_key(key, key_prefix, version):
-        return ':'.join([key_prefix, str(version), smart_str(key)])
+        return ':'.join([key_prefix, str(version), smart_bytes(key)])
 
 You may use any key function you want, as long as it has the same
 argument signature.
diff --git a/docs/ref/unicode.txt b/docs/ref/unicode.txt
index b9253e70b3..ffab647379 100644
--- a/docs/ref/unicode.txt
+++ b/docs/ref/unicode.txt
@@ -129,7 +129,7 @@ Conversion functions
 The ``django.utils.encoding`` module contains a few functions that are handy
 for converting back and forth between Unicode and bytestrings.
 
-* ``smart_unicode(s, encoding='utf-8', strings_only=False, errors='strict')``
+* ``smart_text(s, encoding='utf-8', strings_only=False, errors='strict')``
   converts its input to a Unicode string. The ``encoding`` parameter
   specifies the input encoding. (For example, Django uses this internally
   when processing form input data, which might not be UTF-8 encoded.) The
@@ -139,27 +139,27 @@ for converting back and forth between Unicode and bytestrings.
   that are accepted by Python's ``unicode()`` function for its error
   handling.
 
-  If you pass ``smart_unicode()`` an object that has a ``__unicode__``
+  If you pass ``smart_text()`` an object that has a ``__unicode__``
   method, it will use that method to do the conversion.
 
-* ``force_unicode(s, encoding='utf-8', strings_only=False,
-  errors='strict')`` is identical to ``smart_unicode()`` in almost all
+* ``force_text(s, encoding='utf-8', strings_only=False,
+  errors='strict')`` is identical to ``smart_text()`` in almost all
   cases. The difference is when the first argument is a :ref:`lazy
-  translation <lazy-translations>` instance. While ``smart_unicode()``
-  preserves lazy translations, ``force_unicode()`` forces those objects to a
+  translation <lazy-translations>` instance. While ``smart_text()``
+  preserves lazy translations, ``force_text()`` forces those objects to a
   Unicode string (causing the translation to occur). Normally, you'll want
-  to use ``smart_unicode()``. However, ``force_unicode()`` is useful in
+  to use ``smart_text()``. However, ``force_text()`` is useful in
   template tags and filters that absolutely *must* have a string to work
   with, not just something that can be converted to a string.
 
-* ``smart_str(s, encoding='utf-8', strings_only=False, errors='strict')``
-  is essentially the opposite of ``smart_unicode()``. It forces the first
+* ``smart_bytes(s, encoding='utf-8', strings_only=False, errors='strict')``
+  is essentially the opposite of ``smart_text()``. It forces the first
   argument to a bytestring. The ``strings_only`` parameter has the same
-  behavior as for ``smart_unicode()`` and ``force_unicode()``. This is
+  behavior as for ``smart_text()`` and ``force_text()``. This is
   slightly different semantics from Python's builtin ``str()`` function,
   but the difference is needed in a few places within Django's internals.
 
-Normally, you'll only need to use ``smart_unicode()``. Call it as early as
+Normally, you'll only need to use ``smart_text()``. Call it as early as
 possible on any input data that might be either Unicode or a bytestring, and
 from then on, you can treat the result as always being Unicode.
 
@@ -324,7 +324,7 @@ A couple of tips to remember when writing your own template tags and filters:
 * Always return Unicode strings from a template tag's ``render()`` method
   and from template filters.
 
-* Use ``force_unicode()`` in preference to ``smart_unicode()`` in these
+* Use ``force_text()`` in preference to ``smart_text()`` in these
   places. Tag rendering and filter calls occur as the template is being
   rendered, so there is no advantage to postponing the conversion of lazy
   translation objects into strings. It's easier to work solely with Unicode
diff --git a/docs/ref/utils.txt b/docs/ref/utils.txt
index 5157c399da..b6cb1035d3 100644
--- a/docs/ref/utils.txt
+++ b/docs/ref/utils.txt
@@ -178,33 +178,53 @@ The functions defined in this module share the following properties:
 
 .. class:: StrAndUnicode
 
-    A class whose ``__str__`` returns its ``__unicode__`` as a UTF-8
-    bytestring. Useful as a mix-in.
+    A class that derives ``__str__`` from ``__unicode__``.
 
-.. function:: smart_unicode(s, encoding='utf-8', strings_only=False, errors='strict')
+    On Python 2, ``__str__`` returns the output of ``__unicode__`` encoded as
+    a UTF-8 bytestring. On Python 3, ``__str__`` returns the output of
+    ``__unicode__``.
+
+    Useful as a mix-in. If you support Python 2 and 3 with a single code base,
+    you can inherit this mix-in and just define ``__unicode__``.
+
+.. function:: smart_text(s, encoding='utf-8', strings_only=False, errors='strict')
 
-    Returns a ``unicode`` object representing ``s``. Treats bytestrings using
-    the 'encoding' codec.
+    .. versionadded:: 1.5
+
+    Returns a text object representing ``s`` -- ``unicode`` on Python 2 and
+    ``str`` on Python 3. Treats bytestrings using the ``encoding`` codec.
 
     If ``strings_only`` is ``True``, don't convert (some) non-string-like
     objects.
 
+.. function:: smart_unicode(s, encoding='utf-8', strings_only=False, errors='strict')
+
+    Historical name of :func:`smart_text`. Only available under Python 2.
+
 .. function:: is_protected_type(obj)
 
     Determine if the object instance is of a protected type.
 
     Objects of protected types are preserved as-is when passed to
-    ``force_unicode(strings_only=True)``.
+    ``force_text(strings_only=True)``.
 
-.. function:: force_unicode(s, encoding='utf-8', strings_only=False, errors='strict')
+.. function:: force_text(s, encoding='utf-8', strings_only=False, errors='strict')
+
+    .. versionadded:: 1.5
 
-    Similar to ``smart_unicode``, except that lazy instances are resolved to
+    Similar to ``smart_text``, except that lazy instances are resolved to
     strings, rather than kept as lazy objects.
 
     If ``strings_only`` is ``True``, don't convert (some) non-string-like
     objects.
 
-.. function:: smart_str(s, encoding='utf-8', strings_only=False, errors='strict')
+.. function:: force_unicode(s, encoding='utf-8', strings_only=False, errors='strict')
+
+    Historical name of :func:`force_text`. Only available under Python 2.
+
+.. function:: smart_bytes(s, encoding='utf-8', strings_only=False, errors='strict')
+
+    .. versionadded:: 1.5
 
     Returns a bytestring version of ``s``, encoded as specified in
     ``encoding``.
@@ -212,6 +232,14 @@ The functions defined in this module share the following properties:
     If ``strings_only`` is ``True``, don't convert (some) non-string-like
     objects.
 
+.. function:: smart_str(s, encoding='utf-8', strings_only=False, errors='strict')
+
+    Alias of :func:`smart_bytes` on Python 2 and :func:`smart_text` on Python
+    3. This function always returns a :class:`str`.
+
+    For instance, this is  suitable for writing to :attr:`sys.stdout` on
+    Python 2 and 3.
+
 .. function:: iri_to_uri(iri)
 
     Convert an Internationalized Resource Identifier (IRI) portion to a URI
@@ -406,7 +434,7 @@ escaping HTML.
 
     Returns the given text with ampersands, quotes and angle brackets encoded
     for use in HTML. The input is first passed through
-    :func:`~django.utils.encoding.force_unicode` and the output has
+    :func:`~django.utils.encoding.force_text` and the output has
     :func:`~django.utils.safestring.mark_safe` applied.
 
 .. function:: conditional_escape(text)
@@ -448,7 +476,7 @@ escaping HTML.
     interpolation, some of the formatting options provided by `str.format`_
     (e.g. number formatting) will not work, since all arguments are passed
     through :func:`conditional_escape` which (ultimately) calls
-    :func:`~django.utils.encoding.force_unicode` on the values.
+    :func:`~django.utils.encoding.force_text` on the values.
 
 
 .. _str.format: http://docs.python.org/library/stdtypes.html#str.format
diff --git a/docs/releases/1.5.txt b/docs/releases/1.5.txt
index d58d3cadf4..f789ebde40 100644
--- a/docs/releases/1.5.txt
+++ b/docs/releases/1.5.txt
@@ -161,7 +161,7 @@ If you have written a :ref:`custom password hasher <auth_password_storage>`,
 your ``encode()``, ``verify()`` or ``safe_summary()`` methods should accept
 Unicode parameters (``password``, ``salt`` or ``encoded``). If any of the
 hashing methods need byte strings, you can use the
-:func:`~django.utils.encoding.smart_str` utility to encode the strings.
+:func:`~django.utils.encoding.smart_bytes` utility to encode the strings.
 
 Validation of previous_page_number and next_page_number
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
diff --git a/docs/topics/cache.txt b/docs/topics/cache.txt
index d0bd9f6992..219b6c7795 100644
--- a/docs/topics/cache.txt
+++ b/docs/topics/cache.txt
@@ -864,7 +864,7 @@ key version to provide a final cache key. By default, the three parts
 are joined using colons to produce a final string::
 
     def make_key(key, key_prefix, version):
-        return ':'.join([key_prefix, str(version), smart_str(key)])
+        return ':'.join([key_prefix, str(version), smart_bytes(key)])
 
 If you want to combine the parts in different ways, or apply other
 processing to the final key (e.g., taking a hash digest of the key
diff --git a/docs/topics/serialization.txt b/docs/topics/serialization.txt
index 505ac17f09..ac1a77ed98 100644
--- a/docs/topics/serialization.txt
+++ b/docs/topics/serialization.txt
@@ -173,12 +173,12 @@ In particular, :ref:`lazy translation objects <lazy-translations>` need a
 
     import json
     from django.utils.functional import Promise
-    from django.utils.encoding import force_unicode
+    from django.utils.encoding import force_text
 
     class LazyEncoder(json.JSONEncoder):
         def default(self, obj):
             if isinstance(obj, Promise):
-                return force_unicode(obj)
+                return force_text(obj)
             return super(LazyEncoder, self).default(obj)
 
 .. _special encoder: http://docs.python.org/library/json.html#encoders-and-decoders
diff --git a/tests/modeltests/field_subclassing/fields.py b/tests/modeltests/field_subclassing/fields.py
index a21085de9d..0d4ff98aa7 100644
--- a/tests/modeltests/field_subclassing/fields.py
+++ b/tests/modeltests/field_subclassing/fields.py
@@ -3,7 +3,7 @@ from __future__ import unicode_literals
 import json
 
 from django.db import models
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.utils import six
 
 
@@ -16,7 +16,7 @@ class Small(object):
         self.first, self.second = first, second
 
     def __unicode__(self):
-        return '%s%s' % (force_unicode(self.first), force_unicode(self.second))
+        return '%s%s' % (force_text(self.first), force_text(self.second))
 
     def __str__(self):
         return six.text_type(self).encode('utf-8')
@@ -46,9 +46,9 @@ class SmallField(models.Field):
 
     def get_prep_lookup(self, lookup_type, value):
         if lookup_type == 'exact':
-            return force_unicode(value)
+            return force_text(value)
         if lookup_type == 'in':
-            return [force_unicode(v) for v in value]
+            return [force_text(v) for v in value]
         if lookup_type == 'isnull':
             return []
         raise TypeError('Invalid lookup type: %r' % lookup_type)
diff --git a/tests/modeltests/field_subclassing/models.py b/tests/modeltests/field_subclassing/models.py
index 5e3c376976..2df9664cdc 100644
--- a/tests/modeltests/field_subclassing/models.py
+++ b/tests/modeltests/field_subclassing/models.py
@@ -5,7 +5,7 @@ Tests for field subclassing.
 from __future__ import absolute_import
 
 from django.db import models
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 
 from .fields import SmallField, SmallerField, JSONField
 
@@ -15,7 +15,7 @@ class MyModel(models.Model):
     data = SmallField('small field')
 
     def __unicode__(self):
-        return force_unicode(self.name)
+        return force_text(self.name)
 
 class OtherModel(models.Model):
     data = SmallerField()
diff --git a/tests/regressiontests/admin_filters/tests.py b/tests/regressiontests/admin_filters/tests.py
index 72cc5d7ee5..b92c2f4c8b 100644
--- a/tests/regressiontests/admin_filters/tests.py
+++ b/tests/regressiontests/admin_filters/tests.py
@@ -10,7 +10,7 @@ from django.contrib.auth.models import User
 from django.core.exceptions import ImproperlyConfigured
 from django.test import TestCase, RequestFactory
 from django.test.utils import override_settings
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 
 from .models import Book, Department, Employee
 
@@ -160,7 +160,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][4]
-        self.assertEqual(force_unicode(filterspec.title), 'date registered')
+        self.assertEqual(force_text(filterspec.title), 'date registered')
         choice = select_by(filterspec.choices(changelist), "display", "Today")
         self.assertEqual(choice['selected'], True)
         self.assertEqual(choice['query_string'], '?date_registered__gte=%s'
@@ -181,7 +181,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][4]
-        self.assertEqual(force_unicode(filterspec.title), 'date registered')
+        self.assertEqual(force_text(filterspec.title), 'date registered')
         choice = select_by(filterspec.choices(changelist), "display", "This month")
         self.assertEqual(choice['selected'], True)
         self.assertEqual(choice['query_string'], '?date_registered__gte=%s'
@@ -202,7 +202,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][4]
-        self.assertEqual(force_unicode(filterspec.title), 'date registered')
+        self.assertEqual(force_text(filterspec.title), 'date registered')
         choice = select_by(filterspec.choices(changelist), "display", "This year")
         self.assertEqual(choice['selected'], True)
         self.assertEqual(choice['query_string'], '?date_registered__gte=%s'
@@ -219,7 +219,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][4]
-        self.assertEqual(force_unicode(filterspec.title), 'date registered')
+        self.assertEqual(force_text(filterspec.title), 'date registered')
         choice = select_by(filterspec.choices(changelist), "display", "Past 7 days")
         self.assertEqual(choice['selected'], True)
         self.assertEqual(choice['query_string'], '?date_registered__gte=%s'
@@ -243,7 +243,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the last choice is None and is selected
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(force_unicode(filterspec.title), 'year')
+        self.assertEqual(force_text(filterspec.title), 'year')
         choices = list(filterspec.choices(changelist))
         self.assertEqual(choices[-1]['selected'], True)
         self.assertEqual(choices[-1]['query_string'], '?year__isnull=True')
@@ -253,7 +253,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(force_unicode(filterspec.title), 'year')
+        self.assertEqual(force_text(filterspec.title), 'year')
         choices = list(filterspec.choices(changelist))
         self.assertEqual(choices[2]['selected'], True)
         self.assertEqual(choices[2]['query_string'], '?year=2002')
@@ -270,7 +270,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the last choice is None and is selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(force_unicode(filterspec.title), 'Verbose Author')
+        self.assertEqual(force_text(filterspec.title), 'Verbose Author')
         choices = list(filterspec.choices(changelist))
         self.assertEqual(choices[-1]['selected'], True)
         self.assertEqual(choices[-1]['query_string'], '?author__isnull=True')
@@ -280,7 +280,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(force_unicode(filterspec.title), 'Verbose Author')
+        self.assertEqual(force_text(filterspec.title), 'Verbose Author')
         # order of choices depends on User model, which has no order
         choice = select_by(filterspec.choices(changelist), "display", "alfred")
         self.assertEqual(choice['selected'], True)
@@ -298,7 +298,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the last choice is None and is selected
         filterspec = changelist.get_filters(request)[0][2]
-        self.assertEqual(force_unicode(filterspec.title), 'Verbose Contributors')
+        self.assertEqual(force_text(filterspec.title), 'Verbose Contributors')
         choices = list(filterspec.choices(changelist))
         self.assertEqual(choices[-1]['selected'], True)
         self.assertEqual(choices[-1]['query_string'], '?contributors__isnull=True')
@@ -308,7 +308,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][2]
-        self.assertEqual(force_unicode(filterspec.title), 'Verbose Contributors')
+        self.assertEqual(force_text(filterspec.title), 'Verbose Contributors')
         choice = select_by(filterspec.choices(changelist), "display", "bob")
         self.assertEqual(choice['selected'], True)
         self.assertEqual(choice['query_string'], '?contributors__id__exact=%d' % self.bob.pk)
@@ -326,7 +326,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the last choice is None and is selected
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(force_unicode(filterspec.title), 'book')
+        self.assertEqual(force_text(filterspec.title), 'book')
         choices = list(filterspec.choices(changelist))
         self.assertEqual(choices[-1]['selected'], True)
         self.assertEqual(choices[-1]['query_string'], '?books_authored__isnull=True')
@@ -336,7 +336,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(force_unicode(filterspec.title), 'book')
+        self.assertEqual(force_text(filterspec.title), 'book')
         choice = select_by(filterspec.choices(changelist), "display", self.bio_book.title)
         self.assertEqual(choice['selected'], True)
         self.assertEqual(choice['query_string'], '?books_authored__id__exact=%d' % self.bio_book.pk)
@@ -351,7 +351,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the last choice is None and is selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(force_unicode(filterspec.title), 'book')
+        self.assertEqual(force_text(filterspec.title), 'book')
         choices = list(filterspec.choices(changelist))
         self.assertEqual(choices[-1]['selected'], True)
         self.assertEqual(choices[-1]['query_string'], '?books_contributed__isnull=True')
@@ -361,7 +361,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(force_unicode(filterspec.title), 'book')
+        self.assertEqual(force_text(filterspec.title), 'book')
         choice = select_by(filterspec.choices(changelist), "display", self.django_book.title)
         self.assertEqual(choice['selected'], True)
         self.assertEqual(choice['query_string'], '?books_contributed__id__exact=%d' % self.django_book.pk)
@@ -387,7 +387,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][3]
-        self.assertEqual(force_unicode(filterspec.title), 'is best seller')
+        self.assertEqual(force_text(filterspec.title), 'is best seller')
         choice = select_by(filterspec.choices(changelist), "display", "No")
         self.assertEqual(choice['selected'], True)
         self.assertEqual(choice['query_string'], '?is_best_seller__exact=0')
@@ -401,7 +401,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][3]
-        self.assertEqual(force_unicode(filterspec.title), 'is best seller')
+        self.assertEqual(force_text(filterspec.title), 'is best seller')
         choice = select_by(filterspec.choices(changelist), "display", "Yes")
         self.assertEqual(choice['selected'], True)
         self.assertEqual(choice['query_string'], '?is_best_seller__exact=1')
@@ -415,7 +415,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][3]
-        self.assertEqual(force_unicode(filterspec.title), 'is best seller')
+        self.assertEqual(force_text(filterspec.title), 'is best seller')
         choice = select_by(filterspec.choices(changelist), "display", "Unknown")
         self.assertEqual(choice['selected'], True)
         self.assertEqual(choice['query_string'], '?is_best_seller__isnull=True')
@@ -434,7 +434,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(force_unicode(filterspec.title), 'publication decade')
+        self.assertEqual(force_text(filterspec.title), 'publication decade')
         choices = list(filterspec.choices(changelist))
         self.assertEqual(choices[0]['display'], 'All')
         self.assertEqual(choices[0]['selected'], True)
@@ -451,7 +451,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(force_unicode(filterspec.title), 'publication decade')
+        self.assertEqual(force_text(filterspec.title), 'publication decade')
         choices = list(filterspec.choices(changelist))
         self.assertEqual(choices[1]['display'], 'the 1980\'s')
         self.assertEqual(choices[1]['selected'], True)
@@ -468,7 +468,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(force_unicode(filterspec.title), 'publication decade')
+        self.assertEqual(force_text(filterspec.title), 'publication decade')
         choices = list(filterspec.choices(changelist))
         self.assertEqual(choices[2]['display'], 'the 1990\'s')
         self.assertEqual(choices[2]['selected'], True)
@@ -485,7 +485,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(force_unicode(filterspec.title), 'publication decade')
+        self.assertEqual(force_text(filterspec.title), 'publication decade')
         choices = list(filterspec.choices(changelist))
         self.assertEqual(choices[3]['display'], 'the 2000\'s')
         self.assertEqual(choices[3]['selected'], True)
@@ -502,14 +502,14 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choices are selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(force_unicode(filterspec.title), 'publication decade')
+        self.assertEqual(force_text(filterspec.title), 'publication decade')
         choices = list(filterspec.choices(changelist))
         self.assertEqual(choices[3]['display'], 'the 2000\'s')
         self.assertEqual(choices[3]['selected'], True)
         self.assertEqual(choices[3]['query_string'], '?publication-decade=the+00s&author__id__exact=%s' % self.alfred.pk)
 
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(force_unicode(filterspec.title), 'Verbose Author')
+        self.assertEqual(force_text(filterspec.title), 'Verbose Author')
         choice = select_by(filterspec.choices(changelist), "display", "alfred")
         self.assertEqual(choice['selected'], True)
         self.assertEqual(choice['query_string'], '?publication-decade=the+00s&author__id__exact=%s' % self.alfred.pk)
@@ -561,7 +561,7 @@ class ListFiltersTests(TestCase):
         changelist = self.get_changelist(request, Book, modeladmin)
 
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(force_unicode(filterspec.title), 'publication decade')
+        self.assertEqual(force_text(filterspec.title), 'publication decade')
         choices = list(filterspec.choices(changelist))
         self.assertEqual(len(choices), 3)
 
@@ -591,7 +591,7 @@ class ListFiltersTests(TestCase):
         self.assertEqual(list(queryset), [self.bio_book])
 
         filterspec = changelist.get_filters(request)[0][-1]
-        self.assertEqual(force_unicode(filterspec.title), 'number')
+        self.assertEqual(force_text(filterspec.title), 'number')
         choices = list(filterspec.choices(changelist))
         self.assertEqual(choices[2]['selected'], True)
         self.assertEqual(choices[2]['query_string'], '?no=207')
@@ -614,7 +614,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(force_unicode(filterspec.title), 'publication decade')
+        self.assertEqual(force_text(filterspec.title), 'publication decade')
         choices = list(filterspec.choices(changelist))
         self.assertEqual(choices[2]['display'], 'the 1990\'s')
         self.assertEqual(choices[2]['selected'], True)
@@ -631,7 +631,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(force_unicode(filterspec.title), 'publication decade')
+        self.assertEqual(force_text(filterspec.title), 'publication decade')
         choices = list(filterspec.choices(changelist))
         self.assertEqual(choices[2]['display'], 'the 1990\'s')
         self.assertEqual(choices[2]['selected'], True)
@@ -657,7 +657,7 @@ class ListFiltersTests(TestCase):
         self.assertEqual(list(queryset), [jack, john])
 
         filterspec = changelist.get_filters(request)[0][-1]
-        self.assertEqual(force_unicode(filterspec.title), 'department')
+        self.assertEqual(force_text(filterspec.title), 'department')
         choices = list(filterspec.choices(changelist))
 
         self.assertEqual(choices[0]['display'], 'All')
@@ -682,7 +682,7 @@ class ListFiltersTests(TestCase):
         self.assertEqual(list(queryset), [john])
 
         filterspec = changelist.get_filters(request)[0][-1]
-        self.assertEqual(force_unicode(filterspec.title), 'department')
+        self.assertEqual(force_text(filterspec.title), 'department')
         choices = list(filterspec.choices(changelist))
 
         self.assertEqual(choices[0]['display'], 'All')
diff --git a/tests/regressiontests/admin_views/admin.py b/tests/regressiontests/admin_views/admin.py
index 6ec933f89b..293ddfebf6 100644
--- a/tests/regressiontests/admin_views/admin.py
+++ b/tests/regressiontests/admin_views/admin.py
@@ -630,7 +630,7 @@ site.register(UndeletableObject, UndeletableObjectAdmin)
 #     related OneToOne object registered in admin
 #     related OneToOne object not registered in admin
 # when deleting Book so as exercise all four troublesome (w.r.t escaping
-# and calling force_unicode to avoid problems on Python 2.3) paths through
+# and calling force_text to avoid problems on Python 2.3) paths through
 # contrib.admin.util's get_deleted_objects function.
 site.register(Book, inlines=[ChapterInline])
 site.register(Promo)
diff --git a/tests/regressiontests/cache/tests.py b/tests/regressiontests/cache/tests.py
index 264ef74abd..8fc749aaa2 100644
--- a/tests/regressiontests/cache/tests.py
+++ b/tests/regressiontests/cache/tests.py
@@ -28,7 +28,7 @@ from django.test.utils import (get_warnings_state, restore_warnings_state,
 from django.utils import timezone, translation, unittest
 from django.utils.cache import (patch_vary_headers, get_cache_key,
     learn_cache_key, patch_cache_control, patch_response_headers)
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 from django.views.decorators.cache import cache_page
 
 from .models import Poll, expensive_calculation
@@ -1307,7 +1307,7 @@ class CacheI18nTest(TestCase):
         request = self._get_request()
         # This is tightly coupled to the implementation,
         # but it's the most straightforward way to test the key.
-        tz = force_unicode(timezone.get_current_timezone_name(), errors='ignore')
+        tz = force_text(timezone.get_current_timezone_name(), errors='ignore')
         tz = tz.encode('ascii', 'ignore').replace(' ', '_')
         response = HttpResponse()
         key = learn_cache_key(request, response)
@@ -1319,7 +1319,7 @@ class CacheI18nTest(TestCase):
     def test_cache_key_no_i18n (self):
         request = self._get_request()
         lang = translation.get_language()
-        tz = force_unicode(timezone.get_current_timezone_name(), errors='ignore')
+        tz = force_text(timezone.get_current_timezone_name(), errors='ignore')
         tz = tz.encode('ascii', 'ignore').replace(' ', '_')
         response = HttpResponse()
         key = learn_cache_key(request, response)
diff --git a/tests/regressiontests/forms/tests/extra.py b/tests/regressiontests/forms/tests/extra.py
index 28b6c12453..e0e62858d0 100644
--- a/tests/regressiontests/forms/tests/extra.py
+++ b/tests/regressiontests/forms/tests/extra.py
@@ -9,7 +9,7 @@ from django.forms.extras import SelectDateWidget
 from django.forms.util import ErrorList
 from django.test import TestCase
 from django.utils import translation
-from django.utils.encoding import force_unicode, smart_unicode
+from django.utils.encoding import force_text, smart_text
 
 from .error_messages import AssertFormErrorsMixin
 
@@ -551,7 +551,7 @@ class FormsExtraTestCase(TestCase, AssertFormErrorsMixin):
         f = GenericIPAddressField(unpack_ipv4=True)
         self.assertEqual(f.clean('::ffff:0a0a:0a0a'), '10.10.10.10')
 
-    def test_smart_unicode(self):
+    def test_smart_text(self):
         class Test:
             def __str__(self):
                return 'ŠĐĆŽćžšđ'.encode('utf-8')
@@ -562,10 +562,10 @@ class FormsExtraTestCase(TestCase, AssertFormErrorsMixin):
             def __unicode__(self):
                return '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111'
 
-        self.assertEqual(smart_unicode(Test()), '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111')
-        self.assertEqual(smart_unicode(TestU()), '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111')
-        self.assertEqual(smart_unicode(1), '1')
-        self.assertEqual(smart_unicode('foo'), 'foo')
+        self.assertEqual(smart_text(Test()), '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111')
+        self.assertEqual(smart_text(TestU()), '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111')
+        self.assertEqual(smart_text(1), '1')
+        self.assertEqual(smart_text('foo'), 'foo')
 
     def test_accessing_clean(self):
         class UserForm(Form):
@@ -591,7 +591,7 @@ class FormsExtraTestCase(TestCase, AssertFormErrorsMixin):
 
             def as_divs(self):
                 if not self: return ''
-                return '<div class="errorlist">%s</div>' % ''.join(['<div class="error">%s</div>' % force_unicode(e) for e in self])
+                return '<div class="errorlist">%s</div>' % ''.join(['<div class="error">%s</div>' % force_text(e) for e in self])
 
         class CommentForm(Form):
             name = CharField(max_length=50, required=False)
diff --git a/tests/regressiontests/signing/tests.py b/tests/regressiontests/signing/tests.py
index f3fe5f3ec7..2368405060 100644
--- a/tests/regressiontests/signing/tests.py
+++ b/tests/regressiontests/signing/tests.py
@@ -4,7 +4,7 @@ import time
 
 from django.core import signing
 from django.test import TestCase
-from django.utils.encoding import force_unicode
+from django.utils.encoding import force_text
 
 
 class TestSigner(TestCase):
@@ -48,7 +48,7 @@ class TestSigner(TestCase):
         )
         for example in examples:
             self.assertNotEqual(
-                force_unicode(example), force_unicode(signer.sign(example)))
+                force_text(example), force_text(signer.sign(example)))
             self.assertEqual(example, signer.unsign(signer.sign(example)))
 
     def unsign_detects_tampering(self):
diff --git a/tests/regressiontests/staticfiles_tests/tests.py b/tests/regressiontests/staticfiles_tests/tests.py
index 2c038e1713..19951f100b 100644
--- a/tests/regressiontests/staticfiles_tests/tests.py
+++ b/tests/regressiontests/staticfiles_tests/tests.py
@@ -17,7 +17,7 @@ from django.core.files.storage import default_storage
 from django.core.management import call_command
 from django.test import TestCase
 from django.test.utils import override_settings
-from django.utils.encoding import smart_unicode
+from django.utils.encoding import smart_text
 from django.utils.functional import empty
 from django.utils._os import rmtree_errorhandler
 from django.utils import six
@@ -80,7 +80,7 @@ class BaseStaticFilesTestCase(object):
         os.unlink(self._backup_filepath)
 
     def assertFileContains(self, filepath, text):
-        self.assertIn(text, self._get_file(smart_unicode(filepath)),
+        self.assertIn(text, self._get_file(smart_text(filepath)),
                         "'%s' not in '%s'" % (text, filepath))
 
     def assertFileNotFound(self, filepath):
@@ -199,7 +199,7 @@ class TestFindStatic(CollectionTestCase, TestDefaults):
         out.seek(0)
         lines = [l.strip() for l in out.readlines()]
         contents = codecs.open(
-            smart_unicode(lines[1].strip()), "r", "utf-8").read()
+            smart_text(lines[1].strip()), "r", "utf-8").read()
         return contents
 
     def test_all_files(self):
-- 
cgit v1.3


From b55e07771fdc9f9cc80fb099429774672aaf9be9 Mon Sep 17 00:00:00 2001
From: Aymeric Augustin <aymeric.augustin@m4x.org>
Date: Sat, 4 Aug 2012 11:17:04 +0200
Subject: [py3] Ported django.utils.baseconv.

---
 tests/regressiontests/utils/baseconv.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/regressiontests/utils/baseconv.py b/tests/regressiontests/utils/baseconv.py
index 75660d8119..cc413b4e8e 100644
--- a/tests/regressiontests/utils/baseconv.py
+++ b/tests/regressiontests/utils/baseconv.py
@@ -1,10 +1,11 @@
 from unittest import TestCase
 from django.utils.baseconv import base2, base16, base36, base56, base62, base64, BaseConverter
+from django.utils.six.moves import xrange
 
 class TestBaseConv(TestCase):
 
     def test_baseconv(self):
-        nums = [-10 ** 10, 10 ** 10] + range(-100, 100)
+        nums = [-10 ** 10, 10 ** 10] + list(xrange(-100, 100))
         for converter in [base2, base16, base36, base56, base62, base64]:
             for i in nums:
                 self.assertEqual(i, converter.decode(converter.encode(i)))
-- 
cgit v1.3


From 127b461b11af985a52fb482f09c7cd7a08832f9d Mon Sep 17 00:00:00 2001
From: Aymeric Augustin <aymeric.augustin@m4x.org>
Date: Sun, 5 Aug 2012 16:12:10 +0200
Subject: [py3] Ported django.utils.crypto.

---
 django/utils/crypto.py                | 11 ++++++-----
 tests/regressiontests/utils/crypto.py | 28 ++++++++++++++++------------
 2 files changed, 22 insertions(+), 17 deletions(-)

(limited to 'tests')

diff --git a/django/utils/crypto.py b/django/utils/crypto.py
index 1edbb43eb3..70a07e7fde 100644
--- a/django/utils/crypto.py
+++ b/django/utils/crypto.py
@@ -50,7 +50,7 @@ def salted_hmac(key_salt, value, secret=None):
     # line is redundant and could be replaced by key = key_salt + secret, since
     # the hmac module does the same thing for keys longer than the block size.
     # However, we need to ensure that we *always* do this.
-    return hmac.new(key, msg=value, digestmod=hashlib.sha1)
+    return hmac.new(key, msg=smart_bytes(value), digestmod=hashlib.sha1)
 
 
 def get_random_string(length=12,
@@ -99,7 +99,7 @@ def _bin_to_long(x):
 
     This is a clever optimization for fast xor vector math
     """
-    return int(x.encode('hex'), 16)
+    return int(binascii.hexlify(x), 16)
 
 
 def _long_to_bin(x, hex_format_string):
@@ -112,13 +112,14 @@ def _long_to_bin(x, hex_format_string):
 
 def _fast_hmac(key, msg, digest):
     """
-    A trimmed down version of Python's HMAC implementation
+    A trimmed down version of Python's HMAC implementation.
+
+    This function operates on bytes.
     """
     dig1, dig2 = digest(), digest()
-    key = smart_bytes(key)
     if len(key) > dig1.block_size:
         key = digest(key).digest()
-    key += chr(0) * (dig1.block_size - len(key))
+    key += b'\x00' * (dig1.block_size - len(key))
     dig1.update(key.translate(_trans_36))
     dig1.update(msg)
     dig2.update(key.translate(_trans_5c))
diff --git a/tests/regressiontests/utils/crypto.py b/tests/regressiontests/utils/crypto.py
index 2bdc5ba530..52a286cb27 100644
--- a/tests/regressiontests/utils/crypto.py
+++ b/tests/regressiontests/utils/crypto.py
@@ -1,4 +1,6 @@
+from __future__ import unicode_literals
 
+import binascii
 import math
 import timeit
 import hashlib
@@ -108,15 +110,15 @@ class TestUtilsCryptoPBKDF2(unittest.TestCase):
                        "c4007d5298f9033c0241d5ab69305e7b64eceeb8d"
                        "834cfec"),
         },
-        # Check leading zeros are not stripped (#17481) 
+        # Check leading zeros are not stripped (#17481)
         {
-            "args": { 
-                "password": chr(186), 
-                "salt": "salt", 
-                "iterations": 1, 
-                "dklen": 20, 
-                "digest": hashlib.sha1, 
-            }, 
+            "args": {
+                "password": b'\xba',
+                "salt": "salt",
+                "iterations": 1,
+                "dklen": 20,
+                "digest": hashlib.sha1,
+            },
             "result": '0053d3b91a7f1e54effebd6d68771e8a6e0b2c5b',
         },
     ]
@@ -124,12 +126,14 @@ class TestUtilsCryptoPBKDF2(unittest.TestCase):
     def test_public_vectors(self):
         for vector in self.rfc_vectors:
             result = pbkdf2(**vector['args'])
-            self.assertEqual(result.encode('hex'), vector['result'])
+            self.assertEqual(binascii.hexlify(result).decode('ascii'),
+                             vector['result'])
 
     def test_regression_vectors(self):
         for vector in self.regression_vectors:
             result = pbkdf2(**vector['args'])
-            self.assertEqual(result.encode('hex'), vector['result'])
+            self.assertEqual(binascii.hexlify(result).decode('ascii'),
+                             vector['result'])
 
     def test_performance_scalability(self):
         """
@@ -140,11 +144,11 @@ class TestUtilsCryptoPBKDF2(unittest.TestCase):
         # to run the test suite and false positives caused by imprecise
         # measurement.
         n1, n2 = 200000, 800000
-        elapsed = lambda f: timeit.Timer(f, 
+        elapsed = lambda f: timeit.Timer(f,
                     'from django.utils.crypto import pbkdf2').timeit(number=1)
         t1 = elapsed('pbkdf2("password", "salt", iterations=%d)' % n1)
         t2 = elapsed('pbkdf2("password", "salt", iterations=%d)' % n2)
         measured_scale_exponent = math.log(t2 / t1, n2 / n1)
-        # This should be less than 1. We allow up to 1.2 so that tests don't 
+        # This should be less than 1. We allow up to 1.2 so that tests don't
         # fail nondeterministically too often.
         self.assertLess(measured_scale_exponent, 1.2)
-- 
cgit v1.3


From 02e6b6409b3df1766abdc3d6438b6f339a3163af Mon Sep 17 00:00:00 2001
From: Aymeric Augustin <aymeric.augustin@m4x.org>
Date: Sat, 4 Aug 2012 13:22:39 +0200
Subject: [py3] Ported django.utils.decorators.

---
 tests/regressiontests/utils/decorators.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/regressiontests/utils/decorators.py b/tests/regressiontests/utils/decorators.py
index 96f4dd4e7a..4d503df026 100644
--- a/tests/regressiontests/utils/decorators.py
+++ b/tests/regressiontests/utils/decorators.py
@@ -105,4 +105,4 @@ class DecoratorFromMiddlewareTests(TestCase):
         response.render()
         self.assertTrue(getattr(request, 'process_response_reached', False))
         # Check that process_response saw the rendered content
-        self.assertEqual(request.process_response_content, "Hello world")
+        self.assertEqual(request.process_response_content, b"Hello world")
-- 
cgit v1.3


From fe8484efda257e151d9c1ca5151e546c9262bf0f Mon Sep 17 00:00:00 2001
From: Aymeric Augustin <aymeric.augustin@m4x.org>
Date: Sat, 4 Aug 2012 15:55:53 +0200
Subject: [py3] Ported django.utils.functional.

---
 django/utils/functional.py                      | 58 ++++++++++++++++---------
 django/utils/safestring.py                      |  4 +-
 tests/regressiontests/utils/simplelazyobject.py | 26 +++++++----
 3 files changed, 57 insertions(+), 31 deletions(-)

(limited to 'tests')

diff --git a/django/utils/functional.py b/django/utils/functional.py
index 177325dfb6..085ec40b63 100644
--- a/django/utils/functional.py
+++ b/django/utils/functional.py
@@ -93,13 +93,19 @@ def lazy(func, *resultclasses):
                         if hasattr(cls, k):
                             continue
                         setattr(cls, k, meth)
-            cls._delegate_str = bytes in resultclasses
-            cls._delegate_unicode = six.text_type in resultclasses
-            assert not (cls._delegate_str and cls._delegate_unicode), "Cannot call lazy() with both str and unicode return types."
-            if cls._delegate_unicode:
-                cls.__unicode__ = cls.__unicode_cast
-            elif cls._delegate_str:
-                cls.__str__ = cls.__str_cast
+            cls._delegate_bytes = bytes in resultclasses
+            cls._delegate_text = six.text_type in resultclasses
+            assert not (cls._delegate_bytes and cls._delegate_text), "Cannot call lazy() with both bytes and text return types."
+            if cls._delegate_text:
+                if six.PY3:
+                    cls.__str__ = cls.__text_cast
+                else:
+                    cls.__unicode__ = cls.__text_cast
+            elif cls._delegate_bytes:
+                if six.PY3:
+                    cls.__bytes__ = cls.__bytes_cast
+                else:
+                    cls.__str__ = cls.__bytes_cast
         __prepare_class__ = classmethod(__prepare_class__)
 
         def __promise__(cls, klass, funcname, method):
@@ -120,17 +126,17 @@ def lazy(func, *resultclasses):
             return __wrapper__
         __promise__ = classmethod(__promise__)
 
-        def __unicode_cast(self):
+        def __text_cast(self):
             return func(*self.__args, **self.__kw)
 
-        def __str_cast(self):
-            return str(func(*self.__args, **self.__kw))
+        def __bytes_cast(self):
+            return bytes(func(*self.__args, **self.__kw))
 
         def __cast(self):
-            if self._delegate_str:
-                return self.__str_cast()
-            elif self._delegate_unicode:
-                return self.__unicode_cast()
+            if self._delegate_bytes:
+                return self.__bytes_cast()
+            elif self._delegate_text:
+                return self.__text_cast()
             else:
                 return func(*self.__args, **self.__kw)
 
@@ -144,10 +150,12 @@ def lazy(func, *resultclasses):
                 other = other.__cast()
             return self.__cast() < other
 
+        __hash__ = object.__hash__
+
         def __mod__(self, rhs):
-            if self._delegate_str:
-                return str(self) % rhs
-            elif self._delegate_unicode:
+            if self._delegate_bytes and not six.PY3:
+                return bytes(self) % rhs
+            elif self._delegate_text:
                 return six.text_type(self) % rhs
             else:
                 raise AssertionError('__mod__ not supported for non-string types')
@@ -234,6 +242,9 @@ class LazyObject(object):
     __dir__ = new_method_proxy(dir)
 
 
+# Workaround for http://bugs.python.org/issue12370
+_super = super
+
 class SimpleLazyObject(LazyObject):
     """
     A lazy object initialised from any function.
@@ -251,13 +262,17 @@ class SimpleLazyObject(LazyObject):
         value.
         """
         self.__dict__['_setupfunc'] = func
-        super(SimpleLazyObject, self).__init__()
+        _super(SimpleLazyObject, self).__init__()
 
     def _setup(self):
         self._wrapped = self._setupfunc()
 
-    __str__ = new_method_proxy(bytes)
-    __unicode__ = new_method_proxy(six.text_type)
+    if six.PY3:
+        __bytes__ = new_method_proxy(bytes)
+        __str__ = new_method_proxy(str)
+    else:
+        __str__ = new_method_proxy(str)
+        __unicode__ = new_method_proxy(unicode)
 
     def __deepcopy__(self, memo):
         if self._wrapped is empty:
@@ -284,7 +299,8 @@ class SimpleLazyObject(LazyObject):
     __class__ = property(new_method_proxy(operator.attrgetter("__class__")))
     __eq__ = new_method_proxy(operator.eq)
     __hash__ = new_method_proxy(hash)
-    __nonzero__ = new_method_proxy(bool)
+    __bool__ = new_method_proxy(bool)       # Python 3
+    __nonzero__ = __bool__                  # Python 2
 
 
 class lazy_property(property):
diff --git a/django/utils/safestring.py b/django/utils/safestring.py
index 1599fc2a66..bfaefd07ee 100644
--- a/django/utils/safestring.py
+++ b/django/utils/safestring.py
@@ -96,7 +96,7 @@ def mark_safe(s):
     """
     if isinstance(s, SafeData):
         return s
-    if isinstance(s, bytes) or (isinstance(s, Promise) and s._delegate_str):
+    if isinstance(s, bytes) or (isinstance(s, Promise) and s._delegate_bytes):
         return SafeString(s)
     if isinstance(s, (six.text_type, Promise)):
         return SafeUnicode(s)
@@ -112,7 +112,7 @@ def mark_for_escaping(s):
     """
     if isinstance(s, (SafeData, EscapeData)):
         return s
-    if isinstance(s, bytes) or (isinstance(s, Promise) and s._delegate_str):
+    if isinstance(s, bytes) or (isinstance(s, Promise) and s._delegate_bytes):
         return EscapeString(s)
     if isinstance(s, (six.text_type, Promise)):
         return EscapeUnicode(s)
diff --git a/tests/regressiontests/utils/simplelazyobject.py b/tests/regressiontests/utils/simplelazyobject.py
index 960a5e3201..3f81e8f608 100644
--- a/tests/regressiontests/utils/simplelazyobject.py
+++ b/tests/regressiontests/utils/simplelazyobject.py
@@ -19,17 +19,27 @@ class _ComplexObject(object):
     def __hash__(self):
         return hash(self.name)
 
-    def __str__(self):
-        return "I am _ComplexObject(%r)" % self.name
+    if six.PY3:
+        def __bytes__(self):
+            return ("I am _ComplexObject(%r)" % self.name).encode("utf-8")
 
-    def __unicode__(self):
-        return six.text_type(self.name)
+        def __str__(self):
+            return self.name
+
+    else:
+        def __str__(self):
+            return b"I am _ComplexObject(%r)" % str(self.name)
+
+        def __unicode__(self):
+            return self.name
 
     def __repr__(self):
         return "_ComplexObject(%r)" % self.name
 
+
 complex_object = lambda: _ComplexObject("joe")
 
+
 class TestUtilsSimpleLazyObject(TestCase):
     """
     Tests for SimpleLazyObject
@@ -54,11 +64,11 @@ class TestUtilsSimpleLazyObject(TestCase):
         # proxy __repr__
         self.assertTrue("SimpleLazyObject" in repr(SimpleLazyObject(complex_object)))
 
-    def test_str(self):
-        self.assertEqual(str_prefix("I am _ComplexObject(%(_)s'joe')"),
-            str(SimpleLazyObject(complex_object)))
+    def test_bytes(self):
+        self.assertEqual(b"I am _ComplexObject('joe')",
+                bytes(SimpleLazyObject(complex_object)))
 
-    def test_unicode(self):
+    def test_text(self):
         self.assertEqual("joe", six.text_type(SimpleLazyObject(complex_object)))
 
     def test_class(self):
-- 
cgit v1.3


From 46cc530fad3c6ae4009557121971fe749742aef6 Mon Sep 17 00:00:00 2001
From: Alex Gaynor <alex.gaynor@gmail.com>
Date: Tue, 7 Aug 2012 07:22:25 -0700
Subject: Fix a test that relied on an exception outliving the `except` block,
 which doesn't happen on py3k.

---
 tests/modeltests/validation/models.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'tests')

diff --git a/tests/modeltests/validation/models.py b/tests/modeltests/validation/models.py
index 0adc9fec32..26fff4b863 100644
--- a/tests/modeltests/validation/models.py
+++ b/tests/modeltests/validation/models.py
@@ -101,6 +101,6 @@ try:
     class MultipleAutoFields(models.Model):
         auto1 = models.AutoField(primary_key=True)
         auto2 = models.AutoField(primary_key=True)
-except AssertionError as assertion_error:
-    pass # Fail silently
+except AssertionError as exc:
+    assertion_error = exc
 assert str(assertion_error) == "A model can't have more than one AutoField."
-- 
cgit v1.3


From 396357741b88dfcd85486db673dbb822da8b2de0 Mon Sep 17 00:00:00 2001
From: Aymeric Augustin <aymeric.augustin@m4x.org>
Date: Tue, 7 Aug 2012 15:41:54 +0200
Subject: [py3] Used compatible imports of StringIO.

---
 tests/modeltests/fixtures/tests.py                | 9 ++++-----
 tests/modeltests/serializers/tests.py             | 2 +-
 tests/modeltests/user_commands/tests.py           | 2 +-
 tests/regressiontests/bash_completion/tests.py    | 4 ++--
 tests/regressiontests/builtin_server/tests.py     | 3 +--
 tests/regressiontests/createsuperuser/tests.py    | 3 +--
 tests/regressiontests/file_uploads/tests.py       | 2 +-
 tests/regressiontests/i18n/commands/extraction.py | 2 +-
 tests/regressiontests/inspectdb/tests.py          | 3 +--
 tests/regressiontests/mail/tests.py               | 2 +-
 tests/regressiontests/middleware/tests.py         | 4 ++--
 tests/regressiontests/multiple_database/tests.py  | 2 +-
 tests/regressiontests/requests/tests.py           | 2 +-
 tests/regressiontests/templates/loaders.py        | 6 +++---
 tests/regressiontests/test_utils/tests.py         | 2 +-
 15 files changed, 22 insertions(+), 26 deletions(-)

(limited to 'tests')

diff --git a/tests/modeltests/fixtures/tests.py b/tests/modeltests/fixtures/tests.py
index 1efa035e8a..b332348425 100644
--- a/tests/modeltests/fixtures/tests.py
+++ b/tests/modeltests/fixtures/tests.py
@@ -1,11 +1,10 @@
 from __future__ import absolute_import
 
-import StringIO
-
 from django.contrib.sites.models import Site
 from django.core import management
 from django.db import connection, IntegrityError
 from django.test import TestCase, TransactionTestCase, skipUnlessDBFeature
+from django.utils.six import StringIO
 
 from .models import Article, Book, Spy, Tag, Visa
 
@@ -26,7 +25,7 @@ class FixtureLoadingTests(TestCase):
 
     def _dumpdata_assert(self, args, output, format='json', natural_keys=False,
                          use_base_manager=False, exclude_list=[]):
-        new_io = StringIO.StringIO()
+        new_io = StringIO()
         management.call_command('dumpdata', *args, **{'format':format,
                                                       'stdout':new_io,
                                                       'stderr':new_io,
@@ -43,7 +42,7 @@ class FixtureLoadingTests(TestCase):
         ])
 
     def test_loading_and_dumping(self):
-        new_io = StringIO.StringIO()
+        new_io = StringIO()
 
         Site.objects.all().delete()
         # Load fixture 1. Single JSON file, with two objects.
@@ -293,7 +292,7 @@ class FixtureLoadingTests(TestCase):
 
 class FixtureTransactionTests(TransactionTestCase):
     def _dumpdata_assert(self, args, output, format='json'):
-        new_io = StringIO.StringIO()
+        new_io = StringIO()
         management.call_command('dumpdata', *args, **{'format':format, 'stdout':new_io})
         command_output = new_io.getvalue().strip()
         self.assertEqual(command_output, output)
diff --git a/tests/modeltests/serializers/tests.py b/tests/modeltests/serializers/tests.py
index 9177227539..ec3cc132db 100644
--- a/tests/modeltests/serializers/tests.py
+++ b/tests/modeltests/serializers/tests.py
@@ -4,13 +4,13 @@ from __future__ import absolute_import, unicode_literals
 import json
 from datetime import datetime
 from xml.dom import minidom
-from StringIO import StringIO
 
 from django.conf import settings
 from django.core import serializers
 from django.db import transaction, connection
 from django.test import TestCase, TransactionTestCase, Approximate
 from django.utils import six
+from django.utils.six import StringIO
 from django.utils import unittest
 
 from .models import (Category, Author, Article, AuthorProfile, Actor, Movie,
diff --git a/tests/modeltests/user_commands/tests.py b/tests/modeltests/user_commands/tests.py
index 509f13f62f..d25911c09f 100644
--- a/tests/modeltests/user_commands/tests.py
+++ b/tests/modeltests/user_commands/tests.py
@@ -1,10 +1,10 @@
 import sys
-from StringIO import StringIO
 
 from django.core import management
 from django.core.management.base import CommandError
 from django.test import TestCase
 from django.utils import translation
+from django.utils.six import StringIO
 
 
 class CommandTests(TestCase):
diff --git a/tests/regressiontests/bash_completion/tests.py b/tests/regressiontests/bash_completion/tests.py
index e4b3bb58f3..ed8cedf1ab 100644
--- a/tests/regressiontests/bash_completion/tests.py
+++ b/tests/regressiontests/bash_completion/tests.py
@@ -3,11 +3,11 @@ A series of tests to establish that the command-line bash completion works.
 """
 import os
 import sys
-import StringIO
 
 from django.conf import settings
 from django.core.management import ManagementUtility
 from django.utils import unittest
+from django.utils.six import StringIO
 
 
 class BashCompletionTests(unittest.TestCase):
@@ -20,7 +20,7 @@ class BashCompletionTests(unittest.TestCase):
     def setUp(self):
         self.old_DJANGO_AUTO_COMPLETE = os.environ.get('DJANGO_AUTO_COMPLETE')
         os.environ['DJANGO_AUTO_COMPLETE'] = '1'
-        self.output = StringIO.StringIO()
+        self.output = StringIO()
         self.old_stdout = sys.stdout
         sys.stdout = self.output
 
diff --git a/tests/regressiontests/builtin_server/tests.py b/tests/regressiontests/builtin_server/tests.py
index aeb5d9febf..4a3b44176b 100644
--- a/tests/regressiontests/builtin_server/tests.py
+++ b/tests/regressiontests/builtin_server/tests.py
@@ -1,6 +1,5 @@
-from StringIO import StringIO
-
 from django.core.servers.basehttp import ServerHandler
+from django.utils.six import StringIO
 from django.utils.unittest import TestCase
 
 #
diff --git a/tests/regressiontests/createsuperuser/tests.py b/tests/regressiontests/createsuperuser/tests.py
index 1c1bb0ed38..7303b1f2e7 100644
--- a/tests/regressiontests/createsuperuser/tests.py
+++ b/tests/regressiontests/createsuperuser/tests.py
@@ -1,9 +1,8 @@
-from StringIO import StringIO
-
 from django.contrib.auth import models
 from django.contrib.auth.management.commands import changepassword
 from django.core.management import call_command
 from django.test import TestCase
+from django.utils.six import StringIO
 
 
 class MultiDBChangepasswordManagementCommandTestCase(TestCase):
diff --git a/tests/regressiontests/file_uploads/tests.py b/tests/regressiontests/file_uploads/tests.py
index 9fe3ca15a7..d2362d7197 100644
--- a/tests/regressiontests/file_uploads/tests.py
+++ b/tests/regressiontests/file_uploads/tests.py
@@ -7,12 +7,12 @@ import hashlib
 import json
 import os
 import shutil
-from StringIO import StringIO
 
 from django.core.files import temp as tempfile
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.http.multipartparser import MultiPartParser
 from django.test import TestCase, client
+from django.utils.six import StringIO
 from django.utils import unittest
 
 from . import uploadhandler
diff --git a/tests/regressiontests/i18n/commands/extraction.py b/tests/regressiontests/i18n/commands/extraction.py
index cd6d50893a..29d9e277ff 100644
--- a/tests/regressiontests/i18n/commands/extraction.py
+++ b/tests/regressiontests/i18n/commands/extraction.py
@@ -3,10 +3,10 @@
 import os
 import re
 import shutil
-from StringIO import StringIO
 
 from django.core import management
 from django.test import TestCase
+from django.utils.six import StringIO
 
 
 LOCALE='de'
diff --git a/tests/regressiontests/inspectdb/tests.py b/tests/regressiontests/inspectdb/tests.py
index 29435b8375..aae7bc5cc7 100644
--- a/tests/regressiontests/inspectdb/tests.py
+++ b/tests/regressiontests/inspectdb/tests.py
@@ -1,7 +1,6 @@
-from StringIO import StringIO
-
 from django.core.management import call_command
 from django.test import TestCase, skipUnlessDBFeature
+from django.utils.six import StringIO
 
 
 class InspectDBTestCase(TestCase):
diff --git a/tests/regressiontests/mail/tests.py b/tests/regressiontests/mail/tests.py
index 2215f56523..0d0af19427 100644
--- a/tests/regressiontests/mail/tests.py
+++ b/tests/regressiontests/mail/tests.py
@@ -7,7 +7,6 @@ import os
 import shutil
 import smtpd
 import sys
-from StringIO import StringIO
 import tempfile
 import threading
 
@@ -18,6 +17,7 @@ from django.core.mail.backends import console, dummy, locmem, filebased, smtp
 from django.core.mail.message import BadHeaderError
 from django.test import TestCase
 from django.test.utils import override_settings
+from django.utils.six import StringIO
 from django.utils.translation import ugettext_lazy
 
 
diff --git a/tests/regressiontests/middleware/tests.py b/tests/regressiontests/middleware/tests.py
index ead34f46db..08a385e6cf 100644
--- a/tests/regressiontests/middleware/tests.py
+++ b/tests/regressiontests/middleware/tests.py
@@ -3,7 +3,6 @@
 import gzip
 import re
 import random
-import StringIO
 
 from django.conf import settings
 from django.core import mail
@@ -16,6 +15,7 @@ from django.middleware.gzip import GZipMiddleware
 from django.test import TestCase, RequestFactory
 from django.test.utils import override_settings
 from django.utils.six.moves import xrange
+from django.utils.six import StringIO
 
 class CommonMiddlewareTest(TestCase):
     def setUp(self):
@@ -526,7 +526,7 @@ class GZipMiddlewareTest(TestCase):
 
     @staticmethod
     def decompress(gzipped_string):
-        return gzip.GzipFile(mode='rb', fileobj=StringIO.StringIO(gzipped_string)).read()
+        return gzip.GzipFile(mode='rb', fileobj=StringIO(gzipped_string)).read()
 
     def test_compress_response(self):
         """
diff --git a/tests/regressiontests/multiple_database/tests.py b/tests/regressiontests/multiple_database/tests.py
index 595c5edb3b..08632fd4ce 100644
--- a/tests/regressiontests/multiple_database/tests.py
+++ b/tests/regressiontests/multiple_database/tests.py
@@ -2,7 +2,6 @@ from __future__ import absolute_import, unicode_literals
 
 import datetime
 import pickle
-from StringIO import StringIO
 
 from django.conf import settings
 from django.contrib.auth.models import User
@@ -11,6 +10,7 @@ from django.core import management
 from django.db import connections, router, DEFAULT_DB_ALIAS
 from django.db.models import signals
 from django.test import TestCase
+from django.utils.six import StringIO
 
 from .models import Book, Person, Pet, Review, UserProfile
 
diff --git a/tests/regressiontests/requests/tests.py b/tests/regressiontests/requests/tests.py
index 146dca2b7b..f192459246 100644
--- a/tests/regressiontests/requests/tests.py
+++ b/tests/regressiontests/requests/tests.py
@@ -3,7 +3,6 @@ from __future__ import unicode_literals
 import time
 import warnings
 from datetime import datetime, timedelta
-from StringIO import StringIO
 
 from django.conf import settings
 from django.core.handlers.wsgi import WSGIRequest, LimitedStream
@@ -11,6 +10,7 @@ from django.http import HttpRequest, HttpResponse, parse_cookie, build_request_r
 from django.test.utils import str_prefix
 from django.utils import unittest
 from django.utils.http import cookie_date
+from django.utils.six import StringIO
 from django.utils.timezone import utc
 
 
diff --git a/tests/regressiontests/templates/loaders.py b/tests/regressiontests/templates/loaders.py
index 5c11916308..6b635c8f23 100644
--- a/tests/regressiontests/templates/loaders.py
+++ b/tests/regressiontests/templates/loaders.py
@@ -12,13 +12,13 @@ if __name__ == '__main__':
 import sys
 import pkg_resources
 import imp
-import StringIO
 import os.path
 
 from django.template import TemplateDoesNotExist, Context
 from django.template.loaders.eggs import Loader as EggLoader
 from django.template import loader
 from django.utils import unittest
+from django.utils.six import StringIO
 
 
 # Mock classes and objects for pkg_resources functions.
@@ -61,8 +61,8 @@ class EggLoaderTest(unittest.TestCase):
 
         self.empty_egg = create_egg("egg_empty", {})
         self.egg_1 = create_egg("egg_1", {
-            os.path.normcase('templates/y.html') : StringIO.StringIO("y"),
-            os.path.normcase('templates/x.txt') : StringIO.StringIO("x"),
+            os.path.normcase('templates/y.html') : StringIO("y"),
+            os.path.normcase('templates/x.txt') : StringIO("x"),
         })
         self._old_installed_apps = settings.INSTALLED_APPS
         settings.INSTALLED_APPS = []
diff --git a/tests/regressiontests/test_utils/tests.py b/tests/regressiontests/test_utils/tests.py
index 46479ebe8b..f43a855a59 100644
--- a/tests/regressiontests/test_utils/tests.py
+++ b/tests/regressiontests/test_utils/tests.py
@@ -493,7 +493,7 @@ __test__ = {"API_TEST": r"""
 # Standard doctests do fairly
 >>> import json
 >>> from django.utils.xmlutils import SimplerXMLGenerator
->>> from StringIO import StringIO
+>>> from django.utils.six import StringIO
 
 >>> def produce_long():
 ...     return 42L
-- 
cgit v1.3


From 0955d16a165e9da2f69813cc9983fd10dddbfa62 Mon Sep 17 00:00:00 2001
From: Alex Gaynor <alex.gaynor@gmail.com>
Date: Wed, 8 Aug 2012 07:50:59 -0700
Subject: Switched to using the standard method for comparing querysets in teh
 templates.

---
 tests/regressiontests/multiple_database/tests.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'tests')

diff --git a/tests/regressiontests/multiple_database/tests.py b/tests/regressiontests/multiple_database/tests.py
index 08632fd4ce..74a5f2f550 100644
--- a/tests/regressiontests/multiple_database/tests.py
+++ b/tests/regressiontests/multiple_database/tests.py
@@ -2,6 +2,7 @@ from __future__ import absolute_import, unicode_literals
 
 import datetime
 import pickle
+from operator import attrgetter
 
 from django.conf import settings
 from django.contrib.auth.models import User
@@ -873,10 +874,10 @@ class QueryTestCase(TestCase):
         dive = Book.objects.using('other').create(title="Dive into Python",
             published=datetime.date(2009, 5, 4))
         val = Book.objects.db_manager("other").raw('SELECT id FROM multiple_database_book')
-        self.assertEqual(map(lambda o: o.pk, val), [dive.pk])
+        self.assertQuerysetEqual(val, [dive.pk], attrgetter("pk"))
 
         val = Book.objects.raw('SELECT id FROM multiple_database_book').using('other')
-        self.assertEqual(map(lambda o: o.pk, val), [dive.pk])
+        self.assertQuerysetEqual(val, [dive.pk], attrgetter("pk"))
 
     def test_select_related(self):
         "Database assignment is retained if an object is retrieved with select_related()"
-- 
cgit v1.3


From 96a6912ec5183e2b338bf2e1b655ea10760bfb54 Mon Sep 17 00:00:00 2001
From: Claude Paroz <claude@2xlibre.net>
Date: Wed, 8 Aug 2012 23:40:20 +0200
Subject: [py3] Fixed compilemessages tests

---
 django/core/management/commands/compilemessages.py | 4 +++-
 tests/regressiontests/i18n/commands/compilation.py | 8 ++++----
 2 files changed, 7 insertions(+), 5 deletions(-)

(limited to 'tests')

diff --git a/django/core/management/commands/compilemessages.py b/django/core/management/commands/compilemessages.py
index fdc3535cf6..b7392b9173 100644
--- a/django/core/management/commands/compilemessages.py
+++ b/django/core/management/commands/compilemessages.py
@@ -1,3 +1,5 @@
+from __future__ import unicode_literals
+
 import codecs
 import os
 import sys
@@ -7,7 +9,7 @@ from django.core.management.base import BaseCommand, CommandError
 def has_bom(fn):
     with open(fn, 'rb') as f:
         sample = f.read(4)
-    return sample[:3] == '\xef\xbb\xbf' or \
+    return sample[:3] == b'\xef\xbb\xbf' or \
             sample.startswith(codecs.BOM_UTF16_LE) or \
             sample.startswith(codecs.BOM_UTF16_BE)
 
diff --git a/tests/regressiontests/i18n/commands/compilation.py b/tests/regressiontests/i18n/commands/compilation.py
index d88e1feef6..b6119cf43d 100644
--- a/tests/regressiontests/i18n/commands/compilation.py
+++ b/tests/regressiontests/i18n/commands/compilation.py
@@ -1,10 +1,10 @@
 import os
-from io import BytesIO
 
 from django.core.management import call_command, CommandError
 from django.test import TestCase
 from django.test.utils import override_settings
 from django.utils import translation
+from django.utils.six import StringIO
 
 test_dir = os.path.abspath(os.path.dirname(__file__))
 
@@ -26,7 +26,7 @@ class PoFileTests(MessageCompilationTests):
         os.chdir(test_dir)
         with self.assertRaisesRegexp(CommandError,
                 "file has a BOM \(Byte Order Mark\)"):
-            call_command('compilemessages', locale=self.LOCALE, stderr=BytesIO())
+            call_command('compilemessages', locale=self.LOCALE, stderr=StringIO())
         self.assertFalse(os.path.exists(self.MO_FILE))
 
 
@@ -42,7 +42,7 @@ class PoFileContentsTests(MessageCompilationTests):
 
     def test_percent_symbol_in_po_file(self):
         os.chdir(test_dir)
-        call_command('compilemessages', locale=self.LOCALE, stderr=BytesIO())
+        call_command('compilemessages', locale=self.LOCALE, stderr=StringIO())
         self.assertTrue(os.path.exists(self.MO_FILE))
 
 
@@ -57,7 +57,7 @@ class PercentRenderingTests(MessageCompilationTests):
     def test_percent_symbol_escaping(self):
         from django.template import Template, Context
         os.chdir(test_dir)
-        call_command('compilemessages', locale=self.LOCALE, stderr=BytesIO())
+        call_command('compilemessages', locale=self.LOCALE, stderr=StringIO())
         with translation.override(self.LOCALE):
             t = Template('{% load i18n %}{% trans "Looks like a str fmt spec %% o but shouldn\'t be interpreted as such" %}')
             rendered = t.render(Context({}))
-- 
cgit v1.3


From 751774c29f6ad8f6ad08bc48a4d085829dd279e0 Mon Sep 17 00:00:00 2001
From: Claude Paroz <claude@2xlibre.net>
Date: Thu, 9 Aug 2012 12:12:22 +0200
Subject: [py3] Fixed mail tests with Python 3

---
 django/core/mail/message.py         | 34 +++++++++++------------
 tests/regressiontests/mail/tests.py | 54 ++++++++++++++++++++-----------------
 2 files changed, 46 insertions(+), 42 deletions(-)

(limited to 'tests')

diff --git a/django/core/mail/message.py b/django/core/mail/message.py
index 8f589ae33d..b332ffba04 100644
--- a/django/core/mail/message.py
+++ b/django/core/mail/message.py
@@ -11,11 +11,10 @@ from email.mime.multipart import MIMEMultipart
 from email.mime.base import MIMEBase
 from email.header import Header
 from email.utils import formatdate, getaddresses, formataddr, parseaddr
-from io import BytesIO
 
 from django.conf import settings
 from django.core.mail.utils import DNS_NAME
-from django.utils.encoding import smart_bytes, force_text
+from django.utils.encoding import force_text
 from django.utils import six
 
 
@@ -83,34 +82,34 @@ def forbid_multi_line_headers(name, val, encoding):
     if '\n' in val or '\r' in val:
         raise BadHeaderError("Header values can't contain newlines (got %r for header %r)" % (val, name))
     try:
-        val = val.encode('ascii')
+        val.encode('ascii')
     except UnicodeEncodeError:
         if name.lower() in ADDRESS_HEADERS:
             val = ', '.join(sanitize_address(addr, encoding)
                 for addr in getaddresses((val,)))
         else:
-            val = str(Header(val, encoding))
+            val = Header(val, encoding).encode()
     else:
         if name.lower() == 'subject':
-            val = Header(val)
-    return smart_bytes(name), val
+            val = Header(val).encode()
+    return str(name), val
 
 
 def sanitize_address(addr, encoding):
     if isinstance(addr, six.string_types):
         addr = parseaddr(force_text(addr))
     nm, addr = addr
-    nm = str(Header(nm, encoding))
+    nm = Header(nm, encoding).encode()
     try:
-        addr = addr.encode('ascii')
+        addr.encode('ascii')
     except UnicodeEncodeError:  # IDN
         if '@' in addr:
             localpart, domain = addr.split('@', 1)
             localpart = str(Header(localpart, encoding))
-            domain = domain.encode('idna')
+            domain = domain.encode('idna').decode('ascii')
             addr = '@'.join([localpart, domain])
         else:
-            addr = str(Header(addr, encoding))
+            addr = Header(addr, encoding).encode()
     return formataddr((nm, addr))
 
 
@@ -132,7 +131,7 @@ class SafeMIMEText(MIMEText):
         This overrides the default as_string() implementation to not mangle
         lines that begin with 'From '. See bug #13433 for details.
         """
-        fp = BytesIO()
+        fp = six.StringIO()
         g = Generator(fp, mangle_from_ = False)
         g.flatten(self, unixfrom=unixfrom)
         return fp.getvalue()
@@ -156,7 +155,7 @@ class SafeMIMEMultipart(MIMEMultipart):
         This overrides the default as_string() implementation to not mangle
         lines that begin with 'From '. See bug #13433 for details.
         """
-        fp = BytesIO()
+        fp = six.StringIO()
         g = Generator(fp, mangle_from_ = False)
         g.flatten(self, unixfrom=unixfrom)
         return fp.getvalue()
@@ -210,8 +209,7 @@ class EmailMessage(object):
 
     def message(self):
         encoding = self.encoding or settings.DEFAULT_CHARSET
-        msg = SafeMIMEText(smart_bytes(self.body, encoding),
-                           self.content_subtype, encoding)
+        msg = SafeMIMEText(self.body, self.content_subtype, encoding)
         msg = self._create_message(msg)
         msg['Subject'] = self.subject
         msg['From'] = self.extra_headers.get('From', self.from_email)
@@ -293,7 +291,7 @@ class EmailMessage(object):
         basetype, subtype = mimetype.split('/', 1)
         if basetype == 'text':
             encoding = self.encoding or settings.DEFAULT_CHARSET
-            attachment = SafeMIMEText(smart_bytes(content, encoding), subtype, encoding)
+            attachment = SafeMIMEText(content, subtype, encoding)
         else:
             # Encode non-text attachments with base64.
             attachment = MIMEBase(basetype, subtype)
@@ -313,9 +311,11 @@ class EmailMessage(object):
         attachment = self._create_mime_attachment(content, mimetype)
         if filename:
             try:
-                filename = filename.encode('ascii')
+                filename.encode('ascii')
             except UnicodeEncodeError:
-                filename = ('utf-8', '', filename.encode('utf-8'))
+                if not six.PY3:
+                    filename = filename.encode('utf-8')
+                filename = ('utf-8', '', filename)
             attachment.add_header('Content-Disposition', 'attachment',
                                   filename=filename)
         return attachment
diff --git a/tests/regressiontests/mail/tests.py b/tests/regressiontests/mail/tests.py
index 0d0af19427..c948662bc3 100644
--- a/tests/regressiontests/mail/tests.py
+++ b/tests/regressiontests/mail/tests.py
@@ -17,7 +17,7 @@ from django.core.mail.backends import console, dummy, locmem, filebased, smtp
 from django.core.mail.message import BadHeaderError
 from django.test import TestCase
 from django.test.utils import override_settings
-from django.utils.six import StringIO
+from django.utils.six import PY3, StringIO
 from django.utils.translation import ugettext_lazy
 
 
@@ -29,7 +29,7 @@ class MailTests(TestCase):
     def test_ascii(self):
         email = EmailMessage('Subject', 'Content', 'from@example.com', ['to@example.com'])
         message = email.message()
-        self.assertEqual(message['Subject'].encode(), 'Subject')
+        self.assertEqual(message['Subject'], 'Subject')
         self.assertEqual(message.get_payload(), 'Content')
         self.assertEqual(message['From'], 'from@example.com')
         self.assertEqual(message['To'], 'to@example.com')
@@ -37,7 +37,7 @@ class MailTests(TestCase):
     def test_multiple_recipients(self):
         email = EmailMessage('Subject', 'Content', 'from@example.com', ['to@example.com', 'other@example.com'])
         message = email.message()
-        self.assertEqual(message['Subject'].encode(), 'Subject')
+        self.assertEqual(message['Subject'], 'Subject')
         self.assertEqual(message.get_payload(), 'Content')
         self.assertEqual(message['From'], 'from@example.com')
         self.assertEqual(message['To'], 'to@example.com, other@example.com')
@@ -77,9 +77,10 @@ class MailTests(TestCase):
         """
         Test for space continuation character in long (ascii) subject headers (#7747)
         """
-        email = EmailMessage('Long subject lines that get wrapped should use a space continuation character to get expected behavior in Outlook and Thunderbird', 'Content', 'from@example.com', ['to@example.com'])
+        email = EmailMessage('Long subject lines that get wrapped should contain a space continuation character to get expected behavior in Outlook and Thunderbird', 'Content', 'from@example.com', ['to@example.com'])
         message = email.message()
-        self.assertEqual(message['Subject'], 'Long subject lines that get wrapped should use a space continuation\n character to get expected behavior in Outlook and Thunderbird')
+        # Note that in Python 3, maximum line length has increased from 76 to 78
+        self.assertEqual(message['Subject'].encode(), b'Long subject lines that get wrapped should contain a space continuation\n character to get expected behavior in Outlook and Thunderbird')
 
     def test_message_header_overrides(self):
         """
@@ -88,7 +89,7 @@ class MailTests(TestCase):
         """
         headers = {"date": "Fri, 09 Nov 2001 01:08:47 -0000", "Message-ID": "foo"}
         email = EmailMessage('subject', 'content', 'from@example.com', ['to@example.com'], headers=headers)
-        self.assertEqual(email.message().as_string(), b'Content-Type: text/plain; charset="utf-8"\nMIME-Version: 1.0\nContent-Transfer-Encoding: 7bit\nSubject: subject\nFrom: from@example.com\nTo: to@example.com\ndate: Fri, 09 Nov 2001 01:08:47 -0000\nMessage-ID: foo\n\ncontent')
+        self.assertEqual(email.message().as_string(), 'Content-Type: text/plain; charset="utf-8"\nMIME-Version: 1.0\nContent-Transfer-Encoding: 7bit\nSubject: subject\nFrom: from@example.com\nTo: to@example.com\ndate: Fri, 09 Nov 2001 01:08:47 -0000\nMessage-ID: foo\n\ncontent')
 
     def test_from_header(self):
         """
@@ -160,7 +161,7 @@ class MailTests(TestCase):
         msg.attach_alternative(html_content, "text/html")
         msg.encoding = 'iso-8859-1'
         self.assertEqual(msg.message()['To'], '=?iso-8859-1?q?S=FCrname=2C_Firstname?= <to@example.com>')
-        self.assertEqual(msg.message()['Subject'].encode(), '=?iso-8859-1?q?Message_from_Firstname_S=FCrname?=')
+        self.assertEqual(msg.message()['Subject'], '=?iso-8859-1?q?Message_from_Firstname_S=FCrname?=')
 
     def test_encoding(self):
         """
@@ -170,7 +171,7 @@ class MailTests(TestCase):
         email = EmailMessage('Subject', 'Firstname Sürname is a great guy.', 'from@example.com', ['other@example.com'])
         email.encoding = 'iso-8859-1'
         message = email.message()
-        self.assertTrue(message.as_string().startswith(b'Content-Type: text/plain; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\nSubject: Subject\nFrom: from@example.com\nTo: other@example.com'))
+        self.assertTrue(message.as_string().startswith('Content-Type: text/plain; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\nSubject: Subject\nFrom: from@example.com\nTo: other@example.com'))
         self.assertEqual(message.get_payload(), 'Firstname S=FCrname is a great guy.')
 
         # Make sure MIME attachments also works correctly with other encodings than utf-8
@@ -179,8 +180,8 @@ class MailTests(TestCase):
         msg = EmailMultiAlternatives('Subject', text_content, 'from@example.com', ['to@example.com'])
         msg.encoding = 'iso-8859-1'
         msg.attach_alternative(html_content, "text/html")
-        self.assertEqual(msg.message().get_payload(0).as_string(), b'Content-Type: text/plain; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\n\nFirstname S=FCrname is a great guy.')
-        self.assertEqual(msg.message().get_payload(1).as_string(), b'Content-Type: text/html; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\n\n<p>Firstname S=FCrname is a <strong>great</strong> guy.</p>')
+        self.assertEqual(msg.message().get_payload(0).as_string(), 'Content-Type: text/plain; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\n\nFirstname S=FCrname is a great guy.')
+        self.assertEqual(msg.message().get_payload(1).as_string(), 'Content-Type: text/html; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\n\n<p>Firstname S=FCrname is a <strong>great</strong> guy.</p>')
 
     def test_attachments(self):
         """Regression test for #9367"""
@@ -291,31 +292,31 @@ class MailTests(TestCase):
         # Regression for #13433 - Make sure that EmailMessage doesn't mangle
         # 'From ' in message body.
         email = EmailMessage('Subject', 'From the future', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
-        self.assertFalse(b'>From the future' in email.message().as_string())
+        self.assertFalse('>From the future' in email.message().as_string())
 
     def test_dont_base64_encode(self):
         # Ticket #3472
         # Shouldn't use Base64 encoding at all
         msg = EmailMessage('Subject', 'UTF-8 encoded body', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
-        self.assertFalse(b'Content-Transfer-Encoding: base64' in msg.message().as_string())
+        self.assertFalse('Content-Transfer-Encoding: base64' in msg.message().as_string())
 
         # Ticket #11212
         # Shouldn't use quoted printable, should detect it can represent content with 7 bit data
         msg = EmailMessage('Subject', 'Body with only ASCII characters.', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
         s = msg.message().as_string()
-        self.assertFalse(b'Content-Transfer-Encoding: quoted-printable' in s)
-        self.assertTrue(b'Content-Transfer-Encoding: 7bit' in s)
+        self.assertFalse('Content-Transfer-Encoding: quoted-printable' in s)
+        self.assertTrue('Content-Transfer-Encoding: 7bit' in s)
 
         # Shouldn't use quoted printable, should detect it can represent content with 8 bit data
         msg = EmailMessage('Subject', 'Body with latin characters: àáä.', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
         s = msg.message().as_string()
-        self.assertFalse(b'Content-Transfer-Encoding: quoted-printable' in s)
-        self.assertTrue(b'Content-Transfer-Encoding: 8bit' in s)
+        self.assertFalse(str('Content-Transfer-Encoding: quoted-printable') in s)
+        self.assertTrue(str('Content-Transfer-Encoding: 8bit') in s)
 
         msg = EmailMessage('Subject', 'Body with non latin characters: А Б В Г Д Е Ж Ѕ З И І К Л М Н О П.', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
         s = msg.message().as_string()
-        self.assertFalse(b'Content-Transfer-Encoding: quoted-printable' in s)
-        self.assertTrue(b'Content-Transfer-Encoding: 8bit' in s)
+        self.assertFalse(str('Content-Transfer-Encoding: quoted-printable') in s)
+        self.assertTrue(str('Content-Transfer-Encoding: 8bit') in s)
 
 
 class BaseEmailBackendTests(object):
@@ -440,7 +441,7 @@ class BaseEmailBackendTests(object):
         email = EmailMessage('Subject', 'Content', 'from@example.com', ['to@example.com'], cc=['cc@example.com'])
         mail.get_connection().send_messages([email])
         message = self.get_the_message()
-        self.assertStartsWith(message.as_string(), b'Content-Type: text/plain; charset="utf-8"\nMIME-Version: 1.0\nContent-Transfer-Encoding: 7bit\nSubject: Subject\nFrom: from@example.com\nTo: to@example.com\nCc: cc@example.com\nDate: ')
+        self.assertStartsWith(message.as_string(), 'Content-Type: text/plain; charset="utf-8"\nMIME-Version: 1.0\nContent-Transfer-Encoding: 7bit\nSubject: Subject\nFrom: from@example.com\nTo: to@example.com\nCc: cc@example.com\nDate: ')
 
     def test_idn_send(self):
         """
@@ -519,9 +520,9 @@ class FileBackendTests(BaseEmailBackendTests, TestCase):
     def get_mailbox_content(self):
         messages = []
         for filename in os.listdir(self.tmp_dir):
-            with open(os.path.join(self.tmp_dir, filename), 'rb') as fp:
-                session = fp.read().split(b'\n' + (b'-' * 79) + b'\n')
-            messages.extend(email.message_from_string(m) for m in session if m)
+            with open(os.path.join(self.tmp_dir, filename), 'r') as fp:
+                session = fp.read().split('\n' + ('-' * 79) + '\n')
+            messages.extend(email.message_from_string(str(m)) for m in session if m)
         return messages
 
     def test_file_sessions(self):
@@ -571,8 +572,8 @@ class ConsoleBackendTests(BaseEmailBackendTests, TestCase):
         self.stream = sys.stdout = StringIO()
 
     def get_mailbox_content(self):
-        messages = self.stream.getvalue().split(b'\n' + (b'-' * 79) + b'\n')
-        return [email.message_from_string(m) for m in messages if m]
+        messages = self.stream.getvalue().split('\n' + ('-' * 79) + '\n')
+        return [email.message_from_string(str(m)) for m in messages if m]
 
     def test_console_stream_kwarg(self):
         """
@@ -600,7 +601,10 @@ class FakeSMTPServer(smtpd.SMTPServer, threading.Thread):
 
     def process_message(self, peer, mailfrom, rcpttos, data):
         m = email.message_from_string(data)
-        maddr = email.Utils.parseaddr(m.get('from'))[1]
+        if PY3:
+            maddr = email.utils.parseaddr(m.get('from'))[1]
+        else:
+            maddr = email.Utils.parseaddr(m.get('from'))[1]
         if mailfrom != maddr:
             return "553 '%s' != '%s'" % (mailfrom, maddr)
         with self.sink_lock:
-- 
cgit v1.3