Commits

Anonymous committed 7c34ceb

bootstrapping.py -> distribute_setup.py

  • Participants
  • Parent commits 51e8df2

Comments (0)

Files changed (10)

 http://bitbucket.org/tarek/distribute/downloads.
 
 It can be installed using easy_install or pip, with the source tarball, with the
-eggs distribution, or using the ``bootstrapping.py`` script provided online.
+eggs distribution, or using the ``distribute_setup.py`` script provided online.
 
-``bootstrapping.py`` is the simplest and preferred way on all systems.
+``distribute_setup.py`` is the simplest and preferred way on all systems.
 
-bootstrapping.py
-================
+distribute_setup.py
+===================
 
-Download ``bootstrapping.py`` and execute it, using the Python interpreter of
+Download ``distribute_setup.py`` and execute it, using the Python interpreter of
 your choice.
 
-If your shell has the `wget` programm you can do::
+If your shell has the `wget` program you can do::
 
-    $ wget http://bitbucket.org/tarek/distribute/downloads/bootstrapping.py
-    $ python bootstrapping.py
+    $ wget http://bitbucket.org/tarek/distribute/downloads/distribute_setup.py
+    $ python distribute_setup.py
 
 easy_install or pip
 ===================
 -------
 
 Don't install Distribute trying to execute the egg, because it's aimed to 
-sh-based shells. Instead, use the ``bootstrapping.py`` method, that will 
+sh-based shells. Instead, use the ``distribute_setup.py`` method, that will 
 download the egg for you, then install the egg.
 
 ---------------------------

bootstrapping.py

