home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / distutils / versionpredicate.pyc (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2008-10-29  |  5.5 KB  |  160 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''Module for parsing and testing package version predicate strings.
  5. '''
  6. import re
  7. import distutils.version as distutils
  8. import operator
  9. re_validPackage = re.compile('(?i)^\\s*([a-z_]\\w*(?:\\.[a-z_]\\w*)*)(.*)')
  10. re_paren = re.compile('^\\s*\\((.*)\\)\\s*$')
  11. re_splitComparison = re.compile('^\\s*(<=|>=|<|>|!=|==)\\s*([^\\s,]+)\\s*$')
  12.  
  13. def splitUp(pred):
  14.     '''Parse a single version comparison.
  15.  
  16.     Return (comparison string, StrictVersion)
  17.     '''
  18.     res = re_splitComparison.match(pred)
  19.     if not res:
  20.         raise ValueError('bad package restriction syntax: %r' % pred)
  21.     
  22.     (comp, verStr) = res.groups()
  23.     return (comp, distutils.version.StrictVersion(verStr))
  24.  
  25. compmap = {
  26.     '<': operator.lt,
  27.     '<=': operator.le,
  28.     '==': operator.eq,
  29.     '>': operator.gt,
  30.     '>=': operator.ge,
  31.     '!=': operator.ne }
  32.  
  33. class VersionPredicate:
  34.     """Parse and test package version predicates.
  35.  
  36.     >>> v = VersionPredicate('pyepat.abc (>1.0, <3333.3a1, !=1555.1b3)')
  37.  
  38.     The `name` attribute provides the full dotted name that is given::
  39.  
  40.     >>> v.name
  41.     'pyepat.abc'
  42.  
  43.     The str() of a `VersionPredicate` provides a normalized
  44.     human-readable version of the expression::
  45.  
  46.     >>> print v
  47.     pyepat.abc (> 1.0, < 3333.3a1, != 1555.1b3)
  48.  
  49.     The `satisfied_by()` method can be used to determine with a given
  50.     version number is included in the set described by the version
  51.     restrictions::
  52.  
  53.     >>> v.satisfied_by('1.1')
  54.     True
  55.     >>> v.satisfied_by('1.4')
  56.     True
  57.     >>> v.satisfied_by('1.0')
  58.     False
  59.     >>> v.satisfied_by('4444.4')
  60.     False
  61.     >>> v.satisfied_by('1555.1b3')
  62.     False
  63.  
  64.     `VersionPredicate` is flexible in accepting extra whitespace::
  65.  
  66.     >>> v = VersionPredicate(' pat( ==  0.1  )  ')
  67.     >>> v.name
  68.     'pat'
  69.     >>> v.satisfied_by('0.1')
  70.     True
  71.     >>> v.satisfied_by('0.2')
  72.     False
  73.  
  74.     If any version numbers passed in do not conform to the
  75.     restrictions of `StrictVersion`, a `ValueError` is raised::
  76.  
  77.     >>> v = VersionPredicate('p1.p2.p3.p4(>=1.0, <=1.3a1, !=1.2zb3)')
  78.     Traceback (most recent call last):
  79.       ...
  80.     ValueError: invalid version number '1.2zb3'
  81.  
  82.     It the module or package name given does not conform to what's
  83.     allowed as a legal module or package name, `ValueError` is
  84.     raised::
  85.  
  86.     >>> v = VersionPredicate('foo-bar')
  87.     Traceback (most recent call last):
  88.       ...
  89.     ValueError: expected parenthesized list: '-bar'
  90.  
  91.     >>> v = VersionPredicate('foo bar (12.21)')
  92.     Traceback (most recent call last):
  93.       ...
  94.     ValueError: expected parenthesized list: 'bar (12.21)'
  95.  
  96.     """
  97.     
  98.     def __init__(self, versionPredicateStr):
  99.         '''Parse a version predicate string.
  100.         '''
  101.         versionPredicateStr = versionPredicateStr.strip()
  102.         if not versionPredicateStr:
  103.             raise ValueError('empty package restriction')
  104.         
  105.         match = re_validPackage.match(versionPredicateStr)
  106.         if not match:
  107.             raise ValueError('bad package name in %r' % versionPredicateStr)
  108.         
  109.         (self.name, paren) = match.groups()
  110.         paren = paren.strip()
  111.  
  112.     
  113.     def __str__(self):
  114.         pass
  115.  
  116.     
  117.     def satisfied_by(self, version):
  118.         '''True if version is compatible with all the predicates in self.
  119.         The parameter version must be acceptable to the StrictVersion
  120.         constructor.  It may be either a string or StrictVersion.
  121.         '''
  122.         for cond, ver in self.pred:
  123.             if not compmap[cond](version, ver):
  124.                 return False
  125.                 continue
  126.         
  127.         return True
  128.  
  129.  
  130. _provision_rx = None
  131.  
  132. def split_provision(value):
  133.     """Return the name and optional version number of a provision.
  134.  
  135.     The version number, if given, will be returned as a `StrictVersion`
  136.     instance, otherwise it will be `None`.
  137.  
  138.     >>> split_provision('mypkg')
  139.     ('mypkg', None)
  140.     >>> split_provision(' mypkg( 1.2 ) ')
  141.     ('mypkg', StrictVersion ('1.2'))
  142.     """
  143.     global _provision_rx
  144.     if _provision_rx is None:
  145.         _provision_rx = re.compile('([a-zA-Z_]\\w*(?:\\.[a-zA-Z_]\\w*)*)(?:\\s*\\(\\s*([^)\\s]+)\\s*\\))?$')
  146.     
  147.     value = value.strip()
  148.     m = _provision_rx.match(value)
  149.     if not m:
  150.         raise ValueError('illegal provides specification: %r' % value)
  151.     
  152.     if not m.group(2):
  153.         pass
  154.     ver = None
  155.     if ver:
  156.         ver = distutils.version.StrictVersion(ver)
  157.     
  158.     return (m.group(1), ver)
  159.  
  160.