[Django]-ImageField overwrite image file with same name

class OverwriteStorage(get_storage_class()):
    
    def _save(self, name, content):
        self.delete(name)
        return super(OverwriteStorage, self)._save(name, content)

    def get_available_name(self, name, max_length=None):
        return name

You can write storage class even better this way:

class OverwriteStorage(FileSystemStorage):

    def get_available_name(self, name, max_length=None):
        self.delete(name)
        return name

Basically this will overwrite the function get_available_name to delete the file if already exists and return the name of the file already storaged

Just refference your model image field, delete it and save again.

model.image.delete()
model.image.save()

ahem… it may sound unorthodox, but my solution, at present, is to check&remove the existing file within the callback I already use for providing the name of the uploaded file. In models.py:

import os
from django.conf import settings

def avatar_file_name(instance, filename):
    imgname = 'whatever.xyz'
    fullname = os.path.join(settings.MEDIA_ROOT, imgname)
    if os.path.exists(fullname):
        os.remove(fullname)
    return imgname
class UserProfile(models.Model):
    avatar = models.ImageField(upload_to=avatar_file_name,
                                default=IMGNOPIC, verbose_name='avatar')

For Django 1.10 I found I had to modify the top answer to include the max_length argument in the Function:

from django.core.files.storage import FileSystemStorage
import os

class OverwriteStorage(FileSystemStorage):
def get_available_name(self, name, max_length=None):
    if self.exists(name):
        os.remove(os.path.join(settings.MEDIA_ROOT, name))
    return name

You can try to define your own Filesystemstorage and override the default get_availbale_name method.

from django.core.files.storage import FileSystemStorage 
import os

class MyFileSystemStorage(FileSystemStorage):
    def get_available_name(self, name):
        if os.path.exists(self.path(name)):
            os.remove(self.path(name))
        return name

For your image you could define a fs like this:

fs = MyFileSystemStorage(base_url='/your/url/', 
     location='/var/www/vhosts/domain/file/path/')
avatar = models.ImageField(upload_to=upload_avatar, storage=fs)

Hope this helps.

I tried the solutions mentioned here. But it seem not to work at django 1.10. It would raise the following error somewhere at the admin’s template:

url() missing 1 required positional argument: 'name'

So I came up with my own solution, which consists on creating a pre_save signal that tries to get the instance from the database before it’s saved and remove it’s file path:

from django.db.models.signals import pre_save


@receiver(pre_save, sender=Attachment)
def attachment_file_update(sender, **kwargs):
    attachment = kwargs['instance']
    # As it was not yet saved, we get the instance from DB with 
    # the old file name to delete it. Which won't happen if it's a new instance
    if attachment.id:
        attachment = Attachment.objects.get(pk=attachment.id)
        storage, path = attachment.its_file.storage, attachment.its_file.path
        storage.delete(path)

in Django 4.2 You can try to define your own Filesystemstorage and override the default exists method.

class OverwriteStorage(FileSystemStorage):
    def exists(self, name):
        exists = os.path.lexists(self.path(name))
        if exists:
            os.remove(os.path.join(settings.MEDIA_ROOT, name))
        return exists

and define your model with a new filesystem class

class IMGUpload(TimeStampMixin):
    file = models.FileField(blank=False, null=False,
                            storage=OverwriteStorage(),
                            upload_to=get_uploaded_file_path,
                            validators=[validate_file_extension])