Refs #23919 -- Removed six.<various>_types usage

Thanks Tim Graham and Simon Charette for the reviews.

12 files changed, 49 insertions, 56 deletions

diff --git a/django/utils/archive.py b/django/utils/archive.py
index 57e87658a6..456145a520 100644
--- a/django/utils/archive.py
+++ b/django/utils/archive.py
@@ -27,8 +27,6 @@ import stat
 import tarfile
 import zipfile
 
-from django.utils import six
-
 
 class ArchiveException(Exception):
     """
@@ -61,7 +59,7 @@ class Archive(object):
     @staticmethod
     def _archive_cls(file):
         cls = None
-        if isinstance(file, six.string_types):
+        if isinstance(file, str):
             filename = file
         else:
             try:
diff --git a/django/utils/dateformat.py b/django/utils/dateformat.py
index 861bf8f923..ded952df99 100644
--- a/django/utils/dateformat.py
+++ b/django/utils/dateformat.py
@@ -15,7 +15,6 @@ import datetime
 import re
 import time
 
-from django.utils import six
 from django.utils.dates import (
     MONTHS, MONTHS_3, MONTHS_ALT, MONTHS_AP, WEEKDAYS, WEEKDAYS_ABBR,
 )
@@ -182,7 +181,7 @@ class TimeFormat(Formatter):
             pass
         if name is None:
             name = self.format('O')
-        return six.text_type(name)
+        return str(name)
 
     def u(self):
         "Microseconds; i.e. '000000' to '999999'"
@@ -350,7 +349,7 @@ class DateFormat(TimeFormat):
 
     def y(self):
         "Year, 2 digits; e.g. '99'"
-        return six.text_type(self.data.year)[2:]
+        return str(self.data.year)[2:]
 
     def Y(self):
         "Year, 4 digits; e.g. '1999'"
diff --git a/django/utils/encoding.py b/django/utils/encoding.py
index f0627f5d39..abd17526c6 100644
--- a/django/utils/encoding.py
+++ b/django/utils/encoding.py
@@ -36,8 +36,8 @@ def smart_text(s, encoding='utf-8', strings_only=False, errors='strict'):
     return force_text(s, encoding, strings_only, errors)
 
 
-_PROTECTED_TYPES = six.integer_types + (
-    type(None), float, Decimal, datetime.datetime, datetime.date, datetime.time
+_PROTECTED_TYPES = (
+    type(None), int, float, Decimal, datetime.datetime, datetime.date, datetime.time,
 )
 
 
@@ -58,18 +58,18 @@ def force_text(s, encoding='utf-8', strings_only=False, errors='strict'):
     If strings_only is True, don't convert (some) non-string-like objects.
     """
     # Handle the common case first for performance reasons.
-    if issubclass(type(s), six.text_type):
+    if issubclass(type(s), str):
         return s
     if strings_only and is_protected_type(s):
         return s
     try:
-        if not issubclass(type(s), six.string_types):
+        if not issubclass(type(s), str):
             if isinstance(s, bytes):
-                s = six.text_type(s, encoding, errors)
+                s = str(s, encoding, errors)
             else:
-                s = six.text_type(s)
+                s = str(s)
         else:
-            # Note: We use .decode() here, instead of six.text_type(s, encoding,
+            # Note: We use .decode() here, instead of str(s, encoding,
             # errors), so that if s is a SafeBytes, it ends up being a
             # SafeText at the end.
             s = s.decode(encoding, errors)
@@ -114,13 +114,13 @@ def force_bytes(s, encoding='utf-8', strings_only=False, errors='strict'):
             return s.decode('utf-8', errors).encode(encoding, errors)
     if strings_only and is_protected_type(s):
         return s
-    if isinstance(s, six.memoryview):
+    if isinstance(s, memoryview):
         return bytes(s)
     if isinstance(s, Promise):
-        return six.text_type(s).encode(encoding, errors)
-    if not isinstance(s, six.string_types):
+        return str(s).encode(encoding, errors)
+    if not isinstance(s, str):
         try:
-            return six.text_type(s).encode(encoding)
+            return str(s).encode(encoding)
         except UnicodeEncodeError:
             if isinstance(s, Exception):
                 # An Exception subclass containing non-ASCII data that doesn't
