Merge pull request #34 from clamsproject/33-fix-uv

keighrim · web-flow · commit cef51faf765f · 2024-03-13T09:08:11.000-04:00
fixes, and then turn-off UV
diff --git a/app.py b/app.py
@@ -9,7 +9,8 @@
 
 import cache
 from cache import set_last_access, cleanup
-from utils import app, render_ocr, documents_to_htmls, prep_annotations, prepare_ocr_visualization
+import utils
+from utils import app
 
 
 @app.route('/')
@@ -24,7 +25,7 @@ def ocr():
         mmif_str = open(cache.get_cache_root() / data["mmif_id"] / "file.mmif").read()
         mmif = Mmif(mmif_str)
         ocr_view = mmif.get_view_by_id(data["view_id"])
-        return prepare_ocr_visualization(mmif, ocr_view, data["mmif_id"])
+        return utils.prepare_ocr_visualization(mmif, ocr_view, data["mmif_id"])
     except Exception as e:
         return f'<p class="error">{e}</h1>'
 
@@ -33,7 +34,7 @@ def ocr():
 def ocrpage():
     data = request.json
     try:
-        return render_ocr(data["mmif_id"], data['vid_path'], data["view_id"], data["page_number"])
+        return utils.render_ocr(data["mmif_id"], data['vid_path'], data["view_id"], data["page_number"])
     except Exception as e:
         return f'<p class="error">Unexpected error of type {type(e)}: {e}</h1>'
 
@@ -99,16 +100,6 @@ def send_js(path):
     return send_from_directory("uv", path)
 
 
-def render_mmif(mmif_str, viz_id):
-    mmif = Mmif(mmif_str)
-    htmlized_docs = documents_to_htmls(mmif, viz_id)
-    app.logger.debug(f"Prepared document: {[d[0] for d in htmlized_docs]}")
-    annotations = prep_annotations(mmif, viz_id)
-    app.logger.debug(f"Prepared Annotations: {[annotation[0] for annotation in annotations]}")
-    return render_template('player.html',
-                           docs=htmlized_docs, viz_id=viz_id, annotations=annotations)
-
-
 def upload_file(in_mmif):
     # Save file locally
     in_mmif_bytes = in_mmif if isinstance(in_mmif, bytes) else in_mmif.read()
@@ -123,7 +114,13 @@ def upload_file(in_mmif):
         with open(path / 'file.mmif', 'w') as in_mmif_file:
             app.logger.debug(f"Writing original MMIF to {path / 'file.mmif'}")
             in_mmif_file.write(in_mmif_str)
-        html_page = render_mmif(in_mmif_str, viz_id)
+        mmif = Mmif(in_mmif_str)
+        htmlized_docs = utils.documents_to_htmls(mmif, viz_id)
+        app.logger.debug(f"Prepared document: {[d[0] for d in htmlized_docs]}")
+        annotations = utils.prep_annotations(mmif, viz_id)
+        app.logger.debug(f"Prepared Annotations: {[annotation[0] for annotation in annotations]}")
+        html_page = render_template('player.html',
+                               docs=htmlized_docs, viz_id=viz_id, annotations=annotations)
         with open(os.path.join(path, "index.html"), "w") as f:
             f.write(html_page)
     except FileExistsError:
diff --git a/cache.py b/cache.py
@@ -1,3 +1,4 @@
+import logging
 import os
 import pathlib
 import shutil
@@ -16,7 +17,7 @@ def get_cache_root():
     return pathlib.Path(_CACHE_DIR_ROOT.name)
 
 
-def invalidate_cache(viz_ids):
+def invalidate_cache(viz_ids=[]):
     if not viz_ids:
         shutil.rmtree(get_cache_root())
         os.makedirs(get_cache_root())
@@ -55,11 +56,11 @@ def scan_tmp_directory():
 
 def cleanup():
     with lock:
-        print("Checking visualization cache...")
+        logging.info("Checking visualization cache...")
         # Max tmp size is 500MB
         max_size = 500000000
         folder_size, oldest_dir = scan_tmp_directory()
         while folder_size > max_size:
