solenv/gdb/six.py

   1 # Copyright (c) 2010-2018 Benjamin Peterson
   2 #
   3 # Permission is hereby granted, free of charge, to any person obtaining a copy
   4 # of this software and associated documentation files (the "Software"), to deal
   5 # in the Software without restriction, including without limitation the rights
   6 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   7 # copies of the Software, and to permit persons to whom the Software is
   8 # furnished to do so, subject to the following conditions:
   9 #
  10 # The above copyright notice and this permission notice shall be included in all
  11 # copies or substantial portions of the Software.
  12 #
  13 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  18 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  19 # SOFTWARE.
  20
  21 """Utilities for writing code that runs on Python 2 and 3"""
  22
  23 from __future__ import absolute_import
  24
  25 import functools
  26 import itertools
  27 import operator
  28 import sys
  29 import types
  30
  31 __author__ = "Benjamin Peterson <benjamin@python.org>"
  32 __version__ = "1.12.0"
  33
  34
  35 # Useful for very coarse version differentiation.
  36 PY2 = sys.version_info[0] == 2
  37 PY3 = sys.version_info[0] == 3
  38 PY34 = sys.version_info[0:2] >= (3, 4)
  39
  40 if PY3:
  41     string_types = str,
  42     integer_types = int,
  43     class_types = type,
  44     text_type = str
  45     binary_type = bytes
  46
  47     MAXSIZE = sys.maxsize
  48 else:
  49     string_types = basestring,
  50     integer_types = (int, long)
  51     class_types = (type, types.ClassType)
  52     text_type = unicode
  53     binary_type = str
  54
  55     if sys.platform.startswith("java"):
  56         # Jython always uses 32 bits.
  57         MAXSIZE = int((1 << 31) - 1)
  58     else:
  59         # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
  60         class X(object):
  61
  62             def __len__(self):
  63                 return 1 << 31
  64         try:
  65             len(X())
  66         except OverflowError:
  67             # 32-bit
  68             MAXSIZE = int((1 << 31) - 1)
  69         else:
  70             # 64-bit
  71             MAXSIZE = int((1 << 63) - 1)
  72         del X
  73
  74
  75 def _add_doc(func, doc):
  76     """Add documentation to a function."""
  77     func.__doc__ = doc
  78
  79
  80 def _import_module(name):
  81     """Import module, returning the module after the last dot."""
  82     __import__(name)
  83     return sys.modules[name]
  84
  85
  86 class _LazyDescr(object):
  87
  88     def __init__(self, name):
  89         self.name = name
  90
  91     def __get__(self, obj, tp):
  92         result = self._resolve()
  93         setattr(obj, self.name, result)  # Invokes __set__.
  94         try:
  95             # This is a bit ugly, but it avoids running this again by
  96             # removing this descriptor.
  97             delattr(obj.__class__, self.name)
  98         except AttributeError:
  99             pass
 100         return result
 101
 102
 103 class MovedModule(_LazyDescr):
 104
 105     def __init__(self, name, old, new=None):
 106         super(MovedModule, self).__init__(name)
 107         if PY3:
 108             if new is None:
 109                 new = name
 110             self.mod = new
 111         else:
 112             self.mod = old
 113
 114     def _resolve(self):
 115         return _import_module(self.mod)
 116
 117     def __getattr__(self, attr):
 118         _module = self._resolve()
 119         value = getattr(_module, attr)
 120         setattr(self, attr, value)
 121         return value
 122
 123
 124 class _LazyModule(types.ModuleType):
 125
 126     def __init__(self, name):
 127         super(_LazyModule, self).__init__(name)
 128         self.__doc__ = self.__class__.__doc__
 129
 130     def __dir__(self):
 131         attrs = ["__doc__", "__name__"]
 132         attrs += [attr.name for attr in self._moved_attributes]
 133         return attrs
 134
 135     # Subclasses should override this
 136     _moved_attributes = []
 137
 138
 139 class MovedAttribute(_LazyDescr):
 140
 141     def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
 142         super(MovedAttribute, self).__init__(name)
 143         if PY3:
 144             if new_mod is None:
 145                 new_mod = name
 146             self.mod = new_mod
 147             if new_attr is None:
 148                 if old_attr is None:
 149                     new_attr = name
 150                 else:
 151                     new_attr = old_attr
 152             self.attr = new_attr
 153         else:
 154             self.mod = old_mod
 155             if old_attr is None:
 156                 old_attr = name
 157             self.attr = old_attr
 158
 159     def _resolve(self):
 160         module = _import_module(self.mod)
 161         return getattr(module, self.attr)
 162
 163
 164 class _SixMetaPathImporter(object):
 165
 166     """
 167     A meta path importer to import six.moves and its submodules.
 168
 169     This class implements a PEP302 finder and loader. It should be compatible
 170     with Python 2.5 and all existing versions of Python3
 171     """
 172
 173     def __init__(self, six_module_name):
 174         self.name = six_module_name
 175         self.known_modules = {}
 176
 177     def _add_module(self, mod, *fullnames):
 178         for fullname in fullnames:
 179             self.known_modules[self.name + "." + fullname] = mod
 180
 181     def _get_module(self, fullname):
 182         return self.known_modules[self.name + "." + fullname]
 183
 184     def find_module(self, fullname, path=None):
 185         if fullname in self.known_modules:
 186             return self
 187         return None
 188
 189     def __get_module(self, fullname):
 190         try:
 191             return self.known_modules[fullname]
 192         except KeyError:
 193             raise ImportError("This loader does not know module " + fullname)
 194
 195     def load_module(self, fullname):
 196         try:
 197             # in case of a reload
 198             return sys.modules[fullname]
 199         except KeyError:
 200             pass
 201         mod = self.__get_module(fullname)
 202         if isinstance(mod, MovedModule):
 203             mod = mod._resolve()
 204         else:
 205             mod.__loader__ = self
 206         sys.modules[fullname] = mod
 207         return mod
 208
 209     def is_package(self, fullname):
 210         """
 211         Return true, if the named module is a package.
 212
 213         We need this method to get correct spec objects with
 214         Python 3.4 (see PEP451)
 215         """
 216         return hasattr(self.__get_module(fullname), "__path__")
 217
 218     def get_code(self, fullname):
 219         """Return None
 220
 221         Required, if is_package is implemented"""
 222         self.__get_module(fullname)  # eventually raises ImportError
 223         return None
 224     get_source = get_code  # same as get_code
 225
 226 _importer = _SixMetaPathImporter(__name__)
 227
 228
 229 class _MovedItems(_LazyModule):
 230
 231     """Lazy loading of moved objects"""
 232     __path__ = []  # mark as package
 233
 234
 235 _moved_attributes = [
 236     MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
 237     MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
 238     MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
 239     MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
 240     MovedAttribute("intern", "__builtin__", "sys"),
 241     MovedAttribute("map", "itertools", "builtins", "imap", "map"),
 242     MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),
 243     MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),
 244     MovedAttribute("getoutput", "commands", "subprocess"),
 245     MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
 246     MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
 247     MovedAttribute("reduce", "__builtin__", "functools"),
 248     MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
 249     MovedAttribute("StringIO", "StringIO", "io"),
 250     MovedAttribute("UserDict", "UserDict", "collections"),
 251     MovedAttribute("UserList", "UserList", "collections"),
 252     MovedAttribute("UserString", "UserString", "collections"),
 253     MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
 254     MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
 255     MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
 256     MovedModule("builtins", "__builtin__"),
 257     MovedModule("configparser", "ConfigParser"),
 258     MovedModule("copyreg", "copy_reg"),
 259     MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
 260     MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"),
 261     MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
 262     MovedModule("http_cookies", "Cookie", "http.cookies"),
 263     MovedModule("html_entities", "htmlentitydefs", "html.entities"),
 264     MovedModule("html_parser", "HTMLParser", "html.parser"),
 265     MovedModule("http_client", "httplib", "http.client"),
 266     MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
 267     MovedModule("email_mime_image", "email.MIMEImage", "email.mime.image"),
 268     MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
 269     MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
 270     MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
 271     MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
 272     MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
 273     MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
 274     MovedModule("cPickle", "cPickle", "pickle"),
 275     MovedModule("queue", "Queue"),
 276     MovedModule("reprlib", "repr"),
 277     MovedModule("socketserver", "SocketServer"),
 278     MovedModule("_thread", "thread", "_thread"),
 279     MovedModule("tkinter", "Tkinter"),
 280     MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
 281     MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
 282     MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
 283     MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
 284     MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
 285     MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
 286     MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
 287     MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
 288     MovedModule("tkinter_colorchooser", "tkColorChooser",
 289                 "tkinter.colorchooser"),
 290     MovedModule("tkinter_commondialog", "tkCommonDialog",
 291                 "tkinter.commondialog"),
 292     MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
 293     MovedModule("tkinter_font", "tkFont", "tkinter.font"),
 294     MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
 295     MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
 296                 "tkinter.simpledialog"),
 297     MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
 298     MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
 299     MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
 300     MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
 301     MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
 302     MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
 303 ]
 304 # Add windows specific modules.
 305 if sys.platform == "win32":
 306     _moved_attributes += [
 307         MovedModule("winreg", "_winreg"),
 308     ]
 309
 310 for attr in _moved_attributes:
 311     setattr(_MovedItems, attr.name, attr)
 312     if isinstance(attr, MovedModule):
 313         _importer._add_module(attr, "moves." + attr.name)
 314 del attr
 315
 316 _MovedItems._moved_attributes = _moved_attributes
 317
 318 moves = _MovedItems(__name__ + ".moves")
 319 _importer._add_module(moves, "moves")
 320
 321
 322 class Module_six_moves_urllib_parse(_LazyModule):
 323
 324     """Lazy loading of moved objects in six.moves.urllib_parse"""
 325
 326
 327 _urllib_parse_moved_attributes = [
 328     MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
 329     MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
 330     MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
 331     MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
 332     MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
 333     MovedAttribute("urljoin", "urlparse", "urllib.parse"),
 334     MovedAttribute("urlparse", "urlparse", "urllib.parse"),
 335     MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
 336     MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
 337     MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
 338     MovedAttribute("quote", "urllib", "urllib.parse"),
 339     MovedAttribute("quote_plus", "urllib", "urllib.parse"),
 340     MovedAttribute("unquote", "urllib", "urllib.parse"),
 341     MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
 342     MovedAttribute("unquote_to_bytes", "urllib", "urllib.parse", "unquote", "unquote_to_bytes"),
 343     MovedAttribute("urlencode", "urllib", "urllib.parse"),
 344     MovedAttribute("splitquery", "urllib", "urllib.parse"),
 345     MovedAttribute("splittag", "urllib", "urllib.parse"),
 346     MovedAttribute("splituser", "urllib", "urllib.parse"),
 347     MovedAttribute("splitvalue", "urllib", "urllib.parse"),
 348     MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
 349     MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
 350     MovedAttribute("uses_params", "urlparse", "urllib.parse"),
 351     MovedAttribute("uses_query", "urlparse", "urllib.parse"),
 352     MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
 353 ]
 354 for attr in _urllib_parse_moved_attributes:
 355     setattr(Module_six_moves_urllib_parse, attr.name, attr)
 356 del attr
 357
 358 Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
 359
 360 _importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
 361                       "moves.urllib_parse", "moves.urllib.parse")
 362
 363
 364 class Module_six_moves_urllib_error(_LazyModule):
 365
 366     """Lazy loading of moved objects in six.moves.urllib_error"""
 367
 368
 369 _urllib_error_moved_attributes = [
 370     MovedAttribute("URLError", "urllib2", "urllib.error"),
 371     MovedAttribute("HTTPError", "urllib2", "urllib.error"),
 372     MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
 373 ]
 374 for attr in _urllib_error_moved_attributes:
 375     setattr(Module_six_moves_urllib_error, attr.name, attr)
 376 del attr
 377
 378 Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
 379
 380 _importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
 381                       "moves.urllib_error", "moves.urllib.error")
 382
 383
 384 class Module_six_moves_urllib_request(_LazyModule):
 385
 386     """Lazy loading of moved objects in six.moves.urllib_request"""
 387
 388
 389 _urllib_request_moved_attributes = [
 390     MovedAttribute("urlopen", "urllib2", "urllib.request"),
 391     MovedAttribute("install_opener", "urllib2", "urllib.request"),
 392     MovedAttribute("build_opener", "urllib2", "urllib.request"),
 393     MovedAttribute("pathname2url", "urllib", "urllib.request"),
 394     MovedAttribute("url2pathname", "urllib", "urllib.request"),
 395     MovedAttribute("getproxies", "urllib", "urllib.request"),
 396     MovedAttribute("Request", "urllib2", "urllib.request"),
 397     MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
 398     MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
 399     MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
 400     MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
 401     MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
 402     MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
 403     MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
 404     MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
 405     MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
 406     MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
 407     MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
 408     MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
 409     MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
 410     MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
 411     MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
 412     MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
 413     MovedAttribute("FileHandler", "urllib2", "urllib.request"),
 414     MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
 415     MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
 416     MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
 417     MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
 418     MovedAttribute("urlretrieve", "urllib", "urllib.request"),
 419     MovedAttribute("urlcleanup", "urllib", "urllib.request"),
 420     MovedAttribute("URLopener", "urllib", "urllib.request"),
 421     MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
 422     MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
 423     MovedAttribute("parse_http_list", "urllib2", "urllib.request"),
 424     MovedAttribute("parse_keqv_list", "urllib2", "urllib.request"),
 425 ]
 426 for attr in _urllib_request_moved_attributes:
 427     setattr(Module_six_moves_urllib_request, attr.name, attr)
 428 del attr
 429
 430 Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
 431
 432 _importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
 433                       "moves.urllib_request", "moves.urllib.request")
 434
 435
 436 class Module_six_moves_urllib_response(_LazyModule):
 437
 438     """Lazy loading of moved objects in six.moves.urllib_response"""
 439
 440
 441 _urllib_response_moved_attributes = [
 442     MovedAttribute("addbase", "urllib", "urllib.response"),
 443     MovedAttribute("addclosehook", "urllib", "urllib.response"),
 444     MovedAttribute("addinfo", "urllib", "urllib.response"),
 445     MovedAttribute("addinfourl", "urllib", "urllib.response"),
 446 ]
 447 for attr in _urllib_response_moved_attributes:
 448     setattr(Module_six_moves_urllib_response, attr.name, attr)
 449 del attr
 450
 451 Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
 452
 453 _importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
 454                       "moves.urllib_response", "moves.urllib.response")
 455
 456
 457 class Module_six_moves_urllib_robotparser(_LazyModule):
 458
 459     """Lazy loading of moved objects in six.moves.urllib_robotparser"""
 460
 461
 462 _urllib_robotparser_moved_attributes = [
 463     MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
 464 ]
 465 for attr in _urllib_robotparser_moved_attributes:
 466     setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
 467 del attr
 468
 469 Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
 470
 471 _importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
 472                       "moves.urllib_robotparser", "moves.urllib.robotparser")
 473
 474
 475 class Module_six_moves_urllib(types.ModuleType):
 476
 477     """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
 478     __path__ = []  # mark as package
 479     parse = _importer._get_module("moves.urllib_parse")
 480     error = _importer._get_module("moves.urllib_error")
 481     request = _importer._get_module("moves.urllib_request")
 482     response = _importer._get_module("moves.urllib_response")
 483     robotparser = _importer._get_module("moves.urllib_robotparser")
 484
 485     def __dir__(self):
 486         return ['parse', 'error', 'request', 'response', 'robotparser']
 487
 488 _importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
 489                       "moves.urllib")
 490
 491
 492 def add_move(move):
 493     """Add an item to six.moves."""
 494     setattr(_MovedItems, move.name, move)
 495
 496
 497 def remove_move(name):
 498     """Remove item from six.moves."""
 499     try:
 500         delattr(_MovedItems, name)
 501     except AttributeError:
 502         try:
 503             del moves.__dict__[name]
 504         except KeyError:
 505             raise AttributeError("no such move, %r" % (name,))
 506
 507
 508 if PY3:
 509     _meth_func = "__func__"
 510     _meth_self = "__self__"
 511
 512     _func_closure = "__closure__"
 513     _func_code = "__code__"
 514     _func_defaults = "__defaults__"
 515     _func_globals = "__globals__"
 516 else:
 517     _meth_func = "im_func"
 518     _meth_self = "im_self"
 519
 520     _func_closure = "func_closure"
 521     _func_code = "func_code"
 522     _func_defaults = "func_defaults"
 523     _func_globals = "func_globals"
 524
 525
 526 try:
 527     advance_iterator = next
 528 except NameError:
 529     def advance_iterator(it):
 530         return it.next()
 531 next = advance_iterator
 532
 533
 534 try:
 535     callable = callable
 536 except NameError:
 537     def callable(obj):
 538         return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
 539
 540
 541 if PY3:
 542     def get_unbound_function(unbound):
 543         return unbound
 544
 545     create_bound_method = types.MethodType
 546
 547     def create_unbound_method(func, cls):
 548         return func
 549
 550     Iterator = object
 551 else:
 552     def get_unbound_function(unbound):
 553         return unbound.im_func
 554
 555     def create_bound_method(func, obj):
 556         return types.MethodType(func, obj, obj.__class__)
 557
 558     def create_unbound_method(func, cls):
 559         return types.MethodType(func, None, cls)
 560
 561     class Iterator(object):
 562
 563         def next(self):
 564             return type(self).__next__(self)
 565
 566     callable = callable
 567 _add_doc(get_unbound_function,
 568          """Get the function out of a possibly unbound function""")
 569
 570
 571 get_method_function = operator.attrgetter(_meth_func)
 572 get_method_self = operator.attrgetter(_meth_self)
 573 get_function_closure = operator.attrgetter(_func_closure)
 574 get_function_code = operator.attrgetter(_func_code)
 575 get_function_defaults = operator.attrgetter(_func_defaults)
 576 get_function_globals = operator.attrgetter(_func_globals)
 577
 578
 579 if PY3:
 580     def iterkeys(d, **kw):
 581         return iter(d.keys(**kw))
 582
 583     def itervalues(d, **kw):
 584         return iter(d.values(**kw))
 585
 586     def iteritems(d, **kw):
 587         return iter(d.items(**kw))
 588
 589     def iterlists(d, **kw):
 590         return iter(d.lists(**kw))
 591
 592     viewkeys = operator.methodcaller("keys")
 593
 594     viewvalues = operator.methodcaller("values")
 595
 596     viewitems = operator.methodcaller("items")
 597 else:
 598     def iterkeys(d, **kw):
 599         return d.iterkeys(**kw)
 600
 601     def itervalues(d, **kw):
 602         return d.itervalues(**kw)
 603
 604     def iteritems(d, **kw):
 605         return d.iteritems(**kw)
 606
 607     def iterlists(d, **kw):
 608         return d.iterlists(**kw)
 609
 610     viewkeys = operator.methodcaller("viewkeys")
 611
 612     viewvalues = operator.methodcaller("viewvalues")
 613
 614     viewitems = operator.methodcaller("viewitems")
 615
 616 _add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
 617 _add_doc(itervalues, "Return an iterator over the values of a dictionary.")
 618 _add_doc(iteritems,
 619          "Return an iterator over the (key, value) pairs of a dictionary.")
 620 _add_doc(iterlists,
 621          "Return an iterator over the (key, [values]) pairs of a dictionary.")
 622
 623
 624 if PY3:
 625     def b(s):
 626         return s.encode("latin-1")
 627
 628     def u(s):
 629         return s
 630     unichr = chr
 631     import struct
 632     int2byte = struct.Struct(">B").pack
 633     del struct
 634     byte2int = operator.itemgetter(0)
 635     indexbytes = operator.getitem
 636     iterbytes = iter
 637     import io
 638     StringIO = io.StringIO
 639     BytesIO = io.BytesIO
 640     del io
 641     _assertCountEqual = "assertCountEqual"
 642     if sys.version_info[1] <= 1:
 643         _assertRaisesRegex = "assertRaisesRegexp"
 644         _assertRegex = "assertRegexpMatches"
 645     else:
 646         _assertRaisesRegex = "assertRaisesRegex"
 647         _assertRegex = "assertRegex"
 648 else:
 649     def b(s):
 650         return s
 651     # Workaround for standalone backslash
 652
 653     def u(s):
 654         return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
 655     unichr = unichr
 656     int2byte = chr
 657
 658     def byte2int(bs):
 659         return ord(bs[0])
 660
 661     def indexbytes(buf, i):
 662         return ord(buf[i])
 663     iterbytes = functools.partial(itertools.imap, ord)
 664     import StringIO
 665     StringIO = BytesIO = StringIO.StringIO
 666     _assertCountEqual = "assertItemsEqual"
 667     _assertRaisesRegex = "assertRaisesRegexp"
 668     _assertRegex = "assertRegexpMatches"
 669 _add_doc(b, """Byte literal""")
 670 _add_doc(u, """Text literal""")
 671
 672
 673 def assertCountEqual(self, *args, **kwargs):
 674     return getattr(self, _assertCountEqual)(*args, **kwargs)
 675
 676
 677 def assertRaisesRegex(self, *args, **kwargs):
 678     return getattr(self, _assertRaisesRegex)(*args, **kwargs)
 679
 680
 681 def assertRegex(self, *args, **kwargs):
 682     return getattr(self, _assertRegex)(*args, **kwargs)
 683
 684
 685 if PY3:
 686     exec_ = getattr(moves.builtins, "exec")
 687
 688     def reraise(tp, value, tb=None):
 689         try:
 690             if value is None:
 691                 value = tp()
 692             if value.__traceback__ is not tb:
 693                 raise value.with_traceback(tb)
 694             raise value
 695         finally:
 696             value = None
 697             tb = None
 698
 699 else:
 700     def exec_(_code_, _globs_=None, _locs_=None):
 701         """Execute code in a namespace."""
 702         if _globs_ is None:
 703             frame = sys._getframe(1)
 704             _globs_ = frame.f_globals
 705             if _locs_ is None:
 706                 _locs_ = frame.f_locals
 707             del frame
 708         elif _locs_ is None:
 709             _locs_ = _globs_
 710         exec("""exec _code_ in _globs_, _locs_""")
 711
 712     exec_("""def reraise(tp, value, tb=None):
 713     try:
 714         raise tp, value, tb
 715     finally:
 716         tb = None
 717 """)
 718
 719
 720 if sys.version_info[:2] == (3, 2):
 721     exec_("""def raise_from(value, from_value):
 722     try:
 723         if from_value is None:
 724             raise value
 725         raise value from from_value
 726     finally:
 727         value = None
 728 """)
 729 elif sys.version_info[:2] > (3, 2):
 730     exec_("""def raise_from(value, from_value):
 731     try:
 732         raise value from from_value
 733     finally:
 734         value = None
 735 """)
 736 else:
 737     def raise_from(value, from_value):
 738         raise value
 739
 740
 741 print_ = getattr(moves.builtins, "print", None)
 742 if print_ is None:
 743     def print_(*args, **kwargs):
 744         """The new-style print function for Python 2.4 and 2.5."""
 745         fp = kwargs.pop("file", sys.stdout)
 746         if fp is None:
 747             return
 748
 749         def write(data):
 750             if not isinstance(data, basestring):
 751                 data = str(data)
 752             # If the file has an encoding, encode unicode with it.
 753             if (isinstance(fp, file) and
 754                     isinstance(data, unicode) and
 755                     fp.encoding is not None):
 756                 errors = getattr(fp, "errors", None)
 757                 if errors is None:
 758                     errors = "strict"
 759                 data = data.encode(fp.encoding, errors)
 760             fp.write(data)
 761         want_unicode = False
 762         sep = kwargs.pop("sep", None)
 763         if sep is not None:
 764             if isinstance(sep, unicode):
 765                 want_unicode = True
 766             elif not isinstance(sep, str):
 767                 raise TypeError("sep must be None or a string")
 768         end = kwargs.pop("end", None)
 769         if end is not None:
 770             if isinstance(end, unicode):
 771                 want_unicode = True
 772             elif not isinstance(end, str):
 773                 raise TypeError("end must be None or a string")
 774         if kwargs:
 775             raise TypeError("invalid keyword arguments to print()")
 776         if not want_unicode:
 777             for arg in args:
 778                 if isinstance(arg, unicode):
 779                     want_unicode = True
 780                     break
 781         if want_unicode:
 782             newline = unicode("\n")
 783             space = unicode(" ")
 784         else:
 785             newline = "\n"
 786             space = " "
 787         if sep is None:
 788             sep = space
 789         if end is None:
 790             end = newline
 791         for i, arg in enumerate(args):
 792             if i:
 793                 write(sep)
 794             write(arg)
 795         write(end)
 796 if sys.version_info[:2] < (3, 3):
 797     _print = print_
 798
 799     def print_(*args, **kwargs):
 800         fp = kwargs.get("file", sys.stdout)
 801         flush = kwargs.pop("flush", False)
 802         _print(*args, **kwargs)
 803         if flush and fp is not None:
 804             fp.flush()
 805
 806 _add_doc(reraise, """Reraise an exception.""")
 807
 808 if sys.version_info[0:2] < (3, 4):
 809     def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
 810               updated=functools.WRAPPER_UPDATES):
 811         def wrapper(f):
 812             f = functools.wraps(wrapped, assigned, updated)(f)
 813             f.__wrapped__ = wrapped
 814             return f
 815         return wrapper
 816 else:
 817     wraps = functools.wraps
 818
 819
 820 def with_metaclass(meta, *bases):
 821     """Create a base class with a metaclass."""
 822     # This requires a bit of explanation: the basic idea is to make a dummy
 823     # metaclass for one level of class instantiation that replaces itself with
 824     # the actual metaclass.
 825     class metaclass(type):
 826
 827         def __new__(cls, name, this_bases, d):
 828             return meta(name, bases, d)
 829
 830         @classmethod
 831         def __prepare__(cls, name, this_bases):
 832             return meta.__prepare__(name, bases)
 833     return type.__new__(metaclass, 'temporary_class', (), {})
 834
 835
 836 def add_metaclass(metaclass):
 837     """Class decorator for creating a class with a metaclass."""
 838     def wrapper(cls):
 839         orig_vars = cls.__dict__.copy()
 840         slots = orig_vars.get('__slots__')
 841         if slots is not None:
 842             if isinstance(slots, str):
 843                 slots = [slots]
 844             for slots_var in slots:
 845                 orig_vars.pop(slots_var)
 846         orig_vars.pop('__dict__', None)
 847         orig_vars.pop('__weakref__', None)
 848         if hasattr(cls, '__qualname__'):
 849             orig_vars['__qualname__'] = cls.__qualname__
 850         return metaclass(cls.__name__, cls.__bases__, orig_vars)
 851     return wrapper
 852
 853
 854 def ensure_binary(s, encoding='utf-8', errors='strict'):
 855     """Coerce **s** to six.binary_type.
 856
 857     For Python 2:
 858       - `unicode` -> encoded to `str`
 859       - `str` -> `str`
 860
 861     For Python 3:
 862       - `str` -> encoded to `bytes`
 863       - `bytes` -> `bytes`
 864     """
 865     if isinstance(s, text_type):
 866         return s.encode(encoding, errors)
 867     elif isinstance(s, binary_type):
 868         return s
 869     else:
 870         raise TypeError("not expecting type '%s'" % type(s))
 871
 872
 873 def ensure_str(s, encoding='utf-8', errors='strict'):
 874     """Coerce *s* to `str`.
 875
 876     For Python 2:
 877       - `unicode` -> encoded to `str`
 878       - `str` -> `str`
 879
 880     For Python 3:
 881       - `str` -> `str`
 882       - `bytes` -> decoded to `str`
 883     """
 884     if not isinstance(s, (text_type, binary_type)):
 885         raise TypeError("not expecting type '%s'" % type(s))
 886     if PY2 and isinstance(s, text_type):
 887         s = s.encode(encoding, errors)
 888     elif PY3 and isinstance(s, binary_type):
 889         s = s.decode(encoding, errors)
 890     return s
 891
 892
 893 def ensure_text(s, encoding='utf-8', errors='strict'):
 894     """Coerce *s* to six.text_type.
 895
 896     For Python 2:
 897       - `unicode` -> `unicode`
 898       - `str` -> `unicode`
 899
 900     For Python 3:
 901       - `str` -> `str`
 902       - `bytes` -> decoded to `str`
 903     """
 904     if isinstance(s, binary_type):
 905         return s.decode(encoding, errors)
 906     elif isinstance(s, text_type):
 907         return s
 908     else:
 909         raise TypeError("not expecting type '%s'" % type(s))
 910
 911
 912
 913 def python_2_unicode_compatible(klass):
 914     """
 915     A decorator that defines __unicode__ and __str__ methods under Python 2.
 916     Under Python 3 it does nothing.
 917
 918     To support Python 2 and 3 with a single code base, define a __str__ method
 919     returning text and apply this decorator to the class.
 920     """
 921     if PY2:
 922         if '__str__' not in klass.__dict__:
 923             raise ValueError("@python_2_unicode_compatible cannot be applied "
 924                              "to %s because it doesn't define __str__()." %
 925                              klass.__name__)
 926         klass.__unicode__ = klass.__str__
 927         klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
 928     return klass
 929
 930
 931 # Complete the moves implementation.
 932 # This code is at the end of this module to speed up module loading.
 933 # Turn this module into a package.
 934 __path__ = []  # required for PEP 302 and PEP 451
 935 __package__ = __name__  # see PEP 366 @ReservedAssignment
 936 if globals().get("__spec__") is not None:
 937     __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
 938 # Remove other six meta path importers, since they cause problems. This can
 939 # happen if six is removed from sys.modules and then reloaded. (Setuptools does
 940 # this for some reason.)
 941 if sys.meta_path:
 942     for i, importer in enumerate(sys.meta_path):
 943         # Here's some real nastiness: Another "instance" of the six module might
 944         # be floating around. Therefore, we can't use isinstance() to check for
 945         # the six meta path importer, since the other six instance will have
 946         # inserted an importer with different class.
 947         if (type(importer).__name__ == "_SixMetaPathImporter" and
 948                 importer.name == __name__):
 949             del sys.meta_path[i]
 950             break
 951     del i, importer
 952 # Finally, add the importer to the meta path import hook.
 953 sys.meta_path.append(_importer)