mmif-python 1.0.16__tar.gz → 1.0.18__tar.gz

{mmif_python-1.0.16 → mmif_python-1.0.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mmif-python
-Version: 1.0.16
+Version: 1.0.18
 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.18/VERSION

@@ -0,0 +1 @@
+1.0.18

{mmif_python-1.0.16 → mmif_python-1.0.18}/mmif/serialize/annotation.py

@@ -14,7 +14,7 @@ import pkgutil
 import re
 import typing
 import warnings
-from typing import Union, Dict, List, Optional, Iterator, MutableMapping, TypeVar
+from typing import Union, Dict, Optional, Iterator, MutableMapping, TypeVar
 from urllib.parse import urlparse
 
 from mmif.vocabulary import ThingTypesBase, DocumentTypesBase
@@ -46,12 +46,13 @@ class Annotation(MmifObject):
     MmifObject that represents an annotation in a MMIF view.
     """
 
-    def __init__(self, anno_obj: Optional[Union[bytes, str, dict]] = None) -> None:
+    def __init__(self, anno_obj: Optional[Union[bytes, str, dict]] = None, *_) -> None:
         self._type: ThingTypesBase = ThingTypesBase('')
         # to store the parent view ID
         self._parent_view_id = ''
         self._props_ephemeral: AnnotationProperties = AnnotationProperties()
-        self.reserved_names.update(('_parent_view_id', '_props_ephemeral'))
+        self._alignments = {}  # to hold alignment information (Alignment anno long_id -> aligned anno long_id)
+        self.reserved_names.update(('_parent_view_id', '_props_ephemeral', '_alignments'))
         if not hasattr(self, 'properties'):  # don't overwrite DocumentProperties on super() call
             self.properties: AnnotationProperties = AnnotationProperties()
             self._attribute_classes = {'properties': AnnotationProperties}
@@ -59,6 +60,9 @@ class Annotation(MmifObject):
         self._required_attributes = ["_type", "properties"]
         super().__init__(anno_obj)
     
+    def __hash__(self):
+        return hash(self.serialize())
+    
     def _deserialize(self, input_dict: dict) -> None:
         self.at_type = input_dict.pop('_type', '')
         # TODO (krim @ 6/1/21): If annotation IDs must follow a certain string format,
@@ -69,6 +73,40 @@ class Annotation(MmifObject):
         for k, v in self.properties.items():
             self._add_prop_aliases(k, v)
                             
+    def _cache_alignment(self, alignment_ann: 'Annotation', alignedto_ann: 'Annotation') -> None:
+        """
+        Cache alignment information. This cache will not be serialized. 
+        
+        :param alignment_ann: the Alignment annotation that has this annotation on one side
+        :param alignedto_ann: the annotation that this annotation is aligned to (other side of Alignment)
+        """
+        self._alignments[alignment_ann] = alignedto_ann
+    
+    def aligned_to_by(self, alignment: 'Annotation') -> Optional['Annotation']:
+        """
+        Retrieves the other side of ``Alignment`` annotation that has this annotation on one side. 
+        
+        :param alignment: ``Alignment`` annotation that has this annotation on one side
+        :return: the annotation that this annotation is aligned to (other side of ``Alignment``), 
+                 or None if this annotation is not used in the ``Alignment``.
+        """
+        return self._alignments.get(alignment)
+    
+    def get_all_aligned(self) -> Iterator['Annotation']:
+        """
+        Generator to iterate through all alignments and aligned annotations. Note that this generator will yield
+        the `Alignment` annotations as well. Every odd-numbered yield will be an `Alignment` annotation, and every
+        even-numbered yield will be the aligned annotation. If there's a specific annotation type that you're looking
+        for, you need to filter the generated results outside. 
+        
+        :return: yields the alignment annotation and the aligned annotation.
+                 The order is decided by the order of appearance of Alignment annotations in the MMIF
+        """
+        for alignment, aligned in self._alignments.items():
+            yield alignment
+            yield aligned
+        
+        
     def _add_prop_aliases(self, key_to_add, val_to_add):
         """
         Method to handle aliases of the same property.
@@ -163,6 +201,7 @@ class Annotation(MmifObject):
                      value: Union[PRMTV_TYPES, LIST_PRMTV, LIST_LIST_PRMTV, DICT_PRMTV, DICT_LIST_PRMTV]) -> None:
         """
         Adds a property to the annotation's properties.
+        
         :param name: the name of the property
         :param value: the property's desired value
         :return: None
@@ -241,7 +280,7 @@ class Document(Annotation):
 
     :param document_obj: the JSON data that defines the document
     """
-    def __init__(self, doc_obj: Optional[Union[bytes, str, dict]] = None) -> None:
+    def __init__(self, doc_obj: Optional[Union[bytes, str, dict]] = None, *_) -> None:
         # see https://github.com/clamsproject/mmif-python/issues/226 for discussion
         # around the use of these three dictionaries
         # (names changed since, `existing` >> `ephemeral` and `temporary` >> `pending`)
@@ -284,6 +323,10 @@ class Document(Annotation):
            only keep the latest value (in order of appearances in views list) of 
            the property, effectively overwriting the previous values.
         """
+        # we don't checking if this k-v already exists in _original (new props) or _ephemeral (read from existing MMIF)
+        # because it is impossible to keep the _original updated when a new annotation is added (via `new_annotation`)
+        # without look across other views and top-level documents list. Also see 
+        # ``mmif.serialize.mmif.Mmif.generate_capital_annotations`` for where the "de-duplication" happens.
         if name == "text":
             self.properties.text = Text(value)
         elif name == "mime":
@@ -434,7 +477,7 @@ class AnnotationProperties(MmifObject, MutableMapping[str, T]):
         else:
             return self._unnamed_attributes[key]
 
-    def __init__(self, mmif_obj: Optional[Union[bytes, str, dict]] = None) -> None:
+    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"]
@@ -451,7 +494,7 @@ class DocumentProperties(AnnotationProperties):
     :param mmif_obj: the JSON data that defines the properties
     """
 
-    def __init__(self, mmif_obj: Optional[Union[bytes, str, dict]] = None) -> None:
+    def __init__(self, mmif_obj: Optional[Union[bytes, str, dict]] = None, *_) -> None:
         self.mime: str = ''
         # note the trailing underscore here. I wanted to use the name `location`
         # for @property in this class and `Document` class, so had to use a diff
@@ -572,7 +615,7 @@ class DocumentProperties(AnnotationProperties):
 
 class Text(MmifObject):
 
-    def __init__(self, text_obj: Optional[Union[bytes, str, dict]] = None) -> None:
+    def __init__(self, text_obj: Optional[Union[bytes, str, dict]] = None, *_) -> None:
         self._value: str = ''
         self._language: str = ''
         self.disallow_additional_properties()

