Estou construindo um aplicativo da web em Django. Tenho um modelo que carrega um arquivo, mas não consigo excluí-lo. Aqui está o meu código:

class Song(models.Model):
    name = models.CharField(blank=True, max_length=100)
    author = models.ForeignKey(User, to_field='id', related_name="id_user2")
    song = models.FileField(upload_to='/songs/')
    image = models.ImageField(upload_to='/pictures/', blank=True)
    date_upload = models.DateField(auto_now_add=True)

    def delete(self, *args, **kwargs):
        # You have to prepare what you need before delete the model
        storage, path = self.song.storage, self.song.path
        # Delete the model before the file
        super(Song, self).delete(*args, **kwargs)
        # Delete the file after the model
        storage.delete(path)

Então, em "python manage.py shell", faço o seguinte:

song = Song.objects.get(pk=1)
song.delete()

Ele exclui do banco de dados, mas não o arquivo no servidor. O que mais posso tentar?

Obrigado!

Antes do Django 1.3, o arquivo era excluído do sistema de arquivos automaticamente quando você excluía a instância de modelo correspondente. Você provavelmente está usando uma versão mais recente do Django, então terá que implementar a exclusão do arquivo do sistema de arquivos por conta própria.

Você pode fazer isso de algumas maneiras, uma das quais é usando um pre_deleteoupost_delete sinal .

Exemplo

Meu método de escolha atualmente é uma mistura de post_deleteepre_save sinais, o que faz com que arquivos obsoletos sejam excluídos sempre que os modelos correspondentes forem excluídos ou seus arquivos alterados.

Com base em um MediaFilemodelo hipotético :

import os
import uuid

from django.db import models
from django.dispatch import receiver
from django.utils.translation import ugettext_lazy as _


class MediaFile(models.Model):
    file = models.FileField(_("file"),
        upload_to=lambda instance, filename: str(uuid.uuid4()))


# These two auto-delete files from filesystem when they are unneeded:

@receiver(models.signals.post_delete, sender=MediaFile)
def auto_delete_file_on_delete(sender, instance, **kwargs):
    """
    Deletes file from filesystem
    when corresponding `MediaFile` object is deleted.
    """
    if instance.file:
        if os.path.isfile(instance.file.path):
            os.remove(instance.file.path)

@receiver(models.signals.pre_save, sender=MediaFile)
def auto_delete_file_on_change(sender, instance, **kwargs):
    """
    Deletes old file from filesystem
    when corresponding `MediaFile` object is updated
    with new file.
    """
    if not instance.pk:
        return False

    try:
        old_file = MediaFile.objects.get(pk=instance.pk).file
    except MediaFile.DoesNotExist:
        return False

    new_file = instance.file
    if not old_file == new_file:
        if os.path.isfile(old_file.path):
            os.remove(old_file.path)

• Caso extremo: se o seu aplicativo carrega um novo arquivo e aponta a instância do modelo para o novo arquivo sem chamar save()(por exemplo, atualizando em massa a QuerySet), o arquivo antigo continuará parado porque os sinais não serão executados. Isso não acontece se você usar métodos convencionais de tratamento de arquivos.
• Acho que um dos aplicativos que construí tem esse código em produção, mas use por sua própria conta e risco.
• Estilo de codificação: este exemplo usa filecomo nome de campo, o que não é um bom estilo porque entra em conflito com ofile identificador de objeto .

Veja também

• FieldFile.delete()na referência de campo do modelo Django 1.11 (observe que ele descreve a FieldFileclasse, mas você chamaria .delete()diretamente no campo: FileFieldproxies de instância para o correspondenteFieldFile instância , e você acessa seus métodos como se fossem de campo)

  Observe que quando um modelo é excluído, os arquivos relacionados não são excluídos. Se você precisa limpar arquivos órfãos, você mesmo precisa lidar com isso (por exemplo, com um comando de gerenciamento personalizado que pode ser executado manualmente ou programado para ser executado periodicamente via, por exemplo, cron).

• Por que o Django não deleta arquivos automaticamente: entrada nas notas de lançamento do Django 1.3

  Em versões anteriores do Django, quando uma instância de modelo contendo um FileFieldera excluída, FileFieldassumia a responsabilidade de também excluir o arquivo do armazenamento de backend. Isso abriu a porta para vários cenários de perda de dados, incluindo transações revertidas e campos em diferentes modelos que fazem referência ao mesmo arquivo. No Django 1.3, quando um modelo é excluído da FileField's delete()método não será chamado. Se você precisa de limpeza de arquivos órfãos, você precisa lidar com isso sozinho (por exemplo, com um comando de gerenciamento personalizado que pode ser executado manualmente ou programado para ser executado periodicamente via, por exemplo, cron).

• Exemplo de uso de pre_deleteapenas um sinal

Tente django-cleanup , ele invoca automaticamente o método delete em FileField quando você remove o modelo.

pip install django-cleanup

settings.py

INSTALLED_APPS = (
     ...
    'django_cleanup', # should go after your apps
)

Você pode excluir o arquivo do sistema de arquivos com o .deletemétodo de chamada do campo de arquivo mostrado abaixo com Django> = 1.10:

obj = Song.objects.get(pk=1)
obj.song.delete()

