pip._vendor.distlib.util Namespace Reference

Data Structures
class	Cache
class	cached_property
class	Configurator
class	CSVBase
class	CSVReader
class	CSVWriter
class	EventMixin
class	ExportEntry
class	FileOperator
class	HTTPSConnection
class	HTTPSHandler
class	HTTPSOnlyHandler
class	Progress
class	PyPIRCFile
class	SafeTransport
class	Sequencer
class	ServerProxy
class	SubprocessMixin
class	Transport

Functions
	parse_marker (marker_string)
	parse_requirement (req)
	get_resources_dests (resources_root, rules)
	in_venv ()
	get_executable ()
	proceed (prompt, allowed_chars, error_prompt=None, default=None)
	extract_by_key (d, keys)
	read_exports (stream)
	write_exports (exports, stream)
	tempdir ()
	chdir (d)
	socket_timeout (seconds=15)
	convert_path (pathname)
	resolve (module_name, dotted_path)
	get_export_entry (specification)
	get_cache_base (suffix=None)
	path_to_cache_dir (path)
	ensure_slash (s)
	parse_credentials (netloc)
	get_process_umask ()
	is_string_sequence (seq)
	split_filename (filename, project_name=None)
	parse_name_and_version (p)
	get_extras (requested, available)
	_get_external_data (url)
	get_project_data (name)
	get_package_data (name, version)
	unarchive (archive_filename, dest_dir, format=None, check=True)
	zip_dir (directory)
	iglob (path_glob)
	_iglob (path_glob)
	_csv_open (fn, mode, **kwargs)
	normalize_name (name)
	_load_pypirc (index)
	_store_pypirc (index)
	get_host_platform ()
	get_platform ()

Variables
	ssl = None
	logger = logging.getLogger(__name__)
	IDENTIFIER = re.compile(r'^([\w\.-]+)\s*')
	VERSION_IDENTIFIER = re.compile(r'^([\w\.*+-]+)\s*')
	COMPARE_OP = re.compile(r'^(<=?|>=?|={2,3}|[~!]=)\s*')
	MARKER_OP = re.compile(r'^((<=?)|(>=?)|={2,3}|[~!]=|in|not\s+in)\s*')
	OR = re.compile(r'^or\b\s*')
	AND = re.compile(r'^and\b\s*')
	NON_SPACE = re.compile(r'(\S+)\s*')
	STRING_CHUNK = re.compile(r'([\s\w\.{}()*+#:;,/?!~`@$%^&=|<>\[\]-]+)')
	ENTRY_RE = re.compile(, re.VERBOSE)
	PROJECT_NAME_AND_VERSION
	PYTHON_VERSION = re.compile(r'-py(\d\.?\d?)')
	NAME_VERSION_RE
str	_external_data_base_url = 'https://www.red-dove.com/pypi/projects/'
tuple	ARCHIVE_EXTENSIONS
tuple	UNITS = ('', 'K', 'M', 'G','T','P')
	RICH_GLOB = re.compile(r'\{([^}]*)\}')
	_CHECK_RECURSIVE_GLOB = re.compile(r'[^/\\,{]\*\*|\*\*[^/\\,}]')
	_CHECK_MISMATCH_SET = re.compile(r'^[^{]*\}|\{[^}]*$')
dict	_TARGET_TO_PLAT

Function Documentation

_csv_open()

_csv_open (   fn,   mode, **  kwargs  )

protected

Definition at line 1558 of file util.py.

def _csv_open(fn, mode, **kwargs):
    if sys.version_info[0] < 3:
        mode += 'b'
    else:
        kwargs['newline'] = ''
        # Python 3 determines encoding from locale. Force 'utf-8'
        # file encoding to match other forced utf-8 encoding
        kwargs['encoding'] = 'utf-8'
    return open(fn, mode, **kwargs)
 
 

References i.

_get_external_data()

_get_external_data (   url )

protected

Definition at line 913 of file util.py.

def _get_external_data(url):
    result = {}
    try:
        # urlopen might fail if it runs into redirections,
        # because of Python issue #13696. Fixed in locators
        # using a custom redirect handler.
        resp = urlopen(url)
        headers = resp.info()
        ct = headers.get('Content-Type')
        if not ct.startswith('application/json'):
            logger.debug('Unexpected response for JSON request: %s', ct)
        else:
            reader = codecs.getreader('utf-8')(resp)
            #data = reader.read().decode('utf-8')
            #result = json.loads(data)
            result = json.load(reader)
    except Exception as e:
        logger.exception('Failed to get external data for %s: %s', url, e)
    return result
 

References i.

Referenced by pip._vendor.distlib.util.get_package_data(), and pip._vendor.distlib.util.get_project_data().

Here is the caller graph for this function:

_iglob()

_iglob (   path_glob )

protected

Definition at line 1388 of file util.py.

def _iglob(path_glob):
    rich_path_glob = RICH_GLOB.split(path_glob, 1)
    if len(rich_path_glob) > 1:
        assert len(rich_path_glob) == 3, rich_path_glob
        prefix, set, suffix = rich_path_glob
        for item in set.split(','):
            for path in _iglob(''.join((prefix, item, suffix))):
                yield path
    else:
        if '**' not in path_glob:
            for item in std_iglob(path_glob):
                yield item
        else:
            prefix, radical = path_glob.split('**', 1)
            if prefix == '':
                prefix = '.'
            if radical == '':
                radical = '*'
            else:
                # we support both
                radical = radical.lstrip('/')
                radical = radical.lstrip('\\')
            for path, dir, files in os.walk(prefix):
                path = os.path.normpath(path)
                for fn in _iglob(os.path.join(path, radical)):
                    yield fn
 