@@ -128,7 +128,7 @@ def force_bytes(s, encoding='utf-8', strings_only=False, errors='strict'):
                 # further exception.
                 return b' '.join(force_bytes(arg, encoding, strings_only, errors)
                                  for arg in s)
-            return six.text_type(s).encode(encoding, errors)
+            return str(s).encode(encoding, errors)
     else:
         return s.encode(encoding, errors)
 
diff --git a/django/utils/formats.py b/django/utils/formats.py
index e381c1fbca..894003b4fa 100644
--- a/django/utils/formats.py
+++ b/django/utils/formats.py
@@ -4,7 +4,7 @@ import unicodedata
 from importlib import import_module
 
 from django.conf import settings
-from django.utils import dateformat, datetime_safe, numberformat, six
+from django.utils import dateformat, datetime_safe, numberformat
 from django.utils.encoding import force_str
 from django.utils.functional import lazy
 from django.utils.safestring import mark_safe
@@ -71,7 +71,7 @@ def iter_format_modules(lang, format_module_path=None):
 
     format_locations = []
     if format_module_path:
-        if isinstance(format_module_path, six.string_types):
+        if isinstance(format_module_path, str):
             format_module_path = [format_module_path]
         for path in format_module_path:
             format_locations.append(path + '.%s')
@@ -148,7 +148,7 @@ def get_format(format_type, lang=None, use_l10n=None):
     return val
 
 
-get_format_lazy = lazy(get_format, six.text_type, list, tuple)
+get_format_lazy = lazy(get_format, str, list, tuple)
 
 
 def date_format(value, format=None, use_l10n=None):
@@ -201,11 +201,11 @@ def localize(value, use_l10n=None):
     If use_l10n is provided and is not None, that will force the value to
     be localized (or not), overriding the value of settings.USE_L10N.
     """
-    if isinstance(value, six.string_types):  # Handle strings first for performance reasons.
+    if isinstance(value, str):  # Handle strings first for performance reasons.
         return value
     elif isinstance(value, bool):  # Make sure booleans don't get treated as numbers
-        return mark_safe(six.text_type(value))
-    elif isinstance(value, (decimal.Decimal, float) + six.integer_types):
+        return mark_safe(str(value))
+    elif isinstance(value, (decimal.Decimal, float, int)):
         return number_format(value, use_l10n=use_l10n)
     elif isinstance(value, datetime.datetime):
         return date_format(value, 'DATETIME_FORMAT', use_l10n=use_l10n)
@@ -221,11 +221,11 @@ def localize_input(value, default=None):
     Checks if an input value is a localizable type and returns it
     formatted with the appropriate formatting string of the current locale.
     """
-    if isinstance(value, six.string_types):  # Handle strings first for performance reasons.
+    if isinstance(value, str):  # Handle strings first for performance reasons.
         return value
     elif isinstance(value, bool):  # Don't treat booleans as numbers.
-        return six.text_type(value)
-    elif isinstance(value, (decimal.Decimal, float) + six.integer_types):
+        return str(value)
+    elif isinstance(value, (decimal.Decimal, float, int)):
         return number_format(value)
     elif isinstance(value, datetime.datetime):
         value = datetime_safe.new_datetime(value)
@@ -246,7 +246,7 @@ def sanitize_separators(value):
     Sanitizes a value according to the current decimal and
     thousand separator setting. Used with form field input.
     """
-    if settings.USE_L10N and isinstance(value, six.string_types):
+    if settings.USE_L10N and isinstance(value, str):
         parts = []
         decimal_separator = get_format('DECIMAL_SEPARATOR')
         if decimal_separator in value:
diff --git a/django/utils/functional.py b/django/utils/functional.py
index 933085391d..3e35582cbf 100644
--- a/django/utils/functional.py
+++ b/django/utils/functional.py
@@ -88,7 +88,7 @@ def lazy(func, *resultclasses):
                         meth = cls.__promise__(method_name)
                         setattr(cls, method_name, meth)
             cls._delegate_bytes = bytes in resultclasses
-            cls._delegate_text = six.text_type in resultclasses
+            cls._delegate_text = str 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:
@@ -148,7 +148,7 @@ def lazy(func, *resultclasses):
 
         def __mod__(self, rhs):
             if self._delegate_text:
-                return six.text_type(self) % rhs
+                return str(self) % rhs
             return self.__cast() % rhs
 
         def __deepcopy__(self, memo):
@@ -175,7 +175,7 @@ def lazystr(text):
     Shortcut for the common case of a lazy callable that returns str.
     """
     from django.utils.encoding import force_text  # Avoid circular import
