pip._vendor.distlib.compat Namespace Reference

Data Structures
class	BaseConfigurator
class	CertificateError
class	ChainMap
class	Container
class	ConvertingDict
class	ConvertingList
class	ConvertingTuple
class	OrderedDict
class	ZipExtFile
class	ZipFile

Functions
	quote (s)
	_dnsname_match (dn, hostname, max_wildcards=1)
	match_hostname (cert, hostname)
	which (cmd, mode=os.F_OK|os.X_OK, path=None)
	python_implementation ()
	callable (obj)
	fsencode (filename)
	fsdecode (filename)
	_get_normal_name (orig_enc)
	detect_encoding (readline)
	_recursive_repr (fillvalue='...')
	cache_from_source (path, debug_override=None)
	valid_ident (s)
	pop (self, key, default=None)

Variables
	ssl = None
	string_types = basestring,
	text_type = unicode
	raw_input = raw_input
	filter = filter
	ZipFile = BaseZipFile
	callable = callable
	fsencode = os.fsencode
	fsdecode = os.fsdecode
str	_fsencoding = sys.getfilesystemencoding() or 'utf-8'
str	_fserrors = 'strict'
	cookie_re = re.compile(r"coding[:=]\s*([-\w.]+)")
	unescape = HTMLParser().unescape
	IDENTIFIER = re.compile('^[a-z_][a-z0-9_]*$', re.I)

Function Documentation

_dnsname_match()

_dnsname_match (   dn,   hostname,   max_wildcards = 1  )

protected

Matching according to RFC 6125, section 6.4.3

http://tools.ietf.org/html/rfc6125#section-6.4.3

Definition at line 99 of file compat.py.

    def _dnsname_match(dn, hostname, max_wildcards=1):
        """Matching according to RFC 6125, section 6.4.3
 
        http://tools.ietf.org/html/rfc6125#section-6.4.3
        """
        pats = []
        if not dn:
            return False
 
        parts = dn.split('.')
        leftmost, remainder = parts[0], parts[1:]
 
        wildcards = leftmost.count('*')
        if wildcards > max_wildcards:
            # Issue #17980: avoid denials of service by refusing more
            # than one wildcard per fragment.  A survey of established
            # policy among SSL implementations showed it to be a
            # reasonable choice.
            raise CertificateError(
                "too many wildcards in certificate DNS name: " + repr(dn))
 
        # speed up common case w/o wildcards
        if not wildcards:
            return dn.lower() == hostname.lower()
 
        # RFC 6125, section 6.4.3, subitem 1.
        # The client SHOULD NOT attempt to match a presented identifier in which
        # the wildcard character comprises a label other than the left-most label.
        if leftmost == '*':
            # When '*' is a fragment by itself, it matches a non-empty dotless
            # fragment.
            pats.append('[^.]+')
        elif leftmost.startswith('xn--') or hostname.startswith('xn--'):
            # RFC 6125, section 6.4.3, subitem 3.
            # The client SHOULD NOT attempt to match a presented identifier
            # where the wildcard character is embedded within an A-label or
            # U-label of an internationalized domain name.
            pats.append(re.escape(leftmost))
        else:
            # Otherwise, '*' matches any dotless string, e.g. www*
            pats.append(re.escape(leftmost).replace(r'\*', '[^.]*'))
 
        # add the remaining fragments, ignore any wildcards
        for frag in remainder:
            pats.append(re.escape(frag))
 
        pat = re.compile(r'\A' + r'\.'.join(pats) + r'\Z', re.IGNORECASE)
        return pat.match(hostname)
 
 

Referenced by pip._vendor.distlib.compat.match_hostname().

Here is the caller graph for this function:

_get_normal_name()

_get_normal_name (   orig_enc )

protected

Imitates get_normal_name in tokenizer.c.

Definition at line 369 of file compat.py.

    def _get_normal_name(orig_enc):
        """Imitates get_normal_name in tokenizer.c."""
        # Only care about the first 12 characters.
        enc = orig_enc[:12].lower().replace("_", "-")
        if enc == "utf-8" or enc.startswith("utf-8-"):
            return "utf-8"
        if enc in ("latin-1", "iso-8859-1", "iso-latin-1") or \
           enc.startswith(("latin-1-", "iso-8859-1-", "iso-latin-1-")):
            return "iso-8859-1"
        return orig_enc
 

