Image Pipeline - Recursive Batch

PracticalmediumPremium

45:00

Desktop only

Coding Challenges are optimized for Desktop

Come back on a wider screen - the live editor needs room to breathe. You can still read the problem brief above.

Problem

An asset service stores images in a directory tree - say IMAGES/Large/ and IMAGES/Small/ - and a set of named transform recipes as JSON files in a TRANSFORMS/ directory. The job is to apply every recipe to every image, write the results into an output tree that mirrors the input layout, and do it fast and fault-tolerantly. At real scale this is millions of (image, transform) combinations, so the work has to fan out and survive bad inputs.

A transform is {"transform": name, "arg": [...]} where arg is always a list. Supported names: mirror [], flip [], rotate [degrees], resize [width, height], blur [radius], grayscale [], crop [left, top, right, bottom]. Pillow is available in the sandbox (from PIL import Image, ImageFilter, ImageOps).

For the parallel level, build the pool with from _compat import get_executor rather than constructing a ThreadPoolExecutor directly - it runs real threads where the runtime supports them and serially in this browser sandbox, with identical results.

Level 1 - Single image, single transform list

def apply_transforms(image_path: str, transforms: list[dict], output_path: str) -> None

Open the image, apply each transform in order, and save to output_path. Output size and mode reflect the transforms; an unknown transform name raises.

Example:

apply_transforms("photo.png", [{"transform": "mirror", "arg": []},
                                {"transform": "blur", "arg": [2]}], "out.png")

Level 2 - All images by all transforms, serial

def process_all(images_dir, transforms_dir, output_dir) -> dict[tuple[str, str], str]

Walk images_dir recursively (including subfolders), load every .json file from transforms_dir (keyed by filename stem), and apply each transform list to each image. The output path must preserve the source subfolder: an input IMAGES/Large/photo.png with transform t01 writes to <output_dir>/Large/photo_t01.png. Return {(image_path, transform_name): output_path} for every combination.

Example:

IMAGES/Large/a.png, IMAGES/Small/b.png + transforms {t01, t02}
-> 4 combinations; Large outputs under output/Large/, Small under output/Small/

Level 3 - Parallel execution with fault isolation

def process_all_parallel(images_dir, transforms_dir, output_dir, max_workers=8)
    -> tuple[dict[tuple[str, str], str], dict[tuple[str, str], Exception]]

Same discovery and same outputs as process_all, but run the combinations through a thread pool. Return (results, errors): a failing combination (a corrupt transform file, an unknown transform) lands in errors and must not stop the others. The successful coverage must match the serial version exactly.

Example:

transforms = {good.json, bad.json} over 4 images
-> results has the 4 good combinations; errors has the 4 bad ones; batch completes

Loading editor...

The live editor for this challenge unlocks with Premium.

Browse free problems

0/0 passed