mmif-python 1.0.8__tar.gz → 1.0.10__tar.gz

{mmif-python-1.0.8/mmif_python.egg-info → mmif-python-1.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mmif-python
-Version: 1.0.8
+Version: 1.0.10
 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.10/VERSION

@@ -0,0 +1 @@
+1.0.10

{mmif-python-1.0.8 → mmif-python-1.0.10}/mmif/res/clams.vocabulary.yaml

@@ -37,13 +37,57 @@ metadata:
       defined either at the metadata level, in which case it has scope over all
       annotations of the same type in a view, or at the instance level, in which
       it has scope over just the single annotation.
+  labelset:
+    type: List of Strings
+    description: >-
+      When an annotation object contains results of a classification task,
+      this metadata is used to specify the label values used in classification.
+      Individual annotations then must have <code>label</code> property that
+      is one of the values in this list. 
+      <br><br>
+      [Note] Annotations from a classifier app must have this metadata or <code>
+      labelsetUri </code> metadata.
+      <br><br>
+      [Note] Not all of labels specified
+      in the <code>labelset</code> must occur in the output annotations. For 
+      example, a <code>labelset</code> can contain a <i>catch-all</i> negative
+      label, but if the negative label can be not interesting enough to keep in 
+      the output annotation.
+  labelsetUri:
+    type: String
+    description: >-
+      A URI to an externally defined labelset. Since the <code>labelset</code>
+      metadata is a list of simple strings, this URI can be used to point to a
+      more detailed definition of the labelset. This can be a JSON-LD document
+      or a SKOS concept scheme, for example. 
+      <br><br>
+      [Note] Annotations from a classifier app must have this metadata or <code>
+      labelset </code> metadata.
 
 properties:
   document:
     type: ID
     description: >-
       The identifier of the document that the annotation is over.
-
+  label:
+    type: String
+    description: >-
+      A label given to this object by a classifier. The value must be a simple 
+      string value of the label and must be one of the values defined in the
+      <code>labelset</code> or <code>labelsetUri</code> annotation metadata.
+      <br><br>
+      [Note] Annotations from a classifier app must have this property.
+  classifications:
+    type: Map from String to Number
+    description: >-
+      A map from label values to their "score" numbers provided by a classifier.
+      The score can be probability, similarity, confidence, or any other real 
+      number that was used to determine the label value. 
+      <br><br>
+      [Optional] on top of the <code>label</code> property. However when this 
+      property is used, the <code>label</code> property must be one of the keys
+      and the keys must match to the values defined in the <code>labelset</code>
+        or <code>labelsetUri</code> annotation metadata.
 
 ---
 
@@ -117,7 +161,8 @@ properties:
 name: Span
 parent: Interval
 
-similarTo: http://vocab.lappsgrid.org/Region
+similarTo:
+  - http://vocab.lappsgrid.org/Region
 
 description: >-
   An annotation over a region in primary text data. A Span may be defined by
@@ -134,10 +179,17 @@ description: >-
   segment used in audio processing, but that term has a different meaning in the
   image and video community.
 
+
 properties:
   frameType:
     type: String
-    description: The type of TimeFrame. Could be bars-and-tones, speech, noise, music, other.
+    description: The type of TimeFrame. Possible values include, but are not
+      limited to, bars, tones, bars-and-tones, speech, noise, music, slate,
+      chyron, lower-third, credits, and other.
+      <br><br>
+      No longer encouraged to use, instead <code>label</code> property
+      should replace this property.
+
 
 ---
 
@@ -186,7 +238,11 @@ description: >-
 properties:
   boxType:
     type: String
-    description: The type of BoundingBox. Mostly used for text boxes where we use the value text.
+    description: >-
+      The type of BoundingBox. Mostly used for text boxes where we use the value text.
+      <br><br>
+      No longer encouraged to use, and instead <code>label</code> property 
+      should replace this property.
 
 ---
 
@@ -197,7 +253,7 @@ description: >-
   A sequence of Polygons, where each Polygon is associated with a
   TimePoint. So a VideoObject is in effect a sequence of image objects at
   certain time points.
-  
+
 properties:
   polygons:
     type: List of IDs

{mmif-python-1.0.8 → mmif-python-1.0.10}/mmif/res/mmif.json

@@ -32,7 +32,10 @@
       "type": "object",
       "patternProperties": {
         ".+": {
-          "type": "string"
+          "anyOf": [
+            {"type": "string"},
+            {"type": "array", "items": { "type": "string" }}
+          ]
         }
       }
     },
