Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1# Copyright (c) 2010-2019 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 

23from __future__ import absolute_import 

24 

25import functools 

26import itertools 

27import operator 

28import sys 

29import types 

30 

31__author__ = "Benjamin Peterson <benjamin@python.org>" 

32__version__ = "1.12.0" 

33 

34 

35# Useful for very coarse version differentiation. 

36PY2 = sys.version_info[0] == 2 

37PY3 = sys.version_info[0] == 3 

38PY34 = sys.version_info[0:2] >= (3, 4) 

39 

40if 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 

48else: 

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 def __len__(self): 

62 return 1 << 31 

63 

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 

75def _add_doc(func, doc): 

76 """Add documentation to a function.""" 

77 func.__doc__ = doc 

78 

79 

80def _import_module(name): 

81 """Import module, returning the module after the last dot.""" 

82 __import__(name) 

83 return sys.modules[name] 

84 

85 

86class _LazyDescr(object): 

87 def __init__(self, name): 

88 self.name = name 

89 

90 def __get__(self, obj, tp): 

91 result = self._resolve() 

92 setattr(obj, self.name, result) # Invokes __set__. 

93 try: 

94 # This is a bit ugly, but it avoids running this again by 

95 # removing this descriptor. 

96 delattr(obj.__class__, self.name) 

97 except AttributeError: 

98 pass 

99 return result 

100 

101 

102class MovedModule(_LazyDescr): 

103 def __init__(self, name, old, new=None): 

104 super(MovedModule, self).__init__(name) 

105 if PY3: 

106 if new is None: 

107 new = name 

108 self.mod = new 

109 else: 

110 self.mod = old 

111 

112 def _resolve(self): 

113 return _import_module(self.mod) 

114 

115 def __getattr__(self, attr): 

116 _module = self._resolve() 

117 value = getattr(_module, attr) 

118 setattr(self, attr, value) 

119 return value 

120 

121 

122class _LazyModule(types.ModuleType): 

123 def __init__(self, name): 

124 super(_LazyModule, self).__init__(name) 

125 self.__doc__ = self.__class__.__doc__ 

126 

127 def __dir__(self): 

128 attrs = ["__doc__", "__name__"] 

129 attrs += [attr.name for attr in self._moved_attributes] 

130 return attrs 

131 

132 # Subclasses should override this 

133 _moved_attributes = [] 

134 

135 

136class MovedAttribute(_LazyDescr): 

137 def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None): 

138 super(MovedAttribute, self).__init__(name) 

139 if PY3: 

140 if new_mod is None: 

141 new_mod = name 

142 self.mod = new_mod 

143 if new_attr is None: 

144 if old_attr is None: 

145 new_attr = name 

146 else: 

147 new_attr = old_attr 

148 self.attr = new_attr 

149 else: 

150 self.mod = old_mod 

151 if old_attr is None: 

152 old_attr = name 

153 self.attr = old_attr 

154 

155 def _resolve(self): 

156 module = _import_module(self.mod) 

157 return getattr(module, self.attr) 

158 

159 

160class _SixMetaPathImporter(object): 

161 

162 """ 

163 A meta path importer to import six.moves and its submodules. 

164 

165 This class implements a PEP302 finder and loader. It should be compatible 

166 with Python 2.5 and all existing versions of Python3 

167 """ 

168 

169 def __init__(self, six_module_name): 

170 self.name = six_module_name 

171 self.known_modules = {} 

172 

173 def _add_module(self, mod, *fullnames): 

174 for fullname in fullnames: 

175 self.known_modules[self.name + "." + fullname] = mod 

176 

177 def _get_module(self, fullname): 

178 return self.known_modules[self.name + "." + fullname] 

179 

180 def find_module(self, fullname, path=None): 

181 if fullname in self.known_modules: 

182 return self 

183 return None 

184 

185 def __get_module(self, fullname): 

186 try: 

187 return self.known_modules[fullname] 

188 except KeyError: 

189 raise ImportError("This loader does not know module " + fullname) 

190 

191 def load_module(self, fullname): 

192 try: 

193 # in case of a reload 

194 return sys.modules[fullname] 

195 except KeyError: 

196 pass 

