Add counter, CSV logging, secret-gated ZIP download

README.md

@@ -1,30 +1,65 @@
----
-title: Spell Recorder
-emoji: ✨
-colorFrom: indigo
-colorTo: purple
-colorBottom: purple
-sdk: gradio
-app_file: app.py
-pinned: false
-license: mit
-short_description: Collect microphone recordings for six spells
----
+# Spell Recorder (Gradio)
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Collect microphone recordings for a small set of Harry Potter spells and save them to disk for training a classifier.
 
-## Persistence of Recordings
+Spells collected:
+- Lumos
+- Nox
+- Alohomora
+- Wingardium Leviosa
+- Accio
+- Reparo
 
-Recordings created via the UI are written at runtime into the `recordings/` folder inside the Space container. In addition, this app uploads each saved WAV file to MongoDB using GridFS (if configured).
+## How it works
+- Enter a username (used in filenames; sanitized to safe characters).
+- Record with your microphone (preferred) or upload an audio file for any spell.
+- Click Submit.
+- The app will save any provided recordings to `recordings/` as 16 kHz mono WAVs named: `<spell>_<username>_<timestamp>.wav`.
+- A live counter shows how many spells are selected (recorded/uploaded) before submitting.
+- A CSV log is written to `recordings/log.csv` with columns: `timestamp_ms, session_id, username, spell, filename`.
+- You can prepare a ZIP of this session's saved files if you enter the correct download key.
 
-### MongoDB configuration
+## Run locally
 
-Set the following Space secrets:
-- `MONGO_URI`: your MongoDB connection string (supports `mongodb+srv://`)
-- `MONGO_DB` (optional): database name, default `spells`
-- `GRIDFS_BUCKET` (optional): GridFS bucket prefix, default `fs`
+Requirements (see `requirements.txt`):
+- gradio
+- numpy
+- soundfile
+- scipy
 
-On submit, each provided spell is saved locally and uploaded to your Mongo database with metadata: `spell`, `username`, `timestamp`, and original `filename`.
+On Windows PowerShell:
 
-If Mongo is not configured, files are still saved locally under `recordings/`.
+```powershell
+python -m venv .venv
+.\.venv\Scripts\Activate.ps1
+pip install -r requirements.txt
+python app.py
+```
 
+Then open the printed local URL in your browser.
+
+## Deploy on Hugging Face Spaces
+1. Create a new Space (Gradio) in your account.
+2. Upload `app.py`, `requirements.txt`, and optionally `README.md`.
+3. Spaces will auto-build and run the app.
+4. Recordings will be saved inside the Space's `recordings/` directory. You can download them from the Space files tab or via `git lfs` if you commit them.
+
+Notes:
+- Microphone recording is enabled in the browser; no need to upload.
+- If you need more durable storage or collaboration, consider pushing saved WAVs to a dataset repo programmatically.
+
+### Enable password-protected ZIP download
+
+Set a Space secret so only people with the key can generate a ZIP of their session files:
+
+- Go to your Space → Settings → Variables and secrets
+- Add a secret named `ZIP_DOWNLOAD_KEY` with your chosen value
+- In the app UI, paste that key into the "Download Key" field before clicking "Prepare ZIP"
+
+## Privacy and consent
+- Only collect voices from people who consent to being recorded.
+- Consider informing contributors how their audio will be used and stored.
+- Do not collect sensitive information in the username.
+
+## Why 16 kHz mono?
+Standardizing sample rate and channels simplifies downstream model training and reduces storage.

app.py

@@ -1,19 +1,23 @@
 import os
-import json
 import re
 import time
 import math
-from typing import List, Tuple, Optional, Sequence
+import csv
+import uuid
+import zipfile
+from typing import List, Tuple, Optional
+
 import numpy as np
 import gradio as gr
 import soundfile as sf
 from scipy.signal import resample_poly
