Merge branch 'main' into pretty-print

Author: sneakers-the-rat

linkml_runtime/exceptions.py

@@ -0,0 +1,2 @@
+class OrderingError(RuntimeError):
+    """Exception raised when there is a problem with SchemaView ordering"""

linkml_runtime/utils/eval_utils.py

@@ -17,7 +17,12 @@
 
 def eval_conditional(*conds: List[Tuple[bool, Any]]) -> Any:
     """
-    >>> cond(x < 25 : 'low', x > 25 : 'high', True: 'low')
+    Evaluate a collection of expression,value tuples, returing the first value whose expression is true
+
+    >>> x= 40
+    >>> eval_conditional((x < 25, 'low'),  (x > 25, 'high'), (True, 'low'))
+    'high'
+
     :param subj:
     :return:
     """
@@ -58,10 +63,9 @@ def eval_expr(expr: str, **kwargs) -> Any:
 
     Nulls:
 
-    - If a variable is enclosed in {}s then entire expression will eval to None if variable is unset
+    - If a variable is enclosed in {}s then entire expression will eval to None if any variable is unset
 
-    >>> eval_expr('{x} + {y}', x=None, y=2)
-    None
+    >>> assert eval_expr('{x} + {y}', x=None, y=2) is None
 
     Functions:
 
@@ -92,9 +96,6 @@ def eval_expr(expr: str, **kwargs) -> Any:
 
 
 
-
-
-
 def eval_(node, bindings={}):
     if isinstance(node, ast.Num):
         return node.n

linkml_runtime/utils/schemaview.py

@@ -6,14 +6,15 @@
 from copy import copy, deepcopy
 from collections import defaultdict, deque
 from pathlib import Path
-from typing import Mapping, Tuple
+from typing import Mapping, Tuple, TypeVar
 import warnings
 
 from linkml_runtime.utils.namespaces import Namespaces
 from deprecated.classic import deprecated
 from linkml_runtime.utils.context_utils import parse_import_map, map_import
 from linkml_runtime.utils.pattern import PatternResolver
 from linkml_runtime.linkml_model.meta import *
+from linkml_runtime.exceptions import OrderingError
 from enum import Enum
 
 logger = logging.getLogger(__name__)
@@ -33,11 +34,23 @@
 TYPE_NAME = Union[TypeDefinitionName, str]
 ENUM_NAME = Union[EnumDefinitionName, str]
 
+ElementType = TypeVar("ElementType", bound=Element)
+ElementNameType = TypeVar("ElementNameType", bound=Union[ElementName,str])
+DefinitionType = TypeVar("DefinitionType", bound=Definition)
+DefinitionNameType = TypeVar("DefinitionNameType", bound=Union[DefinitionName,str])
+ElementDict = Dict[ElementNameType, ElementType]
+DefDict = Dict[DefinitionNameType, DefinitionType]
+
 
 class OrderedBy(Enum):
     RANK = "rank"
     LEXICAL = "lexical"
     PRESERVE = "preserve"
+    INHERITANCE = "inheritance"
+    """
+    Order according to inheritance such that if C is a child of P then C appears after P
+    """
+
 
 
 def _closure(f, x, reflexive=True, depth_first=True, **kwargs):
@@ -305,7 +318,22 @@ def all_class(self, imports=True) -> Dict[ClassDefinitionName, ClassDefinition]:
         """
         return self._get_dict(CLASSES, imports)
 
-    def _order_lexically(self, elements: dict):
+    def ordered(self, elements: ElementDict, ordered_by: Optional[OrderedBy] = None) -> ElementDict:
+        """
+        Order a dictionary of elements with some ordering method in :class:`.OrderedBy`
+        """
+        if ordered_by in (OrderedBy.LEXICAL, OrderedBy.LEXICAL.value):
+            return self._order_lexically(elements)
+        elif ordered_by in (OrderedBy.RANK, OrderedBy.RANK.value):
+            return self._order_rank(elements)
+        elif ordered_by in (OrderedBy.INHERITANCE, OrderedBy.INHERITANCE.value):
+            return self._order_inheritance(elements)
+        elif ordered_by is None or ordered_by in (OrderedBy.PRESERVE, OrderedBy.PRESERVE.value):
+            return elements
+        else:
+            raise ValueError(f"ordered_by must be in OrderedBy or None, got {ordered_by}")
+
+    def _order_lexically(self, elements: ElementDict) -> ElementDict:
         """
         :param element: slots or class type to order
         :param imports
