Fix Self-Teaching tab: float sliders, deduplication, Kaggle API fallback

- Cast slider values to int (Gradio returns float; broke Wikipedia aplimit
and Kaggle ds.take() in notebook Cell 9)
- Deduplicate dataset_sources.jsonl on each HF import (avoid loading same
dataset multiple times per training run)
- Kaggle trigger: try Python API (KaggleApiExtended) first to avoid binary
PATH issues; subprocess + shutil.which as fallback
- Fix Fula dataset registry: fleurs uses legacy script loader incompatible
with datasets>=3.0; switch to google/WaxalNLP ful_asr
- Fix UI description: HF import writes to dataset_sources.jsonl (streamed
by Kaggle), not to corrections.jsonl

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app.py

@@ -609,27 +609,62 @@ def _count_corrections() -> int:
 
 def _trigger_kaggle_training(lang: str = "bam") -> str:
     """
-    Push the master trainer notebook to Kaggle via the kaggle CLI,
-    which creates a new kernel version (i.e. triggers a run).
+    Push the master trainer notebook to Kaggle, creating a new kernel version
+    (i.e. triggering a run). Requires KAGGLE_USERNAME + KAGGLE_KEY secrets.
 
-    Requires KAGGLE_USERNAME + KAGGLE_KEY Space secrets.
-    The notebook is read from notebooks/ inside the Space filesystem.
+    Tries the Python API first (no PATH issues), falls back to subprocess.
     """
     if not KAGGLE_USERNAME or not KAGGLE_KEY:
         return "⚠️ KAGGLE_USERNAME / KAGGLE_KEY not set in Space secrets."
 
-    import subprocess
-
     notebooks_dir = ROOT / "notebooks"
-    meta_file     = notebooks_dir / "kernel-metadata.json"
-    nb_file       = notebooks_dir / "kaggle_master_trainer.ipynb"
+    nb_file   = notebooks_dir / "kaggle_master_trainer.ipynb"
+    meta_file = notebooks_dir / "kernel-metadata.json"
 
     if not nb_file.exists():
         return "❌ notebooks/kaggle_master_trainer.ipynb not found in Space."
     if not meta_file.exists():
         return "❌ notebooks/kernel-metadata.json not found in Space."
 
-    # Pass credentials directly as env vars (newer kaggle CLI ignores KAGGLE_CONFIG_DIR)
+    # Inject credentials into os.environ before any kaggle import —
+    # kaggle.authenticate() reads KAGGLE_USERNAME + KAGGLE_KEY from env.
+    os.environ["KAGGLE_USERNAME"] = KAGGLE_USERNAME
+    os.environ["KAGGLE_KEY"] = KAGGLE_KEY
+
+    # ── Method 1: Python API (no binary PATH issues) ─────────────────────────
+    api_err = None
+    try:
+        from kaggle.api.kaggle_api_extended import KaggleApiExtended
+        _kapi = KaggleApiExtended()
+        _kapi.authenticate()
+        _kapi.kernels_push_cli(str(notebooks_dir), quiet=True)
+        return (
+            "✅ Kaggle training triggered!\n"
+            f"Kernel: {KAGGLE_KERNEL_SLUG}\n"
+            "Check https://www.kaggle.com for run progress."
+        )
+    except Exception as e:
+        api_err = str(e)
+
+    # ── Method 2: subprocess fallback ────────────────────────────────────────
+    import subprocess, shutil
+    kaggle_bin = shutil.which("kaggle")
+    if kaggle_bin is None:
+        for cand in [
+            Path(sys.executable).parent / "kaggle",
+            Path("/usr/local/bin/kaggle"),
+            Path("/usr/bin/kaggle"),
+        ]:
+            if cand.exists():
+                kaggle_bin = str(cand)
+                break
+
+    if kaggle_bin is None:
+        return (
+            f"❌ Kaggle CLI not found (API error: {api_err}).\n"
+            "Ensure kaggle>=1.6.0 is in requirements.txt and the Space rebuilt."
+        )
+
     env = {
         **os.environ,
         "KAGGLE_USERNAME": KAGGLE_USERNAME,
@@ -637,18 +672,18 @@ def _trigger_kaggle_training(lang: str = "bam") -> str:
         "PYTHONUTF8": "1",
         "PYTHONIOENCODING": "utf-8",
     }
-
-    result = subprocess.run(
-        ["kaggle", "kernels", "push", "-p", str(notebooks_dir)],
-        capture_output=True, text=True, timeout=60, env=env,
-    )
-
-    if result.returncode == 0:
-        output = (result.stdout or "").strip()
-        return f"✅ Kaggle training triggered!\n{output or 'Kernel version created — check Kaggle for progress.'}"
-    else:
+    try:
+        result = subprocess.run(
+            [kaggle_bin, "kernels", "push", "-p", str(notebooks_dir)],
+            capture_output=True, text=True, timeout=60, env=env,
+        )
+        if result.returncode == 0:
+            out = (result.stdout or "").strip()
+            return f"✅ Kaggle training triggered!\n{out or 'Kernel version created.'}"
         err = (result.stderr or result.stdout or "unknown error").strip()
         return f"❌ Kaggle push failed:\n{err}"
