added __str__ to view ErrorDict for human-readable formatting, added getters on various levels

Author: keighrim

mmif/serialize/mmif.py

@@ -447,6 +447,16 @@ def get_views_for_document(self, doc_id: str) -> List[View]:
                             pass
         return views
 
+    def get_all_views_with_error(self) -> List[View]:
+        """
+        Returns the list of all views in the MMIF that have errors. 
+        
+        :return: the list of views that contain errors but no annotations
+        """
+        return [v for v in self.views if v.has_error()]
+    
+    get_views_with_error = get_all_views_with_error
+            
     def get_all_views_contain(self, at_types: Union[ThingTypesBase, str, List[Union[str, ThingTypesBase]]]) -> List[View]:
         """
         Returns the list of all views in the MMIF if given types
@@ -461,11 +471,27 @@ def get_all_views_contain(self, at_types: Union[ThingTypesBase, str, List[Union[
         else:
             return [view for view in self.views if at_types in view.metadata.contains]
 
-    def get_views_contain(self, at_types: Union[ThingTypesBase, str, List[Union[str, ThingTypesBase]]]) -> List[View]:
+    get_views_contain = get_all_views_contain
+    
+    def get_view_with_error(self) -> Optional[View]:
+        """
+        Returns the last view appended that contains an error.
+        
+        :return: the view, or None if no error is found
         """
-        An alias to `get_all_views_contain` method.
+        for view in reversed(self.views):
+            if view.has_error():
+                return view
+        return None
+    
+    def get_last_error(self) -> Optional[str]:
+        """
+        Returns the last error message found in the views.
+        
+        :return: the error message in human-readable format, or None if no error is found
         """
-        return self.get_all_views_contain(at_types)
+        v = self.get_view_with_error()
+        return v.get_error() if v is not None else None
 
     def get_view_contains(self, at_types: Union[ThingTypesBase, str, List[Union[str, ThingTypesBase]]]) -> Optional[View]:
         """

mmif/serialize/view.py

@@ -5,6 +5,7 @@
 In MMIF, views are created by apps in a pipeline that are annotating
 data that was previously present in the MMIF file.
 """
+import json
 from datetime import datetime
 from typing import Dict, Union, Optional, Generator, List, cast
 
@@ -230,6 +231,23 @@ def __getitem__(self, key: str) -> 'Annotation':
     def set_error(self, err_message: str, err_trace: str) -> None:
         self.metadata.set_error(err_message, err_trace)
         self.annotations.empty()
+    
+    def get_error(self) -> Optional[str]:
+        """
+        Get the "text" representation of the error occurred during 
+        processing. Text representation is supposed to be human-readable. 
+        When ths view does not have any error, returns None.
+        """
+        if self.has_error():
+            return self.metadata.get_error_as_text()
+        else:
+            return None
+
+    def has_error(self) -> bool:
+        return self.metadata.has_error()
+
+    def has_warnings(self):
+        return self.metadata.has_warnings()
 
 
 class ViewMetadata(MmifObject):
@@ -267,7 +285,24 @@ def _serialize(self, alt_container: Optional[Dict] = None) -> dict:
         if not (self.contains.items() or self.error or self.warnings):
             serialized['contains'] = {}
         return serialized
-
+    
+    def has_error(self) -> bool:
+        return len(self.error) > 0
+    
+    def has_warnings(self):
+        return len(self.warnings) > 0
+    
+    def get_error_as_text(self) -> str:
+        if self.has_error():
+            if isinstance(self.error, ErrorDict):
+                return str(self.error)
+            elif isinstance(self.error, dict):
+                return f"Error: {json.dumps(self.error, indent=2)}"
+            else:
+                return f"Error (unknown error format): {self.error}"
+        else:
+            raise KeyError(f"No error found")
+            
     def new_contain(self, at_type: Union[str, ThingTypesBase], **contains_metadata) -> Optional['Contain']:
         """
         Adds a new element to the ``contains`` dictionary.
@@ -346,6 +381,9 @@ def __init__(self, error_obj: Optional[Union[bytes, str, dict]] = None) -> None:
         self.message: str = ''
         self.stackTrace: str = ''
         super().__init__(error_obj)
+    
+    def __str__(self):
+        return f"({self.message})\n\n{self.stackTrace}"
 
 
 class Contain(DataDict[str, str]):

tests/test_serialize.py

@@ -763,6 +763,42 @@ def test_errordict(self):
         self.assertTrue("error" in roundtrip.metadata)
         self.assertFalse("contains" in roundtrip.metadata)
 
+    def test_error_to_text(self):
+        err_msg = "some message"
+        err_trace = "some trace line1\n\ttrace line 2\n\ttrace line 3"
+        error = ErrorDict({"message": err_msg, "stackTrace": err_trace})
+        mmif_obj = Mmif(validate=False)
+        aview = mmif_obj.new_view()
+        aview.set_error(err_msg, err_trace)
+        self.assertTrue(aview.has_error())
+        aview.metadata.error = error
+        self.assertTrue(aview.has_error())
+        self.assertFalse(aview.has_warnings())
+        # assumes the "text" representation of the error contains the message and the trace
+        self.assertGreaterEqual(len(aview.metadata.get_error_as_text()), len(err_msg) + len(err_trace))
+        self.assertIn(err_msg, aview.metadata.get_error_as_text())
+        self.assertIn(err_trace, aview.metadata.get_error_as_text())
+        self.assertEqual(aview.metadata.get_error_as_text(), aview.get_error())
+        self.assertEqual(1, len(mmif_obj.get_views_with_error()))
+        self.assertEqual(aview.id, mmif_obj.get_view_with_error().id)
+        self.assertEqual(aview.metadata.get_error_as_text(), mmif_obj.get_last_error())
+        
+        # and then test for custom error objects
+        aview.metadata.error = {'errorName': 'custom error', 'errorDetails': 'some details', 'errorTimestamp': 'now'}
+        self.assertTrue(aview.has_error())
+        self.assertTrue(isinstance(mmif_obj.get_last_error(), str))
+        err_str = 'custom error as a single long string'
+        aview.metadata.error = err_str
+        self.assertTrue(aview.has_error())
+        self.assertTrue(isinstance(mmif_obj.get_last_error(), str))
+        self.assertIn(err_str, mmif_obj.get_last_error())
+        aview.metadata.error = {}  # no error
+        self.assertFalse(aview.has_error())
+        with self.assertRaises(KeyError):
+            _ = aview.metadata.get_error_as_text()
+        self.assertIsNone(aview.get_error())
+        self.assertIsNone(mmif_obj.get_last_error())
+
 
 class TestAnnotation(unittest.TestCase):
     # TODO (angus-lherrou @ 7/27/2020): testing should include validation for required attrs