Merge pull request #471 from linkml/schemaview_induced_slot_range

schemaview.py: adding `induced_slot_range` function to retrieve the possible ranges for a slot

Author: ialarmedalien

linkml_runtime/utils/schemaview.py

@@ -1875,12 +1875,61 @@ def slot_range_as_union(self, slot: SlotDefinition) -> list[ElementName]:
         :param slot:
         :return: list of ranges
         """
-        r = slot.range
-        range_union_of = [r]
-        for x in slot.exactly_one_of + slot.any_of:
-            if x.range:
-                range_union_of.append(x.range)
-        return range_union_of
+        return list({y.range for y in [slot, *[x for x in [*slot.exactly_one_of, *slot.any_of] if x.range]]})
+
+    def induced_slot_range(self, slot: SlotDefinition, strict: bool = False) -> set[str | ElementName]:  # noqa: FBT001, FBT002
+        """Retrieve all applicable ranges for a slot, falling back to the default if necessary.
+
+        Performs several validation checks if `strict` is True:
+        - ensures that the slot has a range specified
+        - requires the slot range to be set to a class with CURIE `linkml:Any` if one of the boolean specifiers is used for the range
+        - ensures that only one of `any_of` and `exactly_one_of` is used if the range is `linkml:Any`
+
+        :param slot: the slot to be investigated
+        :type slot: SlotDefinition
+        :param strict: whether or not to throw errors if there are validation issues with the schema, defaults to False
+        :type strict: bool, optional
+        :return: set of ranges
+        :rtype: set[str | ElementName]
+        """
+
+        slot_range = slot.range
+        any_of_range = {x.range for x in slot.any_of if x.range}
+        exactly_one_of_range = {x.range for x in slot.exactly_one_of if x.range}
+
+        is_any = False
+        if slot_range:
+            range_class = self.get_class(slot_range)
+            if range_class and range_class.class_uri == "linkml:Any":
+                is_any = True
+
+        if strict:
+            # no range specified and no schema default
+            if not (any_of_range or exactly_one_of_range or slot_range):
+                err_msg = f"{slot.owner} slot {slot.name} has no range specified"
+                raise ValueError(err_msg)
+
+            # ensure that only one of any_of and exactly_one_of is specified
+            if any_of_range and exactly_one_of_range:
+                err_msg = f"{slot.owner} slot {slot.name} has range specified in both `exactly_one_of` and `any_of`"
+                raise ValueError(err_msg)
+
+            # if any_of or exactly_one_of is set, the slot range should be linkml:Any
+            if (any_of_range or exactly_one_of_range) and not (slot_range and is_any):
+                err_msg = f"{slot.owner} slot {slot.name} has range specified in `exactly_one_of` or `any_of` but the slot range is not linkml:Any"
+                raise ValueError(err_msg)
+
+        # if the range is linkml:Any and one/both of these ranges is set, return them
+        if is_any and (any_of_range or exactly_one_of_range):
+            return {*any_of_range, *exactly_one_of_range}
+
+        # return the slot range (if set)
+        if slot_range:
+            return {slot_range}
+
+        # return empty set (not {None})
+        # note: this is only returned when strict mode is False
+        return set()
 
     def get_classes_by_slot(self, slot: SlotDefinition, include_induced: bool = False) -> list[ClassDefinitionName]:
         """Get all classes that use a given slot, either as a direct or induced slot.

tests/test_utils/test_schemaview.py

@@ -1680,6 +1680,13 @@ def sv_range_riid_gen(request: pytest.FixtureRequest) -> tuple[SchemaView, tuple
     for key, value in ranges_replaced_by_defaults["none_range"].items()
 }
 
