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