version.py 12.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
#
# distutils/version.py
#
# Implements multiple version numbering conventions for the
# Python Module Distribution Utilities.
#
# $Id$
#

"""Provides classes to represent module version numbers (one class for
each style of version numbering).  There are currently two such classes
implemented: StrictVersion and LooseVersion.

Every version number class implements the following interface:
  * the 'parse' method takes a string and parses it to some internal
    representation; if the string is an invalid version number,
    'parse' raises a ValueError exception
  * the class constructor takes an optional string argument which,
    if supplied, is passed to 'parse'
  * __str__ reconstructs the string that was passed to 'parse' (or
    an equivalent string -- ie. one that will generate an equivalent
    version number instance)
  * __repr__ generates Python code to recreate the version number instance
24
  * _cmp compares the current instance with either another instance
25 26 27 28
    of the same class or a string (which will be parsed to an instance
    of the same class, thus must follow the same rules)
"""

29
import re
30 31 32 33

class Version:
    """Abstract base class for version numbering classes.  Just provides
    constructor (__init__) and reproducer (__repr__), because those
34
    seem to be the same for all version numbering classes; and route
35
    rich comparisons to _cmp.
36 37 38 39
    """

    def __init__ (self, vstring=None):
        if vstring:
40
            self.parse(vstring)
41 42

    def __repr__ (self):
43
        return "%s ('%s')" % (self.__class__.__name__, str(self))
44

45
    def __eq__(self, other):
46
        c = self._cmp(other)
47 48 49 50 51
        if c is NotImplemented:
            return c
        return c == 0

    def __ne__(self, other):
52
        c = self._cmp(other)
53 54 55 56 57
        if c is NotImplemented:
            return c
        return c != 0

    def __lt__(self, other):
58
        c = self._cmp(other)
59 60 61 62 63
        if c is NotImplemented:
            return c
        return c < 0

    def __le__(self, other):
64
        c = self._cmp(other)
65 66 67 68 69
        if c is NotImplemented:
            return c
        return c <= 0

    def __gt__(self, other):
70
        c = self._cmp(other)
71 72 73 74 75
        if c is NotImplemented:
            return c
        return c > 0

    def __ge__(self, other):
76
        c = self._cmp(other)
77 78 79 80
        if c is NotImplemented:
            return c
        return c >= 0

81 82 83 84 85 86 87 88 89 90 91 92 93

# Interface for version-number classes -- must be implemented
# by the following classes (the concrete ones -- Version should
# be treated as an abstract class).
#    __init__ (string) - create and take same action as 'parse'
#                        (string parameter is optional)
#    parse (string)    - convert a string representation to whatever
#                        internal representation is appropriate for
#                        this style of version numbering
#    __str__ (self)    - convert back to a string; should be very similar
#                        (if not identical to) the string supplied to parse
#    __repr__ (self)   - generate Python code to recreate
#                        the instance
94
#    _cmp (self, other) - compare two version numbers ('other' may
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
#                        be an unparsed version string, or another
#                        instance of your version class)


class StrictVersion (Version):

    """Version numbering for anal retentives and software idealists.
    Implements the standard interface for version number classes as
    described above.  A version number consists of two or three
    dot-separated numeric components, with an optional "pre-release" tag
    on the end.  The pre-release tag consists of the letter 'a' or 'b'
    followed by a number.  If the numeric components of two version
    numbers are equal, then one with a pre-release tag will always
    be deemed earlier (lesser) than one without.

    The following are valid version numbers (shown in the order that
    would be obtained by sorting according to the supplied cmp function):

        0.4       0.4.0  (these two are equivalent)
        0.4.1
        0.5a1
        0.5b3
        0.5
        0.9.6
        1.0
        1.0.4a3
        1.0.4b1
        1.0.4

    The following are examples of invalid version numbers:

        1
        2.7.2.2
        1.3.a4
        1.3pl1
        1.3c4

    The rationale for this version numbering system will be explained
    in the distutils documentation.
    """
Fred Drake's avatar
Fred Drake committed
135