-            print(f"Maximum cache size reached. Deleting {os.path.basename(oldest_dir)}.")
+            logging.info(f"Maximum cache size reached. Deleting {os.path.basename(oldest_dir)}.")
             shutil.rmtree(oldest_dir)
             folder_size, oldest_dir = scan_tmp_directory()
diff --git a/iiif_utils.py b/iiif_utils.py
@@ -1,14 +1,15 @@
 import datetime
 import json
-import os
 import tempfile
 from typing import Dict
 
 import mmif
 from flask import url_for
 from mmif import AnnotationTypes, DocumentTypes, Mmif
+from mmif.utils import video_document_helper as vdh
 
 import cache
+import utils
 
 
 def generate_iiif_manifest(in_mmif: mmif.Mmif, viz_id):
@@ -27,18 +28,20 @@ def generate_iiif_manifest(in_mmif: mmif.Mmif, viz_id):
         ],
         "structures": []
     }
-    add_canvas_from_documents(in_mmif, iiif_json)
+    add_canvas_from_documents(viz_id, in_mmif, iiif_json)
     add_structure_from_timeframe(in_mmif, iiif_json)
     return save_manifest(iiif_json, viz_id)
 
 
-def add_canvas_from_documents(in_mmif, iiif_json):
+def add_canvas_from_documents(viz_id, in_mmif, iiif_json):
     video_documents = in_mmif.get_documents_by_type(DocumentTypes.VideoDocument)
     audio_documents = in_mmif.get_documents_by_type(DocumentTypes.AudioDocument)
     image_documents = in_mmif.get_documents_by_type(DocumentTypes.ImageDocument)
     all_documents = video_documents + audio_documents + image_documents
     document_canvas_dict = {}
     for _id, document in enumerate(all_documents, start=1):
+        canvas_media_path = url_for(
+            'static', filename=f"{cache._CACHE_DIR_SUFFIX}/{viz_id}/{utils.get_src_media_symlink_basename(document)}")
         document_canvas_dict[document.id] = _id
         canvas = {
             "id": f"http://0.0.0.0:5000/mmif_example_manifest.json/canvas/{_id}",
@@ -62,7 +65,7 @@ def add_canvas_from_documents(in_mmif, iiif_json):
                                     "choiceHint": "user",
                                     "items": [
                                         {
-                                            "id": build_document_url(document),
+                                            "id": canvas_media_path,
                                             "type": get_iiif_type(document),
                                             "label": "",
                                             "format": get_iiif_format(document)
@@ -76,34 +79,37 @@ def add_canvas_from_documents(in_mmif, iiif_json):
                 }
             ],
         }
-        # if not os.path.isfile(f"static{document.location_path()}"):
-        #     shutil.copyfile(
-        #         f"{document.location_path()}",
-        #         f"static{os.path.basename(document.location_path())}"
-        #     )
         iiif_json["sequences"][0]["canvases"].append(canvas)
         break # todo currently only supports single document, needs more work to align canvas values
 
 
-def build_document_url(document):
-    """
-    This trims off all of the path to the document except the filename then prepends data/video/. This is so
-    mmif's from running locally can still be found if the viewe
-    r is run in docker, assuming the volume mount or
-    symlink is correctly set.
-    """
-    location = document.location
-    if location.startswith("file://"):
-        location = document.location[7:]
-    file_path = os.path.join("data", "video", os.path.basename(location))
-    return url_for('static', filename=file_path)
-
-
 def add_structure_from_timeframe(in_mmif: Mmif, iiif_json: Dict):
     # # get all views with timeframe annotations from mmif obj
     tf_views = in_mmif.get_views_contain(AnnotationTypes.TimeFrame)
     for range_id, view in enumerate(tf_views, start=1):
