Update app.py

app.py

@@ -6,40 +6,29 @@ import random
 import datetime
 import uuid
 import json
-from huggingface_hub import HfApi, create_repo
-from datasets import Dataset
-import soundfile as sf # Added for explicit use in save_recording
-import shutil # Added for explicit use in save_recording
-
-# Configuration
+import io # For BytesIO
+from huggingface_hub import HfApi, create_repo, HfFileSystem
+from datasets import Dataset # Still useful for potential future aggregation
+import soundfile as sf
+import shutil
+import traceback # For detailed error logging
+
+# --- Configuration ---
 SAMPLE_PROMPTS = [
-    "नमस्ते, मेरो नाम __ हो। म नेपाली बोल्छु।",
-    "आज मौसम धेरै राम्रो छ।",
-    "नेपाल एक सुन्दर देश हो जहाँ हिमाल, पहाड र तराई छन्।",
-    "काठमाडौं नेपालको राजधानी हो।",
-    "म आज बिहान स्कूल जाँदैछु।",
-    "नेपाली भाषा बोल्ने मानिसहरू विश्वभर छन्।",
-    "हिमालमा हिउँ परिरहेको छ।",
-    "मलाई नेपाली खाना धेरै मन पर्छ।",
-    "बुद्ध नेपालमा जन्मिएका थिए।",
-    "सगरमाथा विश्वको सबैभन्दा अग्लो हिमाल हो।"
+    "नमस्ते, मेरो नाम __ हो। म नेपाली बोल्छु।", "आज मौसम धेरै राम्रो छ।",
+    "नेपाल एक सुन्दर देश हो जहाँ हिमाल, पहाड र तराई छन्।", "काठमाडौं नेपालको राजधानी हो।",
+    "म आज बिहान स्कूल जाँदैछु।", "नेपाली भाषा बोल्ने मानिसहरू विश्वभर छन्।",
+    "हिमालमा हिउँ परिरहेको छ।", "मलाई नेपाली खाना धेरै मन पर्छ।",
+    "बुद्ध नेपालमा जन्मिएका थिए।", "सगरमाथा विश्वको सबैभन्दा अग्लो हिमाल हो।"
 ]
-
 EMOTIONS = ["सामान्य (Neutral)", "खुसी (Happy)", "दुःखी (Sad)", "रिसाएको (Angry)", "अचम्मित (Surprised)"]
 GENDERS = ["पुरुष (Male)", "महिला (Female)", "अन्य (Other)", "भन्न चाहन्न (Prefer not to say)"]
 AGE_GROUPS = ["18 भन्दा कम", "18-24", "25-34", "35-44", "45-54", "55-64", "65+"]
-
-# Nepal-specific data
 REGIONS = [
-    "प्रदेश १ (Province 1)",
-    "मधेश प्रदेश (Madhesh Province)",
-    "बागमती प्रदेश (Bagmati Province)",
-    "गण्डकी प्रदेश (Gandaki Province)",
-    "लुम्बिनी प्रदेश (Lumbini Province)",
-    "कर्णाली प्रदेश (Karnali Province)",
-    "सुदूरपश्चिम प्रदेश (Sudurpashchim Province)"
+    "प्रदेश १ (Province 1)", "मधेश प्रदेश (Madhesh Province)", "बागमती प्रदेश (Bagmati Province)",
+    "गण्डकी प्रदेश (Gandaki Province)", "लुम्बिनी प्रदेश (Lumbini Province)",
+    "कर्णाली प्रदेश (Karnali Province)", "सुदूरपश्चिम प्रदेश (Sudurpashchim Province)"
 ]
-
 COMMON_LAST_NAMES = {
     "पहाडी (Pahadi)": ["शर्मा (Sharma)", "पौडेल (Poudel)", "खनाल (Khanal)", "अधिकारी (Adhikari)", "भट्टराई (Bhattarai)", "अन्य पहाडी (Other Pahadi)"],
     "नेवार (Newar)": ["श्रेष्ठ (Shrestha)", "प्रधान (Pradhan)", "महर्जन (Maharjan)", "बज्राचार्य (Bajracharya)", "अन्य नेवार (Other Newar)"],
@@ -54,488 +43,536 @@ COMMON_LAST_NAMES = {
     "अन्य (Other)": ["अन्य (Other)"]
 }
 
-# --- Directory and File Paths ---
-# These paths are relative to where app.py is run.
-# In a Hugging Face Space, this means they are within the Space's file system.
-RECORDINGS_DIR = "recordings"
-METADATA_DIR = "metadata"
-RATINGS_DIR = "ratings"
-METADATA_FILE = os.path.join(METADATA_DIR, "metadata.csv")
-RATINGS_FILE = os.path.join(RATINGS_DIR, "ratings.json")
+# --- Directory and File Paths (Local to the Space) ---
+BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # Ensures paths are relative to app.py
+RECORDINGS_DIR = os.path.join(BASE_DIR, "recordings")
+METADATA_DIR = os.path.join(BASE_DIR, "metadata")
+RATINGS_DIR = os.path.join(BASE_DIR, "ratings")
+LOCAL_METADATA_FILE = os.path.join(METADATA_DIR, "local_metadata.csv")
+LOCAL_RATINGS_FILE = os.path.join(RATINGS_DIR, "local_ratings.json")
+HF_UPLOAD_LOG_FILE = os.path.join(METADATA_DIR, "hf_upload_log.csv") # To track HF uploads
+
+# --- Hugging Face Configuration (from Space Secrets) ---
+# These will be fetched from environment variables set by Space Secrets
+# HF_TOKEN: Your HF Write Token
+# ADMIN_UPLOAD_PASSWORD: Password for admin functions
+# TARGET_HF_DATASET_REPO_ID: e.g., "yourusername/your-dataset-repo"
 
 # --- Initialization ---
 def initialize_data_storage():
-    """Creates directories and initial files if they don't exist."""
     os.makedirs(RECORDINGS_DIR, exist_ok=True)
     os.makedirs(METADATA_DIR, exist_ok=True)
     os.makedirs(RATINGS_DIR, exist_ok=True)
 
-    if not os.path.exists(METADATA_FILE):
+    if not os.path.exists(LOCAL_METADATA_FILE):
         pd.DataFrame(columns=[
-            "id", "text", "audio_path", "gender", "age_group", "ethnicity",
-            "last_name", "region", "emotion", "timestamp", "recording_type"
-        ]).to_csv(METADATA_FILE, index=False)
+            "id", "text", "local_audio_path", "gender", "age_group", "ethnicity",
+            "last_name", "region", "emotion", "timestamp", "recording_type",
+            "hf_audio_uploaded", "hf_metadata_uploaded" # Track HF upload status
+        ]).to_csv(LOCAL_METADATA_FILE, index=False)
 
-    if not os.path.exists(RATINGS_FILE):
-        with open(RATINGS_FILE, 'w') as f:
+    if not os.path.exists(LOCAL_RATINGS_FILE):
+        with open(LOCAL_RATINGS_FILE, 'w') as f:
             json.dump({}, f)
 
-initialize_data_storage() # Call initialization at script start
+    if not os.path.exists(HF_UPLOAD_LOG_FILE):
+        pd.DataFrame(columns=["id", "timestamp", "hf_repo_id", "type", "status", "message"]).to_csv(HF_UPLOAD_LOG_FILE, index=False)
+
+initialize_data_storage()
+
+# --- Helper: Log HF Upload Attempts ---
+def log_hf_upload_attempt(recording_id, hf_repo_id, upload_type, status, message=""):
+    log_df = pd.read_csv(HF_UPLOAD_LOG_FILE)
+    new_log_entry = pd.DataFrame([{
+        "id": recording_id,
+        "timestamp": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "hf_repo_id": hf_repo_id,
+        "type": upload_type, # "audio", "metadata_entry", "ratings_sync"
+        "status": status,   # "success", "failure"
+        "message": message
+    }])
+    updated_log_df = pd.concat([log_df, new_log_entry], ignore_index=True)
+    updated_log_df.to_csv(HF_UPLOAD_LOG_FILE, index=False)
 
 # --- Core Functions ---
-def save_recording(audio, text, gender, age_group, ethnicity, last_name, region, emotion, recording_type):
-    """Save the recording and metadata"""
-    if audio is None:
+def save_and_direct_upload_recording(audio_input, text, gender, age_group, ethnicity, last_name, region, emotion, recording_type):
+    """Saves recording locally and attempts immediate upload to Hugging Face."""
+    if audio_input is None:
         return "कृपया पहिले रेकर्डिङ गर्नुहोस्। (Please record audio first)", None
 