@@ -66,7 +69,7 @@
           "additionalProperties": false,
           "patternProperties": {
             "^https?:\/\/": {
-              "$ref": "#/definitions/strStrMap"
+              "type": "object"
             }
           }
         },

{mmif-python-1.0.8 → mmif-python-1.0.10}/mmif/serialize/annotation.py

@@ -19,16 +19,26 @@ from urllib.parse import urlparse
 
 from mmif.vocabulary import ThingTypesBase, DocumentTypesBase
 from .model import MmifObject, JSON_PRMTV_TYPES
+from .. import DocumentTypes, AnnotationTypes
+import mmif_docloc_http
 
 __all__ = ['Annotation', 'AnnotationProperties', 'Document', 'DocumentProperties', 'Text']
 
 T = TypeVar('T')
+LIST_PRMTV = typing.List[JSON_PRMTV_TYPES]  # list of values (most cases for annotation props)
+LIST_LIST_PRMTV = typing.List[LIST_PRMTV]   # list of list of values (e.g. for coordinates)
+DICT_PRMTV = typing.Dict[str, JSON_PRMTV_TYPES]  # dict of values (`text` prop of `TextDocument` and other complex props)
+DICT_LIST_PRMTV = typing.Dict[str, LIST_PRMTV]  # dict of list of values (even more complex props)
 
-from .. import DocumentTypes, AnnotationTypes
 
+# some built-in document location helpers
 discovered_docloc_plugins = {
-    name[len('mmif_docloc_'):]: importlib.import_module(name) for _, name, _ in pkgutil.iter_modules() if re.match(r'mmif[-_]docloc[-_]', name)
+    'http': mmif_docloc_http,
+    'https': mmif_docloc_http
 }
+discovered_docloc_plugins.update({
+    name[len('mmif_docloc_'):]: importlib.import_module(name) for _, name, _ in pkgutil.iter_modules() if re.match(r'mmif[-_]docloc[-_]', name)
+})
 
 
 class Annotation(MmifObject):
@@ -56,7 +66,32 @@ 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 _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_reprep, 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'Found both "{key_to_add}" and "{alias}" in the properties of "{self.id}" annotation in "{self.parent}" view. '
+                            if alias == alias_reprep:
+                                warning_msg += f'However "{key_to_add}" is an alias of "{alias_reprep}".'
+                            else:
+                                warning_msg += f'However "{key_to_add}" and "{alias}" are boath aliases of "{alias_reprep}".'
+                            warning_msg += f'Having two synonyms in the same annotation can cause unexpected behavior. '
+                            warnings.warn(warning_msg, UserWarning)
+
     def is_type(self, at_type: Union[str, ThingTypesBase]) -> bool:
         """
         Check if the @type of this object matches.
@@ -94,30 +129,40 @@ class Annotation(MmifObject):
         
     @staticmethod
     def check_prop_value_is_simple_enough(
-            value: Union[JSON_PRMTV_TYPES, List[JSON_PRMTV_TYPES], List[List[JSON_PRMTV_TYPES]]]):
+            value: Union[JSON_PRMTV_TYPES, LIST_PRMTV, LIST_LIST_PRMTV, DICT_PRMTV, DICT_LIST_PRMTV]) -> bool:
+        
         def json_primitives(x): 
             return isinstance(x, typing.get_args(JSON_PRMTV_TYPES))
+        
+        def json_primitives_list(x):
+            return isinstance(x, list) and all(map(json_primitives, x))
+        
+        def json_primitives_list_of_list(x):
+            return all(map(lambda elem: isinstance(elem, list), x) and map(json_primitives, [subelem for elem in x for subelem in elem]))
+
         return json_primitives(value) \
-            or (isinstance(value, list) and all(map(json_primitives, value))) \
-            or (all(map(lambda elem: isinstance(elem, list), value)) and map(json_primitives, [subelem for elem in value for subelem in elem]))
+            or json_primitives_list(value) \
+            or json_primitives_list_of_list(value) \
+            or (isinstance(value, dict) and all(map(lambda x: isinstance(x[0], str) and (json_primitives(x[1]) or json_primitives_list(x[1])), value.items())))
 
     def add_property(self, name: str,
-                     value: Union[JSON_PRMTV_TYPES, List[JSON_PRMTV_TYPES], List[List[JSON_PRMTV_TYPES]]]
-                     ) -> None:
+                     value: Union[JSON_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
         """
