fix tests, convert schemaview to pytest

Author: sierra-moxon

linkml_runtime/utils/schemaview.py

@@ -8,6 +8,7 @@
 from pathlib import Path
 from typing import Mapping, Optional, Tuple, TypeVar
 import warnings
+from pprint import pprint
 
 from linkml_runtime.utils.namespaces import Namespaces
 from deprecated.classic import deprecated
@@ -17,6 +18,8 @@
 from linkml_runtime.linkml_model.meta import *
 from linkml_runtime.exceptions import OrderingError
 from enum import Enum
+from linkml_runtime.linkml_model.meta import ClassDefinition, SlotDefinition, ClassDefinitionName
+from dataclasses import asdict, is_dataclass, fields
 
 logger = logging.getLogger(__name__)
 
@@ -36,9 +39,9 @@
 ENUM_NAME = Union[EnumDefinitionName, str]
 
 ElementType = TypeVar("ElementType", bound=Element)
-ElementNameType = TypeVar("ElementNameType", bound=Union[ElementName,str])
+ElementNameType = TypeVar("ElementNameType", bound=Union[ElementName, str])
 DefinitionType = TypeVar("DefinitionType", bound=Definition)
-DefinitionNameType = TypeVar("DefinitionNameType", bound=Union[DefinitionName,str])
+DefinitionNameType = TypeVar("DefinitionNameType", bound=Union[DefinitionName, str])
 ElementDict = Dict[ElementNameType, ElementType]
 DefDict = Dict[DefinitionNameType, DefinitionType]
 
@@ -53,7 +56,6 @@ class OrderedBy(Enum):
     """
 
 
-
 def _closure(f, x, reflexive=True, depth_first=True, **kwargs):
     if reflexive:
         rv = [x]
@@ -84,7 +86,7 @@ def load_schema_wrap(path: str, **kwargs):
     schema: SchemaDefinition
     schema = yaml_loader.load(path, target_class=SchemaDefinition, **kwargs)
     if "\n" not in path:
-    # if "\n" not in path and "://" not in path:
+        # if "\n" not in path and "://" not in path:
         # only set path if the input is not a yaml string or URL.
         # Setting the source path is necessary for relative imports;
         # while initializing a schema with a yaml string is possible, there
@@ -146,6 +148,7 @@ def get_anonymous_class_definition(class_as_dict: ClassDefinition) -> AnonymousC
     :return: An AnonymousClassExpression.
     """
     an_expr = AnonymousClassExpression()
+    print(class_as_dict)
     valid_fields = {field.name for field in fields(an_expr)}
     for k, v in class_as_dict.items():
         if k in valid_fields:
@@ -154,6 +157,7 @@ def get_anonymous_class_definition(class_as_dict: ClassDefinition) -> AnonymousC
         setattr(an_expr, k, v)
     return an_expr
 
+
 @dataclass
 class SchemaView(object):
     """
@@ -265,7 +269,8 @@ def load_import(self, imp: str, from_schema: SchemaDefinition = None):
         return schema
 
     @lru_cache(None)
-    def imports_closure(self, imports: bool = True, traverse: Optional[bool] = None, inject_metadata=True) -> List[SchemaDefinitionName]:
+    def imports_closure(self, imports: bool = True, traverse: Optional[bool] = None, inject_metadata=True) -> List[
+        SchemaDefinitionName]:
         """
         Return all imports
 
