1 import re
   2 
   3 # -- version 1
   4 
   5 class VersionParser(re.Scanner):
   6     tagmap = {'alpha': -30, 'a': -30,
   7               'beta': -20, 'b': -20,
   8               'rc': -10, 'c': -10}
   9     def __init__(self):
  10         re.Scanner.__init__(self, [(r'\d+', self.handle_number),
  11                                    (r'[a-z-]+', self.handle_tag),
  12                                    (r'[-.]', None)])
  13     def handle_number(self, s, n):
  14         return int(n)
  15     def handle_tag(self, s, t):
  16         if not self.had_tag:
  17             self.had_tag = True
  18             return self.tagmap.get(t, -40)
  19         raise ValueError('only one tag is allowed')
  20     def parse(self, version):
  21         self.had_tag = False
  22         self.tag_index = -1
  23         self.index = 0
  24         result, rest = self.scan(version)
  25         if rest:
  26             raise ValueError('%r unexpected in version' % rest)
  27         # strip out redundant '.0's
  28         a = b = len(result)
  29         for i, p in enumerate(result):
  30             if p < 0:
  31                 if a == -1:
  32                     a = i
  33                 b = i
  34                 break
  35             elif p == 0:
  36                 if a == -1:
  37                     a = i
  38             else:
  39                 a = -1
  40         return result[:a], result[b:]
  41 
  42 p = VersionParser().parse
  43 
  44 # -- version 2
  45 
  46 n_re = re.compile(r'\d+')
  47 t_re = re.compile(r'[a-z-]+')
  48 i_re = re.compile('[-.]+')
  49 
  50 def parse_version(version):
  51     length = len(version)
  52     pos = 0
  53     n, t = [], []
  54     c = n
  55     while pos < length:
  56         m = n_re.match(version, pos)
  57         if m:
  58             c.append(int(m.group()))
  59             pos = m.end()
  60         else:
  61             m = t_re.match(version, pos)
  62             if m:
  63                 if c is t:
  64                     raise ValueError('two tags')
  65                 c = t
  66                 c.append(VersionParser.tagmap.get(m.group(), -40))
  67                 pos = m.end()
  68             else:
  69                 m = i_re.match(version, pos)
  70                 if m:
  71                     pos = m.end()
  72                 else:
  73                     raise ValueError('unexpected char')
  74     while n[-1] == 0:
  75         n.pop()
  76     return n, t
  77 
  78 q = parse_version