text: from distutils.command.sdist import sdist as _sdist
  from distutils.util import convert_path
  from distutils import log
  import os, re, sys, pkg_resources
  from glob import glob
  
  entities = [
      ("&lt;","<"), ("&gt;", ">"), ("&quot;", '"'), ("&apos;", "'"),
      ("&amp;", "&")
  ]
  
  def unescape(data):
      for old,new in entities:
          data = data.replace(old,new)
      return data
  
  def re_finder(pattern, postproc=None):
      def find(dirname, filename):
          f = open(filename,'rU')
          data = f.read()
          f.close()
          for match in pattern.finditer(data):
              path = match.group(1)
              if postproc:
                  path = postproc(path)
              yield joinpath(dirname,path)
      return find
  
  def joinpath(prefix,suffix):
      if not prefix:
          return suffix
      return os.path.join(prefix,suffix)
  
  
  
  
  
  
  
  
  
  
  def walk_revctrl(dirname=''):
      """Find all files under revision control"""
      for ep in pkg_resources.iter_entry_points('setuptools.file_finders'):
          for item in ep.load()(dirname):
              yield item
  
  def _default_revctrl(dirname=''):
      for path, finder in finders:
          path = joinpath(dirname,path)
          if os.path.isfile(path):
              for path in finder(dirname,path):
                  if os.path.isfile(path):
                      yield path
                  elif os.path.isdir(path):
                      for item in _default_revctrl(path):
                          yield item
  
  def externals_finder(dirname, filename):
      """Find any 'svn:externals' directories"""
      found = False
      f = open(filename,'rt')
      for line in iter(f.readline, ''):    # can't use direct iter!
          parts = line.split()
          if len(parts)==2:
              kind,length = parts
              data = f.read(int(length))
              if kind=='K' and data=='svn:externals':
                  found = True
              elif kind=='V' and found:
                  f.close()
                  break
      else:
          f.close()
          return
  
      for line in data.splitlines():
          parts = line.split()
          if parts:
              yield joinpath(dirname, parts[0])
  
  
  entries_pattern = re.compile(r'name="([^"]+)"(?![^>]+deleted="true")', re.I)
  
  def entries_finder(dirname, filename):
      f = open(filename,'rU')
      data = f.read()
      f.close()
      if data.startswith('10') or data.startswith('9') or data.startswith('8'):
          for record in map(str.splitlines, data.split('\n\x0c\n')[1:]):
              # subversion 1.6/1.5/1.4
              if not record or len(record)>=6 and record[5]=="delete":
                  continue    # skip deleted
              yield joinpath(dirname, record[0])
      elif data.startswith('<?xml'):
          for match in entries_pattern.finditer(data):
              yield joinpath(dirname,unescape(match.group(1)))
      else:
          log.warn("unrecognized .svn/entries format in %s", dirname)
  
  
  finders = [
      (convert_path('CVS/Entries'),
          re_finder(re.compile(r"^\w?/([^/]+)/", re.M))),
      (convert_path('.svn/entries'), entries_finder),
      (convert_path('.svn/dir-props'), externals_finder),
      (convert_path('.svn/dir-prop-base'), externals_finder),  # svn 1.4
  ]
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  class sdist(_sdist):
      """Smart sdist that finds anything supported by revision control"""
  
      user_options = [
          ('formats=', None,
           "formats for source distribution (comma-separated list)"),
          ('keep-temp', 'k',
           "keep the distribution tree around after creating " +
           "archive file(s)"),
          ('dist-dir=', 'd',
           "directory to put the source distribution archive(s) in "
           "[default: dist]"),
          ]
  
      negative_opt = {}
  
      def run(self):
          self.run_command('egg_info')
          ei_cmd = self.get_finalized_command('egg_info')
          self.filelist = ei_cmd.filelist
          self.filelist.append(os.path.join(ei_cmd.egg_info,'SOURCES.txt'))
          self.check_readme()
          self.check_metadata()
          self.make_distribution()
  
          dist_files = getattr(self.distribution,'dist_files',[])
          for file in self.archive_files:
              data = ('sdist', '', file)
              if data not in dist_files:
                  dist_files.append(data)
  
      def add_defaults(self):
          standards = [('README', 'README.txt'),
                       self.distribution.script_name]
          for fn in standards:
              if isinstance(fn, tuple):
                  alts = fn
                  got_it = 0
                  for fn in alts:
                      if os.path.exists(fn):
                          got_it = 1
                          self.filelist.append(fn)
                          break
  
                  if not got_it:
                      self.warn("standard file not found: should have one of " +
                                ', '.join(alts))
              else:
                  if os.path.exists(fn):
                      self.filelist.append(fn)
                  else:
                      self.warn("standard file '%s' not found" % fn)
  
          optional = ['test/test*.py', 'setup.cfg']
          for pattern in optional:
              files = filter(os.path.isfile, glob(pattern))
              if files:
                  self.filelist.extend(files)
  
          # getting python files
          if self.distribution.has_pure_modules():
              build_py = self.get_finalized_command('build_py')
              self.filelist.extend(build_py.get_source_files())
  
          if self.distribution.has_ext_modules():
              build_ext = self.get_finalized_command('build_ext')
              self.filelist.extend(build_ext.get_source_files())
  
          if self.distribution.has_c_libraries():
              build_clib = self.get_finalized_command('build_clib')
              self.filelist.extend(build_clib.get_source_files())
  
          if self.distribution.has_scripts():
              build_scripts = self.get_finalized_command('build_scripts')
              self.filelist.extend(build_scripts.get_source_files())
  
      def read_template(self):
          try:
              _sdist.read_template(self)
          except:
              # grody hack to close the template file (MANIFEST.in)
              # this prevents easy_install's attempt at deleting the file from
              # dying and thus masking the real error
              sys.exc_info()[2].tb_next.tb_frame.f_locals['template'].close()
              raise
  
      def check_readme(self):
          alts = ("README", "README.txt")
          for f in alts:
              if os.path.exists(f):
                  return
          else:
              self.warn(
                  "standard file not found: should have one of " +', '.join(alts)
              )
  
  
      def make_release_tree(self, base_dir, files):
          _sdist.make_release_tree(self, base_dir, files)
  
          # Save any egg_info command line options used to create this sdist
          dest = os.path.join(base_dir, 'setup.cfg')
          if hasattr(os,'link') and os.path.exists(dest):
              # unlink and re-copy, since it might be hard-linked, and
              # we don't want to change the source version
              os.unlink(dest)
              self.copy_file('setup.cfg', dest)
  
          self.get_finalized_command('egg_info').save_version_info(dest)
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  #
  