chore: simplify to MongoDB-only uploads; remove Hub/Drive and checkboxes; docs+deps updated

README.md

@@ -15,49 +15,16 @@ Check out the configuration reference at https://huggingface.co/docs/hub/spaces-
 
 ## Persistence of Recordings
 
-Recordings created via the UI are written at runtime into the `recordings/` folder inside the Space container. These files are NOT automatically versioned or shown in the repository file browser. To make them visible in the repo you must either:
+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).
 
-1. Commit them manually (e.g., pull the Space locally, copy files, `git add recordings/*.wav`, push).
-2. Or enable automatic upload using a Hugging Face token.
+### MongoDB configuration
 
-### Automatic Upload (Recommended)
-
-Set a secret named `HF_TOKEN` in the Space settings (must have write access). Optionally set:
-
-- `HF_UPLOAD_REPO` target repo id (recommended: a dataset like `username/spell-recordings`).
-- `HF_UPLOAD_REPO_TYPE` one of `dataset` (default), `space`, or `model`.
-
-If `HF_UPLOAD_REPO` is omitted the current Space id is used (uploading into the Space repo when `HF_UPLOAD_REPO_TYPE=space`).
-
-Then check the "Upload to Hub" box before submitting. Each saved `.wav` file will be committed via the Hub API with a message like `Add recordings <timestamp>`.
-
-Uploads may take a few seconds. Large batches could hit rate limits; keep per-submit sizes modest.
-
-### Why You Don't See Runtime Files
-
-The repository view shows only Git-tracked content. Runtime-generated files live only in the ephemeral container filesystem until the Space restarts. Upload or commit them if you need persistence.
-
-## Google Drive Upload (Alternative)
-
-If you prefer uploading to Google Drive:
-
-1. Create a Google Cloud service account with Drive API enabled and grant it access to a Drive folder.
-2. Put the service account JSON in a Space secret named `GDRIVE_SERVICE_ACCOUNT_JSON`. You can paste the JSON string or mount a path and store the path in the secret.
-3. Add another secret `GDRIVE_FOLDER_ID` with the target folder ID.
-4. In the app UI, tick "Upload to Google Drive" before Submit.
-
-The app uses `google-api-python-client` to upload each WAV file into that folder. Errors will be shown in the results area if credentials or permissions are incorrect.
-
-## MongoDB Upload (Alternative)
-
-You can also upload recordings to MongoDB using GridFS.
-
-Secrets to configure in your Space:
+Set the following Space secrets:
 - `MONGO_URI`: your MongoDB connection string (supports `mongodb+srv://`)
-- `MONGO_DB`: database name (default: `spells`)
-- `GRIDFS_BUCKET`: GridFS bucket prefix (default: `fs`)
+- `MONGO_DB` (optional): database name, default `spells`
+- `GRIDFS_BUCKET` (optional): GridFS bucket prefix, default `fs`
 
-Then in the UI, tick "Upload to MongoDB (GridFS)" before Submit.
+On submit, each provided spell is saved locally and uploaded to your Mongo database with metadata: `spell`, `username`, `timestamp`, and original `filename`.
 
-Each file is stored in GridFS with metadata: `spell`, `username`, `timestamp`, and original `filename`.
+If Mongo is not configured, files are still saved locally under `recordings/`.
 

app.py

@@ -4,34 +4,12 @@ import re
 import time
 import math
 from typing import List, Tuple, Optional, Sequence
-
 import numpy as np
 import gradio as gr
 import soundfile as sf
 from scipy.signal import resample_poly
-try:
-    from huggingface_hub import HfApi, HfFolder
-except Exception:  # package might be missing in some local runs
-    HfApi = None
-    HfFolder = None
-
-# Google Drive API (service account) optional imports
-try:
-    from google.oauth2 import service_account
-    from googleapiclient.discovery import build
-    from googleapiclient.http import MediaFileUpload
-except Exception:
-    service_account = None
-    build = None
-    MediaFileUpload = None
-
-# MongoDB (GridFS) optional imports
-try:
-    from pymongo import MongoClient
-    import gridfs
-except Exception:
-    MongoClient = None
-    gridfs = None
+from pymongo import MongoClient
+import gridfs
 
 # Output directory for saved recordings
 OUT_DIR = "recordings"
