mmif-python 1.0.13__tar.gz → 1.0.14__tar.gz

{mmif-python-1.0.13/mmif_python.egg-info → mmif-python-1.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mmif-python
-Version: 1.0.13
+Version: 1.0.14
 Summary: Python implementation of MultiMedia Interchange Format specification. (https://mmif.clams.ai)
 Home-page: https://mmif.clams.ai
 Author: Brandeis Lab for Linguistics and Computation

mmif-python-1.0.14/VERSION

@@ -0,0 +1 @@
+1.0.14

{mmif-python-1.0.13 → mmif-python-1.0.14}/mmif/serialize/annotation.py

@@ -415,26 +415,31 @@ class AnnotationProperties(MmifObject, MutableMapping[str, T]):
                 
     def __iter__(self) -> Iterator[str]:
         """
-        ``__iter__`` on Mapping should basically work as ``keys()`` method of vanilla dict
-        however, when MMIF objects are serialized, all optional (not in ``_req_atts``),
-        empty props are ignored (note that emtpy but required props are serialized 
-        with the *emtpy* value). 
-        Hence, this ``__iter__`` method should also work in the same way and 
-        ignore empty optional props. 
+        ``__iter__`` on Mapping should basically work as ``keys()`` method 
+        of vanilla dict.
         """
         for key in itertools.chain(self._named_attributes(), self._unnamed_attributes):
-            if key in self._required_attributes:
-                yield key
-            else:
-                try:
-                    self.__getitem__(key)
-                    yield key
-                except KeyError:
-                    pass
+            yield key
+                
+    def __getitem__(self, key):
+        """
+        Parent MmifObject class has a __getitem__ method that checks if 
+        the value is empty when asked for an unnamed attribute. But for 
+        AnnotationProperties, any arbitrary property that's added 
+        explicitly by the user (developer) should not be ignored and 
+        returned even the value is empty. 
+        """
+        if key in self._named_attributes():
+            return self.__dict__[key]
+        else:
+            return self._unnamed_attributes[key]
 
     def __init__(self, mmif_obj: Optional[Union[bytes, str, dict]] = None) -> None:
         self.id: str = ''
+        # any individual at_type (subclassing this class) can have its own set of required attributes
         self._required_attributes = ["id"]
+        # allowing additional attributes for arbitrary annotation properties
+        self._unnamed_attributes = {}
         super().__init__(mmif_obj)
 
 

{mmif-python-1.0.13 → mmif-python-1.0.14}/mmif/serialize/mmif.py

@@ -447,6 +447,16 @@ class Mmif(MmifObject):
                             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 @@ class Mmif(MmifObject):
         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-python-1.0.13 → mmif-python-1.0.14}/mmif/serialize/model.py

@@ -44,35 +44,39 @@ class MmifObject(object):
 
     1. _unnamed_attributes:
        Only can be either None or an empty dictionary. If it's set to None,
-       it means the class won't take any ``Additional Attributes`` in the JSON
-       schema sense. If it's a dict, users can throw any k-v pairs to the
-       class, EXCEPT for the reserved two key names.
+       it means the class won't take any ``Additional Attributes`` in the 
+       JSON schema sense. If it's an empty dict, users can throw any k-v 
+       pairs to the class, as long as the key is not a "reserved" name, 
+       and those additional attributes will be stored in this dict while
+       in memory. 
     2. _attribute_classes:
        This is a dict from a key name to a specific python class to use for
        deserialize the value. Note that a key name in this dict does NOT
        have to be a *named* attribute, but is recommended to be one.
     3. _required_attributes:
-       This is a simple list of names of attributes that are required in the object.
-       When serialize, an object will skip its *empty* (e.g. zero-length, or None)
-       attributes unless they are in this list. Otherwise, the serialized JSON
-       string would have empty representations (e.g. ``""``, ``[]``).
+       This is a simple list of names of attributes that are required in 
+       the object. When serialize, an object will skip its *empty* (e.g. 
+       zero-length, or None) attributes unless they are in this list. 
+       Otherwise, the serialized JSON string would have empty 
+       representations (e.g. ``""``, ``[]``).
     4. _exclude_from_diff:
-       This is a simple list of names of attributes that should be excluded from
-       the diff calculation in ``__eq__``. 
+       This is a simple list of names of attributes that should be excluded 
+       from the diff calculation in ``__eq__``. 
 
     # TODO (krim @ 8/17/20): this dict is however, a duplicate with the type hints in the class definition.
-    Maybe there is a better way to utilize type hints (e.g. getting them as a programmatically), but for now
-    developers should be careful to add types to hints as well as to this dict.
+    Maybe there is a better way to utilize type hints (e.g. getting them 
+    as a programmatically), but for now developers should be careful to 
+    add types to hints as well as to this dict.
 
     Also note that those special attributes MUST be set in the __init__()
     before calling super method, otherwise deserialization will not work.
 
     And also, a subclass that has one or more *named* attributes, it must
-    set those attributes in the __init__() before calling super method. When
-    serializing a MmifObject, all *empty* attributes will be ignored, so for
-    optional named attributes, you must leave the values empty (len == 0), but
-    NOT None. Any None-valued named attributes will cause issues with current
-    implementation.
+    set those attributes in the __init__() before calling super method. 
+    When serializing a MmifObject, all *empty* attributes will be ignored, 
+    so for optional named attributes, you must leave the values empty 
+    (len == 0), but NOT None. Any None-valued named attributes will cause 
+    issues with current implementation.
 
     :param mmif_obj: JSON string or `dict` to initialize an object.
      If not given, an empty object will be initialized, sometimes with
@@ -272,8 +276,8 @@ class MmifObject(object):
         """
         Returns number of attributes that are not *empty*. 
         """
-        return sum([named in self and not self.is_empty(self[named]) for named in self._named_attributes()]) \
-               + (len(self._unnamed_attributes) if self._unnamed_attributes else 0)
+        return (sum([named in self and not self.is_empty(self[named]) for named in self._named_attributes()]) 
+                + (len(self._unnamed_attributes) if self._unnamed_attributes else 0))
 
     def __setitem__(self, key, value) -> None:
         if key in self.reserved_names:

{mmif-python-1.0.13 → mmif-python-1.0.14}/mmif/serialize/view.py

@@ -5,6 +5,7 @@ as a live Python object.
 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 @@ class View(MmifObject):
     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 @@ class ViewMetadata(MmifObject):
         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 @@ class ErrorDict(MmifObject):
         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]):

mmif-python-1.0.14/mmif/ver/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "1.0.14"
+__specver__ = "1.0.4"

{mmif-python-1.0.13 → mmif-python-1.0.14/mmif_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mmif-python
-Version: 1.0.13
+Version: 1.0.14
 Summary: Python implementation of MultiMedia Interchange Format specification. (https://mmif.clams.ai)
 Home-page: https://mmif.clams.ai
 Author: Brandeis Lab for Linguistics and Computation

mmif-python-1.0.13/VERSION

@@ -1 +0,0 @@
-1.0.13

mmif-python-1.0.13/mmif/ver/__init__.py

@@ -1,2 +0,0 @@
-__version__ = "1.0.13"
-__specver__ = "1.0.4"