def make_image(data: Optional[bytes]) -> io.BytesIO:
image_buffer = None
if data:
image_buffer = io.BytesIO(data)
try:
Image.from_blob(image_buffer.getbuffer())
except UnrecognizedImageError:
image_buffer = None
if not image_buffer:
broken_img_path = pathlib.Path(__file__).parent / "image-broken.png"
image_buffer = io.BytesIO(broken_img_path.read_bytes())
return image_buffer
def make_image(data):
image_buffer = None
if data:
image_buffer = io.BytesIO(data)
try:
Image.from_blob(image_buffer.getbuffer())
except (UnrecognizedImageError, UnexpectedEndOfFileError,
InvalidImageStreamError):
image_buffer = None
if not image_buffer:
broken_img = load_inline_image(IMG_BLANK)
image_buffer = io.BytesIO(broken_img)
return image_buffer
def it_can_construct_from_an_image_path(self, from_path_fixture):
image_path, _from_stream_, stream_, blob, filename, image_ = (
from_path_fixture
)
image = Image.from_file(image_path)
_from_stream_.assert_called_once_with(stream_, blob, filename)
assert image is image_
def it_can_construct_from_an_image_blob(self, blob_, BytesIO_,
_from_stream_, stream_, image_):
image = Image.from_blob(blob_)
BytesIO_.assert_called_once_with(blob_)
_from_stream_.assert_called_once_with(stream_, blob_)
assert image is image_
def parse_image(file, guid):
if file.startswith("http://") or file.startswith("https://"):
response = requests.get(file)
image = Image.open(BytesIO(response.content))
else:
image = Image.open(file)
iwidth, iheight = image.size
f_format = get_extension(file)
with connection.cursor() as cursor:
cursor.execute(
"""
INSERT INTO image_metadata (
file_guid, width, height, file_format
) VALUES (
%s, %s, %s, %s
)
""", [guid, iwidth, iheight, f_format])
return True
def replace_part(items, raw_items):
for k, p in items:
if path.basename(p.partname) == from_pic:
image = Image.from_file(to_pic)
partname = path.join(path.dirname(p.partname), image.filename)
partname = PackURI(partname)
img_part = ImagePart.from_image(image, partname)
raw_items.__setitem__(k, img_part)
break
def get_or_add_image_part(self, image_descriptor):
"""
Return an |ImagePart| instance containing the image identified by
*image_descriptor*, newly created if a matching one is not present in
the collection.
"""
image = Image.from_file(image_descriptor)
matching_image_part = self._get_by_sha1(image.sha1)
if matching_image_part is not None:
return matching_image_part
return self._add_image_part(image)
def get_or_add_image_part(self, image_descriptor):
"""
Return an |ImagePart| instance containing the image identified by
*image_descriptor*, newly created if a matching one is not present in
the collection.
"""
image = Image.from_file(image_descriptor)
matching_image_part = self._get_by_sha1(image.sha1)
if matching_image_part is not None:
return matching_image_part
return self._add_image_part(image)
def it_can_construct_from_an_image_stream(self, from_stream_fixture):
stream_, blob_, filename_in = from_stream_fixture[:3]
_ImageHeaderFactory_, image_header_ = from_stream_fixture[3:5]
Image__init_, filename_out = from_stream_fixture[5:]
image = Image._from_stream(stream_, blob_, filename_in)
_ImageHeaderFactory_.assert_called_once_with(stream_)
Image__init_.assert_called_once_with(ANY, blob_, filename_out,
image_header_)
assert isinstance(image, Image)
def it_correctly_characterizes_known_images(self, known_image_fixture):
image_path, characteristics = known_image_fixture
ext, content_type, px_width, px_height, horz_dpi, vert_dpi = (
characteristics)
with open(test_file(image_path), 'rb') as stream:
image = Image.from_file(stream)
assert image.content_type == content_type
assert image.ext == ext
assert image.px_width == px_width
assert image.px_height == px_height
assert image.horz_dpi == horz_dpi
assert image.vert_dpi == vert_dpi
def image_size(
image_buffer: io.BytesIO,
width_px: Optional[int] = None,
height_px: Optional[int] = None,
) -> Dict[str, int]:
"""
Compute width and height to feed python-docx so that image is contained in the page
and respects width_px and height_px.
Return:
Empty: No resize
Single dimension (width or height): image ratio is expected to be maintained
Two dimensions (width and height): image should be resized to dimensions
"""
image = Image.from_blob(image_buffer.getbuffer())
# Normalize image size to inches.
# - Without a specified pixel size, images are their actual pixel size, so that
# images of the same pixel size appear the same size in the document, regardless
# of their resolution.
# - With a specified pixel size, images should take the specified size, regardless
# of their resolution.
if height_px is None:
height = image.px_height / image.vert_dpi
else:
height = height_px / DEFAULT_DPI
if width_px is None:
width = image.px_width / image.horz_dpi
else:
width = width_px / DEFAULT_DPI
height = Inches(height)
width = Inches(width)
size = {}
if width > USABLE_WIDTH:
new_height = round(image.px_height / (image.px_width / USABLE_WIDTH))
if new_height > USABLE_HEIGHT:
size["height"] = USABLE_HEIGHT
else:
size["width"] = USABLE_WIDTH
elif height > USABLE_HEIGHT:
new_width = round(image.px_width / (image.px_height / USABLE_HEIGHT))
if new_width > USABLE_WIDTH:
size["width"] = USABLE_WIDTH
else:
size["height"] = USABLE_HEIGHT
else:
if width_px is not None:
size["width"] = width
if height_px is not None:
size["height"] = height
return size
def it_correctly_characterizes_known_images(self, known_image_fixture):
image_path, characteristics = known_image_fixture
ext, content_type, px_width, px_height, horz_dpi, vert_dpi = (
characteristics
)
with open(test_file(image_path), 'rb') as stream:
image = Image.from_file(stream)
assert image.content_type == content_type
assert image.ext == ext
assert image.px_width == px_width
assert image.px_height == px_height
assert image.horz_dpi == horz_dpi
assert image.vert_dpi == vert_dpi
def it_can_construct_from_an_image_stream(self, from_stream_fixture):
# fixture ----------------------
stream_, blob_, filename_in = from_stream_fixture[:3]
_ImageHeaderFactory_, image_header_ = from_stream_fixture[3:5]
Image__init_, filename_out = from_stream_fixture[5:]
# exercise ---------------------
image = Image._from_stream(stream_, blob_, filename_in)
# verify -----------------------
_ImageHeaderFactory_.assert_called_once_with(stream_)
Image__init_.assert_called_once_with(
blob_, filename_out, image_header_
)
assert isinstance(image, Image)
def _get_parts(self):
parts = []
pkg_meta = self._get_pkg_meta()
for part_name, content_type in pkg_meta:
blob = self.blob_for(part_name)
if 'image' in content_type:
image = Image(blob, None, None, content_type)
part = ImagePart.from_image(image, PackURI(part_name))
else:
part = XmlPart.load(PackURI(part_name), content_type, blob,
None)
parts.append(part)
return parts
def dimensions_fixture(self, request):
image_file_path = test_file('monty-truth.png')
image = Image.from_file(image_file_path)
expected_cx, expected_cy = 1905000, 2717800
# case 1: image part is loaded by PartFactory w/no Image inst
if request.param == 'loaded':
partname = PackURI('/word/media/image1.png')
content_type = CT.PNG
image_part = ImagePart.load(partname, content_type, image.blob,
None)
# case 2: image part is newly created from image file
elif request.param == 'new':
image_part = ImagePart.from_image(image, None)
return image_part, expected_cx, expected_cy
def dimensions_fixture(self, request):
image_file_path = test_file('monty-truth.png')
image = Image.from_file(image_file_path)
expected_cx, expected_cy = 1905000, 2717800
# case 1: image part is loaded by PartFactory w/no Image inst
if request.param == 'loaded':
partname = PackURI('/word/media/image1.png')
content_type = CT.PNG
image_part = ImagePart.load(
partname, content_type, image.blob, None
)
# case 2: image part is newly created from image file
elif request.param == 'new':
image_part = ImagePart.from_image(image, None)
return image_part, expected_cx, expected_cy
def image_size(
image_buffer: io.BytesIO,
width_px: Optional[int] = None,
height_px: Optional[int] = None,
) -> Dict[str, int]:
"""
Compute width and height to feed python-docx so that image is contained in the page
and respects width_px and height_px.
Return:
Empty: No resize
Single dimension (width or height): image ratio is expected to be maintained
Two dimensions (width and height): image should be resized to dimensions
"""
image = Image.from_blob(image_buffer.getbuffer())
height = image.px_height if height_px is None else height_px
width = image.px_width if width_px is None else width_px
height = Inches(height / image.vert_dpi)
width = Inches(width / image.horz_dpi)
size = {}
if width > USABLE_WIDTH:
new_height = round(image.px_height / (image.px_width / USABLE_WIDTH))
if new_height > USABLE_HEIGHT:
size["height"] = USABLE_HEIGHT
else:
size["width"] = USABLE_WIDTH
elif height > USABLE_HEIGHT:
new_width = round(image.px_width / (image.px_height / USABLE_HEIGHT))
if new_width > USABLE_WIDTH:
size["width"] = USABLE_WIDTH
else:
size["height"] = USABLE_HEIGHT
else:
if width_px is not None:
size["width"] = width
if height_px is not None:
size["height"] = height
return size
def it_knows_the_image_filename_extension(self):
image = Image(None, 'foobar.png', None)
assert image.ext == 'png'
def image(self):
if self._image is None:
self._image = Image.from_blob(self.blob)
return self._image
def image(self):
if self._image is None:
self._image = Image.from_blob(self.blob)
return self._image
def it_can_construct_from_an_image_blob(self, from_blob_fixture):
blob_, BytesIO_, _from_stream_, stream_, image_ = from_blob_fixture
image = Image.from_blob(blob_)
BytesIO_.assert_called_once_with(blob_)
_from_stream_.assert_called_once_with(stream_, blob_)
assert image is image_
def it_can_construct_from_an_image_file_like(self, from_filelike_fixture):
image_stream, _from_stream_, blob, image_ = from_filelike_fixture
image = Image.from_file(image_stream)
_from_stream_.assert_called_once_with(image_stream, blob, None)
assert image is image_
def it_knows_the_image_filename(self):
filename = 'foobar.png'
image = Image(None, filename, None)
assert image.filename == filename
def it_knows_the_horz_and_vert_dpi_of_the_image(self, dpi_fixture):
image_header_, horz_dpi, vert_dpi = dpi_fixture
image = Image(None, None, image_header_)
assert image.horz_dpi == horz_dpi
assert image.vert_dpi == vert_dpi
def it_knows_the_image_px_dimensions(self, dimensions_fixture):
image_header_, px_width, px_height = dimensions_fixture
image = Image(None, None, image_header_)
assert image.px_width == px_width
assert image.px_height == px_height
def it_knows_the_image_content_type(self, content_type_fixture):
image_header_, content_type = content_type_fixture
image = Image(None, None, image_header_)
assert image.content_type == content_type
def it_provides_access_to_the_image_blob(self):
blob = b'foobar'
image = Image(blob, None, None)
assert image.blob == blob
def it_can_construct_from_an_image_file_like(self, from_filelike_fixture):
image_stream, _from_stream_, blob, image_ = from_filelike_fixture
image = Image.from_file(image_stream)
_from_stream_.assert_called_once_with(image_stream, blob, None)
assert image is image_
def size_fixture(self, image_header_):
image_header_.px_width, image_header_.px_height = 150, 75
image_header_.horz_dpi, image_header_.vert_dpi = 72, 200
image = Image(None, None, image_header_)
return image, 1905000, 342900
def scale_fixture(self, request, width_prop_, height_prop_):
width, height, scaled_width, scaled_height = request.param
width_prop_.return_value = Emu(1000)
height_prop_.return_value = Emu(2000)
image = Image(None, None, None)
return image, width, height, (scaled_width, scaled_height)
def it_knows_the_sha1_of_its_image(self):
blob = b'fO0Bar'
image = Image(blob, None, None)
assert image.sha1 == '4921e7002ddfba690a937d54bda226a7b8bdeb68'
def when_construct_image_using_path(context):
context.image = Image.from_file(context.image_path)