{mmif_python-1.0.16 → mmif_python-1.0.18}/mmif/serialize/mmif.py

@@ -10,16 +10,16 @@ import math
 import warnings
 from collections import defaultdict
 from datetime import datetime
-from typing import List, Union, Optional, Dict, cast, Iterator, Tuple
+from typing import List, Union, Optional, Dict, cast, Iterator
 
 import jsonschema.validators
 
 import mmif
 from mmif import ThingTypesBase
+from mmif.serialize.annotation import Annotation, Document
+from mmif.serialize.model import MmifObject, DataList
+from mmif.serialize.view import View
 from mmif.vocabulary import AnnotationTypes, DocumentTypes
-from .annotation import Annotation, Document
-from .model import MmifObject, DataList
-from .view import View
 
 __all__ = ['Mmif']
 
@@ -31,7 +31,7 @@ class MmifMetadata(MmifObject):
     :param metadata_obj: the JSON data
     """
 
-    def __init__(self, metadata_obj: Optional[Union[bytes, str, dict]] = None) -> None:
+    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"]
@@ -81,7 +81,9 @@ class ViewsList(DataList[View]):
     """
     _items: Dict[str, View]
 
-    def __init__(self, mmif_obj: Optional[Union[bytes, str, list]] = None):
+    def __init__(self, mmif_obj: Optional[Union[bytes, str, list]] = None, parent_mmif=None, *_):
+        self._parent_mmif = parent_mmif
+        self.reserved_names.update(("_parent_mmif", "_id_counts"))
         super().__init__(mmif_obj)
 
     def _deserialize(self, input_list: list) -> None:  # pytype: disable=signature-mismatch
@@ -93,7 +95,7 @@ class ViewsList(DataList[View]):
         :return: None
         """
         if input_list:
-            self._items = {item['id']: View(item) for item in input_list}
+            self._items = {item['id']: View(item, self._parent_mmif) for item in input_list}
 
     def append(self, value: View, overwrite=False) -> None:
         """
@@ -113,13 +115,24 @@ class ViewsList(DataList[View]):
         """
         super()._append_with_key(value.id, value, overwrite)
 
-    def get_last(self) -> Optional[View]:
+    def get_last_contentful_view(self) -> Optional[View]:
         """
-        Returns the last view appended to the list.
+        Returns the last view that is contentful, i.e., has no error or warning .
         """
         for view in reversed(self._items.values()):
             if 'error' not in view.metadata and 'warning' not in view.metadata:
                 return view
+    
+    def get_last_view(self) -> Optional[View]:
+        """
+        Returns the last view appended.
+        """
+        if self._items:
+            return self._items[list(self._items.keys())[-1]]
+            
+    def get_last(self) -> Optional[View]:
+        warnings.warn('get_last() is deprecated, use get_last_contentful_view() instead.', DeprecationWarning)
+        return self.get_last_contentful_view()
 
 
 class Mmif(MmifObject):
@@ -205,6 +218,7 @@ class Mmif(MmifObject):
         """
         super()._deserialize(input_dict)
         for view in self.views:
+            view._parent_mmif = self
             # this dict will be populated with properties 
             # that are not encoded in individual annotations objects themselves
             extrinsic_props = defaultdict(dict)
@@ -212,6 +226,7 @@ class Mmif(MmifObject):
                 for prop_key, prop_value in type_lv_props.items():
                     extrinsic_props[at_type][prop_key] = prop_value
             for ann in view.get_annotations():
+                ## for "capital" Annotation properties
                 # first add all extrinsic properties to the Annotation objects
                 # as "ephemeral" properties
                 for prop_key, prop_value in extrinsic_props[ann.at_type].items():
@@ -226,13 +241,44 @@ class Mmif(MmifObject):
                     except KeyError:
                         warnings.warn(f"Annotation {ann.id} (in view {view.id}) has a document ID {doc_id} that "
                                       f"does not exist in the MMIF object. Skipping.", RuntimeWarning)
-                # lastly, add quick access to `start` and `end` values if the annotation is using `targets` property
+                        
+                ## caching start and end points for time-based annotations
+                # add quick access to `start` and `end` values if the annotation is using `targets` property
                 if 'targets' in ann.properties:
                     if 'start' in ann.properties or 'end' in ann.properties:
-                        raise ValueError(f"Annotation {ann.id} (in view {view.id}) has `targes` and `start`/`end/` "
+                        raise ValueError(f"Annotation {ann.id} (in view {view.id}) has `targets` and `start`/`end/` "
                                          f"properties at the same time. Annotation anchors are ambiguous.")
                     ann._props_ephemeral['start'] = self._get_linear_anchor_point(ann, start=True)
                     ann._props_ephemeral['end'] = self._get_linear_anchor_point(ann, start=False)
+                
+                ## caching alignments
+                if ann.at_type == AnnotationTypes.Alignment:
+                    self._cache_alignment(ann)
+    
+    def _cache_alignment(self, alignment_ann: Annotation):
+        view = self.views.get(alignment_ann.parent)
+        if view is None:
+            warnings.warn(f"Alignment {alignment_ann.long_id} doesn't have a parent view, but it should.", RuntimeWarning)
+            return
+
+        ## caching alignments
+        def _desprately_search_annotation_object(ann_short_id):
+            ann_long_id = f"{view.id}{self.id_delimiter}{ann_short_id}"
+            try:
+                return self.__getitem__(ann_long_id)
+            except KeyError:
+                return self.__getitem__(ann_short_id)
+
+        if all(map(lambda x: x in alignment_ann.properties, ('source', 'target'))):
+            source_ann = _desprately_search_annotation_object(alignment_ann.get('source'))
+            target_ann = _desprately_search_annotation_object(alignment_ann.get('target'))
+            if isinstance(source_ann, Annotation) and isinstance(target_ann, Annotation):
+                source_ann._cache_alignment(alignment_ann, target_ann)
+                target_ann._cache_alignment(alignment_ann, source_ann)
+            else:
+                warnings.warn(
+                    f"Alignment {alignment_ann.long_id} has `source` and `target` properties that do not point to Annotation objects.",
+                    RuntimeWarning)
 
     def generate_capital_annotations(self):
         """
@@ -243,13 +289,23 @@ class Mmif(MmifObject):
         See https://github.com/clamsproject/mmif-python/issues/226 for rationale
         behind this behavior and discussion.
         """
-        # this view will be the default kitchen sink for all generated annotations
-        last_view = self.views.get_last()
+        # this view will be the default kitchen sink for all generated annotations.
+        last_view = self.views.get_last_contentful_view()
+        
         # proceed only when there's at least one view
         if last_view:
+            
+            # this app name is used to check a view is generated by the "currently running" app.
+            # knowing the currently running app is important so that properties of `Document` objects generated by the 
+            # current app can be properly recorded inside the `Document` objects (since they are "writable" to the 
+            # current app), instead of being recorded in a separate `Annotation` object.
+            current_app = last_view.metadata.app
+
             # to avoid duplicate property recording, this will be populated with
             # existing Annotation objects from all existing views
             existing_anns = defaultdict(lambda: defaultdict(dict))
+            # ideally, if we can "de-duplicate" props at `add_property()` time, that'd be more efficient, 
+            # but that is impossible without looking for the target `document` across other views and top documents list
             
             # new properties to record in the current serialization call
             anns_to_write = defaultdict(dict)
@@ -261,20 +317,30 @@ class Mmif(MmifObject):
                     for ann in view.get_annotations(AnnotationTypes.Annotation):
                         if doc_id is None:
                             doc_id = ann.get_property('document')
+                        # only if we are sure that the document ID is unique across all views... (with v_id prefix)
+                        # TODO (krim @ 7/15/24): update id checking once https://github.com/clamsproject/mmif/issues/228 is resolved
+                        if not any([doc_id == doc.id for doc in self.documents]) and Mmif.id_delimiter not in doc_id:
+                            doc_id = f"{view.id}{Mmif.id_delimiter}{doc_id}"
                         existing_anns[doc_id].update(ann.properties)
                 for doc in view.get_documents():
-                    anns_to_write[doc.id].update(doc._props_pending)
+                    anns_to_write[doc.long_id].update(doc._props_pending)
             for doc in self.documents:
-                anns_to_write[doc.id].update(doc._props_pending)
+                anns_to_write[doc.long_id].update(doc._props_pending)
             # additional iteration of views, to find a proper view to add the 
             # generated annotations. If none found, use the last view as the kitchen sink
             last_view_for_docs = defaultdict(lambda: last_view)
             doc_ids = set(anns_to_write.keys())
             for doc_id in doc_ids:
+                if len(last_view.annotations) == 0:
+                    # meaning, this new app didn't generate any annotation except for these document properties
+                    # thus, we should add capital annotations to the last (empty) view
+                    last_view_for_docs[doc_id] = last_view
+                    break
                 for view in reversed(self.views):
                     # first try to find out if this view "contains" any annotation to the doc
                     # then, check for individual annotations
-                    if [cont for cont in view.metadata.contains.values() if cont.get('document', None) == doc_id] \
+                    # TODO (krim @ 7/15/24): update id checking once https://github.com/clamsproject/mmif/issues/228 is resolved
+                    if [cont for cont in view.metadata.contains.values() if doc_id.endswith(cont.get('document', 'TODO:this endswith test is a temporal solution we use until long_id is forced everywhere'))] \
                             or list(view.get_annotations(document=doc_id)):
                         last_view_for_docs[doc_id] = view
                         break
@@ -288,14 +354,18 @@ class Mmif(MmifObject):
                     if k != 'id' and existing_anns[doc_id][k] != v:
                         props[k] = v
                 if props:
-                    if len(anns_to_write) == 1:
-                        # if there's only one document, we can record the doc_id in the contains metadata
-                        last_view_for_docs[doc_id].metadata.new_contain(AnnotationTypes.Annotation, document=doc_id)
-                        props.pop('document', None)
+                    view_to_write = last_view_for_docs[doc_id]
+                    if view_to_write.metadata.app == current_app and view_to_write.annotations.get(doc_id) is not None:
+                        view_to_write.get_document_by_id(doc_id).properties.update(props)
                     else:
-                        # otherwise, doc_id needs to be recorded in the annotation property
-                        props['document'] = doc_id
-                    last_view_for_docs[doc_id].new_annotation(AnnotationTypes.Annotation, **props)
+                        if len(anns_to_write) == 1:
+                            # if there's only one document, we can record the doc_id in the contains metadata
+                            view_to_write.metadata.new_contain(AnnotationTypes.Annotation, document=doc_id)
+                            props.pop('document', None)
+                        else:
+                            # otherwise, doc_id needs to be recorded in the annotation property
+                            props['document'] = doc_id
+                        view_to_write.new_annotation(AnnotationTypes.Annotation, **props)
 
     def sanitize(self):
         """
@@ -339,7 +409,7 @@ class Mmif(MmifObject):
         new_view = View()
         new_view.id = self.new_view_id()
         new_view.metadata.timestamp = datetime.now()
-        self.views.append(new_view)
+        self.add_view(new_view)
         return new_view
 
     def add_view(self, view: View, overwrite=False) -> None:
@@ -353,6 +423,7 @@ class Mmif(MmifObject):
                           an existing view with the same ID
         :return: None
         """
+        view._parent_mmif = self
         self.views.append(view, overwrite)
 
     def add_document(self, document: Document, overwrite=False) -> None:
@@ -555,7 +626,7 @@ class Mmif(MmifObject):
     
     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]:
+    def get_all_views_contain(self, *at_types: Union[ThingTypesBase, str]) -> List[View]:
         """
         Returns the list of all views in the MMIF if given types
         are present in that view's 'contains' metadata.
@@ -563,11 +634,8 @@ class Mmif(MmifObject):
         :param at_types: a list of types or just a type to check for. When given more than one types, all types must be found.
         :return: the list of views that contain the type
         """
-        if isinstance(at_types, list):
-            return [view for view in self.views
-                    if all(map(lambda x: x in view.metadata.contains, at_types))]
-        else:
-            return [view for view in self.views if at_types in view.metadata.contains]
+        return [view for view in self.views
+                if all(map(lambda x: x in view.metadata.contains, at_types))]
 
     get_views_contain = get_all_views_contain
     
@@ -610,72 +678,54 @@ class Mmif(MmifObject):
                     return view
         return None
 
-    def _is_in_time_between(self, start: Union[int, float], end: Union[int, float], annotation: Annotation) -> bool:
-        s, e = self.get_start(annotation), self.get_end(annotation)
-        return (s < start < e) or (s > start and e < end) or (s < end < e)
+    def _is_in_time_range(self, ann: Annotation, range_s: Union[int, float], range_e: Union[int, float]) -> bool:
+        """
+        Checks if the annotation is anchored within the given time range. Any overlap is considered included. 
+
+        :param ann: the Annotation object to check, must be time-based itself or anchored to time-based annotations
+        :param range_s: the start time point of the range (in milliseconds)
+        :param range_e: the end time point of the range (in milliseconds)
+
+        :return: True if the annotation is anchored within the time range, False otherwise
+        """
+        ann_s, ann_e = self.get_start(ann), self.get_end(ann)
+        return (ann_s < range_s < ann_e) or (ann_s < range_e < ann_e) or (ann_s > range_s and ann_e < range_e)
+
+    def get_annotations_between_time(self, start: Union[int, float], end: Union[int, float], time_unit: str = "ms",
+                                     at_types: List[Union[ThingTypesBase, str]] = []) -> Iterator[Annotation]:
+        """
+        Finds annotations that are anchored between the given time points.
 
-    def _handle_time_unit(self, input_unit: str, ann_unit: str,
-                          start: int, end: int) -> Tuple[Union[int, float, str], Union[int, float, str]]:
+        :param start: the start time point in the unit of `input_unit`
+        :param end: the end time point in the unit of `input_unit`
+        :param time_unit: the unit of the input time points. Default is `ms`.
+        :param at_types: a list of annotation types to filter with. Any type in this list will be included in the return.
+        :return: an iterator of Annotation objects that are anchored between the given time points
+        """
+        assert start < end, f"Start time point must be smaller than the end time point, given {start} and {end}"
+        assert start >= 0, f"Start time point must be non-negative, given {start}"
+        assert end >= 0, f"End time point must be non-negative, given {end}"
+        
         from mmif.utils.timeunit_helper import convert