+    except Exception as e:
+        return f"❌ Kaggle push failed (API: {api_err}) (CLI: {e})"
 
 
 def _maybe_auto_trigger() -> None:
@@ -807,6 +842,7 @@ def _harvest_wikipedia(lang_label: str, max_articles: int = 100) -> str:
     lang = SUPPORTED_LANGUAGES.get(lang_label, "bam")
     if lang not in ("bam", "ful"):
         return "⚠️ Supported for Bambara and Fula only."
+    max_articles = int(max_articles)  # Gradio slider returns float
 
     try:
         from src.data.web_harvester import harvest_wikipedia_text
@@ -839,31 +875,62 @@ def _harvest_hf_dataset(lang_label: str, max_samples: int = 500) -> str:
     lang = SUPPORTED_LANGUAGES.get(lang_label, "bam")
     if lang not in ("bam", "ful"):
         return "⚠️ Supported for Bambara and Fula only."
+    max_samples = int(max_samples)  # Gradio slider returns float
 
     from src.data.web_harvester import get_hf_dataset_refs
     refs = get_hf_dataset_refs(lang)
     if not refs:
         return f"⚠️ No HF dataset configured for {lang}."
 
-    # Write dataset references with user-requested max_samples cap
-    entries = []
+    # Read existing entries to avoid duplicates
+    from huggingface_hub import hf_hub_download
+    try:
+        local = hf_hub_download(
+            repo_id=FEEDBACK_REPO_ID, filename="dataset_sources.jsonl",
+            repo_type="dataset", token=HF_TOKEN,
+        )
+        with open(local, encoding="utf-8") as f:
+            existing_entries = [json.loads(l) for l in f if l.strip()]
+    except Exception:
+        existing_entries = []
+
+    existing_keys = {
+        (e.get("repo", e.get("repo_id", "")), e.get("config", ""))
+        for e in existing_entries
+    }
+
+    new_entries = []
+    already = []
     for ref in refs:
+        key = (ref.get("repo", ref.get("repo_id", "")), ref.get("config", ""))
+        if key in existing_keys:
+            already.append(ref["repo"])
+            continue
         entry = dict(ref)
-        entry["max"]       = max_samples
-        entry["enabled"]   = True
-        entry["added_at"]  = datetime.now(timezone.utc).isoformat()
-        entries.append(entry)
+        entry["max"]      = max_samples
+        entry["enabled"]  = True
+        entry["added_at"] = datetime.now(timezone.utc).isoformat()
+        new_entries.append(entry)
+
+    if not new_entries:
+        repos = ", ".join(already)
+        return (
+            f"✅ Already registered!\n"
+            f"  `{repos}` is already in your training config.\n"
+            f"  Click 'Trigger Training Now' to start a run with this data."
+        )
 
-    total, err = _upload_jsonl("dataset_sources.jsonl", entries)
+    total, err = _upload_jsonl("dataset_sources.jsonl", new_entries)
     if err:
         return f"❌ Upload failed: {err}"
 
     repos = ", ".join(r["repo"] for r in refs)
     return (
         f"✅ Dataset registered for training!\n"
-        f"  Source(s) : {repos}\n"
+        f"  Source(s)   : {repos}\n"
         f"  Max samples : {max_samples}\n"
-        f"  The Kaggle notebook will load this dataset directly at training time.\n"
+        f"  The Kaggle notebook will stream this dataset directly at training time.\n"
+        f"  Click 'Trigger Training Now' to start a training run.\n"
         f"  Total registered sources: {total}"
     )
 
@@ -1225,11 +1292,13 @@ def build_ui() -> gr.Blocks:
                     with gr.Column():
                         gr.Markdown(
                             "### 🤗 HuggingFace Dataset Import\n"
-                            "Pulls real audio + transcriptions from:\n"
+                            "Registers large public datasets as training sources:\n"
                             "- **Bambara**: `RobotsMali/jeli-asr` (33,000 samples)\n"
-                            "- **Fula**: `google/fleurs ff_sn`\n\n"
-                            "Samples are added to `corrections.jsonl` and counted toward "
-                            f"the auto-training threshold ({AUTO_TRAIN_THRESHOLD} entries)."
+                            "- **Fula**: `google/WaxalNLP ful_asr`\n\n"
+                            "This writes a reference to `dataset_sources.jsonl`. "
+                            "The Kaggle training notebook streams the dataset directly "
+                            "at training time — no re-upload needed.\n\n"
+                            "**One click is enough** — duplicates are ignored automatically."
                         )
                         hf_lang = gr.Dropdown(
                             choices=["Bambara (bam)", "Fula (ful)"],

src/data/web_harvester.py

@@ -40,8 +40,8 @@ HF_DATASET_REGISTRY = {
     ],
     "ful": [
         {
-            "repo":      "google/fleurs",
-            "config":    "ff_sn",
+            "repo":      "google/WaxalNLP",
+            "config":    "ful_asr",
             "split":     "train",
             "audio_col": "audio",
             "text_col":  "transcription",