home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2007 September / PCWSEP07.iso / Software / Linux / Linux Mint 3.0 Light / LinuxMint-3.0-Light.iso / casper / filesystem.squashfs / usr / share / pycentral-data / pyversions.py next >
Encoding:
Python Source  |  2007-04-10  |  13.4 KB  |  365 lines

  1. #! /usr/bin/python
  2.  
  3. import os, re, sys
  4. try:
  5.     SetType = set
  6. except NameError:
  7.     import sets
  8.     SetType = sets.Set
  9.     set = sets.Set
  10.  
  11. _defaults = None
  12. def read_default(name=None):
  13.     global _defaults
  14.     from ConfigParser import SafeConfigParser, NoOptionError
  15.     if not _defaults:
  16.         if os.path.exists('/usr/share/python/debian_defaults'):
  17.             config = SafeConfigParser()
  18.             config.readfp(file('/usr/share/python/debian_defaults'))
  19.             _defaults = config
  20.     if _defaults and name:
  21.         try:
  22.             value = _defaults.get('DEFAULT', name)
  23.         except NoOptionError:
  24.             raise ValueError
  25.         return value
  26.     return None
  27.  
  28. def parse_versions(vstring):
  29.     import operator
  30.     operators = { None: operator.eq, '=': operator.eq,
  31.                   '>=': operator.ge, '<=': operator.le,
  32.                   '<<': operator.lt
  33.                   }
  34.     vinfo = {}
  35.     exact_versions = set([])
  36.     version_range = set(supported_versions(version_only=True))
  37.     relop_seen = False
  38.     for field in vstring.split(','):
  39.         field = field.strip()
  40.         if field == 'all':
  41.             vinfo['all'] = 'all'
  42.             continue
  43.         if field in ('current', 'current_ext'):
  44.             vinfo['current'] = field
  45.             continue
  46.         vinfo.setdefault('versions', set())
  47.         ve = re.compile('(>=|<=|<<|=)? *(\d\.\d)$')
  48.         m = ve.match(field)
  49.         try:
  50.             op, v = m.group(1), m.group(2)
  51.             if op in (None, '='):
  52.                 exact_versions.add(v)
  53.             else:
  54.                 relop_seen = True
  55.                 filtop = operators[op]
  56.                 version_range = [av for av in version_range if filtop(av ,v)]
  57.         except Exception:
  58.             raise ValueError, 'error parsing Python-Version attribute'
  59.     if 'versions' in vinfo:
  60.         vinfo['versions'] = exact_versions
  61.         if relop_seen:
  62.             vinfo['versions'] = exact_versions.union(version_range)
  63.     return vinfo
  64.  
  65. _old_versions = None
  66. def old_versions(version_only=False):
  67.     global _old_versions
  68.     if not _old_versions:
  69.         try:
  70.             value = read_default('old-versions')
  71.             _old_versions = [s.strip() for s in value.split(',')]
  72.         except ValueError:
  73.             _old_versions = []
  74.     if version_only:
  75.         return [v[6:] for v in _old_versions]
  76.     else:
  77.         return _old_versions
  78.  
  79. _unsupported_versions = None
  80. def unsupported_versions(version_only=False):
  81.     global _unsupported_versions
  82.     if not _unsupported_versions:
  83.         try:
  84.             value = read_default('unsupported-versions')
  85.             _unsupported_versions = [s.strip() for s in value.split(',')]
  86.         except ValueError:
  87.             _unsupported_versions = []
  88.     if version_only:
  89.         return [v[6:] for v in _unsupported_versions]
  90.     else:
  91.         return _unsupported_versions
  92.  
  93. _supported_versions = None
  94. def supported_versions(version_only=False):
  95.     global _supported_versions
  96.     if not _supported_versions:
  97.         try:
  98.             value = read_default('supported-versions')
  99.             _supported_versions = [s.strip() for s in value.split(',')]
  100.         except ValueError:
  101.             cmd = ['/usr/bin/apt-cache', '--no-all-versions',
  102.                    'show', 'python-all']
  103.             try:
  104.                 import subprocess
  105.                 p = subprocess.Popen(cmd, bufsize=1,
  106.                                      shell=False, stdout=subprocess.PIPE)
  107.                 fd = p.stdout
  108.             except ImportError:
  109.                 fd = os.popen(' '.join(cmd))
  110.             depends = None
  111.             for line in fd:
  112.                 if line.startswith('Depends:'):
  113.                     depends = line.split(':', 1)[1].strip().split(',')
  114.             fd.close()
  115.             depends = [re.sub(r'\s*(\S+)[ (]?.*', r'\1', s) for s in depends]
  116.             _supported_versions = depends
  117.     if version_only:
  118.         return [v[6:] for v in _supported_versions]
  119.     else:
  120.         return _supported_versions
  121.  
  122. _default_version = None
  123. def default_version(version_only=False):
  124.     global _default_version
  125.     if not _default_version:
  126.         _default_version = link = os.readlink('/usr/bin/python')
  127.     # consistency check
  128.     debian_default = read_default('default-version')
  129.     if not _default_version in (debian_default, os.path.join('/usr/bin', debian_default)):
  130.         raise ValueError, "the symlink /usr/bin/python does not point to the python default version. It must be reset to point to %s" % debian_default
  131.     _default_version = debian_default
  132.     if version_only:
  133.         return _default_version[6:]
  134.     else:
  135.         return _default_version
  136.  
  137. def requested_versions(vstring, version_only=False):
  138.     versions = None
  139.     vinfo = parse_versions(vstring)
  140.     supported = supported_versions(version_only=True)
  141.     if len(vinfo) == 1:
  142.         if 'all' in vinfo:
  143.             versions = supported
  144.         elif 'current' in vinfo:
  145.             versions = [default_version(version_only=True)]
  146.         else:
  147.             versions = vinfo['versions'].intersection(supported)
  148.     elif 'all' in vinfo and 'current' in vinfo:
  149.         raise ValueError, "both `current' and `all' in version string"
  150.     elif 'all' in vinfo:
  151.         versions = versions = vinfo['versions'].intersection(supported)
  152.     elif 'current' in vinfo:
  153.         current = default_version(version_only=True)
  154.         if not current in vinfo['versions']:
  155.             raise ValueError, "`current' version not in supported versions"
  156.         versions = [current]
  157.     else:
  158.         raise ValueError, 'error in version string'
  159.     if not versions:
  160.         raise ValueError, 'empty set of versions'
  161.     if version_only:
  162.         return versions
  163.     else:
  164.         return ['python%s' % v for v in versions]
  165.  
  166. # This function is used by python-central to decide which installed
  167. # runtimes must be supported. It's not nice, but it's designed to mimic
  168. # closely requested_versions in an attempt to avoid introducing bugs this
  169. # late in the release cycle. Some cleanup is in order post-etch though.
  170. def requested_versions_for_runtime(vstring, version_only=False):
  171.     versions = None
  172.     vinfo = parse_versions(vstring)
  173.     old = old_versions(version_only=True)
  174.     unsupported = unsupported_versions(version_only=True)
  175.     supported = supported_versions(version_only=True)
  176.     # You might want to add unsupported versions too... later.
  177.     supported.extend(old)
  178.     if len(vinfo) == 1:
  179.         if 'all' in vinfo:
  180.             versions = supported
  181.         elif 'current' in vinfo:
  182.             versions = [default_version(version_only=True)]
  183.         else:
  184.             versions = vinfo['versions'].intersection(supported)
  185.     elif 'all' in vinfo and 'current' in vinfo:
  186.         raise ValueError, "both `current' and `all' in version string"
  187.     elif 'all' in vinfo:
  188.         versions = versions = vinfo['versions'].intersection(supported)
  189.     elif 'current' in vinfo:
  190.         current = default_version(version_only=True)
  191.         if not current in vinfo['versions']:
  192.             raise ValueError, "`current' version not in supported versions"
  193.         versions = [current]
  194.     else:
  195.         raise ValueError, 'error in version string'
  196.     if not versions:
  197.         raise ValueError, 'empty set of versions'
  198.     if version_only:
  199.         return versions
  200.     else:
  201.         return ['python%s' % v for v in versions]
  202.  
  203. def installed_versions(version_only=False):
  204.     import glob
  205.     supported = supported_versions()
  206.     versions = [os.path.basename(s)
  207.                 for s in glob.glob('/usr/bin/python[0-9].[0-9]')
  208.                 if os.path.basename(s) in supported]
  209.     versions.sort()
  210.     if version_only:
  211.         return [v[6:] for v in versions]
  212.     else:
  213.         return versions
  214.  
  215. class ControlFileValueError(ValueError):
  216.     pass
  217. class MissingVersionValueError(ValueError):
  218.     pass
  219.  
  220. def extract_pyversion_attribute(fn, pkg):
  221.     """read the debian/control file, extract the XS-Python-Version
  222.     field; check that XB-Python-Version exists for the package."""
  223.  
  224.     version = None
  225.     sversion = None
  226.     section = None
  227.     for line in file(fn):
  228.         line = line.strip()
  229.         if line == '':
  230.             if pkg == 'Source':
  231.                 break
  232.             section = None
  233.         elif line.startswith('Source:'):
  234.             section = 'Source'
  235.         elif line.startswith('Package: ' + pkg):
  236.             section = pkg
  237.         elif line.startswith('XS-Python-Version:'):
  238.             if section != 'Source':
  239.                 raise ValueError, \
  240.                       'attribute XS-Python-Version not in Source section'
  241.             sversion = line.split(':', 1)[1].strip()
  242.         elif line.startswith('XB-Python-Version:'):
  243.             if section == pkg:
  244.                 version = line.split(':', 1)[1].strip()
  245.     if section == None:
  246.         raise ControlFileValueError, 'not a control file'
  247.     if pkg == 'Source':
  248.         if sversion == None:
  249.             raise MissingVersionValueError, \
  250.                   'missing XS-Python-Version in control file'
  251.         return sversion
  252.     if version == None:
  253.         raise MissingVersionValueError, \
  254.               'missing XB-Python-Version for package `%s' % pkg
  255.     return version
  256.  
  257. # compatibility functions to parse debian/pyversions
  258.  
  259. def version_cmp(ver1,ver2):
  260.     v1=[int(i) for i in ver1.split('.')]
  261.     v2=[int(i) for i in ver2.split('.')]
  262.     return cmp(v1,v2)
  263.  
  264. def requested_versions_bis(vstring, version_only=False):
  265.     versions = []
  266.     py_supported_short = supported_versions(version_only=True)
  267.     for item in vstring.split(','):
  268.         v=item.split('-')
  269.         if len(v)>1:
  270.             if not v[0]:
  271.                 v[0] = py_supported_short[0]
  272.             if not v[1]:
  273.                 v[1] = py_supported_short[-1]
  274.             for ver in py_supported_short:
  275.                 try:
  276.                     if version_cmp(ver,v[0]) >= 0 \
  277.                            and version_cmp(ver,v[1]) <= 0:
  278.                         versions.append(ver)
  279.                 except ValueError:
  280.                     pass
  281.         else:
  282.             if v[0] in py_supported_short:
  283.                 versions.append(v[0])
  284.     versions.sort(version_cmp)
  285.     if not versions:
  286.         raise ValueError, 'empty set of versions'
  287.     if not version_only:
  288.         versions=['python'+i for i in versions]
  289.     return versions
  290.  
  291. def extract_pyversion_attribute_bis(fn):
  292.     vstring = file(fn).readline().rstrip('\n')
  293.     return vstring
  294.  
  295. def main():
  296.     from optparse import OptionParser
  297.     usage = '[-v] [-h] [-d|--default] [-s|--supported] [-i|--installed] [-r|--requested <version string>|<control file>]'
  298.     parser = OptionParser(usage=usage)
  299.     parser.add_option('-d', '--default',
  300.                       help='print the default python version',
  301.                       action='store_true', dest='default')
  302.     parser.add_option('-s', '--supported',
  303.                       help='print the supported python versions',
  304.                       action='store_true', dest='supported')
  305.     parser.add_option('-r', '--requested',
  306.                       help='print the python versions requested by a build; the argument is either the name of a control file or the value of the XS-Python-Version attribute',
  307.                       action='store_true', dest='requested')
  308.     parser.add_option('-i', '--installed',
  309.                       help='print the installed supported python versions',
  310.                       action='store_true', dest='installed')
  311.     parser.add_option('-v', '--version',
  312.                       help='print just the version number(s)',
  313.                       default=False, action='store_true', dest='version_only')
  314.     opts, args = parser.parse_args()
  315.     program = os.path.basename(sys.argv[0])
  316.  
  317.     if opts.default and len(args) == 0:
  318.         try:
  319.             print default_version(opts.version_only)
  320.         except ValueError, msg:
  321.             print "%s:" % program, msg
  322.             sys.exit(1)
  323.     elif opts.supported and len(args) == 0:
  324.         print ' '.join(supported_versions(opts.version_only))
  325.     elif opts.installed and len(args) == 0:
  326.         print ' '.join(installed_versions(opts.version_only))
  327.     elif opts.requested and len(args) <= 1:
  328.         if len(args) == 0:
  329.             versions = 'debian/control'
  330.         else:
  331.             versions = args[0]
  332.         try:
  333.             if os.path.isfile(versions):
  334.                 fn = versions
  335.                 try:
  336.                     vstring = extract_pyversion_attribute(fn, 'Source')
  337.                     vs = requested_versions(vstring, opts.version_only)
  338.                 except ControlFileValueError:
  339.                     sys.stderr.write("%s: not a control file: %s, " \
  340.                                      % (program, fn))
  341.                     sys.exit(1)
  342.                 except MissingVersionValueError:
  343.                     fn = os.path.join(os.path.dirname(fn), 'pyversions')
  344.                     sys.stderr.write("%s: missing XS-Python-Version in control file, fall back to %s\n" \
  345.                                      % (program, fn))
  346.                     try:
  347.                         vstring = extract_pyversion_attribute_bis(fn)
  348.                         vs = requested_versions_bis(vstring, opts.version_only)
  349.                     except IOError:
  350.                         sys.stderr.write("%s: missing debian/pyversions file, fall back to supported versions\n" \
  351.                                          % program)
  352.                         vs = supported_versions(opts.version_only)
  353.             else:
  354.                 vs = requested_versions(versions, opts.version_only)
  355.             print ' '.join(vs)
  356.         except ValueError, msg:
  357.             sys.stderr.write("%s: %s\n" % (program, msg))
  358.             sys.exit(1)
  359.     else:
  360.         sys.stderr.write("usage: %s %s\n" % (program, usage))
  361.         sys.exit(1)
  362.  
  363. if __name__ == '__main__':
  364.     main()
  365.