Add download aliases button to UI

alias_store.py

@@ -1,42 +1,21 @@
 """
-alias_store.py — Manages the school_aliases.json file stored on HuggingFace.
-
-Schema:
-{
-  "18050406004": {
-    "names": [
-      {"name": "SARUPETA GIRLS HE SCHOOL", "year_month": "2025-07", "source": "Old Master"}
-    ],
-    "last_updated": "2026-07-07"
-  }
-}
+alias_store.py — Manages the school_aliases.csv file stored on HuggingFace.
 """
 
 import os
-import json
 import tempfile
+import pandas as pd
 from datetime import datetime, timezone
 from huggingface_hub import HfApi, hf_hub_download
 
 HF_TOKEN = os.getenv("HF_TOKEN", "")
 HF_SCRAPER_REPO = os.getenv("HF_SCRAPER_REPO", "")
-ALIAS_FILE = "school_aliases.json"
-
-
-def _migrate_names(names: list) -> list[dict]:
-    migrated = []
-    for item in names:
-        if isinstance(item, str):
-            migrated.append({"name": item, "year_month": "", "source": "Unknown (Migrated)"})
-        elif isinstance(item, dict):
-            migrated.append(item)
-    return migrated
-
+ALIAS_FILE = "school_aliases.csv"
 
 def load_aliases() -> dict:
     """
-    Download and return the alias dictionary from HF as a Python dict.
-    Returns an empty dict {} if the file doesn't exist yet.
+    Download the CSV from HF, parse it, and return a dictionary identical to 
+    the old JSON format so that app.py doesn't have to change at all!
     """
     if not HF_SCRAPER_REPO:
         return {}
@@ -48,25 +27,39 @@ def load_aliases() -> dict:
             token=HF_TOKEN or None,
             force_download=True,
         )
-        with open(path, "r", encoding="utf-8") as f:
-            data = json.load(f)
-            # Migrate old string arrays to object arrays on load
-            for udise, info in data.items():
-                if "names" in info:
-                    info["names"] = _migrate_names(info["names"])
-            return data
+        df = pd.read_csv(path)
+        
+        data = {}
+        for _, row in df.iterrows():
+            code = str(row["UDISE_Code"]).strip()
+            name = str(row["Alias_Name"]).strip()
+            source = str(row["Source"]).strip()
+            
+            # Handle empty values gracefully
+            ym = str(row["Year_Month"]) if pd.notna(row["Year_Month"]) else ""
+            if ym == "nan": ym = ""
+            
+            lu = str(row["Last_Updated"]) if pd.notna(row["Last_Updated"]) else ""
+            if lu == "nan": lu = ""
+            
+            if code not in data:
+                data[code] = {"names": [], "last_updated": lu}
+            
+            data[code]["names"].append({
+                "name": name,
+                "source": source,
+                "year_month": ym
+            })
+        return data
     except Exception as e:
         if "404" in str(e) or "not found" in str(e).lower() or "Entry Not Found" in str(e):
             return {}
-        print(f"[alias_store] Error loading aliases: {e}")
+        print(f"[alias_store] Error loading CSV aliases: {e}")
         return {}
 
-
 def save_aliases(new_entries: list[dict]) -> str:
     """
-    Upsert new alias entries into the cloud JSON.
-
-    Each entry should have: udise_code, alias_name, source_label
+    Upsert new alias entries into the cloud CSV.
     """
     if not HF_SCRAPER_REPO:
         return "⚠️ HF_SCRAPER_REPO is not configured — cannot save aliases."
@@ -74,45 +67,59 @@ def save_aliases(new_entries: list[dict]) -> str:
         return "⚠️ No entries provided."
 
     today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
-    data = load_aliases()
+    
+    try:
+        path = hf_hub_download(
+            repo_id=HF_SCRAPER_REPO,
+            filename=ALIAS_FILE,
+            repo_type="dataset",
+            token=HF_TOKEN or None,
+            force_download=True,
+        )
+        df = pd.read_csv(path)
+    except Exception:
+        # File might not exist yet
+        df = pd.DataFrame(columns=["UDISE_Code", "Alias_Name", "Source", "Year_Month", "Last_Updated"])
 
     added_count = 0
     skipped_count = 0
+    new_rows = []
 
     for entry in new_entries:
         code = str(entry.get("udise_code", "")).strip()
         name = str(entry.get("alias_name", "")).strip()
         source = str(entry.get("source_label", "")).strip()
-        year_month = str(entry.get("year_month", "")).strip()
+        ym = str(entry.get("year_month", "")).strip()
         
         if not code or not name:
             continue
 
-        if code not in data:
-            data[code] = {"names": [], "last_updated": today}
-
-        existing_upper = {n["name"].upper() for n in data[code]["names"]}
-        
-        if name.upper() in existing_upper:
-            skipped_count += 1
-            continue
-
-        data[code]["names"].append({
-            "name": name,
-            "source": source,
-            "year_month": year_month
+        # Check if alias already exists (case-insensitive) for this UDISE
+        if not df.empty:
+            mask = (df["UDISE_Code"].astype(str).str.strip() == code) & (df["Alias_Name"].astype(str).str.strip().str.upper() == name.upper())
+            if mask.any():
+                skipped_count += 1
+                continue
+
+        new_rows.append({
+            "UDISE_Code": code,
+            "Alias_Name": name,
+            "Source": source,
+            "Year_Month": ym,
+            "Last_Updated": today
         })
-        data[code]["last_updated"] = today
         added_count += 1
 
     if added_count == 0:
-        return f"ℹ️ All {skipped_count} name(s) already in dictionary — nothing new to save."
+        return f"ℹ️ All {skipped_count} name(s) already in CSV — nothing new to save."
+
+    df = pd.concat([df, pd.DataFrame(new_rows)], ignore_index=True)
 
     # Upload to HF
     try:
         api = HfApi()
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False, encoding="utf-8") as f:
-            json.dump(data, f, indent=2, ensure_ascii=False)
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".csv", delete=False, encoding="utf-8") as f:
+            df.to_csv(f.name, index=False)
             tmp_path = f.name
 
         udise_sample = new_entries[0].get("udise_code", "unknown")
