How to limit the maximum value of a numeric field in a Django model?

You can use Django's built-in validators—

from django.db.models import IntegerField, Model
from django.core.validators import MaxValueValidator, MinValueValidator

class CoolModelBro(Model):
    limited_integer_field = IntegerField(
        default=1,
        validators=[
            MaxValueValidator(100),
            MinValueValidator(1)
        ]
     )

Edit: When working directly with the model, make sure to call the model full_clean method before saving the model in order to trigger the validators. This is not required when using ModelForm since the forms will do that automatically.

from django.db import models
from django.core.validators import MinValueValidator, MaxValueValidator

size = models.IntegerField(validators=[MinValueValidator(0),
                                       MaxValueValidator(5)])

I had this very same problem; here was my solution:

SCORE_CHOICES = zip( range(1,n), range(1,n) )
score = models.IntegerField(choices=SCORE_CHOICES, blank=True)

There are two ways to do this. One is to use form validation to never let any number over 50 be entered by a user. Form validation docs.

If there is no user involved in the process, or you're not using a form to enter data, then you'll have to override the model's save method to throw an exception or limit the data going into the field.

Here is the best solution if you want some extra flexibility and don't want to change your model field. Just add this custom validator:

#Imports
from django.core.exceptions import ValidationError      

class validate_range_or_null(object):
    compare = lambda self, a, b, c: a > c or a < b
    clean = lambda self, x: x
    message = ('Ensure this value is between %(limit_min)s and %(limit_max)s (it is %(show_value)s).')
    code = 'limit_value'

    def __init__(self, limit_min, limit_max):
        self.limit_min = limit_min
        self.limit_max = limit_max

    def __call__(self, value):
        cleaned = self.clean(value)
        params = {'limit_min': self.limit_min, 'limit_max': self.limit_max, 'show_value': cleaned}
        if value:  # make it optional, remove it to make required, or make required on the model
            if self.compare(cleaned, self.limit_min, self.limit_max):
                raise ValidationError(self.message, code=self.code, params=params)

And it can be used as such:

class YourModel(models.Model):

    ....
    no_dependents = models.PositiveSmallIntegerField("How many dependants?", blank=True, null=True, default=0, validators=[validate_range_or_null(1,100)])

The two parameters are max and min, and it allows nulls. You can customize the validator if you like by getting rid of the marked if statement or change your field to be blank=False, null=False in the model. That will of course require a migration.

Note: I had to add the validator because Django does not validate the range on PositiveSmallIntegerField, instead it creates a smallint (in postgres) for this field and you get a DB error if the numeric specified is out of range.

Hope this helps :) More on Validators in Django.

PS. I based my answer on BaseValidator in django.core.validators, but everything is different except for the code.

For example, you can use MaxValueValidator() and MinValueValidator() for models.DecimalField() and models.PositiveIntegerField() to set the available range of the value as shown below:

# "models.py"

from django.db import models
from django.core.validators import MaxValueValidator, MinValueValidator

class Test(models.Model):
    num1 = models.DecimalField(
        max_digits=3,
        decimal_places=1,
        validators=[
            MaxValueValidator(10.0),
            MinValueValidator(0.0)
        ],
    )
    num2 = models.PositiveIntegerField(
        validators=[
            MaxValueValidator(10),
            MinValueValidator(0)
        ],
    )

Finally, you better override num1 and num2 fields with forms.DecimalField() and forms.IntegerField() to set the available range of the value in Django Admin as shown below:

from django.contrib import admin
from .models import Test
from django import forms

class TestForm(forms.ModelForm):
    num1 = forms.DecimalField(
        max_value=10.0, min_value=0.0, step_size=0.1
    )
    num2 = forms.IntegerField(
        max_value=10, min_value=0
    )

@admin.register(Test)
class TestAdmin(admin.ModelAdmin):
    form = TestForm

In addition, the code with forms.NumberInput below is identical to the code above:

from django.contrib import admin
from .models import Test
from django import forms

class TestForm(forms.ModelForm):
    num1 = forms.DecimalField(
        widget=forms.NumberInput(attrs={'max': 10.0, 'min': 0.0, 'step': 0.1})
    )
    num2 = forms.IntegerField(
        widget=forms.NumberInput(attrs={'max': 10, 'min': 0})
    )

@admin.register(Test)
class TestAdmin(admin.ModelAdmin):
    form = TestForm

In the forms.py

Class FloatForm(forms.ModelForm):

    class Meta:
        model = Float
        fields = ('name','country', 'city', 'point', 'year')

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['point'] = forms.FloatField(max_value=100, min_value=1)

It is worth mentioning that sometimes Django validation doesn't work as Django validation is mostly an application-level validation, not validation at the database level. Also, Model validation is not run automatically on the save/create/update of the model. If you want to validate your values instantly in your code then you need to do it manually — using the override save() method:

class UserRating():
    SCORE_CHOICES = (
        (1, _("Terrible")),
        (2, _("Poor")),
        (3, _("Average")),
        (4, _("Very Good")),
        (5, _("Excellent")),
    )
    score = models.PositiveSmallIntegerField(
        choices=SCORE_CHOICES, default=1, 
            validators=[
                MaxValueValidator(5),
                MinValueValidator(1)
            ]
    )
    
    def save(self, *args, **kwargs):
        if int(self.score) < 1 or int(self.score) > 5:
            raise ValidationError('Score must be located between 0 to 5')
        super(UserRating, self).save(*args, **kwargs)
    
    ...

Add validator like this your model column in models.py

class Planogram(models.Model):
    camera = models.ForeignKey(Camera, on_delete=models.CASCADE)
    xtl = models.DecimalField(decimal_places=10, max_digits=11,validators=[MaxValueValidator(1),MinValueValidator(0)])

if you are using create function to create objects change it to constructor like below.... and call fullclean() on that object and then save.. everything will work perfectly.

planogram = Planogram(camera_id = camera,xtl=xtl,ytl=ytl,xbr=xbr,ybr=ybr,product_id=product_id)
planogram.full_clean()
planogram.save()

I'm surprised that database constraints haven't been mentioned here. Validators only validate user input, they don't ensure data consistency. Inconsistent data in the database can cause some pretty gnarly unexpected bugs.

The below will have the same user-facing behavior as validators, but will also ensure the DB records can't fall outside the expected values through means other than user input (bulk insert/update for instance).

from decimal import Decimal

from django.db import models
from django.utils.translation import gettext_lazy as _


class ConstrainedModel(models.Model):
    decimal = models.DecimalField()
    integer = models.PositiveIntegerField()

    class Meta:
        constraints = [
            models.CheckConstraint(
                check=models.Q(
                    decimal__gte=Decimal(0), decimal__lte=Decimal(5)
                ),
                name="%(app_label)s_%(class)s_decimal_range",
                violation_error_message=_("Decimal must be between 0 and 5"),
            ),
            models.CheckConstraint(
                check=models.Q(integer__lte=50),
                name="%(app_label)s_%(class)s_integer_range",
                violation_error_message=_("Integer must be between 0 and 50"),
            ),
        ]