Upload backup-manager.py with huggingface_hub

backup-manager.py

@@ -1,25 +1,25 @@
 #!/usr/bin/env python3
 """
-backup-manager.py -- WebDAV + HF Dataset ?????/??
-
-????:
- +------------------+----------+--------------------------+--------------------------+
- | ??              | ??     | ??                     | ??                     |
- +------------------+----------+--------------------------+--------------------------+
- | WebDAV            | ??+??| BACKUP_WEBDAV_INTERVAL   | WEBDAV_MAX_BACKUPS ?    |
- |                   |          | (?? 60 ?)             | (?? 30 ?)             |
- +------------------+----------+--------------------------+--------------------------+
- | HF Dataset        | ???   | BACKUP_HF_INTERVAL_SMALL | 1 ? (??)              |
- |                   |          | (?? 30 ?)             |                          |
- +------------------+----------+--------------------------+--------------------------+
- | HF Dataset        | ???   | BACKUP_HF_INTERVAL_BIG   | DATASET_MAX_BACKUPS ?   |
- |                   |          | (?? 30 ?)             | (?? 30 ?)             |
- +------------------+----------+--------------------------+--------------------------+
-
-????: HF Dataset ?? 1GB, ?????
-??: WebDAV -> HF Dataset ??
-
-????: ???????? last_run ??, ???????
+backup-manager.py  WebDAV + HF Dataset /
+
+:
+ 
+                                                                  
+ 
+  WebDAV             + BACKUP_WEBDAV_INTERVAL    WEBDAV_MAX_BACKUPS     
+                               ( 60 )              ( 30 )             
+ 
+  HF Dataset             BACKUP_HF_INTERVAL_SMALL  1  ()              
+                               ( 30 )                                       
+ 
+  HF Dataset             BACKUP_HF_INTERVAL_BIG    DATASET_MAX_BACKUPS    
+                               ( 30 )              ( 30 )             
+ 
+
+: HF Dataset  1GB, 
+: WebDAV  HF Dataset 
+
+:  last_run , 
 """
 
 import hashlib, json, os, tarfile, time, sys
@@ -28,13 +28,13 @@ from pathlib import Path
 
 import requests
 
-# ???????????????????????????????????????????????????????????????????????????????
-# ??
-# ???????????????????????????????????????????????????????????????????????????????
+# 
+# 
+# 
 
 STATE_DIR = os.environ.get("OPENCLAW_STATE_DIR", "/root/.openclaw")
 
-# -- WebDAV --
+#  WebDAV 
 WEBDAV_URL = os.environ.get("WEBDAV_URL", "").rstrip("/")
 WEBDAV_USER = os.environ.get("WEBDAV_USERNAME", "")
 WEBDAV_PASS = os.environ.get("WEBDAV_PASSWORD", "")
@@ -42,64 +42,64 @@ WEBDAV_BACKUP_DIR = os.environ.get("WEBDAV_BACKUP_DIR", "openclaw-backup")
 WEBDAV_INTERVAL = int(os.environ.get("BACKUP_WEBDAV_INTERVAL", "60"))
 WEBDAV_MAX_BACKUPS = int(os.environ.get("WEBDAV_MAX_BACKUPS", "30"))
 
-# -- HF Dataset --
+#  HF Dataset 
 HF_REPO = os.environ.get("HF_DATASET", "")
 HF_TOKEN = os.environ.get("HF_TOKEN", "")
 HF_SMALL_INTERVAL = int(os.environ.get("BACKUP_HF_INTERVAL_SMALL", "30"))
 HF_BIG_INTERVAL = int(os.environ.get("BACKUP_HF_INTERVAL_BIG", "30"))
 DATASET_MAX_BACKUPS = int(os.environ.get("DATASET_MAX_BACKUPS", "30"))
 
-# -- ????? --
+#   
 FULL_NAME = "openclaw-full.tar.gz"
 MANIFEST_NAME = "_incremental_manifest.json"
 
-# -- HF ???? --
+#  HF  
 MAX_HF_STORAGE = 1 * 1024 * 1024 * 1024  # 1 GB
 
-# -- ???? --
-HASH_CHUNK_SIZE = 65536       # SHA256 ??????
-WD_CHECK_TIMEOUT = 3          # WebDAV ???????
-WD_REQ_TIMEOUT = 30           # WebDAV ??????
+#   
+HASH_CHUNK_SIZE = 65536       # SHA256 
+WD_CHECK_TIMEOUT = 3          # WebDAV 
+WD_REQ_TIMEOUT = 30           # WebDAV 
 
-# -- ???? --
+#   
 RED    = "\033[91m"
 GREEN  = "\033[92m"
 YELLOW = "\033[93m"
 RESET  = "\033[0m"
 
