Merge pull request #477 from linkml/schemaview_minor_file_reorg

schemaview.py: minor reorg and test reorganisation

Author: amc-corey-cox

linkml_runtime/utils/schemaview.py

@@ -1152,6 +1152,17 @@ def type_ancestors(
             **kwargs,
         )
 
+    @lru_cache(None)
+    def type_roots(self, imports: bool = True) -> list[TypeDefinitionName]:
+        """Return all types that have no parents.
+
+        :param imports: whether or not to include imports, defaults to True
+        :type imports: bool, optional
+        :return: list of all root types
+        :rtype: list[TypeDefinitionName]
+        """
+        return [t for t in self.all_types(imports=imports) if not self.type_parents(t, imports=imports)]
+
     @lru_cache(None)
     def enum_parents(
         self, enum_name: ENUM_NAME, imports: bool = False, mixins: bool = False, is_a: bool = True
@@ -1279,17 +1290,6 @@ def permissible_value_descendants(
             **kwargs,
         )
 
-    @lru_cache(None)
-    def type_roots(self, imports: bool = True) -> list[TypeDefinitionName]:
-        """Return all types that have no parents.
-
-        :param imports: whether or not to include imports, defaults to True
-        :type imports: bool, optional
-        :return: list of all root types
-        :rtype: list[TypeDefinitionName]
-        """
-        return [t for t in self.all_types(imports=imports) if not self.type_parents(t, imports=imports)]
-
     @lru_cache(None)
     def is_multivalued(self, slot_name: SlotDefinition) -> bool:
         """Return True if slot is multivalued, else returns False.

tests/test_utils/test_schemaview.py

@@ -1271,6 +1271,160 @@ def test_class_parents_ancestors(creature_view: SchemaView) -> None:
         }
 
 
+"""
+Tests of the detect_cycles function, which can identify cyclic relationships between classes, types, and other schema elements.
+"""
+
+
+@pytest.mark.parametrize("dodgy_input", [None, [], set(), {}, 12345, 123.45, "some string", ()])
+def test_detect_cycles_input_error(dodgy_input: Any) -> None:
+    """Ensure that `detect_cycles` throws an error if input is not supplied in the appropriate form."""
+    with pytest.raises(ValueError, match="detect_cycles requires a list of values to process"):
+        detect_cycles(lambda x: x, dodgy_input)
+
+
+@pytest.fixture(scope="module")
+def sv_cycles_schema() -> SchemaView:
+    """A schema containing cycles!"""
+    return SchemaView(INPUT_DIR_PATH / "cycles.yaml")
+
+
+# metadata for elements in the `sv_cycles_schema`
+CYCLES = {
+    TYPES: {
+        # types in cycles, either directly or via ancestors
+        # key: type, value: node where the cycle starts
+        0: {
+            "curve_type": "circular_type",
+            "semi_circular_type": "circular_type",
+            "circular_type": "circular_type",
+            "type_circular": "type_circular",
+            "circle": "circle",
+            "circle_of_life": "circle",
+        },
+        # types not involved in cycles
+        # key: the type, value: ancestors of the type
+        1: {
+            "supreme_string": {"supreme_string", "super_string", "string"},
+            "super_string": {"super_string", "string"},
+            "string": {"string"},
+            "integer": {"integer"},
+            "boolean": {"boolean"},
+        },
+    },
+    CLASSES: {
+        # classes involved in cycles
+        # key: class name, value: node where the cycle starts
+        0: {
+            "ClassA": "ClassA",
+            "ClassB": "ClassB",
+            "ClassC": "ClassC",
+            "ClassD": "ClassA",
+            "ClassE": "ClassA",
+            "ClassF": "ClassF",
+            "ClassG": "ClassF",
+            "Mixin1": "Mixin1",
+            "Mixin2": "Mixin2",
+            "MixedClass": "Mixin2",
+        },
+        # class ancestors for classes not in cycles
+        # key: class name, value: class ancestors
+        1: {
+            "BaseClass": {"BaseClass"},
+            "MixinA": {"MixinA"},  # no ID slot
+            "MixinB": {"MixinB"},  # no ID slot
+            "NonCycleClassA": {"NonCycleClassA", "BaseClass"},
+            "NonCycleClassB": {"MixinA", "NonCycleClassB", "NonCycleClassA", "BaseClass"},
+            "NonCycleClassC": {"MixinB", "NonCycleClassC", "NonCycleClassA", "BaseClass"},
+            "IdentifierCycleClassA": {"IdentifierCycleClassA"},
+            "IdentifierCycleClassB": {"IdentifierCycleClassB"},
+            "IdentifierCycleClassC": {"IdentifierCycleClassC"},
+            "IdentifierCycleClassD": {"IdentifierCycleClassD"},
+        },
+    },
+}
+
+
+@pytest.mark.parametrize(("target", "cycle_start_node"), list(CYCLES[TYPES][0].items()))
+@pytest.mark.parametrize("fn", ["detect_cycles", "graph_closure", "type_ancestors"])
+def test_detect_type_cycles_error(sv_cycles_schema: SchemaView, target: str, cycle_start_node: str, fn: str) -> None:
+    """Test detection of cycles in the types segment of the cycles schema."""
+    if fn == "detect_cycles":
+        with pytest.raises(ValueError, match=f"Cycle detected at node '{cycle_start_node}'"):
+            detect_cycles(sv_cycles_schema.type_parents, [target])
+    elif fn == "graph_closure":
+        with pytest.raises(ValueError, match=f"Cycle detected at node '{cycle_start_node}'"):
+            graph_closure(sv_cycles_schema.type_parents, target, detect_cycles=True)
+    else:
+        with pytest.raises(ValueError, match=f"Cycle detected at node '{cycle_start_node}'"):
+            sv_cycles_schema.type_ancestors(type_name=target, detect_cycles=True)
+
+
+@pytest.mark.parametrize(("target", "expected"), list(CYCLES[TYPES][1].items()))
+@pytest.mark.parametrize("fn", ["detect_cycles", "graph_closure", "type_ancestors"])
+def test_detect_type_cycles_no_cycles(sv_cycles_schema: SchemaView, target: str, expected: set[str], fn: str) -> None:
+    """Ensure that types without cycles in their ancestry do not throw an error."""
+    if fn == "detect_cycles":
+        detect_cycles(sv_cycles_schema.type_parents, [target])
+    elif fn == "graph_closure":
+        got = graph_closure(sv_cycles_schema.type_parents, target, detect_cycles=True)
+        assert set(got) == expected
+    else:
+        got = sv_cycles_schema.type_ancestors(target, detect_cycles=True)
+        assert set(got) == expected
+
+
+@pytest.mark.parametrize(("target", "cycle_start_node"), list(CYCLES[CLASSES][0].items()))
+@pytest.mark.parametrize("fn", ["detect_cycles", "graph_closure", "class_ancestors"])
+def test_detect_class_cycles_error(sv_cycles_schema: SchemaView, target: str, cycle_start_node: str, fn: str) -> None:
+    """Test detection of class cycles in the cycles schema."""
+    if fn == "detect_cycles":
+        with pytest.raises(ValueError, match=f"Cycle detected at node '{cycle_start_node}'"):
+            detect_cycles(sv_cycles_schema.class_parents, [target])
+
+    elif fn == "graph_closure":
+        with pytest.raises(ValueError, match=f"Cycle detected at node '{cycle_start_node}'"):
+            graph_closure(sv_cycles_schema.class_parents, target, detect_cycles=True)
+    else:
+        with pytest.raises(ValueError, match=f"Cycle detected at node '{cycle_start_node}'"):
+            sv_cycles_schema.class_ancestors(target, detect_cycles=True)
+
+
+@pytest.mark.parametrize(("target", "expected"), list(CYCLES[CLASSES][1].items()))
+@pytest.mark.parametrize("fn", ["detect_cycles", "graph_closure", "class_ancestors"])
+def test_detect_class_cycles_no_cycles(sv_cycles_schema: SchemaView, target: str, expected: set[str], fn: str) -> None:
+    """Ensure that classes without cycles in their ancestry do not throw an error."""
+    if fn == "detect_cycles":
+        detect_cycles(sv_cycles_schema.class_parents, [target])
+    elif fn == "graph_closure":
+        got = graph_closure(sv_cycles_schema.class_parents, target, detect_cycles=True)
+        assert set(got) == expected
+    else:
+        got = sv_cycles_schema.class_ancestors(target, detect_cycles=True)
+        assert set(got) == expected
+
+
+@pytest.mark.parametrize("target", CYCLES[CLASSES][1].keys())
+def test_detect_class_as_range_cycles(sv_cycles_schema: SchemaView, target: str) -> None:
+    """Test cycle detection in cases where a class is used as a range."""
+
+    def check_recursive_id_slots(class_name: str) -> list[str]:
+        """Given a class, retrieve any classes used as the range for the class identifier slot."""
+        id_slot = sv_cycles_schema.get_identifier_slot(class_name, use_key=True)
+        if not id_slot:
+            return []
+        ind_range = sv_cycles_schema.slot_range_as_union(id_slot)
+        return [sv_cycles_schema.get_class(x).name for x in ind_range if sv_cycles_schema.get_class(x)] or []
+
+    # classes with a cycle in the class identifier slot range are cunningly named
+    if "IdentifierCycle" in target:
+        with pytest.raises(ValueError, match="Cycle detected at node "):
+            detect_cycles(check_recursive_id_slots, [target])
+
+    else:
+        detect_cycles(check_recursive_id_slots, [target])
+
+
 ORDERING_TESTS = {
     # Bassoon and Abacus are unranked, so appear at the end of the list.
     "rank": ["wind instrument", "instrument", "Didgeridoo", "counting instrument", "Clarinet", "Bassoon", "Abacus"],
@@ -2981,160 +3135,6 @@ def test_class_name_mappings() -> None:
     assert {snm_def.name: snm for snm, snm_def in view.slot_name_mappings().items()} == slot_names
 
 
-"""
-Tests of the detect_cycles function, which can identify cyclic relationships between classes, types, and other schema elements.
-"""
-
-
-@pytest.mark.parametrize("dodgy_input", [None, [], set(), {}, 12345, 123.45, "some string", ()])
-def test_detect_cycles_input_error(dodgy_input: Any) -> None:
-    """Ensure that `detect_cycles` throws an error if input is not supplied in the appropriate form."""
-    with pytest.raises(ValueError, match="detect_cycles requires a list of values to process"):
-        detect_cycles(lambda x: x, dodgy_input)
-
-
-@pytest.fixture(scope="module")
-def sv_cycles_schema() -> SchemaView:
-    """A schema containing cycles!"""
-    return SchemaView(INPUT_DIR_PATH / "cycles.yaml")
-
-
-# metadata for elements in the `sv_cycles_schema`
-CYCLES = {
-    TYPES: {
-        # types in cycles, either directly or via ancestors
-        # key: type, value: node where the cycle starts
-        0: {
-            "curve_type": "circular_type",
-            "semi_circular_type": "circular_type",
-            "circular_type": "circular_type",
-            "type_circular": "type_circular",
-            "circle": "circle",
-            "circle_of_life": "circle",
-        },
-        # types not involved in cycles
-        # key: the type, value: ancestors of the type
-        1: {
-            "supreme_string": {"supreme_string", "super_string", "string"},
-            "super_string": {"super_string", "string"},
-            "string": {"string"},
-            "integer": {"integer"},
-            "boolean": {"boolean"},
-        },
-    },
-    CLASSES: {
-        # classes involved in cycles
-        # key: class name, value: node where the cycle starts
-        0: {
-            "ClassA": "ClassA",
-            "ClassB": "ClassB",
-            "ClassC": "ClassC",
-            "ClassD": "ClassA",
-            "ClassE": "ClassA",
-            "ClassF": "ClassF",
-            "ClassG": "ClassF",
-            "Mixin1": "Mixin1",
-            "Mixin2": "Mixin2",
-            "MixedClass": "Mixin2",
-        },
-        # class ancestors for classes not in cycles
-        # key: class name, value: class ancestors
-        1: {
-            "BaseClass": {"BaseClass"},
-            "MixinA": {"MixinA"},  # no ID slot
-            "MixinB": {"MixinB"},  # no ID slot
-            "NonCycleClassA": {"NonCycleClassA", "BaseClass"},
-            "NonCycleClassB": {"MixinA", "NonCycleClassB", "NonCycleClassA", "BaseClass"},
-            "NonCycleClassC": {"MixinB", "NonCycleClassC", "NonCycleClassA", "BaseClass"},
-            "IdentifierCycleClassA": {"IdentifierCycleClassA"},
-            "IdentifierCycleClassB": {"IdentifierCycleClassB"},
-            "IdentifierCycleClassC": {"IdentifierCycleClassC"},
-            "IdentifierCycleClassD": {"IdentifierCycleClassD"},
-        },
-    },
-}
-
-
-@pytest.mark.parametrize(("target", "cycle_start_node"), list(CYCLES[TYPES][0].items()))
-@pytest.mark.parametrize("fn", ["detect_cycles", "graph_closure", "type_ancestors"])
-def test_detect_type_cycles_error(sv_cycles_schema: SchemaView, target: str, cycle_start_node: str, fn: str) -> None:
-    """Test detection of cycles in the types segment of the cycles schema."""
-    if fn == "detect_cycles":
-        with pytest.raises(ValueError, match=f"Cycle detected at node '{cycle_start_node}'"):
-            detect_cycles(sv_cycles_schema.type_parents, [target])
-    elif fn == "graph_closure":
-        with pytest.raises(ValueError, match=f"Cycle detected at node '{cycle_start_node}'"):
-            graph_closure(sv_cycles_schema.type_parents, target, detect_cycles=True)
-    else:
-        with pytest.raises(ValueError, match=f"Cycle detected at node '{cycle_start_node}'"):
-            sv_cycles_schema.type_ancestors(type_name=target, detect_cycles=True)
-
-
-@pytest.mark.parametrize(("target", "expected"), list(CYCLES[TYPES][1].items()))
-@pytest.mark.parametrize("fn", ["detect_cycles", "graph_closure", "type_ancestors"])
-def test_detect_type_cycles_no_cycles(sv_cycles_schema: SchemaView, target: str, expected: set[str], fn: str) -> None:
-    """Ensure that types without cycles in their ancestry do not throw an error."""
-    if fn == "detect_cycles":
-        detect_cycles(sv_cycles_schema.type_parents, [target])
-    elif fn == "graph_closure":
-        got = graph_closure(sv_cycles_schema.type_parents, target, detect_cycles=True)
-        assert set(got) == expected
-    else:
-        got = sv_cycles_schema.type_ancestors(target, detect_cycles=True)
-        assert set(got) == expected
-
-
-@pytest.mark.parametrize(("target", "cycle_start_node"), list(CYCLES[CLASSES][0].items()))
-@pytest.mark.parametrize("fn", ["detect_cycles", "graph_closure", "class_ancestors"])
-def test_detect_class_cycles_error(sv_cycles_schema: SchemaView, target: str, cycle_start_node: str, fn: str) -> None:
-    """Test detection of class cycles in the cycles schema."""
-    if fn == "detect_cycles":
-        with pytest.raises(ValueError, match=f"Cycle detected at node '{cycle_start_node}'"):
-            detect_cycles(sv_cycles_schema.class_parents, [target])
-
-    elif fn == "graph_closure":
-        with pytest.raises(ValueError, match=f"Cycle detected at node '{cycle_start_node}'"):
-            graph_closure(sv_cycles_schema.class_parents, target, detect_cycles=True)
-    else:
-        with pytest.raises(ValueError, match=f"Cycle detected at node '{cycle_start_node}'"):
-            sv_cycles_schema.class_ancestors(target, detect_cycles=True)
-
-
-@pytest.mark.parametrize(("target", "expected"), list(CYCLES[CLASSES][1].items()))
-@pytest.mark.parametrize("fn", ["detect_cycles", "graph_closure", "class_ancestors"])
-def test_detect_class_cycles_no_cycles(sv_cycles_schema: SchemaView, target: str, expected: set[str], fn: str) -> None:
-    """Ensure that classes without cycles in their ancestry do not throw an error."""
-    if fn == "detect_cycles":
-        detect_cycles(sv_cycles_schema.class_parents, [target])
-    elif fn == "graph_closure":
-        got = graph_closure(sv_cycles_schema.class_parents, target, detect_cycles=True)
-        assert set(got) == expected
-    else:
-        got = sv_cycles_schema.class_ancestors(target, detect_cycles=True)
-        assert set(got) == expected
-
-
-@pytest.mark.parametrize("target", CYCLES[CLASSES][1].keys())
-def test_detect_class_as_range_cycles(sv_cycles_schema: SchemaView, target: str) -> None:
-    """Test cycle detection in cases where a class is used as a range."""
-
-    def check_recursive_id_slots(class_name: str) -> list[str]:
-        """Given a class, retrieve any classes used as the range for the class identifier slot."""
-        id_slot = sv_cycles_schema.get_identifier_slot(class_name, use_key=True)
-        if not id_slot:
-            return []
-        ind_range = sv_cycles_schema.slot_range_as_union(id_slot)
-        return [sv_cycles_schema.get_class(x).name for x in ind_range if sv_cycles_schema.get_class(x)] or []
-
-    # classes with a cycle in the class identifier slot range are cunningly named
-    if "IdentifierCycle" in target:
-        with pytest.raises(ValueError, match="Cycle detected at node "):
-            detect_cycles(check_recursive_id_slots, [target])
-
-    else:
-        detect_cycles(check_recursive_id_slots, [target])
-
-
 @pytest.mark.parametrize(
     ("entity_type", "entity_name", "type_for_methods", "get_all_method"),
     [