136
    version_re = re.compile(r'^(\d+) \. (\d+) (\. (\d+))? ([ab](\d+))?$',
137
                            re.VERBOSE | re.ASCII)
138 139 140


    def parse (self, vstring):
141
        match = self.version_re.match(vstring)
142
        if not match:
143
            raise ValueError("invalid version number '%s'" % vstring)
144 145

        (major, minor, patch, prerelease, prerelease_num) = \
146
            match.group(1, 2, 4, 5, 6)
147 148

        if patch:
149
            self.version = tuple(map(int, [major, minor, patch]))
150
        else:
151
            self.version = tuple(map(int, [major, minor])) + (0,)
152 153

        if prerelease:
154
            self.prerelease = (prerelease[0], int(prerelease_num))
155 156 157 158 159
        else:
            self.prerelease = None


    def __str__ (self):
Fred Drake's avatar
Fred Drake committed
160

161
        if self.version[2] == 0:
162
            vstring = '.'.join(map(str, self.version[0:2]))
163
        else:
164
            vstring = '.'.join(map(str, self.version))
165 166

        if self.prerelease:
167
            vstring = vstring + self.prerelease[0] + str(self.prerelease[1])
168 169

        return vstring
Fred Drake's avatar
Fred Drake committed
170

171

172
    def _cmp (self, other):
173
        if isinstance(other, str):
174
            other = StrictVersion(other)
175

176 177 178 179 180 181 182
        if self.version != other.version:
            # numeric versions don't match
            # prerelease stuff doesn't matter
            if self.version < other.version:
                return -1
            else:
                return 1
183

184 185 186 187 188 189 190 191 192 193 194 195 196 197
        # have to compare prerelease
        # case 1: neither has prerelease; they're equal
        # case 2: self has prerelease, other doesn't; other is greater
        # case 3: self doesn't have prerelease, other does: self is greater
        # case 4: both have prerelease: must compare them!

        if (not self.prerelease and not other.prerelease):
            return 0
        elif (self.prerelease and not other.prerelease):
            return -1
        elif (not self.prerelease and other.prerelease):
            return 1
        elif (self.prerelease and other.prerelease):
            if self.prerelease == other.prerelease:
198
                return 0
199
            elif self.prerelease < other.prerelease:
200
                return -1
201
            else:
202
                return 1
203 204
        else:
            assert False, "never get here"
205 206 207 208 209

# end class StrictVersion