References i.

Referenced by pip._vendor.distlib.compat.detect_encoding().

Here is the caller graph for this function:

_recursive_repr()

_recursive_repr (   fillvalue = '...' )

protected

Decorator to make a repr function return fillvalue for a recursive
call

Definition at line 488 of file compat.py.

        def _recursive_repr(fillvalue='...'):
            '''
            Decorator to make a repr function return fillvalue for a recursive
            call
            '''
 
            def decorating_function(user_function):
                repr_running = set()
 
                def wrapper(self):
                    key = id(self), get_ident()
                    if key in repr_running:
                        return fillvalue
                    repr_running.add(key)
                    try:
                        result = user_function(self)
                    finally:
                        repr_running.discard(key)
                    return result
 
                # Can't use functools.wraps() here because of bootstrap issues
                wrapper.__module__ = getattr(user_function, '__module__')
                wrapper.__doc__ = getattr(user_function, '__doc__')
                wrapper.__name__ = getattr(user_function, '__name__')
                wrapper.__annotations__ = getattr(user_function, '__annotations__', {})
                return wrapper
 
            return decorating_function
 

References i.

cache_from_source()

cache_from_source	(		path,
			debug_override = None
	)

Definition at line 618 of file compat.py.

    def cache_from_source(path, debug_override=None):
        assert path.endswith('.py')
        if debug_override is None:
            debug_override = __debug__
        if debug_override:
            suffix = 'c'
        else:
            suffix = 'o'
        return path + suffix
 

References i.

callable()

callable

(

obj

)

Definition at line 323 of file compat.py.

    def callable(obj):
        return isinstance(obj, Callable)
 
 

References i.

detect_encoding()

detect_encoding

(

readline

)

The detect_encoding() function is used to detect the encoding that should
be used to decode a Python source file.  It requires one argument, readline,
in the same way as the tokenize() generator.

It will call readline a maximum of twice, and return the encoding used
(as a string) and a list of any lines (left as bytes) it has read in.

It detects the encoding from the presence of a utf-8 bom or an encoding
cookie as specified in pep-0263.  If both a bom and a cookie are present,
but disagree, a SyntaxError will be raised.  If the encoding cookie is an
invalid charset, raise a SyntaxError.  Note that if a utf-8 bom is found,
'utf-8-sig' is returned.

If no encoding is specified, then the default of 'utf-8' will be returned.

Definition at line 380 of file compat.py.

    def detect_encoding(readline):
        """
        The detect_encoding() function is used to detect the encoding that should
        be used to decode a Python source file.  It requires one argument, readline,
        in the same way as the tokenize() generator.
 
        It will call readline a maximum of twice, and return the encoding used
        (as a string) and a list of any lines (left as bytes) it has read in.
 
        It detects the encoding from the presence of a utf-8 bom or an encoding
        cookie as specified in pep-0263.  If both a bom and a cookie are present,
        but disagree, a SyntaxError will be raised.  If the encoding cookie is an
        invalid charset, raise a SyntaxError.  Note that if a utf-8 bom is found,
        'utf-8-sig' is returned.
 
        If no encoding is specified, then the default of 'utf-8' will be returned.
        """
        try:
            filename = readline.__self__.name
        except AttributeError:
            filename = None
        bom_found = False
        encoding = None
        default = 'utf-8'
        def read_or_stop():
            try:
                return readline()
            except StopIteration:
                return b''
 
        def find_cookie(line):
            try:
                # Decode as UTF-8. Either the line is an encoding declaration,
                # in which case it should be pure ASCII, or it must be UTF-8
                # per default encoding.
                line_string = line.decode('utf-8')
            except UnicodeDecodeError:
                msg = "invalid or missing encoding declaration"
                if filename is not None:
                    msg = '{} for {!r}'.format(msg, filename)
                raise SyntaxError(msg)
 
            matches = cookie_re.findall(line_string)
            if not matches:
                return None
            encoding = _get_normal_name(matches[0])
            try:
                codec = lookup(encoding)
            except LookupError:
                # This behaviour mimics the Python interpreter
                if filename is None:
                    msg = "unknown encoding: " + encoding
                else:
                    msg = "unknown encoding for {!r}: {}".format(filename,
                            encoding)
                raise SyntaxError(msg)
 
            if bom_found:
                if codec.name != 'utf-8':
                    # This behaviour mimics the Python interpreter
                    if filename is None:
                        msg = 'encoding problem: utf-8'
                    else:
                        msg = 'encoding problem for {!r}: utf-8'.format(filename)
                    raise SyntaxError(msg)
                encoding += '-sig'
            return encoding
 
        first = read_or_stop()
        if first.startswith(BOM_UTF8):
            bom_found = True
            first = first[3:]
            default = 'utf-8-sig'
        if not first:
            return default, []
 
        encoding = find_cookie(first)
        if encoding:
            return encoding, [first]
 
        second = read_or_stop()
        if not second:
            return default, [first]
 
        encoding = find_cookie(second)
        if encoding:
            return encoding, [first, second]
 
        return default, [first, second]
 