References pip._vendor.distlib.util._iglob(), and i.

Referenced by pip._vendor.distlib.util._iglob(), and pip._vendor.distlib.util.iglob().

Here is the call graph for this function:

Here is the caller graph for this function:

_load_pypirc()

_load_pypirc (   index )

protected

Read the PyPI access configuration as supported by distutils.

Definition at line 1824 of file util.py.

def _load_pypirc(index):
    """
    Read the PyPI access configuration as supported by distutils.
    """
    return PyPIRCFile(url=index.url).read()
 

References i.

_store_pypirc()

_store_pypirc (   index )

protected

Definition at line 1830 of file util.py.

def _store_pypirc(index):
    PyPIRCFile().update(index.username, index.password)
 
#
# get_platform()/get_host_platform() copied from Python 3.10.a0 source, with some minor
# tweaks
#
 

References i.

chdir()

chdir

(

d

)

Definition at line 424 of file util.py.

def chdir(d):
    cwd = os.getcwd()
    try:
        os.chdir(d)
        yield
    finally:
        os.chdir(cwd)
 
 
@contextlib.contextmanager

References i.

convert_path()

convert_path

(

pathname

)

Return 'pathname' as a name that will work on the native filesystem.

The path is split on '/' and put back together again using the current
directory separator.  Needed because filenames in the setup script are
always supplied in Unix style, and have to be converted to the local
convention before we can actually use them in the filesystem.  Raises
ValueError on non-Unix-ish systems if 'pathname' either starts or
ends with a slash.

Definition at line 457 of file util.py.

def convert_path(pathname):
    """Return 'pathname' as a name that will work on the native filesystem.
 
    The path is split on '/' and put back together again using the current
    directory separator.  Needed because filenames in the setup script are
    always supplied in Unix style, and have to be converted to the local
    convention before we can actually use them in the filesystem.  Raises
    ValueError on non-Unix-ish systems if 'pathname' either starts or
    ends with a slash.
    """
    if os.sep == '/':
        return pathname
    if not pathname:
        return pathname
    if pathname[0] == '/':
        raise ValueError("path '%s' cannot be absolute" % pathname)
    if pathname[-1] == '/':
        raise ValueError("path '%s' cannot end with '/'" % pathname)
 
    paths = pathname.split('/')
    while os.curdir in paths:
        paths.remove(os.curdir)
    if not paths:
        return os.curdir
    return os.path.join(*paths)
 
 

References i.

ensure_slash()

ensure_slash

(

s

)

Definition at line 804 of file util.py.

def ensure_slash(s):
    if not s.endswith('/'):
        return s + '/'
    return s
 
 

References i.

extract_by_key()

extract_by_key	(		d,
			keys
	)

Definition at line 340 of file util.py.

def extract_by_key(d, keys):
    if isinstance(keys, string_types):
        keys = keys.split()
    result = {}
    for key in keys:
        if key in d:
            result[key] = d[key]
    return result
 

References i.

get_cache_base()

get_cache_base

(

suffix = None

)

Return the default base location for distlib caches. If the directory does
not exist, it is created. Use the suffix provided for the base directory,
and default to '.distlib' if it isn't provided.

On Windows, if LOCALAPPDATA is defined in the environment, then it is
assumed to be a directory, and will be the parent directory of the result.
On POSIX, and on Windows if LOCALAPPDATA is not defined, the user's home
directory - using os.expanduser('~') - will be the parent directory of
the result.

The result is just the directory '.distlib' in the parent directory as
determined above, or with the name specified with ``suffix``.

Definition at line 746 of file util.py.

def get_cache_base(suffix=None):
    """
    Return the default base location for distlib caches. If the directory does
    not exist, it is created. Use the suffix provided for the base directory,
    and default to '.distlib' if it isn't provided.
 
    On Windows, if LOCALAPPDATA is defined in the environment, then it is
    assumed to be a directory, and will be the parent directory of the result.
    On POSIX, and on Windows if LOCALAPPDATA is not defined, the user's home
    directory - using os.expanduser('~') - will be the parent directory of
    the result.
 
    The result is just the directory '.distlib' in the parent directory as
    determined above, or with the name specified with ``suffix``.
    """
    if suffix is None:
        suffix = '.distlib'
    if os.name == 'nt' and 'LOCALAPPDATA' in os.environ:
        result = os.path.expandvars('$localappdata')
    else:
        # Assume posix, or old Windows
        result = os.path.expanduser('~')
    # we use 'isdir' instead of 'exists', because we want to
    # fail if there's a file with that name
    if os.path.isdir(result):
        usable = os.access(result, os.W_OK)
        if not usable:
            logger.warning('Directory exists but is not writable: %s', result)
    else:
        try:
            os.makedirs(result)
            usable = True
        except OSError:
            logger.warning('Unable to create %s', result, exc_info=True)
            usable = False
    if not usable:
        result = tempfile.mkdtemp()
        logger.warning('Default location unusable, using %s', result)
    return os.path.join(result, suffix)
 
 

