export_clean.py

#!/usr/bin/env python3
"""
导出干净的项目代码，删除构建缓存和大文件
"""

import os
import shutil
import argparse
from pathlib import Path

# 要删除的目录
DIRS_TO_DELETE = [
    "build",
    ".vs",
    "__pycache__",
    "CMakeFiles",
    "x64",
    "Debug",
    "Release",
    ".cache",
    "out",
    # extern 子模块中的构建目录
    "**/build",
    "**/.vs",
    "**/CMakeFiles",
]

# 要删除的文件扩展名（构建产物）
EXTENSIONS_TO_DELETE = [
    # 编译产物
    ".o", ".obj", ".lo", ".slo",
    ".a", ".lib", ".la", ".lai",
    ".so", ".dll", ".dylib",
    ".exe", ".out", ".app",
    ".pch", ".gch",
    ".d", ".mod", ".smod",
    # Visual Studio
    ".pdb", ".ilk", ".exp",
    ".idb", ".ipdb", ".iobj",
    # CMake
    ".cmake",
    # Python 缓存
    ".pyc", ".pyo",
    # CUDA 编译产物
    ".ptx", ".cubin", ".fatbin",
    # 临时文件
    ".tmp", ".temp", ".log",
]

# 要删除的特定文件名
FILES_TO_DELETE = [
    "CMakeCache.txt",
    "cmake_install.cmake",
    "Makefile",
    "compile_commands.json",
    ".DS_Store",
    "Thumbs.db",
    "desktop.ini",
]

# 要删除的大文件目录或文件（根据你的项目调整）
LARGE_ITEMS_TO_DELETE = [
    # 渲染输出的 EXR 文件（很大）
    "scenes/curly/render.exr",
    "scenes/curly/render*.exr",
    "scenes/envmaps",  # 环境贴图很大
    # assets 目录中的二进制文件（可选，如果需要保留模型就注释掉）
    # "assets/*.bin",
]

# 要保留的代码文件扩展名
CODE_EXTENSIONS = {
    ".cpp", ".cc", ".cxx", ".c",
    ".h", ".hpp", ".hxx", ".hh",
    ".cu", ".cuh",  # CUDA
    ".py",
    ".cmake", ".txt",  # CMakeLists.txt
    ".json",
    ".md",
    ".sh", ".bat",
    ".gitignore", ".gitmodules",
}


def get_size_str(size_bytes):
    """将字节转换为可读的大小字符串"""
    for unit in ['B', 'KB', 'MB', 'GB']:
        if size_bytes < 1024:
            return f"{size_bytes:.2f} {unit}"
        size_bytes /= 1024
    return f"{size_bytes:.2f} TB"


def get_dir_size(path):
    """计算目录大小"""
    total = 0
    try:
        for entry in os.scandir(path):
            if entry.is_file(follow_symlinks=False):
                total += entry.stat().st_size
            elif entry.is_dir(follow_symlinks=False):
                total += get_dir_size(entry.path)
    except (PermissionError, OSError):
        pass
    return total


def find_items_to_delete(root_path, delete_exr=True, delete_envmaps=True, delete_assets_bin=False):
    """查找所有需要删除的项目"""
    items_to_delete = []
    root = Path(root_path)
    
    # 1. 查找要删除的目录
    dir_patterns = ["build", ".vs", "__pycache__", "CMakeFiles", "x64", "Debug", "Release", ".cache", "out"]
    for dirpath, dirnames, filenames in os.walk(root):
        dirpath = Path(dirpath)
        
        # 跳过 .git 目录
        if ".git" in dirpath.parts:
            continue
            
        for dirname in dirnames[:]:  # 使用切片复制列表以便修改
            if dirname in dir_patterns:
                full_path = dirpath / dirname
                size = get_dir_size(full_path)
                items_to_delete.append(("dir", full_path, size))
                dirnames.remove(dirname)  # 不再遍历这个目录
    
    # 2. 查找要删除的文件（按扩展名）
    for dirpath, dirnames, filenames in os.walk(root):
        dirpath = Path(dirpath)
        
        # 跳过 .git 目录
        if ".git" in dirpath.parts:
            continue
            
        # 跳过已标记删除的目录
        skip = False
        for item_type, item_path, _ in items_to_delete:
            if item_type == "dir" and str(dirpath).startswith(str(item_path)):
                skip = True
                break
        if skip:
            continue
            
        for filename in filenames:
            filepath = dirpath / filename
            
            # 检查扩展名
            ext = filepath.suffix.lower()
            if ext in EXTENSIONS_TO_DELETE:
                try:
                    size = filepath.stat().st_size
                    items_to_delete.append(("file", filepath, size))
                except OSError:
                    pass
                continue
            
            # 检查特定文件名
            if filename in FILES_TO_DELETE:
                try:
                    size = filepath.stat().st_size
                    items_to_delete.append(("file", filepath, size))
                except OSError:
                    pass
                continue
            
            # 检查 EXR 文件
            if delete_exr and ext == ".exr":
                try:
                    size = filepath.stat().st_size
                    items_to_delete.append(("file", filepath, size))
                except OSError:
                    pass
    
    # 3. 检查环境贴图目录
    if delete_envmaps:
        envmaps_dir = root / "scenes" / "envmaps"
        if envmaps_dir.exists():
            size = get_dir_size(envmaps_dir)
            items_to_delete.append(("dir", envmaps_dir, size))
    
    # 4. 检查 assets 中的 bin 文件
    if delete_assets_bin:
        assets_dir = root / "assets"
        if assets_dir.exists():
            for f in assets_dir.glob("*.bin"):
                try:
                    size = f.stat().st_size
                    items_to_delete.append(("file", f, size))
                except OSError:
                    pass
    
    return items_to_delete