-        if self.check_prop_value_is_simple_enough(value):
-            self.properties[name] = value
-        else:
-            raise ValueError("Property values cannot be a complex object. It must be "
-                             "either string, number, boolean, None, or a list of them."
-                             f"(\"{name}\": \"{str(value)}\"")
-
-    def get(self, prop_name: str) -> Union['AnnotationProperties', JSON_PRMTV_TYPES, List[JSON_PRMTV_TYPES], List[List[JSON_PRMTV_TYPES]]]:
+        # if self.check_prop_value_is_simple_enough(value):
+        self.properties[name] = value
+        # else:
+        #     raise ValueError("Property values cannot be a complex object. It must be "
+        #                      "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 get(self, prop_name: str) -> Union['AnnotationProperties', JSON_PRMTV_TYPES, LIST_PRMTV, LIST_LIST_PRMTV, DICT_PRMTV, DICT_LIST_PRMTV]:
         """
         A special getter for Annotation properties. This is to allow for
         directly accessing properties without having to go through the
@@ -148,8 +193,25 @@ 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.at_type, DocumentTypesBase)
+        return isinstance(self._type, DocumentTypesBase)
 
 
 class Document(Annotation):
@@ -180,7 +242,7 @@ class Document(Annotation):
         super().__init__(doc_obj)
     
     def add_property(self, name: str,
-                     value: Union[JSON_PRMTV_TYPES, List[JSON_PRMTV_TYPES]]
+                     value: Union[JSON_PRMTV_TYPES, LIST_PRMTV]
                      ) -> None:
         """
         Adds a property to the document's properties.
@@ -249,30 +311,26 @@ class Document(Annotation):
     
     @property
     def text_language(self) -> str:
-        if self.at_type == DocumentTypes.TextDocument:
+        if self._type == DocumentTypes.TextDocument:
             return self.properties.text_language
         else:
             raise ValueError("Only TextDocument can have `text` field.")
 
     @text_language.setter
     def text_language(self, lang_code: str) -> None:
-        if self.at_type == DocumentTypes.TextDocument:
+        if self._type == DocumentTypes.TextDocument:
             self.properties.text_language = lang_code
         else:
             raise ValueError("Only TextDocument can have `text` field.")
 
     @property
     def text_value(self) -> str:
-        if self.at_type == DocumentTypes.TextDocument:
+        if self._type == DocumentTypes.TextDocument:
             if self.location:
-                if self.location_scheme() == 'file':
-                    f = open(self.location_path(), 'r', encoding='utf8')
-                    textvalue = f.read()
-                    f.close()
-                    return textvalue
-                else: 
-                    # TODO (krim @ 7/11/21): add more handlers for other types of locations (e.g. s3, https, ...)
-                    return ''
+                f = open(self.location_path(nonexist_ok=False), 'r', encoding='utf8')
+                textvalue = f.read()
+                f.close()
+                return textvalue
             else:
                 return self.properties.text_value
         else:
@@ -280,7 +338,7 @@ class Document(Annotation):
 
     @text_value.setter
     def text_value(self, text_value: str) -> None:
-        if self.at_type == DocumentTypes.TextDocument:
+        if self._type == DocumentTypes.TextDocument:
             self.properties.text_value = text_value
         else:
             raise ValueError("Only TextDocument can have `text` field.")

{mmif-python-1.0.8 → mmif-python-1.0.10}/mmif/serialize/mmif.py