References i.

get_executable()

get_executable

(

)

Definition at line 306 of file util.py.

def get_executable():
# The __PYVENV_LAUNCHER__ dance is apparently no longer needed, as
# changes to the stub launcher mean that sys.executable always points
# to the stub on OS X
#    if sys.platform == 'darwin' and ('__PYVENV_LAUNCHER__'
#                                     in os.environ):
#        result =  os.environ['__PYVENV_LAUNCHER__']
#    else:
#        result = sys.executable
#    return result
    # Avoid normcasing: see issue #143
    # result = os.path.normcase(sys.executable)
    result = sys.executable
    if not isinstance(result, text_type):
        result = fsdecode(result)
    return result
 
 

References i.

get_export_entry()

get_export_entry

(

specification

)

Definition at line 715 of file util.py.

def get_export_entry(specification):
    m = ENTRY_RE.search(specification)
    if not m:
        result = None
        if '[' in specification or ']' in specification:
            raise DistlibException("Invalid specification "
                                   "'%s'" % specification)
    else:
        d = m.groupdict()
        name = d['name']
        path = d['callable']
        colons = path.count(':')
        if colons == 0:
            prefix, suffix = path, None
        else:
            if colons != 1:
                raise DistlibException("Invalid specification "
                                       "'%s'" % specification)
            prefix, suffix = path.split(':')
        flags = d['flags']
        if flags is None:
            if '[' in specification or ']' in specification:
                raise DistlibException("Invalid specification "
                                       "'%s'" % specification)
            flags = []
        else:
            flags = [f.strip() for f in flags.split(',')]
        result = ExportEntry(name, prefix, suffix, flags)
    return result
 
 

References i.

get_extras()

get_extras	(		requested,
			available
	)

Definition at line 888 of file util.py.

def get_extras(requested, available):
    result = set()
    requested = set(requested or [])
    available = set(available or [])
    if '*' in requested:
        requested.remove('*')
        result |= available
    for r in requested:
        if r == '-':
            result.add(r)
        elif r.startswith('-'):
            unwanted = r[1:]
            if unwanted not in available:
                logger.warning('undeclared extra: %s' % unwanted)
            if unwanted in result:
                result.remove(unwanted)
        else:
            if r not in available:
                logger.warning('undeclared extra: %s' % r)
            result.add(r)
    return result
#
# Extended metadata functionality
#
 

References i.

get_host_platform()

get_host_platform

(

)

Return a string that identifies the current platform.  This is used mainly to
distinguish platform-specific build directories and platform-specific built
distributions.  Typically includes the OS name and version and the
architecture (as supplied by 'os.uname()'), although the exact information
included depends on the OS; eg. on Linux, the kernel version isn't
particularly important.

Examples of returned values:
   linux-i586
   linux-alpha (?)
   solaris-2.6-sun4u

Windows will return one of:
   win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
   win32 (all others - specifically, sys.platform is returned)

For other non-POSIX platforms, currently just returns 'sys.platform'.

Definition at line 1838 of file util.py.

def get_host_platform():
    """Return a string that identifies the current platform.  This is used mainly to
    distinguish platform-specific build directories and platform-specific built
    distributions.  Typically includes the OS name and version and the
    architecture (as supplied by 'os.uname()'), although the exact information
    included depends on the OS; eg. on Linux, the kernel version isn't
    particularly important.
 
    Examples of returned values:
       linux-i586
       linux-alpha (?)
       solaris-2.6-sun4u
 
    Windows will return one of:
       win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
       win32 (all others - specifically, sys.platform is returned)
 
    For other non-POSIX platforms, currently just returns 'sys.platform'.
 
    """
    if os.name == 'nt':
        if 'amd64' in sys.version.lower():
            return 'win-amd64'
        if '(arm)' in sys.version.lower():
            return 'win-arm32'
        if '(arm64)' in sys.version.lower():
            return 'win-arm64'
        return sys.platform
 
    # Set for cross builds explicitly
    if "_PYTHON_HOST_PLATFORM" in os.environ:
        return os.environ["_PYTHON_HOST_PLATFORM"]
 
    if os.name != 'posix' or not hasattr(os, 'uname'):
        # XXX what about the architecture? NT is Intel or Alpha,
        # Mac OS is M68k or PPC, etc.
        return sys.platform
 
    # Try to distinguish various flavours of Unix
 
    (osname, host, release, version, machine) = os.uname()
 
    # Convert the OS name to lowercase, remove '/' characters, and translate
    # spaces (for "Power Macintosh")
    osname = osname.lower().replace('/', '')
    machine = machine.replace(' ', '_').replace('/', '-')
 
    if osname[:5] == 'linux':
        # At least on Linux/Intel, 'machine' is the processor --
        # i386, etc.
        # XXX what about Alpha, SPARC, etc?
        return  "%s-%s" % (osname, machine)
 
    elif osname[:5] == 'sunos':
        if release[0] >= '5':           # SunOS 5 == Solaris 2
            osname = 'solaris'
            release = '%d.%s' % (int(release[0]) - 3, release[2:])
            # We can't use 'platform.architecture()[0]' because a
            # bootstrap problem. We use a dict to get an error
            # if some suspicious happens.
            bitness = {2147483647:'32bit', 9223372036854775807:'64bit'}
            machine += '.%s' % bitness[sys.maxsize]
        # fall through to standard osname-release-machine representation
    elif osname[:3] == 'aix':
        from _aix_support import aix_platform
        return aix_platform()
    elif osname[:6] == 'cygwin':
        osname = 'cygwin'
        rel_re = re.compile (r'[\d.]+', re.ASCII)
        m = rel_re.match(release)
        if m:
            release = m.group()
    elif osname[:6] == 'darwin':
        import _osx_support, distutils.sysconfig
        osname, release, machine = _osx_support.get_platform_osx(
                                        distutils.sysconfig.get_config_vars(),
                                        osname, release, machine)
 
    return '%s-%s-%s' % (osname, release, machine)
 
 