def delete_items(items, dry_run=False):
    """删除指定的项目"""
    total_freed = 0
    deleted_count = 0
    
    for item_type, item_path, size in items:
        try:
            if dry_run:
                print(f"[DRY-RUN] 将删除 {item_type}: {item_path} ({get_size_str(size)})")
            else:
                if item_type == "dir":
                    shutil.rmtree(item_path)
                else:
                    os.remove(item_path)
                print(f"已删除 {item_type}: {item_path} ({get_size_str(size)})")
            total_freed += size
            deleted_count += 1
        except Exception as e:
            print(f"无法删除 {item_path}: {e}")
    
    return deleted_count, total_freed


def copy_clean_project(src_root, dest_root, delete_exr=True, delete_envmaps=True, delete_assets_bin=False):
    """复制干净的项目到新目录"""
    src_root = Path(src_root)
    dest_root = Path(dest_root)
    
    if dest_root.exists():
        print(f"目标目录 {dest_root} 已存在，是否覆盖？(y/n)")
        if input().lower() != 'y':
            print("取消操作")
            return
        shutil.rmtree(dest_root)
    
    # 获取要跳过的模式
    skip_dirs = {"build", ".vs", "__pycache__", "CMakeFiles", "x64", "Debug", "Release", ".cache", "out", ".git"}
    skip_extensions = set(EXTENSIONS_TO_DELETE)
    if delete_exr:
        skip_extensions.add(".exr")
    
    copied_files = 0
    total_size = 0
    
    for dirpath, dirnames, filenames in os.walk(src_root):
        dirpath = Path(dirpath)
        rel_path = dirpath.relative_to(src_root)
        
        # 跳过特定目录
        dirnames[:] = [d for d in dirnames if d not in skip_dirs]
        
        # 跳过环境贴图目录
        if delete_envmaps and rel_path == Path("scenes"):
            if "envmaps" in dirnames:
                dirnames.remove("envmaps")
        
        # 创建目标目录
        dest_dir = dest_root / rel_path
        dest_dir.mkdir(parents=True, exist_ok=True)
        
        for filename in filenames:
            src_file = dirpath / filename
            ext = src_file.suffix.lower()
            
            # 跳过构建产物
            if ext in skip_extensions:
                continue
            
            # 跳过特定文件
            if filename in FILES_TO_DELETE:
                continue
            
            # 跳过 assets 中的 bin 文件（可选）
            if delete_assets_bin and rel_path == Path("assets") and ext == ".bin":
                continue
            
            # 复制文件
            dest_file = dest_dir / filename
            try:
                shutil.copy2(src_file, dest_file)
                copied_files += 1
                total_size += src_file.stat().st_size
            except Exception as e:
                print(f"无法复制 {src_file}: {e}")
    
    print(f"\n复制完成！")
    print(f"复制了 {copied_files} 个文件")
    print(f"总大小: {get_size_str(total_size)}")
    print(f"目标目录: {dest_root}")


def calculate_remaining(root_path, items_to_delete):
    """计算删除后会保留的文件数量和大小"""
    root = Path(root_path)
    
    # 构建要删除的路径集合
    delete_paths = set()
    delete_dirs = set()
    for item_type, item_path, _ in items_to_delete:
        if item_type == "dir":
            delete_dirs.add(Path(item_path))
        else:
            delete_paths.add(Path(item_path))
    
    remaining_files = 0
    remaining_size = 0
    remaining_by_ext = {}
    
    for dirpath, dirnames, filenames in os.walk(root):
        dirpath = Path(dirpath)
        
        # 跳过 .git 目录
        if ".git" in dirpath.parts:
            continue
        
        # 检查是否在要删除的目录中
        skip_dir = False
        for del_dir in delete_dirs:
            if dirpath == del_dir or del_dir in dirpath.parents or dirpath in del_dir.parents:
                if str(dirpath).startswith(str(del_dir)):
                    skip_dir = True
                    break
        if skip_dir:
            continue
        
        for filename in filenames:
            filepath = dirpath / filename
            
            # 跳过要删除的文件
            if filepath in delete_paths:
                continue
            
            try:
                size = filepath.stat().st_size
                remaining_files += 1
                remaining_size += size
                
                # 按扩展名统计
                ext = filepath.suffix.lower() or "(无扩展名)"
                if ext not in remaining_by_ext:
                    remaining_by_ext[ext] = {"count": 0, "size": 0}
                remaining_by_ext[ext]["count"] += 1
                remaining_by_ext[ext]["size"] += size
            except OSError:
                pass
    
    return remaining_files, remaining_size, remaining_by_ext


