"""Преобразование изображения, pipeline_version=1. Запускается worker'ом ОТДЕЛЬНЫМ процессом с лимитами. python imaging.py Почему отдельный процесс: декодер Pillow работает в C, его нельзя прервать изнутри Python и нельзя ограничить по памяти отдельно от остального worker. Процесс сам ставит себе RLIMIT_AS (память, IMAGING_MEMORY_MB), RLIMIT_CPU (процессорное время) и RLIMIT_FSIZE до импорта Pillow, а worker убивает его по таймауту JOB_TIMEOUT_SECONDS. Падение, зависание или нехватка памяти здесь не роняют worker и не ломают подключение к брокеру. Результат: файлы thumbnail.jpg, crop.jpg, optimized.webp в out_dir и одна строка JSON в stdout. Код выхода: 0 — успех; 3 — невалидное изображение; 4 — слишком много пикселей; 5 — не хватило памяти; прочее (в том числе убит сигналом) — неожиданная ошибка, worker считает её временной. Правила вариантов (contracts/README.md): - thumbnail: JPEG, вписан в 256x256 с сохранением пропорций, без увеличения, размеры округляются вниз (минимум 1 px), EXIF orientation применяется, прозрачность накладывается на белый фон. 320x200 -> 256x160. - crop: JPEG 128x128, центрированный квадрат (маленькие исходники увеличиваются). - optimized: WebP, вписан в 1280x1280 без увеличения, quality=80, method=4; прозрачность сохраняется. Во всех вариантах нет EXIF/XMP/комментариев: в save() передаётся только ICC-профиль (цвет), остальное отбрасывается. Pillow при одинаковой версии даёт побайтно одинаковый результат, поэтому повтор job пишет в те же ключи S3 те же байты. """ import json import os import resource import sys import time def apply_limits() -> None: """Лимиты на себя, ДО импорта Pillow: память (RLIMIT_AS), CPU, размер записываемых файлов.""" memory = int(os.environ.get("IMAGING_MEMORY_MB", "640")) * 1024 * 1024 cpu = int(os.environ.get("IMAGING_CPU_SECONDS", "60")) resource.setrlimit(resource.RLIMIT_AS, (memory, memory)) resource.setrlimit(resource.RLIMIT_CPU, (cpu, cpu + 5)) resource.setrlimit(resource.RLIMIT_FSIZE, (64 * 1024 * 1024, 64 * 1024 * 1024)) if __name__ == "__main__": apply_limits() from PIL import Image # noqa: E402 — после apply_limits: память декодера тоже под лимитом PIPELINE_VERSION = 1 THUMB_BOX = 256 CROP_SIZE = 128 OPTIMIZED_BOX = 1280 THUMB_QUALITY = 85 CROP_QUALITY = 85 WEBP_QUALITY = 80 WEBP_METHOD = 4 EXIT_INVALID = 3 EXIT_TOO_LARGE = 4 EXIT_MEMORY = 5 FORMATS = {"image/png": "PNG", "image/jpeg": "JPEG"} # EXIF orientation -> преобразование (как в PIL.ImageOps.exif_transpose) ORIENTATION = { 2: [Image.Transpose.FLIP_LEFT_RIGHT], 3: [Image.Transpose.ROTATE_180], 4: [Image.Transpose.FLIP_TOP_BOTTOM], 5: [Image.Transpose.TRANSPOSE], 6: [Image.Transpose.ROTATE_270], 7: [Image.Transpose.TRANSVERSE], 8: [Image.Transpose.ROTATE_90], } class TooLarge(Exception): pass def fit(width: int, height: int, box: int) -> tuple[int, int]: """Вписать в box x box без увеличения; размеры вниз, минимум 1 px. Целочисленно, без float.""" if width <= box and height <= box: return width, height if width >= height: return box, max(1, height * box // width) return max(1, width * box // height), box def orientation_of(image: Image.Image) -> int: try: value = image.getexif().get(0x0112, 1) except Exception: # noqa: BLE001 — битый EXIF не делает картинку невалидной, ориентацию не трогаем return 1 return value if value in ORIENTATION else 1 def normalize(image: Image.Image) -> Image.Image: """Любой режим PNG/JPEG -> L, RGB или RGBA (RGBA только если есть прозрачность).""" mode = image.mode transparent = "transparency" in image.info if mode in ("I;16", "I;16B", "I;16L", "I"): image = image.convert("I").point(lambda value: value * (1 / 256)).convert("L") mode = "L" if mode == "1": return image.convert("L") if mode in ("P", "PA"): return image.convert("RGBA" if transparent or mode == "PA" else "RGB") if mode in ("LA", "La", "RGBa"): return image.convert("RGBA") if mode in ("L", "RGB") and transparent: return image.convert("RGBA") if mode in ("L", "RGB", "RGBA"): return image return image.convert("RGB") # CMYK, YCbCr, LAB, ... def on_white(image: Image.Image) -> Image.Image: """Прозрачность -> белый фон (для JPEG).""" if image.mode != "RGBA": return image background = Image.new("RGB", image.size, (255, 255, 255)) background.paste(image, mask=image.getchannel("A")) return background def process(source: str, out_dir: str, content_type: str, max_pixels: int) -> dict: Image.MAX_IMAGE_PIXELS = max_pixels # lab7 (скан зависимостей): декодируются только PNG/JPEG — остальные плагины Pillow (TIFF, GIF, PDF, EPS, BMP, # MSP...) недостижимы, даже если в staging попал бы файл другого формата. with Image.open(source, formats=("PNG", "JPEG")) as image: if image.format != FORMATS.get(content_type): raise ValueError("format does not match stored content type") width, height = image.size if width * height > max_pixels: raise TooLarge() orientation = orientation_of(image) icc = image.info.get("icc_profile") swap = orientation in (5, 6, 7, 8) oriented = (height, width) if swap else (width, height) # Сначала уменьшаем до optimized (<= 1280), потом поворачиваем: квадратные рамки 1280/256/128 # не зависят от поворота, а поворот маленькой картинки дешевле, чем копия 40-мегапиксельной. target = fit(*oriented, OPTIMIZED_BOX) stored_target = (target[1], target[0]) if swap else target if image.format == "JPEG": image.draft(None, stored_target) # декодирование сразу в масштабе 1/2..1/8, если хватает image.load() work = normalize(image) if work.size != stored_target: work = work.resize(stored_target, Image.Resampling.LANCZOS, reducing_gap=3.0) elif work is image: work = work.copy() for step in ORIENTATION.get(orientation, []): work = work.transpose(step) extra = {"icc_profile": icc} if icc else {} results = [] optimized = work if work.mode != "L" else work.convert("RGB") path = os.path.join(out_dir, "optimized.webp") optimized.save(path, format="WEBP", quality=WEBP_QUALITY, method=WEBP_METHOD, **extra) results.append({"name": "optimized", "content_type": "image/webp", "width": optimized.width, "height": optimized.height, "file": "optimized.webp"}) thumb_size = fit(*oriented, THUMB_BOX) # от размеров ИСХОДНИКА, а не промежуточной копии thumb = work if work.size == thumb_size else work.resize(thumb_size, Image.Resampling.LANCZOS) thumb = on_white(thumb) path = os.path.join(out_dir, "thumbnail.jpg") thumb.save(path, format="JPEG", quality=THUMB_QUALITY, optimize=True, **extra) results.append({"name": "thumbnail", "content_type": "image/jpeg", "width": thumb.width, "height": thumb.height, "file": "thumbnail.jpg"}) side = min(work.size) left, top = (work.width - side) // 2, (work.height - side) // 2 crop = work.crop((left, top, left + side, top + side)) crop = on_white(crop.resize((CROP_SIZE, CROP_SIZE), Image.Resampling.LANCZOS)) path = os.path.join(out_dir, "crop.jpg") crop.save(path, format="JPEG", quality=CROP_QUALITY, optimize=True, **extra) results.append({"name": "crop", "content_type": "image/jpeg", "width": CROP_SIZE, "height": CROP_SIZE, "file": "crop.jpg"}) return {"pipeline_version": PIPELINE_VERSION, "source": {"width": width, "height": height, "orientation": orientation}, "variants": results} def injected_fault() -> None: """Учебные сбои (FAULT_IMAGING задаёт worker, только при FAULT_INJECTION=1).""" fault = os.environ.get("FAULT_IMAGING", "") if fault == "hang": time.sleep(3600) elif fault == "invalid": raise ValueError("injected invalid image") elif fault == "oom": blocks = [] while True: blocks.append(bytearray(64 * 1024 * 1024)) def main() -> int: source, out_dir, content_type, max_pixels = sys.argv[1], sys.argv[2], sys.argv[3], int(sys.argv[4]) try: injected_fault() result = process(source, out_dir, content_type, max_pixels) except (TooLarge, Image.DecompressionBombError): return EXIT_TOO_LARGE except MemoryError: return EXIT_MEMORY except (OSError, SyntaxError, ValueError, IndexError, TypeError, EOFError, Image.UnidentifiedImageError): # Pillow сообщает о битом файле разными исключениями; подробности не нужны ни клиенту, ни логу. return EXIT_INVALID print(json.dumps(result), flush=True) return 0 if __name__ == "__main__": sys.exit(main())