-        view_range = tf_view_to_iiif_range(range_id, view)
+        view_range = {
+            "id": f"http://0.0.0.0:5000/mmif_example_manifest.json/range/{range_id}",
+            "type": "Range",
+            "label": f"View: {view.id}",
+            "members": []
+        }
+        for ann in view.get_annotations(AnnotationTypes.TimeFrame):
+            label = ann.get_property('label')
+            s, e = vdh.convert_timeframe(in_mmif, ann, "seconds")
+
+            structure = {
+                "id": f"http://0.0.0.0:5000/mmif_example_manifest.json/range/{range_id}",
+                "type": "Range",
+                "label": f"{label.capitalize()}",
+                "members": [
+                    {
+                        "id": f"http://0.0.0.0:5000/mmif_example_manifest.json/canvas/{1}#t={s},{e}",
+                        # need to align id here to support more than one document
+                        "type": "Canvas"
+                    }
+                ]
+            }
+            view_range["members"].append(structure)
         iiif_json["structures"].append(view_range)
 
 
@@ -115,55 +121,6 @@ def save_manifest(iiif_json: Dict, viz_id) -> str:
     return manifest.name
 
 
-def tf_view_to_iiif_range(range_id, view):
-    view_range = {
-        "id": f"http://0.0.0.0:5000/mmif_example_manifest.json/range/{range_id}",
-        "type": "Range",
-        "label": f"View: {view.id}",
-        "members": []
-    }
-    # for annotation in view.annotations:
-        # # TODO: TimeUnits generated by Kaldi have no "timeUnit" or "unit" property.
-        # The mmif documentation does specify a "unit" property, but the Kaldi
-        # ASR doesn't seem to include that in annotations.
-
-        # if annotation.at_type == AnnotationTypes.TimeFrame:
-        #     if 'unit' in annotation.properties:
-        #         annotation_unit = annotation.properties['unit']
-        #     elif 'unit' in view.metadata.parameters:
-        #         annotation_unit = view.metadata.parameters['unit']
-        #     else:
-        #         raise Exception("Error finding timeframe unit.")
-        #     frame_type = annotation.properties["frameType"]
-        #     if annotation_unit == "frame":
-        #         start_fn = int(annotation.properties["start"])
-        #         end_fn = int(annotation.properties["end"])
-        #         frame_rate = 29.97
-        #         start_sec = int(start_fn // frame_rate)
-        #         end_sec = int(end_fn // frame_rate)
-        #     elif annotation_unit == "milliseconds":
-        #         start_milli = int(annotation.properties["start"])
-        #         end_milli = int(annotation.properties["end"])
-        #         start_sec = int(start_milli // 1000)
-        #         end_sec = int(end_milli // 1000)
-        #     else:
-        #         continue
-        #     structure = {
-        #         "id": f"http://0.0.0.0:5000/mmif_example_manifest.json/range/{range_id}",
-        #         "type": "Range",
-        #         "label": f"{frame_type.capitalize()}",
-        #         "members": [
-        #             {
-        #                 "id": f"http://0.0.0.0:5000/mmif_example_manifest.json/canvas/{1}#t={start_sec},{end_sec}",
-        #                 # need to align id here to support more than one document
-        #                 "type": "Canvas"
-        #             }
-        #         ]
-        #     }
-        #     view_range["members"].append(structure)
-    return view_range
-
-
 def get_iiif_format(document):
     if document.is_type(DocumentTypes.VideoDocument):
         return 'video/mp4'
