solenv/gdb/six.py

   1 # Copyright (c) 2010-2020 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.14.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("collections_abc", "collections", "collections.abc" if sys.version_info >= (3, 3) else "collections"),
 259     MovedModule("copyreg", "copy_reg"),
 260     MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
 261     MovedModule("dbm_ndbm", "dbm", "dbm.ndbm"),
 262     MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread" if sys.version_info < (3, 9) else "_thread"),
 263     MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
 264     MovedModule("http_cookies", "Cookie", "http.cookies"),
 265     MovedModule("html_entities", "htmlentitydefs", "html.entities"),
 266     MovedModule("html_parser", "HTMLParser", "html.parser"),
 267     MovedModule("http_client", "httplib", "http.client"),
 268     MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
 269     MovedModule("email_mime_image", "email.MIMEImage", "email.mime.image"),
 270     MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
 271     MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
 272     MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
 273     MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
 274     MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
 275     MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
 276     MovedModule("cPickle", "cPickle", "pickle"),
 277     MovedModule("queue", "Queue"),
 278     MovedModule("reprlib", "repr"),
 279     MovedModule("socketserver", "SocketServer"),
 280     MovedModule("_thread", "thread", "_thread"),
 281     MovedModule("tkinter", "Tkinter"),
 282     MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
 283     MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
 284     MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
 285     MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
 286     MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
 287     MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
 288     MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
 289     MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
 290     MovedModule("tkinter_colorchooser", "tkColorChooser",
 291                 "tkinter.colorchooser"),
 292     MovedModule("tkinter_commondialog", "tkCommonDialog",
 293                 "tkinter.commondialog"),
 294     MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
 295     MovedModule("tkinter_font", "tkFont", "tkinter.font"),
 296     MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
 297     MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
 298                 "tkinter.simpledialog"),
 299     MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
 300     MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
 301     MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
 302     MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
 303     MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
 304     MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
 305 ]
 306 # Add windows specific modules.
 307 if sys.platform == "win32":
 308     _moved_attributes += [
 309         MovedModule("winreg", "_winreg"),
 310     ]
 311
 312 for attr in _moved_attributes:
 313     setattr(_MovedItems, attr.name, attr)
 314     if isinstance(attr, MovedModule):
 315         _importer._add_module(attr, "moves." + attr.name)
 316 del attr
 317
 318 _MovedItems._moved_attributes = _moved_attributes
 319
 320 moves = _MovedItems(__name__ + ".moves")
 321 _importer._add_module(moves, "moves")
 322
 323
 324 class Module_six_moves_urllib_parse(_LazyModule):
 325
 326     """Lazy loading of moved objects in six.moves.urllib_parse"""
 327
 328
 329 _urllib_parse_moved_attributes = [
 330     MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
 331     MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
 332     MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
 333     MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
 334     MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
 335     MovedAttribute("urljoin", "urlparse", "urllib.parse"),
 336     MovedAttribute("urlparse", "urlparse", "urllib.parse"),
 337     MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
 338     MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
 339     MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
 340     MovedAttribute("quote", "urllib", "urllib.parse"),
 341     MovedAttribute("quote_plus", "urllib", "urllib.parse"),
 342     MovedAttribute("unquote", "urllib", "urllib.parse"),
 343     MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
 344     MovedAttribute("unquote_to_bytes", "urllib", "urllib.parse", "unquote", "unquote_to_bytes"),
 345     MovedAttribute("urlencode", "urllib", "urllib.parse"),
 346     MovedAttribute("splitquery", "urllib", "urllib.parse"),
 347     MovedAttribute("splittag", "urllib", "urllib.parse"),
 348     MovedAttribute("splituser", "urllib", "urllib.parse"),
 349     MovedAttribute("splitvalue", "urllib", "urllib.parse"),
 350     MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
 351     MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
 352     MovedAttribute("uses_params", "urlparse", "urllib.parse"),
 353     MovedAttribute("uses_query", "urlparse", "urllib.parse"),
 354     MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
 355 ]
 356 for attr in _urllib_parse_moved_attributes:
 357     setattr(Module_six_moves_urllib_parse, attr.name, attr)
 358 del attr
 359
 360 Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
 361
 362 _importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
 363                       "moves.urllib_parse", "moves.urllib.parse")
 364
 365
 366 class Module_six_moves_urllib_error(_LazyModule):
 367
 368     """Lazy loading of moved objects in six.moves.urllib_error"""
 369
 370
 371 _urllib_error_moved_attributes = [
 372     MovedAttribute("URLError", "urllib2", "urllib.error"),
 373     MovedAttribute("HTTPError", "urllib2", "urllib.error"),
 374     MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
 375 ]
 376 for attr in _urllib_error_moved_attributes:
 377     setattr(Module_six_moves_urllib_error, attr.name, attr)
 378 del attr
 379
 380 Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
 381
 382 _importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
 383                       "moves.urllib_error", "moves.urllib.error")
 384
 385
 386 class Module_six_moves_urllib_request(_LazyModule):
 387
 388     """Lazy loading of moved objects in six.moves.urllib_request"""
 389
 390
 391 _urllib_request_moved_attributes = [
 392     MovedAttribute("urlopen", "urllib2", "urllib.request"),
 393     MovedAttribute("install_opener", "urllib2", "urllib.request"),
 394     MovedAttribute("build_opener", "urllib2", "urllib.request"),
 395     MovedAttribute("pathname2url", "urllib", "urllib.request"),
 396     MovedAttribute("url2pathname", "urllib", "urllib.request"),
 397     MovedAttribute("getproxies", "urllib", "urllib.request"),
 398     MovedAttribute("Request", "urllib2", "urllib.request"),
 399     MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
 400     MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
 401     MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
 402     MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
 403     MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
 404     MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
 405     MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
 406     MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
 407     MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
 408     MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
 409     MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
 410     MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
 411     MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
 412     MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
 413     MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
 414     MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
 415     MovedAttribute("FileHandler", "urllib2", "urllib.request"),
 416     MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
 417     MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
 418     MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
 419     MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
 420     MovedAttribute("urlretrieve", "urllib", "urllib.request"),
 421     MovedAttribute("urlcleanup", "urllib", "urllib.request"),
 422     MovedAttribute("URLopener", "urllib", "urllib.request"),
 423     MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
 424     MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
 425     MovedAttribute("parse_http_list", "urllib2", "urllib.request"),
 426     MovedAttribute("parse_keqv_list", "urllib2", "urllib.request"),
 427 ]
 428 for attr in _urllib_request_moved_attributes:
 429     setattr(Module_six_moves_urllib_request, attr.name, attr)
 430 del attr
 431
 432 Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
 433
 434 _importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
 435                       "moves.urllib_request", "moves.urllib.request")
 436
 437
 438 class Module_six_moves_urllib_response(_LazyModule):
 439
 440     """Lazy loading of moved objects in six.moves.urllib_response"""
 441
 442
 443 _urllib_response_moved_attributes = [
 444     MovedAttribute("addbase", "urllib", "urllib.response"),
 445     MovedAttribute("addclosehook", "urllib", "urllib.response"),
 446     MovedAttribute("addinfo", "urllib", "urllib.response"),
 447     MovedAttribute("addinfourl", "urllib", "urllib.response"),
 448 ]
 449 for attr in _urllib_response_moved_attributes:
 450     setattr(Module_six_moves_urllib_response, attr.name, attr)
 451 del attr
 452
 453 Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
 454
 455 _importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
 456                       "moves.urllib_response", "moves.urllib.response")
 457
 458
 459 class Module_six_moves_urllib_robotparser(_LazyModule):
 460
 461     """Lazy loading of moved objects in six.moves.urllib_robotparser"""
 462
 463
 464 _urllib_robotparser_moved_attributes = [
 465     MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
 466 ]
 467 for attr in _urllib_robotparser_moved_attributes:
 468     setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
 469 del attr
 470
 471 Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
 472
 473 _importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
 474                       "moves.urllib_robotparser", "moves.urllib.robotparser")
 475
 476
 477 class Module_six_moves_urllib(types.ModuleType):
 478
 479     """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
 480     __path__ = []  # mark as package
 481     parse = _importer._get_module("moves.urllib_parse")
 482     error = _importer._get_module("moves.urllib_error")
 483     request = _importer._get_module("moves.urllib_request")
 484     response = _importer._get_module("moves.urllib_response")
 485     robotparser = _importer._get_module("moves.urllib_robotparser")
 486
 487     def __dir__(self):
 488         return ['parse', 'error', 'request', 'response', 'robotparser']
 489
 490 _importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
 491                       "moves.urllib")
 492
 493
 494 def add_move(move):
 495     """Add an item to six.moves."""
 496     setattr(_MovedItems, move.name, move)
 497
 498
 499 def remove_move(name):
 500     """Remove item from six.moves."""
 501     try:
 502         delattr(_MovedItems, name)
 503     except AttributeError:
 504         try:
 505             del moves.__dict__[name]
 506         except KeyError:
 507             raise AttributeError("no such move, %r" % (name,))
 508
 509
 510 if PY3:
 511     _meth_func = "__func__"
 512     _meth_self = "__self__"
 513
 514     _func_closure = "__closure__"
 515     _func_code = "__code__"
 516     _func_defaults = "__defaults__"
 517     _func_globals = "__globals__"
 518 else:
 519     _meth_func = "im_func"
 520     _meth_self = "im_self"
 521
 522     _func_closure = "func_closure"
 523     _func_code = "func_code"
 524     _func_defaults = "func_defaults"
 525     _func_globals = "func_globals"
 526
 527
 528 try:
 529     advance_iterator = next
 530 except NameError:
 531     def advance_iterator(it):
 532         return it.next()
 533 next = advance_iterator
 534
 535
 536 try:
 537     callable = callable
 538 except NameError:
 539     def callable(obj):
 540         return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
 541
 542
 543 if PY3:
 544     def get_unbound_function(unbound):
 545         return unbound
 546
 547     create_bound_method = types.MethodType
 548
 549     def create_unbound_method(func, cls):
 550         return func
 551
 552     Iterator = object
 553 else:
 554     def get_unbound_function(unbound):
 555         return unbound.im_func
 556
 557     def create_bound_method(func, obj):
 558         return types.MethodType(func, obj, obj.__class__)
 559
 560     def create_unbound_method(func, cls):
 561         return types.MethodType(func, None, cls)
 562
 563     class Iterator(object):
 564
 565         def next(self):
 566             return type(self).__next__(self)
 567
 568     callable = callable
 569 _add_doc(get_unbound_function,
 570          """Get the function out of a possibly unbound function""")
 571
 572
 573 get_method_function = operator.attrgetter(_meth_func)
 574 get_method_self = operator.attrgetter(_meth_self)
 575 get_function_closure = operator.attrgetter(_func_closure)
 576 get_function_code = operator.attrgetter(_func_code)
 577 get_function_defaults = operator.attrgetter(_func_defaults)
 578 get_function_globals = operator.attrgetter(_func_globals)
 579
 580
 581 if PY3:
 582     def iterkeys(d, **kw):
 583         return iter(d.keys(**kw))
 584
 585     def itervalues(d, **kw):
 586         return iter(d.values(**kw))
 587
 588     def iteritems(d, **kw):
 589         return iter(d.items(**kw))
 590
 591     def iterlists(d, **kw):
 592         return iter(d.lists(**kw))
 593
 594     viewkeys = operator.methodcaller("keys")
 595
 596     viewvalues = operator.methodcaller("values")
 597
 598     viewitems = operator.methodcaller("items")
 599 else:
 600     def iterkeys(d, **kw):
 601         return d.iterkeys(**kw)
 602
 603     def itervalues(d, **kw):
 604         return d.itervalues(**kw)
 605
 606     def iteritems(d, **kw):
 607         return d.iteritems(**kw)
 608
 609     def iterlists(d, **kw):
 610         return d.iterlists(**kw)
 611
 612     viewkeys = operator.methodcaller("viewkeys")
 613
 614     viewvalues = operator.methodcaller("viewvalues")
 615
 616     viewitems = operator.methodcaller("viewitems")
 617
 618 _add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
 619 _add_doc(itervalues, "Return an iterator over the values of a dictionary.")
 620 _add_doc(iteritems,
 621          "Return an iterator over the (key, value) pairs of a dictionary.")
 622 _add_doc(iterlists,
 623          "Return an iterator over the (key, [values]) pairs of a dictionary.")
 624
 625
 626 if PY3:
 627     def b(s):
 628         return s.encode("latin-1")
 629
 630     def u(s):
 631         return s
 632     unichr = chr
 633     import struct
 634     int2byte = struct.Struct(">B").pack
 635     del struct
 636     byte2int = operator.itemgetter(0)
 637     indexbytes = operator.getitem
 638     iterbytes = iter
 639     import io
 640     StringIO = io.StringIO
 641     BytesIO = io.BytesIO
 642     del io
 643     _assertCountEqual = "assertCountEqual"
 644     if sys.version_info[1] <= 1:
 645         _assertRaisesRegex = "assertRaisesRegexp"
 646         _assertRegex = "assertRegexpMatches"
 647         _assertNotRegex = "assertNotRegexpMatches"
 648     else:
 649         _assertRaisesRegex = "assertRaisesRegex"
 650         _assertRegex = "assertRegex"
 651         _assertNotRegex = "assertNotRegex"
 652 else:
 653     def b(s):
 654         return s
 655     # Workaround for standalone backslash
 656
 657     def u(s):
 658         return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
 659     unichr = unichr
 660     int2byte = chr
 661
 662     def byte2int(bs):
 663         return ord(bs[0])
 664
 665     def indexbytes(buf, i):
 666         return ord(buf[i])
 667     iterbytes = functools.partial(itertools.imap, ord)
 668     import StringIO
 669     StringIO = BytesIO = StringIO.StringIO
 670     _assertCountEqual = "assertItemsEqual"
 671     _assertRaisesRegex = "assertRaisesRegexp"
 672     _assertRegex = "assertRegexpMatches"
 673     _assertNotRegex = "assertNotRegexpMatches"
 674 _add_doc(b, """Byte literal""")
 675 _add_doc(u, """Text literal""")
 676
 677
 678 def assertCountEqual(self, *args, **kwargs):
 679     return getattr(self, _assertCountEqual)(*args, **kwargs)
 680
 681
 682 def assertRaisesRegex(self, *args, **kwargs):
 683     return getattr(self, _assertRaisesRegex)(*args, **kwargs)
 684
 685
 686 def assertRegex(self, *args, **kwargs):
 687     return getattr(self, _assertRegex)(*args, **kwargs)
 688
 689
 690 def assertNotRegex(self, *args, **kwargs):
 691     return getattr(self, _assertNotRegex)(*args, **kwargs)
 692
 693
 694 if PY3:
 695     exec_ = getattr(moves.builtins, "exec")
 696
 697     def reraise(tp, value, tb=None):
 698         try:
 699             if value is None:
 700                 value = tp()
 701             if value.__traceback__ is not tb:
 702                 raise value.with_traceback(tb)
 703             raise value
 704         finally:
 705             value = None
 706             tb = None
 707
 708 else:
 709     def exec_(_code_, _globs_=None, _locs_=None):
 710         """Execute code in a namespace."""
 711         if _globs_ is None:
 712             frame = sys._getframe(1)
 713             _globs_ = frame.f_globals
 714             if _locs_ is None:
 715                 _locs_ = frame.f_locals
 716             del frame
 717         elif _locs_ is None:
 718             _locs_ = _globs_
 719         exec("""exec _code_ in _globs_, _locs_""")
 720
 721     exec_("""def reraise(tp, value, tb=None):
 722     try:
 723         raise tp, value, tb
 724     finally:
 725         tb = None
 726 """)
 727
 728
 729 if sys.version_info[:2] > (3,):
 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     # This does exactly the same what the :func:`py3:functools.update_wrapper`
 810     # function does on Python versions after 3.2. It sets the ``__wrapped__``
 811     # attribute on ``wrapper`` object and it doesn't raise an error if any of
 812     # the attributes mentioned in ``assigned`` and ``updated`` are missing on
 813     # ``wrapped`` object.
 814     def _update_wrapper(wrapper, wrapped,
 815                         assigned=functools.WRAPPER_ASSIGNMENTS,
 816                         updated=functools.WRAPPER_UPDATES):
 817         for attr in assigned:
 818             try:
 819                 value = getattr(wrapped, attr)
 820             except AttributeError:
 821                 continue
 822             else:
 823                 setattr(wrapper, attr, value)
 824         for attr in updated:
 825             getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
 826         wrapper.__wrapped__ = wrapped
 827         return wrapper
 828     _update_wrapper.__doc__ = functools.update_wrapper.__doc__
 829
 830     def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
 831               updated=functools.WRAPPER_UPDATES):
 832         return functools.partial(_update_wrapper, wrapped=wrapped,
 833                                  assigned=assigned, updated=updated)
 834     wraps.__doc__ = functools.wraps.__doc__
 835
 836 else:
 837     wraps = functools.wraps
 838
 839
 840 def with_metaclass(meta, *bases):
 841     """Create a base class with a metaclass."""
 842     # This requires a bit of explanation: the basic idea is to make a dummy
 843     # metaclass for one level of class instantiation that replaces itself with
 844     # the actual metaclass.
 845     class metaclass(type):
 846
 847         def __new__(cls, name, this_bases, d):
 848             if sys.version_info[:2] >= (3, 7):
 849                 # This version introduced PEP 560 that requires a bit
 850                 # of extra care (we mimic what is done by __build_class__).
 851                 resolved_bases = types.resolve_bases(bases)
 852                 if resolved_bases is not bases:
 853                     d['__orig_bases__'] = bases
 854             else:
 855                 resolved_bases = bases
 856             return meta(name, resolved_bases, d)
 857
 858         @classmethod
 859         def __prepare__(cls, name, this_bases):
 860             return meta.__prepare__(name, bases)
 861     return type.__new__(metaclass, 'temporary_class', (), {})
 862
 863
 864 def add_metaclass(metaclass):
 865     """Class decorator for creating a class with a metaclass."""
 866     def wrapper(cls):
 867         orig_vars = cls.__dict__.copy()
 868         slots = orig_vars.get('__slots__')
 869         if slots is not None:
 870             if isinstance(slots, str):
 871                 slots = [slots]
 872             for slots_var in slots:
 873                 orig_vars.pop(slots_var)
 874         orig_vars.pop('__dict__', None)
 875         orig_vars.pop('__weakref__', None)
 876         if hasattr(cls, '__qualname__'):
 877             orig_vars['__qualname__'] = cls.__qualname__
 878         return metaclass(cls.__name__, cls.__bases__, orig_vars)
 879     return wrapper
 880
 881
 882 def ensure_binary(s, encoding='utf-8', errors='strict'):
 883     """Coerce **s** to six.binary_type.
 884
 885     For Python 2:
 886       - `unicode` -> encoded to `str`
 887       - `str` -> `str`
 888
 889     For Python 3:
 890       - `str` -> encoded to `bytes`
 891       - `bytes` -> `bytes`
 892     """
 893     if isinstance(s, text_type):
 894         return s.encode(encoding, errors)
 895     elif isinstance(s, binary_type):
 896         return s
 897     else:
 898         raise TypeError("not expecting type '%s'" % type(s))
 899
 900
 901 def ensure_str(s, encoding='utf-8', errors='strict'):
 902     """Coerce *s* to `str`.
 903
 904     For Python 2:
 905       - `unicode` -> encoded to `str`
 906       - `str` -> `str`
 907
 908     For Python 3:
 909       - `str` -> `str`
 910       - `bytes` -> decoded to `str`
 911     """
 912     if not isinstance(s, (text_type, binary_type)):
 913         raise TypeError("not expecting type '%s'" % type(s))
 914     if PY2 and isinstance(s, text_type):
 915         s = s.encode(encoding, errors)
 916     elif PY3 and isinstance(s, binary_type):
 917         s = s.decode(encoding, errors)
 918     return s
 919
 920
 921 def ensure_text(s, encoding='utf-8', errors='strict'):
 922     """Coerce *s* to six.text_type.
 923
 924     For Python 2:
 925       - `unicode` -> `unicode`
 926       - `str` -> `unicode`
 927
 928     For Python 3:
 929       - `str` -> `str`
 930       - `bytes` -> decoded to `str`
 931     """
 932     if isinstance(s, binary_type):
 933         return s.decode(encoding, errors)
 934     elif isinstance(s, text_type):
 935         return s
 936     else:
 937         raise TypeError("not expecting type '%s'" % type(s))
 938
 939
 940 def python_2_unicode_compatible(klass):
 941     """
 942     A class decorator that defines __unicode__ and __str__ methods under Python 2.
 943     Under Python 3 it does nothing.
 944
 945     To support Python 2 and 3 with a single code base, define a __str__ method
 946     returning text and apply this decorator to the class.
 947     """
 948     if PY2:
 949         if '__str__' not in klass.__dict__:
 950             raise ValueError("@python_2_unicode_compatible cannot be applied "
 951                              "to %s because it doesn't define __str__()." %
 952                              klass.__name__)
 953         klass.__unicode__ = klass.__str__
 954         klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
 955     return klass
 956
 957
 958 # Complete the moves implementation.
 959 # This code is at the end of this module to speed up module loading.
 960 # Turn this module into a package.
 961 __path__ = []  # required for PEP 302 and PEP 451
 962 __package__ = __name__  # see PEP 366 @ReservedAssignment
 963 if globals().get("__spec__") is not None:
 964     __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
 965 # Remove other six meta path importers, since they cause problems. This can
 966 # happen if six is removed from sys.modules and then reloaded. (Setuptools does
 967 # this for some reason.)
 968 if sys.meta_path:
 969     for i, importer in enumerate(sys.meta_path):
 970         # Here's some real nastiness: Another "instance" of the six module might
 971         # be floating around. Therefore, we can't use isinstance() to check for
 972         # the six meta path importer, since the other six instance will have
 973         # inserted an importer with different class.
 974         if (type(importer).__name__ == "_SixMetaPathImporter" and
 975                 importer.name == __name__):
 976             del sys.meta_path[i]
 977             break
 978     del i, importer
 979 # Finally, add the importer to the meta path import hook.
 980 sys.meta_path.append(_importer)