+    # --- Get HF Config from Secrets ---
+    hf_token = os.environ.get("HF_TOKEN")
+    target_hf_repo_id = os.environ.get("TARGET_HF_DATASET_REPO_ID")
+
+    if not hf_token or not target_hf_repo_id:
+        # Critical config missing, only save locally
+        status_msg, _ = save_recording_locally(
+            audio_input, text, gender, age_group, ethnicity, last_name, region, emotion, recording_type,
+            hf_audio_uploaded=False, hf_metadata_uploaded=False # Mark as not uploaded
+        )
+        return f"{status_msg} (HF config missing in secrets, saved locally only)", None
+
+    # --- Save Locally First (always) ---
+    status_msg_local, recording_id, local_audio_path = save_recording_locally(
+        audio_input, text, gender, age_group, ethnicity, last_name, region, emotion, recording_type,
+        hf_audio_uploaded=False, hf_metadata_uploaded=False # Initial state
+    )
+    if not recording_id: # Failed to save locally
+        return status_msg_local, None
+
+    # --- Attempt Direct HF Upload ---
+    hf_upload_success = True
+    final_status_message = status_msg_local # Start with local save message
+
+    try:
+        api = HfApi(token=hf_token)
+        # Ensure base repo and standard subfolders exist
+        create_repo(repo_id=target_hf_repo_id, token=hf_token, repo_type="dataset", exist_ok=True, private=False)
+        for folder in ["audio", "metadata_entries", "ratings_entries"]:
+            try:
+                api.create_folder(repo_id=target_hf_repo_id, folder_path=folder, repo_type="dataset", exist_ok=True)
+            except Exception: pass # Ignore if folder exists
+
+        # 1. Upload Audio File to HF
+        hf_audio_path = f"audio/{os.path.basename(local_audio_path)}"
+        api.upload_file(
+            path_or_fileobj=local_audio_path,
+            path_in_repo=hf_audio_path,
+            repo_id=target_hf_repo_id,
+            repo_type="dataset",
+            commit_message=f"feat: Add audio for recording {recording_id}"
+        )
+        log_hf_upload_attempt(recording_id, target_hf_repo_id, "audio", "success")
+        update_local_metadata_hf_status(recording_id, hf_audio_uploaded=True)
+        final_status_message += f"\nअडियो सफलतापूर्वक HF मा अपलोड गरियो। (Audio uploaded to HF successfully.)"
+
+        # 2. Prepare and Upload Metadata Entry to HF
+        single_metadata_dict_for_hf = {
+            "id": recording_id, "text": text, "hf_audio_path": hf_audio_path,
+            "gender": gender, "age_group": age_group, "ethnicity": ethnicity,
+            "last_name": last_name, "region": region, "emotion": emotion,
+            "timestamp": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), # Use current time for HF metadata
+            "recording_type": recording_type
+            # Initial ratings are not part of this base metadata; they'll be separate
+        }
+        hf_metadata_entry_path = f"metadata_entries/{recording_id}.json"
+        api.upload_file(
+            path_or_fileobj=io.BytesIO(json.dumps(single_metadata_dict_for_hf, ensure_ascii=False, indent=2).encode('utf-8')),
+            path_in_repo=hf_metadata_entry_path,
+            repo_id=target_hf_repo_id,
+            repo_type="dataset",
+            commit_message=f"feat: Add metadata for recording {recording_id}"
+        )
+        log_hf_upload_attempt(recording_id, target_hf_repo_id, "metadata_entry", "success")
+        update_local_metadata_hf_status(recording_id, hf_metadata_uploaded=True)
+        final_status_message += f"\nमेटाडाटा सफलतापूर्वक HF मा अपलोड गरियो। (Metadata uploaded to HF successfully.)"
+
+    except Exception as e:
+        tb_str = traceback.format_exc()
+        error_message = f"HF अपलोडको क्रममा त्रुटि: {str(e)}. (Error during HF upload.)\nविवरण (Details): {tb_str}"
+        log_hf_upload_attempt(recording_id, target_hf_repo_id, "audio_or_metadata_entry_direct", "failure", error_message)
+        final_status_message += f"\n{error_message}\nडाटा स्थानीय रूपमा सुरक्षित गरिएको छ। (Data saved locally.)"
+        hf_upload_success = False # Mark that direct upload had issues
+
+    return final_status_message, None # Clear audio input
+
+def save_recording_locally(audio_input, text, gender, age_group, ethnicity, last_name, region, emotion, recording_type, hf_audio_uploaded=False, hf_metadata_uploaded=False):
+    """Saves recording and metadata locally in the Space."""
     recording_id = str(uuid.uuid4())
     timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     audio_filename_relative = f"{recording_id}.wav"
-    audio_filepath_in_space = os.path.join(RECORDINGS_DIR, audio_filename_relative)
+    local_audio_path = os.path.join(RECORDINGS_DIR, audio_filename_relative)
 
     try:
-        if isinstance(audio, tuple):  # If it's a tuple (sr, data) from gr.Audio(type="numpy")
-            sr, data = audio
-            sf.write(audio_filepath_in_space, data, sr)
-        elif isinstance(audio, str) and os.path.exists(audio): # If it's a path from gr.Audio(type="filepath")
-            shutil.copy(audio, audio_filepath_in_space)
-            # Gradio might place temp files elsewhere, so we ensure it's in our recordings dir
+        if isinstance(audio_input, tuple):
+            sr, data = audio_input
+            sf.write(local_audio_path, data, sr)
+        elif isinstance(audio_input, str) and os.path.exists(audio_input):
+            shutil.copy(audio_input, local_audio_path)
         else:
-            return "अडियो फाइल बचत गर्न सकिएन। (Could not save audio file. Invalid audio format.)", None
+            return "अडियो फाइल बचत गर्न सकिएन। (Could not save audio file. Invalid audio input.)", None, None
     except Exception as e:
-        return f"अडियो फाइल बचत गर्दा त्रुटि भयो: {e} (Error saving audio file: {e})", None
-
+        return f"स्थानीय रूपमा अडियो बचत गर्दा त्रुटि भयो: {e} (Error saving audio locally: {e})", None, None
 
-    metadata_df = pd.read_csv(METADATA_FILE)
-    new_row = pd.DataFrame([{
-        "id": recording_id,
-        "text": text,
-        "audio_path": audio_filepath_in_space, # Store path relative to space root
-        "gender": gender,
-        "age_group": age_group,
-        "ethnicity": ethnicity,
-        "last_name": last_name,
-        "region": region,
-        "emotion": emotion,
-        "timestamp": timestamp,
-        "recording_type": recording_type
-    }])
-
-    updated_metadata = pd.concat([metadata_df, new_row], ignore_index=True)
-    updated_metadata.to_csv(METADATA_FILE, index=False)
-
-    with open(RATINGS_FILE, 'r+') as f:
-        ratings = json.load(f)
-        ratings[recording_id] = {
-            "upvotes": 0, "downvotes": 0,
-            "quality_score": 0, "quality_votes": 0,
-            "correctness_score": 0, "correctness_votes": 0
-        }
-        f.seek(0)
-        json.dump(ratings, f, indent=2)
-        f.truncate()
+    # Save to local metadata CSV
+    try:
+        metadata_df = pd.read_csv(LOCAL_METADATA_FILE)
+        new_row = pd.DataFrame([{
+            "id": recording_id, "text": text, "local_audio_path": local_audio_path,
+            "gender": gender, "age_group": age_group, "ethnicity": ethnicity,
+            "last_name": last_name, "region": region, "emotion": emotion,
+            "timestamp": timestamp, "recording_type": recording_type,
+            "hf_audio_uploaded": hf_audio_uploaded, "hf_metadata_uploaded": hf_metadata_uploaded
+        }])
+        updated_metadata = pd.concat([metadata_df, new_row], ignore_index=True)
+        updated_metadata.to_csv(LOCAL_METADATA_FILE, index=False)
+    except Exception as e:
+        # If metadata save fails, try to clean up audio to avoid orphans
+        if os.path.exists(local_audio_path): os.remove(local_audio_path)
+        return f"स्थानीय मेटाडाटा बचत गर्दा त्रुटि: {e} (Error saving local metadata: {e})", None, None
 
-    return f"रेकर्डिङ सफलतापूर्वक सुरक्षित गरियो! ID: {recording_id} (Recording saved successfully!)", None # Return None to clear audio input
+    # Initialize local ratings
+    try:
+        with open(LOCAL_RATINGS_FILE, 'r+') as f:
+            ratings = json.load(f)
+            ratings[recording_id] = {"upvotes": 0, "downvotes": 0, "quality_score": 0, "quality_votes": 0, "correctness_score": 0, "correctness_votes": 0}
+            f.seek(0)
+            json.dump(ratings, f, indent=2, ensure_ascii=False)
+            f.truncate()
+    except Exception as e:
+        # Non-critical for recording saving, but log it
+        print(f"Warning: Could not initialize local ratings for {recording_id}: {e}")
 
-def get_random_prompt():
-    return random.choice(SAMPLE_PROMPTS)
+    return f"रेकर्डिङ सफलतापूर्वक स्थानीय रूपमा सुरक्षित गरियो! ID: {recording_id} (Recording saved locally successfully!)", recording_id, local_audio_path
 