References i.

Referenced by pip._vendor.distlib.util.get_platform().

Here is the caller graph for this function:

get_package_data()

get_package_data	(		name,
			version
	)

Definition at line 941 of file util.py.

def get_package_data(name, version):
    url = '%s/%s/package-%s.json' % (name[0].upper(), name, version)
    url = urljoin(_external_data_base_url, url)
    return _get_external_data(url)
 
 

References pip._vendor.distlib.util._get_external_data(), and i.

Here is the call graph for this function:

get_platform()

get_platform

(

)

Definition at line 1926 of file util.py.

def get_platform():
    if os.name != 'nt':
        return get_host_platform()
    cross_compilation_target = os.environ.get('VSCMD_ARG_TGT_ARCH')
    if cross_compilation_target not in _TARGET_TO_PLAT:
        return get_host_platform()
    return _TARGET_TO_PLAT[cross_compilation_target]

References pip._vendor.distlib.util.get_host_platform(), and i.

Here is the call graph for this function:

get_process_umask()

get_process_umask

(

)

Definition at line 825 of file util.py.

def get_process_umask():
    result = os.umask(0o22)
    os.umask(result)
    return result
 

References i.

get_project_data()

get_project_data

(

name

)

Definition at line 935 of file util.py.

def get_project_data(name):
    url = '%s/%s/project.json' % (name[0].upper(), name)
    url = urljoin(_external_data_base_url, url)
    result = _get_external_data(url)
    return result
 

References pip._vendor.distlib.util._get_external_data(), and i.

Here is the call graph for this function:

get_resources_dests()

get_resources_dests	(		resources_root,
			rules
	)

Find destinations for resources files

Definition at line 270 of file util.py.

def get_resources_dests(resources_root, rules):
    """Find destinations for resources files"""
 
    def get_rel_path(root, path):
        # normalizes and returns a lstripped-/-separated path
        root = root.replace(os.path.sep, '/')
        path = path.replace(os.path.sep, '/')
        assert path.startswith(root)
        return path[len(root):].lstrip('/')
 
    destinations = {}
    for base, suffix, dest in rules:
        prefix = os.path.join(resources_root, base)
        for abs_base in iglob(prefix):
            abs_glob = os.path.join(abs_base, suffix)
            for abs_path in iglob(abs_glob):
                resource_file = get_rel_path(resources_root, abs_path)
                if dest is None:  # remove the entry if it was here
                    destinations.pop(resource_file, None)
                else:
                    rel_path = get_rel_path(abs_base, abs_path)
                    rel_dest = dest.replace(os.path.sep, '/').rstrip('/')
                    destinations[resource_file] = rel_dest + '/' + rel_path
    return destinations
 
 

References i.

iglob()

iglob

(

path_glob

)

Extended globbing function that supports ** and {opt1,opt2,opt3}.

Definition at line 1377 of file util.py.

def iglob(path_glob):
    """Extended globbing function that supports ** and {opt1,opt2,opt3}."""
    if _CHECK_RECURSIVE_GLOB.search(path_glob):
        msg = """invalid glob %r: recursive glob "**" must be used alone"""
        raise ValueError(msg % path_glob)
    if _CHECK_MISMATCH_SET.search(path_glob):
        msg = """invalid glob %r: mismatching set marker '{' or '}'"""
        raise ValueError(msg % path_glob)
    return _iglob(path_glob)
 
 

References pip._vendor.distlib.util._iglob(), and i.

Here is the call graph for this function:

in_venv()

in_venv

(

)

Definition at line 296 of file util.py.

def in_venv():
    if hasattr(sys, 'real_prefix'):
        # virtualenv venvs
        result = True
    else:
        # PEP 405 venvs
        result = sys.prefix != getattr(sys, 'base_prefix', sys.prefix)
    return result
 
 

References i.

is_string_sequence()

is_string_sequence

(

seq

)

Definition at line 830 of file util.py.

def is_string_sequence(seq):
    result = True
    i = None
    for i, s in enumerate(seq):
        if not isinstance(s, string_types):
            result = False
            break
    assert i is not None
    return result
 

References i.

normalize_name()

normalize_name

(

name

)

Normalize a python package name a la PEP 503

Definition at line 1728 of file util.py.

def normalize_name(name):
    """Normalize a python package name a la PEP 503"""
    # https://www.python.org/dev/peps/pep-0503/#normalized-names
    return re.sub('[-_.]+', '-', name).lower()
 
