Django Standardized Image Field
Clone or download
Pull request Compare This branch is 251 commits ahead, 3 commits behind xarg:master.

Django-CC version ci codecov code-health MIT License

Django Standardized Image Field

Django Field that implement the following features:

  • Django-Storages compatible (S3)
  • Resize images to different sizes
  • Access thumbnails on model level, no template tags required
  • Preserves original image
  • Asynchronous rendering (Celery & Co)
  • Multi threading and processing for optimum performance
  • Restrict accepted image dimensions
  • Rename files to a standardized name (using a callable upload_to)


Simply install the latest stable package using the command

pip install django-stdimage

and add 'stdimage' to INSTALLED_APPs in your, that's it!


StdImageField works just like Django's own ImageField except that you can specify different sized variations.


Variations are specified within a dictionary. The key will be the attribute referencing the resized image. A variation can be defined both as a tuple or a dictionary.


from django.db import models
from stdimage.models import StdImageField

class MyModel(models.Model):
    # works just like django's ImageField
    image = StdImageField(upload_to='path/to/img')

    # creates a thumbnail resized to maximum size to fit a 100x75 area
    image = StdImageField(upload_to='path/to/img',
                          variations={'thumbnail': {'width': 100, 'height': 75}})

    # is the same as dictionary-style call
    image = StdImageField(upload_to='path/to/img', variations={'thumbnail': (100, 75)})

    # creates a thumbnail resized to 100x100 croping if necessary
    image = StdImageField(upload_to='path/to/img', variations={
        'thumbnail': {"width": 100, "height": 100, "crop": True}

    ## Full ammo here. Please note all the definitions below are equal
    image = StdImageField(upload_to='path/to/img', blank=True, variations={
        'large': (600, 400),
        'thumbnail': (100, 100, True),
        'medium': (300, 200),

For using generated variations in templates use myimagefield.variation_name.


<a href="{{ object.myimage.url }}"><img alt="" src="{{ object.myimage.thumbnail.url }}"/></a>


Since version 4 the custom upload_to utils have been dropped in favor of Django Dynamic Filenames.


The StdImageField doesn't implement any size validation. Validation can be specified using the validator attribute and using a set of validators shipped with this package. Validators can be used for both Forms and Models.


from django.db import models
from stdimage.validators import MinSizeValidator, MaxSizeValidator
from stdimage.models import StdImageField

class MyClass(models.Model):
    image1 = StdImageField(validators=[MinSizeValidator(800, 600)])
    image2 = StdImageField(validators=[MaxSizeValidator(1028, 768)])

CAUTION: The MaxSizeValidator should be used with caution. As storage isn't expensive, you shouldn't restrict upload dimensions. If you seek prevent users form overflowing your memory you should restrict the HTTP upload body size.

Deleting images

Django dropped support for automated deletions in version 1.3. Implementing file deletion should be done inside your own applications using the post_delete or pre_delete signal. Clearing the field if blank is true, does not delete the file. This can also be achieved using pre_save and post_save signals. This packages contains two signal callback methods that handle file deletion for all SdtImageFields of a model.

from django.db.models.signals import pre_delete, pre_save
from stdimage.utils import pre_delete_delete_callback, pre_save_delete_callback

from . import models

pre_delete.connect(pre_delete_delete_callback, sender=models.MyModel)
pre_save.connect(pre_save_delete_callback, sender=models.MyModel)

Warning: You should not use the signal callbacks in production. They may result in data loss.

Async image processing

Tools like celery allow to execute time-consuming tasks outside of the request. If you don't want to wait for your variations to be rendered in request, StdImage provides your the option to pass a async keyword and a util. Note that the callback is not transaction save, but the file will be there. This example is based on celery.

    from django.apps import apps
    get_model = apps.get_model
except ImportError:
    from django.apps import apps

from celery import shared_task

from stdimage.utils import render_variations

def process_photo_image(file_name, variations, storage):
    render_variations(file_name, variations, replace=True, storage=storage)
    obj = apps.get_model('myapp', 'Photo').objects.get(image=file_name)
    obj.processed = True

from django.db import models
from stdimage.models import StdImageField

from tasks import process_photo_image

def image_processor(file_name, variations, storage):
    process_photo_image.delay(file_name, variations, storage)
    return False  # prevent default rendering

class AsyncImageModel(models.Model):
    image = StdImageField(
        # above task definition can only handle one model object per image filename
        render_variations=image_processor  # pass boolean or callable
    processed = models.BooleanField(default=False)  # flag that could be used for view querysets

Re-rendering variations

You might want to add new variations to a field. That means you need to render new variations for missing fields. This can be accomplished using a management command.

python rendervariations 'app_name.model_name.field_name' [--replace] [-i/--ignore-missing]

The replace option will replace all existing files. The ignore-missing option will suspend missing source file errors and keep rendering variations for other files. Othervise command will stop on first missing file.

Multi processing

Since version 2 stdImage supports multiprocessing. Every image is rendered in separate process. It not only increased performance but the garbage collection and therefore the huge memory footprint from previous versions.

Note: PyPy seems to have some problems regarding multiprocessing, for that matter all multiprocessing is disabled in PyPy.