Files
mtusi2026lab6/imaging.py
T

210 lines
9.9 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Преобразование изображения, pipeline_version=1. Запускается worker'ом ОТДЕЛЬНЫМ процессом с лимитами.
python imaging.py <source> <out_dir> <content_type> <max_pixels>
Почему отдельный процесс: декодер 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
with Image.open(source) 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())