← Back to branch summary

~ibmcharmers/charms/xenial/ibm-cinder-storwize-svc/trunk

« back to all changes in this revision

Viewing changes to .tox/py35/lib/python3.5/site-packages/pip/_vendor/requests/packages/urllib3/packages/six.py

  • Committer: Ankammarao
  • Date: 2017-03-06 05:11:42 UTC
  • Revision ID: achittet@in.ibm.com-20170306051142-dpg27z4es1k56hfn
Marked tests folder executable

Show diffs side-by-side

added added

removed removed

Lines of Context:
.tox/py35/lib/python3.5/site-packages/pip/_vendor/requests/packages/urllib3/packages/six.py
 
1
"""Utilities for writing code that runs on Python 2 and 3"""
 
2
 
 
3
# Copyright (c) 2010-2015 Benjamin Peterson
 
4
#
 
5
# Permission is hereby granted, free of charge, to any person obtaining a copy
 
6
# of this software and associated documentation files (the "Software"), to deal
 
7
# in the Software without restriction, including without limitation the rights
 
8
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
9
# copies of the Software, and to permit persons to whom the Software is
 
10
# furnished to do so, subject to the following conditions:
 
11
#
 
12
# The above copyright notice and this permission notice shall be included in all
 
13
# copies or substantial portions of the Software.
 
14
#
 
15
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
16
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
17
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 
18
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
19
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
20
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 
21
# SOFTWARE.
 
22
 
 
23
from __future__ import absolute_import
 
24
 
 
25
import functools
 
26
import itertools
 
27
import operator
 
28
import sys
 
29
import types
 
30
 
 
31
__author__ = "Benjamin Peterson <benjamin@python.org>"
 
32
__version__ = "1.10.0"
 
33
 
 
34
 
 
35
# Useful for very coarse version differentiation.
 
36
PY2 = sys.version_info[0] == 2
 
37
PY3 = sys.version_info[0] == 3
 
38
PY34 = sys.version_info[0:2] >= (3, 4)
 
39
 
 
40
if 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
 
48
else:
 
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
 
 
75
def _add_doc(func, doc):
 
76
    """Add documentation to a function."""
 
77
    func.__doc__ = doc
 
78
 
 
79
 
 
80
def _import_module(name):
 
81
    """Import module, returning the module after the last dot."""
 
82
    __import__(name)
 
83
    return sys.modules[name]
 
84
 
 
85
 
 
86
class _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
 
 
103
class 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
 
 
124
class _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
 
 
139
class 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
 
 
164
class _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
 
 
229
class _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("range", "__builtin__", "builtins", "xrange", "range"),
 
245
    MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
 
246
    MovedAttribute("reduce", "__builtin__", "functools"),
 
247
    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
 
248
    MovedAttribute("StringIO", "StringIO", "io"),
 
249
    MovedAttribute("UserDict", "UserDict", "collections"),
 
250
    MovedAttribute("UserList", "UserList", "collections"),
 
251
    MovedAttribute("UserString", "UserString", "collections"),
 
252
    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
 
253
    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
 
254
    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
 
255
    MovedModule("builtins", "__builtin__"),
 
256
    MovedModule("configparser", "ConfigParser"),
 
257
    MovedModule("copyreg", "copy_reg"),
 
258
    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
 
259
    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"),
 
260
    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
 
261
    MovedModule("http_cookies", "Cookie", "http.cookies"),
 
262
    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
 
263
    MovedModule("html_parser", "HTMLParser", "html.parser"),
 
264
    MovedModule("http_client", "httplib", "http.client"),
 
265
    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
 
266
    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
 
267
    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
 
268
    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
 
269
    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
 
270
    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
 
271
    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
 
272
    MovedModule("cPickle", "cPickle", "pickle"),
 
273
    MovedModule("queue", "Queue"),
 
274
    MovedModule("reprlib", "repr"),
 
275
    MovedModule("socketserver", "SocketServer"),
 
276
    MovedModule("_thread", "thread", "_thread"),
 
277
    MovedModule("tkinter", "Tkinter"),
 
278
    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
 
279
    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
 
280
    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
 
281
    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
 
282
    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
 
283
    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
 
284
    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
 
285
    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
 
286
    MovedModule("tkinter_colorchooser", "tkColorChooser",
 
287
                "tkinter.colorchooser"),
 
