mirror of
https://github.com/pypa/pip
synced 2023-12-13 21:30:23 +01:00
376 lines
12 KiB
Python
376 lines
12 KiB
Python
import sys
|
|
import shutil
|
|
import os
|
|
import posixpath
|
|
import stat
|
|
import urllib
|
|
import urllib2
|
|
import re
|
|
from pip.backwardcompat import WindowsError
|
|
from pip.exceptions import InstallationError
|
|
from pip.locations import site_packages
|
|
|
|
__all__ = ['rmtree', 'display_path', 'backup_dir',
|
|
'find_command', 'splitext', 'ask', 'Inf',
|
|
'url_to_filename', 'filename_to_url',
|
|
'filename_to_url2', 'normalize_name',
|
|
'format_size', 'is_url', 'is_filename',
|
|
'strip_prefix', 'is_svn_page', 'file_contents',
|
|
'split_leading_dir', 'has_leading_dir',
|
|
'make_path_relative', 'normalize_path',
|
|
'get_file_content', 'renames', 'get_terminal_size']
|
|
|
|
def rmtree(dir):
|
|
shutil.rmtree(dir, ignore_errors=True,
|
|
onerror=rmtree_errorhandler)
|
|
|
|
def rmtree_errorhandler(func, path, exc_info):
|
|
"""On Windows, the files in .svn are read-only, so when rmtree() tries to
|
|
remove them, an exception is thrown. We catch that here, remove the
|
|
read-only attribute, and hopefully continue without problems."""
|
|
exctype, value = exc_info[:2]
|
|
# lookin for a windows error
|
|
if exctype is not WindowsError or 'Access is denied' not in str(value):
|
|
raise
|
|
# file type should currently be read only
|
|
if ((os.stat(path).st_mode & stat.S_IREAD) != stat.S_IREAD):
|
|
raise
|
|
# convert to read/write
|
|
os.chmod(path, stat.S_IWRITE)
|
|
# use the original function to repeat the operation
|
|
func(path)
|
|
|
|
def display_path(path):
|
|
"""Gives the display value for a given path, making it relative to cwd
|
|
if possible."""
|
|
path = os.path.normcase(os.path.abspath(path))
|
|
if path.startswith(os.getcwd() + os.path.sep):
|
|
path = '.' + path[len(os.getcwd()):]
|
|
return path
|
|
|
|
def backup_dir(dir, ext='.bak'):
|
|
"""Figure out the name of a directory to back up the given dir to
|
|
(adding .bak, .bak2, etc)"""
|
|
n = 1
|
|
extension = ext
|
|
while os.path.exists(dir + extension):
|
|
n += 1
|
|
extension = ext + str(n)
|
|
return dir + extension
|
|
|
|
def splitext(path):
|
|
"""Like os.path.splitext, but take off .tar too"""
|
|
base, ext = posixpath.splitext(path)
|
|
if base.lower().endswith('.tar'):
|
|
ext = base[-4:] + ext
|
|
base = base[:-4]
|
|
return base, ext
|
|
|
|
def find_command(cmd, paths=None, pathext=None):
|
|
"""Searches the PATH for the given command and returns its path"""
|
|
if paths is None:
|
|
paths = os.environ.get('PATH', []).split(os.pathsep)
|
|
if isinstance(paths, basestring):
|
|
paths = [paths]
|
|
# check if there are funny path extensions for executables, e.g. Windows
|
|
if pathext is None:
|
|
pathext = os.environ.get('PATHEXT', '.COM;.EXE;.BAT;.CMD')
|
|
pathext = [ext for ext in pathext.lower().split(os.pathsep)]
|
|
# don't use extensions if the command ends with one of them
|
|
if os.path.splitext(cmd)[1].lower() in pathext:
|
|
pathext = ['']
|
|
# check if we find the command on PATH
|
|
for path in paths:
|
|
# try without extension first
|
|
cmd_path = os.path.join(path, cmd)
|
|
for ext in pathext:
|
|
# then including the extension
|
|
cmd_path_ext = cmd_path + ext
|
|
if os.path.exists(cmd_path_ext):
|
|
return cmd_path_ext
|
|
if os.path.exists(cmd_path):
|
|
return cmd_path
|
|
return None
|
|
|
|
def ask(message, options):
|
|
"""Ask the message interactively, with the given possible responses"""
|
|
while 1:
|
|
if os.environ.get('PIP_NO_INPUT'):
|
|
raise Exception('No input was expected ($PIP_NO_INPUT set); question: %s' % message)
|
|
response = raw_input(message)
|
|
response = response.strip().lower()
|
|
if response not in options:
|
|
print 'Your response (%r) was not one of the expected responses: %s' % (
|
|
response, ', '.join(options))
|
|
else:
|
|
return response
|
|
|
|
class _Inf(object):
|
|
"""I am bigger than everything!"""
|
|
def __cmp__(self, a):
|
|
if self is a:
|
|
return 0
|
|
return 1
|
|
def __repr__(self):
|
|
return 'Inf'
|
|
Inf = _Inf()
|
|
del _Inf
|
|
|
|
|
|
def url_to_filename(url):
|
|
"""
|
|
Convert a file: URL to a path.
|
|
"""
|
|
assert url.startswith('file:'), (
|
|
"You can only turn file: urls into filenames (not %r)" % url)
|
|
filename = url[len('file:'):].lstrip('/')
|
|
filename = urllib.unquote(filename)
|
|
if _url_drive_re.match(filename):
|
|
filename = filename[0] + ':' + filename[2:]
|
|
else:
|
|
filename = '/' + filename
|
|
return filename
|
|
|
|
_drive_re = re.compile('^([a-z]):', re.I)
|
|
_url_drive_re = re.compile('^([a-z])[:|]', re.I)
|
|
|
|
def filename_to_url(filename):
|
|
"""
|
|
Convert a path to a file: URL. The path will be made absolute.
|
|
"""
|
|
filename = os.path.normcase(os.path.abspath(filename))
|
|
if _drive_re.match(filename):
|
|
filename = filename[0] + '|' + filename[2:]
|
|
url = urllib.quote(filename)
|
|
url = url.replace(os.path.sep, '/')
|
|
url = url.lstrip('/')
|
|
return 'file:///' + url
|
|
|
|
def filename_to_url2(filename):
|
|
"""
|
|
Convert a path to a file: URL. The path will be made absolute and have
|
|
quoted path parts.
|
|
"""
|
|
filename = os.path.normcase(os.path.abspath(filename))
|
|
drive, filename = os.path.splitdrive(filename)
|
|
filepath = filename.split(os.path.sep)
|
|
url = '/'.join([urllib.quote(part) for part in filepath])
|
|
if not drive:
|
|
url = url.lstrip('/')
|
|
return 'file:///' + drive + url
|
|
|
|
_normalize_re = re.compile(r'[^a-z]', re.I)
|
|
|
|
def normalize_name(name):
|
|
return _normalize_re.sub('-', name.lower())
|
|
|
|
def format_size(bytes):
|
|
if bytes > 1000*1000:
|
|
return '%.1fMb' % (bytes/1000.0/1000)
|
|
elif bytes > 10*1000:
|
|
return '%iKb' % (bytes/1000)
|
|
elif bytes > 1000:
|
|
return '%.1fKb' % (bytes/1000.0)
|
|
else:
|
|
return '%ibytes' % bytes
|
|
|
|
def is_url(name):
|
|
"""Returns true if the name looks like a URL"""
|
|
from pip.vcs import vcs
|
|
if ':' not in name:
|
|
return False
|
|
scheme = name.split(':', 1)[0].lower()
|
|
return scheme in ['http', 'https', 'file', 'ftp'] + vcs.all_schemes
|
|
|
|
def is_filename(name):
|
|
if (splitext(name)[1].lower() in ('.zip', '.tar.gz', '.tar.bz2', '.tgz', '.tar', '.pybundle')
|
|
and os.path.exists(name)):
|
|
return True
|
|
if os.path.sep not in name and '/' not in name:
|
|
# Doesn't have any path components, probably a requirement like 'Foo'
|
|
return False
|
|
return True
|
|
|
|
def is_svn_page(html):
|
|
"""Returns true if the page appears to be the index page of an svn repository"""
|
|
return (re.search(r'<title>[^<]*Revision \d+:', html)
|
|
and re.search(r'Powered by (?:<a[^>]*?>)?Subversion', html, re.I))
|
|
|
|
def file_contents(filename):
|
|
fp = open(filename, 'rb')
|
|
try:
|
|
return fp.read()
|
|
finally:
|
|
fp.close()
|
|
|
|
def split_leading_dir(path):
|
|
path = str(path)
|
|
path = path.lstrip('/').lstrip('\\')
|
|
if '/' in path and (('\\' in path and path.find('/') < path.find('\\'))
|
|
or '\\' not in path):
|
|
return path.split('/', 1)
|
|
elif '\\' in path:
|
|
return path.split('\\', 1)
|
|
else:
|
|
return path, ''
|
|
|
|
def has_leading_dir(paths):
|
|
"""Returns true if all the paths have the same leading path name
|
|
(i.e., everything is in one subdirectory in an archive)"""
|
|
common_prefix = None
|
|
for path in paths:
|
|
prefix, rest = split_leading_dir(path)
|
|
if not prefix:
|
|
return False
|
|
elif common_prefix is None:
|
|
common_prefix = prefix
|
|
elif prefix != common_prefix:
|
|
return False
|
|
return True
|
|
|
|
def make_path_relative(path, rel_to):
|
|
"""
|
|
Make a filename relative, where the filename path, and it is
|
|
relative to rel_to
|
|
|
|
>>> make_relative_path('/usr/share/something/a-file.pth',
|
|
... '/usr/share/another-place/src/Directory')
|
|
'../../../something/a-file.pth'
|
|
>>> make_relative_path('/usr/share/something/a-file.pth',
|
|
... '/home/user/src/Directory')
|
|
'../../../usr/share/something/a-file.pth'
|
|
>>> make_relative_path('/usr/share/a-file.pth', '/usr/share/')
|
|
'a-file.pth'
|
|
"""
|
|
path_filename = os.path.basename(path)
|
|
path = os.path.dirname(path)
|
|
path = os.path.normpath(os.path.abspath(path))
|
|
rel_to = os.path.normpath(os.path.abspath(rel_to))
|
|
path_parts = path.strip(os.path.sep).split(os.path.sep)
|
|
rel_to_parts = rel_to.strip(os.path.sep).split(os.path.sep)
|
|
while path_parts and rel_to_parts and path_parts[0] == rel_to_parts[0]:
|
|
path_parts.pop(0)
|
|
rel_to_parts.pop(0)
|
|
full_parts = ['..']*len(rel_to_parts) + path_parts + [path_filename]
|
|
if full_parts == ['']:
|
|
return '.' + os.path.sep
|
|
return os.path.sep.join(full_parts)
|
|
|
|
def normalize_path(path):
|
|
"""
|
|
Convert a path to its canonical, case-normalized, absolute version.
|
|
|
|
"""
|
|
return os.path.normcase(os.path.realpath(path))
|
|
|
|
_scheme_re = re.compile(r'^(http|https|file):', re.I)
|
|
_url_slash_drive_re = re.compile(r'/*([a-z])\|', re.I)
|
|
|
|
def get_file_content(url, comes_from=None):
|
|
"""Gets the content of a file; it may be a filename, file: URL, or
|
|
http: URL. Returns (location, content)"""
|
|
match = _scheme_re.search(url)
|
|
if match:
|
|
scheme = match.group(1).lower()
|
|
if (scheme == 'file' and comes_from
|
|
and comes_from.startswith('http')):
|
|
raise InstallationError(
|
|
'Requirements file %s references URL %s, which is local'
|
|
% (comes_from, url))
|
|
if scheme == 'file':
|
|
path = url.split(':', 1)[1]
|
|
path = path.replace('\\', '/')
|
|
match = _url_slash_drive_re.match(path)
|
|
if match:
|
|
path = match.group(1) + ':' + path.split('|', 1)[1]
|
|
path = urllib.unquote(path)
|
|
if path.startswith('/'):
|
|
path = '/' + path.lstrip('/')
|
|
url = path
|
|
else:
|
|
## FIXME: catch some errors
|
|
resp = urllib2.urlopen(url)
|
|
return resp.geturl(), resp.read()
|
|
f = open(url)
|
|
content = f.read()
|
|
f.close()
|
|
return url, content
|
|
|
|
def renames(old, new):
|
|
"""Like os.renames(), but handles renaming across devices."""
|
|
# Implementation borrowed from os.renames().
|
|
head, tail = os.path.split(new)
|
|
if head and tail and not os.path.exists(head):
|
|
os.makedirs(head)
|
|
|
|
shutil.move(old, new)
|
|
|
|
head, tail = os.path.split(old)
|
|
if head and tail:
|
|
try:
|
|
os.removedirs(head)
|
|
except OSError:
|
|
pass
|
|
|
|
def is_local(path):
|
|
"""
|
|
Return True if path is within sys.prefix, if we're running in a virtualenv.
|
|
|
|
If we're not in a virtualenv, all paths are considered "local."
|
|
|
|
"""
|
|
if not hasattr(sys, 'real_prefix'):
|
|
return True
|
|
return normalize_path(path).startswith(normalize_path(sys.prefix))
|
|
|
|
def egg_link_path(dist):
|
|
"""
|
|
Return the path where we'd expect to find a .egg-link file for
|
|
this distribution. (There doesn't seem to be any metadata in the
|
|
Distribution object for a develop egg that points back to its
|
|
.egg-link and easy-install.pth files).
|
|
|
|
This won't find a globally-installed develop egg if we're in a
|
|
virtualenv.
|
|
|
|
"""
|
|
return os.path.join(site_packages, dist.project_name) + '.egg-link'
|
|
|
|
def dist_location(dist):
|
|
"""
|
|
Get the site-packages location of this distribution. Generally
|
|
this is dist.location, except in the case of develop-installed
|
|
packages, where dist.location is the source code location, and we
|
|
want to know where the egg-link file is.
|
|
|
|
"""
|
|
egg_link = egg_link_path(dist)
|
|
if os.path.exists(egg_link):
|
|
return egg_link
|
|
return dist.location
|
|
|
|
def get_terminal_size():
|
|
"""Returns a tuple (x, y) representing the width(x) and the height(x)
|
|
in characters of the terminal window."""
|
|
def ioctl_GWINSZ(fd):
|
|
try:
|
|
import fcntl, termios, struct
|
|
cr = struct.unpack('hh', fcntl.ioctl(fd, termios.TIOCGWINSZ,
|
|
'1234'))
|
|
except:
|
|
return None
|
|
return cr
|
|
cr = ioctl_GWINSZ(0) or ioctl_GWINSZ(1) or ioctl_GWINSZ(2)
|
|
if not cr:
|
|
try:
|
|
fd = os.open(os.ctermid(), os.O_RDONLY)
|
|
cr = ioctl_GWINSZ(fd)
|
|
os.close(fd)
|
|
except:
|
|
pass
|
|
if not cr:
|
|
try:
|
|
cr = (env['LINES'], env['COLUMNS'])
|
|
except:
|
|
cr = (25, 80)
|
|
return int(cr[1]), int(cr[0])
|