-#!python
-"""Bootstrap distribute installation
-
-If you want to use setuptools in your package's setup.py, just include this
-file in the same directory with it, and add this to the top of your setup.py::
-
-    from bootstrapping import use_setuptools
-    use_setuptools()
-
-If you want to require a specific version of setuptools, set a download
-mirror, or use an alternate download directory, you can do so by supplying
-the appropriate options to ``use_setuptools()``.
-
-This file can also be run as a script to install or upgrade setuptools.
-"""
-import sys
-import os
-import shutil
-import time
-import fnmatch
-from distutils import log
-from distutils.errors import DistutilsError
-
-is_jython = sys.platform.startswith('java')
-if is_jython:
-    import subprocess
-
-try:
-    from hashlib import md5
-except ImportError:
-    from md5 import md5
-
-DEFAULT_VERSION = "0.6"
-#DEFAULT_URL     = "http://pypi.python.org/packages/%s/d/distribute/" % sys.version[:3]
-DEFAULT_URL     = "http://nightly.ziade.org/"
-
-md5_data = {
-    'distribute-0.6-py2.3.egg': 'a9ba0aaf677b912a90e9fb485fa4db19',
-    'distribute-0.6-py2.4.egg': 'a7c8ccf5609bee803497de62960b698c',
-    'distribute-0.6-py2.5.egg': 'c624cd74c056757908a1cdafa288d03c',
-    'distribute-0.6-py2.6.egg': '7ab763a7c8261759c8d2215c5cd3ee26',
-}
-
-def _validate_md5(egg_name, data):
-    if egg_name in md5_data:
-        digest = md5(data).hexdigest()
-        if digest != md5_data[egg_name]:
-            print >>sys.stderr, (
-                "md5 validation of %s failed!  (Possible download problem?)"
-                % egg_name
-            )
-            sys.exit(2)
-    return data
-
-def use_setuptools(
-    version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir,
-    download_delay=15
-):
-    """Automatically find/download setuptools and make it available on sys.path
-
-    `version` should be a valid setuptools version number that is available
-    as an egg for download under the `download_base` URL (which should end with
-    a '/').  `to_dir` is the directory where setuptools will be downloaded, if
-    it is not already available.  If `download_delay` is specified, it should
-    be the number of seconds that will be paused before initiating a download,
-    should one be required.  If an older version of setuptools is installed,
-    this routine will print a message to ``sys.stderr`` and raise SystemExit in
-    an attempt to abort the calling script.
-    """
-    was_imported = 'pkg_resources' in sys.modules or 'setuptools' in sys.modules
-    def do_download():
-        egg = download_setuptools(version, download_base, to_dir, download_delay)
-        sys.path.insert(0, egg)
-        import setuptools; setuptools.bootstrap_install_from = egg
-    try:
-        import pkg_resources
-        if not hasattr(pkg_resources, '_distribute'):
-            raise ImportError
-    except ImportError:
-        return do_download()
-    try:
-        pkg_resources.require("distribute>="+version); return
-    except pkg_resources.VersionConflict, e:
-        if was_imported:
-            print >>sys.stderr, (
-            "The required version of distribute (>=%s) is not available, and\n"
-            "can't be installed while this script is running. Please install\n"
-            " a more recent version first, using 'easy_install -U distribute'."
-            "\n\n(Currently using %r)"
-            ) % (version, e.args[0])
-            sys.exit(2)
-        else:
-            del pkg_resources, sys.modules['pkg_resources']    # reload ok
-            return do_download()
-    except pkg_resources.DistributionNotFound:
-        return do_download()
-
-def download_setuptools(
-    version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir,
-    delay = 15
-):
-    """Download distribute from a specified location and return its filename
-
-    `version` should be a valid distribute version number that is available
-    as an egg for download under the `download_base` URL (which should end
-    with a '/'). `to_dir` is the directory where the egg will be downloaded.
-    `delay` is the number of seconds to pause before an actual download attempt.
-    """
-    import urllib2, shutil
-    egg_name = "distribute-%s-py%s.egg" % (version,sys.version[:3])
-    url = download_base + egg_name
-    saveto = os.path.join(to_dir, egg_name)
-    src = dst = None
-    if not os.path.exists(saveto):  # Avoid repeated downloads
-        try:
-            from distutils import log
-            if delay:
-                log.warn("""
----------------------------------------------------------------------------
-This script requires distribute version %s to run (even to display
-help).  I will attempt to download it for you (from
-%s), but
-you may need to enable firewall access for this script first.
-I will start the download in %d seconds.
-
-(Note: if this machine does not have network access, please obtain the file
-
-   %s
-
-and place it in this directory before rerunning this script.)
----------------------------------------------------------------------------""",
-                    version, download_base, delay, url
-                ); from time import sleep; sleep(delay)
-            log.warn("Downloading %s", url)
-            src = urllib2.urlopen(url)
-            # Read/write all in one block, so we don't create a corrupt file
-            # if the download is interrupted.
-            data = _validate_md5(egg_name, src.read())
-            dst = open(saveto,"wb"); dst.write(data)
-        finally:
-            if src: src.close()
-            if dst: dst.close()
-    return os.path.realpath(saveto)
-
-
-SETUPTOOLS_PKG_INFO  = """\
-Metadata-Version: 1.0
-Name: setuptools
-Version: 0.6c9
-Summary: xxxx
-Home-page: xxx
-Author: xxx
-Author-email: xxx
-License: xxx
-Description: xxx
-"""
-
-def _patch_file(path, content):
-    """Will backup the file then patch it"""
-    existing_content = open(path).read()
-    if existing_content == content:
-        # already patched
-        log.warn('Already patched.')
-        return False
-    log.warn('Patching...')
-    os.rename(path, path +'.OLD.%s' % time.time())
-    f = open(path, 'w')
-    try:
-        f.write(content)
-    finally:
-        f.close()
-    return True
-
-def _same_content(path, content):
-    return open(path).read() == content
-
-def _rename_path(path):
-    new_name = path + '.OLD.%s' % time.time()
-    log.warn('Renaming %s into %s' % (path, new_name))
-    os.rename(path, new_name)
-    return new_name
-
-def _remove_flat_installation(placeholder):
-    if not os.path.isdir(placeholder):
-        log.warn('Unkown installation at %s' % placeholder)
-        return False
-    found = False
-    for file in os.listdir(placeholder):
-        if fnmatch.fnmatch(file, 'setuptools*.egg-info'):
-            found = True
-            break
-    if not found:
-        log.warn('Could not locate setuptools*.egg-info')
-    else:
-        log.warn('Removing elements out of the way...')
-        pkg_info = os.path.join(placeholder, file)
-        if os.path.isdir(pkg_info):
-            patched = _patch_egg_dir(pkg_info)
-        else:
-            patched = _patch_file(pkg_info, SETUPTOOLS_PKG_INFO)
-
-    if not patched:
-        log.warn('%s already patched.' % pkg_info)
-        return False
-    # now let's move the files out of the way
-    for element in ('setuptools', 'pkg_resources.py', 'site.py'):
-        element = os.path.join(placeholder, element)
-        if os.path.exists(element):
-            _rename_path(element)
-        else:
-            log.warn('Could not find the %s element of the '
-                     'Setuptools distribution' % element)
-    return True
-
-def after_install(dist):
-    log.warn('After install bootstrap.')
-    placeholder = dist.get_command_obj('install').install_purelib
-    if not os.path.exists(placeholder):
-        log.warn('Could not find the install location')
-        return
-    pyver = '%s.%s' % (sys.version_info[0], sys.version_info[1])
-    setuptools_file = 'setuptools-0.6c9-py%s.egg-info' % pyver
-    pkg_info = os.path.join(placeholder, setuptools_file)
-    if os.path.exists(pkg_info):
-        log.warn('%s already exists' % pkg_info)
-        return
-    log.warn('Creating %s' % pkg_info)
-    f = open(pkg_info, 'w')
-    try:
-        f.write(SETUPTOOLS_PKG_INFO)
-    finally:
-        f.close()
-    pth_file = os.path.join(placeholder, 'setuptools.pth')
-    log.warn('Creating %s' % pth_file)
-    f = open(pth_file, 'w')
-    try:
-        f.write(os.path.join(os.curdir, setuptools_file))
-    finally:
-        f.close()
-
-def _patch_egg_dir(path):
-    # let's check if it's already patched
-    pkg_info = os.path.join(path, 'EGG-INFO', 'PKG-INFO')
-    if os.path.exists(pkg_info):
-        if _same_content(pkg_info, SETUPTOOLS_PKG_INFO):
-            log.warn('%s already patched.' % pkg_info)
-            return False
-    _rename_path(path)
-    os.mkdir(path)
-    os.mkdir(os.path.join(path, 'EGG-INFO'))
-    pkg_info = os.path.join(path, 'EGG-INFO', 'PKG-INFO')
-    f = open(pkg_info, 'w')
-    try:
-        f.write(SETUPTOOLS_PKG_INFO)
-    finally:
-        f.close()
-    return True
-
-def before_install():
-    log.warn('Before install bootstrap.')
-    fake_setuptools()
-
-def fake_setuptools():
-    log.warn('Scanning installed packages')
-    try:
-        import pkg_resources
-    except ImportError:
-        # we're cool
-        log.warn('Setuptools or Distribute does not seem to be installed.')
-        return
-    ws = pkg_resources.working_set
-    setuptools_dist = ws.find(pkg_resources.Requirement.parse('setuptools'))
-    if setuptools_dist is None:
-        log.warn('No setuptools distribution found')
-        return
-    # detecting if it was already faked
-    setuptools_location = setuptools_dist.location
-    log.warn('Setuptools installation detected at %s' % setuptools_location)
-
-    # let's see if its an egg
-    if not setuptools_location.endswith('.egg'):
-        log.warn('Non-egg installation')
-        res = _remove_flat_installation(setuptools_location)
-        if not res:
-            return
-    else:
-        log.warn('Egg installation')
-        pkg_info = os.path.join(setuptools_location, 'EGG-INFO', 'PKG-INFO')
-        if (os.path.exists(pkg_info) and
-            _same_content(pkg_info, SETUPTOOLS_PKG_INFO)):
-            log.warn('Already patched.')
-            return
-        log.warn('Patching...')
-        # let's create a fake egg replacing setuptools one
-        res = _patch_egg_dir(setuptools_location)
-        if not res:
-            return
-    log.warn('Patched done.')
-    _relaunch()
-
-def _relaunch():
-    log.warn('Relaunching...')
-    # we have to relaunch the process
-    args = [sys.executable]  + sys.argv
-    if is_jython:
-        sys.exit(subprocess.call(args))
-    else:
-        sys.exit(os.spawnv(os.P_WAIT, sys.executable, args))
-
-def _easy_install(argv, egg=None):
-    from setuptools import setup
-    from setuptools.dist import Distribution
-    import distutils.core
-    if egg is not None:
-        setup_args = list(argv) + ['-v'] + [egg]
-    else:
-        setup_args = list(argv)
-    try:
-        return setup(script_args = ['-q','easy_install',
-                                    '-v'] + setup_args,
-                    script_name = sys.argv[0] or 'easy_install',
-                    distclass=Distribution)
-    except DistutilsError:
-        return sys.exit(2)
-
-def main(argv, version=DEFAULT_VERSION):
-    """Install or upgrade setuptools and EasyInstall"""
-    # let's deactivate any existing setuptools installation first
-    fake_setuptools()
-    try:
-        import setuptools
-        # we need to check if the installed setuptools
-        # is from Distribute or from setuptools
-        if not hasattr(setuptools, '_distribute'):
-            # now we are ready to install distribute
-            raise ImportError
-    except ImportError:
-        egg = None
-        try:
-            egg = download_setuptools(version, delay=0)
-            sys.path.insert(0, egg)
-            import setuptools
-            if not hasattr(setuptools, '_distribute'):
-                placeholder = os.path.split(os.path.dirname(setuptools.__file__))[0]
-                if not placeholder.endswith('.egg'):
-                    res = _remove_flat_installation(placeholder)
-                    if res:
-                        _relaunch()
-                print >> sys.stderr, (
-                "The patch didn't work, Setuptools is still active.\n"
-                "Possible reason: your have a system-wide setuptools installed "
-                "and you are in a virtualenv.\n"
-                "If you are inside a virtualenv, make sure you used the --no-site-packages option"
-                )
-                sys.exit(2)
-            dist = _easy_install(argv, egg)
-            after_install(dist)
-            return
-            #from setuptools.command import easy_install
-            #try:
-            #    return easy_install.main(list(argv)+['-v']+[egg])
-            #except DistutilsError:
-            #    return sys.exit(2)
-        finally:
-            if egg and os.path.exists(egg):
-                os.unlink(egg)
-    else:
-        if setuptools.__version__ == '0.0.1':
-            print >>sys.stderr, (
-            "You have an obsolete version of setuptools installed.  Please\n"
-            "remove it from your system entirely before rerunning this script."
-            )
-            sys.exit(2)
-
-    req = "distribute>="+version
-    import pkg_resources
-    try:
-        pkg_resources.require(req)
-    except pkg_resources.VersionConflict:
-        try:
-            _easy_install(argv, [download_setuptools(delay=0)])
-            #from setuptools.command.easy_install import main
-        except ImportError:
-            from easy_install import main
-            main(list(argv)+[download_setuptools(delay=0)])
-        sys.exit(0) # try to force an exit
-    else:
-        if argv:
-            _easy_install(argv)
-            #from setuptools.command.easy_install import main
-            #main(argv)
-        else:
-            print "distribute version",version,"or greater has been installed."
-            print '(Run "bootstrapping.py -U distribute" to reinstall or upgrade.)'
-
-def update_md5(filenames):
-    """Update our built-in md5 registry"""
-
-    import re
-
-    for name in filenames:
-        base = os.path.basename(name)
-        f = open(name,'rb')
-        md5_data[base] = md5(f.read()).hexdigest()
-        f.close()
-
-    data = ["    %r: %r,\n" % it for it in md5_data.items()]
-    data.sort()
-    repl = "".join(data)
-
-    import inspect
-    srcfile = inspect.getsourcefile(sys.modules[__name__])
-    f = open(srcfile, 'rb'); src = f.read(); f.close()
-
-    match = re.search("\nmd5_data = {\n([^}]+)}", src)
-    if not match:
-        print >>sys.stderr, "Internal error!"
-        sys.exit(2)
-
-    src = src[:match.start(1)] + repl + src[match.end(1):]
-    f = open(srcfile,'w')
-    f.write(src)
-    f.close()
-
-
-if __name__ == '__main__':
-    if len(sys.argv) > 2 and sys.argv[1] == '--md5update':
-        update_md5(sys.argv[2:])
-    else:
-        main(sys.argv[1:])
-