@@ -12,10 +12,10 @@ from datetime import datetime
 from typing import List, Union, Optional, Dict, ClassVar, cast
 
 import jsonschema.validators
-
 import mmif
 from mmif import ThingTypesBase
 from mmif.vocabulary import AnnotationTypes, DocumentTypes
+
 from .annotation import Annotation, Document
 from .model import MmifObject, DataList
 from .view import View
@@ -478,6 +478,47 @@ class Mmif(MmifObject):
                 if at_types in view.metadata.contains:
                     return view
         return None
+    
+    def _get_linear_anchor_point(self, ann: Annotation, 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)
+        """
+        Retrieves the anchor point of the annotation. Currently, this method only supports linear anchors, 
+        namely time and text, hence does not work with spatial anchors (polygons or video-object).
+        
+        :param ann: An Annotation object that has a linear anchor point. Namely, some subtypes of `Region` vocabulary type.
+        :param start: If True, returns the start anchor point. Otherwise, returns the end anchor point. N/A for `timePoint` anchors.
+        :return: the anchor point of the annotation. 1d for linear regions (time, text)
+        """
+        props = ann.properties
+        if 'timePoint' in props:
+            return ann.get_property('timePoint')
+        elif 'targets' in props:
+            target_id = ann.get_property('targets')[0 if start else -1]
+            # TODO (krim @ 2/5/24): not sure if this is the correct way to pick the "first" (or "last") target,
+            # since the targets list is not guaranteed to be sorted.
+            # However, due the recursive nature of this method, it is likely impossible
+            # to get all `start` (or `end`) values of the targets recursively and then pick the min (or max) value.
+            if Mmif.id_delimiter in target_id:
+                target = self.__getitem__(target_id)
+            else:
+                target = self.__getitem__(Mmif.id_delimiter.join((ann.parent, target_id)))
+            return self._get_linear_anchor_point(target, start=start)
+        elif (start and 'start' in props) or (not start and 'end' in props):
+            return ann.get_property('start' if start else 'end')
+        else:
+            raise ValueError(f"{ann.id} ({ann.at_type}) does not have a valid anchor point. Is it a valid 'Region' type?")
+    
+    def get_start(self, annotation: Annotation) -> Union[int, float]:
+        """
+        An alias to `get_anchor_point` method with `start=True`.
+        """
+        return self._get_linear_anchor_point(annotation, start=True)
+    
+    def get_end(self, annotation: Annotation) -> Union[int, float]:
+        """
+        An alias to `get_anchor_point` method with `start=False`.
+        """
+        return self._get_linear_anchor_point(annotation, start=False)
 
     # pytype: disable=bad-return-type
     def __getitem__(self, item: str) -> Union[Document, View, Annotation]:

{mmif-python-1.0.8 → mmif-python-1.0.10}/mmif/serialize/view.py

@@ -186,7 +186,7 @@ class View(MmifObject):
                            properties.items())):
                     yield annotation
     
-    def get_annotation_by_id(self, ann_id):
+    def get_annotation_by_id(self, ann_id) -> Annotation:
         ann_found = self.annotations.get(ann_id)
         if ann_found is None or not isinstance(ann_found, Annotation):
             raise KeyError(f"Annotation \"{ann_id}\" is not found in view {self.id}.")
@@ -367,7 +367,10 @@ class AnnotationsList(DataList[Union[Annotation, Document]]):
 class ContainsDict(DataDict[ThingTypesBase, Contain]):
 
     def _deserialize(self, input_dict: dict) -> None:
-        self._items = {ThingTypesBase.from_str(key): Contain(value) for key, value in input_dict.items()}
+        for key, value in input_dict.items():
+            if isinstance(key, str):
+                key = ThingTypesBase.from_str(key)
+            self._items[key] = Contain(value)
 
     def update(self, other: Union[dict, 'ContainsDict'], overwrite=False):
         for k, v in other.items():

mmif-python-1.0.10/mmif/utils/timeunit_helper.py

