When saving, how can you check if a field has changed?

When saving, how can you check if a field has changed?

In my model I have :
class Alias(MyBaseModel):
    remote_image = models.URLField(max_length=500, null=True, help_text="A URL that is downloaded and cached for the image. Only
 used when the alias is made")
    image = models.ImageField(upload_to='alias', default='alias-default.png', help_text="An image representing the alias")

    def save(self, *args, **kw):
        if (not self.image or self.image.name == 'alias-default.png') and self.remote_image :
            try :
                data = utils.fetch(self.remote_image)
                image = StringIO.StringIO(data)
                image = Image.open(image)
                buf = StringIO.StringIO()
                image.save(buf, format='PNG')
                self.image.save(hashlib.md5(self.string_id).hexdigest() + ".png", ContentFile(buf.getvalue()))
            except IOError :

Which works great for the first time the remote_image changes. 
How can I fetch a new image when someone has modified the remote_image on the alias? And secondly, is there a better way to cache a remote image?


Answer 1:

Essentially, you want to override the __init__ method of models.Model so that you keep a copy of the original value. This makes it so that you don’t have to do another DB lookup (which is always a good thing).

class Person(models.Model):
    name = models.CharField()

    __original_name = None

    def __init__(self, *args, **kwargs):
        super(Person, self).__init__(*args, **kwargs)
        self.__original_name = self.name

    def save(self, force_insert=False, force_update=False, *args, **kwargs):
        if self.name != self.__original_name:
            # name changed - do something here

        super(Person, self).save(force_insert, force_update, *args, **kwargs)
        self.__original_name = self.name

Answer 2:

I use following mixin:

from django.forms.models import model_to_dict

class ModelDiffMixin(object):
    A model mixin that tracks model fields' values and provide some useful api
    to know what fields have been changed.

    def __init__(self, *args, **kwargs):
        super(ModelDiffMixin, self).__init__(*args, **kwargs)
        self.__initial = self._dict

    def diff(self):
        d1 = self.__initial
        d2 = self._dict
        diffs = [(k, (v, d2[k])) for k, v in d1.items() if v != d2[k]]
        return dict(diffs)

    def has_changed(self):
        return bool(self.diff)

    def changed_fields(self):
        return self.diff.keys()

    def get_field_diff(self, field_name):
        Returns a diff for field if it's changed and None otherwise.
        return self.diff.get(field_name, None)

    def save(self, *args, **kwargs):
        Saves model and set initial state.
        super(ModelDiffMixin, self).save(*args, **kwargs)
        self.__initial = self._dict

    def _dict(self):
        return model_to_dict(self, fields=[field.name for field in


>>> p = Place()
>>> p.has_changed
>>> p.changed_fields
>>> p.rank = 42
>>> p.has_changed
>>> p.changed_fields
>>> p.diff
{'rank': (0, 42)}
>>> p.categories = [1, 3, 5]
>>> p.diff
{'categories': (None, [1, 3, 5]), 'rank': (0, 42)}
>>> p.get_field_diff('categories')
(None, [1, 3, 5])
>>> p.get_field_diff('rank')
(0, 42)


Please note that this solution works well in context of current request only. Thus it’s suitable primarily for simple cases. In concurrent environment where multiple requests can manipulate the same model instance at the same time, you definitely need a different approach.

Answer 3:

Best way is with a pre_save signal. May not have been an option back in ’09 when this question was asked and answered, but anyone seeing this today should do it this way:

@receiver(pre_save, sender=MyModel)
def do_something_if_changed(sender, instance, **kwargs):
        obj = sender.objects.get(pk=instance.pk)
    except sender.DoesNotExist:
        pass # Object is new, so field hasn't technically changed, but you may want to do something else here.
        if not obj.some_field == instance.some_field: # Field has changed
            # do something

Answer 4:

And now for direct answer: one way to check if the value for the field has changed is to fetch original data from database before saving instance. Consider this example:

class MyModel(models.Model):
    f1 = models.CharField(max_length=1)

    def save(self, *args, **kw):
        if self.pk is not None:
            orig = MyModel.objects.get(pk=self.pk)
            if orig.f1 != self.f1:
                print 'f1 changed'
        super(MyModel, self).save(*args, **kw)

The same thing applies when working with a form. You can detect it at the clean or save method of a ModelForm:

class MyModelForm(forms.ModelForm):

    def clean(self):
        cleaned_data = super(ProjectForm, self).clean()
        #if self.has_changed():  # new instance or existing updated (form has data to save)
        if self.instance.pk is not None:  # new instance only
            if self.instance.f1 != cleaned_data['f1']:
                print 'f1 changed'
        return cleaned_data

    class Meta:
        model = MyModel
        exclude = []

Answer 5:

Since Django 1.8 released, you can use from_db classmethod to cache old value of remote_image. Then in save method you can compare old and new value of field to check if the value has changed.

def from_db(cls, db, field_names, values):
    new = super(Alias, cls).from_db(db, field_names, values)
    # cache value went from the base
    new._loaded_remote_image = values[field_names.index('remote_image')]
    return new

def save(self, force_insert=False, force_update=False, using=None,
    if (self._state.adding and self.remote_image) or \
        (not self._state.adding and self._loaded_remote_image != self.remote_image):
        # If it is first save and there is no cached remote_image but there is new one, 
        # or the value of remote_image has changed - do your stuff!

Answer 6:

Note that field change tracking is available in django-model-utils.


Answer 7:

If you are using a form, you can use Form’s changed_data (docs):

class AliasForm(ModelForm):

    def save(self, commit=True):
        if 'remote_image' in self.changed_data:
            # do things
            remote_image = self.cleaned_data['remote_image']
        super(AliasForm, self).save(commit)

    class Meta:
        model = Alias

Answer 8:

I am a bit late to the party but I found this solution also:
Django Dirty Fields

Answer 9:

As of Django 1.8, there’s the from_db method, as Serge mentions. In fact, the Django docs include this specific use case as an example:


Below is an example showing how to record the initial values of fields that are loaded from the database

Answer 10:

You can use django-model-changes to do this without an additional database lookup:

from django.dispatch import receiver
from django_model_changes import ChangesMixin

class Alias(ChangesMixin, MyBaseModel):
   # your model

@receiver(pre_save, sender=Alias)
def do_something_if_changed(sender, instance, **kwargs):
    if 'remote_image' in instance.changes():
        # do something

Answer 11:

Another late answer, but if you’re just trying to see if a new file has been uploaded to a file field, try this: (adapted from Christopher Adams’s comment on the link http://zmsmith.com/2010/05/django-check-if-a-field-has-changed/ in zach’s comment here)

Updated link: https://web.archive.org/web/20130101010327/http://zmsmith.com:80/2010/05/django-check-if-a-field-has-changed/

def save(self, *args, **kw):
    from django.core.files.uploadedfile import UploadedFile
    if hasattr(self.image, 'file') and isinstance(self.image.file, UploadedFile) :
        # Handle FileFields as special cases, because the uploaded filename could be
        # the same as the filename that's already there even though there may
        # be different file contents.

        # if a file was just uploaded, the storage model with be UploadedFile
        # Do new file stuff here

Answer 12:

This works for me in Django 1.8

def clean(self):
    if self.cleaned_data['name'] != self.initial['name']:
        # Do something

Answer 13:

The optimal solution is probably one that does not include an additional database read operation prior to saving the model instance, nor any further django-library. This is why laffuste’s solutions is preferable. In the context of an admin site, one can simply override the save_model-method, and invoke the form’s has_changed method there, just as in Sion’s answer above. You arrive at something like this, drawing on Sion’s example setting but using “changed_data” to get every possible change:

class ModelAdmin(admin.ModelAdmin):
   def save_model(self, request, obj, form, change):
     form.changed_data #output could be ['name']
     #do somethin the changed name value...
     #call the super method
     super(self,ModelAdmin).save_model(request, obj, form, change)
  • Overwrite save_model:


  • Built-in changed_data-method for a Field:


Answer 14:

While this doesn’t actually answer your question, I’d go about this in a different way.

Simply clear the remote_image field after successfully saving the local copy. Then in your save method you can always update the image whenever remote_image isn’t empty.

If you’d like to keep a reference to the url, you could use an non-editable boolean field to handle the caching flag rather than remote_image field itself.