197 mod = self.__get_module(fullname) 

198 if isinstance(mod, MovedModule): 

199 mod = mod._resolve() 

200 else: 

201 mod.__loader__ = self 

202 sys.modules[fullname] = mod 

203 return mod 

204 

205 def is_package(self, fullname): 

206 """ 

207 Return true, if the named module is a package. 

208 

209 We need this method to get correct spec objects with 

210 Python 3.4 (see PEP451) 

211 """ 

212 return hasattr(self.__get_module(fullname), "__path__") 

213 

214 def get_code(self, fullname): 

215 """Return None 

216 

217 Required, if is_package is implemented""" 

218 self.__get_module(fullname) # eventually raises ImportError 

219 return None 

220 

221 get_source = get_code # same as get_code 

222 

223 

224_importer = _SixMetaPathImporter(__name__) 

225 

226 

227class _MovedItems(_LazyModule): 

228 

229 """Lazy loading of moved objects""" 

230 

231 __path__ = [] # mark as package 

232 

233 

234_moved_attributes = [ 

235 MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"), 

236 MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"), 

237 MovedAttribute( 

238 "filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse" 

239 ), 

240 MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"), 

241 MovedAttribute("intern", "__builtin__", "sys"), 

242 MovedAttribute("map", "itertools", "builtins", "imap", "map"), 

243 MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"), 

244 MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"), 

245 MovedAttribute("getoutput", "commands", "subprocess"), 

246 MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"), 

247 MovedAttribute( 

248 "reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload" 

249 ), 

250 MovedAttribute("reduce", "__builtin__", "functools"), 

251 MovedAttribute("shlex_quote", "pipes", "shlex", "quote"), 

252 MovedAttribute("StringIO", "StringIO", "io"), 

253 MovedAttribute("UserDict", "UserDict", "collections"), 

254 MovedAttribute("UserList", "UserList", "collections"), 

255 MovedAttribute("UserString", "UserString", "collections"), 

256 MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"), 

257 MovedAttribute("zip", "itertools", "builtins", "izip", "zip"), 

258 MovedAttribute( 

259 "zip_longest", "itertools", "itertools", "izip_longest", "zip_longest" 

260 ), 

261 MovedModule("builtins", "__builtin__"), 

262 MovedModule("configparser", "ConfigParser"), 

263 MovedModule("copyreg", "copy_reg"), 

264 MovedModule("dbm_gnu", "gdbm", "dbm.gnu"), 

265 MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"), 

266 MovedModule("http_cookiejar", "cookielib", "http.cookiejar"), 

267 MovedModule("http_cookies", "Cookie", "http.cookies"), 

268 MovedModule("html_entities", "htmlentitydefs", "html.entities"), 

269 MovedModule("html_parser", "HTMLParser", "html.parser"), 

270 MovedModule("http_client", "httplib", "http.client"), 

271 MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"), 

272 MovedModule("email_mime_image", "email.MIMEImage", "email.mime.image"), 

273 MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"), 

274 MovedModule( 

275 "email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart" 

276 ), 

277 MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"), 

278 MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"), 

279 MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"), 

280 MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"), 

281 MovedModule("cPickle", "cPickle", "pickle"), 

282 MovedModule("queue", "Queue"), 

283 MovedModule("reprlib", "repr"), 

284 MovedModule("socketserver", "SocketServer"), 

285 MovedModule("_thread", "thread", "_thread"), 

286 MovedModule("tkinter", "Tkinter"), 

287 MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"), 

288 MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"), 

289 MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"), 

290 MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"), 

291 MovedModule("tkinter_tix", "Tix", "tkinter.tix"), 

292 MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"), 

293 MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"), 

294 MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"), 

295 MovedModule("tkinter_colorchooser", "tkColorChooser", "tkinter.colorchooser"), 

296 MovedModule("tkinter_commondialog", "tkCommonDialog", "tkinter.commondialog"), 

297 MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"), 

298 MovedModule("tkinter_font", "tkFont", "tkinter.font"), 

299 MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"), 

300 MovedModule("tkinter_tksimpledialog", "tkSimpleDialog", "tkinter.simpledialog"), 

301 MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"), 

302 MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"), 

303 MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"), 

304 MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"), 

305 MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"), 

306 MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"), 

307] 