288
    MovedModule("tkinter_commondialog", "tkCommonDialog",
 
289
                "tkinter.commondialog"),
 
290
    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
 
291
    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
 
292
    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
 
293
    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
 
294
                "tkinter.simpledialog"),
 
295
    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
 
296
    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
 
297
    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
 
298
    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
 
299
    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
 
300
    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
 
301
]
 
302
# Add windows specific modules.
 
303
if sys.platform == "win32":
 
304
    _moved_attributes += [
 
305
        MovedModule("winreg", "_winreg"),
 
306
    ]
 
307
 
 
308
for attr in _moved_attributes:
 
309
    setattr(_MovedItems, attr.name, attr)
 
310
    if isinstance(attr, MovedModule):
 
311
        _importer._add_module(attr, "moves." + attr.name)
 
312
del attr
 
313
 
 
314
_MovedItems._moved_attributes = _moved_attributes
 
315
 
 
316
moves = _MovedItems(__name__ + ".moves")
 
317
_importer._add_module(moves, "moves")
 
318
 
 
319
 
 
320
class Module_six_moves_urllib_parse(_LazyModule):
 
321
 
 
322
    """Lazy loading of moved objects in six.moves.urllib_parse"""
 
323
 
 
324
 
 
325
_urllib_parse_moved_attributes = [
 
326
    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
 
327
    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
 
328
    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
 
329
    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
 
330
    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
 
331
    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
 
332
    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
 
333
    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
 
334
    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
 
335
    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
 
336
    MovedAttribute("quote", "urllib", "urllib.parse"),
 
337
    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
 
338
    MovedAttribute("unquote", "urllib", "urllib.parse"),
 
339
    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
 
340
    MovedAttribute("urlencode", "urllib", "urllib.parse"),
 
341
    MovedAttribute("splitquery", "urllib", "urllib.parse"),
 
342
    MovedAttribute("splittag", "urllib", "urllib.parse"),
 
343
    MovedAttribute("splituser", "urllib", "urllib.parse"),
 
344
    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
 
345
    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
 
346
    MovedAttribute("uses_params", "urlparse", "urllib.parse"),
 
347
    MovedAttribute("uses_query", "urlparse", "urllib.parse"),
 
348
    MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
 
349
]
 
350
for attr in _urllib_parse_moved_attributes:
 
351
    setattr(Module_six_moves_urllib_parse, attr.name, attr)
 
352
del attr
 
353
 
 
354
Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
 
355
 
 
356
_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
 
357
                      "moves.urllib_parse", "moves.urllib.parse")
 
358
 
 
359
 
 
360
class Module_six_moves_urllib_error(_LazyModule):
 
361
 
 
362
    """Lazy loading of moved objects in six.moves.urllib_error"""
 
363
 
 
364
 
 
365
_urllib_error_moved_attributes = [
 
366
    MovedAttribute("URLError", "urllib2", "urllib.error"),
 
367
    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
 
368
    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
 
369
]
 
370
for attr in _urllib_error_moved_attributes:
 
371
    setattr(Module_six_moves_urllib_error, attr.name, attr)
 
372
del attr
 
373
 
 
374
Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
 
375
 
 
376
_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
 
377
                      "moves.urllib_error", "moves.urllib.error")
 
378
 
 
379
 
 
380
class Module_six_moves_urllib_request(_LazyModule):
 
381
 
 
382
    """Lazy loading of moved objects in six.moves.urllib_request"""
 
383
 
 
384
 
 
385
_urllib_request_moved_attributes = [
 
386
    MovedAttribute("urlopen", "urllib2", "urllib.request"),
 
387
    MovedAttribute("install_opener", "urllib2", "urllib.request"),
 
388
    MovedAttribute("build_opener", "urllib2", "urllib.request"),
 
389
    MovedAttribute("pathname2url", "urllib", "urllib.request"),
 
390
    MovedAttribute("url2pathname", "urllib", "urllib.request"),
 
391
    MovedAttribute("getproxies", "urllib", "urllib.request"),
 
392
    MovedAttribute("Request", "urllib2", "urllib.request"),
 
393
    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
 
394
    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
 
395
    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
 
396
    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
 
397
    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
 
398
    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
 
399
    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
 
400
    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
 
401
    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
 
402
    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
 
403
    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
 
404
    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
 
405
    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
 
406
    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
 
407
    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
 
408
    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
 
409
    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
 
410
    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
 
411
    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
 
412
    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
 
413
    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
 
414
    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
 
415
    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
 
416
    MovedAttribute("URLopener", "urllib", "urllib.request"),
 
417
    MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
 
418
    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
 
419
]
 
