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