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