@@ -320,7 +348,7 @@ def _order_lexically(self, elements: dict):
             ordered_elements[self.get_element(name).name] = self.get_element(name)
         return ordered_elements
 
-    def _order_rank(self, elements: dict):
+    def _order_rank(self, elements: ElementDict) -> ElementDict:
         """
         :param elements: slots or classes to order
         :return: all classes or slots sorted by their rank in schema view
@@ -342,6 +370,32 @@ def _order_rank(self, elements: dict):
         rank_ordered_elements.update(unranked_map)
         return rank_ordered_elements
 
+    def _order_inheritance(self, elements: DefDict) -> DefDict:
+        """
+        sort classes such that if C is a child of P then C appears after P in the list
+        """
+        clist = list(elements.values())
+        slist = []  # sorted
+        can_add = False
+        while len(clist) > 0:
+            for i in range(len(clist)):
+                candidate = clist[i]
+                can_add = False
+                if candidate.is_a is None:
+                    can_add = True
+                else:
+                    if candidate.is_a in [p.name for p in slist]:
+                        can_add = True
+                if can_add:
+                    slist = slist + [candidate]
+                    del clist[i]
+                    break
+            if not can_add:
+                raise OrderingError(f"could not find suitable element in {clist} that does not ref {slist}")
+
+        return {s.name: s for s in slist}
+
+
     @lru_cache(None)
     def all_classes(self, ordered_by=OrderedBy.PRESERVE, imports=True) -> Dict[ClassDefinitionName, ClassDefinition]:
         """