@@ -0,0 +1,84 @@
+from datetime import datetime
+from typing import Union
+
+
+UNIT_NORMALIZATION = {
+    'm': 'millisecond',
+    'ms': 'millisecond',
+    'msec': 'millisecond',
+    'millisecond': 'millisecond',
+    'milliseconds': 'millisecond',
+    's': 'second',
+    'se': 'second',
+    'sec': 'second',
+    'second': 'second',
+    'seconds': 'second',
+    'f': 'frame',
+    'fr': 'frame',
+    'frame': 'frame',
+    'frames': 'frame',
+    'i': 'isoformat',
+    'iso': 'isoformat',
+    'isoformat': 'isoformat',
+}
+
+
+def _isoformat_to_millisecond(isoformat: str) -> int:
+    t = datetime.strptime(isoformat, '%H:%M:%S.%f')
+    return int(1000 * (t.hour * 3600 + t.minute * 60 + t.second + t.microsecond / 1000000))
+
+
+def _millisecond_to_isoformat(millisecond: int) -> str:
+    t = datetime.utcfromtimestamp(millisecond / 1000)
+    return t.strftime('%H:%M:%S.%f')[:-3]
+
+
+def _second_to_isoformat(second: float) -> str:
+    t = datetime.utcfromtimestamp(second)
+    return t.strftime('%H:%M:%S.%f')[:-3]  # python strftime will return "microsecond" with 6 digits
+
+
+def convert(t: Union[int, float, str], in_unit: str, out_unit: str, fps: float) -> Union[int, float, str]:
+    """
+    Converts time from one unit to another. Works with ``frames``, ``seconds``, ``milliseconds``.
+
+    :param t: time value to convert
+    :param in_unit: input time unit, one of ``frames``, ``seconds``, ``milliseconds``
+    :param out_unit: output time unit, one of ``frames``, ``seconds``, ``milliseconds``
+    :param fps: frames per second
+    :return: converted time value
+    """
+    try:
+        in_unit = UNIT_NORMALIZATION[in_unit]
+    except KeyError:
+        raise ValueError(f"Not supported time unit: {in_unit}")
+    try:
+        out_unit = UNIT_NORMALIZATION[out_unit]
+    except KeyError:
+        raise ValueError(f"Not supported time unit: {out_unit}")
+    if in_unit == 'isoformat':
+        if isinstance(t, str):
+            t = _isoformat_to_millisecond(t)
+            in_unit = 'millisecond'
+        else:
+            raise ValueError(f"Invalid time format: ISO format string expected, but got {t} of type {type(t)}")
+    # s>s, ms>ms, f>f
+    if in_unit == out_unit:
+        return t
+    elif out_unit == 'frame':
+        # ms>f
+        if 'millisecond' == in_unit:
+            return int(t / 1000 * fps)
+        # s>f
+        elif 'second' == in_unit:
+            return int(t * fps)
+    # s>(ms or i)
+    elif in_unit == 'second':
+        return t * 1000 if out_unit == 'millisecond' else _second_to_isoformat(t)
+    # ms>(s or i)
+    elif in_unit == 'millisecond':
+        return t / 1000 if out_unit == 'second' else _millisecond_to_isoformat(t)
+    # f>ms, f>s
+    else:
+        return (t / fps) if out_unit == 'second' else (t / fps * 1000)  # pytype: disable=bad-return-type
+

{mmif-python-1.0.8 → mmif-python-1.0.10}/mmif/utils/video_document_helper.py

@@ -4,6 +4,7 @@ from typing import List, Union, Tuple
 
 import mmif
 from mmif import Annotation, Document, Mmif
+from mmif.utils.timeunit_helper import convert
 from mmif.vocabulary import DocumentTypes
 
 for cv_dep in ('cv2', 'ffmpeg', 'PIL'):
@@ -19,23 +20,6 @@ FPS_DOCPROP_KEY = 'fps'
 FRAMECOUNT_DOCPROP_KEY = 'frameCount'
 DURATION_DOCPROP_KEY = 'duration'
 DURATIONUNIT_DOCPROP_KEY = 'durationTimeUnit'