420
for attr in _urllib_request_moved_attributes:
 
421
    setattr(Module_six_moves_urllib_request, attr.name, attr)
 
422
del attr
 
423
 
 
424
Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
 
425
 
 
426
_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
 
427
                      "moves.urllib_request", "moves.urllib.request")
 
428
 
 
429
 
 
430
class Module_six_moves_urllib_response(_LazyModule):
 
431
 
 
432
    """Lazy loading of moved objects in six.moves.urllib_response"""
 
433
 
 
434
 
 
435
_urllib_response_moved_attributes = [
 
436
    MovedAttribute("addbase", "urllib", "urllib.response"),
 
437
    MovedAttribute("addclosehook", "urllib", "urllib.response"),
 
438
    MovedAttribute("addinfo", "urllib", "urllib.response"),
 
439
    MovedAttribute("addinfourl", "urllib", "urllib.response"),
 
440
]
 
441
for attr in _urllib_response_moved_attributes:
 
442
    setattr(Module_six_moves_urllib_response, attr.name, attr)
 
443
del attr
 
444
 
 
445
Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
 
446
 
 
447
_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
 
448
                      "moves.urllib_response", "moves.urllib.response")
 
449
 
 
450
 
 
451
class Module_six_moves_urllib_robotparser(_LazyModule):
 
452
 
 
453
    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
 
454
 
 
455
 
 
456
_urllib_robotparser_moved_attributes = [
 
457
    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
 
458
]
 
459
for attr in _urllib_robotparser_moved_attributes:
 
460
    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
 
461
del attr
 
462
 
 
463
Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
 
464
 
 
465
_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
 
466
                      "moves.urllib_robotparser", "moves.urllib.robotparser")
 
467
 
 
468
 
 
469
class Module_six_moves_urllib(types.ModuleType):
 
470
 
 
471
    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
 
472
    __path__ = []  # mark as package
 
473
    parse = _importer._get_module("moves.urllib_parse")
 
474
    error = _importer._get_module("moves.urllib_error")
 
475
    request = _importer._get_module("moves.urllib_request")
 
476
    response = _importer._get_module("moves.urllib_response")
 
477
    robotparser = _importer._get_module("moves.urllib_robotparser")
 
478
 
 
479
    def __dir__(self):
 
480
        return ['parse', 'error', 'request', 'response', 'robotparser']
 
481
 
 
482
_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
 
483
                      "moves.urllib")
 
484
 
 
485
 
 
486
def add_move(move):
 
487
    """Add an item to six.moves."""
 
488
    setattr(_MovedItems, move.name, move)
 
489
 
 
490
 
 
491
def remove_move(name):
 
492
    """Remove item from six.moves."""
 
493
    try:
 
494
        delattr(_MovedItems, name)
 
495
    except AttributeError:
 
496
        try:
 
497
            del moves.__dict__[name]
 
498
        except KeyError:
 
499
            raise AttributeError("no such move, %r" % (name,))
 
500
 
 
501
 
 
502
if PY3:
 
503
    _meth_func = "__func__"
 
504
    _meth_self = "__self__"
 
505
 
 
506
    _func_closure = "__closure__"
 
507
    _func_code = "__code__"
 
508
    _func_defaults = "__defaults__"
 
509
    _func_globals = "__globals__"
 
510
else:
 
511
    _meth_func = "im_func"
 
512
    _meth_self = "im_self"
 
513
 
 
514
    _func_closure = "func_closure"
 
515
    _func_code = "func_code"
 
516
    _func_defaults = "func_defaults"
 
517
    _func_globals = "func_globals"
 
518
 
 
519
 
 
520
try:
 
521
    advance_iterator = next
 
522
except NameError:
 
523
    def advance_iterator(it):
 
524
        return it.next()
 
525
next = advance_iterator
 
526
 
 
527
 
 
528
try:
 
529
    callable = callable
 
530
except NameError:
 
531
    def callable(obj):
 
532
        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
 
533
 
 
534
 
 
535
if PY3:
 
536
    def get_unbound_function(unbound):
 
537
        return unbound
 
538
 
 
539
    create_bound_method = types.MethodType
 
