Update app.py

app.py

@@ -4,40 +4,23 @@ import os
 import pathlib
 import shutil
 import subprocess
-import sys
 from typing import List, Tuple
 
 import gradio as gr
 
-
-def pick_data_root() -> pathlib.Path:
-    # Prefer /data if it exists & is writable; otherwise fall back to /tmp/aot
-    candidates = [pathlib.Path("/data"), pathlib.Path("/tmp/aot")]
-    for p in candidates:
-        try:
-            p.mkdir(parents=True, exist_ok=True)
-            test = p / ".write_test"
-            test.write_text("ok", encoding="utf-8")
-            test.unlink()
-            return p
-        except Exception:
-            continue
-    return pathlib.Path("/tmp/aot")
-
-
-DATA_ROOT = pathlib.Path(os.environ.get("DATA_ROOT", str(pick_data_root())))
+DATA_ROOT = pathlib.Path(os.environ.get("DATA_ROOT", "/tmp/aot"))
 INCOMING_DIR = DATA_ROOT / "incoming_videos"
 STANDARDIZED_DIR = DATA_ROOT / "standardized_videos"
-RUNS_DIR = DATA_ROOT / "dataset" / "runs"
+RUNS_DIR = DATA_ROOT / "runs"
 
 
 def ensure_dirs() -> None:
-    for d in (INCOMING_DIR, STANDARDIZED_DIR, RUNS_DIR):
-        d.mkdir(parents=True, exist_ok=True)
+    for directory in (INCOMING_DIR, STANDARDIZED_DIR, RUNS_DIR):
+        directory.mkdir(parents=True, exist_ok=True)
 
 
 def save_uploads(files: List[str]) -> List[pathlib.Path]:
-    saved: List[pathlib.Path] = []
+    saved = []
     for fp in files:
         src = pathlib.Path(fp)
         dst = INCOMING_DIR / src.name
@@ -75,41 +58,32 @@ def standardize_video(input_path: pathlib.Path) -> Tuple[pathlib.Path, str]:
         str(output_path),
     ]
     p = subprocess.run(cmd, capture_output=True, text=True)
-    log = (p.stdout or "") + ("\n" if p.stdout else "") + (p.stderr or "")
+    log = (p.stdout or "") + "\n" + (p.stderr or "")
     if p.returncode != 0:
         raise RuntimeError(f"ffmpeg failed for {input_path.name}\n{log}")
     return output_path, log
 
 
-def run_avocado(input_path: pathlib.Path, output_path: pathlib.Path) -> Tuple[dict, str]:
-    """
-    Runs AVoCaDO analysis via avocado_infer.py.
-    This is NON-OPTIONAL: if it fails, the whole run fails.
-    """
+def run_avocado(standardized_video: pathlib.Path, output_json: pathlib.Path) -> Tuple[dict, str]:
     cmd = [
-        sys.executable,
+        "python",
         "avocado_infer.py",
         "--input",
-        str(input_path),
+        str(standardized_video),
         "--output",
-        str(output_path),
+        str(output_json),
     ]
     p = subprocess.run(cmd, capture_output=True, text=True)
-    log = (p.stdout or "") + ("\n" if p.stdout else "") + (p.stderr or "")
+    log = (p.stdout or "") + "\n" + (p.stderr or "")
 
-    output_text = ""
-    if output_path.exists():
-        output_text = output_path.read_text(encoding="utf-8")
+    if p.returncode != 0:
+        return {"success": False, "returncode": p.returncode, "stdout": p.stdout, "stderr": p.stderr}, log
 
-    result = {
-        "success": p.returncode == 0,
-        "returncode": p.returncode,
-        "stdout": p.stdout,
-        "stderr": p.stderr,
-        "output_file": str(output_path),
-        "output_json": output_text,
-    }
-    return result, log
+    payload = {}
+    if output_json.exists():
+        payload = json.loads(output_json.read_text(encoding="utf-8"))
+
+    return {"success": True, "returncode": 0, "output_path": str(output_json), "payload": payload}, log
 
 
 def write_jsonl(path: pathlib.Path, rows: List[dict]) -> None:
@@ -127,68 +101,60 @@ def process_videos(files: List[str], include_std_videos: bool) -> Tuple[str, Lis
     run_dir = RUNS_DIR / run_label
     run_dir.mkdir(parents=True, exist_ok=True)
 
-    logs: List[str] = []
-    records: List[dict] = []
+    logs = []
+    records = []
 
+    saved_paths = save_uploads(files)
     logs.append(f"Run label: {run_label}")
-    logs.append(f"DATA_ROOT: {DATA_ROOT}")
     logs.append(f"Run dir: {run_dir}")
 
-    saved_paths = save_uploads(files)
-
     for i, input_path in enumerate(saved_paths, start=1):
         logs.append(f"\n=== [{i}/{len(saved_paths)}] {input_path.name} ===")
 
         standardized_path, ffmpeg_log = standardize_video(input_path)
         logs.append("[ffmpeg]\n" + ffmpeg_log.strip())
 
-        avocado_output_path = run_dir / f"{standardized_path.stem}_avocado.json"
-        avocado_result, avocado_log = run_avocado(standardized_path, avocado_output_path)
-
-        logs.append("[avocado]\n" + avocado_log.strip())
-
-        if not avocado_result["success"]:
-            # AVoCaDO is the whole point: fail hard.
-            raise RuntimeError(
-                f"AVoCaDO failed for {standardized_path.name}\n\n{avocado_result['stderr']}"
-            )
-
-        record = {
-            "run_label": run_label,
-            "source_file": str(input_path),
-            "standardized_file": str(standardized_path),
-            "avocado_output_file": str(avocado_output_path),
-            "avocado": {
-                "success": avocado_result["success"],
-                "returncode": avocado_result["returncode"],
-                "stdout": avocado_result["stdout"],
-                "stderr": avocado_result["stderr"],
-            },
-            "processed_at": datetime.datetime.utcnow().isoformat() + "Z",
-        }
-        records.append(record)
+        avocado_out = run_dir / f"{standardized_path.stem}_avocado.json"
+        avo_result, avo_log = run_avocado(standardized_path, avocado_out)
+        logs.append("[avocado]\n" + avo_log.strip())
+
+        # AVoCaDO is the entire point: fail hard if it fails.
+        if not avo_result["success"]:
+            raise RuntimeError(f"AVoCaDO failed for {standardized_path.name}:\n{avo_result.get('stderr','')}")
 
         if include_std_videos:
             shutil.copy2(standardized_path, run_dir / standardized_path.name)
 
+        records.append(
+            {
+                "run_label": run_label,
+                "source_file": str(input_path),
+                "standardized_file": str(standardized_path),
+                "avocado_output_file": str(avocado_out),
+                "avocado": avo_result,
+                "processed_at": datetime.datetime.utcnow().isoformat() + "Z",
+            }
+        )
+
     annotations_path = run_dir / "annotations.jsonl"
     write_jsonl(annotations_path, records)
 
     manifest_path = run_dir / "manifest.json"
-    manifest_payload = {
-        "run_label": run_label,
-        "created_at": datetime.datetime.utcnow().isoformat() + "Z",
-        "count": len(records),
-        "records": records,
-    }
     manifest_path.write_text(
-        json.dumps(manifest_payload, ensure_ascii=False, indent=2),
+        json.dumps(
+            {
+                "run_label": run_label,
+                "created_at": datetime.datetime.utcnow().isoformat() + "Z",
+                "count": len(records),
+                "records": records,
+            },
+            ensure_ascii=False,
+            indent=2,
+        ),
         encoding="utf-8",
     )
 
-    # Zip the entire run folder (includes per-video *_avocado.json files)
-    zip_base = str(run_dir)  # make_archive wants "path without extension"
-    zip_path = shutil.make_archive(zip_base, "zip", root_dir=run_dir)
+    zip_path = shutil.make_archive(str(run_dir), "zip", root_dir=run_dir)
 
     status = (
         "Processing complete.\n"
@@ -197,12 +163,7 @@ def process_videos(files: List[str], include_std_videos: bool) -> Tuple[str, Lis
         f"Manifest: {manifest_path}\n"
         f"Run zip: {zip_path}"
     )
-
-    downloads = [
-        str(annotations_path),
-        str(manifest_path),
-        str(zip_path),
-    ]
+    downloads = [str(annotations_path), str(manifest_path), str(zip_path)]
     return status, downloads, "\n".join(logs)
 
 
@@ -210,35 +171,28 @@ def build_app() -> gr.Blocks:
     with gr.Blocks() as demo:
         gr.Markdown(
             "# Avocado On Toast\n"
-            "Upload videos → standardize with ffmpeg → **run AVoCaDO** → download outputs."
+            "Upload → standardize → **run AVoCaDO (audio+visual)** → download results."
         )
 
-        files = gr.File(label="Upload videos", file_count="multiple", type="filepath")
-
-        include_std_videos = gr.Checkbox(
-            label="Include standardized videos inside the run .zip (bigger downloads)",
-            value=False,
-        )
+        with gr.Row():
+            files = gr.File(label="Upload videos", file_count="multiple", type="filepath")
+            include_std_videos = gr.Checkbox(label="Include standardized videos in zip", value=False)
 
         run_button = gr.Button("Process videos")
-
         status = gr.Textbox(label="Status", lines=6)
         downloads = gr.File(label="Downloads", file_count="multiple")
-        logs = gr.Textbox(label="Logs (ffmpeg + AVoCaDO)", lines=22)
+        logs = gr.Textbox(label="Logs", lines=20)
 
-        run_button.click(
-            process_videos,
-            inputs=[files, include_std_videos],
-            outputs=[status, downloads, logs],
-        )
+        run_button.click(process_videos, inputs=[files, include_std_videos], outputs=[status, downloads, logs])
 
         gr.Markdown(
-            "Note: The Space **Files** tab shows the git repo only. "
-            "Runtime outputs live under `/tmp/...` or `/data/...`, so you access them via the downloads above."
+            "The Space **Files** tab is your git repo. Runtime outputs are created under `/tmp/...` "
+            "and are surfaced here via the download widgets."
         )
 
     return demo
 
 
 if __name__ == "__main__":
-    build_app().launch(show_error=True)
+    app = build_app()
+    app.launch(show_error=True)