diff --git a/templates/uv_player.html b/templates/uv_player.html
@@ -20,7 +20,7 @@
     $(".nav-item.UV").click(function() {
         if (!uvLoaded) {
             const data = {
-                manifest: "/tmp/{{mmif_id}}/{{manifest}}",
+                manifest: "/mmif-viz-cache/{{mmif_id}}/{{manifest}}",
                 embedded: true
              };
 
diff --git a/utils.py b/utils.py
@@ -2,15 +2,14 @@
 from datetime import timedelta
 from io import StringIO
 
-from flask import Flask
+from flask import Flask, url_for
 from lapps.discriminators import Uri
 from mmif import DocumentTypes
-from mmif.serialize.annotation import Text
+from mmif.serialize.annotation import Text, Document
 from mmif.vocabulary import AnnotationTypes
 
-import cache
 import displacy
-from iiif_utils import generate_iiif_manifest
+import iiif_utils
 from ocr import *
 
 # Get Properties from MMIF file ---
@@ -72,6 +71,31 @@ def build_alignment(alignment, token_idx, timeframe_idx):
         return start, end, text
 
 
+def get_src_media_symlink_basename(doc: Document):
+    doc_path = doc.location_path()
+    return f"{doc.id}.{doc_path.split('.')[-1]}"
+
+
+def get_symlink_relurl(viz_id, symlink_fname):
+    static_folder = pathlib.Path(app.static_folder)
+    symlink_path = pathlib.Path(cache._CACHE_DIR_SUFFIX) / viz_id / symlink_fname
+    return static_folder / symlink_path
+
+
+def symlink_to_static(viz_id, original_path, symlink_fname) -> str:
+    static_folder = pathlib.Path(app.static_folder)
+    symlink_path = pathlib.Path(cache._CACHE_DIR_SUFFIX) / viz_id / symlink_fname
+    app.logger.debug(f"Symlinking {original_path} to {symlink_path}")
+    try:
+        os.symlink(original_path, static_folder / symlink_path)
+    except Exception as e:
+        app.logger.error(f"SOME ERROR when symlinking: {str(e)}")
+    app.logger.debug(f"{original_path} is symlinked to {symlink_path}")
+    symlink_rel_path = url_for('static', filename=symlink_path)
+    app.logger.debug(f"and exposable as {symlink_rel_path}")
+    return symlink_rel_path
+
+
 def documents_to_htmls(mmif, viz_id):
     """
     Returns a list of tuples, one for each element in the documents list of
@@ -83,27 +107,31 @@ def documents_to_htmls(mmif, viz_id):
     for document in mmif.documents:
         doc_path = document.location_path()
         app.logger.debug(f"MMIF on AV asset: {doc_path}")
-        doc_symlink_path = pathlib.Path(app.static_folder) / cache._CACHE_DIR_SUFFIX / viz_id / (f"{document.id}.{doc_path.split('.')[-1]}")
-        os.symlink(doc_path, doc_symlink_path)
-        app.logger.debug(f"{doc_path} is symlinked to {doc_symlink_path}")
-        doc_symlink_rel_path = '/' + doc_symlink_path.relative_to(app.static_folder).as_posix()
-        app.logger.debug(f"and {doc_symlink_rel_path} will be used in HTML src attribute")
+        linked = symlink_to_static(viz_id, doc_path, get_src_media_symlink_basename(document))
         if document.at_type == DocumentTypes.TextDocument:
-            html = html_text(doc_symlink_rel_path)
+            html = html_text(linked)
         elif document.at_type == DocumentTypes.VideoDocument:
             fa_views = get_alignment_views(mmif)
             fa_view = fa_views[0] if fa_views else None
-            html = html_video(viz_id, doc_symlink_rel_path, fa_view)
+            html = html_video(viz_id, linked, fa_view)
         elif document.at_type == DocumentTypes.AudioDocument:
-            html = html_audio(doc_symlink_rel_path)
+            html = html_audio(linked)
         elif document.at_type == DocumentTypes.ImageDocument:
             boxes = get_boxes(mmif)
-            html = html_img(doc_symlink_rel_path, boxes)
+            html = html_img(linked, boxes)
         htmlized.append((document.at_type.shortname, document.id, doc_path, html))
-    manifest_filename = generate_iiif_manifest(mmif, viz_id)
+    manifest_filename = iiif_utils.generate_iiif_manifest(mmif, viz_id)
+    app.logger.debug(f"Generated IIIF manifest: {manifest_filename}")
     man = os.path.basename(manifest_filename)
+    app.logger.debug(f"Manifest filename: {man}")
+    symlink_to_static(viz_id, manifest_filename, man)
+    app.logger.debug(f"Symlinked IIIF manifest: {None}")
     temp = render_template("uv_player.html", manifest=man, mmif_id=viz_id)
-    htmlized.append(('UV', "", "", temp))
+    # TODO (krim @ 2024-03-12): Turning off IIIF added to the HTML page since
+    # 1. current IIIF manifest conversion is based on old version of manifest API, and quite brittle
+    # 2. the conversion code at the moment can only convert TimeFrame annotation to "jump-able" IIIF canvases, 
+    # but the case is already covered by `Thumbnails` tab (look for usage of `pre-ocr.html` template)
+    # htmlized.append(('UV', "", "", temp))
     return htmlized
 
 