-from pymongo import MongoClient
-import gridfs
 
 # Output directory for saved recordings
 OUT_DIR = "recordings"
 os.makedirs(OUT_DIR, exist_ok=True)
+ZIP_DIR = os.path.join(OUT_DIR, "zips")
+os.makedirs(ZIP_DIR, exist_ok=True)
+LOG_CSV = os.path.join(OUT_DIR, "log.csv")
 
 # Fixed target sample rate for ML training
 TARGET_SR = 16000
@@ -61,9 +65,23 @@ def resample_to_target(audio: np.ndarray, sr: int, target_sr: int = TARGET_SR) -
     return resample_poly(audio, up=up, down=down)
 
 
-def save_one_from_path(filepath: Optional[str], spell: str, username: str) -> Optional[str]:
+def ensure_log_header():
+    if not os.path.exists(LOG_CSV):
+        with open(LOG_CSV, mode="w", newline="", encoding="utf-8") as f:
+            writer = csv.writer(f)
+            writer.writerow(["timestamp_ms", "session_id", "username", "spell", "filename"])  # header
+
+
+def log_row(timestamp_ms: int, session_id: str, username: str, spell: str, filename: str) -> None:
+    ensure_log_header()
+    with open(LOG_CSV, mode="a", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f)
+        writer.writerow([timestamp_ms, session_id, username, spell, filename])
+
+
+def save_one_from_path(filepath: Optional[str], spell: str, username: str) -> Optional[Tuple[str, int]]:
     """Load an audio file path (from mic/upload), process to 16k mono, and save.
-    Returns saved file path or None if no audio provided.
+    Returns (saved file path, timestamp_ms) or None if no audio provided.
     """
     if not filepath:
         return None
@@ -83,82 +101,7 @@ def save_one_from_path(filepath: Optional[str], spell: str, username: str) -> Op
     out_path = os.path.join(OUT_DIR, fname)
 
     sf.write(out_path, audio, TARGET_SR, subtype="PCM_16")
