Changeset 388 for python/vendor/current/Lib/distutils

python/vendor/current/Lib/distutils/README

-              r2
+              r388
 This directory contains only a subset of the Distutils, specifically
+the Python modules in the 'distutils' and 'distutils.command'
+packages.  This is all you need to distribute and install Python
+modules using the Distutils.  There is also a separately packaged
+standalone version of the Distutils available for people who want to
+upgrade the Distutils without upgrading Python, available from the
 Distutils web page:
+This directory contains the Distutils package.
+There's a full documentation available at:
+    http://docs.python.org/distutils/
+The Distutils-SIG web page is also a good starting point:
     http://www.python.org/sigs/distutils-sig/
+The standalone version includes all of the code in this directory,
+plus documentation, test scripts, examples, etc.
+WARNING : Distutils must remain compatible with 2.3
+The Distutils documentation is divided into two documents, "Installing
+Python Modules", which explains how to install Python packages, and
+"Distributing Python Modules", which explains how to write setup.py
+files.  Both documents are part of the standard Python documentation
+set, and are available from http://www.python.org/doc/current/ .
+        Greg Ward (gward@python.net)
+$Id: README 29650 2002-11-13 13:26:59Z akuchling $
+$Id$

python/vendor/current/Lib/distutils/init.py

-              r2
+              r388
 """
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: __init__.py 79063 2010-03-18 22:14:36Z barry.warsaw $"
+__revision__ = "$Id$"
 # Distutils version
+#
+# Please coordinate with Marc-Andre Lemburg <mal@egenix.com> when adding
+# new features to distutils that would warrant bumping the version number.
+# Updated automatically by the Python release process.
+#
-# In general, major and minor version should loosely follow the Python
-# version number the distutils code was shipped with.
+#
 #--start constants--
 __version__ = "2.6.5"
+__version__ = "2.7.6"
 #--end constants--

python/vendor/current/Lib/distutils/archive_util.py

-              r2
+              r388
 that sort of thing)."""
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: archive_util.py 62904 2008-05-08 22:09:54Z benjamin.peterson $"
+__revision__ = "$Id$"
 import os
+from warnings import warn
+import sys
 from distutils.errors import DistutilsExecError
 from distutils.spawn import spawn
 …
 from distutils import log
+def make_tarball (base_name, base_dir, compress="gzip",
+                  verbose=0, dry_run=0):
+try:
+    from pwd import getpwnam
+except ImportError:
+    getpwnam = None
+try:
+    from grp import getgrnam
+except ImportError:
+    getgrnam = None
+def _get_gid(name):
+    """Returns a gid, given a group name."""
+    if getgrnam is None or name is None:
+        return None
+    try:
+        result = getgrnam(name)
+    except KeyError:
+        result = None
+    if result is not None:
+        return result[2]
+    return None
+def _get_uid(name):
+    """Returns an uid, given a user name."""
+    if getpwnam is None or name is None:
+        return None
+    try:
+        result = getpwnam(name)
+    except KeyError:
+        result = None
+    if result is not None:
+        return result[2]
+    return None
+def make_tarball(base_name, base_dir, compress="gzip", verbose=0, dry_run=0,
+                 owner=None, group=None):
     """Create a (possibly compressed) tar file from all the files under
     'base_dir'.  'compress' must be "gzip" (the default), "compress",
+    "bzip2", or None.  Both "tar" and the compression utility named by
     'compress' must be on the default program search path, so this is
     probably Unix-specific.  The output tar file will be named 'base_dir' +
+    ".tar", possibly plus the appropriate compression extension (".gz",
     ".bz2" or ".Z").  Return the output filename.
     """
     # XXX GNU tar 1.13 has a nifty option to add a prefix directory.
+    # It's pretty new, though, so we certainly can't require it --
     # but it would be nice to take advantage of it to skip the
     # "create a tree of hardlinks" step!  (Would also be nice to
+    # detect GNU tar to use its 'z' option and save a step.)
     compress_ext = { 'gzip': ".gz",
                      'bzip2': '.bz2',
                      'compress': ".Z" }
+    'base_dir'.
+    'compress' must be "gzip" (the default), "compress", "bzip2", or None.
+    (compress will be deprecated in Python 3.2)
+    'owner' and 'group' can be used to define an owner and a group for the
+    archive that is being built. If not provided, the current owner and group
+    will be used.
+    The output tar file will be named 'base_dir' +  ".tar", possibly plus
+    the appropriate compression extension (".gz", ".bz2" or ".Z").
+    Returns the output filename.
+    """
+    tar_compression = {'gzip': 'gz', 'bzip2': 'bz2', None: '', 'compress': ''}
+    compress_ext = {'gzip': '.gz', 'bzip2': '.bz2', 'compress': '.Z'}
     # flags for compression program, each element of list will be an argument
-    compress_flags = {'gzip': ["-f9"],
-                      'compress': ["-f"],
-                      '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'"
+    archive_name = base_name + ".tar"
+              ("bad value for 'compress': must be None, 'gzip', 'bzip2' "
+               "or 'compress'")
+    archive_name = base_name + '.tar'
+    if compress != 'compress':
+        archive_name += compress_ext.get(compress, '')
     mkpath(os.path.dirname(archive_name), dry_run=dry_run)
+    cmd = ["tar", "-cf", archive_name, base_dir]
+    spawn(cmd, dry_run=dry_run)
+    if compress:
+        spawn([compress] + compress_flags[compress] + [archive_name],
+              dry_run=dry_run)
+        return archive_name + compress_ext[compress]
+    else:
+        return archive_name
+# make_tarball ()
+def make_zipfile (base_name, base_dir, verbose=0, dry_run=0):
+    """Create a zip file from all the files under 'base_dir'.  The output
+    zip file will be named 'base_dir' + ".zip".  Uses either the "zipfile"
+    Python module (if available) or the InfoZIP "zip" utility (if installed
+    and found on the default search path).  If neither tool is available,
+    raises DistutilsExecError.  Returns the name of the output zip file.
+    # creating the tarball
+    import tarfile  # late import so Python build itself doesn't break
+    log.info('Creating tar archive')
+    uid = _get_uid(owner)
+    gid = _get_gid(group)
+    def _set_uid_gid(tarinfo):
+        if gid is not None:
+            tarinfo.gid = gid
+            tarinfo.gname = group
+        if uid is not None:
+            tarinfo.uid = uid
+            tarinfo.uname = owner
+        return tarinfo
+    if not dry_run:
+        tar = tarfile.open(archive_name, 'w|%s' % tar_compression[compress])
+        try:
+            tar.add(base_dir, filter=_set_uid_gid)
+        finally:
+            tar.close()
+    # compression using `compress`
+    if compress == 'compress':
+        warn("'compress' will be deprecated.", PendingDeprecationWarning)
+        # the option varies depending on the platform
+        compressed_name = archive_name + compress_ext[compress]
+        if sys.platform == 'win32':
+            cmd = [compress, archive_name, compressed_name]
+        else:
+            cmd = [compress, '-f', archive_name]
+        spawn(cmd, dry_run=dry_run)
+        return compressed_name
+    return archive_name
+def make_zipfile(base_name, base_dir, verbose=0, dry_run=0):
+    """Create a zip file from all the files under 'base_dir'.
+    The output zip file will be named 'base_name' + ".zip".  Uses either the
+    "zipfile" Python module (if available) or the InfoZIP "zip" utility
+    (if installed and found on the default search path).  If neither tool is
+    available, raises DistutilsExecError.  Returns the name of the output zip
+    file.
     """
     try:
 …
         if not dry_run:
             z = zipfile.ZipFile(zip_filename, "w",
                                 compression=zipfile.ZIP_DEFLATED)
+            zip = zipfile.ZipFile(zip_filename, "w",
+                                  compression=zipfile.ZIP_DEFLATED)
             for dirpath, dirnames, filenames in os.walk(base_dir):
 …
                     path = os.path.normpath(os.path.join(dirpath, name))
                     if os.path.isfile(path):
                         z.write(path, path)
+                        zip.write(path, path)
                         log.info("adding '%s'" % path)
             z.close()
+            zip.close()
     return zip_filename
-# make_zipfile ()
 ARCHIVE_FORMATS = {
 …
+    }
+def check_archive_formats (formats):
+def check_archive_formats(formats):
+    """Returns the first format from the 'format' list that is unknown.
+    If all formats are known, returns None
+    """
     for format in formats:
         if format not in ARCHIVE_FORMATS:
             return format
+    else:
+        return None
+def make_archive (base_name, format,
+                  root_dir=None, base_dir=None,
+                  verbose=0, dry_run=0):
+    """Create an archive file (eg. zip or tar).  'base_name' is the name
+    of the file to create, minus any format-specific extension; 'format'
+    is the archive format: one of "zip", "tar", "ztar", or "gztar".
+    return None
+def make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,
+                 dry_run=0, owner=None, group=None):
+    """Create an archive file (eg. zip or tar).
+    'base_name' is the name of the file to create, minus any format-specific
+    extension; 'format' is the archive format: one of "zip", "tar", "ztar",
+    or "gztar".
     'root_dir' is a directory that will be the root directory of the
     archive; ie. we typically chdir into 'root_dir' before creating the
 …
     directories in the archive.  'root_dir' and 'base_dir' both default
     to the current directory.  Returns the name of the archive file.
+    'owner' and 'group' are used when creating a tar archive. By default,
+    uses the current owner and group.
     """
     save_cwd = os.getcwd()
 …
         base_dir = os.curdir
     kwargs = { 'dry_run': dry_run }
+    kwargs = {'dry_run': dry_run}
     try:
 …
     func = format_info[0]
     for (arg,val) in format_info[1]:
+    for arg, val in format_info[1]:
         kwargs[arg] = val
+    filename = apply(func, (base_name, base_dir), kwargs)
+    if root_dir is not None:
+        log.debug("changing back to '%s'", save_cwd)
+        os.chdir(save_cwd)
+    if format != 'zip':
+        kwargs['owner'] = owner
+        kwargs['group'] = group
+    try:
+        filename = func(base_name, base_dir, **kwargs)
+    finally:
+        if root_dir is not None:
+            log.debug("changing back to '%s'", save_cwd)
+            os.chdir(save_cwd)
     return filename
-# make_archive ()

python/vendor/current/Lib/distutils/bcppcompiler.py

-              r2
+              r388
 # WindowsCCompiler!  --GPW
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: bcppcompiler.py 61000 2008-02-23 17:40:11Z christian.heimes $"
+__revision__ = "$Id$"
 import os
+from distutils.errors import \
+     DistutilsExecError, DistutilsPlatformError, \
+     CompileError, LibError, LinkError, UnknownFileError
+from distutils.ccompiler import \
+     CCompiler, gen_preprocess_options, gen_lib_options
+from distutils.errors import (DistutilsExecError, CompileError, LibError,
+                              LinkError, UnknownFileError)
+from distutils.ccompiler import CCompiler, gen_preprocess_options
 from distutils.file_util import write_file
 from distutils.dep_util import newer

python/vendor/current/Lib/distutils/ccompiler.py

-              r2
+              r388
 for the Distutils compiler abstraction model."""
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: ccompiler.py 77425 2010-01-11 22:54:57Z tarek.ziade $"
 import sys, os, re
+from types import *
 from copy import copy
+from distutils.errors import *
+__revision__ = "$Id$"
+import sys
+import os
+import re
+from distutils.errors import (CompileError, LinkError, UnknownFileError,
+                              DistutilsPlatformError, DistutilsModuleError)
 from distutils.spawn import spawn
 from distutils.file_util import move_file
 from distutils.dir_util import mkpath
 from distutils.dep_util import newer_pairwise, newer_group
+from distutils.dep_util import newer_group
 from distutils.util import split_quoted, execute
 from distutils import log
+# following import is for backward compatibility
+from distutils.sysconfig import customize_compiler
 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.set_executable(key, self.executables[key])
+    # __init__ ()
+    def set_executables (self, **args):
+    def set_executables(self, **args):
         """Define the executables (and options for them) that will be run
         to perform the various stages of compilation.  The exact set of
 …
             self.set_executable(key, args[key])
-    # set_executables ()
     def set_executable(self, key, value):
         if type(value) is StringType:
+        if isinstance(value, str):
             setattr(self, key, split_quoted(value))
         else:
             setattr(self, key, value)
+    def _find_macro (self, name):
+    def _find_macro(self, name):
         i = 0
         for defn in self.macros:
 …
                 return i
             i = 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
 …
         """
         for defn in definitions:
             if not (type (defn) is TupleType and
+            if not (isinstance(defn, tuple) and
                     (len (defn) == 1 or
                      (len (defn) == 2 and
                       (type (defn[1]) is StringType or defn[1] is None))) and
                     type (defn[0]) is StringType):
+                      (isinstance(defn[1], str) or defn[1] is None))) and
+                    isinstance(defn[0], str)):
                 raise TypeError, \
                       ("invalid macro definition '%s': " % defn) + \
 …
     # -- 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
 …
         self.macros.append (defn)
+    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
 …
         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
 …
         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
 …
         search by default.
         """
+        self.include_dirs = copy (dirs)
+    def add_library (self, libname):
+        self.include_dirs = dirs[:]
+    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'
 …
         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
 …
         include by default.
         """
         self.libraries = copy (libnames)
     def add_library_dir (self, dir):
+        self.libraries = libnames[:]
+    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
 …
         are supplied to 'add_library_dir()' and/or 'set_library_dirs()'.
         """
         self.library_dirs.append (dir)
     def set_library_dirs (self, dirs):
+        self.library_dirs.append(dir)
+    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)
+    def add_runtime_library_dir (self, dir):
+        self.library_dirs = dirs[:]
+    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)
     def set_runtime_library_dirs (self, dirs):
+        self.runtime_library_dirs.append(dir)
+    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
 …
         default.
         """
+        self.runtime_library_dirs = copy (dirs)
+    def add_link_object (self, object):
+        self.runtime_library_dirs = dirs[:]
+    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
 …
         object.
         """
         self.objects.append (object)
     def set_link_objects (self, objects):
+        self.objects.append(object)
+    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
 …
         libraries).
         """
         self.objects = copy (objects)
+        self.objects = objects[:]
 …
         if outdir is None:
             outdir = self.output_dir
         elif type(outdir) is not StringType:
+        elif not isinstance(outdir, str):
             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:
 …
         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:
 …
         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'
 …
         if output_dir is None:
             output_dir = self.output_dir
         elif type (output_dir) is not StringType:
+        elif not isinstance(output_dir, str):
             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:
 …
         if include_dirs is None:
             include_dirs = self.include_dirs
         elif type (include_dirs) in (ListType, TupleType):
+        elif isinstance(include_dirs, (list, tuple)):
             include_dirs = list (include_dirs) + (self.include_dirs or [])
         else:
 …
         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.
+        Determine the list of object files corresponding to 'sources',
+        and figure out which ones really need to be recompiled.
+        Return a list of all object files and a dictionary telling
+        which source files can be skipped.
+        """
+        # Get the list of expected output (object) files
+        objects = self.object_filenames(sources, output_dir=output_dir)
+        assert len(objects) == len(sources)
+        # Return an empty dict for the "which source files can be skipped"
+        # return value to preserve API compatibility.
+        return objects, {}
+    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
 …
         'objects' and 'output_dir'.
         """
         if type (objects) not in (ListType, TupleType):
+        if not isinstance(objects, (list, tuple)):
             raise TypeError, \
                   "'objects' must be a list or tuple of strings"
 …
         if output_dir is None:
             output_dir = self.output_dir
         elif type (output_dir) is not StringType:
+        elif not isinstance(output_dir, str):
             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
 …
         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:
 …
         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:
 …
         if runtime_library_dirs is None:
             runtime_library_dirs = self.runtime_library_dirs
         elif type (runtime_library_dirs) in (ListType, TupleType):
+        elif isinstance(runtime_library_dirs, (list, tuple)):
             runtime_library_dirs = (list (runtime_library_dirs) +
                                     (self.runtime_library_dirs or []))
 …
         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'.
 …
             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
 …
         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
 …
         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
 …
         pass
     # values for target_desc parameter in link()
     SHARED_OBJECT = "shared_object"
 …
     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.
 …
     # 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'),
 …
+    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,
 …
                   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,
 …
     # 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
 …
         fd, fname = tempfile.mkstemp(".c", funcname, text=True)
         f = os.fdopen(fd, "w")
+        for incl in includes:
+            f.write("""#include "%s"\n""" % incl)
+        f.write("""\
+        try:
+            for incl in includes:
+                f.write("""#include "%s"\n""" % incl)
+            f.write("""\
 main (int argc, char **argv) {
     %s();
+}
 """ % funcname)
+        f.close()
+        finally:
+            f.close()
         try:
             objects = self.compile([fname], include_dirs=include_dirs)
 …
     # -- 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 execute (self, func, args, msg=None, level=1):
+    def warn(self, msg):
+        sys.stderr.write("warning: %s\n" % msg)
+    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 move_file (self, src, dst):
         return move_file (src, dst, dry_run=self.dry_run)
     def mkpath (self, name, mode=0777):
         mkpath (name, mode, 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 mkpath(self, name, mode=0777):
+        mkpath(name, mode, dry_run=self.dry_run)
 …
     ('posix', 'unix'),
     ('nt', 'msvc'),
-    ('mac', 'mwerks'),
+    )
 def get_default_compiler(osname=None, platform=None):
     """ Determine the default compiler to use for the given platform.
 …
                    'bcpp':    ('bcppcompiler', 'BCPPCompiler',
                                "Borland C++ Compiler"),
-                   'mwerks':  ('mwerkscompiler', 'MWerksCompiler',
-                               "MetroWerks CodeWarrior"),
                    'emx':     ('emxccompiler', 'EMXCCompiler',
                                "EMX port of GNU C Compiler for OS/2"),
 …
+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'
 …
     # with classes that expect verbose to be the first positional
     # argument.
     return klass (None, dry_run, force)
 def gen_preprocess_options (macros, include_dirs):
+    return klass(None, dry_run, force)
+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++.
 …
     for macro in macros:
         if not (type (macro) is TupleType and
+        if not (isinstance(macro, tuple) and
 <= len (macro) <= 2):
             raise TypeError, \
 …
     return pp_opts
+# gen_preprocess_options ()
+def gen_lib_options (compiler, library_dirs, runtime_library_dirs, libraries):
+def gen_lib_options(compiler, library_dirs, runtime_library_dirs, libraries):
     """Generate linker options for searching library directories and
+    linking with specific libraries.  'libraries' and 'library_dirs' are,
+    respectively, lists of library names (not filenames!) and search
+    directories.  Returns a list of command-line options suitable for use
+    with some compiler (depending on the two format strings passed in).
+    linking with specific libraries.
+    'libraries' and 'library_dirs' are, respectively, lists of library names
+    (not filenames!) and search directories.  Returns a list of command-line
+    options suitable for use with some compiler (depending on the two format
+    strings passed in).
     """
     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:
             lib_opts = lib_opts + opt
+        opt = compiler.runtime_library_dir_option(dir)
+        if isinstance(opt, list):
+            lib_opts.extend(opt)
         else:
             lib_opts.append (opt)
+            lib_opts.append(opt)
     # XXX it's important that we *not* remove redundant library mentions!
 …
     for lib in libraries:
         (lib_dir, lib_name) = os.path.split (lib)
         if lib_dir:
             lib_file = compiler.find_library_file ([lib_dir], lib_name)
             if lib_file:
                 lib_opts.append (lib_file)
+        lib_dir, lib_name = os.path.split(lib)
+        if lib_dir != '':
+            lib_file = compiler.find_library_file([lib_dir], lib_name)
+            if lib_file is not None:
+                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 ()

python/vendor/current/Lib/distutils/cmd.py

-              r2
+              r388
 """
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: cmd.py 37828 2004-11-10 22:23:15Z loewis $"
+import sys, os, string, re
+from types import *
+from distutils.errors import *
+__revision__ = "$Id$"
+import sys, os, re
+from distutils.errors import DistutilsOptionError
 from distutils import util, dir_util, file_util, archive_util, dep_util
 from distutils import log
 …
     # -- 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
 …
         self.finalized = 0
-    # __init__ ()
     # XXX A more explicit way to customize dry_run would be better.
+    def __getattr__ (self, attr):
+    def __getattr__(self, attr):
         if attr == 'dry_run':
             myval = getattr(self, "_" + attr)
 …
             raise AttributeError, attr
+    def ensure_finalized (self):
+    def ensure_finalized(self):
         if not self.finalized:
             self.finalize_options()
         self.finalized = 1
     # Subclasses must define:
 …
     #     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
 …
               "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
 …
     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()
         print indent + header
+        self.announce(indent + header, level=log.INFO)
         indent = indent + "  "
         for (option, _, _) in self.user_options:
             option = string.translate(option, longopt_xlate)
+            option = option.translate(longopt_xlate)
             if option[-1] == "=":
                 option = option[:-1]
             value = getattr(self, option)
             print indent + "%s = %s" % (option, value)
     def run (self):
+            self.announce(indent + "%s = %s" % (option, value),
+                          level=log.INFO)
+    def run(self):
         """A command's raison d'etre: carry out the action it exists to
         perform, controlled by the options initialized in
 …
         This method must be implemented by all command classes.
         """
         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.
 …
             print msg
             sys.stdout.flush()
 …
     # 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 type(val) is not StringType:
+        elif not isinstance(val, str):
             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
 …
         if val is None:
             return
         elif type(val) is StringType:
+        elif isinstance(val, str):
             setattr(self, option, re.split(r',\s*|\s+', val))
         else:
+            if type(val) is ListType:
+                types = map(type, val)
+                ok = (types == [StringType] * len(val))
+            if isinstance(val, list):
+                # checks if all elements are str
+                ok = 1
+                for element in val:
+                    if not isinstance(element, str):
+                        ok = 0
+                        break
             else:
                 ok = 0
 …
             if not ok:
                 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):
+                    "'%s' must be a list of strings (got %r)" % \
+                        (option, val)
+    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):
 …
                   ("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,
 …
                                    "'%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",
 …
     # -- Convenience methods for commands ------------------------------
     def get_command_name (self):
+    def get_command_name(self):
         if hasattr(self, 'command_name'):
             return self.command_name
 …
             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
 …
     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
 …
     # XXX rename to 'get_reinitialized_command()'? (should do the
     # same in dist.py, if so)
     def reinitialize_command (self, command, reinit_subcommands=0):
+    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
 …
         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
 …
     # -- External world manipulation -----------------------------------
+    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 warn(self, msg):
+        log.warn("warning: %s: %s\n" %
+                (self.get_command_name(), msg))
+    def execute(self, func, args, msg=None, level=1):
         util.execute(func, args, msg, dry_run=self.dry_run)
+    def mkpath (self, name, mode=0777):
+    def mkpath(self, name, mode=0777):
         dir_util.mkpath(name, mode, dry_run=self.dry_run)
+    def copy_file (self, infile, outfile,
+    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
 …
             dry_run=self.dry_run)
+    def copy_tree (self, infile, outfile,
+    def copy_tree(self, infile, outfile,
                    preserve_mode=1, preserve_times=1, preserve_symlinks=0,
                    level=1):
 …
     def move_file (self, src, dst, level=1):
         """Move a file respectin dry-run flag."""
+        """Move a file respecting dry-run flag."""
         return file_util.move_file(src, dst, 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_file (self, infiles, outfile, func, args,
                    exec_msg=None, skip_msg=None, level=1):
+    def make_archive(self, base_name, format, root_dir=None, base_dir=None,
+                     owner=None, group=None):
+        return archive_util.make_archive(base_name, format, root_dir,
+                                         base_dir, dry_run=self.dry_run,
+                                         owner=owner, group=group)
+    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
 …
         timestamp checks.
         """
+        if skip_msg is None:
+            skip_msg = "skipping %s (inputs unchanged)" % outfile
+        # Allow 'infiles' to be a single string
+        if isinstance(infiles, str):
+            infiles = (infiles,)
+        elif not isinstance(infiles, (list, tuple)):
+            raise TypeError, \
+                  "'infiles' must be a string, or a list or tuple of strings"
         if exec_msg is None:
             exec_msg = "generating %s from %s" % \
+                       (outfile, string.join(infiles, ', '))
+        if skip_msg is None:
+            skip_msg = "skipping %s (inputs unchanged)" % outfile
+        # Allow 'infiles' to be a single string
+        if type(infiles) is StringType:
+            infiles = (infiles,)
+        elif type(infiles) not in (ListType, TupleType):
+            raise TypeError, \
+                  "'infiles' must be a string, or a list or tuple of strings"
+                       (outfile, ', '.join(infiles))
         # 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):
+        if self.force or dep_util.newer_group(infiles, outfile):
             self.execute(func, args, exec_msg, level)
 …
         else:
             log.debug(skip_msg)
-    # make_file ()
-# class Command
 # XXX 'install_misc' class not currently used -- it was the base class for
 …
 # 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.
 …
         self.outfiles = []
     def _install_dir_from (self, dirname):
+    def _install_dir_from(self, dirname):
         self.set_undefined_options('install', (dirname, 'install_dir'))
     def _copy_files (self, filelist):
+    def _copy_files(self, filelist):
         self.outfiles = []
         if not filelist:
 …
             self.outfiles.append(os.path.join(self.install_dir, f))
     def get_outputs (self):
+    def get_outputs(self):
         return self.outfiles
-if __name__ == "__main__":
-    print "ok"

python/vendor/current/Lib/distutils/command/init.py

-              r2
+              r388
 commands."""
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: __init__.py 71272 2009-04-05 21:21:05Z georg.brandl $"
+__revision__ = "$Id$"
 __all__ = ['build',
 …
            'bdist_wininst',
            'upload',
+           'check',
            # These two are reserved for future use:
            #'bdist_sdux',

python/vendor/current/Lib/distutils/command/bdist.py

-              r2
+              r388
 distribution)."""
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: bdist.py 62197 2008-04-07 01:53:39Z mark.hammond $"
+__revision__ = "$Id$"
 import os
+from types import *
+from distutils.util import get_platform
 from distutils.core import Command
+from distutils.errors import *
+from distutils.util import get_platform
+from distutils.errors import DistutilsPlatformError, DistutilsOptionError
 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,
 …
 class bdist (Command):
+class bdist(Command):
     description = "create a built (binary) distribution"
 …
                     ('skip-build', None,
                      "skip rebuilding everything (for testing/debugging)"),
+                    ('owner=', 'u',
+                     "Owner name used when creating a tar file"
+                     " [default: current user]"),
+                    ('group=', 'g',
+                     "Group name used when creating a tar file"
+                     " [default: current group]"),
+                   ]
 …
     # The following commands do not take a format option from bdist
+    no_format_option = ('bdist_rpm',
+                        #'bdist_sdux', 'bdist_pkgtool'
+                        )
+    no_format_option = ('bdist_rpm',)
     # This won't do in reality: will need to distinguish RPM-ish Linux,
     # Debian-ish Linux, Solaris, FreeBSD, ..., Windows, Mac OS.
     default_format = { 'posix': 'gztar',
                        'nt': 'zip',
                        'os2': 'zip', }
+    default_format = {'posix': 'gztar',
+                      'nt': 'zip',
+                      'os2': 'zip'}
     # Establish the preferred order (for the --help-formats option).
     format_commands = ['rpm', 'gztar', 'bztar', 'ztar', 'tar',
+                       'wininst', 'zip',
+                       #'pkgtool', 'sdux'
+                       ]
+                       'wininst', 'zip', 'msi']
     # And the real information.
+    format_command = { 'rpm':   ('bdist_rpm',  "RPM distribution"),
+                       'zip':   ('bdist_dumb', "ZIP file"),
+                       'gztar': ('bdist_dumb', "gzip'ed tar file"),
+                       'bztar': ('bdist_dumb', "bzip2'ed tar file"),
+                       'ztar':  ('bdist_dumb', "compressed tar file"),
+                       'tar':   ('bdist_dumb', "tar file"),
+                       'wininst': ('bdist_wininst',
+                                   "Windows executable installer"),
+                       'zip':   ('bdist_dumb', "ZIP file"),
+                       #'pkgtool': ('bdist_pkgtool',
+                       #            "Solaris pkgtool distribution"),
+                       #'sdux':  ('bdist_sdux', "HP-UX swinstall depot"),
+    format_command = {'rpm':   ('bdist_rpm',  "RPM distribution"),
+                      'gztar': ('bdist_dumb', "gzip'ed tar file"),
+                      'bztar': ('bdist_dumb', "bzip2'ed tar file"),
+                      'ztar':  ('bdist_dumb', "compressed tar file"),
+                      'tar':   ('bdist_dumb', "tar file"),
+                      'wininst': ('bdist_wininst',
+                                  "Windows executable installer"),
+                      'zip':   ('bdist_dumb', "ZIP file"),
+                      'msi':   ('bdist_msi',  "Microsoft Installer")
+                      }
     def initialize_options (self):
+    def initialize_options(self):
         self.bdist_base = None
         self.plat_name = None
 …
         self.dist_dir = None
         self.skip_build = 0
+        self.group = None
+        self.owner = None
+    # 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.dist_dir = "dist"
+    # finalize_options()
+    def run (self):
+    def run(self):
         # Figure out which sub-commands we need to run.
         commands = []
 …
                 sub_cmd.format = self.formats[i]
+            # passing the owner and group names for tar archiving
+            if cmd_name == 'bdist_dumb':
+                sub_cmd.owner = self.owner
+                sub_cmd.group = self.group
             # If we're going to need to run this command again, tell it to
             # keep its temporary files around so subsequent runs go faster.
 …
                 sub_cmd.keep_temp = 1
             self.run_command(cmd_name)
-    # run()
-# class bdist

python/vendor/current/Lib/distutils/command/bdist_dumb.py

-              r2
+              r388
 $exec_prefix)."""
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: bdist_dumb.py 61000 2008-02-23 17:40:11Z christian.heimes $"
+__revision__ = "$Id$"
 import os
+from sysconfig import get_python_version
+from distutils.util import get_platform
 from distutils.core import Command
-from distutils.util import get_platform
 from distutils.dir_util import remove_tree, ensure_relative
+from distutils.errors import *
+from distutils.sysconfig import get_python_version
+from distutils.errors import DistutilsPlatformError
 from distutils import log
 class bdist_dumb (Command):
     description = "create a \"dumb\" built distribution"
+    description = 'create a "dumb" built distribution'
     user_options = [('bdist-dir=', 'd',
 …
                      "build the archive using relative paths"
                      "(default: false)"),
+                    ('owner=', 'u',
+                     "Owner name used when creating a tar file"
+                     " [default: current user]"),
+                    ('group=', 'g',
+                     "Group name used when creating a tar file"
+                     " [default: current group]"),
+                   ]
 …
         self.keep_temp = 0
         self.dist_dir = None
         self.skip_build = 0
+        self.skip_build = None
         self.relative = 0
+        self.owner = None
+        self.group = 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.set_undefined_options('bdist',
                                    ('dist_dir', 'dist_dir'),
+                                   ('plat_name', 'plat_name'))
+                                   ('plat_name', 'plat_name'),
+                                   ('skip_build', 'skip_build'))
+    # finalize_options()
+    def run (self):
+    def run(self):
         if not self.skip_build:
             self.run_command('build')
 …
         # Make the archive
         filename = self.make_archive(pseudoinstall_root,
+                                     self.format, root_dir=archive_root)
+                                     self.format, root_dir=archive_root,
+                                     owner=self.owner, group=self.group)
         if self.distribution.has_ext_modules():
             pyversion = get_python_version()
 …
         if not self.keep_temp:
             remove_tree(self.bdist_dir, dry_run=self.dry_run)
-    # run()
-# class bdist_dumb

python/vendor/current/Lib/distutils/command/bdist_msi.py

-              r2
+              r388
 # -*- coding: iso-8859-1 -*-
 # Copyright (C) 2005, 2006 Martin v. Löwis
+# Copyright (C) 2005, 2006 Martin von Löwis
 # Licensed to PSF under a Contributor Agreement.
 # The bdist_wininst command proper
 …
 Implements the bdist_msi command.
 """
 import sys, os
+from sysconfig import get_python_version
 from distutils.core import Command
 from distutils.dir_util import remove_tree
-from distutils.sysconfig import get_python_version
 from distutils.version import StrictVersion
 from distutils.errors import DistutilsOptionError
+from distutils import log
 from distutils.util import get_platform
+from distutils import log
 import msilib
 from msilib import schema, sequence, text
 …
         Dialog.__init__(self, *args)
         ruler = self.h - 36
-        bmwidth = 152*ruler/328
         #if kw.get("bitmap", True):
         #    self.bitmap("Bitmap", 0, 0, bmwidth, ruler, "PythonWin")
 …
                        'skip-build']
+    all_versions = ['2.0', '2.1', '2.2', '2.3', '2.4',
+                    '2.5', '2.6', '2.7', '2.8', '2.9',
+                    '3.0', '3.1', '3.2', '3.3', '3.4',
+                    '3.5', '3.6', '3.7', '3.8', '3.9']
+    other_version = 'X'
     def initialize_options (self):
         self.bdist_dir = None
 …
         self.target_version = None
         self.dist_dir = None
         self.skip_build = 0
+        self.skip_build = None
         self.install_script = None
         self.pre_install_script = None
+        self.versions = None
     def finalize_options (self):
+        self.set_undefined_options('bdist', ('skip_build', 'skip_build'))
         if self.bdist_dir is None:
             bdist_base = self.get_finalized_command('bdist').bdist_base
             self.bdist_dir = os.path.join(bdist_base, 'msi')
         short_version = get_python_version()
+        if (not self.target_version) and self.distribution.has_ext_modules():
+            self.target_version = short_version
         if self.target_version:
+            self.versions = [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'" \
+                      "target version can only be %s, or the '--skip-build'" \
                       " option must be specified" % (short_version,)
         else:
             self.target_version = short_version
+            self.versions = list(self.all_versions)
         self.set_undefined_options('bdist',
 …
         # it sorts together with the other Python packages
         # in Add-Remove-Programs (APR)
+        product_name = "Python %s %s" % (self.target_version,
+                       self.distribution.get_fullname())
+        fullname = self.distribution.get_fullname()
+        if self.target_version:
+            product_name = "Python %s %s" % (self.target_version, fullname)
+        else:
+            product_name = "Python %s" % (fullname)
         self.db = msilib.init_database(installer_name, schema,
                 product_name, msilib.gen_uuid(),
 …
         if hasattr(self.distribution, 'dist_files'):
+            self.distribution.dist_files.append(('bdist_msi', self.target_version, fullname))
+            tup = 'bdist_msi', self.target_version or 'any', fullname
+            self.distribution.dist_files.append(tup)
         if not self.keep_temp:
 …
         db = self.db
         cab = msilib.CAB("distfiles")
-        f = Feature(db, "default", "Default Feature", "Everything", 1, directory="TARGETDIR")
-        f.set_current()
         rootdir = os.path.abspath(self.bdist_dir)
         root = Directory(db, cab, None, rootdir, "TARGETDIR", "SourceDir")
+        f = Feature(db, "Python", "Python", "Everything",
+, 1, directory="TARGETDIR")
+        items = [(f, root, '')]
+        for version in self.versions + [self.other_version]:
+            target = "TARGETDIR" + version
+            name = default = "Python" + version
+            desc = "Everything"
+            if version is self.other_version:
+                title = "Python from another location"
+                level = 2
+            else:
+                title = "Python %s from registry" % version
+                level = 1
+            f = Feature(db, name, title, desc, 1, level, directory=target)
+            dir = Directory(db, cab, root, rootdir, target, default)
+            items.append((f, dir, version))
         db.Commit()
+        todo = [root]
+        while todo:
+            dir = todo.pop()
+            for file in os.listdir(dir.absolute):
+                afile = os.path.join(dir.absolute, file)
+                if os.path.isdir(afile):
+                    newdir = Directory(db, cab, dir, file, file, "%s|%s" % (dir.make_short(file), file))
+                    todo.append(newdir)
+                else:
+                    key = dir.add_file(file)
+                    if file==self.install_script:
+                        if self.install_script_key:
+                            raise DistutilsOptionError, "Multiple files with name %s" % file
+                        self.install_script_key = '[#%s]' % key
+        seen = {}
+        for feature, dir, version in items:
+            todo = [dir]
+            while todo:
+                dir = todo.pop()
+                for file in os.listdir(dir.absolute):
+                    afile = os.path.join(dir.absolute, file)
+                    if os.path.isdir(afile):
+                        short = "%s|%s" % (dir.make_short(file), file)
+                        default = file + version
+                        newdir = Directory(db, cab, dir, file, default, short)
+                        todo.append(newdir)
+                    else:
+                        if not dir.component:
+                            dir.start_component(dir.logical, feature, 0)
+                        if afile not in seen:
+                            key = seen[afile] = dir.add_file(file)
+                            if file==self.install_script:
+                                if self.install_script_key:
+                                    raise DistutilsOptionError(
+                                          "Multiple files with name %s" % file)
+                                self.install_script_key = '[#%s]' % key
+                        else:
+                            key = seen[afile]
+                            add_data(self.db, "DuplicateFile",
+                                [(key + version, dir.component, key, None, dir.logical)])
+            db.Commit()
         cab.commit(db)
     def add_find_python(self):
         """Adds code to the installer to compute the location of Python.
+        Properties PYTHON.MACHINE, PYTHON.USER, PYTHONDIR and PYTHON will be set
+        in both the execute and UI sequences; PYTHONDIR will be set from
+        PYTHON.USER if defined, else from PYTHON.MACHINE.
+        PYTHON is PYTHONDIR\python.exe"""
+        install_path = r"SOFTWARE\Python\PythonCore\%s\InstallPath" % self.target_version
+        if msilib.Win64:
+            # type: msidbLocatorTypeRawValue + msidbLocatorType64bit
+            Type = 2+16
+        else:
+            Type = 2
+        add_data(self.db, "RegLocator",
+                [("python.machine", 2, install_path, None, Type),
+                 ("python.user", 1, install_path, None, Type)])
+        add_data(self.db, "AppSearch",
+                [("PYTHON.MACHINE", "python.machine"),
+                 ("PYTHON.USER", "python.user")])
+        add_data(self.db, "CustomAction",
+                [("PythonFromMachine", 51+256, "PYTHONDIR", "[PYTHON.MACHINE]"),
+                 ("PythonFromUser", 51+256, "PYTHONDIR", "[PYTHON.USER]"),
+                 ("PythonExe", 51+256, "PYTHON", "[PYTHONDIR]\\python.exe"),
+                 ("InitialTargetDir", 51+256, "TARGETDIR", "[PYTHONDIR]")])
+        add_data(self.db, "InstallExecuteSequence",
+                [("PythonFromMachine", "PYTHON.MACHINE", 401),
+                 ("PythonFromUser", "PYTHON.USER", 402),
+                 ("PythonExe", None, 403),
+                 ("InitialTargetDir", 'TARGETDIR=""', 404),
+                ])
+        add_data(self.db, "InstallUISequence",
+                [("PythonFromMachine", "PYTHON.MACHINE", 401),
+                 ("PythonFromUser", "PYTHON.USER", 402),
+                 ("PythonExe", None, 403),
+                 ("InitialTargetDir", 'TARGETDIR=""', 404),
+                ])
+        Properties PYTHON.MACHINE.X.Y and PYTHON.USER.X.Y will be set from the
+        registry for each version of Python.
+        Properties TARGETDIRX.Y will be set from PYTHON.USER.X.Y if defined,
+        else from PYTHON.MACHINE.X.Y.
+        Properties PYTHONX.Y will be set to TARGETDIRX.Y\\python.exe"""
+        start = 402
+        for ver in self.versions:
+            install_path = r"SOFTWARE\Python\PythonCore\%s\InstallPath" % ver
+            machine_reg = "python.machine." + ver
+            user_reg = "python.user." + ver
+            machine_prop = "PYTHON.MACHINE." + ver
+            user_prop = "PYTHON.USER." + ver
+            machine_action = "PythonFromMachine" + ver
+            user_action = "PythonFromUser" + ver
+            exe_action = "PythonExe" + ver
+            target_dir_prop = "TARGETDIR" + ver
+            exe_prop = "PYTHON" + ver
+            if msilib.Win64:
+                # type: msidbLocatorTypeRawValue + msidbLocatorType64bit
+                Type = 2+16
+            else:
+                Type = 2
+            add_data(self.db, "RegLocator",
+                    [(machine_reg, 2, install_path, None, Type),
+                     (user_reg, 1, install_path, None, Type)])
+            add_data(self.db, "AppSearch",
+                    [(machine_prop, machine_reg),
+                     (user_prop, user_reg)])
+            add_data(self.db, "CustomAction",
+                    [(machine_action, 51+256, target_dir_prop, "[" + machine_prop + "]"),
+                     (user_action, 51+256, target_dir_prop, "[" + user_prop + "]"),
+                     (exe_action, 51+256, exe_prop, "[" + target_dir_prop + "]\\python.exe"),
+                    ])
+            add_data(self.db, "InstallExecuteSequence",
+                    [(machine_action, machine_prop, start),
+                     (user_action, user_prop, start + 1),
+                     (exe_action, None, start + 2),
+                    ])
+            add_data(self.db, "InstallUISequence",
+                    [(machine_action, machine_prop, start),
+                     (user_action, user_prop, start + 1),
+                     (exe_action, None, start + 2),
+                    ])
+            add_data(self.db, "Condition",
+                    [("Python" + ver, 0, "NOT TARGETDIR" + ver)])
+            start += 4
+            assert start < 500
     def add_scripts(self):
         if self.install_script:
+            add_data(self.db, "CustomAction",
+                    [("install_script", 50, "PYTHON", self.install_script_key)])
+            add_data(self.db, "InstallExecuteSequence",
+                    [("install_script", "NOT Installed", 6800)])
+            start = 6800
+            for ver in self.versions + [self.other_version]:
+                install_action = "install_script." + ver
+                exe_prop = "PYTHON" + ver
+                add_data(self.db, "CustomAction",
+                        [(install_action, 50, exe_prop, self.install_script_key)])
+                add_data(self.db, "InstallExecuteSequence",
+                        [(install_action, "&Python%s=3" % ver, start)])
+                start += 1
+        # XXX pre-install scripts are currently refused in finalize_options()
+        #     but if this feature is completed, it will also need to add
+        #     entries for each version as the above code does
         if self.pre_install_script:
             scriptfn = os.path.join(self.bdist_dir, "preinstall.bat")
 …
         modal = 3      # visible | modal
         modeless = 1   # visible
-        track_disk_space = 32
         # UI customization properties
 …
                   ("WhichUsersDlg", "Privileged and not Windows9x and not Installed", 141),
                   # In the user interface, assume all-users installation if privileged.
                   ("SelectDirectoryDlg", "Not Installed", 1230),
+                  ("SelectFeaturesDlg", "Not Installed", 1230),
                   # XXX no support for resume installations yet
                   #("ResumeDlg", "Installed AND (RESUME OR Preselected)", 1240),
 …
         #####################################################################
         # Target directory selection
         seldlg = PyDialog(db, "SelectDirectoryDlg", x, y, w, h, modal, title,
+        # Feature (Python directory) selection
+        seldlg = PyDialog(db, "SelectFeaturesDlg", x, y, w, h, modal, title,
                         "Next", "Next", "Cancel")
         seldlg.title("Select Destination Directory")
         version = sys.version[:3]+" "
         seldlg.text("Hint", 15, 30, 300, 40, 3,
                 "The destination directory should contain a Python %sinstallation" % version)
+        seldlg.title("Select Python Installations")
+        seldlg.text("Hint", 15, 30, 300, 20, 3,
+                    "Select the Python locations where %s should be installed."
+                    % self.distribution.get_fullname())
         seldlg.back("< Back", None, active=0)
         c = seldlg.next("Next >", "Cancel")
+        c.event("SetTargetPath", "TARGETDIR", ordering=1)
+        c.event("SpawnWaitDialog", "WaitForCostingDlg", ordering=2)
+        c.event("EndDialog", "Return", ordering=3)
+        c = seldlg.cancel("Cancel", "DirectoryCombo")
+        order = 1
+        c.event("[TARGETDIR]", "[SourceDir]", ordering=order)
+        for version in self.versions + [self.other_version]:
+            order += 1
+            c.event("[TARGETDIR]", "[TARGETDIR%s]" % version,
+                    "FEATURE_SELECTED AND &Python%s=3" % version,
+                    ordering=order)
+        c.event("SpawnWaitDialog", "WaitForCostingDlg", ordering=order + 1)
+        c.event("EndDialog", "Return", ordering=order + 2)
+        c = seldlg.cancel("Cancel", "Features")
         c.event("SpawnDialog", "CancelDlg")
+        seldlg.control("DirectoryCombo", "DirectoryCombo", 15, 70, 272, 80, 393219,
+                       "TARGETDIR", None, "DirectoryList", None)
+        seldlg.control("DirectoryList", "DirectoryList", 15, 90, 308, 136, 3, "TARGETDIR",
+                       None, "PathEdit", None)
+        seldlg.control("PathEdit", "PathEdit", 15, 230, 306, 16, 3, "TARGETDIR", None, "Next", None)
+        c = seldlg.pushbutton("Up", 306, 70, 18, 18, 3, "Up", None)
+        c.event("DirectoryListUp", "0")
+        c = seldlg.pushbutton("NewDir", 324, 70, 30, 18, 3, "New", None)
+        c.event("DirectoryListNew", "0")
+        c = seldlg.control("Features", "SelectionTree", 15, 60, 300, 120, 3,
+                           "FEATURE", None, "PathEdit", None)
+        c.event("[FEATURE_SELECTED]", "1")
+        ver = self.other_version
+        install_other_cond = "FEATURE_SELECTED AND &Python%s=3" % ver
+        dont_install_other_cond = "FEATURE_SELECTED AND &Python%s<>3" % ver
+        c = seldlg.text("Other", 15, 200, 300, 15, 3,
+                        "Provide an alternate Python location")
+        c.condition("Enable", install_other_cond)
+        c.condition("Show", install_other_cond)
+        c.condition("Disable", dont_install_other_cond)
+        c.condition("Hide", dont_install_other_cond)
+        c = seldlg.control("PathEdit", "PathEdit", 15, 215, 300, 16, 1,
+                           "TARGETDIR" + ver, None, "Next", None)
+        c.condition("Enable", install_other_cond)
+        c.condition("Show", install_other_cond)
+        c.condition("Disable", dont_install_other_cond)
+        c.condition("Hide", dont_install_other_cond)
         #####################################################################
 …
     def get_installer_filename(self, fullname):
         # Factored out to allow overriding in subclasses
+        base_name = "%s.%s-py%s.msi" % (fullname, self.plat_name,
+                                        self.target_version)
+        if self.target_version:
+            base_name = "%s.%s-py%s.msi" % (fullname, self.plat_name,
+                                            self.target_version)
+        else:
+            base_name = "%s.%s.msi" % (fullname, self.plat_name)
         installer_name = os.path.join(self.dist_dir, base_name)
         return installer_name

python/vendor/current/Lib/distutils/command/bdist_rpm.py

-              r2
+              r388
 distributions)."""
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: bdist_rpm.py 61000 2008-02-23 17:40:11Z christian.heimes $"
 import sys, os, string
+from types import *
+__revision__ = "$Id$"
+import sys
+import os
+import string
 from distutils.core import Command
 from distutils.debug import DEBUG
-from distutils.util import get_platform
 from distutils.file_util import write_file
 from distutils.errors import *
+from distutils.sysconfig import get_python_version
+from distutils.errors import (DistutilsOptionError, DistutilsPlatformError,
+                              DistutilsFileError, DistutilsExecError)
 from distutils import log
 …
         ('force-arch=', None,
          "Force an architecture onto the RPM build process"),
+       ]
+        ('quiet', 'q',
+         "Run the INSTALL phase of RPM building in quiet mode"),
+        ]
     boolean_options = ['keep-temp', 'use-rpm-opt-flags', 'rpm3-mode',
                        'no-autoreq']
+                       'no-autoreq', 'quiet']
     negative_opt = {'no-keep-temp': 'keep-temp',
 …
         self.force_arch = None
+        self.quiet = 0
     # initialize_options()
 …
         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:
 …
            os.path.exists('/bin/rpmbuild'):
             rpm_cmd = ['rpmbuild']
         if self.source_only: # what kind of RPMs?
             rpm_cmd.append('-bs')
 …
         if not self.keep_temp:
             rpm_cmd.append('--clean')
+        if self.quiet:
+            rpm_cmd.append('--quiet')
         rpm_cmd.append(spec_path)
         # Determine the binary rpm names that should be built out of this spec
 …
         out = os.popen(q_cmd)
+        binary_rpms = []
+        source_rpm = None
+        while 1:
+            line = out.readline()
+            if not line:
+                break
+            l = string.split(string.strip(line))
+            assert(len(l) == 2)
+            binary_rpms.append(l[1])
+            # The source rpm is named after the first entry in the spec file
+            if source_rpm is None:
+                source_rpm = l[0]
+        status = out.close()
+        if status:
+            raise DistutilsExecError("Failed to execute: %s" % repr(q_cmd))
+        try:
+            binary_rpms = []
+            source_rpm = None
+            while 1:
+                line = out.readline()
+                if not line:
+                    break
+                l = string.split(string.strip(line))
+                assert(len(l) == 2)
+                binary_rpms.append(l[1])
+                # The source rpm is named after the first entry in the spec file
+                if source_rpm is None:
+                    source_rpm = l[0]
+            status = out.close()
+            if status:
+                raise DistutilsExecError("Failed to execute: %s" % repr(q_cmd))
+        finally:
+            out.close()
         self.spawn(rpm_cmd)
         if not self.dry_run:
+            if self.distribution.has_ext_modules():
+                pyversion = get_python_version()
+            else:
+                pyversion = 'any'
             if not self.binary_only:
                 srpm = os.path.join(rpm_dir['SRPMS'], source_rpm)
                 assert(os.path.exists(srpm))
                 self.move_file(srpm, self.dist_dir)
+                filename = os.path.join(self.dist_dir, source_rpm)
+                self.distribution.dist_files.append(
+                    ('bdist_rpm', pyversion, filename))
             if not self.source_only:
 …
                     if os.path.exists(rpm):
                         self.move_file(rpm, self.dist_dir)
+                        filename = os.path.join(self.dist_dir,
+                                                os.path.basename(rpm))
+                        self.distribution.dist_files.append(
+                            ('bdist_rpm', pyversion, filename))
     # run()
 …
                       ):
             val = getattr(self, string.lower(field))
             if type(val) is ListType:
+            if isinstance(val, list):
                 spec_file.append('%s: %s' % (field, string.join(val)))
             elif val is not None:
 …
         # are just text that we drop in as-is.  Hmmm.
+        install_cmd = ('%s install -O1 --root=$RPM_BUILD_ROOT '
+                       '--record=INSTALLED_FILES') % def_setup_call
         script_options = [
             ('prep', 'prep_script', "%setup -n %{name}-%{unmangled_version}"),
             ('build', 'build_script', def_build),
+            ('install', 'install_script',
+             ("%s install "
+              "--root=$RPM_BUILD_ROOT "
+              "--record=INSTALLED_FILES") % def_setup_call),
+            ('install', 'install_script', install_cmd),
             ('clean', 'clean_script', "rm -rf $RPM_BUILD_ROOT"),
             ('verifyscript', 'verify_script', None),

python/vendor/current/Lib/distutils/command/bdist_wininst.py

-              r2
+              r388
 exe-program."""
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: bdist_wininst.py 71422 2009-04-09 22:48:19Z tarek.ziade $"
+import sys, os, string
+__revision__ = "$Id$"
+import sys
+import os
+import string
+from sysconfig import get_python_version
 from distutils.core import Command
+from distutils.dir_util import remove_tree
+from distutils.errors import DistutilsOptionError, DistutilsPlatformError
+from distutils import log
 from distutils.util import get_platform
-from distutils.dir_util import create_tree, remove_tree
-from distutils.errors import *
-from distutils.sysconfig import get_python_version
-from distutils import log
 class bdist_wininst (Command):
 …
         self.bitmap = None
         self.title = None
         self.skip_build = 0
+        self.skip_build = None
         self.install_script = None
         self.pre_install_script = None
 …
     def finalize_options (self):
+        self.set_undefined_options('bdist', ('skip_build', 'skip_build'))
         if self.bdist_dir is None:
             if self.skip_build and self.plat_name:
 …
             bdist_base = self.get_finalized_command('bdist').bdist_base
             self.bdist_dir = os.path.join(bdist_base, 'wininst')
         if not self.target_version:
             self.target_version = ""
         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, \
                       "target version can only be %s, or the '--skip_build'" \
+                      "target version can only be %s, or the '--skip-build'" \
                       " option must be specified" % (short_version,)
             self.target_version = short_version
 …
         filename = os.path.join(directory, "wininst-%.1f%s.exe" % (bv, sfix))
+        return open(filename, "rb").read()
+        f = open(filename, "rb")
+        try:
+            return f.read()
+        finally:
+            f.close()
 # class bdist_wininst

python/vendor/current/Lib/distutils/command/build.py

-              r2
+              r388
 Implements the Distutils 'build' command."""
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: build.py 62197 2008-04-07 01:53:39Z mark.hammond $"
+__revision__ = "$Id$"
 import sys, os
+from distutils.util import get_platform
 from distutils.core import Command
 from distutils.errors import DistutilsOptionError
-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"
 …
+        ]
     def initialize_options (self):
+    def initialize_options(self):
         self.build_base = 'build'
         # these are decided only after 'build_base' has its final value
 …
         self.executable = None
+    def finalize_options (self):
+    def finalize_options(self):
         if self.plat_name is None:
             self.plat_name = get_platform()
 …
         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
 …
         for cmd_name in self.get_sub_commands():
             self.run_command(cmd_name)
     # -- Predicates for the sub-command list ---------------------------
 …
         return self.distribution.has_scripts()
     sub_commands = [('build_py',      has_pure_modules),
                     ('build_clib',    has_c_libraries),
 …
                     ('build_scripts', has_scripts),
+                   ]
-# class build

python/vendor/current/Lib/distutils/command/build_clib.py

-              r2
+              r388
 module."""
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: build_clib.py 37828 2004-11-10 22:23:15Z loewis $"
+__revision__ = "$Id$"
 …
 # cut 'n paste.  Sigh.
+import os, string
+from types import *
+import os
 from distutils.core import Command
 from distutils.errors import *
+from distutils.errors import DistutilsSetupError
 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"
     user_options = [
         ('build-clib', 'b',
+        ('build-clib=', 'b',
          "directory to build C/C++ libraries to"),
         ('build-temp', 't',
+        ('build-temp=', 't',
          "directory to put temporary build by-products"),
         ('debug', 'g',
 …
+        ]
     def initialize_options (self):
+    def initialize_options(self):
         self.build_clib = None
         self.build_temp = None
 …
         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
 …
         if self.include_dirs is None:
             self.include_dirs = self.distribution.include_dirs or []
+        if type(self.include_dirs) is StringType:
+            self.include_dirs = string.split(self.include_dirs,
+                                             os.pathsep)
+        if isinstance(self.include_dirs, str):
+            self.include_dirs = self.include_dirs.split(os.pathsep)
         # 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
 …
         self.build_libraries(self.libraries)
+    # run()
+    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
+-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:
+    def check_library_list(self, libraries):
+        """Ensure that the list of libraries is valid.
+        `library` is presumably provided as a command option 'libraries'.
+        This method checks that 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.
+        """
+        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:
+            if not isinstance(lib, tuple) and len(lib) != 2:
                 raise DistutilsSetupError, \
                       "each element of 'libraries' must a 2-tuple"
+            if type(lib[0]) is not StringType:
+            name, build_info = lib
+            if not isinstance(name, str):
                 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]):
+            if '/' in name or (os.sep != '/' and os.sep in name):
                 raise DistutilsSetupError, \
                       ("bad library name '%s': " +
 …
                       lib[0]
             if type(lib[1]) is not DictionaryType:
+            if not isinstance(build_info, dict):
                 raise DistutilsSetupError, \
                       "second element of each tuple in 'libraries' " + \
                       "must be a dictionary (build info)"
+        # for lib
+    # check_library_list ()
+    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
 …
         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) ):
+            if sources is None or not isinstance(sources, (list, tuple)):
                 raise DistutilsSetupError, \
                       ("in 'libraries' option (library '%s'), "
 …
             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):
+            if sources is None or not isinstance(sources, (list, tuple)):
                 raise DistutilsSetupError, \
                       ("in 'libraries' option (library '%s'), " +
 …
                                             output_dir=self.build_clib,
                                             debug=self.debug)
-        # for libraries
-    # build_libraries ()
-# class build_lib

python/vendor/current/Lib/distutils/command/build_ext.py

-              r2
+              r388
 # This module should be kept compatible with Python 2.1.
 __revision__ = "$Id: build_ext.py 75395 2009-10-13 21:17:34Z tarek.ziade $"
+__revision__ = "$Id$"
 import sys, os, string, re
 …
             self.include_dirs.append(plat_py_include)
+        if isinstance(self.libraries, str):
+            self.libraries = [self.libraries]
+        self.ensure_string_list('libraries')
         # Life is easier if we're not forever checking for None, so
 …
             elif MSVC_VERSION == 8:
                 self.library_dirs.append(os.path.join(sys.exec_prefix,
                                          'PC', 'VS8.0', 'win32release'))
+                                         'PC', 'VS8.0'))
             elif MSVC_VERSION == 7:
                 self.library_dirs.append(os.path.join(sys.exec_prefix,
 …
                 self.library_dirs.append('.')
         # for extensions under Linux or Solaris with a shared Python library,
+        # For building extensions with a shared Python library,
         # Python's library directory must be appended to library_dirs
+        sysconfig.get_config_var('Py_ENABLE_SHARED')
+        if ((sys.platform.startswith('linux') or sys.platform.startswith('gnu')
+             or sys.platform.startswith('sunos'))
+            and sysconfig.get_config_var('Py_ENABLE_SHARED')):
+        # See Issues: #1600860, #4366
+        if (sysconfig.get_config_var('Py_ENABLE_SHARED')):
             if sys.executable.startswith(os.path.join(sys.exec_prefix, "bin")):
                 # building third party extensions
 …
         so_ext = get_config_var('SO')
         if os.name == 'nt' and self.debug:
             return apply(os.path.join, ext_path) + '_d' + so_ext
+            return os.path.join(*ext_path) + '_d' + so_ext
         return os.path.join(*ext_path) + so_ext
 …
             # Don't use the default code below
             return ext.libraries
+        elif sys.platform[:3] == 'aix':
+            # Don't use the default code below
+            return ext.libraries
         else:
             from distutils import sysconfig

python/vendor/current/Lib/distutils/command/build_py.py

-              r2
+              r388
 Implements the Distutils 'build_py' command."""
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: build_py.py 77376 2010-01-08 23:27:23Z tarek.ziade $"
+import string, os
+from types import *
+__revision__ = "$Id$"
+import os
 import sys
 from glob import glob
 from distutils.core import Command
 from distutils.errors import *
+from distutils.errors import DistutilsOptionError, DistutilsFileError
 from distutils.util import convert_path
 from distutils import log
 class build_py (Command):
+class build_py(Command):
     description = "\"build\" pure Python modules (copy to build directory)"
 …
     negative_opt = {'no-compile' : 'compile'}
+    def initialize_options (self):
+    def initialize_options(self):
         self.build_lib = None
         self.py_modules = None
 …
         self.force = None
     def finalize_options (self):
+    def finalize_options(self):
         self.set_undefined_options('build',
                                    ('build_lib', 'build_lib'),
 …
         # 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
 …
         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 = []
 …
         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('', [])
 …
         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:
             for filename in filenames:
 …
                                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 = string.split(package, '.')
+        path = package.split('.')
         if not self.package_dir:
             if path:
                 return apply(os.path.join, path)
+                return os.path.join(*path)
             else:
                 return ''
 …
             while path:
                 try:
                     pdir = self.package_dir[string.join(path, '.')]
+                    pdir = self.package_dir['.'.join(path)]
                 except KeyError:
                     tail.insert(0, path[-1])
 …
                 if tail:
                     return apply(os.path.join, tail)
+                    return os.path.join(*tail)
                 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
 …
         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"
 …
         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
+    # check_module ()
+    def find_package_modules (self, package, package_dir):
+            return True
+    def find_package_modules(self, package, package_dir):
         self.check_package(package, package_dir)
         module_files = glob(os.path.join(package_dir, "*.py"))
 …
         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.
         """
         # Map package names to tuples of useful info about the package:
         #    (package_dir, checked)
 …
         # 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 = string.split(module, '.')
             package = string.join(path[0:-1], '.')
+            path = module.split('.')
+            package = '.'.join(path[0:-1])
             module_base = path[-1]
 …
         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
 …
         (package, module, module_file), just like 'find_modules()' and
         'find_package_modules()' do."""
         modules = []
         if self.py_modules:
 …
                 m = self.find_package_modules(package, package_dir)
                 modules.extend(m)
         return modules
+    # 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_source_files(self):
+        return [module[-1] for module in self.find_all_modules()]
+    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:
             package = string.split(package, '.')
+            package = package.split('.')
             filename = self.get_module_outfile(self.build_lib, package, module)
             outputs.append(filename)
 …
         return outputs
+    def build_module (self, module, module_file, package):
+        if type(package) is StringType:
+            package = string.split(package, '.')
+        elif type(package) not in (ListType, TupleType):
+            raise TypeError, \
+                  "'package' must be a string (dot-separated), list, or tuple"
+    def build_module(self, module, module_file, package):
+        if isinstance(package, str):
+            package = package.split('.')
+        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
 …
         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:
 …
             self.build_module(module, module_file, package)
+    # build_modules ()
+    def build_packages (self):
+    def build_packages(self):
         for package in self.packages:
 …
                 self.build_module(module, module_file, package)
+    # build_packages ()
+    def byte_compile (self, files):
+    def byte_compile(self, files):
         if sys.dont_write_bytecode:
             self.warn('byte-compiling is disabled, skipping.')
 …
             byte_compile(files, optimize=self.optimize,
                          force=self.force, prefix=prefix, dry_run=self.dry_run)
-# class build_py

python/vendor/current/Lib/distutils/command/build_scripts.py

-              r2
+              r388
 Implements the Distutils 'build_scripts' command."""
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: build_scripts.py 69599 2009-02-13 23:02:44Z tarek.ziade $"
+__revision__ = "$Id$"
 import os, re
 from stat import ST_MODE
-from distutils import sysconfig
 from distutils.core import Command
 from distutils.dep_util import newer
 …
         line to refer to the current Python interpreter as we copy.
         """
+        _sysconfig = __import__('sysconfig')
         self.mkpath(self.build_dir)
         outfiles = []
 …
                 if not self.dry_run:
                     outf = open(outfile, "w")
                     if not sysconfig.python_build:
+                    if not _sysconfig.is_python_build():
                         outf.write("#!%s%s\n" %
                                    (self.executable,
 …
                         outf.write("#!%s%s\n" %
                                    (os.path.join(
                             sysconfig.get_config_var("BINDIR"),
                            "python%s%s" % (sysconfig.get_config_var("VERSION"),
                                            sysconfig.get_config_var("EXE"))),
+                            _sysconfig.get_config_var("BINDIR"),
+                           "python%s%s" % (_sysconfig.get_config_var("VERSION"),
+                                           _sysconfig.get_config_var("EXE"))),
                                     post_interp))
                     outf.writelines(f.readlines())

python/vendor/current/Lib/distutils/command/clean.py

-              r2
+              r388
 # 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: clean.py 38532 2005-03-03 08:12:27Z loewis $"
+__revision__ = "$Id$"
 import os
 …
 from distutils import log
 class clean (Command):
+class clean(Command):
     description = "clean up temporary files from 'build' command"

python/vendor/current/Lib/distutils/command/config.py

-              r2
+              r388
 """
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: config.py 37828 2004-11-10 22:23:15Z loewis $"
+import sys, os, string, re
+from types import *
+__revision__ = "$Id$"
+import os
+import re
 from distutils.core import Command
 from distutils.errors import DistutilsExecError
 …
 from distutils import log
+LANG_EXT = {'c': '.c',
+            'c++': '.cxx'}
+class config (Command):
+LANG_EXT = {'c': '.c', 'c++': '.cxx'}
+class config(Command):
     description = "prepare to build"
 …
     # 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
-        #self.define = None
-        #self.undef = None
         self.libraries = None
         self.library_dirs = None
 …
         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 type(self.include_dirs) is StringType:
             self.include_dirs = string.split(self.include_dirs, os.pathsep)
+        elif isinstance(self.include_dirs, str):
+            self.include_dirs = self.include_dirs.split(os.pathsep)
         if self.libraries is None:
             self.libraries = []
         elif type(self.libraries) is StringType:
+        elif isinstance(self.libraries, str):
             self.libraries = [self.libraries]
         if self.library_dirs is None:
             self.library_dirs = []
+        elif type(self.library_dirs) is StringType:
+            self.library_dirs = string.split(self.library_dirs, os.pathsep)
+    def run (self):
+        elif isinstance(self.library_dirs, str):
+            self.library_dirs = self.library_dirs.split(os.pathsep)
+    def run(self):
         pass
 …
     # 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.
 …
     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")
 …
         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"
 …
         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:
 …
         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]
 …
         return (src, obj, prog)
     def _clean (self, *filenames):
+    def _clean(self, *filenames):
         if not filenames:
             filenames = self.temp_files
             self.temp_files = []
         log.info("removing: %s", string.join(filenames))
+        log.info("removing: %s", ' '.join(filenames))
         for filename in filenames:
             try:
 …
     # 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)
 …
         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
 …
         symbols the preprocessor and compiler set by default.
         """
+        self._check_compiler()
+        (src, out) = self._preprocess(body, headers, include_dirs, lang)
+        if type(pattern) is StringType:
+        self._check_compiler()
+        src, out = self._preprocess(body, headers, include_dirs, lang)
+        if isinstance(pattern, str):
             pattern = re.compile(pattern)
 …
         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.
 …
         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
 …
         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
 …
     # 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
 …
             body.append("  %s;" % func)
         body.append("}")
         body = string.join(body, "\n") + "\n"
+        body = "\n".join(body) + "\n"
         return self.try_link(body, headers, include_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
 …
                              [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,
 …
+# class config
+def dump_file (filename, head=None):
+def dump_file(filename, head=None):
+    """Dumps a file content into log.info.
+    If head is not None, will be dumped before the file content.
+    """
     if head is None:
         print filename + ":"
+        log.info('%s' % filename)
     else:
+        print head
+        log.info(head)
     file = open(filename)
+    sys.stdout.write(file.read())
+    file.close()
+    try:
+        log.info(file.read())
+    finally:
+        file.close()

python/vendor/current/Lib/distutils/command/install.py

-              r2
+              r388
 # This module should be kept compatible with Python 2.1.
 __revision__ = "$Id: install.py 62788 2008-05-06 22:41:46Z christian.heimes $"
+__revision__ = "$Id$"
 import sys, os, string
 …
         'data'   : '$userbase',
         },
-    'mac': {
-        'purelib': '$base/Lib/site-packages',
-        'platlib': '$base/Lib/site-packages',
-        'headers': '$base/Include/$dist_name',
-        'scripts': '$base/Scripts',
-        'data'   : '$base',
-        },
-    'mac_user': {
-        'purelib': '$usersite',
-        'platlib': '$usersite',
-        'headers': '$userbase/$py_version_short/include/$dist_name',
-        'scripts': '$userbase/bin',
-        'data'   : '$userbase',
-        },
     'os2': {
         'purelib': '$base/Lib/site-packages',
 …
         if self.user and (self.prefix or self.exec_prefix or self.home or
                 self.install_base or self.install_platbase):
             raise DistutilsOptionError("can't combine user with with prefix/"
                                        "exec_prefix/home or install_(plat)base")
+            raise DistutilsOptionError("can't combine user with prefix, "
+                                       "exec_prefix/home, or install_(plat)base")
         # Next, stuff that's wrong (or dubious) only on certain platforms.

python/vendor/current/Lib/distutils/command/install_data.py

-              r2
+              r388
 # contributed by Bastian Kleineidam
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: install_data.py 37828 2004-11-10 22:23:15Z loewis $"
+__revision__ = "$Id$"
 import os
-from types import StringType
 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"
 …
     boolean_options = ['force']
     def initialize_options (self):
+    def initialize_options(self):
         self.install_dir = None
         self.outfiles = []
         self.root = None
         self.force = 0
         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'),
 …
+                                  )
     def run (self):
+    def run(self):
         self.mkpath(self.install_dir)
         for f in self.data_files:
             if type(f) is StringType:
+            if isinstance(f, str):
                 # it's a simple file, so copy it
                 f = convert_path(f)
 …
                         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

python/vendor/current/Lib/distutils/command/install_headers.py

-              r2
+              r388
 files to the Python include directory."""
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: install_headers.py 61000 2008-02-23 17:40:11Z christian.heimes $"
+__revision__ = "$Id$"
 from distutils.core import Command
+class install_headers (Command):
+# XXX force is never used
+class install_headers(Command):
     description = "install C/C++ header files"
 …
     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'),
 …
     def run (self):
+    def run(self):
         headers = self.distribution.headers
         if not headers:
 …
             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

python/vendor/current/Lib/distutils/command/install_lib.py

-              r2
+              r388
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: install_lib.py 77376 2010-01-08 23:27:23Z tarek.ziade $"
+"""distutils.command.install_lib
+Implements the Distutils 'install_lib' command
+(install all Python modules)."""
+__revision__ = "$Id$"
 import os
-from types import IntType
 import sys
 …
     PYTHON_SOURCE_EXTENSION = ".py"
 class install_lib (Command):
+class install_lib(Command):
     description = "install all Python modules (extensions and pure Python)"
 …
     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.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,
 …
             self.optimize = 0
         if type(self.optimize) is not IntType:
+        if not isinstance(self.optimize, int):
             try:
                 self.optimize = int(self.optimize)
 …
                 raise DistutilsOptionError, "optimize must be 0, 1, or 2"
+    def run (self):
+    def run(self):
         # Make sure we have built everything we need first
         self.build()
 …
             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_ext')
     def install (self):
+    def install(self):
         if os.path.isdir(self.build_dir):
             outfiles = self.copy_tree(self.build_dir, self.install_dir)
 …
         return outfiles
     def byte_compile (self, files):
+    def byte_compile(self, files):
         if sys.dont_write_bytecode:
             self.warn('byte-compiling is disabled, skipping.')
 …
     # -- 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 []
 …
         return outputs
+    # _mutate_outputs ()
+    def _bytecode_filenames (self, py_filenames):
+    def _bytecode_filenames(self, py_filenames):
         bytecode_files = []
         for py_file in py_filenames:
 …
     # (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
 …
         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.
 …
         return inputs
-# class install_lib

python/vendor/current/Lib/distutils/command/install_scripts.py

-              r2
+              r388
 # contributed by Bastian Kleineidam
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: install_scripts.py 37828 2004-11-10 22:23:15Z loewis $"
+__revision__ = "$Id$"
 import os

python/vendor/current/Lib/distutils/command/register.py

-              r2
+              r388
 # created 2002/10/21, Richard Jones
+__revision__ = "$Id: register.py 77719 2010-01-24 00:57:20Z tarek.ziade $"
+import os, string, urllib2, getpass, urlparse
+import StringIO
+__revision__ = "$Id$"
+import urllib2
+import getpass
+import urlparse
+from warnings import warn
 from distutils.core import PyPIRCCommand
-from distutils.errors import *
 from distutils import log
 …
         ('list-classifiers', None,
          'list the valid Trove classifiers'),
+        ('strict', None ,
+         'Will stop the registering if the meta-data are not fully compliant')
+        ]
     boolean_options = PyPIRCCommand.boolean_options + [
+        'verify', 'list-classifiers']
+        'verify', 'list-classifiers', 'strict']
+    sub_commands = [('check', lambda self: True)]
     def initialize_options(self):
         PyPIRCCommand.initialize_options(self)
         self.list_classifiers = 0
+        self.strict = 0
+    def finalize_options(self):
+        PyPIRCCommand.finalize_options(self)
+        # setting options for the `check` subcommand
+        check_options = {'strict': ('register', self.strict),
+                         'restructuredtext': ('register', 1)}
+        self.distribution.command_options['check'] = check_options
     def run(self):
         self.finalize_options()
         self._set_config()
+        self.check_metadata()
+        # Run sub commands
+        for cmd_name in self.get_sub_commands():
+            self.run_command(cmd_name)
         if self.dry_run:
             self.verify_metadata()
 …
     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
+           any are missing.
+        """
+        metadata = self.distribution.metadata
+        missing = []
+        for attr in ('name', 'version', 'url'):
+            if not (hasattr(metadata, attr) and getattr(metadata, attr)):
+                missing.append(attr)
+        if missing:
+            self.warn("missing required meta-data: " +
+                      string.join(missing, ", "))
+        if metadata.author:
+            if not metadata.author_email:
+                self.warn("missing meta-data: if 'author' supplied, " +
+                          "'author_email' must be supplied too")
+        elif metadata.maintainer:
+            if not metadata.maintainer_email:
+                self.warn("missing meta-data: if 'maintainer' supplied, " +
+                          "'maintainer_email' must be supplied too")
+        else:
+            self.warn("missing meta-data: either (author and author_email) " +
+                      "or (maintainer and maintainer_email) " +
+                      "must be supplied")
+        """Deprecated API."""
+        warn("distutils.command.register.check_metadata is deprecated, \
+              use the check command instead", PendingDeprecationWarning)
+        check = self.distribution.get_command_obj('check')
+        check.ensure_finalized()
+        check.strict = self.strict
+        check.restructuredtext = 1
+        check.run()
     def _set_config(self):
 …
         '''
         response = urllib2.urlopen(self.repository+'?:action=list_classifiers')
         print response.read()
+        log.info(response.read())
     def verify_metadata(self):
 …
         # send the info to the server and report the result
         (code, result) = self.post_to_server(self.build_post_data('verify'))
         print 'Server response (%s): %s'%(code, result)
+        log.info('Server response (%s): %s' % (code, result))
 …
             # possibly save the login
+            if not self.has_config and code == 200:
+                self.announce(('I can store your PyPI login so future '
+                               'submissions will be faster.'), log.INFO)
+                self.announce('(the login will be stored in %s)' % \
+                              self._get_rc_file(), log.INFO)
+                choice = 'X'
+                while choice.lower() not in 'yn':
+                    choice = raw_input('Save your login (y/N)?')
+                    if not choice:
+                        choice = 'n'
+                if choice.lower() == 'y':
+                    self._store_pypirc(username, password)
+            if code == 200:
+                if self.has_config:
+                    # sharing the password in the distribution instance
+                    # so the upload command can reuse it
+                    self.distribution.password = password
+                else:
+                    self.announce(('I can store your PyPI login so future '
+                                   'submissions will be faster.'), log.INFO)
+                    self.announce('(the login will be stored in %s)' % \
+                                  self._get_rc_file(), log.INFO)
+                    choice = 'X'
+                    while choice.lower() not in 'yn':
+                        choice = raw_input('Save your login (y/N)?')
+                        if not choice:
+                            choice = 'n'
+                    if choice.lower() == 'y':
+                        self._store_pypirc(username, password)
         elif choice == '2':
 …
             code, result = self.post_to_server(data)
             if code != 200:
                 print 'Server response (%s): %s'%(code, result)
+                log.info('Server response (%s): %s' % (code, result))
             else:
+                print 'You will receive an email shortly.'
+                print 'Follow the instructions in it to complete registration.'
+                log.info('You will receive an email shortly.')
+                log.info(('Follow the instructions in it to '
+                          'complete registration.'))
         elif choice == '3':
             data = {':action': 'password_reset'}
 …
                 data['email'] = raw_input('Your email address: ')
             code, result = self.post_to_server(data)
             print 'Server response (%s): %s'%(code, result)
+            log.info('Server response (%s): %s' % (code, result))
     def build_post_data(self, action):
 …
         ''' Post a query to the server, and return a string response.
         '''
+        self.announce('Registering %s to %s' % (data['name'],
+                                                self.repository), log.INFO)
+        if 'name' in data:
+            self.announce('Registering %s to %s' % (data['name'],
+                                                   self.repository),
+                                                   log.INFO)
         # Build up the MIME payload for the urllib2 POST data
         boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
         sep_boundary = '\n--' + boundary
         end_boundary = sep_boundary + '--'
         body = StringIO.StringIO()
+        chunks = []
         for key, value in data.items():
             # handle multiple entries for the same name
 …
                 value = [value]
             for value in value:
                 body.write(sep_boundary)
                 body.write('\nContent-Disposition: form-data; name="%s"'%key)
                 body.write("\n\n")
                 body.write(value)
+                chunks.append(sep_boundary)
+                chunks.append('\nContent-Disposition: form-data; name="%s"'%key)
+                chunks.append("\n\n")
+                chunks.append(value)
                 if value and value[-1] == '\r':
+                    body.write('\n')  # write an extra newline (lurve Macs)
+        body.write(end_boundary)
+        body.write("\n")
+        body = body.getvalue()
+                    chunks.append('\n')  # write an extra newline (lurve Macs)
+        chunks.append(end_boundary)
+        chunks.append("\n")
+        # chunks may be bytes (str) or unicode objects that we need to encode
+        body = []
+        for chunk in chunks:
+            if isinstance(chunk, unicode):
+                body.append(chunk.encode('utf-8'))
+            else:
+                body.append(chunk)
+        body = ''.join(body)
         # build the Request
 …
             result = 200, 'OK'
         if self.show_response:
+            print '-'*75, data, '-'*75
+            dashes = '-' * 75
+            self.announce('%s%s%s' % (dashes, data, dashes))
         return result

python/vendor/current/Lib/distutils/command/sdist.py

-              r2
+              r388
 Implements the Distutils 'sdist' command (create a source distribution)."""
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: sdist.py 68968 2009-01-26 17:20:15Z tarek.ziade $"
+import os, string
+__revision__ = "$Id$"
+import os
+import string
 import sys
-from types import *
 from glob import glob
+from warnings import warn
 from distutils.core import Command
 from distutils import dir_util, dep_util, file_util, archive_util
 from distutils.text_file import TextFile
+from distutils.errors import *
+from distutils.errors import (DistutilsPlatformError, DistutilsOptionError,
+                              DistutilsTemplateError)
 from distutils.filelist import FileList
 from distutils import log
 def show_formats ():
+from distutils.util import convert_path
+def show_formats():
     """Print all possible values for the 'formats' option (used by
     the "--help-formats" command-line option).
 …
     from distutils.fancy_getopt import FancyGetopt
     from distutils.archive_util import ARCHIVE_FORMATS
     formats=[]
+    formats = []
     for format in ARCHIVE_FORMATS.keys():
         formats.append(("formats=" + format, None,
                         ARCHIVE_FORMATS[format][2]))
     formats.sort()
+    pretty_printer = FancyGetopt(formats)
+    pretty_printer.print_help(
+    FancyGetopt(formats).print_help(
         "List of available source distribution formats:")
 class sdist (Command):
+class sdist(Command):
     description = "create a source distribution (tarball, zip file, etc.)"
+    def checking_metadata(self):
+        """Callable used for the check sub-command.
+        Placed here so user_options can view it"""
+        return self.metadata_check
     user_options = [
 …
          "(implies --force-manifest)"),
         ('force-manifest', 'f',
+         "forcibly regenerate the manifest and carry on as usual"),
+         "forcibly regenerate the manifest and carry on as usual. "
+         "Deprecated: now the manifest is always regenerated."),
         ('formats=', None,
          "formats for source distribution (comma-separated list)"),
 …
          "directory to put the source distribution archive(s) in "
          "[default: dist]"),
+        ('metadata-check', None,
+         "Ensure that all required elements of meta-data "
+         "are supplied. Warn if any missing. [default]"),
+        ('owner=', 'u',
+         "Owner name used when creating a tar file [default: current user]"),
+        ('group=', 'g',
+         "Group name used when creating a tar file [default: current group]"),
+        ]
     boolean_options = ['use-defaults', 'prune',
                        'manifest-only', 'force-manifest',
                        'keep-temp']
+                       'keep-temp', 'metadata-check']
     help_options = [
 …
                     'no-prune': 'prune' }
+    default_format = { 'posix': 'gztar',
+                       'nt': 'zip' }
+    def initialize_options (self):
+    default_format = {'posix': 'gztar',
+                      'nt': 'zip' }
+    sub_commands = [('check', checking_metadata)]
+    def initialize_options(self):
         # 'template' and 'manifest' are, respectively, the names of
         # the manifest template and manifest file.
 …
         self.archive_files = None
+    def finalize_options (self):
+        self.metadata_check = 1
+        self.owner = None
+        self.group = None
+    def finalize_options(self):
         if self.manifest is None:
             self.manifest = "MANIFEST"
 …
             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()
         # Ensure that all required meta-data is given; warn if not (but
         # don't die, it's not *that* serious!)
         self.check_metadata()
+        # Run sub commands
+        for cmd_name in self.get_sub_commands():
+            self.run_command(cmd_name)
         # Do whatever it takes to get the list of files to process
 …
         self.make_distribution()
+    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
+        any are missing.
+        """
+        metadata = self.distribution.metadata
+        missing = []
+        for attr in ('name', 'version', 'url'):
+            if not (hasattr(metadata, attr) and getattr(metadata, attr)):
+                missing.append(attr)
+        if missing:
+            self.warn("missing required meta-data: " +
+                      string.join(missing, ", "))
+        if metadata.author:
+            if not metadata.author_email:
+                self.warn("missing meta-data: if 'author' supplied, " +
+                          "'author_email' must be supplied too")
+        elif metadata.maintainer:
+            if not metadata.maintainer_email:
+                self.warn("missing meta-data: if 'maintainer' supplied, " +
+                          "'maintainer_email' must be supplied too")
+        else:
+            self.warn("missing meta-data: either (author and author_email) " +
+                      "or (maintainer and maintainer_email) " +
+                      "must be supplied")
+    # check_metadata ()
+    def get_file_list (self):
+    def check_metadata(self):
+        """Deprecated API."""
+        warn("distutils.command.sdist.check_metadata is deprecated, \
+              use the check command instead", PendingDeprecationWarning)
+        check = self.distribution.get_command_obj('check')
+        check.ensure_finalized()
+        check.run()
+    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.
+        depends on the user's options.
+        """
+        # new behavior when using a template:
+        # the file list is recalculated every time because
+        # even if MANIFEST.in or setup.py are not changed
+        # the user might have added some files in the tree that
+        # need to be included.
+        #
+        #  This makes --force the default and only behavior with templates.
         template_exists = os.path.isfile(self.template)
+        if template_exists:
+            template_newer = dep_util.newer(self.template, self.manifest)
+        # The contents of the manifest file almost certainly depend on the
+        # setup script as well as the manifest template -- so if the setup
+        # script is newer than the manifest, we'll regenerate the manifest
+        # from the template.  (Well, not quite: if we already have a
+        # manifest, but there's no template -- which will happen if the
+        # developer elects to generate a manifest some other way -- then we
+        # can't regenerate the manifest, so we don't.)
+        self.debug_print("checking if %s newer than %s" %
+                         (self.distribution.script_name, self.manifest))
+        setup_newer = dep_util.newer(self.distribution.script_name,
+                                     self.manifest)
+        # cases:
+        #   1) no manifest, template exists: generate manifest
+        #      (covered by 2a: no manifest == template newer)
+        #   2) manifest & template exist:
+        #      2a) template or setup script newer than manifest:
+        #          regenerate manifest
+        #      2b) manifest newer than both:
+        #          do nothing (unless --force or --manifest-only)
+        #   3) manifest exists, no template:
+        #      do nothing (unless --force or --manifest-only)
+        #   4) no manifest, no template: generate w/ warning ("defaults only")
+        manifest_outofdate = (template_exists and
+                              (template_newer or setup_newer))
+        force_regen = self.force_manifest or self.manifest_only
+        manifest_exists = os.path.isfile(self.manifest)
+        neither_exists = (not template_exists and not manifest_exists)
+        # 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.filelist.findall()
+            if self.use_defaults:
+                self.add_defaults()
+            if template_exists:
+                self.read_template()
+            if self.prune:
+                self.prune_file_list()
+        if not template_exists and self._manifest_is_not_generated():
+            self.read_manifest()
             self.filelist.sort()
             self.filelist.remove_duplicates()
+            self.write_manifest()
+        # Don't regenerate the manifest, just read it in.
+        else:
+            self.read_manifest()
+    # get_file_list ()
+    def add_defaults (self):
+            return
+        if not template_exists:
+            self.warn(("manifest template '%s' does not exist " +
+                        "(using default file list)") %
+                        self.template)
+        self.filelist.findall()
+        if self.use_defaults:
+            self.add_defaults()
+        if template_exists:
+            self.read_template()
+        if self.prune:
+            self.prune_file_list()
+        self.filelist.sort()
+        self.filelist.remove_duplicates()
+        self.write_manifest()
+    def add_defaults(self):
         """Add all the default files to self.filelist:
           - README or README.txt
 …
           - test/test*.py
           - all pure Python modules mentioned in setup script
+          - all files pointed by package_data (build_py)
+          - all files defined in data_files.
+          - all files defined as scripts.
           - all C sources listed as part of extensions or C libraries
             in the setup script (doesn't catch C headers!)
 …
         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
 …
                 self.filelist.extend(files)
+        # build_py is used to get:
+        #  - python modules
+        #  - files defined in package_data
+        build_py = self.get_finalized_command('build_py')
+        # getting python files
         if self.distribution.has_pure_modules():
-            build_py = self.get_finalized_command('build_py')
             self.filelist.extend(build_py.get_source_files())
+        # getting package_data files
+        # (computed in build_py.data_files by build_py.finalize_options)
+        for pkg, src_dir, build_dir, filenames in build_py.data_files:
+            for filename in filenames:
+                self.filelist.append(os.path.join(src_dir, filename))
+        # getting distribution.data_files
+        if self.distribution.has_data_files():
+            for item in self.distribution.data_files:
+                if isinstance(item, str): # plain file
+                    item = convert_path(item)
+                    if os.path.isfile(item):
+                        self.filelist.append(item)
+                else:    # a (dirname, filenames) tuple
+                    dirname, filenames = item
+                    for f in filenames:
+                        f = convert_path(f)
+                        if os.path.isfile(f):
+                            self.filelist.append(f)
         if self.distribution.has_ext_modules():
 …
             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.
 …
                             collapse_join=1)
+        while 1:
+            line = template.readline()
+            if line is None:            # end of file
+                break
+            try:
+                self.filelist.process_template_line(line)
+            except DistutilsTemplateError, msg:
+                self.warn("%s, line %d: %s" % (template.filename,
+                                               template.current_line,
+                                               msg))
+    # read_template ()
+    def prune_file_list (self):
+        try:
+            while 1:
+                line = template.readline()
+                if line is None:            # end of file
+                    break
+                try:
+                    self.filelist.process_template_line(line)
+                # the call above can raise a DistutilsTemplateError for
+                # malformed lines, or a ValueError from the lower-level
+                # convert_path function
+                except (DistutilsTemplateError, ValueError) as msg:
+                    self.warn("%s, line %d: %s" % (template.filename,
+                                                   template.current_line,
+                                                   msg))
+        finally:
+            template.close()
+    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:
 …
         self.filelist.exclude_pattern(vcs_ptrn, 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'.
         """
+        self.execute(file_util.write_file,
+                     (self.manifest, self.filelist.files),
+        if self._manifest_is_not_generated():
+            log.info("not writing to manually maintained "
+                     "manifest file '%s'" % self.manifest)
+            return
+        content = self.filelist.files[:]
+        content.insert(0, '# file GENERATED by distutils, do NOT edit')
+        self.execute(file_util.write_file, (self.manifest, content),
                      "writing manifest file '%s'" % self.manifest)
+    # write_manifest ()
+    def read_manifest (self):
+    def _manifest_is_not_generated(self):
+        # check for special comment used in 2.7.1 and higher
+        if not os.path.isfile(self.manifest):
+            return False
+        fp = open(self.manifest, 'rU')
+        try:
+            first_line = fp.readline()
+        finally:
+            fp.close()
+        return first_line != '# file GENERATED by distutils, do NOT edit\n'
+    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
 …
         log.info("reading manifest file '%s'", self.manifest)
         manifest = open(self.manifest)
+        while 1:
+            line = manifest.readline()
+            if line == '':              # end of file
+                break
+            if line[-1] == '\n':
+                line = line[0:-1]
+        for line in manifest:
+            # ignore comments and blank lines
+            line = line.strip()
+            if line.startswith('#') or not line:
+                continue
             self.filelist.append(line)
         manifest.close()
+    # 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
 …
         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
 …
         for fmt in self.formats:
+            file = self.make_archive(base_name, fmt, base_dir=base_dir)
+            file = self.make_archive(base_name, fmt, base_dir=base_dir,
+                                     owner=self.owner, group=self.group)
             archive_files.append(file)
             self.distribution.dist_files.append(('sdist', '', file))
 …
             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

python/vendor/current/Lib/distutils/command/upload.py

-              r2
+              r388
 Implements the Distutils 'upload' subcommand (upload package to PyPI)."""
+import os
+import socket
+import platform
+from urllib2 import urlopen, Request, HTTPError
+from base64 import standard_b64encode
+import urlparse
+import cStringIO as StringIO
+from hashlib import md5
 from distutils.errors import *
+from distutils.errors import DistutilsOptionError
 from distutils.core import PyPIRCCommand
 from distutils.spawn import spawn
 from distutils import log
-from hashlib import md5
-import os
-import socket
-import platform
-import httplib
-from base64 import standard_b64encode
-import urlparse
-import cStringIO as StringIO
-from ConfigParser import ConfigParser
 class upload(PyPIRCCommand):
 …
             self.realm = config['realm']
+        # getting the password from the distribution
+        # if previously set by the register command
+        if not self.password and self.distribution.password:
+            self.password = self.distribution.password
     def run(self):
         if not self.distribution.dist_files:
 …
     def upload_file(self, command, pyversion, filename):
+        # Makes sure the repository URL is compliant
+        schema, netloc, url, params, query, fragments = \
+            urlparse.urlparse(self.repository)
+        if params or query or fragments:
+            raise AssertionError("Incompatible url %s" % self.repository)
+        if schema not in ('http', 'https'):
+            raise AssertionError("unsupported schema " + schema)
         # Sign if requested
         if self.sign:
 …
         # Fill in the data - send all the meta-data in case we need to
         # register a new release
+        content = open(filename,'rb').read()
+        f = open(filename,'rb')
+        try:
+            content = f.read()
+        finally:
+            f.close()
         meta = self.distribution.metadata
         data = {
 …
         for key, value in data.items():
             # handle multiple entries for the same name
             if type(value) != type([]):
+            if not isinstance(value, list):
                 value = [value]
             for value in value:
                 if type(value) is tuple:
+                if isinstance(value, tuple):
                     fn = ';filename="%s"' % value[0]
                     value = value[1]
 …
         # build the Request
+        # We can't use urllib2 since we need to send the Basic
+        # auth right with the first request
+        schema, netloc, url, params, query, fragments = \
+            urlparse.urlparse(self.repository)
+        assert not params and not query and not fragments
+        if schema == 'http':
+            http = httplib.HTTPConnection(netloc)
+        elif schema == 'https':
+            http = httplib.HTTPSConnection(netloc)
+        else:
+            raise AssertionError, "unsupported schema "+schema
+        headers = {'Content-type':
+                        'multipart/form-data; boundary=%s' % boundary,
+                   'Content-length': str(len(body)),
+                   'Authorization': auth}
+        data = ''
+        loglevel = log.INFO
+        request = Request(self.repository, data=body,
+                          headers=headers)
+        # send the data
         try:
+            http.connect()
+            http.putrequest("POST", url)
+            http.putheader('Content-type',
+                           'multipart/form-data; boundary=%s'%boundary)
+            http.putheader('Content-length', str(len(body)))
+            http.putheader('Authorization', auth)
+            http.endheaders()
+            http.send(body)
+            result = urlopen(request)
+            status = result.getcode()
+            reason = result.msg
+            if self.show_response:
+                msg = '\n'.join(('-' * 75, r.read(), '-' * 75))
+                self.announce(msg, log.INFO)
         except socket.error, e:
             self.announce(str(e), log.ERROR)
             return
+        except HTTPError, e:
+            status = e.code
+            reason = e.msg
+        r = http.getresponse()
+        if r.status == 200:
+            self.announce('Server response (%s): %s' % (r.status, r.reason),
+        if status == 200:
+            self.announce('Server response (%s): %s' % (status, reason),
                           log.INFO)
         else:
             self.announce('Upload failed (%s): %s' % (r.status, r.reason),
+            self.announce('Upload failed (%s): %s' % (status, reason),
                           log.ERROR)
-        if self.show_response:
-            print '-'*75, r.read(), '-'*75

python/vendor/current/Lib/distutils/config.py

-              r2
+              r388
 """
 import os
-import sys
 from ConfigParser import ConfigParser
 …
         """Creates a default .pypirc file."""
         rc = self._get_rc_file()
         f = open(rc, 'w')
+        f = os.fdopen(os.open(rc, os.O_CREAT | os.O_WRONLY, 0600), 'w')
         try:
             f.write(DEFAULT_PYPIRC % (username, password))
         finally:
             f.close()
-        try:
-            os.chmod(rc, 0600)
-        except OSError:
-            # should do something better here
-            pass
     def _read_pypirc(self):
 …
             self.announce('Using PyPI login from %s' % rc)
             repository = self.repository or self.DEFAULT_REPOSITORY
-            realm = self.realm or self.DEFAULT_REALM
             config = ConfigParser()
             config.read(rc)
 …
                     current = {'server': server}
                     current['username'] = config.get(server, 'username')
-                    current['password'] = config.get(server, 'password')
                     # optional params
                     for key, default in (('repository',
                                           self.DEFAULT_REPOSITORY),
+                                         ('realm', self.DEFAULT_REALM)):
+                                         ('realm', self.DEFAULT_REALM),
+                                         ('password', None)):
                         if config.has_option(server, key):
                             current[key] = config.get(server, key)

python/vendor/current/Lib/distutils/core.py

-              r2
+              r388
 """
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: core.py 65806 2008-08-18 11:13:45Z marc-andre.lemburg $"
+import sys, os
+from types import *
+__revision__ = "$Id$"
+import sys
+import os
 from distutils.debug import DEBUG
+from distutils.errors import *
+from distutils.errors import (DistutilsSetupError, DistutilsArgError,
+                              DistutilsError, CCompilerError)
 from distutils.util import grok_environment_error
 …
 """
 def gen_usage (script_name):
+def gen_usage(script_name):
     script = os.path.basename(script_name)
     return USAGE % vars()
+    return USAGE % {'script': script}
 …
                       'swig_opts', 'export_symbols', 'depends', 'language')
 def setup (**attrs):
+def setup(**attrs):
     """The gateway to the Distutils: do everything your setup script needs
     to do, in a highly flexible and user-driven way.  Briefly: create a
 …
         return dist
+    # Parse the command line; any command-line errors are the end user's
+    # fault, so turn them into SystemExit to suppress tracebacks.
+    # Parse the command line and override config files; any
+    # command-line errors are the end user's fault, so turn them into
+    # SystemExit to suppress tracebacks.
     try:
         ok = dist.parse_command_line()
 …
     return dist
+# setup ()
+def run_setup (script_name, script_args=None, stop_after="run"):
+def run_setup(script_name, script_args=None, stop_after="run"):
     """Run a setup script in a somewhat controlled environment, and
     return the Distribution instance that drives things.  This is useful
 …
             if script_args is not None:
                 sys.argv[1:] = script_args
+            exec open(script_name, 'r').read() in g, l
+            f = open(script_name)
+            try:
+                exec f.read() in g, l
+            finally:
+                f.close()
         finally:
             sys.argv = save_argv
 …
     # I wonder if the setup script's namespace -- g and l -- would be of
     # any interest to callers?
-    #print "_setup_distribution:", _setup_distribution
     return _setup_distribution
-# run_setup ()

python/vendor/current/Lib/distutils/cygwinccompiler.py

-              r2
+              r388
 # This module should be kept compatible with Python 2.1.
 __revision__ = "$Id: cygwinccompiler.py 73349 2009-06-11 09:17:19Z tarek.ziade $"
+__revision__ = "$Id$"
 import os,sys,copy
 …
             entry_point = ''
+        self.set_executables(compiler='gcc -mno-cygwin -O -Wall',
+                             compiler_so='gcc -mno-cygwin -mdll -O -Wall',
+                             compiler_cxx='g++ -mno-cygwin -O -Wall',
+                             linker_exe='gcc -mno-cygwin',
+                             linker_so='%s -mno-cygwin %s %s'
+                                        % (self.linker_dll, shared_option,
+                                           entry_point))
+        if self.gcc_version < '4' or is_cygwingcc():
+            no_cygwin = ' -mno-cygwin'
+        else:
+            no_cygwin = ''
+        self.set_executables(compiler='gcc%s -O -Wall' % no_cygwin,
+                             compiler_so='gcc%s -mdll -O -Wall' % no_cygwin,
+                             compiler_cxx='g++%s -O -Wall' % no_cygwin,
+                             linker_exe='gcc%s' % no_cygwin,
+                             linker_so='%s%s %s %s'
+                                    % (self.linker_dll, no_cygwin,
+                                       shared_option, entry_point))
         # Maybe we should also append -mthreads, but then the finished
         # dlls need another dll (mingwm10.dll see Mingw32 docs)
 …
         # But we do this only once, and it is fast enough
         f = open(fn)
+        s = f.read()
+        f.close()
+        try:
+            s = f.read()
+        finally:
+            f.close()
     except IOError, exc:
 …
         dllwrap_version = None
     return (gcc_version, ld_version, dllwrap_version)
+def is_cygwingcc():
+    '''Try to determine if the gcc that would be used is from cygwin.'''
+    out = os.popen('gcc -dumpmachine', 'r')
+    out_string = out.read()
+    out.close()
+    # out_string is the target triplet cpu-vendor-os
+    # Cygwin's gcc sets the os to 'cygwin'
+    return out_string.strip().endswith('cygwin')

python/vendor/current/Lib/distutils/debug.py

-              r2
+              r388
 import os
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: debug.py 37828 2004-11-10 22:23:15Z loewis $"
+__revision__ = "$Id$"
 # If DISTUTILS_DEBUG is anything other than the empty string, we run in

python/vendor/current/Lib/distutils/dep_util.py

-              r2
+              r388
 timestamp dependency analysis."""
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: dep_util.py 58049 2007-09-08 00:34:17Z skip.montanaro $"
+__revision__ = "$Id$"
 import os
+from stat import ST_MTIME
 from distutils.errors import DistutilsFileError
+def newer(source, target):
+    """Tells if the target is newer than the source.
+def newer (source, target):
+    """Return true if 'source' exists and is more recently modified than
+    'target', or if 'source' exists and 'target' doesn't.  Return false if
+    both exist and 'target' is the same age or younger than 'source'.
+    Raise DistutilsFileError if 'source' does not exist.
+    Return true if 'source' exists and is more recently modified than
+    'target', or if 'source' exists and 'target' doesn't.
+    Return false if both exist and 'target' is the same age or younger
+    than 'source'. Raise DistutilsFileError if 'source' does not exist.
+    Note that this test is not very accurate: files created in the same second
+    will have the same "age".
     """
     if not os.path.exists(source):
         raise DistutilsFileError, ("file '%s' does not exist" %
                                    os.path.abspath(source))
+        raise DistutilsFileError("file '%s' does not exist" %
+                                 os.path.abspath(source))
     if not os.path.exists(target):
         return 1
+        return True
+    from stat import ST_MTIME
+    mtime1 = os.stat(source)[ST_MTIME]
+    mtime2 = os.stat(target)[ST_MTIME]
+    return os.stat(source)[ST_MTIME] > os.stat(target)[ST_MTIME]
+    return mtime1 > mtime2
+# newer ()
+def newer_pairwise (sources, targets):
+def newer_pairwise(sources, targets):
     """Walk two filename lists in parallel, testing if each source is newer
     than its corresponding target.  Return a pair of lists (sources,
 …
     n_sources = []
     n_targets = []
     for i in range(len(sources)):
         if newer(sources[i], targets[i]):
             n_sources.append(sources[i])
             n_targets.append(targets[i])
+    for source, target in zip(sources, targets):
+        if newer(source, target):
+            n_sources.append(source)
+            n_targets.append(target)
     return (n_sources, n_targets)
+    return n_sources, n_targets
+# newer_pairwise ()
+def newer_group(sources, target, missing='error'):
+    """Return true if 'target' is out-of-date with respect to any file
+    listed in 'sources'.
+def newer_group (sources, target, missing='error'):
+    """Return true if 'target' is out-of-date with respect to any file
+    listed in 'sources'.  In other words, if 'target' exists and is newer
+    In other words, if 'target' exists and is newer
     than every file in 'sources', return false; otherwise return true.
     'missing' controls what we do when a source file is missing; the
 …
     # If the target doesn't even exist, then it's definitely out-of-date.
     if not os.path.exists(target):
         return 1
+        return True
     # Otherwise we have to find out the hard way: if *any* source file
 …
     # we can immediately return true.  If we fall through to the end
     # of the loop, then 'target' is up-to-date and we return false.
-    from stat import ST_MTIME
     target_mtime = os.stat(target)[ST_MTIME]
     for source in sources:
         if not os.path.exists(source):
 …
                 continue                #  target's dependency list
             elif missing == 'newer':    # missing source means target is
                 return 1                #  out-of-date
+                return True             #  out-of-date
+        source_mtime = os.stat(source)[ST_MTIME]
+        if source_mtime > target_mtime:
+            return 1
+    else:
+        return 0
+        if os.stat(source)[ST_MTIME] > target_mtime:
+            return True
+# newer_group ()
+    return False

python/vendor/current/Lib/distutils/dir_util.py

-              r2
+              r388
 Utility functions for manipulating directories and directory trees."""
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: dir_util.py 60923 2008-02-21 18:18:37Z guido.van.rossum $"
+import os, sys
+from types import *
+__revision__ = "$Id$"
+import os
+import errno
 from distutils.errors import DistutilsFileError, DistutilsInternalError
 from distutils import log
 …
 # b) it blows up if the directory already exists (I want to silently
 # succeed in that case).
+def mkpath (name, mode=0777, verbose=0, dry_run=0):
+    """Create a directory and any missing ancestor directories.  If the
+       directory already exists (or if 'name' is the empty string, which
+       means the current directory, which of course exists), then do
+       nothing.  Raise DistutilsFileError if unable to create some
+       directory along the way (eg. some sub-path exists, but is a file
+       rather than a directory).  If 'verbose' is true, print a one-line
+       summary of each mkdir to stdout.  Return the list of directories
+       actually created."""
+def mkpath(name, mode=0777, verbose=1, dry_run=0):
+    """Create a directory and any missing ancestor directories.
+    If the directory already exists (or if 'name' is the empty string, which
+    means the current directory, which of course exists), then do nothing.
+    Raise DistutilsFileError if unable to create some directory along the way
+    (eg. some sub-path exists, but is a file rather than a directory).
+    If 'verbose' is true, print a one-line summary of each mkdir to stdout.
+    Return the list of directories actually created.
+    """
     global _path_created
     # Detect a common bug -- name is None
     if not isinstance(name, StringTypes):
+    if not isinstance(name, basestring):
         raise DistutilsInternalError, \
               "mkpath: 'name' must be a string (got %r)" % (name,)
 …
     while head and tail and not os.path.isdir(head):
-        #print "splitting '%s': " % head,
         (head, tail) = os.path.split(head)
-        #print "to ('%s','%s')" % (head, tail)
         tails.insert(0, tail)          # push next higher dir onto stack
-    #print "stack of tails:", tails
     # now 'head' contains the deepest directory that already exists
 …
             continue
+        log.info("creating %s", head)
+        if verbose >= 1:
+            log.info("creating %s", head)
         if not dry_run:
             try:
+                os.mkdir(head)
+                created_dirs.append(head)
+                os.mkdir(head, mode)
             except OSError, exc:
+                raise DistutilsFileError, \
+                      "could not create '%s': %s" % (head, exc[-1])
+                if not (exc.errno == errno.EEXIST and os.path.isdir(head)):
+                    raise DistutilsFileError(
+                          "could not create '%s': %s" % (head, exc.args[-1]))
+            created_dirs.append(head)
         _path_created[abs_head] = 1
     return created_dirs
+# mkpath ()
+def create_tree (base_dir, files, mode=0777, verbose=0, dry_run=0):
+    """Create all the empty directories under 'base_dir' needed to
+       put 'files' there.  'base_dir' is just the a name of a directory
+       which doesn't necessarily exist yet; 'files' is a list of filenames
+       to be interpreted relative to 'base_dir'.  'base_dir' + the
+       directory portion of every file in 'files' will be created if it
+       doesn't already exist.  'mode', 'verbose' and 'dry_run' flags are as
+       for 'mkpath()'."""
+def create_tree(base_dir, files, mode=0777, verbose=1, dry_run=0):
+    """Create all the empty directories under 'base_dir' needed to put 'files'
+    there.
+    'base_dir' is just the a name of a directory which doesn't necessarily
+    exist yet; 'files' is a list of filenames to be interpreted relative to
+    'base_dir'.  'base_dir' + the directory portion of every file in 'files'
+    will be created if it doesn't already exist.  'mode', 'verbose' and
+    'dry_run' flags are as for 'mkpath()'.
+    """
     # First get the list of directories to create
     need_dir = {}
 …
     # Now create them
     for dir in need_dirs:
+        mkpath(dir, mode, dry_run=dry_run)
+# create_tree ()
+def copy_tree (src, dst,
+               preserve_mode=1,
+               preserve_times=1,
+               preserve_symlinks=0,
+               update=0,
+               verbose=0,
+               dry_run=0):
+    """Copy an entire directory tree 'src' to a new location 'dst'.  Both
+       'src' and 'dst' must be directory names.  If 'src' is not a
+       directory, raise DistutilsFileError.  If 'dst' does not exist, it is
+       created with 'mkpath()'.  The end result of the copy is that every
+       file in 'src' is copied to 'dst', and directories under 'src' are
+       recursively copied to 'dst'.  Return the list of files that were
+       copied or might have been copied, using their output name.  The
+       return value is unaffected by 'update' or 'dry_run': it is simply
+       the list of all files under 'src', with the names changed to be
+       under 'dst'.
+       'preserve_mode' and 'preserve_times' are the same as for
+       'copy_file'; note that they only apply to regular files, not to
+       directories.  If 'preserve_symlinks' is true, symlinks will be
+       copied as symlinks (on platforms that support them!); otherwise
+       (the default), the destination of the symlink will be copied.
+       'update' and 'verbose' are the same as for 'copy_file'."""
+        mkpath(dir, mode, verbose=verbose, dry_run=dry_run)
+def copy_tree(src, dst, preserve_mode=1, preserve_times=1,
+              preserve_symlinks=0, update=0, verbose=1, dry_run=0):
+    """Copy an entire directory tree 'src' to a new location 'dst'.
+    Both 'src' and 'dst' must be directory names.  If 'src' is not a
+    directory, raise DistutilsFileError.  If 'dst' does not exist, it is
+    created with 'mkpath()'.  The end result of the copy is that every
+    file in 'src' is copied to 'dst', and directories under 'src' are
+    recursively copied to 'dst'.  Return the list of files that were
+    copied or might have been copied, using their output name.  The
+    return value is unaffected by 'update' or 'dry_run': it is simply
+    the list of all files under 'src', with the names changed to be
+    under 'dst'.
+    'preserve_mode' and 'preserve_times' are the same as for
+    'copy_file'; note that they only apply to regular files, not to
+    directories.  If 'preserve_symlinks' is true, symlinks will be
+    copied as symlinks (on platforms that support them!); otherwise
+    (the default), the destination of the symlink will be copied.
+    'update' and 'verbose' are the same as for 'copy_file'.
+    """
     from distutils.file_util import copy_file
 …
     if not dry_run:
         mkpath(dst)
+        mkpath(dst, verbose=verbose)
     outputs = []
 …
         dst_name = os.path.join(dst, n)
+        if n.startswith('.nfs'):
+            # skip NFS rename files
+            continue
         if preserve_symlinks and os.path.islink(src_name):
             link_dest = os.readlink(src_name)
+            log.info("linking %s -> %s", dst_name, link_dest)
+            if verbose >= 1:
+                log.info("linking %s -> %s", dst_name, link_dest)
             if not dry_run:
                 os.symlink(link_dest, dst_name)
 …
                 copy_tree(src_name, dst_name, preserve_mode,
                           preserve_times, preserve_symlinks, update,
                           dry_run=dry_run))
+                          verbose=verbose, dry_run=dry_run))
         else:
             copy_file(src_name, dst_name, preserve_mode,
+                      preserve_times, update, dry_run=dry_run)
+                      preserve_times, update, verbose=verbose,
+                      dry_run=dry_run)
             outputs.append(dst_name)
     return outputs
-# copy_tree ()
-# Helper for remove_tree()
 def _build_cmdtuple(path, cmdtuples):
+    """Helper for remove_tree()."""
     for f in os.listdir(path):
         real_f = os.path.join(path,f)
 …
     cmdtuples.append((os.rmdir, path))
+def remove_tree (directory, verbose=0, dry_run=0):
+    """Recursively remove an entire directory tree.  Any errors are ignored
+    (apart from being reported to stdout if 'verbose' is true).
+def remove_tree(directory, verbose=1, dry_run=0):
+    """Recursively remove an entire directory tree.
+    Any errors are ignored (apart from being reported to stdout if 'verbose'
+    is true).
     """
     from distutils.util import grok_environment_error
     global _path_created
+    log.info("removing '%s' (and everything under it)", directory)
+    if verbose >= 1:
+        log.info("removing '%s' (and everything under it)", directory)
     if dry_run:
         return
 …
     for cmd in cmdtuples:
         try:
             apply(cmd[0], (cmd[1],))
+            cmd[0](cmd[1])
             # remove dir from cache if it's already there
             abspath = os.path.abspath(cmd[1])
 …
                     exc, "error removing %s: " % directory))
+def ensure_relative (path):
+    """Take the full path 'path', and make it a relative path so
     it can be the second argument to os.path.join().
+def ensure_relative(path):
+    """Take the full path 'path', and make it a relative path.
+    This is useful to make 'path' the second argument to os.path.join().
     """
     drive, path = os.path.splitdrive(path)
+    if sys.platform == 'mac':
+        return os.sep + path
+    else:
+        if path[0:1] == os.sep:
+            path = drive + path[1:]
+        return path
+    if path[0:1] == os.sep:
+        path = drive + path[1:]
+    return path

python/vendor/current/Lib/distutils/dist.py

-              r2
+              r388
 """
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: dist.py 77719 2010-01-24 00:57:20Z tarek.ziade $"
+import sys, os, string, re
+from types import *
+from copy import copy
+__revision__ = "$Id$"
+import sys, os, re
+from email import message_from_file
 try:
 …
     warnings = None
+from distutils.errors import *
+from distutils.errors import (DistutilsOptionError, DistutilsArgError,
+                              DistutilsModuleError, DistutilsClassError)
 from distutils.fancy_getopt import FancyGetopt, translate_longopt
 from distutils.util import check_environ, strtobool, rfc822_escape
 …
                       ('dry-run', 'n', "don't actually do anything"),
                       ('help', 'h', "show detailed help message"),
+                     ]
+                      ('no-user-cfg', None,
+                       'ignore pydistutils.cfg in your home directory'),
+    ]
     # 'common_usage' is a short (2-3 line) string describing the common
 …
         self.scripts = None
         self.data_files = None
+        self.password = ''
         # And now initialize bookkeeping stuff that can't be supplied by
 …
             # Now work on the rest of the attributes.  Any attribute that's
             # not already defined is invalid!
             for (key,val) in attrs.items():
+            for (key, val) in attrs.items():
                 if hasattr(self.metadata, "set_" + key):
                     getattr(self.metadata, "set_" + key)(val)
 …
                         sys.stderr.write(msg + "\n")
+        # no-user-cfg is handled before other command line args
+        # because other args override the config files, and this
+        # one is needed before we can load the config files.
+        # If attrs['script_args'] wasn't passed, assume false.
+        #
+        # This also make sure we just look at the global options
+        self.want_user_cfg = True
+        if self.script_args is not None:
+            for arg in self.script_args:
+                if not arg.startswith('-'):
+                    break
+                if arg == '--no-user-cfg':
+                    self.want_user_cfg = False
+                    break
         self.finalize_options()
+    # __init__ ()
+    def get_option_dict (self, command):
+    def get_option_dict(self, command):
         """Get the option dictionary for a given command.  If that
         command's option dictionary hasn't been created yet, then create it
 …
         option dictionary.
         """
         dict = self.command_options.get(command)
         if dict is None:
 …
         return dict
+    def dump_option_dicts (self, header=None, commands=None, indent=""):
+    def dump_option_dicts(self, header=None, commands=None, indent=""):
         from pprint import pformat
 …
         if header is not None:
             print indent + header
+            self.announce(indent + header)
             indent = indent + "  "
         if not commands:
             print indent + "no commands known yet"
+            self.announce(indent + "no commands known yet")
             return
 …
             opt_dict = self.command_options.get(cmd_name)
             if opt_dict is None:
+                print indent + "no option dict for '%s' command" % cmd_name
+                self.announce(indent +
+                              "no option dict for '%s' command" % cmd_name)
             else:
+                print indent + "option dict for '%s' command:" % cmd_name
+                self.announce(indent +
+                              "option dict for '%s' command:" % cmd_name)
                 out = pformat(opt_dict)
+                for line in string.split(out, "\n"):
+                    print indent + "  " + line
+    # dump_option_dicts ()
+                for line in out.split('\n'):
+                    self.announce(indent + "  " + line)
     # -- Config file finding/parsing methods ---------------------------
     def find_config_files (self):
+    def find_config_files(self):
         """Find as many configuration files as should be processed for this
         platform, and return a list of filenames in the order in which they
 …
         Distutils __inst__.py file lives), a file in the user's home
         directory named .pydistutils.cfg on Unix and pydistutils.cfg
+        on Windows/Mac, and setup.cfg in the current directory.
+        on Windows/Mac; and setup.cfg in the current directory.
+        The file in the user's home directory can be disabled with the
+        --no-user-cfg option.
         """
         files = []
 …
         # And look for the user config file
+        user_file = os.path.join(os.path.expanduser('~'), user_filename)
+        if os.path.isfile(user_file):
+            files.append(user_file)
+        if self.want_user_cfg:
+            user_file = os.path.join(os.path.expanduser('~'), user_filename)
+            if os.path.isfile(user_file):
+                files.append(user_file)
         # All platforms support local setup.cfg
 …
             files.append(local_file)
+        if DEBUG:
+            self.announce("using config files: %s" % ', '.join(files))
         return files
+    # find_config_files ()
+    def parse_config_files (self, filenames=None):
+    def parse_config_files(self, filenames=None):
         from ConfigParser import ConfigParser
 …
             filenames = self.find_config_files()
+        if DEBUG: print "Distribution.parse_config_files():"
+        if DEBUG:
+            self.announce("Distribution.parse_config_files():")
         parser = ConfigParser()
         for filename in filenames:
+            if DEBUG: print "  reading", filename
+            if DEBUG:
+                self.announce("  reading %s" % filename)
             parser.read(filename)
             for section in parser.sections():
 …
                     if opt != '__name__':
                         val = parser.get(section,opt)
                         opt = string.replace(opt, '-', '_')
+                        opt = opt.replace('-', '_')
                         opt_dict[opt] = (filename, val)
 …
                     raise DistutilsOptionError, msg
-    # parse_config_files ()
     # -- Command-line parsing methods ----------------------------------
     def parse_command_line (self):
+    def parse_command_line(self):
         """Parse the setup script's command line, taken from the
         'script_args' instance attribute (which defaults to 'sys.argv[1:]'
 …
+        #
         toplevel_options = self._get_toplevel_options()
-        if sys.platform == 'mac':
-            import EasyDialogs
-            cmdlist = self.get_command_list()
-            self.script_args = EasyDialogs.GetArgv(
-                toplevel_options + self.display_options, cmdlist)
         # We have to parse the command line a bit at a time -- global
 …
         if self.handle_display_options(option_order):
             return
         while args:
             args = self._parse_command_opts(parser, args)
 …
         return 1
+    # parse_command_line()
+    def _get_toplevel_options (self):
+    def _get_toplevel_options(self):
         """Return the non-display options recognized at the top level.
 …
+            ]
     def _parse_command_opts (self, parser, args):
+    def _parse_command_opts(self, parser, args):
         """Parse the command-line options for a single command.
         'parser' must be a FancyGetopt instance; 'args' must be the list
 …
         # known options.
         if not (hasattr(cmd_class, 'user_options') and
                 type(cmd_class.user_options) is ListType):
+                isinstance(cmd_class.user_options, list)):
             raise DistutilsClassError, \
                   ("command class %s must provide " +
 …
         negative_opt = self.negative_opt
         if hasattr(cmd_class, 'negative_opt'):
             negative_opt = copy(negative_opt)
+            negative_opt = negative_opt.copy()
             negative_opt.update(cmd_class.negative_opt)
 …
         # format (tuple of four) so we need to preprocess them here.
         if (hasattr(cmd_class, 'help_options') and
             type(cmd_class.help_options) is ListType):
+            isinstance(cmd_class.help_options, list)):
             help_options = fix_help_options(cmd_class.help_options)
         else:
 …
         if (hasattr(cmd_class, 'help_options') and
             type(cmd_class.help_options) is ListType):
+            isinstance(cmd_class.help_options, list)):
             help_option_found=0
             for (help_option, short, desc, func) in cmd_class.help_options:
                 if hasattr(opts, parser.get_attr_name(help_option)):
                     help_option_found=1
+                    #print "showing help for option %s of command %s" % \
+                    #      (help_option[0],cmd_class)
+                    if callable(func):
+                    if hasattr(func, '__call__'):
                         func()
                     else:
 …
         return args
+    # _parse_command_opts ()
+    def finalize_options (self):
+    def finalize_options(self):
         """Set final values for all the options on the Distribution
         instance, analogous to the .finalize_options() method of Command
         objects.
         """
+        keywords = self.metadata.keywords
+        if keywords is not None:
+            if type(keywords) is StringType:
+                keywordlist = string.split(keywords, ',')
+                self.metadata.keywords = map(string.strip, keywordlist)
+        platforms = self.metadata.platforms
+        if platforms is not None:
+            if type(platforms) is StringType:
+                platformlist = string.split(platforms, ',')
+                self.metadata.platforms = map(string.strip, platformlist)
+    def _show_help (self,
+                    parser,
+                    global_options=1,
+                    display_options=1,
+                    commands=[]):
+        for attr in ('keywords', 'platforms'):
+            value = getattr(self.metadata, attr)
+            if value is None:
+                continue
+            if isinstance(value, str):
+                value = [elm.strip() for elm in value.split(',')]
+                setattr(self.metadata, attr, value)
+    def _show_help(self, parser, global_options=1, display_options=1,
+                   commands=[]):
         """Show help for the setup script command-line in the form of
         several lists of command-line options.  'parser' should be a
 …
             parser.set_option_table(options)
             parser.print_help(self.common_usage + "\nGlobal options:")
             print
+            print('')
         if display_options:
 …
                 "Information display options (just display " +
                 "information, ignore any commands)")
             print
+            print('')
         for command in self.commands:
             if type(command) is ClassType and issubclass(command, Command):
+            if isinstance(command, type) and issubclass(command, Command):
                 klass = command
             else:
                 klass = self.get_command_class(command)
             if (hasattr(klass, 'help_options') and
                 type(klass.help_options) is ListType):
+                isinstance(klass.help_options, list)):
                 parser.set_option_table(klass.user_options +
                                         fix_help_options(klass.help_options))
 …
                 parser.set_option_table(klass.user_options)
             parser.print_help("Options for '%s' command:" % klass.__name__)
+            print
+        print gen_usage(self.script_name)
+        return
+    # _show_help ()
+    def handle_display_options (self, option_order):
+            print('')
+        print(gen_usage(self.script_name))
+    def handle_display_options(self, option_order):
         """If there were any non-global "display-only" options
         (--help-commands or the metadata display options) on the command
 …
         if self.help_commands:
             self.print_commands()
             print
             print gen_usage(self.script_name)
+            print('')
+            print(gen_usage(self.script_name))
             return 1
 …
                 value = getattr(self.metadata, "get_"+opt)()
                 if opt in ['keywords', 'platforms']:
                     print string.join(value, ',')
+                    print(','.join(value))
                 elif opt in ('classifiers', 'provides', 'requires',
                              'obsoletes'):
                     print string.join(value, '\n')
+                    print('\n'.join(value))
                 else:
                     print value
+                    print(value)
                 any_display_options = 1
         return any_display_options
+    # handle_display_options()
+    def print_command_list (self, commands, header, max_length):
+    def print_command_list(self, commands, header, max_length):
         """Print a subset of the list of all commands -- used by
         'print_commands()'.
         """
+        print header + ":"
+        print(header + ":")
         for cmd in commands:
 …
                 description = "(no description available)"
+            print "  %-*s  %s" % (max_length, cmd, description)
+    # print_command_list ()
+    def print_commands (self):
+            print("  %-*s  %s" % (max_length, cmd, description))
+    def print_commands(self):
         """Print out a help message listing all available commands with a
         description of each.  The list is divided into "standard commands"
 …
         'description'.
         """
         import distutils.command
         std_commands = distutils.command.__all__
 …
                                     max_length)
+    # print_commands ()
+    def get_command_list (self):
+    def get_command_list(self):
         """Get a list of (command, description) tuples.
         The list is divided into "standard commands" (listed in
 …
     # -- Command class/object methods ----------------------------------
     def get_command_packages (self):
+    def get_command_packages(self):
         """Return a list of packages from which commands are loaded."""
         pkgs = self.command_packages
+        if not isinstance(pkgs, type([])):
+            pkgs = string.split(pkgs or "", ",")
+            for i in range(len(pkgs)):
+                pkgs[i] = string.strip(pkgs[i])
+            pkgs = filter(None, pkgs)
+        if not isinstance(pkgs, list):
+            if pkgs is None:
+                pkgs = ''
+            pkgs = [pkg.strip() for pkg in pkgs.split(',') if pkg != '']
             if "distutils.command" not in pkgs:
                 pkgs.insert(0, "distutils.command")
 …
         return pkgs
     def get_command_class (self, command):
+    def get_command_class(self, command):
         """Return the class that implements the Distutils command named by
         'command'.  First we check the 'cmdclass' dictionary; if the
 …
+    # get_command_class ()
+    def get_command_obj (self, command, create=1):
+    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
 …
         if not cmd_obj and create:
             if DEBUG:
                 print "Distribution.get_command_obj(): " \
                       "creating '%s' command object" % command
+                self.announce("Distribution.get_command_obj(): " \
+                              "creating '%s' command object" % command)
             klass = self.get_command_class(command)
 …
         return cmd_obj
     def _set_command_options (self, command_obj, option_dict=None):
+    def _set_command_options(self, command_obj, option_dict=None):
         """Set the options for 'command_obj' from 'option_dict'.  Basically
         this means copying elements of a dictionary ('option_dict') to
 …
             option_dict = self.get_option_dict(command_name)
+        if DEBUG: print "  setting options for '%s' command:" % command_name
+        if DEBUG:
+            self.announce("  setting options for '%s' command:" % command_name)
         for (option, (source, value)) in option_dict.items():
+            if DEBUG: print "    %s = %s (from %s)" % (option, value, source)
+            if DEBUG:
+                self.announce("    %s = %s (from %s)" % (option, value,
+                                                         source))
             try:
                 bool_opts = map(translate_longopt, command_obj.boolean_options)
 …
             try:
                 is_string = type(value) is StringType
+                is_string = isinstance(value, str)
                 if option in neg_opt and is_string:
                     setattr(command_obj, neg_opt[option], not strtobool(value))
 …
                 raise DistutilsOptionError, msg
     def reinitialize_command (self, command, reinit_subcommands=0):
+    def reinitialize_command(self, command, reinit_subcommands=0):
         """Reinitializes a command to the state it was in when first
         returned by 'get_command_obj()': ie., initialized but not yet
 …
         return command
     # -- Methods that operate on the Distribution ----------------------
     def announce (self, msg, level=1):
         log.debug(msg)
     def run_commands (self):
+    def announce(self, msg, level=log.INFO):
+        log.log(level, msg)
+    def run_commands(self):
         """Run each command that was seen on the setup script command line.
         Uses the list of commands found and cache of command objects
 …
             self.run_command(cmd)
     # -- Methods that operate on its Commands --------------------------
     def run_command (self, command):
+    def run_command(self, command):
         """Do whatever it takes to run a command (including nothing at all,
         if the command has already been run).  Specifically: if we have
 …
     # -- Distribution query methods ------------------------------------
     def has_pure_modules (self):
+    def has_pure_modules(self):
         return len(self.packages or self.py_modules or []) > 0
     def has_ext_modules (self):
+    def has_ext_modules(self):
         return self.ext_modules and len(self.ext_modules) > 0
     def has_c_libraries (self):
+    def has_c_libraries(self):
         return self.libraries and len(self.libraries) > 0
     def has_modules (self):
+    def has_modules(self):
         return self.has_pure_modules() or self.has_ext_modules()
     def has_headers (self):
+    def has_headers(self):
         return self.headers and len(self.headers) > 0
     def has_scripts (self):
+    def has_scripts(self):
         return self.scripts and len(self.scripts) > 0
     def has_data_files (self):
+    def has_data_files(self):
         return self.data_files and len(self.data_files) > 0
     def is_pure (self):
+    def is_pure(self):
         return (self.has_pure_modules() and
                 not self.has_ext_modules() and
 …
     # to self.metadata.get_XXX.  The actual code is in the
     # DistributionMetadata class, below.
-# class Distribution
 class DistributionMetadata:
 …
+                         )
+    def __init__ (self):
+        self.name = None
+        self.version = None
+        self.author = None
+        self.author_email = None
+    def __init__(self, path=None):
+        if path is not None:
+            self.read_pkg_file(open(path))
+        else:
+            self.name = None
+            self.version = None
+            self.author = None
+            self.author_email = None
+            self.maintainer = None
+            self.maintainer_email = None
+            self.url = None
+            self.license = None
+            self.description = None
+            self.long_description = None
+            self.keywords = None
+            self.platforms = None
+            self.classifiers = None
+            self.download_url = None
+            # PEP 314
+            self.provides = None
+            self.requires = None
+            self.obsoletes = None
+    def read_pkg_file(self, file):
+        """Reads the metadata values from a file object."""
+        msg = message_from_file(file)
+        def _read_field(name):
+            value = msg[name]
+            if value == 'UNKNOWN':
+                return None
+            return value
+        def _read_list(name):
+            values = msg.get_all(name, None)
+            if values == []:
+                return None
+            return values
+        metadata_version = msg['metadata-version']
+        self.name = _read_field('name')
+        self.version = _read_field('version')
+        self.description = _read_field('summary')
+        # we are filling author only.
+        self.author = _read_field('author')
         self.maintainer = None
+        self.author_email = _read_field('author-email')
         self.maintainer_email = None
+        self.url = None
+        self.license = None
+        self.description = None
+        self.long_description = None
+        self.keywords = None
+        self.platforms = None
+        self.classifiers = None
+        self.download_url = None
+        # PEP 314
+        self.provides = None
+        self.requires = None
+        self.obsoletes = None
+    def write_pkg_info (self, base_dir):
+        self.url = _read_field('home-page')
+        self.license = _read_field('license')
+        if 'download-url' in msg:
+            self.download_url = _read_field('download-url')
+        else:
+            self.download_url = None
+        self.long_description = _read_field('description')
+        self.description = _read_field('summary')
+        if 'keywords' in msg:
+            self.keywords = _read_field('keywords').split(',')
+        self.platforms = _read_list('platform')
+        self.classifiers = _read_list('classifier')
+        # PEP 314 - these fields only exist in 1.1
+        if metadata_version == '1.1':
+            self.requires = _read_list('requires')
+            self.provides = _read_list('provides')
+            self.obsoletes = _read_list('obsoletes')
+        else:
+            self.requires = None
+            self.provides = None
+            self.obsoletes = None
+    def write_pkg_info(self, base_dir):
         """Write the PKG-INFO file into the release tree.
         """
+        pkg_info = open( os.path.join(base_dir, 'PKG-INFO'), 'w')
+        self.write_pkg_file(pkg_info)
+        pkg_info.close()
+    # write_pkg_info ()
+    def write_pkg_file (self, file):
+        pkg_info = open(os.path.join(base_dir, 'PKG-INFO'), 'w')
+        try:
+            self.write_pkg_file(pkg_info)
+        finally:
+            pkg_info.close()
+    def write_pkg_file(self, file):
         """Write the PKG-INFO format data to a file object.
         """
         version = '1.0'
+        if self.provides or self.requires or self.obsoletes:
+        if (self.provides or self.requires or self.obsoletes or
+            self.classifiers or self.download_url):
             version = '1.1'
 …
             self._write_field(file, 'Download-URL', self.download_url)
         long_desc = rfc822_escape( self.get_long_description())
+        long_desc = rfc822_escape(self.get_long_description())
         self._write_field(file, 'Description', long_desc)
         keywords = string.join( self.get_keywords(), ',')
+        keywords = ','.join(self.get_keywords())
         if keywords:
             self._write_field(file, 'Keywords', keywords)
 …
     def _write_list (self, file, name, values):
         for value in values:
             self._write_field(file, name, value)
 …
     # -- Metadata query methods ----------------------------------------
     def get_name (self):
+    def get_name(self):
         return self.name or "UNKNOWN"
 …
         return self.version or "0.0.0"
     def get_fullname (self):
+    def get_fullname(self):
         return "%s-%s" % (self.get_name(), self.get_version())
 …
     def get_contact_email(self):
+        return (self.maintainer_email or
+                self.author_email or
+                "UNKNOWN")
+        return self.maintainer_email or self.author_email or "UNKNOWN"
     def get_url(self):
 …
     # PEP 314
     def get_requires(self):
         return self.requires or []
 …
         self.obsoletes = value
+# class DistributionMetadata
+def fix_help_options (options):
+def fix_help_options(options):
     """Convert a 4-tuple 'help_options' list as found in various command
     classes to the 3-tuple form required by FancyGetopt.
 …
         new_options.append(help_tuple[0:3])
     return new_options
-if __name__ == "__main__":
-    dist = Distribution()
-    print "ok"

python/vendor/current/Lib/distutils/emxccompiler.py

-              r2
+              r388
 # * EMX gcc 2.81/EMX 0.9d fix03
 __revision__ = "$Id: emxccompiler.py 34786 2003-12-02 12:17:59Z aimacintyre $"
+__revision__ = "$Id$"
 import os,sys,copy
 …
         # But we do this only once, and it is fast enough
         f = open(fn)
+        s = f.read()
+        f.close()
+        try:
+            s = f.read()
+        finally:
+            f.close()
     except IOError, exc:
 …
     if gcc_exe:
         out = os.popen(gcc_exe + ' -dumpversion','r')
+        out_string = out.read()
+        out.close()
+        try:
+            out_string = out.read()
+        finally:
+            out.close()
         result = re.search('(\d+\.\d+\.\d+)',out_string)
         if result:

python/vendor/current/Lib/distutils/errors.py

-              r2
+              r388
 symbols whose names start with "Distutils" and end with "Error"."""
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id$"
+__revision__ = "$Id: errors.py 77376 2010-01-08 23:27:23Z tarek.ziade $"
+class DistutilsError(Exception):
+    """The root of all Distutils evil."""
+class DistutilsError (Exception):
+    """The root of all Distutils evil."""
+    pass
+class DistutilsModuleError (DistutilsError):
+class DistutilsModuleError(DistutilsError):
     """Unable to load an expected module, or to find an expected class
     within some module (in particular, command modules and classes)."""
-    pass
 class DistutilsClassError (DistutilsError):
+class DistutilsClassError(DistutilsError):
     """Some command class (or possibly distribution class, if anyone
     feels a need to subclass Distribution) is found not to be holding
     up its end of the bargain, ie. implementing some part of the
     "command "interface."""
-    pass
 class DistutilsGetoptError (DistutilsError):
+class DistutilsGetoptError(DistutilsError):
     """The option table provided to 'fancy_getopt()' is bogus."""
-    pass
 class DistutilsArgError (DistutilsError):
+class DistutilsArgError(DistutilsError):
     """Raised by fancy_getopt in response to getopt.error -- ie. an
     error in the command line usage."""
-    pass
 class DistutilsFileError (DistutilsError):
+class DistutilsFileError(DistutilsError):
     """Any problems in the filesystem: expected file not found, etc.
     Typically this is for problems that we detect before IOError or
     OSError could be raised."""
-    pass
 class DistutilsOptionError (DistutilsError):
+class DistutilsOptionError(DistutilsError):
     """Syntactic/semantic errors in command options, such as use of
     mutually conflicting options, or inconsistent options,
 …
     files, or what-have-you -- but if we *know* something originated in
     the setup script, we'll raise DistutilsSetupError instead."""
-    pass
 class DistutilsSetupError (DistutilsError):
+class DistutilsSetupError(DistutilsError):
     """For errors that can be definitely blamed on the setup script,
     such as invalid keyword arguments to 'setup()'."""
-    pass
 class DistutilsPlatformError (DistutilsError):
+class DistutilsPlatformError(DistutilsError):
     """We don't know how to do something on the current platform (but
     we do know how to do it on some platform) -- eg. trying to compile
     C files on a platform not supported by a CCompiler subclass."""
-    pass
 class DistutilsExecError (DistutilsError):
+class DistutilsExecError(DistutilsError):
     """Any problems executing an external program (such as the C
     compiler, when compiling C files)."""
-    pass
 class DistutilsInternalError (DistutilsError):
+class DistutilsInternalError(DistutilsError):
     """Internal inconsistencies or impossibilities (obviously, this
     should never be seen if the code is working!)."""
-    pass
 class DistutilsTemplateError (DistutilsError):
+class DistutilsTemplateError(DistutilsError):
     """Syntax error in a file list template."""
 …
 # Exception classes used by the CCompiler implementation classes
 class CCompilerError (Exception):
+class CCompilerError(Exception):
     """Some compile/link operation failed."""
 class PreprocessError (CCompilerError):
+class PreprocessError(CCompilerError):
     """Failure to preprocess one or more C/C++ files."""
 class CompileError (CCompilerError):
+class CompileError(CCompilerError):
     """Failure to compile one or more C/C++ source files."""
 class LibError (CCompilerError):
+class LibError(CCompilerError):
     """Failure to create a static library from one or more C/C++ object
     files."""
 class LinkError (CCompilerError):
+class LinkError(CCompilerError):
     """Failure to link one or more C/C++ object files into an executable
     or shared library file."""
 class UnknownFileError (CCompilerError):
+class UnknownFileError(CCompilerError):
     """Attempt to process an unknown file type."""

python/vendor/current/Lib/distutils/extension.py

-              r2
+              r388
 modules in setup scripts."""
 __revision__ = "$Id: extension.py 37623 2004-10-14 10:02:08Z anthonybaxter $"
+__revision__ = "$Id$"
 import os, string, sys
 …
                     strip_comments=1, skip_blanks=1, join_lines=1,
                     lstrip_ws=1, rstrip_ws=1)
+    extensions = []
+    while 1:
+        line = file.readline()
+        if line is None:                # eof
+            break
+        if _variable_rx.match(line):    # VAR=VALUE, handled in first pass
+            continue
+        if line[0] == line[-1] == "*":
+            file.warn("'%s' lines not handled yet" % line)
+            continue
+        #print "original line: " + line
+        line = expand_makefile_vars(line, vars)
+        words = split_quoted(line)
+        #print "expanded line: " + line
+        # NB. this parses a slightly different syntax than the old
+        # makesetup script: here, there must be exactly one extension per
+        # line, and it must be the first word of the line.  I have no idea
+        # why the old syntax supported multiple extensions per line, as
+        # they all wind up being the same.
+        module = words[0]
+        ext = Extension(module, [])
+        append_next_word = None
+        for word in words[1:]:
+            if append_next_word is not None:
+                append_next_word.append(word)
+                append_next_word = None
+    try:
+        extensions = []
+        while 1:
+            line = file.readline()
+            if line is None:                # eof
+                break
+            if _variable_rx.match(line):    # VAR=VALUE, handled in first pass
                 continue
+            suffix = os.path.splitext(word)[1]
+            switch = word[0:2] ; value = word[2:]
+            if suffix in (".c", ".cc", ".cpp", ".cxx", ".c++", ".m", ".mm"):
+                # hmm, should we do something about C vs. C++ sources?
+                # or leave it up to the CCompiler implementation to
+                # worry about?
+                ext.sources.append(word)
+            elif switch == "-I":
+                ext.include_dirs.append(value)
+            elif switch == "-D":
+                equals = string.find(value, "=")
+                if equals == -1:        # bare "-DFOO" -- no value
+                    ext.define_macros.append((value, None))
+                else:                   # "-DFOO=blah"
+                    ext.define_macros.append((value[0:equals],
+                                              value[equals+2:]))
+            elif switch == "-U":
+                ext.undef_macros.append(value)
+            elif switch == "-C":        # only here 'cause makesetup has it!
+                ext.extra_compile_args.append(word)
+            elif switch == "-l":
+                ext.libraries.append(value)
+            elif switch == "-L":
+                ext.library_dirs.append(value)
+            elif switch == "-R":
+                ext.runtime_library_dirs.append(value)
+            elif word == "-rpath":
+                append_next_word = ext.runtime_library_dirs
+            elif word == "-Xlinker":
+                append_next_word = ext.extra_link_args
+            elif word == "-Xcompiler":
+                append_next_word = ext.extra_compile_args
+            elif switch == "-u":
+                ext.extra_link_args.append(word)
+                if not value:
+                if line[0] == line[-1] == "*":
+                    file.warn("'%s' lines not handled yet" % line)
+                    continue
+            #print "original line: " + line
+            line = expand_makefile_vars(line, vars)
+            words = split_quoted(line)
+            #print "expanded line: " + line
+            # NB. this parses a slightly different syntax than the old
+            # makesetup script: here, there must be exactly one extension per
+            # line, and it must be the first word of the line.  I have no idea
+            # why the old syntax supported multiple extensions per line, as
+            # they all wind up being the same.
+            module = words[0]
+            ext = Extension(module, [])
+            append_next_word = None
+            for word in words[1:]:
+                if append_next_word is not None:
+                    append_next_word.append(word)
+                    append_next_word = None
+                    continue
+                suffix = os.path.splitext(word)[1]
+                switch = word[0:2] ; value = word[2:]
+                if suffix in (".c", ".cc", ".cpp", ".cxx", ".c++", ".m", ".mm"):
+                    # hmm, should we do something about C vs. C++ sources?
+                    # or leave it up to the CCompiler implementation to
+                    # worry about?
+                    ext.sources.append(word)
+                elif switch == "-I":
+                    ext.include_dirs.append(value)
+                elif switch == "-D":
+                    equals = string.find(value, "=")
+                    if equals == -1:        # bare "-DFOO" -- no value
+                        ext.define_macros.append((value, None))
+                    else:                   # "-DFOO=blah"
+                        ext.define_macros.append((value[0:equals],
+                                                  value[equals+2:]))
+                elif switch == "-U":
+                    ext.undef_macros.append(value)
+                elif switch == "-C":        # only here 'cause makesetup has it!
+                    ext.extra_compile_args.append(word)
+                elif switch == "-l":
+                    ext.libraries.append(value)
+                elif switch == "-L":
+                    ext.library_dirs.append(value)
+                elif switch == "-R":
+                    ext.runtime_library_dirs.append(value)
+                elif word == "-rpath":
+                    append_next_word = ext.runtime_library_dirs
+                elif word == "-Xlinker":
                     append_next_word = ext.extra_link_args
+            elif suffix in (".a", ".so", ".sl", ".o", ".dylib"):
+                # NB. a really faithful emulation of makesetup would
+                # append a .o file to extra_objects only if it
+                # had a slash in it; otherwise, it would s/.o/.c/
+                # and append it to sources.  Hmmmm.
+                ext.extra_objects.append(word)
+            else:
+                file.warn("unrecognized argument '%s'" % word)
+        extensions.append(ext)
+                elif word == "-Xcompiler":
+                    append_next_word = ext.extra_compile_args
+                elif switch == "-u":
+                    ext.extra_link_args.append(word)
+                    if not value:
+                        append_next_word = ext.extra_link_args
+                elif word == "-Xcompiler":
+                    append_next_word = ext.extra_compile_args
+                elif switch == "-u":
+                    ext.extra_link_args.append(word)
+                    if not value:
+                        append_next_word = ext.extra_link_args
+                elif suffix in (".a", ".so", ".sl", ".o", ".dylib"):
+                    # NB. a really faithful emulation of makesetup would
+                    # append a .o file to extra_objects only if it
+                    # had a slash in it; otherwise, it would s/.o/.c/
+                    # and append it to sources.  Hmmmm.
+                    ext.extra_objects.append(word)
+                else:
+                    file.warn("unrecognized argument '%s'" % word)
+            extensions.append(ext)
+    finally:
+        file.close()
         #print "module:", module

python/vendor/current/Lib/distutils/fancy_getopt.py

-              r2
+              r388
 """
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: fancy_getopt.py 60923 2008-02-21 18:18:37Z guido.van.rossum $"
+import sys, string, re
+from types import *
+__revision__ = "$Id$"
+import sys
+import string
+import re
 import getopt
 from distutils.errors import *
+from distutils.errors import DistutilsGetoptError, DistutilsArgError
 # Much like command_re in distutils.core, this is close to but not quite
 …
     def _check_alias_dict (self, aliases, what):
         assert type(aliases) is DictionaryType
+        assert isinstance(aliases, dict)
         for (alias, opt) in aliases.items():
             if alias not in self.option_index:
 …
             # Type- and value-check the option names
             if type(long) is not StringType or len(long) < 2:
+            if not isinstance(long, str) or len(long) < 2:
                 raise DistutilsGetoptError, \
                       ("invalid long option '%s': "
 …
             if (not ((short is None) or
                      (type(short) is StringType and len(short) == 1))):
+                     (isinstance(short, str) and len(short) == 1))):
                 raise DistutilsGetoptError, \
                       ("invalid short option '%s': "
 …
     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 "_".
 …
         for opt in options:
             setattr(self, opt, None)
-# class OptionDummy
-if __name__ == "__main__":
-    text = """\
-Tra-la-la, supercalifragilisticexpialidocious.
-How *do* you spell that odd word, anyways?
-(Someone ask Mary -- she'll know [or she'll
-say, "How should I know?"].)"""
-    for w in (10, 20, 30, 40):
-        print "width: %d" % w
-        print string.join(wrap_text(text, w), "\n")
-        print

python/vendor/current/Lib/distutils/file_util.py

-              r2
+              r388
 """
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: file_util.py 37828 2004-11-10 22:23:15Z loewis $"
+__revision__ = "$Id$"
 import os
 …
 # for generating verbose output in 'copy_file()'
+_copy_action = { None:   'copying',
+                 'hard': 'hard linking',
+                 'sym':  'symbolically linking' }
+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'
+    bytes (default 16k).  No attempt is made to handle anything apart from
+    regular files.
+_copy_action = {None: 'copying',
+                'hard': 'hard linking',
+                'sym': 'symbolically linking'}
+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' bytes (default 16k).  No attempt
+    is made to handle anything apart from regular files.
     """
     # Stolen from shutil module in the standard library, but with
     # custom error-handling added.
     fsrc = None
     fdst = None
 …
             fsrc = open(src, 'rb')
         except os.error, (errno, errstr):
+            raise DistutilsFileError, \
+                  "could not open '%s': %s" % (src, errstr)
+            raise DistutilsFileError("could not open '%s': %s" % (src, errstr))
         if os.path.exists(dst):
 …
                 os.unlink(dst)
             except os.error, (errno, errstr):
                 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, (errno, errstr):
             raise DistutilsFileError, \
                   "could not create '%s': %s" % (dst, errstr)
+            raise DistutilsFileError(
+                  "could not create '%s': %s" % (dst, errstr))
         while 1:
 …
                 buf = fsrc.read(buffer_size)
             except os.error, (errno, errstr):
                 raise DistutilsFileError, \
                       "could not read from '%s': %s" % (src, errstr)
+                raise DistutilsFileError(
+                      "could not read from '%s': %s" % (src, errstr))
             if not buf:
 …
                 fdst.write(buf)
             except os.error, (errno, errstr):
                 raise DistutilsFileError, \
                       "could not write to '%s': %s" % (dst, errstr)
+                raise DistutilsFileError(
+                      "could not write to '%s': %s" % (dst, errstr))
     finally:
 …
             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):
+    """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'
+    is true (the default), the file's mode (type and permission bits, or
+    whatever is analogous on the current platform) is copied.  If
+    'preserve_times' is true (the default), the last-modified and
+    last-access times are copied as well.  If 'update' is true, 'src' will
+    only be copied if 'dst' does not exist, or if 'dst' does exist but is
+    older than 'src'.
+def copy_file(src, dst, preserve_mode=1, preserve_times=1, update=0,
+              link=None, verbose=1, 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' is true (the default),
+    the file's mode (type and permission bits, or whatever is analogous on
+    the current platform) is copied.  If 'preserve_times' is true (the
+    default), the last-modified and last-access times are copied as well.
+    If 'update' is true, 'src' will only be copied if 'dst' does not exist,
+    or if 'dst' does exist but is older than 'src'.
     'link' allows you to make hard links (os.link) or symbolic links
 …
     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):
 …
     if update and not newer(src, dst):
+        log.debug("not copying %s (output up-to-date)", src)
+        if verbose >= 1:
+            log.debug("not copying %s (output up-to-date)", src)
         return dst, 0
 …
         action = _copy_action[link]
     except KeyError:
+        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:
+        log.info("%s %s -> %s", action, src, dst)
+        raise ValueError("invalid value '%s' for 'link' argument" % link)
+    if verbose >= 1:
+        if os.path.basename(dst) == os.path.basename(src):
+            log.info("%s %s -> %s", action, src, dir)
+        else:
+            log.info("%s %s -> %s", action, src, dst)
     if dry_run:
         return (dst, 1)
-    # On Mac OS, use the native file copy routine
-    if os.name == 'mac':
-        import macostools
-        try:
-            macostools.copy(src, dst, 0, preserve_times)
-        except os.error, exc:
-            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)
     elif link == 'hard':
+    if link == 'hard':
         if not (os.path.exists(dst) and os.path.samefile(src, dst)):
             os.link(src, dst)
 …
     return (dst, 1)
-# copy_file ()
 # XXX I suspect this is Unix-specific -- need porting help!
+def move_file (src, dst,
+               verbose=0,
+               dry_run=0):
+    """Move a file 'src' to 'dst'.  If 'dst' is a directory, the file will
+    be moved into it with the same name; otherwise, 'src' is just renamed
+    to 'dst'.  Return the new full name of the file.
+def move_file (src, dst, verbose=1, dry_run=0):
+    """Move a file 'src' to 'dst'.
+    If 'dst' is a directory, the file will be moved into it with the same
+    name; otherwise, 'src' is just renamed to 'dst'.  Return the new
+    full name of the file.
     Handles cross-device moves on Unix using 'copy_file()'.  What about
 …
     import errno
+    log.info("moving %s -> %s", src, dst)
+    if verbose >= 1:
+        log.info("moving %s -> %s", src, dst)
     if dry_run:
 …
     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, \
+        raise DistutilsFileError(
               "can't move '%s': destination '%s' not a valid path" % \
               (src, dst)
+              (src, dst))
     copy_it = 0
 …
             copy_it = 1
         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)
+        copy_file(src, dst, verbose=verbose)
         try:
             os.unlink(src)
 …
             except os.error:
                 pass
             raise DistutilsFileError, \
+            raise DistutilsFileError(
                   ("couldn't move '%s' to '%s' by copy/delete: " +
+                   "delete '%s' failed: %s") % \
+                  (src, dst, src, msg)
+                   "delete '%s' failed: %s") %
+                  (src, dst, src, msg))
     return dst
-# move_file ()
 …
     """
     f = open(filename, "w")
+    for line in contents:
+        f.write(line + "\n")
+    f.close()
+    try:
+        for line in contents:
+            f.write(line + "\n")
+    finally:
+        f.close()

python/vendor/current/Lib/distutils/filelist.py

-              r2
+              r388
 """
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: filelist.py 76044 2009-11-01 23:04:26Z tarek.ziade $"
+import os, string, re
+__revision__ = "$Id$"
+import os, re
 import fnmatch
-from types import *
 from distutils.util import convert_path
 from distutils.errors import DistutilsTemplateError, DistutilsInternalError
 …
 class FileList:
     """A list of files built by on exploring the filesystem and filtered by
     applying various patterns to what we find there.
 …
     """
+    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.
 …
     # -- 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 = map(os.path.split, self.files)
 …
         self.files = []
         for sort_tuple in sortable_files:
             self.files.append(apply(os.path.join, sort_tuple))
+            self.files.append(os.path.join(*sort_tuple))
     # -- 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):
 …
     # -- "File template" methods ---------------------------------------
     def _parse_template_line (self, line):
         words = string.split(line)
+    def _parse_template_line(self, line):
+        words = line.split()
         action = words[0]
 …
         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
 …
         # three are defined depends on the action; it'll be either
         # patterns, (dir and patterns), or (dir_pattern).
         (action, patterns, dir, dir_pattern) = self._parse_template_line(line)
+        action, patterns, dir, dir_pattern = self._parse_template_line(line)
         # OK, now we know that the action is valid and we have the
 …
         # can proceed with minimal error-checking.
         if action == 'include':
             self.debug_print("include " + string.join(patterns))
+            self.debug_print("include " + ' '.join(patterns))
             for pattern in patterns:
                 if not self.include_pattern(pattern, anchor=1):
 …
         elif action == 'exclude':
             self.debug_print("exclude " + string.join(patterns))
+            self.debug_print("exclude " + ' '.join(patterns))
             for pattern in patterns:
                 if not self.exclude_pattern(pattern, anchor=1):
 …
         elif action == 'global-include':
             self.debug_print("global-include " + string.join(patterns))
+            self.debug_print("global-include " + ' '.join(patterns))
             for pattern in patterns:
                 if not self.include_pattern(pattern, anchor=0):
 …
         elif action == 'global-exclude':
             self.debug_print("global-exclude " + string.join(patterns))
+            self.debug_print("global-exclude " + ' '.join(patterns))
             for pattern in patterns:
                 if not self.exclude_pattern(pattern, anchor=0):
 …
         elif action == 'recursive-include':
             self.debug_print("recursive-include %s %s" %
                              (dir, string.join(patterns)))
+                             (dir, ' '.join(patterns)))
             for pattern in patterns:
                 if not self.include_pattern(pattern, prefix=dir):
 …
         elif action == 'recursive-exclude':
             self.debug_print("recursive-exclude %s %s" %
                              (dir, string.join(patterns)))
+                             (dir, ' '.join(patterns)))
             for pattern in patterns:
                 if not self.exclude_pattern(pattern, prefix=dir):
 …
                   "this cannot happen: invalid action '%s'" % action
-    # process_template_line ()
     # -- 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: '*'
+        and '?'  match non-special characters, where "special" is platform-
+        dependent: slash on Unix; colon, slash, and backslash on
+        match 'pattern', a Unix-style wildcard (glob) pattern.
+        Patterns are not quite the same as implemented by the 'fnmatch'
+        module: '*' and '?'  match non-special characters, where "special"
+        is platform-dependent: slash on Unix; colon, slash, and backslash on
         DOS/Windows; and colon on Mac OS.
 …
         Return 1 if files are found.
         """
+        # XXX docstring lying about what the special chars are?
         files_found = 0
         pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
 …
         return files_found
+    # include_pattern ()
+    def exclude_pattern (self, pattern,
+                         anchor=1, prefix=None, is_regex=0):
+    def exclude_pattern(self, pattern, anchor=1, prefix=None, is_regex=0):
         """Remove strings (presumably filenames) from 'files' that match
+        '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.
+        '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.
         """
         files_found = 0
 …
         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').
 …
 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
+    platform-specific).
+    """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 platform-specific).
     """
     pattern_re = fnmatch.translate(pattern)
 …
     # and by extension they shouldn't match such "special characters" under
     # any OS.  So change all non-escaped dots in the RE to match any
+    # character except the special characters.
+    # XXX currently the "special characters" are just slash -- i.e. this is
+    # Unix-only.
+    pattern_re = re.sub(r'((?<!\\)(\\\\)*)\.', r'\1[^/]', pattern_re)
+    # character except the special characters (currently: just os.sep).
+    sep = os.sep
+    if os.sep == '\\':
+        # we're using a regex to manipulate a regex, so we need
+        # to escape the backslash twice
+        sep = r'\\\\'
+    escaped = r'\1[^%s]' % sep
+    pattern_re = re.sub(r'((?<!\\)(\\\\)*)\.', escaped, 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,
+    expression.
+    Return the compiled regex.  If 'is_regex' true,
     then 'pattern' is directly compiled to a regex (if it's a string)
     or just returned as-is (assumes it's a regex object).
     """
     if is_regex:
         if type(pattern) is StringType:
+        if isinstance(pattern, str):
             return re.compile(pattern)
         else:
 …
         # ditch end of pattern character
         empty_pattern = glob_to_re('')
+        prefix_re = (glob_to_re(prefix))[:-len(empty_pattern)]
+        pattern_re = "^" + os.path.join(prefix_re, ".*" + pattern_re)
+        prefix_re = glob_to_re(prefix)[:-len(empty_pattern)]
+        sep = os.sep
+        if os.sep == '\\':
+            sep = r'\\'
+        pattern_re = "^" + sep.join((prefix_re, ".*" + pattern_re))
     else:                               # no prefix -- respect anchor flag
         if anchor:
 …
     return re.compile(pattern_re)
-# translate_pattern ()

python/vendor/current/Lib/distutils/log.py

-              r2
+              r388
 """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
 …
     def _log(self, level, msg, args):
+        if level not in (DEBUG, INFO, WARN, ERROR, FATAL):
+            raise ValueError('%s wrong log level' % str(level))
         if level >= self.threshold:
             if not args:
                 # msg may contain a '%'. If args is empty,
                 # don't even try to string-format
                 print msg
+            if args:
+                msg = msg % args
+            if level in (WARN, ERROR, FATAL):
+                stream = sys.stderr
             else:
+                print msg % args
+            sys.stdout.flush()
+                stream = sys.stdout
+            stream.write('%s\n' % msg)
+            stream.flush()
     def log(self, level, msg, *args):

python/vendor/current/Lib/distutils/msvc9compiler.py

-              r2
+              r388
 # ported to VS2005 and VS 2008 by Christian Heimes
 __revision__ = "$Id: msvc9compiler.py 76652 2009-12-03 20:56:15Z martin.v.loewis $"
+__revision__ = "$Id$"
 import os
 …
 import sys
 import re
 from distutils.errors import (DistutilsExecError, DistutilsPlatformError,
+    CompileError, LibError, LinkError)
+from distutils.ccompiler import (CCompiler, gen_preprocess_options,
+    gen_lib_options)
+                              CompileError, LibError, LinkError)
+from distutils.ccompiler import CCompiler, gen_lib_options
 from distutils import log
 from distutils.util import get_platform
 …
          _winreg.HKEY_CLASSES_ROOT)
+VS_BASE = r"Software\Microsoft\VisualStudio\%0.1f"
+WINSDK_BASE = r"Software\Microsoft\Microsoft SDKs\Windows"
+NET_BASE = r"Software\Microsoft\.NETFramework"
+NATIVE_WIN64 = (sys.platform == 'win32' and sys.maxsize > 2**32)
+if NATIVE_WIN64:
+    # Visual C++ is a 32-bit application, so we need to look in
+    # the corresponding registry branch, if we're running a
+    # 64-bit Python on Win64
+    VS_BASE = r"Software\Wow6432Node\Microsoft\VisualStudio\%0.1f"
+    VSEXPRESS_BASE = r"Software\Wow6432Node\Microsoft\VCExpress\%0.1f"
+    WINSDK_BASE = r"Software\Wow6432Node\Microsoft\Microsoft SDKs\Windows"
+    NET_BASE = r"Software\Wow6432Node\Microsoft\.NETFramework"
+else:
+    VS_BASE = r"Software\Microsoft\VisualStudio\%0.1f"
+    VSEXPRESS_BASE = r"Software\Microsoft\VCExpress\%0.1f"
+    WINSDK_BASE = r"Software\Microsoft\Microsoft SDKs\Windows"
+    NET_BASE = r"Software\Microsoft\.NETFramework"
 # A map keyed by get_platform() return values to values accepted by
 …
     """
-    @classmethod
     def get_value(cls, path, key):
         for base in HKEYS:
 …
                 return d[key]
         raise KeyError(key)
+    @classmethod
+    get_value = classmethod(get_value)
     def read_keys(cls, base, key):
         """Return list of registry keys."""
 …
             i += 1
         return L
+    @classmethod
+    read_keys = classmethod(read_keys)
     def read_values(cls, base, key):
         """Return dict of registry keys and values.
 …
             i += 1
         return d
+    @staticmethod
+    read_values = classmethod(read_values)
     def convert_mbcs(s):
         dec = getattr(s, "decode", None)
 …
                 pass
         return s
+    convert_mbcs = staticmethod(convert_mbcs)
 class MacroExpander:
 …
             else:
                 raise KeyError("sdkinstallrootv2.0")
         except KeyError as exc: #
+        except KeyError:
             raise DistutilsPlatformError(
             """Python was built with Visual Studio 2008;
 …
                                    "productdir")
     except KeyError:
-        log.debug("Unable to find productdir in registry")
         productdir = None
+    # trying Express edition
+    if productdir is None:
+        vsbase = VSEXPRESS_BASE % version
+        try:
+            productdir = Reg.get_value(r"%s\Setup\VC" % vsbase,
+                                       "productdir")
+        except KeyError:
+            productdir = None
+            log.debug("Unable to find productdir in registry")
     if not productdir or not os.path.isdir(productdir):
 …
                              stdout=subprocess.PIPE,
                              stderr=subprocess.PIPE)
+    stdout, stderr = popen.communicate()
+    if popen.wait() != 0:
+        raise DistutilsPlatformError(stderr.decode("mbcs"))
+    stdout = stdout.decode("mbcs")
+    for line in stdout.split("\n"):
+        line = Reg.convert_mbcs(line)
+        if '=' not in line:
+            continue
+        line = line.strip()
+        key, value = line.split('=', 1)
+        key = key.lower()
+        if key in interesting:
+            if value.endswith(os.pathsep):
+                value = value[:-1]
+            result[key] = removeDuplicates(value)
+    try:
+        stdout, stderr = popen.communicate()
+        if popen.wait() != 0:
+            raise DistutilsPlatformError(stderr.decode("mbcs"))
+        stdout = stdout.decode("mbcs")
+        for line in stdout.split("\n"):
+            line = Reg.convert_mbcs(line)
+            if '=' not in line:
+                continue
+            line = line.strip()
+            key, value = line.split('=', 1)
+            key = key.lower()
+            if key in interesting:
+                if value.endswith(os.pathsep):
+                    value = value[:-1]
+                result[key] = removeDuplicates(value)
+    finally:
+        popen.stdout.close()
+        popen.stderr.close()
     if len(result) != len(interesting):
 …
                     self.spawn([self.rc] + pp_opts +
                                [output_opt] + [input_opt])
                 except DistutilsExecError as msg:
+                except DistutilsExecError, msg:
                     raise CompileError(msg)
                 continue
 …
                                ["/fo" + obj] + [rc_file])
                 except DistutilsExecError as msg:
+                except DistutilsExecError, msg:
                     raise CompileError(msg)
                 continue
 …
                            [input_opt, output_opt] +
                            extra_postargs)
             except DistutilsExecError as msg:
+            except DistutilsExecError, msg:
                 raise CompileError(msg)
 …
             try:
                 self.spawn([self.lib] + lib_args)
             except DistutilsExecError as msg:
+            except DistutilsExecError, msg:
                 raise LibError(msg)
         else:
 …
                 ld_args.append ('/IMPLIB:' + implib_file)
+            # Embedded manifests are recommended - see MSDN article titled
+            # "How to: Embed a Manifest Inside a C/C++ Application"
+            # (currently at http://msdn2.microsoft.com/en-us/library/ms235591(VS.80).aspx)
+            # Ask the linker to generate the manifest in the temp dir, so
+            # we can embed it later.
+            temp_manifest = os.path.join(
+                    build_temp,
+                    os.path.basename(output_filename) + ".manifest")
+            ld_args.append('/MANIFESTFILE:' + temp_manifest)
+            self.manifest_setup_ldargs(output_filename, build_temp, ld_args)
             if extra_preargs:
 …
             try:
                 self.spawn([self.linker] + ld_args)
             except DistutilsExecError as msg:
+            except DistutilsExecError, msg:
                 raise LinkError(msg)
 …
             # manifest.  Maybe we should link to a temp file?  OTOH, that
             # implies a build environment error that shouldn't go undetected.
             if target_desc == CCompiler.EXECUTABLE:
                 mfid = 1
             else:
                 mfid = 2
+            mfinfo = self.manifest_get_embed_info(target_desc, ld_args)
+            if mfinfo is not None:
+                mffilename, mfid = mfinfo
+                out_arg = '-outputresource:%s;%s' % (output_filename, mfid)
                 try:
+                    # Remove references to the Visual C runtime, so they will
+                    # fall through to the Visual C dependency of Python.exe.
+                    # This way, when installed for a restricted user (e.g.
+                    # runtimes are not in WinSxS folder, but in Python's own
+                    # folder), the runtimes do not need to be in every folder
+                    # with .pyd's.
+                    manifest_f = open(temp_manifest, "rb")
+                    manifest_buf = manifest_f.read()
+                    manifest_f.close()
+                    pattern = re.compile(
+                        r"""<assemblyIdentity.*?name=("|')Microsoft\."""\
+                        r"""VC\d{2}\.CRT("|').*?(/>|</assemblyIdentity>)""",
+                        re.DOTALL)
+                    manifest_buf = re.sub(pattern, "", manifest_buf)
+                    pattern = "<dependentAssembly>\s*</dependentAssembly>"
+                    manifest_buf = re.sub(pattern, "", manifest_buf)
+                    manifest_f = open(temp_manifest, "wb")
+                    manifest_f.write(manifest_buf)
+                    manifest_f.close()
+                except IOError:
+                    pass
+            out_arg = '-outputresource:%s;%s' % (output_filename, mfid)
+                    self.spawn(['mt.exe', '-nologo', '-manifest',
+                                mffilename, out_arg])
+                except DistutilsExecError, msg:
+                    raise LinkError(msg)
+        else:
+            log.debug("skipping %s (up-to-date)", output_filename)
+    def manifest_setup_ldargs(self, output_filename, build_temp, ld_args):
+        # If we need a manifest at all, an embedded manifest is recommended.
+        # See MSDN article titled
+        # "How to: Embed a Manifest Inside a C/C++ Application"
+        # (currently at http://msdn2.microsoft.com/en-us/library/ms235591(VS.80).aspx)
+        # Ask the linker to generate the manifest in the temp dir, so
+        # we can check it, and possibly embed it, later.
+        temp_manifest = os.path.join(
+                build_temp,
+                os.path.basename(output_filename) + ".manifest")
+        ld_args.append('/MANIFESTFILE:' + temp_manifest)
+    def manifest_get_embed_info(self, target_desc, ld_args):
+        # If a manifest should be embedded, return a tuple of
+        # (manifest_filename, resource_id).  Returns None if no manifest
+        # should be embedded.  See http://bugs.python.org/issue7833 for why
+        # we want to avoid any manifest for extension modules if we can)
+        for arg in ld_args:
+            if arg.startswith("/MANIFESTFILE:"):
+                temp_manifest = arg.split(":", 1)[1]
+                break
+        else:
+            # no /MANIFESTFILE so nothing to do.
+            return None
+        if target_desc == CCompiler.EXECUTABLE:
+            # by default, executables always get the manifest with the
+            # CRT referenced.
+            mfid = 1
+        else:
+            # Extension modules try and avoid any manifest if possible.
+            mfid = 2
+            temp_manifest = self._remove_visual_c_ref(temp_manifest)
+        if temp_manifest is None:
+            return None
+        return temp_manifest, mfid
+    def _remove_visual_c_ref(self, manifest_file):
+        try:
+            # Remove references to the Visual C runtime, so they will
+            # fall through to the Visual C dependency of Python.exe.
+            # This way, when installed for a restricted user (e.g.
+            # runtimes are not in WinSxS folder, but in Python's own
+            # folder), the runtimes do not need to be in every folder
+            # with .pyd's.
+            # Returns either the filename of the modified manifest or
+            # None if no manifest should be embedded.
+            manifest_f = open(manifest_file)
             try:
+                self.spawn(['mt.exe', '-nologo', '-manifest',
+                            temp_manifest, out_arg])
+            except DistutilsExecError as msg:
+                raise LinkError(msg)
+        else:
+            log.debug("skipping %s (up-to-date)", output_filename)
+                manifest_buf = manifest_f.read()
+            finally:
+                manifest_f.close()
+            pattern = re.compile(
+                r"""<assemblyIdentity.*?name=("|')Microsoft\."""\
+                r"""VC\d{2}\.CRT("|').*?(/>|</assemblyIdentity>)""",
+                re.DOTALL)
+            manifest_buf = re.sub(pattern, "", manifest_buf)
+            pattern = "<dependentAssembly>\s*</dependentAssembly>"
+            manifest_buf = re.sub(pattern, "", manifest_buf)
+            # Now see if any other assemblies are referenced - if not, we
+            # don't want a manifest embedded.
+            pattern = re.compile(
+                r"""<assemblyIdentity.*?name=(?:"|')(.+?)(?:"|')"""
+                r""".*?(?:/>|</assemblyIdentity>)""", re.DOTALL)
+            if re.search(pattern, manifest_buf) is None:
+                return None
+            manifest_f = open(manifest_file, 'w')
+            try:
+                manifest_f.write(manifest_buf)
+                return manifest_file
+            finally:
+                manifest_f.close()
+        except IOError:
+            pass
     # -- Miscellaneous methods -----------------------------------------

python/vendor/current/Lib/distutils/msvccompiler.py

-              r2
+              r388
 #   finding DevStudio (through the registry)
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id: msvccompiler.py 62197 2008-04-07 01:53:39Z mark.hammond $"
+import sys, os, string
+from distutils.errors import \
+     DistutilsExecError, DistutilsPlatformError, \
+     CompileError, LibError, LinkError
+from distutils.ccompiler import \
+     CCompiler, gen_preprocess_options, gen_lib_options
+__revision__ = "$Id$"
+import sys
+import os
+import string
+from distutils.errors import (DistutilsExecError, DistutilsPlatformError,
+                              CompileError, LibError, LinkError)
+from distutils.ccompiler import CCompiler, gen_lib_options
 from distutils import log
 …
             else:
                 self.set_macro("FrameworkSDKDir", net, "sdkinstallroot")
         except KeyError, exc: #
+        except KeyError:
             raise DistutilsPlatformError, \
                   ("""Python was built with Visual Studio 2003;

python/vendor/current/Lib/distutils/spawn.py

-              r2
+              r388
 """
+# This module should be kept compatible with Python 2.1.
+__revision__ = "$Id$"
+__revision__ = "$Id: spawn.py 37828 2004-11-10 22:23:15Z loewis $"
+import sys
+import os
+import sys, os, string
+from distutils.errors import *
+from distutils.errors import DistutilsPlatformError, DistutilsExecError
 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.
+    """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' 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.
     There is no way to run a program with a name different from that of its
 …
               "don't know how to spawn programs on platform '%s'" % os.name
+# spawn ()
+def _nt_quote_args(args):
+    """Quote command-line arguments for DOS/Windows conventions.
+def _nt_quote_args (args):
+    """Quote command-line arguments for DOS/Windows conventions: just
+    wraps every argument which contains blanks in double quotes, and
+    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
 …
     # have to be escaped?  Is there an escaping mechanism other than
     # quoting?)
+    for i in range(len(args)):
+        if string.find(args[i], ' ') != -1:
+            args[i] = '"%s"' % args[i]
+    for i, arg in enumerate(args):
+        if ' ' in arg:
+            args[i] = '"%s"' % arg
     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)
 …
         # either we find one or it stays the same
         executable = find_executable(executable) or executable
     log.info(string.join([executable] + cmd[1:], ' '))
+    log.info(' '.join([executable] + cmd[1:]))
     if not dry_run:
         # spawn for NT requires a full path to the .exe
 …
                   "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:
         # either we find one or it stays the same
         executable = find_executable(executable) or executable
     log.info(string.join([executable] + cmd[1:], ' '))
+    log.info(' '.join([executable] + cmd[1:]))
     if not dry_run:
         # spawnv for OS/2 EMX requires a full path to the .exe
 …
         if rc != 0:
             # and this reflects the command running but failing
             print "command '%s' failed with exit status %d" % (cmd[0], rc)
+            log.debug("command '%s' failed with exit status %d" % (cmd[0], rc))
             raise DistutilsExecError, \
                   "command '%s' failed with exit status %d" % (cmd[0], rc)
+if sys.platform == 'darwin':
+    from distutils import sysconfig
+    _cfg_target = None
+    _cfg_target_split = None
+def _spawn_posix (cmd,
+                  search_path=1,
+                  verbose=0,
+                  dry_run=0):
+    log.info(string.join(cmd, ' '))
+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
+    exec_args = [cmd[0], cmd]
+    if sys.platform == 'darwin':
+        global _cfg_target, _cfg_target_split
+        if _cfg_target is None:
+            _cfg_target = sysconfig.get_config_var(
+                                  'MACOSX_DEPLOYMENT_TARGET') or ''
+            if _cfg_target:
+                _cfg_target_split = [int(x) for x in _cfg_target.split('.')]
+        if _cfg_target:
+            # ensure that the deployment target of build process is not less
+            # than that used when the interpreter was built. This ensures
+            # extension modules are built with correct compatibility values
+            cur_target = os.environ.get('MACOSX_DEPLOYMENT_TARGET', _cfg_target)
+            if _cfg_target_split > [int(x) for x in cur_target.split('.')]:
+                my_msg = ('$MACOSX_DEPLOYMENT_TARGET mismatch: '
+                          'now "%s" but "%s" during configure'
+                                % (cur_target, _cfg_target))
+                raise DistutilsPlatformError(my_msg)
+            env = dict(os.environ,
+                       MACOSX_DEPLOYMENT_TARGET=cur_target)
+            exec_fn = search_path and os.execvpe or os.execve
+            exec_args.append(env)
     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)
+            exec_fn(*exec_args)
         except OSError, e:
             sys.stderr.write("unable to execute %s: %s\n" %
 …
         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:
             try:
                 (pid, status) = os.waitpid(pid, 0)
+                pid, status = os.waitpid(pid, 0)
             except OSError, exc:
                 import errno
 …
                 exit_status = os.WEXITSTATUS(status)
                 if exit_status == 0:
                     return              # hey, it succeeded!
+                    return   # hey, it succeeded!
                 else:
                     raise DistutilsExecError, \
 …
                       "unknown error executing '%s': termination status %d" % \
                       (cmd[0], status)
-# _spawn_posix ()
 def find_executable(executable, path=None):
     """Try to find 'executable' in the directories listed in 'path' (a
+    string listing directories separated by 'os.pathsep'; defaults to
     os.environ['PATH']).  Returns the complete filename or None if not
     found.
+    """Tries to find 'executable' in the directories listed in 'path'.
+    A string listing directories separated by 'os.pathsep'; defaults to
+    os.environ['PATH'].  Returns the complete filename or None if not found.
     """
     if path is None:
         path = os.environ['PATH']
+    paths = string.split(path, os.pathsep)
+    (base, ext) = os.path.splitext(executable)
+    paths = path.split(os.pathsep)
+    base, ext = os.path.splitext(executable)
     if (sys.platform == 'win32' or os.name == 'os2') and (ext != '.exe'):
         executable = executable + '.exe'
     if not os.path.isfile(executable):
         for p in paths:
 …
     else:
         return executable
-# find_executable()

python/vendor/current/Lib/distutils/sysconfig.py

-              r2
+              r388
 """
 __revision__ = "$Id: sysconfig.py 76739 2009-12-10 10:29:05Z ronald.oussoren $"
+__revision__ = "$Id$"
 import os
 …
                                                 os.path.pardir))
+# set for cross builds
+if "_PYTHON_PROJECT_BASE" in os.environ:
+    # this is the build directory, at least for posix
+    project_base = os.path.normpath(os.environ["_PYTHON_PROJECT_BASE"])
 # python_build: (Boolean) if true, we're either building Python or
 # building an extension with an un-installed Python, so we use
 …
     if prefix is None:
         prefix = plat_specific and EXEC_PREFIX or PREFIX
     if os.name == "posix":
         if python_build:
             base = os.path.dirname(os.path.abspath(sys.executable))
+            buildir = os.path.dirname(sys.executable)
             if plat_specific:
+                inc_dir = base
+                # python.h is located in the buildir
+                inc_dir = buildir
             else:
+                inc_dir = os.path.join(base, "Include")
+                if not os.path.exists(inc_dir):
+                    inc_dir = os.path.join(os.path.dirname(base), "Include")
+                # the source dir is relative to the buildir
+                srcdir = os.path.abspath(os.path.join(buildir,
+                                         get_config_var('srcdir')))
+                # Include is located in the srcdir
+                inc_dir = os.path.join(srcdir, "Include")
             return inc_dir
         return os.path.join(prefix, "include", "python" + get_python_version())
     elif os.name == "nt":
         return os.path.join(prefix, "include")
-    elif os.name == "mac":
-        if plat_specific:
-            return os.path.join(prefix, "Mac", "Include")
-        else:
-            return os.path.join(prefix, "Include")
     elif os.name == "os2":
         return os.path.join(prefix, "Include")
 …
                 return os.path.join(prefix, "Lib", "site-packages")
-    elif os.name == "mac":
-        if plat_specific:
-            if standard_lib:
-                return os.path.join(prefix, "Lib", "lib-dynload")
-            else:
-                return os.path.join(prefix, "Lib", "site-packages")
-        else:
-            if standard_lib:
-                return os.path.join(prefix, "Lib")
-            else:
-                return os.path.join(prefix, "Lib", "site-packages")
     elif os.name == "os2":
         if standard_lib:
 …
 def customize_compiler(compiler):
     """Do any platform-specific customization of a CCompiler instance.
 …
     """
     if compiler.compiler_type == "unix":
+        (cc, cxx, opt, cflags, ccshared, ldshared, so_ext) = \
+        if sys.platform == "darwin":
+            # Perform first-time customization of compiler-related
+            # config vars on OS X now that we know we need a compiler.
+            # This is primarily to support Pythons from binary
+            # installers.  The kind and paths to build tools on
+            # the user system may vary significantly from the system
+            # that Python itself was built on.  Also the user OS
+            # version and build tools may not support the same set
+            # of CPU architectures for universal builds.
+            global _config_vars
+            if not _config_vars.get('CUSTOMIZED_OSX_COMPILER', ''):
+                import _osx_support
+                _osx_support.customize_compiler(_config_vars)
+                _config_vars['CUSTOMIZED_OSX_COMPILER'] = 'True'
+        (cc, cxx, opt, cflags, ccshared, ldshared, so_ext, ar, ar_flags) = \
             get_config_vars('CC', 'CXX', 'OPT', 'CFLAGS',
+                            'CCSHARED', 'LDSHARED', 'SO')
+                            'CCSHARED', 'LDSHARED', 'SO', 'AR',
+                            'ARFLAGS')
         if 'CC' in os.environ:
+            cc = os.environ['CC']
+            newcc = os.environ['CC']
+            if (sys.platform == 'darwin'
+                    and 'LDSHARED' not in os.environ
+                    and ldshared.startswith(cc)):
+                # On OS X, if CC is overridden, use that as the default
+                #       command for LDSHARED as well
+                ldshared = newcc + ldshared[len(cc):]
+            cc = newcc
         if 'CXX' in os.environ:
             cxx = os.environ['CXX']
 …
             cflags = cflags + ' ' + os.environ['CPPFLAGS']
             ldshared = ldshared + ' ' + os.environ['CPPFLAGS']
+        if 'AR' in os.environ:
+            ar = os.environ['AR']
+        if 'ARFLAGS' in os.environ:
+            archiver = ar + ' ' + os.environ['ARFLAGS']
+        else:
+            archiver = ar + ' ' + ar_flags
         cc_cmd = cc + ' ' + cflags
 …
             compiler_cxx=cxx,
             linker_so=ldshared,
+            linker_exe=cc)
+            linker_exe=cc,
+            archiver=archiver)
         compiler.shared_lib_extension = so_ext
 …
     """Return full pathname of installed Makefile from the Python build."""
     if python_build:
         return os.path.join(os.path.dirname(sys.executable), "Makefile")
+        return os.path.join(project_base, "Makefile")
     lib_dir = get_python_lib(plat_specific=1, standard_lib=1)
     return os.path.join(lib_dir, "config", "Makefile")
 …
     fp.close()
+    # strip spurious spaces
+    for k, v in done.items():
+        if isinstance(v, str):
+            done[k] = v.strip()
     # save the results in the global dictionary
     g.update(done)
 …
 def _init_posix():
     """Initialize the module as appropriate for POSIX systems."""
+    g = {}
+    # load the installed Makefile:
+    try:
+        filename = get_makefile_filename()
+        parse_makefile(filename, g)
+    except IOError, msg:
+        my_msg = "invalid Python installation: unable to open %s" % filename
+        if hasattr(msg, "strerror"):
+            my_msg = my_msg + " (%s)" % msg.strerror
+        raise DistutilsPlatformError(my_msg)
+    # load the installed pyconfig.h:
+    try:
+        filename = get_config_h_filename()
+        parse_config_h(file(filename), g)
+    except IOError, msg:
+        my_msg = "invalid Python installation: unable to open %s" % filename
+        if hasattr(msg, "strerror"):
+            my_msg = my_msg + " (%s)" % msg.strerror
+        raise DistutilsPlatformError(my_msg)
+    # On MacOSX we need to check the setting of the environment variable
+    # MACOSX_DEPLOYMENT_TARGET: configure bases some choices on it so
+    # it needs to be compatible.
+    # If it isn't set we set it to the configure-time value
+    if sys.platform == 'darwin' and 'MACOSX_DEPLOYMENT_TARGET' in g:
+        cfg_target = g['MACOSX_DEPLOYMENT_TARGET']
+        cur_target = os.getenv('MACOSX_DEPLOYMENT_TARGET', '')
+        if cur_target == '':
+            cur_target = cfg_target
+            os.putenv('MACOSX_DEPLOYMENT_TARGET', cfg_target)
+        elif map(int, cfg_target.split('.')) > map(int, cur_target.split('.')):
+            my_msg = ('$MACOSX_DEPLOYMENT_TARGET mismatch: now "%s" but "%s" during configure'
+                % (cur_target, cfg_target))
+            raise DistutilsPlatformError(my_msg)
+    # On AIX, there are wrong paths to the linker scripts in the Makefile
+    # -- these paths are relative to the Python source, but when installed
+    # the scripts are in another directory.
+    if python_build:
+        g['LDSHARED'] = g['BLDSHARED']
+    elif get_python_version() < '2.1':
+        # The following two branches are for 1.5.2 compatibility.
+        if sys.platform == 'aix4':          # what about AIX 3.x ?
+            # Linker script is in the config directory, not in Modules as the
+            # Makefile says.
+            python_lib = get_python_lib(standard_lib=1)
+            ld_so_aix = os.path.join(python_lib, 'config', 'ld_so_aix')
+            python_exp = os.path.join(python_lib, 'config', 'python.exp')
+            g['LDSHARED'] = "%s %s -bI:%s" % (ld_so_aix, g['CC'], python_exp)
+        elif sys.platform == 'beos':
+            # Linker script is in the config directory.  In the Makefile it is
+            # relative to the srcdir, which after installation no longer makes
+            # sense.
+            python_lib = get_python_lib(standard_lib=1)
+            linkerscript_path = string.split(g['LDSHARED'])[0]
+            linkerscript_name = os.path.basename(linkerscript_path)
+            linkerscript = os.path.join(python_lib, 'config',
+                                        linkerscript_name)
+            # XXX this isn't the right place to do this: adding the Python
+            # library to the link, if needed, should be in the "build_ext"
+            # command.  (It's also needed for non-MS compilers on Windows, and
+            # it's taken care of for them by the 'build_ext.get_libraries()'
+            # method.)
+            g['LDSHARED'] = ("%s -L%s/lib -lpython%s" %
+                             (linkerscript, PREFIX, get_python_version()))
+    # _sysconfigdata is generated at build time, see the sysconfig module
+    from _sysconfigdata import build_time_vars
     global _config_vars
+    _config_vars = g
+    _config_vars = {}
+    _config_vars.update(build_time_vars)
 …
-def _init_mac():
-    """Initialize the module as appropriate for Macintosh systems"""
-    g = {}
-    # set basic install directories
-    g['LIBDEST'] = get_python_lib(plat_specific=0, standard_lib=1)
-    g['BINLIBDEST'] = get_python_lib(plat_specific=1, standard_lib=1)
-    # XXX hmmm.. a normal install puts include files here
-    g['INCLUDEPY'] = get_python_inc(plat_specific=0)
-    import MacOS
-    if not hasattr(MacOS, 'runtimemodel'):
-        g['SO'] = '.ppc.slb'
-    else:
-        g['SO'] = '.%s.slb' % MacOS.runtimemodel
-    # XXX are these used anywhere?
-    g['install_lib'] = os.path.join(EXEC_PREFIX, "Lib")
-    g['install_platlib'] = os.path.join(EXEC_PREFIX, "Mac", "Lib")
-    # These are used by the extension module build
-    g['srcdir'] = ':'
-    global _config_vars
-    _config_vars = g
 def _init_os2():
     """Initialize the module as appropriate for OS/2"""
 …
         _config_vars['exec_prefix'] = EXEC_PREFIX
+        # OS X platforms require special customization to handle
+        # multi-architecture, multi-os-version installers
         if sys.platform == 'darwin':
+            kernel_version = os.uname()[2] # Kernel version (8.4.3)
+            major_version = int(kernel_version.split('.')[0])
+            if major_version < 8:
+                # On Mac OS X before 10.4, check if -arch and -isysroot
+                # are in CFLAGS or LDFLAGS and remove them if they are.
+                # This is needed when building extensions on a 10.3 system
+                # using a universal build of python.
+                for key in ('LDFLAGS', 'BASECFLAGS', 'LDSHARED',
+                        # a number of derived variables. These need to be
+                        # patched up as well.
+                        'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'):
+                    flags = _config_vars[key]
+                    flags = re.sub('-arch\s+\w+\s', ' ', flags)
+                    flags = re.sub('-isysroot [^ \t]*', ' ', flags)
+                    _config_vars[key] = flags
+            else:
+                # Allow the user to override the architecture flags using
+                # an environment variable.
+                # NOTE: This name was introduced by Apple in OSX 10.5 and
+                # is used by several scripting languages distributed with
+                # that OS release.
+                if 'ARCHFLAGS' in os.environ:
+                    arch = os.environ['ARCHFLAGS']
+                    for key in ('LDFLAGS', 'BASECFLAGS', 'LDSHARED',
+                        # a number of derived variables. These need to be
+                        # patched up as well.
+                        'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'):
+                        flags = _config_vars[key]
+                        flags = re.sub('-arch\s+\w+\s', ' ', flags)
+                        flags = flags + ' ' + arch
+                        _config_vars[key] = flags
+                # If we're on OSX 10.5 or later and the user tries to
+                # compiles an extension using an SDK that is not present
+                # on the current machine it is better to not use an SDK
+                # than to fail.
+                #
+                # The major usecase for this is users using a Python.org
+                # binary installer  on OSX 10.6: that installer uses
+                # the 10.4u SDK, but that SDK is not installed by default
+                # when you install Xcode.
+                #
+                m = re.search('-isysroot\s+(\S+)', _config_vars['CFLAGS'])
+                if m is not None:
+                    sdk = m.group(1)
+                    if not os.path.exists(sdk):
+                        for key in ('LDFLAGS', 'BASECFLAGS', 'LDSHARED',
+                             # a number of derived variables. These need to be
+                             # patched up as well.
+                            'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'):
+                            flags = _config_vars[key]
+                            flags = re.sub('-isysroot\s+\S+(\s|$)', ' ', flags)
+                            _config_vars[key] = flags
+            import _osx_support
+            _osx_support.customize_config_vars(_config_vars)
     if args:

python/vendor/current/Lib/distutils/tests/init.py

-              r2
+              r388
 import sys
 import unittest
+from test.test_support import run_unittest
 here = os.path.dirname(__file__)
+here = os.path.dirname(__file__) or os.curdir
 …
 if __name__ == "__main__":
     unittest.main(defaultTest="test_suite")
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/tests/support.py

-              r2
+              r388
 """Support code for distutils test cases."""
 import os
+import sys
 import shutil
 import tempfile
+import unittest
+import sysconfig
+from copy import deepcopy
+import warnings
+from distutils import log
 from distutils.log import DEBUG, INFO, WARN, ERROR, FATAL
+from distutils import log
+from distutils.dist import Distribution
+from distutils.cmd import Command
+from distutils.core import Distribution
+def capture_warnings(func):
+    def _capture_warnings(*args, **kw):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            return func(*args, **kw)
+    return _capture_warnings
 class LoggingSilencer(object):
 …
         log.Log._log = self._log
         self.logs = []
-        self._old_warn = Command.warn
-        Command.warn = self._warn
     def tearDown(self):
         log.set_threshold(self.threshold)
         log.Log._log = self._old_log
-        Command.warn = self._old_warn
         super(LoggingSilencer, self).tearDown()
-    def _warn(self, msg):
-        self.logs.append(('', msg, ''))
     def _log(self, level, msg, args):
 …
     def setUp(self):
         super(TempdirManager, self).setUp()
+        self.old_cwd = os.getcwd()
         self.tempdirs = []
     def tearDown(self):
+        # Restore working dir, for Solaris and derivatives, where rmdir()
+        # on the current directory fails.
+        os.chdir(self.old_cwd)
         super(TempdirManager, self).tearDown()
         while self.tempdirs:
             d = self.tempdirs.pop()
             shutil.rmtree(d)
+            shutil.rmtree(d, os.name in ('nt', 'cygwin'))
     def mkdtemp(self):
 …
     def write_file(self, path, content='xxx'):
         """Writes a file in the given path.
         path can be a string or a sequence.
 …
         return pkg_dir, dist
 class DummyCommand:
     """Class to store options for retrieval via set_undefined_options()."""
 …
     def ensure_finalized(self):
         pass
+class EnvironGuard(object):
+    def setUp(self):
+        super(EnvironGuard, self).setUp()
+        self.old_environ = deepcopy(os.environ)
+    def tearDown(self):
+        for key, value in self.old_environ.items():
+            if os.environ.get(key) != value:
+                os.environ[key] = value
+        for key in os.environ.keys():
+            if key not in self.old_environ:
+                del os.environ[key]
+        super(EnvironGuard, self).tearDown()
+def copy_xxmodule_c(directory):
+    """Helper for tests that need the xxmodule.c source file.
+    Example use:
+        def test_compile(self):
+            copy_xxmodule_c(self.tmpdir)
+            self.assertIn('xxmodule.c', os.listdir(self.tmpdir))
+    If the source file can be found, it will be copied to *directory*.  If not,
+    the test will be skipped.  Errors during copy are not caught.
+    """
+    filename = _get_xxmodule_path()
+    if filename is None:
+        raise unittest.SkipTest('cannot find xxmodule.c (test must run in '
+                                'the python build dir)')
+    shutil.copy(filename, directory)
+def _get_xxmodule_path():
+    # FIXME when run from regrtest, srcdir seems to be '.', which does not help
+    # us find the xxmodule.c file
+    srcdir = sysconfig.get_config_var('srcdir')
+    candidates = [
+        # use installed copy if available
+        os.path.join(os.path.dirname(__file__), 'xxmodule.c'),
+        # otherwise try using copy from build directory
+        os.path.join(srcdir, 'Modules', 'xxmodule.c'),
+        # srcdir mysteriously can be $srcdir/Lib/distutils/tests when
+        # this file is run from its parent directory, so walk up the
+        # tree to find the real srcdir
+        os.path.join(srcdir, '..', '..', '..', 'Modules', 'xxmodule.c'),
+    ]
+    for path in candidates:
+        if os.path.exists(path):
+            return path
+def fixup_build_ext(cmd):
+    """Function needed to make build_ext tests pass.
+    When Python was build with --enable-shared on Unix, -L. is not good
+    enough to find the libpython<blah>.so.  This is because regrtest runs
+    it under a tempdir, not in the top level where the .so lives.  By the
+    time we've gotten here, Python's already been chdir'd to the tempdir.
+    When Python was built with in debug mode on Windows, build_ext commands
+    need their debug attribute set, and it is not done automatically for
+    some reason.
+    This function handles both of these things.  Example use:
+        cmd = build_ext(dist)
+        support.fixup_build_ext(cmd)
+        cmd.ensure_finalized()
+    Unlike most other Unix platforms, Mac OS X embeds absolute paths
+    to shared libraries into executables, so the fixup is not needed there.
+    """
+    if os.name == 'nt':
+        cmd.debug = sys.executable.endswith('_d.exe')
+    elif sysconfig.get_config_var('Py_ENABLE_SHARED'):
+        # To further add to the shared builds fun on Unix, we can't just add
+        # library_dirs to the Extension() instance because that doesn't get
+        # plumbed through to the final compiler command.
+        runshared = sysconfig.get_config_var('RUNSHARED')
+        if runshared is None:
+            cmd.library_dirs = ['.']
+        else:
+            if sys.platform == 'darwin':
+                cmd.library_dirs = []
+            else:
+                name, equals, value = runshared.partition('=')
+                cmd.library_dirs = value.split(os.pathsep)

python/vendor/current/Lib/distutils/tests/test_bdist_wininst.py

-              r2
+              r388
 """Tests for distutils.command.bdist_wininst."""
 import unittest
-import os
+from distutils.dist import Distribution
+from test.test_support import run_unittest
 from distutils.command.bdist_wininst import bdist_wininst
 from distutils.tests import support
 …
         # this test makes sure it works now for every platform
         # let's create a command
+        tmp_dir = self.mkdtemp()
+        pkg_dir = os.path.join(tmp_dir, 'foo')
+        os.mkdir(pkg_dir)
+        dist = Distribution()
+        pkg_pth, dist = self.create_dist()
         cmd = bdist_wininst(dist)
         cmd.ensure_finalized()
 …
         # no matter what platform we have
         exe_file = cmd.get_exe_bytes()
         self.assert_(len(exe_file) > 10)
+        self.assertTrue(len(exe_file) > 10)
 def test_suite():
 …
 if __name__ == '__main__':
     test_support.run_unittest(test_suite())
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/tests/test_build_ext.py

-              r2
+              r388
 import sys
 import os
-import tempfile
-import shutil
 from StringIO import StringIO
+import textwrap
 from distutils.core import Extension, Distribution
 …
 from distutils import sysconfig
 from distutils.tests import support
+from distutils.errors import DistutilsSetupError
+from distutils.errors import (DistutilsSetupError, CompileError,
+                              DistutilsPlatformError)
 import unittest
 …
 ALREADY_TESTED = False
-def _get_source_filename():
-    srcdir = sysconfig.get_config_var('srcdir')
-    if srcdir is None:
-        return os.path.join(sysconfig.project_base, 'Modules', 'xxmodule.c')
-    return os.path.join(srcdir, 'Modules', 'xxmodule.c')
 class BuildExtTestCase(support.TempdirManager,
 …
                        unittest.TestCase):
     def setUp(self):
-        # Create a simple test environment
-        # Note that we're making changes to sys.path
         super(BuildExtTestCase, self).setUp()
         self.tmp_dir = tempfile.mkdtemp(prefix="pythontest_")
         self.sys_path = sys.path[:]
+        self.tmp_dir = self.mkdtemp()
+        self.xx_created = False
         sys.path.append(self.tmp_dir)
+        shutil.copy(_get_source_filename(), self.tmp_dir)
+        self.addCleanup(sys.path.remove, self.tmp_dir)
+        if sys.version > "2.6":
+            import site
+            self.old_user_base = site.USER_BASE
+            site.USER_BASE = self.mkdtemp()
+            from distutils.command import build_ext
+            build_ext.USER_BASE = site.USER_BASE
+    def tearDown(self):
+        if self.xx_created:
+            test_support.unload('xx')
+            # XXX on Windows the test leaves a directory
+            # with xx module in TEMP
+        super(BuildExtTestCase, self).tearDown()
     def test_build_ext(self):
         global ALREADY_TESTED
+        support.copy_xxmodule_c(self.tmp_dir)
+        self.xx_created = True
         xx_c = os.path.join(self.tmp_dir, 'xxmodule.c')
         xx_ext = Extension('xx', [xx_c])
 …
         dist.package_dir = self.tmp_dir
         cmd = build_ext(dist)
+        if os.name == "nt":
+            # On Windows, we must build a debug version iff running
+            # a debug build of Python
+            cmd.debug = sys.executable.endswith("_d.exe")
+        support.fixup_build_ext(cmd)
         cmd.build_lib = self.tmp_dir
         cmd.build_temp = self.tmp_dir
 …
         for attr in ('error', 'foo', 'new', 'roj'):
+            self.assert_(hasattr(xx, attr))
+        self.assertEquals(xx.foo(2, 5), 7)
+        self.assertEquals(xx.foo(13,15), 28)
+        self.assertEquals(xx.new().demo(), None)
+        doc = 'This is a template module just for instruction.'
+        self.assertEquals(xx.__doc__, doc)
+        self.assert_(isinstance(xx.Null(), xx.Null))
+        self.assert_(isinstance(xx.Str(), xx.Str))
+    def tearDown(self):
+        # Get everything back to normal
+        test_support.unload('xx')
+        sys.path = self.sys_path
+        # XXX on Windows the test leaves a directory with xx module in TEMP
+        shutil.rmtree(self.tmp_dir, os.name == 'nt' or sys.platform == 'cygwin')
+        super(BuildExtTestCase, self).tearDown()
+            self.assertTrue(hasattr(xx, attr))
+        self.assertEqual(xx.foo(2, 5), 7)
+        self.assertEqual(xx.foo(13,15), 28)
+        self.assertEqual(xx.new().demo(), None)
+        if test_support.HAVE_DOCSTRINGS:
+            doc = 'This is a template module just for instruction.'
+            self.assertEqual(xx.__doc__, doc)
+        self.assertTrue(isinstance(xx.Null(), xx.Null))
+        self.assertTrue(isinstance(xx.Str(), xx.Str))
     def test_solaris_enable_shared(self):
 …
         # make sure we get some library dirs under solaris
+        self.assert_(len(cmd.library_dirs) > 0)
+        self.assertTrue(len(cmd.library_dirs) > 0)
+    def test_user_site(self):
+        # site.USER_SITE was introduced in 2.6
+        if sys.version < '2.6':
+            return
+        import site
+        dist = Distribution({'name': 'xx'})
+        cmd = build_ext(dist)
+        # making sure the user option is there
+        options = [name for name, short, label in
+                   cmd.user_options]
+        self.assertIn('user', options)
+        # setting a value
+        cmd.user = 1
+        # setting user based lib and include
+        lib = os.path.join(site.USER_BASE, 'lib')
+        incl = os.path.join(site.USER_BASE, 'include')
+        os.mkdir(lib)
+        os.mkdir(incl)
+        cmd.ensure_finalized()
+        # see if include_dirs and library_dirs were set
+        self.assertIn(lib, cmd.library_dirs)
+        self.assertIn(lib, cmd.rpath)
+        self.assertIn(incl, cmd.include_dirs)
     def test_finalize_options(self):
 …
         cmd.finalize_options()
-        from distutils import sysconfig
         py_include = sysconfig.get_python_inc()
         self.assert_(py_include in cmd.include_dirs)
+        self.assertTrue(py_include in cmd.include_dirs)
         plat_py_include = sysconfig.get_python_inc(plat_specific=1)
         self.assert_(plat_py_include in cmd.include_dirs)
+        self.assertTrue(plat_py_include in cmd.include_dirs)
         # make sure cmd.libraries is turned into a list
         # if it's a string
         cmd = build_ext(dist)
         cmd.libraries = 'my_lib'
         cmd.finalize_options()
         self.assertEquals(cmd.libraries, ['my_lib'])
+        cmd.libraries = 'my_lib, other_lib lastlib'
+        cmd.finalize_options()
+        self.assertEqual(cmd.libraries, ['my_lib', 'other_lib', 'lastlib'])
         # make sure cmd.library_dirs is turned into a list
         # if it's a string
         cmd = build_ext(dist)
+        cmd.library_dirs = 'my_lib_dir'
+        cmd.finalize_options()
+        self.assert_('my_lib_dir' in cmd.library_dirs)
+        cmd.library_dirs = 'my_lib_dir%sother_lib_dir' % os.pathsep
+        cmd.finalize_options()
+        self.assertIn('my_lib_dir', cmd.library_dirs)
+        self.assertIn('other_lib_dir', cmd.library_dirs)
         # make sure rpath is turned into a list
         # if it's a list of os.pathsep's paths
         cmd = build_ext(dist)
         cmd.rpath = os.pathsep.join(['one', 'two'])
         cmd.finalize_options()
         self.assertEquals(cmd.rpath, ['one', 'two'])
+        # if it's a string
+        cmd = build_ext(dist)
+        cmd.rpath = 'one%stwo' % os.pathsep
+        cmd.finalize_options()
+        self.assertEqual(cmd.rpath, ['one', 'two'])
         # XXX more tests to perform for win32
 …
         cmd.define = 'one,two'
         cmd.finalize_options()
         self.assertEquals(cmd.define, [('one', '1'), ('two', '1')])
+        self.assertEqual(cmd.define, [('one', '1'), ('two', '1')])
         # make sure undef is turned into a list of
 …
         cmd.undef = 'one,two'
         cmd.finalize_options()
         self.assertEquals(cmd.undef, ['one', 'two'])
+        self.assertEqual(cmd.undef, ['one', 'two'])
         # make sure swig_opts is turned into a list
 …
         cmd.swig_opts = None
         cmd.finalize_options()
         self.assertEquals(cmd.swig_opts, [])
+        self.assertEqual(cmd.swig_opts, [])
         cmd = build_ext(dist)
         cmd.swig_opts = '1 2'
         cmd.finalize_options()
         self.assertEquals(cmd.swig_opts, ['1', '2'])
+        self.assertEqual(cmd.swig_opts, ['1', '2'])
     def test_check_extensions_list(self):
 …
         cmd.check_extensions_list(exts)
         ext = exts[0]
         self.assert_(isinstance(ext, Extension))
+        self.assertTrue(isinstance(ext, Extension))
         # check_extensions_list adds in ext the values passed
         # when they are in ('include_dirs', 'library_dirs', 'libraries'
         # 'extra_objects', 'extra_compile_args', 'extra_link_args')
         self.assertEquals(ext.libraries, 'foo')
         self.assert_(not hasattr(ext, 'some'))
+        self.assertEqual(ext.libraries, 'foo')
+        self.assertTrue(not hasattr(ext, 'some'))
         # 'macros' element of build info dict must be 1- or 2-tuple
 …
         exts[0][1]['macros'] = [('1', '2'), ('3',)]
         cmd.check_extensions_list(exts)
         self.assertEquals(exts[0].undef_macros, ['3'])
         self.assertEquals(exts[0].define_macros, [('1', '2')])
+        self.assertEqual(exts[0].undef_macros, ['3'])
+        self.assertEqual(exts[0].define_macros, [('1', '2')])
     def test_get_source_files(self):
 …
         cmd = build_ext(dist)
         cmd.ensure_finalized()
         self.assertEquals(cmd.get_source_files(), ['xxx'])
+        self.assertEqual(cmd.get_source_files(), ['xxx'])
     def test_compiler_option(self):
 …
         cmd.ensure_finalized()
         cmd.run()
         self.assertEquals(cmd.compiler, 'unix')
+        self.assertEqual(cmd.compiler, 'unix')
     def test_get_outputs(self):
 …
                              'ext_modules': [ext]})
         cmd = build_ext(dist)
+        cmd.ensure_finalized()
+        self.assertEquals(len(cmd.get_outputs()), 1)
+        if os.name == "nt":
+            cmd.debug = sys.executable.endswith("_d.exe")
+        support.fixup_build_ext(cmd)
+        cmd.ensure_finalized()
+        self.assertEqual(len(cmd.get_outputs()), 1)
         cmd.build_lib = os.path.join(self.tmp_dir, 'build')
 …
         finally:
             os.chdir(old_wd)
         self.assert_(os.path.exists(so_file))
         self.assertEquals(os.path.splitext(so_file)[-1],
                           sysconfig.get_config_var('SO'))
+        self.assertTrue(os.path.exists(so_file))
+        self.assertEqual(os.path.splitext(so_file)[-1],
+                         sysconfig.get_config_var('SO'))
         so_dir = os.path.dirname(so_file)
         self.assertEquals(so_dir, other_tmp_dir)
+        self.assertEqual(so_dir, other_tmp_dir)
         cmd.compiler = None
         cmd.inplace = 0
         cmd.run()
         so_file = cmd.get_outputs()[0]
         self.assert_(os.path.exists(so_file))
         self.assertEquals(os.path.splitext(so_file)[-1],
                           sysconfig.get_config_var('SO'))
+        self.assertTrue(os.path.exists(so_file))
+        self.assertEqual(os.path.splitext(so_file)[-1],
+                         sysconfig.get_config_var('SO'))
         so_dir = os.path.dirname(so_file)
         self.assertEquals(so_dir, cmd.build_lib)
+        self.assertEqual(so_dir, cmd.build_lib)
         # inplace = 0, cmd.package = 'bar'
 …
         # checking that the last directory is the build_dir
         path = os.path.split(path)[0]
         self.assertEquals(path, cmd.build_lib)
+        self.assertEqual(path, cmd.build_lib)
         # inplace = 1, cmd.package = 'bar'
 …
         path = os.path.split(path)[0]
         lastdir = os.path.split(path)[-1]
         self.assertEquals(lastdir, 'bar')
+        self.assertEqual(lastdir, 'bar')
     def test_ext_fullpath(self):
 …
         wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext)
         path = cmd.get_ext_fullpath('lxml.etree')
         self.assertEquals(wanted, path)
+        self.assertEqual(wanted, path)
         # building lxml.etree not inplace
 …
         wanted = os.path.join(curdir, 'tmpdir', 'lxml', 'etree' + ext)
         path = cmd.get_ext_fullpath('lxml.etree')
         self.assertEquals(wanted, path)
+        self.assertEqual(wanted, path)
         # building twisted.runner.portmap not inplace
 …
         wanted = os.path.join(curdir, 'tmpdir', 'twisted', 'runner',
                               'portmap' + ext)
         self.assertEquals(wanted, path)
+        self.assertEqual(wanted, path)
         # building twisted.runner.portmap inplace
 …
         path = cmd.get_ext_fullpath('twisted.runner.portmap')
         wanted = os.path.join(curdir, 'twisted', 'runner', 'portmap' + ext)
         self.assertEquals(wanted, path)
+        self.assertEqual(wanted, path)
     def test_build_ext_inplace(self):
 …
         wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext)
         path = cmd.get_ext_fullpath('lxml.etree')
         self.assertEquals(wanted, path)
+        self.assertEqual(wanted, path)
     def test_setuptools_compat(self):
+        from setuptools_build_ext import build_ext as setuptools_build_ext
+        from setuptools_extension import Extension
+        etree_c = os.path.join(self.tmp_dir, 'lxml.etree.c')
+        etree_ext = Extension('lxml.etree', [etree_c])
+        dist = Distribution({'name': 'lxml', 'ext_modules': [etree_ext]})
+        cmd = setuptools_build_ext(dist)
+        cmd.ensure_finalized()
+        cmd.inplace = 1
+        cmd.distribution.package_dir = {'': 'src'}
+        cmd.distribution.packages = ['lxml', 'lxml.html']
+        curdir = os.getcwd()
+        ext = sysconfig.get_config_var("SO")
+        wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext)
+        path = cmd.get_ext_fullpath('lxml.etree')
+        self.assertEquals(wanted, path)
+        import distutils.core, distutils.extension, distutils.command.build_ext
+        saved_ext = distutils.extension.Extension
+        try:
+            # on some platforms, it loads the deprecated "dl" module
+            test_support.import_module('setuptools_build_ext', deprecated=True)
+            # theses import patch Distutils' Extension class
+            from setuptools_build_ext import build_ext as setuptools_build_ext
+            from setuptools_extension import Extension
+            etree_c = os.path.join(self.tmp_dir, 'lxml.etree.c')
+            etree_ext = Extension('lxml.etree', [etree_c])
+            dist = Distribution({'name': 'lxml', 'ext_modules': [etree_ext]})
+            cmd = setuptools_build_ext(dist)
+            cmd.ensure_finalized()
+            cmd.inplace = 1
+            cmd.distribution.package_dir = {'': 'src'}
+            cmd.distribution.packages = ['lxml', 'lxml.html']
+            curdir = os.getcwd()
+            ext = sysconfig.get_config_var("SO")
+            wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext)
+            path = cmd.get_ext_fullpath('lxml.etree')
+            self.assertEqual(wanted, path)
+        finally:
+            # restoring Distutils' Extension class otherwise its broken
+            distutils.extension.Extension = saved_ext
+            distutils.core.Extension = saved_ext
+            distutils.command.build_ext.Extension = saved_ext
     def test_build_ext_path_with_os_sep(self):
 …
         ext_path = cmd.get_ext_fullpath(ext_name)
         wanted = os.path.join(cmd.build_lib, 'UpdateManager', 'fdsend' + ext)
         self.assertEquals(ext_path, wanted)
+        self.assertEqual(ext_path, wanted)
     def test_build_ext_path_cross_platform(self):
 …
         ext_path = cmd.get_ext_fullpath(ext_name)
         wanted = os.path.join(cmd.build_lib, 'UpdateManager', 'fdsend' + ext)
+        self.assertEquals(ext_path, wanted)
+        self.assertEqual(ext_path, wanted)
+    @unittest.skipUnless(sys.platform == 'darwin', 'test only relevant for MacOSX')
+    def test_deployment_target_default(self):
+        # Issue 9516: Test that, in the absence of the environment variable,
+        # an extension module is compiled with the same deployment target as
+        #  the interpreter.
+        self._try_compile_deployment_target('==', None)
+    @unittest.skipUnless(sys.platform == 'darwin', 'test only relevant for MacOSX')
+    def test_deployment_target_too_low(self):
+        # Issue 9516: Test that an extension module is not allowed to be
+        # compiled with a deployment target less than that of the interpreter.
+        self.assertRaises(DistutilsPlatformError,
+            self._try_compile_deployment_target, '>', '10.1')
+    @unittest.skipUnless(sys.platform == 'darwin', 'test only relevant for MacOSX')
+    def test_deployment_target_higher_ok(self):
+        # Issue 9516: Test that an extension module can be compiled with a
+        # deployment target higher than that of the interpreter: the ext
+        # module may depend on some newer OS feature.
+        deptarget = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET')
+        if deptarget:
+            # increment the minor version number (i.e. 10.6 -> 10.7)
+            deptarget = [int(x) for x in deptarget.split('.')]
+            deptarget[-1] += 1
+            deptarget = '.'.join(str(i) for i in deptarget)
+            self._try_compile_deployment_target('<', deptarget)
+    def _try_compile_deployment_target(self, operator, target):
+        orig_environ = os.environ
+        os.environ = orig_environ.copy()
+        self.addCleanup(setattr, os, 'environ', orig_environ)
+        if target is None:
+            if os.environ.get('MACOSX_DEPLOYMENT_TARGET'):
+                del os.environ['MACOSX_DEPLOYMENT_TARGET']
+        else:
+            os.environ['MACOSX_DEPLOYMENT_TARGET'] = target
+        deptarget_c = os.path.join(self.tmp_dir, 'deptargetmodule.c')
+        with open(deptarget_c, 'w') as fp:
+            fp.write(textwrap.dedent('''\
+                #include <AvailabilityMacros.h>
+                int dummy;
+                #if TARGET %s MAC_OS_X_VERSION_MIN_REQUIRED
+                #else
+                #error "Unexpected target"
+                #endif
+            ''' % operator))
+        # get the deployment target that the interpreter was built with
+        target = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET')
+        target = tuple(map(int, target.split('.')))
+        target = '%02d%01d0' % target
+        deptarget_ext = Extension(
+            'deptarget',
+            [deptarget_c],
+            extra_compile_args=['-DTARGET=%s'%(target,)],
+        )
+        dist = Distribution({
+            'name': 'deptarget',
+            'ext_modules': [deptarget_ext]
+        })
+        dist.package_dir = self.tmp_dir
+        cmd = build_ext(dist)
+        cmd.build_lib = self.tmp_dir
+        cmd.build_temp = self.tmp_dir
+        try:
+            cmd.ensure_finalized()
+            cmd.run()
+        except CompileError:
+            self.fail("Wrong deployment target during compilation")
 def test_suite():
+    src = _get_source_filename()
+    if not os.path.exists(src):
+        if test_support.verbose:
+            print ('test_build_ext: Cannot find source code (test'
+                   ' must run in python build dir)')
+        return unittest.TestSuite()
+    else: return unittest.makeSuite(BuildExtTestCase)
+    return unittest.makeSuite(BuildExtTestCase)
 if __name__ == '__main__':

python/vendor/current/Lib/distutils/tests/test_build_py.py

-              r2
+              r388
 from distutils.tests import support
+from test.test_support import run_unittest
 …
         sources = self.mkdtemp()
         f = open(os.path.join(sources, "__init__.py"), "w")
+        f.write("# Pretend this is a package.")
+        f.close()
+        try:
+            f.write("# Pretend this is a package.")
+        finally:
+            f.close()
         f = open(os.path.join(sources, "README.txt"), "w")
+        f.write("Info about this package")
+        f.close()
+        try:
+            f.write("Info about this package")
+        finally:
+            f.close()
         destination = self.mkdtemp()
 …
         pkgdest = os.path.join(destination, "pkg")
         files = os.listdir(pkgdest)
+        self.assert_("__init__.py" in files)
+        self.assert_("__init__.pyc" in files)
+        self.assert_("README.txt" in files)
+        self.assertIn("__init__.py", files)
+        self.assertIn("README.txt", files)
+        # XXX even with -O, distutils writes pyc, not pyo; bug?
+        if sys.dont_write_bytecode:
+            self.assertNotIn("__init__.pyc", files)
+        else:
+            self.assertIn("__init__.pyc", files)
     def test_empty_package_dir (self):
+    def test_empty_package_dir(self):
         # See SF 1668596/1720897.
         cwd = os.getcwd()
 …
             sys.dont_write_bytecode = old_dont_write_bytecode
         self.assertTrue('byte-compiling is disabled' in self.logs[0][1])
+        self.assertIn('byte-compiling is disabled', self.logs[0][1])
 def test_suite():
 …
 if __name__ == "__main__":
     unittest.main(defaultTest="test_suite")
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/tests/test_build_scripts.py

-              r2
+              r388
 from distutils.command.build_scripts import build_scripts
 from distutils.core import Distribution
 from distutils import sysconfig
+import sysconfig
 from distutils.tests import support
+from test.test_support import run_unittest
 …
     def test_default_settings(self):
         cmd = self.get_build_scripts_cmd("/foo/bar", [])
         self.assert_(not cmd.force)
         self.assert_(cmd.build_dir is None)
+        self.assertTrue(not cmd.force)
+        self.assertTrue(cmd.build_dir is None)
         cmd.finalize_options()
         self.assert_(cmd.force)
+        self.assertTrue(cmd.force)
         self.assertEqual(cmd.build_dir, "/foo/bar")
 …
         built = os.listdir(target)
         for name in expected:
             self.assert_(name in built)
+            self.assertTrue(name in built)
     def get_build_scripts_cmd(self, target, scripts):
 …
     def write_script(self, dir, name, text):
         f = open(os.path.join(dir, name), "w")
+        f.write(text)
+        f.close()
+        try:
+            f.write(text)
+        finally:
+            f.close()
     def test_version_int(self):
 …
         # failed when writing the name of the executable
         old = sysconfig.get_config_vars().get('VERSION')
         sysconfig._config_vars['VERSION'] = 4
+        sysconfig._CONFIG_VARS['VERSION'] = 4
         try:
             cmd.run()
         finally:
             if old is not None:
                 sysconfig._config_vars['VERSION'] = old
+                sysconfig._CONFIG_VARS['VERSION'] = old
         built = os.listdir(target)
         for name in expected:
             self.assert_(name in built)
+            self.assertTrue(name in built)
 def test_suite():
 …
 if __name__ == "__main__":
     unittest.main(defaultTest="test_suite")
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/tests/test_config.py

-              r2
+              r388
 import os
 import unittest
+import tempfile
+import shutil
 from distutils.core import PyPIRCCommand
 …
 from distutils.tests import support
+from test.test_support import run_unittest
 PYPIRC = """\
 …
+class PyPIRCCommandTestCase(support.TempdirManager, unittest.TestCase):
+class PyPIRCCommandTestCase(support.TempdirManager,
+                            support.LoggingSilencer,
+                            support.EnvironGuard,
+                            unittest.TestCase):
     def setUp(self):
         """Patches the environment."""
         super(PyPIRCCommandTestCase, self).setUp()
+        if os.environ.has_key('HOME'):
+            self._old_home = os.environ['HOME']
+        else:
+            self._old_home = None
+        tempdir = self.mkdtemp()
+        os.environ['HOME'] = tempdir
+        self.rc = os.path.join(tempdir, '.pypirc')
+        self.tmp_dir = self.mkdtemp()
+        os.environ['HOME'] = self.tmp_dir
+        self.rc = os.path.join(self.tmp_dir, '.pypirc')
         self.dist = Distribution()
 …
     def tearDown(self):
         """Removes the patch."""
-        if self._old_home is None:
-            del os.environ['HOME']
-        else:
-            os.environ['HOME'] = self._old_home
         set_threshold(self.old_threshold)
         super(PyPIRCCommandTestCase, self).tearDown()
 …
         # new format
+        f = open(self.rc, 'w')
+        try:
+            f.write(PYPIRC)
+        finally:
+            f.close()
+        self.write_file(self.rc, PYPIRC)
         cmd = self._cmd(self.dist)
         config = cmd._read_pypirc()
 …
                   ('repository', 'http://pypi.python.org/pypi'),
                   ('server', 'server1'), ('username', 'me')]
         self.assertEquals(config, waited)
+        self.assertEqual(config, waited)
         # old format
+        f = open(self.rc, 'w')
+        f.write(PYPIRC_OLD)
+        f.close()
+        self.write_file(self.rc, PYPIRC_OLD)
         config = cmd._read_pypirc()
         config = config.items()
 …
                   ('repository', 'http://pypi.python.org/pypi'),
                   ('server', 'server-login'), ('username', 'tarek')]
         self.assertEquals(config, waited)
+        self.assertEqual(config, waited)
     def test_server_empty_registration(self):
         cmd = self._cmd(self.dist)
         rc = cmd._get_rc_file()
+        self.assert_(not os.path.exists(rc))
+        self.assertTrue(not os.path.exists(rc))
         cmd._store_pypirc('tarek', 'xxx')
+        self.assert_(os.path.exists(rc))
+        content = open(rc).read()
+        self.assertEquals(content, WANTED)
+        self.assertTrue(os.path.exists(rc))
+        f = open(rc)
+        try:
+            content = f.read()
+            self.assertEqual(content, WANTED)
+        finally:
+            f.close()
 def test_suite():
 …
 if __name__ == "__main__":
     unittest.main(defaultTest="test_suite")
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/tests/test_core.py

-              r2
+              r388
 import sys
 import test.test_support
+from test.test_support import captured_stdout, run_unittest
 import unittest
+from distutils.tests import support
 # setup script that uses __file__
 …
 class CoreTestCase(unittest.TestCase):
+class CoreTestCase(support.EnvironGuard, unittest.TestCase):
     def setUp(self):
+        super(CoreTestCase, self).setUp()
         self.old_stdout = sys.stdout
         self.cleanup_testfn()
+        self.old_argv = sys.argv, sys.argv[:]
     def tearDown(self):
         sys.stdout = self.old_stdout
         self.cleanup_testfn()
+        sys.argv = self.old_argv[0]
+        sys.argv[:] = self.old_argv[1]
+        super(CoreTestCase, self).tearDown()
     def cleanup_testfn(self):
 …
     def write_setup(self, text, path=test.test_support.TESTFN):
+        open(path, "w").write(text)
+        f = open(path, "w")
+        try:
+            f.write(text)
+        finally:
+            f.close()
         return path
 …
         self.assertEqual(cwd, output)
+    def test_debug_mode(self):
+        # this covers the code called when DEBUG is set
+        sys.argv = ['setup.py', '--name']
+        with captured_stdout() as stdout:
+            distutils.core.setup(name='bar')
+        stdout.seek(0)
+        self.assertEqual(stdout.read(), 'bar\n')
+        distutils.core.DEBUG = True
+        try:
+            with captured_stdout() as stdout:
+                distutils.core.setup(name='bar')
+        finally:
+            distutils.core.DEBUG = False
+        stdout.seek(0)
+        wanted = "options (after parsing config files):\n"
+        self.assertEqual(stdout.readlines()[0], wanted)
 def test_suite():
 …
 if __name__ == "__main__":
     unittest.main(defaultTest="test_suite")
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/tests/test_dist.py

-              r2
+              r388
 # -*- coding: latin-1 -*-
+# -*- coding: utf8 -*-
 """Tests for distutils.dist."""
-import distutils.cmd
-import distutils.dist
 import os
 import StringIO
 …
 import textwrap
+from test.test_support import TESTFN
+class test_dist(distutils.cmd.Command):
+from distutils.dist import Distribution, fix_help_options
+from distutils.cmd import Command
+import distutils.dist
+from test.test_support import TESTFN, captured_stdout, run_unittest
+from distutils.tests import support
+class test_dist(Command):
     """Sample distutils extension command."""
 …
 class TestDistribution(distutils.dist.Distribution):
+class TestDistribution(Distribution):
     """Distribution subclasses that avoids the default search for
     configuration files.
 …
+class DistributionTestCase(unittest.TestCase):
+class DistributionTestCase(support.TempdirManager,
+                           support.LoggingSilencer,
+                           support.EnvironGuard,
+                           unittest.TestCase):
     def setUp(self):
+        self.argv = sys.argv[:]
+        super(DistributionTestCase, self).setUp()
+        self.argv = sys.argv, sys.argv[:]
         del sys.argv[1:]
     def tearDown(self):
+        sys.argv[:] = self.argv
+        sys.argv = self.argv[0]
+        sys.argv[:] = self.argv[1]
+        super(DistributionTestCase, self).tearDown()
     def create_distribution(self, configfiles=()):
 …
         d.parse_command_line()
         return d
+    def test_debug_mode(self):
+        with open(TESTFN, "w") as f:
+            f.write("[global]\n")
+            f.write("command_packages = foo.bar, splat")
+        files = [TESTFN]
+        sys.argv.append("build")
+        with captured_stdout() as stdout:
+            self.create_distribution(files)
+        stdout.seek(0)
+        self.assertEqual(stdout.read(), '')
+        distutils.dist.DEBUG = True
+        try:
+            with captured_stdout() as stdout:
+                self.create_distribution(files)
+            stdout.seek(0)
+            self.assertEqual(stdout.read(), '')
+        finally:
+            distutils.dist.DEBUG = False
     def test_command_packages_unspecified(self):
 …
                          ["distutils.command", "foo.bar", "distutils.tests"])
         cmd = d.get_command_obj("test_dist")
         self.assert_(isinstance(cmd, test_dist))
+        self.assertIsInstance(cmd, test_dist)
         self.assertEqual(cmd.sample_option, "sometext")
     def test_command_packages_configfile(self):
         sys.argv.append("build")
+        self.addCleanup(os.unlink, TESTFN)
         f = open(TESTFN, "w")
         try:
+            print >>f, "[global]"
+            print >>f, "command_packages = foo.bar, splat"
+            print >> f, "[global]"
+            print >> f, "command_packages = foo.bar, splat"
+        finally:
             f.close()
+            d = self.create_distribution([TESTFN])
+            self.assertEqual(d.get_command_packages(),
+                             ["distutils.command", "foo.bar", "splat"])
+            # ensure command line overrides config:
+            sys.argv[1:] = ["--command-packages", "spork", "build"]
+            d = self.create_distribution([TESTFN])
+            self.assertEqual(d.get_command_packages(),
+                             ["distutils.command", "spork"])
+            # Setting --command-packages to '' should cause the default to
+            # be used even if a config file specified something else:
+            sys.argv[1:] = ["--command-packages", "", "build"]
+            d = self.create_distribution([TESTFN])
+            self.assertEqual(d.get_command_packages(), ["distutils.command"])
+        finally:
+            os.unlink(TESTFN)
+        d = self.create_distribution([TESTFN])
+        self.assertEqual(d.get_command_packages(),
+                         ["distutils.command", "foo.bar", "splat"])
+        # ensure command line overrides config:
+        sys.argv[1:] = ["--command-packages", "spork", "build"]
+        d = self.create_distribution([TESTFN])
+        self.assertEqual(d.get_command_packages(),
+                         ["distutils.command", "spork"])
+        # Setting --command-packages to '' should cause the default to
+        # be used even if a config file specified something else:
+        sys.argv[1:] = ["--command-packages", "", "build"]
+        d = self.create_distribution([TESTFN])
+        self.assertEqual(d.get_command_packages(), ["distutils.command"])
     def test_write_pkg_file(self):
         # Check DistributionMetadata handling of Unicode fields
+        my_file = os.path.join(os.path.dirname(__file__), 'f')
+        klass = distutils.dist.Distribution
+        dist = klass(attrs={'author': u'Mister Café',
+        tmp_dir = self.mkdtemp()
+        my_file = os.path.join(tmp_dir, 'f')
+        klass = Distribution
+        dist = klass(attrs={'author': u'Mister CafÃ©',
                             'name': 'my.package',
+                            'maintainer': u'Café Junior',
+                            'description': u'Café torréfié',
+                            'long_description': u'Héhéhé'})
+                            'maintainer': u'CafÃ© Junior',
+                            'description': u'CafÃ© torrÃ©fiÃ©',
+                            'long_description': u'HÃ©hÃ©hÃ©'})
         # let's make sure the file can be written
         # with Unicode fields. they are encoded with
         # PKG_INFO_ENCODING
+        try:
+            dist.metadata.write_pkg_file(open(my_file, 'w'))
+        finally:
+            if os.path.exists(my_file):
+                os.remove(my_file)
+        dist.metadata.write_pkg_file(open(my_file, 'w'))
         # regular ascii is of course always usable
 …
                             'long_description': 'Hehehe'})
+        try:
+            dist.metadata.write_pkg_file(open(my_file, 'w'))
+        finally:
+            if os.path.exists(my_file):
+                os.remove(my_file)
+        my_file2 = os.path.join(tmp_dir, 'f2')
+        dist.metadata.write_pkg_file(open(my_file2, 'w'))
     def test_empty_options(self):
         # an empty options dictionary should not stay in the
         # list of attributes
-        klass = distutils.dist.Distribution
         # catching warnings
         warns = []
         def _warn(msg):
             warns.append(msg)
         old_warn = warnings.warn
+        self.addCleanup(setattr, warnings, 'warn', warnings.warn)
         warnings.warn = _warn
+        dist = Distribution(attrs={'author': 'xxx', 'name': 'xxx',
+                                   'version': 'xxx', 'url': 'xxxx',
+                                   'options': {}})
+        self.assertEqual(len(warns), 0)
+        self.assertNotIn('options', dir(dist))
+    def test_finalize_options(self):
+        attrs = {'keywords': 'one,two',
+                 'platforms': 'one,two'}
+        dist = Distribution(attrs=attrs)
+        dist.finalize_options()
+        # finalize_option splits platforms and keywords
+        self.assertEqual(dist.metadata.platforms, ['one', 'two'])
+        self.assertEqual(dist.metadata.keywords, ['one', 'two'])
+    def test_get_command_packages(self):
+        dist = Distribution()
+        self.assertEqual(dist.command_packages, None)
+        cmds = dist.get_command_packages()
+        self.assertEqual(cmds, ['distutils.command'])
+        self.assertEqual(dist.command_packages,
+                         ['distutils.command'])
+        dist.command_packages = 'one,two'
+        cmds = dist.get_command_packages()
+        self.assertEqual(cmds, ['distutils.command', 'one', 'two'])
+    def test_announce(self):
+        # make sure the level is known
+        dist = Distribution()
+        args = ('ok',)
+        kwargs = {'level': 'ok2'}
+        self.assertRaises(ValueError, dist.announce, args, kwargs)
+    def test_find_config_files_disable(self):
+        # Ticket #1180: Allow user to disable their home config file.
+        temp_home = self.mkdtemp()
+        if os.name == 'posix':
+            user_filename = os.path.join(temp_home, ".pydistutils.cfg")
+        else:
+            user_filename = os.path.join(temp_home, "pydistutils.cfg")
+        with open(user_filename, 'w') as f:
+            f.write('[distutils]\n')
+        def _expander(path):
+            return temp_home
+        old_expander = os.path.expanduser
+        os.path.expanduser = _expander
         try:
+            dist = klass(attrs={'author': 'xxx',
+                                'name': 'xxx',
+                                'version': 'xxx',
+                                'url': 'xxxx',
+                                'options': {}})
+            d = distutils.dist.Distribution()
+            all_files = d.find_config_files()
+            d = distutils.dist.Distribution(attrs={'script_args':
+                                            ['--no-user-cfg']})
+            files = d.find_config_files()
         finally:
+            warnings.warn = old_warn
+        self.assertEquals(len(warns), 0)
+class MetadataTestCase(unittest.TestCase):
+    def test_simple_metadata(self):
+        attrs = {"name": "package",
+                 "version": "1.0"}
+        dist = distutils.dist.Distribution(attrs)
+        meta = self.format_metadata(dist)
+        self.assert_("Metadata-Version: 1.0" in meta)
+        self.assert_("provides:" not in meta.lower())
+        self.assert_("requires:" not in meta.lower())
+        self.assert_("obsoletes:" not in meta.lower())
+    def test_provides(self):
+        attrs = {"name": "package",
+                 "version": "1.0",
+                 "provides": ["package", "package.sub"]}
+        dist = distutils.dist.Distribution(attrs)
+        self.assertEqual(dist.metadata.get_provides(),
+                         ["package", "package.sub"])
+        self.assertEqual(dist.get_provides(),
+                         ["package", "package.sub"])
+        meta = self.format_metadata(dist)
+        self.assert_("Metadata-Version: 1.1" in meta)
+        self.assert_("requires:" not in meta.lower())
+        self.assert_("obsoletes:" not in meta.lower())
+    def test_provides_illegal(self):
+        self.assertRaises(ValueError,
+                          distutils.dist.Distribution,
+                          {"name": "package",
+                           "version": "1.0",
+                           "provides": ["my.pkg (splat)"]})
+    def test_requires(self):
+        attrs = {"name": "package",
+                 "version": "1.0",
+                 "requires": ["other", "another (==1.0)"]}
+        dist = distutils.dist.Distribution(attrs)
+        self.assertEqual(dist.metadata.get_requires(),
+                         ["other", "another (==1.0)"])
+        self.assertEqual(dist.get_requires(),
+                         ["other", "another (==1.0)"])
+        meta = self.format_metadata(dist)
+        self.assert_("Metadata-Version: 1.1" in meta)
+        self.assert_("provides:" not in meta.lower())
+        self.assert_("Requires: other" in meta)
+        self.assert_("Requires: another (==1.0)" in meta)
+        self.assert_("obsoletes:" not in meta.lower())
+    def test_requires_illegal(self):
+        self.assertRaises(ValueError,
+                          distutils.dist.Distribution,
+                          {"name": "package",
+                           "version": "1.0",
+                           "requires": ["my.pkg (splat)"]})
+    def test_obsoletes(self):
+        attrs = {"name": "package",
+                 "version": "1.0",
+                 "obsoletes": ["other", "another (<1.0)"]}
+        dist = distutils.dist.Distribution(attrs)
+        self.assertEqual(dist.metadata.get_obsoletes(),
+                         ["other", "another (<1.0)"])
+        self.assertEqual(dist.get_obsoletes(),
+                         ["other", "another (<1.0)"])
+        meta = self.format_metadata(dist)
+        self.assert_("Metadata-Version: 1.1" in meta)
+        self.assert_("provides:" not in meta.lower())
+        self.assert_("requires:" not in meta.lower())
+        self.assert_("Obsoletes: other" in meta)
+        self.assert_("Obsoletes: another (<1.0)" in meta)
+    def test_obsoletes_illegal(self):
+        self.assertRaises(ValueError,
+                          distutils.dist.Distribution,
+                          {"name": "package",
+                           "version": "1.0",
+                           "obsoletes": ["my.pkg (splat)"]})
+    def format_metadata(self, dist):
+        sio = StringIO.StringIO()
+        dist.metadata.write_pkg_file(sio)
+        return sio.getvalue()
+    def test_custom_pydistutils(self):
+        # fixes #2166
+        # make sure pydistutils.cfg is found
+        old = {}
+        for env in ('HOME', 'HOMEPATH', 'HOMEDRIVE'):
+            value = os.environ.get(env)
+            old[env] = value
+            if value is not None:
+                del os.environ[env]
+        if os.name == 'posix':
+            user_filename = ".pydistutils.cfg"
+        else:
+            user_filename = "pydistutils.cfg"
+        curdir = os.path.dirname(__file__)
+        user_filename = os.path.join(curdir, user_filename)
+        f = open(user_filename, 'w')
+        f.write('.')
+        f.close()
+        try:
+            dist = distutils.dist.Distribution()
+            # linux-style
+            if sys.platform in ('linux', 'darwin'):
+                os.environ['HOME'] = curdir
+                files = dist.find_config_files()
+                self.assert_(user_filename in files)
+            # win32-style
+            if sys.platform == 'win32':
+                # home drive should be found
+                os.environ['HOME'] = curdir
+                files = dist.find_config_files()
+                self.assert_(user_filename in files,
+                             '%r not found in %r' % (user_filename, files))
+        finally:
+            for key, value in old.items():
+                if value is None:
+                    continue
+                os.environ[key] = value
+            os.remove(user_filename)
+            os.path.expanduser = old_expander
+        # make sure --no-user-cfg disables the user cfg file
+        self.assertEqual(len(all_files)-1, len(files))
+class MetadataTestCase(support.TempdirManager, support.EnvironGuard,
+                       unittest.TestCase):
+    def setUp(self):
+        super(MetadataTestCase, self).setUp()
+        self.argv = sys.argv, sys.argv[:]
+    def tearDown(self):
+        sys.argv = self.argv[0]
+        sys.argv[:] = self.argv[1]
+        super(MetadataTestCase, self).tearDown()
+    def test_classifier(self):
+        attrs = {'name': 'Boa', 'version': '3.0',
+                 'classifiers': ['Programming Language :: Python :: 3']}
+        dist = Distribution(attrs)
+        meta = self.format_metadata(dist)
+        self.assertIn('Metadata-Version: 1.1', meta)
+    def test_download_url(self):
+        attrs = {'name': 'Boa', 'version': '3.0',
+                 'download_url': 'http://example.org/boa'}
+        dist = Distribution(attrs)
+        meta = self.format_metadata(dist)
+        self.assertIn('Metadata-Version: 1.1', meta)
     def test_long_description(self):
 …
                  "long_description": long_desc}
         dist = distutils.dist.Distribution(attrs)
+        dist = Distribution(attrs)
         meta = self.format_metadata(dist)
         meta = meta.replace('\n' + 8 * ' ', '\n')
+        self.assertTrue(long_desc in meta)
+        self.assertIn(long_desc, meta)
+    def test_simple_metadata(self):
+        attrs = {"name": "package",
+                 "version": "1.0"}
+        dist = Distribution(attrs)
+        meta = self.format_metadata(dist)
+        self.assertIn("Metadata-Version: 1.0", meta)
+        self.assertNotIn("provides:", meta.lower())
+        self.assertNotIn("requires:", meta.lower())
+        self.assertNotIn("obsoletes:", meta.lower())
+    def test_provides(self):
+        attrs = {"name": "package",
+                 "version": "1.0",
+                 "provides": ["package", "package.sub"]}
+        dist = Distribution(attrs)
+        self.assertEqual(dist.metadata.get_provides(),
+                         ["package", "package.sub"])
+        self.assertEqual(dist.get_provides(),
+                         ["package", "package.sub"])
+        meta = self.format_metadata(dist)
+        self.assertIn("Metadata-Version: 1.1", meta)
+        self.assertNotIn("requires:", meta.lower())
+        self.assertNotIn("obsoletes:", meta.lower())
+    def test_provides_illegal(self):
+        self.assertRaises(ValueError, Distribution,
+                          {"name": "package",
+                           "version": "1.0",
+                           "provides": ["my.pkg (splat)"]})
+    def test_requires(self):
+        attrs = {"name": "package",
+                 "version": "1.0",
+                 "requires": ["other", "another (==1.0)"]}
+        dist = Distribution(attrs)
+        self.assertEqual(dist.metadata.get_requires(),
+                         ["other", "another (==1.0)"])
+        self.assertEqual(dist.get_requires(),
+                         ["other", "another (==1.0)"])
+        meta = self.format_metadata(dist)
+        self.assertIn("Metadata-Version: 1.1", meta)
+        self.assertNotIn("provides:", meta.lower())
+        self.assertIn("Requires: other", meta)
+        self.assertIn("Requires: another (==1.0)", meta)
+        self.assertNotIn("obsoletes:", meta.lower())
+    def test_requires_illegal(self):
+        self.assertRaises(ValueError, Distribution,
+                          {"name": "package",
+                           "version": "1.0",
+                           "requires": ["my.pkg (splat)"]})
+    def test_obsoletes(self):
+        attrs = {"name": "package",
+                 "version": "1.0",
+                 "obsoletes": ["other", "another (<1.0)"]}
+        dist = Distribution(attrs)
+        self.assertEqual(dist.metadata.get_obsoletes(),
+                         ["other", "another (<1.0)"])
+        self.assertEqual(dist.get_obsoletes(),
+                         ["other", "another (<1.0)"])
+        meta = self.format_metadata(dist)
+        self.assertIn("Metadata-Version: 1.1", meta)
+        self.assertNotIn("provides:", meta.lower())
+        self.assertNotIn("requires:", meta.lower())
+        self.assertIn("Obsoletes: other", meta)
+        self.assertIn("Obsoletes: another (<1.0)", meta)
+    def test_obsoletes_illegal(self):
+        self.assertRaises(ValueError, Distribution,
+                          {"name": "package",
+                           "version": "1.0",
+                           "obsoletes": ["my.pkg (splat)"]})
+    def format_metadata(self, dist):
+        sio = StringIO.StringIO()
+        dist.metadata.write_pkg_file(sio)
+        return sio.getvalue()
+    def test_custom_pydistutils(self):
+        # fixes #2166
+        # make sure pydistutils.cfg is found
+        if os.name == 'posix':
+            user_filename = ".pydistutils.cfg"
+        else:
+            user_filename = "pydistutils.cfg"
+        temp_dir = self.mkdtemp()
+        user_filename = os.path.join(temp_dir, user_filename)
+        f = open(user_filename, 'w')
+        try:
+            f.write('.')
+        finally:
+            f.close()
+        try:
+            dist = Distribution()
+            # linux-style
+            if sys.platform in ('linux', 'darwin'):
+                os.environ['HOME'] = temp_dir
+                files = dist.find_config_files()
+                self.assertIn(user_filename, files)
+            # win32-style
+            if sys.platform == 'win32':
+                # home drive should be found
+                os.environ['HOME'] = temp_dir
+                files = dist.find_config_files()
+                self.assertIn(user_filename, files,
+                             '%r not found in %r' % (user_filename, files))
+        finally:
+            os.remove(user_filename)
+    def test_fix_help_options(self):
+        help_tuples = [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]
+        fancy_options = fix_help_options(help_tuples)
+        self.assertEqual(fancy_options[0], ('a', 'b', 'c'))
+        self.assertEqual(fancy_options[1], (1, 2, 3))
+    def test_show_help(self):
+        # smoke test, just makes sure some help is displayed
+        dist = Distribution()
+        sys.argv = []
+        dist.help = 1
+        dist.script_name = 'setup.py'
+        with captured_stdout() as s:
+            dist.parse_command_line()
+        output = [line for line in s.getvalue().split('\n')
+                  if line.strip() != '']
+        self.assertTrue(output)
+    def test_read_metadata(self):
+        attrs = {"name": "package",
+                 "version": "1.0",
+                 "long_description": "desc",
+                 "description": "xxx",
+                 "download_url": "http://example.com",
+                 "keywords": ['one', 'two'],
+                 "requires": ['foo']}
+        dist = Distribution(attrs)
+        metadata = dist.metadata
+        # write it then reloads it
+        PKG_INFO = StringIO.StringIO()
+        metadata.write_pkg_file(PKG_INFO)
+        PKG_INFO.seek(0)
+        metadata.read_pkg_file(PKG_INFO)
+        self.assertEqual(metadata.name, "package")
+        self.assertEqual(metadata.version, "1.0")
+        self.assertEqual(metadata.description, "xxx")
+        self.assertEqual(metadata.download_url, 'http://example.com')
+        self.assertEqual(metadata.keywords, ['one', 'two'])
+        self.assertEqual(metadata.platforms, ['UNKNOWN'])
+        self.assertEqual(metadata.obsoletes, None)
+        self.assertEqual(metadata.requires, ['foo'])
 def test_suite():
 …
 if __name__ == "__main__":
     unittest.main(defaultTest="test_suite")
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/tests/test_filelist.py

-              r2
+              r388
 """Tests for distutils.filelist."""
+import os
+import re
 import unittest
+from distutils.filelist import glob_to_re
+class FileListTestCase(unittest.TestCase):
+from distutils import debug
+from distutils.log import WARN
+from distutils.errors import DistutilsTemplateError
+from distutils.filelist import glob_to_re, translate_pattern, FileList
+from test.test_support import captured_stdout, run_unittest
+from distutils.tests import support
+MANIFEST_IN = """\
+include ok
+include xo
+exclude xo
+include foo.tmp
+include buildout.cfg
+global-include *.x
+global-include *.txt
+global-exclude *.tmp
+recursive-include f *.oo
+recursive-exclude global *.x
+graft dir
+prune dir3
+"""
+def make_local_path(s):
+    """Converts '/' in a string to os.sep"""
+    return s.replace('/', os.sep)
+class FileListTestCase(support.LoggingSilencer,
+                       unittest.TestCase):
+    def assertNoWarnings(self):
+        self.assertEqual(self.get_logs(WARN), [])
+        self.clear_logs()
+    def assertWarnings(self):
+        self.assertGreater(len(self.get_logs(WARN)), 0)
+        self.clear_logs()
     def test_glob_to_re(self):
+        # simple cases
+        self.assertEquals(glob_to_re('foo*'), 'foo[^/]*\\Z(?ms)')
+        self.assertEquals(glob_to_re('foo?'), 'foo[^/]\\Z(?ms)')
+        self.assertEquals(glob_to_re('foo??'), 'foo[^/][^/]\\Z(?ms)')
+        # special cases
+        self.assertEquals(glob_to_re(r'foo\\*'), r'foo\\\\[^/]*\Z(?ms)')
+        self.assertEquals(glob_to_re(r'foo\\\*'), r'foo\\\\\\[^/]*\Z(?ms)')
+        self.assertEquals(glob_to_re('foo????'), r'foo[^/][^/][^/][^/]\Z(?ms)')
+        self.assertEquals(glob_to_re(r'foo\\??'), r'foo\\\\[^/][^/]\Z(?ms)')
+        sep = os.sep
+        if os.sep == '\\':
+            sep = re.escape(os.sep)
+        for glob, regex in (
+            # simple cases
+            ('foo*', r'foo[^%(sep)s]*\Z(?ms)'),
+            ('foo?', r'foo[^%(sep)s]\Z(?ms)'),
+            ('foo??', r'foo[^%(sep)s][^%(sep)s]\Z(?ms)'),
+            # special cases
+            (r'foo\\*', r'foo\\\\[^%(sep)s]*\Z(?ms)'),
+            (r'foo\\\*', r'foo\\\\\\[^%(sep)s]*\Z(?ms)'),
+            ('foo????', r'foo[^%(sep)s][^%(sep)s][^%(sep)s][^%(sep)s]\Z(?ms)'),
+            (r'foo\\??', r'foo\\\\[^%(sep)s][^%(sep)s]\Z(?ms)')):
+            regex = regex % {'sep': sep}
+            self.assertEqual(glob_to_re(glob), regex)
+    def test_process_template_line(self):
+        # testing  all MANIFEST.in template patterns
+        file_list = FileList()
+        l = make_local_path
+        # simulated file list
+        file_list.allfiles = ['foo.tmp', 'ok', 'xo', 'four.txt',
+                              'buildout.cfg',
+                              # filelist does not filter out VCS directories,
+                              # it's sdist that does
+                              l('.hg/last-message.txt'),
+                              l('global/one.txt'),
+                              l('global/two.txt'),
+                              l('global/files.x'),
+                              l('global/here.tmp'),
+                              l('f/o/f.oo'),
+                              l('dir/graft-one'),
+                              l('dir/dir2/graft2'),
+                              l('dir3/ok'),
+                              l('dir3/sub/ok.txt'),
+                             ]
+        for line in MANIFEST_IN.split('\n'):
+            if line.strip() == '':
+                continue
+            file_list.process_template_line(line)
+        wanted = ['ok',
+                  'buildout.cfg',
+                  'four.txt',
+                  l('.hg/last-message.txt'),
+                  l('global/one.txt'),
+                  l('global/two.txt'),
+                  l('f/o/f.oo'),
+                  l('dir/graft-one'),
+                  l('dir/dir2/graft2'),
+                 ]
+        self.assertEqual(file_list.files, wanted)
+    def test_debug_print(self):
+        file_list = FileList()
+        with captured_stdout() as stdout:
+            file_list.debug_print('xxx')
+        self.assertEqual(stdout.getvalue(), '')
+        debug.DEBUG = True
+        try:
+            with captured_stdout() as stdout:
+                file_list.debug_print('xxx')
+            self.assertEqual(stdout.getvalue(), 'xxx\n')
+        finally:
+            debug.DEBUG = False
+    def test_set_allfiles(self):
+        file_list = FileList()
+        files = ['a', 'b', 'c']
+        file_list.set_allfiles(files)
+        self.assertEqual(file_list.allfiles, files)
+    def test_remove_duplicates(self):
+        file_list = FileList()
+        file_list.files = ['a', 'b', 'a', 'g', 'c', 'g']
+        # files must be sorted beforehand (sdist does it)
+        file_list.sort()
+        file_list.remove_duplicates()
+        self.assertEqual(file_list.files, ['a', 'b', 'c', 'g'])
+    def test_translate_pattern(self):
+        # not regex
+        self.assertTrue(hasattr(
+            translate_pattern('a', anchor=True, is_regex=False),
+            'search'))
+        # is a regex
+        regex = re.compile('a')
+        self.assertEqual(
+            translate_pattern(regex, anchor=True, is_regex=True),
+            regex)
+        # plain string flagged as regex
+        self.assertTrue(hasattr(
+            translate_pattern('a', anchor=True, is_regex=True),
+            'search'))
+        # glob support
+        self.assertTrue(translate_pattern(
+            '*.py', anchor=True, is_regex=False).search('filelist.py'))
+    def test_exclude_pattern(self):
+        # return False if no match
+        file_list = FileList()
+        self.assertFalse(file_list.exclude_pattern('*.py'))
+        # return True if files match
+        file_list = FileList()
+        file_list.files = ['a.py', 'b.py']
+        self.assertTrue(file_list.exclude_pattern('*.py'))
+        # test excludes
+        file_list = FileList()
+        file_list.files = ['a.py', 'a.txt']
+        file_list.exclude_pattern('*.py')
+        self.assertEqual(file_list.files, ['a.txt'])
+    def test_include_pattern(self):
+        # return False if no match
+        file_list = FileList()
+        file_list.set_allfiles([])
+        self.assertFalse(file_list.include_pattern('*.py'))
+        # return True if files match
+        file_list = FileList()
+        file_list.set_allfiles(['a.py', 'b.txt'])
+        self.assertTrue(file_list.include_pattern('*.py'))
+        # test * matches all files
+        file_list = FileList()
+        self.assertIsNone(file_list.allfiles)
+        file_list.set_allfiles(['a.py', 'b.txt'])
+        file_list.include_pattern('*')
+        self.assertEqual(file_list.allfiles, ['a.py', 'b.txt'])
+    def test_process_template(self):
+        l = make_local_path
+        # invalid lines
+        file_list = FileList()
+        for action in ('include', 'exclude', 'global-include',
+                       'global-exclude', 'recursive-include',
+                       'recursive-exclude', 'graft', 'prune', 'blarg'):
+            self.assertRaises(DistutilsTemplateError,
+                              file_list.process_template_line, action)
+        # include
+        file_list = FileList()
+        file_list.set_allfiles(['a.py', 'b.txt', l('d/c.py')])
+        file_list.process_template_line('include *.py')
+        self.assertEqual(file_list.files, ['a.py'])
+        self.assertNoWarnings()
+        file_list.process_template_line('include *.rb')
+        self.assertEqual(file_list.files, ['a.py'])
+        self.assertWarnings()
+        # exclude
+        file_list = FileList()
+        file_list.files = ['a.py', 'b.txt', l('d/c.py')]
+        file_list.process_template_line('exclude *.py')
+        self.assertEqual(file_list.files, ['b.txt', l('d/c.py')])
+        self.assertNoWarnings()
+        file_list.process_template_line('exclude *.rb')
+        self.assertEqual(file_list.files, ['b.txt', l('d/c.py')])
+        self.assertWarnings()
+        # global-include
+        file_list = FileList()
+        file_list.set_allfiles(['a.py', 'b.txt', l('d/c.py')])
+        file_list.process_template_line('global-include *.py')
+        self.assertEqual(file_list.files, ['a.py', l('d/c.py')])
+        self.assertNoWarnings()
+        file_list.process_template_line('global-include *.rb')
+        self.assertEqual(file_list.files, ['a.py', l('d/c.py')])
+        self.assertWarnings()
+        # global-exclude
+        file_list = FileList()
+        file_list.files = ['a.py', 'b.txt', l('d/c.py')]
+        file_list.process_template_line('global-exclude *.py')
+        self.assertEqual(file_list.files, ['b.txt'])
+        self.assertNoWarnings()
+        file_list.process_template_line('global-exclude *.rb')
+        self.assertEqual(file_list.files, ['b.txt'])
+        self.assertWarnings()
+        # recursive-include
+        file_list = FileList()
+        file_list.set_allfiles(['a.py', l('d/b.py'), l('d/c.txt'),
+                                l('d/d/e.py')])
+        file_list.process_template_line('recursive-include d *.py')
+        self.assertEqual(file_list.files, [l('d/b.py'), l('d/d/e.py')])
+        self.assertNoWarnings()
+        file_list.process_template_line('recursive-include e *.py')
+        self.assertEqual(file_list.files, [l('d/b.py'), l('d/d/e.py')])
+        self.assertWarnings()
+        # recursive-exclude
+        file_list = FileList()
+        file_list.files = ['a.py', l('d/b.py'), l('d/c.txt'), l('d/d/e.py')]
+        file_list.process_template_line('recursive-exclude d *.py')
+        self.assertEqual(file_list.files, ['a.py', l('d/c.txt')])
+        self.assertNoWarnings()
+        file_list.process_template_line('recursive-exclude e *.py')
+        self.assertEqual(file_list.files, ['a.py', l('d/c.txt')])
+        self.assertWarnings()
+        # graft
+        file_list = FileList()
+        file_list.set_allfiles(['a.py', l('d/b.py'), l('d/d/e.py'),
+                                l('f/f.py')])
+        file_list.process_template_line('graft d')
+        self.assertEqual(file_list.files, [l('d/b.py'), l('d/d/e.py')])
+        self.assertNoWarnings()
+        file_list.process_template_line('graft e')
+        self.assertEqual(file_list.files, [l('d/b.py'), l('d/d/e.py')])
+        self.assertWarnings()
+        # prune
+        file_list = FileList()
+        file_list.files = ['a.py', l('d/b.py'), l('d/d/e.py'), l('f/f.py')]
+        file_list.process_template_line('prune d')
+        self.assertEqual(file_list.files, ['a.py', l('f/f.py')])
+        self.assertNoWarnings()
+        file_list.process_template_line('prune e')
+        self.assertEqual(file_list.files, ['a.py', l('f/f.py')])
+        self.assertWarnings()
 def test_suite():
 …
 if __name__ == "__main__":
     unittest.main(defaultTest="test_suite")
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/tests/test_install.py

-              r2
+              r388
 import os
+import sys
 import unittest
+import site
+from test.test_support import captured_stdout, run_unittest
+from distutils import sysconfig
 from distutils.command.install import install
+from distutils.command import install as install_module
+from distutils.command.build_ext import build_ext
+from distutils.command.install import INSTALL_SCHEMES
 from distutils.core import Distribution
+from distutils.errors import DistutilsOptionError
+from distutils.extension import Extension
 from distutils.tests import support
+class InstallTestCase(support.TempdirManager, unittest.TestCase):
+def _make_ext_name(modname):
+    if os.name == 'nt' and sys.executable.endswith('_d.exe'):
+        modname += '_d'
+    return modname + sysconfig.get_config_var('SO')
+class InstallTestCase(support.TempdirManager,
+                      support.LoggingSilencer,
+                      unittest.TestCase):
     def test_home_installation_scheme(self):
 …
         check_path(cmd.install_data, destination)
+    def test_user_site(self):
+        # site.USER_SITE was introduced in 2.6
+        if sys.version < '2.6':
+            return
+        # preparing the environment for the test
+        self.old_user_base = site.USER_BASE
+        self.old_user_site = site.USER_SITE
+        self.tmpdir = self.mkdtemp()
+        self.user_base = os.path.join(self.tmpdir, 'B')
+        self.user_site = os.path.join(self.tmpdir, 'S')
+        site.USER_BASE = self.user_base
+        site.USER_SITE = self.user_site
+        install_module.USER_BASE = self.user_base
+        install_module.USER_SITE = self.user_site
+        def _expanduser(path):
+            return self.tmpdir
+        self.old_expand = os.path.expanduser
+        os.path.expanduser = _expanduser
+        def cleanup():
+            site.USER_BASE = self.old_user_base
+            site.USER_SITE = self.old_user_site
+            install_module.USER_BASE = self.old_user_base
+            install_module.USER_SITE = self.old_user_site
+            os.path.expanduser = self.old_expand
+        self.addCleanup(cleanup)
+        for key in ('nt_user', 'unix_user', 'os2_home'):
+            self.assertIn(key, INSTALL_SCHEMES)
+        dist = Distribution({'name': 'xx'})
+        cmd = install(dist)
+        # making sure the user option is there
+        options = [name for name, short, lable in
+                   cmd.user_options]
+        self.assertIn('user', options)
+        # setting a value
+        cmd.user = 1
+        # user base and site shouldn't be created yet
+        self.assertFalse(os.path.exists(self.user_base))
+        self.assertFalse(os.path.exists(self.user_site))
+        # let's run finalize
+        cmd.ensure_finalized()
+        # now they should
+        self.assertTrue(os.path.exists(self.user_base))
+        self.assertTrue(os.path.exists(self.user_site))
+        self.assertIn('userbase', cmd.config_vars)
+        self.assertIn('usersite', cmd.config_vars)
+    def test_handle_extra_path(self):
+        dist = Distribution({'name': 'xx', 'extra_path': 'path,dirs'})
+        cmd = install(dist)
+        # two elements
+        cmd.handle_extra_path()
+        self.assertEqual(cmd.extra_path, ['path', 'dirs'])
+        self.assertEqual(cmd.extra_dirs, 'dirs')
+        self.assertEqual(cmd.path_file, 'path')
+        # one element
+        cmd.extra_path = ['path']
+        cmd.handle_extra_path()
+        self.assertEqual(cmd.extra_path, ['path'])
+        self.assertEqual(cmd.extra_dirs, 'path')
+        self.assertEqual(cmd.path_file, 'path')
+        # none
+        dist.extra_path = cmd.extra_path = None
+        cmd.handle_extra_path()
+        self.assertEqual(cmd.extra_path, None)
+        self.assertEqual(cmd.extra_dirs, '')
+        self.assertEqual(cmd.path_file, None)
+        # three elements (no way !)
+        cmd.extra_path = 'path,dirs,again'
+        self.assertRaises(DistutilsOptionError, cmd.handle_extra_path)
+    def test_finalize_options(self):
+        dist = Distribution({'name': 'xx'})
+        cmd = install(dist)
+        # must supply either prefix/exec-prefix/home or
+        # install-base/install-platbase -- not both
+        cmd.prefix = 'prefix'
+        cmd.install_base = 'base'
+        self.assertRaises(DistutilsOptionError, cmd.finalize_options)
+        # must supply either home or prefix/exec-prefix -- not both
+        cmd.install_base = None
+        cmd.home = 'home'
+        self.assertRaises(DistutilsOptionError, cmd.finalize_options)
+        # can't combine user with prefix/exec_prefix/home or
+        # install_(plat)base
+        cmd.prefix = None
+        cmd.user = 'user'
+        self.assertRaises(DistutilsOptionError, cmd.finalize_options)
+    def test_record(self):
+        install_dir = self.mkdtemp()
+        project_dir, dist = self.create_dist(py_modules=['hello'],
+                                             scripts=['sayhi'])
+        os.chdir(project_dir)
+        self.write_file('hello.py', "def main(): print 'o hai'")
+        self.write_file('sayhi', 'from hello import main; main()')
+        cmd = install(dist)
+        dist.command_obj['install'] = cmd
+        cmd.root = install_dir
+        cmd.record = os.path.join(project_dir, 'filelist')
+        cmd.ensure_finalized()
+        cmd.run()
+        f = open(cmd.record)
+        try:
+            content = f.read()
+        finally:
+            f.close()
+        found = [os.path.basename(line) for line in content.splitlines()]
+        expected = ['hello.py', 'hello.pyc', 'sayhi',
+                    'UNKNOWN-0.0.0-py%s.%s.egg-info' % sys.version_info[:2]]
+        self.assertEqual(found, expected)
+    def test_record_extensions(self):
+        install_dir = self.mkdtemp()
+        project_dir, dist = self.create_dist(ext_modules=[
+            Extension('xx', ['xxmodule.c'])])
+        os.chdir(project_dir)
+        support.copy_xxmodule_c(project_dir)
+        buildextcmd = build_ext(dist)
+        support.fixup_build_ext(buildextcmd)
+        buildextcmd.ensure_finalized()
+        cmd = install(dist)
+        dist.command_obj['install'] = cmd
+        dist.command_obj['build_ext'] = buildextcmd
+        cmd.root = install_dir
+        cmd.record = os.path.join(project_dir, 'filelist')
+        cmd.ensure_finalized()
+        cmd.run()
+        f = open(cmd.record)
+        try:
+            content = f.read()
+        finally:
+            f.close()
+        found = [os.path.basename(line) for line in content.splitlines()]
+        expected = [_make_ext_name('xx'),
+                    'UNKNOWN-0.0.0-py%s.%s.egg-info' % sys.version_info[:2]]
+        self.assertEqual(found, expected)
+    def test_debug_mode(self):
+        # this covers the code called when DEBUG is set
+        old_logs_len = len(self.logs)
+        install_module.DEBUG = True
+        try:
+            with captured_stdout():
+                self.test_record()
+        finally:
+            install_module.DEBUG = False
+        self.assertTrue(len(self.logs) > old_logs_len)
 def test_suite():
 …
 if __name__ == "__main__":
     unittest.main(defaultTest="test_suite")
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/tests/test_install_lib.py

-              r2
+              r388
 """Tests for distutils.command.install_data."""
+import os
 import sys
-import os
 import unittest
 …
 from distutils.tests import support
 from distutils.errors import DistutilsOptionError
+from test.test_support import run_unittest
 class InstallLibTestCase(support.TempdirManager,
                          support.LoggingSilencer,
+                         support.EnvironGuard,
                          unittest.TestCase):
+    def test_finalize_options(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = install_lib(dist)
+        cmd.finalize_options()
+        self.assertEqual(cmd.compile, 1)
+        self.assertEqual(cmd.optimize, 0)
+        # optimize must be 0, 1, or 2
+        cmd.optimize = 'foo'
+        self.assertRaises(DistutilsOptionError, cmd.finalize_options)
+        cmd.optimize = '4'
+        self.assertRaises(DistutilsOptionError, cmd.finalize_options)
+        cmd.optimize = '2'
+        cmd.finalize_options()
+        self.assertEqual(cmd.optimize, 2)
+    def _setup_byte_compile(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = install_lib(dist)
+        cmd.compile = cmd.optimize = 1
+        f = os.path.join(pkg_dir, 'foo.py')
+        self.write_file(f, '# python file')
+        cmd.byte_compile([f])
+        return pkg_dir
+    @unittest.skipIf(sys.dont_write_bytecode, 'byte-compile not enabled')
+    def test_byte_compile(self):
+        pkg_dir = self._setup_byte_compile()
+        if sys.flags.optimize < 1:
+            self.assertTrue(os.path.exists(os.path.join(pkg_dir, 'foo.pyc')))
+        else:
+            self.assertTrue(os.path.exists(os.path.join(pkg_dir, 'foo.pyo')))
+    def test_get_outputs(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = install_lib(dist)
+        # setting up a dist environment
+        cmd.compile = cmd.optimize = 1
+        cmd.install_dir = pkg_dir
+        f = os.path.join(pkg_dir, 'foo.py')
+        self.write_file(f, '# python file')
+        cmd.distribution.py_modules = [pkg_dir]
+        cmd.distribution.ext_modules = [Extension('foo', ['xxx'])]
+        cmd.distribution.packages = [pkg_dir]
+        cmd.distribution.script_name = 'setup.py'
+        # get_output should return 4 elements
+        self.assertTrue(len(cmd.get_outputs()) >= 2)
+    def test_get_inputs(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = install_lib(dist)
+        # setting up a dist environment
+        cmd.compile = cmd.optimize = 1
+        cmd.install_dir = pkg_dir
+        f = os.path.join(pkg_dir, 'foo.py')
+        self.write_file(f, '# python file')
+        cmd.distribution.py_modules = [pkg_dir]
+        cmd.distribution.ext_modules = [Extension('foo', ['xxx'])]
+        cmd.distribution.packages = [pkg_dir]
+        cmd.distribution.script_name = 'setup.py'
+        # get_input should return 2 elements
+        self.assertEqual(len(cmd.get_inputs()), 2)
     def test_dont_write_bytecode(self):
 …
 if __name__ == "__main__":
     unittest.main(defaultTest="test_suite")
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/tests/test_install_scripts.py

-              r2
+              r388
 from distutils.tests import support
+from test.test_support import run_unittest
 …
+            )
         cmd = install_scripts(dist)
         self.assert_(not cmd.force)
         self.assert_(not cmd.skip_build)
         self.assert_(cmd.build_dir is None)
         self.assert_(cmd.install_dir is None)
+        self.assertTrue(not cmd.force)
+        self.assertTrue(not cmd.skip_build)
+        self.assertTrue(cmd.build_dir is None)
+        self.assertTrue(cmd.install_dir is None)
         cmd.finalize_options()
         self.assert_(cmd.force)
         self.assert_(cmd.skip_build)
+        self.assertTrue(cmd.force)
+        self.assertTrue(cmd.skip_build)
         self.assertEqual(cmd.build_dir, "/foo/bar")
         self.assertEqual(cmd.install_dir, "/splat/funk")
 …
             expected.append(name)
             f = open(os.path.join(source, name), "w")
+            f.write(text)
+            f.close()
+            try:
+                f.write(text)
+            finally:
+                f.close()
         write_script("script1.py", ("#! /usr/bin/env python2.3\n"
 …
         installed = os.listdir(target)
         for name in expected:
             self.assert_(name in installed)
+            self.assertTrue(name in installed)
 …
 if __name__ == "__main__":
     unittest.main(defaultTest="test_suite")
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/tests/test_msvc9compiler.py

-              r2
+              r388
 import sys
 import unittest
+import os
 from distutils.errors import DistutilsPlatformError
+from distutils.tests import support
+from test.test_support import run_unittest
+class msvc9compilerTestCase(unittest.TestCase):
+# A manifest with the only assembly reference being the msvcrt assembly, so
+# should have the assembly completely stripped.  Note that although the
+# assembly has a <security> reference the assembly is removed - that is
+# currently a "feature", not a bug :)
+_MANIFEST_WITH_ONLY_MSVC_REFERENCE = """\
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1"
+          manifestVersion="1.0">
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+    <security>
+      <requestedPrivileges>
+        <requestedExecutionLevel level="asInvoker" uiAccess="false">
+        </requestedExecutionLevel>
+      </requestedPrivileges>
+    </security>
+  </trustInfo>
+  <dependency>
+    <dependentAssembly>
+      <assemblyIdentity type="win32" name="Microsoft.VC90.CRT"
+         version="9.0.21022.8" processorArchitecture="x86"
+         publicKeyToken="XXXX">
+      </assemblyIdentity>
+    </dependentAssembly>
+  </dependency>
+</assembly>
+"""
+# A manifest with references to assemblies other than msvcrt.  When processed,
+# this assembly should be returned with just the msvcrt part removed.
+_MANIFEST_WITH_MULTIPLE_REFERENCES = """\
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1"
+          manifestVersion="1.0">
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+    <security>
+      <requestedPrivileges>
+        <requestedExecutionLevel level="asInvoker" uiAccess="false">
+        </requestedExecutionLevel>
+      </requestedPrivileges>
+    </security>
+  </trustInfo>
+  <dependency>
+    <dependentAssembly>
+      <assemblyIdentity type="win32" name="Microsoft.VC90.CRT"
+         version="9.0.21022.8" processorArchitecture="x86"
+         publicKeyToken="XXXX">
+      </assemblyIdentity>
+    </dependentAssembly>
+  </dependency>
+  <dependency>
+    <dependentAssembly>
+      <assemblyIdentity type="win32" name="Microsoft.VC90.MFC"
+        version="9.0.21022.8" processorArchitecture="x86"
+        publicKeyToken="XXXX"></assemblyIdentity>
+    </dependentAssembly>
+  </dependency>
+</assembly>
+"""
+_CLEANED_MANIFEST = """\
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1"
+          manifestVersion="1.0">
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+    <security>
+      <requestedPrivileges>
+        <requestedExecutionLevel level="asInvoker" uiAccess="false">
+        </requestedExecutionLevel>
+      </requestedPrivileges>
+    </security>
+  </trustInfo>
+  <dependency>
+  </dependency>
+  <dependency>
+    <dependentAssembly>
+      <assemblyIdentity type="win32" name="Microsoft.VC90.MFC"
+        version="9.0.21022.8" processorArchitecture="x86"
+        publicKeyToken="XXXX"></assemblyIdentity>
+    </dependentAssembly>
+  </dependency>
+</assembly>"""
+if sys.platform=="win32":
+    from distutils.msvccompiler import get_build_version
+    if get_build_version()>=8.0:
+        SKIP_MESSAGE = None
+    else:
+        SKIP_MESSAGE = "These tests are only for MSVC8.0 or above"
+else:
+    SKIP_MESSAGE = "These tests are only for win32"
+@unittest.skipUnless(SKIP_MESSAGE is None, SKIP_MESSAGE)
+class msvc9compilerTestCase(support.TempdirManager,
+                            unittest.TestCase):
     def test_no_compiler(self):
         # makes sure query_vcvarsall throws
+        # makes sure query_vcvarsall raises
         # a DistutilsPlatformError if the compiler
         # is not found
-        if sys.platform != 'win32':
-            # this test is only for win32
-            return
-        from distutils.msvccompiler import get_build_version
-        if get_build_version() < 8.0:
-            # this test is only for MSVC8.0 or above
-            return
         from distutils.msvc9compiler import query_vcvarsall
         def _find_vcvarsall(version):
 …
             msvc9compiler.find_vcvarsall = old_find_vcvarsall
+    def test_reg_class(self):
+        from distutils.msvc9compiler import Reg
+        self.assertRaises(KeyError, Reg.get_value, 'xxx', 'xxx')
+        # looking for values that should exist on all
+        # windows registeries versions.
+        path = r'Control Panel\Desktop'
+        v = Reg.get_value(path, u'dragfullwindows')
+        self.assertTrue(v in (u'0', u'1', u'2'))
+        import _winreg
+        HKCU = _winreg.HKEY_CURRENT_USER
+        keys = Reg.read_keys(HKCU, 'xxxx')
+        self.assertEqual(keys, None)
+        keys = Reg.read_keys(HKCU, r'Control Panel')
+        self.assertTrue('Desktop' in keys)
+    def test_remove_visual_c_ref(self):
+        from distutils.msvc9compiler import MSVCCompiler
+        tempdir = self.mkdtemp()
+        manifest = os.path.join(tempdir, 'manifest')
+        f = open(manifest, 'w')
+        try:
+            f.write(_MANIFEST_WITH_MULTIPLE_REFERENCES)
+        finally:
+            f.close()
+        compiler = MSVCCompiler()
+        compiler._remove_visual_c_ref(manifest)
+        # see what we got
+        f = open(manifest)
+        try:
+            # removing trailing spaces
+            content = '\n'.join([line.rstrip() for line in f.readlines()])
+        finally:
+            f.close()
+        # makes sure the manifest was properly cleaned
+        self.assertEqual(content, _CLEANED_MANIFEST)
+    def test_remove_entire_manifest(self):
+        from distutils.msvc9compiler import MSVCCompiler
+        tempdir = self.mkdtemp()
+        manifest = os.path.join(tempdir, 'manifest')
+        f = open(manifest, 'w')
+        try:
+            f.write(_MANIFEST_WITH_ONLY_MSVC_REFERENCE)
+        finally:
+            f.close()
+        compiler = MSVCCompiler()
+        got = compiler._remove_visual_c_ref(manifest)
+        self.assertIs(got, None)
 def test_suite():
     return unittest.makeSuite(msvc9compilerTestCase)
 if __name__ == "__main__":
     unittest.main(defaultTest="test_suite")
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/tests/test_register.py

-              r2
+              r388
+# -*- encoding: utf8 -*-
 """Tests for distutils.command.register."""
-import sys
 import os
 import unittest
+import getpass
+import urllib2
+import warnings
+from test.test_support import check_warnings, run_unittest
+from distutils.command import register as register_module
 from distutils.command.register import register
+from distutils.core import Distribution
+from distutils.tests import support
+from distutils.tests.test_config import PYPIRC, PyPIRCCommandTestCase
+from distutils.errors import DistutilsSetupError
+from distutils.tests.test_config import PyPIRCCommandTestCase
+try:
+    import docutils
+except ImportError:
+    docutils = None
+PYPIRC_NOPASSWORD = """\
+[distutils]
+index-servers =
+    server1
+[server1]
+username:me
+"""
+WANTED_PYPIRC = """\
+[distutils]
+index-servers =
+    pypi
+[pypi]
+username:tarek
+password:password
+"""
 class RawInputs(object):
 …
             self.index += 1
+WANTED_PYPIRC = """\
+[distutils]
+index-servers =
+    pypi
+[pypi]
+username:tarek
+password:xxx
+"""
+class registerTestCase(PyPIRCCommandTestCase):
+class FakeOpener(object):
+    """Fakes a PyPI server"""
+    def __init__(self):
+        self.reqs = []
+    def __call__(self, *args):
+        return self
+    def open(self, req):
+        self.reqs.append(req)
+        return self
+    def read(self):
+        return 'xxx'
+class RegisterTestCase(PyPIRCCommandTestCase):
+    def setUp(self):
+        super(RegisterTestCase, self).setUp()
+        # patching the password prompt
+        self._old_getpass = getpass.getpass
+        def _getpass(prompt):
+            return 'password'
+        getpass.getpass = _getpass
+        self.old_opener = urllib2.build_opener
+        self.conn = urllib2.build_opener = FakeOpener()
+    def tearDown(self):
+        getpass.getpass = self._old_getpass
+        urllib2.build_opener = self.old_opener
+        super(RegisterTestCase, self).tearDown()
+    def _get_cmd(self, metadata=None):
+        if metadata is None:
+            metadata = {'url': 'xxx', 'author': 'xxx',
+                        'author_email': 'xxx',
+                        'name': 'xxx', 'version': 'xxx'}
+        pkg_info, dist = self.create_dist(**metadata)
+        return register(dist)
     def test_create_pypirc(self):
 …
         # is created when requested.
+        # let's create a fake distribution
+        # and a register instance
+        dist = Distribution()
+        dist.metadata.url = 'xxx'
+        dist.metadata.author = 'xxx'
+        dist.metadata.author_email = 'xxx'
+        dist.metadata.name = 'xxx'
+        dist.metadata.version =  'xxx'
+        cmd = register(dist)
+        # let's create a register instance
+        cmd = self._get_cmd()
         # we shouldn't have a .pypirc file yet
         self.assert_(not os.path.exists(self.rc))
+        self.assertTrue(not os.path.exists(self.rc))
         # patching raw_input and getpass.getpass
 …
         # use your existing login (choice 1.)
         # Username : 'tarek'
         # Password : 'xxx'
+        # Password : 'password'
         # Save your login (y/N)? : 'y'
         inputs = RawInputs('1', 'tarek', 'y')
+        from distutils.command import register as register_module
+        register_module.raw_input = inputs.__call__
+        def _getpass(prompt):
+            return 'xxx'
+        register_module.getpass.getpass = _getpass
+        class FakeServer(object):
+            def __init__(self):
+                self.calls = []
+            def __call__(self, *args):
+                # we want to compare them, so let's store
+                # something comparable
+                els = args[0].items()
+                els.sort()
+                self.calls.append(tuple(els))
+                return 200, 'OK'
+        cmd.post_to_server = pypi_server = FakeServer()
+        # let's run the command
+        cmd.run()
+        register_module.raw_input = inputs.__call__
+        # let's run the command
+        try:
+            cmd.run()
+        finally:
+            del register_module.raw_input
         # we should have a brand new .pypirc file
         self.assert_(os.path.exists(self.rc))
+        self.assertTrue(os.path.exists(self.rc))
         # with the content similar to WANTED_PYPIRC
+        content = open(self.rc).read()
+        self.assertEquals(content, WANTED_PYPIRC)
+        f = open(self.rc)
+        try:
+            content = f.read()
+            self.assertEqual(content, WANTED_PYPIRC)
+        finally:
+            f.close()
         # now let's make sure the .pypirc file generated
 …
         register_module.raw_input = _no_way
+        cmd.show_response = 1
         cmd.run()
         # let's see what the server received : we should
         # have 2 similar requests
+        self.assert_(len(pypi_server.calls), 2)
+        self.assert_(pypi_server.calls[0], pypi_server.calls[1])
+        self.assertEqual(len(self.conn.reqs), 2)
+        req1 = dict(self.conn.reqs[0].headers)
+        req2 = dict(self.conn.reqs[1].headers)
+        self.assertEqual(req2['Content-length'], req1['Content-length'])
+        self.assertTrue('xxx' in self.conn.reqs[1].data)
+    def test_password_not_in_file(self):
+        self.write_file(self.rc, PYPIRC_NOPASSWORD)
+        cmd = self._get_cmd()
+        cmd._set_config()
+        cmd.finalize_options()
+        cmd.send_metadata()
+        # dist.password should be set
+        # therefore used afterwards by other commands
+        self.assertEqual(cmd.distribution.password, 'password')
+    def test_registering(self):
+        # this test runs choice 2
+        cmd = self._get_cmd()
+        inputs = RawInputs('2', 'tarek', 'tarek@ziade.org')
+        register_module.raw_input = inputs.__call__
+        try:
+            # let's run the command
+            cmd.run()
+        finally:
+            del register_module.raw_input
+        # we should have send a request
+        self.assertEqual(len(self.conn.reqs), 1)
+        req = self.conn.reqs[0]
+        headers = dict(req.headers)
+        self.assertEqual(headers['Content-length'], '608')
+        self.assertTrue('tarek' in req.data)
+    def test_password_reset(self):
+        # this test runs choice 3
+        cmd = self._get_cmd()
+        inputs = RawInputs('3', 'tarek@ziade.org')
+        register_module.raw_input = inputs.__call__
+        try:
+            # let's run the command
+            cmd.run()
+        finally:
+            del register_module.raw_input
+        # we should have send a request
+        self.assertEqual(len(self.conn.reqs), 1)
+        req = self.conn.reqs[0]
+        headers = dict(req.headers)
+        self.assertEqual(headers['Content-length'], '290')
+        self.assertTrue('tarek' in req.data)
+    @unittest.skipUnless(docutils is not None, 'needs docutils')
+    def test_strict(self):
+        # testing the script option
+        # when on, the register command stops if
+        # the metadata is incomplete or if
+        # long_description is not reSt compliant
+        # empty metadata
+        cmd = self._get_cmd({})
+        cmd.ensure_finalized()
+        cmd.strict = 1
+        self.assertRaises(DistutilsSetupError, cmd.run)
+        # metadata are OK but long_description is broken
+        metadata = {'url': 'xxx', 'author': 'xxx',
+                    'author_email': u'Ã©xÃ©xÃ©',
+                    'name': 'xxx', 'version': 'xxx',
+                    'long_description': 'title\n==\n\ntext'}
+        cmd = self._get_cmd(metadata)
+        cmd.ensure_finalized()
+        cmd.strict = 1
+        self.assertRaises(DistutilsSetupError, cmd.run)
+        # now something that works
+        metadata['long_description'] = 'title\n=====\n\ntext'
+        cmd = self._get_cmd(metadata)
+        cmd.ensure_finalized()
+        cmd.strict = 1
+        inputs = RawInputs('1', 'tarek', 'y')
+        register_module.raw_input = inputs.__call__
+        # let's run the command
+        try:
+            cmd.run()
+        finally:
+            del register_module.raw_input
+        # strict is not by default
+        cmd = self._get_cmd()
+        cmd.ensure_finalized()
+        inputs = RawInputs('1', 'tarek', 'y')
+        register_module.raw_input = inputs.__call__
+        # let's run the command
+        try:
+            cmd.run()
+        finally:
+            del register_module.raw_input
+        # and finally a Unicode test (bug #12114)
+        metadata = {'url': u'xxx', 'author': u'\u00c9ric',
+                    'author_email': u'xxx', u'name': 'xxx',
+                    'version': u'xxx',
+                    'description': u'Something about esszet \u00df',
+                    'long_description': u'More things about esszet \u00df'}
+        cmd = self._get_cmd(metadata)
+        cmd.ensure_finalized()
+        cmd.strict = 1
+        inputs = RawInputs('1', 'tarek', 'y')
+        register_module.raw_input = inputs.__call__
+        # let's run the command
+        try:
+            cmd.run()
+        finally:
+            del register_module.raw_input
+    @unittest.skipUnless(docutils is not None, 'needs docutils')
+    def test_register_invalid_long_description(self):
+        description = ':funkie:`str`'  # mimic Sphinx-specific markup
+        metadata = {'url': 'xxx', 'author': 'xxx',
+                    'author_email': 'xxx',
+                    'name': 'xxx', 'version': 'xxx',
+                    'long_description': description}
+        cmd = self._get_cmd(metadata)
+        cmd.ensure_finalized()
+        cmd.strict = True
+        inputs = RawInputs('2', 'tarek', 'tarek@ziade.org')
+        register_module.raw_input = inputs
+        self.addCleanup(delattr, register_module, 'raw_input')
+        self.assertRaises(DistutilsSetupError, cmd.run)
+    def test_check_metadata_deprecated(self):
+        # makes sure make_metadata is deprecated
+        cmd = self._get_cmd()
+        with check_warnings() as w:
+            warnings.simplefilter("always")
+            cmd.check_metadata()
+            self.assertEqual(len(w.warnings), 1)
 def test_suite():
     return unittest.makeSuite(registerTestCase)
+    return unittest.makeSuite(RegisterTestCase)
 if __name__ == "__main__":
     unittest.main(defaultTest="test_suite")
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/tests/test_sdist.py

-              r2
+              r388
 """Tests for distutils.command.sdist."""
 import os
+import tarfile
 import unittest
 import shutil
+import warnings
 import zipfile
 from os.path import join
+import sys
+from distutils.command.sdist import sdist
+from textwrap import dedent
+from test.test_support import captured_stdout, check_warnings, run_unittest
+# zlib is not used here, but if it's not available
+# the tests that use zipfile may fail
+try:
+    import zlib
+except ImportError:
+    zlib = None
+try:
+    import grp
+    import pwd
+    UID_GID_SUPPORT = True
+except ImportError:
+    UID_GID_SUPPORT = False
+from distutils.command.sdist import sdist, show_formats
 from distutils.core import Distribution
 from distutils.tests.test_config import PyPIRCCommandTestCase
 from distutils.errors import DistutilsExecError
+from distutils.errors import DistutilsOptionError
 from distutils.spawn import find_executable
+from distutils.log import WARN
+from distutils.filelist import FileList
+from distutils.archive_util import ARCHIVE_FORMATS
 SETUP_PY = """
 …
 """
+MANIFEST_IN = """
+recursive-include somecode *
+MANIFEST = """\
+# file GENERATED by distutils, do NOT edit
+README
+buildout.cfg
+inroot.txt
+setup.py
+data%(sep)sdata.dt
+scripts%(sep)sscript.py
+some%(sep)sfile.txt
+some%(sep)sother_file.txt
+somecode%(sep)s__init__.py
+somecode%(sep)sdoc.dat
+somecode%(sep)sdoc.txt
 """
 class sdistTestCase(PyPIRCCommandTestCase):
+class SDistTestCase(PyPIRCCommandTestCase):
     def setUp(self):
+        super(sdistTestCase, self).setUp()
+        # PyPIRCCommandTestCase creates a temp dir already
+        # and put it in self.tmp_dir
+        super(SDistTestCase, self).setUp()
+        # setting up an environment
         self.old_path = os.getcwd()
+        self.temp_pkg = os.path.join(self.mkdtemp(), 'temppkg')
+        os.mkdir(join(self.tmp_dir, 'somecode'))
+        os.mkdir(join(self.tmp_dir, 'dist'))
+        # a package, and a README
+        self.write_file((self.tmp_dir, 'README'), 'xxx')
+        self.write_file((self.tmp_dir, 'somecode', '__init__.py'), '#')
+        self.write_file((self.tmp_dir, 'setup.py'), SETUP_PY)
+        os.chdir(self.tmp_dir)
     def tearDown(self):
+        # back to normal
         os.chdir(self.old_path)
+        super(sdistTestCase, self).tearDown()
+    def _init_tmp_pkg(self):
+        if os.path.exists(self.temp_pkg):
+            shutil.rmtree(self.temp_pkg)
+        os.mkdir(self.temp_pkg)
+        os.mkdir(join(self.temp_pkg, 'somecode'))
+        os.mkdir(join(self.temp_pkg, 'dist'))
+        # creating a MANIFEST, a package, and a README
+        self._write(join(self.temp_pkg, 'MANIFEST.in'), MANIFEST_IN)
+        self._write(join(self.temp_pkg, 'README'), 'xxx')
+        self._write(join(self.temp_pkg, 'somecode', '__init__.py'), '#')
+        self._write(join(self.temp_pkg, 'setup.py'), SETUP_PY)
+        os.chdir(self.temp_pkg)
+    def _write(self, path, content):
+        f = open(path, 'w')
+        try:
+            f.write(content)
+        finally:
+            f.close()
+    def test_prune_file_list(self):
+        # this test creates a package with some vcs dirs in it
+        # and launch sdist to make sure they get pruned
+        # on all systems
+        self._init_tmp_pkg()
+        # creating VCS directories with some files in them
+        os.mkdir(join(self.temp_pkg, 'somecode', '.svn'))
+        self._write(join(self.temp_pkg, 'somecode', '.svn', 'ok.py'), 'xxx')
+        os.mkdir(join(self.temp_pkg, 'somecode', '.hg'))
+        self._write(join(self.temp_pkg, 'somecode', '.hg',
+                         'ok'), 'xxx')
+        os.mkdir(join(self.temp_pkg, 'somecode', '.git'))
+        self._write(join(self.temp_pkg, 'somecode', '.git',
+                         'ok'), 'xxx')
+        # now building a sdist
+        dist = Distribution()
+        super(SDistTestCase, self).tearDown()
+    def get_cmd(self, metadata=None):
+        """Returns a cmd"""
+        if metadata is None:
+            metadata = {'name': 'fake', 'version': '1.0',
+                        'url': 'xxx', 'author': 'xxx',
+                        'author_email': 'xxx'}
+        dist = Distribution(metadata)
         dist.script_name = 'setup.py'
-        dist.metadata.name = 'fake'
-        dist.metadata.version = '1.0'
-        dist.metadata.url = 'http://xxx'
-        dist.metadata.author = dist.metadata.author_email = 'xxx'
         dist.packages = ['somecode']
         dist.include_package_data = True
         cmd = sdist(dist)
-        cmd.manifest = 'MANIFEST'
-        cmd.template = 'MANIFEST.in'
         cmd.dist_dir = 'dist'
+        return dist, cmd
+    @unittest.skipUnless(zlib, "requires zlib")
+    def test_prune_file_list(self):
+        # this test creates a project with some VCS dirs and an NFS rename
+        # file, then launches sdist to check they get pruned on all systems
+        # creating VCS directories with some files in them
+        os.mkdir(join(self.tmp_dir, 'somecode', '.svn'))
+        self.write_file((self.tmp_dir, 'somecode', '.svn', 'ok.py'), 'xxx')
+        os.mkdir(join(self.tmp_dir, 'somecode', '.hg'))
+        self.write_file((self.tmp_dir, 'somecode', '.hg',
+                         'ok'), 'xxx')
+        os.mkdir(join(self.tmp_dir, 'somecode', '.git'))
+        self.write_file((self.tmp_dir, 'somecode', '.git',
+                         'ok'), 'xxx')
+        self.write_file((self.tmp_dir, 'somecode', '.nfs0001'), 'xxx')
+        # now building a sdist
+        dist, cmd = self.get_cmd()
         # zip is available universally
         # (tar might not be installed under win32)
         cmd.formats = ['zip']
+        cmd.ensure_finalized()
         cmd.run()
         # now let's check what we have
         dist_folder = join(self.temp_pkg, 'dist')
+        dist_folder = join(self.tmp_dir, 'dist')
         files = os.listdir(dist_folder)
         self.assertEquals(files, ['fake-1.0.zip'])
+        self.assertEqual(files, ['fake-1.0.zip'])
         zip_file = zipfile.ZipFile(join(dist_folder, 'fake-1.0.zip'))
 …
         # making sure everything has been pruned correctly
+        self.assertEquals(len(content), 4)
+        self.assertEqual(len(content), 4)
+    @unittest.skipUnless(zlib, "requires zlib")
     def test_make_distribution(self):
 …
             return
-        self._init_tmp_pkg()
         # now building a sdist
+        dist = Distribution()
+        dist.script_name = 'setup.py'
+        dist.metadata.name = 'fake'
+        dist.metadata.version = '1.0'
+        dist.metadata.url = 'http://xxx'
+        dist.metadata.author = dist.metadata.author_email = 'xxx'
+        dist.packages = ['somecode']
+        dist.include_package_data = True
+        cmd = sdist(dist)
+        cmd.manifest = 'MANIFEST'
+        cmd.template = 'MANIFEST.in'
+        cmd.dist_dir = 'dist'
+        dist, cmd = self.get_cmd()
         # creating a gztar then a tar
         cmd.formats = ['gztar', 'tar']
+        cmd.ensure_finalized()
         cmd.run()
         # making sure we have two files
         dist_folder = join(self.temp_pkg, 'dist')
+        dist_folder = join(self.tmp_dir, 'dist')
         result = os.listdir(dist_folder)
         result.sort()
+        self.assertEquals(result,
+                          ['fake-1.0.tar', 'fake-1.0.tar.gz'] )
+        self.assertEqual(result, ['fake-1.0.tar', 'fake-1.0.tar.gz'])
         os.remove(join(dist_folder, 'fake-1.0.tar'))
 …
         # now trying a tar then a gztar
         cmd.formats = ['tar', 'gztar']
+        cmd.ensure_finalized()
         cmd.run()
         result = os.listdir(dist_folder)
         result.sort()
+        self.assertEquals(result,
+                ['fake-1.0.tar', 'fake-1.0.tar.gz'])
+        self.assertEqual(result, ['fake-1.0.tar', 'fake-1.0.tar.gz'])
+    @unittest.skipUnless(zlib, "requires zlib")
+    def test_unicode_metadata_tgz(self):
+        """
+        Unicode name or version should not break building to tar.gz format.
+        Reference issue #11638.
+        """
+        # create the sdist command with unicode parameters
+        dist, cmd = self.get_cmd({'name': u'fake', 'version': u'1.0'})
+        # create the sdist as gztar and run the command
+        cmd.formats = ['gztar']
+        cmd.ensure_finalized()
+        cmd.run()
+        # The command should have created the .tar.gz file
+        dist_folder = join(self.tmp_dir, 'dist')
+        result = os.listdir(dist_folder)
+        self.assertEqual(result, ['fake-1.0.tar.gz'])
+        os.remove(join(dist_folder, 'fake-1.0.tar.gz'))
+    @unittest.skipUnless(zlib, "requires zlib")
+    def test_add_defaults(self):
+        # http://bugs.python.org/issue2279
+        # add_default should also include
+        # data_files and package_data
+        dist, cmd = self.get_cmd()
+        # filling data_files by pointing files
+        # in package_data
+        dist.package_data = {'': ['*.cfg', '*.dat'],
+                             'somecode': ['*.txt']}
+        self.write_file((self.tmp_dir, 'somecode', 'doc.txt'), '#')
+        self.write_file((self.tmp_dir, 'somecode', 'doc.dat'), '#')
+        # adding some data in data_files
+        data_dir = join(self.tmp_dir, 'data')
+        os.mkdir(data_dir)
+        self.write_file((data_dir, 'data.dt'), '#')
+        some_dir = join(self.tmp_dir, 'some')
+        os.mkdir(some_dir)
+        # make sure VCS directories are pruned (#14004)
+        hg_dir = join(self.tmp_dir, '.hg')
+        os.mkdir(hg_dir)
+        self.write_file((hg_dir, 'last-message.txt'), '#')
+        # a buggy regex used to prevent this from working on windows (#6884)
+        self.write_file((self.tmp_dir, 'buildout.cfg'), '#')
+        self.write_file((self.tmp_dir, 'inroot.txt'), '#')
+        self.write_file((some_dir, 'file.txt'), '#')
+        self.write_file((some_dir, 'other_file.txt'), '#')
+        dist.data_files = [('data', ['data/data.dt',
+                                     'buildout.cfg',
+                                     'inroot.txt',
+                                     'notexisting']),
+                           'some/file.txt',
+                           'some/other_file.txt']
+        # adding a script
+        script_dir = join(self.tmp_dir, 'scripts')
+        os.mkdir(script_dir)
+        self.write_file((script_dir, 'script.py'), '#')
+        dist.scripts = [join('scripts', 'script.py')]
+        cmd.formats = ['zip']
+        cmd.use_defaults = True
+        cmd.ensure_finalized()
+        cmd.run()
+        # now let's check what we have
+        dist_folder = join(self.tmp_dir, 'dist')
+        files = os.listdir(dist_folder)
+        self.assertEqual(files, ['fake-1.0.zip'])
+        zip_file = zipfile.ZipFile(join(dist_folder, 'fake-1.0.zip'))
+        try:
+            content = zip_file.namelist()
+        finally:
+            zip_file.close()
+        # making sure everything was added
+        self.assertEqual(len(content), 12)
+        # checking the MANIFEST
+        f = open(join(self.tmp_dir, 'MANIFEST'))
+        try:
+            manifest = f.read()
+        finally:
+            f.close()
+        self.assertEqual(manifest, MANIFEST % {'sep': os.sep})
+    @unittest.skipUnless(zlib, "requires zlib")
+    def test_metadata_check_option(self):
+        # testing the `medata-check` option
+        dist, cmd = self.get_cmd(metadata={})
+        # this should raise some warnings !
+        # with the `check` subcommand
+        cmd.ensure_finalized()
+        cmd.run()
+        warnings = [msg for msg in self.get_logs(WARN) if
+                    msg.startswith('warning: check:')]
+        self.assertEqual(len(warnings), 2)
+        # trying with a complete set of metadata
+        self.clear_logs()
+        dist, cmd = self.get_cmd()
+        cmd.ensure_finalized()
+        cmd.metadata_check = 0
+        cmd.run()
+        warnings = [msg for msg in self.get_logs(WARN) if
+                    msg.startswith('warning: check:')]
+        self.assertEqual(len(warnings), 0)
+    def test_check_metadata_deprecated(self):
+        # makes sure make_metadata is deprecated
+        dist, cmd = self.get_cmd()
+        with check_warnings() as w:
+            warnings.simplefilter("always")
+            cmd.check_metadata()
+            self.assertEqual(len(w.warnings), 1)
+    def test_show_formats(self):
+        with captured_stdout() as stdout:
+            show_formats()
+        # the output should be a header line + one line per format
+        num_formats = len(ARCHIVE_FORMATS.keys())
+        output = [line for line in stdout.getvalue().split('\n')
+                  if line.strip().startswith('--formats=')]
+        self.assertEqual(len(output), num_formats)
+    def test_finalize_options(self):
+        dist, cmd = self.get_cmd()
+        cmd.finalize_options()
+        # default options set by finalize
+        self.assertEqual(cmd.manifest, 'MANIFEST')
+        self.assertEqual(cmd.template, 'MANIFEST.in')
+        self.assertEqual(cmd.dist_dir, 'dist')
+        # formats has to be a string splitable on (' ', ',') or
+        # a stringlist
+        cmd.formats = 1
+        self.assertRaises(DistutilsOptionError, cmd.finalize_options)
+        cmd.formats = ['zip']
+        cmd.finalize_options()
+        # formats has to be known
+        cmd.formats = 'supazipa'
+        self.assertRaises(DistutilsOptionError, cmd.finalize_options)
+    @unittest.skipUnless(zlib, "requires zlib")
+    @unittest.skipUnless(UID_GID_SUPPORT, "Requires grp and pwd support")
+    def test_make_distribution_owner_group(self):
+        # check if tar and gzip are installed
+        if (find_executable('tar') is None or
+            find_executable('gzip') is None):
+            return
+        # now building a sdist
+        dist, cmd = self.get_cmd()
+        # creating a gztar and specifying the owner+group
+        cmd.formats = ['gztar']
+        cmd.owner = pwd.getpwuid(0)[0]
+        cmd.group = grp.getgrgid(0)[0]
+        cmd.ensure_finalized()
+        cmd.run()
+        # making sure we have the good rights
+        archive_name = join(self.tmp_dir, 'dist', 'fake-1.0.tar.gz')
+        archive = tarfile.open(archive_name)
+        try:
+            for member in archive.getmembers():
+                self.assertEqual(member.uid, 0)
+                self.assertEqual(member.gid, 0)
+        finally:
+            archive.close()
+        # building a sdist again
+        dist, cmd = self.get_cmd()
+        # creating a gztar
+        cmd.formats = ['gztar']
+        cmd.ensure_finalized()
+        cmd.run()
+        # making sure we have the good rights
+        archive_name = join(self.tmp_dir, 'dist', 'fake-1.0.tar.gz')
+        archive = tarfile.open(archive_name)
+        # note that we are not testing the group ownership here
+        # because, depending on the platforms and the container
+        # rights (see #7408)
+        try:
+            for member in archive.getmembers():
+                self.assertEqual(member.uid, os.getuid())
+        finally:
+            archive.close()
+    # the following tests make sure there is a nice error message instead
+    # of a traceback when parsing an invalid manifest template
+    def _check_template(self, content):
+        dist, cmd = self.get_cmd()
+        os.chdir(self.tmp_dir)
+        self.write_file('MANIFEST.in', content)
+        cmd.ensure_finalized()
+        cmd.filelist = FileList()
+        cmd.read_template()
+        warnings = self.get_logs(WARN)
+        self.assertEqual(len(warnings), 1)
+    def test_invalid_template_unknown_command(self):
+        self._check_template('taunt knights *')
+    def test_invalid_template_wrong_arguments(self):
+        # this manifest command takes one argument
+        self._check_template('prune')
+    @unittest.skipIf(os.name != 'nt', 'test relevant for Windows only')
+    def test_invalid_template_wrong_path(self):
+        # on Windows, trailing slashes are not allowed
+        # this used to crash instead of raising a warning: #8286
+        self._check_template('include examples/')
+    @unittest.skipUnless(zlib, "requires zlib")
+    def test_get_file_list(self):
+        # make sure MANIFEST is recalculated
+        dist, cmd = self.get_cmd()
+        # filling data_files by pointing files in package_data
+        dist.package_data = {'somecode': ['*.txt']}
+        self.write_file((self.tmp_dir, 'somecode', 'doc.txt'), '#')
+        cmd.formats = ['gztar']
+        cmd.ensure_finalized()
+        cmd.run()
+        f = open(cmd.manifest)
+        try:
+            manifest = [line.strip() for line in f.read().split('\n')
+                        if line.strip() != '']
+        finally:
+            f.close()
+        self.assertEqual(len(manifest), 5)
+        # adding a file
+        self.write_file((self.tmp_dir, 'somecode', 'doc2.txt'), '#')
+        # make sure build_py is reinitialized, like a fresh run
+        build_py = dist.get_command_obj('build_py')
+        build_py.finalized = False
+        build_py.ensure_finalized()
+        cmd.run()
+        f = open(cmd.manifest)
+        try:
+            manifest2 = [line.strip() for line in f.read().split('\n')
+                         if line.strip() != '']
+        finally:
+            f.close()
+        # do we have the new file in MANIFEST ?
+        self.assertEqual(len(manifest2), 6)
+        self.assertIn('doc2.txt', manifest2[-1])
+    @unittest.skipUnless(zlib, "requires zlib")
+    def test_manifest_marker(self):
+        # check that autogenerated MANIFESTs have a marker
+        dist, cmd = self.get_cmd()
+        cmd.ensure_finalized()
+        cmd.run()
+        f = open(cmd.manifest)
+        try:
+            manifest = [line.strip() for line in f.read().split('\n')
+                        if line.strip() != '']
+        finally:
+            f.close()
+        self.assertEqual(manifest[0],
+                         '# file GENERATED by distutils, do NOT edit')
+    @unittest.skipUnless(zlib, 'requires zlib')
+    def test_manifest_comments(self):
+        # make sure comments don't cause exceptions or wrong includes
+        contents = dedent("""\
+            # bad.py
+            #bad.py
+            good.py
+            """)
+        dist, cmd = self.get_cmd()
+        cmd.ensure_finalized()
+        self.write_file((self.tmp_dir, cmd.manifest), contents)
+        self.write_file((self.tmp_dir, 'good.py'), '# pick me!')
+        self.write_file((self.tmp_dir, 'bad.py'), "# don't pick me!")
+        self.write_file((self.tmp_dir, '#bad.py'), "# don't pick me!")
+        cmd.run()
+        self.assertEqual(cmd.filelist.files, ['good.py'])
+    @unittest.skipUnless(zlib, "requires zlib")
+    def test_manual_manifest(self):
+        # check that a MANIFEST without a marker is left alone
+        dist, cmd = self.get_cmd()
+        cmd.formats = ['gztar']
+        cmd.ensure_finalized()
+        self.write_file((self.tmp_dir, cmd.manifest), 'README.manual')
+        self.write_file((self.tmp_dir, 'README.manual'),
+                         'This project maintains its MANIFEST file itself.')
+        cmd.run()
+        self.assertEqual(cmd.filelist.files, ['README.manual'])
+        f = open(cmd.manifest)
+        try:
+            manifest = [line.strip() for line in f.read().split('\n')
+                        if line.strip() != '']
+        finally:
+            f.close()
+        self.assertEqual(manifest, ['README.manual'])
+        archive_name = join(self.tmp_dir, 'dist', 'fake-1.0.tar.gz')
+        archive = tarfile.open(archive_name)
+        try:
+            filenames = [tarinfo.name for tarinfo in archive]
+        finally:
+            archive.close()
+        self.assertEqual(sorted(filenames), ['fake-1.0', 'fake-1.0/PKG-INFO',
+                                             'fake-1.0/README.manual'])
 def test_suite():
     return unittest.makeSuite(sdistTestCase)
+    return unittest.makeSuite(SDistTestCase)
 if __name__ == "__main__":
     unittest.main(defaultTest="test_suite")
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/tests/test_sysconfig.py

-              r2
+              r388
+"""Tests for distutils.dist."""
+from distutils import sysconfig
+"""Tests for distutils.sysconfig."""
 import os
 import test
 import unittest
+import shutil
+from distutils import sysconfig
+from distutils.tests import support
 from test.test_support import TESTFN
+class SysconfigTestCase(unittest.TestCase):
+class SysconfigTestCase(support.EnvironGuard,
+                        unittest.TestCase):
     def setUp(self):
         super(SysconfigTestCase, self).setUp()
 …
         if self.makefile is not None:
             os.unlink(self.makefile)
+        self.cleanup_testfn()
         super(SysconfigTestCase, self).tearDown()
+    def test_get_config_h_filename(self):
+        config_h = sysconfig.get_config_h_filename()
+        self.assert_(os.path.isfile(config_h), config_h)
+    def cleanup_testfn(self):
+        path = test.test_support.TESTFN
+        if os.path.isfile(path):
+            os.remove(path)
+        elif os.path.isdir(path):
+            shutil.rmtree(path)
     def test_get_python_lib(self):
         lib_dir = sysconfig.get_python_lib()
         # XXX doesn't work on Linux when Python was never installed before
         #self.assert_(os.path.isdir(lib_dir), lib_dir)
+        #self.assertTrue(os.path.isdir(lib_dir), lib_dir)
         # test for pythonxx.lib?
         self.assertNotEqual(sysconfig.get_python_lib(),
                             sysconfig.get_python_lib(prefix=TESTFN))
+        _sysconfig = __import__('sysconfig')
+        res = sysconfig.get_python_lib(True, True)
+        self.assertEqual(_sysconfig.get_path('platstdlib'), res)
     def test_get_python_inc(self):
 …
         self.assertTrue(os.path.isfile(python_h), python_h)
+    def test_get_config_vars(self):
+        cvars = sysconfig.get_config_vars()
+        self.assert_(isinstance(cvars, dict))
+        self.assert_(cvars)
+    def test_parse_makefile_base(self):
+        self.makefile = test.test_support.TESTFN
+        fd = open(self.makefile, 'w')
+        try:
+            fd.write(r"CONFIG_ARGS=  '--arg1=optarg1' 'ENV=LIB'" '\n')
+            fd.write('VAR=$OTHER\nOTHER=foo')
+        finally:
+            fd.close()
+        d = sysconfig.parse_makefile(self.makefile)
+        self.assertEqual(d, {'CONFIG_ARGS': "'--arg1=optarg1' 'ENV=LIB'",
+                             'OTHER': 'foo'})
     def test_parse_makefile_literal_dollar(self):
         self.makefile = test.test_support.TESTFN
         fd = open(self.makefile, 'w')
+        fd.write(r"CONFIG_ARGS=  '--arg1=optarg1' 'ENV=\$$LIB'" '\n')
+        fd.write('VAR=$OTHER\nOTHER=foo')
+        fd.close()
+        try:
+            fd.write(r"CONFIG_ARGS=  '--arg1=optarg1' 'ENV=\$$LIB'" '\n')
+            fd.write('VAR=$OTHER\nOTHER=foo')
+        finally:
+            fd.close()
         d = sysconfig.parse_makefile(self.makefile)
+        self.assertEquals(d, {'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'",
+                              'OTHER': 'foo'})
+        self.assertEqual(d, {'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'",
+                             'OTHER': 'foo'})
+    def test_sysconfig_module(self):
+        import sysconfig as global_sysconfig
+        self.assertEqual(global_sysconfig.get_config_var('CFLAGS'), sysconfig.get_config_var('CFLAGS'))
+        self.assertEqual(global_sysconfig.get_config_var('LDFLAGS'), sysconfig.get_config_var('LDFLAGS'))
+    @unittest.skipIf(sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER'),'compiler flags customized')
+    def test_sysconfig_compiler_vars(self):
+        # On OS X, binary installers support extension module building on
+        # various levels of the operating system with differing Xcode
+        # configurations.  This requires customization of some of the
+        # compiler configuration directives to suit the environment on
+        # the installed machine.  Some of these customizations may require
+        # running external programs and, so, are deferred until needed by
+        # the first extension module build.  With Python 3.3, only
+        # the Distutils version of sysconfig is used for extension module
+        # builds, which happens earlier in the Distutils tests.  This may
+        # cause the following tests to fail since no tests have caused
+        # the global version of sysconfig to call the customization yet.
+        # The solution for now is to simply skip this test in this case.
+        # The longer-term solution is to only have one version of sysconfig.
+        import sysconfig as global_sysconfig
+        if sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER'):
+            return
+        self.assertEqual(global_sysconfig.get_config_var('LDSHARED'), sysconfig.get_config_var('LDSHARED'))
+        self.assertEqual(global_sysconfig.get_config_var('CC'), sysconfig.get_config_var('CC'))

python/vendor/current/Lib/distutils/tests/test_unixccompiler.py

-              r2
+              r388
 """Tests for distutils.unixccompiler."""
+import os
 import sys
 import unittest
+from test.test_support import EnvironmentVarGuard, run_unittest
 from distutils import sysconfig
 …
         self.assertEqual(self.cc.rpath_foo(), '-R/foo')
+    @unittest.skipUnless(sys.platform == 'darwin', 'test only relevant for OS X')
+    def test_osx_cc_overrides_ldshared(self):
+        # Issue #18080:
+        # ensure that setting CC env variable also changes default linker
+        def gcv(v):
+            if v == 'LDSHARED':
+                return 'gcc-4.2 -bundle -undefined dynamic_lookup '
+            return 'gcc-4.2'
+        sysconfig.get_config_var = gcv
+        with EnvironmentVarGuard() as env:
+            env['CC'] = 'my_cc'
+            del env['LDSHARED']
+            sysconfig.customize_compiler(self.cc)
+        self.assertEqual(self.cc.linker_so[0], 'my_cc')
+    @unittest.skipUnless(sys.platform == 'darwin', 'test only relevant for OS X')
+    def test_osx_explict_ldshared(self):
+        # Issue #18080:
+        # ensure that setting CC env variable does not change
+        #   explicit LDSHARED setting for linker
+        def gcv(v):
+            if v == 'LDSHARED':
+                return 'gcc-4.2 -bundle -undefined dynamic_lookup '
+            return 'gcc-4.2'
+        sysconfig.get_config_var = gcv
+        with EnvironmentVarGuard() as env:
+            env['CC'] = 'my_cc'
+            env['LDSHARED'] = 'my_ld -bundle -dynamic'
+            sysconfig.customize_compiler(self.cc)
+        self.assertEqual(self.cc.linker_so[0], 'my_ld')
 def test_suite():
 …
 if __name__ == "__main__":
     unittest.main(defaultTest="test_suite")
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/tests/test_upload.py

-              r2
+              r388
+# -*- encoding: utf8 -*-
 """Tests for distutils.command.upload."""
-# -*- encoding: utf8 -*-
-import sys
 import os
 import unittest
+import httplib
+from test.test_support import run_unittest
+from distutils.command import upload as upload_mod
 from distutils.command.upload import upload
 from distutils.core import Distribution
-from distutils.tests import support
 from distutils.tests.test_config import PYPIRC, PyPIRCCommandTestCase
 …
 """
-class _Resp(object):
-    def __init__(self, status):
-        self.status = status
-        self.reason = 'OK'
+_CONNECTIONS = []
+PYPIRC_NOPASSWORD = """\
+[distutils]
+class _FakeHTTPConnection(object):
+    def __init__(self, netloc):
+        self.requests = []
+        self.headers = {}
+        self.body = None
+        self.netloc = netloc
+        _CONNECTIONS.append(self)
+index-servers =
+    server1
+    def connect(self):
+        pass
+    endheaders = connect
+[server1]
+username:me
+"""
+    def send(self, body):
+        self.body = body
+class FakeOpen(object):
+    def putrequest(self, type_, data):
+        self.requests.append((type_, data))
+    def __init__(self, url):
+        self.url = url
+        if not isinstance(url, str):
+            self.req = url
+        else:
+            self.req = None
+        self.msg = 'OK'
     def putheader(self, name, value):
         self.headers[name] = value
+    def getcode(self):
+        return 200
-    def getresponse(self):
-        return _Resp(200)
 class uploadTestCase(PyPIRCCommandTestCase):
 …
     def setUp(self):
         super(uploadTestCase, self).setUp()
+        self.old_klass = httplib.HTTPConnection
+        httplib.HTTPConnection = _FakeHTTPConnection
+        self.old_open = upload_mod.urlopen
+        upload_mod.urlopen = self._urlopen
+        self.last_open = None
     def tearDown(self):
         httplib.HTTPConnection = self.old_klass
+        upload_mod.urlopen = self.old_open
         super(uploadTestCase, self).tearDown()
+    def _urlopen(self, url):
+        self.last_open = FakeOpen(url)
+        return self.last_open
     def test_finalize_options(self):
         # new format
+        f = open(self.rc, 'w')
+        f.write(PYPIRC)
+        f.close()
+        self.write_file(self.rc, PYPIRC)
         dist = Distribution()
         cmd = upload(dist)
 …
                              ('realm', 'pypi'),
                              ('repository', 'http://pypi.python.org/pypi')):
             self.assertEquals(getattr(cmd, attr), waited)
+            self.assertEqual(getattr(cmd, attr), waited)
+    def test_saved_password(self):
+        # file with no password
+        self.write_file(self.rc, PYPIRC_NOPASSWORD)
+        # make sure it passes
+        dist = Distribution()
+        cmd = upload(dist)
+        cmd.finalize_options()
+        self.assertEqual(cmd.password, None)
+        # make sure we get it as well, if another command
+        # initialized it at the dist level
+        dist.password = 'xxx'
+        cmd = upload(dist)
+        cmd.finalize_options()
+        self.assertEqual(cmd.password, 'xxx')
     def test_upload(self):
 …
         # what did we send ?
+        res = _CONNECTIONS[-1]
+        headers = res.headers
+        self.assert_('dÃ©dÃ©' in res.body)
+        self.assertEquals(headers['Content-length'], '2085')
+        self.assertIn('dÃ©dÃ©', self.last_open.req.data)
+        headers = dict(self.last_open.req.headers)
+        self.assertEqual(headers['Content-length'], '2085')
         self.assertTrue(headers['Content-type'].startswith('multipart/form-data'))
         method, request = res.requests[-1]
         self.assertEquals(method, 'POST')
         self.assertEquals(res.netloc, 'pypi.python.org')
         self.assertTrue('xxx' in res.body)
         self.assertFalse('\n' in headers['Authorization'])
+        self.assertEqual(self.last_open.req.get_method(), 'POST')
+        self.assertEqual(self.last_open.req.get_full_url(),
+                         'http://pypi.python.org/pypi')
+        self.assertTrue('xxx' in self.last_open.req.data)
+        auth = self.last_open.req.headers['Authorization']
+        self.assertFalse('\n' in auth)
 def test_suite():
 …
 if __name__ == "__main__":
     unittest.main(defaultTest="test_suite")
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/tests/test_util.py

-              r2
+              r388
 import sys
 import unittest
+from test.test_support import run_unittest
 from distutils.errors import DistutilsPlatformError, DistutilsByteCompileError
 …
 if __name__ == "__main__":
     unittest.main(defaultTest="test_suite")
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/tests/test_versionpredicate.py

-              r2
+              r388
 import distutils.versionpredicate
 import doctest
+from test.test_support import run_unittest
 def test_suite():
     return doctest.DocTestSuite(distutils.versionpredicate)
+if __name__ == '__main__':
+    run_unittest(test_suite())

python/vendor/current/Lib/distutils/text_file.py

-              r2
+              r388
 lines, and joining lines with backslashes."""
+__revision__ = "$Id: text_file.py 60923 2008-02-21 18:18:37Z guido.van.rossum $"
+from types import *
+import sys, os, string
+__revision__ = "$Id$"
+import sys
 …
             line = self.current_line
         outmsg.append(self.filename + ", ")
         if type (line) in (ListType, TupleType):
+        if isinstance(line, (list, tuple)):
             outmsg.append("lines %d-%d: " % tuple (line))
         else:
             outmsg.append("line %d: " % line)
         outmsg.append(str(msg))
         return string.join(outmsg, "")
+        return ''.join(outmsg)
 …
                 # lurking in there) and otherwise leave the line alone.
                 pos = string.find (line, "#")
+                pos = line.find("#")
                 if pos == -1:           # no "#" -- no comments
                     pass
 …
                     #   there
                     # result in "hello there".
                     if string.strip(line) == "":
+                    if line.strip() == "":
                         continue
                 else:                   # it's an escaped "#"
                     line = string.replace (line, "\\#", "#")
+                    line = line.replace("\\#", "#")
 …
                 if self.collapse_join:
                     line = string.lstrip (line)
+                    line = line.lstrip()
                 line = buildup_line + line
                 # careful: pay attention to line number when incrementing it
                 if type (self.current_line) is ListType:
+                if isinstance(self.current_line, list):
                     self.current_line[1] = self.current_line[1] + 1
                 else:
 …
                 # still have to be careful about incrementing the line number!
                 if type (self.current_line) is ListType:
+                if isinstance(self.current_line, list):
                     self.current_line = self.current_line[1] + 1
                 else:
 …
             # trailing, or one or the other, or neither)
             if self.lstrip_ws and self.rstrip_ws:
                 line = string.strip (line)
+                line = line.strip()
             elif self.lstrip_ws:
                 line = string.lstrip (line)
+                line = line.lstrip()
             elif self.rstrip_ws:
                 line = string.rstrip (line)
+                line = line.rstrip()
             # blank line (whether we rstrip'ed or not)? skip to next line
 …
         self.linebuf.append (line)
-if __name__ == "__main__":
-    test_data = """# test file
-line 3 \\
-# intervening comment
-  continues on next line
-"""
-    # result 1: no fancy options
-    result1 = map (lambda x: x + "\n", string.split (test_data, "\n")[0:-1])
-    # result 2: just strip comments
-    result2 = ["\n",
-               "line 3 \\\n",
-               "  continues on next line\n"]
-    # result 3: just strip blank lines
-    result3 = ["# test file\n",
-               "line 3 \\\n",
-               "# intervening comment\n",
-               "  continues on next line\n"]
-    # result 4: default, strip comments, blank lines, and trailing whitespace
-    result4 = ["line 3 \\",
-               "  continues on next line"]
-    # result 5: strip comments and blanks, plus join lines (but don't
-    # "collapse" joined lines
-    result5 = ["line 3   continues on next line"]
-    # result 6: strip comments and blanks, plus join lines (and
-    # "collapse" joined lines
-    result6 = ["line 3 continues on next line"]
-    def test_input (count, description, file, expected_result):
-        result = file.readlines ()
-        # result = string.join (result, '')
-        if result == expected_result:
-            print "ok %d (%s)" % (count, description)
-        else:
-            print "not ok %d (%s):" % (count, description)
-            print "** expected:"
-            print expected_result
-            print "** received:"
-            print result
-    filename = "test.txt"
-    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=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)
-    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, collapse_join=1)
-    test_input (6, "join lines with collapsing", in_file, result6)
-    os.remove (filename)

python/vendor/current/Lib/distutils/unixccompiler.py

-              r2
+              r388
 """
 __revision__ = "$Id: unixccompiler.py 77378 2010-01-08 23:48:37Z tarek.ziade $"
 import os, sys
+__revision__ = "$Id$"
+import os, sys, re
 from types import StringType, NoneType
 …
      DistutilsExecError, CompileError, LibError, LinkError
 from distutils import log
+if sys.platform == 'darwin':
+    import _osx_support
 # XXX Things not currently handled:
 …
 #     options and carry on.
-def _darwin_compiler_fixup(compiler_so, cc_args):
-    """
-    This function will strip '-isysroot PATH' and '-arch ARCH' from the
-    compile flags if the user has specified one them in extra_compile_flags.
-    This is needed because '-arch ARCH' adds another architecture to the
-    build, without a way to remove an architecture. Furthermore GCC will
-    barf if multiple '-isysroot' arguments are present.
-    """
-    stripArch = stripSysroot = 0
-    compiler_so = list(compiler_so)
-    kernel_version = os.uname()[2] # 8.4.3
-    major_version = int(kernel_version.split('.')[0])
-    if major_version < 8:
-        # OSX before 10.4.0, these don't support -arch and -isysroot at
-        # all.
-        stripArch = stripSysroot = True
-    else:
-        stripArch = '-arch' in cc_args
-        stripSysroot = '-isysroot' in cc_args
-    if stripArch or 'ARCHFLAGS' in os.environ:
-        while 1:
-            try:
-                index = compiler_so.index('-arch')
-                # Strip this argument and the next one:
-                del compiler_so[index:index+2]
-            except ValueError:
-                break
-    if 'ARCHFLAGS' in os.environ and not stripArch:
-        # User specified different -arch flags in the environ,
-        # see also distutils.sysconfig
-        compiler_so = compiler_so + os.environ['ARCHFLAGS'].split()
-    if stripSysroot:
-        try:
-            index = compiler_so.index('-isysroot')
-            # Strip this argument and the next one:
-            del compiler_so[index:index+2]
-        except ValueError:
-            pass
-    # Check if the SDK that is used during compilation actually exists,
-    # the universal build requires the usage of a universal SDK and not all
-    # users have that installed by default.
-    sysroot = None
-    if '-isysroot' in cc_args:
-        idx = cc_args.index('-isysroot')
-        sysroot = cc_args[idx+1]
-    elif '-isysroot' in compiler_so:
-        idx = compiler_so.index('-isysroot')
-        sysroot = compiler_so[idx+1]
-    if sysroot and not os.path.isdir(sysroot):
-        log.warn("Compiling with an SDK that doesn't seem to exist: %s",
-                sysroot)
-        log.warn("Please check your Xcode installation")
-    return compiler_so
 class UnixCCompiler(CCompiler):
 …
         compiler_so = self.compiler_so
         if sys.platform == 'darwin':
+            compiler_so = _darwin_compiler_fixup(compiler_so, cc_args + extra_postargs)
+            compiler_so = _osx_support.compiler_fixup(compiler_so,
+                                                    cc_args + extra_postargs)
         try:
             self.spawn(compiler_so + cc_args + [src, '-o', obj] +
 …
                 if sys.platform == 'darwin':
                     linker = _darwin_compiler_fixup(linker, ld_args)
+                    linker = _osx_support.compiler_fixup(linker, ld_args)
                 self.spawn(linker + ld_args)
 …
         static_f = self.library_filename(lib, lib_type='static')
+        if sys.platform == 'darwin':
+            # On OSX users can specify an alternate SDK using
+            # '-isysroot', calculate the SDK root if it is specified
+            # (and use it further on)
+            cflags = sysconfig.get_config_var('CFLAGS')
+            m = re.search(r'-isysroot\s+(\S+)', cflags)
+            if m is None:
+                sysroot = '/'
+            else:
+                sysroot = m.group(1)
         for dir in dirs:
             shared = os.path.join(dir, shared_f)
             dylib = os.path.join(dir, dylib_f)
             static = os.path.join(dir, static_f)
+            if sys.platform == 'darwin' and (
+                dir.startswith('/System/') or (
+                dir.startswith('/usr/') and not dir.startswith('/usr/local/'))):
+                shared = os.path.join(sysroot, dir[1:], shared_f)
+                dylib = os.path.join(sysroot, dir[1:], dylib_f)
+                static = os.path.join(sysroot, dir[1:], static_f)
             # We're second-guessing the linker here, with not much hard
             # data to go on: GCC seems to prefer the shared library, so I'm

python/vendor/current/Lib/distutils/util.py

-              r2
+              r388
 """
 __revision__ = "$Id: util.py 77376 2010-01-08 23:27:23Z tarek.ziade $"
+__revision__ = "$Id$"
 import sys, os, string, re
 …
         return sys.platform
+    # Set for cross builds explicitly
+    if "_PYTHON_HOST_PLATFORM" in os.environ:
+        return os.environ["_PYTHON_HOST_PLATFORM"]
     if os.name != "posix" or not hasattr(os, 'uname'):
         # XXX what about the architecture? NT is Intel or Alpha,
 …
             osname = "solaris"
             release = "%d.%s" % (int(release[0]) - 3, release[2:])
+            # We can't use "platform.architecture()[0]" because a
+            # bootstrap problem. We use a dict to get an error
+            # if some suspicious happens.
+            bitness = {2147483647:"32bit", 9223372036854775807:"64bit"}
+            machine += ".%s" % bitness[sys.maxint]
         # fall through to standard osname-release-machine representation
     elif osname[:4] == "irix":              # could be "irix64"!
 …
             release = m.group()
     elif osname[:6] == "darwin":
+        #
+        # For our purposes, we'll assume that the system version from
+        # distutils' perspective is what MACOSX_DEPLOYMENT_TARGET is set
+        # to. This makes the compatibility story a bit more sane because the
+        # machine is going to compile and link as if it were
+        # MACOSX_DEPLOYMENT_TARGET.
+        from distutils.sysconfig import get_config_vars
+        cfgvars = get_config_vars()
+        macver = os.environ.get('MACOSX_DEPLOYMENT_TARGET')
+        if not macver:
+            macver = cfgvars.get('MACOSX_DEPLOYMENT_TARGET')
+        if 1:
+            # Always calculate the release of the running machine,
+            # needed to determine if we can build fat binaries or not.
+            macrelease = macver
+            # Get the system version. Reading this plist is a documented
+            # way to get the system version (see the documentation for
+            # the Gestalt Manager)
+            try:
+                f = open('/System/Library/CoreServices/SystemVersion.plist')
+            except IOError:
+                # We're on a plain darwin box, fall back to the default
+                # behaviour.
+                pass
+            else:
+                m = re.search(
+                        r'<key>ProductUserVisibleVersion</key>\s*' +
+                        r'<string>(.*?)</string>', f.read())
+                f.close()
+                if m is not None:
+                    macrelease = '.'.join(m.group(1).split('.')[:2])
+                # else: fall back to the default behaviour
+        if not macver:
+            macver = macrelease
+        if macver:
+            from distutils.sysconfig import get_config_vars
+            release = macver
+            osname = "macosx"
+            if (macrelease + '.') >= '10.4.' and \
+                    '-arch' in get_config_vars().get('CFLAGS', '').strip():
+                # The universal build will build fat binaries, but not on
+                # systems before 10.4
+                #
+                # Try to detect 4-way universal builds, those have machine-type
+                # 'universal' instead of 'fat'.
+                machine = 'fat'
+                cflags = get_config_vars().get('CFLAGS')
+                archs = re.findall('-arch\s+(\S+)', cflags)
+                archs.sort()
+                archs = tuple(archs)
+                if len(archs) == 1:
+                    machine = archs[0]
+                elif archs == ('i386', 'ppc'):
+                    machine = 'fat'
+                elif archs == ('i386', 'x86_64'):
+                    machine = 'intel'
+                elif archs == ('i386', 'ppc', 'x86_64'):
+                    machine = 'fat3'
+                elif archs == ('ppc64', 'x86_64'):
+                    machine = 'fat64'
+                elif archs == ('i386', 'ppc', 'ppc64', 'x86_64'):
+                    machine = 'universal'
+                else:
+                    raise ValueError(
+                       "Don't know machine value for archs=%r"%(archs,))
+            elif machine == 'i386':
+                # On OSX the machine type returned by uname is always the
+                # 32-bit variant, even if the executable architecture is
+                # the 64-bit variant
+                if sys.maxint >= 2**32:
+                    machine = 'x86_64'
+            elif machine in ('PowerPC', 'Power_Macintosh'):
+                # Pick a sane name for the PPC architecture.
+                machine = 'ppc'
+                # See 'i386' case
+                if sys.maxint >= 2**32:
+                    machine = 'ppc64'
+        import _osx_support, distutils.sysconfig
+        osname, release, machine = _osx_support.get_platform_osx(
+                                        distutils.sysconfig.get_config_vars(),
+                                        osname, release, machine)
     return "%s-%s-%s" % (osname, release, machine)
 …
     if not paths:
         return os.curdir
     return apply(os.path.join, paths)
+    return os.path.join(*paths)
 # convert_path ()
 …
             path = path[1:]
         return os.path.join(new_root, path)
-    elif os.name == 'mac':
-        if not os.path.isabs(pathname):
-            return os.path.join(new_root, pathname)
-        else:
-            # Chop off volume name from start of path
-            elements = string.split(pathname, ":", 1)
-            pathname = ":" + elements[1]
-            return os.path.join(new_root, pathname)
     else:
 …
     log.info(msg)
     if not dry_run:
         apply(func, args)
+        func(*args)

python/vendor/current/Lib/distutils/version.py

r2	r388
5	5	# Python Module Distribution Utilities.
6	6	#
7		# $Id~~: version.py 71270 2009-04-05 21:11:43Z georg.brandl~~ $
	7	# $Id$
8	8	#
9	9

Context Navigation

Legend:

Download in other formats: