Upload 3 files

README.md

@@ -1,13 +1,39 @@
 ---
-title: Presentation Viewer
-emoji: 🏃
-colorFrom: indigo
-colorTo: yellow
+title: DataHub Live Viewer
+emoji: 📺
+colorFrom: blue
+colorTo: green
 sdk: gradio
-sdk_version: 6.18.0
-python_version: '3.13'
+sdk_version: 4.44.1
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# DataHub Live Viewer
+
+Public read-only viewer for DataHub segment text and uploaded media.
+
+The app expects an AWS sync process to publish files like this into a Hugging Face Dataset or Space repo:
+
+```text
+live/manifest.json
+live/current/segment.json
+live/current/input.txt
+live/current/details.json
+live/current/media/<uploaded images>
+```
+
+Required environment variables in the Space settings:
+
+```text
+DATA_REPO_ID=yourname/your-datahub-live-dataset
+DATA_REPO_TYPE=dataset
+DATA_PREFIX=live
+```
+
+Optional:
+
+```text
+AUTO_REFRESH_SECONDS=5
+HF_TOKEN=<only if the data repo is private>
+```

app.py

@@ -0,0 +1,479 @@
+import json
+import os
+from pathlib import PurePosixPath
+from typing import Any, Dict, List, Optional, Tuple
+
+import gradio as gr
+from huggingface_hub import hf_hub_download
+
+
+DATA_REPO_ID = os.environ.get("DATA_REPO_ID", "").strip()
+DATA_REPO_TYPE = os.environ.get("DATA_REPO_TYPE", "dataset").strip() or "dataset"
+DATA_PREFIX = os.environ.get("DATA_PREFIX", "live").strip().strip("/")
+DATA_REVISION = os.environ.get("DATA_REVISION", "main").strip() or "main"
+DATA_TOKEN = (
+    os.environ.get("DATA_REPO_TOKEN")
+    or os.environ.get("HF_TOKEN")
+    or os.environ.get("HUGGINGFACE_HUB_TOKEN")
+    or None
+)
+AUTO_REFRESH_SECONDS = float(os.environ.get("AUTO_REFRESH_SECONDS", "5") or "5")
+
+CURRENT_LABEL = "CURRENT / latest synced segment"
+
+
+CSS = """
+#topbar {
+    border-radius: 14px;
+    padding: 12px 16px;
+    background: linear-gradient(90deg, rgba(20,32,70,.95), rgba(20,70,65,.85));
+    color: white;
+}
+.big-status {
+    font-size: 15px;
+}
+.entry-text textarea {
+    font-size: 18px !important;
+    line-height: 1.35 !important;
+}
+.small-note {
+    opacity: .75;
+    font-size: 12px;
+}
+"""
+
+
+def repo_path(*parts: str) -> str:
+    clean_parts = []
+    if DATA_PREFIX:
+        clean_parts.append(DATA_PREFIX)
+    for part in parts:
+        part = str(part or "").strip().strip("/")
+        if part:
+            clean_parts.append(part)
+    return str(PurePosixPath(*clean_parts))
+
+
+def require_config() -> None:
+    if not DATA_REPO_ID:
+        raise RuntimeError(
+            "Missing DATA_REPO_ID. In the Space settings, set DATA_REPO_ID to the "
+            "dataset repo your AWS app is syncing to, for example: krhogan2/datahub-live"
+        )
+
+
+def download_file(path_in_repo: str) -> str:
+    require_config()
+    return hf_hub_download(
+        repo_id=DATA_REPO_ID,
+        repo_type=DATA_REPO_TYPE,
+        filename=path_in_repo,
+        revision=DATA_REVISION,
+        token=DATA_TOKEN,
+    )
+
+
+def download_json(path_in_repo: str) -> Dict[str, Any]:
+    local_path = download_file(path_in_repo)
+    with open(local_path, "r", encoding="utf-8") as fh:
+        data = json.load(fh)
+    if not isinstance(data, dict):
+        raise ValueError(f"{path_in_repo} did not contain a JSON object")
+    return data
+
+
+def load_manifest() -> Dict[str, Any]:
+    try:
+        return download_json(repo_path("manifest.json"))
+    except Exception:
+        return {
+            "updatedUtc": "",
+            "latestSegment": "",
+            "currentSegmentJson": "current/segment.json",
+            "folders": [],
+        }
+
+
+def folder_choices_from_manifest(manifest: Dict[str, Any]) -> List[str]:
+    folders = manifest.get("folders", [])
+    if not isinstance(folders, list):
+        folders = []
+
+    choices = [CURRENT_LABEL]
+    for folder in folders:
+        folder = str(folder or "").strip()
+        if folder and folder not in choices:
+            choices.append(folder)
+
+    return choices
+
+
+def load_segment(folder_choice: Optional[str]) -> Tuple[Dict[str, Any], str, str]:
+    manifest = load_manifest()
+    latest = str(manifest.get("latestSegment") or "").strip()
+
+    if not folder_choice or folder_choice == CURRENT_LABEL:
+        segment_path = repo_path("current", "segment.json")
+        segment = download_json(segment_path)
+        segment["_hf_segment_path"] = segment_path
+        segment["_hf_segment_base"] = str(PurePosixPath(segment_path).parent)
+        return segment, CURRENT_LABEL, ""
+
+    folder_choice = str(folder_choice).strip()
+
+    # This supports a future enhanced sync format:
+    # live/segments/<folder name>/segment.json
+    archive_path = repo_path("segments", folder_choice, "segment.json")
+    try:
+        segment = download_json(archive_path)
+        segment["_hf_segment_path"] = archive_path
+        segment["_hf_segment_base"] = str(PurePosixPath(archive_path).parent)
+        return segment, folder_choice, ""
+    except Exception:
+        pass
+
+    # With the AWS patch we made, only live/current is pushed.
+    # So if the selected folder is the latest folder, use current.
+    if latest and folder_choice == latest:
+        segment_path = repo_path("current", "segment.json")
+        segment = download_json(segment_path)
+        segment["_hf_segment_path"] = segment_path
+        segment["_hf_segment_base"] = str(PurePosixPath(segment_path).parent)
+        return segment, folder_choice, ""
+
+    raise FileNotFoundError(
+        f"'{folder_choice}' is listed in the manifest, but its full segment snapshot "
+        "is not synced yet. The current AWS patch uploads the latest segment to "
+        "live/current/. To browse old folders, add a later AWS sync pass that writes "
+        "live/segments/<folder>/segment.json and live/segments/<folder>/media/."
+    )
+
+
+def entries_from_segment(segment: Dict[str, Any]) -> List[Dict[str, Any]]:
+    entries = segment.get("entries", [])
+    if not isinstance(entries, list):
+        return []
+    return [entry for entry in entries if isinstance(entry, dict)]
+
+
+def entry_label(entry: Dict[str, Any]) -> str:
+    row = entry.get("row", "")
+    name = str(entry.get("name") or "").strip()
+    entry_id = str(entry.get("entryId") or "").strip()
+
+    text = str(entry.get("onScreenText") or "").strip().replace("\n", " ")
+    if len(text) > 70:
+        text = text[:67] + "..."
+
+    pieces = [f"Row {row}"]
+    if name:
+        pieces.append(name)
+    if text:
+        pieces.append(text)
+    if entry_id:
+        pieces.append(entry_id[:8])
+
+    return " | ".join(pieces)
+
+
+def table_rows(segment: Dict[str, Any]) -> List[List[Any]]:
+    rows = []
+    for entry in entries_from_segment(segment):
+        images = entry.get("images", [])
+        if not isinstance(images, list):
+            images = []
+
+        rows.append([
+            entry.get("row", ""),
+            entry.get("type", ""),
+            entry.get("name", ""),
+            entry.get("chart", ""),
+            entry.get("textStatus", ""),
+            len(images),
+            entry.get("onScreenText", ""),
+        ])
+    return rows
+
+
+def image_paths_for_entry(segment: Dict[str, Any], entry: Dict[str, Any]) -> List[str]:
+    base = str(segment.get("_hf_segment_base") or "").strip()
+    image_paths = entry.get("imagePaths", [])
+
+    if not isinstance(image_paths, list) or not image_paths:
+        images = entry.get("images", [])
+        if isinstance(images, list):
+            image_paths = [f"media/{name}" for name in images]
+        else:
+            image_paths = []
+
+    local_images = []
+    for image_path in image_paths:
+        image_path = str(image_path or "").strip().strip("/")
+        if not image_path:
+            continue
+
+        full_repo_path = str(PurePosixPath(base) / image_path) if base else repo_path(image_path)
+
+        try:
+            local_images.append(download_file(full_repo_path))
+        except Exception:
+            continue
+
+    return local_images
+
+
+def first_entry_outputs(segment: Dict[str, Any]) -> Tuple[Any, str, List[str]]:
+    entries = entries_from_segment(segment)
+    if not entries:
+        return gr.update(choices=[], value=None), "", []
+
+    labels = [entry_label(entry) for entry in entries]
+    first = entries[0]
+    return (
+        gr.update(choices=labels, value=labels[0]),
+        str(first.get("onScreenText") or ""),
+        image_paths_for_entry(segment, first),
+    )
+
+
+def status_markdown(
+    segment: Optional[Dict[str, Any]],
+    folder_choice: str,
+    warning: str = "",
+) -> str:
+    if not segment:
+        return (
+            "### Not connected yet\n"
+            "Set `DATA_REPO_ID` in the Space settings to the dataset repo receiving the AWS sync."
+        )
+
+    folder = segment.get("folder") or folder_choice or "Unknown"
+    updated = segment.get("updatedUtc") or "Unknown"
+    count = segment.get("entryCount", len(entries_from_segment(segment)))
+    repo = DATA_REPO_ID or "DATA_REPO_ID not set"
+    path = segment.get("_hf_segment_path", "")
+
+    warning_text = f"\n\n⚠️ {warning}" if warning else ""
+
+    return (
+        f"### {folder}\n"
+        f"**Updated:** {updated}  \n"
+        f"**Entries:** {count}  \n"
+        f"**Source repo:** `{repo}`  \n"
+        f"**Source file:** `{path}`"
+        f"{warning_text}"
+    )
+
+
+def error_outputs(message: str):
+    return (
+        f"### Error\n{message}",
+        gr.update(choices=[CURRENT_LABEL], value=CURRENT_LABEL),
+        {},
+        [],
+        gr.update(choices=[], value=None),
+        "",
+        [],
+        json.dumps({"error": message}, indent=2),
+    )
+
+
+def strip_internal_keys(segment: Dict[str, Any]) -> Dict[str, Any]:
+    clean = {}
+    for key, value in segment.items():
+        if not str(key).startswith("_hf_"):
+            clean[key] = value
+    return clean
+
+
+def refresh_ui(folder_choice: Optional[str]):
+    try:
+        manifest = load_manifest()
+        choices = folder_choices_from_manifest(manifest)
+
+        if not folder_choice or folder_choice not in choices:
+            folder_choice = CURRENT_LABEL
+
+        segment, resolved_folder, warning = load_segment(folder_choice)
+        row_dropdown, first_text, first_images = first_entry_outputs(segment)
+
+        return (
+            status_markdown(segment, resolved_folder, warning),
+            gr.update(choices=choices, value=folder_choice),
+            segment,
+            table_rows(segment),
+            row_dropdown,
+            first_text,
+            first_images,
+            json.dumps(strip_internal_keys(segment), indent=2),
+        )
+    except Exception as e:
+        return error_outputs(str(e))
+
+
+def load_folder_ui(folder_choice: Optional[str]):
+    return refresh_ui(folder_choice)
+
+
+def show_selected_entry(segment: Dict[str, Any], selected_label: Optional[str]):
+    if not segment or not selected_label:
+        return "", []
+
+    for entry in entries_from_segment(segment):
+        if entry_label(entry) == selected_label:
+            return str(entry.get("onScreenText") or ""), image_paths_for_entry(segment, entry)
+
+    return "", []
+
+
+def build_app() -> gr.Blocks:
+    with gr.Blocks(title="DataHub Live Viewer", css=CSS) as demo:
+        segment_state = gr.State({})
+
+        gr.HTML(
+            """
+            <div id="topbar">
+              <h1 style="margin:0;">📺 DataHub Live Viewer</h1>
+              <div class="big-status">
+                Read-only public viewer for on-screen text and Pictures tab uploads.
+              </div>
+            </div>
+            """
+        )
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                folder_dropdown = gr.Dropdown(
+                    choices=[CURRENT_LABEL],
+                    value=CURRENT_LABEL,
+                    label="DataHub segment folder",
+                    interactive=True,
+                )
+                refresh_btn = gr.Button("Refresh now", variant="primary")
+                status = gr.Markdown()
+
+                gr.Markdown(
+                    """
+                    <div class="small-note">
+                    Tip: with the current AWS sync patch, the latest segment appears under
+                    <code>CURRENT / latest synced segment</code>. Older folders will become clickable
+                    once the AWS side also syncs <code>live/segments/&lt;folder&gt;/...</code>.
+                    </div>
+                    """
+                )
+
+            with gr.Column(scale=2):
+                entries_table = gr.Dataframe(
+                    headers=[
+                        "Row",
+                        "Type",
+                        "Name",
+                        "Chart",
+                        "Text Status",
+                        "Images",
+                        "On-Screen Text",
+                    ],
+                    datatype=["number", "str", "str", "str", "str", "number", "str"],
+                    interactive=False,
+                    wrap=True,
+                    label="All on-screen text",
+                )
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                row_dropdown = gr.Dropdown(
+                    choices=[],
+                    label="Pick row / Pictures tab item",
+                    interactive=True,
+                )
+                selected_text = gr.Textbox(
+                    label="Full on-screen text for selected row",
+                    lines=12,
+                    elem_classes=["entry-text"],
+                )
+
+            with gr.Column(scale=1):
+                gallery = gr.Gallery(
+                    label="Uploaded pictures for selected row",
+                    columns=2,
+                    height=420,
+                    show_download_button=True,
+                    object_fit="contain",
+                )
+
+        with gr.Accordion("Raw current segment.json", open=False):
+            raw_json = gr.Code(language="json", label="Raw JSON")
+
+        demo.load(
+            fn=refresh_ui,
+            inputs=[folder_dropdown],
+            outputs=[
+                status,
+                folder_dropdown,
+                segment_state,
+                entries_table,
+                row_dropdown,
+                selected_text,
+                gallery,
+                raw_json,
+            ],
+        )
+
+        refresh_btn.click(
+            fn=refresh_ui,
+            inputs=[folder_dropdown],
+            outputs=[
+                status,
+                folder_dropdown,
+                segment_state,
+                entries_table,
+                row_dropdown,
+                selected_text,
+                gallery,
+                raw_json,
+            ],
+        )
+
+        folder_dropdown.change(
+            fn=load_folder_ui,
+            inputs=[folder_dropdown],
+            outputs=[
+                status,
+                folder_dropdown,
+                segment_state,
+                entries_table,
+                row_dropdown,
+                selected_text,
+                gallery,
+                raw_json,
+            ],
+        )
+
+        row_dropdown.change(
+            fn=show_selected_entry,
+            inputs=[segment_state, row_dropdown],
+            outputs=[selected_text, gallery],
+        )
+
+        if AUTO_REFRESH_SECONDS > 0:
+            timer = gr.Timer(value=AUTO_REFRESH_SECONDS)
+            timer.tick(
+                fn=refresh_ui,
+                inputs=[folder_dropdown],
+                outputs=[
+                    status,
+                    folder_dropdown,
+                    segment_state,
+                    entries_table,
+                    row_dropdown,
+                    selected_text,
+                    gallery,
+                    raw_json,
+                ],
+            )
+
+    return demo
+
+
+if __name__ == "__main__":
+    build_app().launch()

requirements.txt

@@ -0,0 +1,2 @@
+gradio>=4.44.0
+huggingface_hub>=0.23.0