# def _get_pypirc_command():
    # """
    # Get the distutils command for interacting with PyPI configurations.
    # :return: the command.
    # """
    # from distutils.core import Distribution
    # from distutils.config import PyPIRCCommand
    # d = Distribution()
    # return PyPIRCCommand(d)
 

References i.

parse_credentials()

parse_credentials

(

netloc

)

Definition at line 810 of file util.py.

def parse_credentials(netloc):
    username = password = None
    if '@' in netloc:
        prefix, netloc = netloc.rsplit('@', 1)
        if ':' not in prefix:
            username = prefix
        else:
            username, password = prefix.split(':', 1)
    if username:
        username = unquote(username)
    if password:
        password = unquote(password)
    return username, password, netloc
 
 

References i.

parse_marker()

parse_marker

(

marker_string

)

Parse a marker string and return a dictionary containing a marker expression.

The dictionary will contain keys "op", "lhs" and "rhs" for non-terminals in
the expression grammar, or strings. A string contained in quotes is to be
interpreted as a literal string, and a string not contained in quotes is a
variable (such as os_name).

Definition at line 56 of file util.py.

def parse_marker(marker_string):
    """
    Parse a marker string and return a dictionary containing a marker expression.
 
    The dictionary will contain keys "op", "lhs" and "rhs" for non-terminals in
    the expression grammar, or strings. A string contained in quotes is to be
    interpreted as a literal string, and a string not contained in quotes is a
    variable (such as os_name).
    """
    def marker_var(remaining):
        # either identifier, or literal string
        m = IDENTIFIER.match(remaining)
        if m:
            result = m.groups()[0]
            remaining = remaining[m.end():]
        elif not remaining:
            raise SyntaxError('unexpected end of input')
        else:
            q = remaining[0]
            if q not in '\'"':
                raise SyntaxError('invalid expression: %s' % remaining)
            oq = '\'"'.replace(q, '')
            remaining = remaining[1:]
            parts = [q]
            while remaining:
                # either a string chunk, or oq, or q to terminate
                if remaining[0] == q:
                    break
                elif remaining[0] == oq:
                    parts.append(oq)
                    remaining = remaining[1:]
                else:
                    m = STRING_CHUNK.match(remaining)
                    if not m:
                        raise SyntaxError('error in string literal: %s' % remaining)
                    parts.append(m.groups()[0])
                    remaining = remaining[m.end():]
            else:
                s = ''.join(parts)
                raise SyntaxError('unterminated string: %s' % s)
            parts.append(q)
            result = ''.join(parts)
            remaining = remaining[1:].lstrip() # skip past closing quote
        return result, remaining
 
    def marker_expr(remaining):
        if remaining and remaining[0] == '(':
            result, remaining = marker(remaining[1:].lstrip())
            if remaining[0] != ')':
                raise SyntaxError('unterminated parenthesis: %s' % remaining)
            remaining = remaining[1:].lstrip()
        else:
            lhs, remaining = marker_var(remaining)
            while remaining:
                m = MARKER_OP.match(remaining)
                if not m:
                    break
                op = m.groups()[0]
                remaining = remaining[m.end():]
                rhs, remaining = marker_var(remaining)
                lhs = {'op': op, 'lhs': lhs, 'rhs': rhs}
            result = lhs
        return result, remaining
 
    def marker_and(remaining):
        lhs, remaining = marker_expr(remaining)
        while remaining:
            m = AND.match(remaining)
            if not m:
                break
            remaining = remaining[m.end():]
            rhs, remaining = marker_expr(remaining)
            lhs = {'op': 'and', 'lhs': lhs, 'rhs': rhs}
        return lhs, remaining
 
    def marker(remaining):
        lhs, remaining = marker_and(remaining)
        while remaining:
            m = OR.match(remaining)
            if not m:
                break
            remaining = remaining[m.end():]
            rhs, remaining = marker_and(remaining)
            lhs = {'op': 'or', 'lhs': lhs, 'rhs': rhs}
        return lhs, remaining
 
    return marker(marker_string)
 
 

References i.

parse_name_and_version()

parse_name_and_version

(

p

)

A utility method used to get name and version from a string.

From e.g. a Provides-Dist value.

:param p: A value in a form 'foo (1.0)'
:return: The name and version as a tuple.

Definition at line 873 of file util.py.

def parse_name_and_version(p):
    """
    A utility method used to get name and version from a string.
 
    From e.g. a Provides-Dist value.
 
    :param p: A value in a form 'foo (1.0)'
    :return: The name and version as a tuple.
    """
    m = NAME_VERSION_RE.match(p)
    if not m:
        raise DistlibException('Ill-formed name/version string: \'%s\'' % p)
    d = m.groupdict()
    return d['name'].strip().lower(), d['ver']
 

References i.

parse_requirement()

parse_requirement

(

req

)

Parse a requirement passed in as a string. Return a Container
whose attributes contain the various parts of the requirement.

Definition at line 145 of file util.py.

