sbackup-cli 1.0.0__py3-none-any.whl

sbackup/__init__.py

@@ -0,0 +1,193 @@
+import os
+import sys
+import argparse
+import logging
+from typing import NoReturn
+from sbackup.auto_save import BackupManager
+from sbackup.i18n import set_locale, t
+from sbackup.config import load_config, save_lang, save_format
+from sbackup.compression import restore_backup
+
+VERSION = "1.0.0"
+logger = logging.getLogger(__name__)
+
+
+class LocalizedArgumentParser(argparse.ArgumentParser):
+    """本地化错误输出的 ArgumentParser 子类"""
+
+    def error(self, message: str) -> NoReturn:
+        # 将 argparse 生成的英文错误关键词替换为本地化文本
+        localized = message
+        localized = localized.replace(
+            "invalid choice: ", t("err.argparse.invalid_choice")
+        )
+        localized = localized.replace("choose from", t("err.argparse.choose_from"))
+        localized = localized.replace(
+            "invalid float value: ", t("err.argparse.invalid_float")
+        )
+        localized = localized.replace(
+            "invalid int value: ", t("err.argparse.invalid_int")
+        )
+        localized = localized.replace(
+            "unrecognized arguments: ", t("err.argparse.unrecognized_args")
+        )
+        localized = localized.replace("required", t("err.argparse.required"))
+        self.print_usage(sys.stderr)
+        sys.stderr.write(f"{self.prog}: {localized}\n")
+        sys.exit(2)
+
+
+def _detect_lang_from_argv() -> str | None:
+    """从 sys.argv 中提取 --lang 参数值"""
+    for i, arg in enumerate(sys.argv):
+        if arg == "--lang" and i + 1 < len(sys.argv):
+            return sys.argv[i + 1]
+        if arg.startswith("--lang="):
+            return arg.split("=", 1)[1]
+    return None
+
+
+def get_parser() -> argparse.ArgumentParser:
+    parser = LocalizedArgumentParser(
+        prog="sbackup",
+        description=t("cli.description", version=VERSION),
+        epilog=t("cli.epilog"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        add_help=False,
+    )
+
+    parser.add_argument("--debug", action="store_true", help=t("cli.help.debug"))
+    parser.add_argument("-h", "--help", action="help", help=t("cli.help.help"))
+    parser.add_argument("--lang", default=None, help=t("cli.help.lang"))
+    parser.add_argument(
+        "--format",
+        default=None,
+        choices=["zip", "tar", "tar.gz", "tar.bz2", "tar.xz", "tar.zst", "7z"],
+        help=t("cli.help.format"),
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help=t("cli.help.subcommands"))
+
+    add_parser = subparsers.add_parser("add", help=t("cli.help.add"))
+    add_parser.add_argument("source", help=t("cli.help.add.source"))
+    add_parser.add_argument("dest", help=t("cli.help.add.dest"))
+    add_parser.add_argument(
+        "-i", "--ignore", default=".git,__pycache__", help=t("cli.help.add.ignore")
+    )
+    add_parser.add_argument(
+        "--format",
+        default=None,
+        choices=["zip", "tar", "tar.gz", "tar.bz2", "tar.xz", "tar.zst", "7z"],
+        help=t("cli.help.add.format"),
+    )
+
+    rm_parser = subparsers.add_parser("rm", aliases=["remove"], help=t("cli.help.rm"))
+    rm_parser.add_argument("path", help=t("cli.help.rm.path"))
+
+    subparsers.add_parser("all", help=t("cli.help.all"))
+
+    save_parser = subparsers.add_parser("save", help=t("cli.help.save"))
+    save_parser.add_argument(
+        "--keep", type=int, default=0, help=t("cli.help.save.keep")
+    )
+    save_parser.add_argument("--password", default="", help=t("cli.help.save.password"))
+
+    watch_parser = subparsers.add_parser("watch", help=t("cli.help.watch"))
+    watch_parser.add_argument(
+        "--interval", type=float, default=60, help=t("cli.help.watch.interval")
+    )
+    watch_parser.add_argument(
+        "--keep", type=int, default=0, help=t("cli.help.watch.keep")
+    )
+    watch_parser.add_argument(
+        "--password", default="", help=t("cli.help.watch.password")
+    )
+
+    restore_parser = subparsers.add_parser("restore", help=t("cli.help.restore"))
+    restore_parser.add_argument("backup_file", help=t("cli.help.restore.file"))
+    restore_parser.add_argument("target_dir", help=t("cli.help.restore.dir"))
+
+    subparsers.add_parser("version", help=t("cli.help.version"))
+
+    return parser
+
+
+def parse_path(path_str: str) -> str:
+    return os.path.expanduser(path_str.strip())
+
+
+def run() -> int:
+    # 先检测 --lang 参数，初始化语言环境，再创建本地化 parser
+    lang_from_argv = _detect_lang_from_argv()
+    config = load_config()
+    current_lang = lang_from_argv if lang_from_argv is not None else config.lang
+    set_locale(current_lang)
+
+    parser = get_parser()
+    args = parser.parse_args()
+
+    # 持久化语言设置
+    if lang_from_argv is not None:
+        save_lang(lang_from_argv)
+
+    # 持久化格式设置
+    if args.format is not None:
+        save_format(args.format)
+        config.compression_format = args.format.upper().replace(".", "_")
+
+    if args.debug:
+        logging.basicConfig(
+            level=logging.DEBUG,
+            format="%(asctime)s [%(levelname)s] %(message)s",
+            datefmt="%H:%M:%S",
+        )
+
+    if args.command is None:
+        parser.print_help()
+        return 0
+
+    if args.command == "version":
+        print(t("cli.version", version=VERSION))
+        return 0
+
+    manager = BackupManager(data_file=config.data_file)
+
+    if args.command == "add":
+        source = parse_path(args.source)
+        dest = parse_path(args.dest)
+        # 条目级格式：用户在 add 时指定的 --format 仅作用于该条目
+        entry_fmt = args.format.upper().replace(".", "_") if args.format else ""
+        success = manager.add_folder(source, dest, args.ignore, entry_fmt)
+        if success:
+            print(t("cmd.add.success", source=source, dest=dest))
+            return 0
+        return 1
+    elif args.command in ("rm", "remove"):
+        path = parse_path(args.path)
+        success = manager.rm_folder(path)
+        if success:
+            print(t("cmd.rm.success", path=path))
+            return 0
+        return 1
+    elif args.command == "all":
+        print(manager.list_folder_table())
+        return 0
+    elif args.command == "save":
+        manager.execute_backups(keep=args.keep, password=args.password)
+        return 0
+    elif args.command == "watch":
+        import time as _time
+
+        interval_sec = args.interval * 60
+        print(t("cmd.watch.start", interval=args.interval))
+        try:
+            while True:
+                manager.execute_backups(keep=args.keep, password=args.password)
+                _time.sleep(interval_sec)
+        except KeyboardInterrupt:
+            return 0
+    elif args.command == "restore":
+        result = restore_backup(args.backup_file, args.target_dir)
+        return 0 if result["success"] else 1
+
+    return 0

sbackup/__main__.py

@@ -0,0 +1,5 @@
+import sys
+from sbackup import run
+
+if __name__ == "__main__":
+    sys.exit(run())

sbackup/auto_save.py

@@ -0,0 +1,336 @@
+import os
+import json
+import shutil
+import logging
+from pathlib import Path
+from dataclasses import dataclass
+from sbackup.config import (
+    Config,
+    load_config,
+    get_default_data_file,
+    DEFAULT_SKIP_PATTERNS,
+)
+from sbackup.compression import create_compressor
+from sbackup.i18n import t
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class BackupEntry:
+    """备份策略条目"""
+
+    mtime: float
+    target: str
+    skip_patterns: list[str]
+    compression_format: str = ""  # 空字符串表示使用全局默认格式
+
+    def to_list(self) -> list:
+        """转为 JSON 兼容的列表格式"""
+        return [self.mtime, self.target, self.skip_patterns, self.compression_format]
+
+    @staticmethod
+    def from_list(data: list) -> "BackupEntry":
+        """从 JSON 兼容的列表格式创建（向后兼容旧格式）"""
+        fmt = data[3] if len(data) > 3 else ""
+        return BackupEntry(
+            mtime=data[0], target=data[1], skip_patterns=data[2], compression_format=fmt
+        )
+
+
+class BackupManager:
+    """
+    管理备份策略的类，封装状态和读写操作
+    """
+
+    def __init__(self, data_file: str = ""):
+        self.data_file: str = data_file or get_default_data_file()
+        self.data: dict[str, list] = {}
+        self.load()
+
+    def load(self):
+        """
+        从 JSON 文件加载数据到内存
+        """
+        logger.debug(t("log.data.read"), self.data_file)
+        if not os.path.exists(self.data_file):
+            logger.debug(t("log.data.create"), self.data_file)
+            self.save(initial=True)
+        else:
+            logger.debug(t("log.data.load"), self.data_file)
+            try:
+                with open(self.data_file, "r", encoding="utf-8") as f:
+                    self.data = json.load(f)
+            except json.JSONDecodeError:
+                print(t("warn.json.decode.error", path=self.data_file))
+                # 备份损坏文件，避免数据丢失
+                backup_path = self.data_file + ".bak"
+                try:
+                    shutil.copy2(self.data_file, backup_path)
+                    print(t("warn.json.backup", path=backup_path))
+                except OSError:
+                    # 备份失败时重命名损坏文件，避免下次再次触发
+                    try:
+                        os.rename(self.data_file, self.data_file + ".corrupted")
+                        print(
+                            t("warn.json.renamed", path=self.data_file + ".corrupted")
+                        )
+                    except OSError:
+                        pass
+                self.data = {}
+
+    def save(self, initial: bool = False):
+        """
+        将内存数据写入 JSON 文件
+        """
+        if not initial:
+            logger.debug(t("log.data.write"), self.data_file)
+
+        data_dir = os.path.dirname(self.data_file)
+        if data_dir:
+            os.makedirs(data_dir, exist_ok=True)
+
+        with open(self.data_file, "w", encoding="utf-8") as f:
+            json.dump(self.data, f, ensure_ascii=False, indent=4)
+
+    def _get_entry(self, key: str) -> BackupEntry | None:
+        """获取指定路径的备份策略条目"""
+        raw = self.data.get(key)
+        if raw is None:
+            return None
+        return BackupEntry.from_list(raw)
+
+    def _set_entry(self, key: str, entry: BackupEntry):
+        """设置指定路径的备份策略条目"""
+        self.data[key] = entry.to_list()
+
+    def add_folder(
+        self,
+        folder_path: str,
+        target_folder: str,
+        skip_patterns: str | None = None,
+        compression_format: str = "",
+    ):
+        """
+        添加备份策略
+        :param compression_format: 条目级打包格式，空字符串使用全局默认
+        """
+        if skip_patterns is None:
+            skip_patterns = ",".join(DEFAULT_SKIP_PATTERNS)
+        skip_list = (
+            [s.strip() for s in skip_patterns.split(",") if s.strip()]
+            if skip_patterns
+            else []
+        )
+
+        if not os.path.isdir(folder_path):
+            print(t("err.folder.invalid", path=folder_path))
+            return False
+        if not os.path.isdir(target_folder):
+            print(t("err.dest.invalid", path=target_folder))
+            return False
+
+        abs_path = os.path.abspath(folder_path)
+        if abs_path in self.data:
+            print(t("info.already.added", path=abs_path))
+            return False
+
+        try:
+            entry = BackupEntry(
+                mtime=os.stat(abs_path).st_mtime,
+                target=os.path.abspath(target_folder),
+                skip_patterns=skip_list,
+                compression_format=compression_format,
+            )
+        except OSError as e:
+            print(t("err.os", error=e))
+            return False
+        self._set_entry(abs_path, entry)
+        self.save()
+        return True
+
+    def rm_folder(self, folder_path: str) -> bool:
+        """
+        删除备份策略
+        """
+        abs_path = os.path.abspath(folder_path)
+        if abs_path in self.data:
+            del self.data[abs_path]
+            self.save()
+            return True
+        else:
+            print(t("warn.no.strategy.found", path=abs_path))
+            return False
+
+    def execute_backups(self, keep: int = 0, password: str = ""):
+        """
+        执行所有备份策略
+        :param keep: 保留最近 N 个备份文件，0 表示不清理
+        :param password: 加密密码（仅 7z 格式支持）
+        """
+        config = load_config()
+        backup_count = 0
+        skip_count = 0
+        for key, raw in list(self.data.items()):
+            if key == "_history":
+                continue
+            if not os.path.exists(key):
+                print(t("warn.source.missing", path=key))
+                continue
+            try:
+                current_mtime = os.stat(key).st_mtime
+            except OSError as e:
+                print(t("err.os", error=e))
+                continue
+            entry = BackupEntry.from_list(raw)
+            if entry.mtime != current_mtime:
+                # 条目级格式优先，否则使用全局配置
+                fmt = entry.compression_format or config.compression_format
+                config_instance = Config(
+                    folder_path=key,
+                    zipfile_path=entry.target,
+                    skip_patterns=entry.skip_patterns,
+                    compression_format=fmt,
+                    compression_algorithm=config.compression_algorithm,
+                    compression_level=config.compression_level,
+                    password=password,
+                )
+                result = create_compressor(config_instance).compress()
+                if result["success"]:
+                    entry.mtime = current_mtime
+                    self._set_entry(key, entry)
+                    self._add_history(key, result["size_mb"], result["files_count"])
+                    if keep > 0:
+                        self._cleanup_old_backups(entry.target, keep)
+                    backup_count += 1
+            else:
+                skip_count += 1
+        if backup_count > 0:
+            self.save()
+            print(t("cmd.save.completed", count=backup_count))
+        elif skip_count > 0:
+            print(t("cmd.save.uptodate"))
+
+    # 向后兼容别名
+    save_folder = execute_backups
+
+    def _add_history(self, source: str, size_mb: float, files_count: int):
+        """记录备份历史"""
+        from datetime import datetime
+
+        history = self.data.setdefault("_history", [])
+        history.append(
+            {
+                "time": datetime.now().isoformat(timespec="seconds"),
+                "source": source,
+                "size_mb": round(size_mb, 2),
+                "files_count": files_count,
+            }
+        )
+        # 保留最近 100 条记录
+        if len(history) > 100:
+            self.data["_history"] = history[-100:]
+
+    def get_history(self) -> list[dict]:
+        """获取备份历史记录"""
+        return self.data.get("_history", [])
+
+    @staticmethod
+    def _cleanup_old_backups(target_dir: str, keep: int):
+        """清理旧备份文件，仅保留最近 keep 个（keep=0 时不清理）"""
+        if keep <= 0:
+            return
+
+        target = Path(target_dir)
+        if not target.is_dir():
+            return
+        # 收集所有备份文件（.zip / .tar.* / .7z）
+        patterns = [
+            "*.zip",
+            "*.tar",
+            "*.tar.gz",
+            "*.tar.bz2",
+            "*.tar.xz",
+            "*.tar.zst",
+            "*.7z",
+        ]
+        files = []
+        for pat in patterns:
+            files.extend(target.glob(pat))
+        if len(files) <= keep:
+            return
+        # 按修改时间排序，删除旧的
+        files.sort(key=lambda f: f.stat().st_mtime, reverse=True)
+        for old_file in files[keep:]:
+            try:
+                old_file.unlink()
+                logger.debug(t("log.cleanup.delete"), old_file)
+            except OSError:
+                pass
+
+    def all_folder(self) -> dict[str, str]:
+        """
+        查看所有备份策略
+        """
+        return {
+            key: BackupEntry.from_list(raw).target for key, raw in self.data.items()
+        }
+
+    @staticmethod
+    def _display_width(s: str) -> int:
+        """计算字符串的终端显示宽度（中文字符算2，英文字符算1）"""
+        if not isinstance(s, str):
+            return len(str(s))
+        width = 0
+        for ch in s:
+            if ord(ch) > 0x2E80:
+                width += 2
+            else:
+                width += 1
+        return width
+
+    def list_folder_table(self) -> str:
+        """
+        生成对齐的文本表格
+        """
+        if not self.data:
+            return t("cmd.all.empty")
+
+        headers = [
+            t("table.header.source"),
+            t("table.header.dest"),
+            t("table.header.format"),
+            t("table.header.ignore"),
+        ]
+        rows = []
+        for path, raw in self.data.items():
+            if path == "_history":
+                continue
+            entry = BackupEntry.from_list(raw)
+            fmt_display = (
+                entry.compression_format
+                if entry.compression_format
+                else t("table.cell.default")
+            )
+            skip = (
+                ", ".join(entry.skip_patterns)
+                if entry.skip_patterns
+                else t("table.cell.none")
+            )
+            rows.append([path, entry.target, fmt_display, skip])
+
+        col_widths = [self._display_width(h) for h in headers]
+        for row in rows:
+            for i, cell in enumerate(row):
+                col_widths[i] = max(col_widths[i], self._display_width(cell))
+
+        fmt = " | ".join(["{:<" + str(w) + "}" for w in col_widths])
+        sep = "-+-".join(["-" * w for w in col_widths])
+
+        lines = []
+        lines.append(fmt.format(*headers))
+        lines.append(sep)
+        for row in rows:
+            lines.append(fmt.format(*row))
+
+        return "\n".join(lines)