-        start = convert(start, input_unit, ann_unit, 1)
-        end = convert(end, input_unit, ann_unit, 1)
-        return start, end
-
-    def get_annotations_between_time(self, start: int, end: int, time_unit: str = "milliseconds") -> Iterator[Annotation]:
-        """
-        Version: 1.0
-        Returns all 'Token' annotations aligned with 'TimeFrame' annotations sorted by start time within start and end time
-        Note: this function only works for mmif object obtained from Whisper-wrapper
-
-        :param start: the start time
-        :param end: the end time
-        :param time_unit: the time unit, either string "milliseconds" or "seconds", defaults to "milliseconds"
-        :return: a generator of 'Token' annotations
-        """
-        assert start <= end, "Start time must be less than end time"
-        assert start >= 0, "Start time must be greater than or equal to zero"
-        assert end >= 0, "End time must be greater than or equal to zero"
-        # 0. Initialize container and helper method
-        valid_tf_anns = []
-        tf_to_anns = defaultdict(list)
-
-        # 1. find all views that contain the type of TF
-        views = self.get_all_views_contain([AnnotationTypes.TimeFrame, AnnotationTypes.Alignment])
-
-        # 2. For each view, extract annotations that satisfy conditions that are TF/TP and fall into time interval
-        for view in views:
-            # Make sure time unit stay at the same level
-            start_time, end_time = self._handle_time_unit(time_unit, view.metadata.contains.get(AnnotationTypes.TimeFrame)["timeUnit"],
-                                                          start, end)
-            tf_anns = view.get_annotations(at_type=AnnotationTypes.TimeFrame)
-            al_anns = view.get_annotations(at_type=AnnotationTypes.Alignment)
-
-            # Select 'TimeFrame' annotations within given time interval
-            for tf in tf_anns:
-                if self._is_in_time_between(start_time, end_time, tf):
-                    valid_tf_anns.append(tf)
-
-            # Map 'TimeFrame' annotation to its aligned annotation
-            for align in al_anns:
-                source_id, target_id = align.get_property('source'), align.get_property('target')
-                to_long_id = lambda x: x if self.id_delimiter in x else f'{view.id}{self.id_delimiter}{x}'
-                try:
-                    source, target = view.get_annotation_by_id(source_id), view.get_annotation_by_id(target_id)
-                    if source in valid_tf_anns:
-                        tf_to_anns[to_long_id(source_id)].append(target)
-                    elif target in valid_tf_anns:
-                        tf_to_anns[to_long_id(target_id)].append(source)
-                except KeyError:
-                    pass
-
-        # 3. For those extracted 'TimeFrame' annotations, sort them by their start time
-        sort_tf_anns = sorted(valid_tf_anns, key=lambda x: self.get_start(x))
-
-        # 4. Yield all annotations aligned with sorted 'TimeFrame' annotations
-        for tf_ann in sort_tf_anns:
-            anns = tf_to_anns[tf_ann.long_id]
-            for ann in anns:
-                yield ann
+
+        time_anchors_in_range = []
+        at_types = set(at_types)
+
+        for view in self.get_all_views_contain(AnnotationTypes.TimeFrame) + self.get_all_views_contain(AnnotationTypes.TimePoint):
+            time_unit_in_view = view.metadata.contains.get(AnnotationTypes.TimeFrame)["timeUnit"]
+            
+            start_time = convert(start, time_unit, time_unit_in_view, 1)
+            end_time = convert(end, time_unit, time_unit_in_view, 1)
+            for ann in view.get_annotations():
+                if ann.at_type in (AnnotationTypes.TimeFrame, AnnotationTypes.TimePoint) and self._is_in_time_range(ann, start_time, end_time):
+                    time_anchors_in_range.append(ann)
+        time_anchors_in_range.sort(key=lambda x: self.get_start(x))
+        for time_anchor in time_anchors_in_range:
+            if not at_types or time_anchor.at_type in at_types:
+                yield time_anchor
+            for aligned in time_anchor.get_all_aligned():
+                if not at_types or aligned.at_type in at_types:
+                    yield aligned
 
     def _get_linear_anchor_point(self, ann: Annotation, targets_sorted=False, start: bool = True) -> Union[int, float]:
         # TODO (krim @ 2/5/24): Update the return type once timeunits are unified to `ms` as integers (https://github.com/clamsproject/mmif/issues/192)

{mmif_python-1.0.16 → mmif_python-1.0.18}/mmif/serialize/model.py

@@ -99,7 +99,7 @@ class MmifObject(object):
     _exclude_from_diff: Set[str]
     _attribute_classes: Dict[str, Type] = {}  # Mapping: str -> Type
 
-    def __init__(self, mmif_obj: Optional[Union[bytes, str, dict]] = None) -> None:
+    def __init__(self, mmif_obj: Optional[Union[bytes, str, dict]] = None, *_) -> None:
         if isinstance(mmif_obj, bytes):
             mmif_obj = mmif_obj.decode('utf8')
         if not hasattr(self, '_required_attributes'):
@@ -258,7 +258,7 @@ class MmifObject(object):
         """
         for k, v in input_dict.items():
             if self._attribute_classes and k in self._attribute_classes:
-                self[k] = self._attribute_classes[k](v)
+                self[k] = self._attribute_classes[k](v, self)
             else:
                 self[k] = v
 
@@ -285,13 +285,13 @@ class MmifObject(object):
         if key in self._named_attributes():
             if self._attribute_classes and key in self._attribute_classes \
                     and not isinstance(value, (self._attribute_classes[key])):
-                self.__dict__[key] = self._attribute_classes[key](value)
+                self.__dict__[key] = self._attribute_classes[key](value, self)
             else:
                 self.__dict__[key] = value
         else:
             if self._attribute_classes and key in self._attribute_classes \
                     and not isinstance(value, (self._attribute_classes[key])):
-                self.set_additional_property(key, self._attribute_classes[key](value))
+                self.set_additional_property(key, self._attribute_classes[key](value, self))
             else:
                 self.set_additional_property(key, value)
 
@@ -342,7 +342,7 @@ class DataList(MmifObject, Generic[T]):
 
     :param Union[str, list] mmif_obj: the data that the list contains
     """