def parse_requirement(req):
    """
    Parse a requirement passed in as a string. Return a Container
    whose attributes contain the various parts of the requirement.
    """
    remaining = req.strip()
    if not remaining or remaining.startswith('#'):
        return None
    m = IDENTIFIER.match(remaining)
    if not m:
        raise SyntaxError('name expected: %s' % remaining)
    distname = m.groups()[0]
    remaining = remaining[m.end():]
    extras = mark_expr = versions = uri = None
    if remaining and remaining[0] == '[':
        i = remaining.find(']', 1)
        if i < 0:
            raise SyntaxError('unterminated extra: %s' % remaining)
        s = remaining[1:i]
        remaining = remaining[i + 1:].lstrip()
        extras = []
        while s:
            m = IDENTIFIER.match(s)
            if not m:
                raise SyntaxError('malformed extra: %s' % s)
            extras.append(m.groups()[0])
            s = s[m.end():]
            if not s:
                break
            if s[0] != ',':
                raise SyntaxError('comma expected in extras: %s' % s)
            s = s[1:].lstrip()
        if not extras:
            extras = None
    if remaining:
        if remaining[0] == '@':
            # it's a URI
            remaining = remaining[1:].lstrip()
            m = NON_SPACE.match(remaining)
            if not m:
                raise SyntaxError('invalid URI: %s' % remaining)
            uri = m.groups()[0]
            t = urlparse(uri)
            # there are issues with Python and URL parsing, so this test
            # is a bit crude. See bpo-20271, bpo-23505. Python doesn't
            # always parse invalid URLs correctly - it should raise
            # exceptions for malformed URLs
            if not (t.scheme and t.netloc):
                raise SyntaxError('Invalid URL: %s' % uri)
            remaining = remaining[m.end():].lstrip()
        else:
 
            def get_versions(ver_remaining):
                """
                Return a list of operator, version tuples if any are
                specified, else None.
                """
                m = COMPARE_OP.match(ver_remaining)
                versions = None
                if m:
                    versions = []
                    while True:
                        op = m.groups()[0]
                        ver_remaining = ver_remaining[m.end():]
                        m = VERSION_IDENTIFIER.match(ver_remaining)
                        if not m:
                            raise SyntaxError('invalid version: %s' % ver_remaining)
                        v = m.groups()[0]
                        versions.append((op, v))
                        ver_remaining = ver_remaining[m.end():]
                        if not ver_remaining or ver_remaining[0] != ',':
                            break
                        ver_remaining = ver_remaining[1:].lstrip()
                        # Some packages have a trailing comma which would break things
                        # See issue #148
                        if not ver_remaining:
                            break
                        m = COMPARE_OP.match(ver_remaining)
                        if not m:
                            raise SyntaxError('invalid constraint: %s' % ver_remaining)
                    if not versions:
                        versions = None
                return versions, ver_remaining
 
            if remaining[0] != '(':
                versions, remaining = get_versions(remaining)
            else:
                i = remaining.find(')', 1)
                if i < 0:
                    raise SyntaxError('unterminated parenthesis: %s' % remaining)
                s = remaining[1:i]
                remaining = remaining[i + 1:].lstrip()
                # As a special diversion from PEP 508, allow a version number
                # a.b.c in parentheses as a synonym for ~= a.b.c (because this
                # is allowed in earlier PEPs)
                if COMPARE_OP.match(s):
                    versions, _ = get_versions(s)
                else:
                    m = VERSION_IDENTIFIER.match(s)
                    if not m:
                        raise SyntaxError('invalid constraint: %s' % s)
                    v = m.groups()[0]
                    s = s[m.end():].lstrip()
                    if s:
                        raise SyntaxError('invalid constraint: %s' % s)
                    versions = [('~=', v)]
 
    if remaining:
        if remaining[0] != ';':
            raise SyntaxError('invalid requirement: %s' % remaining)
        remaining = remaining[1:].lstrip()
 
        mark_expr, remaining = parse_marker(remaining)
 
    if remaining and remaining[0] != '#':
        raise SyntaxError('unexpected trailing data: %s' % remaining)
 
    if not versions:
        rs = distname
    else:
        rs = '%s %s' % (distname, ', '.join(['%s %s' % con for con in versions]))
    return Container(name=distname, extras=extras, constraints=versions,
                     marker=mark_expr, url=uri, requirement=rs)
 
 

References i.

path_to_cache_dir()

path_to_cache_dir

(

path

)

Convert an absolute path to a directory name for use in a cache.

The algorithm used is:

#. On Windows, any ``':'`` in the drive is replaced with ``'---'``.
#. Any occurrence of ``os.sep`` is replaced with ``'--'``.
#. ``'.cache'`` is appended.

Definition at line 787 of file util.py.

def path_to_cache_dir(path):
    """
    Convert an absolute path to a directory name for use in a cache.
 
    The algorithm used is:
 
    #. On Windows, any ``':'`` in the drive is replaced with ``'---'``.
    #. Any occurrence of ``os.sep`` is replaced with ``'--'``.
    #. ``'.cache'`` is appended.
    """
    d, p = os.path.splitdrive(os.path.abspath(path))
    if d:
        d = d.replace(':', '---')
    p = p.replace(os.sep, '--')
    return d + p + '.cache'
 
 

References i.

Referenced by Cache.prefix_to_dir().

Here is the caller graph for this function:

proceed()

proceed	(		prompt,
			allowed_chars,
			error_prompt = None,
			default = None
	)

Definition at line 324 of file util.py.

