Upload folder using huggingface_hub

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -1,12 +1,6 @@
 ---
-title: Audio Library
-emoji: 📈
-colorFrom: gray
-colorTo: purple
+title: audio-library
+app_file: app.py
 sdk: gradio
 sdk_version: 5.46.0
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,366 @@
+import os, uuid, datetime, traceback
+from pathlib import Path
+import html as _py_html
+import pandas as pd
+import gradio as gr
+
+# ----------- FIXED PATHS -----------
+REPORTS_ROOT   = Path("/data/atlask/Model-Preds-Html/AudioSet-Audio")         # /{model_name}/*.html
+FIXED_MANIFEST = Path("/data/atlask/BAU-Quant/manifest_val.csv")
+# -----------------------------------
+
+DB_PATH = "library.csv"
+ALLOWED_EXTS = {".html"}
+
+# Columns in DB
+EXTRA_COLS = ["model_name", "category", "dataset"]
+BASE_COLS  = ["id","filename","path","tags","keywords","notes","uploaded_at"]
+ALL_DB_COLS = BASE_COLS + EXTRA_COLS
+
+# Columns shown in the table (order)
+TABLE_COLS = ["id","filename","model_name","category","dataset",
+              "tags","keywords","notes","uploaded_at"]
+
+# ---------- DB helpers ----------
+def _load_db() -> pd.DataFrame:
+    if os.path.exists(DB_PATH):
+        df = pd.read_csv(DB_PATH)
+        # migrate: ensure all required columns exist
+        for c in ALL_DB_COLS:
+            if c not in df.columns:
+                df[c] = ""
+        # normalize text-ish fields
+        for c in ["tags","keywords","notes","model_name","category","dataset"]:
+            df[c] = df[c].fillna("").astype(str)
+        # keep only our known columns in stable order
+        return df[ALL_DB_COLS]
+    return pd.DataFrame(columns=ALL_DB_COLS)
+
+def _save_db(df: pd.DataFrame):
+    df.to_csv(DB_PATH, index=False)
+
+# ---------- Table normalizer ----------
+def _df_from_table_value(table_value):
+    cols = TABLE_COLS
+    if isinstance(table_value, pd.DataFrame):
+        for c in cols:
+            if c not in table_value.columns:
+                table_value[c] = ""
+        return table_value[cols]
+    if isinstance(table_value, list):
+        if not table_value:
+            return pd.DataFrame(columns=cols)
+        first = table_value[0]
+        if isinstance(first, dict):
+            df = pd.DataFrame(table_value)
+            for c in cols:
+                if c not in df.columns:
+                    df[c] = ""
+            return df[cols]
+        else:
+            return pd.DataFrame(table_value, columns=cols)
+    return pd.DataFrame(columns=cols)
+
+# ---------- Manifest helpers ----------
+def _stem_for_match(p: Path) -> str:
+    stem = p.stem
+    if "chunk" in stem:
+        stem = stem.split("_chunk")[0]
+    return stem
+
+def _load_manifest():
+    if not FIXED_MANIFEST.exists():
+        return None
+    mf = pd.read_csv(FIXED_MANIFEST)
+    if "file_name" not in mf.columns:
+        return None
+    mf = mf.copy()
+    def mk_from_str(s: str):
+        st = Path(str(s)).stem
+        return st.split("_chunk")[0] if "chunk" in st else st
+    mf["__match_key"] = mf["file_name"].astype(str).apply(mk_from_str)
+    return mf
+
+# ---------- Sync by model ----------
+def sync_model(model_name: str):
+    f"""
+    Index all .html reports under {REPORTS_ROOT}/{model_name}.
+    Adds NEW files to DB (by exact path), sets model_name,
+    and fills category/dataset from the fixed manifest if present.
+    """
+    model_name = (model_name or "").strip()
+    if not model_name:
+        return gr.Info("Please enter a model name."), None, None, None, None
+
+    folder = REPORTS_ROOT / model_name
+    if not folder.exists():
+        return gr.Info(f"Folder not found: {folder}"), None, None, None, None
+
+    df = _load_db()
+    manifest = _load_manifest()
+    now = datetime.datetime.now().isoformat(timespec="seconds")
+    new_rows = []
+
+    for p in sorted(folder.glob("*.html")):
+        if p.suffix.lower() not in ALLOWED_EXTS:
+            continue
+
+        # if already indexed, optionally backfill model_name and skip creating a new row
+        existing = df["path"] == str(p)
+        if existing.any():
+            idxs = df.index[existing]
+            for i in idxs:
+                if (df.at[i, "model_name"] or "") != model_name:
+                    df.at[i, "model_name"] = model_name
+            continue
+
+        category, dataset = "", ""
+        if manifest is not None:
+            mk = _stem_for_match(p)
+            hit = manifest[manifest["__match_key"].str.contains(mk, na=False)]
+            if not hit.empty:
+                if "audio_category" in hit.columns:
+                    category = str(hit.iloc[0]["audio_category"])
+                if "dataset" in hit.columns:
+                    dataset = str(hit.iloc[0]["dataset"])
+
+        uid = uuid.uuid4().hex[:8]
+        new_rows.append({
+            "id": uid,
+            "filename": p.name,
+            "path": str(p),     # keep absolute path; no copying
+            "tags": "",
+            "keywords": "",
+            "notes": "",
+            "uploaded_at": now,
+            "model_name": model_name,
+            "category": category,
+            "dataset": dataset
+        })
+
+    if new_rows:
+        df = pd.concat([df, pd.DataFrame(new_rows)], ignore_index=True)
+
+    _save_db(df)
+    # show refreshed view scoped to this model
+    return refresh_view("", [], "", "", model_name)
+
+# ---------- Search / filters ----------
+def refresh_view(query, tag_filters, category_filter, dataset_filter, model_filter):
+    df = _load_db()
+
+    # tag vocabulary
+    all_tags = sorted({t.strip()
+                       for s in df["tags"].dropna().astype(str).tolist()
+                       for t in s.split(",") if t.strip()})
+    all_cats   = sorted([c for c in df["category"].dropna().astype(str).unique() if c])
+    all_sets   = sorted([c for c in df["dataset"].dropna().astype(str).unique() if c])
+    all_models = sorted([c for c in df["model_name"].dropna().astype(str).unique() if c])
+
+    # free-text query across filename/tags/keywords/notes/category/dataset/model
+    if query:
+        q = query.lower()
+        mask = (
+            df["filename"].str.lower().str.contains(q, na=False) |
+            df["tags"].str.lower().str.contains(q, na=False) |
+            df["keywords"].str.lower().str.contains(q, na=False) |
+            df["notes"].str.lower().str.contains(q, na=False) |
+            df["category"].str.lower().str.contains(q, na=False) |
+            df["dataset"].str.lower().str.contains(q, na=False) |
+            df["model_name"].str.lower().str.contains(q, na=False)
+        )
+        df = df[mask]
+
+    # tag filters (AND semantics)
+    for t in (tag_filters or []):
+        df = df[df["tags"].astype(str).apply(
+            lambda s: t in [x.strip() for x in s.split(",") if x.strip()])]
+
+    # dropdown filters (exact match)
+    if category_filter:
+        df = df[df["category"] == category_filter]
+    if dataset_filter:
+        df = df[df["dataset"] == dataset_filter]
+    if model_filter:
+        df = df[df["model_name"] == model_filter]
+
+    df = df.sort_values("uploaded_at", ascending=False).reset_index(drop=True)
+    view = df[TABLE_COLS].copy()
+    count_text = f"**Showing {len(view)} file(s)**"
+
+    return (
+        view,
+        gr.update(choices=all_tags),
+        gr.update(choices=[""] + all_cats,   value=category_filter or ""),
+        gr.update(choices=[""] + all_sets,   value=dataset_filter or ""),
+        gr.update(choices=[""] + all_models, value=model_filter or ""),
+        count_text
+    )
+
+# ---------- Preview ----------
+def _iframe_from_html_string(raw_html: str, height_px: int = 720) -> str:
+    srcdoc = raw_html.replace("&", "&").replace('"', """)
+    return f'<iframe style="width:100%;height:{height_px}px;border:1px solid #ddd;border-radius:8px;" srcdoc="{srcdoc}"></iframe>'
+
+def select_row(evt: gr.SelectData, table_value):
+    try:
+        view = _df_from_table_value(table_value)
+        if view.empty:
+            return "<em>No rows.</em>", ""
+        # resolve row
+        row_idx = None
+        ix = getattr(evt, "index", None)
+        if isinstance(ix, int):
+            row_idx = ix
+        elif isinstance(ix, (list, tuple)) and ix and isinstance(ix[0], int):
+            row_idx = ix[0]
+        if row_idx is None:
+            val = getattr(evt, "value", None)
+            if isinstance(val, dict) and "id" in val:
+                hits = view.index[view["id"] == val["id"]].tolist()
+                if hits: row_idx = hits[0]
+            elif isinstance(val, list) and len(val) >= 1:
+                hits = view.index[view["id"] == val[0]].tolist()
+                if hits: row_idx = hits[0]
+        if row_idx is None or not (0 <= row_idx < len(view)):
+            return "<em>Invalid selection.</em>", ""
+
+        row = view.iloc[row_idx]
+        sel_id = row["id"]
+
+        db = _load_db()
+        rec = db[db["id"] == sel_id]
+        if rec.empty:
+            return "<em>Could not find file for this row.</em>", ""
+
+        path = rec["path"].values[0]
+        if not os.path.exists(path):
+            return f"<em>File not found:</em> <code>{_py_html.escape(path)}</code>", f"📄 {row['filename']}"
+
+        with open(path, "r", encoding="utf-8") as f:
+            raw_html = f.read()
+
+        iframe = _iframe_from_html_string(raw_html, height_px=720)
+        return iframe, f"📄 {row['filename']}"
+    except Exception as e:
+        traceback.print_exc()
+        return f"<pre>Failed to render (see terminal):\n{_py_html.escape(str(e))}</pre>", ""
+
+# ---------- Save edits ----------
+def save_edits(edited_table):
+    if edited_table is None or not len(edited_table):
+        return gr.Info("Nothing to save.")
+    df_db = _load_db()
+    editable_cols = ["model_name","category","dataset","tags","keywords","notes"]
+    for c in editable_cols:
+        edited_table[c] = edited_table[c].fillna("").astype(str)
+    for _, row in edited_table.iterrows():
+        i = df_db.index[df_db["id"] == row["id"]]
+        if len(i):
+            for c in editable_cols:
+                df_db.at[i[0], c] = row[c]
+    _save_db(df_db)
+    # return refreshed table only
+    return refresh_view("", [], "", "", "")[0]
+
+# -------------------- UI --------------------
+# CSS that targets only the three buttons via elem_id
+custom_css = """
+/* scope styles to only these 3 components */
+#sync-btn button,
+#refresh-btn button,
+#save-btn button,
+#sync-btn .gr-button,
+#refresh-btn .gr-button,
+#save-btn .gr-button,
+#sync-btn [role="button"],
+#refresh-btn [role="button"],
+#save-btn [role="button"] {
+  background: #f97316 !important;   /* orange-500 */
+  border-color: #f97316 !important;
+  color: #fff !important;
+}
+
+/* hover/active */
+#sync-btn button:hover,
+#refresh-btn button:hover,
+#save-btn button:hover,
+#sync-btn .gr-button:hover,
+#refresh-btn .gr-button:hover,
+#save-btn .gr-button:hover,
+#sync-btn [role="button"]:hover,
+#refresh-btn [role="button"]:hover,
+#save-btn [role="button"]:hover {
+  background: #ea580c !important;   /* orange-600 */
+  border-color: #ea580c !important;
+}
+
+/* (optional) also set CSS vars in case theme uses them */
+#sync-btn, #refresh-btn, #save-btn {
+  --button-primary-background-fill: #f97316;
+  --button-primary-background-fill-hover: #ea580c;
+  --button-text-color: #fff;
+}
+"""
+
+
+with gr.Blocks(title="Audio HTML Library", css=custom_css) as demo:
+    gr.Markdown("## 🎧 Audio Reconstruction Reports — sync • search • view")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            # Choose model & sync
+            gr.Markdown(f"**Model folder:** `{REPORTS_ROOT}/model_name`")
+            model_in = gr.Textbox(label="Model name", placeholder="e.g., WavCochV8192")
+            sync_btn = gr.Button("Sync this model", elem_id="sync-btn")  # ⬅️ give id
+
+            # Search & filters
+            gr.Markdown("---\n**Search & filter**")
+            query = gr.Textbox(label="Keyword search (filename/tags/notes/category/dataset/model)", placeholder="type to search…")
+            tag_filter = gr.CheckboxGroup(choices=[], label="Filter by tags (AND)")
+            category_filter = gr.Dropdown(choices=[], label="Category")
+            dataset_filter  = gr.Dropdown(choices=[], label="Dataset")
+            model_filter    = gr.Dropdown(choices=[], label="Model")
+            refresh_btn = gr.Button("Refresh", elem_id="refresh-btn")     # ⬅️ give id
+
+        with gr.Column(scale=2):
+            # Count of current view
+            count_md = gr.Markdown("**Showing 0 file(s)**")
+            gr.Markdown("**Library** (click a row to preview; edit cells and Save)")
+            table = gr.Dataframe(
+                headers=TABLE_COLS,
+                datatype=["str"] * len(TABLE_COLS),
+                interactive=True,
+                wrap=True,
+                row_count=(0, "dynamic"),
+                col_count=(len(TABLE_COLS), "fixed")
+            )
+            with gr.Row():
+                save_btn = gr.Button("Save Edits", elem_id="save-btn")     # ⬅️ give id
+            preview_label = gr.Markdown("")
+            preview_html = gr.HTML("")
+
+    # wiring: sync
+    sync_btn.click(sync_model, [model_in],
+                   [table, tag_filter, category_filter, dataset_filter, model_filter, count_md])
+
+    # wiring: refresh + live filters
+    refresh_btn.click(refresh_view,
+                      [query, tag_filter, category_filter, dataset_filter, model_filter],
+                      [table, tag_filter, category_filter, dataset_filter, model_filter, count_md])
+
+    for comp in (query, tag_filter, category_filter, dataset_filter, model_filter):
+        comp.change(refresh_view,
+                    [query, tag_filter, category_filter, dataset_filter, model_filter],
+                    [table, tag_filter, category_filter, dataset_filter, model_filter, count_md])
+
+    table.select(select_row, [table], [preview_html, preview_label])
+    save_btn.click(save_edits, [table], [table])
+
+    # initial load
+    demo.load(refresh_view,
+              [query, tag_filter, category_filter, dataset_filter, model_filter],
+              [table, tag_filter, category_filter, dataset_filter, model_filter, count_md])
+
+if __name__ == "__main__":
+    demo.launch(share=True)  # auth is optional but recommended

requirements.py

@@ -0,0 +1,2 @@
+gradio
+pandas