I prefer the decorator having a name that indicates it's intent and not the fact that it happens to be testing properties or is a decorator :) I'm not a stickler but it'll make it easier to understand down the road.

@validate_schema or @validate_model or something like that feels much closer to what it does.

The second question is can we do a single decorator that takes in parameters on what it validates (Django Forms, I believe, is similar to this)

@validate_model(enum=Auth, is_null=False)

It makes the decorator explosion a little more manageable.

I'd much rather the individual decorators than one über one. If we have a single one, then we have to account for all possible combinations. That's error prone. If we have multiple decorators, we can compose them into whatever combination we need.

I also prefer the individual decorators. I tried writing one but as Russell pointed out it ended up being an explosion and not nearly as easy to read.

Fair point on wanting them to be composable -- I think that can be done without having an uber method though.

Django does it by having one decorator that takes a list of functions and that does the validation for the model by applying those functions.

So for us it could be:

@validate_model(validators=[is_not_nullable, is_right_type(Auth)])
def function():
    pass

Each function is the composable set of checks we've got today, and if we add more in the future it's a little easier to control the order in which the validations are applied -- and not make functions look giant.

@a
@b
@c
@d.setter
def happy_days():
    pass

Order is not so important except to make sure the setter is first (still an issue in yours).