Changeset 391 for python/trunk/Lib/distutils/command

python/trunk

Property svn:mergeinfo set to
/python/vendor/Python-2.7.6 merged eligible
/python/vendor/current merged eligible

python/trunk/Lib/distutils/command/init.py

-              r2
+              r391
 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/trunk/Lib/distutils/command/bdist.py

-              r2
+              r391
 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/trunk/Lib/distutils/command/bdist_dumb.py

-              r2
+              r391
 $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/trunk/Lib/distutils/command/bdist_msi.py

-              r2
+              r391
 # -*- 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/trunk/Lib/distutils/command/bdist_rpm.py

-              r10
+              r391
 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/trunk/Lib/distutils/command/bdist_wininst.py

-              r2
+              r391
 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/trunk/Lib/distutils/command/build.py

-              r2
+              r391
 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/trunk/Lib/distutils/command/build_clib.py

-              r2
+              r391
 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/trunk/Lib/distutils/command/build_ext.py

-              r2
+              r391
 # 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/trunk/Lib/distutils/command/build_py.py

-              r2
+              r391
 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/trunk/Lib/distutils/command/build_scripts.py

-              r2
+              r391
 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/trunk/Lib/distutils/command/clean.py

-              r2
+              r391
 # 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/trunk/Lib/distutils/command/config.py

-              r2
+              r391
 """
+# 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/trunk/Lib/distutils/command/install.py

-              r10
+              r391
 # 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/trunk/Lib/distutils/command/install_data.py

-              r2
+              r391
 # 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/trunk/Lib/distutils/command/install_headers.py

-              r2
+              r391
 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/trunk/Lib/distutils/command/install_lib.py

-              r2
+              r391
+# 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/trunk/Lib/distutils/command/install_scripts.py

-              r2
+              r391
 # 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/trunk/Lib/distutils/command/register.py

-              r2
+              r391
 # 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/trunk/Lib/distutils/command/sdist.py

-              r2
+              r391
 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/trunk/Lib/distutils/command/upload.py

-              r2
+              r391
 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

Context Navigation

Legend:

python/trunk

python/trunk/Lib/distutils/command/init.py

python/trunk/Lib/distutils/command/bdist.py

python/trunk/Lib/distutils/command/bdist_dumb.py

python/trunk/Lib/distutils/command/bdist_msi.py

python/trunk/Lib/distutils/command/bdist_rpm.py

python/trunk/Lib/distutils/command/bdist_wininst.py

python/trunk/Lib/distutils/command/build.py

python/trunk/Lib/distutils/command/build_clib.py

python/trunk/Lib/distutils/command/build_ext.py

python/trunk/Lib/distutils/command/build_py.py

python/trunk/Lib/distutils/command/build_scripts.py

python/trunk/Lib/distutils/command/clean.py

python/trunk/Lib/distutils/command/config.py

python/trunk/Lib/distutils/command/install.py

python/trunk/Lib/distutils/command/install_data.py

python/trunk/Lib/distutils/command/install_headers.py

python/trunk/Lib/distutils/command/install_lib.py

python/trunk/Lib/distutils/command/install_scripts.py

python/trunk/Lib/distutils/command/register.py

python/trunk/Lib/distutils/command/sdist.py

python/trunk/Lib/distutils/command/upload.py

Download in other formats:

/python/vendor/Python-2.7.6	merged	eligible
/python/vendor/current	merged	eligible