Merge pull request #282 from clamsproject/279-mmif-getitem-for-annID

`mmif.__getitem__()` now works with short annotation ID

Author: keighrim

mmif/serialize/mmif.py

@@ -24,6 +24,104 @@
 __all__ = ['Mmif']
 
 
+class MmifMetadata(MmifObject):
+    """
+    Basic MmifObject class to contain the top-level metadata of a MMIF file.
+
+    :param metadata_obj: the JSON data
+    """
+
+    def __init__(self, metadata_obj: Optional[Union[bytes, str, dict]] = None) -> None:
+        # TODO (krim @ 10/7/20): there could be a better name and a better way to give a value to this
+        self.mmif: str = f"http://mmif.clams.ai/{mmif.__specver__}"
+        self._required_attributes = ["mmif"]
+        super().__init__(metadata_obj)
+
+
+class DocumentsList(DataList[Document]):
+    """
+    DocumentsList object that implements :class:`mmif.serialize.model.DataList`
+    for :class:`mmif.serialize.document.Document`.
+    """
+    _items: Dict[str, Document]
+
+    def _deserialize(self, input_list: list) -> None:  # pytype: disable=signature-mismatch
+        """
+        Extends base ``_deserialize`` method to initialize ``items`` as a dict from
+        document IDs to :class:`mmif.serialize.document.Document` objects.
+
+        :param input_list: the JSON data that defines the list of documents
+        :return: None
+        """
+        self._items = {item['properties']['id']: Document(item) for item in input_list}
+
+    def append(self, value: Document, overwrite=False) -> None:
+        """
+        Appends a document to the list.
+
+        Fails if there is already a document with the same ID
+        in the list, unless ``overwrite`` is set to True.
+
+        :param value: the :class:`mmif.serialize.document.Document`
+                      object to add
+        :param overwrite: if set to True, will overwrite an
+                          existing document with the same ID
+        :raises KeyError: if ``overwrite`` is set to False and
+                          a document with the same ID exists
+                          in the list
+        :return: None
+        """
+        super()._append_with_key(value.id, value, overwrite)
+
+
+class ViewsList(DataList[View]):
+    """
+    ViewsList object that implements :class:`mmif.serialize.model.DataList`
+    for :class:`mmif.serialize.view.View`.
+    """
+    _items: Dict[str, View]
+
+    def __init__(self, mmif_obj: Optional[Union[bytes, str, list]] = None):
+        super().__init__(mmif_obj)
+
+    def _deserialize(self, input_list: list) -> None:  # pytype: disable=signature-mismatch
+        """
+        Extends base ``_deserialize`` method to initialize ``items`` as a dict from
+        view IDs to :class:`mmif.serialize.view.View` objects.
+
+        :param input_list: the JSON data that defines the list of views
+        :return: None
+        """
+        if input_list:
+            self._items = {item['id']: View(item) for item in input_list}
+
+    def append(self, value: View, overwrite=False) -> None:
+        """
+        Appends a view to the list.
+
+        Fails if there is already a view with the same ID
+        in the list, unless ``overwrite`` is set to True.
+
+        :param value: the :class:`mmif.serialize.view.View`
+                      object to add
+        :param overwrite: if set to True, will overwrite an
+                          existing view with the same ID
+        :raises KeyError: if ``overwrite`` is set to False and
+                          a view with the same ID exists
+                          in the list
+        :return: None
+        """
+        super()._append_with_key(value.id, value, overwrite)
+
+    def get_last(self) -> Optional[View]:
+        """
+        Returns the last view appended to the list.
+        """
+        for view in reversed(self._items.values()):
+            if 'error' not in view.metadata and 'warning' not in view.metadata:
+                return view
+
+
 class Mmif(MmifObject):
     """
     MmifObject that represents a full MMIF file.
@@ -560,131 +658,41 @@ def get_end(self, annotation: Annotation) -> Union[int, float]:
         """
         return self._get_linear_anchor_point(annotation, start=False)
 
-    # pytype: disable=bad-return-type
-    def __getitem__(self, item: str) -> Union[Document, View, Annotation]:
+    def __getitem__(self, item: str) \
+            -> Union[Document, View, Annotation, MmifMetadata, DocumentsList, ViewsList]:
         """
-        getitem implementation for Mmif. When nothing is found, this will raise an error
-        rather than returning a None (although pytype doesn't think so...)
+        getitem implementation for Mmif. This will try to find any object, given an identifier or an immediate 
+        attribute name. When nothing is found, this will raise an error rather than returning a None 
 
         :raises KeyError: if the item is not found or if the search results are ambiguous
-        :param item: the search string, a document ID, a view ID, or a view-scoped annotation ID
+        :param item: an attribute name or an object identifier (a document ID, a view ID, or an annotation ID). When 
+                     annotation ID is given as a "short" ID (without view ID prefix), the method will try to find a 
+                     match from the first view, and return immediately if found.
         :return: the object searched for
+        :raise KeyError: if the item is not found or multiple objects are found with the same ID
         """
         if item in self._named_attributes():
             return self.__dict__[item]
         split_attempt = item.split(self.id_delimiter)
 
-        document_result = self.documents.get(split_attempt[0])
-        view_result = self.views.get(split_attempt[0])
+        found = []
 
         if len(split_attempt) == 1:
