Validator helpers

Validators are the same as any other subclass of Spec in that it has a normalise method that takes in meta and val and returns a new val.

It is convention that a validator subclasses Validator and implements a validate method. This means NotSpecified values are ignored and any specified value goes through the validate method.

It is the job of the validator to raise a subclass of BadSpec if something is wrong, otherwise just return val.

The following is all available under For example:

from delfick_project.norms import va, BadSpecValue

class divisible_by_two(va.Validator):
    def validate(self, meta, val):
        val = sb.integer_spec().normalise(meta, val)
        if val % 2 != 0:
            raise BadSpecValue("Value was not divisible by two", got=val, meta=meta)
        return val
class delfick_project.norms.validators.Validator(*pargs, **kwargs)

A specification that either returns NotSpecified if val is NotSpecified or simply calls self.validate.

validate(meta, val)

Subclasses of Validator must implement this method.

It will do validation on a value.

If the value is invalid then raise an instance of BadSpec.

Otherwise return the value


has_either([key1, ..., keyn]).normalise(meta, val)

Will complain if the val.get(key, sb.NotSpecified) returns sb.NotSpecified for all the choices.

I.e. A valid dictionary has either one of the specified keys!


has_only_one_of([key1, ..., keyn]).normalise(meta, val)

Will complain if the val.get(key, sb.NotSpecified) returns sb.NotSpecified for all but one of the choices.

I.e. A valid dictionary must have exactly one of the specified keys!


either_keys([k1, k2], [k3]).normalise(meta, val)

Will complain if the value is not a dictionary

Will complain if the keys from one group are mixed with keys from another group

Will complain if keys from one group appear without the rest of the keys in that group

Will not complain if unspecified keys are in the val


no_whitespace().normalise(meta, val)

Raises an error if we can find the regex \s+ in the val.


no_dots().normalise(meta, val)

# or

no_dots(reason="dots are evil!").normalise(meta, val)

This will complain if val contains any dots

It will use the reason to explain why it’s an error if it’s provided.


regexed(regex1, ..., regexn).normalise(meta, val)

This will match the val against all the regex and will complain if any of them fail, otherwise the val is returned.


deprecated_key(key, reason).normalise(meta, val)

This will raise an error if val is nonempty and contains key. The error will use reason in it’s message.


choice(choice1, ..., choicen).normalise(meta, val)