308# Add windows specific modules. 

309if sys.platform == "win32": 

310 _moved_attributes += [MovedModule("winreg", "_winreg")] 

311 

312for attr in _moved_attributes: 

313 setattr(_MovedItems, attr.name, attr) 

314 if isinstance(attr, MovedModule): 

315 _importer._add_module(attr, "moves." + attr.name) 

316del attr 

317 

318_MovedItems._moved_attributes = _moved_attributes 

319 

320moves = _MovedItems(__name__ + ".moves") 

321_importer._add_module(moves, "moves") 

322 

323 

324class Module_six_moves_urllib_parse(_LazyModule): 

325 

326 """Lazy loading of moved objects in six.moves.urllib_parse""" 

327 

328 

329_urllib_parse_moved_attributes = [ 

330 MovedAttribute("ParseResult", "urlparse", "urllib.parse"), 

331 MovedAttribute("SplitResult", "urlparse", "urllib.parse"), 

332 MovedAttribute("parse_qs", "urlparse", "urllib.parse"), 

333 MovedAttribute("parse_qsl", "urlparse", "urllib.parse"), 

334 MovedAttribute("urldefrag", "urlparse", "urllib.parse"), 

335 MovedAttribute("urljoin", "urlparse", "urllib.parse"), 

336 MovedAttribute("urlparse", "urlparse", "urllib.parse"), 

337 MovedAttribute("urlsplit", "urlparse", "urllib.parse"), 

338 MovedAttribute("urlunparse", "urlparse", "urllib.parse"), 

339 MovedAttribute("urlunsplit", "urlparse", "urllib.parse"), 

340 MovedAttribute("quote", "urllib", "urllib.parse"), 

341 MovedAttribute("quote_plus", "urllib", "urllib.parse"), 

342 MovedAttribute("unquote", "urllib", "urllib.parse"), 

343 MovedAttribute("unquote_plus", "urllib", "urllib.parse"), 

344 MovedAttribute( 

345 "unquote_to_bytes", "urllib", "urllib.parse", "unquote", "unquote_to_bytes" 

346 ), 

347 MovedAttribute("urlencode", "urllib", "urllib.parse"), 

348 MovedAttribute("splitquery", "urllib", "urllib.parse"), 

349 MovedAttribute("splittag", "urllib", "urllib.parse"), 

350 MovedAttribute("splituser", "urllib", "urllib.parse"), 

351 MovedAttribute("splitvalue", "urllib", "urllib.parse"), 

352 MovedAttribute("uses_fragment", "urlparse", "urllib.parse"), 

353 MovedAttribute("uses_netloc", "urlparse", "urllib.parse"), 

354 MovedAttribute("uses_params", "urlparse", "urllib.parse"), 

355 MovedAttribute("uses_query", "urlparse", "urllib.parse"), 

356 MovedAttribute("uses_relative", "urlparse", "urllib.parse"), 

357] 

358for attr in _urllib_parse_moved_attributes: 

359 setattr(Module_six_moves_urllib_parse, attr.name, attr) 

360del attr 

361 

362Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes 

363 

364_importer._add_module( 

365 Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"), 

366 "moves.urllib_parse", 

367 "moves.urllib.parse", 

368) 

369 

370 

371class Module_six_moves_urllib_error(_LazyModule): 

372 

373 """Lazy loading of moved objects in six.moves.urllib_error""" 

374 

375 

376_urllib_error_moved_attributes = [ 

377 MovedAttribute("URLError", "urllib2", "urllib.error"), 

378 MovedAttribute("HTTPError", "urllib2", "urllib.error"), 

379 MovedAttribute("ContentTooShortError", "urllib", "urllib.error"), 

380] 

381for attr in _urllib_error_moved_attributes: 

382 setattr(Module_six_moves_urllib_error, attr.name, attr) 

383del attr 

384 

385Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes 

386 

387_importer._add_module( 

388 Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"), 

389 "moves.urllib_error", 

390 "moves.urllib.error", 

391) 

392 

393 

394class Module_six_moves_urllib_request(_LazyModule): 