distribute_setup.py

+#!python
+"""Bootstrap distribute installation
+
+If you want to use setuptools in your package's setup.py, just include this
+file in the same directory with it, and add this to the top of your setup.py::
+
+    from distribute_setup import use_setuptools
+    use_setuptools()
+
+If you want to require a specific version of setuptools, set a download
+mirror, or use an alternate download directory, you can do so by supplying
+the appropriate options to ``use_setuptools()``.
+
+This file can also be run as a script to install or upgrade setuptools.
+"""
+import sys
+import os
+import shutil
+import time
+import fnmatch
+from distutils import log
+from distutils.errors import DistutilsError
+
+is_jython = sys.platform.startswith('java')
+if is_jython:
+    import subprocess
+
+try:
+    from hashlib import md5
+except ImportError:
+    from md5 import md5
+
+DEFAULT_VERSION = "0.6"
+#DEFAULT_URL     = "http://pypi.python.org/packages/%s/d/distribute/" % sys.version[:3]
+DEFAULT_URL     = "http://nightly.ziade.org/"
+
+md5_data = {
+    'distribute-0.6-py2.3.egg': 'a9ba0aaf677b912a90e9fb485fa4db19',
+    'distribute-0.6-py2.4.egg': 'a7c8ccf5609bee803497de62960b698c',
+    'distribute-0.6-py2.5.egg': 'c624cd74c056757908a1cdafa288d03c',
+    'distribute-0.6-py2.6.egg': '7ab763a7c8261759c8d2215c5cd3ee26',
+}
+
+def _validate_md5(egg_name, data):
+    if egg_name in md5_data:
+        digest = md5(data).hexdigest()
+        if digest != md5_data[egg_name]:
+            print >>sys.stderr, (
+                "md5 validation of %s failed!  (Possible download problem?)"
+                % egg_name
+            )
+            sys.exit(2)
+    return data
+
+def use_setuptools(
+    version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir,
+    download_delay=15
+):
+    """Automatically find/download setuptools and make it available on sys.path
+
+    `version` should be a valid setuptools version number that is available
+    as an egg for download under the `download_base` URL (which should end with
+    a '/').  `to_dir` is the directory where setuptools will be downloaded, if
+    it is not already available.  If `download_delay` is specified, it should
+    be the number of seconds that will be paused before initiating a download,
+    should one be required.  If an older version of setuptools is installed,
+    this routine will print a message to ``sys.stderr`` and raise SystemExit in
+    an attempt to abort the calling script.
+    """
+    was_imported = 'pkg_resources' in sys.modules or 'setuptools' in sys.modules
+    def do_download():
+        egg = download_setuptools(version, download_base, to_dir, download_delay)
+        sys.path.insert(0, egg)
+        import setuptools; setuptools.bootstrap_install_from = egg
+    try:
+        import pkg_resources
+        if not hasattr(pkg_resources, '_distribute'):
+            raise ImportError
+    except ImportError:
+        return do_download()
+    try:
+        pkg_resources.require("distribute>="+version); return
+    except pkg_resources.VersionConflict, e:
+        if was_imported:
+            print >>sys.stderr, (
+            "The required version of distribute (>=%s) is not available, and\n"
+            "can't be installed while this script is running. Please install\n"
+            " a more recent version first, using 'easy_install -U distribute'."
+            "\n\n(Currently using %r)"
+            ) % (version, e.args[0])
+            sys.exit(2)
+        else:
+            del pkg_resources, sys.modules['pkg_resources']    # reload ok
+            return do_download()
+    except pkg_resources.DistributionNotFound:
+        return do_download()
+
+def download_setuptools(
+    version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir,
+    delay = 15
+):
+    """Download distribute from a specified location and return its filename
+
+    `version` should be a valid distribute version number that is available
+    as an egg for download under the `download_base` URL (which should end
+    with a '/'). `to_dir` is the directory where the egg will be downloaded.
+    `delay` is the number of seconds to pause before an actual download attempt.
+    """
+    import urllib2, shutil
+    egg_name = "distribute-%s-py%s.egg" % (version,sys.version[:3])
+    url = download_base + egg_name
+    saveto = os.path.join(to_dir, egg_name)
+    src = dst = None
+    if not os.path.exists(saveto):  # Avoid repeated downloads
+        try:
+            from distutils import log
+            if delay:
+                log.warn("""
+---------------------------------------------------------------------------
+This script requires distribute version %s to run (even to display
+help).  I will attempt to download it for you (from
+%s), but
+you may need to enable firewall access for this script first.
+I will start the download in %d seconds.
+
+(Note: if this machine does not have network access, please obtain the file
+
+   %s
+
+and place it in this directory before rerunning this script.)
+---------------------------------------------------------------------------""",
+                    version, download_base, delay, url
+                ); from time import sleep; sleep(delay)
+            log.warn("Downloading %s", url)
+            src = urllib2.urlopen(url)
+            # Read/write all in one block, so we don't create a corrupt file
+            # if the download is interrupted.
+            data = _validate_md5(egg_name, src.read())
+            dst = open(saveto,"wb"); dst.write(data)
+        finally:
+            if src: src.close()
+            if dst: dst.close()
+    return os.path.realpath(saveto)
+
+
+SETUPTOOLS_PKG_INFO  = """\
+Metadata-Version: 1.0
+Name: setuptools
+Version: 0.6c9
+Summary: xxxx
+Home-page: xxx
+Author: xxx
+Author-email: xxx
+License: xxx
+Description: xxx
+"""
+
+def _patch_file(path, content):
+    """Will backup the file then patch it"""
+    existing_content = open(path).read()
+    if existing_content == content:
+        # already patched
+        log.warn('Already patched.')
+        return False
+    log.warn('Patching...')
+    os.rename(path, path +'.OLD.%s' % time.time())
+    f = open(path, 'w')
+    try:
+        f.write(content)
+    finally:
+        f.close()
+    return True
+
+def _same_content(path, content):
+    return open(path).read() == content
+
+def _rename_path(path):
+    new_name = path + '.OLD.%s' % time.time()
+    log.warn('Renaming %s into %s' % (path, new_name))
+    os.rename(path, new_name)
+    return new_name
+
+def _remove_flat_installation(placeholder):
+    if not os.path.isdir(placeholder):
+        log.warn('Unkown installation at %s' % placeholder)
+        return False
+    found = False
+    for file in os.listdir(placeholder):
+        if fnmatch.fnmatch(file, 'setuptools*.egg-info'):
+            found = True
+            break
+    if not found:
+        log.warn('Could not locate setuptools*.egg-info')
+    else:
+        log.warn('Removing elements out of the way...')
+        pkg_info = os.path.join(placeholder, file)
+        if os.path.isdir(pkg_info):
+            patched = _patch_egg_dir(pkg_info)
+        else:
+            patched = _patch_file(pkg_info, SETUPTOOLS_PKG_INFO)
+
+    if not patched:
+        log.warn('%s already patched.' % pkg_info)
+        return False
+    # now let's move the files out of the way
+    for element in ('setuptools', 'pkg_resources.py', 'site.py'):
+        element = os.path.join(placeholder, element)
+        if os.path.exists(element):
+            _rename_path(element)
+        else:
+            log.warn('Could not find the %s element of the '
+                     'Setuptools distribution' % element)
+    return True
+
+def after_install(dist):
+    log.warn('After install bootstrap.')
+    placeholder = dist.get_command_obj('install').install_purelib
+    if not os.path.exists(placeholder):
+        log.warn('Could not find the install location')
+        return
+    pyver = '%s.%s' % (sys.version_info[0], sys.version_info[1])
+    setuptools_file = 'setuptools-0.6c9-py%s.egg-info' % pyver
+    pkg_info = os.path.join(placeholder, setuptools_file)
+    if os.path.exists(pkg_info):
+        log.warn('%s already exists' % pkg_info)
+        return
+    log.warn('Creating %s' % pkg_info)
+    f = open(pkg_info, 'w')
+    try:
+        f.write(SETUPTOOLS_PKG_INFO)
+    finally:
+        f.close()
+    pth_file = os.path.join(placeholder, 'setuptools.pth')
+    log.warn('Creating %s' % pth_file)
+    f = open(pth_file, 'w')
+    try:
+        f.write(os.path.join(os.curdir, setuptools_file))
+    finally:
+        f.close()
+
+def _patch_egg_dir(path):
+    # let's check if it's already patched
+    pkg_info = os.path.join(path, 'EGG-INFO', 'PKG-INFO')
+    if os.path.exists(pkg_info):
+        if _same_content(pkg_info, SETUPTOOLS_PKG_INFO):
+            log.warn('%s already patched.' % pkg_info)
+            return False
+    _rename_path(path)
+    os.mkdir(path)
+    os.mkdir(os.path.join(path, 'EGG-INFO'))
+    pkg_info = os.path.join(path, 'EGG-INFO', 'PKG-INFO')
+    f = open(pkg_info, 'w')
+    try:
+        f.write(SETUPTOOLS_PKG_INFO)
+    finally:
+        f.close()
+    return True
+
+def before_install():
+    log.warn('Before install bootstrap.')
+    fake_setuptools()
+
+def fake_setuptools():
+    log.warn('Scanning installed packages')
+    try:
+        import pkg_resources
+    except ImportError:
+        # we're cool
+        log.warn('Setuptools or Distribute does not seem to be installed.')
+        return
+    ws = pkg_resources.working_set
+    setuptools_dist = ws.find(pkg_resources.Requirement.parse('setuptools'))
+    if setuptools_dist is None:
+        log.warn('No setuptools distribution found')
+        return
+    # detecting if it was already faked
+    setuptools_location = setuptools_dist.location
+    log.warn('Setuptools installation detected at %s' % setuptools_location)
+
+    # let's see if its an egg
+    if not setuptools_location.endswith('.egg'):
+        log.warn('Non-egg installation')
+        res = _remove_flat_installation(setuptools_location)
+        if not res:
+            return
+    else:
+        log.warn('Egg installation')
+        pkg_info = os.path.join(setuptools_location, 'EGG-INFO', 'PKG-INFO')
+        if (os.path.exists(pkg_info) and
+            _same_content(pkg_info, SETUPTOOLS_PKG_INFO)):
+            log.warn('Already patched.')
+            return
+        log.warn('Patching...')
+        # let's create a fake egg replacing setuptools one
+        res = _patch_egg_dir(setuptools_location)
+        if not res:
+            return
+    log.warn('Patched done.')
+    _relaunch()
+
+def _relaunch():
+    log.warn('Relaunching...')
+    # we have to relaunch the process
+    args = [sys.executable]  + sys.argv
+    if is_jython:
+        sys.exit(subprocess.call(args))
+    else:
+        sys.exit(os.spawnv(os.P_WAIT, sys.executable, args))
+
+def _easy_install(argv, egg=None):
+    from setuptools import setup
+    from setuptools.dist import Distribution
+    import distutils.core
+    if egg is not None:
+        setup_args = list(argv) + ['-v'] + [egg]
+    else:
+        setup_args = list(argv)
+    try:
+        return setup(script_args = ['-q','easy_install',
+                                    '-v'] + setup_args,
+                    script_name = sys.argv[0] or 'easy_install',
+                    distclass=Distribution)
+    except DistutilsError:
+        return sys.exit(2)
+
+def main(argv, version=DEFAULT_VERSION):
+    """Install or upgrade setuptools and EasyInstall"""
+    # let's deactivate any existing setuptools installation first
+    fake_setuptools()
+    try:
+        import setuptools
+        # we need to check if the installed setuptools
+        # is from Distribute or from setuptools
+        if not hasattr(setuptools, '_distribute'):
+            # now we are ready to install distribute
+            raise ImportError
+    except ImportError:
+        egg = None
+        try:
+            egg = download_setuptools(version, delay=0)
+            sys.path.insert(0, egg)
+            import setuptools
+            if not hasattr(setuptools, '_distribute'):
+                placeholder = os.path.split(os.path.dirname(setuptools.__file__))[0]
+                if not placeholder.endswith('.egg'):
+                    res = _remove_flat_installation(placeholder)
+                    if res:
+                        _relaunch()
+                print >> sys.stderr, (
+                "The patch didn't work, Setuptools is still active.\n"
+                "Possible reason: your have a system-wide setuptools installed "
+                "and you are in a virtualenv.\n"
+                "If you are inside a virtualenv, make sure you used the --no-site-packages option"
+                )
+                sys.exit(2)
+            dist = _easy_install(argv, egg)
+            after_install(dist)
+            return
+            #from setuptools.command import easy_install
+            #try:
+            #    return easy_install.main(list(argv)+['-v']+[egg])
+            #except DistutilsError:
+            #    return sys.exit(2)
+        finally:
+            if egg and os.path.exists(egg):
+                os.unlink(egg)
+    else:
+        if setuptools.__version__ == '0.0.1':
+            print >>sys.stderr, (
+            "You have an obsolete version of setuptools installed.  Please\n"
+            "remove it from your system entirely before rerunning this script."
+            )
+            sys.exit(2)
+
+    req = "distribute>="+version
+    import pkg_resources
+    try:
+        pkg_resources.require(req)
+    except pkg_resources.VersionConflict:
+        try:
+            _easy_install(argv, [download_setuptools(delay=0)])
+            #from setuptools.command.easy_install import main
+        except ImportError:
+            from easy_install import main
+            main(list(argv)+[download_setuptools(delay=0)])
+        sys.exit(0) # try to force an exit
+    else:
+        if argv:
+            _easy_install(argv)
+            #from setuptools.command.easy_install import main
+            #main(argv)
+        else:
+            print "distribute version",version,"or greater has been installed."
+            print '(Run "distribute_setup.py -U distribute" to reinstall or upgrade.)'
+
+def update_md5(filenames):
+    """Update our built-in md5 registry"""
+
+    import re
+
+    for name in filenames:
+        base = os.path.basename(name)
+        f = open(name,'rb')
+        md5_data[base] = md5(f.read()).hexdigest()
+        f.close()
+
+    data = ["    %r: %r,\n" % it for it in md5_data.items()]
+    data.sort()
+    repl = "".join(data)
+
+    import inspect
+    srcfile = inspect.getsourcefile(sys.modules[__name__])
+    f = open(srcfile, 'rb'); src = f.read(); f.close()
+
+    match = re.search("\nmd5_data = {\n([^}]+)}", src)
+    if not match:
+        print >>sys.stderr, "Internal error!"
+        sys.exit(2)
+
+    src = src[:match.start(1)] + repl + src[match.end(1):]
+    f = open(srcfile,'w')
+    f.write(src)
+    f.close()
+
+
+if __name__ == '__main__':
+    if len(sys.argv) > 2 and sys.argv[1] == '--md5update':
+        update_md5(sys.argv[2:])
+    else:
+        main(sys.argv[1:])
+

