mmif-python 0.0.1__tar.gz → 0.1.0__tar.gz

usr/lib/python3.8/site-packages/mmif/__init__.py

@@ -0,0 +1,18 @@
+_res_pkg = 'res'
+_ver_pkg = 'ver'
+__version__ = 'UNK'
+_schema_res_oriname = 'schema/mmif.json'
+_schema_res_name = 'mmif.json'
+_vocab_res_oriname = 'vocabulary/clams.vocabulary.yaml'
+_vocab_res_name = 'clams.vocabulary.yaml'
+
+try:
+    import importlib
+    i = importlib.import_module(f'{__name__}.{_ver_pkg}')
+    __version__ = i.__version__  # pytype: disable=attribute-error
+except ImportError:
+    # don't set version
+    pass
+
+from mmif.serialize import *
+from mmif.vocab import *

usr/lib/python3.8/site-packages/mmif/serialize/__init__.py

@@ -0,0 +1,6 @@
+from .annotation import *
+from .mmif import *
+from .view import *
+from .medium import *
+
+

usr/lib/python3.8/site-packages/mmif/serialize/annotation.py

@@ -0,0 +1,34 @@
+from typing import Dict, Union, Optional
+
+from .model import MmifObject
+
+
+class Annotation(MmifObject):
+    properties: 'AnnotationProperties'
+    _type: str
+
+    @property
+    def id(self):
+        return self.properties.id
+
+    @id.setter
+    def id(self, aid):
+        self.properties.id = aid
+
+    def _deserialize(self, input_dict: dict) -> None:
+        self._type = input_dict['_type']
+        self.properties = AnnotationProperties(input_dict['properties'])
+
+    def __init__(self, anno_obj: Union[str, dict] = None):
+        self._type = ''
+        self.properties = AnnotationProperties()
+        super().__init__(anno_obj)
+
+    def add_property(self, name: str, value: str):
+        self.properties[name] = value
+
+
+class AnnotationProperties(MmifObject):
+    id: str
+    start: Optional[int] = -1
+    end: Optional[int] = -1

usr/lib/python3.8/site-packages/mmif/serialize/medium.py

@@ -0,0 +1,52 @@
+from typing import Union, Optional, List
+
+from .model import MmifObject
+
+
+class Medium(MmifObject):
+    id: str
+    type: str
+    mime: Optional[str] = None
+    location: Optional[str] = None
+    text: Optional['Text'] = None
+    metadata: Optional['MediumMetadata'] = None
+    submedia: Optional[List['Submedia']] = None
+
+    def __init__(self, medium_obj: Union[str, dict] = None):
+        self.id = ''
+        self.type = ''
+        super().__init__(medium_obj)
+
+    def _deserialize(self, medium_dict: dict):
+        self.id = medium_dict['id']
+        self.type = medium_dict['type']
+        if 'metadata' in medium_dict:
+            self.metadata = MediumMetadata(medium_dict.get('metadata'))
+        if 'mime' in medium_dict:
+            self.mime = medium_dict['mime']
+        if 'location' in medium_dict:
+            self.location = medium_dict['location']
+        if 'text' in medium_dict:
+            self.text = Text(medium_dict['text'])
+
+    def add_metadata(self, name: str, value: str):
+        self.metadata[name] = value
+
+
+class Text(MmifObject):
+    _value: str
+    _language: Optional[str]
+
+    def __init__(self, text_obj: Union[str, dict]):
+        super().__init__(text_obj)
+
+
+class MediumMetadata(MmifObject):
+    source: str
+    tool: str
+
+
+class Submedia(MmifObject):
+    id: str
+    annotation: str
+    text: 'Text'

usr/lib/python3.8/site-packages/mmif/serialize/mmif.py

