Mercurial > repos > shellac > guppy_basecaller

comparison env/lib/python3.7/site-packages/six.py @ 0:26e78fe6e8c4 draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
"planemo upload commit c699937486c35866861690329de38ec1a5d9f783"
author shellac
date Sat, 02 May 2020 07:14:21 -0400
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:26e78fe6e8c4
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.14.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("getoutput", "commands", "subprocess"),
245 MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
246 MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
247 MovedAttribute("reduce", "__builtin__", "functools"),
248 MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
249 MovedAttribute("StringIO", "StringIO", "io"),
250 MovedAttribute("UserDict", "UserDict", "collections"),
251 MovedAttribute("UserList", "UserList", "collections"),
252 MovedAttribute("UserString", "UserString", "collections"),
253 MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
254 MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
255 MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
256 MovedModule("builtins", "__builtin__"),
257 MovedModule("configparser", "ConfigParser"),
258 MovedModule("collections_abc", "collections", "collections.abc" if sys.version_info >= (3, 3) else "collections"),
259 MovedModule("copyreg", "copy_reg"),
260 MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
261 MovedModule("dbm_ndbm", "dbm", "dbm.ndbm"),
262 MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread" if sys.version_info < (3, 9) else "_thread"),
263 MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
264 MovedModule("http_cookies", "Cookie", "http.cookies"),
265 MovedModule("html_entities", "htmlentitydefs", "html.entities"),
266 MovedModule("html_parser", "HTMLParser", "html.parser"),
267 MovedModule("http_client", "httplib", "http.client"),
268 MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
269 MovedModule("email_mime_image", "email.MIMEImage", "email.mime.image"),
270 MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
271 MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
272 MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
273 MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
274 MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
275 MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
276 MovedModule("cPickle", "cPickle", "pickle"),
277 MovedModule("queue", "Queue"),
278 MovedModule("reprlib", "repr"),
279 MovedModule("socketserver", "SocketServer"),
280 MovedModule("_thread", "thread", "_thread"),
281 MovedModule("tkinter", "Tkinter"),
282 MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
283 MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
284 MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
285 MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
286 MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
287 MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
288 MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
289 MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
290 MovedModule("tkinter_colorchooser", "tkColorChooser",
291 "tkinter.colorchooser"),
292 MovedModule("tkinter_commondialog", "tkCommonDialog",
293 "tkinter.commondialog"),
294 MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
295 MovedModule("tkinter_font", "tkFont", "tkinter.font"),
296 MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
297 MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
298 "tkinter.simpledialog"),
299 MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
300 MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
301 MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
302 MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
303 MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
304 MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
305 ]
306 # Add windows specific modules.
307 if sys.platform == "win32":
308 _moved_attributes += [
309 MovedModule("winreg", "_winreg"),
310 ]
311
312 for attr in _moved_attributes:
313 setattr(_MovedItems, attr.name, attr)
314 if isinstance(attr, MovedModule):
315 _importer._add_module(attr, "moves." + attr.name)
316 del attr
317
318 _MovedItems._moved_attributes = _moved_attributes
319
320 moves = _MovedItems(__name__ + ".moves")
321 _importer._add_module(moves, "moves")
322
323
324 class Module_six_moves_urllib_parse(_LazyModule):
325
326 """Lazy loading of moved objects in six.moves.urllib_parse"""
327
328
329 _urllib_parse_moved_attributes = [
330 MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
331 MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
332 MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
333 MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
334 MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
335 MovedAttribute("urljoin", "urlparse", "urllib.parse"),
336 MovedAttribute("urlparse", "urlparse", "urllib.parse"),
337 MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
338 MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
339 MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
340 MovedAttribute("quote", "urllib", "urllib.parse"),
341 MovedAttribute("quote_plus", "urllib", "urllib.parse"),
342 MovedAttribute("unquote", "urllib", "urllib.parse"),
343 MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
344 MovedAttribute("unquote_to_bytes", "urllib", "urllib.parse", "unquote", "unquote_to_bytes"),
345 MovedAttribute("urlencode", "urllib", "urllib.parse"),
346 MovedAttribute("splitquery", "urllib", "urllib.parse"),
347 MovedAttribute("splittag", "urllib", "urllib.parse"),
348 MovedAttribute("splituser", "urllib", "urllib.parse"),
349 MovedAttribute("splitvalue", "urllib", "urllib.parse"),
350 MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
351 MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
352 MovedAttribute("uses_params", "urlparse", "urllib.parse"),
353 MovedAttribute("uses_query", "urlparse", "urllib.parse"),
354 MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
355 ]
356 for attr in _urllib_parse_moved_attributes:
357 setattr(Module_six_moves_urllib_parse, attr.name, attr)
358 del attr
359
360 Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
361
362 _importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
363 "moves.urllib_parse", "moves.urllib.parse")
364
365
366 class Module_six_moves_urllib_error(_LazyModule):
367
368 """Lazy loading of moved objects in six.moves.urllib_error"""
369
370
371 _urllib_error_moved_attributes = [
372 MovedAttribute("URLError", "urllib2", "urllib.error"),
373 MovedAttribute("HTTPError", "urllib2", "urllib.error"),
374 MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
375 ]
376 for attr in _urllib_error_moved_attributes:
377 setattr(Module_six_moves_urllib_error, attr.name, attr)
378 del attr
379
380 Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
381
382 _importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
383 "moves.urllib_error", "moves.urllib.error")
384
385
386 class Module_six_moves_urllib_request(_LazyModule):
387
388 """Lazy loading of moved objects in six.moves.urllib_request"""
389
390
391 _urllib_request_moved_attributes = [
392 MovedAttribute("urlopen", "urllib2", "urllib.request"),
393 MovedAttribute("install_opener", "urllib2", "urllib.request"),
394 MovedAttribute("build_opener", "urllib2", "urllib.request"),
395 MovedAttribute("pathname2url", "urllib", "urllib.request"),
396 MovedAttribute("url2pathname", "urllib", "urllib.request"),
397 MovedAttribute("getproxies", "urllib", "urllib.request"),
398 MovedAttribute("Request", "urllib2", "urllib.request"),
399 MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
400 MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
401 MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
402 MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
403 MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
404 MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
405 MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
406 MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
407 MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
408 MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
409 MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
410 MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
411 MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
412 MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
413 MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
414 MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
415 MovedAttribute("FileHandler", "urllib2", "urllib.request"),
416 MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
417 MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
418 MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
419 MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
420 MovedAttribute("urlretrieve", "urllib", "urllib.request"),
421 MovedAttribute("urlcleanup", "urllib", "urllib.request"),
422 MovedAttribute("URLopener", "urllib", "urllib.request"),
423 MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
424 MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
425 MovedAttribute("parse_http_list", "urllib2", "urllib.request"),
426 MovedAttribute("parse_keqv_list", "urllib2", "urllib.request"),
427 ]
428 for attr in _urllib_request_moved_attributes:
429 setattr(Module_six_moves_urllib_request, attr.name, attr)
430 del attr
431
432 Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
433
434 _importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
435 "moves.urllib_request", "moves.urllib.request")
436
437
438 class Module_six_moves_urllib_response(_LazyModule):
439
440 """Lazy loading of moved objects in six.moves.urllib_response"""
441
442
443 _urllib_response_moved_attributes = [
444 MovedAttribute("addbase", "urllib", "urllib.response"),
445 MovedAttribute("addclosehook", "urllib", "urllib.response"),
446 MovedAttribute("addinfo", "urllib", "urllib.response"),
447 MovedAttribute("addinfourl", "urllib", "urllib.response"),
448 ]
449 for attr in _urllib_response_moved_attributes:
450 setattr(Module_six_moves_urllib_response, attr.name, attr)
451 del attr
452
453 Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
454
455 _importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
456 "moves.urllib_response", "moves.urllib.response")
457
458
459 class Module_six_moves_urllib_robotparser(_LazyModule):
460
461 """Lazy loading of moved objects in six.moves.urllib_robotparser"""
462
463
464 _urllib_robotparser_moved_attributes = [
465 MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
466 ]
467 for attr in _urllib_robotparser_moved_attributes:
468 setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
469 del attr
470
471 Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
472
473 _importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
474 "moves.urllib_robotparser", "moves.urllib.robotparser")
475
476
477 class Module_six_moves_urllib(types.ModuleType):
478
479 """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
480 __path__ = [] # mark as package
481 parse = _importer._get_module("moves.urllib_parse")
482 error = _importer._get_module("moves.urllib_error")
483 request = _importer._get_module("moves.urllib_request")
484 response = _importer._get_module("moves.urllib_response")
485 robotparser = _importer._get_module("moves.urllib_robotparser")
486
487 def __dir__(self):
488 return ['parse', 'error', 'request', 'response', 'robotparser']
489
490 _importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
491 "moves.urllib")
492
493
494 def add_move(move):
495 """Add an item to six.moves."""
496 setattr(_MovedItems, move.name, move)
497
498
499 def remove_move(name):
500 """Remove item from six.moves."""
501 try:
502 delattr(_MovedItems, name)
503 except AttributeError:
504 try:
505 del moves.__dict__[name]
506 except KeyError:
507 raise AttributeError("no such move, %r" % (name,))
508
509
510 if PY3:
511 _meth_func = "__func__"
512 _meth_self = "__self__"
513
514 _func_closure = "__closure__"
515 _func_code = "__code__"
516 _func_defaults = "__defaults__"
517 _func_globals = "__globals__"
518 else:
519 _meth_func = "im_func"
520 _meth_self = "im_self"
521
522 _func_closure = "func_closure"
523 _func_code = "func_code"
524 _func_defaults = "func_defaults"
525 _func_globals = "func_globals"
526
527
528 try:
529 advance_iterator = next
530 except NameError:
531 def advance_iterator(it):
532 return it.next()
533 next = advance_iterator
534
535
536 try:
537 callable = callable
538 except NameError:
539 def callable(obj):
540 return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
541
542
543 if PY3:
544 def get_unbound_function(unbound):
545 return unbound
546
547 create_bound_method = types.MethodType
548
549 def create_unbound_method(func, cls):
550 return func
551
552 Iterator = object
553 else:
554 def get_unbound_function(unbound):
555 return unbound.im_func
556
557 def create_bound_method(func, obj):
558 return types.MethodType(func, obj, obj.__class__)
559
560 def create_unbound_method(func, cls):
561 return types.MethodType(func, None, cls)
562
563 class Iterator(object):
564
565 def next(self):
566 return type(self).__next__(self)
567
568 callable = callable
569 _add_doc(get_unbound_function,
570 """Get the function out of a possibly unbound function""")
571
572
573 get_method_function = operator.attrgetter(_meth_func)
574 get_method_self = operator.attrgetter(_meth_self)
575 get_function_closure = operator.attrgetter(_func_closure)
576 get_function_code = operator.attrgetter(_func_code)
577 get_function_defaults = operator.attrgetter(_func_defaults)
578 get_function_globals = operator.attrgetter(_func_globals)
579
580
581 if PY3:
582 def iterkeys(d, **kw):
583 return iter(d.keys(**kw))
584
585 def itervalues(d, **kw):
586 return iter(d.values(**kw))
587
588 def iteritems(d, **kw):
589 return iter(d.items(**kw))
590
591 def iterlists(d, **kw):
592 return iter(d.lists(**kw))
593
594 viewkeys = operator.methodcaller("keys")
595
596 viewvalues = operator.methodcaller("values")
597
598 viewitems = operator.methodcaller("items")
599 else:
600 def iterkeys(d, **kw):
601 return d.iterkeys(**kw)
602
603 def itervalues(d, **kw):
604 return d.itervalues(**kw)
605
606 def iteritems(d, **kw):
607 return d.iteritems(**kw)
608
609 def iterlists(d, **kw):
610 return d.iterlists(**kw)
611
612 viewkeys = operator.methodcaller("viewkeys")
613
614 viewvalues = operator.methodcaller("viewvalues")
615
616 viewitems = operator.methodcaller("viewitems")
617
618 _add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
619 _add_doc(itervalues, "Return an iterator over the values of a dictionary.")
620 _add_doc(iteritems,
621 "Return an iterator over the (key, value) pairs of a dictionary.")
622 _add_doc(iterlists,
623 "Return an iterator over the (key, [values]) pairs of a dictionary.")
624
625
626 if PY3:
627 def b(s):
628 return s.encode("latin-1")
629
630 def u(s):
631 return s
632 unichr = chr
633 import struct
634 int2byte = struct.Struct(">B").pack
635 del struct
636 byte2int = operator.itemgetter(0)
637 indexbytes = operator.getitem
638 iterbytes = iter
639 import io
640 StringIO = io.StringIO
641 BytesIO = io.BytesIO
642 del io
643 _assertCountEqual = "assertCountEqual"
644 if sys.version_info[1] <= 1:
645 _assertRaisesRegex = "assertRaisesRegexp"
646 _assertRegex = "assertRegexpMatches"
647 _assertNotRegex = "assertNotRegexpMatches"
648 else:
649 _assertRaisesRegex = "assertRaisesRegex"
650 _assertRegex = "assertRegex"
651 _assertNotRegex = "assertNotRegex"
652 else:
653 def b(s):
654 return s
655 # Workaround for standalone backslash
656
657 def u(s):
658 return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
659 unichr = unichr
660 int2byte = chr
661
662 def byte2int(bs):
663 return ord(bs[0])
664
665 def indexbytes(buf, i):
666 return ord(buf[i])
667 iterbytes = functools.partial(itertools.imap, ord)
668 import StringIO
669 StringIO = BytesIO = StringIO.StringIO
670 _assertCountEqual = "assertItemsEqual"
671 _assertRaisesRegex = "assertRaisesRegexp"
672 _assertRegex = "assertRegexpMatches"
673 _assertNotRegex = "assertNotRegexpMatches"
674 _add_doc(b, """Byte literal""")
675 _add_doc(u, """Text literal""")
676
677
678 def assertCountEqual(self, *args, **kwargs):
679 return getattr(self, _assertCountEqual)(*args, **kwargs)
680
681
682 def assertRaisesRegex(self, *args, **kwargs):
683 return getattr(self, _assertRaisesRegex)(*args, **kwargs)
684
685
686 def assertRegex(self, *args, **kwargs):
687 return getattr(self, _assertRegex)(*args, **kwargs)
688
689
690 def assertNotRegex(self, *args, **kwargs):
691 return getattr(self, _assertNotRegex)(*args, **kwargs)
692
693
694 if PY3:
695 exec_ = getattr(moves.builtins, "exec")
696
697 def reraise(tp, value, tb=None):
698 try:
699 if value is None:
700 value = tp()
701 if value.__traceback__ is not tb:
702 raise value.with_traceback(tb)
703 raise value
704 finally:
705 value = None
706 tb = None
707
708 else:
709 def exec_(_code_, _globs_=None, _locs_=None):
710 """Execute code in a namespace."""
711 if _globs_ is None:
712 frame = sys._getframe(1)
713 _globs_ = frame.f_globals
714 if _locs_ is None:
715 _locs_ = frame.f_locals
716 del frame
717 elif _locs_ is None:
718 _locs_ = _globs_
719 exec("""exec _code_ in _globs_, _locs_""")
720
721 exec_("""def reraise(tp, value, tb=None):
722 try:
723 raise tp, value, tb
724 finally:
725 tb = None
726 """)
727
728
729 if sys.version_info[:2] > (3,):
730 exec_("""def raise_from(value, from_value):
731 try:
732 raise value from from_value
733 finally:
734 value = None
735 """)
736 else:
737 def raise_from(value, from_value):
738 raise value
739
740
741 print_ = getattr(moves.builtins, "print", None)
742 if print_ is None:
743 def print_(*args, **kwargs):
744 """The new-style print function for Python 2.4 and 2.5."""
745 fp = kwargs.pop("file", sys.stdout)
746 if fp is None:
747 return
748
749 def write(data):
750 if not isinstance(data, basestring):
751 data = str(data)
752 # If the file has an encoding, encode unicode with it.
753 if (isinstance(fp, file) and
754 isinstance(data, unicode) and
755 fp.encoding is not None):
756 errors = getattr(fp, "errors", None)
757 if errors is None:
758 errors = "strict"
759 data = data.encode(fp.encoding, errors)
760 fp.write(data)
761 want_unicode = False
762 sep = kwargs.pop("sep", None)
763 if sep is not None:
764 if isinstance(sep, unicode):
765 want_unicode = True
766 elif not isinstance(sep, str):
767 raise TypeError("sep must be None or a string")
768 end = kwargs.pop("end", None)
769 if end is not None:
770 if isinstance(end, unicode):
771 want_unicode = True
772 elif not isinstance(end, str):
773 raise TypeError("end must be None or a string")
774 if kwargs:
775 raise TypeError("invalid keyword arguments to print()")
776 if not want_unicode:
777 for arg in args:
778 if isinstance(arg, unicode):
779 want_unicode = True
780 break
781 if want_unicode:
782 newline = unicode("\n")
783 space = unicode(" ")
784 else:
785 newline = "\n"
786 space = " "
787 if sep is None:
788 sep = space
789 if end is None:
790 end = newline
791 for i, arg in enumerate(args):
792 if i:
793 write(sep)
794 write(arg)
795 write(end)
796 if sys.version_info[:2] < (3, 3):
797 _print = print_
798
799 def print_(*args, **kwargs):
800 fp = kwargs.get("file", sys.stdout)
801 flush = kwargs.pop("flush", False)
802 _print(*args, **kwargs)
803 if flush and fp is not None:
804 fp.flush()
805
806 _add_doc(reraise, """Reraise an exception.""")
807
808 if sys.version_info[0:2] < (3, 4):
809 # This does exactly the same what the :func:`py3:functools.update_wrapper`
810 # function does on Python versions after 3.2. It sets the ``__wrapped__``
811 # attribute on ``wrapper`` object and it doesn't raise an error if any of
812 # the attributes mentioned in ``assigned`` and ``updated`` are missing on
813 # ``wrapped`` object.
814 def _update_wrapper(wrapper, wrapped,
815 assigned=functools.WRAPPER_ASSIGNMENTS,
816 updated=functools.WRAPPER_UPDATES):
817 for attr in assigned:
818 try:
819 value = getattr(wrapped, attr)
820 except AttributeError:
821 continue
822 else:
823 setattr(wrapper, attr, value)
824 for attr in updated:
825 getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
826 wrapper.__wrapped__ = wrapped
827 return wrapper
828 _update_wrapper.__doc__ = functools.update_wrapper.__doc__
829
830 def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
831 updated=functools.WRAPPER_UPDATES):
832 return functools.partial(_update_wrapper, wrapped=wrapped,
833 assigned=assigned, updated=updated)
834 wraps.__doc__ = functools.wraps.__doc__
835
836 else:
837 wraps = functools.wraps
838
839
840 def with_metaclass(meta, *bases):
841 """Create a base class with a metaclass."""
842 # This requires a bit of explanation: the basic idea is to make a dummy
843 # metaclass for one level of class instantiation that replaces itself with
844 # the actual metaclass.
845 class metaclass(type):
846
847 def __new__(cls, name, this_bases, d):
848 if sys.version_info[:2] >= (3, 7):
849 # This version introduced PEP 560 that requires a bit
850 # of extra care (we mimic what is done by __build_class__).
851 resolved_bases = types.resolve_bases(bases)
852 if resolved_bases is not bases:
853 d['__orig_bases__'] = bases
854 else:
855 resolved_bases = bases
856 return meta(name, resolved_bases, d)
857
858 @classmethod
859 def __prepare__(cls, name, this_bases):
860 return meta.__prepare__(name, bases)
861 return type.__new__(metaclass, 'temporary_class', (), {})
862
863
864 def add_metaclass(metaclass):
865 """Class decorator for creating a class with a metaclass."""
866 def wrapper(cls):
867 orig_vars = cls.__dict__.copy()
868 slots = orig_vars.get('__slots__')
869 if slots is not None:
870 if isinstance(slots, str):
871 slots = [slots]
872 for slots_var in slots:
873 orig_vars.pop(slots_var)
874 orig_vars.pop('__dict__', None)
875 orig_vars.pop('__weakref__', None)
876 if hasattr(cls, '__qualname__'):
877 orig_vars['__qualname__'] = cls.__qualname__
878 return metaclass(cls.__name__, cls.__bases__, orig_vars)
879 return wrapper
880
881
882 def ensure_binary(s, encoding='utf-8', errors='strict'):
883 """Coerce **s** to six.binary_type.
884
885 For Python 2:
886 - `unicode` -> encoded to `str`
887 - `str` -> `str`
888
889 For Python 3:
890 - `str` -> encoded to `bytes`
891 - `bytes` -> `bytes`
892 """
893 if isinstance(s, text_type):
894 return s.encode(encoding, errors)
895 elif isinstance(s, binary_type):
896 return s
897 else:
898 raise TypeError("not expecting type '%s'" % type(s))
899
900
901 def ensure_str(s, encoding='utf-8', errors='strict'):
902 """Coerce *s* to `str`.
903
904 For Python 2:
905 - `unicode` -> encoded to `str`
906 - `str` -> `str`
907
908 For Python 3:
909 - `str` -> `str`
910 - `bytes` -> decoded to `str`
911 """
912 if not isinstance(s, (text_type, binary_type)):
913 raise TypeError("not expecting type '%s'" % type(s))
914 if PY2 and isinstance(s, text_type):
915 s = s.encode(encoding, errors)
916 elif PY3 and isinstance(s, binary_type):
917 s = s.decode(encoding, errors)
918 return s
919
920
921 def ensure_text(s, encoding='utf-8', errors='strict'):
922 """Coerce *s* to six.text_type.
923
924 For Python 2:
925 - `unicode` -> `unicode`
926 - `str` -> `unicode`
927
928 For Python 3:
929 - `str` -> `str`
930 - `bytes` -> decoded to `str`
931 """
932 if isinstance(s, binary_type):
933 return s.decode(encoding, errors)
934 elif isinstance(s, text_type):
935 return s
936 else:
937 raise TypeError("not expecting type '%s'" % type(s))
938
939
940 def python_2_unicode_compatible(klass):
941 """
942 A class decorator that defines __unicode__ and __str__ methods under Python 2.
943 Under Python 3 it does nothing.
944
945 To support Python 2 and 3 with a single code base, define a __str__ method
946 returning text and apply this decorator to the class.
947 """
948 if PY2:
949 if '__str__' not in klass.__dict__:
950 raise ValueError("@python_2_unicode_compatible cannot be applied "
951 "to %s because it doesn't define __str__()." %
952 klass.__name__)
953 klass.__unicode__ = klass.__str__
954 klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
955 return klass
956
957
958 # Complete the moves implementation.
959 # This code is at the end of this module to speed up module loading.
960 # Turn this module into a package.
961 __path__ = [] # required for PEP 302 and PEP 451
962 __package__ = __name__ # see PEP 366 @ReservedAssignment
963 if globals().get("__spec__") is not None:
964 __spec__.submodule_search_locations = [] # PEP 451 @UndefinedVariable
965 # Remove other six meta path importers, since they cause problems. This can
966 # happen if six is removed from sys.modules and then reloaded. (Setuptools does
967 # this for some reason.)
968 if sys.meta_path:
969 for i, importer in enumerate(sys.meta_path):
970 # Here's some real nastiness: Another "instance" of the six module might
971 # be floating around. Therefore, we can't use isinstance() to check for
972 # the six meta path importer, since the other six instance will have
973 # inserted an importer with different class.
974 if (type(importer).__name__ == "_SixMetaPathImporter" and
975 importer.name == __name__):
976 del sys.meta_path[i]
977 break
978 del i, importer
979 # Finally, add the importer to the meta path import hook.
980 sys.meta_path.append(_importer)