# For converting & <-> &amp; etc.

References pip._vendor.distlib.compat._get_normal_name(), and i.

Here is the call graph for this function:

fsdecode()

fsdecode

(

filename

)

Definition at line 352 of file compat.py.

    def fsdecode(filename):
        if isinstance(filename, text_type):
            return filename
        elif isinstance(filename, bytes):
            return filename.decode(_fsencoding, _fserrors)
        else:
            raise TypeError("expect bytes or str, not %s" %
                            type(filename).__name__)
 

References i.

fsencode()

fsencode

(

filename

)

Definition at line 343 of file compat.py.

    def fsencode(filename):
        if isinstance(filename, bytes):
            return filename
        elif isinstance(filename, text_type):
            return filename.encode(_fsencoding, _fserrors)
        else:
            raise TypeError("expect bytes or str, not %s" %
                            type(filename).__name__)
 

References i.

match_hostname()

match_hostname	(		cert,
			hostname
	)

Verify that *cert* (in decoded format as returned by
SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125
rules are followed, but IP addresses are not accepted for *hostname*.

CertificateError is raised on failure. On success, the function
returns nothing.

Definition at line 149 of file compat.py.

    def match_hostname(cert, hostname):
        """Verify that *cert* (in decoded format as returned by
        SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125
        rules are followed, but IP addresses are not accepted for *hostname*.
 
        CertificateError is raised on failure. On success, the function
        returns nothing.
        """
        if not cert:
            raise ValueError("empty or no certificate, match_hostname needs a "
                             "SSL socket or SSL context with either "
                             "CERT_OPTIONAL or CERT_REQUIRED")
        dnsnames = []
        san = cert.get('subjectAltName', ())
        for key, value in san:
            if key == 'DNS':
                if _dnsname_match(value, hostname):
                    return
                dnsnames.append(value)
        if not dnsnames:
            # The subject is only checked when there is no dNSName entry
            # in subjectAltName
            for sub in cert.get('subject', ()):
                for key, value in sub:
                    # XXX according to RFC 2818, the most specific Common Name
                    # must be used.
                    if key == 'commonName':
                        if _dnsname_match(value, hostname):
                            return
                        dnsnames.append(value)
        if len(dnsnames) > 1:
            raise CertificateError("hostname %r "
                "doesn't match either of %s"
                % (hostname, ', '.join(map(repr, dnsnames))))
        elif len(dnsnames) == 1:
            raise CertificateError("hostname %r "
                "doesn't match %r"
                % (hostname, dnsnames[0]))
        else:
            raise CertificateError("no appropriate commonName or "
                "subjectAltName fields were found")
 
 

References pip._vendor.distlib.compat._dnsname_match(), and i.

Here is the call graph for this function:

pop()

pop	(		self,
			key,
			default = None
	)

Definition at line 940 of file compat.py.

    def pop(self, key, default=None):
        value = dict.pop(self, key, default)
        result = self.configurator.convert(value)
        if value is not result:
            if type(result) in (ConvertingDict, ConvertingList,
                                ConvertingTuple):
                result.parent = self
                result.key = key
        return result
 

References i.

python_implementation()

python_implementation

(

)

Return a string identifying the Python implementation.

Definition at line 305 of file compat.py.

    def python_implementation():
        """Return a string identifying the Python implementation."""
        if 'PyPy' in sys.version:
            return 'PyPy'
        if os.name == 'java':
            return 'Jython'
        if sys.version.startswith('IronPython'):
            return 'IronPython'
        return 'CPython'
 

References i.

quote()

quote

(

s

)

Definition at line 29 of file compat.py.

    def quote(s):
        if isinstance(s, unicode):
            s = s.encode('utf-8')
        return _quote(s)
 

References i.

valid_ident()

valid_ident

(

s

)

Definition at line 897 of file compat.py.

    def valid_ident(s):
        m = IDENTIFIER.match(s)
        if not m:
            raise ValueError('Not a valid Python identifier: %r' % s)
        return True
 
 

References i.

which()

which	(		cmd,
			mode = os.F_OK | os.X_OK,
			path = None
	)

Given a command, mode, and a PATH string, return the path which
conforms to the given mode on the PATH, or None if there is no such
file.

`mode` defaults to os.F_OK | os.X_OK. `path` defaults to the result
of os.environ.get("PATH"), or can be overridden with a custom search
path.

Definition at line 207 of file compat.py.

    def which(cmd, mode=os.F_OK | os.X_OK, path=None):
        """Given a command, mode, and a PATH string, return the path which
        conforms to the given mode on the PATH, or None if there is no such
        file.
 
        `mode` defaults to os.F_OK | os.X_OK. `path` defaults to the result
        of os.environ.get("PATH"), or can be overridden with a custom search
        path.
 
        """
        # Check that a given file can be accessed with the correct mode.
        # Additionally check that `file` is not a directory, as on Windows
        # directories pass the os.access check.
        def _access_check(fn, mode):
            return (os.path.exists(fn) and os.access(fn, mode)
                    and not os.path.isdir(fn))
 
        # If we're given a path with a directory part, look it up directly rather
        # than referring to PATH directories. This includes checking relative to the
        # current directory, e.g. ./script
        if os.path.dirname(cmd):
            if _access_check(cmd, mode):
                return cmd
            return None
 
        if path is None:
            path = os.environ.get("PATH", os.defpath)
        if not path:
            return None
        path = path.split(os.pathsep)
 
        if sys.platform == "win32":
            # The current directory takes precedence on Windows.
            if not os.curdir in path:
                path.insert(0, os.curdir)
 
            # PATHEXT is necessary to check on Windows.
            pathext = os.environ.get("PATHEXT", "").split(os.pathsep)
            # See if the given file matches any of the expected path extensions.
            # This will allow us to short circuit when given "python.exe".
            # If it does match, only test that one, otherwise we have to try
            # others.
            if any(cmd.lower().endswith(ext.lower()) for ext in pathext):
                files = [cmd]
            else:
                files = [cmd + ext for ext in pathext]
        else:
            # On other platforms you don't have things like PATHEXT to tell you
            # what file suffixes are executable, so just pass on cmd as-is.
            files = [cmd]
 
        seen = set()
        for dir in path:
            normdir = os.path.normcase(dir)
            if not normdir in seen:
                seen.add(normdir)
                for thefile in files:
                    name = os.path.join(dir, thefile)
                    if _access_check(name, mode):
                        return name
        return None
 
 
# ZipFile is a context manager in 2.7, but not in 2.6
 

References i.

Variable Documentation

_fsencoding

str _fsencoding = sys.getfilesystemencoding() or 'utf-8'

protected

Definition at line 337 of file compat.py.

_fserrors

str _fserrors = 'strict'

protected

Definition at line 339 of file compat.py.

callable

callable = callable

Definition at line 319 of file compat.py.

Referenced by BaseConfigurator.configure_custom().

cookie_re

cookie_re = re.compile(r"coding[:=]\s*([-\w.]+)")

Definition at line 367 of file compat.py.

filter

filter = filter

Definition at line 89 of file compat.py.

fsdecode

fsdecode = os.fsdecode

Definition at line 329 of file compat.py.

fsencode

fsencode = os.fsencode

Definition at line 328 of file compat.py.

IDENTIFIER

IDENTIFIER = re.compile('^[a-z_][a-z0-9_]*$', re.I)

Definition at line 894 of file compat.py.

raw_input

raw_input = raw_input

Definition at line 46 of file compat.py.

ssl

ssl = None

Definition at line 16 of file compat.py.

string_types

string_types = basestring,

Definition at line 20 of file compat.py.

text_type

text_type = unicode

Definition at line 21 of file compat.py.

unescape

unescape = HTMLParser().unescape

Definition at line 476 of file compat.py.

ZipFile

ZipFile = BaseZipFile

Definition at line 275 of file compat.py.