mmif-python 1.5.3__tar.gz → 1.5.4__tar.gz

{mmif_python-1.5.3 → mmif_python-1.5.4}/CHANGELOG.md

@@ -1,4 +1,16 @@
 
+## releasing 1.5.3 (2026-07-08)
+### Overview
+This patch includes improvements in automatic conversion between contains-metadata properties and annotation properties (#396) 
+
+### Additions
+* automatic "factoring" of value-shared properties from annotation-level to contains-level at serialization time works much more generally now (formerly only worked for `Annotation` type and `document` prop) 
+
+### Changes
+* fixed a bug in reading old MMIF files with non-canonical prop names (contains-level prop value was not properly propagated at deserialization for those non-canonical named props)
+
+
+
 ## releasing 1.5.2 (2026-07-07)
 ### Overview
 This is a quick patch on the bug that when MMIF is deserialized, the annotation ID counts in the views weren't properly initialized. This should not be a real bug since new annotations should always written to new views (of current processing app) but not to existing views (where annotation count > 0), however, bugs in app code can trigger this condition, and this patch preventively fixes such cases.

{mmif_python-1.5.3 → mmif_python-1.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mmif-python
-Version: 1.5.3
+Version: 1.5.4
 Summary: Python implementation of MultiMedia Interchange Format specification. (https://mmif.clams.ai)
 License-Expression: Apache-2.0
 Project-URL: homepage, https://mmif.clams.ai
@@ -21,7 +21,7 @@ Requires-Dist: pillow; extra == "cv"
 Requires-Dist: opencv-python; extra == "cv"
 Requires-Dist: ffmpeg-python; extra == "cv"
 Requires-Dist: wurlitzer; extra == "cv"
-Requires-Dist: av; extra == "cv"
+Requires-Dist: av>=15; extra == "cv"
 Provides-Extra: seq
 Requires-Dist: numpy; extra == "seq"
 Provides-Extra: docs

{mmif_python-1.5.3 → mmif_python-1.5.4}/documentation/target-versions.csv

@@ -1,4 +1,5 @@
 "``mmif-python`` version","Target MMIF Specification"
+`1.5.4 <https://pypi.org/project/mmif-python/1.5.4/>`__,`1.2.0 <https://mmif.clams.ai/1.2.0/>`__
 `1.5.3 <https://pypi.org/project/mmif-python/1.5.3/>`__,`1.2.0 <https://mmif.clams.ai/1.2.0/>`__
 `1.5.2 <https://pypi.org/project/mmif-python/1.5.2/>`__,`1.2.0 <https://mmif.clams.ai/1.2.0/>`__
 `1.5.1 <https://pypi.org/project/mmif-python/1.5.1/>`__,`1.2.0 <https://mmif.clams.ai/1.2.0/>`__

{mmif_python-1.5.3 → mmif_python-1.5.4}/mmif/serialize/annotation.py

@@ -6,6 +6,7 @@ In MMIF, annotations are created by apps in a workflow as a part
 of a view. For documentation on how views are represented, see
 :mod:`mmif.serialize.view`.
 """
+import functools
 import importlib
 import itertools
 import os
@@ -22,7 +23,7 @@ from .model import MmifObject, PRMTV_TYPES
 from .. import DocumentTypes, AnnotationTypes
 import mmif_docloc_http
 
-__all__ = ['Annotation', 'AnnotationProperties', 'Document', 'DocumentProperties', 'Text']
+__all__ = ['Annotation', 'AnnotationProperties', 'Document', 'DocumentProperties', 'Text', 'canonicalize_prop_name']
 
 T = TypeVar('T')
 LIST_PRMTV = typing.List[PRMTV_TYPES]  # list of values (most cases for annotation props)
@@ -41,6 +42,40 @@ discovered_docloc_plugins.update({
 })
 
 
+@functools.lru_cache(maxsize=None)
+def _prop_alias_map(shortname: str) -> Dict[str, str]:
+    """
+    Maps every spelling of an aliased property of a type to the canonical
+    name. The table is read from the latest version of the type in the
+    vocabulary (``AnnotationTypes.<shortname>``), which is the single source
+    of truth for property aliases.
+
+    :param shortname: shortname of the annotation type (e.g. ``TimeFrame``)
+    :return: ``{spelling: canonical_name}``, empty for types without aliases
+    """
+    latest = getattr(AnnotationTypes, shortname, None)
+    groups = getattr(latest, '_property_aliases', None) or {}
+    return {alias: canonical for canonical, group in groups.items() for alias in group}
+
+
+def canonicalize_prop_name(at_type: ThingTypesBase, prop_name: str) -> str:
+    """
+    Resolves a property name to its canonical spelling for the given type.
+    Property aliases were introduced in MMIF 1.0.2, when the general
+    ``label`` property replaced ``frameType`` (``TimeFrame``) and ``boxType``
+    (``BoundingBox``). Names that are not aliases, and types without an alias
+    table, are returned unchanged.
+
+    :param at_type: the ``@type`` of the annotation
+    :param prop_name: a property name, canonical or deprecated
+    :return: the canonical property name
+    """
+    shortname = getattr(at_type, 'shortname', None)
+    if not shortname:
+        return prop_name
+    return _prop_alias_map(shortname).get(prop_name, prop_name)
+
+
 class Annotation(MmifObject):
     """
     MmifObject that represents an annotation in a MMIF view.
@@ -49,11 +84,11 @@ class Annotation(MmifObject):
     def __init__(self, anno_obj: Optional[Union[bytes, str, dict]] = None, *_) -> None:
         self._type: ThingTypesBase = ThingTypesBase('')
         # to store the parent view ID
-        self._props_ephemeral: AnnotationProperties = AnnotationProperties()
+        self._props_ephemeral: AnnotationProperties = AnnotationProperties(None, self)
         self._alignments = {}  # to hold alignment information (Alignment anno long_id -> aligned anno long_id)
         self.reserved_names.update(('_props_ephemeral', '_alignments'))
         if not hasattr(self, 'properties'):  # don't overwrite DocumentProperties on super() call
-            self.properties: AnnotationProperties = AnnotationProperties()
+            self.properties: AnnotationProperties = AnnotationProperties(None, self)
             self._attribute_classes = {'properties': AnnotationProperties}
         self.disallow_additional_properties()
         self._required_attributes = ["_type", "properties"]
@@ -69,9 +104,7 @@ class Annotation(MmifObject):
         # here is the place to parse formatted IDs and store prefixes in the parent mmif object. 
         # (see https://github.com/clamsproject/mmif/issues/64#issuecomment-849241309 for discussion)
         super()._deserialize(input_dict)
-        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.
@@ -107,29 +140,20 @@ class Annotation(MmifObject):
             yield aligned
         
         
-    def _add_prop_aliases(self, key_to_add, val_to_add):
-        """
-        Method to handle aliases of the same property.
-        Annotation property aliases were first introduced in MMIF 1.0.2, 
-        with addition of general `label` property to all `Annotation` 
-        subtypes, and effectively deprecated `frameType` and `boxType`
-        in `TimeFrame` and `BoundingBox` respectively.
-        """
-        prop_aliases = AnnotationTypes._prop_aliases.get(self._type.shortname, {})
-        for alias_rep, alias_group in prop_aliases.items():
-            if key_to_add in alias_group:
-                for alias in alias_group:
-                    if alias != key_to_add:
-                        self._props_ephemeral[alias] = val_to_add
-                        if alias in self.properties.keys():
-                            warning_msg = (f'Both "{key_to_add}" and "{alias}" are in the properties of "{self.id}", '
-                                           f'however ')
-                            if alias == alias_rep:
-                                warning_msg += f'"{key_to_add}" is an alias of "{alias_rep}".'
-                            else:
-                                warning_msg += f'"{key_to_add}" and "{alias}" are both aliases of "{alias_rep}".'
-                            warning_msg += f'Having two synonyms in the same annotation can cause unexpected behavior. '
-                            warnings.warn(warning_msg, UserWarning)
+    def _add_ephemeral_defaults(self, defaults: typing.Mapping[str, typing.Any]) -> None:
+        """
+        Distributes view-level defaults (from the ``contains`` metadata of the
+        parent view) to this annotation as ephemeral properties, under their
+        canonical names. An annotation-level value takes precedence over a
+        view-level default, so a default is skipped when the annotation
+        carries the property itself.
+
+        :param defaults: property defaults for this annotation's ``@type``
+        """
+        for name, value in defaults.items():
+            name = canonicalize_prop_name(self._type, name)
+            if name not in self.properties:
+                self._props_ephemeral[name] = value
 
     def is_type(self, at_type: Union[str, ThingTypesBase]) -> bool:
         """
@@ -239,7 +263,9 @@ class Annotation(MmifObject):
     def add_property(self, name: str,
                      value: Union[PRMTV_TYPES, LIST_PRMTV, LIST_LIST_PRMTV, DICT_PRMTV, DICT_LIST_PRMTV]) -> None:
         """
-        Adds a property to the annotation's properties.
+        Adds a property to the annotation's properties. A deprecated spelling
+        of an aliased property (e.g. ``frameType``) is stored under its
+        canonical name (``label``), with a :class:`DeprecationWarning`.
 
         :param name: the name of the property
         :param value: the property's desired value
@@ -252,14 +278,14 @@ class Annotation(MmifObject):
         #                      "either string, number, boolean, None, a JSON array of them, "
         #                      "or a JSON object of them keyed by strings."
         #                      f"(\"{name}\": \"{str(value)}\"")
-        self._add_prop_aliases(name, value)
 
     def __getitem__(self, prop_name: str):
         if prop_name in {'at_type', '@type'}:
             return str(self._type)
         elif prop_name == 'properties':
             return self.properties
-        elif prop_name in self.properties:
+        prop_name = canonicalize_prop_name(self._type, prop_name)
+        if prop_name in self.properties:
             return self.properties[prop_name]
         elif prop_name in self._props_ephemeral:
             return self._props_ephemeral[prop_name]
@@ -279,7 +305,9 @@ class Annotation(MmifObject):
         3. Special fields (``@type``, ``properties``)
 
         This allows convenient access to properties without explicitly
-        checking the ``properties`` object or view-level metadata.
+        checking the ``properties`` object or view-level metadata. A
+        deprecated spelling of an aliased property (e.g. ``frameType``)
+        resolves to the canonical property (``label``).
 
         :param prop_name: The name of the property to retrieve
         :param default: The value to return if the property is not found (default: None)
@@ -318,23 +346,6 @@ class Annotation(MmifObject):
         except KeyError:
             return False
     
-    def _get_label(self) -> str:
-        """
-        Another prototypical method to handle property aliases.
-        See :meth:`.Annotation._add_prop_aliases` for more details on 
-        what property aliases are.
-        Not recommended to use this method as `_add_prop_aliases` method 
-        is preferred. 
-        """
-        if 'label' in self:
-            return str(self.get('label'))
-        elif self._type.shortname == 'TimeFrame' and 'frameType' in self:
-            return str(self.get('frameType'))
-        elif self._type.shortname == 'BoundingBox' and 'boxType' in self:
-            return str(self.get('boxType'))
-        else:
-            raise KeyError("No label found in this annotation.")
-    
     def is_document(self):
         return isinstance(self._type, DocumentTypesBase)
 
@@ -356,8 +367,8 @@ class Document(Annotation):
         # 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`)
-        self._props_original: DocumentProperties = DocumentProperties()
-        self._props_pending: AnnotationProperties = AnnotationProperties()
+        self._props_original: DocumentProperties = DocumentProperties(None, self)
+        self._props_pending: AnnotationProperties = AnnotationProperties(None, self)
         self.reserved_names.update(('_props_original', '_props_pending'))
         
         self._type: Union[ThingTypesBase, DocumentTypesBase] = ThingTypesBase('')
@@ -578,6 +589,7 @@ class AnnotationProperties(MmifObject, MutableMapping[str, T]):
     """
 
     def __delitem__(self, key: str) -> None:
+        key = self._canonical(key)
         frm = None
         for k in self.__iter__():
             if k == key:
@@ -593,36 +605,83 @@ class AnnotationProperties(MmifObject, MutableMapping[str, T]):
             del frm[key]
         else:
             raise KeyError(f'Key "{key}" not found.')
-                
+
     def __iter__(self) -> Iterator[str]:
         """
-        ``__iter__`` on Mapping should basically work as ``keys()`` method 
+        ``__iter__`` on Mapping should basically work as ``keys()`` method
         of vanilla dict.
         """
         for key in itertools.chain(self._named_attributes(), self._unnamed_attributes):
             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. 
+        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.
         """
+        key = self._canonical(key)
         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:
+    def __setitem__(self, key: str, value) -> None:
+        """
+        Sets a property. A deprecated spelling of an aliased property (e.g.
+        ``frameType``) is stored under its canonical name (``label``), with
+        a :class:`DeprecationWarning`.
+        """
+        canonical = self._canonical(key)
+        if canonical != key:
+            warnings.warn(f'"{key}" is a deprecated alias of "{canonical}", storing the value as "{canonical}".',
+                          DeprecationWarning)
+        super().__setitem__(canonical, value)
+
+    def __init__(self, mmif_obj: Optional[Union[bytes, str, dict]] = None,
+                 parent: Optional['Annotation'] = 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 = {}
+        # the Annotation these properties belong to; its `@type` decides which
+        # property names are aliases of each other (see `canonicalize_prop_name`)
+        self._parent_annotation = parent
+        self.reserved_names.add('_parent_annotation')
         super().__init__(mmif_obj)
 
+    def _canonical(self, key: str) -> str:
+        if self._parent_annotation is None:
+            return key
+        return canonicalize_prop_name(self._parent_annotation._type, key)
+
+    def _deserialize(self, input_dict: dict) -> None:
+        """
+        Deserializes the properties, rewriting deprecated spellings to their
+        canonical names so that there is one key per property. When two
+        spellings of the same property are present, the canonical one wins
+        (or the first one seen, when neither is canonical), with a warning.
+        """
+        canonical_dict = {}
+        # canonical name -> the deprecated spelling it was read from
+        from_alias = {}
+        for key, value in input_dict.items():
+            canonical = self._canonical(key)
+            if canonical in canonical_dict and (canonical != key or canonical in from_alias):
+                alias = key if canonical != key else from_alias[canonical]
+                warnings.warn(f'Both "{alias}" and "{canonical}" are in the properties of '
+                              f'"{input_dict.get("id", "")}", but "{alias}" is an alias of "{canonical}". '
+                              f'Keeping the value of "{canonical}".', UserWarning)
+                if canonical != key:
+                    continue
+            canonical_dict[canonical] = value
+            if canonical != key:
+                from_alias[canonical] = key
+        super()._deserialize(canonical_dict)
+
 
 class DocumentProperties(AnnotationProperties):
     """
@@ -632,7 +691,8 @@ 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,
+                 parent: Optional['Annotation'] = 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
@@ -643,9 +703,9 @@ class DocumentProperties(AnnotationProperties):
         self._attribute_classes = {'text': Text}
         # in theory, either `location` or `text` should appear in a `document`
         # but with current implementation, there's no easy way to set a condition 
-        # for `oneOf` requirement 
-        # see MmifObject::_required_attributes in model.py 
-        super().__init__(mmif_obj)
+        # for `oneOf` requirement
+        # see MmifObject::_required_attributes in model.py
+        super().__init__(mmif_obj, parent)
 
     def _deserialize(self, input_dict: dict) -> None:
         if "location" in input_dict:

{mmif_python-1.5.3 → mmif_python-1.5.4}/mmif/serialize/mmif.py

@@ -276,25 +276,11 @@ 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)
-            for at_type, type_lv_props in view.metadata.contains.items():
-                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. A view-level `contains` default must
-                # not override an annotation-level value that is already present
-                # in `_props_ephemeral` -- namely an alias of a property set on the
-                # annotation itself (put there by `_add_prop_aliases` during the
-                # annotation's own deserialization, which runs earlier). Per the
-                # spec, the annotation-level value takes precedence over the
-                # view-level default.
-                for prop_key, prop_value in extrinsic_props[ann.at_type].items():
-                    if prop_key not in ann._props_ephemeral:
-                        ann._props_ephemeral[prop_key] = prop_value
+                # first, distribute view-level defaults from `contains` metadata
+                # to the Annotation objects as "ephemeral" properties
+                ann._add_ephemeral_defaults(view.metadata.contains.get(ann.at_type, {}))
                 # then, do the same to associated Document objects. Note that, 
                 # in a view, it is guaranteed that all Annotation objects are not duplicates
                 if ann.at_type == AnnotationTypes.Annotation:

{mmif_python-1.5.3 → mmif_python-1.5.4}/mmif/serialize/view.py

@@ -17,7 +17,7 @@ from datetime import datetime
 from typing import Dict, Union, Optional, Generator, List, cast
 
 from mmif import DocumentTypes, AnnotationTypes, ThingTypesBase, ClamsTypesBase
-from mmif.serialize.annotation import Annotation, Document
+from mmif.serialize.annotation import Annotation, Document, canonicalize_prop_name
 from mmif.serialize.model import PRMTV_TYPES, MmifObject, DataList, DataDict
 from mmif.vocabulary.base_types import AnnotationTypesBase
 
@@ -197,8 +197,6 @@ class View(MmifObject):
         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():
-            new_annotation._props_ephemeral[propk] = propv
         return self.add_annotation(new_annotation, overwrite)
 
     def add_annotation(self, annotation: 'Annotation', overwrite=False) -> 'Annotation':
@@ -222,6 +220,7 @@ class View(MmifObject):
             annotation.id = f"{self.id}{self.id_delimiter}{annotation.id}"
         self.annotations.append(annotation, overwrite)
         self.new_contain(annotation.at_type)
+        annotation._add_ephemeral_defaults(self.metadata.contains.get(annotation.at_type, {}))
         if annotation.at_type == AnnotationTypes.Alignment:
             self._parent_mmif._cache_alignment(annotation)
         return annotation
@@ -280,13 +279,14 @@ class View(MmifObject):
         must match. Note that annotation type metadata are specified in the `contains` view metadata, not in individual \
         annotation objects.
         """
-        def prop_check(k, v, *props):
-            return any(k in prop and prop[k] == v for prop in props)
+        def prop_check(k, v, annotation, at_type_metadata):
+            k = canonicalize_prop_name(annotation.at_type, k)
+            return any(k in prop and prop[k] == v for prop in (annotation.properties, at_type_metadata))
 
         for annotation in self.annotations:
             at_type_metadata = self.metadata.contains.get(annotation.at_type, {})
             if not at_type or (at_type and annotation.at_type == at_type):
-                if all(map(lambda kv: prop_check(kv[0], kv[1], annotation.properties, at_type_metadata), 
+                if all(map(lambda kv: prop_check(kv[0], kv[1], annotation, at_type_metadata), 
                            properties.items())):
                     yield annotation
     
@@ -485,7 +485,7 @@ class ViewMetadata(MmifObject):
             at_type = ThingTypesBase.from_str(at_type)
             
         if at_type not in self.contains:
-            new_contain = Contain(contains_metadata)
+            new_contain = Contain._for_type(at_type, contains_metadata)
             self.add_contain(new_contain, at_type)
             return new_contain
     
@@ -563,6 +563,15 @@ class Contain(DataDict[str, str]):
     annotation type in the ``contains`` metadata of a MMIF view.
     """
 
+    @classmethod
+    def _for_type(cls, at_type: ThingTypesBase, contains_metadata: dict) -> 'Contain':
+        """
+        Builds a ``Contain`` for the given ``@type``, with property names
+        rewritten to their canonical spellings (see
+        :func:`mmif.serialize.annotation.canonicalize_prop_name`).
+        """
+        return cls({canonicalize_prop_name(at_type, k): v for k, v in contains_metadata.items()})
+
 
 class AnnotationsList(DataList[Union[Annotation, Document]]):
     """
@@ -608,7 +617,7 @@ class ContainsDict(DataDict[ThingTypesBase, Contain]):
         for key, value in input_dict.items():
             if isinstance(key, str):
                 key = ThingTypesBase.from_str(key)
-            self._items[key] = Contain(value)
+            self._items[key] = Contain._for_type(key, value)
 
     def update(self, other: Union[dict, 'ContainsDict'], overwrite=False):
         for k, v in other.items():

{mmif_python-1.5.3 → mmif_python-1.5.4}/mmif/utils/summarizer/nodes.py

@@ -1,10 +1,64 @@
 import json
+from collections.abc import MutableMapping
 
 from typing import Any
 
+from mmif.serialize.annotation import canonicalize_prop_name
+from mmif.serialize.model import MmifObject
 from mmif.utils.summarizer import config
 
 
+class NodeProperties(MutableMapping):
+
+    """Read-through view of an annotation's properties for use in a Node. Reads
+    resolve, in order, local writes made by the summarizer, the annotation's own
+    properties (deprecated spellings included, e.g. `word` for `text`), and the
+    view-level defaults for the annotation's type in the view's `contains`
+    metadata. Values are plain JSON types, as they would be after a serialization
+    round trip. Writes never reach the annotation; they are kept locally so that
+    summarizing leaves the loaded MMIF unchanged.
+
+    Note on the alternative: the SDK could instead copy `contains` defaults into
+    each annotation's `.properties` at deserialization and rely on
+    `Mmif.factor_out_shared_properties` to lift them back out on serialization.
+    That round trip is not shape-preserving when a type has a single annotation
+    in the view, when the key is non-factorable (`start`, `source`, `target`, ...),
+    or when another annotation of the type overrides the default, so the SDK
+    keeps defaults out of `.properties` and this class resolves them here."""
+
+    def __init__(self, annotation, view):
+        self.annotation = annotation
+        contains = {} if view is None else view.metadata.contains.get(annotation.at_type, {})
+        self.defaults = {canonicalize_prop_name(annotation.at_type, k): v for k, v in contains.items()}
+        self.local = {}
+
+    @staticmethod
+    def _as_json(value):
+        return json.loads(str(value)) if isinstance(value, MmifObject) else value
+
+    def __getitem__(self, key):
+        if key in self.local:
+            return self.local[key]
+        if key in self.annotation.properties:
+            return self._as_json(self.annotation.properties[key])
+        return self.defaults[canonicalize_prop_name(self.annotation.at_type, key)]
+
+    def __setitem__(self, key, value):
+        self.local[key] = value
+
+    def __delitem__(self, key):
+        del self.local[key]
+
+    def __iter__(self):
+        seen = set()
+        for key in (*self.annotation.properties, *self.defaults, *self.local):
+            if key not in seen:
+                seen.add(key)
+                yield key
+
+    def __len__(self):
+        return sum(1 for _ in self)
+
 
 class Node(object):
 
@@ -16,7 +70,7 @@ class Node(object):
         # copy some information from the Annotation
         self.at_type = annotation.at_type
         self.identifier = annotation.id
-        self.properties = json.loads(str(annotation.properties))
+        self.properties = NodeProperties(annotation, view)
         # get the document from the view or the properties
         self.document = self._get_document()
         # The targets property contains a list of annotations or documents that
@@ -151,23 +205,10 @@ class Node(object):
 
     def _get_document(self):
         """Return the document or annotation node that the annotation/document in
-        the node refers to via the document property. This could be a local property
-        or a metadata property if there is no such local property. Return None
-        if neither of those exist."""
-        # try the local property
+        the node refers to via the document property (the annotation's own, or the
+        view-level default). Return None if there is none."""
         docid = self.properties.get('document')
-        if docid is not None:
-            # print('>>>', docid, self.graph.get_node(docid))
-            return self.graph.get_node(docid)
-        # try the metadata property
-        if self.view is not None:
-            try:
-                metadata = self.view.metadata.contains[self.at_type]
-                docid = metadata['document']
-                return self.graph.get_node(docid)
-            except KeyError:
-                return None
-        return None
+        return None if docid is None else self.graph.get_node(docid)
 
     def summary(self):
         """The default summary is just the identfier, this should typically be
@@ -197,9 +238,9 @@ class Node(object):
 class TimeFrameNode(Node):
 
     def __str__(self):
-        frame_type = ' ' + self.frame_type() if self.has_label() else ''
+        label = f' {self.label()}' if self.has_label() else ''
         return ('<TimeFrameNode %s %s:%s%s>'
-                % (self.identifier, self.start(), self.end(), frame_type))
+                % (self.identifier, self.start(), self.end(), label))
 
     def start(self):
         return self.properties.get('start', -1)
@@ -207,13 +248,11 @@ class TimeFrameNode(Node):
     def end(self):
         return self.properties.get('end', -1)
 
-    def frame_type(self):
-        # TODO: rename this, uses old property since replaced by "label""
-        # NOTE: this is still aloowing for the old property though
-        return self.properties.get('label') or self.properties.get('frameType')
+    def label(self):
+        return self.properties.get('label')
 
     def has_label(self):
-        return self.frame_type() is not None
+        return self.label() is not None
 
     def representatives(self) -> list:
         """Return a list of the representative TimePoints."""
@@ -228,7 +267,7 @@ class TimeFrameNode(Node):
         return { 'id': self.identifier,
                  'start': self.properties['start'],
                  'end': self.properties['end'],
-                 'frameType': self.properties.get('frameType') }
+                 'frameType': self.label() }
 
 
 class EntityNode(Node):

{mmif_python-1.5.3 → mmif_python-1.5.4}/mmif/utils/summarizer/summary.py

@@ -147,7 +147,7 @@ class Annotations(object):
         self.data = defaultdict(list)
         # summary.graph.get_nodes(config.ANNOTATION, view_id=view.id)
         for anno in summary.graph.get_nodes(config.ANNOTATION):
-            self.data[anno.view.id].append(anno.properties)
+            self.data[anno.view.id].append(dict(anno.properties))
 
     def get(self, item):
         return self.data.get(item, [])
@@ -300,7 +300,7 @@ class TranscriptElement:
             # this adds the current token to the transcript
             start = t.properties['start']
             end = t.properties['end']
-            word = t.properties['word']
+            word = t.properties['text']
             transcript.set_chars(word, start, end)
         self.id = identifier
         self.start = sentence[0].anchors['time-offsets'][0]
@@ -378,7 +378,7 @@ class TimeFrames(Nodes):
 
     def _collect_timeframe_summaries(self):
         for tf in self.nodes:
-            label = tf.frame_type()
+            label = tf.label()
             try:
                 start, end = tf.anchors['time-offsets']
             except KeyError: