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)
1022