"""Utilities for writing code that runs on Python 2 and 3"""

# Copyright (c) 2010-2015 Benjamin Peterson

#

# Permission is hereby granted, free of charge, to any person obtaining a copy

# of this software and associated documentation files (the "Software"), to deal

# in the Software without restriction, including without limitation the rights

# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

# copies of the Software, and to permit persons to whom the Software is

# furnished to do so, subject to the following conditions:

#

# The above copyright notice and this permission notice shall be included in all

# copies or substantial portions of the Software.

#

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

# SOFTWARE.

from __future__ import absolute_import

import functools

import itertools

import operator

import sys

import types

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

__version__ = "1.9.0"

# Useful for very coarse version differentiation.

PY2 = sys.version_info[0] == 2

PY3 = sys.version_info[0] == 3

if PY3:

string_types = str,

integer_types = int,

class_types = type,

text_type = str

binary_type = bytes

MAXSIZE = sys.maxsize

else:

string_types = basestring,

integer_types = (int, long)

class_types = (type, types.ClassType)

text_type = unicode

binary_type = str

if sys.platform.startswith("java"):

# Jython always uses 32 bits.

MAXSIZE = int((1 << 31) - 1)

else:

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

class X(object):

def __len__(self):

return 1 << 31

try:

len(X())

except OverflowError:

# 32-bit

MAXSIZE = int((1 << 31) - 1)

else:

# 64-bit

MAXSIZE = int((1 << 63) - 1)

del X

def _add_doc(func, doc):

"""Add documentation to a function."""

func.__doc__ = doc

def _import_module(name):

"""Import module, returning the module after the last dot."""

__import__(name)

return sys.modules[name]

class _LazyDescr(object):

return result

class MovedModule(_LazyDescr):

return value

class _LazyModule(types.ModuleType):

_moved_attributes = []

class MovedAttribute(_LazyDescr):

return getattr(module, self.attr)

class _SixMetaPathImporter(object):

get_source = get_code # same as get_code

_importer = _SixMetaPathImporter(__name__)

class _MovedItems(_LazyModule):

"""Lazy loading of moved objects"""

__path__ = [] # mark as package

_moved_attributes = [

]

for attr in _moved_attributes:

setattr(_MovedItems, attr.name, attr)

if isinstance(attr, MovedModule):

_importer._add_module(attr, "moves." + attr.name)

del attr

_MovedItems._moved_attributes = _moved_attributes

moves = _MovedItems(__name__ + ".moves")

_importer._add_module(moves, "moves")

class Module_six_moves_urllib_parse(_LazyModule):

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

_urllib_parse_moved_attributes = [

]

for attr in _urllib_parse_moved_attributes:

setattr(Module_six_moves_urllib_parse, attr.name, attr)

del attr

Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes

_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),

"moves.urllib_parse", "moves.urllib.parse")

class Module_six_moves_urllib_error(_LazyModule):

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

_urllib_error_moved_attributes = [

]

for attr in _urllib_error_moved_attributes:

setattr(Module_six_moves_urllib_error, attr.name, attr)

del attr

Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes

_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),

"moves.urllib_error", "moves.urllib.error")

class Module_six_moves_urllib_request(_LazyModule):

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

_urllib_request_moved_attributes = [

]

for attr in _urllib_request_moved_attributes:

setattr(Module_six_moves_urllib_request, attr.name, attr)

del attr

Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes

_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),

"moves.urllib_request", "moves.urllib.request")

class Module_six_moves_urllib_response(_LazyModule):

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

_urllib_response_moved_attributes = [

]

for attr in _urllib_response_moved_attributes:

setattr(Module_six_moves_urllib_response, attr.name, attr)

del attr

Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes

_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),

"moves.urllib_response", "moves.urllib.response")

class Module_six_moves_urllib_robotparser(_LazyModule):

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

_urllib_robotparser_moved_attributes = [

MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),

]

for attr in _urllib_robotparser_moved_attributes:

setattr(Module_six_moves_urllib_robotparser, attr.name, attr)

del attr

Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes

_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),

"moves.urllib_robotparser", "moves.urllib.robotparser")

class Module_six_moves_urllib(types.ModuleType):

return ['parse', 'error', 'request', 'response', 'robotparser']

_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),

"moves.urllib")

def add_move(move):

"""Add an item to six.moves."""

setattr(_MovedItems, move.name, move)

def remove_move(name):

raise AttributeError("no such move, %r" % (name,))

if PY3:

_meth_func = "__func__"

_meth_self = "__self__"

_func_closure = "__closure__"

_func_code = "__code__"

_func_defaults = "__defaults__"

_func_globals = "__globals__"

else:

_meth_func = "im_func"

_meth_self = "im_self"

_func_closure = "func_closure"