# The rules according to Greg Stein:
Benjamin Peterson's avatar
Benjamin Peterson committed
210
# 1) a version number has 1 or more numbers separated by a period or by
211 212 213 214 215
#    sequences of letters. If only periods, then these are compared
#    left-to-right to determine an ordering.
# 2) sequences of letters are part of the tuple for comparison and are
#    compared lexicographically
# 3) recognize the numeric components may have leading zeroes
Fred Drake's avatar
Fred Drake committed
216
#
217 218 219 220 221 222 223 224 225 226 227 228 229 230
# The LooseVersion class below implements these rules: a version number
# string is split up into a tuple of integer and string components, and
# comparison is a simple tuple comparison.  This means that version
# numbers behave in a predictable and obvious way, but a way that might
# not necessarily be how people *want* version numbers to behave.  There
# wouldn't be a problem if people could stick to purely numeric version
# numbers: just split on period and compare the numbers as tuples.
# However, people insist on putting letters into their version numbers;
# the most common purpose seems to be:
#   - indicating a "pre-release" version
#     ('alpha', 'beta', 'a', 'b', 'pre', 'p')
#   - indicating a post-release patch ('p', 'pl', 'patch')
# but of course this can't cover all version number schemes, and there's
# no way to know what a programmer means without asking him.
Fred Drake's avatar
Fred Drake committed
231
#
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
# The problem is what to do with letters (and other non-numeric
# characters) in a version number.  The current implementation does the
# obvious and predictable thing: keep them as strings and compare
# lexically within a tuple comparison.  This has the desired effect if
# an appended letter sequence implies something "post-release":
# eg. "0.99" < "0.99pl14" < "1.0", and "5.001" < "5.001m" < "5.002".
#
# However, if letters in a version number imply a pre-release version,
# the "obvious" thing isn't correct.  Eg. you would expect that
# "1.5.1" < "1.5.2a2" < "1.5.2", but under the tuple/lexical comparison
# implemented here, this just isn't so.
#
# Two possible solutions come to mind.  The first is to tie the
# comparison algorithm to a particular set of semantic rules, as has
# been done in the StrictVersion class above.  This works great as long
# as everyone can go along with bondage and discipline.  Hopefully a
# (large) subset of Python module programmers will agree that the
# particular flavour of bondage and discipline provided by StrictVersion
# provides enough benefit to be worth using, and will submit their
# version numbering scheme to its domination.  The free-thinking
# anarchists in the lot will never give in, though, and something needs
Jeremy Hylton's avatar
Jeremy Hylton committed
253
# to be done to accommodate them.
Fred Drake's avatar
Fred Drake committed
254
#
255 256 257 258 259 260 261 262
# Perhaps a "moderately strict" version class could be implemented that
# lets almost anything slide (syntactically), and makes some heuristic
# assumptions about non-digits in version number strings.  This could
# sink into special-case-hell, though; if I was as talented and
# idiosyncratic as Larry Wall, I'd go ahead and implement a class that
# somehow knows that "1.2.1" < "1.2.2a2" < "1.2.2" < "1.2.2pl3", and is
# just as happy dealing with things like "2g6" and "1.13++".  I don't
# think I'm smart enough to do it right though.
Fred Drake's avatar
Fred Drake committed
263
#
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309
# In any case, I've coded the test suite for this module (see
# ../test/test_version.py) specifically to fail on things like comparing
# "1.2a2" and "1.2".  That's not because the *code* is doing anything
# wrong, it's because the simple, obvious design doesn't match my
# complicated, hairy expectations for real-world version numbers.  It
# would be a snap to fix the test suite to say, "Yep, LooseVersion does
# the Right Thing" (ie. the code matches the conception).  But I'd rather
# have a conception that matches common notions about version numbers.

class LooseVersion (Version):

    """Version numbering for anarchists and software realists.
    Implements the standard interface for version number classes as
    described above.  A version number consists of a series of numbers,
    separated by either periods or strings of letters.  When comparing
    version numbers, the numeric components will be compared
    numerically, and the alphabetic components lexically.  The following
    are all valid version numbers, in no particular order:

        1.5.1
        1.5.2b2
        161
        3.10a
        8.02
        3.4j
        1996.07.12
        3.2.pl0
        3.1.1.6
        2g6
        11g
        0.960923
        2.2beta29
        1.13++
        5.5.kw
        2.0b1pl0

    In fact, there is no such thing as an invalid version number under
    this scheme; the rules for comparison are simple and predictable,
    but may not always give the results you want (for some definition
    of "want").
    """

    component_re = re.compile(r'(\d+ | [a-z]+ | \.)', re.VERBOSE)

    def __init__ (self, vstring=None):
        if vstring:
310
            self.parse(vstring)
311 312 313 314 315 316 317


    def parse (self, vstring):
        # I've given up on thinking I can reconstruct the version string
        # from the parsed tuple -- so I just store the string here for
        # use by __str__
        self.vstring = vstring
318 319 320
        components = [x for x in self.component_re.split(vstring)
                              if x and x != '.']
        for i, obj in enumerate(components):
321
            try:
322
                components[i] = int(obj)
323 324 325 326 327 328 329 330 331 332 333
            except ValueError:
                pass

        self.version = components


    def __str__ (self):
        return self.vstring


    def __repr__ (self):
334
        return "LooseVersion ('%s')" % str(self)
335 336


337
    def _cmp (self, other):
338
        if isinstance(other, str):
339
            other = LooseVersion(other)
340

341 342 343 344 345 346
        if self.version == other.version:
            return 0
        if self.version < other.version:
            return -1
        if self.version > other.version:
            return 1
Fred Drake's avatar
Fred Drake committed
347

348 349

# end class LooseVersion