-    def __init__(self, mmif_obj: Optional[Union[bytes, str, list]] = None):
+    def __init__(self, mmif_obj: Optional[Union[bytes, str, list]] = None, *_):
         self.reserved_names.add('_items')
         self._items: Dict[str, T] = dict()
         self.disallow_additional_properties()
@@ -440,7 +440,7 @@ class DataList(MmifObject, Generic[T]):
 
 
 class DataDict(MmifObject, Generic[T, S]):
-    def __init__(self, mmif_obj: Optional[Union[bytes, str, dict]] = None):
+    def __init__(self, mmif_obj: Optional[Union[bytes, str, dict]] = None, *_):
         self.reserved_names.add('_items')
         self._items: Dict[T, S] = dict()
         self.disallow_additional_properties()

{mmif_python-1.0.16 → mmif_python-1.0.18}/mmif/serialize/view.py

@@ -9,15 +9,13 @@ import json
 from datetime import datetime
 from typing import Dict, Union, Optional, Generator, List, cast
 
-from mmif.serialize.model import PRMTV_TYPES
-from mmif.vocabulary import ThingTypesBase, ClamsTypesBase
-from .annotation import Annotation, Document
-from .model import MmifObject, DataList, DataDict
+from mmif import DocumentTypes, AnnotationTypes, ThingTypesBase, ClamsTypesBase
+from mmif.serialize import model
+from mmif.serialize.annotation import Annotation, Document
+from mmif.serialize.model import PRMTV_TYPES, MmifObject, DataList, DataDict
 
 __all__ = ['View', 'ViewMetadata', 'Contain']
 
-from .. import DocumentTypes
-
 
 class View(MmifObject):
     """
@@ -32,10 +30,12 @@ class View(MmifObject):
     :param view_obj: the JSON data that defines the view
     """
 
-    def __init__(self, view_obj: Optional[Union[bytes, str, dict]] = None) -> None:
+    def __init__(self, view_obj: Optional[Union[bytes, str, dict]] = None, parent_mmif=None, *_) -> None:
         # used to autogenerate annotation ids
         self._id_counts = {}
-        self.reserved_names.add("_id_counts")
+        # used to access the parent MMIF object
+        self._parent_mmif = parent_mmif
+        self.reserved_names.update(("_parent_mmif", "_id_counts"))
         self._exclude_from_diff = {"_id_counts"}
         
         self.id: str = ''
@@ -64,7 +64,7 @@ class View(MmifObject):
         else:
             return self.metadata.new_contain(at_type, **contains_metadata)
     
-    def _set_id(self, annotation: Annotation, identifier):
+    def _set_ann_id(self, annotation: Annotation, identifier):
         if identifier is not None:
             annotation.id = identifier
         else:
@@ -73,7 +73,7 @@ class View(MmifObject):
             new_id = f'{prefix}_{new_num}'
             self._id_counts[prefix] = new_num
             annotation.id = new_id
-
+    
     def new_annotation(self, at_type: Union[str, ThingTypesBase], aid: Optional[str] = None, 
                        overwrite=False, **properties) -> 'Annotation':
         """
@@ -96,7 +96,7 @@ class View(MmifObject):
         """
         new_annotation = Annotation()
         new_annotation.at_type = at_type
-        self._set_id(new_annotation, aid)
+        self._set_ann_id(new_annotation, aid)
         for propk, propv in properties.items():
             new_annotation.add_property(propk, propv)
         for propk, propv in self.metadata.contains.get(at_type, {}).items():
@@ -122,8 +122,10 @@ class View(MmifObject):
         annotation.parent = self.id
         self.annotations.append(annotation, overwrite)
         self.new_contain(annotation.at_type)
+        if annotation.at_type == AnnotationTypes.Alignment:
+            self._parent_mmif._cache_alignment(annotation)
         return annotation
-
+    
     def new_textdocument(self, text: str, lang: str = "en", did: Optional[str] = None, 
                          overwrite=False, **properties) -> 'Document':
         """
@@ -147,7 +149,7 @@ class View(MmifObject):
         """
         new_document = Document()
         new_document.at_type = DocumentTypes.TextDocument
-        self._set_id(new_document, did)
+        self._set_ann_id(new_document, did)
         new_document.text_language = lang
         new_document.text_value = text
         for propk, propv in properties.items():
@@ -189,9 +191,18 @@ class View(MmifObject):
                     yield annotation
     
     def get_annotation_by_id(self, ann_id) -> Annotation:
-        ann_found = self.annotations.get(ann_id)
+        if self.id_delimiter in ann_id and not ann_id.startswith(self.id):
+            try:
+                ann_found = self._parent_mmif[ann_id]
+            except KeyError:
+                ann_found = None
+        else:
+            ann_found = self.annotations.get(ann_id.split(self.id_delimiter)[-1])
         if ann_found is None or not isinstance(ann_found, Annotation):
-            raise KeyError(f"Annotation \"{ann_id}\" is not found in view {self.id}.")
+            if self.id_delimiter in ann_id:
+                raise KeyError(f"Annotation \"{ann_id}\" is not found in the MMIF.")
+            else:
+                raise KeyError(f"Annotation \"{ann_id}\" is not found in view {self.id}.")
         else:
             return ann_found
         
@@ -257,7 +268,7 @@ class ViewMetadata(MmifObject):
     :param viewmetadata_obj: the JSON data that defines the metadata
     """
 
-    def __init__(self, viewmetadata_obj: Optional[Union[bytes, str, dict]] = None) -> None:
+    def __init__(self, viewmetadata_obj: Optional[Union[bytes, str, dict]] = None, *_) -> None:
         self.document: str = ''
         self.timestamp: Optional[datetime] = None
         self.app: str = ''
@@ -377,7 +388,7 @@ class ErrorDict(MmifObject):
     """
     Error object that stores information about error occurred during processing. 
     """
-    def __init__(self, error_obj: Optional[Union[bytes, str, dict]] = None) -> None:
+    def __init__(self, error_obj: Optional[Union[bytes, str, dict]] = None, *_) -> None:
         self.message: str = ''
         self.stackTrace: str = ''
         super().__init__(error_obj)
@@ -429,6 +440,16 @@ class AnnotationsList(DataList[Union[Annotation, Document]]):
         :return: None
         """
         super()._append_with_key(value.id, value, overwrite)