-# ???????????????????????????????????????????????????????????????????????????????
-# ???????????????
-# ???????????????????????????????????????????????????????????????????????????????
+# 
+# 
+# 
 
 def _print_banner():
-    """????????????"""
+    """"""
     global WD_SKIPPED, HF_SKIPPED
-    sep = "-" * 50
-    print(f"[backup] +{sep}+")
+    sep = "" * 50
+    print(f"[backup] {sep}")
 
     wd_configured = _wd_is_configured()
     if not wd_configured:
-        print(f"[backup] |  WebDAV    {RED}[FAIL] ??: ?? WEBDAV_URL / WEBDAV_USERNAME / WEBDAV_PASSWORD / WEBDAV_BACKUP_DIR ???????{RESET}")
+        print(f"[backup]   WebDAV    {RED} :  WEBDAV_URL / WEBDAV_USERNAME / WEBDAV_PASSWORD / WEBDAV_BACKUP_DIR {RESET}")
         WD_SKIPPED = True
     else:
-        print(f"[backup] |  WebDAV    {GREEN}[OK] ???{RESET}  ??={WEBDAV_INTERVAL}?  ??={WEBDAV_MAX_BACKUPS}?")
+        print(f"[backup]   WebDAV    {GREEN} {RESET}  ={WEBDAV_INTERVAL}  ={WEBDAV_MAX_BACKUPS}")
         WD_SKIPPED = False
 
     if not HF_REPO or not HF_TOKEN:
         hf_missing = []
         if not HF_REPO:  hf_missing.append("HF_DATASET")
         if not HF_TOKEN: hf_missing.append("HF_TOKEN")
-        print(f"[backup] |  HF???  {RED}[FAIL] ??: ?? {', '.join(hf_missing)}{RESET}")
-        print(f"[backup] |  HF???  {RED}[FAIL] ??{RESET}")
+        print(f"[backup]   HF  {RED} :  {', '.join(hf_missing)}{RESET}")
+        print(f"[backup]   HF  {RED} {RESET}")
         HF_SKIPPED = True
     else:
-        print(f"[backup] |  HF???  {GREEN}[OK] ???{RESET}  ??={HF_SMALL_INTERVAL}?")
-        print(f"[backup] |  HF???  {GREEN}[OK] ???{RESET}  ??={HF_BIG_INTERVAL}?  ??={DATASET_MAX_BACKUPS}?")
+        print(f"[backup]   HF  {GREEN} {RESET}  ={HF_SMALL_INTERVAL}")
+        print(f"[backup]   HF  {GREEN} {RESET}  ={HF_BIG_INTERVAL}  ={DATASET_MAX_BACKUPS}")
         HF_SKIPPED = False
 
-    print(f"[backup] +{sep}+")
+    print(f"[backup] {sep}")
 
-# ???? banner ????? import ??????????
+#  banner  import 
 _DISPLAYED_BANNER = False
 
 def _ensure_banner():
@@ -108,12 +108,12 @@ def _ensure_banner():
         _print_banner()
         _DISPLAYED_BANNER = True
 
-# ???????????????????????????????????????????????????????????????????????????????
-# ????
-# ???????????????????????????????????????????????????????????????????????????????
+# 
+# 
+# 
 
 def _create_tar() -> str:
-    """?? STATE_DIR ? tar.gz, ??????."""
+    """ STATE_DIR  tar.gz, ."""
     tarpath = f"/tmp/openclaw-backup-{int(time.time()*1000)}.tar.gz"
     try:
         with tarfile.open(tarpath, "w:gz") as tar:
@@ -127,22 +127,22 @@ def _create_tar() -> str:
                         try:
                             tar.add(str(item), arcname=name)
                         except (PermissionError, FileNotFoundError) as e:
-                            print(f"[backup] ? ???? {name}: {e}")
+                            print(f"[backup]   {name}: {e}")
                             continue
             else:
-                print(f"[backup] ? STATE_DIR {STATE_DIR} ???, ?????")
+                print(f"[backup]  STATE_DIR {STATE_DIR} , ")
                 root.mkdir(parents=True, exist_ok=True)
         size = os.path.getsize(tarpath)
         print(f"[backup] Archive created ({size/1024/1024:.1f} MB)")
     except (OSError, tarfile.TarError) as e:
-        print(f"[backup] ? ??????: {e}")
+        print(f"[backup]  : {e}")
         if os.path.exists(tarpath):
             os.remove(tarpath)
-        raise  # ??????
+        raise  # 
     return tarpath
 
 def _file_hash(path: str) -> str:
-    """????? SHA256 ??, ??????????."""
+    """ SHA256 , ."""
     try:
         h = hashlib.sha256()
         with open(path, "rb") as f:
@@ -153,15 +153,15 @@ def _file_hash(path: str) -> str:
                 h.update(chunk)
         return h.hexdigest()
     except (OSError, PermissionError, FileNotFoundError) as e:
-        print(f"[backup] ? ????????: {path} -> {e}")
+        print(f"[backup]  : {path}  {e}")
         return ""
 
 def _today_str() -> str:
     return time.strftime("%Y%m%d")
 
-# ???????????????????????????????????????????????????????????????????????????????
-# WebDAV ?? HTTP ?
-# ???????????????????????????????????????????????????????????????????????????????
+# 
+# WebDAV  HTTP 
+# 
 
 def _wd_auth():
     return (WEBDAV_USER, WEBDAV_PASS) if WEBDAV_USER else None
@@ -171,17 +171,17 @@ def _wd_url(path=""):
 
 def _wd_req(method, path="", **kwargs):
     url = _wd_url(path)
-    kwargs.setdefault("timeout", WD_REQ_TIMEOUT)  # ?????/????????
+    kwargs.setdefault("timeout", WD_REQ_TIMEOUT)  # /
     resp = requests.request(method, url, auth=_wd_auth(), **kwargs)
     resp.raise_for_status()
     return resp
 
 def _wd_check():
-    """???? WebDAV ??? (3s ??), ???? False"""
+    """ WebDAV  (3s ),  False"""
     try:
         url = _wd_url("")
         resp = requests.request("PROPFIND", url, auth=_wd_auth(), timeout=3)
-        resp.raise_for_status()  # 401/403/404 ??????
+        resp.raise_for_status()  # 401/403/404 
         return True
     except Exception:
         return False
@@ -200,16 +200,16 @@ def wd_download(path):
     return _wd_req("GET", path).content
 
 def wd_delete(path):
-    """?? WebDAV ????"""
+    """ WebDAV """
     try:
         _wd_req("DELETE", path)
         return True
     except Exception as e:
-        print(f"[backup] ? WebDAV ????: {path} -> {e}")
+        print(f"[backup]  WebDAV : {path}  {e}")
         return False
 
 def wd_mkdir(parts):
-    """???? WebDAV ??"""
+    """ WebDAV """
     try:
         _wd_req("MKCOL", "")
     except Exception:
@@ -222,7 +222,7 @@ def wd_mkdir(parts):
             pass
 
 def wd_list(path=""):