def main():
    parser = argparse.ArgumentParser(description="清理项目构建缓存，导出干净代码")
    parser.add_argument("--dry-run", "-n", action="store_true", 
                        help="仅显示将要删除的内容，不实际删除")
    parser.add_argument("--copy-to", "-c", type=str, 
                        help="复制干净的项目到指定目录（而不是原地删除）")
    parser.add_argument("--keep-exr", action="store_true",
                        help="保留 EXR 渲染结果文件")
    parser.add_argument("--keep-envmaps", action="store_true",
                        help="保留环境贴图目录")
    parser.add_argument("--delete-assets-bin", action="store_true",
                        help="删除 assets 目录中的 .bin 模型文件")
    parser.add_argument("--root", "-r", type=str, default=".",
                        help="项目根目录（默认为当前目录）")
    
    args = parser.parse_args()
    
    root_path = Path(args.root).resolve()
    print(f"项目根目录: {root_path}")
    
    if args.copy_to:
        # 复制模式：复制干净的项目到新目录
        dest_path = Path(args.copy_to).resolve()
        print(f"\n将复制干净的项目到: {dest_path}")
        print(f"  - 删除 EXR 文件: {'否' if args.keep_exr else '是'}")
        print(f"  - 删除环境贴图: {'否' if args.keep_envmaps else '是'}")
        print(f"  - 删除模型 bin 文件: {'是' if args.delete_assets_bin else '否'}")
        
        if not args.dry_run:
            copy_clean_project(
                root_path, dest_path,
                delete_exr=not args.keep_exr,
                delete_envmaps=not args.keep_envmaps,
                delete_assets_bin=args.delete_assets_bin
            )
        else:
            print("\n[DRY-RUN] 不会实际复制文件")
    else:
        # 删除模式：原地删除构建缓存
        print("\n扫描要删除的项目...")
        items = find_items_to_delete(
            root_path,
            delete_exr=not args.keep_exr,
            delete_envmaps=not args.keep_envmaps,
            delete_assets_bin=args.delete_assets_bin
        )
        
        if not items:
            print("没有找到需要删除的项目")
            return
        
        # 按大小排序
        items.sort(key=lambda x: x[2], reverse=True)
        
        total_delete_size = sum(item[2] for item in items)
        print(f"\n找到 {len(items)} 个项目，共 {get_size_str(total_delete_size)}")
        print("\n将要删除的项目:")
        for item_type, item_path, size in items[:20]:  # 显示前20个最大的
            print(f"  [{item_type:4}] {item_path} ({get_size_str(size)})")
        if len(items) > 20:
            print(f"  ... 还有 {len(items) - 20} 个项目")
        
        # 计算保留的内容
        print("\n计算保留的文件...")
        remaining_files, remaining_size, remaining_by_ext = calculate_remaining(root_path, items)
        
        print(f"\n{'='*60}")
        print(f"📊 统计摘要")
        print(f"{'='*60}")
        print(f"  🗑️  将删除: {len(items)} 个项目, {get_size_str(total_delete_size)}")
        print(f"  ✅ 将保留: {remaining_files} 个文件, {get_size_str(remaining_size)}")
        print(f"{'='*60}")
        
        # 按大小排序显示保留的文件类型
        print(f"\n📁 保留文件按类型统计 (按大小排序):")
        sorted_ext = sorted(remaining_by_ext.items(), key=lambda x: x[1]["size"], reverse=True)
        for ext, stats in sorted_ext[:15]:  # 显示前15种类型
            print(f"  {ext:12} : {stats['count']:5} 个文件, {get_size_str(stats['size']):>10}")
        if len(sorted_ext) > 15:
            print(f"  ... 还有 {len(sorted_ext) - 15} 种文件类型")
        
        if args.dry_run:
            print(f"\n[DRY-RUN] 如果删除，将释放 {get_size_str(total_delete_size)} 空间")
            print(f"[DRY-RUN] 删除后项目大小约为 {get_size_str(remaining_size)}")
        else:
            print(f"\n确认删除这些项目？(y/n)")
            if input().lower() == 'y':
                deleted_count, freed_space = delete_items(items)
                print(f"\n删除完成！")
                print(f"删除了 {deleted_count} 个项目")
                print(f"释放了 {get_size_str(freed_space)} 空间")
                print(f"项目当前大小约为 {get_size_str(remaining_size)}")
            else:
                print("取消删除")


if __name__ == "__main__":
    main()