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