def proceed(prompt, allowed_chars, error_prompt=None, default=None):
    p = prompt
    while True:
        s = raw_input(p)
        p = prompt
        if not s and default:
            s = default
        if s:
            c = s[0].lower()
            if c in allowed_chars:
                break
            if error_prompt:
                p = '%c: %s\n%s' % (c, error_prompt, prompt)
    return c
 
 

References i.

read_exports()

read_exports

(

stream

)

Definition at line 349 of file util.py.

def read_exports(stream):
    if sys.version_info[0] >= 3:
        # needs to be a text stream
        stream = codecs.getreader('utf-8')(stream)
    # Try to load as JSON, falling back on legacy format
    data = stream.read()
    stream = StringIO(data)
    try:
        jdata = json.load(stream)
        result = jdata['extensions']['python.exports']['exports']
        for group, entries in result.items():
            for k, v in entries.items():
                s = '%s = %s' % (k, v)
                entry = get_export_entry(s)
                assert entry is not None
                entries[k] = entry
        return result
    except Exception:
        stream.seek(0, 0)
 
    def read_stream(cp, stream):
        if hasattr(cp, 'read_file'):
            cp.read_file(stream)
        else:
            cp.readfp(stream)
 
    cp = configparser.ConfigParser()
    try:
        read_stream(cp, stream)
    except configparser.MissingSectionHeaderError:
        stream.close()
        data = textwrap.dedent(data)
        stream = StringIO(data)
        read_stream(cp, stream)
 
    result = {}
    for key in cp.sections():
        result[key] = entries = {}
        for name, value in cp.items(key):
            s = '%s = %s' % (name, value)
            entry = get_export_entry(s)
            assert entry is not None
            #entry.dist = self
            entries[name] = entry
    return result
 
 

References i.

resolve()

resolve	(		module_name,
			dotted_path
	)

Definition at line 667 of file util.py.

def resolve(module_name, dotted_path):
    if module_name in sys.modules:
        mod = sys.modules[module_name]
    else:
        mod = __import__(module_name)
    if dotted_path is None:
        result = mod
    else:
        parts = dotted_path.split('.')
        result = getattr(mod, parts.pop(0))
        for p in parts:
            result = getattr(result, p)
    return result
 
 

References i.

Referenced by ExportEntry.value().

Here is the caller graph for this function:

socket_timeout()

socket_timeout

(

seconds = 15

)

Definition at line 434 of file util.py.

def socket_timeout(seconds=15):
    cto = socket.getdefaulttimeout()
    try:
        socket.setdefaulttimeout(seconds)
        yield
    finally:
        socket.setdefaulttimeout(cto)
 
 

References i.

split_filename()

split_filename	(		filename,
			project_name = None
	)

Extract name, version, python version from a filename (no extension)

Return name, version, pyver or None

Definition at line 845 of file util.py.

def split_filename(filename, project_name=None):
    """
    Extract name, version, python version from a filename (no extension)
 
    Return name, version, pyver or None
    """
    result = None
    pyver = None
    filename = unquote(filename).replace(' ', '-')
    m = PYTHON_VERSION.search(filename)
    if m:
        pyver = m.group(1)
        filename = filename[:m.start()]
    if project_name and len(filename) > len(project_name) + 1:
        m = re.match(re.escape(project_name) + r'\b', filename)
        if m:
            n = m.end()
            result = filename[:n], filename[n + 1:], pyver
    if result is None:
        m = PROJECT_NAME_AND_VERSION.match(filename)
        if m:
            result = m.group(1), m.group(3), pyver
    return result
 
# Allow spaces in name because of legacy dists like "Twisted Core"

References i.

tempdir()

tempdir

(

)

Definition at line 416 of file util.py.

def tempdir():
    td = tempfile.mkdtemp()
    try:
        yield td
    finally:
        shutil.rmtree(td)
 
@contextlib.contextmanager

References i.

unarchive()

unarchive	(		archive_filename,
			dest_dir,
			format = None,
			check = True
	)

Definition at line 1205 of file util.py.

def unarchive(archive_filename, dest_dir, format=None, check=True):
 
    def check_path(path):
        if not isinstance(path, text_type):
            path = path.decode('utf-8')
        p = os.path.abspath(os.path.join(dest_dir, path))
        if not p.startswith(dest_dir) or p[plen] != os.sep:
            raise ValueError('path outside destination: %r' % p)
 
    dest_dir = os.path.abspath(dest_dir)
    plen = len(dest_dir)
    archive = None
    if format is None:
        if archive_filename.endswith(('.zip', '.whl')):
            format = 'zip'
        elif archive_filename.endswith(('.tar.gz', '.tgz')):
            format = 'tgz'
            mode = 'r:gz'
        elif archive_filename.endswith(('.tar.bz2', '.tbz')):
            format = 'tbz'
            mode = 'r:bz2'
        elif archive_filename.endswith('.tar'):
            format = 'tar'
            mode = 'r'
        else:  # pragma: no cover
            raise ValueError('Unknown format for %r' % archive_filename)
    try:
        if format == 'zip':
            archive = ZipFile(archive_filename, 'r')
            if check:
                names = archive.namelist()
                for name in names:
                    check_path(name)
        else:
            archive = tarfile.open(archive_filename, mode)
            if check:
                names = archive.getnames()
                for name in names:
                    check_path(name)
        if format != 'zip' and sys.version_info[0] < 3:
            # See Python issue 17153. If the dest path contains Unicode,
            # tarfile extraction fails on Python 2.x if a member path name
            # contains non-ASCII characters - it leads to an implicit
            # bytes -> unicode conversion using ASCII to decode.
            for tarinfo in archive.getmembers():
                if not isinstance(tarinfo.name, text_type):
                    tarinfo.name = tarinfo.name.decode('utf-8')
        archive.extractall(dest_dir)
 
    finally:
        if archive:
            archive.close()
 
 

