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