-            anno_result = None
-        elif view_result:
-            anno_result = view_result[split_attempt[1]]
+            found.append(self.documents.get(split_attempt[0]))
+            found.append(self.views.get(split_attempt[0]))
+            for view in self.views:
+                found.append(view.annotations.get(split_attempt[0]))
+        elif len(split_attempt) == 2:
+            v = self.get_view_by_id(split_attempt[0])
+            if v is not None:
+                found.append(v.annotations.get(split_attempt[1]))
         else:
             raise KeyError("Tried to subscript into a view that doesn't exist")
+        found = [x for x in found if x is not None]
 
-        if view_result and document_result:
+        if len(found) > 1:
             raise KeyError("Ambiguous ID search result")
-        if not (view_result or document_result):
+        elif len(found) == 0:
             raise KeyError("ID not found: %s" % item)
-        return anno_result or view_result or document_result
-    # pytype: enable=bad-return-type
-
-
-class MmifMetadata(MmifObject):
-    """
-    Basic MmifObject class to contain the top-level metadata of a MMIF file.
-
-    :param metadata_obj: the JSON data
-    """
-
-    def __init__(self, metadata_obj: Optional[Union[bytes, str, dict]] = None) -> None:
-        # TODO (krim @ 10/7/20): there could be a better name and a better way to give a value to this
-        self.mmif: str = f"http://mmif.clams.ai/{mmif.__specver__}"
-        self._required_attributes = ["mmif"]
-        super().__init__(metadata_obj)
-
-
-class DocumentsList(DataList[Document]):
-    """
-    DocumentsList object that implements :class:`mmif.serialize.model.DataList`
-    for :class:`mmif.serialize.document.Document`.
-    """
-    _items: Dict[str, Document]
-
-    def _deserialize(self, input_list: list) -> None:  # pytype: disable=signature-mismatch
-        """
-        Extends base ``_deserialize`` method to initialize ``items`` as a dict from
-        document IDs to :class:`mmif.serialize.document.Document` objects.
-
-        :param input_list: the JSON data that defines the list of documents
-        :return: None
-        """
-        self._items = {item['properties']['id']: Document(item) for item in input_list}
-
-    def append(self, value: Document, overwrite=False) -> None:
-        """
-        Appends a document to the list.
-
-        Fails if there is already a document with the same ID
-        in the list, unless ``overwrite`` is set to True.
-
-        :param value: the :class:`mmif.serialize.document.Document`
-                      object to add
-        :param overwrite: if set to True, will overwrite an
-                          existing document with the same ID
-        :raises KeyError: if ``overwrite`` is set to False and
-                          a document with the same ID exists
-                          in the list
-        :return: None
-        """
-        super()._append_with_key(value.id, value, overwrite)
-
-
-class ViewsList(DataList[View]):
-    """
-    ViewsList object that implements :class:`mmif.serialize.model.DataList`
-    for :class:`mmif.serialize.view.View`.
-    """
-    _items: Dict[str, View]
-    
-    def __init__(self, mmif_obj: Optional[Union[bytes, str, list]] = None):
-        super().__init__(mmif_obj)
-
-    def _deserialize(self, input_list: list) -> None:  # pytype: disable=signature-mismatch
-        """
-        Extends base ``_deserialize`` method to initialize ``items`` as a dict from
-        view IDs to :class:`mmif.serialize.view.View` objects.
-
-        :param input_list: the JSON data that defines the list of views
-        :return: None
-        """
-        if input_list:
-            self._items = {item['id']: View(item) for item in input_list}
-
-    def append(self, value: View, overwrite=False) -> None:
-        """
-        Appends a view to the list.
-
-        Fails if there is already a view with the same ID
-        in the list, unless ``overwrite`` is set to True.
-
-        :param value: the :class:`mmif.serialize.view.View`
-                      object to add
-        :param overwrite: if set to True, will overwrite an
-                          existing view with the same ID
-        :raises KeyError: if ``overwrite`` is set to False and
-                          a view with the same ID exists
-                          in the list
-        :return: None
-        """
-        super()._append_with_key(value.id, value, overwrite)
-
-    def get_last(self) -> Optional[View]:
-        """
-        Returns the last view appended to the list.
-        """
-        for view in reversed(self._items.values()):
-            if 'error' not in view.metadata and 'warning' not in view.metadata:
-                return view
+        else:
+            return found[-1]

tests/test_serialize.py

@@ -516,6 +516,29 @@ def test_mmif_getitem_document(self):
         except KeyError:
             self.fail("didn't get document 'm1'")
 
+    def test_mmif_getitem_idconflict(self):
+        m = Mmif(validate=False)
+        v1 = m.new_view()
+        v1.id = 'v1'
+        v2 = m.new_view()
+        v2.id = 'v1'
+        with pytest.raises(KeyError):
+            _ = m['v1']
+
+        m = Mmif(validate=False)
+        v1 = m.new_view()
+        v1a = v1.new_annotation(AnnotationTypes.Annotation, id='a1')
+        v2 = m.new_view()
+        v2a = v2.new_annotation(AnnotationTypes.Annotation, id='a1')
+        self.assertIsNotNone(m[v1.id])
+        self.assertIsNotNone(m[v2.id])
+        # conflict short IDs
+        self.assertEqual(v1a.id, v2a.id)
+        with pytest.raises(KeyError):
+            _ = m[v1a.id]
+        self.assertIsNotNone(m[v1a.long_id])
+        self.assertIsNotNone(m[v2a.long_id])
+
     def test_mmif_getitem_view(self):
         try:
             v1 = self.mmif_obj['v1']