日付入りの ZIP バックアップを作成し、アーカイブ内容を検証する

from pathlib import Path

SOURCE = Path("outputs") / "backup_demo"
FILES = {
    "notes.txt": b"alpha\n",
    "reports/week1.txt": b"beta\n",
    "reports/week2.txt": b"gamma\n",
    "settings.ini": b"mode=test\n",
}

SOURCE.parent.mkdir(parents=True, exist_ok=True)
SOURCE.mkdir()  # Stop if the synthetic source already exists.

for relative_name, content in FILES.items():
    target = SOURCE / relative_name
    target.parent.mkdir(parents=True, exist_ok=True)
    with target.open("xb") as stream:
        stream.write(content)

python create_backup_demo.py

python dated_zip_backup.py

from datetime import date
import hashlib
from pathlib import Path
from zipfile import ZIP_DEFLATED, ZipFile

SOURCE = Path("outputs") / "backup_demo"
BACKUP_DIR = Path("outputs") / "backups"
CHUNK_SIZE = 1024 * 1024


def hash_file(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as stream:
        while chunk := stream.read(CHUNK_SIZE):
            digest.update(chunk)
    return digest.hexdigest()


def hash_member(archive: ZipFile, member_name: str) -> str:
    digest = hashlib.sha256()
    with archive.open(member_name, "r") as stream:
        while chunk := stream.read(CHUNK_SIZE):
            digest.update(chunk)
    return digest.hexdigest()


def main() -> None:
    source_root = SOURCE.resolve(strict=True)
    if not source_root.is_dir():
        raise ValueError("SOURCE must be a directory.")

    backup_root = BACKUP_DIR.resolve()
    if backup_root.is_relative_to(source_root):
        raise ValueError("BACKUP_DIR must be outside SOURCE.")

    files = sorted(
        path for path in source_root.rglob("*")
        if path.is_file() and not path.is_symlink()
    )
    if not files:
        raise ValueError("SOURCE contains no regular files to back up.")

    BACKUP_DIR.mkdir(parents=True, exist_ok=True)
    archive_name = f"{source_root.name}_{date.today().isoformat()}.zip"
    archive_path = BACKUP_DIR / archive_name
    if archive_path.exists():
        raise FileExistsError(f"Backup already exists: {archive_path}")

    expected = {}
    with archive_path.open("xb") as raw:
        with ZipFile(raw, "w", compression=ZIP_DEFLATED) as archive:
            for path in files:
                relative = path.relative_to(source_root).as_posix()
                expected[relative] = (path.stat().st_size, hash_file(path))
                archive.write(path, arcname=relative)

    with ZipFile(archive_path, "r") as archive:
        bad_member = archive.testzip()
        if bad_member is not None:
            raise RuntimeError(f"CRC check failed: {bad_member}")

        members = [info for info in archive.infolist() if not info.is_dir()]
        actual_names = [info.filename for info in members]
        expected_names = list(expected)
        if actual_names != expected_names:
            raise RuntimeError("Archive member list does not match the source list.")

        for info in members:
            expected_size, expected_hash = expected[info.filename]
            if info.file_size != expected_size:
                raise RuntimeError(f"Size mismatch: {info.filename}")
            if hash_member(archive, info.filename) != expected_hash:
                raise RuntimeError(f"Hash mismatch: {info.filename}")

    total_bytes = sum(size for size, _ in expected.values())
    print(f"Verified {len(expected)} files totaling {total_bytes} bytes.")
    print(f"Archive: {archive_path.as_posix()}")


if __name__ == "__main__":
    main()

Verified 4 files totaling 27 bytes.
Archive: outputs/backups/backup_demo_2026-09-20.zip