-    """?? WebDAV ?????????"""
+    """ WebDAV """
     try:
         import xml.etree.ElementTree as ET
         resp = requests.request(
@@ -242,12 +242,12 @@ def wd_list(path=""):
                     items.append(name)
         return [x for x in items if x != WEBDAV_BACKUP_DIR.split("/")[-1]]
     except Exception as e:
-        print(f"[backup] ? WebDAV ??????: {e}")
+        print(f"[backup]  WebDAV : {e}")
         return []
 
-# ???????????????????????????????????????????????????????????????????????????????
-# WebDAV ???? (Manifest)
-# ???????????????????????????????????????????????????????????????????????????????
+# 
+# WebDAV  (Manifest)
+# 
 
 def _load_manifest() -> dict:
     try:
@@ -260,7 +260,7 @@ def _save_manifest(manifest: dict):
     wd_upload(MANIFEST_NAME, json.dumps(manifest, indent=2).encode())
 
 def _scan_and_upload_changes(root: Path, manifest: dict) -> int:
-    """?????????? WebDAV. ???????."""
+    """ WebDAV. ."""
     changed = 0
     for fpath in root.rglob("*"):
         if not fpath.is_file():
@@ -292,7 +292,7 @@ def _scan_and_upload_changes(root: Path, manifest: dict) -> int:
                 changed += 1
             except Exception as e:
                 err_str = str(e)
-                # 409 = ????????????????
+                # 409 = 
                 if "409" in err_str or "Conflict" in err_str:
                     manifest[rel] = {
                         "sha256": cur_h,
@@ -301,24 +301,24 @@ def _scan_and_upload_changes(root: Path, manifest: dict) -> int:
                     }
                     changed += 1
                 else:
-                    print(f"[backup] ? ?????? (??): {rel} -> {e}")
+                    print(f"[backup]   (): {rel}  {e}")
     return changed
 
 
 def incremental_backup() -> int:
-    """??????, ??? WebDAV. ???????."""
+    """,  WebDAV. ."""
     root = Path(STATE_DIR)
     if not root.exists():
         return 0
 
-    # ?? WebDAV ?????
+    #  WebDAV 
     if not _wd_is_configured():
-        print(f"[backup] ? WebDAV ?????, ??????")
+        print(f"[backup]  WebDAV , ")
         return 0
 
-    # ???? WebDAV ???
+    #  WebDAV 
     if not _wd_check():
-        print(f"[backup] ? WebDAV ???, ??????")
+        print(f"[backup]  WebDAV , ")
         return 0
 
     manifest = _load_manifest()
@@ -328,15 +328,15 @@ def incremental_backup() -> int:
         try:
             _save_manifest(manifest)
         except Exception as e:
-            print(f"[backup] ? Manifest ????: {e}")
+            print(f"[backup]  Manifest : {e}")
     return changed
 
-# ???????????????????????????????????????????????????????????????????????????????
-# WebDAV ???? + ??
-# ???????????????????????????????????????????????????????????????????????????????
+# 
+# WebDAV  + 
+# 
 
 def _wd_cleanup():
-    """???? WEBDAV_MAX_BACKUPS ?? WebDAV ??????"""
+    """ WEBDAV_MAX_BACKUPS  WebDAV """
     files = wd_list("")
     now = datetime.now()
     deleted = 0
@@ -344,32 +344,32 @@ def _wd_cleanup():
         if not f.startswith("openclaw-full-") or not f.endswith(".tar.gz"):
             continue
         if f == FULL_NAME:
-            continue  # ???????
+            continue  # 
         try:
             date_str = f.replace("openclaw-full-", "").replace(".tar.gz", "")
             dt = datetime.strptime(date_str, "%Y%m%d")
             days_old = (now - dt).days
             if days_old > WEBDAV_MAX_BACKUPS:
                 if wd_delete(f):
-                    print(f"[backup] WebDAV ??????: {f} ({days_old}??)")
+                    print(f"[backup] WebDAV : {f} ({days_old})")
                     deleted += 1
         except ValueError:
             continue
     if deleted:
-        print(f"[backup] WebDAV ??? {deleted} ???????")
+        print(f"[backup] WebDAV  {deleted} ")
     return deleted
 
 def _wd_is_configured() -> bool:
-    """?? WebDAV ?? 4 ???????"""
+    """ WebDAV  4 """
     return bool(WEBDAV_URL and WEBDAV_USER and WEBDAV_PASS and WEBDAV_BACKUP_DIR)
 
 def full_backup():
-    """?? tar -> WebDAV (???: openclaw-full-YYYYMMDD.tar.gz)"""
+    """ tar  WebDAV (: openclaw-full-YYYYMMDD.tar.gz)"""
     tarpath = _create_tar()
     if _wd_is_configured():
-        # ???? WebDAV ???
+        #  WebDAV 
         if not _wd_check():
-            print(f"[backup] ? WebDAV ???, ??????")
+            print(f"[backup]  WebDAV , ")
             os.remove(tarpath)
             return
         wd_mkdir([])
@@ -377,26 +377,26 @@ def full_backup():
         try:
             with open(tarpath, "rb") as f:
                 wd_upload(filename, f.read())
-            print(f"[backup] WebDAV ???????? -> {filename}")
-            # ???????????????????????
+            print(f"[backup] WebDAV   {filename}")
+            # 
             with open(tarpath, "rb") as f:
                 wd_upload(FULL_NAME, f.read())
-            # ????
+            # 
             _wd_cleanup()
         except Exception as e:
-            print(f"[backup] ? WebDAV ????????: {e}")
+            print(f"[backup]  WebDAV : {e}")
     os.remove(tarpath)
 
-# ???????????????????????????????????????????????????????????????????????????????
-# HF Dataset ???
-# ???????????????????????????????????????????????????????????????????????????????
+# 
+# HF Dataset 
+# 
 
 def _hf_list_backup_files() -> dict | None:
     """
-    ?? HF Dataset ????????.
-    ??: {???: ??(bytes)} ??
-         {}                       ?????
-         None                     API ????
+     HF Dataset .
+    : {: (bytes)} 
+         {}                       
+         None                     API 
     """
     if not HF_REPO or not HF_TOKEN:
         return {}
@@ -405,7 +405,7 @@ def _hf_list_backup_files() -> dict | None:
         try:
             api = HfApi(timeout=60)
         except TypeError:
-            api = HfApi()  # ?????? timeout ??
+            api = HfApi()  #  timeout 
         backups = {}
         for entry in api.list_repo_tree(HF_REPO, repo_type="dataset", token=HF_TOKEN):
             name = entry.rfilename
@@ -413,29 +413,29 @@ def _hf_list_backup_files() -> dict | None:
                 backups[name] = entry.size if hasattr(entry, "size") else 0
         return backups
     except Exception as e:
-        print(f"[backup] ? HF Dataset list API ??: {e}")
-        return None  # ??? "?????" (?? {})
+        print(f"[backup]  HF Dataset list API : {e}")
+        return None  #  "" ( {})
 
 def hf_small_backup():
-    """???: tar.gz -> openclaw-full.tar.gz (??), ?????????"""
+    """: tar.gz  openclaw-full.tar.gz (), """
     if not HF_REPO or not HF_TOKEN:
         return
 
     tarpath = _create_tar()
     tar_size = os.path.getsize(tarpath)
 
-    # -- ???? --
+    #   
     backups = _hf_list_backup_files()
-    if backups is None:  # API ????????????
-        print(f"[backup] ? HF?????: Dataset API ???")
+    if backups is None:  # API 
+        print(f"[backup]  HF: Dataset API ")
         os.remove(tarpath)
         return
     existing_total = sum(backups.values())
 
     if existing_total + tar_size > MAX_HF_STORAGE:
-        print(f"{RED}[backup] ? HF?????: 1GB????! "
-              f"(?? {existing_total/1024/1024:.1f}MB + "
-              f"??? {tar_size/1024/1024:.1f}MB > 1GB){RESET}")
+        print(f"{RED}[backup]  HF: 1GB! "
+              f"( {existing_total/1024/1024:.1f}MB + "
+              f" {tar_size/1024/1024:.1f}MB > 1GB){RESET}")
         os.remove(tarpath)
         return
 
@@ -444,7 +444,7 @@ def hf_small_backup():
         try:
             api = HfApi(timeout=60)
         except TypeError:
-            api = HfApi()  # ?????? timeout ??
+            api = HfApi()  #  timeout 
         with open(tarpath, "rb") as f:
             api.upload_file(
                 path_or_fileobj=f,
@@ -453,21 +453,21 @@ def hf_small_backup():
                 repo_type="dataset",
                 token=HF_TOKEN,
             )
-        print(f"[backup] ? HF??????? -> {FULL_NAME}")
+        print(f"[backup]  HF  {FULL_NAME}")
     except Exception as e:
-        print(f"{RED}[backup] ? HF???????: {e}{RESET}")
+        print(f"{RED}[backup]  HF: {e}{RESET}")
     finally:
         if os.path.exists(tarpath):
             os.remove(tarpath)
 
-# ???????????????????????????????????????????????????????????????????????????????
-# HF Dataset ??? + ??
-# ???????????????????????????????????????????????????????????????????????????????
+# 
+# HF Dataset  + 
+# 
 
 def _hf_cleanup():
-    """???? DATASET_MAX_BACKUPS ?? HF ?????"""
+    """ DATASET_MAX_BACKUPS  HF """
     backups = _hf_list_backup_files()
-    if not backups:  # None(API??) ? {} (???) ???
+    if not backups:  # None(API)  {} () 
         return 0
 
     from huggingface_hub import HfApi
@@ -489,21 +489,21 @@ def _hf_cleanup():
                     repo_type="dataset",
                     token=HF_TOKEN,
                 )
