mirror of https://github.com/python/cpython
Standardized whitespace around function calls.
This commit is contained in:
Greg Ward
parent
963cd2d85d
commit
cb1f4c4d33
|
|
@ -132,7 +132,7 @@ class bdist (Command):
|
|||
# keep its temporary files around so subsequent runs go faster.
|
||||
if cmd_name in commands[i+1:]:
|
||||
sub_cmd.keep_temp = 1
|
||||
self.run_command (cmd_name)
|
||||
self.run_command(cmd_name)
|
||||
|
||||
# run()
|
||||
|
||||
|
|
|
|||
|
|
@ -71,24 +71,24 @@ class bdist_dumb (Command):
|
|||
|
||||
def run (self):
|
||||
|
||||
self.run_command ('build')
|
||||
self.run_command('build')
|
||||
|
||||
install = self.reinitialize_command('install', reinit_subcommands=1)
|
||||
install.root = self.bdist_dir
|
||||
|
||||
self.announce ("installing to %s" % self.bdist_dir)
|
||||
self.announce("installing to %s" % self.bdist_dir)
|
||||
self.run_command('install')
|
||||
|
||||
# And make an archive relative to the root of the
|
||||
# pseudo-installation tree.
|
||||
archive_basename = "%s.%s" % (self.distribution.get_fullname(),
|
||||
self.plat_name)
|
||||
self.make_archive (os.path.join(self.dist_dir, archive_basename),
|
||||
self.format,
|
||||
root_dir=self.bdist_dir)
|
||||
self.make_archive(os.path.join(self.dist_dir, archive_basename),
|
||||
self.format,
|
||||
root_dir=self.bdist_dir)
|
||||
|
||||
if not self.keep_temp:
|
||||
remove_tree (self.bdist_dir, self.verbose, self.dry_run)
|
||||
remove_tree(self.bdist_dir, self.verbose, self.dry_run)
|
||||
|
||||
# run()
|
||||
|
||||
|
|
|
|||
|
|
@ -258,7 +258,7 @@ class bdist_rpm (Command):
|
|||
|
||||
# Make a source distribution and copy to SOURCES directory with
|
||||
# optional icon.
|
||||
sdist = self.reinitialize_command ('sdist')
|
||||
sdist = self.reinitialize_command('sdist')
|
||||
if self.use_bzip2:
|
||||
sdist.formats = ['bztar']
|
||||
else:
|
||||
|
|
|
|||
|
|
@ -56,8 +56,8 @@ class bdist_wininst (Command):
|
|||
if self.distribution.has_ext_modules():
|
||||
short_version = sys.version[:3]
|
||||
if self.target_version and self.target_version != short_version:
|
||||
raise DistutilsOptionError ("target version can only be" +
|
||||
short_version)
|
||||
raise DistutilsOptionError, \
|
||||
"target version can only be" + short_version
|
||||
self.target_version = short_version
|
||||
|
||||
self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
|
||||
|
|
@ -73,7 +73,7 @@ class bdist_wininst (Command):
|
|||
("distribution contains extensions and/or C libraries; "
|
||||
"must be compiled on a Windows 32 platform")
|
||||
|
||||
self.run_command ('build')
|
||||
self.run_command('build')
|
||||
|
||||
install = self.reinitialize_command('install')
|
||||
install.root = self.bdist_dir
|
||||
|
|
@ -91,7 +91,7 @@ class bdist_wininst (Command):
|
|||
|
||||
install_lib.ensure_finalized()
|
||||
|
||||
self.announce ("installing to %s" % self.bdist_dir)
|
||||
self.announce("installing to %s" % self.bdist_dir)
|
||||
install.ensure_finalized()
|
||||
install.run()
|
||||
|
||||
|
|
@ -103,24 +103,24 @@ class bdist_wininst (Command):
|
|||
|
||||
# Our archive MUST be relative to sys.prefix, which is the
|
||||
# same as install_purelib in the 'nt' scheme.
|
||||
root_dir = os.path.normpath (install.install_purelib)
|
||||
root_dir = os.path.normpath(install.install_purelib)
|
||||
|
||||
# Sanity check: Make sure everything is included
|
||||
for key in ('purelib', 'platlib', 'headers', 'scripts', 'data'):
|
||||
attrname = 'install_' + key
|
||||
install_x = getattr (install, attrname)
|
||||
install_x = getattr(install, attrname)
|
||||
# (Use normpath so that we can string.find to look for
|
||||
# subdirectories)
|
||||
install_x = os.path.normpath (install_x)
|
||||
if string.find (install_x, root_dir) != 0:
|
||||
install_x = os.path.normpath(install_x)
|
||||
if string.find(install_x, root_dir) != 0:
|
||||
raise DistutilsInternalError \
|
||||
("'%s' not included in install_lib" % key)
|
||||
arcname = self.make_archive (archive_basename, "zip",
|
||||
root_dir=root_dir)
|
||||
self.create_exe (arcname, fullname)
|
||||
arcname = self.make_archive(archive_basename, "zip",
|
||||
root_dir=root_dir)
|
||||
self.create_exe(arcname, fullname)
|
||||
|
||||
if not self.keep_temp:
|
||||
remove_tree (self.bdist_dir, self.verbose, self.dry_run)
|
||||
remove_tree(self.bdist_dir, self.verbose, self.dry_run)
|
||||
|
||||
# run()
|
||||
|
||||
|
|
@ -133,37 +133,37 @@ class bdist_wininst (Command):
|
|||
# Write the [metadata] section. Values are written with
|
||||
# repr()[1:-1], so they do not contain unprintable characters, and
|
||||
# are not surrounded by quote chars.
|
||||
lines.append ("[metadata]")
|
||||
lines.append("[metadata]")
|
||||
|
||||
# 'info' will be displayed in the installer's dialog box,
|
||||
# describing the items to be installed.
|
||||
info = (metadata.long_description or '') + '\n'
|
||||
|
||||
for name in dir (metadata):
|
||||
for name in dir(metadata):
|
||||
if (name != 'long_description'):
|
||||
data = getattr (metadata, name)
|
||||
data = getattr(metadata, name)
|
||||
if data:
|
||||
info = info + ("\n %s: %s" % \
|
||||
(string.capitalize (name), data))
|
||||
lines.append ("%s=%s" % (name, repr (data)[1:-1]))
|
||||
(string.capitalize(name), data))
|
||||
lines.append("%s=%s" % (name, repr(data)[1:-1]))
|
||||
|
||||
# The [setup] section contains entries controlling
|
||||
# the installer runtime.
|
||||
lines.append ("\n[Setup]")
|
||||
lines.append ("info=%s" % repr (info)[1:-1])
|
||||
lines.append ("target_compile=%d" % (not self.no_target_compile))
|
||||
lines.append ("target_optimize=%d" % (not self.no_target_optimize))
|
||||
lines.append("\n[Setup]")
|
||||
lines.append("info=%s" % repr(info)[1:-1])
|
||||
lines.append("target_compile=%d" % (not self.no_target_compile))
|
||||
lines.append("target_optimize=%d" % (not self.no_target_optimize))
|
||||
if self.target_version:
|
||||
lines.append ("target_version=%s" % self.target_version)
|
||||
lines.append("target_version=%s" % self.target_version)
|
||||
|
||||
title = self.distribution.get_fullname()
|
||||
lines.append ("title=%s" % repr (title)[1:-1])
|
||||
lines.append("title=%s" % repr(title)[1:-1])
|
||||
import time
|
||||
import distutils
|
||||
build_info = "Build %s with distutils-%s" % \
|
||||
(time.ctime (time.time()), distutils.__version__)
|
||||
lines.append ("build_info=%s" % build_info)
|
||||
return string.join (lines, "\n")
|
||||
(time.ctime(time.time()), distutils.__version__)
|
||||
lines.append("build_info=%s" % build_info)
|
||||
return string.join(lines, "\n")
|
||||
|
||||
# get_inidata()
|
||||
|
||||
|
|
@ -183,36 +183,36 @@ class bdist_wininst (Command):
|
|||
else:
|
||||
installer_name = os.path.join(self.dist_dir,
|
||||
"%s.win32.exe" % fullname)
|
||||
self.announce ("creating %s" % installer_name)
|
||||
self.announce("creating %s" % installer_name)
|
||||
|
||||
file = open (installer_name, "wb")
|
||||
file.write (self.get_exe_bytes ())
|
||||
file.write (cfgdata)
|
||||
header = struct.pack ("<ii",
|
||||
0x12345679, # tag
|
||||
len (cfgdata)) # length
|
||||
file.write (header)
|
||||
file.write (open (arcname, "rb").read())
|
||||
file = open(installer_name, "wb")
|
||||
file.write(self.get_exe_bytes())
|
||||
file.write(cfgdata)
|
||||
header = struct.pack("<ii",
|
||||
0x12345679, # tag
|
||||
len(cfgdata)) # length
|
||||
file.write(header)
|
||||
file.write(open(arcname, "rb").read())
|
||||
|
||||
# create_exe()
|
||||
|
||||
def get_exe_bytes (self):
|
||||
import base64
|
||||
return base64.decodestring (EXEDATA)
|
||||
return base64.decodestring(EXEDATA)
|
||||
|
||||
# class bdist_wininst
|
||||
|
||||
if __name__ == '__main__':
|
||||
# recreate EXEDATA from wininst.exe by rewriting this file
|
||||
import re, base64
|
||||
moddata = open ("bdist_wininst.py", "r").read()
|
||||
exedata = open ("../../misc/wininst.exe", "rb").read()
|
||||
print "wininst.exe length is %d bytes" % len (exedata)
|
||||
print "wininst.exe encoded length is %d bytes" % len (base64.encodestring (exedata))
|
||||
exp = re.compile ('EXE'+'DATA = """\\\\(\n.*)*\n"""', re.M)
|
||||
data = exp.sub ('EXE' + 'DATA = """\\\\\n%s"""' %
|
||||
base64.encodestring (exedata), moddata)
|
||||
open ("bdist_wininst.py", "w").write (data)
|
||||
moddata = open("bdist_wininst.py", "r").read()
|
||||
exedata = open("../../misc/wininst.exe", "rb").read()
|
||||
print "wininst.exe length is %d bytes" % len(exedata)
|
||||
print "wininst.exe encoded length is %d bytes" % len(base64.encodestring(exedata))
|
||||
exp = re.compile('EXE'+'DATA = """\\\\(\n.*)*\n"""', re.M)
|
||||
data = exp.sub('EXE' + 'DATA = """\\\\\n%s"""' %
|
||||
base64.encodestring(exedata), moddata)
|
||||
open("bdist_wininst.py", "w").write(data)
|
||||
print "bdist_wininst.py recreated"
|
||||
|
||||
EXEDATA = """\
|
||||
|
|
|
|||
|
|
@ -70,10 +70,10 @@ class build (Command):
|
|||
# 'lib.<plat>' under the base build directory. We only use one of
|
||||
# them for a given distribution, though --
|
||||
if self.build_purelib is None:
|
||||
self.build_purelib = os.path.join (self.build_base, 'lib')
|
||||
self.build_purelib = os.path.join(self.build_base, 'lib')
|
||||
if self.build_platlib is None:
|
||||
self.build_platlib = os.path.join (self.build_base,
|
||||
'lib' + plat_specifier)
|
||||
self.build_platlib = os.path.join(self.build_base,
|
||||
'lib' + plat_specifier)
|
||||
|
||||
# 'build_lib' is the actual directory that we will use for this
|
||||
# particular module distribution -- if user didn't supply it, pick
|
||||
|
|
@ -87,10 +87,10 @@ class build (Command):
|
|||
# 'build_temp' -- temporary directory for compiler turds,
|
||||
# "build/temp.<plat>"
|
||||
if self.build_temp is None:
|
||||
self.build_temp = os.path.join (self.build_base,
|
||||
'temp' + plat_specifier)
|
||||
self.build_temp = os.path.join(self.build_base,
|
||||
'temp' + plat_specifier)
|
||||
if self.build_scripts is None:
|
||||
self.build_scripts = os.path.join (self.build_base, 'scripts')
|
||||
self.build_scripts = os.path.join(self.build_base, 'scripts')
|
||||
|
||||
# finalize_options ()
|
||||
|
||||
|
|
|
|||
|
|
@ -80,22 +80,22 @@ class build_clib (Command):
|
|||
# I think that C libraries are really just temporary build
|
||||
# by-products, at least from the point of view of building Python
|
||||
# extensions -- but I want to keep my options open.
|
||||
self.set_undefined_options ('build',
|
||||
('build_temp', 'build_clib'),
|
||||
('build_temp', 'build_temp'),
|
||||
('compiler', 'compiler'),
|
||||
('debug', 'debug'),
|
||||
('force', 'force'))
|
||||
self.set_undefined_options('build',
|
||||
('build_temp', 'build_clib'),
|
||||
('build_temp', 'build_temp'),
|
||||
('compiler', 'compiler'),
|
||||
('debug', 'debug'),
|
||||
('force', 'force'))
|
||||
|
||||
self.libraries = self.distribution.libraries
|
||||
if self.libraries:
|
||||
self.check_library_list (self.libraries)
|
||||
self.check_library_list(self.libraries)
|
||||
|
||||
if self.include_dirs is None:
|
||||
self.include_dirs = self.distribution.include_dirs or []
|
||||
if type (self.include_dirs) is StringType:
|
||||
self.include_dirs = string.split (self.include_dirs,
|
||||
os.pathsep)
|
||||
if type(self.include_dirs) is StringType:
|
||||
self.include_dirs = string.split(self.include_dirs,
|
||||
os.pathsep)
|
||||
|
||||
# XXX same as for build_ext -- what about 'self.define' and
|
||||
# 'self.undef' ?
|
||||
|
|
@ -110,23 +110,23 @@ class build_clib (Command):
|
|||
|
||||
# Yech -- this is cut 'n pasted from build_ext.py!
|
||||
from distutils.ccompiler import new_compiler
|
||||
self.compiler = new_compiler (compiler=self.compiler,
|
||||
verbose=self.verbose,
|
||||
dry_run=self.dry_run,
|
||||
force=self.force)
|
||||
self.compiler = new_compiler(compiler=self.compiler,
|
||||
verbose=self.verbose,
|
||||
dry_run=self.dry_run,
|
||||
force=self.force)
|
||||
customize_compiler(self.compiler)
|
||||
|
||||
if self.include_dirs is not None:
|
||||
self.compiler.set_include_dirs (self.include_dirs)
|
||||
self.compiler.set_include_dirs(self.include_dirs)
|
||||
if self.define is not None:
|
||||
# 'define' option is a list of (name,value) tuples
|
||||
for (name,value) in self.define:
|
||||
self.compiler.define_macro (name, value)
|
||||
self.compiler.define_macro(name, value)
|
||||
if self.undef is not None:
|
||||
for macro in self.undef:
|
||||
self.compiler.undefine_macro (macro)
|
||||
self.compiler.undefine_macro(macro)
|
||||
|
||||
self.build_libraries (self.libraries)
|
||||
self.build_libraries(self.libraries)
|
||||
|
||||
# run()
|
||||
|
||||
|
|
@ -141,16 +141,16 @@ class build_clib (Command):
|
|||
# Yechh, blecch, ackk: this is ripped straight out of build_ext.py,
|
||||
# with only names changed to protect the innocent!
|
||||
|
||||
if type (libraries) is not ListType:
|
||||
if type(libraries) is not ListType:
|
||||
raise DistutilsSetupError, \
|
||||
"'libraries' option must be a list of tuples"
|
||||
|
||||
for lib in libraries:
|
||||
if type (lib) is not TupleType and len (lib) != 2:
|
||||
if type(lib) is not TupleType and len(lib) != 2:
|
||||
raise DistutilsSetupError, \
|
||||
"each element of 'libraries' must a 2-tuple"
|
||||
|
||||
if type (lib[0]) is not StringType:
|
||||
if type(lib[0]) is not StringType:
|
||||
raise DistutilsSetupError, \
|
||||
"first element of each tuple in 'libraries' " + \
|
||||
"must be a string (the library name)"
|
||||
|
|
@ -160,7 +160,7 @@ class build_clib (Command):
|
|||
"may not contain directory separators") % \
|
||||
lib[0]
|
||||
|
||||
if type (lib[1]) is not DictionaryType:
|
||||
if type(lib[1]) is not DictionaryType:
|
||||
raise DistutilsSetupError, \
|
||||
"second element of each tuple in 'libraries' " + \
|
||||
"must be a dictionary (build info)"
|
||||
|
|
@ -178,7 +178,7 @@ class build_clib (Command):
|
|||
|
||||
lib_names = []
|
||||
for (lib_name, build_info) in self.libraries:
|
||||
lib_names.append (lib_name)
|
||||
lib_names.append(lib_name)
|
||||
return lib_names
|
||||
|
||||
# get_library_names ()
|
||||
|
|
@ -189,33 +189,33 @@ class build_clib (Command):
|
|||
compiler = self.compiler
|
||||
|
||||
for (lib_name, build_info) in libraries:
|
||||
sources = build_info.get ('sources')
|
||||
if sources is None or type (sources) not in (ListType, TupleType):
|
||||
sources = build_info.get('sources')
|
||||
if sources is None or type(sources) not in (ListType, TupleType):
|
||||
raise DistutilsSetupError, \
|
||||
("in 'libraries' option (library '%s'), " +
|
||||
"'sources' must be present and must be " +
|
||||
"a list of source filenames") % lib_name
|
||||
sources = list (sources)
|
||||
sources = list(sources)
|
||||
|
||||
self.announce ("building '%s' library" % lib_name)
|
||||
self.announce("building '%s' library" % lib_name)
|
||||
|
||||
# First, compile the source code to object files in the library
|
||||
# directory. (This should probably change to putting object
|
||||
# files in a temporary build directory.)
|
||||
macros = build_info.get ('macros')
|
||||
include_dirs = build_info.get ('include_dirs')
|
||||
objects = self.compiler.compile (sources,
|
||||
output_dir=self.build_temp,
|
||||
macros=macros,
|
||||
include_dirs=include_dirs,
|
||||
debug=self.debug)
|
||||
macros = build_info.get('macros')
|
||||
include_dirs = build_info.get('include_dirs')
|
||||
objects = self.compiler.compile(sources,
|
||||
output_dir=self.build_temp,
|
||||
macros=macros,
|
||||
include_dirs=include_dirs,
|
||||
debug=self.debug)
|
||||
|
||||
# Now "link" the object files together into a static library.
|
||||
# (On Unix at least, this isn't really linking -- it just
|
||||
# builds an archive. Whatever.)
|
||||
self.compiler.create_static_lib (objects, lib_name,
|
||||
output_dir=self.build_clib,
|
||||
debug=self.debug)
|
||||
self.compiler.create_static_lib(objects, lib_name,
|
||||
output_dir=self.build_clib,
|
||||
debug=self.debug)
|
||||
|
||||
# for libraries
|
||||
|
||||
|
|
|
|||
|
|
@ -112,12 +112,12 @@ class build_ext (Command):
|
|||
def finalize_options (self):
|
||||
from distutils import sysconfig
|
||||
|
||||
self.set_undefined_options ('build',
|
||||
('build_lib', 'build_lib'),
|
||||
('build_temp', 'build_temp'),
|
||||
('compiler', 'compiler'),
|
||||
('debug', 'debug'),
|
||||
('force', 'force'))
|
||||
self.set_undefined_options('build',
|
||||
('build_lib', 'build_lib'),
|
||||
('build_temp', 'build_temp'),
|
||||
('compiler', 'compiler'),
|
||||
('debug', 'debug'),
|
||||
('force', 'force'))
|
||||
|
||||
if self.package is None:
|
||||
self.package = self.distribution.ext_package
|
||||
|
|
@ -131,17 +131,16 @@ class build_ext (Command):
|
|||
plat_py_include = sysconfig.get_python_inc(plat_specific=1)
|
||||
if self.include_dirs is None:
|
||||
self.include_dirs = self.distribution.include_dirs or []
|
||||
if type (self.include_dirs) is StringType:
|
||||
self.include_dirs = string.split (self.include_dirs,
|
||||
os.pathsep)
|
||||
if type(self.include_dirs) is StringType:
|
||||
self.include_dirs = string.split(self.include_dirs, os.pathsep)
|
||||
|
||||
# Put the Python "system" include dir at the end, so that
|
||||
# any local include dirs take precedence.
|
||||
self.include_dirs.append (py_include)
|
||||
self.include_dirs.append(py_include)
|
||||
if plat_py_include != py_include:
|
||||
self.include_dirs.append (plat_py_include)
|
||||
self.include_dirs.append(plat_py_include)
|
||||
|
||||
if type (self.libraries) is StringType:
|
||||
if type(self.libraries) is StringType:
|
||||
self.libraries = [self.libraries]
|
||||
|
||||
# Life is easier if we're not forever checking for None, so
|
||||
|
|
@ -157,11 +156,11 @@ class build_ext (Command):
|
|||
# for Release and Debug builds.
|
||||
# also Python's library directory must be appended to library_dirs
|
||||
if os.name == 'nt':
|
||||
self.library_dirs.append (os.path.join(sys.exec_prefix, 'libs'))
|
||||
self.library_dirs.append(os.path.join(sys.exec_prefix, 'libs'))
|
||||
if self.debug:
|
||||
self.build_temp = os.path.join (self.build_temp, "Debug")
|
||||
self.build_temp = os.path.join(self.build_temp, "Debug")
|
||||
else:
|
||||
self.build_temp = os.path.join (self.build_temp, "Release")
|
||||
self.build_temp = os.path.join(self.build_temp, "Release")
|
||||
# finalize_options ()
|
||||
|
||||
|
||||
|
|
@ -188,16 +187,16 @@ class build_ext (Command):
|
|||
# directory where we put them is in the library search path for
|
||||
# linking extensions.
|
||||
if self.distribution.has_c_libraries():
|
||||
build_clib = self.get_finalized_command ('build_clib')
|
||||
self.libraries.extend (build_clib.get_library_names() or [])
|
||||
self.library_dirs.append (build_clib.build_clib)
|
||||
build_clib = self.get_finalized_command('build_clib')
|
||||
self.libraries.extend(build_clib.get_library_names() or [])
|
||||
self.library_dirs.append(build_clib.build_clib)
|
||||
|
||||
# Setup the CCompiler object that we'll use to do all the
|
||||
# compiling and linking
|
||||
self.compiler = new_compiler (compiler=self.compiler,
|
||||
verbose=self.verbose,
|
||||
dry_run=self.dry_run,
|
||||
force=self.force)
|
||||
self.compiler = new_compiler(compiler=self.compiler,
|
||||
verbose=self.verbose,
|
||||
dry_run=self.dry_run,
|
||||
force=self.force)
|
||||
customize_compiler(self.compiler)
|
||||
|
||||
# And make sure that any compile/link-related options (which might
|
||||
|
|
@ -205,25 +204,25 @@ class build_ext (Command):
|
|||
# that CCompiler object -- that way, they automatically apply to
|
||||
# all compiling and linking done here.
|
||||
if self.include_dirs is not None:
|
||||
self.compiler.set_include_dirs (self.include_dirs)
|
||||
self.compiler.set_include_dirs(self.include_dirs)
|
||||
if self.define is not None:
|
||||
# 'define' option is a list of (name,value) tuples
|
||||
for (name,value) in self.define:
|
||||
self.compiler.define_macro (name, value)
|
||||
self.compiler.define_macro(name, value)
|
||||
if self.undef is not None:
|
||||
for macro in self.undef:
|
||||
self.compiler.undefine_macro (macro)
|
||||
self.compiler.undefine_macro(macro)
|
||||
if self.libraries is not None:
|
||||
self.compiler.set_libraries (self.libraries)
|
||||
self.compiler.set_libraries(self.libraries)
|
||||
if self.library_dirs is not None:
|
||||
self.compiler.set_library_dirs (self.library_dirs)
|
||||
self.compiler.set_library_dirs(self.library_dirs)
|
||||
if self.rpath is not None:
|
||||
self.compiler.set_runtime_library_dirs (self.rpath)
|
||||
self.compiler.set_runtime_library_dirs(self.rpath)
|
||||
if self.link_objects is not None:
|
||||
self.compiler.set_link_objects (self.link_objects)
|
||||
self.compiler.set_link_objects(self.link_objects)
|
||||
|
||||
# Now actually compile and link everything.
|
||||
self.build_extensions ()
|
||||
self.build_extensions()
|
||||
|
||||
# run ()
|
||||
|
||||
|
|
@ -320,7 +319,7 @@ class build_ext (Command):
|
|||
|
||||
# Wouldn't it be neat if we knew the names of header files too...
|
||||
for ext in self.extensions:
|
||||
filenames.extend (ext.sources)
|
||||
filenames.extend(ext.sources)
|
||||
|
||||
return filenames
|
||||
|
||||
|
|
@ -330,16 +329,16 @@ class build_ext (Command):
|
|||
# Sanity check the 'extensions' list -- can't assume this is being
|
||||
# done in the same run as a 'build_extensions()' call (in fact, we
|
||||
# can probably assume that it *isn't*!).
|
||||
self.check_extensions_list (self.extensions)
|
||||
self.check_extensions_list(self.extensions)
|
||||
|
||||
# And build the list of output (built) filenames. Note that this
|
||||
# ignores the 'inplace' flag, and assumes everything goes in the
|
||||
# "build" tree.
|
||||
outputs = []
|
||||
for ext in self.extensions:
|
||||
fullname = self.get_ext_fullname (ext.name)
|
||||
outputs.append (os.path.join (self.build_lib,
|
||||
self.get_ext_filename(fullname)))
|
||||
fullname = self.get_ext_fullname(ext.name)
|
||||
outputs.append(os.path.join(self.build_lib,
|
||||
self.get_ext_filename(fullname)))
|
||||
return outputs
|
||||
|
||||
# get_outputs ()
|
||||
|
|
@ -348,40 +347,40 @@ class build_ext (Command):
|
|||
def build_extensions (self):
|
||||
|
||||
# First, sanity-check the 'extensions' list
|
||||
self.check_extensions_list (self.extensions)
|
||||
self.check_extensions_list(self.extensions)
|
||||
|
||||
for ext in self.extensions:
|
||||
sources = ext.sources
|
||||
if sources is None or type (sources) not in (ListType, TupleType):
|
||||
if sources is None or type(sources) not in (ListType, TupleType):
|
||||
raise DistutilsSetupError, \
|
||||
("in 'ext_modules' option (extension '%s'), " +
|
||||
"'sources' must be present and must be " +
|
||||
"a list of source filenames") % ext.name
|
||||
sources = list (sources)
|
||||
sources = list(sources)
|
||||
|
||||
fullname = self.get_ext_fullname (ext.name)
|
||||
fullname = self.get_ext_fullname(ext.name)
|
||||
if self.inplace:
|
||||
# ignore build-lib -- put the compiled extension into
|
||||
# the source tree along with pure Python modules
|
||||
|
||||
modpath = string.split (fullname, '.')
|
||||
package = string.join (modpath[0:-1], '.')
|
||||
modpath = string.split(fullname, '.')
|
||||
package = string.join(modpath[0:-1], '.')
|
||||
base = modpath[-1]
|
||||
|
||||
build_py = self.get_finalized_command ('build_py')
|
||||
package_dir = build_py.get_package_dir (package)
|
||||
ext_filename = os.path.join (package_dir,
|
||||
self.get_ext_filename(base))
|
||||
build_py = self.get_finalized_command('build_py')
|
||||
package_dir = build_py.get_package_dir(package)
|
||||
ext_filename = os.path.join(package_dir,
|
||||
self.get_ext_filename(base))
|
||||
else:
|
||||
ext_filename = os.path.join (self.build_lib,
|
||||
self.get_ext_filename(fullname))
|
||||
ext_filename = os.path.join(self.build_lib,
|
||||
self.get_ext_filename(fullname))
|
||||
|
||||
if not (self.force or newer_group(sources, ext_filename, 'newer')):
|
||||
self.announce ("skipping '%s' extension (up-to-date)" %
|
||||
ext.name)
|
||||
self.announce("skipping '%s' extension (up-to-date)" %
|
||||
ext.name)
|
||||
continue # 'for' loop over all extensions
|
||||
else:
|
||||
self.announce ("building '%s' extension" % ext.name)
|
||||
self.announce("building '%s' extension" % ext.name)
|
||||
|
||||
# First, scan the sources for SWIG definition files (.i), run
|
||||
# SWIG on 'em to create .c files, and modify the sources list
|
||||
|
|
@ -416,22 +415,22 @@ class build_ext (Command):
|
|||
if os.environ.has_key('CFLAGS'):
|
||||
extra_args.extend(string.split(os.environ['CFLAGS']))
|
||||
|
||||
objects = self.compiler.compile (sources,
|
||||
output_dir=self.build_temp,
|
||||
macros=macros,
|
||||
include_dirs=ext.include_dirs,
|
||||
debug=self.debug,
|
||||
extra_postargs=extra_args)
|
||||
objects = self.compiler.compile(sources,
|
||||
output_dir=self.build_temp,
|
||||
macros=macros,
|
||||
include_dirs=ext.include_dirs,
|
||||
debug=self.debug,
|
||||
extra_postargs=extra_args)
|
||||
|
||||
# Now link the object files together into a "shared object" --
|
||||
# of course, first we have to figure out all the other things
|
||||
# that go into the mix.
|
||||
if ext.extra_objects:
|
||||
objects.extend (ext.extra_objects)
|
||||
objects.extend(ext.extra_objects)
|
||||
extra_args = ext.extra_link_args or []
|
||||
|
||||
|
||||
self.compiler.link_shared_object (
|
||||
self.compiler.link_shared_object(
|
||||
objects, ext_filename,
|
||||
libraries=self.get_libraries(ext),
|
||||
library_dirs=ext.library_dirs,
|
||||
|
|
@ -481,11 +480,11 @@ class build_ext (Command):
|
|||
swig = self.find_swig()
|
||||
swig_cmd = [swig, "-python", "-dnone", "-ISWIG"]
|
||||
if self.swig_cpp:
|
||||
swig_cmd.append ("-c++")
|
||||
swig_cmd.append("-c++")
|
||||
|
||||
for source in swig_sources:
|
||||
target = swig_targets[source]
|
||||
self.announce ("swigging %s to %s" % (source, target))
|
||||
self.announce("swigging %s to %s" % (source, target))
|
||||
self.spawn(swig_cmd + ["-o", target, source])
|
||||
|
||||
return new_sources
|
||||
|
|
@ -507,7 +506,7 @@ class build_ext (Command):
|
|||
# if not, act like Unix and assume it's in the PATH.
|
||||
for vers in ("1.3", "1.2", "1.1"):
|
||||
fn = os.path.join("c:\\swig%s" % vers, "swig.exe")
|
||||
if os.path.isfile (fn):
|
||||
if os.path.isfile(fn):
|
||||
return fn
|
||||
else:
|
||||
return "swig.exe"
|
||||
|
|
@ -535,12 +534,12 @@ class build_ext (Command):
|
|||
"""
|
||||
|
||||
from distutils.sysconfig import get_config_var
|
||||
ext_path = string.split (ext_name, '.')
|
||||
ext_path = string.split(ext_name, '.')
|
||||
# extensions in debug_mode are named 'module_d.pyd' under windows
|
||||
so_ext = get_config_var('SO')
|
||||
if os.name == 'nt' and self.debug:
|
||||
return apply (os.path.join, ext_path) + '_d' + so_ext
|
||||
return apply (os.path.join, ext_path) + so_ext
|
||||
return apply(os.path.join, ext_path) + '_d' + so_ext
|
||||
return apply(os.path.join, ext_path) + so_ext
|
||||
|
||||
def get_export_symbols (self, ext):
|
||||
"""Return the list of symbols that a shared extension has to
|
||||
|
|
|
|||
|
|
@ -34,9 +34,9 @@ class build_py (Command):
|
|||
self.force = None
|
||||
|
||||
def finalize_options (self):
|
||||
self.set_undefined_options ('build',
|
||||
('build_lib', 'build_lib'),
|
||||
('force', 'force'))
|
||||
self.set_undefined_options('build',
|
||||
('build_lib', 'build_lib'),
|
||||
('force', 'force'))
|
||||
|
||||
# Get the distribution options that are aliases for build_py
|
||||
# options -- list of packages and list of modules.
|
||||
|
|
@ -83,9 +83,9 @@ class build_py (Command):
|
|||
|
||||
# Now we're down to two cases: 'py_modules' only and 'packages' only.
|
||||
if self.py_modules:
|
||||
self.build_modules ()
|
||||
self.build_modules()
|
||||
else:
|
||||
self.build_packages ()
|
||||
self.build_packages()
|
||||
|
||||
# run ()
|
||||
|
||||
|
|
@ -95,24 +95,24 @@ class build_py (Command):
|
|||
distribution, where package 'package' should be found
|
||||
(at least according to the 'package_dir' option, if any)."""
|
||||
|
||||
path = string.split (package, '.')
|
||||
path = string.split(package, '.')
|
||||
|
||||
if not self.package_dir:
|
||||
if path:
|
||||
return apply (os.path.join, path)
|
||||
return apply(os.path.join, path)
|
||||
else:
|
||||
return ''
|
||||
else:
|
||||
tail = []
|
||||
while path:
|
||||
try:
|
||||
pdir = self.package_dir[string.join (path, '.')]
|
||||
pdir = self.package_dir[string.join(path, '.')]
|
||||
except KeyError:
|
||||
tail.insert (0, path[-1])
|
||||
tail.insert(0, path[-1])
|
||||
del path[-1]
|
||||
else:
|
||||
tail.insert (0, pdir)
|
||||
return apply (os.path.join, tail)
|
||||
tail.insert(0, pdir)
|
||||
return apply(os.path.join, tail)
|
||||
else:
|
||||
# Oops, got all the way through 'path' without finding a
|
||||
# match in package_dir. If package_dir defines a directory
|
||||
|
|
@ -126,7 +126,7 @@ class build_py (Command):
|
|||
tail.insert(0, pdir)
|
||||
|
||||
if tail:
|
||||
return apply (os.path.join, tail)
|
||||
return apply(os.path.join, tail)
|
||||
else:
|
||||
return ''
|
||||
|
||||
|
|
@ -140,22 +140,22 @@ class build_py (Command):
|
|||
# my "empty string means current dir" convention, so we have to
|
||||
# circumvent them.
|
||||
if package_dir != "":
|
||||
if not os.path.exists (package_dir):
|
||||
if not os.path.exists(package_dir):
|
||||
raise DistutilsFileError, \
|
||||
"package directory '%s' does not exist" % package_dir
|
||||
if not os.path.isdir (package_dir):
|
||||
if not os.path.isdir(package_dir):
|
||||
raise DistutilsFileError, \
|
||||
("supposed package directory '%s' exists, " +
|
||||
"but is not a directory") % package_dir
|
||||
|
||||
# Require __init__.py for all but the "root package"
|
||||
if package:
|
||||
init_py = os.path.join (package_dir, "__init__.py")
|
||||
if os.path.isfile (init_py):
|
||||
init_py = os.path.join(package_dir, "__init__.py")
|
||||
if os.path.isfile(init_py):
|
||||
return init_py
|
||||
else:
|
||||
self.warn (("package init file '%s' not found " +
|
||||
"(or not a regular file)") % init_py)
|
||||
self.warn(("package init file '%s' not found " +
|
||||
"(or not a regular file)") % init_py)
|
||||
|
||||
# Either not in a package at all (__init__.py not expected), or
|
||||
# __init__.py doesn't exist -- so don't return the filename.
|
||||
|
|
@ -165,9 +165,9 @@ class build_py (Command):
|
|||
|
||||
|
||||
def check_module (self, module, module_file):
|
||||
if not os.path.isfile (module_file):
|
||||
self.warn ("file %s (for module %s) not found" %
|
||||
(module_file, module))
|
||||
if not os.path.isfile(module_file):
|
||||
self.warn("file %s (for module %s) not found" %
|
||||
(module_file, module))
|
||||
return 0
|
||||
else:
|
||||
return 1
|
||||
|
|
@ -176,16 +176,16 @@ class build_py (Command):
|
|||
|
||||
|
||||
def find_package_modules (self, package, package_dir):
|
||||
self.check_package (package, package_dir)
|
||||
module_files = glob (os.path.join (package_dir, "*.py"))
|
||||
self.check_package(package, package_dir)
|
||||
module_files = glob(os.path.join(package_dir, "*.py"))
|
||||
modules = []
|
||||
setup_script = os.path.abspath(self.distribution.script_name)
|
||||
|
||||
for f in module_files:
|
||||
abs_f = os.path.abspath (f)
|
||||
abs_f = os.path.abspath(f)
|
||||
if abs_f != setup_script:
|
||||
module = os.path.splitext (os.path.basename (f))[0]
|
||||
modules.append ((package, module, f))
|
||||
module = os.path.splitext(os.path.basename(f))[0]
|
||||
modules.append((package, module, f))
|
||||
else:
|
||||
self.debug_print("excluding %s" % setup_script)
|
||||
return modules
|
||||
|
|
@ -218,18 +218,18 @@ class build_py (Command):
|
|||
# - don't check for __init__.py in directory for empty package
|
||||
|
||||
for module in self.py_modules:
|
||||
path = string.split (module, '.')
|
||||
path = string.split(module, '.')
|
||||
package = string.join(path[0:-1], '.')
|
||||
module_base = path[-1]
|
||||
|
||||
try:
|
||||
(package_dir, checked) = packages[package]
|
||||
except KeyError:
|
||||
package_dir = self.get_package_dir (package)
|
||||
package_dir = self.get_package_dir(package)
|
||||
checked = 0
|
||||
|
||||
if not checked:
|
||||
init_py = self.check_package (package, package_dir)
|
||||
init_py = self.check_package(package, package_dir)
|
||||
packages[package] = (package_dir, 1)
|
||||
if init_py:
|
||||
modules.append((package, "__init__", init_py))
|
||||
|
|
@ -237,11 +237,11 @@ class build_py (Command):
|
|||
# XXX perhaps we should also check for just .pyc files
|
||||
# (so greedy closed-source bastards can distribute Python
|
||||
# modules too)
|
||||
module_file = os.path.join (package_dir, module_base + ".py")
|
||||
if not self.check_module (module, module_file):
|
||||
module_file = os.path.join(package_dir, module_base + ".py")
|
||||
if not self.check_module(module, module_file):
|
||||
continue
|
||||
|
||||
modules.append ((package, module_base, module_file))
|
||||
modules.append((package, module_base, module_file))
|
||||
|
||||
return modules
|
||||
|
||||
|
|
@ -256,13 +256,13 @@ class build_py (Command):
|
|||
'find_package_modules()' do."""
|
||||
|
||||
if self.py_modules:
|
||||
modules = self.find_modules ()
|
||||
modules = self.find_modules()
|
||||
else:
|
||||
modules = []
|
||||
for package in self.packages:
|
||||
package_dir = self.get_package_dir (package)
|
||||
m = self.find_package_modules (package, package_dir)
|
||||
modules.extend (m)
|
||||
package_dir = self.get_package_dir(package)
|
||||
m = self.find_package_modules(package, package_dir)
|
||||
modules.extend(m)
|
||||
|
||||
return modules
|
||||
|
||||
|
|
@ -271,43 +271,43 @@ class build_py (Command):
|
|||
|
||||
def get_source_files (self):
|
||||
|
||||
modules = self.find_all_modules ()
|
||||
modules = self.find_all_modules()
|
||||
filenames = []
|
||||
for module in modules:
|
||||
filenames.append (module[-1])
|
||||
filenames.append(module[-1])
|
||||
|
||||
return filenames
|
||||
|
||||
|
||||
def get_module_outfile (self, build_dir, package, module):
|
||||
outfile_path = [build_dir] + list(package) + [module + ".py"]
|
||||
return apply (os.path.join, outfile_path)
|
||||
return apply(os.path.join, outfile_path)
|
||||
|
||||
|
||||
def get_outputs (self):
|
||||
modules = self.find_all_modules ()
|
||||
modules = self.find_all_modules()
|
||||
outputs = []
|
||||
for (package, module, module_file) in modules:
|
||||
package = string.split (package, '.')
|
||||
outputs.append (self.get_module_outfile (self.build_lib,
|
||||
package, module))
|
||||
package = string.split(package, '.')
|
||||
outputs.append(self.get_module_outfile(self.build_lib,
|
||||
package, module))
|
||||
return outputs
|
||||
|
||||
|
||||
def build_module (self, module, module_file, package):
|
||||
if type (package) is StringType:
|
||||
package = string.split (package, '.')
|
||||
elif type (package) not in (ListType, TupleType):
|
||||
if type(package) is StringType:
|
||||
package = string.split(package, '.')
|
||||
elif type(package) not in (ListType, TupleType):
|
||||
raise TypeError, \
|
||||
"'package' must be a string (dot-separated), list, or tuple"
|
||||
|
||||
# Now put the module source file into the "build" area -- this is
|
||||
# easy, we just copy it somewhere under self.build_lib (the build
|
||||
# directory for Python source).
|
||||
outfile = self.get_module_outfile (self.build_lib, package, module)
|
||||
dir = os.path.dirname (outfile)
|
||||
self.mkpath (dir)
|
||||
return self.copy_file (module_file, outfile, preserve_mode=0)
|
||||
outfile = self.get_module_outfile(self.build_lib, package, module)
|
||||
dir = os.path.dirname(outfile)
|
||||
self.mkpath(dir)
|
||||
return self.copy_file(module_file, outfile, preserve_mode=0)
|
||||
|
||||
|
||||
def build_modules (self):
|
||||
|
|
@ -319,7 +319,7 @@ class build_py (Command):
|
|||
# self.build_lib (the build directory for Python source).
|
||||
# (Actually, it gets copied to the directory for this package
|
||||
# under self.build_lib.)
|
||||
self.build_module (module, module_file, package)
|
||||
self.build_module(module, module_file, package)
|
||||
|
||||
# build_modules ()
|
||||
|
||||
|
|
@ -337,14 +337,14 @@ class build_py (Command):
|
|||
# already know its package!), and 'module_file' is the path to
|
||||
# the .py file, relative to the current directory
|
||||
# (ie. including 'package_dir').
|
||||
package_dir = self.get_package_dir (package)
|
||||
modules = self.find_package_modules (package, package_dir)
|
||||
package_dir = self.get_package_dir(package)
|
||||
modules = self.find_package_modules(package, package_dir)
|
||||
|
||||
# Now loop over the modules we found, "building" each one (just
|
||||
# copy it to self.build_lib).
|
||||
for (package_, module, module_file) in modules:
|
||||
assert package == package_
|
||||
self.build_module (module, module_file, package)
|
||||
self.build_module(module, module_file, package)
|
||||
|
||||
# build_packages ()
|
||||
|
||||
|
|
|
|||
|
|
@ -32,9 +32,9 @@ class build_scripts (Command):
|
|||
self.outfiles = None
|
||||
|
||||
def finalize_options (self):
|
||||
self.set_undefined_options ('build',
|
||||
('build_scripts', 'build_dir'),
|
||||
('force', 'force'))
|
||||
self.set_undefined_options('build',
|
||||
('build_scripts', 'build_dir'),
|
||||
('force', 'force'))
|
||||
self.scripts = self.distribution.scripts
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -50,29 +50,29 @@ class clean (Command):
|
|||
def run(self):
|
||||
# remove the build/temp.<plat> directory (unless it's already
|
||||
# gone)
|
||||
if os.path.exists (self.build_temp):
|
||||
remove_tree (self.build_temp, self.verbose, self.dry_run)
|
||||
if os.path.exists(self.build_temp):
|
||||
remove_tree(self.build_temp, self.verbose, self.dry_run)
|
||||
else:
|
||||
self.warn ("'%s' does not exist -- can't clean it" %
|
||||
self.build_temp)
|
||||
self.warn("'%s' does not exist -- can't clean it" %
|
||||
self.build_temp)
|
||||
|
||||
if self.all:
|
||||
# remove build directories
|
||||
for directory in (self.build_lib,
|
||||
self.bdist_base,
|
||||
self.build_scripts):
|
||||
if os.path.exists (directory):
|
||||
remove_tree (directory, self.verbose, self.dry_run)
|
||||
if os.path.exists(directory):
|
||||
remove_tree(directory, self.verbose, self.dry_run)
|
||||
else:
|
||||
self.warn ("'%s' does not exist -- can't clean it" %
|
||||
directory)
|
||||
self.warn("'%s' does not exist -- can't clean it" %
|
||||
directory)
|
||||
|
||||
# just for the heck of it, try to remove the base build directory:
|
||||
# we might have emptied it right now, but if not we don't care
|
||||
if not self.dry_run:
|
||||
try:
|
||||
os.rmdir (self.build_base)
|
||||
self.announce ("removing '%s'" % self.build_base)
|
||||
os.rmdir(self.build_base)
|
||||
self.announce("removing '%s'" % self.build_base)
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
|
|
|
|||
|
|
@ -87,10 +87,10 @@ class config (Command):
|
|||
# import.
|
||||
from distutils.ccompiler import CCompiler, new_compiler
|
||||
if not isinstance(self.compiler, CCompiler):
|
||||
self.compiler = new_compiler (compiler=self.compiler,
|
||||
verbose=self.noisy,
|
||||
dry_run=self.dry_run,
|
||||
force=1)
|
||||
self.compiler = new_compiler(compiler=self.compiler,
|
||||
verbose=self.noisy,
|
||||
dry_run=self.dry_run,
|
||||
force=1)
|
||||
if self.include_dirs:
|
||||
self.compiler.set_include_dirs(self.include_dirs)
|
||||
if self.libraries:
|
||||
|
|
|
|||
|
|
@ -210,10 +210,10 @@ class install (Command):
|
|||
"not both")
|
||||
else:
|
||||
if self.exec_prefix:
|
||||
self.warn ("exec-prefix option ignored on this platform")
|
||||
self.warn("exec-prefix option ignored on this platform")
|
||||
self.exec_prefix = None
|
||||
if self.home:
|
||||
self.warn ("home option ignored on this platform")
|
||||
self.warn("home option ignored on this platform")
|
||||
self.home = None
|
||||
|
||||
# Now the interesting logic -- so interesting that we farm it out
|
||||
|
|
@ -224,14 +224,14 @@ class install (Command):
|
|||
# install_{purelib,platlib,lib,scripts,data,...}, and the
|
||||
# INSTALL_SCHEME dictionary above. Phew!
|
||||
|
||||
self.dump_dirs ("pre-finalize_{unix,other}")
|
||||
self.dump_dirs("pre-finalize_{unix,other}")
|
||||
|
||||
if os.name == 'posix':
|
||||
self.finalize_unix ()
|
||||
self.finalize_unix()
|
||||
else:
|
||||
self.finalize_other ()
|
||||
self.finalize_other()
|
||||
|
||||
self.dump_dirs ("post-finalize_{unix,other}()")
|
||||
self.dump_dirs("post-finalize_{unix,other}()")
|
||||
|
||||
# Expand configuration variables, tilde, etc. in self.install_base
|
||||
# and self.install_platbase -- that way, we can use $base or
|
||||
|
|
@ -250,9 +250,9 @@ class install (Command):
|
|||
'sys_exec_prefix': exec_prefix,
|
||||
'exec_prefix': exec_prefix,
|
||||
}
|
||||
self.expand_basedirs ()
|
||||
self.expand_basedirs()
|
||||
|
||||
self.dump_dirs ("post-expand_basedirs()")
|
||||
self.dump_dirs("post-expand_basedirs()")
|
||||
|
||||
# Now define config vars for the base directories so we can expand
|
||||
# everything else.
|
||||
|
|
@ -262,13 +262,13 @@ class install (Command):
|
|||
if DEBUG:
|
||||
from pprint import pprint
|
||||
print "config vars:"
|
||||
pprint (self.config_vars)
|
||||
pprint(self.config_vars)
|
||||
|
||||
# Expand "~" and configuration variables in the installation
|
||||
# directories.
|
||||
self.expand_dirs ()
|
||||
self.expand_dirs()
|
||||
|
||||
self.dump_dirs ("post-expand_dirs()")
|
||||
self.dump_dirs("post-expand_dirs()")
|
||||
|
||||
# Pick the actual directory to install all modules to: either
|
||||
# install_purelib or install_platlib, depending on whether this
|
||||
|
|
@ -290,9 +290,9 @@ class install (Command):
|
|||
# have to deal with 'extra_path', which is the hack for allowing
|
||||
# non-packagized module distributions (hello, Numerical Python!) to
|
||||
# get their own directories.
|
||||
self.handle_extra_path ()
|
||||
self.handle_extra_path()
|
||||
self.install_libbase = self.install_lib # needed for .pth file
|
||||
self.install_lib = os.path.join (self.install_lib, self.extra_dirs)
|
||||
self.install_lib = os.path.join(self.install_lib, self.extra_dirs)
|
||||
|
||||
# If a new root directory was supplied, make all the installation
|
||||
# dirs relative to it.
|
||||
|
|
@ -300,12 +300,12 @@ class install (Command):
|
|||
self.change_roots('libbase', 'lib', 'purelib', 'platlib',
|
||||
'scripts', 'data', 'headers')
|
||||
|
||||
self.dump_dirs ("after prepending root")
|
||||
self.dump_dirs("after prepending root")
|
||||
|
||||
# Find out the build directories, ie. where to install from.
|
||||
self.set_undefined_options ('build',
|
||||
('build_base', 'build_base'),
|
||||
('build_lib', 'build_lib'))
|
||||
self.set_undefined_options('build',
|
||||
('build_base', 'build_base'),
|
||||
('build_lib', 'build_lib'))
|
||||
|
||||
# Punt on doc directories for now -- after all, we're punting on
|
||||
# documentation completely!
|
||||
|
|
@ -321,8 +321,8 @@ class install (Command):
|
|||
opt_name = opt[0]
|
||||
if opt_name[-1] == "=":
|
||||
opt_name = opt_name[0:-1]
|
||||
opt_name = string.translate (opt_name, longopt_xlate)
|
||||
val = getattr (self, opt_name)
|
||||
opt_name = string.translate(opt_name, longopt_xlate)
|
||||
val = getattr(self, opt_name)
|
||||
print " %s: %s" % (opt_name, val)
|
||||
|
||||
|
||||
|
|
@ -342,15 +342,15 @@ class install (Command):
|
|||
|
||||
if self.home is not None:
|
||||
self.install_base = self.install_platbase = self.home
|
||||
self.select_scheme ("unix_home")
|
||||
self.select_scheme("unix_home")
|
||||
else:
|
||||
if self.prefix is None:
|
||||
if self.exec_prefix is not None:
|
||||
raise DistutilsOptionError, \
|
||||
"must not supply exec-prefix without prefix"
|
||||
|
||||
self.prefix = os.path.normpath (sys.prefix)
|
||||
self.exec_prefix = os.path.normpath (sys.exec_prefix)
|
||||
self.prefix = os.path.normpath(sys.prefix)
|
||||
self.exec_prefix = os.path.normpath(sys.exec_prefix)
|
||||
|
||||
else:
|
||||
if self.exec_prefix is None:
|
||||
|
|
@ -358,7 +358,7 @@ class install (Command):
|
|||
|
||||
self.install_base = self.prefix
|
||||
self.install_platbase = self.exec_prefix
|
||||
self.select_scheme ("unix_prefix")
|
||||
self.select_scheme("unix_prefix")
|
||||
|
||||
# finalize_unix ()
|
||||
|
||||
|
|
@ -366,11 +366,11 @@ class install (Command):
|
|||
def finalize_other (self): # Windows and Mac OS for now
|
||||
|
||||
if self.prefix is None:
|
||||
self.prefix = os.path.normpath (sys.prefix)
|
||||
self.prefix = os.path.normpath(sys.prefix)
|
||||
|
||||
self.install_base = self.install_platbase = self.prefix
|
||||
try:
|
||||
self.select_scheme (os.name)
|
||||
self.select_scheme(os.name)
|
||||
except KeyError:
|
||||
raise DistutilsPlatformError, \
|
||||
"I don't know how to install stuff on '%s'" % os.name
|
||||
|
|
@ -389,26 +389,26 @@ class install (Command):
|
|||
|
||||
def _expand_attrs (self, attrs):
|
||||
for attr in attrs:
|
||||
val = getattr (self, attr)
|
||||
val = getattr(self, attr)
|
||||
if val is not None:
|
||||
if os.name == 'posix':
|
||||
val = os.path.expanduser (val)
|
||||
val = subst_vars (val, self.config_vars)
|
||||
setattr (self, attr, val)
|
||||
val = os.path.expanduser(val)
|
||||
val = subst_vars(val, self.config_vars)
|
||||
setattr(self, attr, val)
|
||||
|
||||
|
||||
def expand_basedirs (self):
|
||||
self._expand_attrs (['install_base',
|
||||
'install_platbase',
|
||||
'root'])
|
||||
self._expand_attrs(['install_base',
|
||||
'install_platbase',
|
||||
'root'])
|
||||
|
||||
def expand_dirs (self):
|
||||
self._expand_attrs (['install_purelib',
|
||||
'install_platlib',
|
||||
'install_lib',
|
||||
'install_headers',
|
||||
'install_scripts',
|
||||
'install_data',])
|
||||
self._expand_attrs(['install_purelib',
|
||||
'install_platlib',
|
||||
'install_lib',
|
||||
'install_headers',
|
||||
'install_scripts',
|
||||
'install_data',])
|
||||
|
||||
|
||||
def convert_paths (self, *names):
|
||||
|
|
@ -423,12 +423,12 @@ class install (Command):
|
|||
self.extra_path = self.distribution.extra_path
|
||||
|
||||
if self.extra_path is not None:
|
||||
if type (self.extra_path) is StringType:
|
||||
self.extra_path = string.split (self.extra_path, ',')
|
||||
if type(self.extra_path) is StringType:
|
||||
self.extra_path = string.split(self.extra_path, ',')
|
||||
|
||||
if len (self.extra_path) == 1:
|
||||
if len(self.extra_path) == 1:
|
||||
path_file = extra_dirs = self.extra_path[0]
|
||||
elif len (self.extra_path) == 2:
|
||||
elif len(self.extra_path) == 2:
|
||||
(path_file, extra_dirs) = self.extra_path
|
||||
else:
|
||||
raise DistutilsOptionError, \
|
||||
|
|
@ -437,7 +437,7 @@ class install (Command):
|
|||
|
||||
# convert to local form in case Unix notation used (as it
|
||||
# should be in setup scripts)
|
||||
extra_dirs = convert_path (extra_dirs)
|
||||
extra_dirs = convert_path(extra_dirs)
|
||||
|
||||
else:
|
||||
path_file = None
|
||||
|
|
@ -463,21 +463,21 @@ class install (Command):
|
|||
|
||||
# Obviously have to build before we can install
|
||||
if not self.skip_build:
|
||||
self.run_command ('build')
|
||||
self.run_command('build')
|
||||
|
||||
# Run all sub-commands (at least those that need to be run)
|
||||
for cmd_name in self.get_sub_commands():
|
||||
self.run_command (cmd_name)
|
||||
self.run_command(cmd_name)
|
||||
|
||||
if self.path_file:
|
||||
self.create_path_file ()
|
||||
self.create_path_file()
|
||||
|
||||
# write list of installed files, if requested.
|
||||
if self.record:
|
||||
outputs = self.get_outputs()
|
||||
if self.root: # strip any package prefix
|
||||
root_len = len(self.root)
|
||||
for counter in xrange (len (outputs)):
|
||||
for counter in xrange(len(outputs)):
|
||||
outputs[counter] = outputs[counter][root_len:]
|
||||
self.execute(write_file,
|
||||
(self.record, outputs),
|
||||
|
|
@ -496,12 +496,12 @@ class install (Command):
|
|||
# run ()
|
||||
|
||||
def create_path_file (self):
|
||||
filename = os.path.join (self.install_libbase,
|
||||
self.path_file + ".pth")
|
||||
filename = os.path.join(self.install_libbase,
|
||||
self.path_file + ".pth")
|
||||
if self.install_path_file:
|
||||
self.execute (write_file,
|
||||
(filename, [self.extra_dirs]),
|
||||
"creating %s" % filename)
|
||||
self.execute(write_file,
|
||||
(filename, [self.extra_dirs]),
|
||||
"creating %s" % filename)
|
||||
else:
|
||||
self.warn("path file '%s' not created" % filename)
|
||||
|
||||
|
|
@ -513,8 +513,8 @@ class install (Command):
|
|||
# get the outputs of all its sub-commands.
|
||||
outputs = []
|
||||
for cmd_name in self.get_sub_commands():
|
||||
cmd = self.get_finalized_command (cmd_name)
|
||||
outputs.extend (cmd.get_outputs())
|
||||
cmd = self.get_finalized_command(cmd_name)
|
||||
outputs.extend(cmd.get_outputs())
|
||||
|
||||
return outputs
|
||||
|
||||
|
|
@ -522,8 +522,8 @@ class install (Command):
|
|||
# XXX gee, this looks familiar ;-(
|
||||
inputs = []
|
||||
for cmd_name in self.get_sub_commands():
|
||||
cmd = self.get_finalized_command (cmd_name)
|
||||
inputs.extend (cmd.get_inputs())
|
||||
cmd = self.get_finalized_command(cmd_name)
|
||||
inputs.extend(cmd.get_inputs())
|
||||
|
||||
return inputs
|
||||
|
||||
|
|
|
|||
|
|
@ -33,11 +33,11 @@ class install_scripts (Command):
|
|||
|
||||
def finalize_options (self):
|
||||
self.set_undefined_options('build', ('build_scripts', 'build_dir'))
|
||||
self.set_undefined_options ('install',
|
||||
('install_scripts', 'install_dir'),
|
||||
('force', 'force'),
|
||||
('skip_build', 'skip_build'),
|
||||
)
|
||||
self.set_undefined_options('install',
|
||||
('install_scripts', 'install_dir'),
|
||||
('force', 'force'),
|
||||
('skip_build', 'skip_build'),
|
||||
)
|
||||
|
||||
def run (self):
|
||||
if not self.skip_build:
|
||||
|
|
|
|||
|
|
@ -118,7 +118,7 @@ class sdist (Command):
|
|||
"don't know how to create source distributions " + \
|
||||
"on platform %s" % os.name
|
||||
|
||||
bad_format = archive_util.check_archive_formats (self.formats)
|
||||
bad_format = archive_util.check_archive_formats(self.formats)
|
||||
if bad_format:
|
||||
raise DistutilsOptionError, \
|
||||
"unknown archive format '%s'" % bad_format
|
||||
|
|
@ -135,12 +135,12 @@ class sdist (Command):
|
|||
|
||||
# Ensure that all required meta-data is given; warn if not (but
|
||||
# don't die, it's not *that* serious!)
|
||||
self.check_metadata ()
|
||||
self.check_metadata()
|
||||
|
||||
# Do whatever it takes to get the list of files to process
|
||||
# (process the manifest template, read an existing manifest,
|
||||
# whatever). File list is accumulated in 'self.filelist'.
|
||||
self.get_file_list ()
|
||||
self.get_file_list()
|
||||
|
||||
# If user just wanted us to regenerate the manifest, stop now.
|
||||
if self.manifest_only:
|
||||
|
|
@ -148,7 +148,7 @@ class sdist (Command):
|
|||
|
||||
# Otherwise, go ahead and create the source distribution tarball,
|
||||
# or zipfile, or whatever.
|
||||
self.make_distribution ()
|
||||
self.make_distribution()
|
||||
|
||||
|
||||
def check_metadata (self):
|
||||
|
|
@ -161,25 +161,25 @@ class sdist (Command):
|
|||
|
||||
missing = []
|
||||
for attr in ('name', 'version', 'url'):
|
||||
if not (hasattr (metadata, attr) and getattr (metadata, attr)):
|
||||
missing.append (attr)
|
||||
if not (hasattr(metadata, attr) and getattr(metadata, attr)):
|
||||
missing.append(attr)
|
||||
|
||||
if missing:
|
||||
self.warn ("missing required meta-data: " +
|
||||
string.join (missing, ", "))
|
||||
self.warn("missing required meta-data: " +
|
||||
string.join(missing, ", "))
|
||||
|
||||
if metadata.author:
|
||||
if not metadata.author_email:
|
||||
self.warn ("missing meta-data: if 'author' supplied, " +
|
||||
"'author_email' must be supplied too")
|
||||
self.warn("missing meta-data: if 'author' supplied, " +
|
||||
"'author_email' must be supplied too")
|
||||
elif metadata.maintainer:
|
||||
if not metadata.maintainer_email:
|
||||
self.warn ("missing meta-data: if 'maintainer' supplied, " +
|
||||
"'maintainer_email' must be supplied too")
|
||||
self.warn("missing meta-data: if 'maintainer' supplied, " +
|
||||
"'maintainer_email' must be supplied too")
|
||||
else:
|
||||
self.warn ("missing meta-data: either (author and author_email) " +
|
||||
"or (maintainer and maintainer_email) " +
|
||||
"must be supplied")
|
||||
self.warn("missing meta-data: either (author and author_email) " +
|
||||
"or (maintainer and maintainer_email) " +
|
||||
"must be supplied")
|
||||
|
||||
# check_metadata ()
|
||||
|
||||
|
|
@ -282,41 +282,41 @@ class sdist (Command):
|
|||
|
||||
standards = [('README', 'README.txt'), self.distribution.script_name]
|
||||
for fn in standards:
|
||||
if type (fn) is TupleType:
|
||||
if type(fn) is TupleType:
|
||||
alts = fn
|
||||
got_it = 0
|
||||
for fn in alts:
|
||||
if os.path.exists (fn):
|
||||
if os.path.exists(fn):
|
||||
got_it = 1
|
||||
self.filelist.append (fn)
|
||||
self.filelist.append(fn)
|
||||
break
|
||||
|
||||
if not got_it:
|
||||
self.warn ("standard file not found: should have one of " +
|
||||
string.join (alts, ', '))
|
||||
self.warn("standard file not found: should have one of " +
|
||||
string.join(alts, ', '))
|
||||
else:
|
||||
if os.path.exists (fn):
|
||||
self.filelist.append (fn)
|
||||
if os.path.exists(fn):
|
||||
self.filelist.append(fn)
|
||||
else:
|
||||
self.warn ("standard file '%s' not found" % fn)
|
||||
self.warn("standard file '%s' not found" % fn)
|
||||
|
||||
optional = ['test/test*.py', 'setup.cfg']
|
||||
for pattern in optional:
|
||||
files = filter (os.path.isfile, glob (pattern))
|
||||
files = filter(os.path.isfile, glob(pattern))
|
||||
if files:
|
||||
self.filelist.extend (files)
|
||||
self.filelist.extend(files)
|
||||
|
||||
if self.distribution.has_pure_modules():
|
||||
build_py = self.get_finalized_command ('build_py')
|
||||
self.filelist.extend (build_py.get_source_files ())
|
||||
build_py = self.get_finalized_command('build_py')
|
||||
self.filelist.extend(build_py.get_source_files())
|
||||
|
||||
if self.distribution.has_ext_modules():
|
||||
build_ext = self.get_finalized_command ('build_ext')
|
||||
self.filelist.extend (build_ext.get_source_files ())
|
||||
build_ext = self.get_finalized_command('build_ext')
|
||||
self.filelist.extend(build_ext.get_source_files())
|
||||
|
||||
if self.distribution.has_c_libraries():
|
||||
build_clib = self.get_finalized_command ('build_clib')
|
||||
self.filelist.extend (build_clib.get_source_files ())
|
||||
build_clib = self.get_finalized_command('build_clib')
|
||||
self.filelist.extend(build_clib.get_source_files())
|
||||
|
||||
# add_defaults ()
|
||||
|
||||
|
|
@ -329,13 +329,13 @@ class sdist (Command):
|
|||
accordingly.
|
||||
"""
|
||||
self.announce("reading manifest template '%s'" % self.template)
|
||||
template = TextFile (self.template,
|
||||
strip_comments=1,
|
||||
skip_blanks=1,
|
||||
join_lines=1,
|
||||
lstrip_ws=1,
|
||||
rstrip_ws=1,
|
||||
collapse_join=1)
|
||||
template = TextFile(self.template,
|
||||
strip_comments=1,
|
||||
skip_blanks=1,
|
||||
join_lines=1,
|
||||
lstrip_ws=1,
|
||||
rstrip_ws=1,
|
||||
collapse_join=1)
|
||||
|
||||
while 1:
|
||||
line = template.readline()
|
||||
|
|
@ -386,14 +386,14 @@ class sdist (Command):
|
|||
distribution.
|
||||
"""
|
||||
self.announce("reading manifest file '%s'" % self.manifest)
|
||||
manifest = open (self.manifest)
|
||||
manifest = open(self.manifest)
|
||||
while 1:
|
||||
line = manifest.readline ()
|
||||
line = manifest.readline()
|
||||
if line == '': # end of file
|
||||
break
|
||||
if line[-1] == '\n':
|
||||
line = line[0:-1]
|
||||
self.filelist.append (line)
|
||||
self.filelist.append(line)
|
||||
|
||||
# read_manifest ()
|
||||
|
||||
|
|
@ -421,7 +421,7 @@ class sdist (Command):
|
|||
# out-of-date, because by default we blow away 'base_dir' when
|
||||
# we're done making the distribution archives.)
|
||||
|
||||
if hasattr (os, 'link'): # can make hard links on this system
|
||||
if hasattr(os, 'link'): # can make hard links on this system
|
||||
link = 'hard'
|
||||
msg = "making hard links in %s..." % base_dir
|
||||
else: # nope, have to copy
|
||||
|
|
@ -431,13 +431,13 @@ class sdist (Command):
|
|||
if not files:
|
||||
self.warn("no files to distribute -- empty manifest?")
|
||||
else:
|
||||
self.announce (msg)
|
||||
self.announce(msg)
|
||||
for file in files:
|
||||
if not os.path.isfile(file):
|
||||
self.warn("'%s' not a regular file -- skipping" % file)
|
||||
else:
|
||||
dest = os.path.join (base_dir, file)
|
||||
self.copy_file (file, dest, link=link)
|
||||
dest = os.path.join(base_dir, file)
|
||||
self.copy_file(file, dest, link=link)
|
||||
|
||||
# make_release_tree ()
|
||||
|
||||
|
|
@ -455,16 +455,16 @@ class sdist (Command):
|
|||
base_dir = self.distribution.get_fullname()
|
||||
base_name = os.path.join(self.dist_dir, base_dir)
|
||||
|
||||
self.make_release_tree (base_dir, self.filelist.files)
|
||||
self.make_release_tree(base_dir, self.filelist.files)
|
||||
archive_files = [] # remember names of files we create
|
||||
for fmt in self.formats:
|
||||
file = self.make_archive (base_name, fmt, base_dir=base_dir)
|
||||
file = self.make_archive(base_name, fmt, base_dir=base_dir)
|
||||
archive_files.append(file)
|
||||
|
||||
self.archive_files = archive_files
|
||||
|
||||
if not self.keep_temp:
|
||||
dir_util.remove_tree (base_dir, self.verbose, self.dry_run)
|
||||
dir_util.remove_tree(base_dir, self.verbose, self.dry_run)
|
||||
|
||||
def get_archive_files (self):
|
||||
"""Return the list of archive files created when the command
|
||||
|
|
|
|||
Loading…
Reference in New Issue