395 

396 """Lazy loading of moved objects in six.moves.urllib_request""" 

397 

398 

399_urllib_request_moved_attributes = [ 

400 MovedAttribute("urlopen", "urllib2", "urllib.request"), 

401 MovedAttribute("install_opener", "urllib2", "urllib.request"), 

402 MovedAttribute("build_opener", "urllib2", "urllib.request"), 

403 MovedAttribute("pathname2url", "urllib", "urllib.request"), 

404 MovedAttribute("url2pathname", "urllib", "urllib.request"), 

405 MovedAttribute("getproxies", "urllib", "urllib.request"), 

406 MovedAttribute("Request", "urllib2", "urllib.request"), 

407 MovedAttribute("OpenerDirector", "urllib2", "urllib.request"), 

408 MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"), 

409 MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"), 

410 MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"), 

411 MovedAttribute("ProxyHandler", "urllib2", "urllib.request"), 

412 MovedAttribute("BaseHandler", "urllib2", "urllib.request"), 

413 MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"), 

414 MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"), 

415 MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"), 

416 MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"), 

417 MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"), 

418 MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"), 

419 MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"), 

420 MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"), 

421 MovedAttribute("HTTPHandler", "urllib2", "urllib.request"), 

422 MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"), 

423 MovedAttribute("FileHandler", "urllib2", "urllib.request"), 

424 MovedAttribute("FTPHandler", "urllib2", "urllib.request"), 

425 MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"), 

426 MovedAttribute("UnknownHandler", "urllib2", "urllib.request"), 

427 MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"), 

428 MovedAttribute("urlretrieve", "urllib", "urllib.request"), 

429 MovedAttribute("urlcleanup", "urllib", "urllib.request"), 

430 MovedAttribute("URLopener", "urllib", "urllib.request"), 

431 MovedAttribute("FancyURLopener", "urllib", "urllib.request"), 

432 MovedAttribute("proxy_bypass", "urllib", "urllib.request"), 

433 MovedAttribute("parse_http_list", "urllib2", "urllib.request"), 

434 MovedAttribute("parse_keqv_list", "urllib2", "urllib.request"), 

435] 

436for attr in _urllib_request_moved_attributes: 

437 setattr(Module_six_moves_urllib_request, attr.name, attr) 

438del attr 

439 

440Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes 

441 

442_importer._add_module( 

443 Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"), 

444 "moves.urllib_request", 

445 "moves.urllib.request", 

446) 

447 

448 

449class Module_six_moves_urllib_response(_LazyModule): 

450 

451 """Lazy loading of moved objects in six.moves.urllib_response""" 

452 

453 

454_urllib_response_moved_attributes = [ 

455 MovedAttribute("addbase", "urllib", "urllib.response"), 

456 MovedAttribute("addclosehook", "urllib", "urllib.response"), 

457 MovedAttribute("addinfo", "urllib", "urllib.response"), 

458 MovedAttribute("addinfourl", "urllib", "urllib.response"), 

459] 

460for attr in _urllib_response_moved_attributes: 

461 setattr(Module_six_moves_urllib_response, attr.name, attr) 

462del attr 

463 

464Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes 

465 

466_importer._add_module( 

467 Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"), 

468 "moves.urllib_response", 

469 "moves.urllib.response", 

470) 

471 

472 

473class Module_six_moves_urllib_robotparser(_LazyModule): 

474 

475 """Lazy loading of moved objects in six.moves.urllib_robotparser""" 

476 

477 

478_urllib_robotparser_moved_attributes = [ 

479 MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser") 

480] 

481for attr in _urllib_robotparser_moved_attributes: 

482 setattr(Module_six_moves_urllib_robotparser, attr.name, attr) 

483del attr 

484 

485Module_six_moves_urllib_robotparser._moved_attributes = ( 

486 _urllib_robotparser_moved_attributes 

487) 

488 

489_importer._add_module( 

490 Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"), 

491 "moves.urllib_robotparser", 

492 "moves.urllib.robotparser", 

493) 

494 

495 

496class Module_six_moves_urllib(types.ModuleType): 

497 

498 """Create a six.moves.urllib namespace that resembles the Python 3 namespace""" 