-                print(f"[backup] HF ???????: {name} ({days_old}??)")
+                print(f"[backup] HF : {name} ({days_old})")
                 deleted += 1
         except (ValueError, Exception):
             continue
 
     if deleted:
-        print(f"[backup] HF ??? {deleted} ??????")
+        print(f"[backup] HF  {deleted} ")
     return deleted
 
 def _hf_make_space(backups: dict, tar_size: int, api) -> bool:
-    """????????????, ?????? True, ???? False."""
-    print(f"[backup] ? HF??????? "
-          f"(?? {sum(backups.values())/1024/1024:.1f}MB + "
-          f"??? {tar_size/1024/1024:.1f}MB > 1GB)")
-    print(f"[backup] -> ????????????...")
+    """,  True,  False."""
+    print(f"[backup]  HF "
+          f"( {sum(backups.values())/1024/1024:.1f}MB + "
+          f" {tar_size/1024/1024:.1f}MB > 1GB)")
+    print(f"[backup]  ...")
 
     dated_big = []
     for name, sz in backups.items():
@@ -525,24 +525,24 @@ def _hf_make_space(backups: dict, tar_size: int, api) -> bool:
                 repo_type="dataset",
                 token=HF_TOKEN,
             )
-            print(f"[backup]   ?? {name} (?? {ds})")
+            print(f"[backup]    {name} ( {ds})")
             del backups[name]
             if sum(backups.values()) + tar_size <= MAX_HF_STORAGE:
                 return True
         except Exception:
             continue
 
-    print(f"{RED}[backup] ? HF?????: ???????????1GB "
-          f"(? {tar_size/1024/1024:.1f}MB > 1GB){RESET}")
+    print(f"{RED}[backup]  HF: 1GB "
+          f"( {tar_size/1024/1024:.1f}MB > 1GB){RESET}")
     return False
 
 
 def _hf_upload_backup(tarpath: str, tar_size: int, filename: str, api) -> None:
-    """?????? HF Dataset??????????."""
-    # -- ???? & ????? --
+    """ HF Dataset."""
+    #   &  
     backups = _hf_list_backup_files()
-    if backups is None:  # API ???????????
-        print(f"[backup] ? HF?????: Dataset API ???")
+    if backups is None:  # API 
+        print(f"[backup]  HF: Dataset API ")
         os.remove(tarpath)
         return
     existing_total = sum(backups.values())