-def get_ethnicity_based_last_names(ethnicity):
-    return gr.Dropdown.update(choices=COMMON_LAST_NAMES.get(ethnicity, COMMON_LAST_NAMES["अन्य (Other)"]))
+def update_local_metadata_hf_status(recording_id, hf_audio_uploaded=None, hf_metadata_uploaded=None):
+    """Updates the HF upload status flags in the local metadata CSV."""
+    try:
+        metadata_df = pd.read_csv(LOCAL_METADATA_FILE)
+        idx = metadata_df[metadata_df['id'] == recording_id].index
+        if not idx.empty:
+            if hf_audio_uploaded is not None:
+                metadata_df.loc[idx, 'hf_audio_uploaded'] = hf_audio_uploaded
+            if hf_metadata_uploaded is not None:
+                metadata_df.loc[idx, 'hf_metadata_uploaded'] = hf_metadata_uploaded
+            metadata_df.to_csv(LOCAL_METADATA_FILE, index=False)
+    except Exception as e:
+        print(f"Error updating local metadata HF status for {recording_id}: {e}")
 
-def vote_recording(recording_id, vote_type, vote_value_str): # vote_value comes as string from slider
-    if not recording_id:
-        return "कृपया पहिले समीक्षा गर्न रेकर्डिङ चयन गर्नुहोस्। (Please select a recording to review first.)"
-    if not os.path.exists(RATINGS_FILE):
-        return "रेटिङ फाइल भेटिएन। (Rating file not found.)"
+def get_random_prompt(): return random.choice(SAMPLE_PROMPTS)
+def get_ethnicity_based_last_names(ethnicity): return gr.Dropdown.update(choices=COMMON_LAST_NAMES.get(ethnicity, COMMON_LAST_NAMES["अन्य (Other)"]))
 
-    try:
-        vote_value = int(vote_value_str) # Convert to int for quality/correctness
-    except ValueError:
-        if vote_type in ["quality", "correctness"]:
-            return "अमान्य मत मान। (Invalid vote value.)"
-        vote_value = 0 # For upvote/downvote
+def vote_recording(recording_id, vote_type, vote_value_str):
+    if not recording_id: return "कृपया पहिले समीक्षा गर्न रेकर्डिङ चयन गर्नुहोस्।"
+    if not os.path.exists(LOCAL_RATINGS_FILE): return "स्थानीय रेटिङ फाइल भेटिएन।"
+    try: vote_value = int(vote_value_str)
+    except ValueError: vote_value = 0
 
     try:
-        with open(RATINGS_FILE, 'r+') as f:
+        with open(LOCAL_RATINGS_FILE, 'r+') as f:
             ratings = json.load(f)
-            if recording_id not in ratings:
-                return "रेकर्डिङ आईडी भेटिएन। (Recording ID not found.)"
-
+            if recording_id not in ratings: return "यस रेकर्डिङको लागि स्थानीय मूल्याङ्कन भेटिएन।"
             rec_ratings = ratings[recording_id]
-            if vote_type == "upvote":
-                rec_ratings["upvotes"] += 1
-            elif vote_type == "downvote":
-                rec_ratings["downvotes"] += 1
+            if vote_type == "upvote": rec_ratings["upvotes"] += 1
+            elif vote_type == "downvote": rec_ratings["downvotes"] += 1
             elif vote_type == "quality":
-                current_score = rec_ratings["quality_score"]
-                current_votes = rec_ratings["quality_votes"]
-                new_votes = current_votes + 1
-                new_score = ((current_score * current_votes) + vote_value) / new_votes
-                rec_ratings["quality_score"] = new_score
+                new_votes = rec_ratings.get("quality_votes", 0) + 1
+                rec_ratings["quality_score"] = ((rec_ratings.get("quality_score", 0) * rec_ratings.get("quality_votes", 0)) + vote_value) / new_votes
                 rec_ratings["quality_votes"] = new_votes
             elif vote_type == "correctness":
-                current_score = rec_ratings["correctness_score"]
-                current_votes = rec_ratings["correctness_votes"]
-                new_votes = current_votes + 1
-                new_score = ((current_score * current_votes) + vote_value) / new_votes
-                rec_ratings["correctness_score"] = new_score
+                new_votes = rec_ratings.get("correctness_votes", 0) + 1
+                rec_ratings["correctness_score"] = ((rec_ratings.get("correctness_score", 0) * rec_ratings.get("correctness_votes", 0)) + vote_value) / new_votes
                 rec_ratings["correctness_votes"] = new_votes
-            else:
-                return "अमान्य मतदान प्रकार। (Invalid vote type.)"
+            else: return "अमान्य मतदान प्रकार।"
+            f.seek(0); json.dump(ratings, f, indent=2, ensure_ascii=False); f.truncate()
+        return "स्थानीय मतदान सफलतापूर्वक दर्ता गरियो!"
+    except Exception as e: return f"स्थानीय मतदान दर्ता गर्दा त्रुटि: {str(e)}"
+
+def get_local_recording_audio(recording_id):
+    if not recording_id: return None, "कुनै रेकर्डिङ आईडी प्रदान गरिएको छैन।"
+    if not os.path.exists(LOCAL_METADATA_FILE): return None, "स्थानीय मेटाडाटा फाइल भेटिएन।"
+    try: metadata = pd.read_csv(LOCAL_METADATA_FILE)
+    except pd.errors.EmptyDataError: return None, "स्थानीय मेटाडाटा खाली छ।"
+    recording = metadata[metadata['id'] == recording_id]
+    if len(recording) == 0: return None, "रेकर्डिङ भेटिएन।"
+    audio_path = recording['local_audio_path'].iloc[0]
+    text = recording['text'].iloc[0]
+    if not os.path.exists(audio_path): return None, f"स्थानीय अडियो फाइल भेटिएन: {audio_path}"
+    return audio_path, text
 
-            f.seek(0)
-            json.dump(ratings, f, indent=2)
-            f.truncate()
-        return "मतदान सफलतापूर्वक दर्ता गरियो! (Vote registered successfully!)"
-    except Exception as e:
-        return f"मतदान दर्ता गर्दा त्रुटि: {str(e)} (Error registering vote: {str(e)})"
+def get_local_recording_ratings(recording_id):
+    if not recording_id: return "रेकर्डिङ आईडी चयन गर्नुहोस्।"
+    if not os.path.exists(LOCAL_RATINGS_FILE): return "स्थानीय मूल्याङ्कन डाटा भेटिएन।"
+    with open(LOCAL_RATINGS_FILE, 'r') as f: ratings_data = json.load(f)
+    if recording_id not in ratings_data: return "यस रेकर्डिङको लागि कुनै स्थानीय मूल्याङ्कन भेटिएन।"
+    r = ratings_data[recording_id]
+    return (f"👍 Upvotes: {r.get('upvotes',0)} | 👎 Downvotes: {r.get('downvotes',0)}\n"
+            f"गुणस्तर (Quality): {r.get('quality_score',0):.1f}/5 ({r.get('quality_votes',0)} मत)\n"
+            f"शुद्धता (Correctness): {r.get('correctness_score',0):.1f}/5 ({r.get('correctness_votes',0)} मत)")
+
+def update_local_count():
+    if os.path.exists(LOCAL_METADATA_FILE):
+        try:
+            metadata = pd.read_csv(LOCAL_METADATA_FILE)
+            uploaded_audio_count = metadata['hf_audio_uploaded'].sum()
+            uploaded_metadata_count = metadata['hf_metadata_uploaded'].sum()
+            return (f"कुल स्थानीय रेकर्डिङ: {len(metadata)}\n"
+                    f"HF मा अडियो अपलोड गरिएको: {uploaded_audio_count}\n"
+                    f"HF मा मेटाडाटा अपलोड गरिएको: {uploaded_metadata_count}")
+        except pd.errors.EmptyDataError: return "स्थानीय रेकर्डिङ: 0"
+    return "कुनै स्थानीय रेकर्डिङ भेटिएन।"
+
+def list_local_recordings(num_items=10):
+    if not os.path.exists(LOCAL_METADATA_FILE): return pd.DataFrame()
+    try: metadata = pd.read_csv(LOCAL_METADATA_FILE)
+    except pd.errors.EmptyDataError: return pd.DataFrame()
+    if len(metadata) == 0: return pd.DataFrame()
+    metadata['timestamp'] = pd.to_datetime(metadata['timestamp'], errors='coerce')
+    sorted_metadata = metadata.sort_values('timestamp', ascending=False).head(int(num_items))
+    display_df = sorted_metadata[['id', 'text', 'ethnicity', 'region', 'timestamp', 'hf_audio_uploaded', 'hf_metadata_uploaded']].copy()
+    display_df['timestamp'] = display_df['timestamp'].dt.strftime('%Y-%m-%d %H:%M').fillna('N/A')
+    return display_df.reset_index(drop=True)
 
