1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
# -*- coding: utf-8 -*-
# thumbor imaging service
# https://github.com/thumbor/thumbor/wiki
# Licensed under the MIT license:
# http://www.opensource.org/licenses/mit-license
# Copyright (c) 2011 globo.com thumbor@googlegroups.com
import unicodedata
from io import BytesIO
from os.path import exists
from unittest import skipUnless
from PIL import Image
from preggy import create_assertions
from thumbor.testing import DetectorTestCase as ThumborDetectorTestCase
from thumbor.testing import FilterTestCase as ThumborFilterTestCase
from thumbor.testing import TestCase as ThumborTestCase
from thumbor.testing import get_ssim
try:
from PIL import _avif # noqa pylint: disable=ungrouped-imports
except ImportError:
try:
from pillow_avif import _avif
except ImportError:
_avif = None
try:
from pillow_heif import HeifImagePlugin
except ImportError:
HeifImagePlugin = None
AVIF_AVAILABLE = _avif is not None
HEIF_AVAILABLE = HeifImagePlugin is not None
skip_unless_avif = skipUnless(
AVIF_AVAILABLE,
"AVIF format support not found. Skipping AVIF tests.",
)
skip_unless_heif = skipUnless(
HEIF_AVAILABLE,
"HEIF format support not found. Skipping HEIF tests.",
)
def skip_unless_avif_encoder(codec_name):
return skipUnless(
_avif and _avif.encoder_codec_available(codec_name),
f"{codec_name} encode not available",
)
class TestCase(ThumborTestCase):
pass
class DetectorTestCase(ThumborDetectorTestCase):
pass
class FilterTestCase(ThumborFilterTestCase):
pass
@create_assertions
def to_exist(topic):
return exists(topic)
def normalize_unicode_path(path):
normalized_path = path
for unicode_format in ["NFD", "NFC", "NFKD", "NFKC"]:
normalized_path = unicodedata.normalize(unicode_format, str(path))
if exists(normalized_path):
break
return normalized_path
@create_assertions
def to_be_the_same_as(topic, expected):
topic = normalize_unicode_path(topic)
expected = normalize_unicode_path(expected)
if not exists(topic):
raise AssertionError(f"File at {topic} does not exist")
if not exists(expected):
raise AssertionError(f"File at {expected} does not exist")
topic_image = Image.open(topic)
expected_image = Image.open(expected)
return get_ssim(topic_image, expected_image) > 0.95
@create_assertions
def to_be_similar_to(topic, expected):
topic_image = Image.open(BytesIO(topic))
expected_image = Image.open(BytesIO(expected))
return get_ssim(topic_image, expected_image) > 0.95
@create_assertions
def to_be_webp(topic):
image = Image.open(BytesIO(topic))
return image.format.lower() == "webp"
@create_assertions
def to_be_avif(topic):
image = Image.open(BytesIO(topic))
return image.format.lower() == "avif"
@create_assertions
def to_be_heif(topic):
image = Image.open(BytesIO(topic))
return image.format.lower() == "heif"
@create_assertions
def to_be_png(topic):
image = Image.open(BytesIO(topic))
return image.format.lower() == "png"
@create_assertions
def to_be_gif(topic):
image = Image.open(BytesIO(topic))
return image.format.lower() == "gif"
@create_assertions
def to_be_jpeg(topic):
image = Image.open(BytesIO(topic))
return image.format.lower() == "jpeg"
@create_assertions
def to_be_resized(image):
return image.has_resized_properly()
@create_assertions
def to_be_cropped(image):
return image.has_cropped_properly()
|