docs/easy_install.txt

 go on a directory that's already on the ``PATH``.  For more information see the
 sections below on `Command-Line Options`_ and `Configuration Files`_.  You
 can pass command line options (such as ``--script-dir``) to
-``bootstrapping.py`` to control where ``easy_install.exe`` will be installed.
+``distribute_setup.py`` to control where ``easy_install.exe`` will be installed.
 
 
 
     install_lib = ~/py-lib
     install_scripts = ~/bin
 
-Be sure to do this *before* you try to run the ``bootstrapping.py``
+Be sure to do this *before* you try to run the ``distribute_setup.py``
 installation script.  Then, follow the standard `installation instructions`_,
 but make sure that ``~/py-lib`` is listed in your ``PYTHONPATH`` environment
 variable.

docs/setuptools.txt

 automatically download and install ``setuptools`` if the user is building your
 package from source and doesn't have a suitable version already installed.
 
-.. _bootstrap module: http://cdn.bitbucket.org/tarek/distribute/downloads/bootstrapping.py
+.. _bootstrap module: http://cdn.bitbucket.org/tarek/distribute/downloads/distribute_setup.py
 
 Feature Highlights:
 
 
 .. contents:: **Table of Contents**
 
-.. _bootstrapping.py: `bootstrap module`_
+.. _distribute_setup.py: `bootstrap module`_
 
 
 -----------------
 If you want the current in-development version of setuptools, you should first
 install a stable version, and then run::
 
