mirror of https://github.com/python/cpython
Strawman for a Package Install Manager for Python. It isn't CPAN yet, but at
less than 500 lines it already manages to test whether Numeric is installed, and can install it if it isn't, including any prerequisites.
This commit is contained in:
Jack Jansen
parent
f032f86e9e
commit
95839b8af9
|
|
@ -0,0 +1,499 @@
|
|||
import sys
|
||||
import os
|
||||
import urllib
|
||||
import urlparse
|
||||
import plistlib
|
||||
import distutils.util
|
||||
|
||||
_scriptExc_NotInstalled = "pimp._scriptExc_NotInstalled"
|
||||
_scriptExc_OldInstalled = "pimp._scriptExc_OldInstalled"
|
||||
_scriptExc_BadInstalled = "pimp._scriptExc_BadInstalled"
|
||||
|
||||
NO_EXECUTE=0
|
||||
|
||||
DEFAULT_FLAVORORDER=['source', 'binary']
|
||||
DEFAULT_DOWNLOADDIR='/tmp'
|
||||
DEFAULT_BUILDDIR='/tmp'
|
||||
DEFAULT_INSTALLDIR=os.path.join(sys.prefix, "Lib", "site-packages")
|
||||
DEFAULT_PIMPDATABASE="http://www.cwi.nl/~jack/pimp/pimp-%s.plist" % distutils.util.get_platform()
|
||||
|
||||
ARCHIVE_FORMATS = [
|
||||
(".tar.Z", "zcat \"%s\" | tar xf -"),
|
||||
(".taz", "zcat \"%s\" | tar xf -"),
|
||||
(".tar.gz", "zcat \"%s\" | tar xf -"),
|
||||
(".tgz", "zcat \"%s\" | tar xf -"),
|
||||
(".tar.bz", "bzcat \"%s\" | tar xf -"),
|
||||
]
|
||||
|
||||
class PimpPreferences:
|
||||
def __init__(self,
|
||||
flavorOrder=None,
|
||||
downloadDir=None,
|
||||
buildDir=None,
|
||||
installDir=None,
|
||||
pimpDatabase=None):
|
||||
if not flavorOrder:
|
||||
flavorOrder = DEFAULT_FLAVORORDER
|
||||
if not downloadDir:
|
||||
downloadDir = DEFAULT_DOWNLOADDIR
|
||||
if not buildDir:
|
||||
buildDir = DEFAULT_BUILDDIR
|
||||
if not installDir:
|
||||
installDir = DEFAULT_INSTALLDIR
|
||||
if not pimpDatabase:
|
||||
pimpDatabase = DEFAULT_PIMPDATABASE
|
||||
self.flavorOrder = flavorOrder
|
||||
self.downloadDir = downloadDir
|
||||
self.buildDir = buildDir
|
||||
self.installDir = installDir
|
||||
self.pimpDatabase = pimpDatabase
|
||||
|
||||
def check(self):
|
||||
rv = ""
|
||||
RWX_OK = os.R_OK|os.W_OK|os.X_OK
|
||||
if not os.path.exists(self.downloadDir):
|
||||
rv += "Warning: Download directory \"%s\" does not exist\n" % self.downloadDir
|
||||
elif not os.access(self.downloadDir, RWX_OK):
|
||||
rv += "Warning: Download directory \"%s\" is not writable or not readable\n" % self.downloadDir
|
||||
if not os.path.exists(self.buildDir):
|
||||
rv += "Warning: Build directory \"%s\" does not exist\n" % self.buildDir
|
||||
elif not os.access(self.buildDir, RWX_OK):
|
||||
rv += "Warning: Build directory \"%s\" is not writable or not readable\n" % self.buildDir
|
||||
if not os.path.exists(self.installDir):
|
||||
rv += "Warning: Install directory \"%s\" does not exist\n" % self.installDir
|
||||
elif not os.access(self.installDir, RWX_OK):
|
||||
rv += "Warning: Install directory \"%s\" is not writable or not readable\n" % self.installDir
|
||||
else:
|
||||
installDir = os.path.realpath(self.installDir)
|
||||
for p in sys.path:
|
||||
try:
|
||||
realpath = os.path.realpath(p)
|
||||
except:
|
||||
pass
|
||||
if installDir == realpath:
|
||||
break
|
||||
else:
|
||||
rv += "Warning: Install directory \"%s\" is not on sys.path\n" % self.installDir
|
||||
return rv
|
||||
|
||||
def compareFlavors(self, left, right):
|
||||
if left in self.flavorOrder:
|
||||
if right in self.flavorOrder:
|
||||
return cmp(self.flavorOrder.index(left), self.flavorOrder.index(right))
|
||||
return -1
|
||||
if right in self.flavorOrder:
|
||||
return 1
|
||||
return cmp(left, right)
|
||||
|
||||
class PimpDatabase:
|
||||
def __init__(self, prefs):
|
||||
self._packages = []
|
||||
self.preferences = prefs
|
||||
self._urllist = []
|
||||
self._version = ""
|
||||
self._maintainer = ""
|
||||
self._description = ""
|
||||
|
||||
def appendURL(self, url, included=0):
|
||||
if url in self._urllist:
|
||||
return
|
||||
self._urllist.append(url)
|
||||
fp = urllib.urlopen(url).fp
|
||||
dict = plistlib.Plist.fromFile(fp)
|
||||
# Test here for Pimp version, etc
|
||||
if not included:
|
||||
self._version = dict.get('version', '0.1')
|
||||
self._maintainer = dict.get('maintainer', '')
|
||||
self._description = dict.get('description', '')
|
||||
self.appendPackages(dict['packages'])
|
||||
others = dict.get('include', [])
|
||||
for url in others:
|
||||
self.appendURL(url, included=1)
|
||||
|
||||
def appendPackages(self, packages):
|
||||
for p in packages:
|
||||
pkg = PimpPackage(self, **dict(p))
|
||||
self._packages.append(pkg)
|
||||
|
||||
def list(self):
|
||||
return self._packages
|
||||
|
||||
def listnames(self):
|
||||
rv = []
|
||||
for pkg in self._packages:
|
||||
rv.append(_fmtpackagename(pkg))
|
||||
return rv
|
||||
|
||||
def dump(self, pathOrFile):
|
||||
packages = []
|
||||
for pkg in self._packages:
|
||||
packages.append(pkg.dump())
|
||||
dict = {
|
||||
'version': self._version,
|
||||
'maintainer': self._maintainer,
|
||||
'description': self._description,
|
||||
'packages': packages
|
||||
}
|
||||
plist = plistlib.Plist(**dict)
|
||||
plist.write(pathOrFile)
|
||||
|
||||
def find(self, ident):
|
||||
if type(ident) == str:
|
||||
# Remove ( and ) for pseudo-packages
|
||||
if ident[0] == '(' and ident[-1] == ')':
|
||||
ident = ident[1:-1]
|
||||
# Split into name-version-flavor
|
||||
fields = ident.split('-')
|
||||
if len(fields) < 1 or len(fields) > 3:
|
||||
return None
|
||||
name = fields[0]
|
||||
if len(fields) > 1:
|
||||
version = fields[1]
|
||||
else:
|
||||
version = None
|
||||
if len(fields) > 2:
|
||||
flavor = fields[2]
|
||||
else:
|
||||
flavor = None
|
||||
else:
|
||||
name = ident['name']
|
||||
version = ident.get('version')
|
||||
flavor = ident.get('flavor')
|
||||
found = None
|
||||
for p in self._packages:
|
||||
if name == p.name and \
|
||||
(not version or version == p.version) and \
|
||||
(not flavor or flavor == p.flavor):
|
||||
if not found or found < p:
|
||||
found = p
|
||||
return found
|
||||
|
||||
class PimpPackage:
|
||||
def __init__(self, db, name,
|
||||
version=None,
|
||||
flavor=None,
|
||||
description=None,
|
||||
longdesc=None,
|
||||
downloadURL=None,
|
||||
installTest=None,
|
||||
prerequisites=None):
|
||||
self._db = db
|
||||
self.name = name
|
||||
self.version = version
|
||||
self.flavor = flavor
|
||||
self.description = description
|
||||
self.longdesc = longdesc
|
||||
self.downloadURL = downloadURL
|
||||
self._installTest = installTest
|
||||
self._prerequisites = prerequisites
|
||||
|
||||
def dump(self):
|
||||
dict = {
|
||||
'name': self.name,
|
||||
}
|
||||
if self.version:
|
||||
dict['version'] = self.version
|
||||
if self.flavor:
|
||||
dict['flavor'] = self.flavor
|
||||
if self.description:
|
||||
dict['description'] = self.description
|
||||
if self.longdesc:
|
||||
dict['longdesc'] = self.longdesc
|
||||
if self.downloadURL:
|
||||
dict['downloadURL'] = self.downloadURL
|
||||
if self._installTest:
|
||||
dict['installTest'] = self._installTest
|
||||
if self._prerequisites:
|
||||
dict['prerequisites'] = self._prerequisites
|
||||
return dict
|
||||
|
||||
def __cmp__(self, other):
|
||||
if not isinstance(other, PimpPackage):
|
||||
return cmp(id(self), id(other))
|
||||
if self.name != other.name:
|
||||
return cmp(self.name, other.name)
|
||||
if self.version != other.version:
|
||||
return cmp(self.version, other.version)
|
||||
return self._db.preferences.compareFlavors(self.flavor, other.flavor)
|
||||
|
||||
def installed(self):
|
||||
namespace = {
|
||||
"NotInstalled": _scriptExc_NotInstalled,
|
||||
"OldInstalled": _scriptExc_OldInstalled,
|
||||
"BadInstalled": _scriptExc_BadInstalled,
|
||||
"os": os,
|
||||
"sys": sys,
|
||||
}
|
||||
installTest = self._installTest.strip() + '\n'
|
||||
try:
|
||||
exec installTest in namespace
|
||||
except ImportError, arg:
|
||||
return "no", str(arg)
|
||||
except _scriptExc_NotInstalled, arg:
|
||||
return "no", str(arg)
|
||||
except _scriptExc_OldInstalled, arg:
|
||||
return "old", str(arg)
|
||||
except _scriptExc_BadInstalled, arg:
|
||||
return "bad", str(arg)
|
||||
except:
|
||||
print 'TEST:', repr(self._installTest)
|
||||
return "bad", "Package install test got exception"
|
||||
return "yes", ""
|
||||
|
||||
def prerequisites(self):
|
||||
rv = []
|
||||
if not self.downloadURL:
|
||||
return [(None, "This package needs to be installed manually")]
|
||||
if not self._prerequisites:
|
||||
return []
|
||||
for item in self._prerequisites:
|
||||
if type(item) == str:
|
||||
pkg = None
|
||||
descr = str(item)
|
||||
else:
|
||||
pkg = self._db.find(item)
|
||||
if not pkg:
|
||||
descr = "Requires unknown %s"%_fmtpackagename(item)
|
||||
else:
|
||||
descr = pkg.description
|
||||
rv.append((pkg, descr))
|
||||
return rv
|
||||
|
||||
def _cmd(self, output, dir, *cmditems):
|
||||
cmd = ("cd \"%s\"; " % dir) + " ".join(cmditems)
|
||||
if output:
|
||||
output.write("+ %s\n" % cmd)
|
||||
if NO_EXECUTE:
|
||||
return 0
|
||||
fp = os.popen(cmd, "r")
|
||||
while 1:
|
||||
line = fp.readline()
|
||||
if not line:
|
||||
break
|
||||
if output:
|
||||
output.write(line)
|
||||
rv = fp.close()
|
||||
return rv
|
||||
|
||||
def downloadSinglePackage(self, output):
|
||||
scheme, loc, path, query, frag = urlparse.urlsplit(self.downloadURL)
|
||||
path = urllib.url2pathname(path)
|
||||
filename = os.path.split(path)[1]
|
||||
self.archiveFilename = os.path.join(self._db.preferences.downloadDir, filename)
|
||||
if self._cmd(output, self._db.preferences.downloadDir, "curl",
|
||||
"--output", self.archiveFilename,
|
||||
self.downloadURL):
|
||||
return "download command failed"
|
||||
if not os.path.exists(self.archiveFilename) and not NO_EXECUTE:
|
||||
return "archive not found after download"
|
||||
|
||||
def unpackSinglePackage(self, output):
|
||||
filename = os.path.split(self.archiveFilename)[1]
|
||||
for ext, cmd in ARCHIVE_FORMATS:
|
||||
if filename[-len(ext):] == ext:
|
||||
break
|
||||
else:
|
||||
return "unknown extension for archive file: %s" % filename
|
||||
basename = filename[:-len(ext)]
|
||||
cmd = cmd % self.archiveFilename
|
||||
self._buildDirname = os.path.join(self._db.preferences.buildDir, basename)
|
||||
if self._cmd(output, self._db.preferences.buildDir, cmd):
|
||||
return "unpack command failed"
|
||||
setupname = os.path.join(self._buildDirname, "setup.py")
|
||||
if not os.path.exists(setupname) and not NO_EXECUTE:
|
||||
return "no setup.py found after unpack of archive"
|
||||
|
||||
def installSinglePackage(self, output):
|
||||
if not self.downloadURL:
|
||||
return "%s: This package needs to be installed manually" % _fmtpackagename(self)
|
||||
msg = self.downloadSinglePackage(output)
|
||||
if msg:
|
||||
return "download %s: %s" % (_fmtpackagename(self), msg)
|
||||
msg = self.unpackSinglePackage(output)
|
||||
if msg:
|
||||
return "unpack %s: %s" % (_fmtpackagename(self), msg)
|
||||
if self._cmd(output, self._buildDirname, sys.executable, "setup.py install"):
|
||||
return "install %s: running \"setup.py install\" failed" % _fmtpackagename(self)
|
||||
return None
|
||||
|
||||
class PimpInstaller:
|
||||
def __init__(self, db):
|
||||
self._todo = []
|
||||
self._db = db
|
||||
self._curtodo = []
|
||||
self._curmessages = []
|
||||
|
||||
def __contains__(self, package):
|
||||
return package in self._todo
|
||||
|
||||
def _addPackages(self, packages):
|
||||
for package in packages:
|
||||
if not package in self._todo:
|
||||
self._todo.insert(0, package)
|
||||
|
||||
def _prepareInstall(self, package, force=0, recursive=1):
|
||||
if not force:
|
||||
status, message = package.installed()
|
||||
if status == "yes":
|
||||
return
|
||||
if package in self._todo or package in self._curtodo:
|
||||
return
|
||||
self._curtodo.insert(0, package)
|
||||
if not recursive:
|
||||
return
|
||||
prereqs = package.prerequisites()
|
||||
for pkg, descr in prereqs:
|
||||
if pkg:
|
||||
self._prepareInstall(pkg, force, recursive)
|
||||
else:
|
||||
self._curmessages.append("Requires: %s" % descr)
|
||||
|
||||
def prepareInstall(self, package, force=0, recursive=1):
|
||||
self._curtodo = []
|
||||
self._curmessages = []
|
||||
self._prepareInstall(package, force, recursive)
|
||||
rv = self._curtodo, self._curmessages
|
||||
self._curtodo = []
|
||||
self._curmessages = []
|
||||
return rv
|
||||
|
||||
def install(self, packages, output):
|
||||
self._addPackages(packages)
|
||||
status = []
|
||||
for pkg in self._todo:
|
||||
msg = pkg.installSinglePackage(output)
|
||||
if msg:
|
||||
status.append(msg)
|
||||
return status
|
||||
|
||||
|
||||
def _fmtpackagename(dict):
|
||||
if isinstance(dict, PimpPackage):
|
||||
dict = dict.dump()
|
||||
rv = dict['name']
|
||||
if dict.has_key('version'):
|
||||
rv = rv + '-%s' % dict['version']
|
||||
if dict.has_key('flavor'):
|
||||
rv = rv + '-%s' % dict['flavor']
|
||||
if not dict.get('downloadURL'):
|
||||
# Pseudo-package, show in parentheses
|
||||
rv = '(%s)' % rv
|
||||
return rv
|
||||
|
||||
def _run(mode, verbose, force, args):
|
||||
prefs = PimpPreferences()
|
||||
prefs.check()
|
||||
db = PimpDatabase(prefs)
|
||||
db.appendURL(prefs.pimpDatabase)
|
||||
|
||||
if mode =='list':
|
||||
if not args:
|
||||
args = db.listnames()
|
||||
print "%-20.20s\t%s" % ("Package", "Description")
|
||||
print
|
||||
for pkgname in args:
|
||||
pkg = db.find(pkgname)
|
||||
if pkg:
|
||||
description = pkg.description
|
||||
pkgname = _fmtpackagename(pkg)
|
||||
else:
|
||||
description = 'Error: no such package'
|
||||
print "%-20.20s\t%s" % (pkgname, description)
|
||||
if verbose:
|
||||
print "\tHome page:\t", pkg.longdesc
|
||||
print "\tDownload URL:\t", pkg.downloadURL
|
||||
if mode =='status':
|
||||
if not args:
|
||||
args = db.listnames()
|
||||
print "%-20.20s\t%s\t%s" % ("Package", "Installed", "Message")
|
||||
print
|
||||
for pkgname in args:
|
||||
pkg = db.find(pkgname)
|
||||
if pkg:
|
||||
status, msg = pkg.installed()
|
||||
pkgname = _fmtpackagename(pkg)
|
||||
else:
|
||||
status = 'error'
|
||||
msg = 'No such package'
|
||||
print "%-20.20s\t%-9.9s\t%s" % (pkgname, status, msg)
|
||||
if verbose and status == "no":
|
||||
prereq = pkg.prerequisites()
|
||||
for pkg, msg in prereq:
|
||||
if not pkg:
|
||||
pkg = ''
|
||||
else:
|
||||
pkg = _fmtpackagename(pkg)
|
||||
print "%-20.20s\tRequirement: %s %s" % ("", pkg, msg)
|
||||
elif mode == 'install':
|
||||
if not args:
|
||||
print 'Please specify packages to install'
|
||||
sys.exit(1)
|
||||
inst = PimpInstaller(db)
|
||||
for pkgname in args:
|
||||
pkg = db.find(pkgname)
|
||||
if not pkg:
|
||||
print '%s: No such package' % pkgname
|
||||
continue
|
||||
list, messages = inst.prepareInstall(pkg, force)
|
||||
if messages and not force:
|
||||
print "%s: Not installed:" % pkgname
|
||||
for m in messages:
|
||||
print "\t", m
|
||||
else:
|
||||
if verbose:
|
||||
output = sys.stdout
|
||||
else:
|
||||
output = None
|
||||
messages = inst.install(list, output)
|
||||
if messages:
|
||||
print "%s: Not installed:" % pkgname
|
||||
for m in messages:
|
||||
print "\t", m
|
||||
|
||||
def main():
|
||||
import getopt
|
||||
def _help():
|
||||
print "Usage: pimp [-v] -s [package ...] List installed status"
|
||||
print " pimp [-v] -l [package ...] Show package information"
|
||||
print " pimp [-vf] -i package ... Install packages"
|
||||
print "Options:"
|
||||
print " -v Verbose"
|
||||
print " -f Force installation"
|
||||
sys.exit(1)
|
||||
|
||||
try:
|
||||
opts, args = getopt.getopt(sys.argv[1:], "slifv")
|
||||
except getopt.Error:
|
||||
_help()
|
||||
if not opts and not args:
|
||||
_help()
|
||||
mode = None
|
||||
force = 0
|
||||
verbose = 0
|
||||
for o, a in opts:
|
||||
if o == '-s':
|
||||
if mode:
|
||||
_help()
|
||||
mode = 'status'
|
||||
if o == '-l':
|
||||
if mode:
|
||||
_help()
|
||||
mode = 'list'
|
||||
if o == '-L':
|
||||
if mode:
|
||||
_help()
|
||||
mode = 'longlist'
|
||||
if o == '-i':
|
||||
mode = 'install'
|
||||
if o == '-f':
|
||||
force = 1
|
||||
if o == '-v':
|
||||
verbose = 1
|
||||
if not mode:
|
||||
_help()
|
||||
_run(mode, verbose, force, args)
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
|
||||
|
||||
Loading…
Reference in New Issue