six.py (34549B)
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"), 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)