499 

500 __path__ = [] # mark as package 

501 parse = _importer._get_module("moves.urllib_parse") 

502 error = _importer._get_module("moves.urllib_error") 

503 request = _importer._get_module("moves.urllib_request") 

504 response = _importer._get_module("moves.urllib_response") 

505 robotparser = _importer._get_module("moves.urllib_robotparser") 

506 

507 def __dir__(self): 

508 return ["parse", "error", "request", "response", "robotparser"] 

509 

510 

511_importer._add_module( 

512 Module_six_moves_urllib(__name__ + ".moves.urllib"), "moves.urllib" 

513) 

514 

515 

516def add_move(move): 

517 """Add an item to six.moves.""" 

518 setattr(_MovedItems, move.name, move) 

519 

520 

521def remove_move(name): 

522 """Remove item from six.moves.""" 

523 try: 

524 delattr(_MovedItems, name) 

525 except AttributeError: 

526 try: 

527 del moves.__dict__[name] 

528 except KeyError: 

529 raise AttributeError("no such move, %r" % (name,)) 

530 

531 

532if PY3: 

533 _meth_func = "__func__" 

534 _meth_self = "__self__" 

535 

536 _func_closure = "__closure__" 

537 _func_code = "__code__" 

538 _func_defaults = "__defaults__" 

539 _func_globals = "__globals__" 

540else: 

541 _meth_func = "im_func" 

542 _meth_self = "im_self" 

543 

544 _func_closure = "func_closure" 

545 _func_code = "func_code" 

546 _func_defaults = "func_defaults" 

547 _func_globals = "func_globals" 

548 

549 

550try: 

551 advance_iterator = next 

552except NameError: 

553 

554 def advance_iterator(it): 

555 return it.next() 

556 

557 

558next = advance_iterator 

559 

560 

561try: 

562 callable = callable 

563except NameError: 

564 

565 def callable(obj): 

566 return any("__call__" in klass.__dict__ for klass in type(obj).__mro__) 

567 

568 

569if PY3: 

570 

571 def get_unbound_function(unbound): 

572 return unbound 

573 

574 create_bound_method = types.MethodType 

575 

576 def create_unbound_method(func, cls): 

577 return func 

578 

579 Iterator = object 

580else: 

581 

582 def get_unbound_function(unbound): 

583 return unbound.im_func 

584 

585 def create_bound_method(func, obj): 

586 return types.MethodType(func, obj, obj.__class__) 

587 

588 def create_unbound_method(func, cls): 

589 return types.MethodType(func, None, cls) 

590 

591 class Iterator(object): 

592 def next(self): 

593 return type(self).__next__(self) 

594 

595 callable = callable 

596_add_doc( 

597 get_unbound_function, """Get the function out of a possibly unbound function""" 

598) 

599 

600 

601get_method_function = operator.attrgetter(_meth_func) 

602get_method_self = operator.attrgetter(_meth_self) 

603get_function_closure = operator.attrgetter(_func_closure) 

604get_function_code = operator.attrgetter(_func_code) 

605get_function_defaults = operator.attrgetter(_func_defaults) 

606get_function_globals = operator.attrgetter(_func_globals) 

607 

608 

609if PY3: 

610 

611 def iterkeys(d, **kw): 

612 return iter(d.keys(**kw)) 

613 

614 def itervalues(d, **kw): 

615 return iter(d.values(**kw)) 

616 

617 def iteritems(d, **kw): 

618 return iter(d.items(**kw)) 

619 

620 def iterlists(d, **kw): 

621 return iter(d.lists(**kw)) 

622 

623 viewkeys = operator.methodcaller("keys") 

624 

625 viewvalues = operator.methodcaller("values") 

626 

627 viewitems = operator.methodcaller("items") 

628else: 

629 

630 def iterkeys(d, **kw): 

631 return d.iterkeys(**kw) 

632 

633 def itervalues(d, **kw): 

634 return d.itervalues(**kw) 

635 

636 def iteritems(d, **kw): 

637 return d.iteritems(**kw) 

638 

639 def iterlists(d, **kw): 

640 return d.iterlists(**kw) 

641 