-    bootstrapping.py setuptools==dev
+    distribute_setup.py setuptools==dev
 
 This will download and install the latest development (i.e. unstable) version
 of setuptools from the Python Subversion sandbox.
 "long" name.  That is, if the egg is built for Python 2.3, there must be a
 ``python2.3`` executable present in a directory on ``PATH``.
 
-This feature is primarily intended to support bootstrapping the installation of
+This feature is primarily intended to support distribute_setup the installation of
 setuptools itself on non-Windows platforms, but may also be useful for other
 projects as well.
 
 
 Your users might not have ``setuptools`` installed on their machines, or even
 if they do, it might not be the right version.  Fixing this is easy; just
-download `bootstrapping.py`_, and put it in the same directory as your ``setup.py``
+download `distribute_setup.py`_, and put it in the same directory as your ``setup.py``
 script.  (Be sure to add it to your revision control system, too.)  Then add
 these two lines to the very top of your setup script, before the script imports
 anything from setuptools::
 
-    import bootstrapping
-    bootstrapping.use_setuptools()
-
-That's it.  The ``bootstrapping`` module will automatically download a matching
+    import distribute_setup
+    distribute_setup.use_setuptools()
+
+That's it.  The ``distribute_setup`` module will automatically download a matching
 version of ``setuptools`` from PyPI, if it isn't present on the target system.
 Whenever you install an updated version of setuptools, you should also update