-                           
-UNIT_NORMALIZATION = {
-    'm': 'millisecond',
-    'ms': 'millisecond',
-    'msec': 'millisecond',
-    'millisecond': 'millisecond',
-    'milliseconds': 'millisecond',
-    's': 'second',
-    'se': 'second',
-    'sec': 'second',
-    'second': 'second',
-    'seconds': 'second',
-    'f': 'frame',
-    'fr': 'frame',
-    'frame': 'frame',
-    'frames': 'frame',
-}
 
 
 def capture(video_document: Document):
@@ -120,7 +104,7 @@ def get_mid_framenum(mmif: Mmif, time_frame: Annotation):
     timeunit = time_frame.get_property('timeUnit')
     video_document = mmif[time_frame.get_property('document')]
     fps = get_framerate(video_document)
-    return sum(convert(float(time_frame.get_property(timepoint_propkey)), timeunit, 'frame', fps) for timepoint_propkey in ('start', 'end')) // 2
+    return convert(mmif.get_start(time_frame) + mmif.get_end(time_frame), timeunit, 'frame', fps) // 2
 
 
 def extract_mid_frame(mmif: Mmif, time_frame: Annotation, as_PIL: bool = False):
@@ -155,45 +139,6 @@ def sample_frames(start_frame: int, end_frame: int, sample_ratio: int = 1) -> Li
     return frame_nums
 
 
-def convert(time: Union[int, float], in_unit: str, out_unit: str, fps: float) -> Union[int, float]:
-    """
-    Converts time from one unit to another. Works with ``frames``, ``seconds``, ``milliseconds``.
-
-    :param time: time value to convert
-    :param in_unit: input time unit, one of ``frames``, ``seconds``, ``milliseconds``
-    :param out_unit: output time unit, one of ``frames``, ``seconds``, ``milliseconds``
-    :param fps: frames per second
-    :return: converted time value
-    """
-    try:
-        in_unit = UNIT_NORMALIZATION[in_unit]
-    except KeyError:
-        raise ValueError(f"Not supported time unit: {in_unit}")
-    try:
-        out_unit = UNIT_NORMALIZATION[out_unit]
-    except KeyError:
-        raise ValueError(f"Not supported time unit: {out_unit}")
-    # s>s, ms>ms, f>f
-    if in_unit == out_unit:
-        return time
-    elif out_unit == 'frame':
-        # ms>f
-        if 'millisecond' == in_unit:
-            return int(time / 1000 * fps)
-        # s>f
-        elif 'second' == in_unit:
-            return int(time * fps)
-    # s>ms
-    elif in_unit == 'second':
-        return time * 1000
-    # ms>s
-    elif in_unit == 'millisecond':
-        return time // 1000
-    # f>ms, f>s
-    else:
-        return (time / fps) if out_unit == 'second' else (time / fps * 1000)  # pytype: disable=bad-return-type
-
-
 def get_annotation_property(mmif, annotation, prop_name):
     """
     .. deprecated:: 1.0.8
@@ -208,7 +153,7 @@ def get_annotation_property(mmif, annotation, prop_name):
     return annotation.get_property(prop_name)
 
 
-def convert_timepoint(mmif: Mmif, timepoint: Annotation, out_unit: str) -> Union[int, float]:
+def convert_timepoint(mmif: Mmif, timepoint: Annotation, out_unit: str) -> Union[int, float, str]:
     """
     Converts a time point included in an annotation to a different time unit.
     The input annotation must have ``timePoint`` property. 
@@ -223,7 +168,7 @@ 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[int, int], Tuple[float, float]]:
+def convert_timeframe(mmif: Mmif, time_frame: Annotation, out_unit: str) -> Union[Tuple[Union[int, float, str], Union[int, float, str]]]:
     """
     Converts start and end points in a ``TimeFrame`` annotation a different time unit.
 
@@ -234,8 +179,8 @@ def convert_timeframe(mmif: Mmif, time_frame: Annotation, out_unit: str) -> Unio
     """
     in_unit = time_frame.get_property('timeUnit')
     vd = mmif[time_frame.get_property('document')]
-    return convert(time_frame.get_property('start'), in_unit, out_unit, get_framerate(vd)), \
-        convert(time_frame.get_property('end'), in_unit, out_unit, get_framerate(vd))
+    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))
 
 
 def framenum_to_second(video_doc: Document, frame: int):

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