642 viewkeys = operator.methodcaller("viewkeys") 

643 

644 viewvalues = operator.methodcaller("viewvalues") 

645 

646 viewitems = operator.methodcaller("viewitems") 

647 

648_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.") 

649_add_doc(itervalues, "Return an iterator over the values of a dictionary.") 

650_add_doc(iteritems, "Return an iterator over the (key, value) pairs of a dictionary.") 

651_add_doc( 

652 iterlists, "Return an iterator over the (key, [values]) pairs of a dictionary." 

653) 

654 

655 

656if PY3: 

657 

658 def b(s): 

659 return s.encode("latin-1") 

660 

661 def u(s): 

662 return s 

663 

664 unichr = chr 

665 import struct 

666 

667 int2byte = struct.Struct(">B").pack 

668 del struct 

669 byte2int = operator.itemgetter(0) 

670 indexbytes = operator.getitem 

671 iterbytes = iter 

672 import io 

673 

674 StringIO = io.StringIO 

675 BytesIO = io.BytesIO 

676 del io 

677 _assertCountEqual = "assertCountEqual" 

678 if sys.version_info[1] <= 1: 

679 _assertRaisesRegex = "assertRaisesRegexp" 

680 _assertRegex = "assertRegexpMatches" 

681 else: 

682 _assertRaisesRegex = "assertRaisesRegex" 

683 _assertRegex = "assertRegex" 

684else: 

685 

686 def b(s): 

687 return s 

688 

689 # Workaround for standalone backslash 

690 

691 def u(s): 

692 return unicode(s.replace(r"\\", r"\\\\"), "unicode_escape") 

693 

694 unichr = unichr 

695 int2byte = chr 

696 

697 def byte2int(bs): 

698 return ord(bs[0]) 

699 

700 def indexbytes(buf, i): 

701 return ord(buf[i]) 

702 

703 iterbytes = functools.partial(itertools.imap, ord) 

704 import StringIO 

705 

706 StringIO = BytesIO = StringIO.StringIO 

707 _assertCountEqual = "assertItemsEqual" 

708 _assertRaisesRegex = "assertRaisesRegexp" 

709 _assertRegex = "assertRegexpMatches" 

710_add_doc(b, """Byte literal""") 

711_add_doc(u, """Text literal""") 

712 

713 

714def assertCountEqual(self, *args, **kwargs): 

715 return getattr(self, _assertCountEqual)(*args, **kwargs) 

716 

717 

718def assertRaisesRegex(self, *args, **kwargs): 

719 return getattr(self, _assertRaisesRegex)(*args, **kwargs) 

720 

721 

722def assertRegex(self, *args, **kwargs): 

723 return getattr(self, _assertRegex)(*args, **kwargs) 

724 

725 

726if PY3: 

727 exec_ = getattr(moves.builtins, "exec") 

728 

729 def reraise(tp, value, tb=None): 

730 try: 

731 if value is None: 

732 value = tp() 

733 if value.__traceback__ is not tb: 

734 raise value.with_traceback(tb) 

735 raise value 

736 finally: 

737 value = None 

738 tb = None 

739 

740 

741else: 

742 

743 def exec_(_code_, _globs_=None, _locs_=None): 

744 """Execute code in a namespace.""" 

745 if _globs_ is None: 

746 frame = sys._getframe(1) 

747 _globs_ = frame.f_globals 

748 if _locs_ is None: 

749 _locs_ = frame.f_locals 

750 del frame 

751 elif _locs_ is None: 

752 _locs_ = _globs_ 

753 exec("""exec _code_ in _globs_, _locs_""") 

754 

755 exec_( 

756 """def reraise(tp, value, tb=None): 

757 try: 

758 raise tp, value, tb 

759 finally: 

760 tb = None 

761""" 

762 ) 

763 

764 

765if sys.version_info[:2] == (3, 2): 

766 exec_( 

767 """def raise_from(value, from_value): 

768 try: 

769 if from_value is None: 

770 raise value 

771 raise value from from_value 

772 finally: 

773 value = None 

774""" 

775 ) 

776elif sys.version_info[:2] > (3, 2): 