540
 
 
541
    def create_unbound_method(func, cls):
 
542
        return func
 
543
 
 
544
    Iterator = object
 
545
else:
 
546
    def get_unbound_function(unbound):
 
547
        return unbound.im_func
 
548
 
 
549
    def create_bound_method(func, obj):
 
550
        return types.MethodType(func, obj, obj.__class__)
 
551
 
 
552
    def create_unbound_method(func, cls):
 
553
        return types.MethodType(func, None, cls)
 
554
 
 
555
    class Iterator(object):
 
556
 
 
557
        def next(self):
 
558
            return type(self).__next__(self)
 
559
 
 
560
    callable = callable
 
561
_add_doc(get_unbound_function,
 
562
         """Get the function out of a possibly unbound function""")
 
563
 
 
564
 
 
565
get_method_function = operator.attrgetter(_meth_func)
 
566
get_method_self = operator.attrgetter(_meth_self)
 
567
get_function_closure = operator.attrgetter(_func_closure)
 
568
get_function_code = operator.attrgetter(_func_code)
 
569
get_function_defaults = operator.attrgetter(_func_defaults)
 
570
get_function_globals = operator.attrgetter(_func_globals)
 
571
 
 
572
 
 
573
if PY3:
 
574
    def iterkeys(d, **kw):
 
575
        return iter(d.keys(**kw))
 
576
 
 
577
    def itervalues(d, **kw):
 
578
        return iter(d.values(**kw))
 
579
 
 
580
    def iteritems(d, **kw):
 
581
        return iter(d.items(**kw))
 
582
 
 
583
    def iterlists(d, **kw):
 
584
        return iter(d.lists(**kw))
 
585
 
 
586
    viewkeys = operator.methodcaller("keys")
 
587
 
 
588
    viewvalues = operator.methodcaller("values")
 
589
 
 
590
    viewitems = operator.methodcaller("items")
 
591
else:
 
592
    def iterkeys(d, **kw):
 
593
        return d.iterkeys(**kw)
 
594
 
 
595
    def itervalues(d, **kw):
 
596
        return d.itervalues(**kw)
 
597
 
 
598
    def iteritems(d, **kw):
 
599
        return d.iteritems(**kw)
 
600
 
 
601
    def iterlists(d, **kw):
 
602
        return d.iterlists(**kw)
 
603
 
 
604
    viewkeys = operator.methodcaller("viewkeys")
 
605
 
 
606
    viewvalues = operator.methodcaller("viewvalues")
 
607
 
 
608
    viewitems = operator.methodcaller("viewitems")
 
609
 
 
610
_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
 
611
_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
 
612
_add_doc(iteritems,
 
613
         "Return an iterator over the (key, value) pairs of a dictionary.")
 
614
_add_doc(iterlists,
 
615
         "Return an iterator over the (key, [values]) pairs of a dictionary.")
 
616
 
 
617
 
 
618
if PY3:
 
619
    def b(s):
 
620
        return s.encode("latin-1")
 
621
 
 
622
    def u(s):
 
623
        return s
 
624
    unichr = chr
 
625
    import struct
 
626
    int2byte = struct.Struct(">B").pack
 
627
    del struct
 
628
    byte2int = operator.itemgetter(0)
 
629
    indexbytes = operator.getitem
 
630
    iterbytes = iter
 
631
    import io
 
632
    StringIO = io.StringIO
 
633
    BytesIO = io.BytesIO
 
634
    _assertCountEqual = "assertCountEqual"
 
635
    if sys.version_info[1] <= 1:
 
636
        _assertRaisesRegex = "assertRaisesRegexp"
 
637
        _assertRegex = "assertRegexpMatches"
 
638
    else:
 
639
        _assertRaisesRegex = "assertRaisesRegex"
 
640
        _assertRegex = "assertRegex"
 
641
else:
 
642
    def b(s):
 
643
        return s
 
644
    # Workaround for standalone backslash
 
645
 
 
646
    def u(s):
 
647
        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
 
648
    unichr = unichr
 
649
    int2byte = chr
 
650
 
 
651
    def byte2int(bs):
 
652
        return ord(bs[0])
 
653
 
 
654
    def indexbytes(buf, i):
 
655
        return ord(buf[i])
 
656
    iterbytes = functools.partial(itertools.imap, ord)
 
657
    import StringIO
 
