sbraz/img2pdf
1
0
Fork 0
forked from josch/img2pdf
Code Issues Pull requests Projects Releases Wiki Activity

src/img2pdf_test.py: add support for imagemagick 7

Browse source
This commit is contained in:
Johannes Schauer Marin Rodrigues 2021-10-03 22:54:33 +02:00
parent 354fd7c264
commit 9c9e5ece19
Signed by untrusted user: josch
GPG key ID: F2CBA5C78FBD83E1
1 changed files with 178 additions and 183 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

347
src/img2pdf_test.py
View file

@ -65,9 +65,16 @@ except FileNotFoundError:
if not HAVE_PDFIMAGES_CMYK: if not HAVE_PDFIMAGES_CMYK:
warnings.warn("pdfimages >= 0.42.0 not available, skipping CMYK checks...") warnings.warn("pdfimages >= 0.42.0 not available, skipping CMYK checks...")
for prog in ["convert", "compare", "identify"]:
try:
subprocess.check_call([prog] + ["-version"], stderr=subprocess.STDOUT)
globals()[prog.upper()] = [prog]
except subprocess.CalledProcessError:
globals()[prog.upper()] = ["magick", prog]
HAVE_IMAGEMAGICK_MODERN = True HAVE_IMAGEMAGICK_MODERN = True
try: try:
ver = subprocess.check_output(["convert", "-version"], stderr=subprocess.STDOUT) ver = subprocess.check_output(CONVERT + ["-version"], stderr=subprocess.STDOUT)
m = re.fullmatch( m = re.fullmatch(
r"Version: ImageMagick ([0-9.]+-[0-9]+) .*", ver.split(b"\n")[0].decode("utf8") r"Version: ImageMagick ([0-9.]+-[0-9]+) .*", ver.split(b"\n")[0].decode("utf8")
) )
@ -87,7 +94,7 @@ if not HAVE_IMAGEMAGICK_MODERN:
HAVE_JP2 = True HAVE_JP2 = True
try: try:
ver = subprocess.check_output( ver = subprocess.check_output(
["identify", "-list", "format"], stderr=subprocess.STDOUT IDENTIFY + ["-list", "format"], stderr=subprocess.STDOUT
) )
found = False found = False
for line in ver.split(b"\n"): for line in ver.split(b"\n"):
@ -307,8 +314,8 @@ def compare(im1, im2, exact, icc, cmyk):
raise Exception("icc cannot be exact") raise Exception("icc cannot be exact")
else: else:
subprocess.check_call( subprocess.check_call(
[ COMPARE
"compare", + [
"-metric", "-metric",
"AE", "AE",
im1, im1,
@ -323,7 +330,7 @@ def compare(im1, im2, exact, icc, cmyk):
pytest.skip("Could not locate an ICC profile") pytest.skip("Could not locate an ICC profile")
iccargs = ["-profile", ICC_PROFILE] iccargs = ["-profile", ICC_PROFILE]
psnr = subprocess.run( psnr = subprocess.run(
["compare"] COMPARE
+ iccargs + iccargs
+ [ + [
"-metric", "-metric",
@ -412,7 +419,14 @@ def compare_pdfimages_jp2(tmpdir, img, pdf):
def compare_pdfimages_tiff(tmpdir, img, pdf): def compare_pdfimages_tiff(tmpdir, img, pdf):
subprocess.check_call(["pdfimages", "-tiff", str(pdf), str(tmpdir / "images")]) subprocess.check_call(["pdfimages", "-tiff", str(pdf), str(tmpdir / "images")])
subprocess.check_call( subprocess.check_call(
["compare", "-metric", "AE", str(img), str(tmpdir / "images-000.tif"), "null:"] COMPARE
+ [
"-metric",
"AE",
str(img),
str(tmpdir / "images-000.tif"),
"null:",
]
) )
(tmpdir / "images-000.tif").unlink() (tmpdir / "images-000.tif").unlink()
@ -422,14 +436,14 @@ def compare_pdfimages_png(tmpdir, img, pdf, exact=True, icc=False):
# images-001.png is the grayscale SMask image (the original alpha channel) # images-001.png is the grayscale SMask image (the original alpha channel)
if os.path.isfile(tmpdir / "images-001.png"): if os.path.isfile(tmpdir / "images-001.png"):
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmpdir / "images-000.png"), str(tmpdir / "images-000.png"),
str(tmpdir / "images-001.png"), str(tmpdir / "images-001.png"),
"-compose", "-compose",
"copy-opacity", "copy-opacity",
"-composite", "-composite",
str(tmpdir / "composite.png") str(tmpdir / "composite.png"),
] ]
) )
(tmpdir / "images-000.png").unlink() (tmpdir / "images-000.png").unlink()
@ -440,8 +454,8 @@ def compare_pdfimages_png(tmpdir, img, pdf, exact=True, icc=False):
if icc: if icc:
raise Exception("not exact with icc") raise Exception("not exact with icc")
subprocess.check_call( subprocess.check_call(
[ COMPARE
"compare", + [
"-metric", "-metric",
"AE", "AE",
str(img), str(img),
@ -454,8 +468,8 @@ def compare_pdfimages_png(tmpdir, img, pdf, exact=True, icc=False):
if ICC_PROFILE is None: if ICC_PROFILE is None:
pytest.skip("Could not locate an ICC profile") pytest.skip("Could not locate an ICC profile")
psnr = subprocess.run( psnr = subprocess.run(
[ COMPARE
"compare", + [
"-metric", "-metric",
"PSNR", "PSNR",
"(", "(",
@ -473,8 +487,8 @@ def compare_pdfimages_png(tmpdir, img, pdf, exact=True, icc=False):
).stderr ).stderr
else: else:
psnr = subprocess.run( psnr = subprocess.run(
[ COMPARE
"compare", + [
"-metric", "-metric",
"PSNR", "PSNR",
str(img), str(img),
@ -994,8 +1008,8 @@ def tmp_palette8_png(tmp_path_factory, alpha):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def jpg_img(tmp_path_factory, tmp_normal_png): def jpg_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("jpg") / "in.jpg" in_img = tmp_path_factory.mktemp("jpg") / "in.jpg"
subprocess.check_call(["convert", str(tmp_normal_png), str(in_img)]) subprocess.check_call(CONVERT + [str(tmp_normal_png), str(in_img)])
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -1036,7 +1050,7 @@ def jpg_img(tmp_path_factory, tmp_normal_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def jpg_rot_img(tmp_path_factory, tmp_normal_png): def jpg_rot_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("jpg_rot") / "in.jpg" in_img = tmp_path_factory.mktemp("jpg_rot") / "in.jpg"
subprocess.check_call(["convert", str(tmp_normal_png), str(in_img)]) subprocess.check_call(CONVERT + [str(tmp_normal_png), str(in_img)])
subprocess.check_call( subprocess.check_call(
["exiftool", "-overwrite_original", "-all=", str(in_img), "-n"] ["exiftool", "-overwrite_original", "-all=", str(in_img), "-n"]
) )
@ -1051,7 +1065,7 @@ def jpg_rot_img(tmp_path_factory, tmp_normal_png):
str(in_img), str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -1088,9 +1102,9 @@ def jpg_rot_img(tmp_path_factory, tmp_normal_png):
def jpg_cmyk_img(tmp_path_factory, tmp_normal_png): def jpg_cmyk_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("jpg_cmyk") / "in.jpg" in_img = tmp_path_factory.mktemp("jpg_cmyk") / "in.jpg"
subprocess.check_call( subprocess.check_call(
["convert", str(tmp_normal_png), "-colorspace", "cmyk", str(in_img)] CONVERT + [str(tmp_normal_png), "-colorspace", "cmyk", str(in_img)]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -1123,8 +1137,8 @@ def jpg_cmyk_img(tmp_path_factory, tmp_normal_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def jpg_2000_img(tmp_path_factory, tmp_normal_png): def jpg_2000_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("jpg_2000") / "in.jp2" in_img = tmp_path_factory.mktemp("jpg_2000") / "in.jp2"
subprocess.check_call(["convert", str(tmp_normal_png), str(in_img)]) subprocess.check_call(CONVERT + [str(tmp_normal_png), str(in_img)])
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -1157,7 +1171,7 @@ def jpg_2000_img(tmp_path_factory, tmp_normal_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def png_rgb8_img(tmp_normal_png): def png_rgb8_img(tmp_normal_png):
in_img = tmp_normal_png in_img = tmp_normal_png
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -1206,7 +1220,7 @@ def png_rgb8_img(tmp_normal_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def png_rgb16_img(tmp_normal16_png): def png_rgb16_img(tmp_normal16_png):
in_img = tmp_normal16_png in_img = tmp_normal16_png
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -1257,9 +1271,9 @@ def png_rgb16_img(tmp_normal16_png):
def png_rgba8_img(tmp_path_factory, tmp_alpha_png): def png_rgba8_img(tmp_path_factory, tmp_alpha_png):
in_img = tmp_path_factory.mktemp("png_rgba8") / "in.png" in_img = tmp_path_factory.mktemp("png_rgba8") / "in.png"
subprocess.check_call( subprocess.check_call(
["convert", str(tmp_alpha_png), "-depth", "8", "-strip", str(in_img)] CONVERT + [str(tmp_alpha_png), "-depth", "8", "-strip", str(in_img)]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -1309,7 +1323,7 @@ def png_rgba8_img(tmp_path_factory, tmp_alpha_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def png_rgba16_img(tmp_alpha_png): def png_rgba16_img(tmp_alpha_png):
in_img = tmp_alpha_png in_img = tmp_alpha_png
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -1360,8 +1374,8 @@ def png_rgba16_img(tmp_alpha_png):
def png_gray8a_img(tmp_path_factory, tmp_alpha_png): def png_gray8a_img(tmp_path_factory, tmp_alpha_png):
in_img = tmp_path_factory.mktemp("png_gray8a") / "in.png" in_img = tmp_path_factory.mktemp("png_gray8a") / "in.png"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_alpha_png), str(tmp_alpha_png),
"-colorspace", "-colorspace",
"Gray", "Gray",
@ -1375,7 +1389,7 @@ def png_gray8a_img(tmp_path_factory, tmp_alpha_png):
str(in_img), str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -1426,8 +1440,8 @@ def png_gray8a_img(tmp_path_factory, tmp_alpha_png):
def png_gray16a_img(tmp_path_factory, tmp_alpha_png): def png_gray16a_img(tmp_path_factory, tmp_alpha_png):
in_img = tmp_path_factory.mktemp("png_gray16a") / "in.png" in_img = tmp_path_factory.mktemp("png_gray16a") / "in.png"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_alpha_png), str(tmp_alpha_png),
"-colorspace", "-colorspace",
"Gray", "Gray",
@ -1437,7 +1451,7 @@ def png_gray16a_img(tmp_path_factory, tmp_alpha_png):
str(in_img), str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -1489,9 +1503,16 @@ def png_gray16a_img(tmp_path_factory, tmp_alpha_png):
def png_interlaced_img(tmp_path_factory, tmp_normal_png): def png_interlaced_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("png_interlaced") / "in.png" in_img = tmp_path_factory.mktemp("png_interlaced") / "in.png"
subprocess.check_call( subprocess.check_call(
["convert", str(tmp_normal_png), "-interlace", "PNG", "-strip", str(in_img)] CONVERT
+ [
str(tmp_normal_png),
"-interlace",
"PNG",
"-strip",
str(in_img),
]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -1541,7 +1562,7 @@ def png_interlaced_img(tmp_path_factory, tmp_normal_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def png_gray1_img(tmp_path_factory, tmp_gray1_png): def png_gray1_img(tmp_path_factory, tmp_gray1_png):
identify = json.loads( identify = json.loads(
subprocess.check_output(["convert", str(tmp_gray1_png), "json:"]) subprocess.check_output(CONVERT + [str(tmp_gray1_png), "json:"])
) )
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
@ -1591,7 +1612,7 @@ def png_gray1_img(tmp_path_factory, tmp_gray1_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def png_gray2_img(tmp_path_factory, tmp_gray2_png): def png_gray2_img(tmp_path_factory, tmp_gray2_png):
identify = json.loads( identify = json.loads(
subprocess.check_output(["convert", str(tmp_gray2_png), "json:"]) subprocess.check_output(CONVERT + [str(tmp_gray2_png), "json:"])
) )
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
@ -1641,7 +1662,7 @@ def png_gray2_img(tmp_path_factory, tmp_gray2_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def png_gray4_img(tmp_path_factory, tmp_gray4_png): def png_gray4_img(tmp_path_factory, tmp_gray4_png):
identify = json.loads( identify = json.loads(
subprocess.check_output(["convert", str(tmp_gray4_png), "json:"]) subprocess.check_output(CONVERT + [str(tmp_gray4_png), "json:"])
) )
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
@ -1691,7 +1712,7 @@ def png_gray4_img(tmp_path_factory, tmp_gray4_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def png_gray8_img(tmp_path_factory, tmp_gray8_png): def png_gray8_img(tmp_path_factory, tmp_gray8_png):
identify = json.loads( identify = json.loads(
subprocess.check_output(["convert", str(tmp_gray8_png), "json:"]) subprocess.check_output(CONVERT + [str(tmp_gray8_png), "json:"])
) )
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
@ -1741,7 +1762,7 @@ def png_gray8_img(tmp_path_factory, tmp_gray8_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def png_gray16_img(tmp_path_factory, tmp_gray16_png): def png_gray16_img(tmp_path_factory, tmp_gray16_png):
identify = json.loads( identify = json.loads(
subprocess.check_output(["convert", str(tmp_gray16_png), "json:"]) subprocess.check_output(CONVERT + [str(tmp_gray16_png), "json:"])
) )
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
@ -1792,7 +1813,7 @@ def png_gray16_img(tmp_path_factory, tmp_gray16_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def png_palette1_img(tmp_path_factory, tmp_palette1_png): def png_palette1_img(tmp_path_factory, tmp_palette1_png):
identify = json.loads( identify = json.loads(
subprocess.check_output(["convert", str(tmp_palette1_png), "json:"]) subprocess.check_output(CONVERT + [str(tmp_palette1_png), "json:"])
) )
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
@ -1842,7 +1863,7 @@ def png_palette1_img(tmp_path_factory, tmp_palette1_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def png_palette2_img(tmp_path_factory, tmp_palette2_png): def png_palette2_img(tmp_path_factory, tmp_palette2_png):
identify = json.loads( identify = json.loads(
subprocess.check_output(["convert", str(tmp_palette2_png), "json:"]) subprocess.check_output(CONVERT + [str(tmp_palette2_png), "json:"])
) )
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
@ -1892,7 +1913,7 @@ def png_palette2_img(tmp_path_factory, tmp_palette2_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def png_palette4_img(tmp_path_factory, tmp_palette4_png): def png_palette4_img(tmp_path_factory, tmp_palette4_png):
identify = json.loads( identify = json.loads(
subprocess.check_output(["convert", str(tmp_palette4_png), "json:"]) subprocess.check_output(CONVERT + [str(tmp_palette4_png), "json:"])
) )
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
@ -1942,7 +1963,7 @@ def png_palette4_img(tmp_path_factory, tmp_palette4_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def png_palette8_img(tmp_path_factory, tmp_palette8_png): def png_palette8_img(tmp_path_factory, tmp_palette8_png):
identify = json.loads( identify = json.loads(
subprocess.check_output(["convert", str(tmp_palette8_png), "json:"]) subprocess.check_output(CONVERT + [str(tmp_palette8_png), "json:"])
) )
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
@ -1992,8 +2013,8 @@ def png_palette8_img(tmp_path_factory, tmp_palette8_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def gif_transparent_img(tmp_path_factory, tmp_alpha_png): def gif_transparent_img(tmp_path_factory, tmp_alpha_png):
in_img = tmp_path_factory.mktemp("gif_transparent_img") / "in.gif" in_img = tmp_path_factory.mktemp("gif_transparent_img") / "in.gif"
subprocess.check_call(["convert", str(tmp_alpha_png), str(in_img)]) subprocess.check_call(CONVERT + [str(tmp_alpha_png), str(in_img)])
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2027,8 +2048,8 @@ def gif_transparent_img(tmp_path_factory, tmp_alpha_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def gif_palette1_img(tmp_path_factory, tmp_palette1_png): def gif_palette1_img(tmp_path_factory, tmp_palette1_png):
in_img = tmp_path_factory.mktemp("gif_palette1_img") / "in.gif" in_img = tmp_path_factory.mktemp("gif_palette1_img") / "in.gif"
subprocess.check_call(["convert", str(tmp_palette1_png), str(in_img)]) subprocess.check_call(CONVERT + [str(tmp_palette1_png), str(in_img)])
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2062,8 +2083,8 @@ def gif_palette1_img(tmp_path_factory, tmp_palette1_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def gif_palette2_img(tmp_path_factory, tmp_palette2_png): def gif_palette2_img(tmp_path_factory, tmp_palette2_png):
in_img = tmp_path_factory.mktemp("gif_palette2_img") / "in.gif" in_img = tmp_path_factory.mktemp("gif_palette2_img") / "in.gif"
subprocess.check_call(["convert", str(tmp_palette2_png), str(in_img)]) subprocess.check_call(CONVERT + [str(tmp_palette2_png), str(in_img)])
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2097,8 +2118,8 @@ def gif_palette2_img(tmp_path_factory, tmp_palette2_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def gif_palette4_img(tmp_path_factory, tmp_palette4_png): def gif_palette4_img(tmp_path_factory, tmp_palette4_png):
in_img = tmp_path_factory.mktemp("gif_palette4_img") / "in.gif" in_img = tmp_path_factory.mktemp("gif_palette4_img") / "in.gif"
subprocess.check_call(["convert", str(tmp_palette4_png), str(in_img)]) subprocess.check_call(CONVERT + [str(tmp_palette4_png), str(in_img)])
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2132,8 +2153,8 @@ def gif_palette4_img(tmp_path_factory, tmp_palette4_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def gif_palette8_img(tmp_path_factory, tmp_palette8_png): def gif_palette8_img(tmp_path_factory, tmp_palette8_png):
in_img = tmp_path_factory.mktemp("gif_palette8_img") / "in.gif" in_img = tmp_path_factory.mktemp("gif_palette8_img") / "in.gif"
subprocess.check_call(["convert", str(tmp_palette8_png), str(in_img)]) subprocess.check_call(CONVERT + [str(tmp_palette8_png), str(in_img)])
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2168,10 +2189,16 @@ def gif_palette8_img(tmp_path_factory, tmp_palette8_png):
def gif_animation_img(tmp_path_factory, tmp_normal_png, tmp_inverse_png): def gif_animation_img(tmp_path_factory, tmp_normal_png, tmp_inverse_png):
in_img = tmp_path_factory.mktemp("gif_animation_img") / "in.gif" in_img = tmp_path_factory.mktemp("gif_animation_img") / "in.gif"
subprocess.check_call( subprocess.check_call(
["convert", str(tmp_normal_png), str(tmp_inverse_png), "-strip", str(in_img)] CONVERT
+ [
str(tmp_normal_png),
str(tmp_inverse_png),
"-strip",
str(in_img),
]
) )
identify = json.loads( identify = json.loads(
subprocess.check_output(["convert", str(in_img) + "[0]", "json:"]) subprocess.check_output(CONVERT + [str(in_img) + "[0]", "json:"])
) )
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
@ -2200,7 +2227,7 @@ def gif_animation_img(tmp_path_factory, tmp_normal_png, tmp_inverse_png):
}, str(identify) }, str(identify)
assert identify[0]["image"].get("compression") == "LZW", str(identify) assert identify[0]["image"].get("compression") == "LZW", str(identify)
identify = json.loads( identify = json.loads(
subprocess.check_output(["convert", str(in_img) + "[1]", "json:"]) subprocess.check_output(CONVERT + [str(in_img) + "[1]", "json:"])
) )
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
@ -2237,8 +2264,8 @@ def gif_animation_img(tmp_path_factory, tmp_normal_png, tmp_inverse_png):
def tiff_float_img(tmp_path_factory, tmp_normal_png): def tiff_float_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("tiff_float_img") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_float_img") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_normal_png), str(tmp_normal_png),
"-depth", "-depth",
"32", "32",
@ -2247,7 +2274,7 @@ def tiff_float_img(tmp_path_factory, tmp_normal_png):
str(in_img), str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2298,17 +2325,17 @@ def tiff_float_img(tmp_path_factory, tmp_normal_png):
def tiff_cmyk8_img(tmp_path_factory, tmp_normal_png): def tiff_cmyk8_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("tiff_cmyk8") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_cmyk8") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_normal_png), str(tmp_normal_png),
"-colorspace", "-colorspace",
"cmyk", "cmyk",
"-compress", "-compress",
"Zip", "Zip",
str(in_img) str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2355,8 +2382,8 @@ def tiff_cmyk8_img(tmp_path_factory, tmp_normal_png):
def tiff_cmyk16_img(tmp_path_factory, tmp_normal_png): def tiff_cmyk16_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("tiff_cmyk16") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_cmyk16") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_normal_png), str(tmp_normal_png),
"-depth", "-depth",
"16", "16",
@ -2367,7 +2394,7 @@ def tiff_cmyk16_img(tmp_path_factory, tmp_normal_png):
str(in_img), str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2414,15 +2441,9 @@ def tiff_cmyk16_img(tmp_path_factory, tmp_normal_png):
def tiff_rgb8_img(tmp_path_factory, tmp_normal_png): def tiff_rgb8_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("tiff_rgb8") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_rgb8") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT + [str(tmp_normal_png), "-compress", "Zip", str(in_img)]
"convert",
str(tmp_normal_png),
"-compress",
"Zip",
str(in_img)
]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2468,17 +2489,17 @@ def tiff_rgb8_img(tmp_path_factory, tmp_normal_png):
def tiff_rgb12_img(tmp_path_factory, tmp_normal16_png): def tiff_rgb12_img(tmp_path_factory, tmp_normal16_png):
in_img = tmp_path_factory.mktemp("tiff_rgb8") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_rgb8") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_normal16_png), str(tmp_normal16_png),
"-depth", "-depth",
"12", "12",
"-compress", "-compress",
"Zip", "Zip",
str(in_img) str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2528,17 +2549,17 @@ def tiff_rgb12_img(tmp_path_factory, tmp_normal16_png):
def tiff_rgb14_img(tmp_path_factory, tmp_normal16_png): def tiff_rgb14_img(tmp_path_factory, tmp_normal16_png):
in_img = tmp_path_factory.mktemp("tiff_rgb8") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_rgb8") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_normal16_png), str(tmp_normal16_png),
"-depth", "-depth",
"14", "14",
"-compress", "-compress",
"Zip", "Zip",
str(in_img) str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2560,9 +2581,6 @@ def tiff_rgb14_img(tmp_path_factory, tmp_normal16_png):
assert identify[0]["image"].get(endian) in ["Undefined", "LSB",], str( assert identify[0]["image"].get(endian) in ["Undefined", "LSB",], str(
identify identify
) # FIXME: should be LSB ) # FIXME: should be LSB
if identify[0].get("version", "0") < "1.0":
assert identify[0]["image"].get("depth") == 14, str(identify)
else:
assert identify[0]["image"].get("depth") == 16, str(identify) assert identify[0]["image"].get("depth") == 16, str(identify)
assert identify[0]["image"].get("baseDepth") == 14, str(identify) assert identify[0]["image"].get("baseDepth") == 14, str(identify)
assert identify[0]["image"].get("pageGeometry") == { assert identify[0]["image"].get("pageGeometry") == {
@ -2588,17 +2606,17 @@ def tiff_rgb14_img(tmp_path_factory, tmp_normal16_png):
def tiff_rgb16_img(tmp_path_factory, tmp_normal16_png): def tiff_rgb16_img(tmp_path_factory, tmp_normal16_png):
in_img = tmp_path_factory.mktemp("tiff_rgb8") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_rgb8") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_normal16_png), str(tmp_normal16_png),
"-depth", "-depth",
"16", "16",
"-compress", "-compress",
"Zip", "Zip",
str(in_img) str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2644,18 +2662,18 @@ def tiff_rgb16_img(tmp_path_factory, tmp_normal16_png):
def tiff_rgba8_img(tmp_path_factory, tmp_alpha_png): def tiff_rgba8_img(tmp_path_factory, tmp_alpha_png):
in_img = tmp_path_factory.mktemp("tiff_rgba8") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_rgba8") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_alpha_png), str(tmp_alpha_png),
"-depth", "-depth",
"8", "8",
"-strip", "-strip",
"-compress", "-compress",
"Zip", "Zip",
str(in_img) str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2701,18 +2719,18 @@ def tiff_rgba8_img(tmp_path_factory, tmp_alpha_png):
def tiff_rgba16_img(tmp_path_factory, tmp_alpha_png): def tiff_rgba16_img(tmp_path_factory, tmp_alpha_png):
in_img = tmp_path_factory.mktemp("tiff_rgba16") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_rgba16") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_alpha_png), str(tmp_alpha_png),
"-depth", "-depth",
"16", "16",
"-strip", "-strip",
"-compress", "-compress",
"Zip", "Zip",
str(in_img) str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2758,17 +2776,17 @@ def tiff_rgba16_img(tmp_path_factory, tmp_alpha_png):
def tiff_gray1_img(tmp_path_factory, tmp_gray1_png): def tiff_gray1_img(tmp_path_factory, tmp_gray1_png):
in_img = tmp_path_factory.mktemp("tiff_gray1") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_gray1") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_gray1_png), str(tmp_gray1_png),
"-depth", "-depth",
"1", "1",
"-compress", "-compress",
"Zip", "Zip",
str(in_img) str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2815,17 +2833,17 @@ def tiff_gray1_img(tmp_path_factory, tmp_gray1_png):
def tiff_gray2_img(tmp_path_factory, tmp_gray2_png): def tiff_gray2_img(tmp_path_factory, tmp_gray2_png):
in_img = tmp_path_factory.mktemp("tiff_gray2") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_gray2") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_gray2_png), str(tmp_gray2_png),
"-depth", "-depth",
"2", "2",
"-compress", "-compress",
"Zip", "Zip",
str(in_img) str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2872,17 +2890,17 @@ def tiff_gray2_img(tmp_path_factory, tmp_gray2_png):
def tiff_gray4_img(tmp_path_factory, tmp_gray4_png): def tiff_gray4_img(tmp_path_factory, tmp_gray4_png):
in_img = tmp_path_factory.mktemp("tiff_gray4") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_gray4") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_gray4_png), str(tmp_gray4_png),
"-depth", "-depth",
"4", "4",
"-compress", "-compress",
"Zip", "Zip",
str(in_img) str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2929,17 +2947,17 @@ def tiff_gray4_img(tmp_path_factory, tmp_gray4_png):
def tiff_gray8_img(tmp_path_factory, tmp_gray8_png): def tiff_gray8_img(tmp_path_factory, tmp_gray8_png):
in_img = tmp_path_factory.mktemp("tiff_gray8") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_gray8") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_gray8_png), str(tmp_gray8_png),
"-depth", "-depth",
"8", "8",
"-compress", "-compress",
"Zip", "Zip",
str(in_img) str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -2986,17 +3004,17 @@ def tiff_gray8_img(tmp_path_factory, tmp_gray8_png):
def tiff_gray16_img(tmp_path_factory, tmp_gray16_png): def tiff_gray16_img(tmp_path_factory, tmp_gray16_png):
in_img = tmp_path_factory.mktemp("tiff_gray16") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_gray16") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_gray16_png), str(tmp_gray16_png),
"-depth", "-depth",
"16", "16",
"-compress", "-compress",
"Zip", "Zip",
str(in_img) str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -3043,18 +3061,18 @@ def tiff_gray16_img(tmp_path_factory, tmp_gray16_png):
def tiff_multipage_img(tmp_path_factory, tmp_normal_png, tmp_inverse_png): def tiff_multipage_img(tmp_path_factory, tmp_normal_png, tmp_inverse_png):
in_img = tmp_path_factory.mktemp("tiff_multipage_img") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_multipage_img") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_normal_png), str(tmp_normal_png),
str(tmp_inverse_png), str(tmp_inverse_png),
"-strip", "-strip",
"-compress", "-compress",
"Zip", "Zip",
str(in_img) str(in_img),
] ]
) )
identify = json.loads( identify = json.loads(
subprocess.check_output(["convert", str(in_img) + "[0]", "json:"]) subprocess.check_output(CONVERT + [str(in_img) + "[0]", "json:"])
) )
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
@ -3094,7 +3112,7 @@ def tiff_multipage_img(tmp_path_factory, tmp_normal_png, tmp_inverse_png):
identify[0]["image"].get("properties", {}).get("tiff:photometric") == "RGB" identify[0]["image"].get("properties", {}).get("tiff:photometric") == "RGB"
), str(identify) ), str(identify)
identify = json.loads( identify = json.loads(
subprocess.check_output(["convert", str(in_img) + "[1]", "json:"]) subprocess.check_output(CONVERT + [str(in_img) + "[1]", "json:"])
) )
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
@ -3142,15 +3160,9 @@ def tiff_multipage_img(tmp_path_factory, tmp_normal_png, tmp_inverse_png):
def tiff_palette1_img(tmp_path_factory, tmp_palette1_png): def tiff_palette1_img(tmp_path_factory, tmp_palette1_png):
in_img = tmp_path_factory.mktemp("tiff_palette1_img") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_palette1_img") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT + [str(tmp_palette1_png), "-compress", "Zip", str(in_img)]
"convert",
str(tmp_palette1_png),
"-compress",
"Zip",
str(in_img)
]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -3198,15 +3210,9 @@ def tiff_palette1_img(tmp_path_factory, tmp_palette1_png):
def tiff_palette2_img(tmp_path_factory, tmp_palette2_png): def tiff_palette2_img(tmp_path_factory, tmp_palette2_png):
in_img = tmp_path_factory.mktemp("tiff_palette2_img") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_palette2_img") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT + [str(tmp_palette2_png), "-compress", "Zip", str(in_img)]
"convert",
str(tmp_palette2_png),
"-compress",
"Zip",
str(in_img)
]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -3254,15 +3260,9 @@ def tiff_palette2_img(tmp_path_factory, tmp_palette2_png):
def tiff_palette4_img(tmp_path_factory, tmp_palette4_png): def tiff_palette4_img(tmp_path_factory, tmp_palette4_png):
in_img = tmp_path_factory.mktemp("tiff_palette4_img") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_palette4_img") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT + [str(tmp_palette4_png), "-compress", "Zip", str(in_img)]
"convert",
str(tmp_palette4_png),
"-compress",
"Zip",
str(in_img)
]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -3310,15 +3310,9 @@ def tiff_palette4_img(tmp_path_factory, tmp_palette4_png):
def tiff_palette8_img(tmp_path_factory, tmp_palette8_png): def tiff_palette8_img(tmp_path_factory, tmp_palette8_png):
in_img = tmp_path_factory.mktemp("tiff_palette8_img") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_palette8_img") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT + [str(tmp_palette8_png), "-compress", "Zip", str(in_img)]
"convert",
str(tmp_palette8_png),
"-compress",
"Zip",
str(in_img)
]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -3365,8 +3359,8 @@ def tiff_palette8_img(tmp_path_factory, tmp_palette8_png):
def tiff_ccitt_lsb_m2l_white_img(tmp_path_factory, tmp_gray1_png): def tiff_ccitt_lsb_m2l_white_img(tmp_path_factory, tmp_gray1_png):
in_img = tmp_path_factory.mktemp("tiff_ccitt_lsb_m2l_white_img") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_ccitt_lsb_m2l_white_img") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_gray1_png), str(tmp_gray1_png),
"-compress", "-compress",
"group4", "group4",
@ -3381,7 +3375,7 @@ def tiff_ccitt_lsb_m2l_white_img(tmp_path_factory, tmp_gray1_png):
str(in_img), str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -3446,8 +3440,8 @@ def tiff_ccitt_lsb_m2l_white_img(tmp_path_factory, tmp_gray1_png):
def tiff_ccitt_msb_m2l_white_img(tmp_path_factory, tmp_gray1_png): def tiff_ccitt_msb_m2l_white_img(tmp_path_factory, tmp_gray1_png):
in_img = tmp_path_factory.mktemp("tiff_ccitt_msb_m2l_white_img") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_ccitt_msb_m2l_white_img") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_gray1_png), str(tmp_gray1_png),
"-compress", "-compress",
"group4", "group4",
@ -3462,7 +3456,7 @@ def tiff_ccitt_msb_m2l_white_img(tmp_path_factory, tmp_gray1_png):
str(in_img), str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -3528,8 +3522,8 @@ def tiff_ccitt_msb_m2l_white_img(tmp_path_factory, tmp_gray1_png):
def tiff_ccitt_msb_l2m_white_img(tmp_path_factory, tmp_gray1_png): def tiff_ccitt_msb_l2m_white_img(tmp_path_factory, tmp_gray1_png):
in_img = tmp_path_factory.mktemp("tiff_ccitt_msb_l2m_white_img") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_ccitt_msb_l2m_white_img") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_gray1_png), str(tmp_gray1_png),
"-compress", "-compress",
"group4", "group4",
@ -3544,7 +3538,7 @@ def tiff_ccitt_msb_l2m_white_img(tmp_path_factory, tmp_gray1_png):
str(in_img), str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -3615,8 +3609,8 @@ def tiff_ccitt_lsb_m2l_black_img(tmp_path_factory, tmp_gray1_png):
# or at least 6.9.10-12 from Sep 7, 2018 (for the ImageMagick6 branch) # or at least 6.9.10-12 from Sep 7, 2018 (for the ImageMagick6 branch)
# also see: https://www.imagemagick.org/discourse-server/viewtopic.php?f=1&t=34605 # also see: https://www.imagemagick.org/discourse-server/viewtopic.php?f=1&t=34605
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_gray1_png), str(tmp_gray1_png),
"-compress", "-compress",
"group4", "group4",
@ -3631,7 +3625,7 @@ def tiff_ccitt_lsb_m2l_black_img(tmp_path_factory, tmp_gray1_png):
str(in_img), str(in_img),
] ]
) )
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -3696,8 +3690,8 @@ def tiff_ccitt_lsb_m2l_black_img(tmp_path_factory, tmp_gray1_png):
def tiff_ccitt_nometa1_img(tmp_path_factory, tmp_gray1_png): def tiff_ccitt_nometa1_img(tmp_path_factory, tmp_gray1_png):
in_img = tmp_path_factory.mktemp("tiff_ccitt_nometa1_img") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_ccitt_nometa1_img") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_gray1_png), str(tmp_gray1_png),
"-compress", "-compress",
"group4", "group4",
@ -3721,7 +3715,7 @@ def tiff_ccitt_nometa1_img(tmp_path_factory, tmp_gray1_png):
subprocess.check_call( subprocess.check_call(
["tiffset", "-u", "277", str(in_img)] ["tiffset", "-u", "277", str(in_img)]
) # remove SamplesPerPixel (277) ) # remove SamplesPerPixel (277)
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -3786,8 +3780,8 @@ def tiff_ccitt_nometa1_img(tmp_path_factory, tmp_gray1_png):
def tiff_ccitt_nometa2_img(tmp_path_factory, tmp_gray1_png): def tiff_ccitt_nometa2_img(tmp_path_factory, tmp_gray1_png):
in_img = tmp_path_factory.mktemp("tiff_ccitt_nometa2_img") / "in.tiff" in_img = tmp_path_factory.mktemp("tiff_ccitt_nometa2_img") / "in.tiff"
subprocess.check_call( subprocess.check_call(
[ CONVERT
"convert", + [
str(tmp_gray1_png), str(tmp_gray1_png),
"-compress", "-compress",
"group4", "group4",
@ -3805,7 +3799,7 @@ def tiff_ccitt_nometa2_img(tmp_path_factory, tmp_gray1_png):
subprocess.check_call( subprocess.check_call(
["tiffset", "-u", "278", str(in_img)] ["tiffset", "-u", "278", str(in_img)]
) # remove RowsPerStrip (278) ) # remove RowsPerStrip (278)
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -3864,7 +3858,7 @@ def tiff_ccitt_nometa2_img(tmp_path_factory, tmp_gray1_png):
@pytest.fixture(scope="session") @pytest.fixture(scope="session")
def png_icc_img(tmp_icc_png): def png_icc_img(tmp_icc_png):
in_img = tmp_icc_png in_img = tmp_icc_png
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"])) identify = json.loads(subprocess.check_output(CONVERT + [str(in_img), "json:"]))
assert len(identify) == 1 assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was # somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just # put into an array, here we cater for the older version containing just
@ -5296,7 +5290,7 @@ def test_jpg_rot(tmp_path_factory, jpg_rot_img, jpg_rot_pdf):
) )
jpg_rot_png = tmpdir / "jpg_rot.png" jpg_rot_png = tmpdir / "jpg_rot.png"
subprocess.check_call( subprocess.check_call(
["convert", "-rotate", "90", str(jpg_rot_pnm), str(jpg_rot_png)] CONVERT + ["-rotate", "90", str(jpg_rot_pnm), str(jpg_rot_png)]
) )
jpg_rot_pnm.unlink() jpg_rot_pnm.unlink()
compare_ghostscript(tmpdir, jpg_rot_png, jpg_rot_pdf) compare_ghostscript(tmpdir, jpg_rot_png, jpg_rot_pdf)
@ -5367,6 +5361,7 @@ def test_png_rgba8(tmp_path_factory, png_rgba8_img, png_rgba8_pdf):
tmpdir = tmp_path_factory.mktemp("png_rgba8") tmpdir = tmp_path_factory.mktemp("png_rgba8")
compare_pdfimages_png(tmpdir, png_rgba8_img, png_rgba8_pdf) compare_pdfimages_png(tmpdir, png_rgba8_img, png_rgba8_pdf)
@pytest.mark.skipif( @pytest.mark.skipif(
sys.platform in ["win32"], sys.platform in ["win32"],
reason="test utilities not available on Windows and MacOS", reason="test utilities not available on Windows and MacOS",