+        
+    def __getitem__(self, key: str):
+        """
+        specialized getter implementation to workaround https://github.com/clamsproject/mmif/issues/228
+        # TODO (krim @ 7/12/24): annotation ids must be in the long form in the future, so this check will be unnecessary once https://github.com/clamsproject/mmif/issues/228 is resolved. 
+        """
+        if ":" in key:
+            _, aid = key.split(":")
+            return self._items.__getitem__(aid)
+        return self._items.get(key, None)
 
 
 class ContainsDict(DataDict[ThingTypesBase, Contain]):

{mmif_python-1.0.16 → mmif_python-1.0.18}/mmif/utils/video_document_helper.py

@@ -1,12 +1,12 @@
 import importlib
+import math
 import warnings
 from typing import List, Union, Tuple
-import math
 
 import mmif
 from mmif import Annotation, Document, Mmif
 from mmif.utils.timeunit_helper import convert
-from mmif.vocabulary import DocumentTypes, AnnotationTypes
+from mmif.vocabulary import DocumentTypes
 
 for cv_dep in ('cv2', 'ffmpeg', 'PIL'):
     try:
@@ -212,19 +212,19 @@ def convert_timepoint(mmif: Mmif, timepoint: Annotation, out_unit: str) -> Union
     return convert(timepoint.get_property('timePoint'), in_unit, out_unit, get_framerate(vd))
 
 
-def convert_timeframe(mmif: Mmif, time_frame: Annotation, out_unit: str) -> Union[Tuple[Union[int, float, str], Union[int, float, str]]]:
+def convert_timeframe(mmif: Mmif, time_frame: Annotation, out_unit: str) -> Tuple[Union[int, float, str], Union[int, float, str]]:
     """
     Converts start and end points in a ``TimeFrame`` annotation a different time unit.
 
     :param mmif: :py:class:`~mmif.serialize.mmif.Mmif` instance
     :param time_frame: :py:class:`~mmif.serialize.annotation.Annotation` instance that holds a time interval annotation (``"@type": ".../TimeFrame/..."``)
     :param out_unit: time unit to which the point is converted
-    :return: tuple of frame numbers (integer) or seconds/milliseconds (float) of input start and end
+    :return: tuple of frame numbers, seconds/milliseconds, or ISO notation of TimeFrame's start and end
     """
     in_unit = time_frame.get_property('timeUnit')
     vd = mmif[time_frame.get_property('document')]
-    return convert(mmif.get_start(time_frame), in_unit, out_unit, get_framerate(vd)), \
-        convert(mmif.get_end(time_frame), in_unit, out_unit, get_framerate(vd))
+    fps = get_framerate(vd)
+    return convert(time_frame.get_property('start'), in_unit, out_unit, fps), convert(time_frame.get_property('end'), in_unit, out_unit, fps)
 
 
 def framenum_to_second(video_doc: Document, frame: int):

mmif_python-1.0.18/mmif/ver/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "1.0.18"
+__specver__ = "1.0.5"

{mmif_python-1.0.16 → mmif_python-1.0.18}/mmif/vocabulary/annotation_types.py

@@ -1,4 +1,4 @@
-# Spec version 1.0.4
+# Spec version 1.0.5
 # This file is auto-generated by setup.py
 
 from .base_types import AnnotationTypesBase
@@ -7,7 +7,7 @@ from .base_types import AnnotationTypesBase
 class AnnotationTypes(AnnotationTypesBase):
     """
     This class contains the CLAMS annotation types 
-    defined in the spec version 1.0.4 as class variables. 
+    defined in the spec version 1.0.5 as class variables. 
     """
     
     # prpoerty aliases, first added in MMIF 1.0.2

{mmif_python-1.0.16 → mmif_python-1.0.18}/mmif/vocabulary/base_types.py

@@ -196,7 +196,7 @@ class DocumentTypesBase(ClamsTypesBase):
 class ThingType(ThingTypesBase):
     """
     This class contains the topmost CLAMS thing type 
-    defined in the spec version 1.0.4 as a class variable. 
+    defined in the spec version 1.0.5 as a class variable. 
     """
     Thing = ClamsTypesBase('http://mmif.clams.ai/vocabulary/Thing/v1')
     _typevers = {'Thing': 'v1'}

{mmif_python-1.0.16 → mmif_python-1.0.18}/mmif/vocabulary/document_types.py

@@ -1,4 +1,4 @@
-# Spec version 1.0.4
+# Spec version 1.0.5
 # This file is auto-generated by setup.py
 
 from .base_types import DocumentTypesBase
@@ -7,7 +7,7 @@ from .base_types import DocumentTypesBase
 class DocumentTypes(DocumentTypesBase):
     """
     This class contains the CLAMS document types 
-    defined in the spec version 1.0.4 as class variables. 
+    defined in the spec version 1.0.5 as class variables. 
     """
     Document = DocumentTypesBase('http://mmif.clams.ai/vocabulary/Document/v1')
     VideoDocument = DocumentTypesBase('http://mmif.clams.ai/vocabulary/VideoDocument/v1')

{mmif_python-1.0.16 → mmif_python-1.0.18}/mmif_docloc_http/__init__.py

@@ -10,3 +10,7 @@ def resolve(docloc):
             raise ValueError(f'cannot handle document location scheme: {docloc}')
     except urllib.error.URLError as e:
         raise e
+    
+    
+def help():
+    return "location must be a URL string."

{mmif_python-1.0.16 → mmif_python-1.0.18}/mmif_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mmif-python
-Version: 1.0.16
+Version: 1.0.18
 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.16 → mmif_python-1.0.18}/tests/test_serialize.py

@@ -222,7 +222,7 @@ class TestMmif(unittest.TestCase):
     def test_document_location_helpers_http(self):
         new_doc = Document()
         new_doc.id = "d1"
-        new_doc.location = f"https://www.gnu.org/licenses/gpl-3.0.txt"
+        new_doc.location = f"https://example.com/"
         self.assertEqual(new_doc.location_scheme(), 'https')
         try:
             path = new_doc.location_path()
@@ -277,11 +277,11 @@ class TestMmif(unittest.TestCase):
         self.assertEqual(2, len(views))
         views = mmif_obj.get_all_views_contain('http://vocab.lappsgrid.org/SemanticTag')
         self.assertEqual(1, len(views))
-        views = mmif_obj.get_views_contain([
+        views = mmif_obj.get_views_contain(
             AnnotationTypes.TimeFrame,
             DocumentTypes.TextDocument,
             AnnotationTypes.Alignment,
-        ])
+        )
         self.assertEqual(1, len(views))
         views = mmif_obj.get_all_views_contain(not_existing_attype)
         self.assertEqual(0, len(views))
@@ -323,6 +323,17 @@ class TestMmif(unittest.TestCase):
         views_and_alignments = mmif_obj.get_alignments(DocumentTypes.TextDocument, AnnotationTypes.BoundingBox)
         self.assertEqual(1, len(views_and_alignments))
         self.assertTrue('v6' in views_and_alignments)
