forked from mtusi2026/mtusi2026lab6
210 lines
9.9 KiB
Python
210 lines
9.9 KiB
Python
"""Преобразование изображения, 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())
|