Mengompres Banyak Foto Sekaligus dengan Bantuan ChatGPT dan Python

python -m pip install --upgrade Pillow

from pathlib import Path
from PIL import Image, ImageOps, UnidentifiedImageError
import shutil
import sys

# Sesuaikan lokasi folder dengan komputer Anda.
SOURCE_DIR = Path(r"D:\path\to\source_dir")
OUTPUT_DIR = Path(r"D:\path\to\output_dir")

JPEG_QUALITY = 85
WEBP_QUALITY = 82
PNG_OPTIMIZE = True

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

def format_size(size_bytes: int) -> str:
    value = float(size_bytes)
    for unit in ("B", "KB", "MB", "GB", "TB"):
        if value < 1024 or unit == "TB":
            return f"{value:.2f} {unit}"
        value /= 1024
    return f"{value:.2f} TB"

def copy_original(src: Path, dst: Path) -> None:
    dst.parent.mkdir(parents=True, exist_ok=True)
    shutil.copy2(src, dst)

def has_transparency(image: Image.Image) -> bool:
    if image.mode in ("RGBA", "LA"):
        return image.getchannel("A").getextrema()[0] < 255
    if image.mode == "P" and "transparency" in image.info:
        return True
    return False

def compress_image(src: Path, dst: Path) -> tuple[int, int, str]:
    """
    Mengembalikan (ukuran_asli, ukuran_hasil, status).
    File tujuan menggunakan nama dan ekstensi yang sama.
    """
    original_size = src.stat().st_size
    dst.parent.mkdir(parents=True, exist_ok=True)

    ext = src.suffix.lower()

    # GIF dianjurkan tetap disalin agar animasi dan frame terjaga.
    if ext == ".gif":
        copy_original(src, dst)
        return original_size, dst.stat().st_size, "salin (GIF/animasi)"

    try:
        with Image.open(src) as opened:
            # Memperbaiki orientasi berdasarkan metadata EXIF.
            image = ImageOps.exif_transpose(opened)
            image.load()

            # JPEG
            if ext in (".jpg", ".jpeg"):
                if image.mode not in ("RGB", "L"):
                    image = image.convert("RGB")
                image.save(
                    dst,
                    format="JPEG",
                    quality=JPEG_QUALITY,
                    optimize=True,
                    progressive=True,
                    exif=opened.info.get("exif", b""),
                    icc_profile=opened.info.get("icc_profile"),
                )

            # PNG: lossless optimization agar transparansi tetap terjaga.
            elif ext == ".png":
                image.save(dst, format="PNG", optimize=PNG_OPTIMIZE)

            # WebP
            elif ext == ".webp":
                image.save(
                    dst,
                    format="WEBP",
                    quality=WEBP_QUALITY,
                    method=6,
                    lossless=False,
                )

            # BMP/TIFF: simpan tetap dengan ekstensi asli menggunakan format
            # aslinya; hindari mengganti ekstensi diam-diam.
            elif ext == ".bmp":
                image.save(dst, format="BMP")
            elif ext in (".tif", ".tiff"):
                image.save(dst, format="TIFF", compression="tiff_lzw")
            else:
                copy_original(src, dst)

        # Jika hasil lebih besar, gunakan file asli agar tidak merugikan.
        compressed_size = dst.stat().st_size
        if compressed_size >= original_size:
            copy_original(src, dst)
            return original_size, dst.stat().st_size, "salin (hasil tidak lebih kecil)"

        return original_size, compressed_size, "dikompres"

    except (UnidentifiedImageError, OSError, ValueError) as exc:
        # File bermasalah/tidak dapat dibaca: tetap salin dan lanjutkan.
        copy_original(src, dst)
        return original_size, dst.stat().st_size, f"salin (gagal kompres: {exc})"

def main() -> None:
    if not SOURCE_DIR.exists():
        print(f"Folder sumber tidak ditemukan:\n{SOURCE_DIR}")
        sys.exit(1)

    if SOURCE_DIR.resolve() == OUTPUT_DIR.resolve():
        print("Folder sumber dan tujuan tidak boleh sama.")
        sys.exit(1)

    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)

    files = [
        path for path in SOURCE_DIR.rglob("*")
        if path.is_file() and path.suffix.lower() in SUPPORTED_EXTENSIONS
        and OUTPUT_DIR not in path.parents
    ]

    if not files:
        print("Tidak ditemukan file gambar yang didukung.")
        return

    total_before = 0
    total_after = 0
    compressed_count = 0
    copied_count = 0
    error_count = 0

    print(f"Sumber : {SOURCE_DIR}")
    print(f"Tujuan : {OUTPUT_DIR}")
    print(f"Jumlah file gambar: {len(files)}\n")

    for index, src in enumerate(files, start=1):
        relative_path = src.relative_to(SOURCE_DIR)
        dst = OUTPUT_DIR / relative_path

        before, after, status = compress_image(src, dst)
        total_before += before
        total_after += after

        if status == "dikompres":
            compressed_count += 1
        else:
            copied_count += 1
            if "gagal kompres" in status:
                error_count += 1

        saved = before - after
        print(
            f"[{index}/{len(files)}] {relative_path} | "
            f"{format_size(before)} -> {format_size(after)} | "
            f"{status}"
            + (f" | hemat {format_size(saved)}" if saved > 0 else "")
        )

    saved_total = total_before - total_after
    percent = (saved_total / total_before * 100) if total_before else 0

    print("\n===== RINGKASAN =====")
    print(f"File diproses : {len(files)}")
    print(f"Dikompres     : {compressed_count}")
    print(f"Disalin       : {copied_count}")
    print(f"Gagal kompres : {error_count}")
    print(f"Ukuran awal   : {format_size(total_before)}")
    print(f"Ukuran hasil  : {format_size(total_after)}")
    print(f"Penghematan   : {format_size(saved_total)} ({percent:.2f}%)")
    print(f"\nHasil tersimpan di:\n{OUTPUT_DIR}")

if __name__ == "__main__":
    main()

SOURCE_DIR = Path(r"D:\path\to\source_dir")
OUTPUT_DIR = Path(r"D:\path\to\output_dir")

python "$env:USERPROFILE\Downloads\kompres_foto.py"