Enable HF Space auto-sync env defaults and docs

README.md

@@ -43,7 +43,8 @@ Versi ini difokuskan untuk tahap awal:
 - **Menu Training** (accordion)
   - membaca dataset dari `dataset/train` dan `dataset/test`
   - jika label `.txt` YOLO belum ada, bisa aktifkan pseudo-label
-  - output model terbaik disimpan sebagai `best.pt`
+  - output model terbaik selalu di-overwrite ke `best.pt` setiap training selesai
+  - jika env Hugging Face diisi, `best.pt` otomatis di-sync ke repo HF
 
 Catatan:
 - input evaluasi batch dihapus.
@@ -59,8 +60,14 @@ Catatan:
 
 Opsional environment variable:
 - `MODEL_PATH` - path model lokal custom
-- `HF_MODEL_REPO` - repo model Hugging Face Hub
-- `HF_MODEL_FILE` - nama file model di Hub (default `yolov8n.pt`)
+- `HF_MODEL_REPO` - repo target Hugging Face (contoh: `firgiawann/KLP2`)
+- `HF_MODEL_FILE` - nama file model di Hub (disarankan: `best.pt`)
+- `HF_MODEL_REPO_TYPE` - tipe repo HF: `space` (default), `model`, atau `dataset`
+- `HF_TOKEN` - token untuk upload otomatis saat training selesai
+
+Catatan sync otomatis setelah training:
+- Jika `HF_MODEL_REPO` terisi, aplikasi akan upload `best.pt` ke `HF_MODEL_FILE`.
+- Jika tidak terisi, training tetap jalan normal dan hanya menyimpan `best.pt` lokal.
 
 ## Menjalankan Lokal
 

app.py

@@ -2,9 +2,12 @@ import io
 import os
 import shutil
 import asyncio
+import fnmatch
+import time
 from datetime import datetime
 from functools import lru_cache
 from pathlib import Path
+from threading import Thread
 from typing import Any, Dict, Tuple
 
 import cv2
@@ -12,7 +15,7 @@ import gradio as gr
 import matplotlib.pyplot as plt
 import numpy as np
 import seaborn as sns
-from huggingface_hub import hf_hub_download
+from huggingface_hub import CommitOperationAdd, CommitOperationDelete, HfApi, hf_hub_download
 from ultralytics import YOLO
 
 CM_INIT = {"tp": 0, "fp": 0, "fn": 0, "tn": 0}
@@ -60,8 +63,9 @@ def resolve_model_path(model_choice: str) -> str:
     hf_repo = os.getenv("HF_MODEL_REPO", "").strip()
     default_hf = "best.pt" if model_choice == "Best.pt" else "yolov8n.pt"
     hf_file = os.getenv("HF_MODEL_FILE", default_hf).strip()
+    hf_repo_type = os.getenv("HF_MODEL_REPO_TYPE", "space").strip() or "space"
     if hf_repo:
-        return hf_hub_download(repo_id=hf_repo, filename=hf_file)
+        return hf_hub_download(repo_id=hf_repo, filename=hf_file, repo_type=hf_repo_type)
 
     raise FileNotFoundError(
         f"Model pilihan `{model_choice}` tidak ditemukan. Simpan 'yolov8n.pt' / 'best.pt' di root project, "
@@ -442,6 +446,178 @@ def _prepare_training_dataset(dataset_root: Path, use_pseudo_if_missing: bool, p
     return yaml_path, info
 
 
+def sync_best_to_hf(best_model_path: Path) -> str:
+    hf_repo = os.getenv("HF_MODEL_REPO", "").strip()
+    hf_file = os.getenv("HF_MODEL_FILE", "best.pt").strip() or "best.pt"
+    hf_repo_type = os.getenv("HF_MODEL_REPO_TYPE", "space").strip() or "space"
+    hf_token = os.getenv("HF_TOKEN", "").strip() or None
+
+    if not hf_repo:
+        return "HF sync dilewati: set HF_MODEL_REPO untuk upload otomatis."
+
+    try:
+        api = HfApi(token=hf_token)
+        api.upload_file(
+            path_or_fileobj=str(best_model_path),
+            path_in_repo=hf_file,
+            repo_id=hf_repo,
+            repo_type=hf_repo_type,
+            commit_message=f"Auto-update {hf_file} ({datetime.now().strftime('%Y-%m-%d %H:%M:%S')})",
+        )
+        return f"HF sync sukses: {hf_repo} ({hf_repo_type}) -> {hf_file}"
+    except Exception as err:
+        return f"HF sync gagal: {err}"
+
+
+def _env_true(var_name: str, default: bool = False) -> bool:
+    val = os.getenv(var_name)
+    if val is None:
+        return default
+    return val.strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _parse_globs(raw_value: str) -> list[str]:
+    return [g.strip() for g in raw_value.split(",") if g.strip()]
+
+
+def _snapshot_repo_files(root: Path, ignore_globs: list[str]) -> Dict[str, Tuple[int, int]]:
+    snapshot: Dict[str, Tuple[int, int]] = {}
+    for p in root.rglob("*"):
+        if not p.is_file():
+            continue
+        rel = p.relative_to(root).as_posix()
+        if any(fnmatch.fnmatch(rel, pat) for pat in ignore_globs):
+            continue
+        st = p.stat()
+        snapshot[rel] = (int(st.st_mtime_ns), int(st.st_size))
+    return snapshot
+
+
+def _commit_repo_deltas(
+    api: HfApi,
+    root: Path,
+    repo_id: str,
+    repo_type: str,
+    changed: set[str],
+    deleted: set[str],
+    max_file_mb: float,
+) -> str:
+    ops = []
+    skipped: list[str] = []
+    for rel in sorted(changed):
+        src = root / rel
+        if not src.exists():
+            continue
+        if src.stat().st_size > max_file_mb * 1024 * 1024:
+            skipped.append(rel)
+            continue
+        ops.append(CommitOperationAdd(path_in_repo=rel, path_or_fileobj=str(src)))
+
+    for rel in sorted(deleted):
+        ops.append(CommitOperationDelete(path_in_repo=rel))
+
+    if not ops:
+        if skipped:
+            return f"HF autosync: tidak ada file di-commit (skip terlalu besar: {len(skipped)})."
+        return "HF autosync: tidak ada perubahan untuk di-commit."
+
+    api.create_commit(
+        repo_id=repo_id,
+        repo_type=repo_type,
+        operations=ops,
+        commit_message=(
+            "Auto-sync repo updates "
+            f"({datetime.now().strftime('%Y-%m-%d %H:%M:%S')})"
+        ),
+    )
+    return (
+        "HF autosync sukses: "
+        f"updated={len(changed) - len(skipped)}, deleted={len(deleted)}, skipped={len(skipped)}"
+    )
+
+
+def _repo_autosync_loop(
+    root: Path,
+    api: HfApi,
+    repo_id: str,
+    repo_type: str,
+    interval_sec: int,
+    ignore_globs: list[str],
+    max_file_mb: float,
+) -> None:
+    prev = _snapshot_repo_files(root, ignore_globs)
+    print(
+        f"HF autosync aktif: repo={repo_id} type={repo_type} interval={interval_sec}s"
+    )
+    while True:
+        try:
+            time.sleep(interval_sec)
+            curr = _snapshot_repo_files(root, ignore_globs)
+            changed = {rel for rel, sig in curr.items() if prev.get(rel) != sig}
+            deleted = set(prev.keys()) - set(curr.keys())
+
+            if changed or deleted:
+                msg = _commit_repo_deltas(
+                    api=api,
+                    root=root,
+                    repo_id=repo_id,
+                    repo_type=repo_type,
+                    changed=changed,
+                    deleted=deleted,
+                    max_file_mb=max_file_mb,
+                )
+                print(msg)
+                prev = curr
+        except Exception as err:
+            print(f"HF autosync error: {err}")
+
+
+_repo_autosync_started = False
+
+
+def start_repo_autosync(root: Path) -> str:
+    global _repo_autosync_started
+    if _repo_autosync_started:
+        return "HF autosync sudah aktif."
+
+    repo_id = os.getenv("HF_AUTOSYNC_REPO_ID", "").strip() or os.getenv("HF_MODEL_REPO", "").strip()
+    default_enabled = bool(repo_id)
+    enabled = _env_true("HF_AUTOSYNC_ENABLED", default=default_enabled)
+    if not enabled:
+        return "HF autosync nonaktif (HF_AUTOSYNC_ENABLED=false)."
+    if not repo_id:
+        return "HF autosync dilewati: set HF_AUTOSYNC_REPO_ID atau HF_MODEL_REPO."
+
+    repo_type = (
+        os.getenv("HF_AUTOSYNC_REPO_TYPE", "").strip()
+        or os.getenv("HF_MODEL_REPO_TYPE", "").strip()
+        or "space"
+    )
+    token = os.getenv("HF_AUTOSYNC_TOKEN", "").strip() or os.getenv("HF_TOKEN", "").strip() or None
+    interval_sec = max(3, int(float(os.getenv("HF_AUTOSYNC_INTERVAL_SEC", "15").strip() or "15")))
+    max_file_mb = max(1.0, float(os.getenv("HF_AUTOSYNC_MAX_FILE_MB", "200").strip() or "200"))
+    ignore_globs = _parse_globs(
+        os.getenv(
+            "HF_AUTOSYNC_IGNORE_GLOBS",
+            ".git/**,__pycache__/**,.venv/**,venv/**,*.pyc,*.pyo,*.tmp",
+        )
+    )
+
+    api = HfApi(token=token)
+    worker = Thread(
+        target=_repo_autosync_loop,
+        args=(root, api, repo_id, repo_type, interval_sec, ignore_globs, max_file_mb),
+        daemon=True,
+        name="hf-repo-autosync",
+    )
+    worker.start()
+    _repo_autosync_started = True
+    return (
+        "HF autosync dinyalakan: "
+        f"repo={repo_id}, type={repo_type}, interval={interval_sec}s"
+    )
+
+
 def run_training(
     epochs: float,
     imgsz: float,
@@ -458,7 +634,7 @@ def run_training(
             pseudo_conf=float(pseudo_conf),
         )
 
-        model_path = str(base_dir / "yolov8n.pt") if (base_dir / "yolov8n.pt").exists() else resolve_model_path()
+        model_path = str(base_dir / "yolov8n.pt") if (base_dir / "yolov8n.pt").exists() else resolve_model_path("YOLOv8n")
         model = YOLO(model_path)
         run_name = f"classroom_train_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
         results = model.train(
@@ -476,14 +652,18 @@ def run_training(
         save_dir = Path(str(results.save_dir))
         best_pt = save_dir / "weights" / "best.pt"
         best_out = base_dir / "best.pt"
+        hf_sync_msg = "HF sync dilewati: best.pt tidak ditemukan di output training."
         if best_pt.exists():
             shutil.copy2(best_pt, best_out)
+            load_model.cache_clear()
+            hf_sync_msg = sync_best_to_hf(best_out)
 
         msg = (
             "Training selesai.\n"
             f"- {prep_info}\n"
             f"- Run dir: {save_dir}\n"
-            f"- best.pt: {best_out if best_out.exists() else best_pt}"
+            f"- best.pt: {best_out if best_out.exists() else best_pt}\n"
+            f"- {hf_sync_msg}"
         )
         return msg, str(best_out) if best_out.exists() else ""
     except Exception as err:
@@ -627,4 +807,5 @@ with gr.Blocks(title="Pengecekan dan Klasifikasi Mahasiswa - YOLOv8") as demo:
 
 
 if __name__ == "__main__":
+    print(start_repo_autosync(Path(__file__).resolve().parent))
     demo.launch(css=CUSTOM_CSS, ssr_mode=False)