@@ -108,118 +86,8 @@ def save_one_from_path(filepath: Optional[str], spell: str, username: str) -> Op
     return out_path
 
 
-def upload_recordings(paths: Sequence[str]) -> Tuple[int, Optional[str]]:
-    """Upload given file paths to the Hub repo indicated by env HF_UPLOAD_REPO or the current Space repo.
-
-    Returns (uploaded_count, error_message). error_message is None on success.
-    Requires HF_TOKEN secret configured with write permission.
-    """
-    if not paths:
-        return 0, None
-    if HfApi is None:
-        return 0, "huggingface_hub not installed."
-    token = os.getenv("HF_TOKEN") or (HfFolder.get_token() if HfFolder else None)
-    if not token:
-        return 0, "No HF_TOKEN available (set as Space secret to enable uploads)."
-
-    repo_id = os.getenv("HF_UPLOAD_REPO")
-    # Best-effort infer the current Space repo id from environment if not provided
-    if not repo_id:
-        # In Spaces, SPACE_ID is like "username/space_name" for the current space.
-        # Use that as default so users can upload back to their Space if they want.
-        repo_id = os.getenv("SPACE_ID") or os.getenv("REPO_ID")
-    if not repo_id:
-        return 0, "Unable to infer target repo id (set HF_UPLOAD_REPO)."
-
-    api = HfApi(token=token)
-    uploaded = 0
-    commit_msg = f"Add recordings {int(time.time())}"
-    # Determine repo_type. If user provided HF_UPLOAD_REPO, default to dataset.
-    # If we inferred the current Space id, default to space so it "just works".
-    repo_type_env = os.getenv("HF_UPLOAD_REPO_TYPE")
-    if repo_type_env:
-        repo_type = repo_type_env.lower()
-    else:
-        if os.getenv("HF_UPLOAD_REPO"):
-            repo_type = "dataset"
-        elif os.getenv("SPACE_ID") or os.getenv("REPO_ID"):
-            repo_type = "space"
-        else:
-            repo_type = "dataset"
-    if repo_type not in {"dataset", "space", "model"}:
-        repo_type = "dataset"
-    try:
-        for p in paths:
-            if not os.path.isfile(p):
-                continue
-            api.upload_file(
-                path_or_fileobj=p,
-                path_in_repo=f"recordings/{os.path.basename(p)}",
-                repo_id=repo_id,
-                repo_type=repo_type,
-                commit_message=commit_msg,
-            )
-            uploaded += 1
-    except Exception as e:  # broad catch to surface error in UI
-        return uploaded, f"Upload error: {e}"
-    return uploaded, None
-
-
-def upload_recordings_to_gdrive(paths: Sequence[str]) -> Tuple[int, Optional[str]]:
-    """Upload files to Google Drive into a folder using a service account.
-
-    Requires secrets:
-    - GDRIVE_SERVICE_ACCOUNT_JSON: full JSON credentials for a service account
-    - GDRIVE_FOLDER_ID: target Drive folder ID
-    Returns (uploaded_count, error_message).
-    """
-    if not paths:
-        return 0, None
-    if not (service_account and build and MediaFileUpload):
-        return 0, "Google API client not installed."
-    svc_json = os.getenv("GDRIVE_SERVICE_ACCOUNT_JSON")
-    folder_id = os.getenv("GDRIVE_FOLDER_ID")
-    if not svc_json:
-        return 0, "Missing GDRIVE_SERVICE_ACCOUNT_JSON secret."
-    if not folder_id:
-        return 0, "Missing GDRIVE_FOLDER_ID secret."
-
-    try:
-        creds = None
-        if svc_json.strip().startswith("{"):
-            data = json.loads(svc_json)
-            creds = service_account.Credentials.from_service_account_info(
-                data,
-                scopes=["https://www.googleapis.com/auth/drive.file"],
-            )
-        else:
-            # if not JSON string, maybe it's a file path provided via secret
-            creds = service_account.Credentials.from_service_account_file(
-                svc_json,
-                scopes=["https://www.googleapis.com/auth/drive.file"],
-            )
-        drive = build("drive", "v3", credentials=creds)
-    except Exception as e:
-        return 0, f"Auth error: {e}"
-
-    uploaded = 0
-    try:
-        for p in paths:
-            if not os.path.isfile(p):
-                continue
-            media = MediaFileUpload(p, mimetype="audio/wav", resumable=False)
-            body = {"name": os.path.basename(p), "parents": [folder_id]}
-            drive.files().create(body=body, media_body=media, fields="id").execute()
-            uploaded += 1
-    except Exception as e:
-        return uploaded, f"Drive upload error: {e}"
-    return uploaded, None
-
-
 def _parse_meta_from_filename(basename: str) -> Tuple[str, str, Optional[int]]:
-    """Parse (spell_slug, username, timestamp) from `<spell_slug>_<username>_<ts>.wav`.
-    Username and spell slug can contain underscores; timestamp is the last token.
-    """
+    """Parse (spell_slug, username, timestamp) from `<spell_slug>_<username>_<ts>.wav`."""
     name = basename
     if name.endswith(".wav"):
         name = name[:-4]
@@ -301,9 +169,6 @@ def submit_recordings(
     wingardium_path: Optional[str],
     accio_path: Optional[str],
     reparo_path: Optional[str],
-    upload_flag: bool,
-    gdrive_flag: bool,
-    mongo_flag: bool,
 ) -> str:
     user = sanitize_username(username)
 
@@ -317,9 +182,8 @@ def submit_recordings(
     ]
 
     saved = []
-    skipped = []
-
     saved_paths: List[str] = []
+    skipped = []
     for spell, path in pairs:
         out = save_one_from_path(path, spell, user)
         if out:
@@ -328,7 +192,7 @@ def submit_recordings(
         else:
             skipped.append(spell)
 
-    lines = []
+    lines: List[str] = []
     if saved:
         lines.append("Saved recordings (local runtime):")
         lines += [f"- {s}" for s in saved]
@@ -339,45 +203,20 @@ def submit_recordings(
     if not lines:
         return "No audio captured. Please record at least one spell."
 
-    if upload_flag:
-        uploaded, err = upload_recordings(saved_paths)
-        lines.append("")
-        if err:
-            lines.append(f"Hub upload attempted: {uploaded} succeeded, error: {err}")
-        else:
-            lines.append(f"Hub upload: {uploaded} file(s) committed to repo.")
-            lines.append("(It may take a few seconds to appear in the file browser.)")
-
-    if gdrive_flag:
-        gup, gerr = upload_recordings_to_gdrive(saved_paths)
-        lines.append("")
-        if gerr:
-            lines.append(f"Drive upload attempted: {gup} succeeded, error: {gerr}")
-        else:
-            lines.append(f"Drive upload: {gup} file(s) uploaded to folder.")
-
-    if mongo_flag:
-        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.")
+    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
-        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.
-        """)
+        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.""")
 
         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():
@@ -389,28 +228,16 @@ 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():
-            upload_checkbox = gr.Checkbox(label="Upload to Hub (requires HF_TOKEN)", value=False)
-            gdrive_checkbox = gr.Checkbox(label="Upload to Google Drive (service account)", value=False)
-            mongo_checkbox = gr.Checkbox(label="Upload to MongoDB (GridFS)", value=False)
         submit = gr.Button("Submit")
         result = gr.Markdown()
 
         submit.click(
             fn=submit_recordings,
-            inputs=[username, lumos, nox, alohomora, wingardium, accio, reparo, upload_checkbox, gdrive_checkbox, mongo_checkbox],
+            inputs=[username, lumos, nox, alohomora, wingardium, accio, reparo],
             outputs=[result],
         )
 
-        gr.Markdown("""
-    Notes:
-    - Files are saved locally in `recordings/` with `<spell>_<username>_<timestamp>.wav`.
-    - Check "Upload to Hub" to commit them to the repo (needs HF_TOKEN secret).
-    - Or check "Upload to Google Drive" to upload via a service account.
-    - Or check "Upload to MongoDB (GridFS)" to store in your database.
-    - 16 kHz mono WAV ensures consistent model training.
-    - You can submit partial sets; only provided spells are saved.
-        """)
+        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.""")
 
     return demo
 

requirements.txt

@@ -2,9 +2,4 @@ gradio
 numpy
 soundfile
 scipy
-huggingface_hub
-google-api-python-client
-google-auth
-google-auth-httplib2
-google-auth-oauthlib
 pymongo