Add Django image size validators

Author: codingjoe

.editorconfig

@@ -24,3 +24,6 @@ insert_final_newline = false
 [*.{md,markdown}]
 indent_size = 2
 max_line_length = 80
+
+[Makefile]
+indent_style = tab

.github/workflows/ci.yml

@@ -11,13 +11,18 @@ jobs:
   dist:
     runs-on: ubuntu-latest
     steps:
+      - uses: actions/checkout@v3
       - uses: actions/setup-python@v4
         with:
           python-version: "3.10"
-      - uses: actions/checkout@v3
+      - run: sudo apt install gettext -y
       - run: python -m pip install --upgrade pip build wheel twine
+      - run: make gettext
       - run: python -m build --sdist --wheel
       - run: python -m twine check dist/*
+      - uses: actions/upload-artifact@v3
+        with:
+          path: dist/*
 
   lint:
     runs-on: ubuntu-latest

.github/workflows/release.yml

@@ -13,8 +13,9 @@ jobs:
     - uses: actions/setup-python@v4
       with:
         python-version: "3.10"
+    - run: sudo apt install gettext -y
     - run: python -m pip install --upgrade pip build wheel twine
-    - run: python -m pip install pip~=21.0  # https://github.com/pypa/pip/issues/11133
+    - run: make gettext
     - run: python -m build --sdist --wheel
     - run: python -m twine upload dist/*
       env:

Makefile

@@ -0,0 +1,12 @@
+MSGLANGS = $(wildcard pictures/locale/*/LC_MESSAGES/*.po)
+MSGOBJS = $(MSGLANGS:.po=.mo)
+
+.PHONY: translations gettext gettext-clean
+
+gettext: $(MSGOBJS)
+
+gettext-clean:
+	-rm $(MSGOBJS)
+
+%.mo: %.po
+	msgfmt --check-format --check-domain --statistics -o $@ $*.po

pictures/locale/de/LC_MESSAGES/django.po

@@ -0,0 +1,37 @@
+# Django-Pictures
+# Copyright (C) 2022 Johannes Maron
+# This file is distributed under the same license as the PACKAGE package.
+# Johannes Maron <[email protected]>, 2022.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2022-08-06 13:58+0200\n"
+"PO-Revision-Date: 2022-08-06 14:14+0200\n"
+"Last-Translator: Johannes Maron <[email protected]>\n"
+"Language-Team: \n"
+"Language: de\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n > 1);\n"
+"X-Generator: Poedit 3.1.1\n"
+
+#: validators.py:47
+#, python-format
+msgid ""
+"The image you uploaded is too large. The required maximum resolution is: "
+"%(width)sx%(height)s px."
+msgstr ""
+"Das von Ihnen hochgeladene Bild ist zu groß. Die erforderliche maximale "
+"Auflösung beträgt: %(width)sx%(height)s px."
+
+#: validators.py:65
+#, python-format
+msgid ""
+"The image you uploaded is too small. The required minimum resolution is: "
+"%(width)sx%(height)s px."
+msgstr ""
+"Das von Ihnen hochgeladene Bild ist zu klein. Die erforderliche "
+"Mindestauflösung beträgt: %(width)sx%(height)s px."

pictures/validators.py

@@ -0,0 +1,68 @@
+import io
+
+from django.core.exceptions import ValidationError
+from django.core.validators import BaseValidator
+from django.utils.translation import gettext_lazy as _
+from PIL import Image
+
+
+class BaseSizeValidator(BaseValidator):
+    """Base validator that validates the size of an image."""
+
+    def compare(self, x):
+        return NotImplemented
+
+    def __init__(self, width, height):
+        self.limit_value = width or float("inf"), height or float("inf")
+
+    def __call__(self, value):
+        cleaned = self.clean(value)
+        if self.compare(cleaned, self.limit_value):
+            params = {
+                "width": self.limit_value[0],
+                "height": self.limit_value[1],
+            }
+            raise ValidationError(self.message, code=self.code, params=params)
+
+    @staticmethod
+    def clean(value):
+        value.seek(0)
+        stream = io.BytesIO(value.read())
+        size = Image.open(stream).size
+        value.seek(0)
+        return size
+
+
+class MaxSizeValidator(BaseSizeValidator):
+    """
+    ImageField validator to validate the max width and height of an image.
+
+    You may use None as an infinite boundary.
+    """
+
+    def compare(self, img_size, max_size):
+        return img_size[0] > max_size[0] or img_size[1] > max_size[1]
+
+    message = _(
+        "The image you uploaded is too large."
+        " The required maximum resolution is:"
+        " %(width)sx%(height)s px."
+    )
+    code = "max_resolution"
+
+
+class MinSizeValidator(BaseSizeValidator):
+    """
+    ImageField validator to validate the min width and height of an image.
+
+    You may use None as an infinite boundary.
+    """
+
+    def compare(self, img_size, min_size):
+        return img_size[0] < min_size[0] or img_size[1] < min_size[1]
+
+    message = _(
+        "The image you uploaded is too small."
+        " The required minimum resolution is:"
+        " %(width)sx%(height)s px."
+    )

tests/conftest.py

@@ -9,18 +9,12 @@
 
 
 @pytest.fixture
-def imagedata():
+def image_upload_file():
     img = Image.new("RGB", (800, 800), (255, 55, 255))
 
-    output = io.BytesIO()
-    img.save(output, format="JPEG")
-
-    return output
-
-
-@pytest.fixture
-def image_upload_file(imagedata):
-    return SimpleUploadedFile("image.jpg", imagedata.getvalue())
+    with io.BytesIO() as output:
+        img.save(output, format="JPEG")
+        return SimpleUploadedFile("image.jpg", output.getvalue())
 
 
 @pytest.fixture(autouse=True, scope="function")

tests/test_validators.py

@@ -0,0 +1,104 @@
+import io
+
+import pytest
+from django.core.exceptions import ValidationError
+from django.core.files.uploadedfile import SimpleUploadedFile
+from PIL import Image
+
+from pictures import validators
+from tests.testapp.models import ValidatorModel
+
+
+class TestBaseSizeValidator:
+    def test_init__none(self):
+        assert validators.MinSizeValidator(None, None).limit_value == (
+            float("inf"),
+            float("inf"),
+        )
+
+    def test_compare(self):
+        assert validators.BaseSizeValidator(None, None).compare(None) == NotImplemented
+
+
+class TestMaxSizeValidator:
+    def test_compare__inf(self):
+        limit_value = float("inf"), float("inf")
+        instance = validators.MaxSizeValidator(*limit_value)
+        assert not instance.compare((300, 200), limit_value)
+
+    def test_compare__eq(self):
+        assert not validators.MaxSizeValidator(300, 200).compare((300, 200), (300, 200))
+
+    def test_compare__gt(self):
+        limit_value = 300, 200
+        instance = validators.MaxSizeValidator(*limit_value)
+        assert instance.compare((600, 400), limit_value)
+        assert instance.compare((600, 200), limit_value)
+        assert instance.compare((300, 400), limit_value)
+        assert instance.compare((600, 100), limit_value)
+        assert instance.compare((150, 400), limit_value)
+
+    def test_compare__lt(self):
+        limit_value = 300, 200
+        instance = validators.MaxSizeValidator(*limit_value)
+        assert not instance.compare((150, 100), (300, 200))
+        assert not instance.compare((300, 100), (300, 200))
+        assert not instance.compare((150, 200), (300, 200))
+
+    @pytest.mark.django_db
+    def test_integration(self):
+        img = Image.new("RGB", (800, 800), (255, 55, 255))
+
+        with io.BytesIO() as output:
+            img.save(output, format="JPEG")
+            file = SimpleUploadedFile("image.jpg", output.getvalue())
+
+        obj = ValidatorModel(picture=file)
+        with pytest.raises(ValidationError) as e:
+            obj.full_clean()
+
+        assert "The required maximum resolution is: 800x600 px." in str(
+            e.value.error_dict["picture"][0]
+        )
+
+
+class TestMinSizeValidator:
+    def test_compare__inf(self):
+        limit_value = float("inf"), float("inf")
+        instance = validators.MinSizeValidator(*limit_value)
+        assert instance.compare((300, 200), limit_value)
+
+    def test_compare__eq(self):
+        assert not validators.MinSizeValidator(300, 200).compare((300, 200), (300, 200))
+
+    def test_compare__gt(self):
+        limit_value = 300, 200
+        instance = validators.MinSizeValidator(*limit_value)
+        assert not instance.compare((600, 400), limit_value)
+        assert not instance.compare((600, 200), limit_value)
+        assert not instance.compare((300, 400), limit_value)
+        assert instance.compare((600, 100), limit_value)
+        assert instance.compare((150, 400), limit_value)
+
+    def test_compare__lt(self):
+        limit_value = 300, 200
+        instance = validators.MinSizeValidator(*limit_value)
+        assert instance.compare((150, 100), (300, 200))
+        assert instance.compare((300, 100), (300, 200))
+        assert instance.compare((150, 200), (300, 200))
+
+    @pytest.mark.django_db
+    def test_integration(self):
+        img = Image.new("RGB", (300, 200), (255, 55, 255))
+
+        with io.BytesIO() as output:
+            img.save(output, format="JPEG")
+            file = SimpleUploadedFile("image.jpg", output.getvalue())
+
+        obj = ValidatorModel(picture=file)
+        with pytest.raises(ValidationError) as e:
+            obj.full_clean()
+
+        assert "The required minimum resolution is: 400x300 px." in str(
+            e.value.error_dict["picture"][0]
+        )

tests/testapp/migrations/0003_validatormodel.py

@@ -0,0 +1,58 @@
+# Generated by Django 4.1 on 2022-08-06 11:46
+
+from django.db import migrations, models
+
+import pictures.models
+import pictures.validators
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("testapp", "0002_alter_profile_picture"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="ValidatorModel",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("picture_width", models.PositiveIntegerField(null=True)),
+                ("picture_height", models.PositiveIntegerField(null=True)),
+                (
+                    "picture",
+                    pictures.models.PictureField(
+                        aspect_ratios=[None, "3/2", "16/9"],
+                        blank=True,
+                        breakpoints={
+                            "l": 1200,
+                            "m": 992,
+                            "s": 768,
+                            "xl": 1400,
+                            "xs": 576,
+                        },
+                        container_width=1200,
+                        file_types=["WEBP"],
+                        grid_columns=12,
+                        height_field="picture_height",
+                        null=True,
+                        pixel_densities=[1, 2],
+                        upload_to="testapp/simplemodel/",
+                        validators=[
+                            pictures.validators.MaxSizeValidator(800, 600),
+                            pictures.validators.MinSizeValidator(400, 300),
+                        ],
+                        width_field="picture_width",
+                    ),
+                ),
+            ],
+        ),
+    ]

tests/testapp/models.py

@@ -1,6 +1,7 @@
 from django.db import models
 from django.urls import reverse
 
+from pictures import validators
 from pictures.models import PictureField
 
 
@@ -25,3 +26,20 @@ class Profile(models.Model):
 
     def get_absolute_url(self):
         return reverse("profile_detail", kwargs={"pk": self.pk})
+
+
+class ValidatorModel(models.Model):
+    picture_width = models.PositiveIntegerField(null=True)
+    picture_height = models.PositiveIntegerField(null=True)
+    picture = PictureField(
+        upload_to="testapp/simplemodel/",
+        aspect_ratios=[None, "3/2", "16/9"],
+        width_field="picture_width",
+        height_field="picture_height",
+        validators=[
+            validators.MaxSizeValidator(800, 600),
+            validators.MinSizeValidator(400, 300),
+        ],
+        blank=True,
+        null=True,
+    )