658
    StringIO = BytesIO = StringIO.StringIO
 
659
    _assertCountEqual = "assertItemsEqual"
 
660
    _assertRaisesRegex = "assertRaisesRegexp"
 
661
    _assertRegex = "assertRegexpMatches"
 
662
_add_doc(b, """Byte literal""")
 
663
_add_doc(u, """Text literal""")
 
664
 
 
665
 
 
666
def assertCountEqual(self, *args, **kwargs):
 
667
    return getattr(self, _assertCountEqual)(*args, **kwargs)
 
668
 
 
669
 
 
670
def assertRaisesRegex(self, *args, **kwargs):
 
671
    return getattr(self, _assertRaisesRegex)(*args, **kwargs)
 
672
 
 
673
 
 
674
def assertRegex(self, *args, **kwargs):
 
675
    return getattr(self, _assertRegex)(*args, **kwargs)
 
676
 
 
677
 
 
678
if PY3:
 
679
    exec_ = getattr(moves.builtins, "exec")
 
680
 
 
681
    def reraise(tp, value, tb=None):
 
682
        if value is None:
 
683
            value = tp()
 
684
        if value.__traceback__ is not tb:
 
685
            raise value.with_traceback(tb)
 
686
        raise value
 
687
 
 
688
else:
 
689
    def exec_(_code_, _globs_=None, _locs_=None):
 
690
        """Execute code in a namespace."""
 
691
        if _globs_ is None:
 
692
            frame = sys._getframe(1)
 
693
            _globs_ = frame.f_globals
 
694
            if _locs_ is None:
 
695
                _locs_ = frame.f_locals
 
696
            del frame
 
697
        elif _locs_ is None:
 
698
            _locs_ = _globs_
 
699
        exec("""exec _code_ in _globs_, _locs_""")
 
700
 
 
701
    exec_("""def reraise(tp, value, tb=None):
 
702
    raise tp, value, tb
 
703
""")
 
704
 
 
705
 
 
706
if sys.version_info[:2] == (3, 2):
 
707
    exec_("""def raise_from(value, from_value):
 
708
    if from_value is None:
 
709
        raise value
 
710
    raise value from from_value
 
711
""")
 
712
elif sys.version_info[:2] > (3, 2):
 
713
    exec_("""def raise_from(value, from_value):
 
714
    raise value from from_value
 
715
""")
 
716
else:
 
717
    def raise_from(value, from_value):
 
718
        raise value
 
719
 
 
720
 
 
721
print_ = getattr(moves.builtins, "print", None)
 
722
if print_ is None:
 
723
    def print_(*args, **kwargs):
 
724
        """The new-style print function for Python 2.4 and 2.5."""
 
725
        fp = kwargs.pop("file", sys.stdout)
 
726
        if fp is None:
 
727
            return
 
728
 
 
729
        def write(data):
 
730
            if not isinstance(data, basestring):
 
731
                data = str(data)
 
732
            # If the file has an encoding, encode unicode with it.
 
733
            if (isinstance(fp, file) and
 
734
                    isinstance(data, unicode) and
 
735
                    fp.encoding is not None):
 
736
                errors = getattr(fp, "errors", None)
 
737
                if errors is None:
 
738
                    errors = "strict"
 
739
                data = data.encode(fp.encoding, errors)
 
740
            fp.write(data)
 
741
        want_unicode = False
 
742
        sep = kwargs.pop("sep", None)
 
743
        if sep is not None:
 
744
            if isinstance(sep, unicode):
 
745
                want_unicode = True
 
746
            elif not isinstance(sep, str):
 
747
                raise TypeError("sep must be None or a string")
 
748
        end = kwargs.pop("end", None)
 
749
        if end is not None:
 
750
            if isinstance(end, unicode):
 
751
                want_unicode = True
 
752
            elif not isinstance(end, str):
 
753
                raise TypeError("end must be None or a string")
 
754
        if kwargs:
 
755
            raise TypeError("invalid keyword arguments to print()")
 
756
        if not want_unicode:
 
757
            for arg in args:
 
758
                if isinstance(arg, unicode):
 
759
                    want_unicode = True
 
760
                    break
 
761
        if want_unicode:
 
762
            newline = unicode("\n")
 
763
            space = unicode(" ")
 
764
        else:
 
765
            newline = "\n"
 
766
            space = " "
 
