Make Version hashable (#5238)

* Make Version hashable

* Remove Version.match (unused method)

src/datasets/utils/version.py

@@ -18,14 +18,14 @@
 import dataclasses
 import re
 from dataclasses import dataclass
+from functools import total_ordering
 from typing import Optional, Union
 
 
-_VERSION_TMPL = r"^(?P<major>{v})" r"\.(?P<minor>{v})" r"\.(?P<patch>{v})$"
-_VERSION_WILDCARD_REG = re.compile(_VERSION_TMPL.format(v=r"\d+|\*"))
-_VERSION_RESOLVED_REG = re.compile(_VERSION_TMPL.format(v=r"\d+"))
+_VERSION_REG = re.compile(r"^(?P<major>\d+)" r"\.(?P<minor>\d+)" r"\.(?P<patch>\d+)$")
 
 
+@total_ordering
 @dataclass
 class Version:
     """Dataset version MAJOR.MINOR.PATCH.
@@ -55,7 +55,7 @@ class Version:
     patch: Optional[Union[str, int]] = None
 
     def __post_init__(self):
-        self.major, self.minor, self.patch = _str_to_version(self.version_str)
+        self.major, self.minor, self.patch = _str_to_version_tuple(self.version_str)
 
     def __repr__(self):
         return f"{self.tuple[0]}.{self.tuple[1]}.{self.tuple[2]}"
@@ -79,34 +79,12 @@ def __eq__(self, other):
         else:
             return self.tuple == other.tuple
 
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
     def __lt__(self, other):
         other = self._validate_operand(other)
         return self.tuple < other.tuple
 
-    def __le__(self, other):
-        other = self._validate_operand(other)
-        return self.tuple <= other.tuple
-
-    def __gt__(self, other):
-        other = self._validate_operand(other)
-        return self.tuple > other.tuple
-
-    def __ge__(self, other):
-        other = self._validate_operand(other)
-        return self.tuple >= other.tuple
-
-    def match(self, other_version):
-        """Returns True if other_version matches.
-
-        Args:
-            other_version: string, of the form "x[.y[.x]]" where {x,y,z} can be a
-                number or a wildcard.
-        """
-        major, minor, patch = _str_to_version(other_version, allow_wildcard=True)
-        return major in [self.major, "*"] and minor in [self.minor, "*"] and patch in [self.patch, "*"]
+    def __hash__(self):
+        return hash(_version_tuple_to_str(self.tuple))
 
     @classmethod
     def from_dict(cls, dic):
@@ -117,15 +95,14 @@ def _to_yaml_string(self) -> str:
         return self.version_str
 
 
-def _str_to_version(version_str, allow_wildcard=False):
+def _str_to_version_tuple(version_str):
     """Return the tuple (major, minor, patch) version extracted from the str."""
-    reg = _VERSION_WILDCARD_REG if allow_wildcard else _VERSION_RESOLVED_REG
-    res = reg.match(version_str)
+    res = _VERSION_REG.match(version_str)
     if not res:
-        msg = f"Invalid version '{version_str}'. Format should be x.y.z"
-        if allow_wildcard:
-            msg += " with {x,y,z} being digits or wildcard."
-        else:
-            msg += " with {x,y,z} being digits."
-        raise ValueError(msg)
-    return tuple(v if v == "*" else int(v) for v in [res.group("major"), res.group("minor"), res.group("patch")])
+        raise ValueError(f"Invalid version '{version_str}'. Format should be x.y.z with {{x,y,z}} being digits.")
+    return tuple(int(v) for v in [res.group("major"), res.group("minor"), res.group("patch")])
+
+
+def _version_tuple_to_str(version_tuple):
+    """Return the str version from the version tuple (major, minor, patch)."""
+    return ".".join(str(v) for v in version_tuple)

tests/test_version.py

@@ -16,7 +16,8 @@
         (None, False),
     ],
 )
-def test_version_equalities(other, expected_equality):
+def test_version_equality_and_hash(other, expected_equality):
     version = Version("1.0.0")
     assert (version == other) is expected_equality
     assert (version != other) is not expected_equality
+    assert (hash(version) == hash(other)) is expected_equality