Manipulate version numbers as tuples.

Amend the SSSOMSchemaView#get_minimum_version() method to return a
(major, minor) tuple, rather than a SssomVersionEnum object. The
SssomVersionObject (which is automatically generated from the LinkML
schema) is cumbersome to use, for at least two reasons:

1) obtaining the actual value of the enum requires accessing two levels
   of attributes (SssomVersionObject.code.text);
2) SssomVersionEnum values cannot be meaningfully compared (e.g. to
   check that a given version number is higher than another given
   version), we must (a) obtain the text value, (b) split that value
   over the middle dot, (c) convert the strings to integers, (d) put the
   integers into a tuple. OK, this can be done in one line of code, but
   this is cumbersome all the same, and it's best if that kind of things
   is not left to client code.

Author: gouttegd

src/sssom/constants.py

@@ -4,13 +4,12 @@
 import uuid
 from enum import Enum
 from functools import cached_property, lru_cache
-from typing import Any, Dict, List, Literal, Set, TextIO, Union
+from typing import Any, Dict, List, Literal, Optional, Set, TextIO, Tuple, Union
 
 import importlib_resources
 import yaml
 from linkml_runtime.utils.schema_as_dict import schema_as_dict
 from linkml_runtime.utils.schemaview import SchemaView
-from sssom_schema.datamodel.sssom_schema import SssomVersionEnum
 
 HERE = pathlib.Path(__file__).parent.resolve()
 
@@ -284,24 +283,30 @@ def propagatable_slots(self) -> List[str]:
                 slots.append(slot_name)
         return slots
 
-    def get_minimum_version(self, slot_name: str, class_name: str = "mapping") -> SssomVersionEnum:
+    def get_minimum_version(
+        self, slot_name: str, class_name: str = "mapping"
+    ) -> Optional[Tuple[int, int]]:
         """Get the minimum version of SSSOM required for a given slot.
 
         :param slot_name: The queried slot.
         :param class_name: The class the slot belongs to. This is needed
                            because a slot may have been added to a class
                            in a later version than the version in which
                            it was first introduced in the schema.
-        :return: A SssomVersionEnum value representing the earliest
-                 version of SSSOM that defines the given slot in the
-                 given class. May be None if the requested slot name
-                 is not a valid slot name.
+        :return: A tuple containing the major and minor numbers of the
+                 earliest version of SSSOM that defines the given slot
+                 in the given class. May be None if the requested slot
+                 name is not a valid slot name.
         """
         try:
             slot = self.view.induced_slot(slot_name, class_name)
-            return SssomVersionEnum(slot.annotations.added_in.value)
+            version = [int(s) for s in slot.annotations.added_in.value.split(".")]
+            if len(version) != 2:
+                # Should never happen, schema is incorrect
+                return None
+            return (version[0], version[1])
         except AttributeError:  # No added_in annotation, defaults to 1.0
-            return SssomVersionEnum("1.0")
+            return (1, 0)
         except ValueError:  # No such slot
             return None
 

src/sssom/util.py

@@ -501,18 +501,18 @@ def _to_string(row: dict[str, Any], side: str) -> str:
     def get_compatible_version(self) -> str:
         """Get the minimum version of SSSOM this set is compatible with."""
         schema = SSSOMSchemaView()
-        versions: Set[str] = set()
+        versions: Set[Tuple[int, int]] = set()
 
         # First get the minimum versions required by the slots present
         # in the set; this is entirely provided by the SSSOM model.
         for slot in self.metadata.keys():
             version = schema.get_minimum_version(slot, "mapping set")
             if version is not None:
-                versions.add(str(version))
+                versions.add(version)
         for slot in self.df.columns:
             version = schema.get_minimum_version(slot, "mapping")
             if version is not None:
-                versions.add(str(version))
+                versions.add(version)
 
         # Then take care of enum values; we cannot use the SSSOM model
         # for that (enum values are not tagged with an "added_in"
@@ -531,16 +531,13 @@ def get_compatible_version(self) -> str:
                 and "composed entity expression" in self.df[OBJECT_TYPE].values
             )
         ):
-            versions.add("1.1")
+            versions.add((1, 1))
 
         if MAPPING_CARDINALITY in self.df.columns and "0:0" in self.df[MAPPING_CARDINALITY].values:
-            versions.add("1.1")
+            versions.add((1, 1))
 
-        # Get the highest of the accumulated versions. We do a numerical
-        # sort, so that version 1.10 (if we ever get that far in the 1.x
-        # branch) does not get sorted before version 1.9.
-        def _version_to_compare_key(version):
-            return tuple(int(s) for s in version.split("."))
+        # Get the highest of the accumulated versions.
+        return ".".join([str(i) for i in max(versions)])
 
         return max(versions, key=_version_to_compare_key)