767
        if sep is None:
 
768
            sep = space
 
769
        if end is None:
 
770
            end = newline
 
771
        for i, arg in enumerate(args):
 
772
            if i:
 
773
                write(sep)
 
774
            write(arg)
 
775
        write(end)
 
776
if sys.version_info[:2] < (3, 3):
 
777
    _print = print_
 
778
 
 
779
    def print_(*args, **kwargs):
 
780
        fp = kwargs.get("file", sys.stdout)
 
781
        flush = kwargs.pop("flush", False)
 
782
        _print(*args, **kwargs)
 
783
        if flush and fp is not None:
 
784
            fp.flush()
 
785
 
 
786
_add_doc(reraise, """Reraise an exception.""")
 
787
 
 
788
if sys.version_info[0:2] < (3, 4):
 
789
    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
 
790
              updated=functools.WRAPPER_UPDATES):
 
791
        def wrapper(f):
 
792
            f = functools.wraps(wrapped, assigned, updated)(f)
 
793
            f.__wrapped__ = wrapped
 
794
            return f
 
795
        return wrapper
 
796
else:
 
797
    wraps = functools.wraps
 
798
 
 
799
 
 
800
def with_metaclass(meta, *bases):
 
801
    """Create a base class with a metaclass."""
 
802
    # This requires a bit of explanation: the basic idea is to make a dummy
 
803
    # metaclass for one level of class instantiation that replaces itself with
 
804
    # the actual metaclass.
 
805
    class metaclass(meta):
 
806
 
 
807
        def __new__(cls, name, this_bases, d):
 
808
            return meta(name, bases, d)
 
809
    return type.__new__(metaclass, 'temporary_class', (), {})
 
810
 
 
811
 
 
812
def add_metaclass(metaclass):
 
813
    """Class decorator for creating a class with a metaclass."""
 
814
    def wrapper(cls):
 
815
        orig_vars = cls.__dict__.copy()
 
816
        slots = orig_vars.get('__slots__')
 
817
        if slots is not None:
 
818
            if isinstance(slots, str):
 
819
                slots = [slots]
 
820
            for slots_var in slots:
 
821
                orig_vars.pop(slots_var)
 
822
        orig_vars.pop('__dict__', None)
 
823
        orig_vars.pop('__weakref__', None)
 
824
        return metaclass(cls.__name__, cls.__bases__, orig_vars)
 
825
    return wrapper
 
826
 
 
827
 
 
828
def python_2_unicode_compatible(klass):
 
829
    """
 
830
    A decorator that defines __unicode__ and __str__ methods under Python 2.
 
831
    Under Python 3 it does nothing.
 
832
 
 
833
    To support Python 2 and 3 with a single code base, define a __str__ method
 
834
    returning text and apply this decorator to the class.
 
835
    """
 
836
    if PY2:
 
837
        if '__str__' not in klass.__dict__:
 
838
            raise ValueError("@python_2_unicode_compatible cannot be applied "
 
839
                             "to %s because it doesn't define __str__()." %
 
840
                             klass.__name__)
 
841
        klass.__unicode__ = klass.__str__
 
842
        klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
 
843
    return klass
 
844
 
 
845
 
 
846
# Complete the moves implementation.
 
847
# This code is at the end of this module to speed up module loading.
 
848
# Turn this module into a package.
 
849
__path__ = []  # required for PEP 302 and PEP 451
 
850
__package__ = __name__  # see PEP 366 @ReservedAssignment
 
851
if globals().get("__spec__") is not None:
 
852
    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
 
853
# Remove other six meta path importers, since they cause problems. This can
 
854
# happen if six is removed from sys.modules and then reloaded. (Setuptools does
 
855
# this for some reason.)
 
856
if sys.meta_path:
 
857
    for i, importer in enumerate(sys.meta_path):
 
858
        # Here's some real nastiness: Another "instance" of the six module might
 
859
        # be floating around. Therefore, we can't use isinstance() to check for
 
860
        # the six meta path importer, since the other six instance will have
 
861
        # inserted an importer with different class.
 
862
        if (type(importer).__name__ == "_SixMetaPathImporter" and
 
863
                importer.name == __name__):
 
864
            del sys.meta_path[i]
 
865
            break
 
866
    del i, importer
 
867
# Finally, add the importer to the meta path import hook.
 
868
sys.meta_path.append(_importer)