General cleanup, raise normalization in Lib/distutils.

Lib/distutils/__init__.py

@@ -8,8 +8,6 @@ used from a setup script as
    setup (...)
 """
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 # Distutils version

Lib/distutils/archive_util.py

@@ -3,8 +3,6 @@
 Utility functions for creating archive files (tarballs, zip files,
 that sort of thing)."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import os
@@ -39,8 +37,8 @@ def make_tarball (base_name, base_dir, compress="gzip",
                       'bzip2': ['-f9']}
 
     if compress is not None and compress not in compress_ext.keys():
-        raise ValueError, \
-              "bad value for 'compress': must be None, 'gzip', or 'compress'"
+        raise ValueError(
+              "bad value for 'compress': must be None, 'gzip', or 'compress'")
 
     archive_name = base_name + ".tar"
     mkpath(os.path.dirname(archive_name), dry_run=dry_run)
@@ -86,10 +84,9 @@ def make_zipfile (base_name, base_dir, verbose=0, dry_run=0):
         except DistutilsExecError:
             # XXX really should distinguish between "couldn't find
             # external 'zip' command" and "zip failed".
-            raise DistutilsExecError, \
-                  ("unable to create zip file '%s': "
+            raise DistutilsExecError(("unable to create zip file '%s': "
                    "could neither import the 'zipfile' module nor "
-                   "find a standalone zip utility") % zip_filename
+                   "find a standalone zip utility") % zip_filename)
 
     else:
         log.info("creating '%s' and adding '%s' to it",
@@ -157,7 +154,7 @@ def make_archive (base_name, format,
     try:
         format_info = ARCHIVE_FORMATS[format]
     except KeyError:
-        raise ValueError, "unknown archive format '%s'" % format
+        raise ValueError("unknown archive format '%s'" % format)
 
     func = format_info[0]
     for (arg,val) in format_info[1]:

Lib/distutils/bcppcompiler.py

@@ -11,8 +11,6 @@ for the Borland C++ compiler.
 # someone should sit down and factor out the common code as
 # WindowsCCompiler!  --GPW
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 
@@ -116,7 +114,7 @@ class BCPPCompiler(CCompiler) :
                 try:
                     self.spawn (["brcc32", "-fo", obj, src])
                 except DistutilsExecError as msg:
-                    raise CompileError, msg
+                    raise CompileError(msg)
                 continue # the 'for' loop
 
             # The next two are both for the real compiler.
@@ -140,7 +138,7 @@ class BCPPCompiler(CCompiler) :
                             [input_opt, output_opt] +
                             extra_postargs + [src])
             except DistutilsExecError as msg:
-                raise CompileError, msg
+                raise CompileError(msg)
 
         return objects
 
@@ -165,7 +163,7 @@ class BCPPCompiler(CCompiler) :
             try:
                 self.spawn ([self.lib] + lib_args)
             except DistutilsExecError as msg:
-                raise LibError, msg
+                raise LibError(msg)
         else:
             log.debug("skipping %s (up-to-date)", output_filename)
 
@@ -299,7 +297,7 @@ class BCPPCompiler(CCompiler) :
             try:
                 self.spawn ([self.linker] + ld_args)
             except DistutilsExecError as msg:
-                raise LinkError, msg
+                raise LinkError(msg)
 
         else:
             log.debug("skipping %s (up-to-date)", output_filename)
@@ -345,9 +343,8 @@ class BCPPCompiler(CCompiler) :
             # use normcase to make sure '.rc' is really '.rc' and not '.RC'
             (base, ext) = os.path.splitext (os.path.normcase(src_name))
             if ext not in (self.src_extensions + ['.rc','.res']):
-                raise UnknownFileError, \
-                      "unknown file type '%s' (from '%s')" % \
-                      (ext, src_name)
+                raise UnknownFileError("unknown file type '%s' (from '%s')" % \
+                      (ext, src_name))
             if strip_dir:
                 base = os.path.basename (base)
             if ext == '.res':
@@ -393,6 +390,6 @@ class BCPPCompiler(CCompiler) :
                 self.spawn(pp_args)
             except DistutilsExecError as msg:
                 print(msg)
-                raise CompileError, msg
+                raise CompileError(msg)
 
     # preprocess()

Lib/distutils/ccompiler.py

@@ -3,12 +3,9 @@
 Contains CCompiler, an abstract base class that defines the interface
 for the Distutils compiler abstraction model."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, os, re
-from types import *
 from copy import copy
 from distutils.errors import *
 from distutils.spawn import spawn
@@ -88,11 +85,7 @@ class CCompiler:
                    }
     language_order = ["c++", "objc", "c"]
 
-    def __init__ (self,
-                  verbose=0,
-                  dry_run=0,
-                  force=0):
-
+    def __init__(self, verbose=0, dry_run=0, force=0):
         self.dry_run = dry_run
         self.force = force
         self.verbose = verbose
@@ -128,11 +121,7 @@ class CCompiler:
         for key in self.executables.keys():
             self.set_executable(key, self.executables[key])
 
-    # __init__ ()
-
-
-    def set_executables (self, **args):
-
+    def set_executables(self, **kwargs):
         """Define the executables (and options for them) that will be run
         to perform the various stages of compilation.  The exact set of
         executables that may be specified here depends on the compiler
@@ -158,14 +147,11 @@ class CCompiler:
         # discovered at run-time, since there are many different ways to do
         # basically the same things with Unix C compilers.
 
-        for key in args.keys():
+        for key, value in kwargs.items():
             if key not in self.executables:
-                raise ValueError, \
-                      "unknown executable '%s' for class %s" % \
-                      (key, self.__class__.__name__)
-            self.set_executable(key, args[key])
-
-    # set_executables ()
+                raise ValueError("unknown executable '%s' for class %s" % \
+                      (key, self.__class__.__name__))
+            self.set_executable(key, value)
 
     def set_executable(self, key, value):
         if isinstance(value, basestring):
@@ -173,37 +159,32 @@ class CCompiler:
         else:
             setattr(self, key, value)
 
-
-    def _find_macro (self, name):
+    def _find_macro(self, name):
         i = 0
         for defn in self.macros:
             if defn[0] == name:
                 return i
-            i = i + 1
-
+            i += 1
         return None
 
-
-    def _check_macro_definitions (self, definitions):
+    def _check_macro_definitions(self, definitions):
         """Ensures that every element of 'definitions' is a valid macro
         definition, ie. either (name,value) 2-tuple or a (name,) tuple.  Do
         nothing if all definitions are OK, raise TypeError otherwise.
         """
         for defn in definitions:
-            if not (type (defn) is TupleType and
-                    (len (defn) == 1 or
-                     (len (defn) == 2 and
-                      (isinstance (defn[1], basestring) or defn[1] is None))) and
+            if not (isinstance(defn, tuple) and
+                    (len(defn) in (1, 2) and
+                      (isinstance (defn[1], basestring) or defn[1] is None)) and
                     isinstance (defn[0], basestring)):
-                raise TypeError, \
-                      ("invalid macro definition '%s': " % defn) + \
+                raise TypeError(("invalid macro definition '%s': " % defn) + \
                       "must be tuple (string,), (string, string), or " + \
-                      "(string, None)"
+                      "(string, None)")
 
 
     # -- Bookkeeping methods -------------------------------------------
 
-    def define_macro (self, name, value=None):
+    def define_macro(self, name, value=None):
         """Define a preprocessor macro for all compilations driven by this
         compiler object.  The optional parameter 'value' should be a
         string; if it is not supplied, then the macro will be defined
@@ -216,11 +197,9 @@ class CCompiler:
         if i is not None:
             del self.macros[i]
 
-        defn = (name, value)
-        self.macros.append (defn)
+        self.macros.append((name, value))
 
-
-    def undefine_macro (self, name):
+    def undefine_macro(self, name):
         """Undefine a preprocessor macro for all compilations driven by
         this compiler object.  If the same macro is defined by
         'define_macro()' and undefined by 'undefine_macro()' the last call
@@ -236,18 +215,17 @@ class CCompiler:
             del self.macros[i]
 
         undefn = (name,)
-        self.macros.append (undefn)
-
+        self.macros.append(undefn)
 
-    def add_include_dir (self, dir):
+    def add_include_dir(self, dir):
         """Add 'dir' to the list of directories that will be searched for
         header files.  The compiler is instructed to search directories in
         the order in which they are supplied by successive calls to
         'add_include_dir()'.
         """
-        self.include_dirs.append (dir)
+        self.include_dirs.append(dir)
 
-    def set_include_dirs (self, dirs):
+    def set_include_dirs(self, dirs):
         """Set the list of directories that will be searched to 'dirs' (a
         list of strings).  Overrides any preceding calls to
         'add_include_dir()'; subsequence calls to 'add_include_dir()' add
@@ -255,10 +233,9 @@ class CCompiler:
         any list of standard include directories that the compiler may
         search by default.
         """
-        self.include_dirs = copy (dirs)
-
+        self.include_dirs = copy(dirs)
 
-    def add_library (self, libname):
+    def add_library(self, libname):
         """Add 'libname' to the list of libraries that will be included in
         all links driven by this compiler object.  Note that 'libname'
         should *not* be the name of a file containing a library, but the
@@ -272,63 +249,60 @@ class CCompiler:
         names; the linker will be instructed to link against libraries as
         many times as they are mentioned.
         """
-        self.libraries.append (libname)
+        self.libraries.append(libname)
 
-    def set_libraries (self, libnames):
+    def set_libraries(self, libnames):
         """Set the list of libraries to be included in all links driven by
         this compiler object to 'libnames' (a list of strings).  This does
         not affect any standard system libraries that the linker may
         include by default.
         """
-        self.libraries = copy (libnames)
+        self.libraries = copy(libnames)
 
-
-    def add_library_dir (self, dir):
+    def add_library_dir(self, dir):
         """Add 'dir' to the list of directories that will be searched for
         libraries specified to 'add_library()' and 'set_libraries()'.  The
         linker will be instructed to search for libraries in the order they
         are supplied to 'add_library_dir()' and/or 'set_library_dirs()'.
         """
-        self.library_dirs.append (dir)
+        self.library_dirs.append(dir)
 
-    def set_library_dirs (self, dirs):
+    def set_library_dirs(self, dirs):
         """Set the list of library search directories to 'dirs' (a list of
         strings).  This does not affect any standard library search path
         that the linker may search by default.
         """
-        self.library_dirs = copy (dirs)
-
+        self.library_dirs = copy(dirs)
 
-    def add_runtime_library_dir (self, dir):
+    def add_runtime_library_dir(self, dir):
         """Add 'dir' to the list of directories that will be searched for
         shared libraries at runtime.
         """
-        self.runtime_library_dirs.append (dir)
+        self.runtime_library_dirs.append(dir)
 
-    def set_runtime_library_dirs (self, dirs):
+    def set_runtime_library_dirs(self, dirs):
         """Set the list of directories to search for shared libraries at
         runtime to 'dirs' (a list of strings).  This does not affect any
         standard search path that the runtime linker may search by
         default.
         """
-        self.runtime_library_dirs = copy (dirs)
-
+        self.runtime_library_dirs = copy(dirs)
 
-    def add_link_object (self, object):
+    def add_link_object(self, object):
         """Add 'object' to the list of object files (or analogues, such as
         explicitly named library files or the output of "resource
         compilers") to be included in every link driven by this compiler
         object.
         """
-        self.objects.append (object)
+        self.objects.append(object)
 
-    def set_link_objects (self, objects):
+    def set_link_objects(self, objects):
         """Set the list of object files (or analogues) to be included in
         every link to 'objects'.  This does not affect any standard object
         files that the linker may include by default (such as system
         libraries).
         """
-        self.objects = copy (objects)
+        self.objects = copy(objects)
 
 
     # -- Private utility methods --------------------------------------
@@ -345,29 +319,28 @@ class CCompiler:
         if outdir is None:
             outdir = self.output_dir
         elif not isinstance(outdir, basestring):
-            raise TypeError, "'output_dir' must be a string or None"
+            raise TypeError("'output_dir' must be a string or None")
 
         if macros is None:
             macros = self.macros
-        elif type(macros) is ListType:
+        elif isinstance(macros, list):
             macros = macros + (self.macros or [])
         else:
-            raise TypeError, "'macros' (if supplied) must be a list of tuples"
+            raise TypeError("'macros' (if supplied) must be a list of tuples")
 
         if incdirs is None:
             incdirs = self.include_dirs
-        elif type(incdirs) in (ListType, TupleType):
+        elif isinstance(incdirs, (list, tuple)):
             incdirs = list(incdirs) + (self.include_dirs or [])
         else:
-            raise TypeError, \
-                  "'include_dirs' (if supplied) must be a list of strings"
+            raise TypeError(
+                  "'include_dirs' (if supplied) must be a list of strings")
 
         if extra is None:
             extra = []
 
         # Get the list of expected output (object) files
-        objects = self.object_filenames(sources,
-                                        strip_dir=0,
+        objects = self.object_filenames(sources, strip_dir=0,
                                         output_dir=outdir)
         assert len(objects) == len(sources)
 
@@ -430,7 +403,7 @@ class CCompiler:
             cc_args[:0] = before
         return cc_args
 
-    def _fix_compile_args (self, output_dir, macros, include_dirs):
+    def _fix_compile_args(self, output_dir, macros, include_dirs):
         """Typecheck and fix-up some of the arguments to the 'compile()'
         method, and return fixed-up values.  Specifically: if 'output_dir'
         is None, replaces it with 'self.output_dir'; ensures that 'macros'
@@ -443,28 +416,25 @@ class CCompiler:
         if output_dir is None:
             output_dir = self.output_dir
         elif not isinstance(output_dir, basestring):
-            raise TypeError, "'output_dir' must be a string or None"
+            raise TypeError("'output_dir' must be a string or None")
 
         if macros is None:
             macros = self.macros
-        elif type (macros) is ListType:
+        elif isinstance(macros, list):
             macros = macros + (self.macros or [])
         else:
-            raise TypeError, "'macros' (if supplied) must be a list of tuples"
+            raise TypeError("'macros' (if supplied) must be a list of tuples")
 
         if include_dirs is None:
             include_dirs = self.include_dirs
-        elif type (include_dirs) in (ListType, TupleType):
-            include_dirs = list (include_dirs) + (self.include_dirs or [])
+        elif isinstance(include_dirs, (list, tuple)):
+            include_dirs = list(include_dirs) + (self.include_dirs or [])
         else:
-            raise TypeError, \
-                  "'include_dirs' (if supplied) must be a list of strings"
+            raise TypeError(
+                  "'include_dirs' (if supplied) must be a list of strings")
 
         return output_dir, macros, include_dirs
 
-    # _fix_compile_args ()
-
-
     def _prep_compile(self, sources, output_dir, depends=None):
         """Decide which souce files must be recompiled.
 
@@ -511,29 +481,25 @@ class CCompiler:
 
         return objects, skip_source
 
-    # _prep_compile ()
-
 
-    def _fix_object_args (self, objects, output_dir):
+    def _fix_object_args(self, objects, output_dir):
         """Typecheck and fix up some arguments supplied to various methods.
         Specifically: ensure that 'objects' is a list; if output_dir is
         None, replace with self.output_dir.  Return fixed versions of
         'objects' and 'output_dir'.
         """
-        if type (objects) not in (ListType, TupleType):
-            raise TypeError, \
-                  "'objects' must be a list or tuple of strings"
-        objects = list (objects)
+        if not isinstance(objects, (list, tuple)):
+            raise TypeError("'objects' must be a list or tuple of strings")
+        objects = list(objects)
 
         if output_dir is None:
             output_dir = self.output_dir
         elif not isinstance(output_dir, basestring):
-            raise TypeError, "'output_dir' must be a string or None"
+            raise TypeError("'output_dir' must be a string or None")
 
         return (objects, output_dir)
 
-
-    def _fix_lib_args (self, libraries, library_dirs, runtime_library_dirs):
+    def _fix_lib_args(self, libraries, library_dirs, runtime_library_dirs):
         """Typecheck and fix up some of the arguments supplied to the
         'link_*' methods.  Specifically: ensure that all arguments are
         lists, and augment them with their permanent versions
@@ -542,41 +508,37 @@ class CCompiler:
         """
         if libraries is None:
             libraries = self.libraries
-        elif type (libraries) in (ListType, TupleType):
+        elif isinstance(libraries, (list, tuple)):
             libraries = list (libraries) + (self.libraries or [])
         else:
-            raise TypeError, \
-                  "'libraries' (if supplied) must be a list of strings"
+            raise TypeError(
+                  "'libraries' (if supplied) must be a list of strings")
 
         if library_dirs is None:
             library_dirs = self.library_dirs
-        elif type (library_dirs) in (ListType, TupleType):
+        elif isinstance(library_dirs, (list, tuple)):
             library_dirs = list (library_dirs) + (self.library_dirs or [])
         else:
-            raise TypeError, \
-                  "'library_dirs' (if supplied) must be a list of strings"
+            raise TypeError(
+                  "'library_dirs' (if supplied) must be a list of strings")
 
         if runtime_library_dirs is None:
             runtime_library_dirs = self.runtime_library_dirs
-        elif type (runtime_library_dirs) in (ListType, TupleType):
-            runtime_library_dirs = (list (runtime_library_dirs) +
+        elif isinstance(runtime_library_dirs, (list, tuple)):
+            runtime_library_dirs = (list(runtime_library_dirs) +
                                     (self.runtime_library_dirs or []))
         else:
-            raise TypeError, \
-                  "'runtime_library_dirs' (if supplied) " + \
-                  "must be a list of strings"
+            raise TypeError("'runtime_library_dirs' (if supplied) "
+                            "must be a list of strings")
 
         return (libraries, library_dirs, runtime_library_dirs)
 
-    # _fix_lib_args ()
-
-
-    def _need_link (self, objects, output_file):
+    def _need_link(self, objects, output_file):
         """Return true if we need to relink the files listed in 'objects'
         to recreate 'output_file'.
         """
         if self.force:
-            return 1
+            return True
         else:
             if self.dry_run:
                 newer = newer_group (objects, output_file, missing='newer')
@@ -584,13 +546,11 @@ class CCompiler:
                 newer = newer_group (objects, output_file)
             return newer
 
-    # _need_link ()
-
-    def detect_language (self, sources):
+    def detect_language(self, sources):
         """Detect the language of a given file, or list of files. Uses
         language_map, and language_order to do the job.
         """
-        if type(sources) is not ListType:
+        if not isinstance(sources, list):
             sources = [sources]
         lang = None
         index = len(self.language_order)
@@ -606,18 +566,12 @@ class CCompiler:
                 pass
         return lang
 
-    # detect_language ()
 
     # -- Worker methods ------------------------------------------------
     # (must be implemented by subclasses)
 
-    def preprocess (self,
-                    source,
-                    output_file=None,
-                    macros=None,
-                    include_dirs=None,
-                    extra_preargs=None,
-                    extra_postargs=None):
+    def preprocess(self, source, output_file=None, macros=None,
+                   include_dirs=None, extra_preargs=None, extra_postargs=None):
         """Preprocess a single C/C++ source file, named in 'source'.
         Output will be written to file named 'output_file', or stdout if
         'output_file' not supplied.  'macros' is a list of macro
@@ -680,10 +634,8 @@ class CCompiler:
 
         Raises CompileError on failure.
         """
-
         # A concrete compiler class can either override this method
         # entirely or implement _compile().
-
         macros, objects, extra_postargs, pp_opts, build = \
                 self._setup_compile(output_dir, macros, include_dirs, sources,
                                     depends, extra_postargs)
@@ -701,17 +653,12 @@ class CCompiler:
 
     def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
         """Compile 'src' to product 'obj'."""
-
         # A concrete compiler class that does not override compile()
         # should implement _compile().
         pass
 
-    def create_static_lib (self,
-                           objects,
-                           output_libname,
-                           output_dir=None,
-                           debug=0,
-                           target_lang=None):
+    def create_static_lib(self, objects, output_libname, output_dir=None,
+                          debug=0, target_lang=None):
         """Link a bunch of stuff together to create a static library file.
         The "bunch of stuff" consists of the list of object files supplied
         as 'objects', the extra object files supplied to
@@ -742,20 +689,20 @@ class CCompiler:
     SHARED_LIBRARY = "shared_library"
     EXECUTABLE = "executable"
 
-    def link (self,
-              target_desc,
-              objects,
-              output_filename,
-              output_dir=None,
-              libraries=None,
-              library_dirs=None,
-              runtime_library_dirs=None,
-              export_symbols=None,
-              debug=0,
-              extra_preargs=None,
-              extra_postargs=None,
-              build_temp=None,
-              target_lang=None):
+    def link(self,
+             target_desc,
+             objects,
+             output_filename,
+             output_dir=None,
+             libraries=None,
+             library_dirs=None,
+             runtime_library_dirs=None,
+             export_symbols=None,
+             debug=0,
+             extra_preargs=None,
+             extra_postargs=None,
+             build_temp=None,
+             target_lang=None):
         """Link a bunch of stuff together to create an executable or
         shared library file.
 
@@ -804,19 +751,19 @@ class CCompiler:
 
     # Old 'link_*()' methods, rewritten to use the new 'link()' method.
 
-    def link_shared_lib (self,
-                         objects,
-                         output_libname,
-                         output_dir=None,
-                         libraries=None,
-                         library_dirs=None,
-                         runtime_library_dirs=None,
-                         export_symbols=None,
-                         debug=0,
-                         extra_preargs=None,
-                         extra_postargs=None,
-                         build_temp=None,
-                         target_lang=None):
+    def link_shared_lib(self,
+                        objects,
+                        output_libname,
+                        output_dir=None,
+                        libraries=None,
+                        library_dirs=None,
+                        runtime_library_dirs=None,
+                        export_symbols=None,
+                        debug=0,
+                        extra_preargs=None,
+                        extra_postargs=None,
+                        build_temp=None,
+                        target_lang=None):
         self.link(CCompiler.SHARED_LIBRARY, objects,
                   self.library_filename(output_libname, lib_type='shared'),
                   output_dir,
@@ -825,19 +772,19 @@ class CCompiler:
                   extra_preargs, extra_postargs, build_temp, target_lang)
 
 
-    def link_shared_object (self,
-                            objects,
-                            output_filename,
-                            output_dir=None,
-                            libraries=None,
-                            library_dirs=None,
-                            runtime_library_dirs=None,
-                            export_symbols=None,
-                            debug=0,
-                            extra_preargs=None,
-                            extra_postargs=None,
-                            build_temp=None,
-                            target_lang=None):
+    def link_shared_object(self,
+                           objects,
+                           output_filename,
+                           output_dir=None,
+                           libraries=None,
+                           library_dirs=None,
+                           runtime_library_dirs=None,
+                           export_symbols=None,
+                           debug=0,
+                           extra_preargs=None,
+                           extra_postargs=None,
+                           build_temp=None,
+                           target_lang=None):
         self.link(CCompiler.SHARED_OBJECT, objects,
                   output_filename, output_dir,
                   libraries, library_dirs, runtime_library_dirs,
@@ -845,17 +792,17 @@ class CCompiler:
                   extra_preargs, extra_postargs, build_temp, target_lang)
 
 
-    def link_executable (self,
-                         objects,
-                         output_progname,
-                         output_dir=None,
-                         libraries=None,
-                         library_dirs=None,
-                         runtime_library_dirs=None,
-                         debug=0,
-                         extra_preargs=None,
-                         extra_postargs=None,
-                         target_lang=None):
+    def link_executable(self,
+                        objects,
+                        output_progname,
+                        output_dir=None,
+                        libraries=None,
+                        library_dirs=None,
+                        runtime_library_dirs=None,
+                        debug=0,
+                        extra_preargs=None,
+                        extra_postargs=None,
+                        target_lang=None):
         self.link(CCompiler.EXECUTABLE, objects,
                   self.executable_filename(output_progname), output_dir,
                   libraries, library_dirs, runtime_library_dirs, None,
@@ -867,34 +814,30 @@ class CCompiler:
     # no appropriate default implementation so subclasses should
     # implement all of these.
 
-    def library_dir_option (self, dir):
+    def library_dir_option(self, dir):
         """Return the compiler option to add 'dir' to the list of
         directories searched for libraries.
         """
         raise NotImplementedError
 
-    def runtime_library_dir_option (self, dir):
+    def runtime_library_dir_option(self, dir):
         """Return the compiler option to add 'dir' to the list of
         directories searched for runtime libraries.
         """
         raise NotImplementedError
 
-    def library_option (self, lib):
+    def library_option(self, lib):
         """Return the compiler option to add 'dir' to the list of libraries
         linked into the shared library or executable.
         """
         raise NotImplementedError
 
-    def has_function(self, funcname,
-                     includes=None,
-                     include_dirs=None,
-                     libraries=None,
-                     library_dirs=None):
+    def has_function(self, funcname, includes=None, include_dirs=None,
+                     libraries=None, library_dirs=None):
         """Return a boolean indicating whether funcname is supported on
         the current platform.  The optional arguments can be used to
         augment the compilation environment.
         """
-
         # this can't be included at module scope because it tries to
         # import math which might not be available at that point - maybe
         # the necessary logic should just be inlined?
@@ -982,8 +925,8 @@ main (int argc, char **argv) {
             base = os.path.splitdrive(base)[1] # Chop off the drive
             base = base[os.path.isabs(base):]  # If abs, chop off leading /
             if ext not in self.src_extensions:
-                raise UnknownFileError, \
-                      "unknown file type '%s' (from '%s')" % (ext, src_name)
+                raise UnknownFileError(
+                      "unknown file type '%s' (from '%s')" % (ext, src_name))
             if strip_dir:
                 base = os.path.basename(base)
             obj_names.append(os.path.join(output_dir,
@@ -993,24 +936,25 @@ main (int argc, char **argv) {
     def shared_object_filename(self, basename, strip_dir=0, output_dir=''):
         assert output_dir is not None
         if strip_dir:
-            basename = os.path.basename (basename)
+            basename = os.path.basename(basename)
         return os.path.join(output_dir, basename + self.shared_lib_extension)
 
     def executable_filename(self, basename, strip_dir=0, output_dir=''):
         assert output_dir is not None
         if strip_dir:
-            basename = os.path.basename (basename)
+            basename = os.path.basename(basename)
         return os.path.join(output_dir, basename + (self.exe_extension or ''))
 
     def library_filename(self, libname, lib_type='static',     # or 'shared'
                          strip_dir=0, output_dir=''):
         assert output_dir is not None
         if lib_type not in ("static", "shared", "dylib"):
-            raise ValueError, "'lib_type' must be \"static\", \"shared\" or \"dylib\""
+            raise ValueError(
+                  "'lib_type' must be \"static\", \"shared\" or \"dylib\"")
         fmt = getattr(self, lib_type + "_lib_format")
         ext = getattr(self, lib_type + "_lib_extension")
 
-        dir, base = os.path.split (libname)
+        dir, base = os.path.split(libname)
         filename = fmt % (base, ext)
         if strip_dir:
             dir = ''
@@ -1020,31 +964,28 @@ main (int argc, char **argv) {
 
     # -- Utility methods -----------------------------------------------
 
-    def announce (self, msg, level=1):
+    def announce(self, msg, level=1):
         log.debug(msg)
 
-    def debug_print (self, msg):
+    def debug_print(self, msg):
         from distutils.debug import DEBUG
         if DEBUG:
             print(msg)
 
-    def warn (self, msg):
-        sys.stderr.write ("warning: %s\n" % msg)
+    def warn(self, msg):
+        sys.stderr.write("warning: %s\n" % msg)
 
-    def execute (self, func, args, msg=None, level=1):
+    def execute(self, func, args, msg=None, level=1):
         execute(func, args, msg, self.dry_run)
 
-    def spawn (self, cmd):
-        spawn (cmd, dry_run=self.dry_run)
+    def spawn(self, cmd):
+        spawn(cmd, dry_run=self.dry_run)
 
-    def move_file (self, src, dst):
-        return move_file (src, dst, dry_run=self.dry_run)
+    def move_file(self, src, dst):
+        return move_file(src, dst, dry_run=self.dry_run)
 
-    def mkpath (self, name, mode=0o777):
-        mkpath (name, mode, self.dry_run)
-
-
-# class CCompiler
+    def mkpath(self, name, mode=0o777):
+        mkpath(name, mode, self.dry_run)
 
 
 # Map a sys.platform/os.name ('posix', 'nt') to the default compiler
@@ -1068,16 +1009,14 @@ _default_compilers = (
     )
 
 def get_default_compiler(osname=None, platform=None):
+    """Determine the default compiler to use for the given platform.
 
-    """ Determine the default compiler to use for the given platform.
-
-        osname should be one of the standard Python OS names (i.e. the
-        ones returned by os.name) and platform the common value
-        returned by sys.platform for the platform in question.
-
-        The default values are os.name and sys.platform in case the
-        parameters are not given.
+       osname should be one of the standard Python OS names (i.e. the
+       ones returned by os.name) and platform the common value
+       returned by sys.platform for the platform in question.
 
+       The default values are os.name and sys.platform in case the
+       parameters are not given.
     """
     if osname is None:
         osname = os.name
@@ -1126,11 +1065,7 @@ def show_compilers():
     pretty_printer.print_help("List of available compilers:")
 
 
-def new_compiler (plat=None,
-                  compiler=None,
-                  verbose=0,
-                  dry_run=0,
-                  force=0):
+def new_compiler(plat=None, compiler=None, verbose=0, dry_run=0, force=0):
     """Generate an instance of some CCompiler subclass for the supplied
     platform/compiler combination.  'plat' defaults to 'os.name'
     (eg. 'posix', 'nt'), and 'compiler' defaults to the default compiler
@@ -1153,7 +1088,7 @@ def new_compiler (plat=None,
         msg = "don't know how to compile C/C++ code on platform '%s'" % plat
         if compiler is not None:
             msg = msg + " with '%s' compiler" % compiler
-        raise DistutilsPlatformError, msg
+        raise DistutilsPlatformError(msg)
 
     try:
         module_name = "distutils." + module_name
@@ -1161,21 +1096,21 @@ def new_compiler (plat=None,
         module = sys.modules[module_name]
         klass = vars(module)[class_name]
     except ImportError:
-        raise DistutilsModuleError, \
+        raise DistutilsModuleError(
               "can't compile C/C++ code: unable to load module '%s'" % \
-              module_name
+              module_name)
     except KeyError:
-        raise DistutilsModuleError, \
-              ("can't compile C/C++ code: unable to find class '%s' " +
-               "in module '%s'") % (class_name, module_name)
+        raise DistutilsModuleError(
+               "can't compile C/C++ code: unable to find class '%s' "
+               "in module '%s'" % (class_name, module_name))
 
     # XXX The None is necessary to preserve backwards compatibility
     # with classes that expect verbose to be the first positional
     # argument.
-    return klass (None, dry_run, force)
+    return klass(None, dry_run, force)
 
 
-def gen_preprocess_options (macros, include_dirs):
+def gen_preprocess_options(macros, include_dirs):
     """Generate C pre-processor options (-D, -U, -I) as used by at least
     two types of compilers: the typical Unix compiler and Visual C++.
     'macros' is the usual thing, a list of 1- or 2-tuples, where (name,)
@@ -1196,35 +1131,29 @@ def gen_preprocess_options (macros, include_dirs):
     # redundancies like this should probably be the province of
     # CCompiler, since the data structures used are inherited from it
     # and therefore common to all CCompiler classes.
-
     pp_opts = []
     for macro in macros:
-
-        if not (type (macro) is TupleType and
-                1 <= len (macro) <= 2):
-            raise TypeError, \
-                  ("bad macro definition '%s': " +
-                   "each element of 'macros' list must be a 1- or 2-tuple") % \
-                  macro
-
-        if len (macro) == 1:        # undefine this macro
-            pp_opts.append ("-U%s" % macro[0])
-        elif len (macro) == 2:
+        if not (isinstance(macro, tuple) and 1 <= len(macro) <= 2):
+            raise TypeError(
+                  "bad macro definition '%s': "
+                  "each element of 'macros' list must be a 1- or 2-tuple"
+                  % macro)
+
+        if len(macro) == 1:        # undefine this macro
+            pp_opts.append("-U%s" % macro[0])
+        elif len(macro) == 2:
             if macro[1] is None:    # define with no explicit value
-                pp_opts.append ("-D%s" % macro[0])
+                pp_opts.append("-D%s" % macro[0])
             else:
                 # XXX *don't* need to be clever about quoting the
                 # macro value here, because we're going to avoid the
                 # shell at all costs when we spawn the command!
-                pp_opts.append ("-D%s=%s" % macro)
+                pp_opts.append("-D%s=%s" % macro)
 
     for dir in include_dirs:
-        pp_opts.append ("-I%s" % dir)
-
+        pp_opts.append("-I%s" % dir)
     return pp_opts
 
-# gen_preprocess_options ()
-
 
 def gen_lib_options (compiler, library_dirs, runtime_library_dirs, libraries):
     """Generate linker options for searching library directories and
@@ -1236,14 +1165,14 @@ def gen_lib_options (compiler, library_dirs, runtime_library_dirs, libraries):
     lib_opts = []
 
     for dir in library_dirs:
-        lib_opts.append (compiler.library_dir_option (dir))
+        lib_opts.append(compiler.library_dir_option(dir))
 
     for dir in runtime_library_dirs:
-        opt = compiler.runtime_library_dir_option (dir)
-        if type(opt) is ListType:
+        opt = compiler.runtime_library_dir_option(dir)
+        if isinstance(opt, list):
             lib_opts = lib_opts + opt
         else:
-            lib_opts.append (opt)
+            lib_opts.append(opt)
 
     # XXX it's important that we *not* remove redundant library mentions!
     # sometimes you really do have to say "-lfoo -lbar -lfoo" in order to
@@ -1252,17 +1181,14 @@ def gen_lib_options (compiler, library_dirs, runtime_library_dirs, libraries):
     # pretty nasty way to arrange your C code.
 
     for lib in libraries:
-        (lib_dir, lib_name) = os.path.split (lib)
+        (lib_dir, lib_name) = os.path.split(lib)
         if lib_dir:
-            lib_file = compiler.find_library_file ([lib_dir], lib_name)
+            lib_file = compiler.find_library_file([lib_dir], lib_name)
             if lib_file:
-                lib_opts.append (lib_file)
+                lib_opts.append(lib_file)
             else:
-                compiler.warn ("no library file corresponding to "
-                               "'%s' found (skipping)" % lib)
+                compiler.warn("no library file corresponding to "
+                              "'%s' found (skipping)" % lib)
         else:
-            lib_opts.append (compiler.library_option (lib))
-
+            lib_opts.append(compiler.library_option (lib))
     return lib_opts
-
-# gen_lib_options ()

Lib/distutils/cmd.py

@@ -4,8 +4,6 @@ Provides the Command class, the base class for the command classes
 in the distutils.command package.
 """
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, os, re
@@ -48,7 +46,7 @@ class Command:
 
     # -- Creation/initialization methods -------------------------------
 
-    def __init__ (self, dist):
+    def __init__(self, dist):
         """Create and initialize a new Command object.  Most importantly,
         invokes the 'initialize_options()' method, which is the real
         initializer and depends on the actual command being
@@ -58,9 +56,9 @@ class Command:
         from distutils.dist import Distribution
 
         if not isinstance(dist, Distribution):
-            raise TypeError, "dist must be a Distribution instance"
+            raise TypeError("dist must be a Distribution instance")
         if self.__class__ is Command:
-            raise RuntimeError, "Command is an abstract class"
+            raise RuntimeError("Command is an abstract class")
 
         self.distribution = dist
         self.initialize_options()
@@ -95,11 +93,8 @@ class Command:
         # always calls 'finalize_options()', to respect/update it.
         self.finalized = 0
 
-    # __init__ ()
-
 
     # XXX A more explicit way to customize dry_run would be better.
-
     def __getattr__ (self, attr):
         if attr == 'dry_run':
             myval = getattr(self, "_" + attr)
@@ -108,15 +103,13 @@ class Command:
             else:
                 return myval
         else:
-            raise AttributeError, attr
-
+            raise AttributeError(attr)
 
     def ensure_finalized (self):
         if not self.finalized:
             self.finalize_options()
         self.finalized = 1
 
-
     # Subclasses must define:
     #   initialize_options()
     #     provide default values for all options; may be customized by
@@ -130,7 +123,7 @@ class Command:
     #     run the command: do whatever it is we're here to do,
     #     controlled by the command's various option values
 
-    def initialize_options (self):
+    def initialize_options(self):
         """Set default values for all the options that this command
         supports.  Note that these defaults may be overridden by other
         commands, by the setup script, by config files, or by the
@@ -140,10 +133,10 @@ class Command:
 
         This method must be implemented by all command classes.
         """
-        raise RuntimeError, \
-              "abstract method -- subclass %s must override" % self.__class__
+        raise RuntimeError("abstract method -- subclass %s must override"
+                           % self.__class__)
 
-    def finalize_options (self):
+    def finalize_options(self):
         """Set final values for all the options that this command supports.
         This is always called as late as possible, ie.  after any option
         assignments from the command-line or from other commands have been
@@ -154,11 +147,11 @@ class Command:
 
         This method must be implemented by all command classes.
         """
-        raise RuntimeError, \
-              "abstract method -- subclass %s must override" % self.__class__
+        raise RuntimeError("abstract method -- subclass %s must override"
+                           % self.__class__)
 
 
-    def dump_options (self, header=None, indent=""):
+    def dump_options(self, header=None, indent=""):
         from distutils.fancy_getopt import longopt_xlate
         if header is None:
             header = "command options for '%s':" % self.get_command_name()
@@ -172,7 +165,7 @@ class Command:
             print(indent + "%s = %s" % (option, value))
 
 
-    def run (self):
+    def run(self):
         """A command's raison d'etre: carry out the action it exists to
         perform, controlled by the options initialized in
         'initialize_options()', customized by other commands, the setup
@@ -183,16 +176,16 @@ class Command:
         This method must be implemented by all command classes.
         """
 
-        raise RuntimeError, \
-              "abstract method -- subclass %s must override" % self.__class__
+        raise RuntimeError("abstract method -- subclass %s must override"
+                           % self.__class__)
 
-    def announce (self, msg, level=1):
+    def announce(self, msg, level=1):
         """If the current verbosity level is of greater than or equal to
         'level' print 'msg' to stdout.
         """
         log.log(level, msg)
 
-    def debug_print (self, msg):
+    def debug_print(self, msg):
         """Print 'msg' to stdout if the global DEBUG (taken from the
         DISTUTILS_DEBUG environment variable) flag is true.
         """
@@ -202,7 +195,6 @@ class Command:
             sys.stdout.flush()
 
 
-
     # -- Option validation methods -------------------------------------
     # (these are very handy in writing the 'finalize_options()' method)
     #
@@ -216,23 +208,23 @@ class Command:
     # and they can be guaranteed that thereafter, self.foo will be
     # a list of strings.
 
-    def _ensure_stringlike (self, option, what, default=None):
+    def _ensure_stringlike(self, option, what, default=None):
         val = getattr(self, option)
         if val is None:
             setattr(self, option, default)
             return default
         elif not isinstance(val, basestring):
-            raise DistutilsOptionError, \
-                  "'%s' must be a %s (got `%s`)" % (option, what, val)
+            raise DistutilsOptionError("'%s' must be a %s (got `%s`)"
+                                       % (option, what, val))
         return val
 
-    def ensure_string (self, option, default=None):
+    def ensure_string(self, option, default=None):
         """Ensure that 'option' is a string; if not defined, set it to
         'default'.
         """
         self._ensure_stringlike(option, "string", default)
 
-    def ensure_string_list (self, option):
+    def ensure_string_list(self, option):
         """Ensure that 'option' is a list of strings.  If 'option' is
         currently a string, we split it either on /,\s*/ or /\s+/, so
         "foo bar baz", "foo,bar,baz", and "foo,   bar baz" all become
@@ -247,27 +239,26 @@ class Command:
             if isinstance(val, list):
                 ok = all(isinstance(v, basestring) for v in val)
             else:
-                ok = 0
-
+                ok = False
             if not ok:
-                raise DistutilsOptionError, \
-                      "'%s' must be a list of strings (got %r)" % \
-                      (option, val)
+                raise DistutilsOptionError(
+                      "'%s' must be a list of strings (got %r)"
+                      % (option, val))
 
-    def _ensure_tested_string (self, option, tester,
-                               what, error_fmt, default=None):
+    def _ensure_tested_string(self, option, tester, what, error_fmt,
+                              default=None):
         val = self._ensure_stringlike(option, what, default)
         if val is not None and not tester(val):
-            raise DistutilsOptionError, \
-                  ("error in '%s' option: " + error_fmt) % (option, val)
+            raise DistutilsOptionError(("error in '%s' option: " + error_fmt)
+                                       % (option, val))
 
-    def ensure_filename (self, option):
+    def ensure_filename(self, option):
         """Ensure that 'option' is the name of an existing file."""
         self._ensure_tested_string(option, os.path.isfile,
                                    "filename",
                                    "'%s' does not exist or is not a file")
 
-    def ensure_dirname (self, option):
+    def ensure_dirname(self, option):
         self._ensure_tested_string(option, os.path.isdir,
                                    "directory name",
                                    "'%s' does not exist or is not a directory")
@@ -275,14 +266,13 @@ class Command:
 
     # -- Convenience methods for commands ------------------------------
 
-    def get_command_name (self):
+    def get_command_name(self):
         if hasattr(self, 'command_name'):
             return self.command_name
         else:
             return self.__class__.__name__
 
-
-    def set_undefined_options (self, src_cmd, *option_pairs):
+    def set_undefined_options(self, src_cmd, *option_pairs):
         """Set the values of any "undefined" options from corresponding
         option values in some other command object.  "Undefined" here means
         "is None", which is the convention used to indicate that an option
@@ -296,18 +286,14 @@ class Command:
         'src_option' in the 'src_cmd' command object, and copy it to
         'dst_option' in the current command object".
         """
-
         # Option_pairs: list of (src_option, dst_option) tuples
-
         src_cmd_obj = self.distribution.get_command_obj(src_cmd)
         src_cmd_obj.ensure_finalized()
         for (src_option, dst_option) in option_pairs:
             if getattr(self, dst_option) is None:
-                setattr(self, dst_option,
-                        getattr(src_cmd_obj, src_option))
+                setattr(self, dst_option, getattr(src_cmd_obj, src_option))
 
-
-    def get_finalized_command (self, command, create=1):
+    def get_finalized_command(self, command, create=1):
         """Wrapper around Distribution's 'get_command_obj()' method: find
         (create if necessary and 'create' is true) the command object for
         'command', call its 'ensure_finalized()' method, and return the
@@ -319,19 +305,18 @@ class Command:
 
     # XXX rename to 'get_reinitialized_command()'? (should do the
     # same in dist.py, if so)
-    def reinitialize_command (self, command, reinit_subcommands=0):
-        return self.distribution.reinitialize_command(
-            command, reinit_subcommands)
+    def reinitialize_command(self, command, reinit_subcommands=0):
+        return self.distribution.reinitialize_command(command,
+                                                      reinit_subcommands)
 
-    def run_command (self, command):
+    def run_command(self, command):
         """Run some other command: uses the 'run_command()' method of
         Distribution, which creates and finalizes the command object if
         necessary and then invokes its 'run()' method.
         """
         self.distribution.run_command(command)
 
-
-    def get_sub_commands (self):
+    def get_sub_commands(self):
         """Determine the sub-commands that are relevant in the current
         distribution (ie., that need to be run).  This is based on the
         'sub_commands' class attribute: each tuple in that list may include
@@ -347,62 +332,49 @@ class Command:
 
     # -- External world manipulation -----------------------------------
 
-    def warn (self, msg):
-        sys.stderr.write("warning: %s: %s\n" %
-                         (self.get_command_name(), msg))
-
+    def warn(self, msg):
+        sys.stderr.write("warning: %s: %s\n" % (self.get_command_name(), msg))
 
-    def execute (self, func, args, msg=None, level=1):
+    def execute(self, func, args, msg=None, level=1):
         util.execute(func, args, msg, dry_run=self.dry_run)
 
-
-    def mkpath (self, name, mode=0o777):
+    def mkpath(self, name, mode=0o777):
         dir_util.mkpath(name, mode, dry_run=self.dry_run)
 
-
-    def copy_file (self, infile, outfile,
-                   preserve_mode=1, preserve_times=1, link=None, level=1):
+    def copy_file(self, infile, outfile, preserve_mode=1, preserve_times=1,
+                  link=None, level=1):
         """Copy a file respecting verbose, dry-run and force flags.  (The
         former two default to whatever is in the Distribution object, and
         the latter defaults to false for commands that don't define it.)"""
+        return file_util.copy_file(infile, outfile, preserve_mode,
+                                   preserve_times, not self.force, link,
+                                   dry_run=self.dry_run)
 
-        return file_util.copy_file(
-            infile, outfile,
-            preserve_mode, preserve_times,
-            not self.force,
-            link,
-            dry_run=self.dry_run)
-
-
-    def copy_tree (self, infile, outfile,
-                   preserve_mode=1, preserve_times=1, preserve_symlinks=0,
-                   level=1):
+    def copy_tree (self, infile, outfile, preserve_mode=1, preserve_times=1,
+                   preserve_symlinks=0, level=1):
         """Copy an entire directory tree respecting verbose, dry-run,
         and force flags.
         """
-        return dir_util.copy_tree(
-            infile, outfile,
-            preserve_mode,preserve_times,preserve_symlinks,
-            not self.force,
-            dry_run=self.dry_run)
+        return dir_util.copy_tree(infile, outfile, preserve_mode,
+                                  preserve_times, preserve_symlinks,
+                                  not self.force, dry_run=self.dry_run)
 
     def move_file (self, src, dst, level=1):
         """Move a file respectin dry-run flag."""
-        return file_util.move_file(src, dst, dry_run = self.dry_run)
+        return file_util.move_file(src, dst, dry_run=self.dry_run)
 
-    def spawn (self, cmd, search_path=1, level=1):
+    def spawn(self, cmd, search_path=1, level=1):
         """Spawn an external command respecting dry-run flag."""
         from distutils.spawn import spawn
-        spawn(cmd, search_path, dry_run= self.dry_run)
+        spawn(cmd, search_path, dry_run=self.dry_run)
 
-    def make_archive (self, base_name, format,
-                      root_dir=None, base_dir=None):
-        return archive_util.make_archive(
-            base_name, format, root_dir, base_dir, dry_run=self.dry_run)
+    def make_archive(self, base_name, format, root_dir=None, base_dir=None):
+        return archive_util.make_archive(base_name, format, root_dir, base_dir,
+                                         dry_run=self.dry_run)
 
 
-    def make_file (self, infiles, outfile, func, args,
-                   exec_msg=None, skip_msg=None, level=1):
+    def make_file(self, infiles, outfile, func, args,
+                  exec_msg=None, skip_msg=None, level=1):
         """Special case of 'execute()' for operations that process one or
         more input files and generate one output file.  Works just like
         'execute()', except the operation is skipped and a different
@@ -412,8 +384,7 @@ class Command:
         timestamp checks.
         """
         if exec_msg is None:
-            exec_msg = "generating %s from %s" % \
-                       (outfile, ', '.join(infiles))
+            exec_msg = "generating %s from %s" % (outfile, ', '.join(infiles))
         if skip_msg is None:
             skip_msg = "skipping %s (inputs unchanged)" % outfile
 
@@ -422,30 +393,25 @@ class Command:
         if isinstance(infiles, basestring):
             infiles = (infiles,)
         elif not isinstance(infiles, (list, tuple)):
-            raise TypeError, \
-                  "'infiles' must be a string, or a list or tuple of strings"
+            raise TypeError(
+                  "'infiles' must be a string, or a list or tuple of strings")
 
         # If 'outfile' must be regenerated (either because it doesn't
         # exist, is out-of-date, or the 'force' flag is true) then
         # perform the action that presumably regenerates it
         if self.force or dep_util.newer_group (infiles, outfile):
             self.execute(func, args, exec_msg, level)
-
         # Otherwise, print the "skip" message
         else:
             log.debug(skip_msg)
 
-    # make_file ()
-
-# class Command
-
 
 # XXX 'install_misc' class not currently used -- it was the base class for
 # both 'install_scripts' and 'install_data', but they outgrew it.  It might
 # still be useful for 'install_headers', though, so I'm keeping it around
 # for the time being.
 
-class install_misc (Command):
+class install_misc(Command):
     """Common base class for installing some files in a subdirectory.
     Currently used by install_data and install_scripts.
     """

Lib/distutils/command/__init__.py

@@ -3,8 +3,6 @@
 Package containing implementation of all the standard Distutils
 commands."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 __all__ = ['build',

Lib/distutils/command/bdist.py

@@ -3,22 +3,19 @@
 Implements the Distutils 'bdist' command (create a built [binary]
 distribution)."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import os
-from types import *
 from distutils.core import Command
 from distutils.errors import *
 from distutils.util import get_platform
 
 
-def show_formats ():
+def show_formats():
     """Print list of available formats (arguments to "--format" option).
     """
     from distutils.fancy_getopt import FancyGetopt
-    formats=[]
+    formats = []
     for format in bdist.format_commands:
         formats.append(("formats=" + format, None,
                         bdist.format_command[format][1]))
@@ -26,7 +23,7 @@ def show_formats ():
     pretty_printer.print_help("List of available distribution formats:")
 
 
-class bdist (Command):
+class bdist(Command):
 
     description = "create a built (binary) distribution"
 
@@ -84,17 +81,14 @@ class bdist (Command):
                       }
 
 
-    def initialize_options (self):
+    def initialize_options(self):
         self.bdist_base = None
         self.plat_name = None
         self.formats = None
         self.dist_dir = None
         self.skip_build = 0
 
-    # initialize_options()
-
-
-    def finalize_options (self):
+    def finalize_options(self):
         # have to finalize 'plat_name' before 'bdist_base'
         if self.plat_name is None:
             self.plat_name = get_platform()
@@ -112,25 +106,21 @@ class bdist (Command):
             try:
                 self.formats = [self.default_format[os.name]]
             except KeyError:
-                raise DistutilsPlatformError, \
-                      "don't know how to create built distributions " + \
-                      "on platform %s" % os.name
+                raise DistutilsPlatformError(
+                      "don't know how to create built distributions "
+                      "on platform %s" % os.name)
 
         if self.dist_dir is None:
             self.dist_dir = "dist"
 
-    # finalize_options()
-
-
-    def run (self):
-
+    def run(self):
         # Figure out which sub-commands we need to run.
         commands = []
         for format in self.formats:
             try:
                 commands.append(self.format_command[format][0])
             except KeyError:
-                raise DistutilsOptionError, "invalid format '%s'" % format
+                raise DistutilsOptionError("invalid format '%s'" % format)
 
         # Reinitialize and run each command.
         for i in range(len(self.formats)):
@@ -144,7 +134,3 @@ class bdist (Command):
             if cmd_name in commands[i+1:]:
                 sub_cmd.keep_temp = 1
             self.run_command(cmd_name)
-
-    # run()
-
-# class bdist

Lib/distutils/command/bdist_dumb.py

@@ -4,8 +4,6 @@ Implements the Distutils 'bdist_dumb' command (create a "dumb" built
 distribution -- i.e., just an archive to be unpacked under $prefix or
 $exec_prefix)."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import os
@@ -16,7 +14,7 @@ from distutils.errors import *
 from distutils.sysconfig import get_python_version
 from distutils import log
 
-class bdist_dumb (Command):
+class bdist_dumb(Command):
 
     description = "create a \"dumb\" built distribution"
 
@@ -45,8 +43,7 @@ class bdist_dumb (Command):
                        'nt': 'zip',
                        'os2': 'zip' }
 
-
-    def initialize_options (self):
+    def initialize_options(self):
         self.bdist_dir = None
         self.plat_name = None
         self.format = None
@@ -55,11 +52,7 @@ class bdist_dumb (Command):
         self.skip_build = 0
         self.relative = 0
 
-    # initialize_options()
-
-
-    def finalize_options (self):
-
+    def finalize_options(self):
         if self.bdist_dir is None:
             bdist_base = self.get_finalized_command('bdist').bdist_base
             self.bdist_dir = os.path.join(bdist_base, 'dumb')
@@ -68,19 +61,15 @@ class bdist_dumb (Command):
             try:
                 self.format = self.default_format[os.name]
             except KeyError:
-                raise DistutilsPlatformError, \
-                      ("don't know how to create dumb built distributions " +
-                       "on platform %s") % os.name
+                raise DistutilsPlatformError(
+                       "don't know how to create dumb built distributions "
+                       "on platform %s" % os.name)
 
         self.set_undefined_options('bdist',
                                    ('dist_dir', 'dist_dir'),
                                    ('plat_name', 'plat_name'))
 
-    # finalize_options()
-
-
-    def run (self):
-
+    def run(self):
         if not self.skip_build:
             self.run_command('build')
 
@@ -108,8 +97,8 @@ class bdist_dumb (Command):
         else:
             if (self.distribution.has_ext_modules() and
                 (install.install_base != install.install_platbase)):
-                raise DistutilsPlatformError, \
-                      ("can't make a dumb built distribution where "
+                raise DistutilsPlatformError(
+                       "can't make a dumb built distribution where "
                        "base and platbase are different (%s, %s)"
                        % (repr(install.install_base),
                           repr(install.install_platbase)))
@@ -129,7 +118,3 @@ class bdist_dumb (Command):
 
         if not self.keep_temp:
             remove_tree(self.bdist_dir, dry_run=self.dry_run)
-
-    # run()
-
-# class bdist_dumb

Lib/distutils/command/bdist_msi.py

@@ -81,7 +81,7 @@ class PyDialog(Dialog):
         Return the button, so that events can be associated"""
         return self.pushbutton(name, int(self.w*xpos - 28), self.h-27, 56, 17, 3, title, next)
 
-class bdist_msi (Command):
+class bdist_msi(Command):
 
     description = "create a Microsoft Installer (.msi) binary distribution"
 
@@ -114,7 +114,7 @@ class bdist_msi (Command):
     boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize',
                        'skip-build']
 
-    def initialize_options (self):
+    def initialize_options(self):
         self.bdist_dir = None
         self.keep_temp = 0
         self.no_target_compile = 0
@@ -125,7 +125,7 @@ class bdist_msi (Command):
         self.install_script = None
         self.pre_install_script = None
 
-    def finalize_options (self):
+    def finalize_options(self):
         if self.bdist_dir is None:
             bdist_base = self.get_finalized_command('bdist').bdist_base
             self.bdist_dir = os.path.join(bdist_base, 'msi')
@@ -133,30 +133,29 @@ class bdist_msi (Command):
         if self.target_version:
             if not self.skip_build and self.distribution.has_ext_modules()\
                and self.target_version != short_version:
-                raise DistutilsOptionError, \
-                      "target version can only be %s, or the '--skip_build'" \
-                      " option must be specified" % (short_version,)
+                raise DistutilsOptionError(
+                      "target version can only be %s, or the '--skip_build'"
+                      " option must be specified" % (short_version,))
         else:
             self.target_version = short_version
 
         self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
 
         if self.pre_install_script:
-            raise DistutilsOptionError, "the pre-install-script feature is not yet implemented"
+            raise DistutilsOptionError(
+                  "the pre-install-script feature is not yet implemented")
 
         if self.install_script:
             for script in self.distribution.scripts:
                 if self.install_script == os.path.basename(script):
                     break
             else:
-                raise DistutilsOptionError, \
-                      "install_script '%s' not found in scripts" % \
-                      self.install_script
+                raise DistutilsOptionError(
+                      "install_script '%s' not found in scripts"
+                      % self.install_script)
         self.install_script_key = None
-    # finalize_options()
 
-
-    def run (self):
+    def run(self):
         if not self.skip_build:
             self.run_command('build')
 
@@ -263,7 +262,8 @@ class bdist_msi (Command):
                     key = dir.add_file(file)
                     if file==self.install_script:
                         if self.install_script_key:
-                            raise DistutilsOptionError, "Multiple files with name %s" % file
+                            raise DistutilsOptionError(
+                                  "Multiple files with name %s" % file)
                         self.install_script_key = '[#%s]' % key
 
         cab.commit(db)

Lib/distutils/command/bdist_rpm.py

@@ -3,13 +3,10 @@
 Implements the Distutils 'bdist_rpm' command (create RPM source and binary
 distributions)."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, os
 import glob
-from types import *
 from distutils.core import Command
 from distutils.debug import DEBUG
 from distutils.util import get_platform
@@ -18,7 +15,7 @@ from distutils.errors import *
 from distutils.sysconfig import get_python_version
 from distutils import log
 
-class bdist_rpm (Command):
+class bdist_rpm(Command):
 
     description = "create an RPM distribution"
 
@@ -136,7 +133,7 @@ class bdist_rpm (Command):
                     'rpm2-mode': 'rpm3-mode'}
 
 
-    def initialize_options (self):
+    def initialize_options(self):
         self.bdist_base = None
         self.rpm_base = None
         self.dist_dir = None
@@ -180,15 +177,12 @@ class bdist_rpm (Command):
 
         self.force_arch = None
 
-    # initialize_options()
-
-
-    def finalize_options (self):
+    def finalize_options(self):
         self.set_undefined_options('bdist', ('bdist_base', 'bdist_base'))
         if self.rpm_base is None:
             if not self.rpm3_mode:
-                raise DistutilsOptionError, \
-                      "you must specify --rpm-base in RPM 2 mode"
+                raise DistutilsOptionError(
+                      "you must specify --rpm-base in RPM 2 mode")
             self.rpm_base = os.path.join(self.bdist_base, "rpm")
 
         if self.python is None:
@@ -197,16 +191,15 @@ class bdist_rpm (Command):
             else:
                 self.python = "python"
         elif self.fix_python:
-            raise DistutilsOptionError, \
-                  "--python and --fix-python are mutually exclusive options"
+            raise DistutilsOptionError(
+                  "--python and --fix-python are mutually exclusive options")
 
         if os.name != 'posix':
-            raise DistutilsPlatformError, \
-                  ("don't know how to create RPM "
+            raise DistutilsPlatformError("don't know how to create RPM "
                    "distributions on platform %s" % os.name)
         if self.binary_only and self.source_only:
-            raise DistutilsOptionError, \
-                  "cannot supply both '--source-only' and '--binary-only'"
+            raise DistutilsOptionError(
+                  "cannot supply both '--source-only' and '--binary-only'")
 
         # don't pass CFLAGS to pure python distributions
         if not self.distribution.has_ext_modules():
@@ -215,16 +208,14 @@ class bdist_rpm (Command):
         self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
         self.finalize_package_data()
 
-    # finalize_options()
-
-    def finalize_package_data (self):
+    def finalize_package_data(self):
         self.ensure_string('group', "Development/Libraries")
         self.ensure_string('vendor',
                            "%s <%s>" % (self.distribution.get_contact(),
                                         self.distribution.get_contact_email()))
         self.ensure_string('packager')
         self.ensure_string_list('doc_files')
-        if type(self.doc_files) is ListType:
+        if isinstance(self.doc_files, list):
             for readme in ('README', 'README.txt'):
                 if os.path.exists(readme) and readme not in self.doc_files:
                     self.doc_files.append(readme)
@@ -261,11 +252,8 @@ class bdist_rpm (Command):
         self.ensure_string_list('obsoletes')
 
         self.ensure_string('force_arch')
-    # finalize_package_data ()
-
-
-    def run (self):
 
+    def run(self):
         if DEBUG:
             print("before _get_package_data():")
             print("vendor =", self.vendor)
@@ -315,9 +303,8 @@ class bdist_rpm (Command):
             if os.path.exists(self.icon):
                 self.copy_file(self.icon, source_dir)
             else:
-                raise DistutilsFileError, \
-                      "icon file '%s' does not exist" % self.icon
-
+                raise DistutilsFileError(
+                      "icon file '%s' does not exist" % self.icon)
 
         # build package
         log.info("building RPMs")
@@ -350,7 +337,7 @@ class bdist_rpm (Command):
         out = os.popen(q_cmd)
         binary_rpms = []
         source_rpm = None
-        while 1:
+        while True:
             line = out.readline()
             if not line:
                 break
@@ -378,7 +365,6 @@ class bdist_rpm (Command):
                     rpm = os.path.join(rpm_dir['RPMS'], rpm)
                     if os.path.exists(rpm):
                         self.move_file(rpm, self.dist_dir)
-    # run()
 
     def _dist_path(self, path):
         return os.path.join(self.dist_dir, os.path.basename(path))
@@ -438,7 +424,7 @@ class bdist_rpm (Command):
                       'Obsoletes',
                       ):
             val = getattr(self, field.lower())
-            if type(val) is ListType:
+            if isinstance(val, list):
                 spec_file.append('%s: %s' % (field, ' '.join(val)))
             elif val is not None:
                 spec_file.append('%s: %s' % (field, val))
@@ -536,8 +522,6 @@ class bdist_rpm (Command):
 
         return spec_file
 
-    # _make_spec_file ()
-
     def _format_changelog(self, changelog):
         """Format the changelog correctly and convert it to a list of strings
         """
@@ -558,7 +542,3 @@ class bdist_rpm (Command):
             del new_changelog[0]
 
         return new_changelog
-
-    # _format_changelog()
-
-# class bdist_rpm

Lib/distutils/command/bdist_wininst.py

@@ -3,8 +3,6 @@
 Implements the Distutils 'bdist_wininst' command: create a windows installer
 exe-program."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, os
@@ -15,7 +13,7 @@ from distutils.errors import *
 from distutils.sysconfig import get_python_version
 from distutils import log
 
-class bdist_wininst (Command):
+class bdist_wininst(Command):
 
     description = "create an executable installer for MS Windows"
 
@@ -52,7 +50,7 @@ class bdist_wininst (Command):
     boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize',
                        'skip-build']
 
-    def initialize_options (self):
+    def initialize_options(self):
         self.bdist_dir = None
         self.keep_temp = 0
         self.no_target_compile = 0
@@ -65,10 +63,8 @@ class bdist_wininst (Command):
         self.install_script = None
         self.pre_install_script = None
 
-    # initialize_options()
-
 
-    def finalize_options (self):
+    def finalize_options(self):
         if self.bdist_dir is None:
             bdist_base = self.get_finalized_command('bdist').bdist_base
             self.bdist_dir = os.path.join(bdist_base, 'wininst')
@@ -77,9 +73,9 @@ class bdist_wininst (Command):
         if not self.skip_build and self.distribution.has_ext_modules():
             short_version = get_python_version()
             if self.target_version and self.target_version != short_version:
-                raise DistutilsOptionError, \
+                raise DistutilsOptionError(
                       "target version can only be %s, or the '--skip_build'" \
-                      " option must be specified" % (short_version,)
+                      " option must be specified" % (short_version,))
             self.target_version = short_version
 
         self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
@@ -89,13 +85,11 @@ class bdist_wininst (Command):
                 if self.install_script == os.path.basename(script):
                     break
             else:
-                raise DistutilsOptionError, \
-                      "install_script '%s' not found in scripts" % \
-                      self.install_script
-    # finalize_options()
+                raise DistutilsOptionError(
+                      "install_script '%s' not found in scripts"
+                      % self.install_script)
 
-
-    def run (self):
+    def run(self):
         if (sys.platform != "win32" and
             (self.distribution.has_ext_modules() or
              self.distribution.has_c_libraries())):
@@ -175,11 +169,8 @@ class bdist_wininst (Command):
         if not self.keep_temp:
             remove_tree(self.bdist_dir, dry_run=self.dry_run)
 
-    # run()
-
-    def get_inidata (self):
+    def get_inidata(self):
         # Return data describing the installation.
-
         lines = []
         metadata = self.distribution.metadata
 
@@ -222,9 +213,7 @@ class bdist_wininst (Command):
         lines.append("build_info=%s" % build_info)
         return "\n".join(lines)
 
-    # get_inidata()
-
-    def create_exe (self, arcname, fullname, bitmap=None):
+    def create_exe(self, arcname, fullname, bitmap=None):
         import struct
 
         self.mkpath(self.dist_dir)
@@ -272,8 +261,6 @@ class bdist_wininst (Command):
         file.write(header)
         file.write(open(arcname, "rb").read())
 
-    # create_exe()
-
     def get_installer_filename(self, fullname):
         # Factored out to allow overriding in subclasses
         if self.target_version:
@@ -286,9 +273,8 @@ class bdist_wininst (Command):
             installer_name = os.path.join(self.dist_dir,
                                           "%s.win32.exe" % fullname)
         return installer_name
-    # get_installer_filename()
 
-    def get_exe_bytes (self):
+    def get_exe_bytes(self):
         from distutils.msvccompiler import get_build_version
         # If a target-version other than the current version has been
         # specified, then using the MSVC version from *this* build is no good.
@@ -320,4 +306,3 @@ class bdist_wininst (Command):
         # used for python.  XXX What about mingw, borland, and so on?
         filename = os.path.join(directory, "wininst-%s.exe" % bv)
         return open(filename, "rb").read()
-# class bdist_wininst

Lib/distutils/command/build.py

@@ -2,8 +2,6 @@
 
 Implements the Distutils 'build' command."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, os
@@ -11,12 +9,12 @@ from distutils.core import Command
 from distutils.util import get_platform
 
 
-def show_compilers ():
+def show_compilers():
     from distutils.ccompiler import show_compilers
     show_compilers()
 
 
-class build (Command):
+class build(Command):
 
     description = "build everything needed to install"
 
@@ -51,7 +49,7 @@ class build (Command):
          "list available compilers", show_compilers),
         ]
 
-    def initialize_options (self):
+    def initialize_options(self):
         self.build_base = 'build'
         # these are decided only after 'build_base' has its final value
         # (unless overridden by the user or client)
@@ -65,8 +63,7 @@ class build (Command):
         self.force = 0
         self.executable = None
 
-    def finalize_options (self):
-
+    def finalize_options(self):
         plat_specifier = ".%s-%s" % (get_platform(), sys.version[0:3])
 
         # 'build_purelib' and 'build_platlib' just default to 'lib' and
@@ -98,11 +95,8 @@ class build (Command):
 
         if self.executable is None:
             self.executable = os.path.normpath(sys.executable)
-    # finalize_options ()
-
-
-    def run (self):
 
+    def run(self):
         # Run all relevant sub-commands.  This will be some subset of:
         #  - build_py      - pure Python modules
         #  - build_clib    - standalone C libraries
@@ -114,16 +108,16 @@ class build (Command):
 
     # -- Predicates for the sub-command list ---------------------------
 
-    def has_pure_modules (self):
+    def has_pure_modules(self):
         return self.distribution.has_pure_modules()
 
-    def has_c_libraries (self):
+    def has_c_libraries(self):
         return self.distribution.has_c_libraries()
 
-    def has_ext_modules (self):
+    def has_ext_modules(self):
         return self.distribution.has_ext_modules()
 
-    def has_scripts (self):
+    def has_scripts(self):
         return self.distribution.has_scripts()
 
 
@@ -132,5 +126,3 @@ class build (Command):
                     ('build_ext',     has_ext_modules),
                     ('build_scripts', has_scripts),
                    ]
-
-# class build

Lib/distutils/command/build_clib.py

@@ -4,8 +4,6 @@ Implements the Distutils 'build_clib' command, to build a C/C++ library
 that is included in the module distribution and needed by an extension
 module."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 
@@ -19,18 +17,17 @@ __revision__ = "$Id$"
 # cut 'n paste.  Sigh.
 
 import os
-from types import *
 from distutils.core import Command
 from distutils.errors import *
 from distutils.sysconfig import customize_compiler
 from distutils import log
 
-def show_compilers ():
+def show_compilers():
     from distutils.ccompiler import show_compilers
     show_compilers()
 
 
-class build_clib (Command):
+class build_clib(Command):
 
     description = "build C/C++ libraries used by Python extensions"
 
@@ -54,7 +51,7 @@ class build_clib (Command):
          "list available compilers", show_compilers),
         ]
 
-    def initialize_options (self):
+    def initialize_options(self):
         self.build_clib = None
         self.build_temp = None
 
@@ -69,11 +66,8 @@ class build_clib (Command):
         self.force = 0
         self.compiler = None
 
-    # initialize_options()
-
-
-    def finalize_options (self):
 
+    def finalize_options(self):
         # This might be confusing: both build-clib and build-temp default
         # to build-temp as defined by the "build" command.  This is because
         # I think that C libraries are really just temporary build
@@ -98,11 +92,8 @@ class build_clib (Command):
         # XXX same as for build_ext -- what about 'self.define' and
         # 'self.undef' ?
 
-    # finalize_options()
-
-
-    def run (self):
 
+    def run(self):
         if not self.libraries:
             return
 
@@ -125,51 +116,41 @@ class build_clib (Command):
 
         self.build_libraries(self.libraries)
 
-    # run()
 
-
-    def check_library_list (self, libraries):
+    def check_library_list(self, libraries):
         """Ensure that the list of libraries (presumably provided as a
            command option 'libraries') is valid, i.e. it is a list of
            2-tuples, where the tuples are (library_name, build_info_dict).
            Raise DistutilsSetupError if the structure is invalid anywhere;
            just returns otherwise."""
-
         # 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:
-            raise DistutilsSetupError, \
-                  "'libraries' option must be a list of tuples"
+        if not isinstance(libraries, list):
+            raise DistutilsSetupError(
+                  "'libraries' option must be a list of tuples")
 
         for lib in libraries:
-            if type(lib) is not TupleType and len(lib) != 2:
-                raise DistutilsSetupError, \
-                      "each element of 'libraries' must a 2-tuple"
+            if not isinstance(lib, tuple) and len(lib) != 2:
+                raise DistutilsSetupError(
+                      "each element of 'libraries' must a 2-tuple")
 
             if isinstance(lib[0], basestring):
-                raise DistutilsSetupError, \
-                      "first element of each tuple in 'libraries' " + \
-                      "must be a string (the library name)"
+                raise DistutilsSetupError(
+                      "first element of each tuple in 'libraries' "
+                      "must be a string (the library name)")
             if '/' in lib[0] or (os.sep != '/' and os.sep in lib[0]):
-                raise DistutilsSetupError, \
-                      ("bad library name '%s': " +
-                       "may not contain directory separators") % \
-                      lib[0]
-
-            if type(lib[1]) is not DictionaryType:
-                raise DistutilsSetupError, \
-                      "second element of each tuple in 'libraries' " + \
-                      "must be a dictionary (build info)"
-        # for lib
+                raise DistutilsSetupError("bad library name '%s': "
+                       "may not contain directory separators" % lib[0])
 
-    # check_library_list ()
+            if not isinstance(lib[1], dict):
+                raise DistutilsSetupError(
+                      "second element of each tuple in 'libraries' "
+                      "must be a dictionary (build info)")
 
 
-    def get_library_names (self):
+    def get_library_names(self):
         # Assume the library list is valid -- 'check_library_list()' is
         # called from 'finalize_options()', so it should be!
-
         if not self.libraries:
             return None
 
@@ -178,36 +159,30 @@ class build_clib (Command):
             lib_names.append(lib_name)
         return lib_names
 
-    # get_library_names ()
-
 
-    def get_source_files (self):
+    def get_source_files(self):
         self.check_library_list(self.libraries)
         filenames = []
         for (lib_name, build_info) in self.libraries:
             sources = build_info.get('sources')
-            if (sources is None or
-                type(sources) not in (ListType, TupleType) ):
-                raise DistutilsSetupError, \
-                      ("in 'libraries' option (library '%s'), "
+            if sources is None or not isinstance(sources, (list, tuple)):
+                raise DistutilsSetupError(
+                       "in 'libraries' option (library '%s'), "
                        "'sources' must be present and must be "
-                       "a list of source filenames") % lib_name
+                       "a list of source filenames" % lib_name)
 
             filenames.extend(sources)
-
         return filenames
-    # get_source_files ()
-
 
-    def build_libraries (self, libraries):
 
+    def build_libraries(self, libraries):
         for (lib_name, build_info) in libraries:
             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
+            if sources is None or not isinstance(sources, (list, tuple)):
+                raise DistutilsSetupError(
+                       "in 'libraries' option (library '%s'), "
+                       "'sources' must be present and must be "
+                       "a list of source filenames" % lib_name)
             sources = list(sources)
 
             log.info("building '%s' library", lib_name)
@@ -229,9 +204,3 @@ class build_clib (Command):
             self.compiler.create_static_lib(objects, lib_name,
                                             output_dir=self.build_clib,
                                             debug=self.debug)
-
-        # for libraries
-
-    # build_libraries ()
-
-# class build_lib

Lib/distutils/command/build_ext.py

@@ -4,12 +4,9 @@ Implements the Distutils 'build_ext' command, for building extension
 modules (currently limited to C extensions, should accommodate C++
 extensions ASAP)."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, os, re
-from types import *
 from distutils.core import Command
 from distutils.errors import *
 from distutils.sysconfig import customize_compiler, get_python_version
@@ -28,7 +25,7 @@ def show_compilers ():
     show_compilers()
 
 
-class build_ext (Command):
+class build_ext(Command):
 
     description = "build C/C++ extensions (compile/link to build directory)"
 
@@ -94,7 +91,7 @@ class build_ext (Command):
          "list available compilers", show_compilers),
         ]
 
-    def initialize_options (self):
+    def initialize_options(self):
         self.extensions = None
         self.build_lib = None
         self.build_temp = None
@@ -115,7 +112,7 @@ class build_ext (Command):
         self.swig_cpp = None
         self.swig_opts = None
 
-    def finalize_options (self):
+    def finalize_options(self):
         from distutils import sysconfig
 
         self.set_undefined_options('build',
@@ -130,7 +127,6 @@ class build_ext (Command):
 
         self.extensions = self.distribution.ext_modules
 
-
         # Make sure Python's include directories (for Python.h, pyconfig.h,
         # etc.) are in the include search path.
         py_include = sysconfig.get_python_inc()
@@ -226,11 +222,7 @@ class build_ext (Command):
         else:
             self.swig_opts = self.swig_opts.split(' ')
 
-    # finalize_options ()
-
-
-    def run (self):
-
+    def run(self):
         from distutils.ccompiler import new_compiler
 
         # 'self.extensions', as supplied by setup.py, is a list of
@@ -289,10 +281,7 @@ class build_ext (Command):
         # Now actually compile and link everything.
         self.build_extensions()
 
-    # run ()
-
-
-    def check_extensions_list (self, extensions):
+    def check_extensions_list(self, extensions):
         """Ensure that the list of extensions (presumably provided as a
         command option 'extensions') is valid, i.e. it is a list of
         Extension objects.  We also support the old-style list of 2-tuples,
@@ -302,34 +291,33 @@ class build_ext (Command):
         Raise DistutilsSetupError if the structure is invalid anywhere;
         just returns otherwise.
         """
-        if type(extensions) is not ListType:
-            raise DistutilsSetupError, \
-                  "'ext_modules' option must be a list of Extension instances"
+        if not isinstance(extensions, list):
+            raise DistutilsSetupError(
+                  "'ext_modules' option must be a list of Extension instances")
 
-        for i in range(len(extensions)):
-            ext = extensions[i]
+        for i, ext in enumerate(extensions):
             if isinstance(ext, Extension):
                 continue                # OK! (assume type-checking done
                                         # by Extension constructor)
 
             (ext_name, build_info) = ext
-            log.warn(("old-style (ext_name, build_info) tuple found in "
-                      "ext_modules for extension '%s'"
-                      "-- please convert to Extension instance" % ext_name))
-            if type(ext) is not TupleType and len(ext) != 2:
-                raise DistutilsSetupError, \
-                      ("each element of 'ext_modules' option must be an "
+            log.warn("old-style (ext_name, build_info) tuple found in "
+                     "ext_modules for extension '%s'"
+                     "-- please convert to Extension instance" % ext_name)
+            if not isinstance(ext, tuple) and len(ext) != 2:
+                raise DistutilsSetupError(
+                       "each element of 'ext_modules' option must be an "
                        "Extension instance or 2-tuple")
 
             if not (isinstance(ext_name, basestring) and
                     extension_name_re.match(ext_name)):
-                raise DistutilsSetupError, \
-                      ("first element of each tuple in 'ext_modules' "
+                raise DistutilsSetupError(
+                       "first element of each tuple in 'ext_modules' "
                        "must be the extension name (a string)")
 
-            if type(build_info) is not DictionaryType:
-                raise DistutilsSetupError, \
-                      ("second element of each tuple in 'ext_modules' "
+            if not instance(build_info, DictionaryType):
+                raise DistutilsSetupError(
+                       "second element of each tuple in 'ext_modules' "
                        "must be a dictionary (build info)")
 
             # OK, the (ext_name, build_info) dict is type-safe: convert it
@@ -361,11 +349,10 @@ class build_ext (Command):
                 ext.define_macros = []
                 ext.undef_macros = []
                 for macro in macros:
-                    if not (type(macro) is TupleType and
-                            1 <= len(macro) <= 2):
-                        raise DistutilsSetupError, \
-                              ("'macros' element of build info dict "
-                               "must be 1- or 2-tuple")
+                    if not (isinstance(macro, tuple) and len(macro) in (1, 2)):
+                        raise DistutilsSetupError(
+                              "'macros' element of build info dict "
+                              "must be 1- or 2-tuple")
                     if len(macro) == 1:
                         ext.undef_macros.append(macro[0])
                     elif len(macro) == 2:
@@ -373,24 +360,16 @@ class build_ext (Command):
 
             extensions[i] = ext
 
-        # for extensions
-
-    # check_extensions_list ()
-
-
-    def get_source_files (self):
+    def get_source_files(self):
         self.check_extensions_list(self.extensions)
         filenames = []
 
         # Wouldn't it be neat if we knew the names of header files too...
         for ext in self.extensions:
             filenames.extend(ext.sources)
-
         return filenames
 
-
-    def get_outputs (self):
-
+    def get_outputs(self):
         # 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*!).
@@ -406,8 +385,6 @@ class build_ext (Command):
                                         self.get_ext_filename(fullname)))
         return outputs
 
-    # get_outputs ()
-
     def build_extensions(self):
         # First, sanity-check the 'extensions' list
         self.check_extensions_list(self.extensions)
@@ -417,11 +394,11 @@ class build_ext (Command):
 
     def build_extension(self, ext):
         sources = ext.sources
-        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
+        if sources is None or not isinstance(sources, (list, tuple)):
+            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)
 
         fullname = self.get_ext_fullname(ext.name)
@@ -512,15 +489,12 @@ class build_ext (Command):
             build_temp=self.build_temp,
             target_lang=language)
 
-
-    def swig_sources (self, sources, extension):
-
+    def swig_sources(self, sources, extension):
         """Walk the list of source files in 'sources', looking for SWIG
         interface (.i) files.  Run SWIG on all that are found, and
         return a modified 'sources' list with SWIG source files replaced
         by the generated C (or C++) files.
         """
-
         new_sources = []
         swig_sources = []
         swig_targets = {}
@@ -569,18 +543,14 @@ class build_ext (Command):
 
         return new_sources
 
-    # swig_sources ()
-
-    def find_swig (self):
+    def find_swig(self):
         """Return the name of the SWIG executable.  On Unix, this is
         just "swig" -- it should be in the PATH.  Tries a bit harder on
         Windows.
         """
-
         if os.name == "posix":
             return "swig"
         elif os.name == "nt":
-
             # Look for SWIG in its standard installation directory on
             # Windows (or so I presume!).  If we find it there, great;
             # if not, act like Unix and assume it's in the PATH.
@@ -590,33 +560,28 @@ class build_ext (Command):
                     return fn
             else:
                 return "swig.exe"
-
         elif os.name == "os2":
             # assume swig available in the PATH.
             return "swig.exe"
-
         else:
-            raise DistutilsPlatformError, \
-                  ("I don't know how to find (much less run) SWIG "
-                   "on platform '%s'") % os.name
-
-    # find_swig ()
+            raise DistutilsPlatformError(
+                  "I don't know how to find (much less run) SWIG "
+                  "on platform '%s'" % os.name)
 
     # -- Name generators -----------------------------------------------
     # (extension names, filenames, whatever)
 
-    def get_ext_fullname (self, ext_name):
+    def get_ext_fullname(self, ext_name):
         if self.package is None:
             return ext_name
         else:
             return self.package + '.' + ext_name
 
-    def get_ext_filename (self, ext_name):
+    def get_ext_filename(self, ext_name):
         r"""Convert the name of an extension (eg. "foo.bar") into the name
         of the file from which it will be loaded (eg. "foo/bar.so", or
         "foo\bar.pyd").
         """
-
         from distutils.sysconfig import get_config_var
         ext_path = ext_name.split('.')
         # OS/2 has an 8 character module (extension) limit :-(
@@ -628,19 +593,18 @@ class build_ext (Command):
             return os.path.join(*ext_path) + '_d' + so_ext
         return os.path.join(*ext_path) + so_ext
 
-    def get_export_symbols (self, ext):
+    def get_export_symbols(self, ext):
         """Return the list of symbols that a shared extension has to
         export.  This either uses 'ext.export_symbols' or, if it's not
         provided, "init" + module_name.  Only relevant on Windows, where
         the .pyd file (DLL) must export the module "init" function.
         """
-
         initfunc_name = "init" + ext.name.split('.')[-1]
         if initfunc_name not in ext.export_symbols:
             ext.export_symbols.append(initfunc_name)
         return ext.export_symbols
 
-    def get_libraries (self, ext):
+    def get_libraries(self, ext):
         """Return the list of libraries to link against when building a
         shared extension.  On most platforms, this is just 'ext.libraries';
         on Windows and OS/2, we add the Python library (eg. python20.dll).
@@ -699,11 +663,9 @@ class build_ext (Command):
             # don't extend ext.libraries, it may be shared with other
             # extensions, it is a reference to the original list
             return ext.libraries + [pythonlib, "m"] + extra
-
         elif sys.platform == 'darwin':
             # Don't use the default code below
             return ext.libraries
-
         else:
             from distutils import sysconfig
             if sysconfig.get_config_var('Py_ENABLE_SHARED'):
@@ -713,5 +675,3 @@ class build_ext (Command):
                 return ext.libraries + [pythonlib]
             else:
                 return ext.libraries
-
-# class build_ext

Lib/distutils/command/build_py.py

@@ -2,12 +2,9 @@
 
 Implements the Distutils 'build_py' command."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, os
-from types import *
 from glob import glob
 
 from distutils.core import Command
@@ -32,8 +29,7 @@ class build_py (Command):
     boolean_options = ['compile', 'force']
     negative_opt = {'no-compile' : 'compile'}
 
-
-    def initialize_options (self):
+    def initialize_options(self):
         self.build_lib = None
         self.py_modules = None
         self.package = None
@@ -43,7 +39,7 @@ class build_py (Command):
         self.optimize = 0
         self.force = None
 
-    def finalize_options (self):
+    def finalize_options(self):
         self.set_undefined_options('build',
                                    ('build_lib', 'build_lib'),
                                    ('force', 'force'))
@@ -61,15 +57,14 @@ class build_py (Command):
 
         # Ick, copied straight from install_lib.py (fancy_getopt needs a
         # type system!  Hell, *everything* needs a type system!!!)
-        if type(self.optimize) is not IntType:
+        if not isinstance(self.optimize, int):
             try:
                 self.optimize = int(self.optimize)
                 assert 0 <= self.optimize <= 2
             except (ValueError, AssertionError):
-                raise DistutilsOptionError, "optimize must be 0, 1, or 2"
-
-    def run (self):
+                raise DistutilsOptionError("optimize must be 0, 1, or 2")
 
+    def run(self):
         # XXX copy_file by default preserves atime and mtime.  IMHO this is
         # the right thing to do, but perhaps it should be an option -- in
         # particular, a site administrator might want installed files to
@@ -99,9 +94,7 @@ class build_py (Command):
 
         self.byte_compile(self.get_outputs(include_bytecode=0))
 
-    # run ()
-
-    def get_data_files (self):
+    def get_data_files(self):
         """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
         data = []
         if not self.packages:
@@ -125,7 +118,7 @@ class build_py (Command):
             data.append((package, src_dir, build_dir, filenames))
         return data
 
-    def find_data_files (self, package, src_dir):
+    def find_data_files(self, package, src_dir):
         """Return filenames for package's data files in 'src_dir'"""
         globs = (self.package_data.get('', [])
                  + self.package_data.get(package, []))
@@ -137,7 +130,7 @@ class build_py (Command):
             files.extend([fn for fn in filelist if fn not in files])
         return files
 
-    def build_package_data (self):
+    def build_package_data(self):
         """Copy data files into build directory"""
         lastdir = None
         for package, src_dir, build_dir, filenames in self.data_files:
@@ -147,11 +140,10 @@ class build_py (Command):
                 self.copy_file(os.path.join(src_dir, filename), target,
                                preserve_mode=False)
 
-    def get_package_dir (self, package):
+    def get_package_dir(self, package):
         """Return the directory, relative to the top of the source
            distribution, where package 'package' should be found
            (at least according to the 'package_dir' option, if any)."""
-
         path = package.split('.')
 
         if not self.package_dir:
@@ -187,23 +179,19 @@ class build_py (Command):
                 else:
                     return ''
 
-    # get_package_dir ()
-
-
-    def check_package (self, package, package_dir):
-
+    def check_package(self, package, package_dir):
         # Empty dir name means current directory, which we can probably
         # assume exists.  Also, os.path.exists and isdir don't know about
         # my "empty string means current dir" convention, so we have to
         # circumvent them.
         if package_dir != "":
             if not os.path.exists(package_dir):
-                raise DistutilsFileError, \
-                      "package directory '%s' does not exist" % package_dir
+                raise DistutilsFileError(
+                      "package directory '%s' does not exist" % package_dir)
             if not os.path.isdir(package_dir):
-                raise DistutilsFileError, \
-                      ("supposed package directory '%s' exists, " +
-                       "but is not a directory") % 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:
@@ -218,20 +206,14 @@ class build_py (Command):
         # __init__.py doesn't exist -- so don't return the filename.
         return None
 
-    # check_package ()
-
-
-    def check_module (self, module, module_file):
+    def check_module(self, module, module_file):
         if not os.path.isfile(module_file):
             log.warn("file %s (for module %s) not found", module_file, module)
-            return 0
+            return False
         else:
-            return 1
+            return True
 
-    # check_module ()
-
-
-    def find_package_modules (self, package, package_dir):
+    def find_package_modules(self, package, package_dir):
         self.check_package(package, package_dir)
         module_files = glob(os.path.join(package_dir, "*.py"))
         modules = []
@@ -246,8 +228,7 @@ class build_py (Command):
                 self.debug_print("excluding %s" % setup_script)
         return modules
 
-
-    def find_modules (self):
+    def find_modules(self):
         """Finds individually-specified Python modules, ie. those listed by
         module name in 'self.py_modules'.  Returns a list of tuples (package,
         module_base, filename): 'package' is a tuple of the path through
@@ -256,7 +237,6 @@ class build_py (Command):
         ".py" file (relative to the distribution root) that implements the
         module.
         """
-
         # Map package names to tuples of useful info about the package:
         #    (package_dir, checked)
         # package_dir - the directory where we'll find source files for
@@ -272,7 +252,6 @@ class build_py (Command):
         # just the "package" for a toplevel is empty (either an empty
         # string or empty list, depending on context).  Differences:
         #   - don't check for __init__.py in directory for empty package
-
         for module in self.py_modules:
             path = module.split('.')
             package = '.'.join(path[0:-1])
@@ -301,16 +280,12 @@ class build_py (Command):
 
         return modules
 
-    # find_modules ()
-
-
-    def find_all_modules (self):
+    def find_all_modules(self):
         """Compute the list of all modules that will be built, whether
         they are specified one-module-at-a-time ('self.py_modules') or
         by whole packages ('self.packages').  Return a list of tuples
         (package, module, module_file), just like 'find_modules()' and
         'find_package_modules()' do."""
-
         modules = []
         if self.py_modules:
             modules.extend(self.find_modules())
@@ -319,28 +294,16 @@ class build_py (Command):
                 package_dir = self.get_package_dir(package)
                 m = self.find_package_modules(package, package_dir)
                 modules.extend(m)
-
         return modules
 
-    # find_all_modules ()
+    def get_source_files(self):
+        return [module[-1] for module in self.find_all_modules()]
 
-
-    def get_source_files (self):
-
-        modules = self.find_all_modules()
-        filenames = []
-        for module in modules:
-            filenames.append(module[-1])
-
-        return filenames
-
-
-    def get_module_outfile (self, build_dir, package, module):
+    def get_module_outfile(self, build_dir, package, module):
         outfile_path = [build_dir] + list(package) + [module + ".py"]
         return os.path.join(*outfile_path)
 
-
-    def get_outputs (self, include_bytecode=1):
+    def get_outputs(self, include_bytecode=1):
         modules = self.find_all_modules()
         outputs = []
         for (package, module, module_file) in modules:
@@ -361,13 +324,12 @@ class build_py (Command):
 
         return outputs
 
-
-    def build_module (self, module, module_file, package):
+    def build_module(self, module, module_file, package):
         if isinstance(package, basestring):
             package = package.split('.')
-        elif type(package) not in (ListType, TupleType):
-            raise TypeError, \
-                  "'package' must be a string (dot-separated), list, or tuple"
+        elif not isinstance(package, (list, tuple)):
+            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
@@ -377,25 +339,17 @@ class build_py (Command):
         self.mkpath(dir)
         return self.copy_file(module_file, outfile, preserve_mode=0)
 
-
-    def build_modules (self):
-
+    def build_modules(self):
         modules = self.find_modules()
         for (package, module, module_file) in modules:
-
             # Now "build" the module -- ie. copy the source file to
             # 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)
 
-    # build_modules ()
-
-
-    def build_packages (self):
-
+    def build_packages(self):
         for package in self.packages:
-
             # Get list of (package, module, module_file) tuples based on
             # scanning the package directory.  'package' is only included
             # in the tuple so that 'find_modules()' and
@@ -414,10 +368,7 @@ class build_py (Command):
                 assert package == package_
                 self.build_module(module, module_file, package)
 
-    # build_packages ()
-
-
-    def byte_compile (self, files):
+    def byte_compile(self, files):
         from distutils.util import byte_compile
         prefix = self.build_lib
         if prefix[-1] != os.sep:
@@ -426,12 +377,9 @@ class build_py (Command):
         # XXX this code is essentially the same as the 'byte_compile()
         # method of the "install_lib" command, except for the determination
         # of the 'prefix' string.  Hmmm.
-
         if self.compile:
             byte_compile(files, optimize=0,
                          force=self.force, prefix=prefix, dry_run=self.dry_run)
         if self.optimize > 0:
             byte_compile(files, optimize=self.optimize,
                          force=self.force, prefix=prefix, dry_run=self.dry_run)
-
-# class build_py

Lib/distutils/command/build_scripts.py

@@ -2,8 +2,6 @@
 
 Implements the Distutils 'build_scripts' command."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, os, re
@@ -17,7 +15,7 @@ from distutils import log
 # check if Python is called on the first line with this expression
 first_line_re = re.compile('^#!.*python[0-9.]*([ \t].*)?$')
 
-class build_scripts (Command):
+class build_scripts(Command):
 
     description = "\"build\" scripts (copy and fixup #! line)"
 
@@ -30,14 +28,14 @@ class build_scripts (Command):
     boolean_options = ['force']
 
 
-    def initialize_options (self):
+    def initialize_options(self):
         self.build_dir = None
         self.scripts = None
         self.force = None
         self.executable = None
         self.outfiles = None
 
-    def finalize_options (self):
+    def finalize_options(self):
         self.set_undefined_options('build',
                                    ('build_scripts', 'build_dir'),
                                    ('force', 'force'),
@@ -47,13 +45,13 @@ class build_scripts (Command):
     def get_source_files(self):
         return self.scripts
 
-    def run (self):
+    def run(self):
         if not self.scripts:
             return
         self.copy_scripts()
 
 
-    def copy_scripts (self):
+    def copy_scripts(self):
         """Copy each script listed in 'self.scripts'; if it's marked as a
         Python script in the Unix way (first line matches 'first_line_re',
         ie. starts with "\#!" and contains "python"), then adjust the first
@@ -62,7 +60,7 @@ class build_scripts (Command):
         self.mkpath(self.build_dir)
         outfiles = []
         for script in self.scripts:
-            adjust = 0
+            adjust = False
             script = convert_path(script)
             outfile = os.path.join(self.build_dir, os.path.basename(script))
             outfiles.append(outfile)
@@ -88,7 +86,7 @@ class build_scripts (Command):
 
                 match = first_line_re.match(first_line)
                 if match:
-                    adjust = 1
+                    adjust = True
                     post_interp = match.group(1) or ''
 
             if adjust:
@@ -125,7 +123,3 @@ class build_scripts (Command):
                         log.info("changing mode of %s from %o to %o",
                                  file, oldmode, newmode)
                         os.chmod(file, newmode)
-
-    # copy_scripts ()
-
-# class build_scripts

Lib/distutils/command/clean.py

@@ -4,8 +4,6 @@ Implements the Distutils 'clean' command."""
 
 # contributed by Bastian Kleineidam <calvin@cs.uni-sb.de>, added 2000-03-18
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import os
@@ -13,7 +11,7 @@ from distutils.core import Command
 from distutils.dir_util import remove_tree
 from distutils import log
 
-class clean (Command):
+class clean(Command):
 
     description = "clean up temporary files from 'build' command"
     user_options = [
@@ -78,5 +76,3 @@ class clean (Command):
                 log.info("removing '%s'", self.build_base)
             except OSError:
                 pass
-
-# class clean

Lib/distutils/command/command_template

@@ -10,7 +10,7 @@ __revision__ = "$Id$"
 from distutils.core import Command
 
 
-class x (Command):
+class x(Command):
 
     # Brief (40-50 characters) description of the command
     description = ""
@@ -21,25 +21,13 @@ class x (Command):
                      ""),
                    ]
 
-
-    def initialize_options (self):
+    def initialize_options(self):
         self. = None
         self. = None
         self. = None
 
-    # initialize_options()
-
-
-    def finalize_options (self):
+    def finalize_options(self):
         if self.x is None:
             self.x = 
 
-    # finalize_options()
-
-
-    def run (self):
-
-
-    # run()
-
-# class x
+    def run(self):

Lib/distutils/command/config.py

@@ -9,21 +9,17 @@ configure-like tasks: "try to compile this C code", or "figure out where
 this header file lives".
 """
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, os, re
-from types import *
 from distutils.core import Command
 from distutils.errors import DistutilsExecError
 from distutils.sysconfig import customize_compiler
 from distutils import log
 
-LANG_EXT = {'c': '.c',
-            'c++': '.cxx'}
+LANG_EXT = {"c": ".c", "c++": ".cxx"}
 
-class config (Command):
+class config(Command):
 
     description = "prepare to build"
 
@@ -53,7 +49,7 @@ class config (Command):
     # The three standard command methods: since the "config" command
     # does nothing by default, these are empty.
 
-    def initialize_options (self):
+    def initialize_options(self):
         self.compiler = None
         self.cc = None
         self.include_dirs = None
@@ -70,7 +66,7 @@ class config (Command):
         # to clean at some point
         self.temp_files = []
 
-    def finalize_options (self):
+    def finalize_options(self):
         if self.include_dirs is None:
             self.include_dirs = self.distribution.include_dirs or []
         elif isinstance(self.include_dirs, basestring):
@@ -86,16 +82,14 @@ class config (Command):
         elif isinstance(self.library_dirs, basestring):
             self.library_dirs = self.library_dirs.split(os.pathsep)
 
-
-    def run (self):
+    def run(self):
         pass
 
-
     # Utility methods for actual "config" commands.  The interfaces are
     # loosely based on Autoconf macros of similar names.  Sub-classes
     # may use these freely.
 
-    def _check_compiler (self):
+    def _check_compiler(self):
         """Check that 'self.compiler' really is a CCompiler object;
         if not, make it one.
         """
@@ -113,8 +107,7 @@ class config (Command):
             if self.library_dirs:
                 self.compiler.set_library_dirs(self.library_dirs)
 
-
-    def _gen_temp_sourcefile (self, body, headers, lang):
+    def _gen_temp_sourcefile(self, body, headers, lang):
         filename = "_configtest" + LANG_EXT[lang]
         file = open(filename, "w")
         if headers:
@@ -127,14 +120,14 @@ class config (Command):
         file.close()
         return filename
 
-    def _preprocess (self, body, headers, include_dirs, lang):
+    def _preprocess(self, body, headers, include_dirs, lang):
         src = self._gen_temp_sourcefile(body, headers, lang)
         out = "_configtest.i"
         self.temp_files.extend([src, out])
         self.compiler.preprocess(src, out, include_dirs=include_dirs)
         return (src, out)
 
-    def _compile (self, body, headers, include_dirs, lang):
+    def _compile(self, body, headers, include_dirs, lang):
         src = self._gen_temp_sourcefile(body, headers, lang)
         if self.dump_source:
             dump_file(src, "compiling '%s':" % src)
@@ -143,9 +136,8 @@ class config (Command):
         self.compiler.compile([src], include_dirs=include_dirs)
         return (src, obj)
 
-    def _link (self, body,
-               headers, include_dirs,
-               libraries, library_dirs, lang):
+    def _link(self, body, headers, include_dirs, libraries,
+              library_dirs, lang):
         (src, obj) = self._compile(body, headers, include_dirs, lang)
         prog = os.path.splitext(os.path.basename(src))[0]
         self.compiler.link_executable([obj], prog,
@@ -159,7 +151,7 @@ class config (Command):
 
         return (src, obj, prog)
 
-    def _clean (self, *filenames):
+    def _clean(self, *filenames):
         if not filenames:
             filenames = self.temp_files
             self.temp_files = []
@@ -181,7 +173,7 @@ class config (Command):
 
     # XXX need access to the header search path and maybe default macros.
 
-    def try_cpp (self, body=None, headers=None, include_dirs=None, lang="c"):
+    def try_cpp(self, body=None, headers=None, include_dirs=None, lang="c"):
         """Construct a source file from 'body' (a string containing lines
         of C/C++ code) and 'headers' (a list of header files to include)
         and run it through the preprocessor.  Return true if the
@@ -190,17 +182,17 @@ class config (Command):
         """
         from distutils.ccompiler import CompileError
         self._check_compiler()
-        ok = 1
+        ok = True
         try:
             self._preprocess(body, headers, include_dirs, lang)
         except CompileError:
-            ok = 0
+            ok = False
 
         self._clean()
         return ok
 
-    def search_cpp (self, pattern, body=None,
-                    headers=None, include_dirs=None, lang="c"):
+    def search_cpp(self, pattern, body=None, headers=None,
+                   include_dirs=None, lang="c"):
         """Construct a source file (just like 'try_cpp()'), run it through
         the preprocessor, and return true if any line of the output matches
         'pattern'.  'pattern' should either be a compiled regex object or a
@@ -216,20 +208,20 @@ class config (Command):
             pattern = re.compile(pattern)
 
         file = open(out)
-        match = 0
-        while 1:
+        match = False
+        while True:
             line = file.readline()
             if line == '':
                 break
             if pattern.search(line):
-                match = 1
+                match = True
                 break
 
         file.close()
         self._clean()
         return match
 
-    def try_compile (self, body, headers=None, include_dirs=None, lang="c"):
+    def try_compile(self, body, headers=None, include_dirs=None, lang="c"):
         """Try to compile a source file built from 'body' and 'headers'.
         Return true on success, false otherwise.
         """
@@ -237,18 +229,16 @@ class config (Command):
         self._check_compiler()
         try:
             self._compile(body, headers, include_dirs, lang)
-            ok = 1
+            ok = True
         except CompileError:
-            ok = 0
+            ok = False
 
         log.info(ok and "success!" or "failure.")
         self._clean()
         return ok
 
-    def try_link (self, body,
-                  headers=None, include_dirs=None,
-                  libraries=None, library_dirs=None,
-                  lang="c"):
+    def try_link(self, body, headers=None, include_dirs=None,
+                 libraries=None, library_dirs=None, lang="c"):
         """Try to compile and link a source file, built from 'body' and
         'headers', to executable form.  Return true on success, false
         otherwise.
@@ -258,18 +248,16 @@ class config (Command):
         try:
             self._link(body, headers, include_dirs,
                        libraries, library_dirs, lang)
-            ok = 1
+            ok = True
         except (CompileError, LinkError):
-            ok = 0
+            ok = False
 
         log.info(ok and "success!" or "failure.")
         self._clean()
         return ok
 
-    def try_run (self, body,
-                 headers=None, include_dirs=None,
-                 libraries=None, library_dirs=None,
-                 lang="c"):
+    def try_run(self, body, headers=None, include_dirs=None,
+                libraries=None, library_dirs=None, lang="c"):
         """Try to compile, link to an executable, and run a program
         built from 'body' and 'headers'.  Return true on success, false
         otherwise.
@@ -280,9 +268,9 @@ class config (Command):
             src, obj, exe = self._link(body, headers, include_dirs,
                                        libraries, library_dirs, lang)
             self.spawn([exe])
-            ok = 1
+            ok = True
         except (CompileError, LinkError, DistutilsExecError):
-            ok = 0
+            ok = False
 
         log.info(ok and "success!" or "failure.")
         self._clean()
@@ -293,11 +281,8 @@ class config (Command):
     # (these are the ones that are actually likely to be useful
     # when implementing a real-world config command!)
 
-    def check_func (self, func,
-                    headers=None, include_dirs=None,
-                    libraries=None, library_dirs=None,
-                    decl=0, call=0):
-
+    def check_func(self, func, headers=None, include_dirs=None,
+                   libraries=None, library_dirs=None, decl=0, call=0):
         """Determine if function 'func' is available by constructing a
         source file that refers to 'func', and compiles and links it.
         If everything succeeds, returns true; otherwise returns false.
@@ -311,7 +296,6 @@ class config (Command):
         calls it.  'libraries' and 'library_dirs' are used when
         linking.
         """
-
         self._check_compiler()
         body = []
         if decl:
@@ -327,10 +311,8 @@ class config (Command):
         return self.try_link(body, headers, include_dirs,
                              libraries, library_dirs)
 
-    # check_func ()
-
-    def check_lib (self, library, library_dirs=None,
-                   headers=None, include_dirs=None, other_libraries=[]):
+    def check_lib(self, library, library_dirs=None, headers=None,
+                  include_dirs=None, other_libraries=[]):
         """Determine if 'library' is available to be linked against,
         without actually checking that any particular symbols are provided
         by it.  'headers' will be used in constructing the source file to
@@ -340,12 +322,11 @@ class config (Command):
         has symbols that depend on other libraries.
         """
         self._check_compiler()
-        return self.try_link("int main (void) { }",
-                             headers, include_dirs,
-                             [library]+other_libraries, library_dirs)
+        return self.try_link("int main (void) { }", headers, include_dirs,
+                             [library] + other_libraries, library_dirs)
 
-    def check_header (self, header, include_dirs=None,
-                      library_dirs=None, lang="c"):
+    def check_header(self, header, include_dirs=None, library_dirs=None,
+                     lang="c"):
         """Determine if the system header file named by 'header_file'
         exists and can be found by the preprocessor; return true if so,
         false otherwise.
@@ -354,10 +335,7 @@ class config (Command):
                             include_dirs=include_dirs)
 
 
-# class config
-
-
-def dump_file (filename, head=None):
+def dump_file(filename, head=None):
     if head is None:
         print(filename + ":")
     else:

Lib/distutils/command/install.py

@@ -4,12 +4,9 @@ Implements the Distutils 'install' command."""
 
 from distutils import log
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, os
-from types import *
 from distutils.core import Command
 from distutils.debug import DEBUG
 from distutils.sysconfig import get_config_vars
@@ -141,7 +138,7 @@ class install (Command):
     negative_opt = {'no-compile' : 'compile'}
 
 
-    def initialize_options (self):
+    def initialize_options(self):
 
         # High-level options: these select both an installation base
         # and scheme.
@@ -215,7 +212,7 @@ class install (Command):
     # party Python modules on various platforms given a wide
     # array of user input is decided.  Yes, it's quite complex!)
 
-    def finalize_options (self):
+    def finalize_options(self):
 
         # This method (and its pliant slaves, like 'finalize_unix()',
         # 'finalize_other()', and 'select_scheme()') is where the default
@@ -233,13 +230,13 @@ class install (Command):
 
         if ((self.prefix or self.exec_prefix or self.home) and
             (self.install_base or self.install_platbase)):
-            raise DistutilsOptionError, \
-                  ("must supply either prefix/exec-prefix/home or " +
+            raise DistutilsOptionError(
+                   "must supply either prefix/exec-prefix/home or " +
                    "install-base/install-platbase -- not both")
 
         if self.home and (self.prefix or self.exec_prefix):
-            raise DistutilsOptionError, \
-                  "must supply either home or prefix/exec-prefix -- not both"
+            raise DistutilsOptionError(
+                  "must supply either home or prefix/exec-prefix -- not both")
 
         # Next, stuff that's wrong (or dubious) only on certain platforms.
         if os.name != "posix":
@@ -341,10 +338,8 @@ class install (Command):
         # Punt on doc directories for now -- after all, we're punting on
         # documentation completely!
 
-    # finalize_options ()
-
 
-    def dump_dirs (self, msg):
+    def dump_dirs(self, msg):
         if DEBUG:
             from distutils.fancy_getopt import longopt_xlate
             print(msg + ":")
@@ -362,8 +357,7 @@ class install (Command):
                 print("  %s: %s" % (opt_name, val))
 
 
-    def finalize_unix (self):
-
+    def finalize_unix(self):
         if self.install_base is not None or self.install_platbase is not None:
             if ((self.install_lib is None and
                  self.install_purelib is None and
@@ -371,8 +365,8 @@ class install (Command):
                 self.install_headers is None or
                 self.install_scripts is None or
                 self.install_data is None):
-                raise DistutilsOptionError, \
-                      ("install-base or install-platbase supplied, but "
+                raise DistutilsOptionError(
+                      "install-base or install-platbase supplied, but "
                       "installation scheme is incomplete")
             return
 
@@ -382,8 +376,8 @@ class install (Command):
         else:
             if self.prefix is None:
                 if self.exec_prefix is not None:
-                    raise DistutilsOptionError, \
-                          "must not supply exec-prefix without prefix"
+                    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)
@@ -396,11 +390,8 @@ class install (Command):
             self.install_platbase = self.exec_prefix
             self.select_scheme("unix_prefix")
 
-    # finalize_unix ()
-
-
-    def finalize_other (self):          # Windows and Mac OS for now
 
+    def finalize_other(self):          # Windows and Mac OS for now
         if self.home is not None:
             self.install_base = self.install_platbase = self.home
             self.select_scheme("unix_home")
@@ -412,13 +403,11 @@ class install (Command):
             try:
                 self.select_scheme(os.name)
             except KeyError:
-                raise DistutilsPlatformError, \
-                      "I don't know how to install stuff on '%s'" % os.name
-
-    # finalize_other ()
+                raise DistutilsPlatformError(
+                      "I don't know how to install stuff on '%s'" % os.name)
 
 
-    def select_scheme (self, name):
+    def select_scheme(self, name):
         # it's the caller's problem if they supply a bad name!
         scheme = INSTALL_SCHEMES[name]
         for key in SCHEME_KEYS:
@@ -427,7 +416,7 @@ class install (Command):
                 setattr(self, attrname, scheme[key])
 
 
-    def _expand_attrs (self, attrs):
+    def _expand_attrs(self, attrs):
         for attr in attrs:
             val = getattr(self, attr)
             if val is not None:
@@ -437,12 +426,12 @@ class install (Command):
                 setattr(self, attr, val)
 
 
-    def expand_basedirs (self):
+    def expand_basedirs(self):
         self._expand_attrs(['install_base',
                             'install_platbase',
                             'root'])
 
-    def expand_dirs (self):
+    def expand_dirs(self):
         self._expand_attrs(['install_purelib',
                             'install_platlib',
                             'install_lib',
@@ -451,14 +440,12 @@ class install (Command):
                             'install_data',])
 
 
-    def convert_paths (self, *names):
+    def convert_paths(self, *names):
         for name in names:
             attr = "install_" + name
             setattr(self, attr, convert_path(getattr(self, attr)))
 
-
-    def handle_extra_path (self):
-
+    def handle_extra_path(self):
         if self.extra_path is None:
             self.extra_path = self.distribution.extra_path
 
@@ -471,8 +458,8 @@ class install (Command):
             elif len(self.extra_path) == 2:
                 (path_file, extra_dirs) = self.extra_path
             else:
-                raise DistutilsOptionError, \
-                      ("'extra_path' option must be a list, tuple, or "
+                raise DistutilsOptionError(
+                      "'extra_path' option must be a list, tuple, or "
                       "comma-separated string with 1 or 2 elements")
 
             # convert to local form in case Unix notation used (as it
@@ -488,10 +475,7 @@ class install (Command):
         self.path_file = path_file
         self.extra_dirs = extra_dirs
 
-    # handle_extra_path ()
-
-
-    def change_roots (self, *names):
+    def change_roots(self, *names):
         for name in names:
             attr = "install_" + name
             setattr(self, attr, change_root(self.root, getattr(self, attr)))
@@ -499,8 +483,7 @@ class install (Command):
 
     # -- Command execution methods -------------------------------------
 
-    def run (self):
-
+    def run(self):
         # Obviously have to build before we can install
         if not self.skip_build:
             self.run_command('build')
@@ -535,9 +518,7 @@ class install (Command):
                        "you'll have to change the search path yourself"),
                        self.install_lib)
 
-    # run ()
-
-    def create_path_file (self):
+    def create_path_file(self):
         filename = os.path.join(self.install_libbase,
                                 self.path_file + ".pth")
         if self.install_path_file:
@@ -550,7 +531,7 @@ class install (Command):
 
     # -- Reporting methods ---------------------------------------------
 
-    def get_outputs (self):
+    def get_outputs(self):
         # Assemble the outputs of all the sub-commands.
         outputs = []
         for cmd_name in self.get_sub_commands():
@@ -567,7 +548,7 @@ class install (Command):
 
         return outputs
 
-    def get_inputs (self):
+    def get_inputs(self):
         # XXX gee, this looks familiar ;-(
         inputs = []
         for cmd_name in self.get_sub_commands():
@@ -579,19 +560,19 @@ class install (Command):
 
     # -- Predicates for sub-command list -------------------------------
 
-    def has_lib (self):
+    def has_lib(self):
         """Return true if the current distribution has any Python
         modules to install."""
         return (self.distribution.has_pure_modules() or
                 self.distribution.has_ext_modules())
 
-    def has_headers (self):
+    def has_headers(self):
         return self.distribution.has_headers()
 
-    def has_scripts (self):
+    def has_scripts(self):
         return self.distribution.has_scripts()
 
-    def has_data (self):
+    def has_data(self):
         return self.distribution.has_data_files()
 
 
@@ -603,5 +584,3 @@ class install (Command):
                     ('install_data',    has_data),
                     ('install_egg_info', lambda self:True),
                    ]
-
-# class install

Lib/distutils/command/install_data.py

@@ -5,15 +5,13 @@ platform-independent data files."""
 
 # contributed by Bastian Kleineidam
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import os
 from distutils.core import Command
 from distutils.util import change_root, convert_path
 
-class install_data (Command):
+class install_data(Command):
 
     description = "install data files"
 
@@ -28,7 +26,7 @@ class install_data (Command):
 
     boolean_options = ['force']
 
-    def initialize_options (self):
+    def initialize_options(self):
         self.install_dir = None
         self.outfiles = []
         self.root = None
@@ -37,14 +35,14 @@ class install_data (Command):
         self.data_files = self.distribution.data_files
         self.warn_dir = 1
 
-    def finalize_options (self):
+    def finalize_options(self):
         self.set_undefined_options('install',
                                    ('install_data', 'install_dir'),
                                    ('root', 'root'),
                                    ('force', 'force'),
                                   )
 
-    def run (self):
+    def run(self):
         self.mkpath(self.install_dir)
         for f in self.data_files:
             if isinstance(f, basestring):
@@ -77,8 +75,8 @@ class install_data (Command):
                         (out, _) = self.copy_file(data, dir)
                         self.outfiles.append(out)
 
-    def get_inputs (self):
+    def get_inputs(self):
         return self.data_files or []
 
-    def get_outputs (self):
+    def get_outputs(self):
         return self.outfiles

Lib/distutils/command/install_headers.py

@@ -3,15 +3,13 @@
 Implements the Distutils 'install_headers' command, to install C/C++ header
 files to the Python include directory."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import os
 from distutils.core import Command
 
 
-class install_headers (Command):
+class install_headers(Command):
 
     description = "install C/C++ header files"
 
@@ -23,18 +21,18 @@ class install_headers (Command):
 
     boolean_options = ['force']
 
-    def initialize_options (self):
+    def initialize_options(self):
         self.install_dir = None
         self.force = 0
         self.outfiles = []
 
-    def finalize_options (self):
+    def finalize_options(self):
         self.set_undefined_options('install',
                                    ('install_headers', 'install_dir'),
                                    ('force', 'force'))
 
 
-    def run (self):
+    def run(self):
         headers = self.distribution.headers
         if not headers:
             return
@@ -44,10 +42,8 @@ class install_headers (Command):
             (out, _) = self.copy_file(header, self.install_dir)
             self.outfiles.append(out)
 
-    def get_inputs (self):
+    def get_inputs(self):
         return self.distribution.headers or []
 
-    def get_outputs (self):
+    def get_outputs(self):
         return self.outfiles
-
-# class install_headers

Lib/distutils/command/install_lib.py

-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, os
-from types import IntType
 from distutils.core import Command
 from distutils.errors import DistutilsOptionError
 
@@ -11,7 +8,7 @@ from distutils.errors import DistutilsOptionError
 # Extension for Python source files.
 PYTHON_SOURCE_EXTENSION = ".py"
 
-class install_lib (Command):
+class install_lib(Command):
 
     description = "install all Python modules (extensions and pure Python)"
 
@@ -45,8 +42,7 @@ class install_lib (Command):
     boolean_options = ['force', 'compile', 'skip-build']
     negative_opt = {'no-compile' : 'compile'}
 
-
-    def initialize_options (self):
+    def initialize_options(self):
         # let the 'install' command dictate our installation directory
         self.install_dir = None
         self.build_dir = None
@@ -55,7 +51,7 @@ class install_lib (Command):
         self.optimize = None
         self.skip_build = None
 
-    def finalize_options (self):
+    def finalize_options(self):
 
         # Get all the information we need to install pure Python modules
         # from the umbrella 'install' command -- build (source) directory,
@@ -70,19 +66,18 @@ class install_lib (Command):
                                   )
 
         if self.compile is None:
-            self.compile = 1
+            self.compile = True
         if self.optimize is None:
-            self.optimize = 0
+            self.optimize = False
 
-        if type(self.optimize) is not IntType:
+        if not isinstance(self.optimize, int):
             try:
                 self.optimize = int(self.optimize)
                 assert 0 <= self.optimize <= 2
             except (ValueError, AssertionError):
-                raise DistutilsOptionError, "optimize must be 0, 1, or 2"
-
-    def run (self):
+                raise DistutilsOptionError("optimize must be 0, 1, or 2")
 
+    def run(self):
         # Make sure we have built everything we need first
         self.build()
 
@@ -95,20 +90,18 @@ class install_lib (Command):
         if outfiles is not None and self.distribution.has_pure_modules():
             self.byte_compile(outfiles)
 
-    # run ()
-
 
     # -- Top-level worker functions ------------------------------------
     # (called from 'run()')
 
-    def build (self):
+    def build(self):
         if not self.skip_build:
             if self.distribution.has_pure_modules():
                 self.run_command('build_py')
             if self.distribution.has_ext_modules():
                 self.run_command('build_ext')
 
-    def install (self):
+    def install(self):
         if os.path.isdir(self.build_dir):
             outfiles = self.copy_tree(self.build_dir, self.install_dir)
         else:
@@ -117,7 +110,7 @@ class install_lib (Command):
             return
         return outfiles
 
-    def byte_compile (self, files):
+    def byte_compile(self, files):
         from distutils.util import byte_compile
 
         # Get the "--root" directory supplied to the "install" command,
@@ -138,8 +131,7 @@ class install_lib (Command):
 
     # -- Utility methods -----------------------------------------------
 
-    def _mutate_outputs (self, has_any, build_cmd, cmd_option, output_dir):
-
+    def _mutate_outputs(self, has_any, build_cmd, cmd_option, output_dir):
         if not has_any:
             return []
 
@@ -154,9 +146,7 @@ class install_lib (Command):
 
         return outputs
 
-    # _mutate_outputs ()
-
-    def _bytecode_filenames (self, py_filenames):
+    def _bytecode_filenames(self, py_filenames):
         bytecode_files = []
         for py_file in py_filenames:
             # Since build_py handles package data installation, the
@@ -176,7 +166,7 @@ class install_lib (Command):
     # -- External interface --------------------------------------------
     # (called by outsiders)
 
-    def get_outputs (self):
+    def get_outputs(self):
         """Return the list of files that would be installed if this command
         were actually run.  Not affected by the "dry-run" flag or whether
         modules have actually been built yet.
@@ -197,9 +187,7 @@ class install_lib (Command):
 
         return pure_outputs + bytecode_outputs + ext_outputs
 
-    # get_outputs ()
-
-    def get_inputs (self):
+    def get_inputs(self):
         """Get the list of files that are input to this command, ie. the
         files that get installed as they are named in the build tree.
         The files in this list correspond one-to-one to the output
@@ -216,5 +204,3 @@ class install_lib (Command):
             inputs.extend(build_ext.get_outputs())
 
         return inputs
-
-# class install_lib

Lib/distutils/command/install_scripts.py

@@ -5,8 +5,6 @@ Python scripts."""
 
 # contributed by Bastian Kleineidam
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import os
@@ -14,7 +12,8 @@ from distutils.core import Command
 from distutils import log
 from stat import ST_MODE
 
-class install_scripts (Command):
+
+class install_scripts(Command):
 
     description = "install scripts (Python or otherwise)"
 
@@ -27,14 +26,13 @@ class install_scripts (Command):
 
     boolean_options = ['force', 'skip-build']
 
-
-    def initialize_options (self):
+    def initialize_options(self):
         self.install_dir = None
         self.force = 0
         self.build_dir = None
         self.skip_build = None
 
-    def finalize_options (self):
+    def finalize_options(self):
         self.set_undefined_options('build', ('build_scripts', 'build_dir'))
         self.set_undefined_options('install',
                                    ('install_scripts', 'install_dir'),
@@ -42,7 +40,7 @@ class install_scripts (Command):
                                    ('skip_build', 'skip_build'),
                                   )
 
-    def run (self):
+    def run(self):
         if not self.skip_build:
             self.run_command('build_scripts')
         self.outfiles = self.copy_tree(self.build_dir, self.install_dir)
@@ -57,10 +55,8 @@ class install_scripts (Command):
                     log.info("changing mode of %s to %o", file, mode)
                     os.chmod(file, mode)
 
-    def get_inputs (self):
+    def get_inputs(self):
         return self.distribution.scripts or []
 
     def get_outputs(self):
         return self.outfiles or []
-
-# class install_scripts

Lib/distutils/command/sdist.py

@@ -2,12 +2,9 @@
 
 Implements the Distutils 'sdist' command (create a source distribution)."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, os
-from types import *
 from glob import glob
 from distutils.core import Command
 from distutils import dir_util, dep_util, file_util, archive_util
@@ -82,7 +79,7 @@ class sdist (Command):
     default_format = { 'posix': 'gztar',
                        'nt': 'zip' }
 
-    def initialize_options (self):
+    def initialize_options(self):
         # 'template' and 'manifest' are, respectively, the names of
         # the manifest template and manifest file.
         self.template = None
@@ -103,7 +100,7 @@ class sdist (Command):
         self.archive_files = None
 
 
-    def finalize_options (self):
+    def finalize_options(self):
         if self.manifest is None:
             self.manifest = "MANIFEST"
         if self.template is None:
@@ -114,21 +111,20 @@ class sdist (Command):
             try:
                 self.formats = [self.default_format[os.name]]
             except KeyError:
-                raise DistutilsPlatformError, \
-                      "don't know how to create source distributions " + \
-                      "on platform %s" % os.name
+                raise DistutilsPlatformError(
+                      "don't know how to create source distributions "
+                      "on platform %s" % os.name)
 
         bad_format = archive_util.check_archive_formats(self.formats)
         if bad_format:
-            raise DistutilsOptionError, \
-                  "unknown archive format '%s'" % bad_format
+            raise DistutilsOptionError(
+                  "unknown archive format '%s'" % bad_format)
 
         if self.dist_dir is None:
             self.dist_dir = "dist"
 
 
-    def run (self):
-
+    def run(self):
         # 'filelist' contains the list of files that will make up the
         # manifest
         self.filelist = FileList()
@@ -150,8 +146,7 @@ class sdist (Command):
         # or zipfile, or whatever.
         self.make_distribution()
 
-
-    def check_metadata (self):
+    def check_metadata(self):
         """Ensure that all required elements of meta-data (name, version,
         URL, (author and author_email) or (maintainer and
         maintainer_email)) are supplied by the Distribution object; warn if
@@ -181,17 +176,13 @@ class sdist (Command):
                       "or (maintainer and maintainer_email) " +
                       "must be supplied")
 
-    # check_metadata ()
-
-
-    def get_file_list (self):
+    def get_file_list(self):
         """Figure out the list of files to include in the source
         distribution, and put it in 'self.filelist'.  This might involve
         reading the manifest template (and writing the manifest), or just
         reading the manifest, or just using the default file set -- it all
         depends on the user's options and the state of the filesystem.
         """
-
         # If we have a manifest template, see if it's newer than the
         # manifest; if so, we'll regenerate the manifest.
         template_exists = os.path.isfile(self.template)
@@ -231,9 +222,9 @@ class sdist (Command):
         # Regenerate the manifest if necessary (or if explicitly told to)
         if manifest_outofdate or neither_exists or force_regen:
             if not template_exists:
-                self.warn(("manifest template '%s' does not exist " +
-                           "(using default file list)") %
-                          self.template)
+                self.warn("manifest template '%s' does not exist "
+                          "(using default file list)"
+                          % self.template)
             self.filelist.findall()
 
             if self.use_defaults:
@@ -251,10 +242,8 @@ class sdist (Command):
         else:
             self.read_manifest()
 
-    # get_file_list ()
-
 
-    def add_defaults (self):
+    def add_defaults(self):
         """Add all the default files to self.filelist:
           - README or README.txt
           - setup.py
@@ -265,15 +254,14 @@ class sdist (Command):
         Warns if (README or README.txt) or setup.py are missing; everything
         else is optional.
         """
-
         standards = [('README', 'README.txt'), self.distribution.script_name]
         for fn in standards:
-            if type(fn) is TupleType:
+            if isinstance(fn, tuple):
                 alts = fn
-                got_it = 0
+                got_it = False
                 for fn in alts:
                     if os.path.exists(fn):
-                        got_it = 1
+                        got_it = True
                         self.filelist.append(fn)
                         break
 
@@ -308,25 +296,18 @@ class sdist (Command):
             build_scripts = self.get_finalized_command('build_scripts')
             self.filelist.extend(build_scripts.get_source_files())
 
-    # add_defaults ()
-
-
-    def read_template (self):
+    def read_template(self):
         """Read and parse manifest template file named by self.template.
 
         (usually "MANIFEST.in") The parsing and processing is done by
         'self.filelist', which updates itself accordingly.
         """
         log.info("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,
+        template = TextFile(self.template, strip_comments=1, skip_blanks=1,
+                            join_lines=1, lstrip_ws=1, rstrip_ws=1,
                             collapse_join=1)
 
-        while 1:
+        while True:
             line = template.readline()
             if line is None:            # end of file
                 break
@@ -338,10 +319,7 @@ class sdist (Command):
                                                template.current_line,
                                                msg))
 
-    # read_template ()
-
-
-    def prune_file_list (self):
+    def prune_file_list(self):
         """Prune off branches that might slip into the file list as created
         by 'read_template()', but really don't belong there:
           * the build tree (typically "build")
@@ -356,8 +334,7 @@ class sdist (Command):
         self.filelist.exclude_pattern(None, prefix=base_dir)
         self.filelist.exclude_pattern(r'/(RCS|CVS|\.svn)/.*', is_regex=1)
 
-
-    def write_manifest (self):
+    def write_manifest(self):
         """Write the file list in 'self.filelist' (presumably as filled in
         by 'add_defaults()' and 'read_template()') to the manifest file
         named by 'self.manifest'.
@@ -366,17 +343,14 @@ class sdist (Command):
                      (self.manifest, self.filelist.files),
                      "writing manifest file '%s'" % self.manifest)
 
-    # write_manifest ()
-
-
-    def read_manifest (self):
+    def read_manifest(self):
         """Read the manifest file (named by 'self.manifest') and use it to
         fill in 'self.filelist', the list of files to include in the source
         distribution.
         """
         log.info("reading manifest file '%s'", self.manifest)
         manifest = open(self.manifest)
-        while 1:
+        while True:
             line = manifest.readline()
             if line == '':              # end of file
                 break
@@ -384,10 +358,7 @@ class sdist (Command):
                 line = line[0:-1]
             self.filelist.append(line)
 
-    # read_manifest ()
-
-
-    def make_release_tree (self, base_dir, files):
+    def make_release_tree(self, base_dir, files):
         """Create the directory tree that will become the source
         distribution archive.  All directories implied by the filenames in
         'files' are created under 'base_dir', and then we hard link or copy
@@ -429,9 +400,7 @@ class sdist (Command):
 
         self.distribution.metadata.write_pkg_info(base_dir)
 
-    # make_release_tree ()
-
-    def make_distribution (self):
+    def make_distribution(self):
         """Create the source distribution(s).  First, we create the release
         tree with 'make_release_tree()'; then, we create all required
         archive files (according to 'self.formats') from the release tree.
@@ -456,10 +425,8 @@ class sdist (Command):
         if not self.keep_temp:
             dir_util.remove_tree(base_dir, dry_run=self.dry_run)
 
-    def get_archive_files (self):
+    def get_archive_files(self):
         """Return the list of archive files created when the command
         was run, or None if the command hasn't run yet.
         """
         return self.archive_files
-
-# class sdist

Lib/distutils/command/upload.py

@@ -170,7 +170,7 @@ class upload(Command):
         elif schema == 'https':
             http = httplib.HTTPSConnection(netloc)
         else:
-            raise AssertionError, "unsupported schema "+schema
+            raise AssertionError("unsupported schema "+schema)
 
         data = ''
         loglevel = log.INFO

Lib/distutils/core.py

@@ -6,12 +6,9 @@ indirectly provides the Distribution and Command classes, although they are
 really defined in distutils.dist and distutils.cmd.
 """
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, os
-from types import *
 
 from distutils.debug import DEBUG
 from distutils.errors import *
@@ -112,10 +109,10 @@ def setup (**attrs):
         _setup_distribution = dist = klass(attrs)
     except DistutilsSetupError as msg:
         if 'name' not in attrs:
-            raise SystemExit, "error in setup command: %s" % msg
+            raise SystemExit("error in setup command: %s" % msg)
         else:
-            raise SystemExit, "error in %s setup command: %s" % \
-                  (attrs['name'], msg)
+            raise SystemExit("error in %s setup command: %s" % \
+                  (attrs['name'], msg))
 
     if _setup_stop_after == "init":
         return dist
@@ -136,7 +133,7 @@ def setup (**attrs):
     try:
         ok = dist.parse_command_line()
     except DistutilsArgError as msg:
-        raise SystemExit, gen_usage(dist.script_name) + "\nerror: %s" % msg
+        raise SystemExit(gen_usage(dist.script_name) + "\nerror: %s" % msg)
 
     if DEBUG:
         print("options (after parsing command line):")
@@ -150,7 +147,7 @@ def setup (**attrs):
         try:
             dist.run_commands()
         except KeyboardInterrupt:
-            raise SystemExit, "interrupted"
+            raise SystemExit("interrupted")
         except (IOError, os.error) as exc:
             error = grok_environment_error(exc)
 
@@ -158,14 +155,14 @@ def setup (**attrs):
                 sys.stderr.write(error + "\n")
                 raise
             else:
-                raise SystemExit, error
+                raise SystemExit(error)
 
         except (DistutilsError,
                 CCompilerError) as msg:
             if DEBUG:
                 raise
             else:
-                raise SystemExit, "error: " + str(msg)
+                raise SystemExit("error: " + str(msg))
 
     return dist
 
@@ -204,7 +201,7 @@ def run_setup (script_name, script_args=None, stop_after="run"):
     used to drive the Distutils.
     """
     if stop_after not in ('init', 'config', 'commandline', 'run'):
-        raise ValueError, "invalid value for 'stop_after': %r" % (stop_after,)
+        raise ValueError("invalid value for 'stop_after': %r" % (stop_after,))
 
     global _setup_stop_after, _setup_distribution
     _setup_stop_after = stop_after
@@ -229,10 +226,9 @@ def run_setup (script_name, script_args=None, stop_after="run"):
         raise
 
     if _setup_distribution is None:
-        raise RuntimeError, \
-              ("'distutils.core.setup()' was never called -- "
+        raise RuntimeError(("'distutils.core.setup()' was never called -- "
                "perhaps '%s' is not a Distutils setup script?") % \
-              script_name
+              script_name)
 
     # I wonder if the setup script's namespace -- g and l -- would be of
     # any interest to callers?

Lib/distutils/cygwinccompiler.py

@@ -45,8 +45,6 @@ cygwin in no-cygwin mode).
 # * mingw gcc 3.2/ld 2.13 works
 #   (ld supports -shared)
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import os,sys,copy
@@ -143,13 +141,13 @@ class CygwinCCompiler (UnixCCompiler):
             try:
                 self.spawn(["windres", "-i", src, "-o", obj])
             except DistutilsExecError as msg:
-                raise CompileError, msg
+                raise CompileError(msg)
         else: # for other files use the C-compiler
             try:
                 self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
                            extra_postargs)
             except DistutilsExecError as msg:
-                raise CompileError, msg
+                raise CompileError(msg)
 
     def link (self,
               target_desc,
@@ -260,9 +258,8 @@ class CygwinCCompiler (UnixCCompiler):
             # use normcase to make sure '.rc' is really '.rc' and not '.RC'
             (base, ext) = os.path.splitext (os.path.normcase(src_name))
             if ext not in (self.src_extensions + ['.rc','.res']):
-                raise UnknownFileError, \
-                      "unknown file type '%s' (from '%s')" % \
-                      (ext, src_name)
+                raise UnknownFileError("unknown file type '%s' (from '%s')" % \
+                      (ext, src_name))
             if strip_dir:
                 base = os.path.basename (base)
             if ext == '.res' or ext == '.rc':

Lib/distutils/debug.py

 import os
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 # If DISTUTILS_DEBUG is anything other than the empty string, we run in

Lib/distutils/dep_util.py

@@ -4,8 +4,6 @@ Utility functions for simple, timestamp-based dependency of files
 and groups of files; also, function based entirely on such
 timestamp dependency analysis."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import os
@@ -19,7 +17,7 @@ def newer (source, target):
     Raise DistutilsFileError if 'source' does not exist.
     """
     if not os.path.exists(source):
-        raise DistutilsFileError, "file '%s' does not exist" % source
+        raise DistutilsFileError("file '%s' does not exist" % source)
     if not os.path.exists(target):
         return 1
 
@@ -39,7 +37,7 @@ def newer_pairwise (sources, targets):
     of 'newer()'.
     """
     if len(sources) != len(targets):
-        raise ValueError, "'sources' and 'targets' must be same length"
+        raise ValueError("'sources' and 'targets' must be same length")
 
     # build a pair of lists (sources, targets) where  source is newer
     n_sources = []

Lib/distutils/dir_util.py

@@ -2,12 +2,9 @@
 
 Utility functions for manipulating directories and directory trees."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import os, sys
-from types import *
 from distutils.errors import DistutilsFileError, DistutilsInternalError
 from distutils import log
 
@@ -32,8 +29,8 @@ def mkpath (name, mode=0o777, verbose=0, dry_run=0):
 
     # Detect a common bug -- name is None
     if not isinstance(name, basestring):
-        raise DistutilsInternalError, \
-              "mkpath: 'name' must be a string (got %r)" % (name,)
+        raise DistutilsInternalError(
+              "mkpath: 'name' must be a string (got %r)" % (name,))
 
     # XXX what's the better way to handle verbosity? print as we create
     # each directory in the path (the current behaviour), or only announce
@@ -136,8 +133,8 @@ def copy_tree (src, dst,
     from distutils.file_util import copy_file
 
     if not dry_run and not os.path.isdir(src):
-        raise DistutilsFileError, \
-              "cannot copy tree '%s': not a directory" % src
+        raise DistutilsFileError(
+              "cannot copy tree '%s': not a directory" % src)
     try:
         names = os.listdir(src)
     except os.error as e:
@@ -145,8 +142,8 @@ def copy_tree (src, dst,
         if dry_run:
             names = []
         else:
-            raise DistutilsFileError, \
-                  "error listing files in '%s': %s" % (src, errstr)
+            raise DistutilsFileError(
+                  "error listing files in '%s': %s" % (src, errstr))
 
     if not dry_run:
         mkpath(dst)
@@ -176,8 +173,6 @@ def copy_tree (src, dst,
 
     return outputs
 
-# copy_tree ()
-
 # Helper for remove_tree()
 def _build_cmdtuple(path, cmdtuples):
     for f in os.listdir(path):

Lib/distutils/dist.py

@@ -4,8 +4,6 @@ Provides the Distribution class, which represents the module distribution
 being built/installed/distributed.
 """
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, os, re
@@ -264,8 +262,6 @@ Common commands: (see '--help-commands' for more)
 
         self.finalize_options()
 
-    # __init__ ()
-
 
     def get_option_dict (self, command):
         """Get the option dictionary for a given command.  If that
@@ -305,8 +301,6 @@ Common commands: (see '--help-commands' for more)
                 for line in out.split("\n"):
                     print(indent + "  " + line)
 
-    # dump_option_dicts ()
-
 
 
     # -- Config file finding/parsing methods ---------------------------
@@ -353,8 +347,6 @@ Common commands: (see '--help-commands' for more)
 
         return files
 
-    # find_config_files ()
-
 
     def parse_config_files (self, filenames=None):
 
@@ -397,9 +389,7 @@ Common commands: (see '--help-commands' for more)
                     else:
                         setattr(self, opt, val)
                 except ValueError as msg:
-                    raise DistutilsOptionError, msg
-
-    # parse_config_files ()
+                    raise DistutilsOptionError(msg)
 
 
     # -- Command-line parsing methods ----------------------------------
@@ -472,12 +462,10 @@ Common commands: (see '--help-commands' for more)
 
         # Oops, no commands found -- an end-user error
         if not self.commands:
-            raise DistutilsArgError, "no commands supplied"
+            raise DistutilsArgError("no commands supplied")
 
         # All is well: return true
-        return 1
-
-    # parse_command_line()
+        return True
 
     def _get_toplevel_options (self):
         """Return the non-display options recognized at the top level.
@@ -505,7 +493,7 @@ Common commands: (see '--help-commands' for more)
         # Pull the current command from the head of the command line
         command = args[0]
         if not command_re.match(command):
-            raise SystemExit, "invalid command name '%s'" % command
+            raise SystemExit("invalid command name '%s'" % command)
         self.commands.append(command)
 
         # Dig up the command class that implements this command, so we
@@ -514,22 +502,21 @@ Common commands: (see '--help-commands' for more)
         try:
             cmd_class = self.get_command_class(command)
         except DistutilsModuleError as msg:
-            raise DistutilsArgError, msg
+            raise DistutilsArgError(msg)
 
         # Require that the command class be derived from Command -- want
         # to be sure that the basic "command" interface is implemented.
         if not issubclass(cmd_class, Command):
-            raise DistutilsClassError, \
-                  "command class %s must subclass Command" % cmd_class
+            raise DistutilsClassError(
+                  "command class %s must subclass Command" % cmd_class)
 
         # Also make sure that the command object provides a list of its
         # known options.
         if not (hasattr(cmd_class, 'user_options') and
                 isinstance(cmd_class.user_options, list)):
-            raise DistutilsClassError, \
-                  ("command class %s must provide " +
+            raise DistutilsClassError(("command class %s must provide " +
                    "'user_options' attribute (a list of tuples)") % \
-                  cmd_class
+                  cmd_class)
 
         # If the command class has a list of negative alias options,
         # merge it in with the global negative aliases.
@@ -586,8 +573,6 @@ Common commands: (see '--help-commands' for more)
 
         return args
 
-    # _parse_command_opts ()
-
     def finalize_options (self):
         """Set final values for all the options on the Distribution
         instance, analogous to the .finalize_options() method of Command
@@ -660,8 +645,6 @@ Common commands: (see '--help-commands' for more)
         print(gen_usage(self.script_name))
         return
 
-    # _show_help ()
-
 
     def handle_display_options (self, option_order):
         """If there were any non-global "display-only" options
@@ -703,13 +686,10 @@ Common commands: (see '--help-commands' for more)
 
         return any_display_options
 
-    # handle_display_options()
-
     def print_command_list (self, commands, header, max_length):
         """Print a subset of the list of all commands -- used by
         'print_commands()'.
         """
-
         print(header + ":")
 
         for cmd in commands:
@@ -723,8 +703,6 @@ Common commands: (see '--help-commands' for more)
 
             print("  %-*s  %s" % (max_length, cmd, description))
 
-    # print_command_list ()
-
 
     def print_commands (self):
         """Print out a help message listing all available commands with a
@@ -734,7 +712,6 @@ Common commands: (see '--help-commands' for more)
         descriptions come from the command class attribute
         'description'.
         """
-
         import distutils.command
         std_commands = distutils.command.__all__
         is_std = {}
@@ -760,8 +737,6 @@ Common commands: (see '--help-commands' for more)
                                     "Extra commands",
                                     max_length)
 
-    # print_commands ()
-
     def get_command_list (self):
         """Get a list of (command, description) tuples.
         The list is divided into "standard commands" (listed in
@@ -771,7 +746,6 @@ Common commands: (see '--help-commands' for more)
         """
         # Currently this is only used on Mac OS, for the Mac-only GUI
         # Distutils interface (by Jack Jansen)
-
         import distutils.command
         std_commands = distutils.command.__all__
         is_std = {}
@@ -839,18 +813,15 @@ Common commands: (see '--help-commands' for more)
             try:
                 klass = getattr(module, klass_name)
             except AttributeError:
-                raise DistutilsModuleError, \
-                      "invalid command '%s' (no class '%s' in module '%s')" \
-                      % (command, klass_name, module_name)
+                raise DistutilsModuleError(
+                      "invalid command '%s' (no class '%s' in module '%s')"
+                      % (command, klass_name, module_name))
 
             self.cmdclass[command] = klass
             return klass
 
         raise DistutilsModuleError("invalid command '%s'" % command)
 
-
-    # get_command_class ()
-
     def get_command_obj (self, command, create=1):
         """Return the command object for 'command'.  Normally this object
         is cached on a previous call to 'get_command_obj()'; if no command
@@ -912,11 +883,11 @@ Common commands: (see '--help-commands' for more)
                 elif hasattr(command_obj, option):
                     setattr(command_obj, option, value)
                 else:
-                    raise DistutilsOptionError, \
-                          ("error in %s: command '%s' has no such option '%s'"
-                           % (source, command_name, option))
+                    raise DistutilsOptionError(
+                          "error in %s: command '%s' has no such option '%s'"
+                          % (source, command_name, option))
             except ValueError as msg:
-                raise DistutilsOptionError, msg
+                raise DistutilsOptionError(msg)
 
     def reinitialize_command (self, command, reinit_subcommands=0):
         """Reinitializes a command to the state it was in when first
@@ -1075,8 +1046,6 @@ class DistributionMetadata:
 
         pkg_info.close()
 
-    # write_pkg_info ()
-
     def write_pkg_file (self, file):
         """Write the PKG-INFO format data to a file object.
         """
@@ -1202,8 +1171,6 @@ class DistributionMetadata:
             distutils.versionpredicate.VersionPredicate(v)
         self.obsoletes = value
 
-# class DistributionMetadata
-
 
 def fix_help_options (options):
     """Convert a 4-tuple 'help_options' list as found in various command

Lib/distutils/emxccompiler.py

@@ -80,13 +80,13 @@ class EMXCCompiler (UnixCCompiler):
             try:
                 self.spawn(["rc", "-r", src])
             except DistutilsExecError as msg:
-                raise CompileError, msg
+                raise CompileError(msg)
         else: # for other files use the C-compiler
             try:
                 self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
                            extra_postargs)
             except DistutilsExecError as msg:
-                raise CompileError, msg
+                raise CompileError(msg)
 
     def link (self,
               target_desc,
@@ -189,9 +189,8 @@ class EMXCCompiler (UnixCCompiler):
             # use normcase to make sure '.rc' is really '.rc' and not '.RC'
             (base, ext) = os.path.splitext (os.path.normcase(src_name))
             if ext not in (self.src_extensions + ['.rc']):
-                raise UnknownFileError, \
-                      "unknown file type '%s' (from '%s')" % \
-                      (ext, src_name)
+                raise UnknownFileError("unknown file type '%s' (from '%s')" % \
+                      (ext, src_name))
             if strip_dir:
                 base = os.path.basename (base)
             if ext == '.rc':

Lib/distutils/errors.py

@@ -8,8 +8,6 @@ usually raised for errors that are obviously the end-user's fault
 This module is safe to use in "from ... import *" mode; it only exports
 symbols whose names start with "Distutils" and end with "Error"."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 class DistutilsError (Exception):

Lib/distutils/extension.py

@@ -86,7 +86,7 @@ class Extension:
 
     # When adding arguments to this constructor, be sure to update
     # setup_keywords in core.py.
-    def __init__ (self, name, sources,
+    def __init__(self, name, sources,
                   include_dirs=None,
                   define_macros=None,
                   undef_macros=None,
@@ -125,17 +125,15 @@ class Extension:
 
         # If there are unknown keyword options, warn about them
         if len(kw):
-            L = kw.keys() ; L.sort()
-            L = map(repr, L)
+            L = map(repr, sorted(kw))
             msg = "Unknown Extension options: " + ', '.join(L)
             if warnings is not None:
                 warnings.warn(msg)
             else:
                 sys.stderr.write(msg + '\n')
-# class Extension
 
 
-def read_setup_file (filename):
+def read_setup_file(filename):
     from distutils.sysconfig import \
          parse_makefile, expand_makefile_vars, _variable_rx
     from distutils.text_file import TextFile
@@ -151,7 +149,7 @@ def read_setup_file (filename):
                     lstrip_ws=1, rstrip_ws=1)
     extensions = []
 
-    while 1:
+    while True:
         line = file.readline()
         if line is None:                # eof
             break
@@ -241,5 +239,3 @@ def read_setup_file (filename):
         #                       'lib_args': library_args }
 
     return extensions
-
-# read_setup_file ()

Lib/distutils/fancy_getopt.py

@@ -8,12 +8,9 @@ additional features:
   * options set attributes of a passed-in object
 """
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, string, re
-from types import *
 import getopt
 from distutils.errors import *
 
@@ -43,8 +40,7 @@ class FancyGetopt:
         on the command line sets 'verbose' to false
     """
 
-    def __init__ (self, option_table=None):
-
+    def __init__(self, option_table=None):
         # The option table is (currently) a list of tuples.  The
         # tuples may have 3 or four values:
         #   (long_option, short_option, help_string [, repeatable])
@@ -84,58 +80,51 @@ class FancyGetopt:
         # but expands short options, converts aliases, etc.
         self.option_order = []
 
-    # __init__ ()
-
-
-    def _build_index (self):
+    def _build_index(self):
         self.option_index.clear()
         for option in self.option_table:
             self.option_index[option[0]] = option
 
-    def set_option_table (self, option_table):
+    def set_option_table(self, option_table):
         self.option_table = option_table
         self._build_index()
 
-    def add_option (self, long_option, short_option=None, help_string=None):
+    def add_option(self, long_option, short_option=None, help_string=None):
         if long_option in self.option_index:
-            raise DistutilsGetoptError, \
-                  "option conflict: already an option '%s'" % long_option
+            raise DistutilsGetoptError(
+                  "option conflict: already an option '%s'" % long_option)
         else:
             option = (long_option, short_option, help_string)
             self.option_table.append(option)
             self.option_index[long_option] = option
 
-
-    def has_option (self, long_option):
+    def has_option(self, long_option):
         """Return true if the option table for this parser has an
         option with long name 'long_option'."""
         return long_option in self.option_index
 
-    def get_attr_name (self, long_option):
+    def get_attr_name(self, long_option):
         """Translate long option name 'long_option' to the form it
         has as an attribute of some object: ie., translate hyphens
         to underscores."""
         return long_option.translate(longopt_xlate)
 
-
-    def _check_alias_dict (self, aliases, what):
-        assert type(aliases) is DictionaryType
+    def _check_alias_dict(self, aliases, what):
+        assert isinstance(aliases, dict)
         for (alias, opt) in aliases.items():
             if alias not in self.option_index:
-                raise DistutilsGetoptError, \
-                      ("invalid %s '%s': "
-                       "option '%s' not defined") % (what, alias, alias)
+                raise DistutilsGetoptError(("invalid %s '%s': "
+                       "option '%s' not defined") % (what, alias, alias))
             if opt not in self.option_index:
-                raise DistutilsGetoptError, \
-                      ("invalid %s '%s': "
-                       "aliased option '%s' not defined") % (what, alias, opt)
+                raise DistutilsGetoptError(("invalid %s '%s': "
+                       "aliased option '%s' not defined") % (what, alias, opt))
 
-    def set_aliases (self, alias):
+    def set_aliases(self, alias):
         """Set the aliases for this option parser."""
         self._check_alias_dict(alias, "alias")
         self.alias = alias
 
-    def set_negative_aliases (self, negative_alias):
+    def set_negative_aliases(self, negative_alias):
         """Set the negative aliases for this option parser.
         'negative_alias' should be a dictionary mapping option names to
         option names, both the key and value must already be defined
@@ -143,8 +132,7 @@ class FancyGetopt:
         self._check_alias_dict(negative_alias, "negative alias")
         self.negative_alias = negative_alias
 
-
-    def _grok_option_table (self):
+    def _grok_option_table(self):
         """Populate the various data structures that keep tabs on the
         option table.  Called by 'getopt()' before it can do anything
         worthwhile.
@@ -163,19 +151,17 @@ class FancyGetopt:
             else:
                 # the option table is part of the code, so simply
                 # assert that it is correct
-                raise ValueError, "invalid option tuple: %r" % (option,)
+                raise ValueError("invalid option tuple: %r" % (option,))
 
             # Type- and value-check the option names
             if not isinstance(long, basestring) or len(long) < 2:
-                raise DistutilsGetoptError, \
-                      ("invalid long option '%s': "
-                       "must be a string of length >= 2") % long
+                raise DistutilsGetoptError(("invalid long option '%s': "
+                       "must be a string of length >= 2") % long)
 
             if (not ((short is None) or
                      (isinstance(short, basestring) and len(short) == 1))):
-                raise DistutilsGetoptError, \
-                      ("invalid short option '%s': "
-                       "must a single character or None") % short
+                raise DistutilsGetoptError("invalid short option '%s': "
+                       "must a single character or None" % short)
 
             self.repeat[long] = repeat
             self.long_opts.append(long)
@@ -185,54 +171,45 @@ class FancyGetopt:
                 long = long[0:-1]
                 self.takes_arg[long] = 1
             else:
-
                 # Is option is a "negative alias" for some other option (eg.
                 # "quiet" == "!verbose")?
                 alias_to = self.negative_alias.get(long)
                 if alias_to is not None:
                     if self.takes_arg[alias_to]:
-                        raise DistutilsGetoptError, \
-                              ("invalid negative alias '%s': "
-                               "aliased option '%s' takes a value") % \
-                               (long, alias_to)
+                        raise DistutilsGetoptError(
+                              "invalid negative alias '%s': "
+                              "aliased option '%s' takes a value"
+                              % (long, alias_to))
 
                     self.long_opts[-1] = long # XXX redundant?!
-                    self.takes_arg[long] = 0
-
-                else:
-                    self.takes_arg[long] = 0
+                self.takes_arg[long] = 0
 
             # If this is an alias option, make sure its "takes arg" flag is
             # the same as the option it's aliased to.
             alias_to = self.alias.get(long)
             if alias_to is not None:
                 if self.takes_arg[long] != self.takes_arg[alias_to]:
-                    raise DistutilsGetoptError, \
-                          ("invalid alias '%s': inconsistent with "
-                           "aliased option '%s' (one of them takes a value, "
-                           "the other doesn't") % (long, alias_to)
-
+                    raise DistutilsGetoptError(
+                          "invalid alias '%s': inconsistent with "
+                          "aliased option '%s' (one of them takes a value, "
+                          "the other doesn't"
+                          % (long, alias_to))
 
             # Now enforce some bondage on the long option name, so we can
             # later translate it to an attribute name on some object.  Have
             # to do this a bit late to make sure we've removed any trailing
             # '='.
             if not longopt_re.match(long):
-                raise DistutilsGetoptError, \
-                      ("invalid long option name '%s' " +
-                       "(must be letters, numbers, hyphens only") % long
+                raise DistutilsGetoptError(
+                       "invalid long option name '%s' "
+                       "(must be letters, numbers, hyphens only" % long)
 
             self.attr_name[long] = self.get_attr_name(long)
             if short:
                 self.short_opts.append(short)
                 self.short2long[short[0]] = long
 
-        # for option_table
-
-    # _grok_option_table()
-
-
-    def getopt (self, args=None, object=None):
+    def getopt(self, args=None, object=None):
         """Parse command-line options in args. Store as attributes on object.
 
         If 'args' is None or not supplied, uses 'sys.argv[1:]'.  If
@@ -247,9 +224,9 @@ class FancyGetopt:
             args = sys.argv[1:]
         if object is None:
             object = OptionDummy()
-            created_object = 1
+            created_object = True
         else:
-            created_object = 0
+            created_object = False
 
         self._grok_option_table()
 
@@ -257,7 +234,7 @@ class FancyGetopt:
         try:
             opts, args = getopt.getopt(args, short_opts, self.long_opts)
         except getopt.error as msg:
-            raise DistutilsArgError, msg
+            raise DistutilsArgError(msg)
 
         for opt, val in opts:
             if len(opt) == 2 and opt[0] == '-': # it's a short option
@@ -293,21 +270,17 @@ class FancyGetopt:
         else:
             return args
 
-    # getopt()
-
-
-    def get_option_order (self):
+    def get_option_order(self):
         """Returns the list of (option, value) tuples processed by the
         previous run of 'getopt()'.  Raises RuntimeError if
         'getopt()' hasn't been called yet.
         """
         if self.option_order is None:
-            raise RuntimeError, "'getopt()' hasn't been called yet"
+            raise RuntimeError("'getopt()' hasn't been called yet")
         else:
             return self.option_order
 
-
-    def generate_help (self, header=None):
+    def generate_help(self, header=None):
         """Generate help text (a list of strings, one per suggested line of
         output) from the option table for this FancyGetopt object.
         """
@@ -384,23 +357,16 @@ class FancyGetopt:
 
             for l in text[1:]:
                 lines.append(big_indent + l)
-
-        # for self.option_table
-
         return lines
 
-    # generate_help ()
-
-    def print_help (self, header=None, file=None):
+    def print_help(self, header=None, file=None):
         if file is None:
             file = sys.stdout
         for line in self.generate_help(header):
             file.write(line + "\n")
 
-# class FancyGetopt
-
 
-def fancy_getopt (options, negative_opt, object, args):
+def fancy_getopt(options, negative_opt, object, args):
     parser = FancyGetopt(options)
     parser.set_negative_aliases(negative_opt)
     return parser.getopt(args, object)
@@ -408,13 +374,12 @@ def fancy_getopt (options, negative_opt, object, args):
 
 WS_TRANS = string.maketrans(string.whitespace, ' ' * len(string.whitespace))
 
-def wrap_text (text, width):
+def wrap_text(text, width):
     """wrap_text(text : string, width : int) -> [string]
 
     Split 'text' into multiple lines of no more than 'width' characters
     each, and return the list of strings that results.
     """
-
     if text is None:
         return []
     if len(text) <= width:
@@ -427,7 +392,6 @@ def wrap_text (text, width):
     lines = []
 
     while chunks:
-
         cur_line = []                   # list of chunks (to-be-joined)
         cur_len = 0                     # length of current line
 
@@ -444,7 +408,6 @@ def wrap_text (text, width):
                 break
 
         if chunks:                      # any chunks left to process?
-
             # if the current line is still empty, then we had a single
             # chunk that's too big too fit on a line -- so we break
             # down and break it up at the line width
@@ -462,14 +425,10 @@ def wrap_text (text, width):
         # string, of course!
         lines.append(''.join(cur_line))
 
-    # while chunks
-
     return lines
 
-# wrap_text ()
-
 
-def translate_longopt (opt):
+def translate_longopt(opt):
     """Convert a long option name to a valid Python identifier by
     changing "-" to "_".
     """
@@ -480,14 +439,12 @@ class OptionDummy:
     """Dummy class just used as a place to hold command-line option
     values as instance attributes."""
 
-    def __init__ (self, options=[]):
+    def __init__(self, options=[]):
         """Create a new OptionDummy instance.  The attributes listed in
         'options' will be initialized to None."""
         for opt in options:
             setattr(self, opt, None)
 
-# class OptionDummy
-
 
 if __name__ == "__main__":
     text = """\

Lib/distutils/file_util.py

@@ -3,8 +3,6 @@
 Utility functions for operating on single files.
 """
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import os
@@ -17,7 +15,7 @@ _copy_action = { None:   'copying',
                  'sym':  'symbolically linking' }
 
 
-def _copy_file_contents (src, dst, buffer_size=16*1024):
+def _copy_file_contents(src, dst, buffer_size=16*1024):
     """Copy the file 'src' to 'dst'; both must be filenames.  Any error
     opening either file, reading from 'src', or writing to 'dst', raises
     DistutilsFileError.  Data is read/written in chunks of 'buffer_size'
@@ -26,7 +24,6 @@ def _copy_file_contents (src, dst, buffer_size=16*1024):
     """
     # Stolen from shutil module in the standard library, but with
     # custom error-handling added.
-
     fsrc = None
     fdst = None
     try:
@@ -34,31 +31,30 @@ def _copy_file_contents (src, dst, buffer_size=16*1024):
             fsrc = open(src, 'rb')
         except os.error as e:
             (errno, errstr) = e
-            raise DistutilsFileError, \
-                  "could not open '%s': %s" % (src, errstr)
+            raise DistutilsFileError("could not open '%s': %s" % (src, errstr))
 
         if os.path.exists(dst):
             try:
                 os.unlink(dst)
             except os.error as e:
                 (errno, errstr) = e
-                raise DistutilsFileError, \
-                      "could not delete '%s': %s" % (dst, errstr)
+                raise DistutilsFileError(
+                      "could not delete '%s': %s" % (dst, errstr))
 
         try:
             fdst = open(dst, 'wb')
         except os.error as e:
             (errno, errstr) = e
-            raise DistutilsFileError, \
-                  "could not create '%s': %s" % (dst, errstr)
+            raise DistutilsFileError(
+                  "could not create '%s': %s" % (dst, errstr))
 
-        while 1:
+        while True:
             try:
                 buf = fsrc.read(buffer_size)
             except os.error as e:
                 (errno, errstr) = e
-                raise DistutilsFileError, \
-                      "could not read from '%s': %s" % (src, errstr)
+                raise DistutilsFileError(
+                      "could not read from '%s': %s" % (src, errstr))
 
             if not buf:
                 break
@@ -67,25 +63,16 @@ def _copy_file_contents (src, dst, buffer_size=16*1024):
                 fdst.write(buf)
             except os.error as e:
                 (errno, errstr) = e
-                raise DistutilsFileError, \
-                      "could not write to '%s': %s" % (dst, errstr)
-
+                raise DistutilsFileError(
+                      "could not write to '%s': %s" % (dst, errstr))
     finally:
         if fdst:
             fdst.close()
         if fsrc:
             fsrc.close()
 
-# _copy_file_contents()
-
-def copy_file (src, dst,
-               preserve_mode=1,
-               preserve_times=1,
-               update=0,
-               link=None,
-               verbose=0,
-               dry_run=0):
-
+def copy_file(src, dst, preserve_mode=1, preserve_times=1, update=0,
+              link=None, verbose=0, dry_run=0):
     """Copy a file 'src' to 'dst'.  If 'dst' is a directory, then 'src' is
     copied there with the same name; otherwise, it must be a filename.  (If
     the file exists, it will be ruthlessly clobbered.)  If 'preserve_mode'
@@ -120,8 +107,8 @@ def copy_file (src, dst,
     from stat import ST_ATIME, ST_MTIME, ST_MODE, S_IMODE
 
     if not os.path.isfile(src):
-        raise DistutilsFileError, \
-              "can't copy '%s': doesn't exist or not a regular file" % src
+        raise DistutilsFileError(
+              "can't copy '%s': doesn't exist or not a regular file" % src)
 
     if os.path.isdir(dst):
         dir = dst
@@ -131,13 +118,12 @@ def copy_file (src, dst,
 
     if update and not newer(src, dst):
         log.debug("not copying %s (output up-to-date)", src)
-        return dst, 0
+        return (dst, 0)
 
     try:
         action = _copy_action[link]
     except KeyError:
-        raise ValueError, \
-              "invalid value '%s' for 'link' argument" % link
+        raise ValueError("invalid value '%s' for 'link' argument" % link)
     if os.path.basename(dst) == os.path.basename(src):
         log.info("%s %s -> %s", action, src, dir)
     else:
@@ -152,8 +138,8 @@ def copy_file (src, dst,
         try:
             macostools.copy(src, dst, 0, preserve_times)
         except os.error as exc:
-            raise DistutilsFileError, \
-                  "could not copy '%s' to '%s': %s" % (src, dst, exc[-1])
+            raise DistutilsFileError(
+                  "could not copy '%s' to '%s': %s" % (src, dst, exc[-1]))
 
     # If linking (hard or symbolic), use the appropriate system call
     # (Unix only, of course, but that's the caller's responsibility)
@@ -180,8 +166,6 @@ def copy_file (src, dst,
 
     return (dst, 1)
 
-# copy_file ()
-
 
 # XXX I suspect this is Unix-specific -- need porting help!
 def move_file (src, dst,
@@ -204,31 +188,30 @@ def move_file (src, dst,
         return dst
 
     if not isfile(src):
-        raise DistutilsFileError, \
-              "can't move '%s': not a regular file" % src
+        raise DistutilsFileError("can't move '%s': not a regular file" % src)
 
     if isdir(dst):
         dst = os.path.join(dst, basename(src))
     elif exists(dst):
-        raise DistutilsFileError, \
-              "can't move '%s': destination '%s' already exists" % \
-              (src, dst)
+        raise DistutilsFileError(
+              "can't move '%s': destination '%s' already exists" %
+              (src, dst))
 
     if not isdir(dirname(dst)):
-        raise DistutilsFileError, \
-              "can't move '%s': destination '%s' not a valid path" % \
-              (src, dst)
+        raise DistutilsFileError(
+              "can't move '%s': destination '%s' not a valid path" %
+              (src, dst))
 
-    copy_it = 0
+    copy_it = False
     try:
         os.rename(src, dst)
     except os.error as e:
         (num, msg) = e
         if num == errno.EXDEV:
-            copy_it = 1
+            copy_it = True
         else:
-            raise DistutilsFileError, \
-                  "couldn't move '%s' to '%s': %s" % (src, dst, msg)
+            raise DistutilsFileError(
+                  "couldn't move '%s' to '%s': %s" % (src, dst, msg))
 
     if copy_it:
         copy_file(src, dst)
@@ -240,15 +223,12 @@ def move_file (src, dst,
                 os.unlink(dst)
             except os.error:
                 pass
-            raise DistutilsFileError, \
-                  ("couldn't move '%s' to '%s' by copy/delete: " +
-                   "delete '%s' failed: %s") % \
-                  (src, dst, src, msg)
-
+            raise DistutilsFileError(
+                  "couldn't move '%s' to '%s' by copy/delete: "
+                  "delete '%s' failed: %s"
+                  % (src, dst, src, msg))
     return dst
 
-# move_file ()
-
 
 def write_file (filename, contents):
     """Create a file with the specified name and write 'contents' (a

Lib/distutils/filelist.py

@@ -4,20 +4,16 @@ Provides the FileList class, used for poking about the filesystem
 and building lists of files.
 """
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import os, re
 import fnmatch
-from types import *
 from glob import glob
 from distutils.util import convert_path
 from distutils.errors import DistutilsTemplateError, DistutilsInternalError
 from distutils import log
 
 class FileList:
-
     """A list of files built by on exploring the filesystem and filtered by
     applying various patterns to what we find there.
 
@@ -32,22 +28,19 @@ class FileList:
         filtering applied)
     """
 
-    def __init__(self,
-                 warn=None,
-                 debug_print=None):
+    def __init__(self, warn=None, debug_print=None):
         # ignore argument to FileList, but keep them for backwards
         # compatibility
-
         self.allfiles = None
         self.files = []
 
-    def set_allfiles (self, allfiles):
+    def set_allfiles(self, allfiles):
         self.allfiles = allfiles
 
-    def findall (self, dir=os.curdir):
+    def findall(self, dir=os.curdir):
         self.allfiles = findall(dir)
 
-    def debug_print (self, msg):
+    def debug_print(self, msg):
         """Print 'msg' to stdout if the global DEBUG (taken from the
         DISTUTILS_DEBUG environment variable) flag is true.
         """
@@ -57,13 +50,13 @@ class FileList:
 
     # -- List-like methods ---------------------------------------------
 
-    def append (self, item):
+    def append(self, item):
         self.files.append(item)
 
-    def extend (self, items):
+    def extend(self, items):
         self.files.extend(items)
 
-    def sort (self):
+    def sort(self):
         # Not a strict lexical sort!
         sortable_files = sorted(map(os.path.split, self.files))
         self.files = []
@@ -73,7 +66,7 @@ class FileList:
 
     # -- Other miscellaneous utility methods ---------------------------
 
-    def remove_duplicates (self):
+    def remove_duplicates(self):
         # Assumes list has been sorted!
         for i in range(len(self.files) - 1, 0, -1):
             if self.files[i] == self.files[i - 1]:
@@ -82,7 +75,7 @@ class FileList:
 
     # -- "File template" methods ---------------------------------------
 
-    def _parse_template_line (self, line):
+    def _parse_template_line(self, line):
         words = line.split()
         action = words[0]
 
@@ -91,36 +84,26 @@ class FileList:
         if action in ('include', 'exclude',
                       'global-include', 'global-exclude'):
             if len(words) < 2:
-                raise DistutilsTemplateError, \
-                      "'%s' expects <pattern1> <pattern2> ..." % action
-
+                raise DistutilsTemplateError(
+                      "'%s' expects <pattern1> <pattern2> ..." % action)
             patterns = map(convert_path, words[1:])
-
         elif action in ('recursive-include', 'recursive-exclude'):
             if len(words) < 3:
-                raise DistutilsTemplateError, \
-                      "'%s' expects <dir> <pattern1> <pattern2> ..." % action
-
+                raise DistutilsTemplateError(
+                      "'%s' expects <dir> <pattern1> <pattern2> ..." % action)
             dir = convert_path(words[1])
             patterns = map(convert_path, words[2:])
-
         elif action in ('graft', 'prune'):
             if len(words) != 2:
-                raise DistutilsTemplateError, \
-                     "'%s' expects a single <dir_pattern>" % action
-
+                raise DistutilsTemplateError(
+                      "'%s' expects a single <dir_pattern>" % action)
             dir_pattern = convert_path(words[1])
-
         else:
-            raise DistutilsTemplateError, "unknown action '%s'" % action
+            raise DistutilsTemplateError("unknown action '%s'" % action)
 
         return (action, patterns, dir, dir_pattern)
 
-    # _parse_template_line ()
-
-
-    def process_template_line (self, line):
-
+    def process_template_line(self, line):
         # Parse the line: split it up, make sure the right number of words
         # is there, and return the relevant words.  'action' is always
         # defined: it's the first word of the line.  Which of the other
@@ -149,7 +132,7 @@ class FileList:
             self.debug_print("global-include " + ' '.join(patterns))
             for pattern in patterns:
                 if not self.include_pattern(pattern, anchor=0):
-                    log.warn(("warning: no files found matching '%s' " +
+                    log.warn(("warning: no files found matching '%s' "
                               "anywhere in distribution"), pattern)
 
         elif action == 'global-exclude':
@@ -165,7 +148,7 @@ class FileList:
                              (dir, ' '.join(patterns)))
             for pattern in patterns:
                 if not self.include_pattern(pattern, prefix=dir):
-                    log.warn(("warning: no files found matching '%s' " +
+                    log.warn(("warning: no files found matching '%s' "
                                 "under directory '%s'"),
                              pattern, dir)
 
@@ -187,19 +170,16 @@ class FileList:
         elif action == 'prune':
             self.debug_print("prune " + dir_pattern)
             if not self.exclude_pattern(None, prefix=dir_pattern):
-                log.warn(("no previously-included directories found " +
+                log.warn(("no previously-included directories found "
                           "matching '%s'"), dir_pattern)
         else:
-            raise DistutilsInternalError, \
-                  "this cannot happen: invalid action '%s'" % action
-
-    # process_template_line ()
+            raise DistutilsInternalError(
+                  "this cannot happen: invalid action '%s'" % action)
 
 
     # -- Filtering/selection methods -----------------------------------
 
-    def include_pattern (self, pattern,
-                         anchor=1, prefix=None, is_regex=0):
+    def include_pattern(self, pattern, anchor=1, prefix=None, is_regex=0):
         """Select strings (presumably filenames) from 'self.files' that
         match 'pattern', a Unix-style wildcard (glob) pattern.  Patterns
         are not quite the same as implemented by the 'fnmatch' module: '*'
@@ -222,9 +202,9 @@ class FileList:
 
         Selected strings will be added to self.files.
 
-        Return 1 if files are found.
+        Return True if files are found, False otherwise.
         """
-        files_found = 0
+        files_found = False
         pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
         self.debug_print("include_pattern: applying regex r'%s'" %
                          pattern_re.pattern)
@@ -237,12 +217,9 @@ class FileList:
             if pattern_re.search(name):
                 self.debug_print(" adding " + name)
                 self.files.append(name)
-                files_found = 1
-
+                files_found = True
         return files_found
 
-    # include_pattern ()
-
 
     def exclude_pattern (self, pattern,
                          anchor=1, prefix=None, is_regex=0):
@@ -250,9 +227,9 @@ class FileList:
         'pattern'.  Other parameters are the same as for
         'include_pattern()', above.
         The list 'self.files' is modified in place.
-        Return 1 if files are found.
+        Return True if files are found, False otherwise.
         """
-        files_found = 0
+        files_found = False
         pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
         self.debug_print("exclude_pattern: applying regex r'%s'" %
                          pattern_re.pattern)
@@ -260,19 +237,14 @@ class FileList:
             if pattern_re.search(self.files[i]):
                 self.debug_print(" removing " + self.files[i])
                 del self.files[i]
-                files_found = 1
-
+                files_found = True
         return files_found
 
-    # exclude_pattern ()
-
-# class FileList
-
 
 # ----------------------------------------------------------------------
 # Utility functions
 
-def findall (dir = os.curdir):
+def findall(dir=os.curdir):
     """Find all files under 'dir' and return the list of full filenames
     (relative to 'dir').
     """
@@ -300,11 +272,10 @@ def findall (dir = os.curdir):
                 list.append(fullname)
             elif S_ISDIR(mode) and not S_ISLNK(mode):
                 push(fullname)
-
     return list
 
 
-def glob_to_re (pattern):
+def glob_to_re(pattern):
     """Translate a shell-like glob pattern to a regular expression; return
     a string containing the regex.  Differs from 'fnmatch.translate()' in
     that '*' does not match "special characters" (which are
@@ -322,10 +293,8 @@ def glob_to_re (pattern):
     pattern_re = re.sub(r'(^|[^\\])\.', r'\1[^/]', pattern_re)
     return pattern_re
 
-# glob_to_re ()
 
-
-def translate_pattern (pattern, anchor=1, prefix=None, is_regex=0):
+def translate_pattern(pattern, anchor=1, prefix=None, is_regex=0):
     """Translate a shell-like wildcard pattern to a compiled regular
     expression.  Return the compiled regex.  If 'is_regex' true,
     then 'pattern' is directly compiled to a regex (if it's a string)
@@ -350,5 +319,3 @@ def translate_pattern (pattern, anchor=1, prefix=None, is_regex=0):
             pattern_re = "^" + pattern_re
 
     return re.compile(pattern_re)
-
-# translate_pattern ()

Lib/distutils/log.py

 """A simple log mechanism styled after PEP 282."""
 
-# This module should be kept compatible with Python 2.1.
-
 # The class here is styled after PEP 282 so that it could later be
 # replaced with a standard Python logging implementation.
 

Lib/distutils/msvccompiler.py

@@ -8,8 +8,6 @@ for the Microsoft Visual Studio.
 # hacked by Robin Becker and Thomas Heller to do a better job of
 #   finding DevStudio (through the registry)
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, os
@@ -20,11 +18,11 @@ from distutils.ccompiler import \
      CCompiler, gen_preprocess_options, gen_lib_options
 from distutils import log
 
-_can_read_reg = 0
+_can_read_reg = False
 try:
     import _winreg
 
-    _can_read_reg = 1
+    _can_read_reg = True
     hkey_mod = _winreg
 
     RegOpenKeyEx = _winreg.OpenKeyEx
@@ -36,14 +34,13 @@ except ImportError:
     try:
         import win32api
         import win32con
-        _can_read_reg = 1
+        _can_read_reg = True
         hkey_mod = win32con
 
         RegOpenKeyEx = win32api.RegOpenKeyEx
         RegEnumKey = win32api.RegEnumKey
         RegEnumValue = win32api.RegEnumValue
         RegError = win32api.error
-
     except ImportError:
         log.info("Warning: Can't read registry to find the "
                  "necessary compiler setting\n"
@@ -59,20 +56,19 @@ if _can_read_reg:
 
 def read_keys(base, key):
     """Return list of registry keys."""
-
     try:
         handle = RegOpenKeyEx(base, key)
     except RegError:
         return None
     L = []
     i = 0
-    while 1:
+    while True:
         try:
             k = RegEnumKey(handle, i)
         except RegError:
             break
         L.append(k)
-        i = i + 1
+        i += 1
     return L
 
 def read_values(base, key):
@@ -86,14 +82,14 @@ def read_values(base, key):
         return None
     d = {}
     i = 0
-    while 1:
+    while True:
         try:
             name, value, type = RegEnumValue(handle, i)
         except RegError:
             break
         name = name.lower()
         d[convert_mbcs(name)] = convert_mbcs(value)
-        i = i + 1
+        i += 1
     return d
 
 def convert_mbcs(s):
@@ -106,7 +102,6 @@ def convert_mbcs(s):
     return s
 
 class MacroExpander:
-
     def __init__(self, version):
         self.macros = {}
         self.load_macros(version)
@@ -130,8 +125,8 @@ class MacroExpander:
             else:
                 self.set_macro("FrameworkSDKDir", net, "sdkinstallroot")
         except KeyError as exc: #
-            raise DistutilsPlatformError, \
-                  ("""Python was built with Visual Studio 2003;
+            raise DistutilsPlatformError(
+            """Python was built with Visual Studio 2003;
 extensions must be built with a compiler than can generate compatible binaries.
 Visual Studio 2003 was not found on this system. If you have Cygwin installed,
 you can try compiling with MingW32, by passing "-c mingw32" to setup.py.""")
@@ -157,7 +152,6 @@ def get_build_version():
     For Python 2.3 and up, the version number is included in
     sys.version.  For earlier versions, assume the compiler is MSVC 6.
     """
-
     prefix = "MSC v."
     i = sys.version.find(prefix)
     if i == -1:
@@ -202,7 +196,7 @@ def normalize_and_reduce_paths(paths):
     return reduced_paths
 
 
-class MSVCCompiler (CCompiler) :
+class MSVCCompiler(CCompiler) :
     """Concrete class that implements an interface to Microsoft Visual C++,
        as defined by the CCompiler abstract class."""
 
@@ -232,7 +226,7 @@ class MSVCCompiler (CCompiler) :
     static_lib_format = shared_lib_format = '%s%s'
     exe_extension = '.exe'
 
-    def __init__ (self, verbose=0, dry_run=0, force=0):
+    def __init__(self, verbose=0, dry_run=0, force=0):
         CCompiler.__init__ (self, verbose, dry_run, force)
         self.__version = get_build_version()
         self.__arch = get_build_architecture()
@@ -263,11 +257,11 @@ class MSVCCompiler (CCompiler) :
         else:
             self.__paths = self.get_msvc_paths("path")
 
-            if len (self.__paths) == 0:
-                raise DistutilsPlatformError, \
-                      ("Python was built with %s, "
+            if len(self.__paths) == 0:
+                raise DistutilsPlatformError("Python was built with %s, "
                        "and extensions need to be built with the same "
-                       "version of the compiler, but it isn't installed." % self.__product)
+                       "version of the compiler, but it isn't installed."
+                       % self.__product)
 
             self.cc = self.find_exe("cl.exe")
             self.linker = self.find_exe("link.exe")
@@ -314,10 +308,10 @@ class MSVCCompiler (CCompiler) :
 
     # -- Worker methods ------------------------------------------------
 
-    def object_filenames (self,
-                          source_filenames,
-                          strip_dir=0,
-                          output_dir=''):
+    def object_filenames(self,
+                         source_filenames,
+                         strip_dir=0,
+                         output_dir=''):
         # Copied from ccompiler.py, extended to return .res as 'object'-file
         # for .rc input file
         if output_dir is None: output_dir = ''
@@ -344,17 +338,16 @@ class MSVCCompiler (CCompiler) :
                                                 base + self.obj_extension))
         return obj_names
 
-    # object_filenames ()
-
 
     def compile(self, sources,
                 output_dir=None, macros=None, include_dirs=None, debug=0,
                 extra_preargs=None, extra_postargs=None, depends=None):
 
-        if not self.initialized: self.initialize()
-        macros, objects, extra_postargs, pp_opts, build = \
-                self._setup_compile(output_dir, macros, include_dirs, sources,
-                                    depends, extra_postargs)
+        if not self.initialized:
+            self.initialize()
+        compile_info = self._setup_compile(output_dir, macros, include_dirs,
+                                           sources, depends, extra_postargs)
+        macros, objects, extra_postargs, pp_opts, build = compile_info
 
         compile_opts = extra_preargs or []
         compile_opts.append ('/c')
@@ -383,13 +376,12 @@ class MSVCCompiler (CCompiler) :
                 input_opt = src
                 output_opt = "/fo" + obj
                 try:
-                    self.spawn ([self.rc] + pp_opts +
-                                [output_opt] + [input_opt])
+                    self.spawn([self.rc] + pp_opts +
+                               [output_opt] + [input_opt])
                 except DistutilsExecError as msg:
-                    raise CompileError, msg
+                    raise CompileError(msg)
                 continue
             elif ext in self._mc_extensions:
-
                 # Compile .MC to .RC file to .RES file.
                 #   * '-h dir' specifies the directory for the
                 #     generated include file
@@ -401,99 +393,95 @@ class MSVCCompiler (CCompiler) :
                 # we use the source-directory for the include file and
                 # the build directory for the RC file and message
                 # resources. This works at least for win32all.
-
-                h_dir = os.path.dirname (src)
-                rc_dir = os.path.dirname (obj)
+                h_dir = os.path.dirname(src)
+                rc_dir = os.path.dirname(obj)
                 try:
                     # first compile .MC to .RC and .H file
-                    self.spawn ([self.mc] +
-                                ['-h', h_dir, '-r', rc_dir] + [src])
+                    self.spawn([self.mc] +
+                               ['-h', h_dir, '-r', rc_dir] + [src])
                     base, _ = os.path.splitext (os.path.basename (src))
                     rc_file = os.path.join (rc_dir, base + '.rc')
                     # then compile .RC to .RES file
-                    self.spawn ([self.rc] +
-                                ["/fo" + obj] + [rc_file])
+                    self.spawn([self.rc] +
+                               ["/fo" + obj] + [rc_file])
 
                 except DistutilsExecError as msg:
-                    raise CompileError, msg
+                    raise CompileError(msg)
                 continue
             else:
                 # how to handle this file?
-                raise CompileError (
-                    "Don't know how to compile %s to %s" % \
-                    (src, obj))
+                raise CompileError("Don't know how to compile %s to %s"
+                                   % (src, obj))
 
             output_opt = "/Fo" + obj
             try:
-                self.spawn ([self.cc] + compile_opts + pp_opts +
-                            [input_opt, output_opt] +
-                            extra_postargs)
+                self.spawn([self.cc] + compile_opts + pp_opts +
+                           [input_opt, output_opt] +
+                           extra_postargs)
             except DistutilsExecError as msg:
-                raise CompileError, msg
+                raise CompileError(msg)
 
         return objects
 
-    # compile ()
 
+    def create_static_lib(self,
+                          objects,
+                          output_libname,
+                          output_dir=None,
+                          debug=0,
+                          target_lang=None):
 
-    def create_static_lib (self,
-                           objects,
-                           output_libname,
-                           output_dir=None,
-                           debug=0,
-                           target_lang=None):
+        if not self.initialized:
+            self.initialize()
+        (objects, output_dir) = self._fix_object_args(objects, output_dir)
+        output_filename = self.library_filename(output_libname,
+                                                output_dir=output_dir)
 
-        if not self.initialized: self.initialize()
-        (objects, output_dir) = self._fix_object_args (objects, output_dir)
-        output_filename = \
-            self.library_filename (output_libname, output_dir=output_dir)
-
-        if self._need_link (objects, output_filename):
+        if self._need_link(objects, output_filename):
             lib_args = objects + ['/OUT:' + output_filename]
             if debug:
-                pass                    # XXX what goes here?
+                pass # XXX what goes here?
             try:
-                self.spawn ([self.lib] + lib_args)
+                self.([self.lib] + lib_args)
             except DistutilsExecError as msg:
-                raise LibError, msg
-
+                raise LibError(msg)
         else:
             log.debug("skipping %s (up-to-date)", output_filename)
 
-    # create_static_lib ()
-
-    def link (self,
-              target_desc,
-              objects,
-              output_filename,
-              output_dir=None,
-              libraries=None,
-              library_dirs=None,
-              runtime_library_dirs=None,
-              export_symbols=None,
-              debug=0,
-              extra_preargs=None,
-              extra_postargs=None,
-              build_temp=None,
-              target_lang=None):
-
-        if not self.initialized: self.initialize()
-        (objects, output_dir) = self._fix_object_args (objects, output_dir)
-        (libraries, library_dirs, runtime_library_dirs) = \
-            self._fix_lib_args (libraries, library_dirs, runtime_library_dirs)
+
+    def link(self,
+             target_desc,
+             objects,
+             output_filename,
+             output_dir=None,
+             libraries=None,
+             library_dirs=None,
+             runtime_library_dirs=None,
+             export_symbols=None,
+             debug=0,
+             extra_preargs=None,
+             extra_postargs=None,
+             build_temp=None,
+             target_lang=None):
+
+        if not self.initialized:
+            self.initialize()
+        (objects, output_dir) = self._fix_object_args(objects, output_dir)
+        fixed_args = self._fix_lib_args(libraries, library_dirs,
+                                        runtime_library_dirs)
+        (libraries, library_dirs, runtime_library_dirs) = fixed_args
 
         if runtime_library_dirs:
             self.warn ("I don't know what to do with 'runtime_library_dirs': "
                        + str (runtime_library_dirs))
 
-        lib_opts = gen_lib_options (self,
-                                    library_dirs, runtime_library_dirs,
-                                    libraries)
+        lib_opts = gen_lib_options(self,
+                                   library_dirs, runtime_library_dirs,
+                                   libraries)
         if output_dir is not None:
-            output_filename = os.path.join (output_dir, output_filename)
-
-        if self._need_link (objects, output_filename):
+            output_filename = os.path.join(output_dir, output_filename)
 
+        if self._need_link(objects, output_filename):
             if target_desc == CCompiler.EXECUTABLE:
                 if debug:
                     ldflags = self.ldflags_shared_debug[1:]
@@ -530,34 +518,32 @@ class MSVCCompiler (CCompiler) :
             if extra_postargs:
                 ld_args.extend(extra_postargs)
 
-            self.mkpath (os.path.dirname (output_filename))
+            self.mkpath(os.path.dirname(output_filename))
             try:
-                self.spawn ([self.linker] + ld_args)
+                self.spawn([self.linker] + ld_args)
             except DistutilsExecError as msg:
-                raise LinkError, msg
+                raise LinkError(msg)
 
         else:
             log.debug("skipping %s (up-to-date)", output_filename)
 
-    # link ()
-
 
     # -- Miscellaneous methods -----------------------------------------
     # These are all used by the 'gen_lib_options() function, in
     # ccompiler.py.
 
-    def library_dir_option (self, dir):
+    def library_dir_option(self, dir):
         return "/LIBPATH:" + dir
 
-    def runtime_library_dir_option (self, dir):
-        raise DistutilsPlatformError, \
-              "don't know how to set runtime library search path for MSVC++"
+    def runtime_library_dir_option(self, dir):
+        raise DistutilsPlatformError(
+              "don't know how to set runtime library search path for MSVC++")
 
-    def library_option (self, lib):
-        return self.library_filename (lib)
+    def library_option(self, lib):
+        return self.library_filename(lib)
 
 
-    def find_library_file (self, dirs, lib, debug=0):
+    def find_library_file(self, dirs, lib, debug=0):
         # Prefer a debugging library if found (and requested), but deal
         # with it if we don't have one.
         if debug:
@@ -573,8 +559,6 @@ class MSVCCompiler (CCompiler) :
             # Oops, didn't find it in *any* of 'dirs'
             return None
 
-    # find_library_file ()
-
     # Helper methods for using the MSVC registry settings
 
     def find_exe(self, exe):
@@ -586,7 +570,6 @@ class MSVCCompiler (CCompiler) :
         absolute path that is known to exist.  If none of them work, just
         return the original program name, 'exe'.
         """
-
         for p in self.__paths:
             fn = os.path.join(os.path.abspath(p), exe)
             if os.path.isfile(fn):
@@ -606,7 +589,6 @@ class MSVCCompiler (CCompiler) :
         Return a list of strings.  The list will be empty if unable to
         access the registry or appropriate registry keys not found.
         """
-
         if not _can_read_reg:
             return []
 

Lib/distutils/mwerkscompiler.py

@@ -4,12 +4,9 @@ Contains MWerksCompiler, an implementation of the abstract CCompiler class
 for MetroWerks CodeWarrior on the Macintosh. Needs work to support CW on
 Windows."""
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, os
-from types import *
 from distutils.errors import \
      DistutilsExecError, DistutilsPlatformError, \
      CompileError, LibError, LinkError
@@ -96,13 +93,13 @@ class MWerksCompiler (CCompiler) :
 
         # First examine a couple of options for things that aren't implemented yet
         if not target_desc in (self.SHARED_LIBRARY, self.SHARED_OBJECT):
-            raise DistutilsPlatformError, 'Can only make SHARED_LIBRARY or SHARED_OBJECT targets on the Mac'
+            raise DistutilsPlatformError('Can only make SHARED_LIBRARY or SHARED_OBJECT targets on the Mac')
         if runtime_library_dirs:
-            raise DistutilsPlatformError, 'Runtime library dirs not implemented yet'
+            raise DistutilsPlatformError('Runtime library dirs not implemented yet')
         if extra_preargs or extra_postargs:
-            raise DistutilsPlatformError, 'Runtime library dirs not implemented yet'
+            raise DistutilsPlatformError('Runtime library dirs not implemented yet')
         if len(export_symbols) != 1:
-            raise DistutilsPlatformError, 'Need exactly one export symbol'
+            raise DistutilsPlatformError('Need exactly one export symbol')
         # Next there are various things for which we need absolute pathnames.
         # This is because we (usually) create the project in a subdirectory of
         # where we are now, and keeping the paths relative is too much work right

Lib/distutils/spawn.py

@@ -6,19 +6,13 @@ Also provides the 'find_executable()' to search the path for a given
 executable name.
 """
 
-# This module should be kept compatible with Python 2.1.
-
 __revision__ = "$Id$"
 
 import sys, os
 from distutils.errors import *
 from distutils import log
 
-def spawn (cmd,
-           search_path=1,
-           verbose=0,
-           dry_run=0):
-
+def spawn(cmd, search_path=1, verbose=0, dry_run=0):
     """Run another program, specified as a command list 'cmd', in a new
     process.  'cmd' is just the argument list for the new process, ie.
     cmd[0] is the program to run and cmd[1:] are the rest of its arguments.
@@ -40,34 +34,26 @@ def spawn (cmd,
     elif os.name == 'os2':
         _spawn_os2(cmd, search_path, dry_run=dry_run)
     else:
-        raise DistutilsPlatformError, \
-              "don't know how to spawn programs on platform '%s'" % os.name
+        raise DistutilsPlatformError(
+              "don't know how to spawn programs on platform '%s'" % os.name)
 
-# spawn ()
 
-
-def _nt_quote_args (args):
+def _nt_quote_args(args):
     """Quote command-line arguments for DOS/Windows conventions: just
     wraps every argument which contains blanks in double quotes, and
     returns a new argument list.
     """
-
     # XXX this doesn't seem very robust to me -- but if the Windows guys
     # say it'll work, I guess I'll have to accept it.  (What if an arg
     # contains quotes?  What other magic characters, other than spaces,
     # have to be escaped?  Is there an escaping mechanism other than
     # quoting?)
-
     for i in range(len(args)):
         if args[i].find(' ') != -1:
             args[i] = '"%s"' % args[i]
     return args
 
-def _spawn_nt (cmd,
-               search_path=1,
-               verbose=0,
-               dry_run=0):
-
+def _spawn_nt(cmd, search_path=1, verbose=0, dry_run=0):
     executable = cmd[0]
     cmd = _nt_quote_args(cmd)
     if search_path:
@@ -80,19 +66,15 @@ def _spawn_nt (cmd,
             rc = os.spawnv(os.P_WAIT, executable, cmd)
         except OSError as exc:
             # this seems to happen when the command isn't found
-            raise DistutilsExecError, \
-                  "command '%s' failed: %s" % (cmd[0], exc[-1])
+            raise DistutilsExecError(
+                  "command '%s' failed: %s" % (cmd[0], exc[-1]))
         if rc != 0:
             # and this reflects the command running but failing
-            raise DistutilsExecError, \
-                  "command '%s' failed with exit status %d" % (cmd[0], rc)
+            raise DistutilsExecError(
+                  "command '%s' failed with exit status %d" % (cmd[0], rc))
 
 
-def _spawn_os2 (cmd,
-                search_path=1,
-                verbose=0,
-                dry_run=0):
-
+def _spawn_os2(cmd, search_path=1, verbose=0, dry_run=0):
     executable = cmd[0]
     #cmd = _nt_quote_args(cmd)
     if search_path:
@@ -105,75 +87,62 @@ def _spawn_os2 (cmd,
             rc = os.spawnv(os.P_WAIT, executable, cmd)
         except OSError as exc:
             # this seems to happen when the command isn't found
-            raise DistutilsExecError, \
-                  "command '%s' failed: %s" % (cmd[0], exc[-1])
+            raise DistutilsExecError(
+                  "command '%s' failed: %s" % (cmd[0], exc[-1]))
         if rc != 0:
             # and this reflects the command running but failing
             print("command '%s' failed with exit status %d" % (cmd[0], rc))
-            raise DistutilsExecError, \
-                  "command '%s' failed with exit status %d" % (cmd[0], rc)
-
+            raise DistutilsExecError(
+                  "command '%s' failed with exit status %d" % (cmd[0], rc))
 
-def _spawn_posix (cmd,
-                  search_path=1,
-                  verbose=0,
-                  dry_run=0):
 
+def _spawn_posix(cmd, search_path=1, verbose=0, dry_run=0):
     log.info(' '.join(cmd))
     if dry_run:
         return
     exec_fn = search_path and os.execvp or os.execv
 
     pid = os.fork()
-
-    if pid == 0:                        # in the child
+    if pid == 0: # in the child
         try:
-            #print "cmd[0] =", cmd[0]
-            #print "cmd =", cmd
             exec_fn(cmd[0], cmd)
         except OSError as e:
-            sys.stderr.write("unable to execute %s: %s\n" %
-                             (cmd[0], e.strerror))
+            sys.stderr.write("unable to execute %s: %s\n"
+                             % (cmd[0], e.strerror))
             os._exit(1)
 
         sys.stderr.write("unable to execute %s for unknown reasons" % cmd[0])
         os._exit(1)
-
-
-    else:                               # in the parent
+    else: # in the parent
         # Loop until the child either exits or is terminated by a signal
         # (ie. keep waiting if it's merely stopped)
-        while 1:
+        while True:
             try:
                 (pid, status) = os.waitpid(pid, 0)
             except OSError as exc:
                 import errno
                 if exc.errno == errno.EINTR:
                     continue
-                raise DistutilsExecError, \
-                      "command '%s' failed: %s" % (cmd[0], exc[-1])
+                raise DistutilsExecError(
+                      "command '%s' failed: %s" % (cmd[0], exc[-1]))
             if os.WIFSIGNALED(status):
-                raise DistutilsExecError, \
-                      "command '%s' terminated by signal %d" % \
-                      (cmd[0], os.WTERMSIG(status))
-
+                raise DistutilsExecError(
+                      "command '%s' terminated by signal %d"
+                      % (cmd[0], os.WTERMSIG(status)))
             elif os.WIFEXITED(status):
                 exit_status = os.WEXITSTATUS(status)
                 if exit_status == 0:
                     return              # hey, it succeeded!
                 else:
-                    raise DistutilsExecError, \
-                          "command '%s' failed with exit status %d" % \
-                          (cmd[0], exit_status)
-
+                    raise DistutilsExecError(
+                          "command '%s' failed with exit status %d"
+                          % (cmd[0], exit_status))
             elif os.WIFSTOPPED(status):
                 continue
-
             else:
-                raise DistutilsExecError, \
-                      "unknown error executing '%s': termination status %d" % \
-                      (cmd[0], status)
-# _spawn_posix ()
+                raise DistutilsExecError(
+                      "unknown error executing '%s': termination status %d"
+                      % (cmd[0], status))
 
 
 def find_executable(executable, path=None):
@@ -197,5 +166,3 @@ def find_executable(executable, path=None):
         return None
     else:
         return executable
-
-# find_executable()

Lib/distutils/sysconfig.py

@@ -27,11 +27,7 @@ EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
 # different (hard-wired) directories.
 
 argv0_path = os.path.dirname(os.path.abspath(sys.executable))
-landmark = os.path.join(argv0_path, "Modules", "Setup")
-
-python_build = os.path.isfile(landmark)
-
-del landmark
+python_build = os.path.isfile(os.path.join(argv0_path, "Modules", "Setup"))
 
 
 def get_python_version():
@@ -105,7 +101,6 @@ def get_python_lib(plat_specific=0, standard_lib=0, prefix=None):
             return libpython
         else:
             return os.path.join(libpython, "site-packages")
-
     elif os.name == "nt":
         if standard_lib:
             return os.path.join(prefix, "Lib")
@@ -114,7 +109,6 @@ def get_python_lib(plat_specific=0, standard_lib=0, prefix=None):
                 return prefix
             else:
                 return os.path.join(PREFIX, "Lib", "site-packages")
-
     elif os.name == "mac":
         if plat_specific:
             if standard_lib:
@@ -126,13 +120,11 @@ def get_python_lib(plat_specific=0, standard_lib=0, prefix=None):
                 return os.path.join(prefix, "Lib")
             else:
                 return os.path.join(prefix, "Lib", "site-packages")
-
     elif os.name == "os2":
         if standard_lib:
             return os.path.join(PREFIX, "Lib")
         else:
             return os.path.join(PREFIX, "Lib", "site-packages")
-
     else:
         raise DistutilsPlatformError(
             "I don't know where Python installs its library "
@@ -216,7 +208,7 @@ def parse_config_h(fp, g=None):
     define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n")
     undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n")
     #
-    while 1:
+    while True:
         line = fp.readline()
         if not line:
             break
@@ -254,9 +246,9 @@ def parse_makefile(fn, g=None):
     done = {}
     notdone = {}
 
-    while 1:
+    while True:
         line = fp.readline()
-        if line is None:                # eof
+        if line is None: # eof
             break
         m = _variable_rx.match(line)
         if m:
@@ -325,7 +317,7 @@ def expand_makefile_vars(s, vars):
     # 'parse_makefile()', which takes care of such expansions eagerly,
     # according to make's variable expansion semantics.
 
-    while 1:
+    while True:
         m = _findvar1_rx.search(s) or _findvar2_rx.search(s)
         if m:
             (beg, end) = m.span()

Lib/distutils/text_file.py

@@ -10,7 +10,6 @@ import sys, os, io
 
 
 class TextFile:
-
     """Provides a file-like object that takes care of all the things you
        commonly want to do when processing a text file that has some
        line-by-line syntax: strip comments (as long as "#" is your
@@ -75,32 +74,29 @@ class TextFile:
                         'collapse_join':  0,
                       }
 
-    def __init__ (self, filename=None, file=None, **options):
+    def __init__(self, filename=None, file=None, **options):
         """Construct a new TextFile object.  At least one of 'filename'
            (a string) and 'file' (a file-like object) must be supplied.
            They keyword argument options are described above and affect
            the values returned by 'readline()'."""
-
         if filename is None and file is None:
-            raise RuntimeError, \
-                  "you must supply either or both of 'filename' and 'file'"
+            raise RuntimeError("you must supply either or both of 'filename' and 'file'")
 
         # set values for all options -- either from client option hash
         # or fallback to default_options
         for opt in self.default_options.keys():
             if opt in options:
-                setattr (self, opt, options[opt])
-
+                setattr(self, opt, options[opt])
             else:
-                setattr (self, opt, self.default_options[opt])
+                setattr(self, opt, self.default_options[opt])
 
         # sanity check client option hash
         for opt in options.keys():
             if opt not in self.default_options:
-                raise KeyError, "invalid TextFile option '%s'" % opt
+                raise KeyError("invalid TextFile option '%s'" % opt)
 
         if file is None:
-            self.open (filename)
+            self.open(filename)
         else:
             self.filename = filename
             self.file = file
@@ -111,43 +107,37 @@ class TextFile:
         # 'unreadline()' operation
         self.linebuf = []
 
-
-    def open (self, filename):
+    def open(self, filename):
         """Open a new file named 'filename'.  This overrides both the
            'filename' and 'file' arguments to the constructor."""
-
         self.filename = filename
-        self.file = io.open (self.filename, 'r')
+        self.file = io.open(self.filename, 'r')
         self.current_line = 0
 
-
-    def close (self):
+    def close(self):
         """Close the current file and forget everything we know about it
            (filename, current line number)."""
-
-        self.file.close ()
+        self.file.close()
         self.file = None
         self.filename = None
         self.current_line = None
 
-
-    def gen_error (self, msg, line=None):
+    def gen_error(self, msg, line=None):
         outmsg = []
         if line is None:
             line = self.current_line
         outmsg.append(self.filename + ", ")
-        if isinstance (line, (list, tuple)):
-            outmsg.append("lines %d-%d: " % tuple (line))
+        if isinstance(line, (list, tuple)):
+            outmsg.append("lines %d-%d: " % tuple(line))
         else:
             outmsg.append("line %d: " % line)
         outmsg.append(str(msg))
         return "".join(outmsg)
 
+    def error(self, msg, line=None):
+        raise ValueError("error: " + self.gen_error(msg, line))
 
-    def error (self, msg, line=None):
-        raise ValueError, "error: " + self.gen_error(msg, line)
-
-    def warn (self, msg, line=None):
+    def warn(self, msg, line=None):
         """Print (to stderr) a warning message tied to the current logical
            line in the current file.  If the current logical line in the
            file spans multiple physical lines, the warning refers to the
@@ -157,8 +147,7 @@ class TextFile:
            line."""
         sys.stderr.write("warning: " + self.gen_error(msg, line) + "\n")
 
-
-    def readline (self):
+    def readline(self):
         """Read and return a single logical line from the current file (or
            from an internal buffer if lines have previously been "unread"
            with 'unreadline()').  If the 'join_lines' option is true, this
@@ -168,7 +157,6 @@ class TextFile:
            line(s) just read.  Returns None on end-of-file, since the empty
            string can occur if 'rstrip_ws' is true but 'strip_blanks' is
            not."""
-
         # If any "unread" lines waiting in 'linebuf', return the top
         # one.  (We don't actually buffer read-ahead data -- lines only
         # get put in 'linebuf' if the client explicitly does an
@@ -180,10 +168,11 @@ class TextFile:
 
         buildup_line = ''
 
-        while 1:
+        while True:
             # read the line, make it None if EOF
             line = self.file.readline()
-            if line == '': line = None
+            if line == '':
+                line = None
 
             if self.strip_comments and line:
 
@@ -195,8 +184,8 @@ class TextFile:
                 # unescape it (and any other escaped "#"'s that might be
                 # lurking in there) and otherwise leave the line alone.
 
-                pos = line.find ("#")
-                if pos == -1:           # no "#" -- no comments
+                pos = line.find("#")
+                if pos == -1: # no "#" -- no comments
                     pass
 
                 # It's definitely a comment -- either "#" is the first
@@ -218,51 +207,48 @@ class TextFile:
                     #   # comment that should be ignored
                     #   there
                     # result in "hello there".
-                    if line.strip () == "":
+                    if line.strip() == "":
                         continue
-
-                else:                   # it's an escaped "#"
+                else: # it's an escaped "#"
                     line = line.replace("\\#", "#")
 
-
             # did previous line end with a backslash? then accumulate
             if self.join_lines and buildup_line:
                 # oops: end of file
                 if line is None:
-                    self.warn ("continuation line immediately precedes "
-                               "end-of-file")
+                    self.warn("continuation line immediately precedes "
+                              "end-of-file")
                     return buildup_line
 
                 if self.collapse_join:
-                    line = line.lstrip ()
+                    line = line.lstrip()
                 line = buildup_line + line
 
                 # careful: pay attention to line number when incrementing it
-                if isinstance (self.current_line, list):
+                if isinstance(self.current_line, list):
                     self.current_line[1] = self.current_line[1] + 1
                 else:
                     self.current_line = [self.current_line,
-                                         self.current_line+1]
+                                         self.current_line + 1]
             # just an ordinary line, read it as usual
             else:
-                if line is None:        # eof
+                if line is None: # eof
                     return None
 
                 # still have to be careful about incrementing the line number!
-                if isinstance (self.current_line, list):
+                if isinstance(self.current_line, list):
                     self.current_line = self.current_line[1] + 1
                 else:
                     self.current_line = self.current_line + 1
 
-
             # strip whitespace however the client wants (leading and
             # trailing, or one or the other, or neither)
             if self.lstrip_ws and self.rstrip_ws:
-                line = line.strip ()
+                line = line.strip()
             elif self.lstrip_ws:
-                line = line.lstrip ()
+                line = line.lstrip()
             elif self.rstrip_ws:
-                line = line.rstrip ()
+                line = line.rstrip()
 
             # blank line (whether we rstrip'ed or not)? skip to next line
             # if appropriate
@@ -281,27 +267,21 @@ class TextFile:
             # well, I guess there's some actual content there: return it
             return line
 
-    # readline ()
-
-
-    def readlines (self):
+    def readlines(self):
         """Read and return the list of all logical lines remaining in the
            current file."""
-
         lines = []
-        while 1:
+        while True:
             line = self.readline()
             if line is None:
                 return lines
-            lines.append (line)
+            lines.append(line)
 
-
-    def unreadline (self, line):
+    def unreadline(self, line):
         """Push 'line' (a string) onto an internal buffer that will be
            checked by future 'readline()' calls.  Handy for implementing
            a parser with line-at-a-time lookahead."""
-
-        self.linebuf.append (line)
+        self.linebuf.append(line)
 
 
 if __name__ == "__main__":
@@ -312,7 +292,7 @@ line 3 \\
   continues on next line
 """
     # result 1: no fancy options
-    result1 = map (lambda x: x + "\n", test_data.split ("\n")[0:-1])
+    result1 = map(lambda x: x + "\n", test_data.split("\n")[0:-1])
 
     # result 2: just strip comments
     result2 = ["\n",
@@ -337,9 +317,8 @@ line 3 \\
     # "collapse" joined lines
     result6 = ["line 3 continues on next line"]
 
-    def test_input (count, description, file, expected_result):
-        result = file.readlines ()
-        # result = ''.join (result)
+    def test_input(count, description, file, expected_result):
+        result = file.readlines()
         if result == expected_result:
             print("ok %d (%s)" % (count, description))
         else:
@@ -351,31 +330,31 @@ line 3 \\
 
 
     filename = "test.txt"
-    out_file = open (filename, "w")
-    out_file.write (test_data)
-    out_file.close ()
+    out_file = open(filename, "w")
+    out_file.write(test_data)
+    out_file.close()
 
-    in_file = TextFile (filename, strip_comments=0, skip_blanks=0,
-                        lstrip_ws=0, rstrip_ws=0)
-    test_input (1, "no processing", in_file, result1)
+    in_file = TextFile(filename, strip_comments=0, skip_blanks=0,
+                       lstrip_ws=0, rstrip_ws=0)
+    test_input(1, "no processing", in_file, result1)
 
-    in_file = TextFile (filename, strip_comments=1, skip_blanks=0,
-                        lstrip_ws=0, rstrip_ws=0)
-    test_input (2, "strip comments", in_file, result2)
+    in_file = TextFile(filename, strip_comments=1, skip_blanks=0,
+                       lstrip_ws=0, rstrip_ws=0)
+    test_input(2, "strip comments", in_file, result2)
 
-    in_file = TextFile (filename, strip_comments=0, skip_blanks=1,
-                        lstrip_ws=0, rstrip_ws=0)
-    test_input (3, "strip blanks", in_file, result3)
+    in_file = TextFile(filename, strip_comments=0, skip_blanks=1,
+                       lstrip_ws=0, rstrip_ws=0)
+    test_input(3, "strip blanks", in_file, result3)
 
-    in_file = TextFile (filename)
-    test_input (4, "default processing", in_file, result4)
+    in_file = TextFile(filename)
+    test_input(4, "default processing", in_file, result4)
 
-    in_file = TextFile (filename, strip_comments=1, skip_blanks=1,
-                        join_lines=1, rstrip_ws=1)
-    test_input (5, "join lines without collapsing", in_file, result5)
+    in_file = TextFile(filename, strip_comments=1, skip_blanks=1,
+                       join_lines=1, rstrip_ws=1)
+    test_input(5, "join lines without collapsing", in_file, result5)
 
-    in_file = TextFile (filename, strip_comments=1, skip_blanks=1,
-                        join_lines=1, rstrip_ws=1, collapse_join=1)
-    test_input (6, "join lines with collapsing", in_file, result6)
+    in_file = TextFile(filename, strip_comments=1, skip_blanks=1,
+                       join_lines=1, rstrip_ws=1, collapse_join=1)
+    test_input(6, "join lines with collapsing", in_file, result6)
 
-    os.remove (filename)
+    os.remove(filename)

Lib/distutils/unixccompiler.py

@@ -50,7 +50,7 @@ def _darwin_compiler_fixup(compiler_so, cc_args):
     build, without a way to remove an architecture. Furthermore GCC will
     barf if multiple '-isysroot' arguments are present.
     """
-    stripArch = stripSysroot = 0
+    stripArch = stripSysroot = False
 
     compiler_so = list(compiler_so)
     kernel_version = os.uname()[2] # 8.4.3
@@ -65,7 +65,7 @@ def _darwin_compiler_fixup(compiler_so, cc_args):
         stripSysroot = '-isysroot' in cc_args
 
     if stripArch:
-        while 1:
+        while True:
             try:
                 index = compiler_so.index('-arch')
                 # Strip this argument and the next one:
@@ -137,11 +137,10 @@ class UnixCCompiler(CCompiler):
     if sys.platform == "cygwin":
         exe_extension = ".exe"
 
-    def preprocess(self, source,
-                   output_file=None, macros=None, include_dirs=None,
-                   extra_preargs=None, extra_postargs=None):
-        ignore, macros, include_dirs = \
-            self._fix_compile_args(None, macros, include_dirs)
+    def preprocess(self, source, output_file=None, macros=None,
+                   include_dirs=None, extra_preargs=None, extra_postargs=None):
+        fixed_args = self._fix_compile_args(None, macros, include_dirs)
+        ignore, macros, include_dirs = fixed_args
         pp_opts = gen_preprocess_options(macros, include_dirs)
         pp_args = self.preprocessor + pp_opts
         if output_file:
@@ -162,7 +161,7 @@ class UnixCCompiler(CCompiler):
             try:
                 self.spawn(pp_args)
             except DistutilsExecError as msg:
-                raise CompileError, msg
+                raise CompileError(msg)
 
     def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
         compiler_so = self.compiler_so
@@ -172,7 +171,7 @@ class UnixCCompiler(CCompiler):
             self.spawn(compiler_so + cc_args + [src, '-o', obj] +
                        extra_postargs)
         except DistutilsExecError as msg:
-            raise CompileError, msg
+            raise CompileError(msg)
 
     def create_static_lib(self, objects, output_libname,
                           output_dir=None, debug=0, target_lang=None):
@@ -196,7 +195,7 @@ class UnixCCompiler(CCompiler):
                 try:
                     self.spawn(self.ranlib + [output_filename])
                 except DistutilsExecError as msg:
-                    raise LibError, msg
+                    raise LibError(msg)
         else:
             log.debug("skipping %s (up-to-date)", output_filename)
 
@@ -206,13 +205,14 @@ class UnixCCompiler(CCompiler):
              export_symbols=None, debug=0, extra_preargs=None,
              extra_postargs=None, build_temp=None, target_lang=None):
         objects, output_dir = self._fix_object_args(objects, output_dir)
-        libraries, library_dirs, runtime_library_dirs = \
-            self._fix_lib_args(libraries, library_dirs, runtime_library_dirs)
+        fixed_args = self._fix_lib_args(libraries, library_dirs,
+                                        runtime_library_dirs)
+        libraries, library_dirs, runtime_library_dirs = fixed_args
 
         lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs,
                                    libraries)
         if not isinstance(output_dir, (basestring, type(None))):
-            raise TypeError, "'output_dir' must be a string or None"
+            raise TypeError("'output_dir' must be a string or None")
         if output_dir is not None:
             output_filename = os.path.join(output_dir, output_filename)
 
@@ -241,8 +241,7 @@ class UnixCCompiler(CCompiler):
                     if os.path.basename(linker[0]) == "env":
                         i = 1
                         while '=' in linker[i]:
-                            i = i + 1
-
+                            i += 1
                     linker[i] = self.compiler_cxx[i]
 
                 if sys.platform == 'darwin':
@@ -250,7 +249,7 @@ class UnixCCompiler(CCompiler):
 
                 self.spawn(linker + ld_args)
             except DistutilsExecError as msg:
-                raise LinkError, msg
+                raise LinkError(msg)
         else:
             log.debug("skipping %s (up-to-date)", output_filename)
 

Lib/distutils/util.py

@@ -153,9 +153,9 @@ def convert_path (pathname):
     if not pathname:
         return pathname
     if pathname[0] == '/':
-        raise ValueError, "path '%s' cannot be absolute" % pathname
+        raise ValueError("path '%s' cannot be absolute" % pathname)
     if pathname[-1] == '/':
-        raise ValueError, "path '%s' cannot end with '/'" % pathname
+        raise ValueError("path '%s' cannot end with '/'" % pathname)
 
     paths = pathname.split('/')
     while '.' in paths:
@@ -201,8 +201,7 @@ def change_root (new_root, pathname):
             return os.path.join(new_root, pathname)
 
     else:
-        raise DistutilsPlatformError, \
-              "nothing known about platform '%s'" % os.name
+        raise DistutilsPlatformError("nothing known about platform '%s'" % os.name)
 
 
 _environ_checked = 0
@@ -248,7 +247,7 @@ def subst_vars (s, local_vars):
     try:
         return re.sub(r'\$([a-zA-Z_][a-zA-Z_0-9]*)', _subst, s)
     except KeyError as var:
-        raise ValueError, "invalid variable '$%s'" % var
+        raise ValueError("invalid variable '$%s'" % var)
 
 # subst_vars ()
 
@@ -326,12 +325,10 @@ def split_quoted (s):
             elif s[end] == '"':         # slurp doubly-quoted string
                 m = _dquote_re.match(s, end)
             else:
-                raise RuntimeError, \
-                      "this can't happen (bad char '%c')" % s[end]
+                raise RuntimeError("this can't happen (bad char '%c')" % s[end])
 
             if m is None:
-                raise ValueError, \
-                      "bad string (mismatched %s quotes?)" % s[end]
+                raise ValueError("bad string (mismatched %s quotes?)" % s[end])
 
             (beg, end) = m.span()
             s = s[:beg] + s[beg+1:end-1] + s[end:]
@@ -378,7 +375,7 @@ def strtobool (val):
     elif val in ('n', 'no', 'f', 'false', 'off', '0'):
         return 0
     else:
-        raise ValueError, "invalid truth value %r" % (val,)
+        raise ValueError("invalid truth value %r" % (val,))
 
 
 def byte_compile (py_files,
@@ -502,8 +499,7 @@ byte_compile(files, optimize=%r, force=%r,
             dfile = file
             if prefix:
                 if file[:len(prefix)] != prefix:
-                    raise ValueError, \
-                          ("invalid prefix: filename %r doesn't start with %r"
+                    raise ValueError("invalid prefix: filename %r doesn't start with %r"
                            % (file, prefix))
                 dfile = dfile[len(prefix):]
             if base_dir:

Lib/distutils/version.py

@@ -140,7 +140,7 @@ class StrictVersion (Version):
     def parse (self, vstring):
         match = self.version_re.match(vstring)
         if not match:
-            raise ValueError, "invalid version number '%s'" % vstring
+            raise ValueError("invalid version number '%s'" % vstring)
 
         (major, minor, patch, prerelease, prerelease_num) = \
             match.group(1, 2, 4, 5, 6)