-def upload_to_huggingface(dataset_name, admin_password_attempt):
-    """Upload the collected data to Hugging Face"""
-    # --- Admin Password Check ---
+# --- Admin Functions for HF Syncing ---
+def admin_retry_failed_uploads(admin_password_attempt):
+    hf_token = os.environ.get("HF_TOKEN")
+    target_hf_repo_id = os.environ.get("TARGET_HF_DATASET_REPO_ID")
     expected_admin_password = os.environ.get("ADMIN_UPLOAD_PASSWORD")
-    hf_token_from_secret = os.environ.get("HF_TOKEN")
 
-    if not expected_admin_password:
-        return "त्रुटि: प्रशासक पासवर्ड स्पेस गोप्यमा कन्फिगर गरिएको छैन। (Error: Admin password not configured in Space secrets.)"
-    if admin_password_attempt != expected_admin_password:
-        return "त्रुटि: अपलोडका लागि अमान्य प्रशासक पासवर्ड। (Error: Invalid admin password for upload.)"
-    if not hf_token_from_secret:
-        return "त्रुटि: HF_TOKEN गोप्य स्पेस कन्फिगरेसनमा फेला परेन। अपलोड गर्न सकिँदैन। (Error: HF_TOKEN secret not found in Space configuration. Cannot upload.)"
-    if not dataset_name or len(dataset_name.split('/')) != 2:
-        return "त्रुटि: कृपया मान्य डेटासेट नाम 'username/repo_name' ढाँचामा प्रदान गर्नुहोस्। (Error: Please provide a valid dataset name in 'username/repo_name' format.)"
+    if admin_password_attempt != expected_admin_password: return "अमान्य प्रशासक पासवर्ड।"
+    if not hf_token or not target_hf_repo_id: return "HF कन्फिगरेसन गोप्यमा हराइरहेको छ।"
+    if not os.path.exists(LOCAL_METADATA_FILE): return "कुनै स्थानीय मेटाडाटा फाइल भेटिएन।"
 
-    if not os.path.exists(METADATA_FILE):
-        return "कुनै मेटाडाटा फाइल भेटिएन। (No metadata file found.)"
+    local_meta_df = pd.read_csv(LOCAL_METADATA_FILE)
+    # Find recordings where audio or metadata upload is marked as False
+    to_retry_df = local_meta_df[~(local_meta_df['hf_audio_uploaded'] & local_meta_df['hf_metadata_uploaded'])]
+
+    if to_retry_df.empty: return "पुनः प्रयास गर्न कुनै असफल अपलोडहरू भेटिएन।"
+
+    api = HfApi(token=hf_token)
+    success_count = 0
+    failure_count = 0
+    messages = []
+
+    for _, row in to_retry_df.iterrows():
+        rec_id = row['id']
+        local_audio_p = row['local_audio_path']
+        hf_audio_path = f"audio/{os.path.basename(local_audio_p)}"
+        current_status_msg = f"Retrying {rec_id}: "
 
-    try:
-        api = HfApi(token=hf_token_from_secret)
-        # Ensure repo exists, create if not. private=False for public dataset
-        create_repo(repo_id=dataset_name, token=hf_token_from_secret, repo_type="dataset", exist_ok=True, private=False)
-
-        metadata = pd.read_csv(METADATA_FILE)
-        if len(metadata) == 0:
-            return "कुनै डाटा भेटिएन। (No data to upload.)"
-
-        with open(RATINGS_FILE, 'r') as f:
-            ratings_data = json.load(f)
-
-        metadata["upvotes"] = metadata["id"].apply(lambda x: ratings_data.get(x, {}).get("upvotes", 0))
-        metadata["downvotes"] = metadata["id"].apply(lambda x: ratings_data.get(x, {}).get("downvotes", 0))
-        metadata["quality_score"] = metadata["id"].apply(lambda x: ratings_data.get(x, {}).get("quality_score", 0))
-        metadata["quality_votes"] = metadata["id"].apply(lambda x: ratings_data.get(x, {}).get("quality_votes", 0))
-        metadata["correctness_score"] = metadata["id"].apply(lambda x: ratings_data.get(x, {}).get("correctness_score", 0))
-        metadata["correctness_votes"] = metadata["id"].apply(lambda x: ratings_data.get(x, {}).get("correctness_votes", 0))
-
-        # Prepare audio column for datasets library
-        # The 'audio' column should contain dictionaries with 'path' and optionally 'bytes'
-        # Here, we'll tell datasets to load from the paths we upload.
-        audio_files_for_dataset = []
-        for audio_path_in_space in metadata["audio_path"]:
-            audio_files_for_dataset.append(
-                {"path": os.path.join("audio", os.path.basename(audio_path_in_space))}
-            )
-        
-        dataset_dict = metadata.to_dict(orient='list')
-        dataset_dict['audio'] = audio_files_for_dataset # Add the audio column
-        
-        # Remove the local audio_path column as we now have the 'audio' dict column
-        if 'audio_path' in dataset_dict:
-            del dataset_dict['audio_path']
-
-        hf_dataset = Dataset.from_dict(dataset_dict)
-        
-        # Push dataset metadata (e.g., data.jsonl or data.arrow/parquet files in the repo)
-        hf_dataset.push_to_hub(repo_id=dataset_name) # token is implicitly used if HfApi was init with it or HF_TOKEN env var is set
-
-        # Upload individual audio files
-        # Create the audio folder in the dataset repo if it doesn't exist
         try:
-            api.create_folder(
-                repo_id=dataset_name,
-                folder_path="audio", # Target folder in the dataset repo
-                repo_type="dataset",
-                exist_ok=True
-            )
-        except Exception as e:
-            # Log this, but it's not critical if the folder already exists
-            print(f"सूचना: अडियो फोल्डर सिर्जना गर्न सकिएन (यो पहिले नै अवस्थित हुन सक्छ): {e} (Info: Could not create audio folder (it might already exist): {e})")
-        
-        upload_count = 0
-        for _, row in metadata.iterrows():
-            local_audio_file = row["audio_path"] # This is like "recordings/uuid.wav"
-            if os.path.exists(local_audio_file):
-                # The path_in_repo should match what you put in the 'audio' column for datasets
-                target_path_in_repo = os.path.join("audio", os.path.basename(local_audio_file))
+            # Retry audio if not uploaded
+            if not row['hf_audio_uploaded'] and os.path.exists(local_audio_p):
+                api.upload_file(path_or_fileobj=local_audio_p, path_in_repo=hf_audio_path, repo_id=target_hf_repo_id, repo_type="dataset", commit_message=f"fix: Retry audio upload for {rec_id}")
+                update_local_metadata_hf_status(rec_id, hf_audio_uploaded=True)
+                log_hf_upload_attempt(rec_id, target_hf_repo_id, "audio_retry", "success")
+                current_status_msg += "Audio OK. "
+            elif row['hf_audio_uploaded']:
+                 current_status_msg += "Audio already uploaded. "
+
+
+            # Retry metadata if not uploaded
+            if not row['hf_metadata_uploaded']:
+                # Reconstruct metadata dict for HF
+                hf_meta_dict = {
+                    "id": rec_id, "text": row["text"], "hf_audio_path": hf_audio_path,
+                    "gender": row["gender"], "age_group": row["age_group"], "ethnicity": row["ethnicity"],
+                    "last_name": row["last_name"], "region": row["region"], "emotion": row["emotion"],
+                    "timestamp": row["timestamp"], "recording_type": row["recording_type"]
+                }
+                hf_meta_entry_path = f"metadata_entries/{rec_id}.json"
                 api.upload_file(
-                    path_or_fileobj=local_audio_file,
-                    path_in_repo=target_path_in_repo,
-                    repo_id=dataset_name,
-                    repo_type="dataset"
+                    path_or_fileobj=io.BytesIO(json.dumps(hf_meta_dict, ensure_ascii=False, indent=2).encode('utf-8')),
+                    path_in_repo=hf_meta_entry_path, repo_id=target_hf_repo_id, repo_type="dataset",
+                    commit_message=f"fix: Retry metadata entry upload for {rec_id}"
                 )
-                upload_count +=1
+                update_local_metadata_hf_status(rec_id, hf_metadata_uploaded=True)
+                log_hf_upload_attempt(rec_id, target_hf_repo_id, "metadata_entry_retry", "success")
+                current_status_msg += "Metadata OK."
+            elif row['hf_metadata_uploaded']:
+                current_status_msg += "Metadata already uploaded."
+
+            success_count += 1
+            messages.append(f"SUCCESS: {current_status_msg}")
+        except Exception as e:
+            failure_count += 1
+            err_msg = f"FAILURE for {rec_id}: {str(e)}"
+            messages.append(err_msg)
+            log_hf_upload_attempt(rec_id, target_hf_repo_id, "audio_or_metadata_retry", "failure", str(e))
 
-        return (f"डाटा हगिङफेसमा सफलतापूर्��क अपलोड गरियो! {upload_count} अडियो फाइलहरू अपलोड गरियो। "
-                f"(Data successfully uploaded to Hugging Face at {dataset_name}. {upload_count} audio files uploaded.)")
+    return f"पुनः प्रयास सम्पन्न। सफलता: {success_count}, असफलता: {failure_count}\n" + "\n".join(messages)
 