@@ -350,7 +355,7 @@ def imports_closure(self, imports: bool = True, traverse: Optional[bool] = None,
             visited.add(sn)
 
         # filter duplicates, keeping first entry
-        closure = list({k:None for k in closure}.keys())
+        closure = list({k: None for k in closure}.keys())
 
         if inject_metadata:
             for s in self.schema_map.values():
@@ -456,7 +461,6 @@ def _order_inheritance(self, elements: DefDict) -> DefDict:
 
         return {s.name: s for s in slist}
 
-
     @lru_cache(None)
     def all_classes(self, ordered_by=OrderedBy.PRESERVE, imports=True) -> Dict[ClassDefinitionName, ClassDefinition]:
         """
@@ -901,15 +905,14 @@ def permissible_value_ancestors(self, permissible_value_text: str,
 
     @lru_cache(None)
     def permissible_value_descendants(self, permissible_value_text: str,
-                                    enum_name: ENUM_NAME,
-                                    reflexive=True,
-                                    depth_first=True) -> List[str]:
+                                      enum_name: ENUM_NAME,
+                                      reflexive=True,
+                                      depth_first=True) -> List[str]:
         """
         Closure of permissible_value_children method
         :enum
         """
 
-
         return _closure(lambda x: self.permissible_value_children(x, enum_name),
                         permissible_value_text,
                         reflexive=reflexive,
@@ -1368,7 +1371,6 @@ def induced_slot(self, slot_name: SLOT_NAME, class_name: CLASS_NAME = None, impo
         :param slot_name: slot to be queries
         :param class_name: class used as context
         :param imports: include imports closure
-        :param mangle_name: if True, the slot name will be mangled to include the class name
         :return: dynamic slot constructed by inference
         """
         if class_name:
@@ -1412,53 +1414,18 @@ def induced_slot(self, slot_name: SLOT_NAME, class_name: CLASS_NAME = None, impo
         }
         # iterate through all metaslots, and potentially populate metaslot value for induced slot
         for metaslot_name in self._metaslots_for_slot():
-
             # inheritance of slots; priority order
             #   slot-level assignment < ancestor slot_usage < self slot_usage
             v = getattr(induced_slot, metaslot_name, None)
             if cls is None:
                 propagated_from = []
             else:
                 propagated_from = self.class_ancestors(class_name, reflexive=True, mixins=True)
-
             for an in reversed(propagated_from):
                 induced_slot.owner = an
-                a = self.get_element(an, imports)
-                # slot usage of the slot in the ancestor class, last ancestor iterated through here is "self"
-                # so that self.slot_usage overrides ancestor slot_usage at the conclusion of the loop.
+                a = self.get_class(an, imports)
                 anc_slot_usage = a.slot_usage.get(slot_name, {})
-                # slot name in the ancestor class
-                # getattr(x, 'y') is equivalent to x.y. None here means raise an error if x.y is not found
                 v2 = getattr(anc_slot_usage, metaslot_name, None)
-                # v2 is the value of the metaslot in slot_usage in the ancestor class, which in the loop, means that
-                # the class itself is the last slot_usage to be considered and applied.
-                if metaslot_name in ["any_of", "exactly_one_of"]:
-                    if anc_slot_usage != {}:
-                        for ao in anc_slot_usage.any_of:
-                            if ao.range is not None:
-                                ao_range = self.get_element(ao.range)
-                                if ao_range:
-                                    print(ao_range)
-                                    acd = get_anonymous_class_definition(to_dict(ao_range))
-                                    if induced_slot.range_expression is None:
-                                        induced_slot.range_expression = AnonymousClassExpression()
-                                    if induced_slot.range_expression.any_of is None:
-                                        induced_slot.range_expression.any_of = []
-                                    # Check for duplicates before appending
-                                    if acd not in induced_slot.range_expression.any_of:
-                                        induced_slot.range_expression.any_of.append(acd)
-                        for eoo in anc_slot_usage.exactly_one_of:
-                            if eoo.range is not None:
-                                eoo_range = self.get_element(eoo.range)
-                                print(eoo_range)
-                                acd = get_anonymous_class_definition(as_dict(eoo_range))
-                                if induced_slot.range_expression is None:
-                                    induced_slot.range_expression = AnonymousClassExpression()
-                                if induced_slot.range_expression.exactly_one_of is None:
-                                    induced_slot.range_expression.exactly_one_of = []
-                                # Check for duplicates before appending
-                                if acd not in induced_slot.range_expression.exactly_one_of:
-                                    induced_slot.range_expression.exactly_one_of.append(acd)
                 if v is None:
                     v = v2
                 else:
@@ -1494,33 +1461,8 @@ def induced_slot(self, slot_name: SLOT_NAME, class_name: CLASS_NAME = None, impo
             if induced_slot.name in c.slots or induced_slot.name in c.attributes:
                 if c.name not in induced_slot.domain_of:
                     induced_slot.domain_of.append(c.name)
-        if induced_slot.range is not None:
-            if induced_slot.range_expression is None:
-                induced_slot.range_expression = AnonymousClassExpression()
-                induced_slot.range_expression.any_of = []
-                induced_slot.range_expression.any_of.append(
-                    get_anonymous_class_definition(to_dict(self.get_element(induced_slot.range)))
-                )
-                return induced_slot
-            else:
-                any_of_ancestors = []
-                if induced_slot.range_expression.any_of is not None:
-                    for ao_range in induced_slot.range_expression.any_of:
-                        ao_range_class = self.get_class(ao_range.name)
-                        ao_anc = self.class_ancestors(ao_range_class.name)
-                        for a in ao_anc:
-                            if a not in any_of_ancestors:
-                                any_of_ancestors.append(a)
-                if induced_slot.range in any_of_ancestors:
-                    return induced_slot
-                else:
-                    induced_slot.range_expression.any_of.append(
-                        get_anonymous_class_definition(to_dict(self.get_element(induced_slot.range)))
-                    )
-                return induced_slot
         return induced_slot
 
-
     @lru_cache(None)
     def _metaslots_for_slot(self):
         fake_slot = SlotDefinition('__FAKE')
@@ -1645,7 +1587,7 @@ def is_inlined(self, slot: SlotDefinition, imports=True) -> bool:
                 return True
             elif slot.inlined_as_list:
                 return True
-            
+
             id_slot = self.get_identifier_slot(range, imports=imports)
             if id_slot is None:
                 # must be inlined as has no identifier
@@ -1689,7 +1631,7 @@ def slot_range_as_union(self, slot: SlotDefinition) -> List[ElementName]:
         """
         Returns all applicable ranges for a slot
 
-        Typically any given slot has exactly one range, and one metamodel element type,
+        Typically, any given slot has exactly one range, and one metamodel element type,
         but a proposed feature in LinkML 1.2 is range expressions, where ranges can be defined as unions
 
         :param slot:
@@ -1701,9 +1643,9 @@ def slot_range_as_union(self, slot: SlotDefinition) -> List[ElementName]:
             if x.range:
                 range_union_of.append(x.range)
         return range_union_of
-        
+
     def get_classes_by_slot(
-        self, slot: SlotDefinition, include_induced: bool = False
+            self, slot: SlotDefinition, include_induced: bool = False
     ) -> List[ClassDefinitionName]:
         """Get all classes that use a given slot, either as a direct or induced slot.