Updated six to 1.10.0.

import types

__author__ = "Benjamin Peterson <benjamin@python.org>"

__version__ = "1.9.0"

__version__ = "1.10.0"

# Useful for very coarse version differentiation.

PY2 = sys.version_info[0] == 2

PY3 = sys.version_info[0] == 3

PY34 = sys.version_info[0:2] >= (3, 4)

if PY3:

    string_types = str,

    else:

        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).

        class X(object):

            def __len__(self):

                return 1 << 31

        try:

class _SixMetaPathImporter(object):

    """

    A meta path importer to import six.moves and its submodules.

    This class implements a PEP302 finder and loader. It should be compatible

    with Python 2.5 and all existing versions of Python3

    """

    def __init__(self, six_module_name):

        self.name = six_module_name

        self.known_modules = {}

class _MovedItems(_LazyModule):

    """Lazy loading of moved objects"""

    __path__ = []  # mark as package

    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),

    MovedAttribute("intern", "__builtin__", "sys"),

    MovedAttribute("map", "itertools", "builtins", "imap", "map"),

    MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),

    MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),

    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),

    MovedAttribute("reload_module", "__builtin__", "imp", "reload"),

    MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),

    MovedAttribute("reduce", "__builtin__", "functools"),

    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),

    MovedAttribute("StringIO", "StringIO", "io"),

    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),

    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),

    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),

    MovedModule("builtins", "__builtin__"),

    MovedModule("configparser", "ConfigParser"),

    MovedModule("copyreg", "copy_reg"),

    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),

    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),

    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),

]

# Add windows specific modules.

if sys.platform == "win32":

    _moved_attributes += [

        MovedModule("winreg", "_winreg"),

    ]

for attr in _moved_attributes:

    setattr(_MovedItems, attr.name, attr)

    if isinstance(attr, MovedModule):

class Module_six_moves_urllib_parse(_LazyModule):

    """Lazy loading of moved objects in six.moves.urllib_parse"""

class Module_six_moves_urllib_error(_LazyModule):

    """Lazy loading of moved objects in six.moves.urllib_error"""

class Module_six_moves_urllib_request(_LazyModule):

    """Lazy loading of moved objects in six.moves.urllib_request"""

class Module_six_moves_urllib_response(_LazyModule):

    """Lazy loading of moved objects in six.moves.urllib_response"""

class Module_six_moves_urllib_robotparser(_LazyModule):

    """Lazy loading of moved objects in six.moves.urllib_robotparser"""

class Module_six_moves_urllib(types.ModuleType):

    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""

    __path__ = []  # mark as package

    parse = _importer._get_module("moves.urllib_parse")

    create_bound_method = types.MethodType

    def create_unbound_method(func, cls):

        return func

    Iterator = object

else:

    def get_unbound_function(unbound):

    def create_bound_method(func, obj):

        return types.MethodType(func, obj, obj.__class__)

    def create_unbound_method(func, cls):

        return types.MethodType(func, None, cls)

    class Iterator(object):

        def next(self):

    viewitems = operator.methodcaller("items")

else:

    def iterkeys(d, **kw):

        return iter(d.iterkeys(**kw))

        return d.iterkeys(**kw)

    def itervalues(d, **kw):

        return iter(d.itervalues(**kw))

        return d.itervalues(**kw)

    def iteritems(d, **kw):

        return iter(d.iteritems(**kw))

        return d.iteritems(**kw)

    def iterlists(d, **kw):

        return iter(d.iterlists(**kw))

        return d.iterlists(**kw)

    viewkeys = operator.methodcaller("viewkeys")

if PY3:

    def b(s):

        return s.encode("latin-1")

    def u(s):

        return s

    unichr = chr

    if sys.version_info[1] <= 1:

        def int2byte(i):

            return bytes((i,))

    else:

        # This is about 2x faster than the implementation above on 3.2+

        int2byte = operator.methodcaller("to_bytes", 1, "big")

    import struct

    int2byte = struct.Struct(">B").pack

    del struct

    byte2int = operator.itemgetter(0)

    indexbytes = operator.getitem

    iterbytes = iter

    StringIO = io.StringIO

    BytesIO = io.BytesIO

    _assertCountEqual = "assertCountEqual"

    if sys.version_info[1] <= 1:

        _assertRaisesRegex = "assertRaisesRegexp"

        _assertRegex = "assertRegexpMatches"

    else:

        _assertRaisesRegex = "assertRaisesRegex"

        _assertRegex = "assertRegex"

else:

    def b(s):

        return s

    # Workaround for standalone backslash

    def u(s):

        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")

    unichr = unichr

    int2byte = chr

    def byte2int(bs):

        return ord(bs[0])

    def indexbytes(buf, i):

        return ord(buf[i])

    iterbytes = functools.partial(itertools.imap, ord)

if PY3:

    exec_ = getattr(moves.builtins, "exec")

    def reraise(tp, value, tb=None):

        if value is None:

            value = tp()

            _locs_ = _globs_

        exec("""exec _code_ in _globs_, _locs_""")

    exec_("""def reraise(tp, value, tb=None):

    raise tp, value, tb

""")

        fp = kwargs.pop("file", sys.stdout)

        if fp is None:

            return

        def write(data):

            if not isinstance(data, basestring):

                data = str(data)

        write(end)

if sys.version_info[:2] < (3, 3):

    _print = print_

    def print_(*args, **kwargs):

        fp = kwargs.get("file", sys.stdout)

        flush = kwargs.pop("flush", False)

else:

    wraps = functools.wraps

def with_metaclass(meta, *bases):

    """Create a base class with a metaclass."""

    # This requires a bit of explanation: the basic idea is to make a dummy

    # metaclass for one level of class instantiation that replaces itself with

    # the actual metaclass.

    class metaclass(meta):

        def __new__(cls, name, this_bases, d):

            return meta(name, bases, d)

    return type.__new__(metaclass, 'temporary_class', (), {})

Django 1.8.7 fixes several bugs in 1.8.6.

Additionally, Django's vendored version of six, :mod:`django.utils.six`, has

been upgraded to the latest release (1.10.0).

Bugfixes

========