bitool 0.1.2__py3-none-any.whl

bitool/scripts/filedate.py

@@ -0,0 +1,246 @@
+"""移除文件日期前缀并替换为创建/修改时间."""
+
+from __future__ import annotations
+
+import argparse
+import concurrent.futures
+import logging
+import os
+import platform
+import re
+import time
+from dataclasses import dataclass
+from functools import cached_property, lru_cache
+from pathlib import Path
+from re import Pattern
+from typing import Final
+
+from bitool.core import logger
+
+
+class FileDateConfig:
+    """filedate 工具配置类."""
+
+    NAME: str = "filedate"
+    DETECT_SEPARATORS: str = "-_#.~"
+    SEP: str = "_"
+    MAX_RETRY: int = 100
+    WINDOWS_RESERVED_NAME_LEN: int = 4
+
+
+conf = FileDateConfig()
+
+
+def _is_windows_reserved_name(filename: str) -> bool:
+    """检查给定文件名是否为 Windows 保留名称.
+
+    Windows 保留名称包括 CON, PRN, AUX, NUL, 以及 COM1-COM9, LPT1-LPT9.
+    这些名称在 Windows 系统上不能用作文件或目录名.
+
+    Returns
+    -------
+        bool: 如果文件名是 Windows 保留名称则返回 True, 否则返回 False.
+    """
+    if platform.system().lower() != "windows":
+        return False
+
+    # 规范化文件名为大写并去除扩展名
+    name = Path(filename).stem.upper()
+
+    # 检查基本保留名称
+    if name in {"CON", "PRN", "AUX", "NUL"}:
+        return True
+
+    # 检查 COM 和 LPT 设备名称 (COM1-COM9, LPT1-LPT9)
+    if (name.startswith(("COM", "LPT"))) and len(
+        name
+    ) == conf.WINDOWS_RESERVED_NAME_LEN:
+        try:
+            num = int(name[3])
+            if 1 <= num <= 9:
+                return True
+        except ValueError:
+            pass
+
+    return False
+
+
+# 日期检测模式
+DATE_PATTERN: Final[Pattern[str]] = re.compile(
+    r"(20|19)\d{2}((0[1-9])|(1[012]))((0[1-9])|([12]\d)|(3[01]))"
+)
+
+
+@dataclass(frozen=True)
+class SingleFileRenamer:
+    """单个文件重命名器."""
+
+    path: Path
+
+    @staticmethod
+    def rename(path: Path) -> None:
+        """将带日期前缀的文件重命名为创建/修改时间."""
+        renamer = SingleFileRenamer(path)
+
+        dest_path = renamer.filepath_renamed
+        sequence = 1
+        while dest_path.exists() and sequence <= conf.MAX_RETRY:
+            logger.warning(f"{dest_path} 已存在, 添加唯一后缀.")
+            dest_path = renamer.filepath_renamed.with_name(
+                f"{renamer.filestem_renamed}({sequence}){renamer.file_suffix}"
+            )
+            sequence += 1
+
+        # 如果达到最大重试次数路径仍存在, 则放弃
+        if dest_path.exists() and sequence > conf.MAX_RETRY:
+            logger.error(f"已达到最大重试次数, 放弃处理 {renamer.path}.")
+            return
+
+        try:
+            renamer.path.rename(dest_path)
+        except (OSError, PermissionError):
+            logger.exception("重命名失败: %s -> %s", renamer.path, dest_path)
+            raise
+        else:
+            logger.info("重命名: %s -> %s", renamer.path, dest_path)
+
+    @cached_property
+    def file_suffix(self) -> str:
+        """获取文件后缀."""
+        return self.path.suffix
+
+    @cached_property
+    def filepath_renamed(self) -> Path:
+        """获取重命名后的文件路径."""
+        return self.path.with_name(self.filename_renamed)
+
+    @cached_property
+    def filestem_renamed(self) -> str:
+        """获取重命名后的文件名主干."""
+        # 从文件名字符串中提取主干
+        suffix = self.path.suffix
+        return (
+            self.filename_renamed[: -len(suffix)]
+            if suffix and self.filename_renamed.endswith(suffix)
+            else self.filename_renamed
+        )
+
+    @cached_property
+    def filename_renamed(self) -> str:
+        """获取重命名后的文件名."""
+        return (
+            f"{self.time_mark}{conf.SEP}{self.filestem_without_date}{self.path.suffix}"
+        )
+
+    @cached_property
+    def filestem_without_date(self) -> str:
+        """获取去除日期前缀的文件名主干."""
+
+        @lru_cache(maxsize=1024)
+        def remove_date_prefix(filestem: str) -> str:
+            """从文件名中移除日期前缀.
+
+            Returns
+            -------
+                str: 移除了日期前缀的文件名.
+            """
+            if (
+                filestem.startswith(".")
+                and not filestem[1:].isdigit()
+                and len(filestem) > 1
+            ) and not re.search(DATE_PATTERN, filestem):
+                return ""
+
+            match = re.search(DATE_PATTERN, filestem)
+            if not match:
+                logger.debug("未检测到日期前缀: %s", filestem)
+                return filestem
+            b, e = match.start(), match.end()
+            if b >= 1 and filestem[b - 1] in conf.DETECT_SEPARATORS:
+                filestem = filestem[: b - 1] + filestem[e:]
+            elif e < len(filestem) and filestem[e] in conf.DETECT_SEPARATORS:
+                filestem = filestem[:b] + filestem[e + 1 :]
+            return remove_date_prefix(filestem)
+
+        return remove_date_prefix(self.filestem)
+
+    @cached_property
+    def filestem(self) -> str:
+        """获取当前文件名主干."""
+        return self.path.stem
+
+    @cached_property
+    def filestat(self) -> os.stat_result:
+        """获取文件 stat 信息."""
+        return self.path.stat()
+
+    @cached_property
+    def modified_time(self) -> float:
+        """获取修改时间."""
+        return self.filestat.st_mtime
+
+    @cached_property
+    def created_time(self) -> float:
+        """获取创建时间."""
+        return self.filestat.st_ctime
+
+    @cached_property
+    def time_mark(self) -> str:
+        """获取时间标记."""
+        return time.strftime(
+            "%Y%m%d", time.localtime(max((self.modified_time, self.created_time)))
+        )
+
+
+@dataclass(frozen=True)
+class MultiFileRenamer:
+    """多文件重命名器."""
+
+    paths: list[str]
+
+    @staticmethod
+    def rename_files(paths: list[str]) -> None:
+        """将带日期前缀的文件重命名为创建/修改时间."""
+        renamer = MultiFileRenamer(paths)
+        if not renamer.filtered_paths:
+            logger.error("没有有效的文件可处理.")
+            return
+
+        t0 = time.perf_counter()
+        with concurrent.futures.ThreadPoolExecutor(max_workers=8) as executor:
+            executor.map(SingleFileRenamer.rename, renamer.filtered_paths)
+        logger.info("处理完成, 耗时: %.4fs", time.perf_counter() - t0)
+
+    @cached_property
+    def converted_paths(self) -> list[Path]:
+        """获取转换后的路径列表."""
+        return [Path(p) for p in self.paths]
+
+    @cached_property
+    def filtered_paths(self) -> list[Path]:
+        """获取过滤后的有效路径列表."""
+        return [
+            p
+            for p in self.converted_paths
+            if p.exists() and p.is_file() and not _is_windows_reserved_name(p.name)
+        ]
+
+    @cached_property
+    def missing_paths(self) -> list[Path]:
+        """获取缺失的路径列表."""
+        return list(set(self.converted_paths) - set(self.filtered_paths))
+
+
+def main() -> None:
+    """运行命令行界面入口点."""
+    parser = argparse.ArgumentParser(
+        prog="filedate", description="移除文件日期前缀并替换为创建/修改时间."
+    )
+    parser.add_argument("targets", type=str, nargs="+", help="输入文件列表")
+    parser.add_argument("--debug", "-d", action="store_true", help="启用调试模式")
+    args = parser.parse_args()
+
+    if args.debug:
+        logger.setLevel(logging.DEBUG)
+
+    MultiFileRenamer.rename_files(args.targets)

