summaryrefslogtreecommitdiff
path: root/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings
diff options
context:
space:
mode:
Diffstat (limited to 'venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings')
-rw-r--r--venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/__init__.py342
-rw-r--r--venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/labels.py231
-rw-r--r--venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/mklabels.py59
-rw-r--r--venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/tests.py153
-rw-r--r--venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/x_user_defined.py325
5 files changed, 1110 insertions, 0 deletions
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/__init__.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/__init__.py
new file mode 100644
index 0000000..16671ef
--- /dev/null
+++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/__init__.py
@@ -0,0 +1,342 @@
1# coding: utf-8
2"""
3
4 webencodings
5 ~~~~~~~~~~~~
6
7 This is a Python implementation of the `WHATWG Encoding standard
8 <http://encoding.spec.whatwg.org/>`. See README for details.
9
10 :copyright: Copyright 2012 by Simon Sapin
11 :license: BSD, see LICENSE for details.
12
13"""
14
15from __future__ import unicode_literals
16
17import codecs
18
19from .labels import LABELS
20
21
22VERSION = '0.5.1'
23
24
25# Some names in Encoding are not valid Python aliases. Remap these.
26PYTHON_NAMES = {
27 'iso-8859-8-i': 'iso-8859-8',
28 'x-mac-cyrillic': 'mac-cyrillic',
29 'macintosh': 'mac-roman',
30 'windows-874': 'cp874'}
31
32CACHE = {}
33
34
35def ascii_lower(string):
36 r"""Transform (only) ASCII letters to lower case: A-Z is mapped to a-z.
37
38 :param string: An Unicode string.
39 :returns: A new Unicode string.
40
41 This is used for `ASCII case-insensitive
42 <http://encoding.spec.whatwg.org/#ascii-case-insensitive>`_
43 matching of encoding labels.
44 The same matching is also used, among other things,
45 for `CSS keywords <http://dev.w3.org/csswg/css-values/#keywords>`_.
46
47 This is different from the :meth:`~py:str.lower` method of Unicode strings
48 which also affect non-ASCII characters,
49 sometimes mapping them into the ASCII range:
50
51 >>> keyword = u'Bac\N{KELVIN SIGN}ground'
52 >>> assert keyword.lower() == u'background'
53 >>> assert ascii_lower(keyword) != keyword.lower()
54 >>> assert ascii_lower(keyword) == u'bac\N{KELVIN SIGN}ground'
55
56 """
57 # This turns out to be faster than unicode.translate()
58 return string.encode('utf8').lower().decode('utf8')
59
60
61def lookup(label):
62 """
63 Look for an encoding by its label.
64 This is the spec’s `get an encoding
65 <http://encoding.spec.whatwg.org/#concept-encoding-get>`_ algorithm.
66 Supported labels are listed there.
67
68 :param label: A string.
69 :returns:
70 An :class:`Encoding` object, or :obj:`None` for an unknown label.
71
72 """
73 # Only strip ASCII whitespace: U+0009, U+000A, U+000C, U+000D, and U+0020.
74 label = ascii_lower(label.strip('\t\n\f\r '))
75 name = LABELS.get(label)
76 if name is None:
77 return None
78 encoding = CACHE.get(name)
79 if encoding is None:
80 if name == 'x-user-defined':
81 from .x_user_defined import codec_info
82 else:
83 python_name = PYTHON_NAMES.get(name, name)
84 # Any python_name value that gets to here should be valid.
85 codec_info = codecs.lookup(python_name)
86 encoding = Encoding(name, codec_info)
87 CACHE[name] = encoding
88 return encoding
89
90
91def _get_encoding(encoding_or_label):
92 """
93 Accept either an encoding object or label.
94
95 :param encoding: An :class:`Encoding` object or a label string.
96 :returns: An :class:`Encoding` object.
97 :raises: :exc:`~exceptions.LookupError` for an unknown label.
98
99 """
100 if hasattr(encoding_or_label, 'codec_info'):
101 return encoding_or_label
102
103 encoding = lookup(encoding_or_label)
104 if encoding is None:
105 raise LookupError('Unknown encoding label: %r' % encoding_or_label)
106 return encoding
107
108
109class Encoding(object):
110 """Reresents a character encoding such as UTF-8,
111 that can be used for decoding or encoding.
112
113 .. attribute:: name
114
115 Canonical name of the encoding
116
117 .. attribute:: codec_info
118
119 The actual implementation of the encoding,
120 a stdlib :class:`~codecs.CodecInfo` object.
121 See :func:`codecs.register`.
122
123 """
124 def __init__(self, name, codec_info):
125 self.name = name
126 self.codec_info = codec_info
127
128 def __repr__(self):
129 return '<Encoding %s>' % self.name
130
131
132#: The UTF-8 encoding. Should be used for new content and formats.
133UTF8 = lookup('utf-8')
134
135_UTF16LE = lookup('utf-16le')
136_UTF16BE = lookup('utf-16be')
137
138
139def decode(input, fallback_encoding, errors='replace'):
140 """
141 Decode a single string.
142
143 :param input: A byte string
144 :param fallback_encoding:
145 An :class:`Encoding` object or a label string.
146 The encoding to use if :obj:`input` does note have a BOM.
147 :param errors: Type of error handling. See :func:`codecs.register`.
148 :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
149 :return:
150 A ``(output, encoding)`` tuple of an Unicode string
151 and an :obj:`Encoding`.
152
153 """
154 # Fail early if `encoding` is an invalid label.
155 fallback_encoding = _get_encoding(fallback_encoding)
156 bom_encoding, input = _detect_bom(input)
157 encoding = bom_encoding or fallback_encoding
158 return encoding.codec_info.decode(input, errors)[0], encoding
159
160
161def _detect_bom(input):
162 """Return (bom_encoding, input), with any BOM removed from the input."""
163 if input.startswith(b'\xFF\xFE'):
164 return _UTF16LE, input[2:]
165 if input.startswith(b'\xFE\xFF'):
166 return _UTF16BE, input[2:]
167 if input.startswith(b'\xEF\xBB\xBF'):
168 return UTF8, input[3:]
169 return None, input
170
171
172def encode(input, encoding=UTF8, errors='strict'):
173 """
174 Encode a single string.
175
176 :param input: An Unicode string.
177 :param encoding: An :class:`Encoding` object or a label string.
178 :param errors: Type of error handling. See :func:`codecs.register`.
179 :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
180 :return: A byte string.
181
182 """
183 return _get_encoding(encoding).codec_info.encode(input, errors)[0]
184
185
186def iter_decode(input, fallback_encoding, errors='replace'):
187 """
188 "Pull"-based decoder.
189
190 :param input:
191 An iterable of byte strings.
192
193 The input is first consumed just enough to determine the encoding
194 based on the precense of a BOM,
195 then consumed on demand when the return value is.
196 :param fallback_encoding:
197 An :class:`Encoding` object or a label string.
198 The encoding to use if :obj:`input` does note have a BOM.
199 :param errors: Type of error handling. See :func:`codecs.register`.
200 :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
201 :returns:
202 An ``(output, encoding)`` tuple.
203 :obj:`output` is an iterable of Unicode strings,
204 :obj:`encoding` is the :obj:`Encoding` that is being used.
205
206 """
207
208 decoder = IncrementalDecoder(fallback_encoding, errors)
209 generator = _iter_decode_generator(input, decoder)
210 encoding = next(generator)
211 return generator, encoding
212
213
214def _iter_decode_generator(input, decoder):
215 """Return a generator that first yields the :obj:`Encoding`,
216 then yields output chukns as Unicode strings.
217
218 """
219 decode = decoder.decode
220 input = iter(input)
221 for chunck in input:
222 output = decode(chunck)
223 if output:
224 assert decoder.encoding is not None
225 yield decoder.encoding
226 yield output
227 break
228 else:
229 # Input exhausted without determining the encoding
230 output = decode(b'', final=True)
231 assert decoder.encoding is not None
232 yield decoder.encoding
233 if output:
234 yield output
235 return
236
237 for chunck in input:
238 output = decode(chunck)
239 if output:
240 yield output
241 output = decode(b'', final=True)
242 if output:
243 yield output
244
245
246def iter_encode(input, encoding=UTF8, errors='strict'):
247 """
248 “Pull”-based encoder.
249
250 :param input: An iterable of Unicode strings.
251 :param encoding: An :class:`Encoding` object or a label string.
252 :param errors: Type of error handling. See :func:`codecs.register`.
253 :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
254 :returns: An iterable of byte strings.
255
256 """
257 # Fail early if `encoding` is an invalid label.
258 encode = IncrementalEncoder(encoding, errors).encode
259 return _iter_encode_generator(input, encode)
260
261
262def _iter_encode_generator(input, encode):
263 for chunck in input:
264 output = encode(chunck)
265 if output:
266 yield output
267 output = encode('', final=True)
268 if output:
269 yield output
270
271
272class IncrementalDecoder(object):
273 """
274 “Push”-based decoder.
275
276 :param fallback_encoding:
277 An :class:`Encoding` object or a label string.
278 The encoding to use if :obj:`input` does note have a BOM.
279 :param errors: Type of error handling. See :func:`codecs.register`.
280 :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
281
282 """
283 def __init__(self, fallback_encoding, errors='replace'):
284 # Fail early if `encoding` is an invalid label.
285 self._fallback_encoding = _get_encoding(fallback_encoding)
286 self._errors = errors
287 self._buffer = b''
288 self._decoder = None
289 #: The actual :class:`Encoding` that is being used,
290 #: or :obj:`None` if that is not determined yet.
291 #: (Ie. if there is not enough input yet to determine
292 #: if there is a BOM.)
293 self.encoding = None # Not known yet.
294
295 def decode(self, input, final=False):
296 """Decode one chunk of the input.
297
298 :param input: A byte string.
299 :param final:
300 Indicate that no more input is available.
301 Must be :obj:`True` if this is the last call.
302 :returns: An Unicode string.
303
304 """
305 decoder = self._decoder
306 if decoder is not None:
307 return decoder(input, final)
308
309 input = self._buffer + input
310 encoding, input = _detect_bom(input)
311 if encoding is None:
312 if len(input) < 3 and not final: # Not enough data yet.
313 self._buffer = input
314 return ''
315 else: # No BOM
316 encoding = self._fallback_encoding
317 decoder = encoding.codec_info.incrementaldecoder(self._errors).decode
318 self._decoder = decoder
319 self.encoding = encoding
320 return decoder(input, final)
321
322
323class IncrementalEncoder(object):
324 """
325 “Push”-based encoder.
326
327 :param encoding: An :class:`Encoding` object or a label string.
328 :param errors: Type of error handling. See :func:`codecs.register`.
329 :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
330
331 .. method:: encode(input, final=False)
332
333 :param input: An Unicode string.
334 :param final:
335 Indicate that no more input is available.
336 Must be :obj:`True` if this is the last call.
337 :returns: A byte string.
338
339 """
340 def __init__(self, encoding=UTF8, errors='strict'):
341 encoding = _get_encoding(encoding)
342 self.encode = encoding.codec_info.incrementalencoder(errors).encode
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/labels.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/labels.py
new file mode 100644
index 0000000..9dae102
--- /dev/null
+++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/labels.py
@@ -0,0 +1,231 @@
1"""
2
3 webencodings.labels
4 ~~~~~~~~~~~~~~~~~~~
5
6 Map encoding labels to their name.
7
8 :copyright: Copyright 2012 by Simon Sapin
9 :license: BSD, see LICENSE for details.
10
11"""
12
13# XXX Do not edit!
14# This file is automatically generated by mklabels.py
15
16LABELS = {
17 'unicode-1-1-utf-8': 'utf-8',
18 'utf-8': 'utf-8',
19 'utf8': 'utf-8',
20 '866': 'ibm866',
21 'cp866': 'ibm866',
22 'csibm866': 'ibm866',
23 'ibm866': 'ibm866',
24 'csisolatin2': 'iso-8859-2',
25 'iso-8859-2': 'iso-8859-2',
26 'iso-ir-101': 'iso-8859-2',
27 'iso8859-2': 'iso-8859-2',
28 'iso88592': 'iso-8859-2',
29 'iso_8859-2': 'iso-8859-2',
30 'iso_8859-2:1987': 'iso-8859-2',
31 'l2': 'iso-8859-2',
32 'latin2': 'iso-8859-2',
33 'csisolatin3': 'iso-8859-3',
34 'iso-8859-3': 'iso-8859-3',
35 'iso-ir-109': 'iso-8859-3',
36 'iso8859-3': 'iso-8859-3',
37 'iso88593': 'iso-8859-3',
38 'iso_8859-3': 'iso-8859-3',
39 'iso_8859-3:1988': 'iso-8859-3',
40 'l3': 'iso-8859-3',
41 'latin3': 'iso-8859-3',
42 'csisolatin4': 'iso-8859-4',
43 'iso-8859-4': 'iso-8859-4',
44 'iso-ir-110': 'iso-8859-4',
45 'iso8859-4': 'iso-8859-4',
46 'iso88594': 'iso-8859-4',
47 'iso_8859-4': 'iso-8859-4',
48 'iso_8859-4:1988': 'iso-8859-4',
49 'l4': 'iso-8859-4',
50 'latin4': 'iso-8859-4',
51 'csisolatincyrillic': 'iso-8859-5',
52 'cyrillic': 'iso-8859-5',
53 'iso-8859-5': 'iso-8859-5',
54 'iso-ir-144': 'iso-8859-5',
55 'iso8859-5': 'iso-8859-5',
56 'iso88595': 'iso-8859-5',
57 'iso_8859-5': 'iso-8859-5',
58 'iso_8859-5:1988': 'iso-8859-5',
59 'arabic': 'iso-8859-6',
60 'asmo-708': 'iso-8859-6',
61 'csiso88596e': 'iso-8859-6',
62 'csiso88596i': 'iso-8859-6',
63 'csisolatinarabic': 'iso-8859-6',
64 'ecma-114': 'iso-8859-6',
65 'iso-8859-6': 'iso-8859-6',
66 'iso-8859-6-e': 'iso-8859-6',
67 'iso-8859-6-i': 'iso-8859-6',
68 'iso-ir-127': 'iso-8859-6',
69 'iso8859-6': 'iso-8859-6',
70 'iso88596': 'iso-8859-6',
71 'iso_8859-6': 'iso-8859-6',
72 'iso_8859-6:1987': 'iso-8859-6',
73 'csisolatingreek': 'iso-8859-7',
74 'ecma-118': 'iso-8859-7',
75 'elot_928': 'iso-8859-7',
76 'greek': 'iso-8859-7',
77 'greek8': 'iso-8859-7',
78 'iso-8859-7': 'iso-8859-7',
79 'iso-ir-126': 'iso-8859-7',
80 'iso8859-7': 'iso-8859-7',
81 'iso88597': 'iso-8859-7',
82 'iso_8859-7': 'iso-8859-7',
83 'iso_8859-7:1987': 'iso-8859-7',
84 'sun_eu_greek': 'iso-8859-7',
85 'csiso88598e': 'iso-8859-8',
86 'csisolatinhebrew': 'iso-8859-8',
87 'hebrew': 'iso-8859-8',
88 'iso-8859-8': 'iso-8859-8',
89 'iso-8859-8-e': 'iso-8859-8',
90 'iso-ir-138': 'iso-8859-8',
91 'iso8859-8': 'iso-8859-8',
92 'iso88598': 'iso-8859-8',
93 'iso_8859-8': 'iso-8859-8',
94 'iso_8859-8:1988': 'iso-8859-8',
95 'visual': 'iso-8859-8',
96 'csiso88598i': 'iso-8859-8-i',
97 'iso-8859-8-i': 'iso-8859-8-i',
98 'logical': 'iso-8859-8-i',
99 'csisolatin6': 'iso-8859-10',
100 'iso-8859-10': 'iso-8859-10',
101 'iso-ir-157': 'iso-8859-10',
102 'iso8859-10': 'iso-8859-10',
103 'iso885910': 'iso-8859-10',
104 'l6': 'iso-8859-10',
105 'latin6': 'iso-8859-10',
106 'iso-8859-13': 'iso-8859-13',
107 'iso8859-13': 'iso-8859-13',
108 'iso885913': 'iso-8859-13',
109 'iso-8859-14': 'iso-8859-14',
110 'iso8859-14': 'iso-8859-14',
111 'iso885914': 'iso-8859-14',
112 'csisolatin9': 'iso-8859-15',
113 'iso-8859-15': 'iso-8859-15',
114 'iso8859-15': 'iso-8859-15',
115 'iso885915': 'iso-8859-15',
116 'iso_8859-15': 'iso-8859-15',
117 'l9': 'iso-8859-15',
118 'iso-8859-16': 'iso-8859-16',
119 'cskoi8r': 'koi8-r',
120 'koi': 'koi8-r',
121 'koi8': 'koi8-r',
122 'koi8-r': 'koi8-r',
123 'koi8_r': 'koi8-r',
124 'koi8-u': 'koi8-u',
125 'csmacintosh': 'macintosh',
126 'mac': 'macintosh',
127 'macintosh': 'macintosh',
128 'x-mac-roman': 'macintosh',
129 'dos-874': 'windows-874',
130 'iso-8859-11': 'windows-874',
131 'iso8859-11': 'windows-874',
132 'iso885911': 'windows-874',
133 'tis-620': 'windows-874',
134 'windows-874': 'windows-874',
135 'cp1250': 'windows-1250',
136 'windows-1250': 'windows-1250',
137 'x-cp1250': 'windows-1250',
138 'cp1251': 'windows-1251',
139 'windows-1251': 'windows-1251',
140 'x-cp1251': 'windows-1251',
141 'ansi_x3.4-1968': 'windows-1252',
142 'ascii': 'windows-1252',
143 'cp1252': 'windows-1252',
144 'cp819': 'windows-1252',
145 'csisolatin1': 'windows-1252',
146 'ibm819': 'windows-1252',
147 'iso-8859-1': 'windows-1252',
148 'iso-ir-100': 'windows-1252',
149 'iso8859-1': 'windows-1252',
150 'iso88591': 'windows-1252',
151 'iso_8859-1': 'windows-1252',
152 'iso_8859-1:1987': 'windows-1252',
153 'l1': 'windows-1252',
154 'latin1': 'windows-1252',
155 'us-ascii': 'windows-1252',
156 'windows-1252': 'windows-1252',
157 'x-cp1252': 'windows-1252',
158 'cp1253': 'windows-1253',
159 'windows-1253': 'windows-1253',
160 'x-cp1253': 'windows-1253',
161 'cp1254': 'windows-1254',
162 'csisolatin5': 'windows-1254',
163 'iso-8859-9': 'windows-1254',
164 'iso-ir-148': 'windows-1254',
165 'iso8859-9': 'windows-1254',
166 'iso88599': 'windows-1254',
167 'iso_8859-9': 'windows-1254',
168 'iso_8859-9:1989': 'windows-1254',
169 'l5': 'windows-1254',
170 'latin5': 'windows-1254',
171 'windows-1254': 'windows-1254',
172 'x-cp1254': 'windows-1254',
173 'cp1255': 'windows-1255',
174 'windows-1255': 'windows-1255',
175 'x-cp1255': 'windows-1255',
176 'cp1256': 'windows-1256',
177 'windows-1256': 'windows-1256',
178 'x-cp1256': 'windows-1256',
179 'cp1257': 'windows-1257',
180 'windows-1257': 'windows-1257',
181 'x-cp1257': 'windows-1257',
182 'cp1258': 'windows-1258',
183 'windows-1258': 'windows-1258',
184 'x-cp1258': 'windows-1258',
185 'x-mac-cyrillic': 'x-mac-cyrillic',
186 'x-mac-ukrainian': 'x-mac-cyrillic',
187 'chinese': 'gbk',
188 'csgb2312': 'gbk',
189 'csiso58gb231280': 'gbk',
190 'gb2312': 'gbk',
191 'gb_2312': 'gbk',
192 'gb_2312-80': 'gbk',
193 'gbk': 'gbk',
194 'iso-ir-58': 'gbk',
195 'x-gbk': 'gbk',
196 'gb18030': 'gb18030',
197 'hz-gb-2312': 'hz-gb-2312',
198 'big5': 'big5',
199 'big5-hkscs': 'big5',
200 'cn-big5': 'big5',
201 'csbig5': 'big5',
202 'x-x-big5': 'big5',
203 'cseucpkdfmtjapanese': 'euc-jp',
204 'euc-jp': 'euc-jp',
205 'x-euc-jp': 'euc-jp',
206 'csiso2022jp': 'iso-2022-jp',
207 'iso-2022-jp': 'iso-2022-jp',
208 'csshiftjis': 'shift_jis',
209 'ms_kanji': 'shift_jis',
210 'shift-jis': 'shift_jis',
211 'shift_jis': 'shift_jis',
212 'sjis': 'shift_jis',
213 'windows-31j': 'shift_jis',
214 'x-sjis': 'shift_jis',
215 'cseuckr': 'euc-kr',
216 'csksc56011987': 'euc-kr',
217 'euc-kr': 'euc-kr',
218 'iso-ir-149': 'euc-kr',
219 'korean': 'euc-kr',
220 'ks_c_5601-1987': 'euc-kr',
221 'ks_c_5601-1989': 'euc-kr',
222 'ksc5601': 'euc-kr',
223 'ksc_5601': 'euc-kr',
224 'windows-949': 'euc-kr',
225 'csiso2022kr': 'iso-2022-kr',
226 'iso-2022-kr': 'iso-2022-kr',
227 'utf-16be': 'utf-16be',
228 'utf-16': 'utf-16le',
229 'utf-16le': 'utf-16le',
230 'x-user-defined': 'x-user-defined',
231}
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/mklabels.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/mklabels.py
new file mode 100644
index 0000000..a7f7e76
--- /dev/null
+++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/mklabels.py
@@ -0,0 +1,59 @@
1"""
2
3 webencodings.mklabels
4 ~~~~~~~~~~~~~~~~~~~~~
5
6 Regenarate the webencodings.labels module.
7
8 :copyright: Copyright 2012 by Simon Sapin
9 :license: BSD, see LICENSE for details.
10
11"""
12
13import json
14try:
15 from urllib import urlopen
16except ImportError:
17 from urllib.request import urlopen
18
19
20def assert_lower(string):
21 assert string == string.lower()
22 return string
23
24
25def generate(url):
26 parts = ['''\
27"""
28
29 webencodings.labels
30 ~~~~~~~~~~~~~~~~~~~
31
32 Map encoding labels to their name.
33
34 :copyright: Copyright 2012 by Simon Sapin
35 :license: BSD, see LICENSE for details.
36
37"""
38
39# XXX Do not edit!
40# This file is automatically generated by mklabels.py
41
42LABELS = {
43''']
44 labels = [
45 (repr(assert_lower(label)).lstrip('u'),
46 repr(encoding['name']).lstrip('u'))
47 for category in json.loads(urlopen(url).read().decode('ascii'))
48 for encoding in category['encodings']
49 for label in encoding['labels']]
50 max_len = max(len(label) for label, name in labels)
51 parts.extend(
52 ' %s:%s %s,\n' % (label, ' ' * (max_len - len(label)), name)
53 for label, name in labels)
54 parts.append('}')
55 return ''.join(parts)
56
57
58if __name__ == '__main__':
59 print(generate('http://encoding.spec.whatwg.org/encodings.json'))
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/tests.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/tests.py
new file mode 100644
index 0000000..f6cdbf9
--- /dev/null
+++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/tests.py
@@ -0,0 +1,153 @@
1# coding: utf-8
2"""
3
4 webencodings.tests
5 ~~~~~~~~~~~~~~~~~~
6
7 A basic test suite for Encoding.
8
9 :copyright: Copyright 2012 by Simon Sapin
10 :license: BSD, see LICENSE for details.
11
12"""
13
14from __future__ import unicode_literals
15
16from . import (lookup, LABELS, decode, encode, iter_decode, iter_encode,
17 IncrementalDecoder, IncrementalEncoder, UTF8)
18
19
20def assert_raises(exception, function, *args, **kwargs):
21 try:
22 function(*args, **kwargs)
23 except exception:
24 return
25 else: # pragma: no cover
26 raise AssertionError('Did not raise %s.' % exception)
27
28
29def test_labels():
30 assert lookup('utf-8').name == 'utf-8'
31 assert lookup('Utf-8').name == 'utf-8'
32 assert lookup('UTF-8').name == 'utf-8'
33 assert lookup('utf8').name == 'utf-8'
34 assert lookup('utf8').name == 'utf-8'
35 assert lookup('utf8 ').name == 'utf-8'
36 assert lookup(' \r\nutf8\t').name == 'utf-8'
37 assert lookup('u8') is None # Python label.
38 assert lookup('utf-8 ') is None # Non-ASCII white space.
39
40 assert lookup('US-ASCII').name == 'windows-1252'
41 assert lookup('iso-8859-1').name == 'windows-1252'
42 assert lookup('latin1').name == 'windows-1252'
43 assert lookup('LATIN1').name == 'windows-1252'
44 assert lookup('latin-1') is None
45 assert lookup('LATİN1') is None # ASCII-only case insensitivity.
46
47
48def test_all_labels():
49 for label in LABELS:
50 assert decode(b'', label) == ('', lookup(label))
51 assert encode('', label) == b''
52 for repeat in [0, 1, 12]:
53 output, _ = iter_decode([b''] * repeat, label)
54 assert list(output) == []
55 assert list(iter_encode([''] * repeat, label)) == []
56 decoder = IncrementalDecoder(label)
57 assert decoder.decode(b'') == ''
58 assert decoder.decode(b'', final=True) == ''
59 encoder = IncrementalEncoder(label)
60 assert encoder.encode('') == b''
61 assert encoder.encode('', final=True) == b''
62 # All encoding names are valid labels too:
63 for name in set(LABELS.values()):
64 assert lookup(name).name == name
65
66
67def test_invalid_label():
68 assert_raises(LookupError, decode, b'\xEF\xBB\xBF\xc3\xa9', 'invalid')
69 assert_raises(LookupError, encode, 'é', 'invalid')
70 assert_raises(LookupError, iter_decode, [], 'invalid')
71 assert_raises(LookupError, iter_encode, [], 'invalid')
72 assert_raises(LookupError, IncrementalDecoder, 'invalid')
73 assert_raises(LookupError, IncrementalEncoder, 'invalid')
74
75
76def test_decode():
77 assert decode(b'\x80', 'latin1') == ('€', lookup('latin1'))
78 assert decode(b'\x80', lookup('latin1')) == ('€', lookup('latin1'))
79 assert decode(b'\xc3\xa9', 'utf8') == ('é', lookup('utf8'))
80 assert decode(b'\xc3\xa9', UTF8) == ('é', lookup('utf8'))
81 assert decode(b'\xc3\xa9', 'ascii') == ('é', lookup('ascii'))
82 assert decode(b'\xEF\xBB\xBF\xc3\xa9', 'ascii') == ('é', lookup('utf8')) # UTF-8 with BOM
83
84 assert decode(b'\xFE\xFF\x00\xe9', 'ascii') == ('é', lookup('utf-16be')) # UTF-16-BE with BOM
85 assert decode(b'\xFF\xFE\xe9\x00', 'ascii') == ('é', lookup('utf-16le')) # UTF-16-LE with BOM
86 assert decode(b'\xFE\xFF\xe9\x00', 'ascii') == ('\ue900', lookup('utf-16be'))
87 assert decode(b'\xFF\xFE\x00\xe9', 'ascii') == ('\ue900', lookup('utf-16le'))
88
89 assert decode(b'\x00\xe9', 'UTF-16BE') == ('é', lookup('utf-16be'))
90 assert decode(b'\xe9\x00', 'UTF-16LE') == ('é', lookup('utf-16le'))
91 assert decode(b'\xe9\x00', 'UTF-16') == ('é', lookup('utf-16le'))
92
93 assert decode(b'\xe9\x00', 'UTF-16BE') == ('\ue900', lookup('utf-16be'))
94 assert decode(b'\x00\xe9', 'UTF-16LE') == ('\ue900', lookup('utf-16le'))
95 assert decode(b'\x00\xe9', 'UTF-16') == ('\ue900', lookup('utf-16le'))
96
97
98def test_encode():
99 assert encode('é', 'latin1') == b'\xe9'
100 assert encode('é', 'utf8') == b'\xc3\xa9'
101 assert encode('é', 'utf8') == b'\xc3\xa9'
102 assert encode('é', 'utf-16') == b'\xe9\x00'
103 assert encode('é', 'utf-16le') == b'\xe9\x00'
104 assert encode('é', 'utf-16be') == b'\x00\xe9'
105
106
107def test_iter_decode():
108 def iter_decode_to_string(input, fallback_encoding):
109 output, _encoding = iter_decode(input, fallback_encoding)
110 return ''.join(output)
111 assert iter_decode_to_string([], 'latin1') == ''
112 assert iter_decode_to_string([b''], 'latin1') == ''
113 assert iter_decode_to_string([b'\xe9'], 'latin1') == 'é'
114 assert iter_decode_to_string([b'hello'], 'latin1') == 'hello'
115 assert iter_decode_to_string([b'he', b'llo'], 'latin1') == 'hello'
116 assert iter_decode_to_string([b'hell', b'o'], 'latin1') == 'hello'
117 assert iter_decode_to_string([b'\xc3\xa9'], 'latin1') == 'é'
118 assert iter_decode_to_string([b'\xEF\xBB\xBF\xc3\xa9'], 'latin1') == 'é'
119 assert iter_decode_to_string([
120 b'\xEF\xBB\xBF', b'\xc3', b'\xa9'], 'latin1') == 'é'
121 assert iter_decode_to_string([
122 b'\xEF\xBB\xBF', b'a', b'\xc3'], 'latin1') == 'a\uFFFD'
123 assert iter_decode_to_string([
124 b'', b'\xEF', b'', b'', b'\xBB\xBF\xc3', b'\xa9'], 'latin1') == 'é'
125 assert iter_decode_to_string([b'\xEF\xBB\xBF'], 'latin1') == ''
126 assert iter_decode_to_string([b'\xEF\xBB'], 'latin1') == 'ï»'
127 assert iter_decode_to_string([b'\xFE\xFF\x00\xe9'], 'latin1') == 'é'
128 assert iter_decode_to_string([b'\xFF\xFE\xe9\x00'], 'latin1') == 'é'
129 assert iter_decode_to_string([
130 b'', b'\xFF', b'', b'', b'\xFE\xe9', b'\x00'], 'latin1') == 'é'
131 assert iter_decode_to_string([
132 b'', b'h\xe9', b'llo'], 'x-user-defined') == 'h\uF7E9llo'
133
134
135def test_iter_encode():
136 assert b''.join(iter_encode([], 'latin1')) == b''
137 assert b''.join(iter_encode([''], 'latin1')) == b''
138 assert b''.join(iter_encode(['é'], 'latin1')) == b'\xe9'
139 assert b''.join(iter_encode(['', 'é', '', ''], 'latin1')) == b'\xe9'
140 assert b''.join(iter_encode(['', 'é', '', ''], 'utf-16')) == b'\xe9\x00'
141 assert b''.join(iter_encode(['', 'é', '', ''], 'utf-16le')) == b'\xe9\x00'
142 assert b''.join(iter_encode(['', 'é', '', ''], 'utf-16be')) == b'\x00\xe9'
143 assert b''.join(iter_encode([
144 '', 'h\uF7E9', '', 'llo'], 'x-user-defined')) == b'h\xe9llo'
145
146
147def test_x_user_defined():
148 encoded = b'2,\x0c\x0b\x1aO\xd9#\xcb\x0f\xc9\xbbt\xcf\xa8\xca'
149 decoded = '2,\x0c\x0b\x1aO\uf7d9#\uf7cb\x0f\uf7c9\uf7bbt\uf7cf\uf7a8\uf7ca'
150 encoded = b'aa'
151 decoded = 'aa'
152 assert decode(encoded, 'x-user-defined') == (decoded, lookup('x-user-defined'))
153 assert encode(decoded, 'x-user-defined') == encoded
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/x_user_defined.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/x_user_defined.py
new file mode 100644
index 0000000..748e2c9
--- /dev/null
+++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/webencodings/x_user_defined.py
@@ -0,0 +1,325 @@
1# coding: utf-8
2"""
3
4 webencodings.x_user_defined
5 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
6
7 An implementation of the x-user-defined encoding.
8
9 :copyright: Copyright 2012 by Simon Sapin
10 :license: BSD, see LICENSE for details.
11
12"""
13
14from __future__ import unicode_literals
15
16import codecs
17
18
19### Codec APIs
20
21class Codec(codecs.Codec):
22
23 def encode(self, input, errors='strict'):
24 return codecs.charmap_encode(input, errors, encoding_table)
25
26 def decode(self, input, errors='strict'):
27 return codecs.charmap_decode(input, errors, decoding_table)
28
29
30class IncrementalEncoder(codecs.IncrementalEncoder):
31 def encode(self, input, final=False):
32 return codecs.charmap_encode(input, self.errors, encoding_table)[0]
33
34
35class IncrementalDecoder(codecs.IncrementalDecoder):
36 def decode(self, input, final=False):
37 return codecs.charmap_decode(input, self.errors, decoding_table)[0]
38
39
40class StreamWriter(Codec, codecs.StreamWriter):
41 pass
42
43
44class StreamReader(Codec, codecs.StreamReader):
45 pass
46
47
48### encodings module API
49
50codec_info = codecs.CodecInfo(
51 name='x-user-defined',
52 encode=Codec().encode,
53 decode=Codec().decode,
54 incrementalencoder=IncrementalEncoder,
55 incrementaldecoder=IncrementalDecoder,
56 streamreader=StreamReader,
57 streamwriter=StreamWriter,
58)
59
60
61### Decoding Table
62
63# Python 3:
64# for c in range(256): print(' %r' % chr(c if c < 128 else c + 0xF700))
65decoding_table = (
66 '\x00'
67 '\x01'
68 '\x02'
69 '\x03'
70 '\x04'
71 '\x05'
72 '\x06'
73 '\x07'
74 '\x08'
75 '\t'
76 '\n'
77 '\x0b'
78 '\x0c'
79 '\r'
80 '\x0e'
81 '\x0f'
82 '\x10'
83 '\x11'
84 '\x12'
85 '\x13'
86 '\x14'
87 '\x15'
88 '\x16'
89 '\x17'
90 '\x18'
91 '\x19'
92 '\x1a'
93 '\x1b'
94 '\x1c'
95 '\x1d'
96 '\x1e'
97 '\x1f'
98 ' '
99 '!'
100 '"'
101 '#'
102 '$'
103 '%'
104 '&'
105 "'"
106 '('
107 ')'
108 '*'
109 '+'
110 ','
111 '-'
112 '.'
113 '/'
114 '0'
115 '1'
116 '2'
117 '3'
118 '4'
119 '5'
120 '6'
121 '7'
122 '8'
123 '9'
124 ':'
125 ';'
126 '<'
127 '='
128 '>'
129 '?'
130 '@'
131 'A'
132 'B'
133 'C'
134 'D'
135 'E'
136 'F'
137 'G'
138 'H'
139 'I'
140 'J'
141 'K'
142 'L'
143 'M'
144 'N'
145 'O'
146 'P'
147 'Q'
148 'R'
149 'S'
150 'T'
151 'U'
152 'V'
153 'W'
154 'X'
155 'Y'
156 'Z'
157 '['
158 '\\'
159 ']'
160 '^'
161 '_'
162 '`'
163 'a'
164 'b'
165 'c'
166 'd'
167 'e'
168 'f'
169 'g'
170 'h'
171 'i'
172 'j'
173 'k'
174 'l'
175 'm'
176 'n'
177 'o'
178 'p'
179 'q'
180 'r'
181 's'
182 't'
183 'u'
184 'v'
185 'w'
186 'x'
187 'y'
188 'z'
189 '{'
190 '|'
191 '}'
192 '~'
193 '\x7f'
194 '\uf780'
195 '\uf781'
196 '\uf782'
197 '\uf783'
198 '\uf784'
199 '\uf785'
200 '\uf786'
201 '\uf787'
202 '\uf788'
203 '\uf789'
204 '\uf78a'
205 '\uf78b'
206 '\uf78c'
207 '\uf78d'
208 '\uf78e'
209 '\uf78f'
210 '\uf790'
211 '\uf791'
212 '\uf792'
213 '\uf793'
214 '\uf794'
215 '\uf795'
216 '\uf796'
217 '\uf797'
218 '\uf798'
219 '\uf799'
220 '\uf79a'
221 '\uf79b'
222 '\uf79c'
223 '\uf79d'
224 '\uf79e'
225 '\uf79f'
226 '\uf7a0'
227 '\uf7a1'
228 '\uf7a2'
229 '\uf7a3'
230 '\uf7a4'
231 '\uf7a5'
232 '\uf7a6'
233 '\uf7a7'
234 '\uf7a8'
235 '\uf7a9'
236 '\uf7aa'
237 '\uf7ab'
238 '\uf7ac'
239 '\uf7ad'
240 '\uf7ae'
241 '\uf7af'
242 '\uf7b0'
243 '\uf7b1'
244 '\uf7b2'
245 '\uf7b3'
246 '\uf7b4'
247 '\uf7b5'
248 '\uf7b6'
249 '\uf7b7'
250 '\uf7b8'
251 '\uf7b9'
252 '\uf7ba'
253 '\uf7bb'
254 '\uf7bc'
255 '\uf7bd'
256 '\uf7be'
257 '\uf7bf'
258 '\uf7c0'
259 '\uf7c1'
260 '\uf7c2'
261 '\uf7c3'
262 '\uf7c4'
263 '\uf7c5'
264 '\uf7c6'
265 '\uf7c7'
266 '\uf7c8'
267 '\uf7c9'
268 '\uf7ca'
269 '\uf7cb'
270 '\uf7cc'
271 '\uf7cd'
272 '\uf7ce'
273 '\uf7cf'
274 '\uf7d0'
275 '\uf7d1'
276 '\uf7d2'
277 '\uf7d3'
278 '\uf7d4'
279 '\uf7d5'
280 '\uf7d6'
281 '\uf7d7'
282 '\uf7d8'
283 '\uf7d9'
284 '\uf7da'
285 '\uf7db'
286 '\uf7dc'
287 '\uf7dd'
288 '\uf7de'
289 '\uf7df'
290 '\uf7e0'
291 '\uf7e1'
292 '\uf7e2'
293 '\uf7e3'
294 '\uf7e4'
295 '\uf7e5'
296 '\uf7e6'
297 '\uf7e7'
298 '\uf7e8'
299 '\uf7e9'
300 '\uf7ea'
301 '\uf7eb'
302 '\uf7ec'
303 '\uf7ed'
304 '\uf7ee'
305 '\uf7ef'
306 '\uf7f0'
307 '\uf7f1'
308 '\uf7f2'
309 '\uf7f3'
310 '\uf7f4'
311 '\uf7f5'
312 '\uf7f6'
313 '\uf7f7'
314 '\uf7f8'
315 '\uf7f9'
316 '\uf7fa'
317 '\uf7fb'
318 '\uf7fc'
319 '\uf7fd'
320 '\uf7fe'
321 '\uf7ff'
322)
323
324### Encoding table
325encoding_table = codecs.charmap_build(decoding_table)
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-29 22:57:32 +0000