Source code for pyramid._compat

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