[Python-checkins] python/dist/src/Lib/plat-mac pimp.py,NONE,1.1
jackjansen@users.sourceforge.net
jackjansen@users.sourceforge.net
Sun, 09 Feb 2003 15:10:22 -0800
Update of /cvsroot/python/python/dist/src/Lib/plat-mac
In directory sc8-pr-cvs1:/tmp/cvs-serv20116
Added Files:
pimp.py
Log Message:
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.
--- NEW FILE: pimp.py ---
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()