@@ -0,0 +1,2 @@
+__version__ = "1.0.10"
+__specver__ = "1.0.2"

{mmif-python-1.0.8 → mmif-python-1.0.10}/mmif/vocabulary/annotation_types.py

@@ -1,4 +1,4 @@
-# Spec version 1.0.0
+# Spec version 1.0.2
 # This file is auto-generated by setup.py
 
 from .base_types import AnnotationTypesBase
@@ -7,18 +7,27 @@ from .base_types import AnnotationTypesBase
 class AnnotationTypes(AnnotationTypesBase):
     """
     This class contains the CLAMS annotation types 
-    defined in the spec version 1.0.0 as class variables. 
+    defined in the spec version 1.0.2 as class variables. 
     """
-    Annotation = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/Annotation/v2')
-    Region = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/Region/v1')
-    TimePoint = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/TimePoint/v1')
-    Interval = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/Interval/v1')
-    Span = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/Span/v1')
-    TimeFrame = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/TimeFrame/v1')
-    Chapter = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/Chapter/v1')
-    Polygon = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/Polygon/v1')
-    BoundingBox = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/BoundingBox/v1')
-    VideoObject = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/VideoObject/v1')
-    Relation = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/Relation/v1')
+    
+    # prpoerty aliases, first added in MMIF 1.0.2
+    # map from type short name to a dictionary of property aliases
+    # where nested dictionary maps from representative name to its aliases
+    prop_aliases = {
+        'TimeFrame': {'label': {'frameType', 'label'}},
+        'BoundingBox': {'label': {'boxType', 'label'}},
+    }
+
+    Annotation = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/Annotation/v3')
+    Region = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/Region/v2')
+    TimePoint = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/TimePoint/v2')
+    Interval = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/Interval/v2')
+    Span = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/Span/v2')
+    TimeFrame = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/TimeFrame/v3')
+    Chapter = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/Chapter/v3')
+    Polygon = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/Polygon/v2')
+    BoundingBox = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/BoundingBox/v2')
+    VideoObject = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/VideoObject/v2')
+    Relation = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/Relation/v2')
     Alignment = AnnotationTypesBase('http://mmif.clams.ai/vocabulary/Alignment/v1')
-    typevers = {'Annotation': 'v2', 'Region': 'v1', 'TimePoint': 'v1', 'Interval': 'v1', 'Span': 'v1', 'TimeFrame': 'v1', 'Chapter': 'v1', 'Polygon': 'v1', 'BoundingBox': 'v1', 'VideoObject': 'v1', 'Relation': 'v1', 'Alignment': 'v1'}
+    typevers = {'Annotation': 'v3', 'Region': 'v2', 'TimePoint': 'v2', 'Interval': 'v2', 'Span': 'v2', 'TimeFrame': 'v3', 'Chapter': 'v3', 'Polygon': 'v2', 'BoundingBox': 'v2', 'VideoObject': 'v2', 'Relation': 'v2', 'Alignment': 'v1'}

{mmif-python-1.0.8 → mmif-python-1.0.10}/mmif/vocabulary/base_types.py

@@ -137,7 +137,7 @@ class ClamsTypesBase(TypesBase):
         return True
 
     def __hash__(self):
-        return hash(str(self))
+        return hash(f'{self.base_uri}::{self.shortname}')
     
     def normalize_attype_vers(self):
         if '.' in self.version and self._check_legacy_version(self.version):
