Update __gt__ logic to leverage tuple comparison

Author: absurdfarce

cassandra/util.py

@@ -1724,18 +1724,21 @@ def __init__(self, version):
         try:
             self.prerelease = self._cleanup_str(match[5])
         except:
-            self.prerelease = 0
+            self.prerelease = ""
+
+        # This is used in a few places below so let's just build it now
+        self._tuple = (self.major, self.minor, self.patch, self.build, self.prerelease)
 
     # Trim off the leading '.' characters and convert the discovered value to an integer
     def _cleanup_int(self, instr):
         return int(instr[1:]) if instr else 0
 
     # Trim off the leading '.' or '~' characters and just return the string directly
     def _cleanup_str(self, instr):
-        return instr[1:] if instr else 0
+        return instr[1:] if instr else ""
 
     def __hash__(self):
-        return hash((self.major, self.minor, self.patch, self.build, self.prerelease))
+        return hash(self._tuple)
 
     def __repr__(self):
         version_string = "Version({0}, {1}, {2}".format(self.major, self.minor, self.patch)
@@ -1750,29 +1753,24 @@ def __repr__(self):
     def __str__(self):
         return self._version
 
+    # Methods below leverage the fact that Tuples are compared position by position from left to right
     def __eq__(self, other):
         if not isinstance(other, Version):
             return NotImplemented
 
-        return (self.major == other.major and
-                self.minor == other.minor and
-                self.patch == other.patch and
-                self.build == other.build and
-                self.prerelease == other.prerelease
-                )
+        return self._tuple == other._tuple
 
     def __gt__(self, other):
         if not isinstance(other, Version):
             return NotImplemented
 
-        if self.major != other.major:
-            return self.major > other.major
-        elif self.minor != other.minor:
-            return self.minor > other.minor
-        elif self.patch != other.patch:
-            return self.patch > other.patch
-        elif self.build != other.build:
-            return self.build > other.build
+        # We start by comparing the first four fields directly
+        self_tuple = self._tuple[:4]
+        other_tuple = (other.major, other.minor, other.patch, other.build)
+        if self_tuple != other_tuple:
+            return self_tuple > other_tuple
+        # If we're still around we have to check prereleases... prereleases always come before
+        # the corresponding version
         elif self.prerelease and not other.prerelease:
             return False
         elif other.prerelease and not self.prerelease:

tests/unit/test_util_types.py

@@ -211,8 +211,8 @@ def test_version_parsing(self):
         versions = [
             # Test cases here adapted from the Java driver cases 
             # (https://github.com/apache/cassandra-java-driver/blob/4.19.2/core/src/test/java/com/datastax/oss/driver/api/core/VersionTest.java)
-            ('1.2.19', (1, 2, 19, 0, 0)),
-            ('1.2', (1, 2, 0, 0, 0)),
+            ('1.2.19', (1, 2, 19, 0, "")),
+            ('1.2', (1, 2, 0, 0, "")),
             ('1.2-beta1-SNAPSHOT', (1, 2, 0, 0, 'beta1-SNAPSHOT')),
             ('1.2~beta1-SNAPSHOT', (1, 2, 0, 0, 'beta1-SNAPSHOT')),
             ('1.2.19.2-SNAPSHOT', (1, 2, 19, 2, 'SNAPSHOT')),