-    return lazy(force_text, six.text_type)(text)
+    return lazy(force_text, str)(text)
 
 
 def keep_lazy(*resultclasses):
@@ -207,7 +207,7 @@ def keep_lazy_text(func):
     """
     A decorator for functions that accept lazy arguments and return text.
     """
-    return keep_lazy(six.text_type)(func)
+    return keep_lazy(str)(func)
 
 
 empty = object()
diff --git a/django/utils/html.py b/django/utils/html.py
index 36b5d53283..430350fed6 100644
--- a/django/utils/html.py
+++ b/django/utils/html.py
@@ -33,7 +33,7 @@ simple_url_2_re = re.compile(r'^www\.|^(?!http)\w[^@]+\.(com|edu|gov|int|mil|net
 simple_email_re = re.compile(r'^\S+@\S+\.\S+$')
 
 
-@keep_lazy(six.text_type, SafeText)
+@keep_lazy(str, SafeText)
 def escape(text):
     """
     Returns the given text with ampersands, quotes and angle brackets encoded
@@ -67,7 +67,7 @@ _js_escapes = {
 _js_escapes.update((ord('%c' % z), '\\u%04X' % z) for z in range(32))
 
 
-@keep_lazy(six.text_type, SafeText)
+@keep_lazy(str, SafeText)
 def escapejs(value):
     """Hex encodes characters for use in JavaScript strings."""
     return mark_safe(force_text(value).translate(_js_escapes))
diff --git a/django/utils/numberformat.py b/django/utils/numberformat.py
index d4c9ad74a5..1931015e7b 100644
--- a/django/utils/numberformat.py
+++ b/django/utils/numberformat.py
@@ -1,7 +1,6 @@
 from decimal import Decimal
 
 from django.conf import settings
-from django.utils import six
 from django.utils.safestring import mark_safe
 
 
@@ -24,13 +23,13 @@ def format(number, decimal_sep, decimal_pos=None, grouping=0, thousand_sep='',
     use_grouping = use_grouping and grouping != 0
     # Make the common case fast
     if isinstance(number, int) and not use_grouping and not decimal_pos:
-        return mark_safe(six.text_type(number))
+        return mark_safe(str(number))
     # sign
     sign = ''
     if isinstance(number, Decimal):
         str_number = '{:f}'.format(number)
     else:
-        str_number = six.text_type(number)
+        str_number = str(number)
     if str_number[0] == '-':
         sign = '-'
         str_number = str_number[1:]
diff --git a/django/utils/regex_helper.py b/django/utils/regex_helper.py
index 41f2459491..bc4a09b359 100644
--- a/django/utils/regex_helper.py
+++ b/django/utils/regex_helper.py
@@ -7,7 +7,6 @@ should be good enough for a large class of URLS, however.
 """
 import warnings
 
-from django.utils import six
 from django.utils.deprecation import RemovedInDjango21Warning
 from django.utils.six.moves import zip
 
@@ -318,7 +317,7 @@ def flatten_result(source):
     result_args = [[]]
     pos = last = 0
     for pos, elt in enumerate(source):
-        if isinstance(elt, six.string_types):
+        if isinstance(elt, str):
             continue
         piece = ''.join(source[last:pos])
         if isinstance(elt, Group):
diff --git a/django/utils/safestring.py b/django/utils/safestring.py
index 3f4b3d48fd..609f8f45ac 100644
--- a/django/utils/safestring.py
+++ b/django/utils/safestring.py
@@ -5,7 +5,6 @@ that the producer of the string has already turned characters that should not
 be interpreted by the HTML engine (e.g. '<') into the appropriate entities.
 """
 
-from django.utils import six
 from django.utils.functional import Promise, curry, wraps
 
 
@@ -52,10 +51,10 @@ class SafeBytes(bytes, SafeData):
     decode = curry(_proxy_method, method=bytes.decode)
 
 
-class SafeText(six.text_type, SafeData):
+class SafeText(str, SafeData):
     """
-    A unicode (Python 2) / str (Python 3) subclass that has been specifically
-    marked as "safe" for HTML output purposes.
+    A str subclass that has been specifically marked as "safe" for HTML output
+    purposes.
     """
     def __add__(self, rhs):
         """
@@ -80,7 +79,7 @@ class SafeText(six.text_type, SafeData):
         else:
             return SafeText(data)
 
-    encode = curry(_proxy_method, method=six.text_type.encode)
+    encode = curry(_proxy_method, method=str.encode)
 
 
 SafeString = SafeText
@@ -106,7 +105,7 @@ def mark_safe(s):
         return s
     if isinstance(s, bytes) or (isinstance(s, Promise) and s._delegate_bytes):
         return SafeBytes(s)
-    if isinstance(s, (six.text_type, Promise)):
+    if isinstance(s, (str, Promise)):
         return SafeText(s)
     if callable(s):
         return _safety_decorator(mark_safe, s)
diff --git a/django/utils/text.py b/django/utils/text.py
index fc8677cf4e..15a9b6160a 100644
--- a/django/utils/text.py
+++ b/django/utils/text.py
@@ -408,7 +408,7 @@ def unescape_string_literal(s):
     return s[1:-1].replace(r'\%s' % quote, quote).replace(r'\\', '\\')
 
 
-@keep_lazy(six.text_type, SafeText)
+@keep_lazy(str, SafeText)
 def slugify(value, allow_unicode=False):
     """
     Convert to ASCII if 'allow_unicode' is False. Convert spaces to hyphens.
@@ -441,4 +441,4 @@ def _format_lazy(format_string, *args, **kwargs):
     return format_string.format(*args, **kwargs)
 
 
-format_lazy = lazy(_format_lazy, six.text_type)
+format_lazy = lazy(_format_lazy, str)
diff --git a/django/utils/timezone.py b/django/utils/timezone.py
index 090750793a..992e80086a 100644
--- a/django/utils/timezone.py
+++ b/django/utils/timezone.py
@@ -8,7 +8,7 @@ from threading import local
 import pytz
 
 from django.conf import settings
-from django.utils import lru_cache, six
+from django.utils import lru_cache
 from django.utils.decorators import ContextDecorator
 
 __all__ = [
@@ -130,7 +130,7 @@ def activate(timezone):
     """
     if isinstance(timezone, tzinfo):
         _active.value = timezone
-    elif isinstance(timezone, six.string_types):
+    elif isinstance(timezone, str):
         _active.value = pytz.timezone(timezone)
     else:
         raise ValueError("Invalid timezone: %r" % timezone)
diff --git a/django/utils/translation/__init__.py b/django/utils/translation/__init__.py
index fd02fa16a3..345015d994 100644
--- a/django/utils/translation/__init__.py
+++ b/django/utils/translation/__init__.py
@@ -4,7 +4,6 @@ Internationalization support.
 import re
 import warnings
 
-from django.utils import six
 from django.utils.decorators import ContextDecorator
 from django.utils.deprecation import RemovedInDjango21Warning
 from django.utils.encoding import force_text
@@ -100,12 +99,12 @@ def npgettext(context, singular, plural, number):
 
 
 gettext_lazy = lazy(gettext, str)
-ugettext_lazy = lazy(ugettext, six.text_type)
-pgettext_lazy = lazy(pgettext, six.text_type)
+ugettext_lazy = lazy(ugettext, str)
+pgettext_lazy = lazy(pgettext, str)
 
 
 def lazy_number(func, resultclass, number=None, **kwargs):
-    if isinstance(number, six.integer_types):
+    if isinstance(number, int):
         kwargs['number'] = number
         proxy = lazy(func, resultclass)(**kwargs)
     else:
@@ -153,11 +152,11 @@ def ngettext_lazy(singular, plural, number=None):
 
 
 def ungettext_lazy(singular, plural, number=None):
-    return lazy_number(ungettext, six.text_type, singular=singular, plural=plural, number=number)
+    return lazy_number(ungettext, str, singular=singular, plural=plural, number=number)
 
 
 def npgettext_lazy(context, singular, plural, number=None):
-    return lazy_number(npgettext, six.text_type, context=context, singular=singular, plural=plural, number=number)
+    return lazy_number(npgettext, str, context=context, singular=singular, plural=plural, number=number)
 
 
 def activate(language):
@@ -234,7 +233,7 @@ def _string_concat(*strings):
     return ''.join(force_text(s) for s in strings)
 
 
-string_concat = lazy(_string_concat, six.text_type)
+string_concat = lazy(_string_concat, str)
 
 
 def get_language_info(lang_code):