-your projects' ``bootstrapping.py`` files, so that a matching version gets installed
+your projects' ``distribute_setup.py`` files, so that a matching version gets installed
 on the target machine(s).
 
 By the way, setuptools supports the new PyPI "upload" command, so you can use
 setuptools and ``easy_install``.
 
 Network Access
-    If your project is using ``bootstrapping``, you should inform users of the
+    If your project is using ``distribute_setup``, you should inform users of the
     need to either have network access, or to preinstall the correct version of
     setuptools using the `EasyInstall installation instructions`_.  Those
     instructions also have tips for dealing with firewalls as well as how to
 Managing Multiple Projects
 --------------------------
 
-If you're managing several projects that need to use ``bootstrapping``, and you
+If you're managing several projects that need to use ``distribute_setup``, and you
 are using Subversion as your revision control system, you can use the
-"svn:externals" property to share a single copy of ``bootstrapping`` between
+"svn:externals" property to share a single copy of ``distribute_setup`` between
 projects, so that it will always be up-to-date whenever you check out or update
 an individual project, without having to manually update each project to use
 a new version.
 
 However, because Subversion only supports using directories as externals, you
-have to turn ``bootstrapping.py`` into ``bootstrapping/__init__.py`` in order
-to do this, then create "externals" definitions that map the ``bootstrapping``
+have to turn ``distribute_setup.py`` into ``distribute_setup/__init__.py`` in order
+to do this, then create "externals" definitions that map the ``distribute_setup``
 directory into each project.  Also, if any of your projects use
 ``find_packages()`` on their setup directory, you will need to exclude the
