WEBP is an image compression format that was introduced by Google in 2010. Its main advantage is its low size without visible loss of quality compared to formats such as JPEG or PNG. Therefore, it is quite logical to use this format for storing images on the site, especially if you do not need to store the original images on the site.
After a long search, I still did not find a ready-made and simple solution that would support converting images to WEBP format on the fly.
Therefore, I decided to write my own version, which eventually consists of a couple of dozen lines and is as simple as a wooden board.
Implementation
The whole implementation consists of two parts:
- WEBPFieldFile - a class derived from ImageFieldFile, which saves a file with automatic conversion to WEBP format.
- WEBPField - ImageField class that uses WEBPFieldFile instead of ImageFieldFile
And all this is located in one file fields.py.
To work with images, you need the Pillow library. So let's install it. However, even just to use ImageField fields, you will need this library.
pip install Pillow
fields.py
Create fields.py files in your application and add the following code to it
# -*- coding: utf-8 -*-
import io
from PIL import Image
from django.core.files.base import ContentFile
from django.db import models
from django.db.models.fields.files import ImageFieldFile
class WEBPFieldFile(ImageFieldFile):
def save(self, name, content, save=True):
content.file.seek(0)
image = Image.open(content.file)
image_bytes = io.BytesIO()
image.save(fp=image_bytes, format="WEBP")
image_content_file = ContentFile(content=image_bytes.getvalue())
super().save(name, image_content_file, save)
class WEBPField(models.ImageField):
attr_class = WEBPFieldFile
As you can see, in this code, in the WEBPFieldFile class, the save() method is overridden, which receives the name and contents of the file to be saved as an input argument, converts the contents of the file to the WEBP format, and then saves the file to disk. And the WEBPField class is exactly the same as ImageField , with the only difference being that it uses a modified variant of the class for image processing.
models.py
Now let's use the new image field in our photo model.
# -*- coding: utf-8 -*-
import os
import uuid
from django.conf import settings
from django.db import models
from django.utils.translation import gettext_lazy as _
from photo.fields import WEBPField
def image_folder(instance, filename):
return 'photos/{}.webp'.format(uuid.uuid4().hex)
class Photo(models.Model):
user = models.ForeignKey(to=settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
height = models.IntegerField(verbose_name=_('Height'), default=0, blank=True, null=True)
width = models.IntegerField(verbose_name=_('Width'), default=0, blank=True, null=True)
image = WEBPField(
verbose_name=_('Image'),
upload_to=image_folder,
height_field='height',
width_field='width'
)
As you can see, using this WEBPField field is no different from using the standard ImageField field.
And as a bonus, in this code, in the image_folder function, I added the generation of a random unique file name using uuid .
Очень годно!