-    except Exception as e:
-        import traceback
-        tb_str = traceback.format_exc()
-        return f"अपलोडको क्रममा त्रुटि (Error during upload):\n{str(e)}\n{tb_str}"
+def admin_sync_ratings_to_hf(admin_password_attempt):
+    hf_token = os.environ.get("HF_TOKEN")
+    target_hf_repo_id = os.environ.get("TARGET_HF_DATASET_REPO_ID")
+    expected_admin_password = os.environ.get("ADMIN_UPLOAD_PASSWORD")
 
-def update_count():
-    if os.path.exists(METADATA_FILE):
-        try:
-            metadata = pd.read_csv(METADATA_FILE)
-            return f"हालसम्म {len(metadata)} रेकर्डिङहरू संकलन गरिएको छ। (Total recordings collected: {len(metadata)})"
-        except pd.errors.EmptyDataError:
-             return "हालसम्म ० रेकर्डिङहरू संकलन गरिएको छ। (Total recordings collected: 0)"
-    return "कुनै रेकर्डिङ भेटिएन। (No recordings found.)"
-
-def list_recordings(num_items=10):
-    if not os.path.exists(METADATA_FILE):
-        return pd.DataFrame(columns=['id', 'text', 'ethnicity', 'region', 'timestamp'])
-    try:
-        metadata = pd.read_csv(METADATA_FILE)
-    except pd.errors.EmptyDataError:
-         return pd.DataFrame(columns=['id', 'text', 'ethnicity', 'region', 'timestamp'])
+    if admin_password_attempt != expected_admin_password: return "अमान्य प्रशासक पासवर्ड।"
+    if not hf_token or not target_hf_repo_id: return "HF कन्फिगरेसन गोप्यमा हराइरहेको छ।"
+    if not os.path.exists(LOCAL_RATINGS_FILE): return "कुनै स्थानीय मूल्याङ्कन फाइल भेटिएन।"
 
-    if len(metadata) == 0:
-        return pd.DataFrame(columns=['id', 'text', 'ethnicity', 'region', 'timestamp'])
+    with open(LOCAL_RATINGS_FILE, 'r') as f:
+        local_ratings = json.load(f)
 
-    metadata['timestamp'] = pd.to_datetime(metadata['timestamp'], errors='coerce')
-    sorted_metadata = metadata.sort_values('timestamp', ascending=False).head(int(num_items))
-    display_df = sorted_metadata[['id', 'text', 'ethnicity', 'region', 'timestamp']].copy()
-    display_df['timestamp'] = display_df['timestamp'].dt.strftime('%Y-%m-%d %H:%M').fillna('N/A')
-    return display_df.reset_index(drop=True)
+    if not local_ratings: return "सिंक गर्न कुनै स्थानीय मूल्याङ्कन छैन।"
 
-def get_recording_audio(recording_id):
-    if not recording_id: return None, "कुनै रेकर्डिङ आईडी प्रदान गरिएको छैन। (No recording ID provided.)"
-    if not os.path.exists(METADATA_FILE): return None, "मेटाडाटा फाइल भेटिएन। (Metadata file not found.)"
-    try:
-        metadata = pd.read_csv(METADATA_FILE)
-    except pd.errors.EmptyDataError:
-        return None, "मेटाडाटा खाली छ। (Metadata is empty.)"
+    api = HfApi(token=hf_token)
+    fs = HfFileSystem(token=hf_token) # For checking file existence
 
-    recording = metadata[metadata['id'] == recording_id]
-    if len(recording) == 0: return None, "रेकर्डिङ भेटिएन। (Recording not found.)"
-
-    audio_path = recording['audio_path'].iloc[0]
-    text = recording['text'].iloc[0]
-    if not os.path.exists(audio_path): return None, f"अडियो फाइल भेटिएन: {audio_path} (Audio file not found: {audio_path})"
-    return audio_path, text
+    success_count = 0
+    failure_count = 0
+    messages = []
 
-def get_recording_ratings(recording_id):
-    if not recording_id: return "रेकर्डिङ आईडी चयन गर्नुहोस्। (Select a Recording ID.)"
-    if not os.path.exists(RATINGS_FILE): return "डाटा भेटिएन। (No ratings data found.)"
+    for rec_id, ratings_data in local_ratings.items():
+        # Only sync if there are any votes/scores
+        if not any(ratings_data.values()):
+            continue
 
-    with open(RATINGS_FILE, 'r') as f:
-        ratings = json.load(f)
-    if recording_id not in ratings: return "यस रेकर्डिङको लागि कुनै मूल्याङ्कन भेटिएन। (No ratings found for this recording.)"
+        hf_ratings_path = f"ratings_entries/{rec_id}.json"
+        try:
+            # Optional: Check if ratings on HF are older or different before uploading.
+            # For simplicity, we'll just overwrite/create.
+            api.upload_file(
+                path_or_fileobj=io.BytesIO(json.dumps(ratings_data, ensure_ascii=False, indent=2).encode('utf-8')),
+                path_in_repo=hf_ratings_path,
+                repo_id=target_hf_repo_id,
+                repo_type="dataset",
+                commit_message=f"chore: Sync ratings for recording {rec_id}"
+            )
+            success_count += 1
+            log_hf_upload_attempt(rec_id, target_hf_repo_id, "ratings_sync", "success")
+            messages.append(f"SUCCESS: Synced ratings for {rec_id}")
+        except Exception as e:
+            failure_count += 1
+            err_msg = f"FAILURE syncing ratings for {rec_id}: {str(e)}"
+            messages.append(err_msg)
+            log_hf_upload_attempt(rec_id, target_hf_repo_id, "ratings_sync", "failure", str(e))
 
-    r = ratings[recording_id]
-    upvotes = r.get("upvotes", 0)
-    downvotes = r.get("downvotes", 0)
-    quality = round(r.get("quality_score",0), 1) if r.get("quality_votes",0) > 0 else 0
-    quality_votes = r.get("quality_votes",0)
-    correctness = round(r.get("correctness_score",0), 1) if r.get("correctness_votes",0) > 0 else 0
-    correctness_votes = r.get("correctness_votes",0)
+    return f"मूल्याङ्कन सिंक सम्पन्न। सफलता: {success_count}, असफलता: {failure_count}\n" + "\n".join(messages)
 
-    return f"""👍 Upvotes: {upvotes} | 👎 Downvotes: {downvotes}
-गुणस्तर (Quality): {quality}/5 ({quality_votes} मत/votes)
-शुद्धता (Correctness): {correctness}/5 ({correctness_votes} मत/votes)"""
 
 # --- Gradio UI Build ---
 def build_ui():
-    with gr.Blocks(title="नेपाली ASR डाटा संकलन (Nepali ASR Data Collection)") as app:
+    with gr.Blocks(title="नेपाली ASR डाटा संकलन") as app:
         gr.Markdown("# नेपाली ASR डाटा संकलन (Nepali ASR Data Collection)")
-        gr.Markdown(
-            "यस प्लेटफर्मले नेपाली भाषाको स्वचालित भाषण पहिचान (ASR) प्रविधिको विकासका लागि आवाज डाटा संकलन गर्दछ। "
-            "कृपया आफ्नो आवाज रेकर्ड गरेर योगदान दिनुहोस्।\n"
-            "*This platform collects voice data for the development of Nepali Automatic Speech Recognition (ASR) technology. "
-            "Please contribute by recording your voice.*"
-        )
+        # ... (Your existing Markdown intro) ...
 
-        # --- Data Collection Tabs ---
         with gr.Tabs():
             with gr.TabItem("१. आवाज रेकर्ड गर्नुहोस् (Record Voice)"):
                 with gr.Tabs():
                     with gr.TabItem("स्वतन्त्र पाठ (Free Text)"):
