From b9089912754b36b5b474ef187641b95111c72460 Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Tue, 21 Oct 2025 13:51:59 -0700 Subject: [PATCH 1/2] Deprecate `permissible_value_parent` and replace it with `permissible_value_parents`. --- linkml_runtime/utils/schemaview.py | 26 ++++++++++++++++++++------ tests/test_utils/test_schemaview.py | 13 +++++++------ 2 files changed, 27 insertions(+), 12 deletions(-) diff --git a/linkml_runtime/utils/schemaview.py b/linkml_runtime/utils/schemaview.py index efdeefb1..bfa9a8cf 100644 --- a/linkml_runtime/utils/schemaview.py +++ b/linkml_runtime/utils/schemaview.py @@ -899,7 +899,9 @@ def _parents(self, e: Element, imports: bool = True, mixins: bool = True, is_a: def class_parents( self, class_name: CLASS_NAME, imports: bool = True, mixins: bool = True, is_a: bool = True ) -> list[ClassDefinitionName]: - """:param class_name: child class name + """Get the parents of a class. + + :param class_name: child class name :param imports: include import closure :param mixins: include mixins (default is True) :return: all direct parent class names (is_a and mixins) @@ -1167,7 +1169,9 @@ def type_roots(self, imports: bool = True) -> list[TypeDefinitionName]: def enum_parents( self, enum_name: ENUM_NAME, imports: bool = False, mixins: bool = False, is_a: bool = True ) -> list[EnumDefinitionName]: - """:param enum_name: child enum name + """Get the parents of an enum. + + :param enum_name: child enum name :param imports: include import closure (False) :param mixins: include mixins (default is False) :return: all direct parent enum names (is_a and mixins) @@ -1204,11 +1208,19 @@ def enum_ancestors( **kwargs, ) - @lru_cache(None) + @deprecated("Use `permissible_value_parents` instead") def permissible_value_parent( self, permissible_value: str, enum_name: ENUM_NAME ) -> list[str | PermissibleValueText]: - """:param enum_name: child enum name + return self.permissible_value_parents(permissible_value, enum_name) + + @lru_cache(None) + def permissible_value_parents( + self, permissible_value: str, enum_name: ENUM_NAME + ) -> list[str | PermissibleValueText]: + """Get the parents of a permissible value. + + :param enum_name: child enum name :param permissible_value: permissible value :return: all direct parent enum names (is_a) """ @@ -1223,7 +1235,9 @@ def permissible_value_parent( def permissible_value_children( self, permissible_value: str, enum_name: ENUM_NAME ) -> list[str | PermissibleValueText]: - """:param enum_name: parent enum name + """Get the children of a permissible value. + + :param enum_name: parent enum name :param permissible_value: permissible value :return: all direct child permissible values (is_a) """ @@ -1262,7 +1276,7 @@ def permissible_value_ancestors( :rtype: list[str] """ return _closure( - lambda x: self.permissible_value_parent(x, enum_name), + lambda x: self.permissible_value_parents(x, enum_name), permissible_value_text, reflexive=reflexive, depth_first=depth_first, diff --git a/tests/test_utils/test_schemaview.py b/tests/test_utils/test_schemaview.py index 6a5bf086..d9ac2289 100644 --- a/tests/test_utils/test_schemaview.py +++ b/tests/test_utils/test_schemaview.py @@ -718,7 +718,7 @@ def test_metamodel_in_schemaview() -> None: for tn in ["uriorcurie", "string", "float"]: assert tn in view.all_types() assert tn not in view.all_types(imports=False) - for cn, c in view.all_classes().items(): + for cn in view.all_classes(): uri = view.get_uri(cn, expand=True) assert uri is not None if cn not in ["structured_alias", "UnitOfMeasure", "ValidationReport", "ValidationResult"]: @@ -1598,7 +1598,7 @@ def test_type_roots(schema: str, type_roots: set[str]) -> None: def test_all_enums(schema_view_with_imports: SchemaView) -> None: - """Test all_enums""" + """Test all_enums.""" view = schema_view_with_imports for en, e in view.all_enums().items(): @@ -1809,6 +1809,7 @@ def gen_schema_name(range_tuple: tuple[str, str | None, str | None]) -> str | No def gen_range_file_with_default(range_id: str, tmp_path_factory: pytest.TempPathFactory) -> Path: """Generate a copy of the range file with a default_range added and return the path. + Obviates the need for maintaining a copy with a default_range tagged to the end. :param range_id: the range file to use; must be one of RL, RI @@ -2232,28 +2233,28 @@ def test_permissible_value_relationships(schema_view_no_imports: SchemaView) -> pv_cat = animal_enum.permissible_values["CAT"] assert pv_cat.text == "CAT" assert pv_cat.is_a is None - assert view.permissible_value_parent("CAT", animals) == [] + assert view.permissible_value_parents("CAT", animals) == [] assert view.permissible_value_ancestors("CAT", animals) == ["CAT"] assert set(view.permissible_value_children("CAT", animals)) == {"LION", "TABBY"} assert set(view.permissible_value_descendants("CAT", animals)) == {"CAT", "LION", "ANGRY_LION", "TABBY"} pv_tabby = animal_enum.permissible_values["TABBY"] assert pv_tabby.is_a == "CAT" - assert view.permissible_value_parent("TABBY", animals) == ["CAT"] + assert view.permissible_value_parents("TABBY", animals) == ["CAT"] assert view.permissible_value_ancestors("TABBY", animals) == ["TABBY", "CAT"] assert view.permissible_value_children("TABBY", animals) == [] assert view.permissible_value_descendants("TABBY", animals) == ["TABBY"] pv_lion = animal_enum.permissible_values["LION"] assert pv_lion.is_a == "CAT" - assert view.permissible_value_parent("LION", animals) == ["CAT"] + assert view.permissible_value_parents("LION", animals) == ["CAT"] assert view.permissible_value_ancestors("LION", animals) == ["LION", "CAT"] assert view.permissible_value_children("LION", animals) == ["ANGRY_LION"] assert view.permissible_value_descendants("LION", animals) == ["LION", "ANGRY_LION"] pv_angry_lion = animal_enum.permissible_values["ANGRY_LION"] assert pv_angry_lion.is_a == "LION" - assert view.permissible_value_parent("ANGRY_LION", animals) == ["LION"] + assert view.permissible_value_parents("ANGRY_LION", animals) == ["LION"] assert view.permissible_value_ancestors("ANGRY_LION", animals) == ["ANGRY_LION", "LION", "CAT"] assert view.permissible_value_children("ANGRY_LION", animals) == [] assert view.permissible_value_descendants("ANGRY_LION", animals) == ["ANGRY_LION"] From d0e9d93f0950e6971c56f6b61f1a81ed5aef1c00 Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Tue, 21 Oct 2025 14:29:27 -0700 Subject: [PATCH 2/2] Fix docs for permissible_value_parents/children --- linkml_runtime/utils/schemaview.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/linkml_runtime/utils/schemaview.py b/linkml_runtime/utils/schemaview.py index bfa9a8cf..cecde27b 100644 --- a/linkml_runtime/utils/schemaview.py +++ b/linkml_runtime/utils/schemaview.py @@ -1220,8 +1220,8 @@ def permissible_value_parents( ) -> list[str | PermissibleValueText]: """Get the parents of a permissible value. - :param enum_name: child enum name :param permissible_value: permissible value + :param enum_name: enum for which this is a permissible value :return: all direct parent enum names (is_a) """ enum = self.get_enum(enum_name, strict=True) @@ -1237,8 +1237,8 @@ def permissible_value_children( ) -> list[str | PermissibleValueText]: """Get the children of a permissible value. - :param enum_name: parent enum name :param permissible_value: permissible value + :param enum_name: enum for which this is a permissible value :return: all direct child permissible values (is_a) """ enum = self.get_enum(enum_name, strict=True)