@@ -0,0 +1,89 @@
+import json
+from typing import Dict, List, Union
+
+from jsonschema import validate
+from pkg_resources import resource_stream
+
+import mmif
+from .view import View
+from .medium import Medium
+from .model import MmifObject
+
+
+class Mmif(MmifObject):
+    # TODO (krim @ 7/6/20): maybe need IRI/URI as a python class for typing?
+    _context: str
+    metadata: Dict[str, str]
+    media: List['Medium']
+    views: List['View']
+
+    def __init__(self, mmif_obj: Union[str, dict] = None, validate: bool = True):
+        self._context = ''
+        self.metadata = {}
+        self.media = []
+        self.views = []
+        if validate:
+            self.validate(mmif_obj)
+        super().__init__(mmif_obj)
+
+    def _deserialize(self, input_dict: dict) -> None:
+        self._context = input_dict['_context']
+        self.metadata = input_dict['metadata']
+        self.media = [Medium(m) for m in input_dict['media']]
+        self.views = [View(v) for v in input_dict['views']]
+
+    @staticmethod
+    def validate(json_str: Union[str, dict]):
+        # NOTE that schema file first needs to be copied to resources directory
+        # this is automatically done via setup.py, so for users this shouldn't be a matter
+
+        schema_res = resource_stream(f'{mmif.__name__}.{mmif._res_pkg}', mmif._schema_res_name)
+        schema = json.load(schema_res)
+        schema_res.close()
+        if type(json_str) == str:
+            json_str = json.loads(json_str)
+        validate(json_str, schema)
+
+    def new_view_id(self):
+        return 'v_' + str(len(self.views))
+
+    def new_view(self):
+        new_view = View()
+        new_view.id = self.new_view_id()
+        self.views.append(new_view)
+        return new_view
+
+    def add_media(self, medium: Medium):
+        try:
+            self.get_medium_location(medium.type)
+        # TODO (krim @ 10/7/2018): if get_m_location returns, raise "already exists" error
+        except Exception:
+            self.media.append(medium)
+
+    def get_medium_location(self, md_type: str) -> str:
+        for medium in self.media:
+            if medium["type"] == md_type:
+                return medium["location"]
+        raise Exception("{} type media not found".format(md_type))
+
+    def get_medium_by_id(self, id: str) -> 'Medium':
+        for medium in self.media:
+            if medium.id == id:
+                return medium
+        raise Exception("{} medium not found".format(id))
+
+    def get_view_by_id(self, id: str) -> 'View':
+        for view in self.views:
+            if view.id == id:
+                return view
+        raise Exception("{} view not found".format(id))
+
+    def get_all_views_contain(self, at_type: str):
+        return [view for view in self.views if at_type in view.metadata.contains]
+
+    def get_view_contains(self, at_type: str):
+        # will return the *latest* view
+        for view in reversed(self.views):
+            if at_type in view.metadata.contains:
+                return view
+        return None

usr/lib/python3.8/site-packages/mmif/serialize/model.py