+    
+    def test_cache_alignment(self):
+        mmif_obj = Mmif(MMIF_EXAMPLES['everything'])
+        views_and_alignments = mmif_obj.get_alignments(DocumentTypes.TextDocument, AnnotationTypes.TimeFrame)
+        for vid, alignments in views_and_alignments.items():
+            v = mmif_obj.get_view_by_id(vid)
+            for alignment in alignments:
+                s = v.get_annotation_by_id(alignment.get('source'))
+                t = v.get_annotation_by_id(alignment.get('target'))
+                self.assertTrue(s.aligned_to_by(alignment).long_id.endswith(t.long_id))
+                self.assertTrue(t.aligned_to_by(alignment).long_id.endswith(s.long_id))
 
     def test_new_view_id(self):
         p = Mmif.view_prefix
@@ -350,7 +361,7 @@ class TestMmif(unittest.TestCase):
         # .[] |
         # select(."@type"=="http://vocab.lappsgrid.org/Token")] |
         # sort_by(.properties.id | ltrimstr("t") | tonumber) |
-        # map(.properties.text)' <examples>.json
+        # map(.properties.word)' <examples>.json
         tokens_in_order = ["Hello",
                            ",",
                            "this",
@@ -382,23 +393,26 @@ class TestMmif(unittest.TestCase):
         mmif_obj = Mmif(MMIF_EXAMPLES['everything'])
 
         # Test case 1: All token annotations are selected
-        selected_token_anns = mmif_obj.get_annotations_between_time(0, 22000)
-        self.assertEqual(28, len(list(selected_token_anns)))
+        selected_token_anns = [ann for ann in mmif_obj.get_annotations_between_time(0, 22000) if ann.is_type(token_type)]
+        self.assertEqual(28, len(selected_token_anns))
         for i, ann in enumerate(selected_token_anns):
-            self.assertTrue(ann.is_type(token_type))
-            self.assertEqual(tokens_in_order[i], ann.get_property("text"))
+            self.assertEqual(tokens_in_order[i], ann.get_property("word"))
 
         # Test case 2: No token annotation are selected
-        selected_token_anns = mmif_obj.get_annotations_between_time(0, 5, time_unit="seconds")
-        self.assertEqual(0, len(list(selected_token_anns)))
+        selected_token_anns = list(mmif_obj.get_annotations_between_time(0, 5, time_unit="seconds"))
+        self.assertEqual(4, len(list(selected_token_anns))) 
+        for ann in selected_token_anns:
+            self.assertFalse(ann.is_type(token_type))
 
         # Test case 3(a): Partial tokens are selected (involve partial overlap)
-        selected_token_anns = mmif_obj.get_annotations_between_time(7, 10, time_unit="seconds")
-        self.assertEqual(tokens_in_order[3:9], [ann.get_property("text") for ann in selected_token_anns])
+        selected_token_anns = mmif_obj.get_annotations_between_time(7, 10, time_unit="seconds", 
+                                                                    at_types=['http://vocab.lappsgrid.org/Token'])
+        self.assertEqual(tokens_in_order[3:9], [ann.get_property("word") for ann in selected_token_anns])
 
         # Test case 3(b): Partial tokens are selected (only full overlap)
-        selected_token_anns = mmif_obj.get_annotations_between_time(11500, 14600)
-        self.assertEqual(tokens_in_order[12:17], [ann.get_property("text") for ann in selected_token_anns])
+        selected_token_anns = mmif_obj.get_annotations_between_time(11500, 14600, 
+                                                                    at_types=['http://vocab.lappsgrid.org/Token'])
+        self.assertEqual(tokens_in_order[12:17], [ann.get_property("word") for ann in selected_token_anns])
 
     def test_add_document(self):
         mmif_obj = Mmif(MMIF_EXAMPLES['everything'])
@@ -662,6 +676,7 @@ class TestView(unittest.TestCase):
         self.assertEqual(view_from_str, view_from_bytes)
         self.assertEqual(json.loads(view_from_json.serialize()), json.loads(view_from_str.serialize()))
         self.assertEqual(json.loads(view_from_bytes.serialize()), json.loads(view_from_str.serialize()))
+        
 
     def test_annotation_order_preserved(self):
         view_serial = self.view_obj.serialize()
@@ -885,13 +900,12 @@ class TestAnnotation(unittest.TestCase):
     # TODO (angus-lherrou @ 7/27/2020): testing should include validation for required attrs
     #  once that is implemented (issue #23)
     def setUp(self) -> None:
-        self.data = {i: {'string': example,
-                         'json': json.loads(example),
-                         'mmif': Mmif(example),
-                         'annotations': [annotation
-                                         for view in json.loads(example)['views']
-                                         for annotation in view['annotations']]}
-                     for i, example in MMIF_EXAMPLES.items()}
+        self.data = {}
+        for i, example in MMIF_EXAMPLES.items():
+            self.data[i] = {'string': example,
+                            'json': json.loads(example),
+                            'mmif': Mmif(example),
+                            'annotations': [annotation for view in json.loads(example)['views'] for annotation in view['annotations']]}
 
     def test_annotation_properties(self):
         ann_json = self.data['everything']['annotations'][0]
@@ -1104,11 +1118,11 @@ class TestDocument(unittest.TestCase):
         # then converted to an `Annotation` annotation during serialization at `Mmif`-level
         mmif.add_document(doc1)
         ## no Annotation before serialization
-        self.assertEqual(0, len(list(mmif.views.get_last().get_annotations(AnnotationTypes.Annotation, author='me'))))
+        self.assertEqual(0, len(list(mmif.views.get_last_contentful_view().get_annotations(AnnotationTypes.Annotation, author='me'))))
         ## after serialization, the `Annotation` annotation should be added to the last view
         ## note that we didn't add any views, so the last view before and after the serialization are the same
         mmif_roundtrip = Mmif(mmif.serialize())
-        self.assertTrue(next(mmif_roundtrip.views.get_last().get_annotations(AnnotationTypes.Annotation, author='me')))
+        self.assertTrue(next(mmif_roundtrip.views.get_last_contentful_view().get_annotations(AnnotationTypes.Annotation, author='me')))
         # finally, when deserialized back to a Mmif instance, the `Annotation` props should be added
         # as a property of the document 
         doc1_mmif_roundtrip = mmif_roundtrip.get_document_by_id('doc1')
@@ -1121,7 +1135,7 @@ class TestDocument(unittest.TestCase):
         mmif.add_document(doc1)
         did = 'doc1'
         # last view before serialization rounds
-        r0_vid = mmif.views.get_last().id
+        r0_vid = mmif.views.get_last_contentful_view().id
         doc1.at_type = DocumentTypes.TextDocument
         doc1.id = did
         doc1.location = 'aScheme:///data/doc1.txt'
@@ -1151,7 +1165,7 @@ class TestDocument(unittest.TestCase):
         self.assertEqual(2, len(doc1._props_pending))
         mmif_roundtrip2 = Mmif(mmif_roundtrip1.serialize())
         ## but not serialized
-        self.assertEqual(0, len(list(mmif_roundtrip2.views.get_last().get_annotations(AnnotationTypes.Annotation))))
+        self.assertEqual(0, len(list(mmif_roundtrip2.views.get_last_contentful_view().get_annotations(AnnotationTypes.Annotation))))
 
         # adding non-duplicate value should be serialized into a new Annotation object
         # even when there is a duplicate key in a previous view
@@ -1197,7 +1211,7 @@ class TestDocument(unittest.TestCase):
         doc1.add_property('author', 'me')
         mmif_roundtrip = Mmif(mmif.serialize())
         ## should be only one Annotation object, from manual call of `new_annotation`
-        self.assertEqual(1, len(list(mmif_roundtrip.views.get_last().get_annotations(AnnotationTypes.Annotation))))
+        self.assertEqual(1, len(list(mmif_roundtrip.views.get_last_contentful_view().get_annotations(AnnotationTypes.Annotation))))
 
         # test with duplicate property added by a downstream app
         mmif_roundtrip = Mmif(mmif.serialize())
@@ -1209,9 +1223,9 @@ class TestDocument(unittest.TestCase):
         # author=me is already in the input MMIF
         doc1_prime.add_property('author', 'me')
         mmif_roundtrip2 = Mmif(mmif_roundtrip.serialize())
-        self.assertEqual(1, len(list(mmif.views.get_last().get_annotations(AnnotationTypes.Annotation))))
+        self.assertEqual(1, len(list(mmif.views.get_last_contentful_view().get_annotations(AnnotationTypes.Annotation))))
         # none should be added
-        self.assertEqual(0, len(list(mmif_roundtrip2.views.get_last().get_annotations(AnnotationTypes.Annotation))))
+        self.assertEqual(0, len(list(mmif_roundtrip2.views.get_last_contentful_view().get_annotations(AnnotationTypes.Annotation))))
 
         # test with same key, different value
         mmif_roundtrip = Mmif(mmif.serialize())
@@ -1224,13 +1238,13 @@ class TestDocument(unittest.TestCase):
         doc1_prime.add_property('author', 'you')
         mmif_roundtrip2 = Mmif(mmif_roundtrip.serialize())
         # the Annotation in the previous view should be preserved
-        self.assertEqual(1, len(list(mmif.views.get_last().get_annotations(AnnotationTypes.Annotation))))
+        self.assertEqual(1, len(list(mmif.views.get_last_contentful_view().get_annotations(AnnotationTypes.Annotation))))
         # but a new one should be added
-        self.assertEqual(1, len(list(mmif_roundtrip2.views.get_last().get_annotations(AnnotationTypes.Annotation))))
+        self.assertEqual(1, len(list(mmif_roundtrip2.views.get_last_contentful_view().get_annotations(AnnotationTypes.Annotation))))
 
-        self.assertEqual('me', list(mmif.views.get_last().get_annotations(AnnotationTypes.Annotation))[0].get_property(
+        self.assertEqual('me', list(mmif.views.get_last_contentful_view().get_annotations(AnnotationTypes.Annotation))[0].get_property(
             'author'))
-        self.assertEqual('you', list(mmif_roundtrip2.views.get_last().get_annotations(AnnotationTypes.Annotation))[
+        self.assertEqual('you', list(mmif_roundtrip2.views.get_last_contentful_view().get_annotations(AnnotationTypes.Annotation))[
             0].get_property('author'))
         
     def test_capital_annotation_generation_viewfinder(self):
@@ -1255,6 +1269,28 @@ class TestDocument(unittest.TestCase):
             cap_anns = list(mmif_roundtrip.views[f'v{i}'].get_annotations(AnnotationTypes.Annotation))
             self.assertEqual(1, len(cap_anns))
             self.assertEqual(authors[i-1], cap_anns[0].get_property('author'))
+            
+    def test_capital_annotation_nongeneration_for_writable_documents(self):
+        mmif = Mmif(validate=False)
+        doc = Document()
+        doc.at_type = DocumentTypes.TextDocument
+        doc.id = f'doc0'
+        doc.location = f'aScheme:///data/doc0.txt'
+        mmif.add_document(doc)
+
+        v = mmif.new_view()
+        v.metadata.app = tester_appname
+        vid = v.id
+        new_td_id = mmif[vid].new_textdocument(text='new text', document='doc0', origin='transformation').id
+        doc.add_property('author', 'me')
+        
+        mmif_roundtrip = Mmif(mmif.serialize())
+        
+        self.assertTrue(AnnotationTypes.Annotation in mmif_roundtrip[vid].metadata.contains)
+        self.assertTrue(mmif_roundtrip.get_document_by_id('doc0').get_property('author'), 'me')
+        self.assertTrue(next(mmif_roundtrip[vid].get_annotations(AnnotationTypes.Annotation)).get_property('author'), 'me')
+        self.assertTrue(next(mmif_roundtrip[vid].get_annotations(AnnotationTypes.Annotation)).get_property('document'), doc.id)
+        self.assertTrue(mmif_roundtrip[new_td_id].get_property('origin'), 'transformation')
 
     def test_deserialize_with_whole_mmif(self):
         for i, datum in self.data.items():

{mmif_python-1.0.16 → mmif_python-1.0.18}/tests/test_utils.py

@@ -4,10 +4,9 @@ import pytest
 
 from mmif import Mmif, Document, AnnotationTypes
 from mmif.utils import sequence_helper as sqh
+from mmif.utils import text_document_helper as tdh
 from mmif.utils import timeunit_helper as tuh
 from mmif.utils import video_document_helper as vdh
-from mmif.utils import text_document_helper as tdh
-from mmif.serialize import mmif
 from tests.mmif_examples import *
 
 
@@ -178,7 +177,7 @@ class TestSequenceHelper(unittest.TestCase):
 class TestTextDocHelper(unittest.TestCase):
     mmif_obj = Mmif(MMIF_EXAMPLES['everything'])
 
-    @pytest.mark.skip("The only valid test cases come from kalbi app which annotates wrong property")
+    @pytest.mark.skip("The only valid test cases come from kaldi app which annotates wrong property")
     def test_slice_text(self):
         sliced_text_full_overlap = tdh.slice_text(self.mmif_obj, 11500, 14600)
         sliced_text_partial_overlap = tdh.slice_text(self.mmif_obj, 7, 10, unit="seconds")

mmif_python-1.0.16/VERSION

@@ -1 +0,0 @@
-1.0.16

mmif_python-1.0.16/mmif/ver/__init__.py

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