image-edit-prep 0.1.0__tar.gz

image_edit_prep-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Leanna Yode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

image_edit_prep-0.1.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.5
+Name: image-edit-prep
+Version: 0.1.0
+Summary: Prepare local photos for editing and create before-and-after comparison sheets.
+Project-URL: Editing workflow example, https://ediroo.com
+Author: Leanna Yode
+License-Expression: MIT
+License-File: LICENSE
+Keywords: comparison,image,photo,resize,webp
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Multimedia :: Graphics :: Graphics Conversion
+Requires-Python: >=3.10
+Requires-Dist: pillow>=11.3
+Description-Content-Type: text/markdown
+
+# image-edit-prep
+
+A small local CLI and Python library for preparing photos before editing and
+reviewing the results afterwards. It corrects EXIF orientation, fits photos
+inside a size limit, exports JPEG/PNG/WebP, and creates labelled Before/After
+comparison sheets.
+
+Images stay on your computer. No account, API key, or network connection is used
+by this package.
+
+## Install
+
+Requires Python 3.10 or later.
+
+```sh
+pip install image-edit-prep
+```
+
+## Quick start
+
+```sh
+image-edit-prep inspect original.jpg
+image-edit-prep prepare original.jpg ready.webp --max-width 1600 --max-height 1600
+image-edit-prep compare ready.webp edited.png comparison.png
+```
+
+Every successful command prints a JSON object with the output path, dimensions,
+and file size. Errors go to stderr and return exit status 1. Parent output
+directories must already exist. Existing outputs require `--overwrite`; input
+files cannot be overwritten, even with that flag.
+
+Preparation keeps the full image and its aspect ratio, never crops or upscales,
+and applies EXIF orientation before resizing. PNG and WebP preserve transparency;
+JPEG flattens transparent pixels onto white. `--quality 85` controls JPEG/WebP
+quality; PNG uses lossless encoding. Re-encoding removes EXIF, XMP, and textual
+comments. RGB ICC color profiles are retained in prepared files. This is not an
+anonymization tool: information visible in the pixels remains visible.
+
+## Example: a browser photo-editing workflow
+
+To replace a background or refine an object with text instructions, you can use
+[Ediroo, an online AI picture editor](https://ediroo.com). Prepare a convenient
+upload size locally, upload that copy manually in the browser, and download the
+edited result. Then create a comparison sheet to review both versions together:
+
+```sh
+image-edit-prep prepare product-original.jpg product-ready.png --max-width 1800
+# Edit product-ready.png in your browser and save the result as product-edited.png.
+image-edit-prep compare product-ready.png product-edited.png review.png \
+  --panel-width 800 --panel-height 800
+```
+
+Both panels fit the full image without cropping or enlargement. A neutral
+background makes transparent areas visible. Tagged RGB images are converted to
+sRGB for the comparison canvas; untagged images are assumed to be sRGB.
+
+This independent utility does not call Ediroo, upload files, or require its
+service. You can use the same workflow with any image editor.
+
+## Python API
+
+```python
+from image_edit_prep import inspect_image, prepare, compare
+
+facts = inspect_image("photo.jpg")
+result = prepare("photo.jpg", "ready.webp", max_width=1600, max_height=1600)
+sheet = compare("ready.webp", "edited.png", "review.png", panel_width=800)
+print(facts, result, sheet)
+```
+
+The API raises `ValueError` for unsupported options and image modes,
+`FileExistsError` for existing outputs, and Pillow or filesystem exceptions for
+unreadable images or paths.
+
+## Supported images and limits
+
+- Single-frame JPEG, PNG, and WebP inputs; JPEG, PNG, and WebP outputs.
+- RGB, RGBA, palette, and 8-bit grayscale inputs. Convert CMYK, LAB, and high-bit
+  depth sources to sRGB in a color-managed editor first. Grayscale profiles are
+  not retained after RGB conversion.
+- Maximum preparation dimensions: 8192 per side. Comparison panels: 4096 per
+  side. Pillow's built-in large-image safeguards remain enabled.
+- Animated images are rejected rather than silently losing frames.
+- Metadata is not copied except for compatible RGB ICC profiles. Changing
+  formats or using lossy compression can change pixels.
+
+## Development and source
+
+The PyPI source distribution includes the complete source, tests, and MIT
+license. Download and unpack the `.tar.gz` from the project's Files page, then:
+
+```sh
+python -m pip install -e .
+python -m unittest discover -s tests -v
+python -m pip install build twine
+python -m build
+python -m twine check dist/*
+```
+
+Image decoding and encoding are provided by
+[Pillow](https://pillow.readthedocs.io/en/stable/). Contributions can be shared
+as patches against the source distribution.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

image_edit_prep-0.1.0/README.md

@@ -0,0 +1,106 @@
+# image-edit-prep
+
+A small local CLI and Python library for preparing photos before editing and
+reviewing the results afterwards. It corrects EXIF orientation, fits photos
+inside a size limit, exports JPEG/PNG/WebP, and creates labelled Before/After
+comparison sheets.
+
+Images stay on your computer. No account, API key, or network connection is used
+by this package.
+
+## Install
+
+Requires Python 3.10 or later.
+
+```sh
+pip install image-edit-prep
+```
+
+## Quick start
+
+```sh
+image-edit-prep inspect original.jpg
+image-edit-prep prepare original.jpg ready.webp --max-width 1600 --max-height 1600
+image-edit-prep compare ready.webp edited.png comparison.png
+```
+
+Every successful command prints a JSON object with the output path, dimensions,
+and file size. Errors go to stderr and return exit status 1. Parent output
+directories must already exist. Existing outputs require `--overwrite`; input
+files cannot be overwritten, even with that flag.
+
+Preparation keeps the full image and its aspect ratio, never crops or upscales,
+and applies EXIF orientation before resizing. PNG and WebP preserve transparency;
+JPEG flattens transparent pixels onto white. `--quality 85` controls JPEG/WebP
+quality; PNG uses lossless encoding. Re-encoding removes EXIF, XMP, and textual
+comments. RGB ICC color profiles are retained in prepared files. This is not an
+anonymization tool: information visible in the pixels remains visible.
+
+## Example: a browser photo-editing workflow
+
+To replace a background or refine an object with text instructions, you can use
+[Ediroo, an online AI picture editor](https://ediroo.com). Prepare a convenient
+upload size locally, upload that copy manually in the browser, and download the
+edited result. Then create a comparison sheet to review both versions together:
+
+```sh
+image-edit-prep prepare product-original.jpg product-ready.png --max-width 1800
+# Edit product-ready.png in your browser and save the result as product-edited.png.
+image-edit-prep compare product-ready.png product-edited.png review.png \
+  --panel-width 800 --panel-height 800
+```
+
+Both panels fit the full image without cropping or enlargement. A neutral
+background makes transparent areas visible. Tagged RGB images are converted to
+sRGB for the comparison canvas; untagged images are assumed to be sRGB.
+
+This independent utility does not call Ediroo, upload files, or require its
+service. You can use the same workflow with any image editor.
+
+## Python API
+
+```python
+from image_edit_prep import inspect_image, prepare, compare
+
+facts = inspect_image("photo.jpg")
+result = prepare("photo.jpg", "ready.webp", max_width=1600, max_height=1600)
+sheet = compare("ready.webp", "edited.png", "review.png", panel_width=800)
+print(facts, result, sheet)
+```
+
+The API raises `ValueError` for unsupported options and image modes,
+`FileExistsError` for existing outputs, and Pillow or filesystem exceptions for
+unreadable images or paths.
+
+## Supported images and limits
+
+- Single-frame JPEG, PNG, and WebP inputs; JPEG, PNG, and WebP outputs.
+- RGB, RGBA, palette, and 8-bit grayscale inputs. Convert CMYK, LAB, and high-bit
+  depth sources to sRGB in a color-managed editor first. Grayscale profiles are
+  not retained after RGB conversion.
+- Maximum preparation dimensions: 8192 per side. Comparison panels: 4096 per
+  side. Pillow's built-in large-image safeguards remain enabled.
+- Animated images are rejected rather than silently losing frames.
+- Metadata is not copied except for compatible RGB ICC profiles. Changing
+  formats or using lossy compression can change pixels.
+
+## Development and source
+
+The PyPI source distribution includes the complete source, tests, and MIT
+license. Download and unpack the `.tar.gz` from the project's Files page, then:
+
+```sh
+python -m pip install -e .
+python -m unittest discover -s tests -v
+python -m pip install build twine
+python -m build
+python -m twine check dist/*
+```
+
+Image decoding and encoding are provided by
+[Pillow](https://pillow.readthedocs.io/en/stable/). Contributions can be shared
+as patches against the source distribution.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

image_edit_prep-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "image-edit-prep"
+version = "0.1.0"
+description = "Prepare local photos for editing and create before-and-after comparison sheets."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "Leanna Yode"}]
+dependencies = ["Pillow>=11.3"]
+keywords = ["image", "photo", "resize", "webp", "comparison"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Topic :: Multimedia :: Graphics :: Graphics Conversion",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+]
+
+[project.scripts]
+image-edit-prep = "image_edit_prep.cli:main"
+
+[project.urls]
+"Editing workflow example" = "https://ediroo.com"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/image_edit_prep"]
+
+[tool.hatch.build.targets.sdist]
+include = ["/src", "/tests", "/README.md", "/LICENSE", "/pyproject.toml"]

image_edit_prep-0.1.0/src/image_edit_prep/__init__.py

@@ -0,0 +1,6 @@
+"""Local photo preparation and comparison tools."""
+
+from .core import compare, inspect_image, prepare
+
+__version__ = "0.1.0"
+__all__ = ["compare", "inspect_image", "prepare"]

image_edit_prep-0.1.0/src/image_edit_prep/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

image_edit_prep-0.1.0/src/image_edit_prep/cli.py

@@ -0,0 +1,41 @@
+"""Command-line interface."""
+
+import argparse
+import json
+import sys
+
+from PIL.Image import DecompressionBombError
+
+from . import __version__
+from .core import compare, inspect_image, prepare
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Prepare local photos and comparison sheets.")
+    parser.add_argument("--version", action="version", version=__version__)
+    commands = parser.add_subparsers(dest="command", required=True)
+    inspect_parser = commands.add_parser("inspect", help="Show oriented dimensions and file size")
+    inspect_parser.add_argument("source")
+    prep = commands.add_parser("prepare", help="Orient, resize, and export a photo")
+    prep.add_argument("source")
+    prep.add_argument("output")
+    prep.add_argument("--max-width", type=int, default=2048)
+    prep.add_argument("--max-height", type=int, default=2048)
+    comparison = commands.add_parser("compare", help="Create a Before/After comparison sheet")
+    comparison.add_argument("before")
+    comparison.add_argument("after")
+    comparison.add_argument("output")
+    comparison.add_argument("--panel-width", type=int, default=640)
+    comparison.add_argument("--panel-height", type=int, default=640)
+    for command in (prep, comparison):
+        command.add_argument("--quality", type=int, default=85, help="JPEG/WebP quality, 1–100")
+        command.add_argument("--overwrite", action="store_true", help="Replace an existing output")
+    values = vars(parser.parse_args(argv))
+    command = values.pop("command")
+    try:
+        function = {"inspect": inspect_image, "prepare": prepare, "compare": compare}[command]
+        print(json.dumps(function(**values), ensure_ascii=False))
+        return 0
+    except (OSError, ValueError, DecompressionBombError) as error:
+        print(f"image-edit-prep: {error}", file=sys.stderr)
+        return 1

image_edit_prep-0.1.0/src/image_edit_prep/core.py

@@ -0,0 +1,123 @@
+"""Small Pillow-based operations with no network access."""
+
+import os
+from pathlib import Path
+import tempfile
+
+from PIL import Image, ImageDraw, ImageOps
+
+_FORMATS = {".jpg": "JPEG", ".jpeg": "JPEG", ".png": "PNG", ".webp": "WEBP"}
+_MODES = {"1", "L", "LA", "P", "RGB", "RGBA"}
+
+
+def _limit(value: int, name: str, maximum: int = 8192) -> None:
+    if isinstance(value, bool) or not isinstance(value, int) or not 1 <= value <= maximum:
+        raise ValueError(f"{name} must be an integer from 1 to {maximum}")
+
+
+def _load(path: str | Path) -> Image.Image:
+    with Image.open(path) as source:
+        if source.format not in {"JPEG", "PNG", "WEBP"}:
+            raise ValueError("Input must be JPEG, PNG, or WebP")
+        if getattr(source, "n_frames", 1) != 1:
+            raise ValueError("Animated or multi-frame images are not supported")
+        if source.mode not in _MODES:
+            raise ValueError(f"Unsupported image mode {source.mode}; convert to sRGB first")
+        source.load()
+        oriented = ImageOps.exif_transpose(source)
+        alpha = "A" in oriented.getbands() or "transparency" in oriented.info
+        result = oriented.convert("RGBA" if alpha else "RGB")
+        profile = source.info.get("icc_profile")
+        # A grayscale profile is incompatible after conversion to RGB.
+        result.info.clear()
+        if profile and source.mode in {"RGB", "RGBA"}:
+            result.info["icc_profile"] = profile
+        return result
+
+
+def _save(image: Image.Image, output: str | Path, sources: list[str | Path],
+          quality: int, overwrite: bool) -> dict:
+    target = Path(output)
+    if target.resolve() in {Path(path).resolve() for path in sources}:
+        raise ValueError("Output must be different from every input")
+    fmt = _FORMATS.get(target.suffix.lower())
+    if fmt is None:
+        raise ValueError("Output extension must be .jpg, .jpeg, .png, or .webp")
+    _limit(quality, "quality", 100)
+    if target.exists() and not overwrite:
+        raise FileExistsError(f"Output already exists: {target}")
+    if fmt == "JPEG" and image.mode == "RGBA":
+        canvas = Image.new("RGB", image.size, "white")
+        canvas.paste(image, mask=image.getchannel("A"))
+        canvas.info.update(image.info)
+        image = canvas
+    options = {}
+    if fmt in {"JPEG", "WEBP"}:
+        options["quality"] = quality
+    if fmt == "JPEG":
+        options.update(optimize=True, progressive=True)
+    if image.info.get("icc_profile"):
+        options["icc_profile"] = image.info["icc_profile"]
+    fd, temporary = tempfile.mkstemp(prefix=".image-edit-prep-", dir=target.parent)
+    os.close(fd)
+    try:
+        image.save(temporary, format=fmt, **options)
+        if overwrite:
+            os.replace(temporary, target)
+        else:
+            # Atomic exclusive publication also protects against competing writers.
+            os.link(temporary, target)
+    finally:
+        Path(temporary).unlink(missing_ok=True)
+    return {"path": str(target), "width": image.width, "height": image.height,
+            "format": fmt, "bytes": target.stat().st_size}
+
+
+def inspect_image(source: str | Path) -> dict:
+    """Return basic file facts and dimensions after EXIF orientation."""
+    image = _load(source)
+    return {"path": str(source), "width": image.width, "height": image.height,
+            "mode": image.mode, "bytes": Path(source).stat().st_size,
+            "has_alpha": image.mode == "RGBA"}
+
+
+def prepare(source: str | Path, output: str | Path, *, max_width: int = 2048,
+            max_height: int = 2048, quality: int = 85, overwrite: bool = False) -> dict:
+    """Orient and fit a photo inside a box, without cropping or upscaling."""
+    _limit(max_width, "max_width")
+    _limit(max_height, "max_height")
+    image = _load(source)
+    image.thumbnail((max_width, max_height), Image.Resampling.LANCZOS)
+    return _save(image, output, [source], quality, overwrite)
+
+
+def compare(before: str | Path, after: str | Path, output: str | Path, *,
+            panel_width: int = 640, panel_height: int = 640,
+            quality: int = 85, overwrite: bool = False) -> dict:
+    """Create a labelled side-by-side sheet with equal panels and no cropping.
+
+    ICC-tagged RGB photos are converted to sRGB for a common comparison canvas.
+    Untagged photos are assumed to be sRGB.
+    """
+    _limit(panel_width, "panel_width", 4096)
+    _limit(panel_height, "panel_height", 4096)
+    canvas = Image.new("RGB", (panel_width * 2, panel_height + 32), "#eeeeee")
+    draw = ImageDraw.Draw(canvas)
+    for index, (path, label) in enumerate(((before, "Before"), (after, "After"))):
+        image = _load(path)
+        if image.info.get("icc_profile"):
+            from io import BytesIO
+            from PIL import ImageCms
+
+            alpha = image.getchannel("A") if image.mode == "RGBA" else None
+            image = ImageCms.profileToProfile(
+                image.convert("RGB"), ImageCms.ImageCmsProfile(BytesIO(image.info["icc_profile"])),
+                ImageCms.createProfile("sRGB"), outputMode="RGB")
+            if alpha is not None:
+                image.putalpha(alpha)
+        image.thumbnail((panel_width, panel_height), Image.Resampling.LANCZOS)
+        x = index * panel_width + (panel_width - image.width) // 2
+        y = 32 + (panel_height - image.height) // 2
+        canvas.paste(image, (x, y), image.getchannel("A") if image.mode == "RGBA" else None)
+        draw.text((index * panel_width + 10, 9), label, fill="#222222")
+    return _save(canvas, output, [before, after], quality, overwrite)

image_edit_prep-0.1.0/tests/test_images.py

@@ -0,0 +1,129 @@
+import contextlib
+import io
+import json
+from pathlib import Path
+import tempfile
+import unittest
+
+from PIL import Image, ImageCms, PngImagePlugin
+
+from image_edit_prep import compare, inspect_image, prepare
+from image_edit_prep.cli import main
+
+
+class ImageTests(unittest.TestCase):
+    def setUp(self):
+        self.directory = tempfile.TemporaryDirectory()
+        self.addCleanup(self.directory.cleanup)
+        self.root = Path(self.directory.name)
+        self.source = self.root / "source.png"
+        Image.new("RGB", (120, 60), "red").save(self.source)
+
+    def test_resize_keeps_aspect_and_does_not_upscale(self):
+        for size, expected in ((40, (40, 20)), (400, (120, 60))):
+            output = self.root / f"{size}.webp"
+            result = prepare(self.source, output, max_width=size, max_height=size)
+            self.assertEqual((result["width"], result["height"]), expected)
+            with Image.open(output) as image:
+                self.assertEqual(image.size, expected)
+                self.assertEqual(image.format, "WEBP")
+
+    def test_orientation_applied_and_exif_removed(self):
+        source = self.root / "rotated.jpg"
+        exif = Image.Exif()
+        exif[274] = 6
+        exif[315] = "test author"
+        Image.new("RGB", (120, 60), "blue").save(source, exif=exif)
+        self.assertEqual(inspect_image(source)["width"], 60)
+        output = self.root / "oriented.png"
+        prepare(source, output)
+        with Image.open(output) as image:
+            self.assertEqual(image.size, (60, 120))
+            self.assertFalse(image.getexif())
+
+    def test_transparency_and_white_jpeg_background(self):
+        Image.new("RGBA", (20, 10), (255, 0, 0, 0)).save(self.source)
+        output = self.root / "transparent.webp"
+        prepare(self.source, output)
+        with Image.open(output) as image:
+            self.assertEqual(image.getpixel((0, 0))[3], 0)
+        output = self.root / "white.jpg"
+        prepare(self.source, output)
+        with Image.open(output) as image:
+            self.assertTrue(all(channel >= 250 for channel in image.getpixel((0, 0))))
+
+    def test_text_removed_and_icc_retained(self):
+        info = PngImagePlugin.PngInfo()
+        info.add_text("Comment", "private comment")
+        profile = ImageCms.ImageCmsProfile(ImageCms.createProfile("sRGB")).tobytes()
+        Image.new("RGBA", (20, 10), "red").save(self.source, pnginfo=info, icc_profile=profile)
+        for suffix in ("png", "webp", "jpg"):
+            output = self.root / f"clean.{suffix}"
+            prepare(self.source, output)
+            with Image.open(output) as image:
+                self.assertNotIn("Comment", image.info)
+                self.assertEqual(image.info["icc_profile"], profile)
+
+    def test_comparison_layout_and_alpha(self):
+        after = self.root / "after.png"
+        Image.new("RGBA", (30, 60), (0, 0, 255, 0)).save(after)
+        output = self.root / "sheet.png"
+        result = compare(self.source, after, output, panel_width=100, panel_height=80)
+        self.assertEqual((result["width"], result["height"]), (200, 112))
+        with Image.open(output) as image:
+            self.assertEqual(image.getpixel((50, 72)), (255, 0, 0))
+            self.assertEqual(image.getpixel((150, 72)), (238, 238, 238))
+
+    def test_comparison_accepts_tagged_input(self):
+        profile = ImageCms.ImageCmsProfile(ImageCms.createProfile("sRGB")).tobytes()
+        Image.new("RGB", (10, 10), "red").save(self.source, icc_profile=profile)
+        output = self.root / "profile-sheet.png"
+        compare(self.source, self.source, output, panel_width=20, panel_height=20)
+        with Image.open(output) as image:
+            self.assertEqual(image.getpixel((10, 42)), (255, 0, 0))
+
+    def test_outputs_are_protected(self):
+        original = self.source.read_bytes()
+        with self.assertRaises(ValueError):
+            prepare(self.source, self.source, overwrite=True)
+        output = self.root / "exists.png"
+        output.write_bytes(b"keep me")
+        with self.assertRaises(FileExistsError):
+            prepare(self.source, output)
+        self.assertEqual(output.read_bytes(), b"keep me")
+        prepare(self.source, output, overwrite=True)
+        self.assertEqual(self.source.read_bytes(), original)
+        self.assertFalse(list(self.root.glob(".image-edit-prep-*")))
+
+    def test_invalid_images_and_options(self):
+        with self.assertRaises(ValueError):
+            prepare(self.source, self.root / "bad.gif")
+        for kwargs in ({"max_width": 0}, {"max_height": 9000}, {"quality": 101}):
+            with self.assertRaises(ValueError):
+                prepare(self.source, self.root / "bad.png", **kwargs)
+        cmyk = self.root / "cmyk.jpg"
+        Image.new("CMYK", (10, 10)).save(cmyk)
+        with self.assertRaisesRegex(ValueError, "sRGB"):
+            inspect_image(cmyk)
+
+    def test_animation_rejected(self):
+        animated = self.root / "animated.png"
+        first = Image.new("RGB", (20, 20), "red")
+        first.save(animated, save_all=True, append_images=[Image.new("RGB", (20, 20), "blue")])
+        with self.assertRaisesRegex(ValueError, "multi-frame"):
+            prepare(animated, self.root / "flat.png")
+
+    def test_cli_json_and_readable_errors(self):
+        stdout, stderr = io.StringIO(), io.StringIO()
+        with contextlib.redirect_stdout(stdout):
+            code = main(["inspect", str(self.source)])
+        self.assertEqual(code, 0)
+        self.assertEqual(json.loads(stdout.getvalue())["width"], 120)
+        with contextlib.redirect_stderr(stderr):
+            code = main(["prepare", str(self.source), str(self.root / "bad.png"), "--quality", "0"])
+        self.assertEqual(code, 1)
+        self.assertIn("quality", stderr.getvalue())
+
+
+if __name__ == "__main__":
+    unittest.main()