Stabilize autosync defaults and startup behavior

README.md

@@ -64,11 +64,28 @@ Opsional environment variable:
 - `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
+- `HF_AUTOSYNC_ENABLED` - aktif/nonaktif auto-sync file repo (`true/false`)
+- `HF_AUTOSYNC_LOCAL_ONLY` - default `true`, artinya autosync hanya jalan dari lokal
+- `HF_AUTOSYNC_REALTIME` - default `false`; jika `true` baru watcher realtime aktif
+- `HF_AUTOSYNC_REPO_ID` - repo target auto-sync (fallback ke `HF_MODEL_REPO`)
+- `HF_AUTOSYNC_REPO_TYPE` - tipe repo target auto-sync (default `space`)
+- `HF_AUTOSYNC_TOKEN` - token auto-sync (fallback ke `HF_TOKEN`)
+- `HF_AUTOSYNC_INTERVAL_SEC` - interval cek perubahan file (default `3` detik)
+- `HF_AUTOSYNC_DEBOUNCE_SEC` - jeda batch commit agar tidak commit tiap perubahan kecil (default `8` detik)
+- `HF_AUTOSYNC_INCLUDE_GLOBS` - pola file yang ingin disync (default `*.py,*.md,requirements.txt,.gitignore`)
+- `HF_AUTOSYNC_MAX_FILE_MB` - batas ukuran file yang di-sync (default `200` MB)
+- `HF_AUTOSYNC_IGNORE_GLOBS` - daftar pola file/folder yang diabaikan (dipisah koma)
 
 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.
 
+Catatan auto-sync update file repo:
+- Default `HF_AUTOSYNC_ENABLED=false`, jadi tidak ada sync repo saat startup/runtime.
+- Jika ingin sync repo otomatis, aktifkan manual: `HF_AUTOSYNC_ENABLED=true`.
+- Untuk mode realtime, tambahkan `HF_AUTOSYNC_REALTIME=true`.
+- Disarankan tetap fokus ke sync model `best.pt` setelah training (lebih ringan dan stabil).
+
 ## Menjalankan Lokal
 
 ```bash

app.py