@@ -0,0 +1,112 @@
+import json
+from typing import Union, Any, Dict
+
+
+class MmifObject(object):
+    """
+    Abstract superclass for MMIF related key-value pair objects.
+    """
+
+    def __init__(self, mmif_obj: Union[str, dict] = None):
+        """
+        Any MMIF object can be initialized as an empty placeholder or
+        an actual representation with a JSON formatted string or equivalent
+        `dict` object argument.
+
+        :param mmif_obj: JSON string or `dict` to initialize an object.
+         If not given, an empty object will be initialized, sometimes with
+         an ID value automatically generated, based on its parent object.
+        """
+        if mmif_obj is not None:
+            self.deserialize(mmif_obj)
+
+    def serialize(self, pretty: bool = False) -> str:
+        """
+        Generates JSON-LD representation of an object.
+
+        :param pretty: If True, returns string representation with indentation.
+        :return: JSON-LD string of the object.
+        """
+        return json.dumps(self._serialize(), indent=2 if pretty else None, cls=MmifObjectEncoder)
+
+    def _serialize(self) -> dict:
+        d = {}
+        for k, v in list(self.__dict__.items()):
+            if k.startswith('_'):
+                d[f'@{k[1:]}'] = v
+            else:
+                d[k] = v
+        return d
+
+    @staticmethod
+    def _load_str(json_str: str):
+        """
+        Turns JSON-format string into python dict. In doing so, it replaces "@"
+        signs in JSON-LD field names with "_" to be python-compliant.
+
+        >>> "_type" in MmifObject._load_str('{ "@type": "some_type", "@value": "some_value"}').keys()
+        True
+        >>> "_value" in MmifObject._load_str('{ "@type": "some_type", "@value": "some_value"}').keys()
+        True
+
+        :param json_str:
+        :return:
+        """
+        def to_atsign(d: Dict[str, Any]):
+            for k in list(d.keys()):
+                if k.startswith('@'):
+                    d[f'_{k[1:]}'] = d.pop(k)
+            return d
+        return json.loads(json_str, object_hook=to_atsign)
+
+    def deserialize(self, mmif_json: Union[str, dict]) -> None:
+        """
+        Takes a JSON-formatted string or a simple `dict` that's json-loaded from
+        such a string as an input and populates object's fields with the values
+        specified in the input.
+        NB: this assumes when input is dict type, the keys are properly renamed
+        (@xxx -> _xxx)
+
+        :param mmif_json: JSON-formatted string or dict from such a string
+         that represents a MMIF object
+        """
+        if type(mmif_json) == str:
+            mmif_json = self._load_str(mmif_json)
+        self._deserialize(mmif_json)
+
+    def _deserialize(self, input_dict: dict) -> None:
+        """
+        Maps a plain python dict object to a MMIF object.
+        If a subclass needs special treatment during the mapping, it needs to
+        override this method.
+        :param input_dict:
+        :return:
+        """
+        self.__dict__ = input_dict
+
+    def __str__(self):
+        return self.serialize(False)
+
+    def pretty(self) -> str:
+        """
+        Call :func: .serialize() with indentation.
+        """
+        return self.serialize(True)
+
+    def __eq__(self, other):
+        return self.__dict__ == other.__dict__
+
+
+class MmifObjectEncoder(json.JSONEncoder):
+    """
+    Encoder class to define behaviors of de-/serialization
+    """
+
+    def default(self, obj: 'MmifObject'):
+        """
+        Overrides default encoding behavior to prioritize :func: MmifObject.serilize() .
+        """
+        try:
+            return obj._serialize()
+        except:
+            return json.JSONEncoder.default(self, obj)

usr/lib/python3.8/site-packages/mmif/serialize/view.py