-                        with gr.Row():
-                            with gr.Column(scale=2):
-                                free_text_input = gr.Textbox(label="तपाईंले बोल्न चाहनुभएको पाठ (Text you want to speak)", placeholder="यहाँ लेख्नुहोस्...", lines=3)
-                                free_audio_input = gr.Audio(label="आवाज रेकर्ड गर्नुहोस् (Record your voice)", type="filepath", source="microphone")
-                            with gr.Column(scale=3):
-                                with gr.Row():
-                                    free_gender_dd = gr.Dropdown(label="लिङ्ग (Gender)", choices=GENDERS, value=GENDERS[0])
-                                    free_age_dd = gr.Dropdown(label="उमेर समूह (Age Group)", choices=AGE_GROUPS, value=AGE_GROUPS[1])
-                                with gr.Row():
-                                    free_ethnicity_dd = gr.Dropdown(label="जातीयता (Ethnicity)", choices=list(COMMON_LAST_NAMES.keys()), value=list(COMMON_LAST_NAMES.keys())[0])
-                                    free_lastname_dd = gr.Dropdown(label="थर (Last Name)", choices=COMMON_LAST_NAMES[list(COMMON_LAST_NAMES.keys())[0]])
-                                free_ethnicity_dd.change(fn=get_ethnicity_based_last_names, inputs=free_ethnicity_dd, outputs=free_lastname_dd)
-                                with gr.Row():
-                                    free_region_dd = gr.Dropdown(label="क्षेत्र (Region)", choices=REGIONS, value=REGIONS[2])
-                                    free_emotion_dd = gr.Dropdown(label="भावना (Emotion)", choices=EMOTIONS, value=EMOTIONS[0])
-                        free_submit_btn = gr.Button("सुरक्षित गर्नुहोस् (Save Free Text Recording)")
-                        free_status_output = gr.Textbox(label="स्थिति (Status)", interactive=False)
+                        # ... (UI elements as before, but change .click) ...
+                        free_audio_input = gr.Audio(label="आवाज रेकर्ड गर्नुहोस्", type="filepath", sources=["microphone"]) # Corrected
+                        free_text_input = gr.Textbox(label="पाठ", placeholder="यहाँ लेख्नुहोस्...", lines=3)
+                        # ... (gender, age, ethnicity, lastname, region, emotion dropdowns) ...
+                        free_gender_dd = gr.Dropdown(label="लिङ्ग", choices=GENDERS, value=GENDERS[0])
+                        free_age_dd = gr.Dropdown(label="उमेर समूह", choices=AGE_GROUPS, value=AGE_GROUPS[1])
+                        free_ethnicity_dd = gr.Dropdown(label="जातीयता", choices=list(COMMON_LAST_NAMES.keys()), value=list(COMMON_LAST_NAMES.keys())[0])
+                        free_lastname_dd = gr.Dropdown(label="थर", choices=COMMON_LAST_NAMES[list(COMMON_LAST_NAMES.keys())[0]])
+                        free_ethnicity_dd.change(fn=get_ethnicity_based_last_names, inputs=free_ethnicity_dd, outputs=free_lastname_dd)
+                        free_region_dd = gr.Dropdown(label="क्षेत्र", choices=REGIONS, value=REGIONS[2])
+                        free_emotion_dd = gr.Dropdown(label="भावना", choices=EMOTIONS, value=EMOTIONS[0])
+
+                        free_submit_btn = gr.Button("सुरक्षित र अपलोड गर्नुहोस्")
+                        free_status_output = gr.Textbox(label="स्थिति", interactive=False, lines=3)
                         free_submit_btn.click(
-                            save_recording,
+                            save_and_direct_upload_recording,
                             inputs=[free_audio_input, free_text_input, free_gender_dd, free_age_dd, free_ethnicity_dd, free_lastname_dd, free_region_dd, free_emotion_dd, gr.Textbox(value="free_text", visible=False)],
-                            outputs=[free_status_output, free_audio_input] # Clear audio on success
+                            outputs=[free_status_output, free_audio_input]
                         )
 
                     with gr.TabItem("निर्देशित पाठ (Prompted Text)"):
-                        with gr.Row():
-                            with gr.Column(scale=2):
-                                prompt_text_display = gr.Textbox(label="कृपया यो पाठ पढ्नुहोस् (Please read this text)", value=get_random_prompt(), lines=3, interactive=False)
-                                new_prompt_btn = gr.Button("नयाँ पाठ (New Prompt)")
-                                prompt_audio_input = gr.Audio(label="आवाज रेकर्ड गर्नुहोस् (Record your voice)", type="filepath", source="microphone")
-                            with gr.Column(scale=3):
-                                with gr.Row():
-                                    prompt_gender_dd = gr.Dropdown(label="लिङ्ग (Gender)", choices=GENDERS, value=GENDERS[0])
-                                    prompt_age_dd = gr.Dropdown(label="उमेर समूह (Age Group)", choices=AGE_GROUPS, value=AGE_GROUPS[1])
-                                with gr.Row():
-                                    prompt_ethnicity_dd = gr.Dropdown(label="जातीयता (Ethnicity)", choices=list(COMMON_LAST_NAMES.keys()), value=list(COMMON_LAST_NAMES.keys())[0])
-                                    prompt_lastname_dd = gr.Dropdown(label="थर (Last Name)", choices=COMMON_LAST_NAMES[list(COMMON_LAST_NAMES.keys())[0]])
-                                prompt_ethnicity_dd.change(fn=get_ethnicity_based_last_names, inputs=prompt_ethnicity_dd, outputs=prompt_lastname_dd)
-                                with gr.Row():
-                                    prompt_region_dd = gr.Dropdown(label="क्षेत्र (Region)", choices=REGIONS, value=REGIONS[2])
-                                    prompt_emotion_dd = gr.Dropdown(label="भावना (Emotion)", choices=EMOTIONS, value=EMOTIONS[0])
+                        # ... (UI elements as before, but change .click) ...
+                        prompt_text_display = gr.Textbox(label="कृपया यो पाठ पढ्नुहोस्", value=get_random_prompt(), lines=3, interactive=False)
+                        new_prompt_btn = gr.Button("नयाँ पाठ")
+                        prompt_audio_input = gr.Audio(label="आवाज रेकर्ड गर्नुहोस्", type="filepath", sources=["microphone"]) # Corrected
+                        # ... (gender, age, ethnicity, lastname, region, emotion dropdowns) ...
+                        prompt_gender_dd = gr.Dropdown(label="लिङ्ग", choices=GENDERS, value=GENDERS[0])
+                        prompt_age_dd = gr.Dropdown(label="उमेर समूह", choices=AGE_GROUPS, value=AGE_GROUPS[1])
+                        prompt_ethnicity_dd = gr.Dropdown(label="जातीयता", choices=list(COMMON_LAST_NAMES.keys()), value=list(COMMON_LAST_NAMES.keys())[0])
+                        prompt_lastname_dd = gr.Dropdown(label="थर", choices=COMMON_LAST_NAMES[list(COMMON_LAST_NAMES.keys())[0]])
+                        prompt_ethnicity_dd.change(fn=get_ethnicity_based_last_names, inputs=prompt_ethnicity_dd, outputs=prompt_lastname_dd)
+                        prompt_region_dd = gr.Dropdown(label="क्षेत्र", choices=REGIONS, value=REGIONS[2])
+                        prompt_emotion_dd = gr.Dropdown(label="भावना", choices=EMOTIONS, value=EMOTIONS[0])
+
                         new_prompt_btn.click(get_random_prompt, outputs=prompt_text_display)
-                        prompt_submit_btn = gr.Button("सुरक्षित गर्नुहोस् (Save Prompted Recording)")
-                        prompt_status_output = gr.Textbox(label="स्थिति (Status)", interactive=False)
+                        prompt_submit_btn = gr.Button("सुरक्षित र अपलोड गर्नुहोस्")
+                        prompt_status_output = gr.Textbox(label="स्थिति", interactive=False, lines=3)
                         prompt_submit_btn.click(
-                            save_recording,
+                            save_and_direct_upload_recording,
                             inputs=[prompt_audio_input, prompt_text_display, prompt_gender_dd, prompt_age_dd, prompt_ethnicity_dd, prompt_lastname_dd, prompt_region_dd, prompt_emotion_dd, gr.Textbox(value="prompted_text", visible=False)],
                             outputs=[prompt_status_output, prompt_audio_input]
                         )
 
-            with gr.TabItem("२. रेकर्डिङ समीक्षा गर्नुहोस् (Review Recordings)"):
-                gr.Markdown("हालसालैका रेकर्डिङहरू हेर्नुहोस् र मत दिनुहोस्। (View and vote on recent recordings.)")
-                num_review_items = gr.Number(value=10, label="देखाउने वस्तुहरूको संख्या (Number of items to show)", minimum=1, maximum=50, step=1)
-                refresh_review_list_btn = gr.Button("सूची ताजा गर्नुहोस् (Refresh List)")
-                review_list_df = gr.DataFrame(headers=['id', 'text', 'ethnicity', 'region', 'timestamp'], label="हालका रेकर्डिङहरू (Recent Recordings)", interactive=False, datatype=['str', 'str', 'str', 'str', 'str'])
-
-                with gr.Row():
-                    selected_review_id = gr.Textbox(label="चयन गरिएको आईडी (Selected ID)", interactive=False)
-                    selected_review_text = gr.Textbox(label="रेकर्डिङ पाठ (Recording Text)", interactive=False, lines=2)
-                review_audio_player = gr.Audio(label="रेकर्डिङ सुन्नुहोस् (Listen to Recording)", type="filepath")
-                current_ratings_display = gr.Textbox(label="वर्तमान मूल्याङ्कन (Current Ratings)", interactive=False, lines=3)
+            with gr.TabItem("२. रेकर्डिङ समीक्षा गर्नुहोस् (Review Local Recordings)"):
+                gr.Markdown("स्थानीय रूपमा सुरक्षित गरिएका हालसालैका रेकर्डिङहरू हेर्नुहोस् र मत दिनुहोस्। (View and vote on recent locally saved recordings.)")
+                num_review_items = gr.Number(value=10, label="देखाउने वस्तुहरूको संख्या", minimum=1, maximum=50, step=1)
+                refresh_review_list_btn = gr.Button("स्थानीय सूची ताजा गर्नुहोस्")
+                review_list_df = gr.DataFrame(
+                    headers=['id', 'text', 'ethnicity', 'region', 'timestamp', 'hf_audio_uploaded', 'hf_metadata_uploaded'],
+                    label="हालका स्थानीय रेकर्डिङहरू", interactive=False,
+                    datatype=['str', 'str', 'str', 'str', 'str', 'bool', 'bool']
+                )
+                # ... (Rest of review UI, using get_local_recording_audio and get_local_recording_ratings) ...
+                selected_review_id = gr.Textbox(label="चयन गरिएको आईडी", interactive=False)
+                selected_review_text = gr.Textbox(label="रेकर्डिङ पाठ", interactive=False, lines=2)
+                review_audio_player = gr.Audio(label="रेकर्डिङ सुन्नुहोस्", type="filepath")
+                current_ratings_display = gr.Textbox(label="वर्तमान स्थानीय मूल्याङ्कन", interactive=False, lines=3)
 
                 def select_for_review(evt: gr.SelectData, df_data: pd.DataFrame):
                     if evt.index is None or df_data is None or len(df_data) == 0 or evt.index[0] >= len(df_data):