@@ -139,8 +146,9 @@ def get_names_for_udise(udise_code: str) -> list[dict]:
     data = load_aliases()
     return data.get(str(udise_code).strip(), {}).get("names", [])
 
+
 def delete_alias(udise_code: str, alias_name: str) -> str:
-    """Delete a specific alias name for a UDISE code from the cloud JSON."""
+    """Delete a specific alias name for a UDISE code from the cloud CSV."""
     if not HF_SCRAPER_REPO:
         return "⚠️ HF_SCRAPER_REPO is not configured — cannot delete aliases."
         
@@ -149,29 +157,33 @@ def delete_alias(udise_code: str, alias_name: str) -> str:
     
     if not code or not name_to_delete:
         return "⚠️ Invalid UDISE code or name."
-
-    data = load_aliases()
-    if code not in data:
-        return "⚠️ UDISE code not found in saved aliases."
-
-    original_count = len(data[code].get("names", []))
-    data[code]["names"] = [
-        n for n in data[code].get("names", [])
-        if n.get("name", "").strip().upper() != name_to_delete
-    ]
+        
+    try:
+        path = hf_hub_download(
+            repo_id=HF_SCRAPER_REPO,
+            filename=ALIAS_FILE,
+            repo_type="dataset",
+            token=HF_TOKEN or None,
+            force_download=True,
+        )
+        df = pd.read_csv(path)
+    except Exception:
+        return "⚠️ CSV file not found on HuggingFace."
+        
+    mask = (df["UDISE_Code"].astype(str).str.strip() == code) & (df["Alias_Name"].astype(str).str.strip().str.upper() == name_to_delete)
     
-    if len(data[code]["names"]) == original_count:
+    if not mask.any():
         return f"⚠️ Alias '{alias_name}' not found for UDISE {code}."
-
-    data[code]["last_updated"] = datetime.now(timezone.utc).strftime("%Y-%m-%d")
-
-    # Upload to HF
+        
+    # Keep everything EXCEPT the matching row
+    df = df[~mask]
+    
     try:
         api = HfApi()
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False, encoding="utf-8") as f:
-            json.dump(data, f, indent=2, ensure_ascii=False)
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".csv", delete=False, encoding="utf-8") as f:
+            df.to_csv(f.name, index=False)
             tmp_path = f.name
-
+            
         api.upload_file(
             path_or_fileobj=tmp_path,
             path_in_repo=ALIAS_FILE,
@@ -180,7 +192,6 @@ def delete_alias(udise_code: str, alias_name: str) -> str:
             token=HF_TOKEN or None,
             commit_message=f"Delete alias '{alias_name}' for UDISE {code}",
         )
-
         return f"🗑️ Deleted '{alias_name}' successfully!"
     except Exception as e:
         return f"❌ Failed to delete alias: {e}"

app.py

@@ -473,6 +473,47 @@ with gr.Blocks(title="School Name Resolver") as app:
                         outputs=[status_text, render_trigger]
                     )
 
+    # ── Download Master Sheet ──
+    gr.HTML('<div style="margin-top: 20px;"></div>')
+    download_aliases_btn = gr.DownloadButton("📥 Download Aliases Master Sheet (Excel)", elem_classes="btn-secondary", size="lg")
+    
+    def on_download_aliases():
+        from huggingface_hub import hf_hub_download
+        import os
+        import pandas as pd
+        import tempfile
+        
+        token = os.getenv("HF_TOKEN")
+        repo = os.getenv("HF_SCRAPER_REPO")
+        if not token or not repo: return None
+        try:
+            path = hf_hub_download(
+                repo_id=repo,
+                filename="school_aliases.csv",
+                repo_type="dataset",
+                token=token,
+                force_download=True,
+            )
+            
+            # Convert the CSV into a true Excel (.xlsx) file on the fly!
+            df = pd.read_csv(path)
+            
+            import datetime
+            date_str = datetime.datetime.now().strftime("%b_%Y")
+            download_name = f"school_aliases_{date_str}.xlsx"
+            
+            temp_dir = tempfile.mkdtemp()
+            out_path = os.path.join(temp_dir, download_name)
+            df.to_excel(out_path, index=False)
+            
+            return out_path
+            
+        except Exception as e:
+            print(f"Error downloading for UI: {e}")
+            return None
+            
+    download_aliases_btn.click(fn=on_download_aliases, outputs=[download_aliases_btn])
+
     # ── Settings ──
     with gr.Accordion("⚙️  Settings & Cache", open=False):
         refresh_cache_btn = gr.Button("🔄 Refresh Data Cache", elem_classes="btn-secondary")