_func_code = "func_code"

_func_defaults = "func_defaults"

_func_globals = "func_globals"

try:

advance_iterator = next

except NameError:

def advance_iterator(it):

return it.next()

next = advance_iterator

try:

callable = callable

except NameError:

def callable(obj):

return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)

if PY3:

def get_unbound_function(unbound):

return unbound

create_bound_method = types.MethodType

Iterator = object

else:

def get_unbound_function(unbound):

return unbound.im_func

def create_bound_method(func, obj):

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

class Iterator(object):

def next(self):

return type(self).__next__(self)

callable = callable

_add_doc(get_unbound_function,

"""Get the function out of a possibly unbound function""")

get_method_function = operator.attrgetter(_meth_func)

get_method_self = operator.attrgetter(_meth_self)

get_function_closure = operator.attrgetter(_func_closure)

get_function_code = operator.attrgetter(_func_code)

get_function_defaults = operator.attrgetter(_func_defaults)

get_function_globals = operator.attrgetter(_func_globals)

if PY3:

def iterkeys(d, **kw):

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

def itervalues(d, **kw):

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

def iteritems(d, **kw):

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

def iterlists(d, **kw):

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

viewkeys = operator.methodcaller("keys")

viewvalues = operator.methodcaller("values")

viewitems = operator.methodcaller("items")

else:

def iterkeys(d, **kw):

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

def itervalues(d, **kw):

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

def iteritems(d, **kw):

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

def iterlists(d, **kw):

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

viewkeys = operator.methodcaller("viewkeys")

viewvalues = operator.methodcaller("viewvalues")

viewitems = operator.methodcaller("viewitems")

_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")

_add_doc(itervalues, "Return an iterator over the values of a dictionary.")

_add_doc(iteritems,

"Return an iterator over the (key, value) pairs of a dictionary.")

_add_doc(iterlists,

"Return an iterator over the (key, [values]) pairs of a dictionary.")

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")

byte2int = operator.itemgetter(0)

indexbytes = operator.getitem

iterbytes = iter

import io

StringIO = io.StringIO

BytesIO = io.BytesIO

_assertCountEqual = "assertCountEqual"

_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)

import StringIO

StringIO = BytesIO = StringIO.StringIO

_assertCountEqual = "assertItemsEqual"

_assertRaisesRegex = "assertRaisesRegexp"

_assertRegex = "assertRegexpMatches"

_add_doc(b, """Byte literal""")

_add_doc(u, """Text literal""")

def assertCountEqual(self, *args, **kwargs):

return getattr(self, _assertCountEqual)(*args, **kwargs)

def assertRaisesRegex(self, *args, **kwargs):

return getattr(self, _assertRaisesRegex)(*args, **kwargs)

def assertRegex(self, *args, **kwargs):

return getattr(self, _assertRegex)(*args, **kwargs)

if PY3:

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

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

raise value

else:

def exec_(_code_, _globs_=None, _locs_=None):

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

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

raise tp, value, tb

""")

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

exec_("""def raise_from(value, from_value):

if from_value is None:

raise value

raise value from from_value

""")

elif sys.version_info[:2] > (3, 2):

exec_("""def raise_from(value, from_value):

raise value from from_value

""")

else:

def raise_from(value, from_value):

raise value

print_ = getattr(moves.builtins, "print", None)

if print_ is None:

def print_(*args, **kwargs):

write(end)

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

_print = print_

def print_(*args, **kwargs):

fp.flush()

_add_doc(reraise, """Reraise an exception.""")

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

def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,

return wrapper

else:

wraps = functools.wraps

def with_metaclass(meta, *bases):

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

def add_metaclass(metaclass):

return wrapper

def python_2_unicode_compatible(klass):

return klass

# Complete the moves implementation.

# This code is at the end of this module to speed up module loading.

# Turn this module into a package.

__path__ = [] # required for PEP 302 and PEP 451

__package__ = __name__ # see PEP 366 @ReservedAssignment

if globals().get("__spec__") is not None:

__spec__.submodule_search_locations = [] # PEP 451 @UndefinedVariable

# Remove other six meta path importers, since they cause problems. This can

# happen if six is removed from sys.modules and then reloaded. (Setuptools does

# this for some reason.)

if sys.meta_path:

for i, importer in enumerate(sys.meta_path):

# Here's some real nastiness: Another "instance" of the six module might

# be floating around. Therefore, we can't use isinstance() to check for

# the six meta path importer, since the other six instance will have

# inserted an importer with different class.

if (type(importer).__name__ == "_SixMetaPathImporter" and

importer.name == __name__):

del sys.meta_path[i]

break

del i, importer

# Finally, add the importer to the meta path import hook.

sys.meta_path.append(_importer)