-    return out_path
-
-
-def _parse_meta_from_filename(basename: str) -> Tuple[str, str, Optional[int]]:
-    """Parse (spell_slug, username, timestamp) from `<spell_slug>_<username>_<ts>.wav`."""
-    name = basename
-    if name.endswith(".wav"):
-        name = name[:-4]
-    parts = name.split("_")
-    if len(parts) < 3:
-        return name, "", None
-    try:
-        ts = int(parts[-1])
-    except Exception:
-        ts = None
-    username = parts[-2]
-    spell_slug = "_".join(parts[:-2])
-    return spell_slug, username, ts
-
-
-def upload_recordings_to_mongo(paths: Sequence[str]) -> Tuple[int, Optional[str]]:
-    """Upload files to MongoDB using GridFS.
-
-    Env configuration:
-    - MONGO_URI: connection string (e.g., mongodb+srv://user:pass@cluster/)
-    - MONGO_DB: database name (default: spells)
-    - GRIDFS_BUCKET: GridFS bucket prefix (default: fs)
-    Returns (uploaded_count, error_message).
-    """
-    if not paths:
-        return 0, None
-    if not (MongoClient and gridfs):
-        return 0, "pymongo/gridfs not installed."
-    uri = os.getenv("MONGO_URI")
-    if not uri:
-        return 0, "Missing MONGO_URI."
-    db_name = os.getenv("MONGO_DB", "spells")
-    bucket = os.getenv("GRIDFS_BUCKET", "fs")
-
-    try:
-        client = MongoClient(uri, serverSelectionTimeoutMS=5000)
-        # quick connectivity check
-        client.admin.command("ping")
-        db = client[db_name]
-        fs = gridfs.GridFS(db, collection=bucket)
-    except Exception as e:
-        return 0, f"Mongo connect error: {e}"
-
-    uploaded = 0
-    try:
-        for p in paths:
-            if not os.path.isfile(p):
-                continue
-            base = os.path.basename(p)
-            spell_slug, username, ts = _parse_meta_from_filename(base)
-            with open(p, "rb") as f:
-                fs.put(
-                    f.read(),
-                    filename=base,
-                    contentType="audio/wav",
-                    metadata={
-                        "spell": spell_slug,
-                        "username": username,
-                        "timestamp": ts,
-                        "path": p,
-                    },
-                )
-            uploaded += 1
-    except Exception as e:
-        return uploaded, f"Mongo upload error: {e}"
-    finally:
-        try:
-            client.close()
-        except Exception:
-            pass
-    return uploaded, None
+    return out_path, ts
 
 
 def submit_recordings(
@@ -169,7 +112,9 @@ def submit_recordings(
     wingardium_path: Optional[str],
     accio_path: Optional[str],
     reparo_path: Optional[str],
-) -> str:
+    session_id: str,
+    session_files: List[str],
+) -> Tuple[str, List[str], int]:
     user = sanitize_username(username)
 
     pairs: List[Tuple[str, Optional[str]]] = [
@@ -182,41 +127,83 @@ def submit_recordings(
     ]
 
     saved = []
-    saved_paths: List[str] = []
     skipped = []
+    newly_saved_paths: List[str] = []
+
     for spell, path in pairs:
         out = save_one_from_path(path, spell, user)
         if out:
-            saved.append(f"{spell} -> {os.path.basename(out)}")
-            saved_paths.append(out)
+            out_path, ts = out
+            saved.append(f"{spell} -> {os.path.basename(out_path)}")
+            newly_saved_paths.append(out_path)
+            # CSV log
+            log_row(ts, session_id, user, spell, os.path.basename(out_path))
         else:
             skipped.append(spell)
 
-    lines: List[str] = []
+    lines = []
     if saved:
-        lines.append("Saved recordings (local runtime):")
+        lines.append("Saved recordings:")
         lines += [f"- {s}" for s in saved]
     if skipped:
         lines.append("")
         lines.append("Missing (not provided):")
         lines += [f"- {s}" for s in skipped]
     if not lines:
-        return "No audio captured. Please record at least one spell."
+        return "No audio captured. Please record at least one spell.", session_files, 0
+
+    # Update session files list
+    session_files = list(session_files or []) + newly_saved_paths
+    return "\n".join(lines), session_files, len(newly_saved_paths)
+
+
+def count_selected(
+    lumos_path: Optional[str],
+    nox_path: Optional[str],
+    alohomora_path: Optional[str],
+    wingardium_path: Optional[str],
+    accio_path: Optional[str],
+    reparo_path: Optional[str],
+) -> str:
+    paths = [lumos_path, nox_path, alohomora_path, wingardium_path, accio_path, reparo_path]
+    n = sum(1 for p in paths if p)
+    return f"Selected: {n}/6"
+
+
+def prepare_zip(download_key: str, session_files: List[str]) -> Tuple[Optional[str], str]:
+    expected = os.getenv("ZIP_DOWNLOAD_KEY", "")
+    if not expected:
+        return None, "Download disabled: ZIP_DOWNLOAD_KEY not set in environment."
+    if (download_key or "").strip() != expected:
+        return None, "Invalid key. Please enter the correct download key."
+    files = [p for p in (session_files or []) if p and os.path.exists(p)]
+    if not files:
+        return None, "No files in this session to zip. Submit recordings first."
+
+    session_id = uuid.uuid4().hex[:8]
+    ts = int(time.time() * 1000)
+    zip_path = os.path.join(ZIP_DIR, f"submissions_{session_id}_{ts}.zip")
+    with zipfile.ZipFile(zip_path, mode="w", compression=zipfile.ZIP_DEFLATED) as zf:
+        for f in files:
+            zf.write(f, arcname=os.path.basename(f))
+    return zip_path, f"Prepared ZIP with {len(files)} files."
 
-    mup, merr = upload_recordings_to_mongo(saved_paths)
-    lines.append("")
-    if merr:
-        lines.append(f"Mongo upload attempted: {mup} succeeded, error: {merr}")
-    else:
-        lines.append(f"Mongo upload: {mup} file(s) stored in GridFS.")
 
-    return "\n".join(lines)
 def build_ui() -> gr.Blocks:
     with gr.Blocks(title="Spell Recorder") as demo:
-        gr.Markdown("""# Spell Recorder\nRecord any of the listed spells and press Submit. You can use your microphone directly (preferred) or upload a file.\n\nSpells to collect: Lumos, Nox, Alohomora, Wingardium Leviosa, Accio, Reparo.""")
+        gr.Markdown("""
+        # Spell Recorder
+        Record any of the listed spells and press Submit. You can use your microphone directly (preferred) or upload a file.
+
+        Spells to collect: Lumos, Nox, Alohomora, Wingardium Leviosa, Accio, Reparo.
+        """)
+
+        # Per-session state
+        session_id = gr.State(uuid.uuid4().hex)
+        session_files = gr.State([])  # paths saved during this session
 
         with gr.Row():
-            username = gr.Textbox(label="Your Name (for filename)", placeholder="e.g., harry_p", autofocus=True)
+            username = gr.Textbox(label="Your Name (for filename)", placeholder="e.g., harry_p" , autofocus=True)
 
         with gr.Row():
             with gr.Column():
@@ -228,16 +215,50 @@ def build_ui() -> gr.Blocks:
                 accio = gr.Audio(label="Accio", sources=["microphone", "upload"], type="filepath")
                 reparo = gr.Audio(label="Reparo", sources=["microphone", "upload"], type="filepath")
 
+        with gr.Row():
+            selected_counter = gr.Markdown(value="Selected: 0/6")
+
         submit = gr.Button("Submit")
         result = gr.Markdown()
+        submitted_count = gr.Number(label="New files saved this submit", value=0)
+
+        # Download section (password-gated)
+        with gr.Row():
+            download_key = gr.Textbox(label="Download Key", type="password", placeholder="Enter key to enable ZIP download")
+        with gr.Row():
+            zip_btn = gr.Button("Prepare ZIP of my session files")
+            zip_file = gr.File(label="Download ZIP", interactive=False)
+        zip_status = gr.Markdown()
 
         submit.click(
             fn=submit_recordings,
-            inputs=[username, lumos, nox, alohomora, wingardium, accio, reparo],
-            outputs=[result],
+            inputs=[username, lumos, nox, alohomora, wingardium, accio, reparo, session_id, session_files],
+            outputs=[result, session_files, submitted_count],
+        )
+
+        # Live counter updates when any audio input changes
+        for comp in [lumos, nox, alohomora, wingardium, accio, reparo]:
+            comp.change(
+                fn=count_selected,
+                inputs=[lumos, nox, alohomora, wingardium, accio, reparo],
+                outputs=[selected_counter],
+            )
+
+        # Prepare ZIP on demand (password protected)
+        zip_btn.click(
+            fn=prepare_zip,
+            inputs=[download_key, session_files],
+            outputs=[zip_file, zip_status],
         )
 
-        gr.Markdown("""Notes:\n- Files are saved locally in `recordings/` with `<spell>_<username>_<timestamp>.wav`.\n- Files are also uploaded to MongoDB (GridFS) automatically if MONGO_URI is configured.\n- 16 kHz mono WAV ensures consistent model training.\n- You can submit partial sets; only provided spells are saved.""")
+        gr.Markdown("""
+        Notes:
+        - Files are saved in the app's `recordings/` folder using: `<spell>_<username>_<timestamp>.wav`.
+        - 16 kHz mono WAV is used to make model training consistent.
+        - You don't have to record all spells at once—submit whatever you have.
+        - A CSV log is kept at `recordings/log.csv` with username, spell, timestamp, filename.
+        - To enable ZIP download, set the secret env var `ZIP_DOWNLOAD_KEY` in your Space Settings → Variables & secrets.
+        """)
 
     return demo