-resulting ``bootstrapping`` package, to keep it from being included in your
+resulting ``distribute_setup`` package, to keep it from being included in your
 distributions, e.g.::
 
     setup(
         ...
-        packages = find_packages(exclude=['bootstrapping']),
+        packages = find_packages(exclude=['distribute_setup']),
     )
 
-Of course, the ``bootstrapping`` package will still be included in your
+Of course, the ``distribute_setup`` package will still be included in your
 packages' source distributions, as it needs to be.
 
 For your convenience, you may use the following external definition, which will
 Reusing ``setuptools`` Code
 ===========================
 
-``bootstrapping``
+``distribute_setup``
 -----------------
 
 XXX
 python2.6 setup.py -q egg_info -RDb '' sdist
 
 # updating the md5 hashes
-python bootstrapping.py --md5update dist/distribute-$VERSION-py2.3.egg
-python bootstrapping.py --md5update dist/distribute-$VERSION-py2.4.egg
-python bootstrapping.py --md5update dist/distribute-$VERSION-py2.5.egg
-python bootstrapping.py --md5update dist/distribute-$VERSION-py2.6.egg
+python distribute_setup.py --md5update dist/distribute-$VERSION-py2.3.egg
+python distribute_setup.py --md5update dist/distribute-$VERSION-py2.4.egg
+python distribute_setup.py --md5update dist/distribute-$VERSION-py2.5.egg
+python distribute_setup.py --md5update dist/distribute-$VERSION-py2.6.egg
 
 # XXX uploads will be done here
 
 # if we are installing Distribute using "python setup.py install"
 # we need to get setuptools out of the way
 if 'install' in sys.argv[1:]:
-    from bootstrapping import before_install
+    from distribute_setup import before_install
     before_install()
 
 dist = setup(
     scripts = scripts,
 )
 if 'install' in sys.argv[1:]:
-    from bootstrapping import after_install
+    from distribute_setup import after_install
     after_install(dist)
 
 

setuptools/__init__.py

 # or by the Distribute project, in case Setuptools creates
 # a distribution with the same version.
 #
-# The bootstrapping script for instance, will check if this
+# The distribute_setup script for instance, will check if this
 # attribute is present to decide wether to reinstall the package
 _distribute = True
 
                 os.path.isfile(os.path.join(fn,'__init__.py'))
             ):
                 out.append(prefix+name); stack.append((fn,prefix+name+'.'))
-    for pat in list(exclude)+['ez_setup', 'bootstrapping']:
+    for pat in list(exclude)+['ez_setup', 'distribute_setup']:
         from fnmatch import fnmatchcase
         out = [item for item in out if not fnmatchcase(item,pat)]
     return out

tests/install_test.py

 import sys
 import os
 
-if os.path.exists('bootstrapping.py'):
-    print 'bootstrapping.py exists in the current dir, aborting'
+if os.path.exists('distribute_setup.py'):
+    print 'distribute_setup.py exists in the current dir, aborting'
     sys.exit(2)
 
 print '**** Starting Test'
     import subprocess
 
 print 'Downloading bootstrap'
-file = urllib2.urlopen('http://nightly.ziade.org/bootstrapping.py')
-f = open('bootstrapping.py', 'w')
+file = urllib2.urlopen('http://nightly.ziade.org/distribute_setup.py')
+f = open('distribute_setup.py', 'w')
 f.write(file.read())
 f.close()
 
 # running it
-args = [sys.executable]  + ['bootstrapping.py']
+args = [sys.executable]  + ['distribute_setup.py']
 if is_jython:
     res = subprocess.call(args)
 else:
 
 if res != 0:
     print '**** Test failed, please send me the output at tarek@ziade.org'
-    os.remove('bootstrapping.py')
+    os.remove('distribute_setup.py')
     sys.exit(2)
 
 # now checking if Distribute is installed
 finally:
     if os.path.exists(script_name):
         os.remove(script_name)
-    os.remove('bootstrapping.py')
+    os.remove('distribute_setup.py')
 

virtual-python.py

         return
 
     parser = optparse.OptionParser()
-    
+
     parser.add_option('-v', '--verbose', action='count', dest='verbose',
         default=0, help="Increase verbosity")
-        
+
     parser.add_option('--prefix', dest="prefix", default='~',
         help="The base directory to install to (default ~)")
-        
+
     parser.add_option('--clear', dest='clear', action='store_true',
         help="Clear out the non-root install and start from scratch")
-        
+
     parser.add_option('--no-site-packages', dest='no_site_packages',
         action='store_true',
         help="Don't copy the contents of the global site-packages dir to the "
              "non-root site-packages")
-    
+
     options, args = parser.parse_args()
     global verbose
 
 
     verbose = options.verbose
     assert not args, "No arguments allowed"
-        
+
     if options.clear:
         rmtree(lib_dir)
         rmtree(inc_dir)
         print 'Please make sure you remove any previous custom paths from'
         print "your", pydistutils, "file."
 
-    print "You're now ready to download bootstrapping.py, and run"
-    print py_executable, "bootstrapping.py"
-      
+    print "You're now ready to download distribute_setup.py, and run"
+    print py_executable, "distribute_setup.py"
+
 if __name__ == '__main__':
     main()