@@ -480,12 +480,18 @@ 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]]:
+def _snapshot_repo_files(
+    root: Path,
+    include_globs: list[str],
+    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 include_globs and not any(fnmatch.fnmatch(rel, pat) for pat in include_globs):
+            continue
         if any(fnmatch.fnmatch(rel, pat) for pat in ignore_globs):
             continue
         st = p.stat()
@@ -542,32 +548,50 @@ def _repo_autosync_loop(
     repo_id: str,
     repo_type: str,
     interval_sec: int,
+    debounce_sec: int,
+    include_globs: list[str],
     ignore_globs: list[str],
     max_file_mb: float,
 ) -> None:
-    prev = _snapshot_repo_files(root, ignore_globs)
+    prev = _snapshot_repo_files(root, include_globs, ignore_globs)
+    pending_changed: set[str] = set()
+    pending_deleted: set[str] = set()
+    pending_since = 0.0
     print(
-        f"HF autosync aktif: repo={repo_id} type={repo_type} interval={interval_sec}s"
+        "HF autosync aktif: "
+        f"repo={repo_id} type={repo_type} interval={interval_sec}s debounce={debounce_sec}s"
     )
     while True:
         try:
             time.sleep(interval_sec)
-            curr = _snapshot_repo_files(root, ignore_globs)
+            curr = _snapshot_repo_files(root, include_globs, 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
+                if pending_since <= 0:
+                    pending_since = time.time()
+                pending_changed |= changed
+                pending_deleted |= deleted
+                pending_changed -= pending_deleted
+
+            if pending_changed or pending_deleted:
+                elapsed = time.time() - pending_since if pending_since > 0 else 0.0
+                if elapsed >= debounce_sec:
+                    msg = _commit_repo_deltas(
+                        api=api,
+                        root=root,
+                        repo_id=repo_id,
+                        repo_type=repo_type,
+                        changed=pending_changed,
+                        deleted=pending_deleted,
+                        max_file_mb=max_file_mb,
+                    )
+                    print(msg)
+                    prev = curr
+                    pending_changed = set()
+                    pending_deleted = set()
+                    pending_since = 0.0
         except Exception as err:
             print(f"HF autosync error: {err}")
 
@@ -575,16 +599,49 @@ def _repo_autosync_loop(
 _repo_autosync_started = False
 
 
+def _running_in_hf_space() -> bool:
+    return bool(os.getenv("SPACE_ID", "").strip())
+
+
+def _sync_repo_once(
+    root: Path,
+    api: HfApi,
+    repo_id: str,
+    repo_type: str,
+    include_globs: list[str],
+    ignore_globs: list[str],
+    max_file_mb: float,
+) -> str:
+    current = _snapshot_repo_files(root, include_globs, ignore_globs)
+    changed = set(current.keys())
+    if not changed:
+        return "HF build-sync dilewati: tidak ada file yang cocok pola include."
+    msg = _commit_repo_deltas(
+        api=api,
+        root=root,
+        repo_id=repo_id,
+        repo_type=repo_type,
+        changed=changed,
+        deleted=set(),
+        max_file_mb=max_file_mb,
+    )
+    return f"HF build-sync (one-shot): {msg}"
+
+
 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)
+    enabled = _env_true("HF_AUTOSYNC_ENABLED", default=False)
     if not enabled:
         return "HF autosync nonaktif (HF_AUTOSYNC_ENABLED=false)."
+
+    local_only = _env_true("HF_AUTOSYNC_LOCAL_ONLY", default=True)
+    if local_only and _running_in_hf_space():
+        return "HF autosync dilewati di HF Space (mode local-only aktif)."
+
     if not repo_id:
         return "HF autosync dilewati: set HF_AUTOSYNC_REPO_ID atau HF_MODEL_REPO."
 
@@ -594,27 +651,61 @@ def start_repo_autosync(root: Path) -> str:
         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")))
+    interval_sec = max(2, int(float(os.getenv("HF_AUTOSYNC_INTERVAL_SEC", "3").strip() or "3")))
+    debounce_sec = max(2, int(float(os.getenv("HF_AUTOSYNC_DEBOUNCE_SEC", "8").strip() or "8")))
+    realtime = _env_true("HF_AUTOSYNC_REALTIME", default=False)
     max_file_mb = max(1.0, float(os.getenv("HF_AUTOSYNC_MAX_FILE_MB", "200").strip() or "200"))
+    include_globs = _parse_globs(
+        os.getenv(
+            "HF_AUTOSYNC_INCLUDE_GLOBS",
+            "*.py,*.md,requirements.txt,.gitignore",
+        )
+    )
     ignore_globs = _parse_globs(
         os.getenv(
             "HF_AUTOSYNC_IGNORE_GLOBS",
-            ".git/**,__pycache__/**,.venv/**,venv/**,*.pyc,*.pyo,*.tmp",
+            ".git/**,__pycache__/**,.venv/**,venv/**,*.pyc,*.pyo,*.tmp,runs_train/**,prepared_dataset/**",
         )
     )
 
     api = HfApi(token=token)
+    if not realtime:
+        try:
+            _repo_autosync_started = True
+            return _sync_repo_once(
+                root=root,
+                api=api,
+                repo_id=repo_id,
+                repo_type=repo_type,
+                include_globs=include_globs,
+                ignore_globs=ignore_globs,
+                max_file_mb=max_file_mb,
+            )
+        except Exception as err:
+            _repo_autosync_started = False
+            return f"HF build-sync gagal (one-shot): {err}"
+
     worker = Thread(
         target=_repo_autosync_loop,
-        args=(root, api, repo_id, repo_type, interval_sec, ignore_globs, max_file_mb),
+        args=(
+            root,
+            api,
+            repo_id,
+            repo_type,
+            interval_sec,
+            debounce_sec,
+            include_globs,
+            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"
+        "HF autosync realtime dinyalakan: "
+        f"repo={repo_id}, type={repo_type}, interval={interval_sec}s, debounce={debounce_sec}s"
     )
 
 
@@ -807,5 +898,8 @@ with gr.Blocks(title="Pengecekan dan Klasifikasi Mahasiswa - YOLOv8") as demo:
 
 
 if __name__ == "__main__":
-    print(start_repo_autosync(Path(__file__).resolve().parent))
+    if _env_true("HF_AUTOSYNC_ENABLED", default=False):
+        print(start_repo_autosync(Path(__file__).resolve().parent))
+    else:
+        print("HF autosync nonaktif (HF_AUTOSYNC_ENABLED=false).")
     demo.launch(css=CUSTOM_CSS, ssr_mode=False)