Batch-Compress a Photo Folder and Bundle It as a ZIP

import sys
import json
import os
import zipfile
from datetime import datetime
from concurrent.futures import ProcessPoolExecutor, as_completed
from PIL import Image

# Assumptions:
# - Supported formats: JPG/JPEG, PNG, WebP, BMP, TIFF
# - Output filenames keep the original name and extension
# - PNG stays lossless; only optimize=True is applied (to preserve transparency)
# - Per-level parameters use common quality/size tradeoffs
# - Parallelism uses a process pool (image encoding is CPU-bound, so not threads)
# - Worker count is CPU cores - 1 (minimum 1)
# - zip filename is "{basename}_photos_{timestamp}.zip" under the output folder
# - zip stores the compressed images flat (no subfolders)
# - zip compression is ZIP_DEFLATED (pre-compressed images do not shrink much, but it is the standard choice)
# - Compressed images are deleted only when zip creation succeeds AND testzip() is OK AND the file counts match
# - A summary log "{basename}_log_{timestamp}.txt" is written to the output folder

# Per-level settings
compression_settings = {
    "Light (preserve quality)": {"jpeg_quality": 85, "max_size": None},
    "Light (preserve quality)": {"jpeg_quality": 85, "max_size": None},
    "Balanced (recommended)": {"jpeg_quality": 75, "max_size": 2560},
    "Balanced (recommended)": {"jpeg_quality": 75, "max_size": 2560},
    "Strong (smallest size)": {"jpeg_quality": 60, "max_size": 1920},
    "Strong (smallest size)": {"jpeg_quality": 60, "max_size": 1920},
}

supported_extensions = {".jpg", ".jpeg", ".png", ".webp", ".bmp", ".tif", ".tiff"}


def compress_image(args):
    """Compress one file. Called by the process pool."""
    input_path, output_path, jpeg_quality, max_size = args
    filename = os.path.basename(input_path)
    ext = os.path.splitext(filename)[1].lower()

    try:
        original_size = os.path.getsize(input_path)

        with Image.open(input_path) as img:
            exif = img.info.get("exif")

            if max_size is not None:
                w, h = img.size
                longest_edge = max(w, h)
                if longest_edge > max_size:
                    ratio = max_size / longest_edge
                    new_w = int(w * ratio)
                    new_h = int(h * ratio)
                    img = img.resize((new_w, new_h), Image.LANCZOS)

            if ext in (".jpg", ".jpeg"):
                if img.mode not in ("RGB", "L"):
                    img = img.convert("RGB")
                save_kwargs = {
                    "format": "JPEG",
                    "quality": jpeg_quality,
                    "optimize": True,
                    "progressive": True,
                }
                if exif:
                    save_kwargs["exif"] = exif
                img.save(output_path, **save_kwargs)

            elif ext == ".png":
                img.save(output_path, format="PNG", optimize=True)

            elif ext == ".webp":
                img.save(output_path, format="WEBP", quality=jpeg_quality, method=6)

            elif ext == ".bmp":
                img.save(output_path, format="BMP")

            elif ext in (".tif", ".tiff"):
                img.save(output_path, format="TIFF", compression="tiff_lzw")

        compressed_size = os.path.getsize(output_path)
        return {
            "ok": True,
            "filename": filename,
            "original_size": original_size,
            "compressed_size": compressed_size,
        }

    except Exception as e:
        return {
            "ok": False,
            "filename": filename,
            "error": str(e),
        }