777 exec_( 

778 """def raise_from(value, from_value): 

779 try: 

780 raise value from from_value 

781 finally: 

782 value = None 

783""" 

784 ) 

785else: 

786 

787 def raise_from(value, from_value): 

788 raise value 

789 

790 

791print_ = getattr(moves.builtins, "print", None) 

792if print_ is None: 

793 

794 def print_(*args, **kwargs): 

795 """The new-style print function for Python 2.4 and 2.5.""" 

796 fp = kwargs.pop("file", sys.stdout) 

797 if fp is None: 

798 return 

799 

800 def write(data): 

801 if not isinstance(data, basestring): 

802 data = str(data) 

803 # If the file has an encoding, encode unicode with it. 

804 if ( 

805 isinstance(fp, file) 

806 and isinstance(data, unicode) 

807 and fp.encoding is not None 

808 ): 

809 errors = getattr(fp, "errors", None) 

810 if errors is None: 

811 errors = "strict" 

812 data = data.encode(fp.encoding, errors) 

813 fp.write(data) 

814 

815 want_unicode = False 

816 sep = kwargs.pop("sep", None) 

817 if sep is not None: 

818 if isinstance(sep, unicode): 

819 want_unicode = True 

820 elif not isinstance(sep, str): 

821 raise TypeError("sep must be None or a string") 

822 end = kwargs.pop("end", None) 

823 if end is not None: 

824 if isinstance(end, unicode): 

825 want_unicode = True 

826 elif not isinstance(end, str): 

827 raise TypeError("end must be None or a string") 

828 if kwargs: 

829 raise TypeError("invalid keyword arguments to print()") 

830 if not want_unicode: 

831 for arg in args: 

832 if isinstance(arg, unicode): 

833 want_unicode = True 

834 break 

835 if want_unicode: 

836 newline = unicode("\n") 

837 space = unicode(" ") 

838 else: 

839 newline = "\n" 

840 space = " " 

841 if sep is None: 

842 sep = space 

843 if end is None: 

844 end = newline 

845 for i, arg in enumerate(args): 

846 if i: 

847 write(sep) 

848 write(arg) 

849 write(end) 

850 

851 

852if sys.version_info[:2] < (3, 3): 

853 _print = print_ 

854 

855 def print_(*args, **kwargs): 

856 fp = kwargs.get("file", sys.stdout) 

857 flush = kwargs.pop("flush", False) 

858 _print(*args, **kwargs) 

859 if flush and fp is not None: 

860 fp.flush() 

861 

862 

863_add_doc(reraise, """Reraise an exception.""") 

864 

865if sys.version_info[0:2] < (3, 4): 

866 

867 def wraps( 

868 wrapped, 

869 assigned=functools.WRAPPER_ASSIGNMENTS, 

870 updated=functools.WRAPPER_UPDATES, 

871 ): 

872 def wrapper(f): 

873 f = functools.wraps(wrapped, assigned, updated)(f) 

874 f.__wrapped__ = wrapped 

875 return f 

876 

877 return wrapper 

878 

879 

880else: 

881 wraps = functools.wraps 

882 

883 

884def with_metaclass(meta, *bases): 

885 """Create a base class with a metaclass.""" 

886 # This requires a bit of explanation: the basic idea is to make a dummy 

887 # metaclass for one level of class instantiation that replaces itself with 

888 # the actual metaclass. 

889 class metaclass(type): 

890 def __new__(cls, name, this_bases, d): 

891 return meta(name, bases, d) 

892 

893 @classmethod 

894 def __prepare__(cls, name, this_bases): 

895 return meta.__prepare__(name, bases) 

896 

897 return type.__new__(metaclass, "temporary_class", (), {}) 

898 

899 

900def add_metaclass(metaclass): 

901 """Class decorator for creating a class with a metaclass.""" 

902 

903 def wrapper(cls): 

904 orig_vars = cls.__dict__.copy() 

905 slots = orig_vars.get("__slots__") 

906 if slots is not None: 

907 if isinstance(slots, str): 

908 slots = [slots] 

909 for slots_var in slots: 

910 orig_vars.pop(slots_var) 

911 orig_vars.pop("__dict__", None) 

912 orig_vars.pop("__weakref__", None) 