+induced_range_strict_errors = {
+    "any_of_and_exactly_one_of_range": "ClassWithRanges slot any_of_and_exactly_one_of_range has range specified in both `exactly_one_of` and `any_of`",
+    "invalid_any_range_no_linkml_any": "ClassWithRanges slot invalid_any_range_no_linkml_any has range specified in `exactly_one_of` or `any_of` but the slot range is not linkml:Any",
+    "invalid_any_range_enum": "ClassWithRanges slot invalid_any_range_enum has range specified in `exactly_one_of` or `any_of` but the slot range is not linkml:Any",
+    "invalid_any_range_class": "ClassWithRanges slot invalid_any_range_class has range specified in `exactly_one_of` or `any_of` but the slot range is not linkml:Any",
+}
+
 
 def test_generated_range_schema(sv_range_riid_gen: tuple[SchemaView, tuple[str, str | None, str | None]]) -> None:
     """Tests for generation of range schemas.
@@ -1696,8 +1703,17 @@ def test_generated_range_schema(sv_range_riid_gen: tuple[SchemaView, tuple[str,
     assert isinstance(sv_range, SchemaView)
 
 
-@pytest.mark.parametrize("range_function", ["slot_range", "slot_range_as_union", "slot_applicable_range_elements"])
 @pytest.mark.parametrize("slot_name", ranges_no_defaults.keys())
+@pytest.mark.parametrize(
+    "range_function",
+    [
+        "slot_range",
+        "slot_range_as_union",
+        "induced_slot_range",
+        "induced_range_strict",
+        "slot_applicable_range_elements",
+    ],
+)
 def test_slot_range(
     range_function: str,
     slot_name: str,
@@ -1713,25 +1729,37 @@ def test_slot_range(
     :type sv_range_riid_gen: tuple[SchemaView, tuple[str, str | None, str | None]]
     """
     (sv_range, range_tuple) = sv_range_riid_gen
-
-    slots_by_name = {s.name: s for s in sv_range.class_induced_slots("ClassWithRanges")}
+    slot_object = sv_range.induced_slot(slot_name, "ClassWithRanges")
     expected = ranges_no_defaults[slot_name]
+
     if slot_name in ranges_replaced_by_defaults:
         expected = ranges_replaced_by_defaults[slot_name][range_tuple]
+
     if range_function == "slot_range":
-        assert slots_by_name[slot_name].range == expected[0]
+        assert slot_object.range == expected[0]
     elif range_function == "slot_range_as_union":
-        assert set(sv_range.slot_range_as_union(slots_by_name[slot_name])) == expected[1]
+        assert set(sv_range.slot_range_as_union(slot_object)) == expected[1]
     elif range_function == "induced_slot_range":
-        assert sv_range.induced_slot_range(slots_by_name[slot_name]) == expected[2]
+        assert sv_range.induced_slot_range(slot_object) == expected[2]
+    elif range_function == "induced_range_strict":
+        # err_msg will be None if there is no error in the slot range specification
+        err_msg = induced_range_strict_errors.get(slot_name)
+        if not err_msg and expected[2] == set():
+            err_msg = f"ClassWithRanges slot {slot_name} has no range specified"
+
+        if err_msg:
+            with pytest.raises(ValueError, match=err_msg):
+                sv_range.induced_slot_range(slot_object, strict=True)
+        else:
+            assert sv_range.induced_slot_range(slot_object, strict=True) == expected[2]
     elif range_function == "slot_applicable_range_elements":
         if slot_name in ranges_replaced_by_defaults and len(expected) < 4:
             expected = ranges_no_defaults[slot_name]
         if isinstance(expected[3], set):
-            assert set(sv_range.slot_applicable_range_elements(slots_by_name[slot_name])) == expected[3]
+            assert set(sv_range.slot_applicable_range_elements(slot_object)) == expected[3]
         else:
             with pytest.raises(expected[3], match="Unrecognized range: None"):
-                sv_range.slot_applicable_range_elements(slots_by_name[slot_name])
+                sv_range.slot_applicable_range_elements(slot_object)
     else:
         pytest.fail(f"Unexpected range_function value: {range_function}")