From cb1f4c4d33711a964dcd40b32a562e2acf745fc2 Mon Sep 17 00:00:00 2001 From: Greg Ward Date: Sat, 30 Sep 2000 18:27:54 +0000 Subject: Standardized whitespace around function calls. --- Lib/distutils/command/bdist.py | 2 +- Lib/distutils/command/bdist_dumb.py | 12 +-- Lib/distutils/command/bdist_rpm.py | 2 +- Lib/distutils/command/bdist_wininst.py | 88 ++++++++++----------- Lib/distutils/command/build.py | 12 +-- Lib/distutils/command/build_clib.py | 74 +++++++++--------- Lib/distutils/command/build_ext.py | 127 +++++++++++++++---------------- Lib/distutils/command/build_py.py | 108 +++++++++++++------------- Lib/distutils/command/build_scripts.py | 6 +- Lib/distutils/command/clean.py | 20 ++--- Lib/distutils/command/config.py | 8 +- Lib/distutils/command/install.py | 112 +++++++++++++-------------- Lib/distutils/command/install_scripts.py | 10 +-- Lib/distutils/command/sdist.py | 96 +++++++++++------------ 14 files changed, 338 insertions(+), 339 deletions(-) diff --git a/Lib/distutils/command/bdist.py b/Lib/distutils/command/bdist.py index 8651e70..c0cb1d3 100644 --- a/Lib/distutils/command/bdist.py +++ b/Lib/distutils/command/bdist.py @@ -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() diff --git a/Lib/distutils/command/bdist_dumb.py b/Lib/distutils/command/bdist_dumb.py index 520098d..8dfc327 100644 --- a/Lib/distutils/command/bdist_dumb.py +++ b/Lib/distutils/command/bdist_dumb.py @@ -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() diff --git a/Lib/distutils/command/bdist_rpm.py b/Lib/distutils/command/bdist_rpm.py index c293f1f..f421590 100644 --- a/Lib/distutils/command/bdist_rpm.py +++ b/Lib/distutils/command/bdist_rpm.py @@ -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: diff --git a/Lib/distutils/command/bdist_wininst.py b/Lib/distutils/command/bdist_wininst.py index 3251bac..afe6955 100644 --- a/Lib/distutils/command/bdist_wininst.py +++ b/Lib/distutils/command/bdist_wininst.py @@ -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 ("' 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." 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 () diff --git a/Lib/distutils/command/build_clib.py b/Lib/distutils/command/build_clib.py index 775b7ad..2726b97 100644 --- a/Lib/distutils/command/build_clib.py +++ b/Lib/distutils/command/build_clib.py @@ -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 diff --git a/Lib/distutils/command/build_ext.py b/Lib/distutils/command/build_ext.py index 9147c3d..70e8a73 100644 --- a/Lib/distutils/command/build_ext.py +++ b/Lib/distutils/command/build_ext.py @@ -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 diff --git a/Lib/distutils/command/build_py.py b/Lib/distutils/command/build_py.py index ebe30e8..6a8a7f4 100644 --- a/Lib/distutils/command/build_py.py +++ b/Lib/distutils/command/build_py.py @@ -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 () diff --git a/Lib/distutils/command/build_scripts.py b/Lib/distutils/command/build_scripts.py index eacf798..495f4c3 100644 --- a/Lib/distutils/command/build_scripts.py +++ b/Lib/distutils/command/build_scripts.py @@ -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 diff --git a/Lib/distutils/command/clean.py b/Lib/distutils/command/clean.py index 4f04f08..fb8822f 100644 --- a/Lib/distutils/command/clean.py +++ b/Lib/distutils/command/clean.py @@ -50,29 +50,29 @@ class clean (Command): def run(self): # remove the build/temp. 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 diff --git a/Lib/distutils/command/config.py b/Lib/distutils/command/config.py index 5c3f26a..a13055c 100644 --- a/Lib/distutils/command/config.py +++ b/Lib/distutils/command/config.py @@ -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: diff --git a/Lib/distutils/command/install.py b/Lib/distutils/command/install.py index 8c6aa1c..e9528c6 100644 --- a/Lib/distutils/command/install.py +++ b/Lib/distutils/command/install.py @@ -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 diff --git a/Lib/distutils/command/install_scripts.py b/Lib/distutils/command/install_scripts.py index b8938c4..3bc23e7 100644 --- a/Lib/distutils/command/install_scripts.py +++ b/Lib/distutils/command/install_scripts.py @@ -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: diff --git a/Lib/distutils/command/sdist.py b/Lib/distutils/command/sdist.py index adaf492..5116868 100644 --- a/Lib/distutils/command/sdist.py +++ b/Lib/distutils/command/sdist.py @@ -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 -- cgit v0.12