@@ -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.0 as a class variable. 
+    defined in the spec version 1.0.2 as a class variable. 
     """
     Thing = ClamsTypesBase('http://mmif.clams.ai/vocabulary/Thing/v1')
     typevers = {'Thing': 'v1'}

{mmif-python-1.0.8 → mmif-python-1.0.10}/mmif/vocabulary/document_types.py

@@ -1,4 +1,4 @@
-# Spec version 1.0.0
+# Spec version 1.0.2
 # 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.0 as class variables. 
+    defined in the spec version 1.0.2 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.10/mmif_docloc_http/__init__.py

@@ -0,0 +1,12 @@
+import urllib.request
+import urllib.error
+
+
+def resolve(docloc):
+    try:
+        if docloc.startswith('http://') or docloc.startswith('https://'):
+            return urllib.request.urlretrieve(docloc)[0]
+        else:
+            raise ValueError(f'cannot handle document location scheme: {docloc}')
+    except urllib.error.URLError as e:
+        raise e

{mmif-python-1.0.8 → mmif-python-1.0.10/mmif_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mmif-python
-Version: 1.0.8
+Version: 1.0.10
 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.8 → mmif-python-1.0.10}/mmif_python.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ mmif/serialize/mmif.py
 mmif/serialize/model.py
 mmif/serialize/view.py
 mmif/utils/__init__.py
+mmif/utils/timeunit_helper.py
 mmif/utils/video_document_helper.py
 mmif/ver/__init__.py
 mmif/ver/do-not-edit.txt
@@ -24,6 +25,7 @@ mmif/vocabulary/annotation_types.py
 mmif/vocabulary/base_types.py
 mmif/vocabulary/do-not-edit.txt
 mmif/vocabulary/document_types.py
+mmif_docloc_http/__init__.py
 mmif_python.egg-info/PKG-INFO
 mmif_python.egg-info/SOURCES.txt
 mmif_python.egg-info/dependency_links.txt

{mmif-python-1.0.8 → mmif-python-1.0.10}/mmif_python.egg-info/requires.txt

@@ -11,4 +11,3 @@ pytest
 pytest-pep8
 pytest-cov
 pytype
-sphinx

mmif-python-1.0.10/mmif_python.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+mmif
+mmif_docloc_http

{mmif-python-1.0.8 → mmif-python-1.0.10}/setup.py

@@ -162,15 +162,19 @@ def generate_vocabulary(spec_version, clams_types_vers):
 
 
 def get_latest_mmif_gittag():
-    cur_p = 1
-    body = [None]
-    tags = []
-    while len(body) > 0:
-        # for when we have more than 30 (default pagination size) tags
-        res = request.urlopen(f'https://api.github.com/repos/clamsproject/mmif/tags?per_page=100&page={cur_p}')
-        body = json.loads(res.read())
-        tags.extend([tag['name'] for tag in body])
-        cur_p += 1
+    if LOCALMMIF is not None:
+        tags = subprocess.run(f'git --git-dir {LOCALMMIF}/.git --no-pager tag'.split(), 
+                              capture_output=True).stdout.decode('utf-8').split('\n')
+    else:
+        cur_p = 1
+        body = [None]
+        tags = []
+        while len(body) > 0:
+            # for when we have more than 30 (default pagination size) tags
+            res = request.urlopen(f'https://api.github.com/repos/clamsproject/mmif/tags?per_page=100&page={cur_p}')
+            body = json.loads(res.read())
+            tags.extend([tag['name'] for tag in body])
+            cur_p += 1
     # sort and return highest version
     print(tags)
     mmif_ver_format = lambda x: re.match(r'\d+\.\d+\.\d$', x)
@@ -209,7 +213,7 @@ def prep_ext_files(setuptools_cmd):
         latest_mmif_gittag = get_latest_mmif_gittag()
         spec_file_gitref = latest_mmif_gittag if '.dev' not in version else 'develop'
         # legacy version tags were formatted as xx-a.b.c (e.g., vocab-0.0.1)
-        spec_version = latest_mmif_gittag.split('-')[-1]
+        spec_version = latest_mmif_gittag.split('-')[-1].strip()
         # making resources into a python package so that `pkg_resources` can access resource files
         res_dir = generate_subpack(mmif_name, mmif_res_pkg)
 
@@ -296,7 +300,6 @@ setuptools.setup(
             'pytest-pep8',
             'pytest-cov',
             'pytype',
-            'sphinx'
         ]
     },
     python_requires='>=3.8',

mmif-python-1.0.8/VERSION

@@ -1 +0,0 @@
-1.0.8

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

@@ -1,2 +0,0 @@
-__version__ = "1.0.8"
-__specver__ = "1.0.0"

mmif-python-1.0.8/mmif_python.egg-info/top_level.txt

@@ -1 +0,0 @@
-mmif