bitool/scripts/filelevel.py

@@ -0,0 +1,191 @@
+"""重命名文件等级后缀."""
+
+from __future__ import annotations
+
+import argparse
+import concurrent.futures
+import logging
+import os
+from pathlib import Path
+from typing import Final
+
+from bitool.core import logger
+
+
+class FilelevelConfig:
+    """文件等级配置."""
+
+    LEVELS: Final[dict[str, str]] = {"0": "", "1": "PUB,NOR", "2": "INT", "3": "CON", "4": "CLA"}
+    BRACKETS: Final[tuple[str, str]] = (" ([_(【-", " )]_）】")
+
+
+conf = FilelevelConfig()
+
+_MAX_LEVELS = len(conf.LEVELS)
+_MIN_FILES_FOR_CONCURRENT = 5  # 触发并行处理的最小文件数
+_LEVEL_VALUES = list(conf.LEVELS.values())
+_LEFT_BRACKETS, _RIGHT_BRACKETS = conf.BRACKETS
+
+
+def remove_marks(stem: str, marks: list[str]) -> str:
+    """从文件名主干中移除所有标记.
+
+    Args:
+        stem: 文件名主干
+        marks: 要移除的标记列表
+
+    Returns:
+        str: 移除了标记的文件名主干
+    """
+    for mark in marks:
+        pos = 0
+        while True:
+            pos = stem.find(mark, pos)
+            if pos == -1:
+                break
+            b, e = pos - 1, pos + len(mark)
+            if b >= 0 and e < len(stem) and stem[b] in _LEFT_BRACKETS and stem[e] in _RIGHT_BRACKETS:
+                stem = stem[:b] + stem[e + 1 :]
+            else:
+                pos = e
+    return stem
+
+
+def process_file(target: Path, level: int = 0) -> bool:
+    """处理单个文件，使用指定等级.
+
+    Args:
+        target: 目标文件路径
+        level: 文件等级 (0-4), 0 用于清除等级
+
+    Returns:
+        bool: 处理成功返回 True，失败返回 False
+    """
+    try:
+        if not (0 <= level < _MAX_LEVELS):
+            logger.error("无效的等级 %d, 必须在 0 和 %d 之间", level, _MAX_LEVELS - 1)
+            return False
+
+        if not target.exists() or not os.access(target, os.W_OK):
+            logger.error("文件不存在或不可写:%s", target)
+            return False
+
+        # 处理文件名
+        filestem = target.stem
+        original_stem = filestem
+
+        # 移除所有等级标记
+        for level_names in _LEVEL_VALUES:
+            if level_names:
+                filestem = remove_marks(filestem, level_names.split(","))
+
+        # 移除数字标记
+        for digit in map(str, range(1, 10)):
+            filestem = remove_marks(filestem, [digit])
+
+        # 仅在文件名改变或需要添加标记时进行处理
+        if filestem != original_stem or level > 0:
+            # 添加等级标记
+            if level > 0:
+                levelstr = conf.LEVELS.get(str(level), "").split(",")[0]
+                if levelstr:
+                    filestem = f"{filestem}({levelstr})"
+
+            # 重命名文件
+            target_path = target.with_name(filestem + target.suffix)
+            if target_path != target:
+                logger.info("重命名:%s -> %s", target, target_path)
+                target.rename(target_path)
+    except (OSError, ValueError, RuntimeError):
+        logger.exception("处理文件 %s 时出错", target)
+        return False
+    else:
+        return True
+
+
+def _handle_future_exception(future: concurrent.futures.Future) -> None:
+    """安全地获取 Future 结果，捕获并记录异常.
+
+    Args:
+        future: 要检查的 Future 对象
+    """
+    try:
+        future.result()
+    except (OSError, ValueError, RuntimeError):
+        logger.exception("处理文件时出错")
+
+
+def _process_files_concurrent(targets: list[Path], level: int, max_workers: int) -> None:
+    """使用线程池并行处理多个文件.
+
+    Args:
+        targets: 目标文件路径列表
+        level: 文件等级 (0-4)
+        max_workers: 最大工作线程数
+    """
+    logger.info("对大量文件使用并行处理")
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = [executor.submit(process_file, target, level) for target in targets]
+        for future in concurrent.futures.as_completed(futures):
+            _handle_future_exception(future)
+
+
+def parse_args(args: list[str] | None = None) -> argparse.Namespace:
+    """解析命令行参数.
+
+    Args:
+        args: 命令行参数列表，None 时使用 sys.argv
+
+    Returns:
+        argparse.Namespace: 包含以下内容的已解析命名空间:
+            - targets (list[Path]): 要处理的文件
+            - level (int): 文件等级 0-4
+            - max_workers (int): 线程池大小
+            - debug (bool): 启用调试日志
+    """
+    parser = argparse.ArgumentParser(
+        description="重命名文件等级后缀",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+示例:
+  filelevel file1.txt file2.txt --level 1
+  filelevel *.txt -l 2
+  filelevel document.pdf --level 0  # 清除等级
+        """,
+    )
+    parser.add_argument("targets", nargs="+", type=Path, help="要处理的目标文件")
+    parser.add_argument(
+        "--level",
+        "-l",
+        type=int,
+        default=0,
+        choices=range(_MAX_LEVELS),
+        help=f"文件等级 (0-{_MAX_LEVELS - 1}), 0 用于清除等级 (默认:0)",
+    )
+    parser.add_argument("--max-workers", "-w", type=int, default=4, help="并行处理的最大工作线程数 (默认:4)")
+    parser.add_argument("--debug", "-d", action="store_true", help="启用调试模式")
+
+    return parser.parse_args(args)
+
+
+def main() -> None:
+    """运行命令行界面入口点."""
+    args = parse_args()
+
+    if args.debug:
+        logger.setLevel(logging.DEBUG)
+
+    if not any(Path(t).exists() for t in args.targets):
+        logger.error("在以下文件中未找到有效文件:%s", args.targets)
+        return
+
+    if len(args.targets) >= _MIN_FILES_FOR_CONCURRENT:
+        _process_files_concurrent(args.targets, args.level, args.max_workers)
+    else:
+        logger.info("对小量文件使用串行处理")
+        for target in args.targets:
+            process_file(target, args.level)
+
+
+if __name__ == "__main__":
+    main()

bitool/scripts/gittool.py

@@ -0,0 +1,178 @@
+"""Git工具模块.
+
+提供Git仓库管理的常用操作封装, 支持初始化、提交、清理、推送等功能.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+from pathlib import Path
+
+from bitool.cmd import CommandScheduler, RunCommand
+from bitool.core import ConfigMixin
+from bitool.utils import execute
+
+
+class GitToolConfig(ConfigMixin):
+    """Git工具配置类."""
+
+    CACHE_DIRS_FOR_CLEAN: list[str] = [  # noqa: RUF012
+        ".coverage",
+        ".benchmarks",
+        ".ruff_cache",
+        ".pytest_cache",
+        ".mypy_cache",
+        "__pycache__",
+        ".hypothesis",
+        "htmlcov",
+    ]
+
+    EXCLUDE_DIRS_FOR_CLEAN: list[str] = [  # noqa: RUF012
+        ".venv",
+        "node_modules",
+        ".git",
+        ".idea",
+        ".vscode",
+    ]
+
+
+conf = GitToolConfig()
+
+
+def init_subdirs_scheduler() -> CommandScheduler:
+    """初始化子目录的Git仓库."""
+
+    def func() -> None:
+        """初始化子目录的Git仓库."""
+        origin = Path.cwd()
+        subdirs = [d for d in Path.cwd().iterdir() if d.is_dir()]
+        for subdir in subdirs:
+            os.chdir(str(subdir))
+            execute(
+                [
+                    ["git", "init"],
+                    ["git", "add", "."],
+                    ["git", "commit", "-m", "init commit"],
+                ]
+            )
+
+        os.chdir(str(origin))
+
+    return CommandScheduler(commands=[RunCommand(cmd=func)])
+
+
+def create_scheduler_map() -> dict[str, CommandScheduler]:
+    """创建Git工具命令调度器映射."""
+    return {
+        "a": CommandScheduler(
+            commands=[
+                RunCommand(
+                    name="add",
+                    cmd=["git", "add", "."],
+                    description="将所有更改添加到暂存区",
+                ),
+                RunCommand(
+                    name="commit",
+                    cmd=["git", "commit", "-m", "chore: update"],
+                    description="提交所有更改",
+                ),
+            ]
+        ),
+        "c": CommandScheduler(
+            commands=[
+                RunCommand(
+                    name="clean",
+                    cmd=["git", "clean", "-xfd"]
+                    + [arg for d in conf.EXCLUDE_DIRS_FOR_CLEAN for arg in ["-e", d]],
+                    description="清理工作区",
+                ),
+                RunCommand(
+                    name="status",
+                    cmd=["git", "status", "--porcelain"],
+                    description="显示状态",
+                ),
+            ]
+        ),
+        "i": CommandScheduler(
+            commands=[
+                RunCommand(
+                    name="init",
+                    cmd=["git", "init"],
+                    description="初始化Git仓库",
+                    forbid_conditions=[
+                        (
+                            lambda: (
+                                ".git"
+                                in [d.name for d in Path.cwd().iterdir() if d.is_dir()]
+                            ),
+                            "Git仓库已初始化",
+                        )
+                    ],
+                ),
+                RunCommand(
+                    name="add",
+                    cmd=["git", "add", "."],
+                    description="将所有更改添加到暂存区",
+                    forbid_conditions=[
+                        (lambda: not Path.cwd().glob("*"), "没有文件可添加")
+                    ],
+                ),
+                RunCommand(
+                    name="commit",
+                    cmd=["git", "commit", "-m", "chore: update"],
+                    description="提交所有更改",
+                    forbid_conditions=[
+                        (lambda: not Path.cwd().glob("*"), "没有文件可提交")
+                    ],
+                ),
+            ]
+        ),
+        "isub": init_subdirs_scheduler(),
+        "p": CommandScheduler(
+            commands=[
+                RunCommand(
+                    name="push", cmd=["git", "push"], description="推送更改到远程仓库"
+                )
+            ]
+        ),
+        "pl": CommandScheduler(
+            commands=[
+                RunCommand(
+                    name="pull",
+                    cmd=["git", "pull"],
+                    description="从远程仓库拉取最新更改",
+                )
+            ]
+        ),
+        "re": CommandScheduler(
+            commands=[
+                RunCommand(
+                    name="重启tgitcache",
+                    cmd=["taskkill", "/f", "/t", "/im", "tgitcache.exe"],
+                    description="重启tgitcache服务(如果正在运行)",
+                )
+            ]
+        ),
+    }
+
+
+ACTIONS = list(create_scheduler_map().keys())
+
+
+def parse_args() -> argparse.Namespace:
+    """解析命令行参数."""
+    parser = argparse.ArgumentParser(description="Git工具")
+    parser.add_argument("action", choices=ACTIONS, help="要执行的操作")
+    return parser.parse_args()
+
+
+def main() -> None:
+    """Git工具主函数."""
+    args = parse_args()
+    scheduler_map = create_scheduler_map()
+    scheduler = scheduler_map.get(args.action, None)
+    if not scheduler:
+        raise ValueError(f"无效的操作: {args.action}")
+
+    scheduler.run()