References i.

write_exports()

write_exports	(		exports,
			stream
	)

Definition at line 396 of file util.py.

def write_exports(exports, stream):
    if sys.version_info[0] >= 3:
        # needs to be a text stream
        stream = codecs.getwriter('utf-8')(stream)
    cp = configparser.ConfigParser()
    for k, v in exports.items():
        # TODO check k, v for valid values
        cp.add_section(k)
        for entry in v.values():
            if entry.suffix is None:
                s = entry.prefix
            else:
                s = '%s:%s' % (entry.prefix, entry.suffix)
            if entry.flags:
                s = '%s [%s]' % (s, ', '.join(entry.flags))
            cp.set(k, entry.name, s)
    cp.write(stream)
 
 
@contextlib.contextmanager

References i.

zip_dir()

zip_dir

(

directory

)

zip a directory tree into a BytesIO object

Definition at line 1259 of file util.py.

def zip_dir(directory):
    """zip a directory tree into a BytesIO object"""
    result = io.BytesIO()
    dlen = len(directory)
    with ZipFile(result, "w") as zf:
        for root, dirs, files in os.walk(directory):
            for name in files:
                full = os.path.join(root, name)
                rel = root[dlen:]
                dest = os.path.join(rel, name)
                zf.write(full, dest)
    return result
 
#
# Simple progress bar
#
 

References i.

Variable Documentation

_CHECK_MISMATCH_SET

_CHECK_MISMATCH_SET = re.compile(r'^[^{]*\}|\{[^}]*$')

protected

Definition at line 1374 of file util.py.

_CHECK_RECURSIVE_GLOB

_CHECK_RECURSIVE_GLOB = re.compile(r'[^/\\,{]\*\*|\*\*[^/\\,}]')

protected

Definition at line 1373 of file util.py.

_external_data_base_url

str _external_data_base_url = 'https://www.red-dove.com/pypi/projects/'

protected

Definition at line 933 of file util.py.

_TARGET_TO_PLAT

dict _TARGET_TO_PLAT

protected

Initial value:

=  {
    'x86' : 'win32',
    'x64' : 'win-amd64',
    'arm' : 'win-arm32',
}

Definition at line 1919 of file util.py.

AND

AND = re.compile(r'^and\b\s*')

Definition at line 51 of file util.py.

ARCHIVE_EXTENSIONS

tuple ARCHIVE_EXTENSIONS

Initial value:

=  ('.tar.gz', '.tar.bz2', '.tar', '.zip',
                      '.tgz', '.tbz', '.whl')

Definition at line 1202 of file util.py.

COMPARE_OP

COMPARE_OP = re.compile(r'^(<=?|>=?|={2,3}|[~!]=)\s*')

Definition at line 48 of file util.py.

ENTRY_RE

ENTRY_RE = re.compile(, re.VERBOSE)

Definition at line 710 of file util.py.

IDENTIFIER

IDENTIFIER = re.compile(r'^([\w\.-]+)\s*')

Definition at line 46 of file util.py.

logger

logger = logging.getLogger(__name__)

Definition at line 40 of file util.py.

MARKER_OP

MARKER_OP = re.compile(r'^((<=?)|(>=?)|={2,3}|[~!]=|in|not\s+in)\s*')

Definition at line 49 of file util.py.

NAME_VERSION_RE

NAME_VERSION_RE

Initial value:

=  re.compile(r'(?P<name>[\w .-]+)\s*'
                             r'\‍(\s*(?P<ver>[^\s)]+)\‍)$')

Definition at line 870 of file util.py.

NON_SPACE

NON_SPACE = re.compile(r'(\S+)\s*')

Definition at line 52 of file util.py.

OR

OR = re.compile(r'^or\b\s*')

Definition at line 50 of file util.py.

PROJECT_NAME_AND_VERSION

PROJECT_NAME_AND_VERSION

Initial value:

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

Definition at line 840 of file util.py.

PYTHON_VERSION

PYTHON_VERSION = re.compile(r'-py(\d\.?\d?)')

Definition at line 842 of file util.py.

RICH_GLOB

RICH_GLOB = re.compile(r'\{([^}]*)\}')

Definition at line 1372 of file util.py.

ssl

ssl = None

Definition at line 20 of file util.py.

STRING_CHUNK

STRING_CHUNK = re.compile(r'([\s\w\.{}()*+#:;,/?!~`@$%^&=|<>\[\]-]+)')

Definition at line 53 of file util.py.

UNITS

tuple UNITS = ('', 'K', 'M', 'G','T','P')

Definition at line 1276 of file util.py.

VERSION_IDENTIFIER

VERSION_IDENTIFIER = re.compile(r'^([\w\.*+-]+)\s*')

Definition at line 47 of file util.py.