import inspect
import platform
import sys
import types
WIN = platform.system() == 'Windows'
try: # pragma: no cover
import __pypy__
PYPY = True
except BaseException: # pragma: no cover
__pypy__ = None
PYPY = False
try:
import cPickle as pickle
except ImportError: # pragma: no cover
import pickle
try:
from functools import lru_cache
except ImportError:
from repoze.lru import lru_cache
# PY3 is left as bw-compat but PY2 should be used for most checks.
PY2 = sys.version_info[0] == 2
PY3 = sys.version_info[0] == 3
if PY2:
string_types = (basestring,)
integer_types = (int, long)
class_types = (type, types.ClassType)
text_type = unicode
binary_type = str
long = long
else:
string_types = (str,)
integer_types = (int,)
class_types = (type,)
text_type = str
binary_type = bytes
long = int
[docs]
def text_(s, encoding='latin-1', errors='strict'):
"""If ``s`` is an instance of ``binary_type``, return
``s.decode(encoding, errors)``, otherwise return ``s``"""
if isinstance(s, binary_type):
return s.decode(encoding, errors)
return s
[docs]
def bytes_(s, encoding='latin-1', errors='strict'):
"""If ``s`` is an instance of ``text_type``, return
``s.encode(encoding, errors)``, otherwise return ``s``"""
if isinstance(s, text_type):
return s.encode(encoding, errors)
return s
if PY2:
def ascii_native_(s):
if isinstance(s, text_type):
s = s.encode('ascii')
return str(s)
else:
[docs]
def ascii_native_(s):
if isinstance(s, text_type):
s = s.encode('ascii')
return str(s, 'ascii', 'strict')
ascii_native_.__doc__ = """
Python 3: If ``s`` is an instance of ``text_type``, return
``s.encode('ascii')``, otherwise return ``str(s, 'ascii', 'strict')``
Python 2: If ``s`` is an instance of ``text_type``, return
``s.encode('ascii')``, otherwise return ``str(s)``
"""
if PY2:
def native_(s, encoding='latin-1', errors='strict'):
"""If ``s`` is an instance of ``text_type``, return
``s.encode(encoding, errors)``, otherwise return ``str(s)``"""
if isinstance(s, text_type):
return s.encode(encoding, errors)
return str(s)
else:
[docs]
def native_(s, encoding='latin-1', errors='strict'):
"""If ``s`` is an instance of ``text_type``, return
``s``, otherwise return ``str(s, encoding, errors)``"""
if isinstance(s, text_type):
return s
return str(s, encoding, errors)
native_.__doc__ = """
Python 3: If ``s`` is an instance of ``text_type``, return ``s``, otherwise
return ``str(s, encoding, errors)``
Python 2: If ``s`` is an instance of ``text_type``, return
``s.encode(encoding, errors)``, otherwise return ``str(s)``
"""
if PY2:
import urlparse
from urllib import quote as url_quote
from urllib import quote_plus as url_quote_plus
from urllib import unquote as url_unquote
from urllib import urlencode as url_encode
from urllib2 import urlopen as url_open
def url_unquote_text(
v, encoding='utf-8', errors='replace'
): # pragma: no cover
v = url_unquote(v)
return v.decode(encoding, errors)
def url_unquote_native(
v, encoding='utf-8', errors='replace'
): # pragma: no cover
return native_(url_unquote_text(v, encoding, errors))
else:
from urllib import parse
urlparse = parse
from urllib.parse import quote as url_quote
from urllib.parse import quote_plus as url_quote_plus
from urllib.parse import unquote as url_unquote
from urllib.parse import urlencode as url_encode
from urllib.request import urlopen as url_open
url_unquote_text = url_unquote
url_unquote_native = url_unquote
if PY2: # pragma: no cover
def exec_(code, globs=None, locs=None):
"""Execute code in a namespace."""
if globs is None:
frame = sys._getframe(1)
globs = frame.f_globals
if locs is None:
locs = frame.f_locals
del frame
elif locs is None:
locs = globs
exec("""exec code in globs, locs""")
exec_(
"""def reraise(tp, value, tb=None):
raise tp, value, tb
"""
)
else: # pragma: no cover
import builtins
exec_ = getattr(builtins, "exec")
[docs]
def reraise(tp, value, tb=None):
if value is None:
value = tp
if value.__traceback__ is not tb:
raise value.with_traceback(tb)
raise value
del builtins
if PY2: # pragma: no cover
def iteritems_(d):
return d.iteritems()
def itervalues_(d):
return d.itervalues()
def iterkeys_(d):
return d.iterkeys()
else: # pragma: no cover
[docs]
def iteritems_(d):
return d.items()
[docs]
def itervalues_(d):
return d.values()
[docs]
def iterkeys_(d):
return d.keys()
if PY2:
map_ = map
else:
[docs]
def map_(*arg):
return list(map(*arg))
if PY2:
def is_nonstr_iter(v):
return hasattr(v, '__iter__')
else:
[docs]
def is_nonstr_iter(v):
if isinstance(v, str):
return False
return hasattr(v, '__iter__')
if PY2:
im_func = 'im_func'
im_self = 'im_self'
else:
im_func = '__func__'
im_self = '__self__'
try:
import configparser
except ImportError: # pragma: nocover (virtualenv pulls in configparser backport)
import ConfigParser as configparser
try:
from http.cookies import SimpleCookie
except ImportError:
from Cookie import SimpleCookie
if PY2:
from cgi import escape
else:
from html import escape
if PY2:
input_ = raw_input
else:
input_ = input
if PY2:
from io import BytesIO as NativeIO
else:
from io import StringIO as NativeIO
# "json" is not an API; it's here to support older pyramid_debugtoolbar
# versions which attempt to import it
import json
if PY2:
def decode_path_info(path):
return path.decode('utf-8')
else:
# see PEP 3333 for why we encode WSGI PATH_INFO to latin-1 before
# decoding it to utf-8
def decode_path_info(path):
return path.encode('latin-1').decode('utf-8')
if PY2:
from urlparse import unquote as unquote_to_bytes
def unquote_bytes_to_wsgi(bytestring):
return unquote_to_bytes(bytestring)
else:
# see PEP 3333 for why we decode the path to latin-1
from urllib.parse import unquote_to_bytes
def unquote_bytes_to_wsgi(bytestring):
return unquote_to_bytes(bytestring).decode('latin-1')
def is_bound_method(ob):
return inspect.ismethod(ob) and getattr(ob, im_self, None) is not None
# support annotations and keyword-only arguments in PY3
if PY2:
from inspect import getargspec
else:
from inspect import getfullargspec as getargspec
if PY2:
from itertools import izip_longest as zip_longest
else:
from itertools import zip_longest
def is_unbound_method(fn):
"""
This consistently verifies that the callable is bound to a
class.
"""
is_bound = is_bound_method(fn)
if not is_bound and inspect.isroutine(fn):
spec = getargspec(fn)
has_self = len(spec.args) > 0 and spec.args[0] == 'self'
if PY2 and inspect.ismethod(fn):
return True
elif inspect.isfunction(fn) and has_self:
return True
return False