913 if hasattr(cls, "__qualname__"): 

914 orig_vars["__qualname__"] = cls.__qualname__ 

915 return metaclass(cls.__name__, cls.__bases__, orig_vars) 

916 

917 return wrapper 

918 

919 

920def ensure_binary(s, encoding="utf-8", errors="strict"): 

921 """Coerce **s** to six.binary_type. 

922 

923 For Python 2: 

924 - `unicode` -> encoded to `str` 

925 - `str` -> `str` 

926 

927 For Python 3: 

928 - `str` -> encoded to `bytes` 

929 - `bytes` -> `bytes` 

930 """ 

931 if isinstance(s, text_type): 

932 return s.encode(encoding, errors) 

933 elif isinstance(s, binary_type): 

934 return s 

935 else: 

936 raise TypeError("not expecting type '%s'" % type(s)) 

937 

938 

939def ensure_str(s, encoding="utf-8", errors="strict"): 

940 """Coerce *s* to `str`. 

941 

942 For Python 2: 

943 - `unicode` -> encoded to `str` 

944 - `str` -> `str` 

945 

946 For Python 3: 

947 - `str` -> `str` 

948 - `bytes` -> decoded to `str` 

949 """ 

950 if not isinstance(s, (text_type, binary_type)): 

951 raise TypeError("not expecting type '%s'" % type(s)) 

952 if PY2 and isinstance(s, text_type): 

953 s = s.encode(encoding, errors) 

954 elif PY3 and isinstance(s, binary_type): 

955 s = s.decode(encoding, errors) 

956 return s 

957 

958 

959def ensure_text(s, encoding="utf-8", errors="strict"): 

960 """Coerce *s* to six.text_type. 

961 

962 For Python 2: 

963 - `unicode` -> `unicode` 

964 - `str` -> `unicode` 

965 

966 For Python 3: 

967 - `str` -> `str` 

968 - `bytes` -> decoded to `str` 

969 """ 

970 if isinstance(s, binary_type): 

971 return s.decode(encoding, errors) 

972 elif isinstance(s, text_type): 

973 return s 

974 else: 

975 raise TypeError("not expecting type '%s'" % type(s)) 

976 

977 

978def python_2_unicode_compatible(klass): 

979 """ 

980 A decorator that defines __unicode__ and __str__ methods under Python 2. 

981 Under Python 3 it does nothing. 

982 

983 To support Python 2 and 3 with a single code base, define a __str__ method 

984 returning text and apply this decorator to the class. 

985 """ 

986 if PY2: 

987 if "__str__" not in klass.__dict__: 

988 raise ValueError( 

989 "@python_2_unicode_compatible cannot be applied " 

990 "to %s because it doesn't define __str__()." % klass.__name__ 

991 ) 

992 klass.__unicode__ = klass.__str__ 

993 klass.__str__ = lambda self: self.__unicode__().encode("utf-8") 

994 return klass 

995 

996 

997# Complete the moves implementation. 

998# This code is at the end of this module to speed up module loading. 

999# Turn this module into a package. 

1000__path__ = [] # required for PEP 302 and PEP 451 

1001__package__ = __name__ # see PEP 366 @ReservedAssignment 

1002if globals().get("__spec__") is not None: 

1003 __spec__.submodule_search_locations = [] # PEP 451 @UndefinedVariable 

1004# Remove other six meta path importers, since they cause problems. This can 

1005# happen if six is removed from sys.modules and then reloaded. (Setuptools does 

1006# this for some reason.) 

1007if sys.meta_path: 

1008 for i, importer in enumerate(sys.meta_path): 

1009 # Here's some real nastiness: Another "instance" of the six module might 

1010 # be floating around. Therefore, we can't use isinstance() to check for 

1011 # the six meta path importer, since the other six instance will have 

1012 # inserted an importer with different class. 

1013 if ( 

1014 type(importer).__name__ == "_SixMetaPathImporter" 

1015 and importer.name == __name__ 

1016 ): 

1017 del sys.meta_path[i] 

1018 break 

1019 del i, importer 

1020# Finally, add the importer to the meta path import hook. 

1021sys.meta_path.append(_importer)