mmif-python 1.2.0__tar.gz → 1.2.1__tar.gz

{mmif_python-1.2.0/mmif_python.egg-info → mmif_python-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mmif-python
-Version: 1.2.0
+Version: 1.2.1
 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.2.1/VERSION

@@ -0,0 +1 @@
+1.2.1

{mmif_python-1.2.0 → mmif_python-1.2.1}/mmif/serialize/annotation.py

@@ -2,7 +2,7 @@
 The :mod:`annotation` module contains the classes used to represent a
 MMIF annotation as a live Python object.
 
-In MMIF, annotations are created by apps in a pipeline as a part
+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`.
 """

{mmif_python-1.2.0 → mmif_python-1.2.1}/mmif/serialize/mmif.py

@@ -635,7 +635,7 @@ class Mmif(MmifObject):
     def get_views_for_document(self, doc_id: str) -> List[View]:
         """
         Returns the list of all views that have annotations anchored on a particular document.
-        Note that when the document is inside a view (generated during the pipeline's running),
+        Note that when the document is inside a view (generated during the workflow's running),
         doc_id must be prefixed with the view_id.
         """
         views = []

{mmif_python-1.2.0 → mmif_python-1.2.1}/mmif/serialize/view.py

@@ -2,7 +2,7 @@
 The :mod:`view` module contains the classes used to represent a MMIF view
 as a live Python object.
 
-In MMIF, views are created by apps in a pipeline that are annotating
+In MMIF, views are created by apps in a workflow that are annotating
 data that was previously present in the MMIF file.
 
 The :class:`View` class is a high-level container that provides convenient

mmif_python-1.2.1/mmif/utils/cli/describe.py

@@ -0,0 +1,140 @@
+import argparse
+import json
+import sys
+import textwrap
+from pathlib import Path
+from typing import Union
+
+from mmif.utils.workflow_helper import generate_workflow_identifier, describe_single_mmif, \
+    describe_mmif_collection
+# gen_param_hash is imported for backward compatibility
+from mmif.utils.workflow_helper import generate_param_hash
+
+
+def get_pipeline_specs(mmif_file: Union[str, Path]):
+    import warnings
+    warnings.warn("get_pipeline_specs is deprecated, use mmif.utils.workflow_helper.describe_single_mmif instead",
+                  DeprecationWarning)
+    return describe_single_mmif(mmif_file)
+
+
+def generate_pipeline_identifier(mmif_file: Union[str, Path]) -> str:
+    import warnings
+    warnings.warn("generate_pipeline_identifier is deprecated, use generate_workflow_identifier instead",
+                  DeprecationWarning)
+    return generate_workflow_identifier(mmif_file)
+
+
+def describe_argparser():
+    """
+    Returns two strings: one-line description of the argparser, and
+    additional material, which will be shown in `clams --help` and
+    `clams <subcmd> --help`, respectively.
+    """
+    oneliner = (
+        'provides CLI to describe the workflow specification from a MMIF '
+        'file or a collection of MMIF files.'
+    )
+
+    # get and clean docstrings
+    single_doc = describe_single_mmif.__doc__.split(':param')[0]
+    single_doc = textwrap.dedent(single_doc).strip()
+    collection_doc = describe_mmif_collection.__doc__.split(':param')[0]
+    collection_doc = textwrap.dedent(collection_doc).strip()
+
+    additional = textwrap.dedent(f"""
+    This command extracts workflow information from a single MMIF file or 
+    summarizes a directory of MMIF files.
+    
+    ==========================
+    For a single MMIF file
+    ==========================
+    {single_doc}
+
+    ===============================
+    For a directory of MMIF files
+    ===============================
+    {collection_doc}
+    """)
+    return oneliner, oneliner + '\n\n' + additional.strip()
+
+
+def prep_argparser(**kwargs):
+    parser = argparse.ArgumentParser(
+        description=describe_argparser()[1],
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        **kwargs
+    )
+    parser.add_argument(
+        "MMIF_FILE",
+        nargs="?",
+        type=str,
+        default=None if sys.stdin.isatty() else sys.stdin,
+        help='input MMIF file, a directory of MMIF files, or STDIN if `-` or not provided.'
+    )
+    parser.add_argument(
+        "-o", "--output",
+        type=argparse.FileType("w"),
+        default=sys.stdout,
+        help='output file path, or STDOUT if not provided.'
+    )
+    parser.add_argument(
+        "-p", "--pretty",
+        action="store_true",
+        help="Pretty-print JSON output"
+    )
+    return parser
+
+
+def main(args):
+    """
+    Main entry point for the describe CLI command.
+
+    Reads a MMIF file and outputs a JSON summary containing:
+    - workflow_id: unique identifier for the source and app sequence
+    - stats: view counts, annotation counts (total/per-view/per-type),
+      and lists of error/warning/empty view IDs
+    - views: map of view IDs to app configurations and profiling data
+
+    :param args: Parsed command-line arguments
+    """
+    output = {}
+    # if input is a directory
+    if isinstance(args.MMIF_FILE, str) and Path(args.MMIF_FILE).is_dir():
+        output = describe_mmif_collection(args.MMIF_FILE)
+    # if input is a file or stdin
+    else:
+        # Read MMIF content
+        if hasattr(args.MMIF_FILE, 'read'):
+            mmif_content = args.MMIF_FILE.read()
+        else:
+            with open(args.MMIF_FILE, 'r') as f:
+                mmif_content = f.read()
+
+        # For file input, we need to handle the path
+        # If input is from stdin, create a temp file
+        import tempfile
+        tmp_path = None
+        try:
+            with tempfile.NamedTemporaryFile(
+                    mode='w', suffix='.mmif', delete=False
+            ) as tmp:
+                tmp.write(mmif_content)
+                tmp_path = Path(tmp.name)
+            output = describe_single_mmif(tmp_path)
+        finally:
+            if tmp_path and tmp_path.exists():
+                tmp_path.unlink()
+
+    if output:
+        if args.pretty:
+            json.dump(output, args.output, indent=2)
+        else:
+            json.dump(output, args.output)
+        args.output.write('\n')
+
+
+if __name__ == "__main__":
+    parser = prep_argparser()
+    args = parser.parse_args()
+    main(args)

{mmif_python-1.2.0 → mmif_python-1.2.1}/mmif/utils/cli/rewind.py

@@ -3,26 +3,26 @@ import sys
 import textwrap
 
 import mmif
+from mmif.utils.workflow_helper import group_views_by_app
 
 
 def prompt_user(mmif_obj: mmif.Mmif) -> int:
     """
     Function to ask user to choose the rewind range.
     """
+    grouped_apps = group_views_by_app(mmif_obj.views)
+    view_to_app_num = {}
+    for i, execution in enumerate(grouped_apps):
+        for view in execution:
+            view_to_app_num[view.id] = i + 1
 
-    ## Give a user options (#, "app", "timestamp") - time order
-    n = len(mmif_obj.views)
-    i = 0  # option number
-    aname = ""
-    a = 0
     # header
     print("\n" + "{:<8} {:<8} {:<30} {:<100}".format("view-num", "app-num", "timestamp", "app"))
+    view_num = 0
     for view in reversed(mmif_obj.views):
-        if view.metadata.app != aname:
-            aname = view.metadata.app
-            a += 1
-        i += 1
-        print("{:<8} {:<8} {:<30} {:<100}".format(i, a, str(view.metadata.timestamp), str(view.metadata.app)))
+        view_num += 1
+        app_exec_num = view_to_app_num.get(view.id, 'N/A')
+        print("{:<8} {:<15} {:<30} {:<100}".format(view_num, app_exec_num, str(view.metadata.timestamp), str(view.metadata.app)))
 
     ## User input
     return int(input("\nEnter the number to delete from that point by rewinding: "))
@@ -33,7 +33,7 @@ def rewind_mmif(mmif_obj: mmif.Mmif, choice: int, choice_is_viewnum: bool = True
     Rewind MMIF by deleting the last N views. 
     The number of views to rewind is given as a number of "views", or number of "producer apps". 
     By default, the number argument is interpreted as the number of "views". 
-    Note that when the same app is repeatedly run in a CLAMS pipeline and produces multiple views in a row,
+    Note that when the same app is repeatedly run in a CLAMS workflow and produces multiple views in a row,
     rewinding in "app" mode will rewind all those views at once.
 
     :param mmif_obj: mmif object
@@ -46,16 +46,9 @@ def rewind_mmif(mmif_obj: mmif.Mmif, choice: int, choice_is_viewnum: bool = True
         for vid in list(v.id for v in mmif_obj.views)[-1:-choice-1:-1]:
             mmif_obj.views._items.pop(vid)
     else:
-        app_count = 0
-        cur_app = ""
-        vid_to_pop = []
-        for v in reversed(mmif_obj.views):
-            vid_to_pop.append(v.id)
-            if app_count >= choice:
-                break
-            if v.metadata.app != cur_app:
-                app_count += 1
-                cur_app = v.metadata.app
+        grouped_apps = group_views_by_app(mmif_obj.views)
+        executions_to_rewind = grouped_apps[-choice:]
+        vid_to_pop = [view.id for execution in executions_to_rewind for view in execution]
         for vid in vid_to_pop:
             mmif_obj.views._items.pop(vid)
     return mmif_obj
@@ -66,7 +59,7 @@ def describe_argparser():
     returns two strings: one-line description of the argparser, and addition material, 
     which will be shown in `clams --help` and `clams <subcmd> --help`, respectively.
     """
-    oneliner = 'provides CLI to rewind a MMIF from a CLAMS pipeline.'
+    oneliner = 'provides CLI to rewind a MMIF from a CLAMS workflow.'
     additional = textwrap.dedent("""
     MMIF rewinder rewinds a MMIF by deleting the last N views.
     N can be specified as a number of views, or a number of producer apps. """)

{mmif_python-1.2.0 → mmif_python-1.2.1}/mmif/utils/cli/source.py

@@ -233,7 +233,7 @@ def prep_argparser(**kwargs):
         name[len('mmif_docloc_'):]: importlib.import_module(name) for _, name, _ in pkgutil.iter_modules() if
         re.match(r'mmif[-_]docloc[-_]', name)
     }
-    parser = argparse.ArgumentParser(description=describe_argparser()[1], formatter_class=argparse.RawTextHelpFormatter, **kwargs)
+    parser = argparse.ArgumentParser(description=describe_argparser()[1], formatter_class=argparse.RawDescriptionHelpFormatter, **kwargs)
     parser.add_argument(
         'documents',
         default=None,