text: #!python
  """\
  Easy Install
  ------------
  
  A tool for doing automatic download/extract/build of distutils-based Python
  packages.  For detailed documentation, see the accompanying EasyInstall.txt
  file, or visit the `EasyInstall home page`__.
  
  __ http://peak.telecommunity.com/DevCenter/EasyInstall
  """
  import sys, os.path, zipimport, shutil, tempfile, zipfile, re, stat, random
  from glob import glob
  from setuptools import Command
  from setuptools.sandbox import run_setup
  from distutils import log, dir_util
  from distutils.sysconfig import get_python_lib
  from distutils.errors import DistutilsArgError, DistutilsOptionError, \
      DistutilsError
  from setuptools.archive_util import unpack_archive
  from setuptools.package_index import PackageIndex, parse_bdist_wininst
  from setuptools.package_index import URL_SCHEME
  from setuptools.command import bdist_egg, egg_info
  from pkg_resources import *
  sys_executable = os.path.normpath(sys.executable)
  
  __all__ = [
      'samefile', 'easy_install', 'PthDistributions', 'extract_wininst_cfg',
      'main', 'get_exe_prefixes',
  ]
  
  def samefile(p1,p2):
      if hasattr(os.path,'samefile') and (
          os.path.exists(p1) and os.path.exists(p2)
      ):
          return os.path.samefile(p1,p2)
      return (
          os.path.normpath(os.path.normcase(p1)) ==
          os.path.normpath(os.path.normcase(p2))
      )
  
  class easy_install(Command):
      """Manage a download/build/install process"""
      description = "Find/get/install Python packages"
      command_consumes_arguments = True
  
      user_options = [
          ('prefix=', None, "installation prefix"),
          ("zip-ok", "z", "install package as a zipfile"),
          ("multi-version", "m", "make apps have to require() a version"),
          ("upgrade", "U", "force upgrade (searches PyPI for latest versions)"),
          ("install-dir=", "d", "install package to DIR"),
          ("script-dir=", "s", "install scripts to DIR"),
          ("exclude-scripts", "x", "Don't install scripts"),
          ("always-copy", "a", "Copy all needed packages to install dir"),
          ("index-url=", "i", "base URL of Python Package Index"),
          ("find-links=", "f", "additional URL(s) to search for packages"),
          ("delete-conflicting", "D", "no longer needed; don't use this"),
          ("ignore-conflicts-at-my-risk", None,
              "no longer needed; don't use this"),
          ("build-directory=", "b",
              "download/extract/build in DIR; keep the results"),
          ('optimize=', 'O',
           "also compile with optimization: -O1 for \"python -O\", "
           "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
          ('record=', None,
           "filename in which to record list of installed files"),
          ('always-unzip', 'Z', "don't install as a zipfile, no matter what"),
          ('site-dirs=','S',"list of directories where .pth files work"),
          ('editable', 'e', "Install specified packages in editable form"),
          ('no-deps', 'N', "don't install dependencies"),
          ('allow-hosts=', 'H', "pattern(s) that hostnames must match"),
          ('local-snapshots-ok', 'l', "allow building eggs from local checkouts"),
      ]
      boolean_options = [
          'zip-ok', 'multi-version', 'exclude-scripts', 'upgrade', 'always-copy',
          'delete-conflicting', 'ignore-conflicts-at-my-risk', 'editable',
          'no-deps', 'local-snapshots-ok',
      ]
      negative_opt = {'always-unzip': 'zip-ok'}
      create_index = PackageIndex
  
      def initialize_options(self):
          self.zip_ok = self.local_snapshots_ok = None
          self.install_dir = self.script_dir = self.exclude_scripts = None
          self.index_url = None
          self.find_links = None
          self.build_directory = None
          self.args = None
          self.optimize = self.record = None
          self.upgrade = self.always_copy = self.multi_version = None
          self.editable = self.no_deps = self.allow_hosts = None
          self.root = self.prefix = self.no_report = None
  
          # Options not specifiable via command line
          self.package_index = None
          self.pth_file = self.always_copy_from = None
          self.delete_conflicting = None
          self.ignore_conflicts_at_my_risk = None
          self.site_dirs = None
          self.installed_projects = {}
          self.sitepy_installed = False
          # Always read easy_install options, even if we are subclassed, or have
          # an independent instance created.  This ensures that defaults will
          # always come from the standard configuration file(s)' "easy_install"
          # section, even if this is a "develop" or "install" command, or some
          # other embedding.
          self._dry_run = None
          self.verbose = self.distribution.verbose
          self.distribution._set_command_options(
              self, self.distribution.get_option_dict('easy_install')
          )
  
      def delete_blockers(self, blockers):
          for filename in blockers:
              if os.path.exists(filename) or os.path.islink(filename):
                  log.info("Deleting %s", filename)
                  if not self.dry_run:
                      if os.path.isdir(filename) and not os.path.islink(filename):
                          rmtree(filename)
                      else:
                          os.unlink(filename)
  
      def finalize_options(self):
          self._expand('install_dir','script_dir','build_directory','site_dirs')
          # If a non-default installation directory was specified, default the
          # script directory to match it.
          if self.script_dir is None:
              self.script_dir = self.install_dir
  
          # Let install_dir get set by install_lib command, which in turn
          # gets its info from the install command, and takes into account
          # --prefix and --home and all that other crud.
          self.set_undefined_options('install_lib',
              ('install_dir','install_dir')
          )
          # Likewise, set default script_dir from 'install_scripts.install_dir'
          self.set_undefined_options('install_scripts',
              ('install_dir', 'script_dir')
          )
          # default --record from the install command
          self.set_undefined_options('install', ('record', 'record'))
          normpath = map(normalize_path, sys.path)
          self.all_site_dirs = get_site_dirs()
          if self.site_dirs is not None:
              site_dirs = [
                  os.path.expanduser(s.strip()) for s in self.site_dirs.split(',')
              ]
              for d in site_dirs:
                  if not os.path.isdir(d):
                      log.warn("%s (in --site-dirs) does not exist", d)
                  elif normalize_path(d) not in normpath:
                      raise DistutilsOptionError(
                          d+" (in --site-dirs) is not on sys.path"
                      )
                  else:
                      self.all_site_dirs.append(normalize_path(d))
          if not self.editable: self.check_site_dir()
          self.index_url = self.index_url or "http://pypi.python.org/simple"
          self.shadow_path = self.all_site_dirs[:]
          for path_item in self.install_dir, normalize_path(self.script_dir):
              if path_item not in self.shadow_path:
                  self.shadow_path.insert(0, path_item)
  
          if self.allow_hosts is not None:
              hosts = [s.strip() for s in self.allow_hosts.split(',')]
          else:
              hosts = ['*']
          if self.package_index is None:
              self.package_index = self.create_index(
                  self.index_url, search_path = self.shadow_path, hosts=hosts,
              )
          self.local_index = Environment(self.shadow_path+sys.path)
  
          if self.find_links is not None:
              if isinstance(self.find_links, basestring):
                  self.find_links = self.find_links.split()
          else:
              self.find_links = []
          if self.local_snapshots_ok:
              self.package_index.scan_egg_links(self.shadow_path+sys.path)
          self.package_index.add_find_links(self.find_links)
          self.set_undefined_options('install_lib', ('optimize','optimize'))
          if not isinstance(self.optimize,int):
              try:
                  self.optimize = int(self.optimize)
                  if not (0 <= self.optimize <= 2): raise ValueError
              except ValueError:
                  raise DistutilsOptionError("--optimize must be 0, 1, or 2")
  
          if self.delete_conflicting and self.ignore_conflicts_at_my_risk:
              raise DistutilsOptionError(
                  "Can't use both --delete-conflicting and "
                  "--ignore-conflicts-at-my-risk at the same time"
              )
          if self.editable and not self.build_directory:
              raise DistutilsArgError(
                  "Must specify a build directory (-b) when using --editable"
              )
          if not self.args:
              raise DistutilsArgError(
                  "No urls, filenames, or requirements specified (see --help)")
  
          self.outputs = []
  
      def run(self):
          if self.verbose!=self.distribution.verbose:
              log.set_verbosity(self.verbose)
          try:
              for spec in self.args:
                  self.easy_install(spec, not self.no_deps)
              if self.record:
                  outputs = self.outputs
                  if self.root:               # strip any package prefix
                      root_len = len(self.root)
                      for counter in xrange(len(outputs)):
                          outputs[counter] = outputs[counter][root_len:]
                  from distutils import file_util
                  self.execute(
                      file_util.write_file, (self.record, outputs),
                      "writing list of installed files to '%s'" %
                      self.record
                  )
              self.warn_deprecated_options()
          finally:
              log.set_verbosity(self.distribution.verbose)
  
      def pseudo_tempname(self):
          """Return a pseudo-tempname base in the install directory.
          This code is intentionally naive; if a malicious party can write to
          the target directory you're already in deep doodoo.
          """
          try:
              pid = os.getpid()
          except:
              pid = random.randint(0,sys.maxint)
          return os.path.join(self.install_dir, "test-easy-install-%s" % pid)
  
      def warn_deprecated_options(self):
          if self.delete_conflicting or self.ignore_conflicts_at_my_risk:
              log.warn(
                  "Note: The -D, --delete-conflicting and"
                  " --ignore-conflicts-at-my-risk no longer have any purpose"
                  " and should not be used."
              )
  
      def check_site_dir(self):
          """Verify that self.install_dir is .pth-capable dir, if needed"""
          instdir = normalize_path(self.install_dir)
          pth_file = os.path.join(instdir,'easy-install.pth')
  
          # Is it a configured, PYTHONPATH, implicit, or explicit site dir?
          is_site_dir = instdir in self.all_site_dirs
  
          if not is_site_dir and not self.multi_version:
              # No?  Then directly test whether it does .pth file processing
              is_site_dir = self.check_pth_processing()
          else:
              # make sure we can write to target dir
              testfile = self.pseudo_tempname()+'.write-test'
              test_exists = os.path.exists(testfile)
              try:
                  if test_exists: os.unlink(testfile)
                  open(testfile,'w').close()
                  os.unlink(testfile)
              except (OSError,IOError):
                  self.cant_write_to_target()
  
          if not is_site_dir and not self.multi_version:
              # Can't install non-multi to non-site dir
              raise DistutilsError(self.no_default_version_msg())
  
          if is_site_dir:
              if self.pth_file is None:
                  self.pth_file = PthDistributions(pth_file, self.all_site_dirs)
          else:
              self.pth_file = None
  
          PYTHONPATH = os.environ.get('PYTHONPATH','').split(os.pathsep)
          if instdir not in map(normalize_path, filter(None,PYTHONPATH)):
              # only PYTHONPATH dirs need a site.py, so pretend it's there
              self.sitepy_installed = True
          elif self.multi_version and not os.path.exists(pth_file):
              self.sitepy_installed = True    # don't need site.py in this case
              self.pth_file = None            # and don't create a .pth file
          self.install_dir = instdir
  
      def cant_write_to_target(self):
          msg = """can't create or remove files in install directory
  
  The following error occurred while trying to add or remove files in the
  installation directory:
  
      %s
  
  The installation directory you specified (via --install-dir, --prefix, or
  the distutils default setting) was:
  
      %s
  """     % (sys.exc_info()[1], self.install_dir,)
  
          if not os.path.exists(self.install_dir):
              msg += """
  This directory does not currently exist.  Please create it and try again, or
  choose a different installation directory (using the -d or --install-dir
  option).
  """
          else:
              msg += """
  Perhaps your account does not have write access to this directory?  If the
  installation directory is a system-owned directory, you may need to sign in
  as the administrator or "root" account.  If you do not have administrative
  access to this machine, you may wish to choose a different installation
  directory, preferably one that is listed in your PYTHONPATH environment
  variable.
  
  For information on other options, you may wish to consult the
  documentation at:
  
    http://peak.telecommunity.com/EasyInstall.html
  
  Please make the appropriate changes for your system and try again.
  """
          raise DistutilsError(msg)
  
  
  
  
      def check_pth_processing(self):
          """Empirically verify whether .pth files are supported in inst. dir"""
          instdir = self.install_dir
          log.info("Checking .pth file support in %s", instdir)
          pth_file = self.pseudo_tempname()+".pth"
          ok_file = pth_file+'.ok'
          ok_exists = os.path.exists(ok_file)
          try:
              if ok_exists: os.unlink(ok_file)
              f = open(pth_file,'w')
          except (OSError,IOError):
              self.cant_write_to_target()
          else:
              try:
                  f.write("import os;open(%r,'w').write('OK')\n" % (ok_file,))
                  f.close(); f=None
                  executable = sys.executable
                  if os.name=='nt':
                      dirname,basename = os.path.split(executable)
                      alt = os.path.join(dirname,'pythonw.exe')
                      if basename.lower()=='python.exe' and os.path.exists(alt):
                          # use pythonw.exe to avoid opening a console window
                          executable = alt
  
                  from distutils.spawn import spawn
                  spawn([executable,'-E','-c','pass'],0)
  
                  if os.path.exists(ok_file):
                      log.info(
                          "TEST PASSED: %s appears to support .pth files",
                          instdir
                      )
                      return True
              finally:
                  if f: f.close()
                  if os.path.exists(ok_file): os.unlink(ok_file)
                  if os.path.exists(pth_file): os.unlink(pth_file)
          if not self.multi_version:
              log.warn("TEST FAILED: %s does NOT support .pth files", instdir)
          return False
  
      def install_egg_scripts(self, dist):
          """Write all the scripts for `dist`, unless scripts are excluded"""
          if not self.exclude_scripts and dist.metadata_isdir('scripts'):
              for script_name in dist.metadata_listdir('scripts'):
                  self.install_script(
                      dist, script_name,
                      dist.get_metadata('scripts/'+script_name)
                  )
          self.install_wrapper_scripts(dist)
  
      def add_output(self, path):
          if os.path.isdir(path):
              for base, dirs, files in os.walk(path):
                  for filename in files:
                      self.outputs.append(os.path.join(base,filename))
          else:
              self.outputs.append(path)
  
      def not_editable(self, spec):
          if self.editable:
              raise DistutilsArgError(
                  "Invalid argument %r: you can't use filenames or URLs "
                  "with --editable (except via the --find-links option)."
                  % (spec,)
              )
  
      def check_editable(self,spec):
          if not self.editable:
              return
  
          if os.path.exists(os.path.join(self.build_directory, spec.key)):
              raise DistutilsArgError(
                  "%r already exists in %s; can't do a checkout there" %
                  (spec.key, self.build_directory)
              )
  
  
  
  
  
  
      def easy_install(self, spec, deps=False):
          tmpdir = tempfile.mkdtemp(prefix="easy_install-")
          download = None
          if not self.editable: self.install_site_py()
  
          try:
              if not isinstance(spec,Requirement):
                  if URL_SCHEME(spec):
                      # It's a url, download it to tmpdir and process
                      self.not_editable(spec)
                      download = self.package_index.download(spec, tmpdir)
                      return self.install_item(None, download, tmpdir, deps, True)
  
                  elif os.path.exists(spec):
                      # Existing file or directory, just process it directly
                      self.not_editable(spec)
                      return self.install_item(None, spec, tmpdir, deps, True)
                  else:
                      spec = parse_requirement_arg(spec)
  
              self.check_editable(spec)
              dist = self.package_index.fetch_distribution(
                  spec, tmpdir, self.upgrade, self.editable, not self.always_copy,
                  self.local_index
              )
              if dist is None:
                  msg = "Could not find suitable distribution for %r" % spec
                  if self.always_copy:
                      msg+=" (--always-copy skips system and development eggs)"
                  raise DistutilsError(msg)
              elif dist.precedence==DEVELOP_DIST:
                  # .egg-info dists don't need installing, just process deps
                  self.process_distribution(spec, dist, deps, "Using")
                  return dist
              else:
                  return self.install_item(spec, dist.location, tmpdir, deps)
  
          finally:
              if os.path.exists(tmpdir):
                  rmtree(tmpdir)
  
      def install_item(self, spec, download, tmpdir, deps, install_needed=False):
  
          # Installation is also needed if file in tmpdir or is not an egg
          install_needed = install_needed or self.always_copy
          install_needed = install_needed or os.path.dirname(download) == tmpdir
          install_needed = install_needed or not download.endswith('.egg')
          install_needed = install_needed or (
              self.always_copy_from is not None and
              os.path.dirname(normalize_path(download)) ==
              normalize_path(self.always_copy_from)
          )
  
          if spec and not install_needed:
              # at this point, we know it's a local .egg, we just don't know if
              # it's already installed.
              for dist in self.local_index[spec.project_name]:
                  if dist.location==download:
                      break
              else:
                  install_needed = True   # it's not in the local index
  
          log.info("Processing %s", os.path.basename(download))
  
          if install_needed:
              dists = self.install_eggs(spec, download, tmpdir)
              for dist in dists:
                  self.process_distribution(spec, dist, deps)
          else:
              dists = [self.check_conflicts(self.egg_distribution(download))]
              self.process_distribution(spec, dists[0], deps, "Using")
  
          if spec is not None:
              for dist in dists:
                  if dist in spec:
                      return dist
  
  
  
  
  
  
      def process_distribution(self, requirement, dist, deps=True, *info):
          self.update_pth(dist)
          self.package_index.add(dist)
          self.local_index.add(dist)
          self.install_egg_scripts(dist)
          self.installed_projects[dist.key] = dist
          log.info(self.installation_report(requirement, dist, *info))
          if dist.has_metadata('dependency_links.txt'):
              self.package_index.add_find_links(
                  dist.get_metadata_lines('dependency_links.txt')
              )
          if not deps and not self.always_copy:
              return
          elif requirement is not None and dist.key != requirement.key:
              log.warn("Skipping dependencies for %s", dist)
              return  # XXX this is not the distribution we were looking for
          elif requirement is None or dist not in requirement:
              # if we wound up with a different version, resolve what we've got
              distreq = dist.as_requirement()
              requirement = requirement or distreq
              requirement = Requirement(
                  distreq.project_name, distreq.specs, requirement.extras
              )
          log.info("Processing dependencies for %s", requirement)
          try:
              distros = WorkingSet([]).resolve(
                  [requirement], self.local_index, self.easy_install
              )
          except DistributionNotFound, e:
              raise DistutilsError(
                  "Could not find required distribution %s" % e.args
              )
          except VersionConflict, e:
              raise DistutilsError(
                  "Installed distribution %s conflicts with requirement %s"
                  % e.args
              )
          if self.always_copy or self.always_copy_from:
              # Force all the relevant distros to be copied or activated
              for dist in distros:
                  if dist.key not in self.installed_projects:
                      self.easy_install(dist.as_requirement())
          log.info("Finished processing dependencies for %s", requirement)
  
      def should_unzip(self, dist):
          if self.zip_ok is not None:
              return not self.zip_ok
          if dist.has_metadata('not-zip-safe'):
              return True
          if not dist.has_metadata('zip-safe'):
              return True
          return False
  
      def maybe_move(self, spec, dist_filename, setup_base):
          dst = os.path.join(self.build_directory, spec.key)
          if os.path.exists(dst):
              log.warn(
                 "%r already exists in %s; build directory %s will not be kept",
                 spec.key, self.build_directory, setup_base
              )
              return setup_base
          if os.path.isdir(dist_filename):
              setup_base = dist_filename
          else:
              if os.path.dirname(dist_filename)==setup_base:
                  os.unlink(dist_filename)   # get it out of the tmp dir
              contents = os.listdir(setup_base)
              if len(contents)==1:
                  dist_filename = os.path.join(setup_base,contents[0])
                  if os.path.isdir(dist_filename):
                      # if the only thing there is a directory, move it instead
                      setup_base = dist_filename
          ensure_directory(dst); shutil.move(setup_base, dst)
          return dst
  
      def install_wrapper_scripts(self, dist):
          if not self.exclude_scripts:
              for args in get_script_args(dist):
                  self.write_script(*args)
  
  
  
      def install_script(self, dist, script_name, script_text, dev_path=None):
          """Generate a legacy script wrapper and install it"""
          spec = str(dist.as_requirement())
          is_script = is_python_script(script_text, script_name)
  
          if is_script and dev_path:
              script_text = get_script_header(script_text) + (
                  "# EASY-INSTALL-DEV-SCRIPT: %(spec)r,%(script_name)r\n"
                  "__requires__ = %(spec)r\n"
                  "from pkg_resources import require; require(%(spec)r)\n"
                  "del require\n"
                  "__file__ = %(dev_path)r\n"
                  "execfile(__file__)\n"
              ) % locals()
          elif is_script:
              script_text = get_script_header(script_text) + (
                  "# EASY-INSTALL-SCRIPT: %(spec)r,%(script_name)r\n"
                  "__requires__ = %(spec)r\n"
                  "import pkg_resources\n"
                  "pkg_resources.run_script(%(spec)r, %(script_name)r)\n"
              ) % locals()
          self.write_script(script_name, script_text, 'b')
  
      def write_script(self, script_name, contents, mode="t", blockers=()):
          """Write an executable file to the scripts directory"""
          self.delete_blockers(   # clean up old .py/.pyw w/o a script
              [os.path.join(self.script_dir,x) for x in blockers])
          log.info("Installing %s script to %s", script_name, self.script_dir)
          target = os.path.join(self.script_dir, script_name)
          self.add_output(target)
  
          if not self.dry_run:
              ensure_directory(target)
              f = open(target,"w"+mode)
              f.write(contents)
              f.close()
              chmod(target,0755)
  
  
  
  
      def install_eggs(self, spec, dist_filename, tmpdir):
          # .egg dirs or files are already built, so just return them
          if dist_filename.lower().endswith('.egg'):
              return [self.install_egg(dist_filename, tmpdir)]
          elif dist_filename.lower().endswith('.exe'):
              return [self.install_exe(dist_filename, tmpdir)]
  
          # Anything else, try to extract and build
          setup_base = tmpdir
          if os.path.isfile(dist_filename) and not dist_filename.endswith('.py'):
              unpack_archive(dist_filename, tmpdir, self.unpack_progress)
          elif os.path.isdir(dist_filename):
              setup_base = os.path.abspath(dist_filename)
  
          if (setup_base.startswith(tmpdir)   # something we downloaded
              and self.build_directory and spec is not None
          ):
              setup_base = self.maybe_move(spec, dist_filename, setup_base)
  
          # Find the setup.py file
          setup_script = os.path.join(setup_base, 'setup.py')
  
          if not os.path.exists(setup_script):
              setups = glob(os.path.join(setup_base, '*', 'setup.py'))
              if not setups:
                  raise DistutilsError(
                      "Couldn't find a setup script in %s" % os.path.abspath(dist_filename)
                  )
              if len(setups)>1:
                  raise DistutilsError(
                      "Multiple setup scripts in %s" % os.path.abspath(dist_filename)
                  )
              setup_script = setups[0]
  
          # Now run it, and return the result
          if self.editable:
              log.info(self.report_editable(spec, setup_script))
              return []
          else:
              return self.build_and_install(setup_script, setup_base)
  
      def egg_distribution(self, egg_path):
          if os.path.isdir(egg_path):
              metadata = PathMetadata(egg_path,os.path.join(egg_path,'EGG-INFO'))
          else:
              metadata = EggMetadata(zipimport.zipimporter(egg_path))
          return Distribution.from_filename(egg_path,metadata=metadata)
  
      def install_egg(self, egg_path, tmpdir):
          destination = os.path.join(self.install_dir,os.path.basename(egg_path))
          destination = os.path.abspath(destination)
          if not self.dry_run:
              ensure_directory(destination)
  
          dist = self.egg_distribution(egg_path)
          self.check_conflicts(dist)
          if not samefile(egg_path, destination):
              if os.path.isdir(destination) and not os.path.islink(destination):
                  dir_util.remove_tree(destination, dry_run=self.dry_run)
              elif os.path.exists(destination):
                  self.execute(os.unlink,(destination,),"Removing "+destination)
              uncache_zipdir(destination)
              if os.path.isdir(egg_path):
                  if egg_path.startswith(tmpdir):
                      f,m = shutil.move, "Moving"
                  else:
                      f,m = shutil.copytree, "Copying"
              elif self.should_unzip(dist):
                  self.mkpath(destination)
                  f,m = self.unpack_and_compile, "Extracting"
              elif egg_path.startswith(tmpdir):
                  f,m = shutil.move, "Moving"
              else:
                  f,m = shutil.copy2, "Copying"
  
              self.execute(f, (egg_path, destination),
                  (m+" %s to %s") %
                  (os.path.basename(egg_path),os.path.dirname(destination)))
  
          self.add_output(destination)
          return self.egg_distribution(destination)
  
      def install_exe(self, dist_filename, tmpdir):
          # See if it's valid, get data
          cfg = extract_wininst_cfg(dist_filename)
          if cfg is None:
              raise DistutilsError(
                  "%s is not a valid distutils Windows .exe" % dist_filename
              )
          # Create a dummy distribution object until we build the real distro
          dist = Distribution(None,
              project_name=cfg.get('metadata','name'),
              version=cfg.get('metadata','version'), platform="win32"
          )
  
          # Convert the .exe to an unpacked egg
          egg_path = dist.location = os.path.join(tmpdir, dist.egg_name()+'.egg')
          egg_tmp  = egg_path+'.tmp'
          egg_info = os.path.join(egg_tmp, 'EGG-INFO')
          pkg_inf = os.path.join(egg_info, 'PKG-INFO')
          ensure_directory(pkg_inf)   # make sure EGG-INFO dir exists
          dist._provider = PathMetadata(egg_tmp, egg_info)    # XXX
          self.exe_to_egg(dist_filename, egg_tmp)
  
          # Write EGG-INFO/PKG-INFO
          if not os.path.exists(pkg_inf):
              f = open(pkg_inf,'w')
              f.write('Metadata-Version: 1.0\n')
              for k,v in cfg.items('metadata'):
                  if k!='target_version':
                      f.write('%s: %s\n' % (k.replace('_','-').title(), v))
              f.close()
          script_dir = os.path.join(egg_info,'scripts')
          self.delete_blockers(   # delete entry-point scripts to avoid duping
              [os.path.join(script_dir,args[0]) for args in get_script_args(dist)]
          )
          # Build .egg file from tmpdir
          bdist_egg.make_zipfile(
              egg_path, egg_tmp, verbose=self.verbose, dry_run=self.dry_run
          )
          # install the .egg
          return self.install_egg(egg_path, tmpdir)
  
      def exe_to_egg(self, dist_filename, egg_tmp):
          """Extract a bdist_wininst to the directories an egg would use"""
          # Check for .pth file and set up prefix translations
          prefixes = get_exe_prefixes(dist_filename)
          to_compile = []
          native_libs = []
          top_level = {}
          def process(src,dst):
              s = src.lower()
              for old,new in prefixes:
                  if s.startswith(old):
                      src = new+src[len(old):]
                      parts = src.split('/')
                      dst = os.path.join(egg_tmp, *parts)
                      dl = dst.lower()
                      if dl.endswith('.pyd') or dl.endswith('.dll'):
                          parts[-1] = bdist_egg.strip_module(parts[-1])
                          top_level[os.path.splitext(parts[0])[0]] = 1
                          native_libs.append(src)
                      elif dl.endswith('.py') and old!='SCRIPTS/':
                          top_level[os.path.splitext(parts[0])[0]] = 1
                          to_compile.append(dst)
                      return dst
              if not src.endswith('.pth'):
                  log.warn("WARNING: can't process %s", src)
              return None
          # extract, tracking .pyd/.dll->native_libs and .py -> to_compile
          unpack_archive(dist_filename, egg_tmp, process)
          stubs = []
          for res in native_libs:
              if res.lower().endswith('.pyd'):    # create stubs for .pyd's
                  parts = res.split('/')
                  resource = parts[-1]
                  parts[-1] = bdist_egg.strip_module(parts[-1])+'.py'
                  pyfile = os.path.join(egg_tmp, *parts)
                  to_compile.append(pyfile); stubs.append(pyfile)
                  bdist_egg.write_stub(resource, pyfile)
          self.byte_compile(to_compile)   # compile .py's
          bdist_egg.write_safety_flag(os.path.join(egg_tmp,'EGG-INFO'),
              bdist_egg.analyze_egg(egg_tmp, stubs))  # write zip-safety flag
  
          for name in 'top_level','native_libs':
              if locals()[name]:
                  txt = os.path.join(egg_tmp, 'EGG-INFO', name+'.txt')
                  if not os.path.exists(txt):
                      open(txt,'w').write('\n'.join(locals()[name])+'\n')
  
      def check_conflicts(self, dist):
          """Verify that there are no conflicting "old-style" packages"""
  
          return dist     # XXX temporarily disable until new strategy is stable
          from imp import find_module, get_suffixes
          from glob import glob
  
          blockers = []
          names = dict.fromkeys(dist._get_metadata('top_level.txt')) # XXX private attr
  
          exts = {'.pyc':1, '.pyo':1}     # get_suffixes() might leave one out
          for ext,mode,typ in get_suffixes():
              exts[ext] = 1
  
          for path,files in expand_paths([self.install_dir]+self.all_site_dirs):
              for filename in files:
                  base,ext = os.path.splitext(filename)
                  if base in names:
                      if not ext:
                          # no extension, check for package
                          try:
                              f, filename, descr = find_module(base, [path])
                          except ImportError:
                              continue
                          else:
                              if f: f.close()
                              if filename not in blockers:
                                  blockers.append(filename)
                      elif ext in exts and base!='site':  # XXX ugh
                          blockers.append(os.path.join(path,filename))
          if blockers:
              self.found_conflicts(dist, blockers)
  
          return dist
  
      def found_conflicts(self, dist, blockers):
          if self.delete_conflicting:
              log.warn("Attempting to delete conflicting packages:")
              return self.delete_blockers(blockers)
  
          msg = """\
  -------------------------------------------------------------------------
  CONFLICT WARNING:
  
  The following modules or packages have the same names as modules or
  packages being installed, and will be *before* the installed packages in
  Python's search path.  You MUST remove all of the relevant files and
  directories before you will be able to use the package(s) you are
  installing:
  
     %s
  
  """ % '\n   '.join(blockers)
  
          if self.ignore_conflicts_at_my_risk:
              msg += """\
  (Note: you can run EasyInstall on '%s' with the
  --delete-conflicting option to attempt deletion of the above files
  and/or directories.)
  """ % dist.project_name
          else:
              msg += """\
  Note: you can attempt this installation again with EasyInstall, and use
  either the --delete-conflicting (-D) option or the
  --ignore-conflicts-at-my-risk option, to either delete the above files
  and directories, or to ignore the conflicts, respectively.  Note that if
  you ignore the conflicts, the installed package(s) may not work.
  """
          msg += """\
  -------------------------------------------------------------------------
  """
          sys.stderr.write(msg)
          sys.stderr.flush()
          if not self.ignore_conflicts_at_my_risk:
              raise DistutilsError("Installation aborted due to conflicts")
  
      def installation_report(self, req, dist, what="Installed"):
          """Helpful installation message for display to package users"""
          msg = "\n%(what)s %(eggloc)s%(extras)s"
          if self.multi_version and not self.no_report:
              msg += """
  
  Because this distribution was installed --multi-version, before you can
  import modules from this package in an application, you will need to
  'import pkg_resources' and then use a 'require()' call similar to one of
  these examples, in order to select the desired version:
  
      pkg_resources.require("%(name)s")  # latest installed version
      pkg_resources.require("%(name)s==%(version)s")  # this exact version
      pkg_resources.require("%(name)s>=%(version)s")  # this version or higher
  """
              if self.install_dir not in map(normalize_path,sys.path):
                  msg += """
  
  Note also that the installation directory must be on sys.path at runtime for
  this to work.  (e.g. by being the application's script directory, by being on
  PYTHONPATH, or by being added to sys.path by your code.)
  """
          eggloc = dist.location
          name = dist.project_name
          version = dist.version
          extras = '' # TODO: self.report_extras(req, dist)
          return msg % locals()
  
      def report_editable(self, spec, setup_script):
          dirname = os.path.dirname(setup_script)
          python = sys.executable
          return """\nExtracted editable version of %(spec)s to %(dirname)s
  
  If it uses setuptools in its setup script, you can activate it in
  "development" mode by going to that directory and running::
  
      %(python)s setup.py develop
  
  See the setuptools documentation for the "develop" command for more info.
  """ % locals()
  
      def run_setup(self, setup_script, setup_base, args):
          sys.modules.setdefault('distutils.command.bdist_egg', bdist_egg)
          sys.modules.setdefault('distutils.command.egg_info', egg_info)
  
          args = list(args)
          if self.verbose>2:
              v = 'v' * (self.verbose - 1)
              args.insert(0,'-'+v)
          elif self.verbose<2:
              args.insert(0,'-q')
          if self.dry_run:
              args.insert(0,'-n')
          log.info(
              "Running %s %s", setup_script[len(setup_base)+1:], ' '.join(args)
          )
          try:
              run_setup(setup_script, args)
          except SystemExit, v:
              raise DistutilsError("Setup script exited with %s" % (v.args[0],))
  
      def build_and_install(self, setup_script, setup_base):
          args = ['bdist_egg', '--dist-dir']
          dist_dir = tempfile.mkdtemp(
              prefix='egg-dist-tmp-', dir=os.path.dirname(setup_script)
          )
          try:
              args.append(dist_dir)
              self.run_setup(setup_script, setup_base, args)
              all_eggs = Environment([dist_dir])
              eggs = []
              for key in all_eggs:
                  for dist in all_eggs[key]:
                      eggs.append(self.install_egg(dist.location, setup_base))
              if not eggs and not self.dry_run:
                  log.warn("No eggs found in %s (setup script problem?)",
                      dist_dir)
              return eggs
          finally:
              rmtree(dist_dir)
              log.set_verbosity(self.verbose) # restore our log verbosity
  
      def update_pth(self,dist):
          if self.pth_file is None:
              return
  
          for d in self.pth_file[dist.key]:    # drop old entries
              if self.multi_version or d.location != dist.location:
                  log.info("Removing %s from easy-install.pth file", d)
                  self.pth_file.remove(d)
                  if d.location in self.shadow_path:
                      self.shadow_path.remove(d.location)
  
          if not self.multi_version:
              if dist.location in self.pth_file.paths:
                  log.info(
                      "%s is already the active version in easy-install.pth",
                      dist
                  )
              else:
                  log.info("Adding %s to easy-install.pth file", dist)
                  self.pth_file.add(dist) # add new entry
                  if dist.location not in self.shadow_path:
                      self.shadow_path.append(dist.location)
  
          if not self.dry_run:
  
              self.pth_file.save()
  
              if dist.key=='setuptools':
                  # Ensure that setuptools itself never becomes unavailable!
                  # XXX should this check for latest version?
                  filename = os.path.join(self.install_dir,'setuptools.pth')
                  if os.path.islink(filename): os.unlink(filename)
                  f = open(filename, 'wt')
                  f.write(self.pth_file.make_relative(dist.location)+'\n')
                  f.close()
  
      def unpack_progress(self, src, dst):
          # Progress filter for unpacking
          log.debug("Unpacking %s to %s", src, dst)
          return dst     # only unpack-and-compile skips files for dry run
  
      def unpack_and_compile(self, egg_path, destination):
          to_compile = []; to_chmod = []
  
          def pf(src,dst):
              if dst.endswith('.py') and not src.startswith('EGG-INFO/'):
                  to_compile.append(dst)
              elif dst.endswith('.dll') or dst.endswith('.so'):
                  to_chmod.append(dst)
              self.unpack_progress(src,dst)
              return not self.dry_run and dst or None
  
          unpack_archive(egg_path, destination, pf)
          self.byte_compile(to_compile)
          if not self.dry_run:
              for f in to_chmod:
                  mode = ((os.stat(f)[stat.ST_MODE]) | 0555) & 07755
                  chmod(f, mode)
  
      def byte_compile(self, to_compile):
          from distutils.util import byte_compile
          try:
              # try to make the byte compile messages quieter
              log.set_verbosity(self.verbose - 1)
  
              byte_compile(to_compile, optimize=0, force=1, dry_run=self.dry_run)
              if self.optimize:
                  byte_compile(
                      to_compile, optimize=self.optimize, force=1,
                      dry_run=self.dry_run
                  )
          finally:
              log.set_verbosity(self.verbose)     # restore original verbosity
  
  
  
  
  
  
  
  
  
      def no_default_version_msg(self):
          return """bad install directory or PYTHONPATH
  
  You are attempting to install a package to a directory that is not
  on PYTHONPATH and which Python does not read ".pth" files from.  The
  installation directory you specified (via --install-dir, --prefix, or
  the distutils default setting) was:
  
      %s
  
  and your PYTHONPATH environment variable currently contains:
  
      %r
  
  Here are some of your options for correcting the problem:
  
  * You can choose a different installation directory, i.e., one that is
    on PYTHONPATH or supports .pth files
  
  * You can add the installation directory to the PYTHONPATH environment
    variable.  (It must then also be on PYTHONPATH whenever you run
    Python and want to use the package(s) you are installing.)
  
  * You can set up the installation directory to support ".pth" files by
    using one of the approaches described here:
  
    http://peak.telecommunity.com/EasyInstall.html#custom-installation-locations
  
  Please make the appropriate changes for your system and try again.""" % (
          self.install_dir, os.environ.get('PYTHONPATH','')
      )
  
  
  
  
  
  
  
  
  
  
      def install_site_py(self):
          """Make sure there's a site.py in the target dir, if needed"""
  
          if self.sitepy_installed:
              return  # already did it, or don't need to
  
          sitepy = os.path.join(self.install_dir, "site.py")
          source = resource_string(Requirement.parse("setuptools"), "site.py")
          current = ""
  
          if os.path.exists(sitepy):
              log.debug("Checking existing site.py in %s", self.install_dir)
              current = open(sitepy,'rb').read()
              if not current.startswith('def __boot():'):
                  raise DistutilsError(
                      "%s is not a setuptools-generated site.py; please"
                      " remove it." % sitepy
                  )
  
          if current != source:
              log.info("Creating %s", sitepy)
              if not self.dry_run:
                  ensure_directory(sitepy)
                  f = open(sitepy,'wb')
                  f.write(source)
                  f.close()
              self.byte_compile([sitepy])
  
          self.sitepy_installed = True
  
  
  
  
  
  
  
  
  
  
  
  
      INSTALL_SCHEMES = dict(
          posix = dict(
              install_dir = '$base/lib/python$py_version_short/site-packages',
              script_dir  = '$base/bin',
          ),
      )
  
      DEFAULT_SCHEME = dict(
          install_dir = '$base/Lib/site-packages',
          script_dir  = '$base/Scripts',
      )
  
      def _expand(self, *attrs):
          config_vars = self.get_finalized_command('install').config_vars
  
          if self.prefix:
              # Set default install_dir/scripts from --prefix
              config_vars = config_vars.copy()
              config_vars['base'] = self.prefix
              scheme = self.INSTALL_SCHEMES.get(os.name,self.DEFAULT_SCHEME)
              for attr,val in scheme.items():
                  if getattr(self,attr,None) is None:
                      setattr(self,attr,val)
  
          from distutils.util import subst_vars
          for attr in attrs:
              val = getattr(self, attr)
              if val is not None:
                  val = subst_vars(val, config_vars)
                  if os.name == 'posix':
                      val = os.path.expanduser(val)
                  setattr(self, attr, val)
  
  
  
  
  
  
  
  
  
  def get_site_dirs():
      # return a list of 'site' dirs
      sitedirs = filter(None,os.environ.get('PYTHONPATH','').split(os.pathsep))
      prefixes = [sys.prefix]
      if sys.exec_prefix != sys.prefix:
          prefixes.append(sys.exec_prefix)
      for prefix in prefixes:
          if prefix:
              if sys.platform in ('os2emx', 'riscos'):
                  sitedirs.append(os.path.join(prefix, "Lib", "site-packages"))
              elif os.sep == '/':
                  sitedirs.extend([os.path.join(prefix,
                                           "lib",
                                           "python" + sys.version[:3],
                                           "site-packages"),
                              os.path.join(prefix, "lib", "site-python")])
              else:
                  sitedirs.extend(
                      [prefix, os.path.join(prefix, "lib", "site-packages")]
                  )
              if sys.platform == 'darwin':
                  # for framework builds *only* we add the standard Apple
                  # locations. Currently only per-user, but /Library and
                  # /Network/Library could be added too
                  if 'Python.framework' in prefix:
                      home = os.environ.get('HOME')
                      if home:
                          sitedirs.append(
                              os.path.join(home,
                                           'Library',
                                           'Python',
                                           sys.version[:3],
                                           'site-packages'))
      for plat_specific in (0,1):
          site_lib = get_python_lib(plat_specific)
          if site_lib not in sitedirs: sitedirs.append(site_lib)
  
      sitedirs = map(normalize_path, sitedirs)
      return sitedirs
  
  
  def expand_paths(inputs):
      """Yield sys.path directories that might contain "old-style" packages"""
  
      seen = {}
  
      for dirname in inputs:
          dirname = normalize_path(dirname)
          if dirname in seen:
              continue
  
          seen[dirname] = 1
          if not os.path.isdir(dirname):
              continue
  
          files = os.listdir(dirname)
          yield dirname, files
  
          for name in files:
              if not name.endswith('.pth'):
                  # We only care about the .pth files
                  continue
              if name in ('easy-install.pth','setuptools.pth'):
                  # Ignore .pth files that we control
                  continue
  
              # Read the .pth file
              f = open(os.path.join(dirname,name))
              lines = list(yield_lines(f))
              f.close()
  
              # Yield existing non-dupe, non-import directory lines from it
              for line in lines:
                  if not line.startswith("import"):
                      line = normalize_path(line.rstrip())
                      if line not in seen:
                          seen[line] = 1
                          if not os.path.isdir(line):
                              continue
                          yield line, os.listdir(line)
  
  
  def extract_wininst_cfg(dist_filename):
      """Extract configuration data from a bdist_wininst .exe
  
      Returns a ConfigParser.RawConfigParser, or None
      """
      f = open(dist_filename,'rb')
      try:
          endrec = zipfile._EndRecData(f)
          if endrec is None:
              return None
  
          prepended = (endrec[9] - endrec[5]) - endrec[6]
          if prepended < 12:  # no wininst data here
              return None
          f.seek(prepended-12)
  
          import struct, StringIO, ConfigParser
          tag, cfglen, bmlen = struct.unpack("<iii",f.read(12))
          if tag not in (0x1234567A, 0x1234567B):
              return None     # not a valid tag
  
          f.seek(prepended-(12+cfglen))
          cfg = ConfigParser.RawConfigParser({'version':'','target_version':''})
          try:
              cfg.readfp(StringIO.StringIO(f.read(cfglen).split(chr(0),1)[0]))
          except ConfigParser.Error:
              return None
          if not cfg.has_section('metadata') or not cfg.has_section('Setup'):
              return None
          return cfg
  
      finally:
          f.close()
  
  
  
  
  
  
  
  
  def get_exe_prefixes(exe_filename):
      """Get exe->egg path translations for a given .exe file"""
  
      prefixes = [
          ('PURELIB/', ''), ('PLATLIB/pywin32_system32', ''),
          ('PLATLIB/', ''),
          ('SCRIPTS/', 'EGG-INFO/scripts/')
      ]
      z = zipfile.ZipFile(exe_filename)
      try:
          for info in z.infolist():
              name = info.filename
              parts = name.split('/')
              if len(parts)==3 and parts[2]=='PKG-INFO':
                  if parts[1].endswith('.egg-info'):
                      prefixes.insert(0,('/'.join(parts[:2]), 'EGG-INFO/'))
                      break
              if len(parts)!=2 or not name.endswith('.pth'):
                  continue
              if name.endswith('-nspkg.pth'):
                  continue
              if parts[0].upper() in ('PURELIB','PLATLIB'):
                  for pth in yield_lines(z.read(name)):
                      pth = pth.strip().replace('\\','/')
                      if not pth.startswith('import'):
                          prefixes.append((('%s/%s/' % (parts[0],pth)), ''))
      finally:
          z.close()
      prefixes = [(x.lower(),y) for x, y in prefixes]
      prefixes.sort(); prefixes.reverse()
      return prefixes
  
  
  def parse_requirement_arg(spec):
      try:
          return Requirement.parse(spec)
      except ValueError:
          raise DistutilsError(
              "Not a URL, existing file, or requirement spec: %r" % (spec,)
          )
  
  class PthDistributions(Environment):
      """A .pth file with Distribution paths in it"""
  
      dirty = False
  
      def __init__(self, filename, sitedirs=()):
          self.filename = filename; self.sitedirs=map(normalize_path, sitedirs)
          self.basedir = normalize_path(os.path.dirname(self.filename))
          self._load(); Environment.__init__(self, [], None, None)
          for path in yield_lines(self.paths):
              map(self.add, find_distributions(path, True))
  
      def _load(self):
          self.paths = []
          saw_import = False
          seen = dict.fromkeys(self.sitedirs)
          if os.path.isfile(self.filename):
              for line in open(self.filename,'rt'):
                  if line.startswith('import'):
                      saw_import = True
                      continue
                  path = line.rstrip()
                  self.paths.append(path)
                  if not path.strip() or path.strip().startswith('#'):
                      continue
                  # skip non-existent paths, in case somebody deleted a package
                  # manually, and duplicate paths as well
                  path = self.paths[-1] = normalize_path(
                      os.path.join(self.basedir,path)
                  )
                  if not os.path.exists(path) or path in seen:
                      self.paths.pop()    # skip it
                      self.dirty = True   # we cleaned up, so we're dirty now :)
                      continue
                  seen[path] = 1
  
          if self.paths and not saw_import:
              self.dirty = True   # ensure anything we touch has import wrappers
          while self.paths and not self.paths[-1].strip():
              self.paths.pop()
  
      def save(self):
          """Write changed .pth file back to disk"""
          if not self.dirty:
              return
  
          data = '\n'.join(map(self.make_relative,self.paths))
          if data:
              log.debug("Saving %s", self.filename)
              data = (
                  "import sys; sys.__plen = len(sys.path)\n"
                  "%s\n"
                  "import sys; new=sys.path[sys.__plen:];"
                  " del sys.path[sys.__plen:];"
                  " p=getattr(sys,'__egginsert',0); sys.path[p:p]=new;"
                  " sys.__egginsert = p+len(new)\n"
              ) % data
  
              if os.path.islink(self.filename):
                  os.unlink(self.filename)
              f = open(self.filename,'wb')
              f.write(data); f.close()
  
          elif os.path.exists(self.filename):
              log.debug("Deleting empty %s", self.filename)
              os.unlink(self.filename)
  
          self.dirty = False
  
      def add(self,dist):
          """Add `dist` to the distribution map"""
          if dist.location not in self.paths and dist.location not in self.sitedirs:
              self.paths.append(dist.location); self.dirty = True
          Environment.add(self,dist)
  
      def remove(self,dist):
          """Remove `dist` from the distribution map"""
          while dist.location in self.paths:
              self.paths.remove(dist.location); self.dirty = True
          Environment.remove(self,dist)
  
  
      def make_relative(self,path):
          npath, last = os.path.split(normalize_path(path))
          baselen = len(self.basedir)
          parts = [last]
          sep = os.altsep=='/' and '/' or os.sep
          while len(npath)>=baselen:
              if npath==self.basedir:
                  parts.append(os.curdir)
                  parts.reverse()
                  return sep.join(parts)
              npath, last = os.path.split(npath)
              parts.append(last)
          else:
              return path
  
  def get_script_header(script_text, executable=sys_executable, wininst=False):
      """Create a #! line, getting options (if any) from script_text"""
      from distutils.command.build_scripts import first_line_re
      first = (script_text+'\n').splitlines()[0]
      match = first_line_re.match(first)
      options = ''
      if match:
          options = match.group(1) or ''
          if options: options = ' '+options
      if wininst:
          executable = "python.exe"
      else:
          executable = nt_quote_arg(executable)
      hdr = "#!%(executable)s%(options)s\n" % locals()
      if unicode(hdr,'ascii','ignore').encode('ascii') != hdr:
          # Non-ascii path to sys.executable, use -x to prevent warnings
          if options:
              if options.strip().startswith('-'):
                  options = ' -x'+options.strip()[1:]
              # else: punt, we can't do it, let the warning happen anyway
          else:
              options = ' -x'
      executable = fix_jython_executable(executable, options)
      hdr = "#!%(executable)s%(options)s\n" % locals()
      return hdr
  
  def auto_chmod(func, arg, exc):
      if func is os.remove and os.name=='nt':
          chmod(arg, stat.S_IWRITE)
          return func(arg)
      exc = sys.exc_info()
      raise exc[0], (exc[1][0], exc[1][1] + (" %s %s" % (func,arg)))
  
  def uncache_zipdir(path):
      """Ensure that the importer caches dont have stale info for `path`"""
      from zipimport import _zip_directory_cache as zdc
      _uncache(path, zdc)
      _uncache(path, sys.path_importer_cache)
  
  def _uncache(path, cache):
      if path in cache:
          del cache[path]
      else:
          path = normalize_path(path)
          for p in cache:
              if normalize_path(p)==path:
                  del cache[p]
                  return
  
  def is_python(text, filename='<string>'):
      "Is this string a valid Python script?"
      try:
          compile(text, filename, 'exec')
      except (SyntaxError, TypeError):
          return False
      else:
          return True
  
  def is_sh(executable):
      """Determine if the specified executable is a .sh (contains a #! line)"""
      try:
          fp = open(executable)
          magic = fp.read(2)
          fp.close()
      except (OSError,IOError): return executable
      return magic == '#!'
  
  def nt_quote_arg(arg):
      """Quote a command line argument according to Windows parsing rules"""
  
      result = []
      needquote = False
      nb = 0
  
      needquote = (" " in arg) or ("\t" in arg)
      if needquote:
          result.append('"')
  
      for c in arg:
          if c == '\\':
              nb += 1
          elif c == '"':
              # double preceding backslashes, then add a \"
              result.append('\\' * (nb*2) + '\\"')
              nb = 0
          else:
              if nb:
                  result.append('\\' * nb)
                  nb = 0
              result.append(c)
  
      if nb:
          result.append('\\' * nb)
  
      if needquote:
          result.append('\\' * nb)    # double the trailing backslashes
          result.append('"')
  
      return ''.join(result)
  
  
  
  
  
  
  
  
  
  def is_python_script(script_text, filename):
      """Is this text, as a whole, a Python script? (as opposed to shell/bat/etc.
      """
      if filename.endswith('.py') or filename.endswith('.pyw'):
          return True     # extension says it's Python
      if is_python(script_text, filename):
          return True     # it's syntactically valid Python
      if script_text.startswith('#!'):
          # It begins with a '#!' line, so check if 'python' is in it somewhere
          return 'python' in script_text.splitlines()[0].lower()
  
      return False    # Not any Python I can recognize
  
  try:
      from os import chmod as _chmod
  except ImportError:
      # Jython compatibility
      def _chmod(*args): pass
  
  def chmod(path, mode):
      log.debug("changing mode of %s to %o", path, mode)
      try:
          _chmod(path, mode)
      except os.error, e:
          log.debug("chmod failed: %s", e)
  
  def fix_jython_executable(executable, options):
      if sys.platform.startswith('java') and is_sh(executable):
          # Workaround Jython's sys.executable being a .sh (an invalid
          # shebang line interpreter)
          if options:
              # Can't apply the workaround, leave it broken
              log.warn("WARNING: Unable to adapt shebang line for Jython,"
                               " the following script is NOT executable\n"
                       "         see http://bugs.jython.org/issue1112 for"
                               " more information.")
          else:
              return '/usr/bin/env %s' % executable
      return executable
  
  
  def get_script_args(dist, executable=sys_executable, wininst=False):
      """Yield write_script() argument tuples for a distribution's entrypoints"""
      spec = str(dist.as_requirement())
      header = get_script_header("", executable, wininst)
      for group in 'console_scripts', 'gui_scripts':
          for name,ep in dist.get_entry_map(group).items():
              script_text = (
                  "# EASY-INSTALL-ENTRY-SCRIPT: %(spec)r,%(group)r,%(name)r\n"
                  "__requires__ = %(spec)r\n"
                  "import sys\n"
                  "from pkg_resources import load_entry_point\n"
                  "\n"
                  "sys.exit(\n"
                  "   load_entry_point(%(spec)r, %(group)r, %(name)r)()\n"
                  ")\n"
              ) % locals()
              if sys.platform=='win32' or wininst:
                  # On Windows/wininst, add a .py extension and an .exe launcher
                  if group=='gui_scripts':
                      ext, launcher = '-script.pyw', 'gui.exe'
                      old = ['.pyw']
                      new_header = re.sub('(?i)python.exe','pythonw.exe',header)
                  else:
                      ext, launcher = '-script.py', 'cli.exe'
                      old = ['.py','.pyc','.pyo']
                      new_header = re.sub('(?i)pythonw.exe','python.exe',header)
  
                  if os.path.exists(new_header[2:-1]) or sys.platform!='win32':
                      hdr = new_header
                  else:
                      hdr = header
                  yield (name+ext, hdr+script_text, 't', [name+x for x in old])
                  yield (
                      name+'.exe', resource_string('setuptools', launcher),
                      'b') # write in binary mode
                  yield (name+'.exe.manifest', _launcher_manifest % (name,), 't')
              else:
                  # On other platforms, we assume the right thing to do is to
                  # just write the stub with no extension.
                  yield (name, header+script_text)
  
  _launcher_manifest = """
  <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
  <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
   <assemblyIdentity version="1.0.0.0"
   processorArchitecture="X86"
   name="%s.exe"
   type="win32"/>
  
   <!-- Identify the application security requirements. -->
   <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
   <security>
   <requestedPrivileges>
   <requestedExecutionLevel level="asInvoker" uiAccess="false"/>
   </requestedPrivileges>
   </security>
   </trustInfo>
  </assembly>"""
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  def rmtree(path, ignore_errors=False, onerror=auto_chmod):
      """Recursively delete a directory tree.
  
      This code is taken from the Python 2.4 version of 'shutil', because
      the 2.3 version doesn't really work right.
      """
      if ignore_errors:
          def onerror(*args):
              pass
      elif onerror is None:
          def onerror(*args):
              raise
      names = []
      try:
          names = os.listdir(path)
      except os.error, err:
          onerror(os.listdir, path, sys.exc_info())
      for name in names:
          fullname = os.path.join(path, name)
          try:
              mode = os.lstat(fullname).st_mode
          except os.error:
              mode = 0
          if stat.S_ISDIR(mode):
              rmtree(fullname, ignore_errors, onerror)
          else:
              try:
                  os.remove(fullname)
              except os.error, err:
                  onerror(os.remove, fullname, sys.exc_info())
      try:
          os.rmdir(path)
      except os.error:
          onerror(os.rmdir, path, sys.exc_info())
  
  def bootstrap():
      # This function is called when setuptools*.egg is run using /bin/sh
      import setuptools; argv0 = os.path.dirname(setuptools.__path__[0])
      sys.argv[0] = argv0; sys.argv.append(argv0); main()
  
  
  def main(argv=None, **kw):
      from setuptools import setup
      from setuptools.dist import Distribution
      import distutils.core
  
      USAGE = """\
  usage: %(script)s [options] requirement_or_url ...
     or: %(script)s --help
  """
  
      def gen_usage (script_name):
          script = os.path.basename(script_name)
          return USAGE % vars()
  
      def with_ei_usage(f):
          old_gen_usage = distutils.core.gen_usage
          try:
              distutils.core.gen_usage = gen_usage
              return f()
          finally:
              distutils.core.gen_usage = old_gen_usage
  
      class DistributionWithoutHelpCommands(Distribution):
          common_usage = ""
          def _show_help(self,*args,**kw):
              with_ei_usage(lambda: Distribution._show_help(self,*args,**kw))
  
      if argv is None:
          argv = sys.argv[1:]
  
      with_ei_usage(lambda:
          setup(
              script_args = ['-q','easy_install', '-v']+argv,
              script_name = sys.argv[0] or 'easy_install',
              distclass=DistributionWithoutHelpCommands, **kw
          )
      )
  
  
  
  
  