@@ -551,12 +551,12 @@ def _hf_upload_backup(tarpath: str, tar_size: int, filename: str, api) -> None:
         if not _hf_make_space(backups, tar_size, api):
             os.remove(tarpath)
             return
-        print(f"[backup] -> ?????, ???????")
-        backups = _hf_list_backup_files()  # ??????????
+        print(f"[backup]  , ")
+        backups = _hf_list_backup_files()  # 
         if backups is None:
             backups = {}
 
-    # -- ??????????, ?????? --
+    #  ,  
     if filename in backups:
         try:
             api.delete_file(
@@ -566,9 +566,9 @@ def _hf_upload_backup(tarpath: str, tar_size: int, filename: str, api) -> None:
                 token=HF_TOKEN,
             )
         except Exception:
-            print(f"[backup] ? ?????????? (??): {filename}")
+            print(f"[backup]   (): {filename}")
 
-    # -- ?? --
+    #   
     with open(tarpath, "rb") as f:
         api.upload_file(
             path_or_fileobj=f,
@@ -577,16 +577,16 @@ def _hf_upload_backup(tarpath: str, tar_size: int, filename: str, api) -> None:
             repo_type="dataset",
             token=HF_TOKEN,
         )
-    print(f"[backup] ? HF??????? -> {filename}")
+    print(f"[backup]  HF  {filename}")
 
-    # -- ???? --
+    #   
     _hf_cleanup()
 
 
 def hf_large_backup():
     """
-    ???: tar.gz -> openclaw-full-YYYYMMDD.tar.gz
-    ?????????????????, ????????
+    : tar.gz  openclaw-full-YYYYMMDD.tar.gz
+    , 
     """
     if not HF_REPO or not HF_TOKEN:
         return
@@ -608,20 +608,20 @@ def hf_large_backup():
         try:
             api = HfApi(timeout=60)
         except TypeError:
-            api = HfApi()  # ?????? timeout ??
+            api = HfApi()  #  timeout 
         _hf_upload_backup(tarpath, tar_size, filename, api)
     except Exception as e:
-        print(f"{RED}[backup] ? HF???????: {e}{RESET}")
+        print(f"{RED}[backup]  HF: {e}{RESET}")
     finally:
         if os.path.exists(tarpath):
             os.remove(tarpath)
 
-# ???????????????????????????????????????????????????????????????????????????????
-# ??
-# ???????????????????????????????????????????????????????????????????????????????
+# 
+# 
+# 
 
 def _hf_download(filename: str = FULL_NAME) -> str | None:
-    """? HF Dataset ????????."""
+    """ HF Dataset ."""
     if not HF_REPO or not HF_TOKEN:
         return None
     try:
@@ -694,7 +694,7 @@ def _start_openviking():
 
 
 def _restore_from_webdav(root: Path, target: str, source: str) -> bool:
-    """? WebDAV ??????????????????? True?"""
+    """ WebDAV  True"""
     if not WEBDAV_URL or not wd_exists(target):
         return False
     print(f"[restore] Downloading {target} from WebDAV...")
@@ -719,7 +719,7 @@ def _restore_from_webdav(root: Path, target: str, source: str) -> bool:
                     p.write_bytes(data)
                     count += 1
                 except Exception as e:
-                    print(f"[restore] ? ????????: {rel} -> {e}")
+                    print(f"[restore]  : {rel}  {e}")
             print(f"[restore] Applied {count} incremental file overrides")
         except Exception:
             print("[restore] No incremental manifest found (clean start)")
@@ -729,7 +729,7 @@ def _restore_from_webdav(root: Path, target: str, source: str) -> bool:
 
 
 def _restore_from_dataset(target: str) -> bool:
-    """? HF Dataset ???????????? True?"""
+    """ HF Dataset  True"""
     print(f"[restore] Trying HF Dataset: {target}...")
     path = _hf_download(target)
     if not path:
@@ -742,12 +742,12 @@ def _restore_from_dataset(target: str) -> bool:
 
 def restore(source="auto", filename=None):
     """
-    ??:
-    - source="auto": WebDAV ?? (?? -> ????) -> HF Dataset ??
-    - source="webdav": ? WebDAV ???? filename ??
-    - source="dataset": ? HF Dataset ???? filename ??
+    :
+    - source="auto": WebDAV  (  )  HF Dataset 
+    - source="webdav":  WebDAV  filename 
+    - source="dataset":  HF Dataset  filename 
 
-    ? filename ? None ?????? openclaw-full.tar.gz?
+     filename  None  openclaw-full.tar.gz
     """
     root = Path(STATE_DIR)
     root.mkdir(parents=True, exist_ok=True)