-                        return "", "", None, "कुनै रेकर्डिङ चयन गरिएको छैन (No recording selected)"
+                        return "", "", None, "कुनै रेकर्डिङ चयन गरिएको छैन"
                     selected_id_val = df_data.iloc[evt.index[0]]['id']
-                    audio_p, text_val = get_recording_audio(selected_id_val)
-                    ratings_text_val = get_recording_ratings(selected_id_val)
+                    audio_p, text_val = get_local_recording_audio(selected_id_val) # Use local getter
+                    ratings_text_val = get_local_recording_ratings(selected_id_val) # Use local getter
                     return selected_id_val, text_val, audio_p, ratings_text_val
 
                 review_list_df.select(select_for_review, inputs=[review_list_df], outputs=[selected_review_id, selected_review_text, review_audio_player, current_ratings_display])
-                refresh_review_list_btn.click(list_recordings, inputs=[num_review_items], outputs=review_list_df)
-
-                gr.Markdown("### मतदान गर्नुहोस् (Cast Your Vote)")
-                with gr.Row():
-                    upvote_btn = gr.Button("👍 मन पर्यो (Upvote)")
-                    downvote_btn = gr.Button("👎 मन परेन (Downvote)")
-                with gr.Row():
-                    quality_rating_slider = gr.Slider(minimum=1, maximum=5, step=1, label="गुणस्तर मूल्याङ्कन (Quality Rating 1-5)", value=3)
-                    submit_quality_btn = gr.Button("गुणस्तर मत दिनुहोस् (Submit Quality)")
-                with gr.Row():
-                    correctness_rating_slider = gr.Slider(minimum=1, maximum=5, step=1, label="शुद्धता मूल्याङ्कन (Correctness Rating 1-5)", value=3)
-                    submit_correctness_btn = gr.Button("शुद्धता मत दिनुहोस् (Submit Correctness)")
-                vote_status_output = gr.Textbox(label="मतदान स्थिति (Voting Status)", interactive=False)
-
-                def vote_and_refresh(rec_id, vote_t, vote_val_str):
-                    status = vote_recording(rec_id, vote_t, str(vote_val_str)) # Ensure vote_val is str
-                    new_ratings = get_recording_ratings(rec_id) if rec_id else "रेकर्डिङ चयन गर्नुहोस् (Select a recording)"
-                    # Also refresh the main list to reflect potential score changes indirectly
-                    # latest_list = list_recordings(num_review_items.value) # This needs to be handled carefully to avoid component errors
+                refresh_review_list_btn.click(list_local_recordings, inputs=[num_review_items], outputs=review_list_df)
+
+                gr.Markdown("### स्थानीय मतदान गर्नुहोस् (Cast Your Local Vote)")
+                # ... (voting buttons as before, using vote_recording which now acts locally) ...
+                upvote_btn = gr.Button("👍 मन पर्यो")
+                downvote_btn = gr.Button("👎 मन परेन")
+                quality_rating_slider = gr.Slider(minimum=1, maximum=5, step=1, label="गुणस्तर मूल्याङ्कन", value=3)
+                submit_quality_btn = gr.Button("गुणस्तर मत दिनुहोस्")
+                correctness_rating_slider = gr.Slider(minimum=1, maximum=5, step=1, label="शुद्धता मूल्याङ्कन", value=3)
+                submit_correctness_btn = gr.Button("शुद्धता मत दिनुहोस्")
+                vote_status_output = gr.Textbox(label="मतदान स्थिति", interactive=False)
+
+                def vote_and_refresh_local(rec_id, vote_t, vote_val_str):
+                    status = vote_recording(rec_id, vote_t, str(vote_val_str))
+                    new_ratings = get_local_recording_ratings(rec_id) if rec_id else "रेकर्डिङ चयन गर्नुहोस्"
                     return status, new_ratings
 
-                upvote_btn.click(vote_and_refresh, inputs=[selected_review_id, gr.Textbox(value="upvote", visible=False), gr.Number(value=0, visible=False)], outputs=[vote_status_output, current_ratings_display])
-                downvote_btn.click(vote_and_refresh, inputs=[selected_review_id, gr.Textbox(value="downvote", visible=False), gr.Number(value=0, visible=False)], outputs=[vote_status_output, current_ratings_display])
-                submit_quality_btn.click(vote_and_refresh, inputs=[selected_review_id, gr.Textbox(value="quality", visible=False), quality_rating_slider], outputs=[vote_status_output, current_ratings_display])
-                submit_correctness_btn.click(vote_and_refresh, inputs=[selected_review_id, gr.Textbox(value="correctness", visible=False), correctness_rating_slider], outputs=[vote_status_output, current_ratings_display])
+                upvote_btn.click(vote_and_refresh_local, inputs=[selected_review_id, gr.Textbox(value="upvote", visible=False), gr.Number(value=0, visible=False)], outputs=[vote_status_output, current_ratings_display])
+                downvote_btn.click(vote_and_refresh_local, inputs=[selected_review_id, gr.Textbox(value="downvote", visible=False), gr.Number(value=0, visible=False)], outputs=[vote_status_output, current_ratings_display])
+                submit_quality_btn.click(vote_and_refresh_local, inputs=[selected_review_id, gr.Textbox(value="quality", visible=False), quality_rating_slider], outputs=[vote_status_output, current_ratings_display])
+                submit_correctness_btn.click(vote_and_refresh_local, inputs=[selected_review_id, gr.Textbox(value="correctness", visible=False), correctness_rating_slider], outputs=[vote_status_output, current_ratings_display])
 
-            with gr.TabItem("३. प्रगति र अपलोड (Progress & Upload)"):
-                gr.Markdown("## संकलन प्रगति (Collection Progress)")
-                total_count_display = gr.Textbox(label="कुल संकलित रेकर्डिङ (Total Recordings Collected)", interactive=False)
-                refresh_total_count_btn = gr.Button("गणना ताजा गर्नुहोस् (Refresh Count)")
-                refresh_total_count_btn.click(update_count, outputs=total_count_display)
 
+            with gr.TabItem("३. प्रशासक: सिंक र प्रगति (Admin: Sync & Progress)"):
+                gr.Markdown("## स्थानीय संकलन प्रगति (Local Collection Progress)")
+                total_count_display = gr.Textbox(label="स्थानीय तथ्याङ्क", interactive=False, lines=3)
+                refresh_total_count_btn = gr.Button("स्थानीय गणना ताजा गर्नुहोस्")
+                refresh_total_count_btn.click(update_local_count, outputs=total_count_display)
                 gr.Markdown("---")
