Python code coverage for Lib/plat-mac/pimp.py

#	count	content
1	n/a	"""Package Install Manager for Python.
2	n/a
3	n/a	This is currently a MacOSX-only strawman implementation.
4	n/a	Despite other rumours the name stands for "Packman IMPlementation".
5	n/a
6	n/a	Tools to allow easy installation of packages. The idea is that there is
7	n/a	an online XML database per (platform, python-version) containing packages
8	n/a	known to work with that combination. This module contains tools for getting
9	n/a	and parsing the database, testing whether packages are installed, computing
10	n/a	dependencies and installing packages.
11	n/a
12	n/a	There is a minimal main program that works as a command line tool, but the
13	n/a	intention is that the end user will use this through a GUI.
14	n/a	"""
15	n/a
16	n/a	from warnings import warnpy3k
17	n/a	warnpy3k("In 3.x, the pimp module is removed.", stacklevel=2)
18	n/a
19	n/a	import sys
20	n/a	import os
21	n/a	import subprocess
22	n/a	import urllib
23	n/a	import urllib2
24	n/a	import urlparse
25	n/a	import plistlib
26	n/a	import distutils.util
27	n/a	import distutils.sysconfig
28	n/a	import hashlib
29	n/a	import tarfile
30	n/a	import tempfile
31	n/a	import shutil
32	n/a	import time
33	n/a
34	n/a	__all__ = ["PimpPreferences", "PimpDatabase", "PimpPackage", "main",
35	n/a	"getDefaultDatabase", "PIMP_VERSION", "main"]
36	n/a
37	n/a	_scriptExc_NotInstalled = "pimp._scriptExc_NotInstalled"
38	n/a	_scriptExc_OldInstalled = "pimp._scriptExc_OldInstalled"
39	n/a	_scriptExc_BadInstalled = "pimp._scriptExc_BadInstalled"
40	n/a
41	n/a	NO_EXECUTE=0
42	n/a
43	n/a	PIMP_VERSION="0.5"
44	n/a
45	n/a	# Flavors:
46	n/a	# source: setup-based package
47	n/a	# binary: tar (or other) archive created with setup.py bdist.
48	n/a	# installer: something that can be opened
49	n/a	DEFAULT_FLAVORORDER=['source', 'binary', 'installer']
50	n/a	DEFAULT_DOWNLOADDIR='/tmp'
51	n/a	DEFAULT_BUILDDIR='/tmp'
52	n/a	DEFAULT_INSTALLDIR=distutils.sysconfig.get_python_lib()
53	n/a	DEFAULT_PIMPDATABASE_FMT="http://www.python.org/packman/version-%s/%s-%s-%s-%s-%s.plist"
54	n/a
55	n/a	def getDefaultDatabase(experimental=False):
56	n/a	if experimental:
57	n/a	status = "exp"
58	n/a	else:
59	n/a	status = "prod"
60	n/a
61	n/a	major, minor, micro, state, extra = sys.version_info
62	n/a	pyvers = '%d.%d' % (major, minor)
63	n/a	if micro == 0 and state != 'final':
64	n/a	pyvers = pyvers + '%s%d' % (state, extra)
65	n/a
66	n/a	longplatform = distutils.util.get_platform()
67	n/a	osname, release, machine = longplatform.split('-')
68	n/a	# For some platforms we may want to differentiate between
69	n/a	# installation types
70	n/a	if osname == 'darwin':
71	n/a	if sys.prefix.startswith('/System/Library/Frameworks/Python.framework'):
72	n/a	osname = 'darwin_apple'
73	n/a	elif sys.prefix.startswith('/Library/Frameworks/Python.framework'):
74	n/a	osname = 'darwin_macpython'
75	n/a	# Otherwise we don't know...
76	n/a	# Now we try various URLs by playing with the release string.
77	n/a	# We remove numbers off the end until we find a match.
78	n/a	rel = release
79	n/a	while True:
80	n/a	url = DEFAULT_PIMPDATABASE_FMT % (PIMP_VERSION, status, pyvers, osname, rel, machine)
81	n/a	try:
82	n/a	urllib2.urlopen(url)
83	n/a	except urllib2.HTTPError, arg:
84	n/a	pass
85	n/a	else:
86	n/a	break
87	n/a	if not rel:
88	n/a	# We're out of version numbers to try. Use the
89	n/a	# full release number, this will give a reasonable
90	n/a	# error message later
91	n/a	url = DEFAULT_PIMPDATABASE_FMT % (PIMP_VERSION, status, pyvers, osname, release, machine)
92	n/a	break
93	n/a	idx = rel.rfind('.')
94	n/a	if idx < 0:
95	n/a	rel = ''
96	n/a	else:
97	n/a	rel = rel[:idx]
98	n/a	return url
99	n/a
100	n/a	def _cmd(output, dir, *cmditems):
101	n/a	"""Internal routine to run a shell command in a given directory."""
102	n/a
103	n/a	cmd = ("cd \"%s\"; " % dir) + " ".join(cmditems)
104	n/a	if output:
105	n/a	output.write("+ %s\n" % cmd)
106	n/a	if NO_EXECUTE:
107	n/a	return 0
108	n/a	child = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE,
109	n/a	stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
110	n/a	child.stdin.close()
111	n/a	while 1:
112	n/a	line = child.stdout.readline()
113	n/a	if not line:
114	n/a	break
115	n/a	if output:
116	n/a	output.write(line)
117	n/a	return child.wait()
118	n/a
119	n/a	class PimpDownloader:
120	n/a	"""Abstract base class - Downloader for archives"""
121	n/a
122	n/a	def __init__(self, argument,
123	n/a	dir="",
124	n/a	watcher=None):
125	n/a	self.argument = argument
126	n/a	self._dir = dir
127	n/a	self._watcher = watcher
128	n/a
129	n/a	def download(self, url, filename, output=None):
130	n/a	return None
131	n/a
132	n/a	def update(self, str):
133	n/a	if self._watcher:
134	n/a	return self._watcher.update(str)
135	n/a	return True
136	n/a
137	n/a	class PimpCurlDownloader(PimpDownloader):
138	n/a
139	n/a	def download(self, url, filename, output=None):
140	n/a	self.update("Downloading %s..." % url)
141	n/a	exitstatus = _cmd(output, self._dir,
142	n/a	"curl",
143	n/a	"--output", filename,
144	n/a	url)
145	n/a	self.update("Downloading %s: finished" % url)
146	n/a	return (not exitstatus)
147	n/a
148	n/a	class PimpUrllibDownloader(PimpDownloader):
149	n/a
150	n/a	def download(self, url, filename, output=None):
151	n/a	output = open(filename, 'wb')
152	n/a	self.update("Downloading %s: opening connection" % url)
153	n/a	keepgoing = True
154	n/a	download = urllib2.urlopen(url)
155	n/a	if 'content-length' in download.headers:
156	n/a	length = long(download.headers['content-length'])
157	n/a	else:
158	n/a	length = -1
159	n/a
160	n/a	data = download.read(4096) #read 4K at a time
161	n/a	dlsize = 0
162	n/a	lasttime = 0
163	n/a	while keepgoing:
164	n/a	dlsize = dlsize + len(data)
165	n/a	if len(data) == 0:
166	n/a	#this is our exit condition
167	n/a	break
168	n/a	output.write(data)
169	n/a	if int(time.time()) != lasttime:
170	n/a	# Update at most once per second
171	n/a	lasttime = int(time.time())
172	n/a	if length == -1:
173	n/a	keepgoing = self.update("Downloading %s: %d bytes..." % (url, dlsize))
174	n/a	else:
175	n/a	keepgoing = self.update("Downloading %s: %d%% (%d bytes)..." % (url, int(100.0*dlsize/length), dlsize))
176	n/a	data = download.read(4096)
177	n/a	if keepgoing:
178	n/a	self.update("Downloading %s: finished" % url)
179	n/a	return keepgoing
180	n/a
181	n/a	class PimpUnpacker:
182	n/a	"""Abstract base class - Unpacker for archives"""
183	n/a
184	n/a	_can_rename = False
185	n/a
186	n/a	def __init__(self, argument,
187	n/a	dir="",
188	n/a	renames=[],
189	n/a	watcher=None):
190	n/a	self.argument = argument
191	n/a	if renames and not self._can_rename:
192	n/a	raise RuntimeError, "This unpacker cannot rename files"
193	n/a	self._dir = dir
194	n/a	self._renames = renames
195	n/a	self._watcher = watcher
196	n/a
197	n/a	def unpack(self, archive, output=None, package=None):
198	n/a	return None
199	n/a
200	n/a	def update(self, str):
201	n/a	if self._watcher:
202	n/a	return self._watcher.update(str)
203	n/a	return True
204	n/a
205	n/a	class PimpCommandUnpacker(PimpUnpacker):
206	n/a	"""Unpack archives by calling a Unix utility"""
207	n/a
208	n/a	_can_rename = False
209	n/a
210	n/a	def unpack(self, archive, output=None, package=None):
211	n/a	cmd = self.argument % archive
212	n/a	if _cmd(output, self._dir, cmd):
213	n/a	return "unpack command failed"
214	n/a
215	n/a	class PimpTarUnpacker(PimpUnpacker):
216	n/a	"""Unpack tarfiles using the builtin tarfile module"""
217	n/a
218	n/a	_can_rename = True
219	n/a
220	n/a	def unpack(self, archive, output=None, package=None):
221	n/a	tf = tarfile.open(archive, "r")
222	n/a	members = tf.getmembers()
223	n/a	skip = []
224	n/a	if self._renames:
225	n/a	for member in members:
226	n/a	for oldprefix, newprefix in self._renames:
227	n/a	if oldprefix[:len(self._dir)] == self._dir:
228	n/a	oldprefix2 = oldprefix[len(self._dir):]
229	n/a	else:
230	n/a	oldprefix2 = None
231	n/a	if member.name[:len(oldprefix)] == oldprefix:
232	n/a	if newprefix is None:
233	n/a	skip.append(member)
234	n/a	#print 'SKIP', member.name
235	n/a	else:
236	n/a	member.name = newprefix + member.name[len(oldprefix):]
237	n/a	print ' ', member.name
238	n/a	break
239	n/a	elif oldprefix2 and member.name[:len(oldprefix2)] == oldprefix2:
240	n/a	if newprefix is None:
241	n/a	skip.append(member)
242	n/a	#print 'SKIP', member.name
243	n/a	else:
244	n/a	member.name = newprefix + member.name[len(oldprefix2):]
245	n/a	#print ' ', member.name
246	n/a	break
247	n/a	else:
248	n/a	skip.append(member)
249	n/a	#print '????', member.name
250	n/a	for member in members:
251	n/a	if member in skip:
252	n/a	self.update("Skipping %s" % member.name)
253	n/a	continue
254	n/a	self.update("Extracting %s" % member.name)
255	n/a	tf.extract(member, self._dir)
256	n/a	if skip:
257	n/a	names = [member.name for member in skip if member.name[-1] != '/']
258	n/a	if package:
259	n/a	names = package.filterExpectedSkips(names)
260	n/a	if names:
261	n/a	return "Not all files were unpacked: %s" % " ".join(names)
262	n/a
263	n/a	ARCHIVE_FORMATS = [
264	n/a	(".tar.Z", PimpTarUnpacker, None),
265	n/a	(".taz", PimpTarUnpacker, None),
266	n/a	(".tar.gz", PimpTarUnpacker, None),
267	n/a	(".tgz", PimpTarUnpacker, None),
268	n/a	(".tar.bz", PimpTarUnpacker, None),
269	n/a	(".zip", PimpCommandUnpacker, "unzip \"%s\""),
270	n/a	]
271	n/a
272	n/a	class PimpPreferences:
273	n/a	"""Container for per-user preferences, such as the database to use
274	n/a	and where to install packages."""
275	n/a
276	n/a	def __init__(self,
277	n/a	flavorOrder=None,
278	n/a	downloadDir=None,
279	n/a	buildDir=None,
280	n/a	installDir=None,
281	n/a	pimpDatabase=None):
282	n/a	if not flavorOrder:
283	n/a	flavorOrder = DEFAULT_FLAVORORDER
284	n/a	if not downloadDir:
285	n/a	downloadDir = DEFAULT_DOWNLOADDIR
286	n/a	if not buildDir:
287	n/a	buildDir = DEFAULT_BUILDDIR
288	n/a	if not pimpDatabase:
289	n/a	pimpDatabase = getDefaultDatabase()
290	n/a	self.setInstallDir(installDir)
291	n/a	self.flavorOrder = flavorOrder
292	n/a	self.downloadDir = downloadDir
293	n/a	self.buildDir = buildDir
294	n/a	self.pimpDatabase = pimpDatabase
295	n/a	self.watcher = None
296	n/a
297	n/a	def setWatcher(self, watcher):
298	n/a	self.watcher = watcher
299	n/a
300	n/a	def setInstallDir(self, installDir=None):
301	n/a	if installDir:
302	n/a	# Installing to non-standard location.
303	n/a	self.installLocations = [
304	n/a	('--install-lib', installDir),
305	n/a	('--install-headers', None),
306	n/a	('--install-scripts', None),
307	n/a	('--install-data', None)]
308	n/a	else:
309	n/a	installDir = DEFAULT_INSTALLDIR
310	n/a	self.installLocations = []
311	n/a	self.installDir = installDir
312	n/a
313	n/a	def isUserInstall(self):
314	n/a	return self.installDir != DEFAULT_INSTALLDIR
315	n/a
316	n/a	def check(self):
317	n/a	"""Check that the preferences make sense: directories exist and are
318	n/a	writable, the install directory is on sys.path, etc."""
319	n/a
320	n/a	rv = ""
321	n/a	RWX_OK = os.R_OK\|os.W_OK\|os.X_OK
322	n/a	if not os.path.exists(self.downloadDir):
323	n/a	rv += "Warning: Download directory \"%s\" does not exist\n" % self.downloadDir
324	n/a	elif not os.access(self.downloadDir, RWX_OK):
325	n/a	rv += "Warning: Download directory \"%s\" is not writable or not readable\n" % self.downloadDir
326	n/a	if not os.path.exists(self.buildDir):
327	n/a	rv += "Warning: Build directory \"%s\" does not exist\n" % self.buildDir
328	n/a	elif not os.access(self.buildDir, RWX_OK):
329	n/a	rv += "Warning: Build directory \"%s\" is not writable or not readable\n" % self.buildDir
330	n/a	if not os.path.exists(self.installDir):
331	n/a	rv += "Warning: Install directory \"%s\" does not exist\n" % self.installDir
332	n/a	elif not os.access(self.installDir, RWX_OK):
333	n/a	rv += "Warning: Install directory \"%s\" is not writable or not readable\n" % self.installDir
334	n/a	else:
335	n/a	installDir = os.path.realpath(self.installDir)
336	n/a	for p in sys.path:
337	n/a	try:
338	n/a	realpath = os.path.realpath(p)
339	n/a	except:
340	n/a	pass
341	n/a	if installDir == realpath:
342	n/a	break
343	n/a	else:
344	n/a	rv += "Warning: Install directory \"%s\" is not on sys.path\n" % self.installDir
345	n/a	return rv
346	n/a
347	n/a	def compareFlavors(self, left, right):
348	n/a	"""Compare two flavor strings. This is part of your preferences
349	n/a	because whether the user prefers installing from source or binary is."""
350	n/a	if left in self.flavorOrder:
351	n/a	if right in self.flavorOrder:
352	n/a	return cmp(self.flavorOrder.index(left), self.flavorOrder.index(right))
353	n/a	return -1
354	n/a	if right in self.flavorOrder:
355	n/a	return 1
356	n/a	return cmp(left, right)
357	n/a
358	n/a	class PimpDatabase:
359	n/a	"""Class representing a pimp database. It can actually contain
360	n/a	information from multiple databases through inclusion, but the
361	n/a	toplevel database is considered the master, as its maintainer is
362	n/a	"responsible" for the contents."""
363	n/a
364	n/a	def __init__(self, prefs):
365	n/a	self._packages = []
366	n/a	self.preferences = prefs
367	n/a	self._url = ""
368	n/a	self._urllist = []
369	n/a	self._version = ""
370	n/a	self._maintainer = ""
371	n/a	self._description = ""
372	n/a
373	n/a	# Accessor functions
374	n/a	def url(self): return self._url
375	n/a	def version(self): return self._version
376	n/a	def maintainer(self): return self._maintainer
377	n/a	def description(self): return self._description
378	n/a
379	n/a	def close(self):
380	n/a	"""Clean up"""
381	n/a	self._packages = []
382	n/a	self.preferences = None
383	n/a
384	n/a	def appendURL(self, url, included=0):
385	n/a	"""Append packages from the database with the given URL.
386	n/a	Only the first database should specify included=0, so the
387	n/a	global information (maintainer, description) get stored."""
388	n/a
389	n/a	if url in self._urllist:
390	n/a	return
391	n/a	self._urllist.append(url)
392	n/a	fp = urllib2.urlopen(url).fp
393	n/a	plistdata = plistlib.Plist.fromFile(fp)
394	n/a	# Test here for Pimp version, etc
395	n/a	if included:
396	n/a	version = plistdata.get('Version')
397	n/a	if version and version > self._version:
398	n/a	sys.stderr.write("Warning: included database %s is for pimp version %s\n" %
399	n/a	(url, version))
400	n/a	else:
401	n/a	self._version = plistdata.get('Version')
402	n/a	if not self._version:
403	n/a	sys.stderr.write("Warning: database has no Version information\n")
404	n/a	elif self._version > PIMP_VERSION:
405	n/a	sys.stderr.write("Warning: database version %s newer than pimp version %s\n"
406	n/a	% (self._version, PIMP_VERSION))
407	n/a	self._maintainer = plistdata.get('Maintainer', '')
408	n/a	self._description = plistdata.get('Description', '').strip()
409	n/a	self._url = url
410	n/a	self._appendPackages(plistdata['Packages'], url)
411	n/a	others = plistdata.get('Include', [])
412	n/a	for o in others:
413	n/a	o = urllib.basejoin(url, o)
414	n/a	self.appendURL(o, included=1)
415	n/a
416	n/a	def _appendPackages(self, packages, url):
417	n/a	"""Given a list of dictionaries containing package
418	n/a	descriptions create the PimpPackage objects and append them
419	n/a	to our internal storage."""
420	n/a
421	n/a	for p in packages:
422	n/a	p = dict(p)
423	n/a	if 'Download-URL' in p:
424	n/a	p['Download-URL'] = urllib.basejoin(url, p['Download-URL'])
425	n/a	flavor = p.get('Flavor')
426	n/a	if flavor == 'source':
427	n/a	pkg = PimpPackage_source(self, p)
428	n/a	elif flavor == 'binary':
429	n/a	pkg = PimpPackage_binary(self, p)
430	n/a	elif flavor == 'installer':
431	n/a	pkg = PimpPackage_installer(self, p)
432	n/a	elif flavor == 'hidden':
433	n/a	pkg = PimpPackage_installer(self, p)
434	n/a	else:
435	n/a	pkg = PimpPackage(self, dict(p))
436	n/a	self._packages.append(pkg)
437	n/a
438	n/a	def list(self):
439	n/a	"""Return a list of all PimpPackage objects in the database."""
440	n/a
441	n/a	return self._packages
442	n/a
443	n/a	def listnames(self):
444	n/a	"""Return a list of names of all packages in the database."""
445	n/a
446	n/a	rv = []
447	n/a	for pkg in self._packages:
448	n/a	rv.append(pkg.fullname())
449	n/a	rv.sort()
450	n/a	return rv
451	n/a
452	n/a	def dump(self, pathOrFile):
453	n/a	"""Dump the contents of the database to an XML .plist file.
454	n/a
455	n/a	The file can be passed as either a file object or a pathname.
456	n/a	All data, including included databases, is dumped."""
457	n/a
458	n/a	packages = []
459	n/a	for pkg in self._packages:
460	n/a	packages.append(pkg.dump())
461	n/a	plistdata = {
462	n/a	'Version': self._version,
463	n/a	'Maintainer': self._maintainer,
464	n/a	'Description': self._description,
465	n/a	'Packages': packages
466	n/a	}
467	n/a	plist = plistlib.Plist(**plistdata)
468	n/a	plist.write(pathOrFile)
469	n/a
470	n/a	def find(self, ident):
471	n/a	"""Find a package. The package can be specified by name
472	n/a	or as a dictionary with name, version and flavor entries.
473	n/a
474	n/a	Only name is obligatory. If there are multiple matches the
475	n/a	best one (higher version number, flavors ordered according to
476	n/a	users' preference) is returned."""
477	n/a
478	n/a	if type(ident) == str:
479	n/a	# Remove ( and ) for pseudo-packages
480	n/a	if ident[0] == '(' and ident[-1] == ')':
481	n/a	ident = ident[1:-1]
482	n/a	# Split into name-version-flavor
483	n/a	fields = ident.split('-')
484	n/a	if len(fields) < 1 or len(fields) > 3:
485	n/a	return None
486	n/a	name = fields[0]
487	n/a	if len(fields) > 1:
488	n/a	version = fields[1]
489	n/a	else:
490	n/a	version = None
491	n/a	if len(fields) > 2:
492	n/a	flavor = fields[2]
493	n/a	else:
494	n/a	flavor = None
495	n/a	else:
496	n/a	name = ident['Name']
497	n/a	version = ident.get('Version')
498	n/a	flavor = ident.get('Flavor')
499	n/a	found = None
500	n/a	for p in self._packages:
501	n/a	if name == p.name() and \
502	n/a	(not version or version == p.version()) and \
503	n/a	(not flavor or flavor == p.flavor()):
504	n/a	if not found or found < p:
505	n/a	found = p
506	n/a	return found
507	n/a
508	n/a	ALLOWED_KEYS = [
509	n/a	"Name",
510	n/a	"Version",
511	n/a	"Flavor",
512	n/a	"Description",
513	n/a	"Home-page",
514	n/a	"Download-URL",
515	n/a	"Install-test",
516	n/a	"Install-command",
517	n/a	"Pre-install-command",
518	n/a	"Post-install-command",
519	n/a	"Prerequisites",
520	n/a	"MD5Sum",
521	n/a	"User-install-skips",
522	n/a	"Systemwide-only",
523	n/a	]
524	n/a
525	n/a	class PimpPackage:
526	n/a	"""Class representing a single package."""
527	n/a
528	n/a	def __init__(self, db, plistdata):
529	n/a	self._db = db
530	n/a	name = plistdata["Name"]
531	n/a	for k in plistdata.keys():
532	n/a	if not k in ALLOWED_KEYS:
533	n/a	sys.stderr.write("Warning: %s: unknown key %s\n" % (name, k))
534	n/a	self._dict = plistdata
535	n/a
536	n/a	def __getitem__(self, key):
537	n/a	return self._dict[key]
538	n/a
539	n/a	def name(self): return self._dict['Name']
540	n/a	def version(self): return self._dict.get('Version')
541	n/a	def flavor(self): return self._dict.get('Flavor')
542	n/a	def description(self): return self._dict['Description'].strip()
543	n/a	def shortdescription(self): return self.description().splitlines()[0]
544	n/a	def homepage(self): return self._dict.get('Home-page')
545	n/a	def downloadURL(self): return self._dict.get('Download-URL')
546	n/a	def systemwideOnly(self): return self._dict.get('Systemwide-only')
547	n/a
548	n/a	def fullname(self):
549	n/a	"""Return the full name "name-version-flavor" of a package.
550	n/a
551	n/a	If the package is a pseudo-package, something that cannot be
552	n/a	installed through pimp, return the name in (parentheses)."""
553	n/a
554	n/a	rv = self._dict['Name']
555	n/a	if 'Version' in self._dict:
556	n/a	rv = rv + '-%s' % self._dict['Version']
557	n/a	if 'Flavor' in self._dict:
558	n/a	rv = rv + '-%s' % self._dict['Flavor']
559	n/a	if self._dict.get('Flavor') == 'hidden':
560	n/a	# Pseudo-package, show in parentheses
561	n/a	rv = '(%s)' % rv
562	n/a	return rv
563	n/a
564	n/a	def dump(self):
565	n/a	"""Return a dict object containing the information on the package."""
566	n/a	return self._dict
567	n/a
568	n/a	def __cmp__(self, other):
569	n/a	"""Compare two packages, where the "better" package sorts lower."""
570	n/a
571	n/a	if not isinstance(other, PimpPackage):
572	n/a	return cmp(id(self), id(other))
573	n/a	if self.name() != other.name():
574	n/a	return cmp(self.name(), other.name())
575	n/a	if self.version() != other.version():
576	n/a	return -cmp(self.version(), other.version())
577	n/a	return self._db.preferences.compareFlavors(self.flavor(), other.flavor())
578	n/a
579	n/a	def installed(self):
580	n/a	"""Test wheter the package is installed.
581	n/a
582	n/a	Returns two values: a status indicator which is one of
583	n/a	"yes", "no", "old" (an older version is installed) or "bad"
584	n/a	(something went wrong during the install test) and a human
585	n/a	readable string which may contain more details."""
586	n/a
587	n/a	namespace = {
588	n/a	"NotInstalled": _scriptExc_NotInstalled,
589	n/a	"OldInstalled": _scriptExc_OldInstalled,
590	n/a	"BadInstalled": _scriptExc_BadInstalled,
591	n/a	"os": os,
592	n/a	"sys": sys,
593	n/a	}
594	n/a	installTest = self._dict['Install-test'].strip() + '\n'
595	n/a	try:
596	n/a	exec installTest in namespace
597	n/a	except ImportError, arg:
598	n/a	return "no", str(arg)
599	n/a	except _scriptExc_NotInstalled, arg:
600	n/a	return "no", str(arg)
601	n/a	except _scriptExc_OldInstalled, arg:
602	n/a	return "old", str(arg)
603	n/a	except _scriptExc_BadInstalled, arg:
604	n/a	return "bad", str(arg)
605	n/a	except:
606	n/a	sys.stderr.write("-------------------------------------\n")
607	n/a	sys.stderr.write("---- %s: install test got exception\n" % self.fullname())
608	n/a	sys.stderr.write("---- source:\n")
609	n/a	sys.stderr.write(installTest)
610	n/a	sys.stderr.write("---- exception:\n")
611	n/a	import traceback
612	n/a	traceback.print_exc(file=sys.stderr)
613	n/a	if self._db._maintainer:
614	n/a	sys.stderr.write("---- Please copy this and mail to %s\n" % self._db._maintainer)
615	n/a	sys.stderr.write("-------------------------------------\n")
616	n/a	return "bad", "Package install test got exception"
617	n/a	return "yes", ""
618	n/a
619	n/a	def prerequisites(self):
620	n/a	"""Return a list of prerequisites for this package.
621	n/a
622	n/a	The list contains 2-tuples, of which the first item is either
623	n/a	a PimpPackage object or None, and the second is a descriptive
624	n/a	string. The first item can be None if this package depends on
625	n/a	something that isn't pimp-installable, in which case the descriptive
626	n/a	string should tell the user what to do."""
627	n/a
628	n/a	rv = []
629	n/a	if not self._dict.get('Download-URL'):
630	n/a	# For pseudo-packages that are already installed we don't
631	n/a	# return an error message
632	n/a	status, _ = self.installed()
633	n/a	if status == "yes":
634	n/a	return []
635	n/a	return [(None,
636	n/a	"Package %s cannot be installed automatically, see the description" %
637	n/a	self.fullname())]
638	n/a	if self.systemwideOnly() and self._db.preferences.isUserInstall():
639	n/a	return [(None,
640	n/a	"Package %s can only be installed system-wide" %
641	n/a	self.fullname())]
642	n/a	if not self._dict.get('Prerequisites'):
643	n/a	return []
644	n/a	for item in self._dict['Prerequisites']:
645	n/a	if type(item) == str:
646	n/a	pkg = None
647	n/a	descr = str(item)
648	n/a	else:
649	n/a	name = item['Name']
650	n/a	if 'Version' in item:
651	n/a	name = name + '-' + item['Version']
652	n/a	if 'Flavor' in item:
653	n/a	name = name + '-' + item['Flavor']
654	n/a	pkg = self._db.find(name)
655	n/a	if not pkg:
656	n/a	descr = "Requires unknown %s"%name
657	n/a	else:
658	n/a	descr = pkg.shortdescription()
659	n/a	rv.append((pkg, descr))
660	n/a	return rv
661	n/a
662	n/a
663	n/a	def downloadPackageOnly(self, output=None):
664	n/a	"""Download a single package, if needed.
665	n/a
666	n/a	An MD5 signature is used to determine whether download is needed,
667	n/a	and to test that we actually downloaded what we expected.
668	n/a	If output is given it is a file-like object that will receive a log
669	n/a	of what happens.
670	n/a
671	n/a	If anything unforeseen happened the method returns an error message
672	n/a	string.
673	n/a	"""
674	n/a
675	n/a	scheme, loc, path, query, frag = urlparse.urlsplit(self._dict['Download-URL'])
676	n/a	path = urllib.url2pathname(path)
677	n/a	filename = os.path.split(path)[1]
678	n/a	self.archiveFilename = os.path.join(self._db.preferences.downloadDir, filename)
679	n/a	if not self._archiveOK():
680	n/a	if scheme == 'manual':
681	n/a	return "Please download package manually and save as %s" % self.archiveFilename
682	n/a	downloader = PimpUrllibDownloader(None, self._db.preferences.downloadDir,
683	n/a	watcher=self._db.preferences.watcher)
684	n/a	if not downloader.download(self._dict['Download-URL'],
685	n/a	self.archiveFilename, output):
686	n/a	return "download command failed"
687	n/a	if not os.path.exists(self.archiveFilename) and not NO_EXECUTE:
688	n/a	return "archive not found after download"
689	n/a	if not self._archiveOK():
690	n/a	return "archive does not have correct MD5 checksum"
691	n/a
692	n/a	def _archiveOK(self):
693	n/a	"""Test an archive. It should exist and the MD5 checksum should be correct."""
694	n/a
695	n/a	if not os.path.exists(self.archiveFilename):
696	n/a	return 0
697	n/a	if not self._dict.get('MD5Sum'):
698	n/a	sys.stderr.write("Warning: no MD5Sum for %s\n" % self.fullname())
699	n/a	return 1
700	n/a	data = open(self.archiveFilename, 'rb').read()
701	n/a	checksum = hashlib.md5(data).hexdigest()
702	n/a	return checksum == self._dict['MD5Sum']
703	n/a
704	n/a	def unpackPackageOnly(self, output=None):
705	n/a	"""Unpack a downloaded package archive."""
706	n/a
707	n/a	filename = os.path.split(self.archiveFilename)[1]
708	n/a	for ext, unpackerClass, arg in ARCHIVE_FORMATS:
709	n/a	if filename[-len(ext):] == ext:
710	n/a	break
711	n/a	else:
712	n/a	return "unknown extension for archive file: %s" % filename
713	n/a	self.basename = filename[:-len(ext)]
714	n/a	unpacker = unpackerClass(arg, dir=self._db.preferences.buildDir,
715	n/a	watcher=self._db.preferences.watcher)
716	n/a	rv = unpacker.unpack(self.archiveFilename, output=output)
717	n/a	if rv:
718	n/a	return rv
719	n/a
720	n/a	def installPackageOnly(self, output=None):
721	n/a	"""Default install method, to be overridden by subclasses"""
722	n/a	return "%s: This package needs to be installed manually (no support for flavor=\"%s\")" \
723	n/a	% (self.fullname(), self._dict.get(flavor, ""))
724	n/a
725	n/a	def installSinglePackage(self, output=None):
726	n/a	"""Download, unpack and install a single package.
727	n/a
728	n/a	If output is given it should be a file-like object and it
729	n/a	will receive a log of what happened."""
730	n/a
731	n/a	if not self._dict.get('Download-URL'):
732	n/a	return "%s: This package needs to be installed manually (no Download-URL field)" % self.fullname()
733	n/a	msg = self.downloadPackageOnly(output)
734	n/a	if msg:
735	n/a	return "%s: download: %s" % (self.fullname(), msg)
736	n/a
737	n/a	msg = self.unpackPackageOnly(output)
738	n/a	if msg:
739	n/a	return "%s: unpack: %s" % (self.fullname(), msg)
740	n/a
741	n/a	return self.installPackageOnly(output)
742	n/a
743	n/a	def beforeInstall(self):
744	n/a	"""Bookkeeping before installation: remember what we have in site-packages"""
745	n/a	self._old_contents = os.listdir(self._db.preferences.installDir)
746	n/a
747	n/a	def afterInstall(self):
748	n/a	"""Bookkeeping after installation: interpret any new .pth files that have
749	n/a	appeared"""
750	n/a
751	n/a	new_contents = os.listdir(self._db.preferences.installDir)
752	n/a	for fn in new_contents:
753	n/a	if fn in self._old_contents:
754	n/a	continue
755	n/a	if fn[-4:] != '.pth':
756	n/a	continue
757	n/a	fullname = os.path.join(self._db.preferences.installDir, fn)
758	n/a	f = open(fullname)
759	n/a	for line in f.readlines():
760	n/a	if not line:
761	n/a	continue
762	n/a	if line[0] == '#':
763	n/a	continue
764	n/a	if line[:6] == 'import':
765	n/a	exec line
766	n/a	continue
767	n/a	if line[-1] == '\n':
768	n/a	line = line[:-1]
769	n/a	if not os.path.isabs(line):
770	n/a	line = os.path.join(self._db.preferences.installDir, line)
771	n/a	line = os.path.realpath(line)
772	n/a	if not line in sys.path:
773	n/a	sys.path.append(line)
774	n/a
775	n/a	def filterExpectedSkips(self, names):
776	n/a	"""Return a list that contains only unpexpected skips"""
777	n/a	if not self._db.preferences.isUserInstall():
778	n/a	return names
779	n/a	expected_skips = self._dict.get('User-install-skips')
780	n/a	if not expected_skips:
781	n/a	return names
782	n/a	newnames = []
783	n/a	for name in names:
784	n/a	for skip in expected_skips:
785	n/a	if name[:len(skip)] == skip:
786	n/a	break
787	n/a	else:
788	n/a	newnames.append(name)
789	n/a	return newnames
790	n/a
791	n/a	class PimpPackage_binary(PimpPackage):
792	n/a
793	n/a	def unpackPackageOnly(self, output=None):
794	n/a	"""We don't unpack binary packages until installing"""
795	n/a	pass
796	n/a
797	n/a	def installPackageOnly(self, output=None):
798	n/a	"""Install a single source package.
799	n/a
800	n/a	If output is given it should be a file-like object and it
801	n/a	will receive a log of what happened."""
802	n/a
803	n/a	if 'Install-command' in self._dict:
804	n/a	return "%s: Binary package cannot have Install-command" % self.fullname()
805	n/a
806	n/a	if 'Pre-install-command' in self._dict:
807	n/a	if _cmd(output, '/tmp', self._dict['Pre-install-command']):
808	n/a	return "pre-install %s: running \"%s\" failed" % \
809	n/a	(self.fullname(), self._dict['Pre-install-command'])
810	n/a
811	n/a	self.beforeInstall()
812	n/a
813	n/a	# Install by unpacking
814	n/a	filename = os.path.split(self.archiveFilename)[1]
815	n/a	for ext, unpackerClass, arg in ARCHIVE_FORMATS:
816	n/a	if filename[-len(ext):] == ext:
817	n/a	break
818	n/a	else:
819	n/a	return "%s: unknown extension for archive file: %s" % (self.fullname(), filename)
820	n/a	self.basename = filename[:-len(ext)]
821	n/a
822	n/a	install_renames = []
823	n/a	for k, newloc in self._db.preferences.installLocations:
824	n/a	if not newloc:
825	n/a	continue
826	n/a	if k == "--install-lib":
827	n/a	oldloc = DEFAULT_INSTALLDIR
828	n/a	else:
829	n/a	return "%s: Don't know installLocation %s" % (self.fullname(), k)
830	n/a	install_renames.append((oldloc, newloc))
831	n/a
832	n/a	unpacker = unpackerClass(arg, dir="/", renames=install_renames)
833	n/a	rv = unpacker.unpack(self.archiveFilename, output=output, package=self)
834	n/a	if rv:
835	n/a	return rv
836	n/a
837	n/a	self.afterInstall()
838	n/a
839	n/a	if 'Post-install-command' in self._dict:
840	n/a	if _cmd(output, '/tmp', self._dict['Post-install-command']):
841	n/a	return "%s: post-install: running \"%s\" failed" % \
842	n/a	(self.fullname(), self._dict['Post-install-command'])
843	n/a
844	n/a	return None
845	n/a
846	n/a
847	n/a	class PimpPackage_source(PimpPackage):
848	n/a
849	n/a	def unpackPackageOnly(self, output=None):
850	n/a	"""Unpack a source package and check that setup.py exists"""
851	n/a	PimpPackage.unpackPackageOnly(self, output)
852	n/a	# Test that a setup script has been create
853	n/a	self._buildDirname = os.path.join(self._db.preferences.buildDir, self.basename)
854	n/a	setupname = os.path.join(self._buildDirname, "setup.py")
855	n/a	if not os.path.exists(setupname) and not NO_EXECUTE:
856	n/a	return "no setup.py found after unpack of archive"
857	n/a
858	n/a	def installPackageOnly(self, output=None):
859	n/a	"""Install a single source package.
860	n/a
861	n/a	If output is given it should be a file-like object and it
862	n/a	will receive a log of what happened."""
863	n/a
864	n/a	if 'Pre-install-command' in self._dict:
865	n/a	if _cmd(output, self._buildDirname, self._dict['Pre-install-command']):
866	n/a	return "pre-install %s: running \"%s\" failed" % \
867	n/a	(self.fullname(), self._dict['Pre-install-command'])
868	n/a
869	n/a	self.beforeInstall()
870	n/a	installcmd = self._dict.get('Install-command')
871	n/a	if installcmd and self._install_renames:
872	n/a	return "Package has install-command and can only be installed to standard location"
873	n/a	# This is the "bit-bucket" for installations: everything we don't
874	n/a	# want. After installation we check that it is actually empty
875	n/a	unwanted_install_dir = None
876	n/a	if not installcmd:
877	n/a	extra_args = ""
878	n/a	for k, v in self._db.preferences.installLocations:
879	n/a	if not v:
880	n/a	# We don't want these files installed. Send them
881	n/a	# to the bit-bucket.
882	n/a	if not unwanted_install_dir:
883	n/a	unwanted_install_dir = tempfile.mkdtemp()
884	n/a	v = unwanted_install_dir
885	n/a	extra_args = extra_args + " %s \"%s\"" % (k, v)
886	n/a	installcmd = '"%s" setup.py install %s' % (sys.executable, extra_args)
887	n/a	if _cmd(output, self._buildDirname, installcmd):
888	n/a	return "install %s: running \"%s\" failed" % \
889	n/a	(self.fullname(), installcmd)
890	n/a	if unwanted_install_dir and os.path.exists(unwanted_install_dir):
891	n/a	unwanted_files = os.listdir(unwanted_install_dir)
892	n/a	if unwanted_files:
893	n/a	rv = "Warning: some files were not installed: %s" % " ".join(unwanted_files)
894	n/a	else:
895	n/a	rv = None
896	n/a	shutil.rmtree(unwanted_install_dir)
897	n/a	return rv
898	n/a
899	n/a	self.afterInstall()
900	n/a
901	n/a	if 'Post-install-command' in self._dict:
902	n/a	if _cmd(output, self._buildDirname, self._dict['Post-install-command']):
903	n/a	return "post-install %s: running \"%s\" failed" % \
904	n/a	(self.fullname(), self._dict['Post-install-command'])
905	n/a	return None
906	n/a
907	n/a	class PimpPackage_installer(PimpPackage):
908	n/a
909	n/a	def unpackPackageOnly(self, output=None):
910	n/a	"""We don't unpack dmg packages until installing"""
911	n/a	pass
912	n/a
913	n/a	def installPackageOnly(self, output=None):
914	n/a	"""Install a single source package.
915	n/a
916	n/a	If output is given it should be a file-like object and it
917	n/a	will receive a log of what happened."""
918	n/a
919	n/a	if 'Post-install-command' in self._dict:
920	n/a	return "%s: Installer package cannot have Post-install-command" % self.fullname()
921	n/a
922	n/a	if 'Pre-install-command' in self._dict:
923	n/a	if _cmd(output, '/tmp', self._dict['Pre-install-command']):
924	n/a	return "pre-install %s: running \"%s\" failed" % \
925	n/a	(self.fullname(), self._dict['Pre-install-command'])
926	n/a
927	n/a	self.beforeInstall()
928	n/a
929	n/a	installcmd = self._dict.get('Install-command')
930	n/a	if installcmd:
931	n/a	if '%' in installcmd:
932	n/a	installcmd = installcmd % self.archiveFilename
933	n/a	else:
934	n/a	installcmd = 'open \"%s\"' % self.archiveFilename
935	n/a	if _cmd(output, "/tmp", installcmd):
936	n/a	return '%s: install command failed (use verbose for details)' % self.fullname()
937	n/a	return '%s: downloaded and opened. Install manually and restart Package Manager' % self.archiveFilename
938	n/a
939	n/a	class PimpInstaller:
940	n/a	"""Installer engine: computes dependencies and installs
941	n/a	packages in the right order."""
942	n/a
943	n/a	def __init__(self, db):
944	n/a	self._todo = []
945	n/a	self._db = db
946	n/a	self._curtodo = []
947	n/a	self._curmessages = []
948	n/a
949	n/a	def __contains__(self, package):
950	n/a	return package in self._todo
951	n/a
952	n/a	def _addPackages(self, packages):
953	n/a	for package in packages:
954	n/a	if not package in self._todo:
955	n/a	self._todo.append(package)
956	n/a
957	n/a	def _prepareInstall(self, package, force=0, recursive=1):
958	n/a	"""Internal routine, recursive engine for prepareInstall.
959	n/a
960	n/a	Test whether the package is installed and (if not installed
961	n/a	or if force==1) prepend it to the temporary todo list and
962	n/a	call ourselves recursively on all prerequisites."""
963	n/a
964	n/a	if not force:
965	n/a	status, message = package.installed()
966	n/a	if status == "yes":
967	n/a	return
968	n/a	if package in self._todo or package in self._curtodo:
969	n/a	return
970	n/a	self._curtodo.insert(0, package)
971	n/a	if not recursive:
972	n/a	return
973	n/a	prereqs = package.prerequisites()
974	n/a	for pkg, descr in prereqs:
975	n/a	if pkg:
976	n/a	self._prepareInstall(pkg, False, recursive)
977	n/a	else:
978	n/a	self._curmessages.append("Problem with dependency: %s" % descr)
979	n/a
980	n/a	def prepareInstall(self, package, force=0, recursive=1):
981	n/a	"""Prepare installation of a package.
982	n/a
983	n/a	If the package is already installed and force is false nothing
984	n/a	is done. If recursive is true prerequisites are installed first.
985	n/a
986	n/a	Returns a list of packages (to be passed to install) and a list
987	n/a	of messages of any problems encountered.
988	n/a	"""
989	n/a
990	n/a	self._curtodo = []
991	n/a	self._curmessages = []
992	n/a	self._prepareInstall(package, force, recursive)
993	n/a	rv = self._curtodo, self._curmessages
994	n/a	self._curtodo = []
995	n/a	self._curmessages = []
996	n/a	return rv
997	n/a
998	n/a	def install(self, packages, output):
999	n/a	"""Install a list of packages."""
1000	n/a
1001	n/a	self._addPackages(packages)
1002	n/a	status = []
1003	n/a	for pkg in self._todo:
1004	n/a	msg = pkg.installSinglePackage(output)
1005	n/a	if msg:
1006	n/a	status.append(msg)
1007	n/a	return status
1008	n/a
1009	n/a
1010	n/a
1011	n/a	def _run(mode, verbose, force, args, prefargs, watcher):
1012	n/a	"""Engine for the main program"""
1013	n/a
1014	n/a	prefs = PimpPreferences(**prefargs)
1015	n/a	if watcher:
1016	n/a	prefs.setWatcher(watcher)
1017	n/a	rv = prefs.check()
1018	n/a	if rv:
1019	n/a	sys.stdout.write(rv)
1020	n/a	db = PimpDatabase(prefs)
1021	n/a	db.appendURL(prefs.pimpDatabase)
1022	n/a
1023	n/a	if mode == 'dump':
1024	n/a	db.dump(sys.stdout)
1025	n/a	elif mode =='list':
1026	n/a	if not args:
1027	n/a	args = db.listnames()
1028	n/a	print "%-20.20s\t%s" % ("Package", "Description")
1029	n/a	print
1030	n/a	for pkgname in args:
1031	n/a	pkg = db.find(pkgname)
1032	n/a	if pkg:
1033	n/a	description = pkg.shortdescription()
1034	n/a	pkgname = pkg.fullname()
1035	n/a	else:
1036	n/a	description = 'Error: no such package'
1037	n/a	print "%-20.20s\t%s" % (pkgname, description)
1038	n/a	if verbose:
1039	n/a	print "\tHome page:\t", pkg.homepage()
1040	n/a	try:
1041	n/a	print "\tDownload URL:\t", pkg.downloadURL()
1042	n/a	except KeyError:
1043	n/a	pass
1044	n/a	description = pkg.description()
1045	n/a	description = '\n\t\t\t\t\t'.join(description.splitlines())
1046	n/a	print "\tDescription:\t%s" % description
1047	n/a	elif mode =='status':
1048	n/a	if not args:
1049	n/a	args = db.listnames()
1050	n/a	print "%-20.20s\t%s\t%s" % ("Package", "Installed", "Message")
1051	n/a	print
1052	n/a	for pkgname in args:
1053	n/a	pkg = db.find(pkgname)
1054	n/a	if pkg:
1055	n/a	status, msg = pkg.installed()
1056	n/a	pkgname = pkg.fullname()
1057	n/a	else:
1058	n/a	status = 'error'
1059	n/a	msg = 'No such package'
1060	n/a	print "%-20.20s\t%-9.9s\t%s" % (pkgname, status, msg)
1061	n/a	if verbose and status == "no":
1062	n/a	prereq = pkg.prerequisites()
1063	n/a	for pkg, msg in prereq:
1064	n/a	if not pkg:
1065	n/a	pkg = ''
1066	n/a	else:
1067	n/a	pkg = pkg.fullname()
1068	n/a	print "%-20.20s\tRequirement: %s %s" % ("", pkg, msg)
1069	n/a	elif mode == 'install':
1070	n/a	if not args:
1071	n/a	print 'Please specify packages to install'
1072	n/a	sys.exit(1)
1073	n/a	inst = PimpInstaller(db)
1074	n/a	for pkgname in args:
1075	n/a	pkg = db.find(pkgname)
1076	n/a	if not pkg:
1077	n/a	print '%s: No such package' % pkgname
1078	n/a	continue
1079	n/a	list, messages = inst.prepareInstall(pkg, force)
1080	n/a	if messages and not force:
1081	n/a	print "%s: Not installed:" % pkgname
1082	n/a	for m in messages:
1083	n/a	print "\t", m
1084	n/a	else:
1085	n/a	if verbose:
1086	n/a	output = sys.stdout
1087	n/a	else:
1088	n/a	output = None
1089	n/a	messages = inst.install(list, output)
1090	n/a	if messages:
1091	n/a	print "%s: Not installed:" % pkgname
1092	n/a	for m in messages:
1093	n/a	print "\t", m
1094	n/a
1095	n/a	def main():
1096	n/a	"""Minimal commandline tool to drive pimp."""
1097	n/a
1098	n/a	import getopt
1099	n/a	def _help():
1100	n/a	print "Usage: pimp [options] -s [package ...] List installed status"
1101	n/a	print " pimp [options] -l [package ...] Show package information"
1102	n/a	print " pimp [options] -i package ... Install packages"
1103	n/a	print " pimp -d Dump database to stdout"
1104	n/a	print " pimp -V Print version number"
1105	n/a	print "Options:"
1106	n/a	print " -v Verbose"
1107	n/a	print " -f Force installation"
1108	n/a	print " -D dir Set destination directory"
1109	n/a	print " (default: %s)" % DEFAULT_INSTALLDIR
1110	n/a	print " -u url URL for database"
1111	n/a	sys.exit(1)
1112	n/a
1113	n/a	class _Watcher:
1114	n/a	def update(self, msg):
1115	n/a	sys.stderr.write(msg + '\r')
1116	n/a	return 1
1117	n/a
1118	n/a	try:
1119	n/a	opts, args = getopt.getopt(sys.argv[1:], "slifvdD:Vu:")
1120	n/a	except getopt.GetoptError:
1121	n/a	_help()
1122	n/a	if not opts and not args:
1123	n/a	_help()
1124	n/a	mode = None
1125	n/a	force = 0
1126	n/a	verbose = 0
1127	n/a	prefargs = {}
1128	n/a	watcher = None
1129	n/a	for o, a in opts:
1130	n/a	if o == '-s':
1131	n/a	if mode:
1132	n/a	_help()
1133	n/a	mode = 'status'
1134	n/a	if o == '-l':
1135	n/a	if mode:
1136	n/a	_help()
1137	n/a	mode = 'list'
1138	n/a	if o == '-d':
1139	n/a	if mode:
1140	n/a	_help()
1141	n/a	mode = 'dump'
1142	n/a	if o == '-V':
1143	n/a	if mode:
1144	n/a	_help()
1145	n/a	mode = 'version'
1146	n/a	if o == '-i':
1147	n/a	mode = 'install'
1148	n/a	if o == '-f':
1149	n/a	force = 1
1150	n/a	if o == '-v':
1151	n/a	verbose = 1
1152	n/a	watcher = _Watcher()
1153	n/a	if o == '-D':
1154	n/a	prefargs['installDir'] = a
1155	n/a	if o == '-u':
1156	n/a	prefargs['pimpDatabase'] = a
1157	n/a	if not mode:
1158	n/a	_help()
1159	n/a	if mode == 'version':
1160	n/a	print 'Pimp version %s; module name is %s' % (PIMP_VERSION, __name__)
1161	n/a	else:
1162	n/a	_run(mode, verbose, force, args, prefargs, watcher)
1163	n/a
1164	n/a	# Finally, try to update ourselves to a newer version.
1165	n/a	# If the end-user updates pimp through pimp the new version
1166	n/a	# will be called pimp_update and live in site-packages
1167	n/a	# or somewhere similar
1168	n/a	if __name__ != 'pimp_update':
1169	n/a	try:
1170	n/a	import pimp_update
1171	n/a	except ImportError:
1172	n/a	pass
1173	n/a	else:
1174	n/a	if pimp_update.PIMP_VERSION <= PIMP_VERSION:
1175	n/a	import warnings
1176	n/a	warnings.warn("pimp_update is version %s, not newer than pimp version %s" %
1177	n/a	(pimp_update.PIMP_VERSION, PIMP_VERSION))
1178	n/a	else:
1179	n/a	from pimp_update import *
1180	n/a
1181	n/a	if __name__ == '__main__':
1182	n/a	main()