@@ -0,0 +1,72 @@
+from datetime import datetime
+from typing import Dict, List, Union, Optional
+
+from .annotation import Annotation
+from .model import MmifObject
+
+
+class View(MmifObject):
+    id: str
+    metadata: 'ViewMetadata'
+    annotations: List['Annotation']
+    anno_ids = set()
+
+    def __init__(self, view_obj: Union[str, dict] = None):
+        self.id = ''
+        self.metadata = ViewMetadata()
+        self.annotations = []
+        super().__init__(view_obj)
+
+    def _deserialize(self, view_dict: dict):
+        self.id = view_dict['id']
+        self.metadata = ViewMetadata(view_dict['metadata'])
+        for anno_dict in view_dict['annotations']:
+            self.add_annotation(Annotation(anno_dict))
+
+    def new_contain(self, at_type: str, contain_dict: dict):
+        return self.metadata.new_contain(at_type, contain_dict)
+
+    def new_annotation(self, aid: str, at_type: str):
+        new_annotation = Annotation()
+        new_annotation.at_type = at_type
+        new_annotation.id = aid
+        return self.add_annotation(new_annotation)
+
+    def add_annotation(self, annotation: 'Annotation') -> 'Annotation':
+        self.annotations.append(annotation)
+        self.anno_ids.add(annotation.id)
+        return annotation
+
+
+class ViewMetadata(MmifObject):
+    medium: str
+    timestamp: Optional[datetime] = None
+    tool: str
+    contains: Dict[str, 'Contain']
+
+    def __init__(self, viewmetadata_obj: Union[str, dict] = None):
+        self.medium = ''
+        self.timestamp = datetime.now()
+        self.tool = ''
+        self.contains = {}
+        super().__init__(viewmetadata_obj)
+
+    def _deserialize(self, input_dict: dict) -> None:
+        self.__dict__ = input_dict
+        self.contains = dict([(at_type, Contain(contain_obj)) for at_type, contain_obj in input_dict.get('contains').items()])
+
+    def new_contain(self, at_type: str, contain_dict: dict):
+        new_contain = Contain(contain_dict)
+        self.contains[at_type] = new_contain
+        return new_contain
+
+
+class Contain(MmifObject):
+    producer: str
+    gen_time: datetime
+
+    def __init__(self, contain_obj: Union[str, dict] = None):
+        self.producer = ''
+        self.gen_time = datetime.now()     # datetime.datetime
+        super().__init__(contain_obj)
+

usr/lib/python3.8/site-packages/mmif/ver/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