-                gr.Markdown("## हगिङफेसमा अपलोड गर्नुहोस् (Upload to Hugging Face)")
-                gr.Markdown(
-                    "**महत्वपूर्ण:** यो कार्यले स्पेसमा संकलित सबै डाटालाई हगिङ फेस डेटासेटमा पुश गर्नेछ। "
-                    "स्पेसको स्टोरेज अस्थायी हुन सक्छ, त्यसैले नियमित रूपमा अपलोड गर्न सिफारिस गरिन्छ।\n"
-                    "यो कार्य गर्नको लागि, तपाईंले स्पेस सेटिङहरूमा `HF_TOKEN` (लेख्ने पहुँच सहितको हगिङ फेस टोकन) "
-                    "र `ADMIN_UPLOAD_PASSWORD` गोप्य रूपमा थप्नुपर्छ।\n\n"
-                    "**IMPORTANT:** This action will push all data collected in this Space to the Hugging Face Dataset. "
-                    "Space storage can be ephemeral, so regular uploads are recommended. "
-                    "To perform this action, you must have added `HF_TOKEN` (a Hugging Face token with write access) "
-                    "and `ADMIN_UPLOAD_PASSWORD` as secrets in the Space settings."
-                )
-                hf_dataset_name_input = gr.Textbox(label="Dataset Name (e.g., your_username/nepali-asr-data)", placeholder="your_hf_username/dataset_repo_name")
-                admin_password_input = gr.Textbox(label="Admin Upload Password", type="password", placeholder="Enter admin password")
-                upload_to_hf_btn = gr.Button("हगिङफेसमा अपलोड गर्नुहोस् (Upload to Hugging Face)")
-                upload_status_output = gr.Textbox(label="अपलोड स्थिति (Upload Status)", interactive=False, lines=5)
-                upload_to_hf_btn.click(upload_to_huggingface, inputs=[hf_dataset_name_input, admin_password_input], outputs=upload_status_output)
+                gr.Markdown("## प्रशासक कार्यहरू (Admin Actions)")
+                gr.Markdown("यी कार्यहरूका लागि प्रशासक पासवर्ड आवश्यक छ (गोप्यमा `ADMIN_UPLOAD_PASSWORD` को रूपमा सेट गरिएको)। "
+                            "HF टोकन र लक्ष्य रिपो आईडी पनि गोप्यमा (`HF_TOKEN`, `TARGET_HF_DATASET_REPO_ID`) हुनुपर्छ।")
+                admin_password_input_sync = gr.Textbox(label="प्रशासक पासवर्ड", type="password", placeholder="प्रशासक पासवर्��� प्रविष्ट गर्नुहोस्")
 
-            with gr.TabItem("४. जानकारी (Information)"):
-                gr.Markdown(render_info_page()) # Using a helper for cleaner code
+                with gr.Row():
+                    retry_failed_uploads_btn = gr.Button("असफल HF अपलोडहरू पुनः प्रयास गर्नुहोस्")
+                    sync_ratings_btn = gr.Button("स्थानीय मूल्याङ्कनहरू HF मा सिंक गर्नुहोस्")
+                admin_action_status_output = gr.Textbox(label="प्रशासक कार्य स्थिति", interactive=False, lines=10)
 
-        # Initial loads
-        app.load(fn=update_count, inputs=None, outputs=total_count_display)
-        app.load(fn=lambda n: list_recordings(n), inputs=[num_review_items], outputs=review_list_df) # Load initial review list
+                retry_failed_uploads_btn.click(admin_retry_failed_uploads, inputs=[admin_password_input_sync], outputs=admin_action_status_output)
+                sync_ratings_btn.click(admin_sync_ratings_to_hf, inputs=[admin_password_input_sync], outputs=admin_action_status_output)
+
+            with gr.TabItem("४. जानकारी (Information)"):
+                gr.Markdown(render_info_page())
 
+        app.load(fn=update_local_count, inputs=None, outputs=total_count_display)
+        app.load(fn=lambda n: list_local_recordings(n), inputs=[num_review_items], outputs=review_list_df)
     return app
 
 def render_info_page():
+    # ... (Your existing info page content is fine) ...
     return """
     ## नेपाली ASR डाटा संकलन प्रोजेक्टको बारेमा (About the Nepali ASR Data Collection Project)
-    
     यो प्रोजेक्टले नेपाली भाषाको स्वचालित भाषण पहिचान (ASR) प्रविधिको विकासका लागि आवश्यक डाटा संकलन गर्दछ। 
-    तपाईंको योगदानले नेपाली भाषा प्रविधिको विकासमा ठूलो मद्दत पुर्‍याउनेछ।
-    
+    तपाईंको प्रत्येक रेकर्डिङ सिधै हाम्रो खुला हगिङ फेस डेटासेटमा योगदान गरिनेछ।
     ### कसरी योगदान दिने (How to Contribute):
-    1.  **आवाज रेकर्ड गर्नुहोस् (Record Voice)** ट्याबमा जानुहोस्।
-        *   **स्वतन्त्र पाठ (Free Text)** अन्तर्गत, तपाईं आफ्नो इच्छा अनुसारको पाठ लेख्नुहोस्, आवश्यक विवरणहरू (लिङ्ग, उमेर, आदि) छान्नुहोस्, र आफ्नो आवाज रेकर्ड गर्नुहोस्।
-        *   **निर्देशित पाठ (Prompted Text)** अन्तर्गत, दिइएको नेपाली वाक्य पढ्नुहोस्, विवरणहरू छान्नुहोस्, र आफ्नो आवाज रेकर्ड गर्नुहोस्। "नयाँ पाठ" बटनले तपाईंलाई फरक वाक्य दिनेछ।
-    2.  **रेकर्डिङ समीक्षा गर्नुहोस् (Review Recordings)** ट्याबमा गएर अरूले गरेका रेकर्डिङहरू सुन्नुहोस् र तिनीहरूको गुणस्तर र शुद्धताको लागि मतदान गर्नुहोस्। यसले डाटाको गुणस्तर सुधार गर्न मद्दत गर्दछ।
-    3.  रेकर्डिङ पछि, "सुरक्षित गर्नुहोस् (Save)" बटनमा क्लिक गर्नुहोस्।
-    
+    1.  **आवाज रेकर्ड गर्नुहोस् (Record Voice)** ट्याबमा जानुहोस् र आफ्नो आवाज रेकर्ड गर्नुहोस्।
+    2.  **रेकर्डिङ समीक्षा गर्नुहोस् (Review Local Recordings)** ट्याबमा गएर अरूले गरेका (वा तपाईंले गरेका) स्थानीय रूपमा सुरक्षित गरिएका रेकर्डिङहरू सुन्नुहोस् र मत दिनुहोस्। यी मतहरू पछि हगिङ फेसमा सिंक गर्न सकिन्छ।
     ### गोपनीयता नीति (Privacy Policy):
-    -   तपाईंको आव��ज रेकर्डिङ र सम्बन्धित मेटाडाटा (जस्तै उमेर समूह, लिङ्ग, क्षेत्र) सार्वजनिक अनुसन्धान उद्देश्यका लागि प्रयोग गरिनेछ।
-    -   हामी तपाईंको नाम वा सम्पर्क जानकारी जस्ता प्रत्यक्ष व्यक्तिगत पहिचान योग्य जानकारी सङ्कलन गर्दैनौं। तपाईंले प्रदान गर्नुभएको जातीयता/थरको जानकारी उच्चारण र विविधता अध्ययनको लागि हो।
-    -   यो डाटासेट खुला स्रोत हुनेछ र हगिङ फेस जस्ता प्लेटफर्महरूमा अनुसन्धान समुदायको लागि उपलब्ध गराइनेछ।
-    -   कृपया रेकर्डिङको क्रममा कुनै पनि संवेदनशील व्यक्तिगत जानकारी नबोल्नुहोस्।
-    
-    ---
-    
-    ## About Nepali ASR Data Collection Project
-    
-    This project collects voice data essential for developing Automatic Speech Recognition (ASR) technology for the Nepali language.
-    Your contribution will significantly aid in the advancement of Nepali language technology.
-    
-    ### How to Contribute:
-    1.  Go to the **Record Voice (आवाज रेकर्ड गर्नुहोस्)** tab.
-        *   Under **Free Text (स्वतन्त्र पाठ)**, type any Nepali text you wish, select the required demographic details (gender, age, etc.), and record your voice.
-        *   Under **Prompted Text (निर्देशित पाठ)**, read the provided Nepali sentence, select demographic details, and record your voice. The "New Text (नयाँ पाठ)" button will give you a different sentence.
-    2.  Go to the **Review Recordings (रेकर्डिङ समीक्षा गर्नुहोस्)** tab to listen to recordings made by others and vote on their quality and correctness. This helps improve the overall quality of the dataset.
-    3.  After recording, click the "Save (सुरक्षित गर्नुहोस्)" button.
-    
-    ### Privacy Policy:
-    -   Your voice recordings and associated metadata (like age group, gender, region) will be used for public research purposes.
-    -   We do not collect directly personally identifiable information such as your name or contact details. The ethnicity/last name information you provide is for studying accent and diversity.
-    -   This dataset will be open-source and made available to the research community on platforms like Hugging Face.
-    -   Please do not speak any sensitive personal information during your recordings.
-    """
+    -   तपाईंको आवाज रेकर्डिङ र मेटाडाटा सार्वजनिक अनुसन्धान उद्देश्यका लागि हगिङ फेसमा खुला रूपमा उपलब्ध हुनेछ।
+    -   कृपया व्यक्तिगत पहिचान गर्न सकिने जानकारी शेयर नगर्नुहोस्।
+    """ # Keep your more detailed version
 
 # --- Main Execution ---
 if __name__ == "__main__":
-    # Ensure storage is initialized when running locally too
     initialize_data_storage()
-    
     app_ui = build_ui()
     app_ui.launch()