diff options
author | Shubham Saini <shubham6405@gmail.com> | 2019-08-05 08:32:33 +0000 |
---|---|---|
committer | Shubham Saini <shubham6405@gmail.com> | 2019-08-05 08:32:33 +0000 |
commit | 227b2d30a8675b44918f9d9ca89b24144a938215 (patch) | |
tree | 9f8e6a28724514b6fdf463a9ab2067a7ef309b72 /venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages | |
parent | 842a8cfbbbdb1f92889d892e4859dbd5d40c5be8 (diff) |
removing venv files
Diffstat (limited to 'venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages')
7 files changed, 0 insertions, 1361 deletions
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/__init__.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/__init__.py deleted file mode 100644 index 324c551..0000000 --- a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/__init__.py +++ /dev/null | |||
@@ -1,5 +0,0 @@ | |||
1 | from __future__ import absolute_import | ||
2 | |||
3 | from . import ssl_match_hostname | ||
4 | |||
5 | __all__ = ('ssl_match_hostname', ) | ||
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/backports/__init__.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/backports/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/backports/__init__.py +++ /dev/null | |||
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/backports/makefile.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/backports/makefile.py deleted file mode 100644 index 00dee0b..0000000 --- a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/backports/makefile.py +++ /dev/null | |||
@@ -1,53 +0,0 @@ | |||
1 | # -*- coding: utf-8 -*- | ||
2 | """ | ||
3 | backports.makefile | ||
4 | ~~~~~~~~~~~~~~~~~~ | ||
5 | |||
6 | Backports the Python 3 ``socket.makefile`` method for use with anything that | ||
7 | wants to create a "fake" socket object. | ||
8 | """ | ||
9 | import io | ||
10 | |||
11 | from socket import SocketIO | ||
12 | |||
13 | |||
14 | def backport_makefile(self, mode="r", buffering=None, encoding=None, | ||
15 | errors=None, newline=None): | ||
16 | """ | ||
17 | Backport of ``socket.makefile`` from Python 3.5. | ||
18 | """ | ||
19 | if not set(mode) <= set(["r", "w", "b"]): | ||
20 | raise ValueError( | ||
21 | "invalid mode %r (only r, w, b allowed)" % (mode,) | ||
22 | ) | ||
23 | writing = "w" in mode | ||
24 | reading = "r" in mode or not writing | ||
25 | assert reading or writing | ||
26 | binary = "b" in mode | ||
27 | rawmode = "" | ||
28 | if reading: | ||
29 | rawmode += "r" | ||
30 | if writing: | ||
31 | rawmode += "w" | ||
32 | raw = SocketIO(self, rawmode) | ||
33 | self._makefile_refs += 1 | ||
34 | if buffering is None: | ||
35 | buffering = -1 | ||
36 | if buffering < 0: | ||
37 | buffering = io.DEFAULT_BUFFER_SIZE | ||
38 | if buffering == 0: | ||
39 | if not binary: | ||
40 | raise ValueError("unbuffered streams must be binary") | ||
41 | return raw | ||
42 | if reading and writing: | ||
43 | buffer = io.BufferedRWPair(raw, raw, buffering) | ||
44 | elif reading: | ||
45 | buffer = io.BufferedReader(raw, buffering) | ||
46 | else: | ||
47 | assert writing | ||
48 | buffer = io.BufferedWriter(raw, buffering) | ||
49 | if binary: | ||
50 | return buffer | ||
51 | text = io.TextIOWrapper(buffer, encoding, errors, newline) | ||
52 | text.mode = mode | ||
53 | return text | ||
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/ordered_dict.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/ordered_dict.py deleted file mode 100644 index 62dcb42..0000000 --- a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/ordered_dict.py +++ /dev/null | |||
@@ -1,259 +0,0 @@ | |||
1 | # Backport of OrderedDict() class that runs on Python 2.4, 2.5, 2.6, 2.7 and pypy. | ||
2 | # Passes Python2.7's test suite and incorporates all the latest updates. | ||
3 | # Copyright 2009 Raymond Hettinger, released under the MIT License. | ||
4 | # http://code.activestate.com/recipes/576693/ | ||
5 | try: | ||
6 | from thread import get_ident as _get_ident | ||
7 | except ImportError: | ||
8 | from dummy_thread import get_ident as _get_ident | ||
9 | |||
10 | try: | ||
11 | from _abcoll import KeysView, ValuesView, ItemsView | ||
12 | except ImportError: | ||
13 | pass | ||
14 | |||
15 | |||
16 | class OrderedDict(dict): | ||
17 | 'Dictionary that remembers insertion order' | ||
18 | # An inherited dict maps keys to values. | ||
19 | # The inherited dict provides __getitem__, __len__, __contains__, and get. | ||
20 | # The remaining methods are order-aware. | ||
21 | # Big-O running times for all methods are the same as for regular dictionaries. | ||
22 | |||
23 | # The internal self.__map dictionary maps keys to links in a doubly linked list. | ||
24 | # The circular doubly linked list starts and ends with a sentinel element. | ||
25 | # The sentinel element never gets deleted (this simplifies the algorithm). | ||
26 | # Each link is stored as a list of length three: [PREV, NEXT, KEY]. | ||
27 | |||
28 | def __init__(self, *args, **kwds): | ||
29 | '''Initialize an ordered dictionary. Signature is the same as for | ||
30 | regular dictionaries, but keyword arguments are not recommended | ||
31 | because their insertion order is arbitrary. | ||
32 | |||
33 | ''' | ||
34 | if len(args) > 1: | ||
35 | raise TypeError('expected at most 1 arguments, got %d' % len(args)) | ||
36 | try: | ||
37 | self.__root | ||
38 | except AttributeError: | ||
39 | self.__root = root = [] # sentinel node | ||
40 | root[:] = [root, root, None] | ||
41 | self.__map = {} | ||
42 | self.__update(*args, **kwds) | ||
43 | |||
44 | def __setitem__(self, key, value, dict_setitem=dict.__setitem__): | ||
45 | 'od.__setitem__(i, y) <==> od[i]=y' | ||
46 | # Setting a new item creates a new link which goes at the end of the linked | ||
47 | # list, and the inherited dictionary is updated with the new key/value pair. | ||
48 | if key not in self: | ||
49 | root = self.__root | ||
50 | last = root[0] | ||
51 | last[1] = root[0] = self.__map[key] = [last, root, key] | ||
52 | dict_setitem(self, key, value) | ||
53 | |||
54 | def __delitem__(self, key, dict_delitem=dict.__delitem__): | ||
55 | 'od.__delitem__(y) <==> del od[y]' | ||
56 | # Deleting an existing item uses self.__map to find the link which is | ||
57 | # then removed by updating the links in the predecessor and successor nodes. | ||
58 | dict_delitem(self, key) | ||
59 | link_prev, link_next, key = self.__map.pop(key) | ||
60 | link_prev[1] = link_next | ||
61 | link_next[0] = link_prev | ||
62 | |||
63 | def __iter__(self): | ||
64 | 'od.__iter__() <==> iter(od)' | ||
65 | root = self.__root | ||
66 | curr = root[1] | ||
67 | while curr is not root: | ||
68 | yield curr[2] | ||
69 | curr = curr[1] | ||
70 | |||
71 | def __reversed__(self): | ||
72 | 'od.__reversed__() <==> reversed(od)' | ||
73 | root = self.__root | ||
74 | curr = root[0] | ||
75 | while curr is not root: | ||
76 | yield curr[2] | ||
77 | curr = curr[0] | ||
78 | |||
79 | def clear(self): | ||
80 | 'od.clear() -> None. Remove all items from od.' | ||
81 | try: | ||
82 | for node in self.__map.itervalues(): | ||
83 | del node[:] | ||
84 | root = self.__root | ||
85 | root[:] = [root, root, None] | ||
86 | self.__map.clear() | ||
87 | except AttributeError: | ||
88 | pass | ||
89 | dict.clear(self) | ||
90 | |||
91 | def popitem(self, last=True): | ||
92 | '''od.popitem() -> (k, v), return and remove a (key, value) pair. | ||
93 | Pairs are returned in LIFO order if last is true or FIFO order if false. | ||
94 | |||
95 | ''' | ||
96 | if not self: | ||
97 | raise KeyError('dictionary is empty') | ||
98 | root = self.__root | ||
99 | if last: | ||
100 | link = root[0] | ||
101 | link_prev = link[0] | ||
102 | link_prev[1] = root | ||
103 | root[0] = link_prev | ||
104 | else: | ||
105 | link = root[1] | ||
106 | link_next = link[1] | ||
107 | root[1] = link_next | ||
108 | link_next[0] = root | ||
109 | key = link[2] | ||
110 | del self.__map[key] | ||
111 | value = dict.pop(self, key) | ||
112 | return key, value | ||
113 | |||
114 | # -- the following methods do not depend on the internal structure -- | ||
115 | |||
116 | def keys(self): | ||
117 | 'od.keys() -> list of keys in od' | ||
118 | return list(self) | ||
119 | |||
120 | def values(self): | ||
121 | 'od.values() -> list of values in od' | ||
122 | return [self[key] for key in self] | ||
123 | |||
124 | def items(self): | ||
125 | 'od.items() -> list of (key, value) pairs in od' | ||
126 | return [(key, self[key]) for key in self] | ||
127 | |||
128 | def iterkeys(self): | ||
129 | 'od.iterkeys() -> an iterator over the keys in od' | ||
130 | return iter(self) | ||
131 | |||
132 | def itervalues(self): | ||
133 | 'od.itervalues -> an iterator over the values in od' | ||
134 | for k in self: | ||
135 | yield self[k] | ||
136 | |||
137 | def iteritems(self): | ||
138 | 'od.iteritems -> an iterator over the (key, value) items in od' | ||
139 | for k in self: | ||
140 | yield (k, self[k]) | ||
141 | |||
142 | def update(*args, **kwds): | ||
143 | '''od.update(E, **F) -> None. Update od from dict/iterable E and F. | ||
144 | |||
145 | If E is a dict instance, does: for k in E: od[k] = E[k] | ||
146 | If E has a .keys() method, does: for k in E.keys(): od[k] = E[k] | ||
147 | Or if E is an iterable of items, does: for k, v in E: od[k] = v | ||
148 | In either case, this is followed by: for k, v in F.items(): od[k] = v | ||
149 | |||
150 | ''' | ||
151 | if len(args) > 2: | ||
152 | raise TypeError('update() takes at most 2 positional ' | ||
153 | 'arguments (%d given)' % (len(args),)) | ||
154 | elif not args: | ||
155 | raise TypeError('update() takes at least 1 argument (0 given)') | ||
156 | self = args[0] | ||
157 | # Make progressively weaker assumptions about "other" | ||
158 | other = () | ||
159 | if len(args) == 2: | ||
160 | other = args[1] | ||
161 | if isinstance(other, dict): | ||
162 | for key in other: | ||
163 | self[key] = other[key] | ||
164 | elif hasattr(other, 'keys'): | ||
165 | for key in other.keys(): | ||
166 | self[key] = other[key] | ||
167 | else: | ||
168 | for key, value in other: | ||
169 | self[key] = value | ||
170 | for key, value in kwds.items(): | ||
171 | self[key] = value | ||
172 | |||
173 | __update = update # let subclasses override update without breaking __init__ | ||
174 | |||
175 | __marker = object() | ||
176 | |||
177 | def pop(self, key, default=__marker): | ||
178 | '''od.pop(k[,d]) -> v, remove specified key and return the corresponding value. | ||
179 | If key is not found, d is returned if given, otherwise KeyError is raised. | ||
180 | |||
181 | ''' | ||
182 | if key in self: | ||
183 | result = self[key] | ||
184 | del self[key] | ||
185 | return result | ||
186 | if default is self.__marker: | ||
187 | raise KeyError(key) | ||
188 | return default | ||
189 | |||
190 | def setdefault(self, key, default=None): | ||
191 | 'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od' | ||
192 | if key in self: | ||
193 | return self[key] | ||
194 | self[key] = default | ||
195 | return default | ||
196 | |||
197 | def __repr__(self, _repr_running={}): | ||
198 | 'od.__repr__() <==> repr(od)' | ||
199 | call_key = id(self), _get_ident() | ||
200 | if call_key in _repr_running: | ||
201 | return '...' | ||
202 | _repr_running[call_key] = 1 | ||
203 | try: | ||
204 | if not self: | ||
205 | return '%s()' % (self.__class__.__name__,) | ||
206 | return '%s(%r)' % (self.__class__.__name__, self.items()) | ||
207 | finally: | ||
208 | del _repr_running[call_key] | ||
209 | |||
210 | def __reduce__(self): | ||
211 | 'Return state information for pickling' | ||
212 | items = [[k, self[k]] for k in self] | ||
213 | inst_dict = vars(self).copy() | ||
214 | for k in vars(OrderedDict()): | ||
215 | inst_dict.pop(k, None) | ||
216 | if inst_dict: | ||
217 | return (self.__class__, (items,), inst_dict) | ||
218 | return self.__class__, (items,) | ||
219 | |||
220 | def copy(self): | ||
221 | 'od.copy() -> a shallow copy of od' | ||
222 | return self.__class__(self) | ||
223 | |||
224 | @classmethod | ||
225 | def fromkeys(cls, iterable, value=None): | ||
226 | '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S | ||
227 | and values equal to v (which defaults to None). | ||
228 | |||
229 | ''' | ||
230 | d = cls() | ||
231 | for key in iterable: | ||
232 | d[key] = value | ||
233 | return d | ||
234 | |||
235 | def __eq__(self, other): | ||
236 | '''od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive | ||
237 | while comparison to a regular mapping is order-insensitive. | ||
238 | |||
239 | ''' | ||
240 | if isinstance(other, OrderedDict): | ||
241 | return len(self)==len(other) and self.items() == other.items() | ||
242 | return dict.__eq__(self, other) | ||
243 | |||
244 | def __ne__(self, other): | ||
245 | return not self == other | ||
246 | |||
247 | # -- the following methods are only used in Python 2.7 -- | ||
248 | |||
249 | def viewkeys(self): | ||
250 | "od.viewkeys() -> a set-like object providing a view on od's keys" | ||
251 | return KeysView(self) | ||
252 | |||
253 | def viewvalues(self): | ||
254 | "od.viewvalues() -> an object providing a view on od's values" | ||
255 | return ValuesView(self) | ||
256 | |||
257 | def viewitems(self): | ||
258 | "od.viewitems() -> a set-like object providing a view on od's items" | ||
259 | return ItemsView(self) | ||
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/six.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/six.py deleted file mode 100644 index 7bd9225..0000000 --- a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/six.py +++ /dev/null | |||
@@ -1,868 +0,0 @@ | |||
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) | ||
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/ssl_match_hostname/__init__.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/ssl_match_hostname/__init__.py deleted file mode 100644 index accb927..0000000 --- a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/ssl_match_hostname/__init__.py +++ /dev/null | |||
@@ -1,19 +0,0 @@ | |||
1 | import sys | ||
2 | |||
3 | try: | ||
4 | # Our match_hostname function is the same as 3.5's, so we only want to | ||
5 | # import the match_hostname function if it's at least that good. | ||
6 | if sys.version_info < (3, 5): | ||
7 | raise ImportError("Fallback to vendored code") | ||
8 | |||
9 | from ssl import CertificateError, match_hostname | ||
10 | except ImportError: | ||
11 | try: | ||
12 | # Backport of the function from a pypi module | ||
13 | from backports.ssl_match_hostname import CertificateError, match_hostname | ||
14 | except ImportError: | ||
15 | # Our vendored copy | ||
16 | from ._implementation import CertificateError, match_hostname | ||
17 | |||
18 | # Not needed, but documenting what we provide. | ||
19 | __all__ = ('CertificateError', 'match_hostname') | ||
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/ssl_match_hostname/_implementation.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/ssl_match_hostname/_implementation.py deleted file mode 100644 index 7272d86..0000000 --- a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/packages/ssl_match_hostname/_implementation.py +++ /dev/null | |||
@@ -1,157 +0,0 @@ | |||
1 | """The match_hostname() function from Python 3.3.3, essential when using SSL.""" | ||
2 | |||
3 | # Note: This file is under the PSF license as the code comes from the python | ||
4 | # stdlib. http://docs.python.org/3/license.html | ||
5 | |||
6 | import re | ||
7 | import sys | ||
8 | |||
9 | # ipaddress has been backported to 2.6+ in pypi. If it is installed on the | ||
10 | # system, use it to handle IPAddress ServerAltnames (this was added in | ||
11 | # python-3.5) otherwise only do DNS matching. This allows | ||
12 | # backports.ssl_match_hostname to continue to be used all the way back to | ||
13 | # python-2.4. | ||
14 | try: | ||
15 | from pip._vendor import ipaddress | ||
16 | except ImportError: | ||
17 | ipaddress = None | ||
18 | |||
19 | __version__ = '3.5.0.1' | ||
20 | |||
21 | |||
22 | class CertificateError(ValueError): | ||
23 | pass | ||
24 | |||
25 | |||
26 | def _dnsname_match(dn, hostname, max_wildcards=1): | ||
27 | """Matching according to RFC 6125, section 6.4.3 | ||
28 | |||
29 | http://tools.ietf.org/html/rfc6125#section-6.4.3 | ||
30 | """ | ||
31 | pats = [] | ||
32 | if not dn: | ||
33 | return False | ||
34 | |||
35 | # Ported from python3-syntax: | ||
36 | # leftmost, *remainder = dn.split(r'.') | ||
37 | parts = dn.split(r'.') | ||
38 | leftmost = parts[0] | ||
39 | remainder = parts[1:] | ||
40 | |||
41 | wildcards = leftmost.count('*') | ||
42 | if wildcards > max_wildcards: | ||
43 | # Issue #17980: avoid denials of service by refusing more | ||
44 | # than one wildcard per fragment. A survey of established | ||
45 | # policy among SSL implementations showed it to be a | ||
46 | # reasonable choice. | ||
47 | raise CertificateError( | ||
48 | "too many wildcards in certificate DNS name: " + repr(dn)) | ||
49 | |||
50 | # speed up common case w/o wildcards | ||
51 | if not wildcards: | ||
52 | return dn.lower() == hostname.lower() | ||
53 | |||
54 | # RFC 6125, section 6.4.3, subitem 1. | ||
55 | # The client SHOULD NOT attempt to match a presented identifier in which | ||
56 | # the wildcard character comprises a label other than the left-most label. | ||
57 | if leftmost == '*': | ||
58 | # When '*' is a fragment by itself, it matches a non-empty dotless | ||
59 | # fragment. | ||
60 | pats.append('[^.]+') | ||
61 | elif leftmost.startswith('xn--') or hostname.startswith('xn--'): | ||
62 | # RFC 6125, section 6.4.3, subitem 3. | ||
63 | # The client SHOULD NOT attempt to match a presented identifier | ||
64 | # where the wildcard character is embedded within an A-label or | ||
65 | # U-label of an internationalized domain name. | ||
66 | pats.append(re.escape(leftmost)) | ||
67 | else: | ||
68 | # Otherwise, '*' matches any dotless string, e.g. www* | ||
69 | pats.append(re.escape(leftmost).replace(r'\*', '[^.]*')) | ||
70 | |||
71 | # add the remaining fragments, ignore any wildcards | ||
72 | for frag in remainder: | ||
73 | pats.append(re.escape(frag)) | ||
74 | |||
75 | pat = re.compile(r'\A' + r'\.'.join(pats) + r'\Z', re.IGNORECASE) | ||
76 | return pat.match(hostname) | ||
77 | |||
78 | |||
79 | def _to_unicode(obj): | ||
80 | if isinstance(obj, str) and sys.version_info < (3,): | ||
81 | obj = unicode(obj, encoding='ascii', errors='strict') | ||
82 | return obj | ||
83 | |||
84 | def _ipaddress_match(ipname, host_ip): | ||
85 | """Exact matching of IP addresses. | ||
86 | |||
87 | RFC 6125 explicitly doesn't define an algorithm for this | ||
88 | (section 1.7.2 - "Out of Scope"). | ||
89 | """ | ||
90 | # OpenSSL may add a trailing newline to a subjectAltName's IP address | ||
91 | # Divergence from upstream: ipaddress can't handle byte str | ||
92 | ip = ipaddress.ip_address(_to_unicode(ipname).rstrip()) | ||
93 | return ip == host_ip | ||
94 | |||
95 | |||
96 | def match_hostname(cert, hostname): | ||
97 | """Verify that *cert* (in decoded format as returned by | ||
98 | SSLSocket.getpeercert()) matches the *hostname*. RFC 2818 and RFC 6125 | ||
99 | rules are followed, but IP addresses are not accepted for *hostname*. | ||
100 | |||
101 | CertificateError is raised on failure. On success, the function | ||
102 | returns nothing. | ||
103 | """ | ||
104 | if not cert: | ||
105 | raise ValueError("empty or no certificate, match_hostname needs a " | ||
106 | "SSL socket or SSL context with either " | ||
107 | "CERT_OPTIONAL or CERT_REQUIRED") | ||
108 | try: | ||
109 | # Divergence from upstream: ipaddress can't handle byte str | ||
110 | host_ip = ipaddress.ip_address(_to_unicode(hostname)) | ||
111 | except ValueError: | ||
112 | # Not an IP address (common case) | ||
113 | host_ip = None | ||
114 | except UnicodeError: | ||
115 | # Divergence from upstream: Have to deal with ipaddress not taking | ||
116 | # byte strings. addresses should be all ascii, so we consider it not | ||
117 | # an ipaddress in this case | ||
118 | host_ip = None | ||
119 | except AttributeError: | ||
120 | # Divergence from upstream: Make ipaddress library optional | ||
121 | if ipaddress is None: | ||
122 | host_ip = None | ||
123 | else: | ||
124 | raise | ||
125 | dnsnames = [] | ||
126 | san = cert.get('subjectAltName', ()) | ||
127 | for key, value in san: | ||
128 | if key == 'DNS': | ||
129 | if host_ip is None and _dnsname_match(value, hostname): | ||
130 | return | ||
131 | dnsnames.append(value) | ||
132 | elif key == 'IP Address': | ||
133 | if host_ip is not None and _ipaddress_match(value, host_ip): | ||
134 | return | ||
135 | dnsnames.append(value) | ||
136 | if not dnsnames: | ||
137 | # The subject is only checked when there is no dNSName entry | ||
138 | # in subjectAltName | ||
139 | for sub in cert.get('subject', ()): | ||
140 | for key, value in sub: | ||
141 | # XXX according to RFC 2818, the most specific Common Name | ||
142 | # must be used. | ||
143 | if key == 'commonName': | ||
144 | if _dnsname_match(value, hostname): | ||
145 | return | ||
146 | dnsnames.append(value) | ||
147 | if len(dnsnames) > 1: | ||
148 | raise CertificateError("hostname %r " | ||
149 | "doesn't match either of %s" | ||
150 | % (hostname, ', '.join(map(repr, dnsnames)))) | ||
151 | elif len(dnsnames) == 1: | ||
152 | raise CertificateError("hostname %r " | ||
153 | "doesn't match %r" | ||
154 | % (hostname, dnsnames[0])) | ||
155 | else: | ||
156 | raise CertificateError("no appropriate commonName or " | ||
157 | "subjectAltName fields were found") | ||