Handling Image Resizing with S3 Storage in Django

The issue you're experiencing is related to the order of operations in your save method. With S3BotoStorage, both the original file and the resized file are being saved because you're calling super().save() before resizing the image.

The Problem

When you call super().save(), Django saves the original file to S3. Then when you resize the image and call imageField.save(), it saves the resized version as a new file, resulting in both files being stored in your S3 bucket.

Solution

You need to resize the image before the model is saved to the database. Here's how to modify your code:

PYTHONCopied
def save(self, *args, **kwargs):
    # Check if this is an existing object
    if self.pk:
        try:
            this_object = MyModel.objects.get(pk=self.pk)
            # Check if the background field has changed
            if self.background and this_object.background != self.background:
                # Resize the image before saving the model
                self.resize_image(self.background, (1200, 1200))
        except MyModel.DoesNotExist:
            # This is a new object, resize if background exists
            if self.background:
                self.resize_image(self.background, (1200, 1200))
    else:
        # This is a new object, resize if background exists
        if self.background:
            self.resize_image(self.background, (1200, 1200))
    
    # Now save the model with the resized image
    super(MyModel, self).save(*args, **kwargs)

Alternative Approach Using a Custom Storage Class

Another approach is to create a custom storage class that handles the resizing before saving to S3:

PYTHONCopied
from django.core.files.storage import Storage
from io import BytesIO
from PIL import Image
from django.core.files.base import ContentFile

class ResizingStorage(Storage):
    def __init__(self, base_storage):
        self.storage = base_storage
        
    def _save(self, name, content):
        # Check if this is an image file
        if name.lower().endswith(('.png', '.jpg', '.jpeg', '.gif')):
            # Open the image
            img = Image.open(content)
            # Convert to RGB if needed
            img = img.convert('RGB')
            
            # Resize logic here (similar to your mixin)
            # ...
            
            # Save as JPEG
            output = BytesIO()
            img.save(output, format='JPEG')
            output.seek(0)
            
            # Change file extension to jpg
            name = name.rsplit('.', 1)[0] + '.jpg'
            
            # Create a new content file
            content = ContentFile(output.read())
            
        # Save using the base storage
        return self.storage._save(name, content)
    
    # Delegate all other methods to the base storage
    def __getattr__(self, name):
        return getattr(self.storage, name)

Then in your model:

PYTHONCopied
from django.db import models
from storages.backends.s3boto3 import S3Boto3Storage
from .storage import ResizingStorage

# Create a resizing storage using S3Boto3Storage as the base
s3_storage = S3Boto3Storage()
resizing_storage = ResizingStorage(s3_storage)

class MyModel(models.Model):
    background = models.FileField(upload_to='backgrounds/', storage=resizing_storage)
    # ...

Important Note

Remember that the file is saved as part of saving the model in the database, so the actual file name used on disk cannot be relied on until after the model has been saved. This is why it's important to handle the resizing before the model is saved to ensure only one file is stored.

The first approach (modifying your save method) is simpler and should work well for your use case.