feat: advanced image compressor (batch, URL, metadata, lossless)

Author: x4nth055

python-for-multimedia/compress-image/README.md

@@ -1,4 +1,56 @@
-# [How to Compress Images in Python](https://www.thepythoncode.com/article/compress-images-in-python)
-To run this:
-- `pip3 install -r requirements.txt`
-- `python compress_image.py --help`
+# Compress Image
+
+Advanced Image Compressor with Batch Processing
+
+This script provides advanced image compression and resizing features using Python and Pillow.
+
+## Features
+
+- Batch processing of multiple images or directories
+- Lossy and lossless compression (PNG/WebP)
+- Optional JPEG conversion
+- Resize by ratio or explicit dimensions
+- Preserve or strip metadata (EXIF)
+- Custom output directory
+- Progress bar using `tqdm`
+- Detailed logging
+
+## Requirements
+
+- Python 3.6+
+- [Pillow](https://pypi.org/project/Pillow/)
+- [tqdm](https://pypi.org/project/tqdm/)
+
+Install dependencies:
+
+```bash
+pip install pillow tqdm
+```
+
+## Usage
+
+```bash
+python compress_image.py [options] <input> [<input> ...]
+```
+
+## Options
+- `-o`, `--output-dir`: Output directory (default: same as input)
+- `-q`, `--quality`: Compression quality (0-100, default: 85)
+- `-r`, `--resize-ratio`: Resize ratio (0-1, default: 1.0)
+- `-w`, `--width`: Output width (requires `--height`)
+- `-hh`, `--height`: Output height (requires `--width`)
+- `-j`, `--to-jpg`: Convert output to JPEG
+- `-m`, `--no-metadata`: Strip metadata (default: preserve)
+- `-l`, `--lossless`: Use lossless compression (PNG/WEBP)
+
+## Examples
+
+```bash
+python compress_image.py image.jpg -r 0.5 -q 80 -j
+python compress_image.py images/ -o output/ -m
+python compress_image.py image.png -l
+```
+
+## License
+
+MIT License.

python-for-multimedia/compress-image/compress_image.py

@@ -1,88 +1,104 @@
 import os
 from PIL import Image
+import argparse
+import logging
+from tqdm import tqdm
 
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 
 def get_size_format(b, factor=1024, suffix="B"):
-    """
-    Scale bytes to its proper byte format
-    e.g:
-        1253656 => '1.20MB'
-        1253656678 => '1.17GB'
-    """
+    """Scale bytes to its proper byte format."""
     for unit in ["", "K", "M", "G", "T", "P", "E", "Z"]:
         if b < factor:
             return f"{b:.2f}{unit}{suffix}"
         b /= factor
     return f"{b:.2f}Y{suffix}"
-    
 
-
-def compress_img(image_name, new_size_ratio=0.9, quality=90, width=None, height=None, to_jpg=True):
-    # load the image to memory
-    img = Image.open(image_name)
-    # print the original image shape
-    print("[*] Image shape:", img.size)
-    # get the original image size in bytes
-    image_size = os.path.getsize(image_name)
-    # print the size before compression/resizing
-    print("[*] Size before compression:", get_size_format(image_size))
-    if new_size_ratio < 1.0:
-        # if resizing ratio is below 1.0, then multiply width & height with this ratio to reduce image size
-        img = img.resize((int(img.size[0] * new_size_ratio), int(img.size[1] * new_size_ratio)), Image.LANCZOS)
-        # print new image shape
-        print("[+] New Image shape:", img.size)
-    elif width and height:
-        # if width and height are set, resize with them instead
-        img = img.resize((width, height), Image.LANCZOS)
-        # print new image shape
-        print("[+] New Image shape:", img.size)
-    # split the filename and extension
-    filename, ext = os.path.splitext(image_name)
-    # make new filename appending _compressed to the original file name
-    if to_jpg:
-        # change the extension to JPEG
-        new_filename = f"{filename}_compressed.jpg"
-    else:
-        # retain the same extension of the original image
-        new_filename = f"{filename}_compressed{ext}"
+def compress_image(
+    input_path,
+    output_dir=None,
+    quality=85,
+    resize_ratio=1.0,
+    width=None,
+    height=None,
+    to_jpg=False,
+    preserve_metadata=True,
+    lossless=False,
+):
+    """Compress an image with advanced options."""
     try:
-        # save the image with the corresponding quality and optimize set to True
-        img.save(new_filename, quality=quality, optimize=True)
-    except OSError:
-        # convert the image to RGB mode first
-        img = img.convert("RGB")
-        # save the image with the corresponding quality and optimize set to True
-        img.save(new_filename, quality=quality, optimize=True)
-    print("[+] New file saved:", new_filename)
-    # get the new image size in bytes
-    new_image_size = os.path.getsize(new_filename)
-    # print the new size in a good format
-    print("[+] Size after compression:", get_size_format(new_image_size))
-    # calculate the saving bytes
-    saving_diff = new_image_size - image_size
-    # print the saving percentage
-    print(f"[+] Image size change: {saving_diff/image_size*100:.2f}% of the original image size.")
-    
-    
+        img = Image.open(input_path)
+        logger.info(f"[*] Processing: {os.path.basename(input_path)}")
+        logger.info(f"[*] Original size: {get_size_format(os.path.getsize(input_path))}")
+
+        # Resize if needed
+        if resize_ratio < 1.0:
+            new_size = (int(img.size[0] * resize_ratio), int(img.size[1] * resize_ratio))
+            img = img.resize(new_size, Image.LANCZOS)
+            logger.info(f"[+] Resized to: {new_size}")
+        elif width and height:
+            img = img.resize((width, height), Image.LANCZOS)
+            logger.info(f"[+] Resized to: {width}x{height}")
+
+        # Prepare output path
+        filename, ext = os.path.splitext(os.path.basename(input_path))
+        output_ext = ".jpg" if to_jpg else ext
+        output_filename = f"{filename}_compressed{output_ext}"
+        output_path = os.path.join(output_dir or os.path.dirname(input_path), output_filename)
+
+        # Save with options
+        save_kwargs = {"quality": quality, "optimize": True}
+        if not preserve_metadata:
+            save_kwargs["exif"] = b""  # Strip metadata
+        if lossless and ext.lower() in (".png", ".webp"):
+            save_kwargs["lossless"] = True
+
+        try:
+            img.save(output_path, **save_kwargs)
+        except OSError:
+            img = img.convert("RGB")
+            img.save(output_path, **save_kwargs)
+
+        logger.info(f"[+] Saved to: {output_path}")
+        logger.info(f"[+] New size: {get_size_format(os.path.getsize(output_path))}")
+    except Exception as e:
+        logger.error(f"[!] Error processing {input_path}: {e}")
+
+def batch_compress(
+    input_paths,
+    output_dir=None,
+    quality=85,
+    resize_ratio=1.0,
+    width=None,
+    height=None,
+    to_jpg=False,
+    preserve_metadata=True,
+    lossless=False,
+):
+    """Compress multiple images."""
+    if output_dir and not os.path.exists(output_dir):
+        os.makedirs(output_dir, exist_ok=True)
+    for path in tqdm(input_paths, desc="Compressing images"):
+        compress_image(path, output_dir, quality, resize_ratio, width, height, to_jpg, preserve_metadata, lossless)
+
 if __name__ == "__main__":
-    import argparse
-    parser = argparse.ArgumentParser(description="Simple Python script for compressing and resizing images")
-    parser.add_argument("image", help="Target image to compress and/or resize")
-    parser.add_argument("-j", "--to-jpg", action="store_true", help="Whether to convert the image to the JPEG format")
-    parser.add_argument("-q", "--quality", type=int, help="Quality ranging from a minimum of 0 (worst) to a maximum of 95 (best). Default is 90", default=90)
-    parser.add_argument("-r", "--resize-ratio", type=float, help="Resizing ratio from 0 to 1, setting to 0.5 will multiply width & height of the image by 0.5. Default is 1.0", default=1.0)
-    parser.add_argument("-w", "--width", type=int, help="The new width image, make sure to set it with the `height` parameter")
-    parser.add_argument("-hh", "--height", type=int, help="The new height for the image, make sure to set it with the `width` parameter")
+    parser = argparse.ArgumentParser(description="Advanced Image Compressor with Batch Processing")
+    parser.add_argument("input", nargs='+', help="Input image(s) or directory")
+    parser.add_argument("-o", "--output-dir", help="Output directory (default: same as input)")
+    parser.add_argument("-q", "--quality", type=int, default=85, help="Compression quality (0-100)")
+    parser.add_argument("-r", "--resize-ratio", type=float, default=1.0, help="Resize ratio (0-1)")
+    parser.add_argument("-w", "--width", type=int, help="Output width (requires --height)")
+    parser.add_argument("-hh", "--height", type=int, help="Output height (requires --width)")
+    parser.add_argument("-j", "--to-jpg", action="store_true", help="Convert output to JPEG")
+    parser.add_argument("-m", "--no-metadata", action="store_false", help="Strip metadata")
+    parser.add_argument("-l", "--lossless", action="store_true", help="Use lossless compression (PNG/WEBP)")
+
     args = parser.parse_args()
-    # print the passed arguments
-    print("="*50)
-    print("[*] Image:", args.image)
-    print("[*] To JPEG:", args.to_jpg)
-    print("[*] Quality:", args.quality)
-    print("[*] Resizing ratio:", args.resize_ratio)
-    if args.width and args.height:
-        print("[*] Width:", args.width)
-        print("[*] Height:", args.height)
-    print("="*50)
-    # compress the image
-    compress_img(args.image, args.resize_ratio, args.quality, args.width, args.height, args.to_jpg)
+    input_paths = []
+    for path in args.input:
+        if os.path.isdir(path): input_paths.extend(os.path.join(path, f) for f in os.listdir(path) if f.lower().endswith((".jpg",".jpeg",".png",".webp")))
+        else: input_paths.append(path)
+    if not input_paths: logger.error("No valid images found!"); exit(1)
+    batch_compress(input_paths, args.output_dir, args.quality, args.resize_ratio, args.width, args.height, args.to_jpg, args.no_metadata, args.lossless)