@@ -350,15 +404,8 @@ def all_classes(self, ordered_by=OrderedBy.PRESERVE, imports=True) -> Dict[Class
         :return: all classes in schema view
         """
         classes = copy(self._get_dict(CLASSES, imports))
-
-        if ordered_by == OrderedBy.LEXICAL:
-            ordered_classes = self._order_lexically(elements=classes)
-        elif ordered_by == OrderedBy.RANK:
-            ordered_classes = self._order_rank(elements=classes)
-        else:  # else preserve the order in the yaml
-            ordered_classes = classes
-
-        return ordered_classes
+        classes = self.ordered(classes, ordered_by=ordered_by)
+        return classes
 
     @deprecated("Use `all_slots` instead")
     @lru_cache(None)
@@ -386,14 +433,8 @@ def all_slots(self, ordered_by=OrderedBy.PRESERVE, imports=True, attributes=True
                     if aname not in slots:
                         slots[aname] = a
 
-        if ordered_by == OrderedBy.LEXICAL:
-            ordered_slots = self._order_lexically(elements=slots)
-        elif ordered_by == OrderedBy.RANK:
-            ordered_slots = self._order_rank(elements=slots)
-        else:
-            # preserve order in YAML
-            ordered_slots = slots
-        return ordered_slots
+        slots = self.ordered(slots, ordered_by=ordered_by)
+        return slots
 
     @deprecated("Use `all_enums` instead")
     @lru_cache(None)

tests/test_utils/test_eval_utils.py

@@ -1,7 +1,8 @@
-import unittest
 from dataclasses import dataclass
 from typing import List, Dict
 
+import pytest
+
 from linkml_runtime.utils.eval_utils import eval_expr
 
 
@@ -24,90 +25,58 @@ class Container:
     person_index: Dict[str, Person] = None
 
 
-class EvalUtilsTestCase(unittest.TestCase):
-    """
-    Tests for linkml_runtime.utils.eval_utils
-    """
-
-    def test_eval_expressions(self):
-        """
-        Tests evaluation of expressions using eval_expr
-        """
-        x = eval_expr("1 + 2")
-        self.assertEqual(x, 3)
-        self.assertEqual(eval_expr("1 + 2 + 3"), 6)
-        x = eval_expr("{z} + 2", z=1)
-        self.assertEqual(x, 3)
-        self.assertIsNone(eval_expr('{x} + {y}', x=5, y=None))
-        x = eval_expr("'x' + 'y'")
-        assert x == 'xy'
-        #x = eval_expr("'{x}' + '{y}'", x='a', y='b')
-        #self.assertEqual(x, 'ab')
-        self.assertEqual(eval_expr("['a','b'] + ['c','d']"), ['a', 'b', 'c', 'd'])
-        self.assertEqual(eval_expr("{x} + {y}", x=['a', 'b'], y=['c', 'd']), ['a', 'b', 'c', 'd'])
-        self.assertEqual(eval_expr("{'a': 1}"), {'a': 1})
-        self.assertEqual(eval_expr("max([1, 5, 2])"), 5)
-        self.assertEqual(eval_expr("max({x})", x=[1, 5, 2]), 5)
-        self.assertEqual(eval_expr("True"), True)
-        self.assertEqual(eval_expr("False"), False)
-        self.assertEqual(eval_expr("1 + 1 == 3"), False)
-        self.assertEqual(eval_expr("1 < 2"), True)
-        self.assertEqual(eval_expr("1 <= 1"), True)
-        self.assertEqual(eval_expr("1 >= 1"), True)
-        self.assertEqual(eval_expr("2 > 1"), True)
-        self.assertEqual(eval_expr("'EQ' if {x} == {y} else 'NEQ'", x=1, y=1), 'EQ')
-        self.assertEqual(eval_expr("'EQ' if {x} == {y} else 'NEQ'", x=1, y=2), 'NEQ')
-        self.assertEqual(eval_expr("'NOT_NULL' if x else 'NULL'", x=1), 'NOT_NULL')
-        self.assertEqual(eval_expr("'NOT_NULL' if x else 'NULL'", x=None), 'NULL')
-        self.assertEqual(eval_expr("'EQ' if {x} == {y} else 'NEQ'", x=1, y=2), 'NEQ')
-        case = "case(({x} < 25, 'LOW'), ({x} > 75, 'HIGH'), (True, 'MEDIUM'))"
-        self.assertEqual(eval_expr(case, x=10), 'LOW')
-        self.assertEqual(eval_expr(case, x=100), 'HIGH')
-        self.assertEqual(eval_expr(case, x=50), 'MEDIUM')
-        self.assertEqual(eval_expr('x', x='a'), 'a')
-        self.assertEqual(eval_expr('x+y', x=1, y=2), 3)
-        # todo
-        self.assertEqual(eval_expr('x["a"] + y', x={'a': 1}, y=2), 3)
-        self.assertEqual(eval_expr('x["a"]["b"] + y', x={'a': {'b': 1}}, y=2), 3)
-        p = Person(name='x', aliases=['a', 'b', 'c'], address=Address(street='1 x street'))
-        self.assertEqual(eval_expr('p.name', p=p), 'x')
-        self.assertEqual(eval_expr('p.address.street', p=p), '1 x street')
-        self.assertEqual(eval_expr('len(p.aliases)', p=p), 3)
-        self.assertEqual(eval_expr('p.aliases', p=p), p.aliases)
-        p2 = Person(name='x2', aliases=['a2', 'b2', 'c2'], address=Address(street='2 x street'))
-        c = Container(persons=[p, p2])
-        x = eval_expr('c.persons.name', c=c)
-        self.assertEqual(x, ['x', 'x2'])
-        x = eval_expr('c.persons.address.street', c=c)
-        self.assertEqual(x, ['1 x street', '2 x street'])
-        x = eval_expr('strlen(c.persons.address.street)', c=c)
-        self.assertEqual(x, [10, 10])
-        c = Container(person_index={p.name: p, p2.name: p2})
-        x = eval_expr('c.person_index.name', c=c)
-        #print(x)
-        self.assertEqual(x, ['x', 'x2'])
-        x = eval_expr('c.person_index.address.street', c=c)
-        self.assertEqual(x, ['1 x street', '2 x street'])
-        x = eval_expr('strlen(c.person_index.name)', c=c)
-        self.assertEqual(x, [1, 2])
-        #self.assertEqual('x', eval_expr('"x" if True else "y"'))
-
-    def test_no_eval_prohibited(self):
-        """
-        Ensure that certain patterns cannot be evaluated
+def test_eval_expressions():
+    assert eval_expr("1 + 2") == 3
+    assert eval_expr("1 + 2 + 3") == 6
+    assert eval_expr("{z} + 2", z=1) == 3
+    assert eval_expr('{x} + {y}', x=5, y=None) is None
+    assert eval_expr("'x' + 'y'") == 'xy'
+    assert eval_expr("['a','b'] + ['c','d']") == ['a', 'b', 'c', 'd']
+    assert eval_expr("{x} + {y}", x=['a', 'b'], y=['c', 'd']) == ['a', 'b', 'c', 'd']
+    assert eval_expr("{'a': 1}") == {'a': 1}
+    assert eval_expr("max([1, 5, 2])") == 5
+    assert eval_expr("max({x})", x=[1, 5, 2]) == 5
+    assert eval_expr("True") is True
+    assert eval_expr("False") is False
+    assert eval_expr("1 + 1 == 3") is False
+    assert eval_expr("1 < 2") is True
+    assert eval_expr("1 <= 1") is True
+    assert eval_expr("1 >= 1") is True
+    assert eval_expr("2 > 1") is True
+    assert eval_expr("'EQ' if {x} == {y} else 'NEQ'", x=1, y=1) == 'EQ'
+    assert eval_expr("'EQ' if {x} == {y} else 'NEQ'", x=1, y=2) == 'NEQ'
+    assert eval_expr("'NOT_NULL' if x else 'NULL'", x=1) == 'NOT_NULL'
+    assert eval_expr("'NOT_NULL' if x else 'NULL'", x=None) == 'NULL'
+    assert eval_expr("'EQ' if {x} == {y} else 'NEQ'", x=1, y=2) == 'NEQ'
+    case = "case(({x} < 25, 'LOW'), ({x} > 75, 'HIGH'), (True, 'MEDIUM'))"
+    assert eval_expr(case, x=10) == 'LOW'
+    assert eval_expr(case, x=100) == 'HIGH'
+    assert eval_expr(case, x=50) == 'MEDIUM'
+    assert eval_expr('x', x='a') == 'a'
+    assert eval_expr('x+y', x=1, y=2) == 3
+    assert eval_expr('x["a"] + y', x={'a': 1}, y=2) == 3
+    assert eval_expr('x["a"]["b"] + y', x={'a': {'b': 1}}, y=2) == 3
+    p = Person(name='x', aliases=['a', 'b', 'c'], address=Address(street='1 x street'))
+    assert eval_expr('p.name', p=p) == 'x'
+    assert eval_expr('p.address.street', p=p) == '1 x street'
+    assert eval_expr('len(p.aliases)', p=p) == 3
+    assert eval_expr('p.aliases', p=p) == p.aliases
+    p2 = Person(name='x2', aliases=['a2', 'b2', 'c2'], address=Address(street='2 x street'))
+    c = Container(persons=[p, p2])
+    assert eval_expr('c.persons.name', c=c) == ['x', 'x2']
+    assert eval_expr('c.persons.address.street', c=c) == ['1 x street', '2 x street']
+    assert eval_expr('strlen(c.persons.address.street)', c=c) == [10, 10]
+    c = Container(person_index={p.name: p, p2.name: p2})
+    assert eval_expr('c.person_index.name', c=c) == ['x', 'x2']
+    assert eval_expr('c.person_index.address.street', c=c) == ['1 x street', '2 x street']
+    assert eval_expr('strlen(c.person_index.name)', c=c) == [1, 2]
 
-        See `<https://stackoverflow.com/questions/2371436/evaluating-a-mathematical-expression-in-a-string>`_
-        """
-        with self.assertRaises(NotImplementedError):
-            eval_expr("__import__('os').listdir()")
 
-    def test_funcs(self):
-        """
-        Not yet implemented
-        """
-        with self.assertRaises(NotImplementedError):
-            eval_expr("my_func([1,2,3])")
+def test_no_eval_prohibited():
+    with pytest.raises(NotImplementedError):
+        eval_expr("__import__('os').listdir()")
 
 
-if __name__ == '__main__':
-    unittest.main()
+def test_funcs():
+    with pytest.raises(NotImplementedError):
+        eval_expr("my_func([1,2,3])")