{mmif-python-0.0.1 → usr/lib/python3.8/site-packages/mmif_python-0.1.0-py3.8.egg-info}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: mmif-python
-Version: 0.0.1
+Version: 0.1.0
 Summary: Python implementation of MultiMedia Interchange Format specification. (https://mmif.clams.ai)
-Home-page: https://github.com/clamsproject/mmif-python
+Home-page: https://mmif.clams.ai
 Author: Brandeis Lab for Linguistics and Computation
 Author-email: admin@clams.ai
 License: UNKNOWN
@@ -31,3 +31,4 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
+Provides-Extra: dev

usr/lib/python3.8/site-packages/mmif_python-0.1.0-py3.8.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+README.md
+requirements.txt
+setup.py
+mmif/__init__.py
+mmif/res/__init__.py
+mmif/serialize/__init__.py
+mmif/serialize/annotation.py
+mmif/serialize/medium.py
+mmif/serialize/mmif.py
+mmif/serialize/model.py
+mmif/serialize/view.py
+mmif/ver/__init__.py
+mmif/vocab/__init__.py
+mmif_python.egg-info/PKG-INFO
+mmif_python.egg-info/SOURCES.txt
+mmif_python.egg-info/dependency_links.txt
+mmif_python.egg-info/requires.txt
+mmif_python.egg-info/top_level.txt
+tests/mmif_examples.py
+tests/test_serialize.py

usr/lib/python3.8/site-packages/mmif_python-0.1.0-py3.8.egg-info/requires.txt

@@ -0,0 +1,13 @@
+attrs==19.3.0
+certifi==2020.6.20
+importlib-metadata==1.7.0
+jsonschema==3.2.0
+pyrsistent==0.16.0
+six==1.15.0
+zipp==3.1.0
+
+[dev]
+pytest
+pytest-pep8
+pytest-cov
+pytype

mmif-python-0.0.1/README.md

@@ -1,17 +0,0 @@
-# MMIF for python 
-
-**NOTE** that this project is in pre-alpha and being actively developed. Nothing is guaranteed to reliably work for the moment and developer need to be very careful when using APIs implemented here. Please use [the issue track](../../issues) to report bugs and malfunctions, or send pull requests for even more contribution. 
-
-## MultiMedia Interchange Format
-[MMIF](htts://mmif.clams.ai) is a JSON-LD based data format designed for transfer annotation data between computational analysis applications in [CLAMS project](https://www.clams.ai). 
-
-## installation: 
-Package `mmif-python` is distributed via the official pypi. Users are supposed to pip-install to get latest release. 
-```
-pip install mmif-python
-```
-This will install a packge `mmif` to local python 
-
-## APIs
-
-TBD

mmif-python-0.0.1/mmif/__init__.py

@@ -1,2 +0,0 @@
-from mmif.serialize import *
-from mmif.vocab import *

mmif-python-0.0.1/mmif/serialize/__init__.py

@@ -1,173 +0,0 @@
-import datetime
-import json
-
-
-class MmifObject(object):
-    def __init__(self, mmif_json=None):
-        if mmif_json is not None:
-            self.deserialize(mmif_json)
-
-    def serialize(self):
-        return self.__dict__
-
-    def deserialize(self, mmif):
-        raise NotImplementedError()
-
-    def __str__(self):
-        return json.dumps(self.serialize(), cls=MmifObjectEncoder)
-
-    def pretty(self):
-        return json.dumps(self, indent=2, cls=MmifObjectEncoder)
-
-
-class MmifObjectEncoder(json.JSONEncoder):
-    def default(self, obj):
-        if hasattr(obj, 'serialize'):
-            return obj.serialize()
-        elif hasattr(obj, '__str__'):
-            return str(obj)
-        else:
-            return json.JSONEncoder.default(self, obj)
-
-
-class Mmif(MmifObject):
-    context: str
-    metadata: dict
-    media: list
-    contains: dict
-    views: list
-
-    def __init__(self, mmif_json=None):
-        self.context = ''
-        self.metadata = {}
-        self.media = []
-        self.contains = {}
-        self.views = []
-        super().__init__(mmif_json)
-
-    def serialize(self):
-        d = self.__dict__.copy()
-        d['@context'] = d.pop('context')
-        return d
-
-    def deserialize(self, mmif):
-        in_json = json.loads(mmif)
-
-        # TODO (krim @ 10/3/2018): more robust json parsing
-        self.context = in_json["@context"]
-        self.contains = in_json["contains"]
-        self.metadata = in_json["metadata"]
-        self.media = in_json["media"]
-        self.views = in_json["views"]
-
-    def new_view_id(self):
-        return 'v_' + str(len(self.views))
-
-    def new_view(self):
-        new_view = View(self.new_view_id())
-        self.views.append(new_view)
-        return new_view
-
-    def add_media(self, medium):
-        try:
-            self.get_medium_location(medium)
-        # TODO (krim @ 10/7/2018): if get_m_location returns, raise "already exists" error
-        except Exception:
-            self.media.append(medium)
-
-    def get_medium_location(self, md_type):
-        for medium in self.media:
-            if medium["type"] == md_type:
-                return medium["location"]
-        raise Exception("{} type media not found".format(md_type))
-
-    def get_view_by_id(self, id):
-        for view in self.views:
-            if view.id == id:
-                return view
-        raise Exception("{} view not found".format(id))
-
-    def get_view_contains(self, attype):
-        return self.get_view_by_id(self.contains[attype])
-
-
-class Medium(MmifObject):
-    id: str
-    type: str
-    location: str
-    metadata: dict
-
-    def __init__(self, id, md_type='', uri=''):
-        self.id = id
-        self.type = md_type
-        self.location = uri
-        self.metadata = {}
-
-    def deserialize(self, mmif):
-        pass
-
-    def add_metadata(self, name, value):
-        self.metadata[name] = value
-
-
-class Annotation(MmifObject):
-    start: int
-    end: int
-    feature: dict
-    id: str
-    attype: str
-
-    def __init__(self, id, at_type=''):
-        # TODO (krim @ 10/4/2018): try deserialize "id", then if fails defaults to 0s
-        super().__init__()
-        self.start = 0
-        self.end = 0
-        self.feature = {}
-        self.id = id
-        self.attype = at_type
-
-    def deserialize(self, mmif):
-        pass
-
-    def add_feature(self, name, value):
-        self.feature[name] = value
-
-
-class View(MmifObject):
-    id: str
-    contains: dict
-    annotation: list
-
-    def __init__(self, id="UNIDENTIFIED"):
-        super().__init__()
-        self.id = id
-        self.contains = {}
-        self.annotations = []
-
-    def deserialize(self, view):
-        pass
-
-    def new_contain(self, at_type, producer=""):
-        new_contain = Contain()
-        new_contain.gen_time = datetime.datetime.utcnow().isoformat()
-        self.contains[at_type] = new_contain
-        return new_contain
-
-    def new_annotation(self, aid):
-        new_annotation = Annotation(aid)
-        self.annotations.append(new_annotation)
-        return new_annotation
-
-
-class Contain(MmifObject):
-    producer: str
-    gen_time: str
-
-    def __init__(self):
-        super().__init__()
-        self.producer = ''
-        self.gen_time = None     # datetime.datetime
-
-    def deserialize(self, mmif):
-        pass
-

mmif-python-0.0.1/mmif_python.egg-info/PKG-INFO

@@ -1,33 +0,0 @@
-Metadata-Version: 2.1
-Name: mmif-python
-Version: 0.0.1
-Summary: Python implementation of MultiMedia Interchange Format specification. (https://mmif.clams.ai)
-Home-page: https://github.com/clamsproject/mmif-python
-Author: Brandeis Lab for Linguistics and Computation
-Author-email: admin@clams.ai
-License: UNKNOWN
-Description: # MMIF for python 
-        
-        **NOTE** that this project is in pre-alpha and being actively developed. Nothing is guaranteed to reliably work for the moment and developer need to be very careful when using APIs implemented here. Please use [the issue track](../../issues) to report bugs and malfunctions, or send pull requests for even more contribution. 
-        
-        ## MultiMedia Interchange Format
-        [MMIF](htts://mmif.clams.ai) is a JSON-LD based data format designed for transfer annotation data between computational analysis applications in [CLAMS project](https://www.clams.ai). 
-        
-        ## installation: 
-        Package `mmif-python` is distributed via the official pypi. Users are supposed to pip-install to get latest release. 
-        ```
-        pip install mmif-python
-        ```
-        This will install a packge `mmif` to local python 
-        
-        ## APIs
-        
-        TBD
-        
-Platform: UNKNOWN
-Classifier: Development Status :: 2 - Pre-Alpha
-Classifier: Intended Audience :: Developers 
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown

mmif-python-0.0.1/mmif_python.egg-info/SOURCES.txt

@@ -1,9 +0,0 @@
-README.md
-setup.py
-mmif/__init__.py
-mmif/serialize/__init__.py
-mmif/vocab/__init__.py
-mmif_python.egg-info/PKG-INFO
-mmif_python.egg-info/SOURCES.txt
-mmif_python.egg-info/dependency_links.txt
-mmif_python.egg-info/top_level.txt

mmif-python-0.0.1/setup.cfg

@@ -1,4 +0,0 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-

mmif-python-0.0.1/setup.py

@@ -1,23 +0,0 @@
-import setuptools
-
-with open('README.md') as readme:
-    long_desc = readme.read()
-
-setuptools.setup(
-    name="mmif-python", 
-    version="0.0.1",
-    author="Brandeis Lab for Linguistics and Computation", 
-    author_email="admin@clams.ai",
-    description="Python implementation of MultiMedia Interchange Format specification. (https://mmif.clams.ai)",
-    long_description=long_desc,
-    long_description_content_type="text/markdown",
-    url="https://github.com/clamsproject/mmif-python",
-    packages=setuptools.find_packages() ,
-    python_requires='>=3.6',
-    classifiers=[
-        'Development Status :: 2 - Pre-Alpha',
-        'Intended Audience :: Developers ',
-        'License :: OSI Approved :: Apache Software License',
-        'Programming Language :: Python :: 3 :: Only',
-        ],
-)