🚀 Python으로 완성하는 스마트 폴더 클리너: 재귀적 빈 폴더 자동 정리 시스템 구현 가이드

전체 코드

프로그램의 전체 코드입니다 (recursive_folder_cleaner.py):

import os
import sys
import subprocess
import tkinter as tk
from tkinter import filedialog, messagebox
from pathlib import Path

# 필요한 모듈 설치 확인 및 설치 함수
def check_and_install_requirements():
    try:
        import send2trash
    except ImportError:
        print("프로그램 실행을 위해 'send2trash' 모듈 설치가 필요합니다.")
        response = input("자동으로 설치를 진행할까요? (Y/N): ").strip().upper()
        
        if response == 'Y':
            print("send2trash 모듈을 설치합니다...")
            try:
                subprocess.check_call([sys.executable, "-m", "pip", "install", "send2trash"])
                print("설치가 완료되었습니다.")
                import send2trash
            except Exception as e:
                print(f"설치 중 오류가 발생했습니다: {str(e)}")
                input("아무 키나 누르면 프로그램이 종료됩니다...")
                sys.exit(1)
        else:
            print("설치를 취소했습니다.")
            input("아무 키나 누르면 프로그램이 종료됩니다...")
            sys.exit(0)

# 메인 클래스: 빈 폴더 정리 프로그램
class RecursiveEmptyFolderCleaner:
    def __init__(self):
        # GUI 창 초기화
        self.root = tk.Tk()
        self.root.title("상위 빈 폴더 삭제 프로그램")
        self.root.geometry("500x400")
        
        # UI 구성 요소 생성
        self.create_widgets()
        
        # 삭제된 폴더 수 추적
        self.deleted_count = 0
        
    def create_widgets(self):
        # 상단 설명 레이블
        header_label = tk.Label(
            self.root,
            text="완전히 비어있는 폴더 구조를 찾아 삭제합니다.\n(예: 폴더1/폴더2/폴더3이 모두 비어있으면 폴더1부터 삭제)",
            pady=10,
            wraplength=400
        )
        header_label.pack()
        
        # 경로 표시 프레임
        path_frame = tk.Frame(self.root)
        path_frame.pack(pady=10, padx=20, fill='x')
        
        self.path_var = tk.StringVar()
        path_entry = tk.Entry(path_frame, textvariable=self.path_var, width=50)
        path_entry.pack(side='left', expand=True, fill='x', padx=(0, 10))
        
        browse_btn = tk.Button(
            path_frame,
            text="경로 선택",
            command=self.browse_directory
        )
        browse_btn.pack(side='right')

        # 실행 버튼
        execute_btn = tk.Button(
            self.root,
            text="빈 폴더 검사 및 삭제",
            command=self.execute_deletion,
            width=20,
            height=2
        )
        execute_btn.pack(pady=20)
        
        # 결과 표시 영역
        self.result_text = tk.Text(self.root, height=12, width=50)
        self.result_text.pack(pady=10, padx=20)
    
    def browse_directory(self):
        # 폴더 선택 대화상자 표시
        directory = filedialog.askdirectory()
        if directory:
            self.path_var.set(directory)
    
    def is_directory_empty_recursive(self, path):
        """재귀적으로 디렉토리가 완전히 비어있는지 확인"""
        try:
            path_obj = Path(path)
            if not path_obj.exists():
                return False
            
            # 디렉토리 내의 모든 항목 확인
            for entry in path_obj.iterdir():
                if entry.is_file():
                    # 파일이 있으면 비어있지 않음
                    return False
                elif entry.is_dir():
                    # 하위 디렉토리가 있으면 그 디렉토리도 확인
                    if not self.is_directory_empty_recursive(str(entry)):
                        return False
            return True
        except Exception as e:
            self.result_text.insert('end', f"경로 검사 중 오류 발생: {path} - {str(e)}\n")
            return False
    
    def find_empty_root_folders(self, start_path):
        """완전히 비어있는 최상위 폴더들을 찾음"""
        empty_roots = set()
        start_path_obj = Path(start_path)
        
        try:
            # 모든 디렉토리를 검사
            for path_obj in start_path_obj.rglob('*'):
                if path_obj.is_dir() and self.is_directory_empty_recursive(str(path_obj)):
                    # 현재 폴더가 비어있으면, 상위 폴더들도 검사
                    current_path = path_obj
                    while current_path != start_path_obj.parent:
                        if self.is_directory_empty_recursive(str(current_path)):
                            empty_roots.add(str(current_path))
                            current_path = current_path.parent
                        else:
                            break
        except Exception as e:
            self.result_text.insert('end', f"폴더 검색 중 오류 발생: {str(e)}\n")
        
        # 중복 제거 (하위 폴더가 이미 포함된 상위 폴더는 제외)
        final_roots = set()
        for folder in empty_roots:
            parent_found = False
            folder_path = Path(folder)

            for other in empty_roots:
                if folder != other and str(folder_path).startswith(str(Path(other))):
                    parent_found = True
                    break
            
            if not parent_found:
                final_roots.add(folder)
        
        return final_roots

    def execute_deletion(self):
        """빈 폴더 검사 및 삭제 실행"""
        import send2trash  # 실행 시점에 import
        
        path = self.path_var.get()
        if not path:
            messagebox.showerror("오류", "경로를 선택해주세요.")
            return
            
        if not os.path.exists(path):
            messagebox.showerror("오류", "유효하지 않은 경로입니다.")
            return
            
        self.deleted_count = 0
        self.result_text.delete(1.0, 'end')
        self.result_text.insert('end', "빈 폴더 구조 검사를 시작합니다...\n\n")
        self.root.update()
        
        try:
            # 삭제할 최상위 빈 폴더들을 찾음
            empty_roots = self.find_empty_root_folders(path)
            
            if not empty_roots:
                self.result_text.insert('end', "삭제할 빈 폴더 구조가 없습니다.\n")
                return
            
            # 발견된 빈 폴더 구조들을 표시
            self.result_text.insert('end', "다음 폴더 구조가 완전히 비어있어 삭제됩니다:\n")
            for folder in empty_roots:
                self.result_text.insert('end', f"- {folder}\n")
            self.root.update()
            
            # 사용자 확인
            if messagebox.askyesno("확인", f"{len(empty_roots)}개의 폴더 구조를 휴지통으로 이동하시겠습니까?"):
                for folder in empty_roots:
                    try:
                        send2trash.send2trash(str(Path(folder)))  # Path 객체를 문자열로 변환
                        self.deleted_count += 1
                        self.result_text.insert('end', f"삭제 완료: {folder}\n")
                        self.root.update()
                    except Exception as e:
                        self.result_text.insert('end', f"삭제 실패: {folder} - {str(e)}\n")
                
                self.result_text.insert('end', f"\n작업 완료! 총 {self.deleted_count}개의 폴더 구조가 휴지통으로 이동되었습니다.")
            
        except Exception as e:
            messagebox.showerror("오류", f"처리 중 오류가 발생했습니다: {str(e)}")
            
    def run(self):
        """프로그램 실행"""
        self.root.mainloop()

if __name__ == "__main__":
    # 프로그램 시작
    check_and_install_requirements()
    app = RecursiveEmptyFolderCleaner()
    app.run()

이상이 프로그램의 전체 코드입니다. 이제 이 코드를 실행하면 GUI 기반의 폴더 정리 프로그램을 사용할 수 있습니다. 프로그램을 실행하기 전에 Python이 설치되어 있어야 하며, 필요한 경우 send2trash 모듈이 자동으로 설치됩니다.