def main():
    with open(sys.argv[1], encoding="utf-8") as f:
        inputs = json.load(f)

    photo_dir = inputs["photo_dir"]
    output_dir = inputs["output_dir"]
    compression_level = inputs["compression_level"]
    basename = inputs["zip_basename"]
    create_zip_flag = inputs["create_zip"] == "true"
    delete_flag = inputs["delete_compressed"] == "true"

    if compression_level not in compression_settings:
        normalized = compression_level.replace("(", "(").replace(")", ")")
        if normalized in compression_settings:
            compression_level = normalized
        else:
            print(f"Error: invalid compression level: {compression_level}", file=sys.stderr)
            sys.exit(1)

    setting = compression_settings[compression_level]
    jpeg_quality = setting["jpeg_quality"]
    max_size = setting["max_size"]

    cpu_cores = os.cpu_count() or 1
    worker_count = max(1, cpu_cores - 1)
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")

    print(f"Base name: {basename}")
    print(f"Compression level: {compression_level}")
    print(f"JPEG quality: {jpeg_quality}")
    print(f"Longest edge cap: {max_size if max_size else 'keep original size'}")
    print(f"CPU cores: {cpu_cores} / worker count: {worker_count}")
    print(f"Create zip: {'yes' if create_zip_flag else 'no'}")
    print(f"Delete compressed images: {'yes (after zip integrity + file-count check)' if delete_flag else 'no'}")
    print(f"Input folder: {photo_dir}")
    print(f"Output folder: {output_dir}")
    print("-" * 50)

    os.makedirs(output_dir, exist_ok=True)

    target_files = []
    for filename in os.listdir(photo_dir):
        full_path = os.path.join(photo_dir, filename)
        if os.path.isfile(full_path):
            ext = os.path.splitext(filename)[1].lower()
            if ext in supported_extensions:
                target_files.append(filename)

    total = len(target_files)
    if total == 0:
        print("No supported image files were found.")
        return

    print(f"Target files: {total}")
    print("-" * 50)

    tasks = [
        (
            os.path.join(photo_dir, filename),
            os.path.join(output_dir, filename),
            jpeg_quality,
            max_size,
        )
        for filename in target_files
    ]

    success_count = 0
    fail_count = 0
    total_original = 0
    total_compressed = 0
    done = 0
    success_files = []
    fail_files = []
    per_file_results = []  # used for the summary log

    with ProcessPoolExecutor(max_workers=worker_count) as executor:
        future_to_name = {
            executor.submit(compress_image, task): task[0] for task in tasks
        }

        for future in as_completed(future_to_name):
            done += 1
            result = future.result()

            if result["ok"]:
                orig = result["original_size"]
                comp = result["compressed_size"]
                total_original += orig
                total_compressed += comp
                reduction = (1 - comp / orig) * 100 if orig > 0 else 0
                print(
                    f"[{done}/{total}] {result['filename']}  "
                    f"{orig/1024:.1f}KB → {comp/1024:.1f}KB  "
                    f"({reduction:+.1f}%)"
                )
                success_count += 1
                success_files.append(result["filename"])
                per_file_results.append({
                    "filename": result["filename"],
                    "original_size": orig,
                    "compressed_size": comp,
                    "reduction_rate": reduction,
                    "status": "success",
                })
            else:
                print(
                    f"[{done}/{total}] {result['filename']}  failed: {result['error']}",
                    file=sys.stderr,
                )
                fail_count += 1
                fail_files.append(result["filename"])
                per_file_results.append({
                    "filename": result["filename"],
                    "error": result["error"],
                    "status": "failed",
                })

    print("-" * 50)
    print(f"Done: success {success_count} / failed {fail_count}")
    total_reduction = 0.0
    if total_original > 0:
        total_reduction = (1 - total_compressed / total_original) * 100
        print(
            f"Total size: {total_original/1024/1024:.2f}MB → "
            f"{total_compressed/1024/1024:.2f}MB  "
            f"({total_reduction:+.1f}%)"
        )
    print(f"Output folder: {output_dir}")

    # zip archive
    zip_ok = False
    zip_path = None
    zip_filename = None
    if create_zip_flag and success_files:
        print("-" * 50)
        print("Creating zip archive...")
        zip_filename = f"{basename}_photos_{timestamp}.zip"
        zip_path = os.path.join(output_dir, zip_filename)

        try:
            with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
                for i, filename in enumerate(success_files, 1):
                    file_path = os.path.join(output_dir, filename)
                    zf.write(file_path, arcname=filename)
                    print(f"  [{i}/{len(success_files)}] added {filename}")

            zip_size = os.path.getsize(zip_path)
            print(f"zip created: {zip_filename} ({zip_size/1024/1024:.2f}MB)")
            print(f"zip path: {zip_path}")
            zip_ok = True
        except Exception as e:
            print(f"zip creation failed: {e}", file=sys.stderr)
    elif not create_zip_flag:
        print("Skipped zip creation.")

    # zip integrity check + file-count match -> delete compressed images if OK
    zip_integrity_result = "not checked"
    deletion_result = "not run"
    if delete_flag and zip_ok and zip_path:
        print("-" * 50)
        print("Verifying zip integrity and file count...")
        try:
            with zipfile.ZipFile(zip_path, "r") as zf:
                bad_file = zf.testzip()
                if bad_file is not None:
                    zip_integrity_result = f"CRC failed: {bad_file}"
                    print(
                        f"Integrity check failed: {bad_file} may be corrupted.",
                        file=sys.stderr,
                    )
                    print("Skipping compressed-image deletion for safety.", file=sys.stderr)
                    deletion_result = "skipped (CRC failure)"
                else:
                    zip_contents = set(zf.namelist())
                    expected_files = set(success_files)
                    missing_files = expected_files - zip_contents
                    extra_files = zip_contents - expected_files

                    print(f"  Compressed targets: {len(expected_files)} / in zip: {len(zip_contents)}")

                    if missing_files:
                        zip_integrity_result = f"file count mismatch: {len(missing_files)} missing"
                        print(
                            f"File-count check failed: {len(missing_files)} files missing from the zip.",
                            file=sys.stderr,
                        )
                        for f in sorted(missing_files):
                            print(f"  missing: {f}", file=sys.stderr)
                        print("Skipping compressed-image deletion for safety.", file=sys.stderr)
                        deletion_result = "skipped (file count mismatch)"
                    else:
                        zip_integrity_result = "OK"
                        if extra_files:
                            print(f"Warning: zip contains {len(extra_files)} unexpected files.")
                            for f in sorted(extra_files):
                                print(f"  unexpected: {f}")

                        print("Integrity and file count OK. Deleting compressed images...")
                        deleted_count = 0
                        delete_fail_count = 0
                        for filename in success_files:
                            file_path = os.path.join(output_dir, filename)
                            try:
                                os.remove(file_path)
                                print(f"  deleted: {filename}")
                                deleted_count += 1
                            except Exception as e:
                                print(f"  delete failed: {filename} - {e}", file=sys.stderr)
                                delete_fail_count += 1
                        print(f"Deletion complete: {deleted_count} deleted / {delete_fail_count} failed")
                        deletion_result = f"complete (deleted {deleted_count} / failed {delete_fail_count})"

        except Exception as e:
            zip_integrity_result = f"error during check: {e}"
            print(f"Error during integrity check: {e}", file=sys.stderr)
            print("Skipping compressed-image deletion for safety.", file=sys.stderr)
            deletion_result = "skipped (check error)"
    elif delete_flag and not zip_ok:
        print("zip creation did not succeed; skipping compressed-image deletion.")
        deletion_result = "skipped (zip not created)"

    # Summary log
    print("-" * 50)
    print("Writing summary log...")
    log_filename = f"{basename}_log_{timestamp}.txt"
    log_path = os.path.join(output_dir, log_filename)
    try:
        with open(log_path, "w", encoding="utf-8") as log:
            log.write(f"{'=' * 50}\n")
            log.write(f"  Run summary\n")
            log.write(f"{'=' * 50}\n")
            log.write(f"Base name        : {basename}\n")
            log.write(f"Run at           : {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
            log.write(f"Compression level: {compression_level}\n")
            log.write(f"JPEG quality     : {jpeg_quality}\n")
            log.write(f"Longest edge cap : {max_size if max_size else 'keep original size'}\n")
            log.write(f"Input folder     : {photo_dir}\n")
            log.write(f"Output folder    : {output_dir}\n")
            log.write(f"\n{'─' * 50}\n")
            log.write(f"  Results\n")
            log.write(f"{'─' * 50}\n")
            log.write(f"Target files     : {total}\n")
            log.write(f"Success          : {success_count}\n")
            log.write(f"Failed           : {fail_count}\n")
            if total_original > 0:
                log.write(f"Total size       : {total_original/1024/1024:.2f}MB → {total_compressed/1024/1024:.2f}MB ({total_reduction:+.1f}%)\n")
            log.write(f"\n{'─' * 50}\n")
            log.write(f"  zip / deletion\n")
            log.write(f"{'─' * 50}\n")
            log.write(f"Create zip       : {'yes' if create_zip_flag else 'no'}\n")
            if zip_filename:
                log.write(f"zip filename     : {zip_filename}\n")
                log.write(f"zip path         : {zip_path}\n")
            log.write(f"zip integrity    : {zip_integrity_result}\n")
            log.write(f"Image deletion   : {deletion_result}\n")
            log.write(f"\n{'─' * 50}\n")
            log.write(f"  Per-file results\n")
            log.write(f"{'─' * 50}\n")
            for r in sorted(per_file_results, key=lambda x: x["filename"]):
                if r["status"] == "success":
                    log.write(
                        f"  [success] {r['filename']}  "
                        f"{r['original_size']/1024:.1f}KB → {r['compressed_size']/1024:.1f}KB  "
                        f"({r['reduction_rate']:+.1f}%)\n"
                    )
                else:
                    log.write(f"  [failed] {r['filename']}  error: {r['error']}\n")
            log.write(f"{'=' * 50}\n")

        print(f"Log saved: {log_filename}")
        print(f"Log path: {log_path}")
    except Exception as e:
        print(f"Log write failed: {e}", file=sys.stderr)


if __name__ == "__main__":
    main()