| # -*- coding: utf-8 -*- |
| # flake8: noqa |
| import marshal |
| import sys |
| |
| PY2 = sys.version_info[0] == 2 |
| PYPY = hasattr(sys, "pypy_translation_info") |
| _identity = lambda x: x |
| |
| if not PY2: |
| unichr = chr |
| range_type = range |
| text_type = str |
| string_types = (str,) |
| integer_types = (int,) |
| |
| iterkeys = lambda d: iter(d.keys()) |
| itervalues = lambda d: iter(d.values()) |
| iteritems = lambda d: iter(d.items()) |
| |
| import pickle |
| from io import BytesIO, StringIO |
| |
| NativeStringIO = StringIO |
| |
| def reraise(tp, value, tb=None): |
| if value.__traceback__ is not tb: |
| raise value.with_traceback(tb) |
| raise value |
| |
| ifilter = filter |
| imap = map |
| izip = zip |
| intern = sys.intern |
| |
| implements_iterator = _identity |
| implements_to_string = _identity |
| encode_filename = _identity |
| |
| marshal_dump = marshal.dump |
| marshal_load = marshal.load |
| |
| else: |
| unichr = unichr |
| text_type = unicode |
| range_type = xrange |
| string_types = (str, unicode) |
| integer_types = (int, long) |
| |
| iterkeys = lambda d: d.iterkeys() |
| itervalues = lambda d: d.itervalues() |
| iteritems = lambda d: d.iteritems() |
| |
| import cPickle as pickle |
| from cStringIO import StringIO as BytesIO, StringIO |
| |
| NativeStringIO = BytesIO |
| |
| exec("def reraise(tp, value, tb=None):\n raise tp, value, tb") |
| |
| from itertools import imap, izip, ifilter |
| |
| intern = intern |
| |
| def implements_iterator(cls): |
| cls.next = cls.__next__ |
| del cls.__next__ |
| return cls |
| |
| def implements_to_string(cls): |
| cls.__unicode__ = cls.__str__ |
| cls.__str__ = lambda x: x.__unicode__().encode("utf-8") |
| return cls |
| |
| def encode_filename(filename): |
| if isinstance(filename, unicode): |
| return filename.encode("utf-8") |
| return filename |
| |
| def marshal_dump(code, f): |
| if isinstance(f, file): |
| marshal.dump(code, f) |
| else: |
| f.write(marshal.dumps(code)) |
| |
| def marshal_load(f): |
| if isinstance(f, file): |
| return marshal.load(f) |
| return marshal.loads(f.read()) |
| |
| |
| def with_metaclass(meta, *bases): |
| """Create a base class with a metaclass.""" |
| # This requires a bit of explanation: the basic idea is to make a |
| # dummy metaclass for one level of class instantiation that replaces |
| # itself with the actual metaclass. |
| class metaclass(type): |
| def __new__(cls, name, this_bases, d): |
| return meta(name, bases, d) |
| |
| return type.__new__(metaclass, "temporary_class", (), {}) |
| |
| |
| try: |
| from urllib.parse import quote_from_bytes as url_quote |
| except ImportError: |
| from urllib import quote as url_quote |
| |
| |
| try: |
| from collections import abc |
| except ImportError: |
| import collections as abc |
| |
| |
| try: |
| from os import fspath |
| except ImportError: |
| try: |
| from pathlib import PurePath |
| except ImportError: |
| PurePath = None |
| |
| def fspath(path): |
| if hasattr(path, "__fspath__"): |
| return path.__fspath__() |
| |
| # Python 3.5 doesn't have __fspath__ yet, use str. |
| if PurePath is not None and isinstance(path, PurePath): |
| return str(path) |
| |
| return path |