@@ -764,13 +764,13 @@ def restore(source="auto", filename=None):
         restored = _restore_from_dataset(target)
 
     if not restored:
-        print("[restore] No backup found -- fresh start")
+        print("[restore] No backup found  fresh start")
 
 def list_backups() -> dict:
-    """?? {webdav: [?????], dataset: [?????]}."""
+    """ {webdav: [], dataset: []}."""
     result: dict = {"webdav": [], "dataset": []}
 
-    # WebDAV -- ????????????? banner ??
+    # WebDAV   banner 
     if _wd_is_configured():
         try:
             files = wd_list("")
@@ -778,7 +778,7 @@ def list_backups() -> dict:
         except Exception as e:
             print(f"[backup] WebDAV list error: {e}")
 
-    # HF Dataset -- ??????
+    # HF Dataset  
     if HF_REPO and HF_TOKEN:
         try:
             backups = _hf_list_backup_files()
@@ -790,12 +790,12 @@ def list_backups() -> dict:
     return result
 
 
-# ???????????????????????????????????????????????????????????????????????????????
-# ??? (Tick ??) -- ?????????????OV??vectordb???
-# ???????????????????????????????????????????????????????????????????????????????
+# 
+#  (Tick )  OVvectordb
+# 
 
 def _get_hf_file_mtime(filename: str) -> float:
-    """? HF Dataset ????????????? (unix timestamp)?????? 0"""
+    """ HF Dataset  (unix timestamp) 0"""
     try:
         from huggingface_hub import HfApi
         try:
@@ -807,15 +807,15 @@ def _get_hf_file_mtime(filename: str) -> float:
                 lc = getattr(entry, 'last_commit', None)
                 if lc and hasattr(lc, 'date'):
                     return lc.date.timestamp()
-                return 0.0  # ?????????????????
+                return 0.0  # 
         return 0.0  # file not found
     except Exception as e:
-        print(f"[backup] ? HF ????: {e}")
+        print(f"[backup]  HF : {e}")
         return 0.0
 
 
 def _get_wd_last_backup_time() -> float:
-    """?? WebDAV ???????????? (unix timestamp)?????? 0"""
+    """ WebDAV  (unix timestamp) 0"""
     try:
         files = wd_list("")
         latest = 0.0
@@ -835,7 +835,7 @@ def _get_wd_last_backup_time() -> float:
 
 
 def _get_hf_large_backup_mtime() -> float:
-    """?? HF Dataset ????????????? (unix timestamp)????? 0"""
+    """ HF Dataset  (unix timestamp) 0"""
     try:
         from huggingface_hub import HfApi
         try:
@@ -858,28 +858,28 @@ def _get_hf_large_backup_mtime() -> float:
 
 def _do_one_tick():
     """
-    ?? tick: ???????????? OV -> ?? -> ? OV
+     tick:  OV     OV
     """
     now = time.time()
     today = _today_str()
     need_stop_ov = False
 
-    # -- 1. WebDAV --
+    #  1. WebDAV 
     if not WD_SKIPPED:
         last_wd = _get_wd_last_backup_time()
         if last_wd == 0.0 or (now - last_wd) >= WEBDAV_INTERVAL * 60:
             need_stop_ov = True
 
-    # -- 2. HF ??? --
+    #  2. HF  
     if not HF_SKIPPED:
         last_hf_small = _get_hf_file_mtime(FULL_NAME)
         if last_hf_small == 0.0 or (now - last_hf_small) >= HF_SMALL_INTERVAL * 60:
             need_stop_ov = True
 
-    # -- 3. HF ??? -- ???????????
+    #  3. HF   
     hf_big_due = False
     if not HF_SKIPPED:
-        # ??????????????????? OV?
+        #  OV
         today_file = f"openclaw-full-{_today_str()}.tar.gz"
         try:
             from huggingface_hub import HfApi
@@ -903,9 +903,9 @@ def _do_one_tick():
                 need_stop_ov = True
 
     if not need_stop_ov:
-        return  # ????????
+        return  # 
 
-    # -- ? OV -> ?? -> ? OV --
+    #   OV     OV 
     ov_was_running = False
     import signal
     try:
@@ -926,26 +926,26 @@ def _do_one_tick():
         if last_wd == 0.0 or (now - last_wd) >= WEBDAV_INTERVAL * 60:
             try:
                 c = incremental_backup()
-                print(f"[backup] WebDAV ??: {c} ?????")
+                print(f"[backup] WebDAV : {c} ")
                 full_backup()
             except Exception as e:
-                print(f"[backup] ? WebDAV ?? (??): {e}")
+                print(f"[backup]  WebDAV  (): {e}")
 
-    # HF ???
+    # HF 
     if not HF_SKIPPED:
         last_hf_small = _get_hf_file_mtime(FULL_NAME)
         if last_hf_small == 0.0 or (now - last_hf_small) >= HF_SMALL_INTERVAL * 60:
             try:
                 hf_small_backup()
             except Exception as e:
-                print(f"[backup] ? HF????? (??): {e}")
+                print(f"[backup]  HF (): {e}")
 
-    # HF ?????
+    # HF 
     if not HF_SKIPPED and hf_big_due:
         try:
             hf_large_backup()
         except Exception as e:
-            print(f"[backup] ? HF????? (??): {e}")
+            print(f"[backup]  HF (): {e}")
 
     if ov_was_running:
         _start_openviking()
@@ -953,39 +953,39 @@ def _do_one_tick():
 
 def scheduler_loop():
     """
-    Tick ???? (??????)??????????????????????
-    ? OV ?? vectordb ????
+    Tick  ()
+     OV  vectordb 
     """
     _ensure_banner()
 
-    print(f"[backup] ?? tick ??")
-    print(f"[backup]   WebDAV   ??={WEBDAV_INTERVAL}?  ??={WEBDAV_MAX_BACKUPS}?")
-    print(f"[backup]   HF??? ??={HF_SMALL_INTERVAL}?")
-    print(f"[backup]   HF??? ??={HF_BIG_INTERVAL}?  ??={DATASET_MAX_BACKUPS}?")
+    print(f"[backup]  tick ")
+    print(f"[backup]   WebDAV   ={WEBDAV_INTERVAL}  ={WEBDAV_MAX_BACKUPS}")
+    print(f"[backup]   HF ={HF_SMALL_INTERVAL}")
+    print(f"[backup]   HF ={HF_BIG_INTERVAL}  ={DATASET_MAX_BACKUPS}")
 
-    print(f"[backup] ?? tick ???????5??")
+    print(f"[backup]  tick 5")
 
     while True:
         time.sleep(5)
         _do_one_tick()
 
-# ???????????????????????????????????????????????????????????????????????????????
+# 
 # CLI
-# ???????????????????????????????????????????????????????????????????????????????
+# 
 
 if __name__ == "__main__":
     import argparse
-    parser = argparse.ArgumentParser(description="WebDAV + HF Dataset ?????/??")
+    parser = argparse.ArgumentParser(description="WebDAV + HF Dataset /")
     parser.add_argument("cmd", nargs="?", default="restore",
                         choices=["restore", "list", "incremental", "full", "small", "large", "scheduler", "check"],
-                        help="???? (default: restore)")
+                        help=" (default: restore)")
     parser.add_argument("--source", default="auto",
-                        help="????: auto|webdav|dataset (? restore ??)")
+                        help=": auto|webdav|dataset ( restore )")
     parser.add_argument("--filename", default=None,
-                        help="?????????? (? restore ??)")
+                        help=" ( restore )")
     args = parser.parse_args()
 
-    # list/check ????? banner????? stdout JSON????????
+    # list/check  banner stdout JSON
     if args.cmd not in ("list", "check"):
         _ensure_banner()
 
@@ -996,7 +996,7 @@ if __name__ == "__main__":
         print(json.dumps(list_backups(), ensure_ascii=False))
     elif args.cmd == "incremental":
         c = incremental_backup()
-        print(f"[backup] WebDAV ??: {c} ?????")
+        print(f"[backup] WebDAV : {c} ")
     elif args.cmd == "full":
         full_backup()
     elif args.cmd == "small":
@@ -1016,10 +1016,10 @@ if __name__ == "__main__":
                 api = HfApi()
             for entry in api.list_repo_tree(HF_REPO, repo_type="dataset", token=HF_TOKEN, expand=True):
                 name = getattr(entry, 'rfilename', '')
-                if name == FULL_NAME:  # ?????
+                if name == FULL_NAME:  # 
                     lc = getattr(entry, 'last_commit', None)
                     if lc and hasattr(lc, 'date'):
-                        # UTC ????? (UTC+8)
+                        # UTC  (UTC+8)
                         bj_time = lc.date.astimezone(timezone(timedelta(hours=8)))
                         result["last_backup"] = bj_time.strftime("%Y-%m-%d %H:%M:%S")
                 if name.startswith("openclaw-full-") and name.endswith(".tar.gz") and name != FULL_NAME:
@@ -1031,8 +1031,8 @@ if __name__ == "__main__":
                             result["backup_today"] = True
                             result["last_backup"] = bj_time.strftime("%Y-%m-%d %H:%M:%S")
         except Exception as e:
-            print(f"[backup] ??????: {e}")
+            print(f"[backup] : {e}")
         print(json.dumps(result))
     else:
-        print(f"??: {sys.argv[0]} {{restore|incremental|full|small|large|scheduler}}")
+        print(f": {sys.argv[0]} {{restore|incremental|full|small|large|scheduler}}")
         sys.exit(1)