Você também pode simplesmente sobrescrever a função de exclusão do modelo para verificar se o arquivo existe e excluí-lo antes de chamar a função super.

import os

class Excel(models.Model):
    upload_file = models.FileField(upload_to='/excels/', blank =True)   
    uploaded_on = models.DateTimeField(editable=False)


    def delete(self,*args,**kwargs):
        if os.path.isfile(self.upload_file.path):
            os.remove(self.upload_file.path)

        super(Excel, self).delete(*args,**kwargs)

Solução Django 2.x:

É muito fácil lidar com a exclusão de arquivos no Django 2 . Eu tentei seguir a solução usando Django 2 e SFTP Storage e também FTP STORAGE, e tenho certeza de que funcionará com qualquer outro gerenciador de armazenamento que implementou o deletemétodo. ( deletemétodo é um dosstorage métodos abstratos).

Substitua o deletemétodo do modelo de forma que a instância exclua seus FileFields antes de excluir a si mesma:

class Song(models.Model):
    name = models.CharField(blank=True, max_length=100)
    author = models.ForeignKey(User, to_field='id', related_name="id_user2")
    song = models.FileField(upload_to='/songs/')
    image = models.ImageField(upload_to='/pictures/', blank=True)
    date_upload = models.DateField(auto_now_add=True)

    def delete(self, using=None, keep_parents=False):
        self.song.storage.delete(self.song.name)
        self.image.storage.delete(self.song.name)
        super().delete()

Funciona muito fácil para mim. Se você quiser verificar se o arquivo existe antes da exclusão, você pode usar storage.exists. por exemplo self.song.storage.exists(self.song.name), retornará um booleanrepresentando se a música existe. Então, ficará assim:

def delete(self, using=None, keep_parents=False):
    # assuming that you use same storage for all files in this model:
    storage = self.song.storage

    if storage.exists(self.song.name):
        storage.delete(self.song.name)

    if storage.exists(self.image.name):
        storage.delete(self.song.name)

    super().delete()

EDITAR (além):

Como @HeyMan mencionou, com esta solução, chamar Song.objects.all().delete()não exclui arquivos! Isso está acontecendo porque Song.objects.all().delete()está executando a consulta de exclusão do Default Manager . Portanto, se você deseja excluir arquivos de um modelo usando objectsmétodos, deve escrever e usar um gerenciador personalizado (apenas para substituir sua consulta de exclusão):

class CustomManager(models.Manager):
    def delete(self):
        for obj in self.get_queryset():
            obj.delete()

e para atribuir o CustomManagerao modelo, você deve rubricar objectsem seu modelo:

class Song(models.Model):
    name = models.CharField(blank=True, max_length=100)
    author = models.ForeignKey(User, to_field='id', related_name="id_user2")
    song = models.FileField(upload_to='/songs/')
    image = models.ImageField(upload_to='/pictures/', blank=True)
    date_upload = models.DateField(auto_now_add=True)
    
    objects = CustomManager() # just add this line of code inside of your model

    def delete(self, using=None, keep_parents=False):
        self.song.storage.delete(self.song.name)
        self.image.storage.delete(self.song.name)
        super().delete()

Agora você pode usar .delete()no final de quaisquer objectssubconsultas. Eu escrevi o mais simples CustomManager, mas você pode fazer melhor retornando algo sobre os objetos que você excluiu ou o que quiser.

Este é um aplicativo que removerá arquivos antigos sempre que o modelo for excluído ou um novo arquivo for carregado: django-smartfields

from django.db import models
from smartfields import fields

class Song(models.Model):
    song = fields.FileField(upload_to='/songs/')
    image = fields.ImageField(upload_to='/pictures/', blank=True)

@Anton Strogonoff

Estou faltando alguma coisa no código quando um arquivo muda, se criar um novo arquivo gera um erro, pois é um arquivo novo e não encontrou um caminho. Modifiquei o código de função e adicionei uma frase try / except e funciona bem.

@receiver(models.signals.pre_save, sender=MediaFile)
def auto_delete_file_on_change(sender, instance, **kwargs):
    """Deletes file from filesystem
    when corresponding `MediaFile` object is changed.
    """
    if not instance.pk:
        return False

    try:
        old_file = MediaFile.objects.get(pk=instance.pk).file
    except MediaFile.DoesNotExist:
        return False

    new_file = instance.file
    if not old_file == new_file:
        try:
            if os.path.isfile(old_file.path):
                os.remove(old_file.path)
        except Exception:
            return False

Este código será executado toda vez que eu carregar uma nova imagem (campo de logotipo) e verificar se já existe um logotipo, feche-o e remova-o do disco. O mesmo procedimento pode ser feito na função de receptor. Espero que isto ajude.

 #  Returns the file path with a folder named by the company under /media/uploads
    def logo_file_path(instance, filename):
        company_instance = Company.objects.get(pk=instance.pk)
        if company_instance.logo:
            logo = company_instance.logo
            if logo.file:
                if os.path.isfile(logo.path):
                    logo.file.close()
                    os.remove(logo.path)

        return 'uploads/{0}/{1}'.format(instance.name.lower(), filename)


    class Company(models.Model):
        name = models.CharField(_("Company"), null=False, blank=False, unique=True, max_length=100) 
        logo = models.ImageField(upload_to=logo_file_path, default='')